@riverbankcms/sdk 0.82.0 → 0.84.1

package/dist/client/bookings.mjs

@@ -86,7 +86,7 @@ function ze() {
     /* @__PURE__ */ Te(P)
   );
 }
-function z19(e) {
+function z20(e) {
   if (L) {
     if (/* @__PURE__ */ Te(P) !== null)
       throw Tt(), Je;
@@ -2115,12 +2115,12 @@ function ha(e, t) {
   var mt = we(Dr, 2);
   let Pr;
   var We = X(mt);
-  en(We), We.__change = ui, z19(mt);
+  en(We), We.__change = ui, z20(mt);
   var Ut = we(mt, 2), wi = X(Ut);
   {
     var pi = (n) => {
       var u = na(), _ = Gr(u), y = X(_);
-      Ge(y, () => c(re).verified), z19(_);
+      Ge(y, () => c(re).verified), z20(_);
       var T = we(_, 2);
       en(T), Pe(() => {
         se(T, "name", V()), jo(T, c(Le));
@@ -2129,10 +2129,10 @@ function ha(e, t) {
       {
         var _ = (T) => {
           var E = ia(), p = X(E);
-          Ge(p, () => c(re).verifying), z19(E), ne(T, E);
+          Ge(p, () => c(re).verifying), z20(E), ne(T, E);
         }, y = (T) => {
           var E = oa(), p = X(E);
-          Ge(p, () => c(re).label), z19(E), Pe(() => se(E, "for", c(cr))), ne(T, E);
+          Ge(p, () => c(re).label), z20(E), Pe(() => se(E, "for", c(cr))), ne(T, E);
         };
         $e(
           n,
@@ -2147,18 +2147,18 @@ function ha(e, t) {
       c(C) === b.VERIFIED ? n(pi) : n(bi, false);
     });
   }
-  z19(Ut);
+  z20(Ut);
   var yi = we(Ut, 2);
   {
     var Ei = (n) => {
       var u = aa(), _ = X(u);
-      se(_, "href", sr), z19(u), Pe(() => se(_, "aria-label", c(re).ariaLinkLabel)), ne(n, u);
+      se(_, "href", sr), z20(u), Pe(() => se(_, "aria-label", c(re).ariaLinkLabel)), ne(n, u);
     };
     $e(yi, (n) => {
       (N() !== true || c(Dt)) && n(Ei);
     });
   }
-  z19(Mt);
+  z20(Mt);
   var Or = we(Mt, 2);
   {
     var xi = (n) => {
@@ -2166,16 +2166,16 @@ function ha(e, t) {
       {
         var y = (E) => {
           var p = la(), x = X(p);
-          Ge(x, () => c(re).expired), z19(p), Pe(() => se(p, "title", c(He))), ne(E, p);
+          Ge(x, () => c(re).expired), z20(p), Pe(() => se(p, "title", c(He))), ne(E, p);
         }, T = (E) => {
           var p = sa(), x = X(p);
-          Ge(x, () => c(re).error), z19(p), Pe(() => se(p, "title", c(He))), ne(E, p);
+          Ge(x, () => c(re).error), z20(p), Pe(() => se(p, "title", c(He))), ne(E, p);
         };
         $e(_, (E) => {
           c(C) === b.EXPIRED ? E(y) : E(T, false);
         });
       }
-      z19(u), ne(n, u);
+      z20(u), ne(n, u);
     };
     $e(Or, (n) => {
       (c(He) || c(C) === b.EXPIRED) && n(xi);
@@ -2185,7 +2185,7 @@ function ha(e, t) {
   {
     var $i = (n) => {
       var u = ua(), _ = X(u), y = X(_);
-      Ge(y, () => c(re).footer), z19(_), z19(u), ne(n, u);
+      Ge(y, () => c(re).footer), z20(_), z20(u), ne(n, u);
     };
     $e(Fr, (n) => {
       c(re).footer && (k() !== true || c(Dt)) && n($i);
@@ -2201,7 +2201,7 @@ function ha(e, t) {
       v() && n(Ci);
     });
   }
-  return z19(ot), nn(ot, (n) => D(B, n), () => c(B)), Pe(
+  return z20(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");
     },
@@ -2765,7 +2765,7 @@ var init_altcha = __esm({
 });
 
 // src/bookings/index.ts
-import * as React4 from "react";
+import * as React5 from "react";
 
 // ../blocks/src/system/runtime/api/deduplication.ts
 function createDeduplicationCache(options = {}) {
@@ -4001,7 +4001,7 @@ function rgbColorValue(token) {
   if (alpha === void 0) {
     return `rgb(var(${cssVar}))`;
   }
-  return `rgba(var(${cssVar}), ${alpha})`;
+  return `rgb(var(${cssVar}) / ${alpha})`;
 }
 
 // ../theme-core/src/buttons/types.ts
@@ -4823,6 +4823,95 @@ var joyStamp = defineButtonPersonality({
   }
 });
 
+// ../theme-core/src/buttons/personalities/ornate-ritual.ts
+var 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 = defineButtonPersonality({
   id: "pebble",
@@ -5096,12 +5185,21 @@ var buttonPersonalities = [
   inkStamp,
   brushedWash,
   showtimePill,
-  joyStamp
+  joyStamp,
+  ornateRitual
 ];
 var personalitiesById = new Map(
   buttonPersonalities.map((p) => [p.id, p])
 );
 
+// ../core/src/result.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+
 // ../core/src/branded.ts
 var unsafeAsSiteId = (id) => id;
 var unsafeAsFormId = (id) => id;
@@ -5127,6 +5225,50 @@ function subtractDaysFromIso(isoString, dayCount) {
   return addDaysToIso(isoString, -dayCount);
 }
 
+// ../core/src/event-pricing.ts
+function publicEventPricingType(pricing) {
+  switch (pricing.kind) {
+    case "drop_in":
+    case "free_registration":
+      return "free";
+    case "single_paid":
+    case "ticket_types":
+    case "course":
+      return isFreePublicEventPriceDisplay(pricing.display) ? "free" : "paid";
+  }
+}
+function publicEventScalarPrice(pricing) {
+  return pricing.kind === "single_paid" ? pricing.amount : null;
+}
+function publicEventPricingMode(pricing) {
+  switch (pricing.kind) {
+    case "single_paid":
+    case "free_registration":
+      return "single";
+    case "ticket_types":
+      return "ticket_types";
+    case "drop_in":
+    case "course":
+      return void 0;
+  }
+}
+function publicEventTicketTypes(pricing) {
+  return pricing.kind === "ticket_types" ? pricing.ticketTypes : [];
+}
+function isFreePublicEventPriceDisplay(display) {
+  switch (display.kind) {
+    case "free":
+      return true;
+    case "course":
+      return display.display.kind === "free";
+    case "exact":
+    case "from":
+    case "mixed":
+    case "unavailable":
+      return false;
+  }
+}
+
 // ../core/src/booking-flexible-balance.ts
 function clampFlexibleBalanceConfiguredAmount(amountCents, totalAmountCents) {
   return Math.max(0, Math.min(amountCents, totalAmountCents));
@@ -5261,6 +5403,51 @@ function getSafeTimeZone(timeZone) {
   const normalized = typeof timeZone === "string" ? timeZone.trim() : "";
   return normalized && isValidTimeZone(normalized) ? normalized : FALLBACK_TIMEZONE;
 }
+function parseStrictBookingTimeZone(timeZone) {
+  const normalized = timeZone.trim();
+  if (!normalized || !isValidTimeZone(normalized)) {
+    return null;
+  }
+  return normalized;
+}
+function formatParseError(error) {
+  switch (error.reason) {
+    case "invalid_starts_at":
+      return `Expected a valid UTC/offset-aware ISO datetime in startsAt, received "${error.value}"`;
+    case "invalid_ends_at":
+      return `Expected a valid UTC/offset-aware ISO datetime in endsAt, received "${error.value ?? ""}"`;
+    case "invalid_time_zone":
+      return `Expected a valid IANA timezone in timeZone, received "${error.value}"`;
+  }
+}
+function formatToPartsLookup(date, locale, timeZone, format) {
+  return new Map(
+    new Intl.DateTimeFormat(locale, {
+      ...format,
+      timeZone
+    }).formatToParts(date).map((part) => [part.type, part.value])
+  );
+}
+function getZonedDateTimeParts(date, timeZone) {
+  const parts = formatToPartsLookup(date, "en-GB", timeZone, {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: false
+  });
+  const read = (type) => Number(parts.get(type) ?? "");
+  return {
+    year: read("year"),
+    month: read("month"),
+    day: read("day"),
+    hour: read("hour"),
+    minute: read("minute"),
+    second: read("second")
+  };
+}
 function formatDateKey(date) {
   const year = String(date.year).padStart(4, "0");
   const month = String(date.month).padStart(2, "0");
@@ -5280,6 +5467,63 @@ function resolveBookingTimeZoneId(...candidates) {
   }
   return FALLBACK_TIMEZONE;
 }
+function parseUtcIsoDateTimeString(value) {
+  const normalized = value.trim();
+  const hasUtcSuffix = normalized.endsWith("Z");
+  const hasExplicitOffset = /[+-]\d{2}:\d{2}$/u.test(normalized);
+  if (!hasUtcSuffix && !hasExplicitOffset) {
+    return err("missing-timezone-offset");
+  }
+  const date = new Date(normalized);
+  if (Number.isNaN(date.getTime())) {
+    return err("invalid-date-time");
+  }
+  return ok(date.toISOString());
+}
+function toUtcIsoDateTimeString(value) {
+  const parsed = parseUtcIsoDateTimeString(value);
+  if (!parsed.ok) {
+    const message = parsed.error === "missing-timezone-offset" ? `Expected an offset-aware ISO datetime, received "${value}"` : `Expected a valid ISO datetime, received "${value}"`;
+    throw new Error(message);
+  }
+  return parsed.value;
+}
+function parseScheduledBookingDateTime(input) {
+  try {
+    const startsAt = toUtcIsoDateTimeString(input.startsAt);
+    const timeZone = parseStrictBookingTimeZone(input.timeZone);
+    if (!timeZone) {
+      return {
+        ok: false,
+        field: "timeZone",
+        reason: "invalid_time_zone",
+        value: input.timeZone
+      };
+    }
+    return {
+      ok: true,
+      value: {
+        startsAt,
+        timeZone,
+        locale: input.locale
+      }
+    };
+  } catch {
+    return {
+      ok: false,
+      field: "startsAt",
+      reason: "invalid_starts_at",
+      value: input.startsAt
+    };
+  }
+}
+function toScheduledBookingDateTime(input) {
+  const result = parseScheduledBookingDateTime(input);
+  if (result.ok) {
+    return result.value;
+  }
+  throw new Error(formatParseError(result));
+}
 function formatBookingInstant(isoString, options) {
   const date = new Date(isoString);
   if (Number.isNaN(date.getTime())) {
@@ -5290,6 +5534,9 @@ function formatBookingInstant(isoString, options) {
     timeZone: getSafeTimeZone(options.timeZone)
   }).format(date);
 }
+function getBookingLocalDateKey(input) {
+  return formatDateKey(getLocalScheduleDate(new Date(input.startsAt), input.timeZone));
+}
 function parseBookingLocalDate(value) {
   const match = LOCAL_DATE_PATTERN.exec(value.trim());
   if (!match?.groups) {
@@ -5304,6 +5551,10 @@ function parseBookingLocalDate(value) {
   }
   return { year, month, day };
 }
+function getLocalScheduleDate(date, timeZone) {
+  const parts = getZonedDateTimeParts(date, getSafeTimeZone(timeZone));
+  return { year: parts.year, month: parts.month, day: parts.day };
+}
 function formatLocalScheduleDate(date) {
   return formatDateKey(date);
 }
@@ -5402,6 +5653,9 @@ var accordionSystemSchema = z5.object({
 function defineExactCatalog() {
   return (entries) => entries;
 }
+function asDesignBlockId(value) {
+  return brandNonEmptyString(value, "DesignBlockId");
+}
 function asAppearancePresetId(value) {
   return brandNonEmptyString(value, "AppearancePresetId");
 }
@@ -5450,6 +5704,7 @@ var eventListTreatmentValues = [
 ];
 var eyebrowTreatmentValues = [
   "plain",
+  "accent",
   "pill",
   "accent-pill",
   "pill-bounce",
@@ -6151,6 +6406,126 @@ var logger = {
   withFields: (_) => logger
 };
 
+// ../blocks/src/system/runtime/nodes/events/shared/pricing.ts
+var DEFAULT_EVENT_CURRENCY = "USD";
+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 isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPublicEventPricing(value) {
+  if (!isRecord3(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 isRecord3(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 (!isRecord3(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 isRecord3(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;
+}
+
 // ../theme-core/src/utils/tokenOrColor.ts
 import { z as z6 } from "zod";
 var tokenOrCssColorValueSchema = z6.string();
@@ -6226,6 +6601,13 @@ var cardSystemSchema = z7.object({
   variants: z7.array(cardVariantSchema).min(1).max(3)
 });
 
+// ../blocks/src/system/constants/events.ts
+var EVENT_CONTENT_TYPE_SLUGS = ["event", "events"];
+function isEventContentType(slug) {
+  if (!slug) return false;
+  return EVENT_CONTENT_TYPE_SLUGS.includes(slug);
+}
+
 // ../theme-core/src/site-styles/headerCtaVariants.ts
 function hasButtonVariant(theme, variantId) {
   return theme.buttons?.variants.some((variant) => variant.enabled && variant.id === variantId) ?? false;
@@ -7739,6 +8121,28 @@ var warmDarkEmber = definePaletteVariant({
     { name: "border", hex: "#894e31" }
   ]
 });
+var 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" }
+  ]
+});
 
 // ../theme-core/src/palette/variants/index.ts
 var paletteVariants = [
@@ -7762,7 +8166,8 @@ var paletteVariants = [
   softNaturalWatercolor,
   softNaturalLilac,
   // Warm-dark family (dark mode)
-  warmDarkEmber
+  warmDarkEmber,
+  warmDarkKirtanGold
 ];
 var paletteVariantsById = new Map(
   paletteVariants.map((v) => [v.id, v])
@@ -8970,9 +9375,125 @@ function headerConfigurationKey(configuration) {
 function asFooterLookId(value) {
   return value;
 }
-var guaranteedFallbackFooterLookId = asFooterLookId("footer-muted-grounding");
+function asFooterLayoutId(value) {
+  return value;
+}
+function asFooterStyleId(value) {
+  return value;
+}
+var guaranteedFallbackFooterLookId = asFooterLookId("footer-identity-quiet");
+var 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
+  }
+]);
+var 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."
+  }
+]);
+var footerLayoutsById = new Map(
+  footerLayoutCatalog.map((layout) => [layout.id, layout])
+);
+var footerStylesById = new Map(
+  footerStyleCatalog.map((style) => [style.id, style])
+);
+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 {
@@ -9077,10 +9598,10 @@ function centeredCalmFooter(theme) {
     }
   };
 }
-function editorialColumnsFooter(theme) {
+function splitEditorialFooter(theme) {
   return {
     ...theme.footer,
-    variant: "columns",
+    variant: "split",
     maxWidth: "container",
     background: {
       type: "color",
@@ -9099,17 +9620,23 @@ function editorialColumnsFooter(theme) {
       padding: "none",
       borderRadius: "none"
     },
+    navLayout: {
+      layout: "inline-wrap",
+      align: "start",
+      gapX: "relaxed",
+      gapY: "tight"
+    },
     logo: {
       showLogo: true,
       showLogoText: true,
-      placement: "left",
+      placement: "right",
       size: "sm",
-      align: "start"
+      align: "end"
     },
     bottomBar: {
       enabled: true,
       fullBleed: false,
-      textAlign: "center",
+      textAlign: "left",
       paddingX: "default",
       paddingY: "compact",
       borderTop: {
@@ -9118,26 +9645,89 @@ function editorialColumnsFooter(theme) {
     }
   };
 }
-var footerLookCatalog = defineExactCatalog()([
-  {
-    id: asFooterLookId("footer-muted-grounding"),
-    label: "Muted grounding footer",
-    compile: mutedGroundingFooter
-  },
-  {
-    id: asFooterLookId("footer-centered-calm"),
-    label: "Centered calm footer",
-    compile: centeredCalmFooter
-  },
+function editorialColumnsFooter(theme) {
+  return {
+    ...theme.footer,
+    variant: "columns",
+    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"
+    },
+    logo: {
+      showLogo: true,
+      showLogoText: true,
+      placement: "left",
+      size: "sm",
+      align: "start"
+    },
+    bottomBar: {
+      enabled: true,
+      fullBleed: false,
+      textAlign: "center",
+      paddingX: "default",
+      paddingY: "compact",
+      borderTop: {
+        width: "thin"
+      }
+    }
+  };
+}
+var 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
   }
@@ -9340,6 +9930,30 @@ var luxeContrastTypography = {
   },
   scale: "spacious"
 };
+var 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"
+};
 var boldDisplayTypography = {
   body: {
     family: "Manrope, system-ui, sans-serif",
@@ -9374,16 +9988,16 @@ var originalJoyTypography = {
   },
   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"
 };
@@ -9448,6 +10062,32 @@ var typographyPresets = [
     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",
@@ -9477,11 +10117,11 @@ var typographyPresets = [
   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,
@@ -9505,6 +10145,319 @@ var typographyPresetsById = new Map(
   typographyPresets.map((preset) => [preset.id, preset])
 );
 
+// ../theme-core/src/site-styles/designState.ts
+import { z as z19 } from "zod";
+var themeV2DesignStateSchemaVersion = 1;
+var designResolutionPolicySchema = z19.enum(["generated", "user", "admin", "sdk"]);
+var runtimeStyleFieldNameSchema = z19.enum(themeV2RuntimeStyleFieldNames);
+var nonEmptyRuntimeStyleFieldNamesSchema = z19.array(runtimeStyleFieldNameSchema).min(1).transform((fields) => [
+  fields[0],
+  ...fields.slice(1)
+]);
+var heroLegibilityStrategySchema = z19.enum([
+  "none",
+  "scrim-gradient",
+  "solid-panel"
+]);
+var heroCompositionIntentSchema = z19.enum([
+  "center",
+  "bottom-left"
+]);
+var heroTypographyScaleIntentSchema = z19.enum([
+  "quiet",
+  "editorial",
+  "display",
+  "poster"
+]);
+var sectionHeightIntentSchema = z19.enum([
+  "default",
+  "banner",
+  "hero",
+  "immersive"
+]);
+var imageSurfaceTreatmentIntensitySchema = z19.enum(["soft", "balanced", "strong"]);
+var imageSurfaceMotionSchema = z19.enum(["static", "fixed-frame"]);
+var imageSurfaceTreatmentSchema = z19.discriminatedUnion("kind", [
+  z19.object({ kind: z19.literal("none") }).strict(),
+  z19.object({
+    kind: z19.literal("brand-scrim"),
+    token: z19.enum(["primary", "secondary", "accent"]),
+    intensity: imageSurfaceTreatmentIntensitySchema.optional()
+  }).strict(),
+  z19.object({
+    kind: z19.literal("brand-wash"),
+    token: z19.enum(["primary", "secondary", "accent"]),
+    intensity: imageSurfaceTreatmentIntensitySchema.optional()
+  }).strict(),
+  z19.object({
+    kind: z19.literal("neutral-scrim"),
+    intensity: imageSurfaceTreatmentIntensitySchema.optional()
+  }).strict(),
+  z19.object({
+    kind: z19.literal("neutral-wash"),
+    intensity: imageSurfaceTreatmentIntensitySchema.optional()
+  }).strict(),
+  z19.object({
+    kind: z19.literal("solid-panel"),
+    intensity: imageSurfaceTreatmentIntensitySchema.optional()
+  }).strict()
+]);
+var testimonialCardTreatmentSchema = z19.enum(["default", "accent-quote"]);
+var tileTreatmentSchema = z19.enum(tileTreatmentValues);
+var eventListTreatmentSchema = z19.enum(eventListTreatmentValues);
+var eyebrowTreatmentSchema = z19.enum(eyebrowTreatmentValues);
+function uniqueNonEmpty(values) {
+  const uniqueValues = [...new Set(values)];
+  const firstValue = uniqueValues[0];
+  if (!firstValue) {
+    throw new Error("Expected at least one Theme V2 design state option.");
+  }
+  return [firstValue, ...uniqueValues.slice(1)];
+}
+var userPanelTreatments = uniqueNonEmpty(
+  userDesignOptionCatalog.contentFrames.filter((frame) => frame.kind === "panel").map((frame) => frame.treatment)
+);
+var userFlushTreatments = uniqueNonEmpty(
+  userDesignOptionCatalog.contentFrames.filter((frame) => frame.kind === "flush-panel").map((frame) => frame.treatment)
+);
+var userFlushBleeds = uniqueNonEmpty(
+  userDesignOptionCatalog.contentFrames.filter((frame) => frame.kind === "flush-panel").map((frame) => frame.bleed)
+);
+var contentFrameIntentSchema = z19.discriminatedUnion("kind", [
+  z19.object({ kind: z19.literal("plain") }).strict(),
+  z19.object({
+    kind: z19.literal("panel"),
+    treatment: z19.enum(userPanelTreatments)
+  }).strict(),
+  z19.object({
+    kind: z19.literal("flush-panel"),
+    treatment: z19.enum(userFlushTreatments),
+    bleed: z19.enum(userFlushBleeds)
+  }).strict()
+]);
+var blockDesignPlanSchema = z19.object({
+  blockId: z19.string().min(1).transform(asDesignBlockId),
+  blockKind: z19.string().min(1),
+  purpose: z19.string().min(1),
+  sectionSurface: z19.enum(userDesignOptionCatalog.sectionSurfaces),
+  contentFrame: contentFrameIntentSchema,
+  itemSurface: z19.enum(userDesignOptionCatalog.itemSurfaces),
+  transitionAfter: z19.enum(userDesignOptionCatalog.transitions),
+  emphasis: z19.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();
+var styleAuthoritySchema = z19.discriminatedUnion("kind", [
+  z19.object({
+    kind: z19.literal("theme-v2"),
+    source: designResolutionPolicySchema,
+    siteStyleId: z19.string().min(1).transform(asSiteStyleId),
+    templateId: z19.string().min(1).transform(asDesignSystemTemplateId),
+    templateVersion: z19.number().int().nonnegative(),
+    resolverVersion: z19.number().int().nonnegative()
+  }).strict(),
+  z19.object({
+    kind: z19.literal("legacy-raw"),
+    reason: z19.enum(["pre-theme-v2", "manual-runtime-fields"])
+  }).strict(),
+  z19.object({
+    kind: z19.literal("advanced-detached"),
+    reason: z19.literal("detached-custom-runtime-fields")
+  }).strict()
+]);
+var blockRuntimeStyleAuthoritySchema = z19.object({
+  unit: z19.literal("block-runtime-fields"),
+  blockId: z19.string().min(1).transform(asDesignBlockId),
+  fields: nonEmptyRuntimeStyleFieldNamesSchema,
+  authority: styleAuthoritySchema
+}).strict();
+var persistedPageDesignStateV1Schema = z19.object({
+  schemaVersion: z19.literal(themeV2DesignStateSchemaVersion),
+  siteStyleId: z19.string().min(1).transform(asSiteStyleId),
+  templateId: z19.string().min(1).transform(asDesignSystemTemplateId),
+  templateVersion: z19.number().int().nonnegative(),
+  resolverVersion: z19.number().int().nonnegative(),
+  rhythmPresetId: z19.string().min(1),
+  blocks: z19.array(blockDesignPlanSchema),
+  styleAuthorities: z19.array(blockRuntimeStyleAuthoritySchema)
+}).strict();
+
+// ../theme-core/src/site-styles/runtimeCompiler.ts
+function defineDesignRuntimeRules(rules) {
+  return rules;
+}
+function defineComponentRuntimeRules(rules) {
+  return rules;
+}
+var 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}`
+});
+var 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
+      }
+    }
+  }
+});
+function uniformSectionForeground(token) {
+  return {
+    textColor: token,
+    headingColor: token,
+    linkColor: token,
+    supportingColor: token
+  };
+}
+
 // ../theme-core/src/site-styles/curatedSiteStyles.ts
 var SOFT_EARTH_SITE_STYLE_ID_VALUE = "site-style:soft-earth";
 var SOFT_EARTH_SITE_STYLE_ID = asSiteStyleId(SOFT_EARTH_SITE_STYLE_ID_VALUE);
@@ -9532,6 +10485,50 @@ var expressiveBudget = {
   mediaDensity: "high",
   decorativeRepetition: "medium"
 };
+var 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"
+      }
+    }
+  }
+});
 var expressiveUnderlineInputs = {
   base: {
     background: { type: "transparent" },
@@ -9569,6 +10566,43 @@ var expressiveUnderlineInputs = {
     opacity: 0.6
   }
 };
+var 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
+  }
+};
 function uniqueContentFrameKinds() {
   const kinds = [
     ...new Set(
@@ -9626,6 +10660,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 ? {
@@ -10577,48 +11612,54 @@ var curatedSiteStyles = [
     ]
   }),
   defineCuratedSiteStyle({
-    id: "site-style:original-joy",
-    name: "Original Joy",
-    headingDecoration: { family: "organic-squiggle", colorToken: "primary" },
-    description: "Warm, dark, and editorial: deep clay grounds, cream type, and bold burnt-orange accents for soulful community brands.",
-    generationBrief: "Use a deep brown ground with cream text and burnt-orange accents, large display headings, generous spacing, organic rounded shapes, and bold colour-blocked feature sections. Lead with warmth and belonging; calls to action should feel strong but unhurried.",
+    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: "maximum",
-      radius: "rounded",
+      contrast: "strong",
+      radius: "soft",
       shadow: "subtle",
-      typography: "clean-sans",
+      typography: "serif-editorial",
       spacing: "airy",
-      motion: "expressive"
+      motion: "subtle"
     },
     compositionBudget: expressiveBudget,
     typographyPresetChoices: [
-      typographyChoice("typography-preset:original-joy"),
-      typographyChoice("typography-preset:bold-display"),
-      typographyChoice("typography-preset:modern-sans")
+      typographyChoice("typography-preset:kirtan-ornate"),
+      typographyChoice("typography-preset:luxe-contrast"),
+      typographyChoice("typography-preset:editorial-serif")
     ],
-    defaultTypographyPresetId: "typography-preset:original-joy",
+    defaultTypographyPresetId: "typography-preset:kirtan-ornate",
     themeOverrides: {
-      accordions: boldBorderedAccordionSystem,
-      // Shared card system: warm rounded brown cards (event + testimonial cards
-      // pick this up automatically) with a burnt-orange statement variant.
+      accordions: warmInsetAccordionSystem,
       cards: originalJoyCardSystem,
-      testimonialQuote: accentGlyphQuote,
+      testimonialQuote: serifDisplayQuote,
       bodyText: {
         intro: {
           paragraphSize: "editorial",
           headingSize: "editorial"
         }
-      }
+      },
+      inputs: ornateDarkInputs
     },
-    // Recommended block looks: the bold colour-blocked feature cards, a calm
-    // band for the events spotlight, and statement testimonial cards.
+    designRuntimeRules: kirtanOrnateDesignRuntimeRules,
     recommendedAppearancePresetIds: [
-      "feature-cards-bold-colors",
-      "offerings-calm-list",
-      "testimonials-statement-cards"
+      "hero-brand-scrim-fixed-frame",
+      "media-text-quiet-story",
+      "events-lined-panel",
+      "schedule-details-brand-depth",
+      "testimonials-statement-cards",
+      "contact-form-panel"
     ],
-    // Floating, transparent "Clear Split" header (no fill behind the nav links).
     defaultHeaderSelection: { layoutId: "floating", styleId: "minimal-surface" },
     recommendedHeaderLayoutChoices: [headerLayoutChoice("floating")],
     recommendedHeaderStyleChoicesByLayout: {
@@ -10628,19 +11669,87 @@ var curatedSiteStyles = [
         headerStyleChoice("glass")
       ]
     },
-    // Legacy bridge only (the real curation is the explicit selection above).
-    // Kept to a reserved-space, non-overlay look on purpose: the split hero
-    // flows below the Clear Split header, so we must NOT trigger the immersive
-    // overlay-hero promotion that looks like `floating-glass` would force.
     recommendedHeaderLookIds: ["minimal-transparent"],
     recommendedFooterLookIds: [
       "site-footer-brand-two-band",
       "footer-muted-grounding"
     ],
     buttonPersonalityChoices: [
+      buttonChoice("ornate-ritual"),
       buttonChoice("joy-stamp"),
-      buttonChoice("ink-stamp"),
-      buttonChoice("showtime-pill")
+      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",
+    headingDecoration: { family: "organic-squiggle", colorToken: "primary" },
+    description: "Warm, dark, and editorial: deep clay grounds, cream type, and bold burnt-orange accents for soulful community brands.",
+    generationBrief: "Use a deep brown ground with cream text and burnt-orange accents, large display headings, generous spacing, organic rounded shapes, and bold colour-blocked feature sections. Lead with warmth and belonging; calls to action should feel strong but unhurried.",
+    tokenRecipes: {
+      palette: "brand-led",
+      contrast: "maximum",
+      radius: "rounded",
+      shadow: "subtle",
+      typography: "clean-sans",
+      spacing: "airy",
+      motion: "expressive"
+    },
+    compositionBudget: expressiveBudget,
+    typographyPresetChoices: [
+      typographyChoice("typography-preset:original-joy"),
+      typographyChoice("typography-preset:bold-display"),
+      typographyChoice("typography-preset:modern-sans")
+    ],
+    defaultTypographyPresetId: "typography-preset:original-joy",
+    themeOverrides: {
+      accordions: boldBorderedAccordionSystem,
+      // Shared card system: warm rounded brown cards (event + testimonial cards
+      // pick this up automatically) with a burnt-orange statement variant.
+      cards: originalJoyCardSystem,
+      testimonialQuote: accentGlyphQuote,
+      bodyText: {
+        intro: {
+          paragraphSize: "editorial",
+          headingSize: "editorial"
+        }
+      }
+    },
+    // Recommended block looks: the bold colour-blocked feature cards, a calm
+    // band for the events spotlight, and statement testimonial cards.
+    recommendedAppearancePresetIds: [
+      "feature-cards-bold-colors",
+      "offerings-calm-list",
+      "testimonials-statement-cards"
+    ],
+    // Floating, transparent "Clear Split" header (no fill behind the nav links).
+    defaultHeaderSelection: { layoutId: "floating", styleId: "minimal-surface" },
+    recommendedHeaderLayoutChoices: [headerLayoutChoice("floating")],
+    recommendedHeaderStyleChoicesByLayout: {
+      floating: [
+        headerStyleChoice("minimal-surface"),
+        headerStyleChoice("split-glass"),
+        headerStyleChoice("glass")
+      ]
+    },
+    // Legacy bridge only (the real curation is the explicit selection above).
+    // Kept to a reserved-space, non-overlay look on purpose: the split hero
+    // flows below the Clear Split header, so we must NOT trigger the immersive
+    // overlay-hero promotion that looks like `floating-glass` would force.
+    recommendedHeaderLookIds: ["minimal-transparent"],
+    recommendedFooterLookIds: [
+      "site-footer-brand-two-band",
+      "footer-muted-grounding"
+    ],
+    buttonPersonalityChoices: [
+      buttonChoice("joy-stamp"),
+      buttonChoice("ink-stamp"),
+      buttonChoice("showtime-pill")
     ],
     paletteVariantChoices: [paletteChoice("warm-dark-ember")]
   })
@@ -10677,6 +11786,89 @@ var MQ_TABLET_ONLY = mqBetween(BREAKPOINT_SM, BREAKPOINT_LG_DOWN);
 var MQ_MAX_640 = mqDown(BREAKPOINT_SM);
 var MQ_MAX_768 = mqDown(BREAKPOINT_MD);
 
+// ../blocks/src/system/runtime/nodes/event-registration/registrationDerivations.ts
+function eventMatchesOccurrenceId(event, occurrenceId) {
+  return event.registrationOccurrenceId === occurrenceId || event.publicEventId === occurrenceId;
+}
+function findEventByOccurrenceId(events, occurrenceId) {
+  return events.find((event) => eventMatchesOccurrenceId(event, occurrenceId)) ?? null;
+}
+function findPreSelectedEvent(input) {
+  const occurrenceContext = input.occurrenceContext;
+  if (!occurrenceContext) {
+    return null;
+  }
+  const contextDate = getBookingLocalDateKey(toScheduledBookingDateTime({
+    startsAt: occurrenceContext.startsAt,
+    timeZone: occurrenceContext.timeZone
+  }));
+  return input.scopedEvents.find(
+    (event) => eventMatchesOccurrenceId(event, occurrenceContext.id) || getBookingLocalDateKey(toScheduledBookingDateTime({
+      startsAt: event.startsAt,
+      timeZone: event.timeZone
+    })) === contextDate
+  ) ?? null;
+}
+function resolveRegistrationTarget(input) {
+  const occurrenceId = input.occurrenceContext?.id ?? input.selectedEvent?.registrationOccurrenceId ?? null;
+  if (!occurrenceId) {
+    return null;
+  }
+  return {
+    occurrenceId,
+    selectedEventId: input.selectedEvent?.publicEventId ?? null
+  };
+}
+function resolveEventRequiresPayment(input) {
+  if (input.eligibility) {
+    return input.eligibility.requiresPayment;
+  }
+  if (input.selectedTicketType) {
+    return input.selectedTicketType.priceAmount > 0;
+  }
+  if (!input.event) {
+    return false;
+  }
+  return publicEventPricingType(resolveRuntimeEventPricing(input.event)) !== "free";
+}
+function resolveDiscountContext(input) {
+  const selection = input.paymentSelection.method ? input.paymentSelection : null;
+  if (!input.event) {
+    return null;
+  }
+  if (selection?.method === "pass_bundle" && selection.bundlePassId) {
+    return { type: "pass", passId: selection.bundlePassId };
+  }
+  if (selection?.method === "membership_bundle" && selection.bundleMembershipId) {
+    return { type: "membership", membershipId: selection.bundleMembershipId };
+  }
+  if (!input.eventRequiresPayment) {
+    return null;
+  }
+  if (selection?.method && selection.method !== "stripe") {
+    return null;
+  }
+  return {
+    type: "event",
+    eventSeriesId: input.event.seriesId,
+    eventCategoryId: input.event.eventCategory?.id ?? null,
+    ticketsCount: input.ticketsCount
+  };
+}
+
+// ../blocks/src/system/runtime/nodes/event-registration/registrationEventAdapter.ts
+function toRegistrationEvent(event) {
+  return {
+    ...event,
+    pricing: resolveRuntimeEventPricing(event),
+    publicEventId: event.id,
+    registrationOccurrenceId: event.occurrenceId
+  };
+}
+function toRegistrationEvents(events) {
+  return events.map(toRegistrationEvent);
+}
+
 // ../blocks/src/system/runtime/shared/components/FeedbackMessage.tsx
 import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
 function joinClasses(...parts) {
@@ -10749,8 +11941,8 @@ function AltchaWidget({
         }
       }));
       containerRef.current.appendChild(widget);
-    }).catch((err) => {
-      console.error("Failed to load ALTCHA widget:", err);
+    }).catch((err3) => {
+      console.error("Failed to load ALTCHA widget:", err3);
     });
     return () => {
       if (widget && containerRef.current) {
@@ -10990,10 +12182,10 @@ function useAvailableDates({
           start: append && prev ? prev.start : data.startDate,
           end: data.endDate
         }));
-      } catch (err) {
+      } catch (err3) {
         if (requestId !== requestIdRef.current) return;
         setError(
-          err instanceof Error ? err.message : "Failed to load available dates"
+          err3 instanceof Error ? err3.message : "Failed to load available dates"
         );
       } finally {
         if (mode === "refresh" && requestId === requestIdRef.current) {
@@ -11109,10 +12301,10 @@ function useAvailableSlots({
           }))
         );
         setHasLoaded(true);
-      } catch (err) {
+      } catch (err3) {
         if (requestId !== requestIdRef.current) return;
         setError(
-          err instanceof Error ? err.message : "Failed to load available times"
+          err3 instanceof Error ? err3.message : "Failed to load available times"
         );
       } finally {
         if (mode === "refresh" && requestId === requestIdRef.current) {
@@ -12315,7 +13507,7 @@ function omitRecordKey(record, key) {
   return rest;
 }
 function readAppointmentBookingOverrideData(value) {
-  if (!isRecord3(value)) return null;
+  if (!isRecord4(value)) return null;
   const services = normalizeBookingServices(value.services);
   return {
     form: normalizeBookingFormConfig(value.form),
@@ -12328,7 +13520,7 @@ function createOverrideInputError(reason, message, warnInDev = false) {
   }
   return { ok: false, reason, message };
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null;
 }
 
@@ -13064,13 +14256,13 @@ function usePolling(config) {
       dispatch({ type: "polling-progressed", result: data });
       isPollingRef.current = false;
       return false;
-    } catch (err) {
+    } catch (err3) {
       if (generation !== generationRef.current || !isActiveRef.current) {
         isPollingRef.current = false;
         return true;
       }
-      if (err instanceof Error) {
-        dispatch({ type: "polling-request-failed", error: err });
+      if (err3 instanceof Error) {
+        dispatch({ type: "polling-request-failed", error: err3 });
       }
       isPollingRef.current = false;
       return false;
@@ -14163,6 +15355,20 @@ function buildCheckoutReturnUrls(paramName, anchorId) {
   return { successUrl, cancelUrl };
 }
 
+// ../blocks/src/system/runtime/shared/utils/portalLogout.ts
+function logoutPortal(anchorId) {
+  const form = document.createElement("form");
+  form.method = "POST";
+  form.action = "/api/portal/logout";
+  const redirectInput = document.createElement("input");
+  redirectInput.type = "hidden";
+  redirectInput.name = "redirect_to";
+  redirectInput.value = `${window.location.pathname}#${anchorId}`;
+  form.appendChild(redirectInput);
+  document.body.appendChild(form);
+  form.submit();
+}
+
 // ../blocks/src/system/runtime/shared/utils/scrollToBlock.ts
 function scrollToBlock(anchorId) {
   requestAnimationFrame(() => {
@@ -14170,6 +15376,17 @@ function scrollToBlock(anchorId) {
   });
 }
 
+// ../blocks/src/system/runtime/shared/utils/urlParams.ts
+function consumeSearchParam(paramName) {
+  const url = new URL(window.location.href);
+  const value = url.searchParams.get(paramName);
+  if (value === null) return null;
+  url.searchParams.delete(paramName);
+  const newUrl = url.pathname + (url.search ? url.search : "") + url.hash;
+  window.history.replaceState({}, "", newUrl);
+  return value;
+}
+
 // ../blocks/src/system/runtime/nodes/booking-form.client.tsx
 import { jsx as jsx11, jsxs as jsxs8 } from "react/jsx-runtime";
 var PORTAL_REBOOK_QUERY_PARAM = "rebook";
@@ -14341,97 +15558,1887 @@ var BookingFormClient = ({
   ] });
 };
 
-// ../theme-core/src/header/navDropdownSizing.ts
-var NAV_DROPDOWN_MIN_WIDTH_REM = 12;
-var NAV_DROPDOWN_MAX_WIDTH_REM = 22;
-var NAV_DROPDOWN_VIEWPORT_GUTTER_REM = 1;
-var NAV_DROPDOWN_SHIFT_PROPERTY = "--nav-dropdown-shift-x";
-var NAV_DROPDOWN_MAX_WIDTH_CSS = `min(${NAV_DROPDOWN_MAX_WIDTH_REM}rem, calc(100vw - ${NAV_DROPDOWN_VIEWPORT_GUTTER_REM * 2}rem))`;
-var NAV_DROPDOWN_CONTAINER_RAIL_CSS_RULES = [
-  `min-width: ${NAV_DROPDOWN_MIN_WIDTH_REM}rem;`,
-  `width: max-content;`,
-  `max-width: ${NAV_DROPDOWN_MAX_WIDTH_CSS};`,
-  `transform: translateX(var(${NAV_DROPDOWN_SHIFT_PROPERTY}, 0px));`
-];
-
-// ../theme-core/src/ClientThemeScope.tsx
-import { useMemo as useMemo4 } from "react";
-
-// ../theme-core/src/navigation/presets.ts
-var NAV_LINK_PRESETS = {
-  /**
-   * Minimal - subtle color change on hover
-   */
-  minimal: {
-    name: "Minimal",
-    typography: "body",
-    fontWeight: "medium",
-    textTransform: "none",
-    italic: false,
-    colorToken: "text",
-    hoverColorToken: "primary",
-    padding: "none",
-    borderRadius: "none",
-    effects: {
-      hover: [
-        { effectId: "text-color-change", options: { hoverColorToken: "primary" } }
-      ]
+// ../blocks/src/system/runtime/nodes/event-registration/registrationStateMachine.ts
+function createInitialRegistrationFlowState(hasPreSelectedContext) {
+  return {
+    step: hasPreSelectedContext ? "select-tickets" : "select-event",
+    ticketsCount: 1,
+    isAuthenticated: false,
+    eligibility: null,
+    passOptOut: false,
+    paymentSelection: { method: null },
+    selectionSource: "auto"
+  };
+}
+function selectionEquals(a, b2) {
+  return a.method === b2.method && a.passId === b2.passId && a.membershipId === b2.membershipId && a.bundlePassId === b2.bundlePassId && a.bundleMembershipId === b2.bundleMembershipId && a.productName === b2.productName && a.productDescription === b2.productDescription && a.productPrice === b2.productPrice && a.productCurrency === b2.productCurrency && a.productInterval === b2.productInterval;
+}
+function withDefaultSelection(selection) {
+  if (!selection || !selection.method) {
+    return { method: null };
+  }
+  return selection;
+}
+function computeAutoSelection(input) {
+  const { isAuthenticated, eligibility, ticketsCount, passOptOut } = input;
+  if (!eligibility) return { method: null };
+  if (eligibility.isFree) return { method: "free" };
+  if (isAuthenticated && ticketsCount === 1) {
+    const membership = eligibility.eligibleMemberships[0];
+    if (membership) {
+      return {
+        method: "membership",
+        membershipId: membership.id,
+        productName: membership.membershipName
+      };
     }
-  },
-  /**
-   * Underline - static underline appears on hover
-   */
-  underline: {
-    name: "Underline",
-    typography: "body",
-    fontWeight: "medium",
-    textTransform: "none",
-    italic: false,
-    colorToken: "text",
-    padding: "none",
-    borderRadius: "none",
-    effects: {
-      hover: [{ effectId: "nav-underline", options: { style: "static" } }]
+    const pass = eligibility.eligiblePasses[0];
+    if (pass && !passOptOut) {
+      return {
+        method: "pass",
+        passId: pass.id,
+        productName: pass.passName
+      };
     }
-  },
-  /**
-   * Underline Grow - animated underline grows from center on hover
-   */
-  "underline-grow": {
-    name: "Underline Grow",
-    typography: "body",
-    fontWeight: "medium",
-    textTransform: "none",
-    italic: false,
-    colorToken: "text",
-    padding: "none",
-    borderRadius: "none",
-    effects: {
-      hover: [{ effectId: "nav-underline", options: { style: "grow" } }]
+  }
+  if (eligibility.canPayDirectly && eligibility.price) {
+    return { method: "stripe" };
+  }
+  return { method: null };
+}
+function isSelectionValid(input) {
+  const { selection, isAuthenticated, eligibility, ticketsCount } = input;
+  if (!selection.method) return false;
+  if (!eligibility) {
+    return selection.method === "stripe" || selection.method === "pass_bundle" || selection.method === "membership_bundle";
+  }
+  switch (selection.method) {
+    case "free":
+      return eligibility.isFree;
+    case "stripe":
+      return Boolean(eligibility.canPayDirectly && eligibility.price);
+    case "pass":
+      return isAuthenticated && ticketsCount === 1 && !!selection.passId && eligibility.eligiblePasses.some((pass) => pass.id === selection.passId);
+    case "membership":
+      return isAuthenticated && ticketsCount === 1 && !!selection.membershipId && eligibility.eligibleMemberships.some((membership) => membership.id === selection.membershipId);
+    case "pass_bundle":
+      return ticketsCount === 1 && !!selection.bundlePassId && eligibility.availablePasses.some((pass) => pass.id === selection.bundlePassId);
+    case "membership_bundle":
+      return ticketsCount === 1 && !!selection.bundleMembershipId && eligibility.availableMemberships.some((membership) => membership.id === selection.bundleMembershipId);
+    default:
+      return false;
+  }
+}
+function normalizeRegistrationFlowState(state) {
+  const hasPass = Boolean(state.eligibility?.eligiblePasses.length);
+  const hasMembership = Boolean(state.eligibility?.eligibleMemberships.length);
+  let nextPassOptOut = state.passOptOut;
+  if (nextPassOptOut && (state.step === "select-tickets" || state.ticketsCount !== 1 || !hasPass || hasMembership)) {
+    nextPassOptOut = false;
+  }
+  const autoSelection = computeAutoSelection({
+    isAuthenticated: state.isAuthenticated,
+    eligibility: state.eligibility,
+    ticketsCount: state.ticketsCount,
+    passOptOut: nextPassOptOut
+  });
+  const canKeepManualSelection = state.step === "select-payment" && state.selectionSource === "manual" && isSelectionValid({
+    selection: state.paymentSelection,
+    isAuthenticated: state.isAuthenticated,
+    eligibility: state.eligibility,
+    ticketsCount: state.ticketsCount
+  });
+  const nextSelection = canKeepManualSelection ? state.paymentSelection : autoSelection;
+  const nextSource = canKeepManualSelection ? "manual" : "auto";
+  const normalizedSelection = withDefaultSelection(nextSelection);
+  if (nextPassOptOut === state.passOptOut && nextSource === state.selectionSource && selectionEquals(normalizedSelection, state.paymentSelection)) {
+    return state;
+  }
+  return {
+    ...state,
+    passOptOut: nextPassOptOut,
+    selectionSource: nextSource,
+    paymentSelection: normalizedSelection
+  };
+}
+function registrationFlowReducer(state, action) {
+  switch (action.type) {
+    case "set-step":
+      return normalizeRegistrationFlowState({ ...state, step: action.step });
+    case "set-tickets-count":
+      return normalizeRegistrationFlowState({
+        ...state,
+        ticketsCount: Math.max(1, action.ticketsCount)
+      });
+    case "set-authenticated":
+      return normalizeRegistrationFlowState({ ...state, isAuthenticated: action.isAuthenticated });
+    case "eligibility-updated":
+      return normalizeRegistrationFlowState({ ...state, eligibility: action.eligibility });
+    case "set-manual-payment-selection":
+      return normalizeRegistrationFlowState({
+        ...state,
+        paymentSelection: withDefaultSelection(action.selection),
+        selectionSource: "manual",
+        passOptOut: action.selection.method === "stripe" ? true : state.passOptOut
+      });
+    case "use-card-instead-of-pass":
+      return normalizeRegistrationFlowState({
+        ...state,
+        passOptOut: true,
+        paymentSelection: { method: "stripe" },
+        selectionSource: "manual"
+      });
+    case "event-changed":
+      return normalizeRegistrationFlowState({
+        ...state,
+        step: action.hasPreSelectedContext ? "select-tickets" : "select-event",
+        passOptOut: false,
+        paymentSelection: { method: null },
+        selectionSource: "auto",
+        eligibility: null
+      });
+    case "reset":
+      return createInitialRegistrationFlowState(action.hasPreSelectedContext);
+    default:
+      return state;
+  }
+}
+function isEntitlementSelection(selection) {
+  return selection.method === "pass" || selection.method === "membership";
+}
+function requiresPaymentStep(params) {
+  if (!params.eventRequiresPayment) return false;
+  return !isEntitlementSelection(params.paymentSelection);
+}
+
+// ../blocks/src/system/runtime/nodes/event-registration/event-registration.headless.contract.ts
+var DEFAULT_EVENT_REGISTRATION_MAX_TICKETS = 5;
+
+// ../blocks/src/system/runtime/nodes/event-registration/event-registration.headless.override.ts
+function createEventRegistrationBlockApiConfig(input) {
+  return {
+    baseUrl: input.apiBaseUrl,
+    auth: input.previewToken ? { type: "bearer", token: input.previewToken } : { type: "none" },
+    siteId: input.siteId,
+    isPreview: input.stage === "preview",
+    ...input.portalToken ? { authOverrides: { portal: { type: "bearer", token: input.portalToken } } } : {}
+  };
+}
+function getEventRegistrationOverrideInput(props) {
+  if (!props.siteId) {
+    return {
+      ok: false,
+      reason: "missing-site-id",
+      message: "Event registration is missing site context."
+    };
+  }
+  if (!props.apiBaseUrl) {
+    return {
+      ok: false,
+      reason: "missing-api-base-url",
+      message: "Event registration is missing API configuration."
+    };
+  }
+  const content = props.content ?? {};
+  const data = isRecord5(props.data) ? props.data : {};
+  const events = Array.isArray(data.events) ? data.events.filter(isPublicEventLike) : [];
+  return {
+    ok: true,
+    value: {
+      siteId: props.siteId,
+      apiBaseUrl: props.apiBaseUrl,
+      portalToken: props.portalToken ?? null,
+      previewToken: props.previewToken ?? null,
+      events,
+      ...props.stage ? { stage: props.stage } : {},
+      ...props.occurrenceContext ? { occurrenceContext: props.occurrenceContext } : {},
+      ...isEventRegistrationContentEntryLike(props.contentEntry) ? { contentEntry: props.contentEntry } : {},
+      ...content.maxTickets != null ? { maxTickets: content.maxTickets } : {},
+      ...content.showVenue != null ? { showVenue: content.showVenue } : {},
+      ...content.showCapacity != null ? { showCapacity: content.showCapacity } : {},
+      ...content.successMessage ? { successMessage: content.successMessage } : {},
+      ...content.waitlistMessage ? { waitlistMessage: content.waitlistMessage } : {},
+      ...content.buttonText != null ? { buttonText: content.buttonText } : {},
+      ...content.buttonVariant ? { buttonVariant: content.buttonVariant } : {},
+      ...content.spamProtectionEnabled != null ? { spamProtectionEnabled: content.spamProtectionEnabled } : {},
+      ...content.supportEmail ? { supportEmail: content.supportEmail } : {},
+      ...props.blockId !== void 0 ? { blockId: props.blockId } : {}
     }
-  },
-  /**
-   * Capsule - pill-shaped background on hover
-   */
-  capsule: {
-    name: "Capsule",
-    typography: "body",
-    fontWeight: "medium",
-    textTransform: "none",
-    italic: false,
-    colorToken: "text",
-    padding: "compact",
-    borderRadius: "full",
-    effects: {
-      hover: [
-        {
-          effectId: "background-on-hover-alpha",
-          options: { colorToken: "primary", opacity: 10 }
-        }
-      ],
-      active: [
-        {
-          effectId: "background-on-hover-alpha",
+  };
+}
+function isRecord5(value) {
+  return typeof value === "object" && value !== null;
+}
+function isPublicEventLike(value) {
+  return isRecord5(value) && typeof value.id === "string" && typeof value.occurrenceId === "string" && typeof value.seriesId === "string" && typeof value.title === "string" && typeof value.slug === "string" && typeof value.path === "string" && typeof value.requiresRegistration === "boolean" && isDeliveryMode(value.deliveryMode) && Array.isArray(value.attendanceModes) && typeof value.startsAt === "string" && typeof value.endsAt === "string" && typeof value.timeZone === "string" && isRecord5(value.pricing) && isRecord5(value.paymentTerms) && isAccessRestriction(value.accessRestriction) && Array.isArray(value.allowedCategoryIds);
+}
+function isDeliveryMode(value) {
+  return value === "in_person" || value === "online" || value === "hybrid";
+}
+function isAccessRestriction(value) {
+  return value === "none" || value === "category";
+}
+function isEventRegistrationContentEntryLike(value) {
+  return isRecord5(value) && typeof value.id === "string" && typeof value.slug === "string" && typeof value.contentTypeSlug === "string";
+}
+
+// ../blocks/src/system/runtime/nodes/event-registration/event-registration.headless.planning.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 toHeadlessPaymentSelection(selection) {
+  switch (selection.method) {
+    case null:
+      return { method: "none" };
+    case "free":
+      return { method: "free" };
+    case "stripe":
+      return { method: "stripe" };
+    case "pass":
+      if (!selection.passId) return { method: "none" };
+      return {
+        method: "pass",
+        passId: selection.passId,
+        ...selection.productName ? { productName: selection.productName } : {}
+      };
+    case "membership":
+      if (!selection.membershipId) return { method: "none" };
+      return {
+        method: "membership",
+        membershipId: selection.membershipId,
+        ...selection.productName ? { productName: selection.productName } : {}
+      };
+    case "pass_bundle":
+      if (!selection.bundlePassId) return { method: "none" };
+      return {
+        method: "pass_bundle",
+        passId: selection.bundlePassId,
+        ...selection.productName ? { productName: selection.productName } : {}
+      };
+    case "membership_bundle":
+      if (!selection.bundleMembershipId) return { method: "none" };
+      return {
+        method: "membership_bundle",
+        membershipId: selection.bundleMembershipId,
+        ...selection.productName ? { productName: selection.productName } : {}
+      };
+  }
+}
+function toInternalPaymentSelection(selection) {
+  switch (selection.method) {
+    case "none":
+      return { method: null };
+    case "free":
+      return { method: "free" };
+    case "stripe":
+      return { method: "stripe" };
+    case "pass":
+      return {
+        method: "pass",
+        passId: selection.passId,
+        ...selection.productName ? { productName: selection.productName } : {}
+      };
+    case "membership":
+      return {
+        method: "membership",
+        membershipId: selection.membershipId,
+        ...selection.productName ? { productName: selection.productName } : {}
+      };
+    case "pass_bundle":
+      return {
+        method: "pass_bundle",
+        bundlePassId: selection.passId,
+        ...selection.productName ? { productName: selection.productName } : {}
+      };
+    case "membership_bundle":
+      return {
+        method: "membership_bundle",
+        bundleMembershipId: selection.membershipId,
+        ...selection.productName ? { productName: selection.productName } : {}
+      };
+  }
+}
+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 resolveHeadlessEventRegistrationStatus(wizard) {
+  switch (wizard.step) {
+    case "submitting":
+      return { tag: "submitting" };
+    case "redirecting":
+      return { tag: "redirecting" };
+    case "verifying-payment":
+      return { tag: "verifying-payment" };
+    case "verifying-timeout":
+      return { tag: "verifying-timeout" };
+    case "payment-failed":
+      return { tag: "payment-failed", message: wizard.errorMessage };
+    case "success":
+      return wizard.registrationResult ? { tag: "success", result: wizard.registrationResult } : { tag: "ready" };
+    case "error":
+      return { tag: "error", message: wizard.errorMessage };
+    case "select-event":
+    case "select-tickets":
+    case "enter-details":
+    case "select-payment":
+      return { tag: "ready" };
+  }
+}
+function resolveHeadlessEventRegistrationView(wizard) {
+  if (wizard.scopedEvents.length === 0 && !wizard.occurrenceContext) {
+    return { kind: "empty", message: "No events available for registration." };
+  }
+  const allowedStatuses = getRegistrableStatuses(wizard.api.config.isPreview);
+  const hasRegistrableEvents = wizard.scopedEvents.some(
+    (event) => !event.status || allowedStatuses.includes(event.status)
+  );
+  if (!hasRegistrableEvents && !wizard.occurrenceContext) {
+    return {
+      kind: "unavailable",
+      message: "Registration is not currently available for this event."
+    };
+  }
+  switch (wizard.step) {
+    case "verifying-payment":
+      return { kind: "verifying", message: "Verifying your payment..." };
+    case "success":
+      return wizard.registrationResult ? { kind: "success", result: wizard.registrationResult } : { kind: "form" };
+    case "error":
+    case "payment-failed":
+      return { kind: "error", message: wizard.errorMessage };
+    case "verifying-timeout":
+      return { kind: "verifying", message: "Your registration is saved." };
+    case "select-event":
+    case "select-tickets":
+    case "enter-details":
+    case "select-payment":
+    case "submitting":
+    case "redirecting":
+      return { kind: "form" };
+  }
+}
+function deriveEventRegistrationSteps(input) {
+  const ids = [];
+  if (!input.hasPreSelectedContext) ids.push("select-event");
+  ids.push("select-tickets", "enter-details");
+  const needsPaymentStep = input.eventRequiresPayment && input.paymentSelection.method !== "pass" && input.paymentSelection.method !== "membership";
+  if (needsPaymentStep) ids.push("select-payment");
+  const activeIndex = ids.indexOf(input.step);
+  return ids.map((id, index) => ({
+    id,
+    label: getStepLabel(id),
+    index,
+    state: index === activeIndex ? "active" : activeIndex === -1 || index > activeIndex ? "available" : "complete",
+    canEnter: index <= Math.max(activeIndex + 1, 0),
+    canLeave: activeIndex !== index
+  }));
+}
+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."
+  };
+}
+function getStepLabel(step) {
+  switch (step) {
+    case "select-event":
+      return "Event";
+    case "select-tickets":
+      return "Tickets";
+    case "enter-details":
+      return "Details";
+    case "select-payment":
+      return "Payment";
+  }
+}
+
+// ../blocks/src/system/runtime/nodes/event-registration/utils.ts
+var DEFAULT_EVENT_CURRENCY2 = "usd";
+function transformEligibilityResponse(response) {
+  const { eligibility } = response;
+  const eligiblePasses = eligibility.passes.map((p) => ({
+    id: p.customerPassId,
+    passName: p.passName,
+    creditsRemaining: p.creditsRemaining
+  }));
+  const eligibleMemberships = eligibility.membership ? [{
+    id: eligibility.membership.customerMembershipId,
+    membershipName: eligibility.membership.membershipName
+  }] : [];
+  const isFree = !eligibility.requiresPayment && !eligibility.eventPrice;
+  const canPayDirectly = eligibility.eventPrice !== null && eligibility.eventPrice > 0;
+  const hasPaymentOptions = eligiblePasses.length > 0 || eligibleMemberships.length > 0 || canPayDirectly;
+  const hasUpsellOptions = eligibility.availableForPurchase.passes.length > 0 || eligibility.availableForPurchase.memberships.length > 0;
+  const eligible = eligibility.canJoinWaitlist || !eligibility.isFull && (isFree || hasPaymentOptions || hasUpsellOptions);
+  return {
+    isFree,
+    eligible,
+    requiresPayment: eligibility.requiresPayment,
+    pricingMode: eligibility.pricingMode,
+    selectedTicketTypeId: eligibility.selectedTicketTypeId ?? null,
+    ticketTypes: eligibility.ticketTypes ?? [],
+    isFull: eligibility.isFull,
+    waitlistEnabled: eligibility.waitlistEnabled,
+    canJoinWaitlist: eligibility.canJoinWaitlist,
+    price: eligibility.eventPrice,
+    currency: eligibility.eventPriceCurrency ?? DEFAULT_EVENT_CURRENCY2,
+    requiresAuthForPasses: eligibility.requiresAuthForPasses,
+    requiresAuthForMemberships: eligibility.requiresAuthForMemberships,
+    eligiblePasses,
+    eligibleMemberships,
+    canPayDirectly,
+    eventAcceptsPasses: eligibility.eventAcceptsPasses,
+    eventAcceptsMemberships: eligibility.eventAcceptsMemberships,
+    availablePasses: eligibility.availableForPurchase.passes,
+    availableMemberships: eligibility.availableForPurchase.memberships
+  };
+}
+function getVisibleTicketTypes(input) {
+  const eligibilityTicketTypes = input.eligibility?.ticketTypes;
+  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)
+  );
+}
+function getImplicitSingleAvailableTicketType(ticketTypes) {
+  return ticketTypes.length === 1 && ticketTypes[0]?.availability.kind === "available" ? ticketTypes[0] : null;
+}
+function findSelectedTicketType(input) {
+  if (!input.selectedTicketTypeId) {
+    return null;
+  }
+  return getVisibleTicketTypes({
+    event: input.event,
+    eligibility: input.eligibility,
+    selectedAttendanceMode: input.selectedAttendanceMode
+  }).find((ticketType) => ticketType.id === input.selectedTicketTypeId) ?? null;
+}
+
+// ../blocks/src/system/runtime/nodes/event-registration/hooks.ts
+import { useState as useState6, useEffect as useEffect8, useCallback as useCallback5, useRef as useRef8, useReducer as useReducer4 } from "react";
+
+// ../blocks/src/system/runtime/nodes/event-registration/hooks.state.ts
+var initialEligibilityLookupState = {
+  tag: "idle",
+  eligibility: null,
+  error: null
+};
+function eligibilityLookupReducer(state, action) {
+  switch (action.type) {
+    case "reset":
+      return initialEligibilityLookupState;
+    case "loading-started":
+      return {
+        tag: "loading",
+        eligibility: state.eligibility,
+        error: null
+      };
+    case "resolved":
+      return {
+        tag: "resolved",
+        eligibility: action.eligibility,
+        error: null
+      };
+    case "failed":
+      return {
+        tag: "failed",
+        eligibility: null,
+        error: action.message
+      };
+    default:
+      return assertNever11(action);
+  }
+}
+var initialExistingRegistrationLookupState = {
+  tag: "idle",
+  registration: null
+};
+function existingRegistrationLookupReducer(state, action) {
+  switch (action.type) {
+    case "reset":
+      return initialExistingRegistrationLookupState;
+    case "loading-started":
+      return {
+        tag: "loading",
+        registration: state.registration
+      };
+    case "resolved":
+      return {
+        tag: "resolved",
+        registration: action.registration
+      };
+    default:
+      return assertNever11(action);
+  }
+}
+
+// ../blocks/src/system/runtime/nodes/event-registration/hooks.ts
+function usePortalAuth() {
+  const api = useBlockApi();
+  const [authState, setAuthState] = useState6("checking");
+  const [profile, setProfile] = useState6(null);
+  useEffect8(() => {
+    let cancelled = false;
+    async function checkPortalAuth() {
+      const effectivePortalAuth = api.config.authOverrides?.portal ?? api.config.auth;
+      if (effectivePortalAuth.type !== "bearer") {
+        setAuthState("unauthenticated");
+        return;
+      }
+      setAuthState("checking");
+      try {
+        const me = await api.getPortalProfile();
+        if (cancelled) return;
+        setAuthState("authenticated");
+        setProfile({
+          email: me.profile.email,
+          name: me.profile.name,
+          phone: me.profile.phone || ""
+        });
+      } catch {
+        if (cancelled) return;
+        setAuthState("unauthenticated");
+        setProfile(null);
+      }
+    }
+    void checkPortalAuth();
+    return () => {
+      cancelled = true;
+    };
+  }, [api]);
+  const logout = useCallback5(() => {
+    const form = document.createElement("form");
+    form.method = "POST";
+    form.action = "/api/portal/logout";
+    document.body.appendChild(form);
+    form.submit();
+  }, []);
+  return {
+    authState,
+    isAuthenticated: authState === "authenticated",
+    isChecking: authState === "checking",
+    profile,
+    logout
+  };
+}
+function useEligibility(params) {
+  const api = useBlockApi();
+  const [state, dispatch] = useReducer4(
+    eligibilityLookupReducer,
+    initialEligibilityLookupState
+  );
+  const requestIdRef = useRef8(0);
+  useEffect8(() => {
+    let cancelled = false;
+    async function fetchEligibility() {
+      if (!params.enabled) {
+        requestIdRef.current += 1;
+        dispatch({ type: "reset" });
+        return;
+      }
+      if (!params.occurrenceId || !params.email.trim()) {
+        requestIdRef.current += 1;
+        dispatch({ type: "reset" });
+        return;
+      }
+      const requestId = requestIdRef.current + 1;
+      requestIdRef.current = requestId;
+      dispatch({ type: "loading-started" });
+      try {
+        const result = await api.checkEligibility({
+          occurrenceId: params.occurrenceId,
+          attendanceMode: params.attendanceMode ?? void 0,
+          ticketTypeId: params.ticketTypeId ?? void 0,
+          email: params.email.trim().toLowerCase(),
+          ticketsCount: params.ticketsCount
+        });
+        if (cancelled || requestIdRef.current !== requestId) return;
+        dispatch({
+          type: "resolved",
+          eligibility: transformEligibilityResponse(result)
+        });
+      } catch (err3) {
+        if (cancelled || requestIdRef.current !== requestId) return;
+        dispatch({
+          type: "failed",
+          message: err3 instanceof Error ? err3.message : "Failed to check eligibility"
+        });
+      }
+    }
+    void fetchEligibility();
+    return () => {
+      cancelled = true;
+    };
+  }, [api, params.enabled, params.occurrenceId, params.attendanceMode, params.ticketTypeId, params.email, params.ticketsCount]);
+  return {
+    state,
+    eligibility: state.eligibility,
+    isLoading: state.tag === "loading",
+    error: state.error
+  };
+}
+function useExistingEventRegistration({
+  isAuthenticated,
+  occurrenceId
+}) {
+  const api = useBlockApi();
+  const [state, dispatch] = useReducer4(
+    existingRegistrationLookupReducer,
+    initialExistingRegistrationLookupState
+  );
+  const requestIdRef = useRef8(0);
+  useEffect8(() => {
+    let cancelled = false;
+    async function fetchExistingRegistration() {
+      if (!isAuthenticated || !occurrenceId) {
+        requestIdRef.current += 1;
+        dispatch({ type: "reset" });
+        return;
+      }
+      const requestId = requestIdRef.current + 1;
+      requestIdRef.current = requestId;
+      dispatch({ type: "loading-started" });
+      try {
+        const events = await api.getPortalEvents({ occurrenceId });
+        if (cancelled || requestIdRef.current !== requestId) return;
+        const existing = events.find(
+          (event) => event.occurrenceId === occurrenceId && event.status !== "cancelled" && event.transferState !== "transferred_out"
+        ) ?? null;
+        dispatch({ type: "resolved", registration: existing });
+      } catch {
+        if (cancelled || requestIdRef.current !== requestId) return;
+        dispatch({ type: "resolved", registration: null });
+      }
+    }
+    void fetchExistingRegistration();
+    return () => {
+      cancelled = true;
+    };
+  }, [api, isAuthenticated, occurrenceId]);
+  return {
+    state,
+    registration: state.registration,
+    isLoading: state.tag === "loading"
+  };
+}
+
+// ../blocks/src/system/runtime/nodes/event-registration/sessionStorage.ts
+var STORAGE_PREFIX = "riverbank:event-registration:";
+var STALE_THRESHOLD_MS = 24 * 60 * 60 * 1e3;
+function getStorageKey(siteId, occurrenceId) {
+  return `${STORAGE_PREFIX}${siteId}:${occurrenceId}`;
+}
+function isStorageAvailable() {
+  try {
+    const testKey = "__riverbank_test__";
+    sessionStorage.setItem(testKey, "test");
+    sessionStorage.removeItem(testKey);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function savePendingRegistration(siteId, occurrenceId, data) {
+  if (!isStorageAvailable()) {
+    console.warn("[sessionStorage] Storage not available, skipping save");
+    return;
+  }
+  try {
+    const key = getStorageKey(siteId, occurrenceId);
+    const entry = {
+      ...data,
+      version: 3,
+      timestamp: Date.now()
+    };
+    sessionStorage.setItem(key, JSON.stringify(entry));
+  } catch (error) {
+    console.warn("[sessionStorage] Failed to save registration:", error);
+  }
+}
+function getPendingRegistration(siteId, occurrenceId) {
+  if (!isStorageAvailable()) {
+    return null;
+  }
+  try {
+    if (occurrenceId) {
+      const key = getStorageKey(siteId, occurrenceId);
+      const stored = sessionStorage.getItem(key);
+      if (stored) {
+        return parseAndValidateEntry(stored, key);
+      }
+      return null;
+    }
+    const sitePrefix = `${STORAGE_PREFIX}${siteId}:`;
+    for (let i = 0; i < sessionStorage.length; i++) {
+      const key = sessionStorage.key(i);
+      if (key?.startsWith(sitePrefix)) {
+        const stored = sessionStorage.getItem(key);
+        if (stored) {
+          const entry = parseAndValidateEntry(stored, key);
+          if (entry) return entry;
+        }
+      }
+    }
+    return null;
+  } catch (error) {
+    console.warn("[sessionStorage] Failed to read registration:", error);
+    return null;
+  }
+}
+function parseAndValidateEntry(stored, key) {
+  try {
+    const raw = JSON.parse(stored);
+    if (!raw || typeof raw !== "object") {
+      sessionStorage.removeItem(key);
+      return null;
+    }
+    const version = raw.version;
+    if (version !== 1 && version !== 2 && version !== 3) {
+      console.warn("[sessionStorage] Unknown version, ignoring entry");
+      sessionStorage.removeItem(key);
+      return null;
+    }
+    const entry = raw;
+    const timestamp = typeof entry.timestamp === "number" ? entry.timestamp : NaN;
+    if (!Number.isFinite(timestamp)) {
+      sessionStorage.removeItem(key);
+      return null;
+    }
+    const age = Date.now() - timestamp;
+    if (age > STALE_THRESHOLD_MS) {
+      console.info("[sessionStorage] Entry is stale, removing");
+      sessionStorage.removeItem(key);
+      return null;
+    }
+    if (entry.version === 1) {
+      const legacy = entry;
+      return {
+        version: 3,
+        attendeeId: legacy.attendeeId,
+        formData: legacy.formData,
+        ticketsCount: legacy.ticketsCount,
+        selectedEventId: legacy.selectedEventId,
+        selectedAttendanceMode: null,
+        selectedTicketTypeId: null,
+        paymentSelection: { method: legacy.paymentMethod },
+        timestamp: legacy.timestamp
+      };
+    }
+    if (entry.version === 2) {
+      return {
+        version: 3,
+        attendeeId: entry.attendeeId,
+        formData: entry.formData,
+        ticketsCount: entry.ticketsCount,
+        selectedEventId: entry.selectedEventId,
+        selectedAttendanceMode: null,
+        selectedTicketTypeId: null,
+        paymentSelection: entry.paymentSelection,
+        timestamp: entry.timestamp
+      };
+    }
+    return entry;
+  } catch {
+    console.warn("[sessionStorage] Failed to parse entry, removing");
+    sessionStorage.removeItem(key);
+    return null;
+  }
+}
+function clearPendingRegistration(siteId, occurrenceId) {
+  if (!isStorageAvailable()) {
+    return;
+  }
+  try {
+    const key = getStorageKey(siteId, occurrenceId);
+    sessionStorage.removeItem(key);
+  } catch {
+  }
+}
+function cleanupStaleRegistrations() {
+  if (!isStorageAvailable()) {
+    return;
+  }
+  try {
+    const keysToRemove = [];
+    for (let i = 0; i < sessionStorage.length; i++) {
+      const key = sessionStorage.key(i);
+      if (!key?.startsWith(STORAGE_PREFIX)) {
+        continue;
+      }
+      try {
+        const stored = sessionStorage.getItem(key);
+        if (!stored) continue;
+        const entry = JSON.parse(stored);
+        const age = Date.now() - entry.timestamp;
+        if (age > STALE_THRESHOLD_MS) {
+          keysToRemove.push(key);
+        }
+      } catch {
+        keysToRemove.push(key);
+      }
+    }
+    for (const key of keysToRemove) {
+      sessionStorage.removeItem(key);
+    }
+    if (keysToRemove.length > 0) {
+      console.info(`[sessionStorage] Cleaned up ${keysToRemove.length} stale entries`);
+    }
+  } catch (error) {
+    console.warn("[sessionStorage] Cleanup failed:", error);
+  }
+}
+
+// ../blocks/src/system/runtime/nodes/event-registration/useEventRegistrationWizard.ts
+import { useCallback as useCallback6, useEffect as useEffect11, useMemo as useMemo6, useReducer as useReducer5, useState as useState8 } from "react";
+
+// ../blocks/src/system/runtime/nodes/event-registration/validation.ts
+function validateFormData2(formData) {
+  const errors = {};
+  if (!formData.name.trim()) {
+    errors.name = "Name is required";
+  }
+  if (!formData.email.trim()) {
+    errors.email = "Email is required";
+  } else if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(formData.email)) {
+    errors.email = "Invalid email address";
+  }
+  return errors;
+}
+
+// ../blocks/src/system/runtime/shared/useWaitlistClaim.ts
+import { useEffect as useEffect9, useState as useState7, useSyncExternalStore } from "react";
+var WAITLIST_CLAIM_LOCATION_EVENT = "riverbank:waitlist-claim-location-change";
+var historyPatched = false;
+function emitWaitlistClaimLocationChange() {
+  if (typeof window === "undefined") return;
+  window.dispatchEvent(new Event(WAITLIST_CLAIM_LOCATION_EVENT));
+}
+function ensureWaitlistClaimLocationTracking() {
+  if (typeof window === "undefined" || historyPatched) {
+    return;
+  }
+  historyPatched = true;
+  const history = window.history;
+  if (history.__riverbankWaitlistClaimPatched__) {
+    return;
+  }
+  const wrapHistoryMethod = (method) => {
+    return function patched(...args) {
+      method.apply(this, args);
+      emitWaitlistClaimLocationChange();
+    };
+  };
+  try {
+    history.pushState = wrapHistoryMethod(history.pushState);
+    history.replaceState = wrapHistoryMethod(history.replaceState);
+    history.__riverbankWaitlistClaimPatched__ = true;
+  } catch {
+  }
+  window.addEventListener("popstate", emitWaitlistClaimLocationChange);
+}
+function getWaitlistClaimTokenFromUrl() {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  const token = new URLSearchParams(window.location.search).get("waitlist_claim")?.trim() ?? "";
+  return token.length > 0 ? token : null;
+}
+function subscribeToWaitlistClaimToken(callback) {
+  if (typeof window === "undefined") {
+    return () => {
+    };
+  }
+  ensureWaitlistClaimLocationTracking();
+  window.addEventListener(WAITLIST_CLAIM_LOCATION_EVENT, callback);
+  return () => {
+    window.removeEventListener(WAITLIST_CLAIM_LOCATION_EVENT, callback);
+  };
+}
+function getWaitlistClaimTokenSnapshot() {
+  return getWaitlistClaimTokenFromUrl();
+}
+function useWaitlistClaim() {
+  const api = useBlockApi();
+  const token = useSyncExternalStore(
+    subscribeToWaitlistClaimToken,
+    getWaitlistClaimTokenSnapshot,
+    () => null
+  );
+  const [claim, setClaim] = useState7(null);
+  const [error, setError] = useState7(null);
+  const [loginMessage, setLoginMessage] = useState7(null);
+  const [requiresPortalLogin, setRequiresPortalLogin] = useState7(false);
+  const [isLoading, setIsLoading] = useState7(() => Boolean(token));
+  useEffect9(() => {
+    let cancelled = false;
+    async function resolveClaim() {
+      if (!token) {
+        setClaim(null);
+        setError(null);
+        setLoginMessage(null);
+        setRequiresPortalLogin(false);
+        setIsLoading(false);
+        return;
+      }
+      setIsLoading(true);
+      setClaim(null);
+      setError(null);
+      setLoginMessage(null);
+      setRequiresPortalLogin(false);
+      try {
+        const result = await api.resolveWaitlistClaim({ claimToken: token });
+        if (cancelled) return;
+        setClaim(result);
+      } catch (claimError) {
+        if (cancelled) return;
+        const message = claimError instanceof Error ? claimError.message : "Failed to resolve waitlist claim";
+        setClaim(null);
+        if (claimError instanceof BlockApiError && claimError.status === 401) {
+          setRequiresPortalLogin(true);
+          setLoginMessage(message);
+          setError(null);
+        } else {
+          setError(message);
+        }
+      } finally {
+        if (!cancelled) {
+          setIsLoading(false);
+        }
+      }
+    }
+    void resolveClaim();
+    return () => {
+      cancelled = true;
+    };
+  }, [api, token]);
+  return {
+    token,
+    claim,
+    error,
+    loginMessage,
+    requiresPortalLogin,
+    isLoading
+  };
+}
+
+// ../blocks/src/system/runtime/nodes/event-registration/useEventRegistrationStripeReturn.ts
+import { useEffect as useEffect10, useMemo as useMemo5 } from "react";
+
+// ../blocks/src/system/runtime/hooks/usePaymentVerification.ts
+import { useMemo as useMemo4 } from "react";
+function usePaymentVerification(config) {
+  const api = useBlockApi();
+  const pollingConfig = useMemo4(() => {
+    if (!config) return null;
+    return {
+      pollFn: () => api.getEventRegistrationStatus({ attendeeId: config.transactionId }),
+      isComplete: (result) => result.paymentStatus === "completed" || result.paymentStatus === "not_required",
+      isFailed: (result) => result.paymentStatus === "failed" || result.paymentStatus === "refunded",
+      maxAttempts: config.maxAttempts,
+      interval: config.pollInterval
+    };
+  }, [api, config]);
+  const polling = usePolling(pollingConfig);
+  const paymentStatus = polling.result?.paymentStatus ?? null;
+  let errorMessage = null;
+  if (polling.status === "timeout") {
+    errorMessage = "Could not verify payment. If you were charged, please contact support.";
+  } else if (polling.status === "failed" && paymentStatus) {
+    errorMessage = paymentStatus === "refunded" ? "Payment was refunded. Please contact support." : "Payment was declined. Please try again.";
+  } else if (polling.error) {
+    errorMessage = polling.error.message;
+  }
+  return {
+    status: polling.status,
+    paymentStatus,
+    attendeeStatus: polling.result?.attendeeStatus ?? null,
+    waitlistPosition: polling.result?.waitlistPosition ?? null,
+    error: errorMessage,
+    retry: polling.retry
+  };
+}
+
+// ../blocks/src/system/runtime/nodes/event-registration/useEventRegistrationStripeReturn.ts
+function useEventRegistrationStripeReturn(options) {
+  const {
+    api,
+    events,
+    occurrenceId,
+    pendingAttendeeId,
+    setErrorMessage,
+    setFormData,
+    setPaymentSelection,
+    setPendingAttendeeId,
+    setRegistrationResult,
+    setSelectedEvent,
+    setSelectedAttendanceMode,
+    setSelectedTicketTypeId,
+    setStep,
+    setTicketsCount,
+    step
+  } = options;
+  const verificationConfig = useMemo5(
+    () => step === "verifying-payment" && pendingAttendeeId ? { transactionId: pendingAttendeeId } : null,
+    [step, pendingAttendeeId]
+  );
+  const verification = usePaymentVerification(verificationConfig);
+  useEffect10(() => {
+    cleanupStaleRegistrations();
+    const registrationStatus = consumeSearchParam("registration");
+    if (!registrationStatus) return;
+    const siteId = api.config.siteId;
+    if (!siteId) return;
+    const pending = getPendingRegistration(siteId, occurrenceId || void 0);
+    if (!pending) return;
+    setFormData(pending.formData);
+    setTicketsCount(pending.ticketsCount);
+    if (pending.selectedEventId) {
+      const event = events.find((e) => e.publicEventId === pending.selectedEventId) ?? null;
+      if (event) setSelectedEvent(event);
+    }
+    setSelectedAttendanceMode(pending.selectedAttendanceMode ?? null);
+    setSelectedTicketTypeId(pending.selectedTicketTypeId ?? null);
+    setPaymentSelection(pending.paymentSelection);
+    if (registrationStatus === "cancelled") {
+      setStep("select-payment");
+    } else if (registrationStatus === "success") {
+      setPendingAttendeeId(pending.attendeeId);
+      setStep("verifying-payment");
+    }
+  }, []);
+  useEffect10(() => {
+    if (verification.status === "completed") {
+      const siteId = api.config.siteId;
+      if (siteId && occurrenceId) {
+        clearPendingRegistration(siteId, occurrenceId);
+      }
+      setRegistrationResult({
+        status: "confirmed"
+      });
+      setStep("success");
+    } else if (verification.status === "failed") {
+      setErrorMessage(verification.error ?? "Payment failed. Please try again.");
+      setStep("payment-failed");
+    } else if (verification.status === "timeout") {
+      setStep("verifying-timeout");
+    }
+  }, [
+    verification.status,
+    verification.attendeeStatus,
+    verification.waitlistPosition,
+    verification.error,
+    api.config.siteId,
+    occurrenceId,
+    setErrorMessage,
+    setRegistrationResult,
+    setStep
+  ]);
+  return verification;
+}
+
+// ../blocks/src/system/runtime/nodes/event-registration/useEventRegistrationSubmit.ts
+function useEventRegistrationSubmit(options) {
+  return async (method, passId, membershipId, selection, submitOptions) => {
+    const submitOccurrenceId = options.registrationTarget?.occurrenceId;
+    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";
+      const bundleProductId = isBundle ? passId || membershipId : void 0;
+      const selectionSnapshot = (() => {
+        if (selection?.method) {
+          return selection;
+        }
+        if (method === "pass") {
+          return { method: "pass", passId: passId ?? void 0 };
+        }
+        if (method === "membership") {
+          return { method: "membership", membershipId: membershipId ?? void 0 };
+        }
+        if (method === "pass_bundle") {
+          return { method: "pass_bundle", bundlePassId: bundleProductId ?? void 0 };
+        }
+        if (method === "membership_bundle") {
+          return { method: "membership_bundle", bundleMembershipId: bundleProductId ?? void 0 };
+        }
+        return { method };
+      })();
+      const guestsPayload = options.requireGuestDetails && options.guests.length > 0 ? options.guests.map((guest) => ({
+        name: guest.name.trim(),
+        email: guest.email?.trim().toLowerCase() || void 0,
+        phone: guest.phone?.trim() || void 0
+      })) : void 0;
+      const result = await options.api.registerForEvent({
+        occurrenceId: submitOccurrenceId,
+        attendanceMode: options.selectedAttendanceMode ?? void 0,
+        ticketTypeId: options.selectedTicketTypeId ?? void 0,
+        email: options.formData.email.trim().toLowerCase(),
+        name: options.formData.name.trim(),
+        ticketsCount: options.ticketsCount,
+        phone: options.formData.phone.trim() || void 0,
+        notes: options.formData.notes.trim() || void 0,
+        altchaSolution: options.altchaSolution,
+        paymentMethod: method,
+        customerPassId: method === "pass" ? passId : void 0,
+        customerMembershipId: method === "membership" ? membershipId : void 0,
+        bundleProductId,
+        claimToken: options.claimToken ?? void 0,
+        guests: guestsPayload
+      });
+      const needsStripeCheckout = !result.alreadyRegistered && result.status === "confirmed" && result.pendingPayment && (method === "stripe" || method === "pass_bundle" || method === "membership_bundle");
+      if (needsStripeCheckout) {
+        options.setPendingAttendeeId(result.attendeeId);
+        options.setStep("redirecting");
+        const currentUrl = new URL(window.location.href);
+        const successParams = new URLSearchParams(currentUrl.search);
+        successParams.set("registration", "success");
+        const successUrl = `${currentUrl.origin}${currentUrl.pathname}?${successParams.toString()}${currentUrl.hash}`;
+        const cancelParams = new URLSearchParams(currentUrl.search);
+        cancelParams.set("registration", "cancelled");
+        const cancelUrl = `${currentUrl.origin}${currentUrl.pathname}?${cancelParams.toString()}${currentUrl.hash}`;
+        const checkoutType = method === "pass_bundle" ? "pass_bundle" : method === "membership_bundle" ? "membership_bundle" : "event";
+        const checkoutResult = await options.api.createEventCheckout({
+          attendeeId: result.attendeeId,
+          checkoutType,
+          productId: bundleProductId,
+          discountCode: options.discountCode.trim() ? options.discountCode.trim() : void 0,
+          successUrl,
+          cancelUrl
+        });
+        if (checkoutResult.bypassed) {
+          options.setRegistrationResult({ status: "confirmed" });
+          options.setStep("success");
+          return { ok: true, outcome: { kind: "completed" } };
+        }
+        if (!checkoutResult.checkoutUrl) {
+          throw new Error("Checkout URL missing");
+        }
+        const siteId = options.api.config.siteId;
+        if (siteId && submitOccurrenceId) {
+          savePendingRegistration(siteId, submitOccurrenceId, {
+            attendeeId: result.attendeeId,
+            formData: options.formData,
+            ticketsCount: options.ticketsCount,
+            selectedEventId: options.registrationTarget?.selectedEventId ?? null,
+            selectedAttendanceMode: options.selectedAttendanceMode,
+            selectedTicketTypeId: options.selectedTicketTypeId ?? null,
+            paymentSelection: selectionSnapshot
+          });
+        }
+        if (submitOptions?.redirect === "manual") {
+          return {
+            ok: true,
+            outcome: {
+              kind: "checkout_redirect",
+              checkoutUrl: checkoutResult.checkoutUrl
+            }
+          };
+        }
+        window.location.href = checkoutResult.checkoutUrl;
+        return { ok: true, outcome: { kind: "checkout_redirect", checkoutUrl: checkoutResult.checkoutUrl } };
+      }
+      if (result.alreadyRegistered) {
+        const title = result.status === "waitlist" ? "Already waitlisted" : "Already registered";
+        const fallbackMessage = result.status === "waitlist" ? "You are already on the waitlist for this event." : "You are already registered for this event.";
+        options.setRegistrationResult({
+          status: result.status,
+          variant: "info",
+          title,
+          message: result.message ?? fallbackMessage
+        });
+      } else if (result.status === "waitlist") {
+        const waitlistMessage = typeof result.waitlistPosition === "number" ? `You've been added to the waitlist (position ${result.waitlistPosition}).` : "You've been added to the waitlist.";
+        options.setRegistrationResult({
+          status: "waitlist",
+          title: "Added to waitlist",
+          message: result.message ?? waitlistMessage
+        });
+      } else {
+        options.setRegistrationResult({ status: result.status });
+      }
+      options.setStep("success");
+      return { ok: true, outcome: { kind: "completed" } };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Registration failed";
+      options.setErrorMessage(message);
+      options.setStep("error");
+      return {
+        ok: false,
+        reason: "submission-failed",
+        message
+      };
+    }
+  };
+}
+
+// ../blocks/src/system/runtime/nodes/event-registration/useEventRegistrationWizard.ts
+function useEventRegistrationWizard(options) {
+  const api = useBlockApi();
+  const registrationEvents = useMemo6(
+    () => toRegistrationEvents(options.events ?? []),
+    [options.events]
+  );
+  const scopedEvents = useMemo6(() => {
+    const allEvents = registrationEvents;
+    if (options.occurrenceContext?.seriesId) {
+      return allEvents.filter((event) => event.seriesId === options.occurrenceContext?.seriesId);
+    }
+    const entrySlug = options.contentEntry?.slug;
+    const entryContentType = options.contentEntry?.contentTypeSlug;
+    if (entrySlug && entryContentType && isEventContentType(entryContentType)) {
+      return allEvents.filter((event) => event.slug === entrySlug);
+    }
+    return allEvents;
+  }, [registrationEvents, options.occurrenceContext?.seriesId, options.contentEntry?.slug, options.contentEntry?.contentTypeSlug]);
+  const preSelectedEvent = useMemo6(
+    () => findPreSelectedEvent({
+      scopedEvents,
+      occurrenceContext: options.occurrenceContext
+    }),
+    [scopedEvents, options.occurrenceContext]
+  );
+  const hasPreSelectedContext = !!(options.occurrenceContext || preSelectedEvent);
+  const [flowState, dispatchFlow] = useReducer5(
+    registrationFlowReducer,
+    hasPreSelectedContext,
+    createInitialRegistrationFlowState
+  );
+  const step = flowState.step;
+  const ticketsCount = flowState.ticketsCount;
+  const paymentSelection = flowState.paymentSelection;
+  const [selectedEvent, setSelectedEvent] = useState8(preSelectedEvent ?? null);
+  const [formData, setFormData] = useState8({ name: "", email: "", phone: "", notes: "" });
+  const [errors, setErrors] = useState8({});
+  const [guests, setGuests] = useState8([]);
+  const [guestErrors, setGuestErrors] = useState8({});
+  const [guestSectionShake, setGuestSectionShake] = useState8(false);
+  const [selectedAttendanceMode, setSelectedAttendanceMode] = useState8(
+    preSelectedEvent?.deliveryMode === "online" ? "online" : preSelectedEvent?.deliveryMode === "in_person" ? "in_person" : null
+  );
+  const [selectedTicketTypeId, setSelectedTicketTypeId] = useState8(null);
+  const [registrationResult, setRegistrationResult] = useState8(null);
+  const [errorMessage, setErrorMessage] = useState8("");
+  const [altchaSolution, setAltchaSolution] = useState8(null);
+  const { authState: portalAuthState, profile: portalProfile } = usePortalAuth();
+  const waitlistClaim = useWaitlistClaim();
+  const [showMagicLinkModal, setShowMagicLinkModal] = useState8(false);
+  const [pendingAttendeeId, setPendingAttendeeId] = useState8(null);
+  const [paymentStepState, setPaymentStepState] = useState8({
+    status: "loading",
+    canContinue: false,
+    buttonText: "Continue",
+    showLoginPrompt: false
+  });
+  useEffect11(() => {
+    if (portalAuthState !== "authenticated" || !portalProfile) return;
+    setFormData((prev) => ({
+      ...prev,
+      email: portalProfile.email,
+      name: prev.name || portalProfile.name,
+      phone: prev.phone || portalProfile.phone || ""
+    }));
+  }, [portalAuthState, portalProfile]);
+  const handleLogout = () => logoutPortal(options.anchorId);
+  const registrationTarget = useMemo6(
+    () => resolveRegistrationTarget({
+      occurrenceContext: options.occurrenceContext,
+      selectedEvent
+    }),
+    [options.occurrenceContext, selectedEvent]
+  );
+  const occurrenceId = registrationTarget?.occurrenceId ?? "";
+  const eligibilityResult = useEligibility({
+    enabled: portalAuthState === "authenticated" || step === "enter-details" || step === "select-payment",
+    occurrenceId,
+    attendanceMode: selectedAttendanceMode,
+    ticketTypeId: selectedTicketTypeId,
+    email: formData.email,
+    ticketsCount
+  });
+  const existingRegistrationResult = useExistingEventRegistration({
+    isAuthenticated: portalAuthState === "authenticated",
+    occurrenceId
+  });
+  const eligibility = eligibilityResult.eligibility;
+  const eligibilityLoading = eligibilityResult.isLoading;
+  const eligibilityError = eligibilityResult.error;
+  const setStep = useCallback6((nextStep) => {
+    dispatchFlow({ type: "set-step", step: nextStep });
+  }, []);
+  const setTicketsCount = useCallback6((nextTicketsCount) => {
+    dispatchFlow({
+      type: "set-tickets-count",
+      ticketsCount: waitlistClaim.claim ? 1 : nextTicketsCount
+    });
+  }, [waitlistClaim.claim]);
+  useEffect11(() => {
+    const claim = waitlistClaim.claim;
+    if (!claim || claim.subject.kind !== "event_occurrence") return;
+    const occurrenceId2 = claim.subject.occurrenceId;
+    const matchedEvent = findEventByOccurrenceId(scopedEvents, occurrenceId2);
+    if (!matchedEvent && options.occurrenceContext?.id !== occurrenceId2) {
+      setErrorMessage("This waitlist claim is for a different event.");
+      setStep("error");
+      return;
+    }
+    if (matchedEvent) {
+      setSelectedEvent(matchedEvent);
+    }
+    setSelectedAttendanceMode(claim.subject.attendanceMode);
+    dispatchFlow({ type: "set-tickets-count", ticketsCount: 1 });
+    setFormData((prev) => ({
+      ...prev,
+      email: claim.prefill.email,
+      name: claim.prefill.name,
+      phone: claim.prefill.phone ?? "",
+      notes: claim.prefill.notes ?? ""
+    }));
+    setGuests(
+      claim.prefill.guests.map((guest) => ({
+        name: guest.name,
+        email: guest.email ?? "",
+        phone: guest.phone ?? ""
+      }))
+    );
+  }, [waitlistClaim.claim, scopedEvents, options.occurrenceContext?.id, setStep]);
+  useEffect11(() => {
+    if (waitlistClaim.requiresPortalLogin) return;
+    if (!waitlistClaim.error) return;
+    setErrorMessage(waitlistClaim.error);
+    setStep("error");
+  }, [waitlistClaim.error, waitlistClaim.requiresPortalLogin, setStep]);
+  useEffect11(() => {
+    if (!waitlistClaim.requiresPortalLogin) return;
+    if (portalAuthState !== "unauthenticated") return;
+    setShowMagicLinkModal(true);
+  }, [portalAuthState, waitlistClaim.requiresPortalLogin]);
+  useEffect11(() => {
+    if (portalAuthState === "authenticated" || !waitlistClaim.requiresPortalLogin) {
+      setShowMagicLinkModal(false);
+    }
+  }, [portalAuthState, waitlistClaim.requiresPortalLogin]);
+  useEffect11(() => {
+    dispatchFlow({ type: "set-authenticated", isAuthenticated: portalAuthState === "authenticated" });
+  }, [portalAuthState]);
+  useEffect11(() => {
+    const event = selectedEvent ?? preSelectedEvent;
+    if (!event) {
+      if (selectedAttendanceMode !== null) {
+        setSelectedAttendanceMode(null);
+      }
+      return;
+    }
+    const deliveryMode = event.deliveryMode ?? "in_person";
+    if (deliveryMode === "online") {
+      if (selectedAttendanceMode !== "online") {
+        setSelectedAttendanceMode("online");
+      }
+      return;
+    }
+    if (deliveryMode === "in_person") {
+      if (selectedAttendanceMode !== "in_person") {
+        setSelectedAttendanceMode("in_person");
+      }
+      return;
+    }
+    if (selectedAttendanceMode && (event.attendanceModes ?? []).some((mode) => mode.mode === selectedAttendanceMode)) {
+      return;
+    }
+    setSelectedAttendanceMode(null);
+  }, [preSelectedEvent, selectedAttendanceMode, selectedEvent]);
+  useEffect11(() => {
+    dispatchFlow({ type: "eligibility-updated", eligibility });
+  }, [eligibility]);
+  const verification = useEventRegistrationStripeReturn({
+    api,
+    events: registrationEvents,
+    occurrenceId,
+    step,
+    pendingAttendeeId,
+    setFormData,
+    setTicketsCount,
+    setSelectedEvent,
+    setSelectedAttendanceMode,
+    setSelectedTicketTypeId,
+    setPaymentSelection: (selection) => dispatchFlow({ type: "set-manual-payment-selection", selection }),
+    setPendingAttendeeId,
+    setStep,
+    setRegistrationResult: (result) => setRegistrationResult(result),
+    setErrorMessage
+  });
+  const requireGuestDetails = useMemo6(() => {
+    const event = selectedEvent ?? preSelectedEvent;
+    return event?.requireGuestDetails === true;
+  }, [selectedEvent, preSelectedEvent]);
+  const visibleTicketTypes = useMemo6(
+    () => getVisibleTicketTypes({
+      event: selectedEvent ?? preSelectedEvent,
+      eligibility,
+      selectedAttendanceMode
+    }),
+    [selectedAttendanceMode, selectedEvent, preSelectedEvent, eligibility]
+  );
+  const selectedTicketType = useMemo6(
+    () => findSelectedTicketType({
+      event: selectedEvent ?? preSelectedEvent,
+      eligibility,
+      selectedTicketTypeId,
+      selectedAttendanceMode
+    }),
+    [selectedAttendanceMode, selectedEvent, preSelectedEvent, eligibility, selectedTicketTypeId]
+  );
+  const ticketTypeSelectionRequired = useMemo6(() => {
+    const event = selectedEvent ?? preSelectedEvent;
+    if (!event || publicEventPricingMode(resolveRuntimeEventPricing(event)) !== "ticket_types") {
+      return false;
+    }
+    if ((event.deliveryMode ?? "in_person") === "hybrid" && !selectedAttendanceMode) {
+      return false;
+    }
+    const selectedModeAvailability = selectedAttendanceMode ? (event.attendanceModes ?? []).find((mode) => mode.mode === selectedAttendanceMode) ?? null : null;
+    const canJoinWaitlist = (selectedModeAvailability?.availableSpots ?? event.availableSpots) === 0 && (selectedModeAvailability?.waitlistEnabled ?? event.waitlistEnabled) === true;
+    return !canJoinWaitlist;
+  }, [selectedAttendanceMode, selectedEvent, preSelectedEvent]);
+  const hasValidSelectedTicketType = !ticketTypeSelectionRequired || Boolean(
+    selectedTicketType && selectedTicketType.availability.kind === "available"
+  );
+  useEffect11(() => {
+    const event = selectedEvent ?? preSelectedEvent;
+    if (!event || publicEventPricingMode(resolveRuntimeEventPricing(event)) !== "ticket_types") {
+      if (selectedTicketTypeId !== null) {
+        setSelectedTicketTypeId(null);
+      }
+      return;
+    }
+    const implicitTicketType = getImplicitSingleAvailableTicketType(visibleTicketTypes);
+    if (implicitTicketType && selectedTicketTypeId !== implicitTicketType.id) {
+      setSelectedTicketTypeId(implicitTicketType.id);
+      return;
+    }
+    if (selectedTicketTypeId && !visibleTicketTypes.some((ticketType) => ticketType.id === selectedTicketTypeId)) {
+      setSelectedTicketTypeId(null);
+    }
+  }, [selectedEvent, preSelectedEvent, selectedTicketTypeId, visibleTicketTypes]);
+  useEffect11(() => {
+    if (!requireGuestDetails) {
+      if (guests.length > 0) setGuests([]);
+      return;
+    }
+    const guestCount = ticketsCount - 1;
+    if (guestCount <= 0) {
+      if (guests.length > 0) setGuests([]);
+      return;
+    }
+    if (guests.length !== guestCount) {
+      const newGuests = [];
+      for (let i = 0; i < guestCount; i++) {
+        newGuests.push(guests[i] ?? { name: "", email: "", phone: "" });
+      }
+      setGuests(newGuests);
+    }
+  }, [ticketsCount, requireGuestDetails, guests]);
+  const validateForm = () => {
+    const newErrors = validateFormData2(formData);
+    setErrors(newErrors);
+    const newGuestErrors = {};
+    if (requireGuestDetails && guests.length > 0) {
+      for (const [index, guest] of guests.entries()) {
+        if (!guest.name.trim()) {
+          newGuestErrors[index] = { name: "Name is required" };
+        }
+      }
+    }
+    setGuestErrors(newGuestErrors);
+    return Object.keys(newErrors).length === 0 && Object.keys(newGuestErrors).length === 0;
+  };
+  const handleGuestShakeEnd = () => {
+    setGuestSectionShake(false);
+  };
+  const eventRequiresPayment = useMemo6(
+    () => resolveEventRequiresPayment({
+      eligibility,
+      selectedTicketType,
+      event: selectedEvent ?? preSelectedEvent
+    }),
+    [eligibility, selectedTicketType, selectedEvent, preSelectedEvent]
+  );
+  const handleDetailsComplete = async () => {
+    if (ticketTypeSelectionRequired && !hasValidSelectedTicketType) {
+      const message = "Select a ticket type to continue.";
+      setErrorMessage(message);
+      setStep("error");
+      return { ok: false, reason: "blocked", message };
+    }
+    if (!validateForm()) {
+      setGuestSectionShake(true);
+      return {
+        ok: false,
+        reason: "validation-failed",
+        message: "Check the highlighted fields and try again."
+      };
+    }
+    if (waitlistClaim.claim === null && eligibility?.isFull && !eligibility.canJoinWaitlist) {
+      const message = "This event is sold out.";
+      setErrorMessage(message);
+      setStep("error");
+      return { ok: false, reason: "blocked", message };
+    }
+    const shouldCollectPayment = !eligibility?.canJoinWaitlist && requiresPaymentStep({ eventRequiresPayment, paymentSelection });
+    if (shouldCollectPayment) {
+      setStep("select-payment");
+      return { ok: true, outcome: "payment-step" };
+    }
+    const submitPlan = resolveEventRegistrationSubmitPlan({
+      paymentSelection,
+      eventRequiresPayment,
+      canJoinWaitlist: eligibility?.canJoinWaitlist
+    });
+    if (!submitPlan.ok) {
+      setErrorMessage(submitPlan.message);
+      setStep("error");
+      return { ok: false, reason: "blocked", message: submitPlan.message };
+    }
+    const submitResult = await handleSubmit(
+      submitPlan.args.method,
+      submitPlan.args.passId,
+      submitPlan.args.membershipId,
+      submitPlan.args.selection
+    );
+    if (!submitResult.ok) {
+      return {
+        ok: false,
+        reason: submitResult.reason === "submission-failed" ? "submission-failed" : "blocked",
+        message: submitResult.message
+      };
+    }
+    return { ok: true, outcome: "submitted" };
+  };
+  const handlePaymentSelect = async () => {
+    const submitPlan = resolveEventRegistrationSubmitPlan({
+      paymentSelection,
+      eventRequiresPayment,
+      canJoinWaitlist: eligibility?.canJoinWaitlist
+    });
+    if (!submitPlan.ok) {
+      setErrorMessage(submitPlan.message);
+      setStep("error");
+      return;
+    }
+    await handleSubmit(
+      submitPlan.args.method,
+      submitPlan.args.passId,
+      submitPlan.args.membershipId,
+      submitPlan.args.selection
+    );
+  };
+  const handleUseCardInsteadOfPass = () => {
+    dispatchFlow({ type: "use-card-instead-of-pass" });
+  };
+  const handleBookForSomeoneElse = () => {
+    if (portalAuthState === "authenticated") {
+      handleLogout();
+      return;
+    }
+    setStep("select-tickets");
+  };
+  const discountContext = useMemo6(
+    () => resolveDiscountContext({
+      paymentSelection,
+      event: selectedEvent ?? preSelectedEvent,
+      eventRequiresPayment,
+      ticketsCount
+    }),
+    [eventRequiresPayment, paymentSelection, selectedEvent, preSelectedEvent, ticketsCount]
+  );
+  const discountSubtotalCents = useMemo6(() => {
+    if (discountContext?.type !== "event") return void 0;
+    const event = selectedEvent ?? preSelectedEvent;
+    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 });
+  const selectionMethod = paymentSelection.method;
+  const shouldShowDiscountToggle = discountContext !== null && discountUi.manualCodeEntryAllowed && (selectionMethod === "stripe" || selectionMethod === "pass_bundle" || selectionMethod === "membership_bundle");
+  const handleSubmit = useEventRegistrationSubmit({
+    api,
+    registrationTarget,
+    selectedAttendanceMode,
+    selectedTicketTypeId,
+    ticketsCount,
+    formData,
+    altchaSolution,
+    requireGuestDetails,
+    guests,
+    discountCode: discountUi.discountCode,
+    claimToken: waitlistClaim.token,
+    setPendingAttendeeId: (id) => setPendingAttendeeId(id),
+    setStep,
+    setRegistrationResult: (result) => setRegistrationResult(result),
+    setErrorMessage
+  });
+  const handleEventSelect = (event) => {
+    setSelectedEvent(event);
+    setSelectedAttendanceMode(
+      (event.deliveryMode ?? "in_person") === "hybrid" ? null : (event.deliveryMode ?? "in_person") === "online" ? "online" : "in_person"
+    );
+    setSelectedTicketTypeId(null);
+    dispatchFlow({ type: "event-changed", hasPreSelectedContext: true });
+  };
+  const handleRetry = () => {
+    dispatchFlow({ type: "reset", hasPreSelectedContext });
+    setSelectedTicketTypeId(null);
+    setSelectedAttendanceMode(
+      preSelectedEvent?.deliveryMode === "online" ? "online" : preSelectedEvent?.deliveryMode === "in_person" ? "in_person" : null
+    );
+    setErrorMessage("");
+    setPendingAttendeeId(null);
+  };
+  const handlePaymentStepStateChange = useCallback6((state) => {
+    setPaymentStepState(state);
+  }, []);
+  const handlePaymentSelectionChange = useCallback6((selection) => {
+    dispatchFlow({ type: "set-manual-payment-selection", selection });
+  }, []);
+  const hasEligibility = eligibility !== null && (eligibility.eligiblePasses.length > 0 || eligibility.eligibleMemberships.length > 0);
+  const hasMembershipEligibility = eligibility !== null && eligibility.eligibleMemberships.length > 0;
+  const isMembershipFastTrack = portalAuthState === "authenticated" && hasMembershipEligibility && ticketsCount === 1 && paymentSelection.method === "membership";
+  return {
+    api,
+    anchorId: options.anchorId,
+    occurrenceContext: options.occurrenceContext,
+    registrationTarget,
+    contentEntry: options.contentEntry,
+    events: options.events,
+    maxTicketsNum: waitlistClaim.claim ? 1 : options.maxTicketsNum,
+    scopedEvents,
+    preSelectedEvent,
+    hasPreSelectedContext,
+    step,
+    setStep,
+    selectedEvent,
+    setSelectedEvent,
+    ticketsCount,
+    setTicketsCount,
+    selectedAttendanceMode,
+    setSelectedAttendanceMode,
+    selectedTicketTypeId,
+    setSelectedTicketTypeId,
+    selectedTicketType,
+    visibleTicketTypes,
+    ticketTypeSelectionRequired,
+    hasValidSelectedTicketType,
+    eventRequiresPayment,
+    formData,
+    setFormData,
+    errors,
+    guests,
+    setGuests,
+    guestErrors,
+    guestSectionShake,
+    handleGuestShakeEnd,
+    registrationResult,
+    errorMessage,
+    altchaSolution,
+    setAltchaSolution,
+    portalAuthState,
+    portalProfile,
+    showMagicLinkModal,
+    setShowMagicLinkModal,
+    handleLogout,
+    paymentStepState,
+    handlePaymentStepStateChange,
+    handlePaymentSelectionChange,
+    paymentSelection,
+    isMembershipFastTrack,
+    waitlistClaim,
+    eligibility,
+    eligibilityLoading,
+    eligibilityError,
+    existingRegistration: existingRegistrationResult.registration,
+    existingRegistrationLoading: existingRegistrationResult.isLoading,
+    existingRegistrationState: existingRegistrationResult.state,
+    hasEligibility,
+    hasMembershipEligibility,
+    requireGuestDetails,
+    discountCode: discountUi.discountCode,
+    setDiscountCode: discountUi.setDiscountCode,
+    discountUiOpen: discountUi.discountUiOpen,
+    setDiscountUiOpen: discountUi.setDiscountUiOpen,
+    discountsAvailable: discountUi.discountsAvailable,
+    manualCodeEntryAllowed: discountUi.manualCodeEntryAllowed,
+    autoAppliedDiscount: discountUi.autoAppliedDiscount,
+    discountsAvailableLoading: discountUi.discountsAvailableLoading,
+    discountContext,
+    shouldShowDiscountToggle,
+    verification,
+    handleDetailsComplete,
+    handlePaymentSelect,
+    handleUseCardInsteadOfPass,
+    handleBookForSomeoneElse,
+    handleSubmit,
+    handleEventSelect,
+    handleRetry
+  };
+}
+
+// ../theme-core/src/header/navDropdownSizing.ts
+var NAV_DROPDOWN_MIN_WIDTH_REM = 12;
+var NAV_DROPDOWN_MAX_WIDTH_REM = 22;
+var NAV_DROPDOWN_VIEWPORT_GUTTER_REM = 1;
+var NAV_DROPDOWN_SHIFT_PROPERTY = "--nav-dropdown-shift-x";
+var NAV_DROPDOWN_MAX_WIDTH_CSS = `min(${NAV_DROPDOWN_MAX_WIDTH_REM}rem, calc(100vw - ${NAV_DROPDOWN_VIEWPORT_GUTTER_REM * 2}rem))`;
+var NAV_DROPDOWN_CONTAINER_RAIL_CSS_RULES = [
+  `min-width: ${NAV_DROPDOWN_MIN_WIDTH_REM}rem;`,
+  `width: max-content;`,
+  `max-width: ${NAV_DROPDOWN_MAX_WIDTH_CSS};`,
+  `transform: translateX(var(${NAV_DROPDOWN_SHIFT_PROPERTY}, 0px));`
+];
+
+// ../theme-core/src/ClientThemeScope.tsx
+import { useMemo as useMemo7 } from "react";
+
+// ../theme-core/src/navigation/presets.ts
+var NAV_LINK_PRESETS = {
+  /**
+   * Minimal - subtle color change on hover
+   */
+  minimal: {
+    name: "Minimal",
+    typography: "body",
+    fontWeight: "medium",
+    textTransform: "none",
+    italic: false,
+    colorToken: "text",
+    hoverColorToken: "primary",
+    padding: "none",
+    borderRadius: "none",
+    effects: {
+      hover: [
+        { effectId: "text-color-change", options: { hoverColorToken: "primary" } }
+      ]
+    }
+  },
+  /**
+   * Underline - static underline appears on hover
+   */
+  underline: {
+    name: "Underline",
+    typography: "body",
+    fontWeight: "medium",
+    textTransform: "none",
+    italic: false,
+    colorToken: "text",
+    padding: "none",
+    borderRadius: "none",
+    effects: {
+      hover: [{ effectId: "nav-underline", options: { style: "static" } }]
+    }
+  },
+  /**
+   * Underline Grow - animated underline grows from center on hover
+   */
+  "underline-grow": {
+    name: "Underline Grow",
+    typography: "body",
+    fontWeight: "medium",
+    textTransform: "none",
+    italic: false,
+    colorToken: "text",
+    padding: "none",
+    borderRadius: "none",
+    effects: {
+      hover: [{ effectId: "nav-underline", options: { style: "grow" } }]
+    }
+  },
+  /**
+   * Capsule - pill-shaped background on hover
+   */
+  capsule: {
+    name: "Capsule",
+    typography: "body",
+    fontWeight: "medium",
+    textTransform: "none",
+    italic: false,
+    colorToken: "text",
+    padding: "compact",
+    borderRadius: "full",
+    effects: {
+      hover: [
+        {
+          effectId: "background-on-hover-alpha",
+          options: { colorToken: "primary", opacity: 10 }
+        }
+      ],
+      active: [
+        {
+          effectId: "background-on-hover-alpha",
           options: { colorToken: "primary", opacity: 15 }
         }
       ]
@@ -14533,6 +17540,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));
@@ -15080,15 +18092,286 @@ import { jsx as jsx12, jsxs as jsxs9 } from "react/jsx-runtime";
 // ../theme-core/src/ClientThemeScope.tsx
 import { jsx as jsx13 } from "react/jsx-runtime";
 
+// ../blocks/src/system/runtime/hooks/useHeadlessEventRegistrationFlow.ts
+import React4, { useCallback as useCallback7, useMemo as useMemo8 } from "react";
+function HeadlessEventRegistrationProvider({
+  config,
+  children
+}) {
+  return React4.createElement(BlockApiProvider, { config, children });
+}
+function useHeadlessEventRegistrationFlow(options) {
+  return useEventRegistrationController(options).flow;
+}
+function useEventRegistrationController(options) {
+  const { wizard } = useEventRegistrationWizardController(options);
+  const steps = useMemo8(
+    () => deriveEventRegistrationSteps({
+      step: wizard.step,
+      hasPreSelectedContext: wizard.hasPreSelectedContext,
+      eventRequiresPayment: wizard.eventRequiresPayment,
+      paymentSelection: wizard.paymentSelection
+    }),
+    [
+      wizard.eventRequiresPayment,
+      wizard.hasPreSelectedContext,
+      wizard.paymentSelection,
+      wizard.step
+    ]
+  );
+  const currentStep = steps.find((step) => step.state === "active") ?? null;
+  const submit = useCallback7(
+    async (submitOptions) => {
+      const plan = resolveEventRegistrationSubmitPlan({
+        paymentSelection: wizard.paymentSelection,
+        eventRequiresPayment: wizard.eventRequiresPayment,
+        canJoinWaitlist: wizard.eligibility?.canJoinWaitlist
+      });
+      if (!plan.ok) {
+        return {
+          ok: false,
+          reason: "blocked",
+          message: plan.message
+        };
+      }
+      return wizard.handleSubmit(
+        plan.args.method,
+        plan.args.passId,
+        plan.args.membershipId,
+        plan.args.selection,
+        submitOptions
+      );
+    },
+    [wizard]
+  );
+  const next = useCallback7(async () => {
+    switch (wizard.step) {
+      case "select-event":
+        if (!wizard.selectedEvent) {
+          return {
+            ok: false,
+            reason: "blocked",
+            message: "Select an event to continue."
+          };
+        }
+        wizard.setStep("select-tickets");
+        return { ok: true };
+      case "select-tickets":
+        if (wizard.ticketTypeSelectionRequired && !wizard.hasValidSelectedTicketType) {
+          return {
+            ok: false,
+            reason: "blocked",
+            message: "Select a ticket type to continue."
+          };
+        }
+        wizard.setStep("enter-details");
+        return { ok: true };
+      case "enter-details": {
+        const result = await wizard.handleDetailsComplete();
+        return result.ok ? { ok: true } : result;
+      }
+      case "select-payment": {
+        const result = await submit({ redirect: "manual" });
+        return result.ok ? { ok: true } : {
+          ok: false,
+          reason: result.reason === "submission-failed" ? "submission-failed" : "blocked",
+          message: result.message
+        };
+      }
+      case "error":
+      case "success":
+      case "submitting":
+      case "redirecting":
+      case "verifying-payment":
+      case "verifying-timeout":
+      case "payment-failed":
+        return {
+          ok: false,
+          reason: "blocked",
+          message: "This registration step cannot continue."
+        };
+    }
+  }, [submit, wizard]);
+  const back = useCallback7(() => {
+    switch (wizard.step) {
+      case "enter-details":
+        wizard.setStep("select-tickets");
+        return;
+      case "select-payment":
+        wizard.setStep("enter-details");
+        return;
+      case "select-tickets":
+        if (!wizard.hasPreSelectedContext) wizard.setStep("select-event");
+        return;
+      case "select-event":
+      case "error":
+      case "success":
+      case "submitting":
+      case "redirecting":
+      case "verifying-payment":
+      case "verifying-timeout":
+      case "payment-failed":
+        return;
+    }
+  }, [wizard]);
+  const updateAttendee = useCallback7(
+    (values) => {
+      wizard.setFormData(values);
+    },
+    [wizard]
+  );
+  const updateGuests = useCallback7(
+    (guests) => {
+      wizard.setGuests(guests);
+    },
+    [wizard]
+  );
+  const selectPayment = useCallback7(
+    (selection) => {
+      wizard.handlePaymentSelectionChange(toInternalPaymentSelection(selection));
+    },
+    [wizard]
+  );
+  const showSpamProtection = options.spamProtectionEnabled ?? isSpamProtectionEnabled();
+  const spamProtection = showSpamProtection ? {
+    enabled: true,
+    provider: "altcha",
+    challenge: { url: getChallengeUrl(), auto: "onfocus" },
+    solution: wizard.altchaSolution
+  } : { enabled: false };
+  const payment = resolvePaymentModel(wizard);
+  const flow = {
+    status: resolveHeadlessEventRegistrationStatus(wizard),
+    view: resolveHeadlessEventRegistrationView(wizard),
+    steps,
+    currentStep,
+    events: {
+      items: wizard.events,
+      scoped: wizard.scopedEvents,
+      selected: wizard.selectedEvent,
+      preSelected: wizard.preSelectedEvent,
+      hasPreSelectedContext: wizard.hasPreSelectedContext,
+      target: wizard.registrationTarget,
+      occurrenceContext: wizard.occurrenceContext,
+      contentEntry: wizard.contentEntry
+    },
+    tickets: {
+      count: wizard.ticketsCount,
+      max: wizard.maxTicketsNum,
+      selectedTicketTypeId: wizard.selectedTicketTypeId,
+      selectedTicketType: wizard.selectedTicketType,
+      visibleTicketTypes: wizard.visibleTicketTypes,
+      selectionRequired: wizard.ticketTypeSelectionRequired,
+      hasValidSelection: wizard.hasValidSelectedTicketType,
+      eventRequiresPayment: wizard.eventRequiresPayment,
+      selectedAttendanceMode: wizard.selectedAttendanceMode
+    },
+    attendee: {
+      values: wizard.formData,
+      errors: wizard.errors
+    },
+    guests: {
+      required: wizard.requireGuestDetails,
+      items: wizard.guests,
+      errors: wizard.guestErrors,
+      shake: wizard.guestSectionShake
+    },
+    payment,
+    discount: {
+      code: wizard.discountCode,
+      isOpen: wizard.discountUiOpen,
+      available: wizard.discountsAvailable,
+      manualCodeEntryAllowed: wizard.manualCodeEntryAllowed,
+      loading: wizard.discountsAvailableLoading,
+      autoAppliedDiscount: wizard.autoAppliedDiscount
+    },
+    portalAuth: {
+      state: wizard.portalAuthState,
+      profile: wizard.portalProfile,
+      isAuthenticated: wizard.portalAuthState === "authenticated",
+      showMagicLinkModal: wizard.showMagicLinkModal
+    },
+    existingRegistration: {
+      state: resolveExistingRegistrationState(wizard),
+      registration: wizard.existingRegistration
+    },
+    waitlistClaim: wizard.waitlistClaim,
+    spamProtection,
+    terminal: {
+      result: wizard.registrationResult,
+      errorMessage: wizard.errorMessage,
+      verification: wizard.verification
+    },
+    actions: {
+      selectEvent: wizard.handleEventSelect,
+      selectAttendanceMode: wizard.setSelectedAttendanceMode,
+      selectTicketType: wizard.setSelectedTicketTypeId,
+      setTicketsCount: wizard.setTicketsCount,
+      updateAttendee,
+      updateGuests,
+      selectPayment,
+      setDiscountCode: wizard.setDiscountCode,
+      setDiscountOpen: wizard.setDiscountUiOpen,
+      setAltchaSolution: wizard.setAltchaSolution,
+      requestLogin: () => wizard.setShowMagicLinkModal(true),
+      logout: wizard.handleLogout,
+      next,
+      back,
+      submit,
+      retry: wizard.handleRetry
+    }
+  };
+  return { flow, wizard };
+}
+function useEventRegistrationWizardController(options) {
+  const maxTicketsNum = normalizeEventRegistrationMaxTickets(options.maxTickets);
+  const wizard = useEventRegistrationWizard({
+    anchorId: options.anchorId ?? "event-registration",
+    occurrenceContext: options.occurrenceContext ?? null,
+    contentEntry: options.contentEntry ?? null,
+    events: [...options.events ?? []],
+    maxTicketsNum
+  });
+  return { wizard };
+}
+function resolveExistingRegistrationState(wizard) {
+  switch (wizard.existingRegistrationState.tag) {
+    case "idle":
+      return { tag: "idle", value: wizard.existingRegistration };
+    case "loading":
+      return { tag: "loading", value: wizard.existingRegistration };
+    case "resolved":
+      return { tag: "loaded", value: wizard.existingRegistration };
+  }
+}
+function resolvePaymentModel(wizard) {
+  const selection = toHeadlessPaymentSelection(wizard.paymentSelection);
+  if (wizard.step !== "select-payment") {
+    return {
+      kind: "hidden",
+      selection,
+      stepState: wizard.paymentStepState
+    };
+  }
+  const status = wizard.paymentStepState.status;
+  return {
+    kind: status,
+    selection,
+    stepState: wizard.paymentStepState,
+    eligibility: wizard.eligibility,
+    eligibilityError: wizard.eligibilityError
+  };
+}
+
 // ../blocks/src/system/runtime/hooks/useBookingFormConfig.ts
-import { useState as useState6, useEffect as useEffect8 } from "react";
+import { useState as useState9, useEffect as useEffect12 } from "react";
 function useBookingFormConfig(siteId, formId) {
   const api = useBlockApi();
-  const [formConfig, setFormConfig] = useState6(null);
-  const [services, setServices] = useState6([]);
-  const [isLoading, setIsLoading] = useState6(true);
-  const [error, setError] = useState6(null);
-  useEffect8(() => {
+  const [formConfig, setFormConfig] = useState9(null);
+  const [services, setServices] = useState9([]);
+  const [isLoading, setIsLoading] = useState9(true);
+  const [error, setError] = useState9(null);
+  useEffect12(() => {
     let mounted = true;
     async function loadFormAndServices() {
       try {
@@ -15130,8 +18413,8 @@ function useBookingFormConfig(siteId, formId) {
           } catch {
           }
         }
-      } catch (err) {
-        console.error("Failed to load form:", err);
+      } catch (err3) {
+        console.error("Failed to load form:", err3);
         if (mounted) {
           setError("Failed to load booking form. Please try again later.");
         }
@@ -15151,16 +18434,19 @@ function useBookingFormConfig(siteId, formId) {
 
 // src/bookings/index.ts
 var BookingFormClient2 = (props) => {
-  return React4.createElement(BookingFormClient, props);
+  return React5.createElement(BookingFormClient, props);
 };
 function useBookingFormConfig2(siteId, formId) {
   return useBookingFormConfig(siteId, formId);
 }
 var HeadlessBookingProvider2 = (props) => {
-  return React4.createElement(HeadlessBookingProvider, props);
+  return React5.createElement(HeadlessBookingProvider, props);
+};
+var HeadlessEventRegistrationProvider2 = (props) => {
+  return React5.createElement(HeadlessEventRegistrationProvider, props);
 };
 var HeadlessBookingPaymentSelectionStep2 = (props) => {
-  return React4.createElement(HeadlessBookingPaymentSelectionStep, props);
+  return React5.createElement(HeadlessBookingPaymentSelectionStep, props);
 };
 export {
   BOOKING_FORM_DATA_RESERVED_KEY_VALUES,
@@ -15168,8 +18454,13 @@ export {
   AltchaWidget as HeadlessBookingAltchaWidget,
   HeadlessBookingPaymentSelectionStep2 as HeadlessBookingPaymentSelectionStep,
   HeadlessBookingProvider2 as HeadlessBookingProvider,
+  AltchaWidget as HeadlessEventRegistrationAltchaWidget,
+  HeadlessEventRegistrationProvider2 as HeadlessEventRegistrationProvider,
   createBookingBlockApiConfig,
+  createEventRegistrationBlockApiConfig,
   getAppointmentBookingOverrideInput,
+  getEventRegistrationOverrideInput,
   useBookingFormConfig2 as useBookingFormConfig,
-  useHeadlessBookingFlow
+  useHeadlessBookingFlow,
+  useHeadlessEventRegistrationFlow
 };