@riverbankcms/sdk 0.89.1 → 0.90.1

package/dist/client/bookings.mjs

@@ -86,7 +86,7 @@ function ze() {
     /* @__PURE__ */ Te(P)
   );
 }
-function z20(e) {
+function z25(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, z20(mt);
+  en(We), We.__change = ui, z25(mt);
   var Ut = we(mt, 2), wi = X(Ut);
   {
     var pi = (n) => {
       var u = na(), _ = Gr(u), y = X(_);
-      Ge(y, () => c(re).verified), z20(_);
+      Ge(y, () => c(re).verified), z25(_);
       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), z20(E), ne(T, E);
+          Ge(p, () => c(re).verifying), z25(E), ne(T, E);
         }, y = (T) => {
           var E = oa(), p = X(E);
-          Ge(p, () => c(re).label), z20(E), Pe(() => se(E, "for", c(cr))), ne(T, E);
+          Ge(p, () => c(re).label), z25(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);
     });
   }
-  z20(Ut);
+  z25(Ut);
   var yi = we(Ut, 2);
   {
     var Ei = (n) => {
       var u = aa(), _ = X(u);
-      se(_, "href", sr), z20(u), Pe(() => se(_, "aria-label", c(re).ariaLinkLabel)), ne(n, u);
+      se(_, "href", sr), z25(u), Pe(() => se(_, "aria-label", c(re).ariaLinkLabel)), ne(n, u);
     };
     $e(yi, (n) => {
       (N() !== true || c(Dt)) && n(Ei);
     });
   }
-  z20(Mt);
+  z25(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), z20(p), Pe(() => se(p, "title", c(He))), ne(E, p);
+          Ge(x, () => c(re).expired), z25(p), Pe(() => se(p, "title", c(He))), ne(E, p);
         }, T = (E) => {
           var p = sa(), x = X(p);
-          Ge(x, () => c(re).error), z20(p), Pe(() => se(p, "title", c(He))), ne(E, p);
+          Ge(x, () => c(re).error), z25(p), Pe(() => se(p, "title", c(He))), ne(E, p);
         };
         $e(_, (E) => {
           c(C) === b.EXPIRED ? E(y) : E(T, false);
         });
       }
-      z20(u), ne(n, u);
+      z25(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), z20(_), z20(u), ne(n, u);
+      Ge(y, () => c(re).footer), z25(_), z25(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 z20(ot), nn(ot, (n) => D(B, n), () => c(B)), Pe(
+  return z25(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");
     },
@@ -3931,6 +3931,24 @@ function useBlockApi() {
   return client;
 }
 
+// ../blocks/src/system/runtime/api/types.ts
+function discountAvailabilityHasDiscounts(availability) {
+  return availability.type !== "none";
+}
+function discountAvailabilityAllowsManualEntry(availability) {
+  return "manualCodeEntryAllowed" in availability && availability.manualCodeEntryAllowed;
+}
+function getAutoAppliedDiscountPreview(availability) {
+  switch (availability.type) {
+    case "none":
+    case "manual":
+      return null;
+    case "auto":
+    case "auto_and_manual":
+      return availability.autoAppliedDiscount;
+  }
+}
+
 // ../../node_modules/.pnpm/clsx@2.1.1/node_modules/clsx/dist/clsx.mjs
 function r(e) {
   var t, f, n = "";
@@ -5271,6 +5289,8 @@ function publicEventPricingType(pricing) {
     case "ticket_types":
     case "course":
       return isFreePublicEventPriceDisplay(pricing.display) ? "free" : "paid";
+    case "external":
+      return "external";
   }
 }
 function publicEventScalarPrice(pricing) {
@@ -5285,6 +5305,7 @@ function publicEventPricingMode(pricing) {
       return "ticket_types";
     case "drop_in":
     case "course":
+    case "external":
       return void 0;
   }
 }
@@ -5302,6 +5323,7 @@ function isFreePublicEventPriceDisplay(display) {
     case "range":
     case "mixed":
     case "unavailable":
+    case "external":
       return false;
   }
 }
@@ -5604,9 +5626,107 @@ function addLocalScheduleDays(date, days) {
   };
 }
 
-// ../theme-core/src/accordions/types.ts
+// ../blocks/src/system/manifest/richTextSchema.ts
 import { z as z5 } from "zod";
-var accordionIconSchema = z5.enum([
+var TipTapMarkSchema = z5.object({
+  type: z5.string(),
+  attrs: z5.record(z5.string(), z5.unknown()).optional()
+});
+var TipTapNodeSchema = z5.lazy(
+  () => z5.object({
+    type: z5.string(),
+    content: z5.array(TipTapNodeSchema).optional(),
+    text: z5.string().optional(),
+    attrs: z5.record(z5.string(), z5.unknown()).optional(),
+    marks: z5.array(TipTapMarkSchema).optional()
+  })
+);
+var RichTextValueSchema = z5.union([
+  // Canonical: TipTap document directly
+  TipTapNodeSchema,
+  // Legacy (read-tolerance only): wrapped in { doc: {...} }
+  z5.object({
+    doc: TipTapNodeSchema
+  })
+]);
+var RichTextDocSchema = z5.object({
+  type: z5.literal("doc"),
+  content: z5.array(TipTapNodeSchema)
+});
+
+// ../blocks/src/lib/media.ts
+import z6 from "zod";
+var hotspotSchema = z6.object({
+  x: z6.number().min(0).max(1),
+  y: z6.number().min(0).max(1),
+  radius: z6.number().optional()
+});
+var rotationSchema = z6.union([z6.literal(0), z6.literal(90), z6.literal(180), z6.literal(270)]);
+var rectSchema = z6.tuple([z6.number(), z6.number(), z6.number(), z6.number()]);
+var aspectCropSchema = z6.object({
+  aspect: z6.preprocess((value) => value == null ? void 0 : value, z6.string().optional()),
+  rect: z6.preprocess((value) => value == null ? void 0 : value, rectSchema.optional()),
+  hotspot: z6.preprocess((value) => value == null ? void 0 : value, hotspotSchema.optional()),
+  rotation: z6.preprocess((value) => value == null ? void 0 : value, rotationSchema.optional())
+});
+var transformSchema = z6.object({
+  aspectCrops: z6.preprocess((value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return void 0;
+    }
+    return value;
+  }, z6.record(z6.string(), aspectCropSchema.catch({}))).optional(),
+  rect: rectSchema.optional(),
+  hotspot: hotspotSchema.optional(),
+  rotation: rotationSchema.optional()
+});
+var mediaPosterSchema = z6.discriminatedUnion("tag", [
+  z6.object({
+    tag: z6.literal("storage"),
+    assetId: z6.string().optional(),
+    storageBucket: z6.string().min(1),
+    storagePath: z6.string().min(1)
+  }),
+  z6.object({
+    tag: z6.literal("external-src"),
+    assetId: z6.string().optional(),
+    src: z6.string().url()
+  })
+]);
+var mediaBaseSchema = z6.object({
+  purpose: z6.string().optional(),
+  placeholder: z6.boolean().default(true).optional(),
+  assetId: z6.string().optional(),
+  identifier: z6.string().optional(),
+  src: z6.string().optional(),
+  alt: z6.string().optional(),
+  filename: z6.string().optional(),
+  mimeType: z6.string().optional(),
+  width: z6.number().optional(),
+  height: z6.number().optional(),
+  storageBucket: z6.string().optional(),
+  storagePath: z6.string().optional(),
+  poster: mediaPosterSchema.optional(),
+  transform: transformSchema.optional()
+});
+var imageMediaSchema = mediaBaseSchema.extend({ type: z6.literal("image") });
+var videoMediaSchema = mediaBaseSchema.extend({ type: z6.literal("video") });
+var audioMediaSchema = mediaBaseSchema.extend({ type: z6.literal("audio") });
+var documentMediaSchema = mediaBaseSchema.extend({ type: z6.literal("document") });
+var spreadsheetMediaSchema = mediaBaseSchema.extend({ type: z6.literal("spreadsheet") });
+var archiveMediaSchema = mediaBaseSchema.extend({ type: z6.literal("archive") });
+var mediaSchema = z6.discriminatedUnion("type", [
+  imageMediaSchema,
+  videoMediaSchema,
+  audioMediaSchema,
+  documentMediaSchema,
+  spreadsheetMediaSchema,
+  archiveMediaSchema
+]);
+
+// ../theme-core/src/accordions/types.ts
+import { z as z7 } from "zod";
+var accordionIconSchema = z7.enum([
   "plus-minus",
   // + becomes - (swap or rotate 90°)
   "chevron",
@@ -5618,70 +5738,70 @@ var accordionIconSchema = z5.enum([
   "circle-plus-minus"
   // ⊕ becomes ⊖ (swap with fade)
 ]);
-var accordionSystemSchema = z5.object({
+var accordionSystemSchema = z7.object({
   // Visual styling (solid color only - gradients can be added later if needed).
   // null = no fill, so the accordion sits transparently on the section
   // surface (used by open, boxless "divided" looks).
-  background: z5.object({
-    type: z5.literal("solid"),
+  background: z7.object({
+    type: z7.literal("solid"),
     colorToken: themeColorTokenSchema
   }).nullable(),
   // Spacing (padding inside items)
-  spacing: z5.enum(["none", "compact", "cozy", "medium", "comfortable", "spacious"]),
+  spacing: z7.enum(["none", "compact", "cozy", "medium", "comfortable", "spacious"]),
   // Border radius (null = inherit from theme.corners)
-  corners: z5.enum(["square", "soft", "rounded", "pill"]).nullable(),
+  corners: z7.enum(["square", "soft", "rounded", "pill"]).nullable(),
   // Border styling (null = inherit from theme.border)
-  border: z5.object({
-    widthClass: z5.string(),
+  border: z7.object({
+    widthClass: z7.string(),
     // e.g., 'border', 'border-2', 'border-0'
     colorToken: themeColorTokenSchema
   }).nullable(),
   // Shadow (null = inherit from theme.shadow)
-  shadow: z5.object({
-    elevation: z5.enum(["none", "low", "medium", "high"]),
-    softness: z5.enum(["soft", "crisp", "hard"]).nullable(),
-    position: z5.enum(["bottom", "bottom-right"])
+  shadow: z7.object({
+    elevation: z7.enum(["none", "low", "medium", "high"]),
+    softness: z7.enum(["soft", "crisp", "hard"]).nullable(),
+    position: z7.enum(["bottom", "bottom-right"])
   }).nullable(),
   // Icon style and animation
-  icon: z5.object({
+  icon: z7.object({
     style: accordionIconSchema,
-    position: z5.enum(["left", "right"]),
-    size: z5.enum(["sm", "md", "lg"]),
+    position: z7.enum(["left", "right"]),
+    size: z7.enum(["sm", "md", "lg"]),
     colorToken: themeColorTokenSchema.optional()
   }),
   // Trigger (question) styling
-  trigger: z5.object({
+  trigger: z7.object({
     textColorToken: themeColorTokenSchema,
-    fontWeight: z5.enum(["regular", "medium", "semibold", "bold"]).nullable(),
+    fontWeight: z7.enum(["regular", "medium", "semibold", "bold"]).nullable(),
     // null = inherit from theme
     // Question typography. Defaults keep the historical body-font look; set
     // fontFamily 'heading' + a larger scale to give questions real presence.
-    fontFamily: z5.enum(["body", "heading"]).optional(),
+    fontFamily: z7.enum(["body", "heading"]).optional(),
     // default 'body'
-    fontScale: z5.enum(["body", "md", "lg"]).optional(),
+    fontScale: z7.enum(["body", "md", "lg"]).optional(),
     // default 'body'
-    letterSpacing: z5.enum(["normal", "tight", "wide"]).optional(),
-    textTransform: z5.enum(["none", "uppercase"]).optional()
+    letterSpacing: z7.enum(["normal", "tight", "wide"]).optional(),
+    textTransform: z7.enum(["none", "uppercase"]).optional()
   }),
   // Hover state styling
-  hover: z5.object({
+  hover: z7.object({
     backgroundColorToken: themeColorTokenSchema.optional(),
     textColorToken: themeColorTokenSchema.optional(),
     borderColorToken: themeColorTokenSchema.optional()
   }),
   // Open-state emphasis: how an expanded item is visually rewarded. All
   // optional; omit for the historical "only the text recolors" behaviour.
-  openState: z5.object({
+  openState: z7.object({
     backgroundColorToken: themeColorTokenSchema.optional(),
     triggerColorToken: themeColorTokenSchema.optional(),
-    accent: z5.object({
-      edge: z5.enum(["left", "top", "bottom"]),
+    accent: z7.object({
+      edge: z7.enum(["left", "top", "bottom"]),
       colorToken: themeColorTokenSchema,
-      thickness: z5.enum(["thin", "medium", "thick"])
+      thickness: z7.enum(["thin", "medium", "thick"])
     }).optional()
   }).optional(),
   // Content (answer) styling
-  content: z5.object({
+  content: z7.object({
     textColorToken: themeColorTokenSchema
   })
 });
@@ -5861,8 +5981,8 @@ function SpinnerNode({
 }
 
 // ../frontend-state/dist/index.mjs
-var IDLE_FEEDBACK = idleFeedback();
-function idleFeedback() {
+var IDLE_FEEDBACK$2 = idleFeedback$3();
+function idleFeedback$3() {
   return { tag: "idle" };
 }
 function clearWorkflowFeedback(state) {
@@ -5887,18 +6007,30 @@ function idleSubmissionFeedback() {
   return { tag: "idle" };
 }
 function errorSubmissionFeedback(message) {
-  return { tag: "error", message };
+  return {
+    tag: "error",
+    message
+  };
 }
 function successSubmissionFeedback(message) {
-  return { tag: "success", message };
+  return {
+    tag: "success",
+    message
+  };
 }
-function okWith2(data) {
-  return { ok: true, data };
+function okWith(data) {
+  return {
+    ok: true,
+    data
+  };
 }
 function err2(error) {
-  return { ok: false, error };
+  return {
+    ok: false,
+    error
+  };
 }
-function assertNever11(value, message) {
+function assertNever4(value, message) {
   throw new Error(message ?? `Unexpected value: ${String(value)}`);
 }
 
@@ -6053,7 +6185,7 @@ function deriveBookingFormViewState(input) {
         resourceName: input.verificationState.resourceName
       };
     default:
-      return assertNever11(input.verificationState);
+      return assertNever4(input.verificationState);
   }
 }
 function resolveBookingSiteId(siteId, form) {
@@ -6223,7 +6355,7 @@ function getBookingServicePaymentSelectionMode(service) {
       case "flexible_balance":
         return "implicit_flexible_balance";
       default:
-        return assertNever11(onlyKind);
+        return assertNever4(onlyKind);
     }
   }
   if (allowedKinds.length === 2 && allowedKinds.includes("upfront") && (allowedKinds.includes("deferred_manual") || allowedKinds.includes("instalment_plan") || allowedKinds.includes("flexible_balance"))) {
@@ -6425,7 +6557,7 @@ function formatBookingSubmissionPreparationError(error) {
     case "service-missing-duration":
       return `Service "${error.serviceTitle}" is missing duration. Please update the service in the dashboard to include a duration (e.g., 30 minutes).`;
     default:
-      return assertNever11(error);
+      return assertNever4(error);
   }
 }
 function getBookingSuccessMessage(successMessage) {
@@ -6443,12 +6575,170 @@ var logger = {
   withFields: (_) => logger
 };
 
+// ../blocks/src/system/blocks/shared/bookingPaymentTerms.ts
+import { z as z8 } from "zod";
+var bookingDepositRefundPolicySchema = z8.enum([
+  "refundable",
+  "non_refundable"
+]);
+var bookingInstalmentPlanSchema = z8.union([
+  z8.object({
+    kind: z8.literal("deposit_plus_one_remainder"),
+    depositAmountCents: z8.number().int().min(0),
+    depositRefundability: bookingDepositRefundPolicySchema,
+    remainderDueCount: z8.number().int().positive(),
+    intervalUnit: z8.enum(["day", "week", "month"])
+  }),
+  z8.object({
+    kind: z8.literal("deposit_plus_scheduled_instalments"),
+    depositAmountCents: z8.number().int().min(0),
+    depositRefundability: bookingDepositRefundPolicySchema,
+    instalmentCount: z8.number().int().positive(),
+    intervalCount: z8.number().int().positive(),
+    intervalUnit: z8.enum(["day", "week", "month"])
+  }),
+  z8.object({
+    kind: z8.literal("equal_scheduled_instalments"),
+    instalmentCount: z8.number().int().positive(),
+    intervalCount: z8.number().int().positive(),
+    intervalUnit: z8.enum(["day", "week", "month"])
+  })
+]);
+var bookingFlexibleBalanceDueDateRuleSchema = z8.union([
+  z8.object({
+    kind: z8.literal("relative_to_start_date"),
+    daysBeforeStart: z8.number().int().positive()
+  }),
+  z8.object({
+    kind: z8.literal("fixed_calendar_date"),
+    dueAt: z8.string().datetime()
+  })
+]);
+var bookingFlexibleBalanceConfigSchema = z8.object({
+  upfrontAmountCents: z8.number().int().min(0),
+  dueDateRule: bookingFlexibleBalanceDueDateRuleSchema,
+  depositRefundability: bookingDepositRefundPolicySchema
+});
+var blockBookingPaymentCollectionOptionSchema = z8.union([
+  z8.object({
+    kind: z8.literal("upfront")
+  }),
+  z8.object({
+    kind: z8.literal("deferred_manual")
+  }),
+  z8.object({
+    kind: z8.literal("instalment_plan"),
+    plan: bookingInstalmentPlanSchema
+  }),
+  z8.object({
+    kind: z8.literal("flexible_balance"),
+    config: bookingFlexibleBalanceConfigSchema
+  })
+]);
+var blockBookingPaymentTermsSchema = z8.object({
+  allowedOptions: z8.array(blockBookingPaymentCollectionOptionSchema).min(1)
+});
+
+// ../blocks/src/system/blocks/courses/shared/schemas.ts
+import { z as z9 } from "zod";
+var courseVenueSchema = z9.object({
+  id: z9.string(),
+  name: z9.string(),
+  address: z9.string().nullable()
+});
+var courseSessionSchema = z9.object({
+  id: z9.string(),
+  startsAt: z9.string(),
+  endsAt: z9.string(),
+  timeZone: z9.string(),
+  capacityOverride: z9.number().nullable().optional(),
+  overrides: z9.record(z9.string(), z9.unknown()).nullable().optional()
+});
+var courseTeamMemberSummarySchema = z9.object({
+  id: z9.string(),
+  name: z9.string(),
+  roleLabel: z9.string().nullable(),
+  summary: z9.string().nullable(),
+  profilePath: z9.string().nullable()
+});
+var coursePricingOptionSchema = z9.object({
+  id: z9.string(),
+  name: z9.string(),
+  description: z9.string().nullable(),
+  priceAmount: z9.number(),
+  isActive: z9.boolean(),
+  sortOrder: z9.number(),
+  capacityLimit: z9.number().nullable(),
+  saleStartsAt: z9.string().nullable(),
+  saleEndsAt: z9.string().nullable(),
+  attendanceScope: z9.enum(["in_person", "online", "both"]).nullable().optional()
+});
+var coursePricingSchema = z9.object({
+  bookingRequirement: z9.enum(["none", "required"]),
+  pricingStrategy: z9.enum(["free", "single", "tiered"]),
+  currency: z9.string(),
+  singlePriceAmount: z9.number().nullable(),
+  paymentTerms: blockBookingPaymentTermsSchema,
+  options: z9.array(coursePricingOptionSchema)
+});
+var publicCourseSchema = z9.object({
+  id: z9.string(),
+  title: z9.string(),
+  slug: z9.string(),
+  description: z9.unknown().nullable(),
+  teamMembers: z9.array(courseTeamMemberSummarySchema).optional(),
+  enrollmentOpen: z9.boolean(),
+  pricing: coursePricingSchema.optional(),
+  priceCents: z9.number().nullable(),
+  currency: z9.string(),
+  paymentTerms: blockBookingPaymentTermsSchema,
+  enrollmentCapacity: z9.number().nullable(),
+  acceptsMemberships: z9.boolean(),
+  status: z9.enum(["active", "draft", "cancelled"]),
+  sessionsCount: z9.number(),
+  enrolledCount: z9.number(),
+  availableSpots: z9.number().nullable(),
+  sessions: z9.array(courseSessionSchema),
+  venue: courseVenueSchema.nullable(),
+  contentEntryId: z9.string().nullable()
+});
+var publicCoursesArraySchema = z9.array(publicCourseSchema);
+
+// ../blocks/src/system/runtime/nodes/events/shared/destination.ts
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isRuntimeEventDestination(value) {
+  if (!isRecord3(value) || typeof value.kind !== "string") return false;
+  if (value.kind === "native") {
+    return (value.mode === "cms-managed" || value.mode === "system-managed") && typeof value.path === "string";
+  }
+  return value.kind === "external" && typeof value.url === "string" && typeof value.label === "string";
+}
+function resolveRuntimeEventDestination(event) {
+  if (isRuntimeEventDestination(event.destination)) {
+    return event.destination;
+  }
+  return {
+    kind: "native",
+    mode: event.eventDestinationMode === "system-managed" ? "system-managed" : "cms-managed",
+    path: typeof event.path === "string" ? event.path : ""
+  };
+}
+
 // ../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 destination = resolveRuntimeEventDestination(event);
+  if (destination.kind === "external") {
+    return {
+      kind: "external",
+      display: { kind: "external", label: "External registration" }
+    };
+  }
   const legacy = event;
   const currency = readCurrency(legacy.currency);
   if (event.requiresRegistration === false) {
@@ -6485,22 +6775,22 @@ function resolveRuntimeEventPricing(event) {
 function readCurrency(value) {
   return typeof value === "string" && value.trim().length > 0 ? value : DEFAULT_EVENT_CURRENCY;
 }
-function isRecord3(value) {
+function isRecord4(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";
+  if (!isRecord4(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" || value.kind === "external";
 }
 function isPublicEventTicketType(value) {
-  return isRecord3(value) && typeof value.id === "string";
+  return isRecord4(value) && typeof value.id === "string";
 }
 function readTicketTypePriceDisplay(value, currency) {
   const display = readLegacyPriceDisplay(value, currency);
-  return display.kind === "course" ? { kind: "unavailable", currency } : display;
+  return display.kind === "course" || display.kind === "external" ? { kind: "unavailable", currency } : display;
 }
 function readLegacyPriceDisplay(value, currency) {
-  if (!isRecord3(value) || typeof value.kind !== "string") {
+  if (!isRecord4(value) || typeof value.kind !== "string") {
     return { kind: "unavailable", currency };
   }
   const displayCurrency = readCurrency(value.currency);
@@ -6539,7 +6829,7 @@ function readLegacyPriceDisplay(value, currency) {
     case "unavailable":
       return { kind: "unavailable", currency: displayCurrency };
     case "course":
-      return isRecord3(value.display) ? {
+      return isRecord4(value.display) ? {
         kind: "course",
         display: readCoursePriceDisplay(value.display, displayCurrency)
       } : {
@@ -6575,69 +6865,69 @@ function readAmount(value) {
 }
 
 // ../theme-core/src/utils/tokenOrColor.ts
-import { z as z6 } from "zod";
-var tokenOrCssColorValueSchema = z6.string();
+import { z as z10 } from "zod";
+var tokenOrCssColorValueSchema = z10.string();
 
 // ../theme-core/src/cards/types.ts
-import { z as z7 } from "zod";
+import { z as z11 } from "zod";
 var cardVariantRoleValues = ["default", "alternative"];
 var boxlessCardVariantValue = "none";
-var cardSpacingSchema = z7.enum(["none", "compact", "cozy", "medium", "comfortable", "spacious"]);
-var gradientDirectionSchema2 = z7.enum(["to-r", "to-l", "to-t", "to-b", "to-tr", "to-tl", "to-br", "to-bl"]);
-var cardVariantRoleSchema = z7.enum(cardVariantRoleValues);
-var boxStylesCardVariantSchema = z7.enum([
+var cardSpacingSchema = z11.enum(["none", "compact", "cozy", "medium", "comfortable", "spacious"]);
+var gradientDirectionSchema2 = z11.enum(["to-r", "to-l", "to-t", "to-b", "to-tr", "to-tl", "to-br", "to-bl"]);
+var cardVariantRoleSchema = z11.enum(cardVariantRoleValues);
+var boxStylesCardVariantSchema = z11.enum([
   ...cardVariantRoleValues,
   boxlessCardVariantValue
 ]);
-var cardBackgroundSchema = z7.discriminatedUnion("type", [
-  z7.object({ type: z7.literal("solid"), colorToken: themeColorTokenSchema }),
-  z7.object({
-    type: z7.literal("gradient"),
+var cardBackgroundSchema = z11.discriminatedUnion("type", [
+  z11.object({ type: z11.literal("solid"), colorToken: themeColorTokenSchema }),
+  z11.object({
+    type: z11.literal("gradient"),
     fromToken: themeColorTokenSchema,
     toToken: themeColorTokenSchema,
     direction: gradientDirectionSchema2
   }),
-  z7.object({ type: z7.literal("transparent") })
+  z11.object({ type: z11.literal("transparent") })
 ]);
-var cardBorderSchema = z7.object({
-  widthClass: z7.string(),
+var cardBorderSchema = z11.object({
+  widthClass: z11.string(),
   colorToken: themeColorTokenSchema
 });
-var cardCornerValueSchema = z7.enum([
+var cardCornerValueSchema = z11.enum([
   "square",
   "soft",
   "rounded",
   "pill",
   "expressive"
 ]);
-var cardAccentEdgeSchema = z7.object({
-  edge: z7.enum(["left", "top", "right", "bottom"]),
+var cardAccentEdgeSchema = z11.object({
+  edge: z11.enum(["left", "top", "right", "bottom"]),
   colorToken: themeColorTokenSchema,
-  width: z7.enum(["thin", "medium", "thick", "heavy"])
+  width: z11.enum(["thin", "medium", "thick", "heavy"])
 });
-var cardCornerRadiiSchema = z7.object({
+var cardCornerRadiiSchema = z11.object({
   topLeft: cardCornerValueSchema.optional(),
   topRight: cardCornerValueSchema.optional(),
   bottomLeft: cardCornerValueSchema.optional(),
   bottomRight: cardCornerValueSchema.optional()
 });
-var cardVariantSchema = z7.object({
-  id: z7.string(),
-  name: z7.string().min(1).max(20),
-  enabled: z7.boolean(),
-  priority: z7.union([z7.literal(1), z7.literal(2), z7.literal(3)]),
+var cardVariantSchema = z11.object({
+  id: z11.string(),
+  name: z11.string().min(1).max(20),
+  enabled: z11.boolean(),
+  priority: z11.union([z11.literal(1), z11.literal(2), z11.literal(3)]),
   // Appearance (token-based)
   background: cardBackgroundSchema,
   spacing: cardSpacingSchema,
   // Optional foreground (card text) color, for cards on a strong fill.
   foregroundToken: themeColorTokenSchema.optional(),
   // Optional overrides (uses theme defaults if not specified)
-  shadow: z7.object({
-    elevation: z7.enum(["none", "low", "medium", "high"]),
-    softness: z7.enum(["crisp", "soft", "hard"]).nullable(),
-    position: z7.enum(["bottom", "bottom-right"]).default("bottom")
+  shadow: z11.object({
+    elevation: z11.enum(["none", "low", "medium", "high"]),
+    softness: z11.enum(["crisp", "soft", "hard"]).nullable(),
+    position: z11.enum(["bottom", "bottom-right"]).default("bottom")
   }).optional(),
-  corners: z7.enum(["square", "soft", "rounded", "pill"]).optional(),
+  corners: z11.enum(["square", "soft", "rounded", "pill"]).optional(),
   // Per-corner radius override; wins over `corners` when set.
   cornerRadii: cardCornerRadiiSchema.optional(),
   // Border (optional)
@@ -6645,10 +6935,206 @@ var cardVariantSchema = z7.object({
   // Single accent edge; replaces `border` when set.
   accentEdge: cardAccentEdgeSchema.optional()
 });
-var cardSystemSchema = z7.object({
-  variants: z7.array(cardVariantSchema).min(1).max(3)
+var cardSystemSchema = z11.object({
+  variants: z11.array(cardVariantSchema).min(1).max(3)
 });
 
+// ../blocks/src/system/blocks/events/shared/schemas.ts
+import { z as z12 } from "zod";
+var eventPresetSchema = z12.enum(["event", "class", "workshop", "retreat", "performance"]);
+var eventScheduleScopeSchema = z12.enum(["recurring", "oneOff"]);
+var eventDestinationModeSchema = z12.enum(["cms-managed", "system-managed"]);
+var publicEventDestinationSchema = z12.discriminatedUnion("kind", [
+  z12.object({
+    kind: z12.literal("native"),
+    mode: eventDestinationModeSchema,
+    path: z12.string()
+  }),
+  z12.object({
+    kind: z12.literal("external"),
+    url: z12.string(),
+    label: z12.string()
+  })
+]);
+var eventVenueSchema = z12.object({
+  id: z12.string(),
+  name: z12.string(),
+  address: z12.string().nullable(),
+  location: z12.object({
+    lat: z12.number(),
+    lng: z12.number()
+  }).nullable()
+});
+var eventCategorySchema = z12.object({
+  id: z12.string(),
+  name: z12.string(),
+  color: z12.string().nullable()
+});
+var pricingTypeSchema = z12.enum(["free", "paid", "external"]);
+var accessRestrictionSchema = z12.enum(["none", "category"]);
+var eventPricingModeSchema = z12.enum(["single", "ticket_types"]);
+var publicCoursePriceDisplaySchema = z12.discriminatedUnion("kind", [
+  z12.object({ kind: z12.literal("free"), currency: z12.string() }),
+  z12.object({ kind: z12.literal("exact"), amount: z12.number(), currency: z12.string() }),
+  z12.object({ kind: z12.literal("from"), amount: z12.number(), currency: z12.string() }),
+  z12.object({ kind: z12.literal("unavailable"), currency: z12.string() })
+]);
+var publicEventPriceDisplaySchema = z12.discriminatedUnion("kind", [
+  z12.object({ kind: z12.literal("free"), currency: z12.string() }),
+  z12.object({ kind: z12.literal("exact"), amount: z12.number(), currency: z12.string() }),
+  z12.object({ kind: z12.literal("from"), amount: z12.number(), currency: z12.string() }),
+  z12.object({ kind: z12.literal("range"), minAmount: z12.number(), maxAmount: z12.number(), currency: z12.string() }),
+  z12.object({
+    kind: z12.literal("mixed"),
+    paidFromAmount: z12.number(),
+    paidToAmount: z12.number(),
+    currency: z12.string()
+  }),
+  z12.object({ kind: z12.literal("unavailable"), currency: z12.string() }),
+  z12.object({ kind: z12.literal("external"), label: z12.string() }),
+  z12.object({ kind: z12.literal("course"), display: publicCoursePriceDisplaySchema })
+]);
+var publicEventTicketTypePriceDisplaySchema = z12.union([
+  z12.object({ kind: z12.literal("free"), currency: z12.string() }),
+  z12.object({ kind: z12.literal("exact"), amount: z12.number(), currency: z12.string() }),
+  z12.object({ kind: z12.literal("from"), amount: z12.number(), currency: z12.string() }),
+  z12.object({ kind: z12.literal("range"), minAmount: z12.number(), maxAmount: z12.number(), currency: z12.string() }),
+  z12.object({
+    kind: z12.literal("mixed"),
+    paidFromAmount: z12.number(),
+    paidToAmount: z12.number(),
+    currency: z12.string()
+  }),
+  z12.object({ kind: z12.literal("unavailable"), currency: z12.string() })
+]);
+var publicEventAttendanceModeSchema = z12.enum(["in_person", "online"]);
+var publicEventAttendanceModeAvailabilitySchema = z12.object({
+  mode: publicEventAttendanceModeSchema,
+  capacity: z12.number().nullable(),
+  registeredCount: z12.number(),
+  availableSpots: z12.number().nullable(),
+  waitlistEnabled: z12.boolean()
+});
+var publicEventTicketTypeAvailabilitySchema = z12.union([
+  z12.object({
+    kind: z12.literal("available"),
+    remainingCapacity: z12.number().nullable()
+  }),
+  z12.object({
+    kind: z12.literal("unavailable"),
+    reason: z12.enum(["inactive", "not_on_sale_yet", "sale_ended", "sold_out", "event_sold_out"]),
+    remainingCapacity: z12.number().nullable()
+  })
+]);
+var publicEventTicketTypeSchema = z12.object({
+  id: z12.string(),
+  siteId: z12.string(),
+  eventSeriesId: z12.string(),
+  name: z12.string(),
+  description: z12.string().nullable(),
+  priceAmount: z12.number(),
+  isActive: z12.boolean(),
+  sortOrder: z12.number(),
+  capacityMode: z12.enum(["limited", "unlimited"]),
+  capacityLimit: z12.number().nullable(),
+  attendanceScope: z12.enum(["in_person", "online", "both"]).optional(),
+  saleStartsAt: z12.string().nullable(),
+  saleEndsAt: z12.string().nullable(),
+  availability: publicEventTicketTypeAvailabilitySchema,
+  createdAt: z12.string(),
+  updatedAt: z12.string()
+});
+var publicEventPricingSchema = z12.discriminatedUnion("kind", [
+  z12.object({
+    kind: z12.literal("drop_in"),
+    currency: z12.string(),
+    display: z12.object({ kind: z12.literal("free"), currency: z12.string() })
+  }),
+  z12.object({
+    kind: z12.literal("free_registration"),
+    currency: z12.string(),
+    display: z12.object({ kind: z12.literal("free"), currency: z12.string() })
+  }),
+  z12.object({
+    kind: z12.literal("single_paid"),
+    amount: z12.number(),
+    currency: z12.string(),
+    display: z12.object({ kind: z12.literal("exact"), amount: z12.number(), currency: z12.string() })
+  }),
+  z12.object({
+    kind: z12.literal("ticket_types"),
+    currency: z12.string(),
+    ticketTypes: z12.array(publicEventTicketTypeSchema),
+    display: publicEventTicketTypePriceDisplaySchema
+  }),
+  z12.object({
+    kind: z12.literal("course"),
+    display: z12.object({ kind: z12.literal("course"), display: publicCoursePriceDisplaySchema })
+  }),
+  z12.object({
+    kind: z12.literal("external"),
+    display: z12.object({ kind: z12.literal("external"), label: z12.string() })
+  })
+]);
+var publicTeamMemberSummarySchema = z12.object({
+  id: z12.string(),
+  name: z12.string(),
+  roleLabel: z12.string().nullable(),
+  summary: z12.string().nullable(),
+  profilePath: z12.string().nullable()
+});
+var publicEventSchema = z12.object({
+  kind: z12.enum(["event", "course_session"]).optional(),
+  eventPreset: eventPresetSchema.optional(),
+  eventDestinationMode: eventDestinationModeSchema.optional(),
+  scheduleScope: eventScheduleScopeSchema.optional(),
+  id: z12.string(),
+  occurrenceId: z12.string(),
+  seriesId: z12.string(),
+  title: z12.string(),
+  description: z12.string().nullable(),
+  content: z12.object({
+    body: RichTextDocSchema.nullable().optional()
+  }).optional(),
+  presentation: z12.object({
+    cardTitleOverride: z12.string().nullable().optional(),
+    summary: z12.string().nullable().optional(),
+    image: mediaSchema.nullable().optional()
+  }).optional(),
+  slug: z12.string(),
+  path: z12.string().nullable(),
+  destination: publicEventDestinationSchema,
+  requiresRegistration: z12.boolean(),
+  deliveryMode: z12.enum(["in_person", "online", "hybrid"]),
+  attendanceModes: z12.array(publicEventAttendanceModeAvailabilitySchema),
+  startsAt: z12.string(),
+  endsAt: z12.string(),
+  capacity: z12.number().nullable(),
+  registeredCount: z12.number(),
+  availableSpots: z12.number().nullable(),
+  waitlistEnabled: z12.boolean(),
+  venue: eventVenueSchema.nullable(),
+  eventCategory: eventCategorySchema.nullable(),
+  teamMembers: z12.array(publicTeamMemberSummarySchema).optional(),
+  status: z12.enum(["active", "draft", "archived"]).optional(),
+  timeZone: z12.string(),
+  pricing: publicEventPricingSchema,
+  paymentTerms: blockBookingPaymentTermsSchema,
+  accessRestriction: accessRestrictionSchema,
+  allowedCategoryIds: z12.array(z12.string()),
+  requireGuestDetails: z12.boolean().optional(),
+  acceptsPasses: z12.boolean().optional(),
+  acceptsMemberships: z12.boolean().optional(),
+  course: z12.object({
+    id: z12.string(),
+    pricing: coursePricingSchema.optional(),
+    priceCents: z12.number().nullable(),
+    currency: z12.string(),
+    enrollmentOpen: z12.boolean()
+  }).nullable().optional()
+});
+var publicEventsArraySchema = z12.array(publicEventSchema);
+
 // ../blocks/src/system/constants/events.ts
 var EVENT_CONTENT_TYPE_SLUGS = ["event", "events"];
 function isEventContentType(slug) {
@@ -6681,172 +7167,172 @@ function resolveHeaderCtaVariant(theme, treatment) {
 }
 
 // ../theme-core/src/palette/variants/types.ts
-import { z as z18 } from "zod";
+import { z as z23 } from "zod";
 
 // ../theme-core/src/schema.ts
-import { z as z17 } from "zod";
+import { z as z22 } from "zod";
 
 // ../theme-core/src/lib/media.ts
-import z8 from "zod";
-var hotspotSchema = z8.object({
-  x: z8.number().min(0).max(1),
-  y: z8.number().min(0).max(1),
-  radius: z8.number().optional()
+import z13 from "zod";
+var hotspotSchema2 = z13.object({
+  x: z13.number().min(0).max(1),
+  y: z13.number().min(0).max(1),
+  radius: z13.number().optional()
 });
-var rotationSchema = z8.union([z8.literal(0), z8.literal(90), z8.literal(180), z8.literal(270)]);
-var rectSchema = z8.tuple([z8.number(), z8.number(), z8.number(), z8.number()]);
-var aspectCropSchema = z8.object({
-  aspect: z8.preprocess((value) => value == null ? void 0 : value, z8.string().optional()),
-  rect: z8.preprocess((value) => value == null ? void 0 : value, rectSchema.optional()),
-  hotspot: z8.preprocess((value) => value == null ? void 0 : value, hotspotSchema.optional()),
-  rotation: z8.preprocess((value) => value == null ? void 0 : value, rotationSchema.optional())
+var rotationSchema2 = z13.union([z13.literal(0), z13.literal(90), z13.literal(180), z13.literal(270)]);
+var rectSchema2 = z13.tuple([z13.number(), z13.number(), z13.number(), z13.number()]);
+var aspectCropSchema2 = z13.object({
+  aspect: z13.preprocess((value) => value == null ? void 0 : value, z13.string().optional()),
+  rect: z13.preprocess((value) => value == null ? void 0 : value, rectSchema2.optional()),
+  hotspot: z13.preprocess((value) => value == null ? void 0 : value, hotspotSchema2.optional()),
+  rotation: z13.preprocess((value) => value == null ? void 0 : value, rotationSchema2.optional())
 });
-var transformSchema = z8.object({
-  aspectCrops: z8.preprocess((value) => {
+var transformSchema2 = z13.object({
+  aspectCrops: z13.preprocess((value) => {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
       return void 0;
     }
     return value;
-  }, z8.record(z8.string(), aspectCropSchema.catch({}))).optional(),
-  rect: rectSchema.optional(),
-  hotspot: hotspotSchema.optional(),
-  rotation: rotationSchema.optional()
+  }, z13.record(z13.string(), aspectCropSchema2.catch({}))).optional(),
+  rect: rectSchema2.optional(),
+  hotspot: hotspotSchema2.optional(),
+  rotation: rotationSchema2.optional()
 });
-var mediaSchema = z8.object({
-  type: z8.enum(["image", "video", "audio", "document", "spreadsheet", "archive"]),
-  purpose: z8.string().optional(),
-  placeholder: z8.boolean().default(true).optional(),
-  assetId: z8.string().optional(),
-  identifier: z8.string().optional(),
-  src: z8.string().optional(),
-  alt: z8.string().optional(),
-  filename: z8.string().optional(),
-  mimeType: z8.string().optional(),
-  width: z8.number().optional(),
-  height: z8.number().optional(),
-  storageBucket: z8.string().optional(),
-  storagePath: z8.string().optional(),
-  transform: transformSchema.optional()
+var mediaSchema2 = z13.object({
+  type: z13.enum(["image", "video", "audio", "document", "spreadsheet", "archive"]),
+  purpose: z13.string().optional(),
+  placeholder: z13.boolean().default(true).optional(),
+  assetId: z13.string().optional(),
+  identifier: z13.string().optional(),
+  src: z13.string().optional(),
+  alt: z13.string().optional(),
+  filename: z13.string().optional(),
+  mimeType: z13.string().optional(),
+  width: z13.number().optional(),
+  height: z13.number().optional(),
+  storageBucket: z13.string().optional(),
+  storagePath: z13.string().optional(),
+  transform: transformSchema2.optional()
 });
 
 // ../theme-core/src/inputs/types.ts
-import { z as z9 } from "zod";
-var inputSystemSchema = z9.object({
+import { z as z14 } from "zod";
+var inputSystemSchema = z14.object({
   // Base styling (applied to all inputs)
-  base: z9.object({
-    background: z9.union([
-      z9.object({
-        type: z9.literal("solid"),
+  base: z14.object({
+    background: z14.union([
+      z14.object({
+        type: z14.literal("solid"),
         colorToken: themeColorTokenSchema
       }),
-      z9.object({
-        type: z9.literal("transparent")
+      z14.object({
+        type: z14.literal("transparent")
       })
     ]),
     textColorToken: themeColorTokenSchema,
-    border: z9.object({
-      widthClass: z9.string(),
+    border: z14.object({
+      widthClass: z14.string(),
       // e.g., 'border', 'border-2'
       colorToken: themeColorTokenSchema,
-      style: z9.enum(["all", "underline"]).optional()
+      style: z14.enum(["all", "underline"]).optional()
     }),
-    corners: z9.enum(["square", "soft", "rounded", "pill"]).nullable(),
+    corners: z14.enum(["square", "soft", "rounded", "pill"]).nullable(),
     // null = inherit from theme.corners
-    shadow: z9.object({
-      elevation: z9.enum(["none", "low", "medium"]),
-      softness: z9.enum(["soft", "crisp", "hard"]).nullable()
+    shadow: z14.object({
+      elevation: z14.enum(["none", "low", "medium"]),
+      softness: z14.enum(["soft", "crisp", "hard"]).nullable()
     }).nullable(),
-    spacing: z9.enum(["compact", "cozy", "medium", "comfortable"]),
+    spacing: z14.enum(["compact", "cozy", "medium", "comfortable"]),
     // padding inside inputs
-    fontSize: z9.enum(["sm", "base", "lg"])
+    fontSize: z14.enum(["sm", "base", "lg"])
   }),
   // Label styling
-  label: z9.object({
+  label: z14.object({
     textColorToken: themeColorTokenSchema,
-    fontWeight: z9.enum(["regular", "medium", "semibold", "bold", "black"]),
-    fontSize: z9.enum(["2xs", "xs", "sm", "base"]),
-    textTransform: z9.enum(["none", "uppercase", "lowercase", "capitalize"]).optional(),
-    letterSpacing: z9.enum(["normal", "wide", "wider", "widest"]).optional(),
-    opacity: z9.number().min(0.2).max(1).optional()
+    fontWeight: z14.enum(["regular", "medium", "semibold", "bold", "black"]),
+    fontSize: z14.enum(["2xs", "xs", "sm", "base"]),
+    textTransform: z14.enum(["none", "uppercase", "lowercase", "capitalize"]).optional(),
+    letterSpacing: z14.enum(["normal", "wide", "wider", "widest"]).optional(),
+    opacity: z14.number().min(0.2).max(1).optional()
   }),
   // Focus state
-  focus: z9.object({
+  focus: z14.object({
     ringColorToken: themeColorTokenSchema,
-    ringWidth: z9.enum(["0", "1", "2", "3"]),
+    ringWidth: z14.enum(["0", "1", "2", "3"]),
     borderColorToken: themeColorTokenSchema.optional()
     // Change border color on focus
   }),
   // Error state (for validation feedback)
-  error: z9.object({
+  error: z14.object({
     borderColorToken: themeColorTokenSchema,
     textColorToken: themeColorTokenSchema
   }),
   // Disabled state
-  disabled: z9.object({
+  disabled: z14.object({
     backgroundColorToken: themeColorTokenSchema,
     textColorToken: themeColorTokenSchema,
-    opacity: z9.number().min(0.3).max(0.7)
+    opacity: z14.number().min(0.3).max(0.7)
   })
 });
 
 // ../theme-core/src/gradients/types.ts
-import { z as z10 } from "zod";
-var gradientStopSchema = z10.object({
+import { z as z15 } from "zod";
+var gradientStopSchema = z15.object({
   color: themeColorTokenSchema,
-  position: z10.number().min(0).max(100)
+  position: z15.number().min(0).max(100)
   // Percentage 0-100
 });
-var gradientConfigSchema = z10.object({
-  type: z10.enum(["linear", "radial"]),
-  angle: z10.number().min(0).max(360).optional(),
+var gradientConfigSchema = z15.object({
+  type: z15.enum(["linear", "radial"]),
+  angle: z15.number().min(0).max(360).optional(),
   // For linear gradients (degrees)
-  position: z10.string().optional(),
+  position: z15.string().optional(),
   // For radial gradients ('center', 'top left', etc.)
-  stops: z10.array(gradientStopSchema).min(2)
+  stops: z15.array(gradientStopSchema).min(2)
 });
 
 // ../theme-core/src/navigation/types.ts
-import { z as z12 } from "zod";
+import { z as z17 } from "zod";
 
 // ../theme-core/src/interactive/baseSchema.ts
-import { z as z11 } from "zod";
-var interactiveTypographySchema = z11.object({
+import { z as z16 } from "zod";
+var interactiveTypographySchema = z16.object({
   /** Font family source */
-  typography: z11.enum(["body", "heading"]).default("body"),
+  typography: z16.enum(["body", "heading"]).default("body"),
   /** Font weight */
-  fontWeight: z11.enum(["regular", "medium", "semibold", "bold"]).default("medium"),
+  fontWeight: z16.enum(["regular", "medium", "semibold", "bold"]).default("medium"),
   /** Text transform */
-  textTransform: z11.enum(["none", "uppercase", "capitalize"]).default("none"),
+  textTransform: z16.enum(["none", "uppercase", "capitalize"]).default("none"),
   /** Italic style */
-  italic: z11.boolean().default(false)
+  italic: z16.boolean().default(false)
 });
-var effectApplicationSchema2 = z11.object({
+var effectApplicationSchema2 = z16.object({
   /** Effect preset ID */
-  effectId: z11.string(),
+  effectId: z16.string(),
   /** User-provided customization options */
-  options: z11.record(z11.string(), z11.any()).optional()
+  options: z16.record(z16.string(), z16.any()).optional()
 });
-var effectCompositionSchema = z11.object({
+var effectCompositionSchema = z16.object({
   /** Effects always applied */
-  base: z11.array(effectApplicationSchema2).optional(),
+  base: z16.array(effectApplicationSchema2).optional(),
   /** Effects applied on hover */
-  hover: z11.array(effectApplicationSchema2).optional(),
+  hover: z16.array(effectApplicationSchema2).optional(),
   /** Effects applied on active/pressed */
-  active: z11.array(effectApplicationSchema2).optional(),
+  active: z16.array(effectApplicationSchema2).optional(),
   /** Effects applied on focus */
-  focus: z11.array(effectApplicationSchema2).optional()
+  focus: z16.array(effectApplicationSchema2).optional()
 });
 
 // ../theme-core/src/navigation/types.ts
-var navLinkPaddingSchema = z12.enum(["none", "compact", "default"]);
-var navLinkPaddingXSchema = z12.enum(["none", "tight", "compact", "default", "relaxed", "spacious"]);
-var navLinkBorderRadiusSchema = z12.enum(["none", "sm", "md", "full"]);
-var navLinkTextSizeSchema = z12.enum(["xs", "sm", "base", "lg"]);
-var navLinkLetterSpacingSchema = z12.enum(["normal", "wide", "wider", "widest"]);
-var navLinkContrastTreatmentSchema = z12.enum(["none", "soft-glow"]);
-var navLinkStyleSchema = z12.object({
+var navLinkPaddingSchema = z17.enum(["none", "compact", "default"]);
+var navLinkPaddingXSchema = z17.enum(["none", "tight", "compact", "default", "relaxed", "spacious"]);
+var navLinkBorderRadiusSchema = z17.enum(["none", "sm", "md", "full"]);
+var navLinkTextSizeSchema = z17.enum(["xs", "sm", "base", "lg"]);
+var navLinkLetterSpacingSchema = z17.enum(["normal", "wide", "wider", "widest"]);
+var navLinkContrastTreatmentSchema = z17.enum(["none", "soft-glow"]);
+var navLinkStyleSchema = z17.object({
   /** Display name for the style */
-  name: z12.string().min(1).max(30).optional(),
+  name: z17.string().min(1).max(30).optional(),
   /** Typography settings (inherited from interactive base) */
   ...interactiveTypographySchema.shape,
   /** Text color token */
@@ -6870,7 +7356,7 @@ var navLinkStyleSchema = z12.object({
 });
 
 // ../theme-core/src/customCss/validation.ts
-import { z as z13 } from "zod";
+import { z as z18 } from "zod";
 var FORBIDDEN_SELECTORS = [":root", "html", "body"];
 var UNIVERSAL_SELECTOR = "*";
 var REMOTE_URL_PATTERN = /url\s*\(\s*['"]?(https?:|\/\/)/i;
@@ -6912,7 +7398,7 @@ function containsForbiddenSelector(selector) {
   }
   return false;
 }
-var selectorSchema = z13.string().min(1, "Selector cannot be empty").max(200, "Selector too long (max 200 characters)").refine(
+var selectorSchema = z18.string().min(1, "Selector cannot be empty").max(200, "Selector too long (max 200 characters)").refine(
   (s) => !containsForbiddenSelector(s),
   { message: "Global selectors (:root, html, body, *) are not allowed" }
 );
@@ -6922,38 +7408,38 @@ function containsRemoteUrl(value) {
 function containsJavascriptUrl(value) {
   return JAVASCRIPT_URL_PATTERN.test(value);
 }
-var declarationValueSchema = z13.string().max(500, "Declaration value too long (max 500 characters)").refine(
+var declarationValueSchema = z18.string().max(500, "Declaration value too long (max 500 characters)").refine(
   (v) => !containsRemoteUrl(v),
   { message: "Remote url() references are not allowed. Use local paths, data URIs, or fragment IDs." }
 ).refine(
   (v) => !containsJavascriptUrl(v),
   { message: "javascript: URLs are not allowed" }
 );
-var declarationsSchema = z13.record(
-  z13.string().min(1).max(100),
+var declarationsSchema = z18.record(
+  z18.string().min(1).max(100),
   // property name
   declarationValueSchema
   // property value
 );
-var customCssRuleSchema = z13.object({
-  id: z13.string().min(1, "Rule ID is required").max(50, "Rule ID too long"),
+var customCssRuleSchema = z18.object({
+  id: z18.string().min(1, "Rule ID is required").max(50, "Rule ID too long"),
   selector: selectorSchema,
   declarations: declarationsSchema
 });
 var blockCustomCssRuleSchema = customCssRuleSchema.extend({
-  blockKind: z13.string().min(1, "Block kind is required").max(50, "Block kind too long")
+  blockKind: z18.string().min(1, "Block kind is required").max(50, "Block kind too long")
 });
-var customCssRulesSchema = z13.array(customCssRuleSchema).optional();
-var blockCustomCssRulesSchema = z13.array(blockCustomCssRuleSchema).optional();
+var customCssRulesSchema = z18.array(customCssRuleSchema).optional();
+var blockCustomCssRulesSchema = z18.array(blockCustomCssRuleSchema).optional();
 
 // ../theme-core/src/customCss/atRuleValidation.ts
-import { z as z14 } from "zod";
+import { z as z19 } from "zod";
 var KEYFRAME_OFFSET_PATTERN = /^(from|to|\d{1,3}%)$/i;
 var ANIMATION_NAME_PATTERN = /^[a-zA-Z_-][a-zA-Z0-9_-]*$/;
 var BLOCKED_AT_RULES = ["@import", "@charset"];
 var BLOCKED_AT_RULE_PATTERN = /@(?:import|charset)\b/i;
-var ruleIdSchema = z14.string().min(1, "Rule ID is required").max(50, "Rule ID too long");
-var nestedRuleSchema = z14.object({
+var ruleIdSchema = z19.string().min(1, "Rule ID is required").max(50, "Rule ID too long");
+var nestedRuleSchema = z19.object({
   selector: selectorSchema,
   declarations: declarationsSchema
 });
@@ -6965,88 +7451,88 @@ function isValidKeyframeOffset(offset) {
   const value = parseInt(match[1], 10);
   return value >= 0 && value <= 100;
 }
-var keyframeOffsetSchema = z14.string().transform((offset) => offset.trim()).refine(
+var keyframeOffsetSchema = z19.string().transform((offset) => offset.trim()).refine(
   (offset) => KEYFRAME_OFFSET_PATTERN.test(offset),
   { message: 'Invalid keyframe offset. Use percentages (0%, 50%, 100%) or "from"/"to"' }
 ).refine(
   isValidKeyframeOffset,
   { message: "Keyframe offset must be between 0% and 100%" }
 );
-var animationNameSchema = z14.string().min(1, "Animation name is required").max(50, "Animation name too long").refine(
+var animationNameSchema = z19.string().min(1, "Animation name is required").max(50, "Animation name too long").refine(
   (name) => ANIMATION_NAME_PATTERN.test(name),
   { message: "Invalid animation name. Use letters, numbers, dashes, underscores (start with letter, dash, or underscore)" }
 );
-var keyframeSchema = z14.object({
+var keyframeSchema = z19.object({
   offset: keyframeOffsetSchema,
   declarations: declarationsSchema
 });
-var keyframesAtRuleSchema = z14.object({
+var keyframesAtRuleSchema = z19.object({
   id: ruleIdSchema,
-  type: z14.literal("keyframes"),
+  type: z19.literal("keyframes"),
   name: animationNameSchema,
-  frames: z14.array(keyframeSchema).min(1, "At least one keyframe is required")
+  frames: z19.array(keyframeSchema).min(1, "At least one keyframe is required")
 });
-var fontFaceDeclarationsSchema = z14.record(z14.string().min(1).max(100), declarationValueSchema).refine(
+var fontFaceDeclarationsSchema = z19.record(z19.string().min(1).max(100), declarationValueSchema).refine(
   (decls) => "fontFamily" in decls || "font-family" in decls,
   { message: "font-family is required in @font-face" }
 );
-var fontFaceAtRuleSchema = z14.object({
+var fontFaceAtRuleSchema = z19.object({
   id: ruleIdSchema,
-  type: z14.literal("font-face"),
+  type: z19.literal("font-face"),
   declarations: fontFaceDeclarationsSchema
 });
-var mediaQuerySchema = z14.string().min(1, "Media query is required").max(200, "Media query too long");
-var mediaAtRuleSchema = z14.object({
+var mediaQuerySchema = z19.string().min(1, "Media query is required").max(200, "Media query too long");
+var mediaAtRuleSchema = z19.object({
   id: ruleIdSchema,
-  type: z14.literal("media"),
+  type: z19.literal("media"),
   query: mediaQuerySchema,
-  rules: z14.array(nestedRuleSchema).min(1, "At least one rule is required")
+  rules: z19.array(nestedRuleSchema).min(1, "At least one rule is required")
 });
-var supportsConditionSchema = z14.string().min(1, "Supports condition is required").max(200, "Supports condition too long");
-var supportsAtRuleSchema = z14.object({
+var supportsConditionSchema = z19.string().min(1, "Supports condition is required").max(200, "Supports condition too long");
+var supportsAtRuleSchema = z19.object({
   id: ruleIdSchema,
-  type: z14.literal("supports"),
+  type: z19.literal("supports"),
   condition: supportsConditionSchema,
-  rules: z14.array(nestedRuleSchema).min(1, "At least one rule is required")
+  rules: z19.array(nestedRuleSchema).min(1, "At least one rule is required")
 });
 function containsBlockedAtRule(css) {
   return BLOCKED_AT_RULE_PATTERN.test(css);
 }
-var rawCssSchema = z14.string().min(1, "CSS is required").max(5e3, "Raw CSS too long (max 5000 characters)").refine(
+var rawCssSchema = z19.string().min(1, "CSS is required").max(5e3, "Raw CSS too long (max 5000 characters)").refine(
   (css) => css.trim().startsWith("@"),
   { message: "Raw at-rule must start with @" }
 ).refine(
   (css) => !containsBlockedAtRule(css),
   { message: `Blocked at-rules: ${BLOCKED_AT_RULES.join(", ")}. Use typed at-rules or local assets instead.` }
 );
-var rawAtRuleSchema = z14.object({
+var rawAtRuleSchema = z19.object({
   id: ruleIdSchema,
-  type: z14.literal("raw"),
+  type: z19.literal("raw"),
   css: rawCssSchema
 });
-var customCssAtRuleSchema = z14.discriminatedUnion("type", [
+var customCssAtRuleSchema = z19.discriminatedUnion("type", [
   keyframesAtRuleSchema,
   fontFaceAtRuleSchema,
   mediaAtRuleSchema,
   supportsAtRuleSchema,
   rawAtRuleSchema
 ]);
-var customCssAtRulesSchema = z14.array(customCssAtRuleSchema).optional();
+var customCssAtRulesSchema = z19.array(customCssAtRuleSchema).optional();
 
 // ../theme-core/src/shared/componentStyles.ts
-import { z as z15 } from "zod";
-var componentBorderSchema = z15.object({
-  width: z15.enum(["none", "hairline", "thin", "medium", "thick"]).default("none"),
-  style: z15.enum(["solid", "dashed"]).default("solid"),
+import { z as z20 } from "zod";
+var componentBorderSchema = z20.object({
+  width: z20.enum(["none", "hairline", "thin", "medium", "thick"]).default("none"),
+  style: z20.enum(["solid", "dashed"]).default("solid"),
   colorToken: themeColorTokenSchema.optional()
   // defaults to "border" if not set
 });
-var componentShadowSchema = z15.object({
-  elevation: z15.enum(["none", "sm", "md", "lg", "xl", "2xl"]).default("sm")
+var componentShadowSchema = z20.object({
+  elevation: z20.enum(["none", "sm", "md", "lg", "xl", "2xl"]).default("sm")
 });
 
 // ../theme-core/src/site-styles/logoBranding.ts
-import { z as z16 } from "zod";
+import { z as z21 } from "zod";
 var logoTextConfidenceValues = ["low", "medium", "high"];
 var logoAssetShapeValues = [
   "none",
@@ -7064,43 +7550,43 @@ var logoKindValues = [
   "unknown"
 ];
 var logoDensityValues = ["simple", "detailed", "unknown"];
-var logoContainsTextSchema = z16.discriminatedUnion("kind", [
-  z16.object({
-    kind: z16.literal("contains-text"),
-    confidence: z16.enum(logoTextConfidenceValues),
-    text: z16.string().trim().min(1).max(200).optional()
+var logoContainsTextSchema = z21.discriminatedUnion("kind", [
+  z21.object({
+    kind: z21.literal("contains-text"),
+    confidence: z21.enum(logoTextConfidenceValues),
+    text: z21.string().trim().min(1).max(200).optional()
   }),
-  z16.object({
-    kind: z16.literal("no-text"),
-    confidence: z16.enum(logoTextConfidenceValues)
+  z21.object({
+    kind: z21.literal("no-text"),
+    confidence: z21.enum(logoTextConfidenceValues)
   }),
-  z16.object({
-    kind: z16.literal("unknown"),
-    reason: z16.enum([
+  z21.object({
+    kind: z21.literal("unknown"),
+    reason: z21.enum([
       "analysis-unavailable",
       "unsupported-file",
       "low-confidence"
     ])
   })
 ]);
-var logoAnalysisSourceSchema = z16.discriminatedUnion("kind", [
-  z16.object({ kind: z16.literal("none") }),
-  z16.object({
-    kind: z16.literal("deterministic"),
-    reason: z16.enum(["dimensions", "fallback"])
+var logoAnalysisSourceSchema = z21.discriminatedUnion("kind", [
+  z21.object({ kind: z21.literal("none") }),
+  z21.object({
+    kind: z21.literal("deterministic"),
+    reason: z21.enum(["dimensions", "fallback"])
   }),
-  z16.object({
-    kind: z16.literal("llm"),
-    model: z16.literal("gpt-5.4-mini"),
-    analyzedAt: z16.string().trim().min(1).max(80).optional()
+  z21.object({
+    kind: z21.literal("llm"),
+    model: z21.literal("gpt-5.4-mini"),
+    analyzedAt: z21.string().trim().min(1).max(80).optional()
   }),
-  z16.object({ kind: z16.literal("manual-override") })
+  z21.object({ kind: z21.literal("manual-override") })
 ]);
-var logoFactsSchema = z16.object({
-  shape: z16.enum(logoAssetShapeValues),
+var logoFactsSchema = z21.object({
+  shape: z21.enum(logoAssetShapeValues),
   containsText: logoContainsTextSchema,
-  kind: z16.enum(logoKindValues),
-  density: z16.enum(logoDensityValues),
+  kind: z21.enum(logoKindValues),
+  density: z21.enum(logoDensityValues),
   source: logoAnalysisSourceSchema
 });
 var brandDisplayModeValues = [
@@ -7158,74 +7644,74 @@ var pageDesignEditorBackgroundOverrideOwner = "page-design-editor";
 var siteChromeBackgroundOverrideOwner = "site-chrome-editor";
 
 // ../theme-core/src/schema.ts
-var axesSchema = z17.object({
-  tone: z17.enum(["minimal", "classic", "bold"]),
-  energy: z17.enum(["calm", "vibrant"]),
-  density: z17.enum(["airy", "regular", "compact"]),
-  mediaBias: z17.enum(["text", "media", "mixed"]),
-  conversionBias: z17.enum(["low", "med", "high"]),
-  motion: z17.enum(["subtle", "standard", "expressive"])
+var axesSchema = z22.object({
+  tone: z22.enum(["minimal", "classic", "bold"]),
+  energy: z22.enum(["calm", "vibrant"]),
+  density: z22.enum(["airy", "regular", "compact"]),
+  mediaBias: z22.enum(["text", "media", "mixed"]),
+  conversionBias: z22.enum(["low", "med", "high"]),
+  motion: z22.enum(["subtle", "standard", "expressive"])
 });
-var colourHexString = z17.string().regex(/^#([0-9A-Fa-f]{3}){1,2}$/);
-var paletteColorSchema = z17.object({
-  name: z17.string().min(1),
+var colourHexString = z22.string().regex(/^#([0-9A-Fa-f]{3}){1,2}$/);
+var paletteColorSchema = z22.object({
+  name: z22.string().min(1),
   hex: colourHexString
 });
-var paletteMetaSchema = z17.object({
-  mode: z17.enum(["light", "dark"])
+var paletteMetaSchema = z22.object({
+  mode: z22.enum(["light", "dark"])
 });
-var paletteSchema = z17.object({
-  colors: z17.array(paletteColorSchema),
+var paletteSchema = z22.object({
+  colors: z22.array(paletteColorSchema),
   meta: paletteMetaSchema
 });
-var typographyStyleSchema = z17.object({
-  family: z17.string().min(1),
-  weight: z17.enum(["light", "regular", "medium", "semibold", "bold"]),
-  letterSpacing: z17.enum(["tight", "normal", "loose"]),
-  lineHeight: z17.enum(["normal", "relaxed", "loose"])
+var typographyStyleSchema = z22.object({
+  family: z22.string().min(1),
+  weight: z22.enum(["light", "regular", "medium", "semibold", "bold"]),
+  letterSpacing: z22.enum(["tight", "normal", "loose"]),
+  lineHeight: z22.enum(["normal", "relaxed", "loose"])
 });
 var bodyTypographyStyleSchema = typographyStyleSchema.extend({
-  size: z17.enum(["md", "lg", "xl"])
+  size: z22.enum(["md", "lg", "xl"])
 });
-var headingSizeSchema = z17.enum(["xs", "sm", "md", "lg", "xl", "2xl"]);
-var headingTypographyOverridesSchema = z17.object({
-  weight: z17.enum(["light", "regular", "medium", "semibold", "bold"]).nullable().optional(),
-  letterSpacing: z17.enum(["tight", "normal", "loose"]).nullable().optional(),
+var headingSizeSchema = z22.enum(["xs", "sm", "md", "lg", "xl", "2xl"]);
+var headingTypographyOverridesSchema = z22.object({
+  weight: z22.enum(["light", "regular", "medium", "semibold", "bold"]).nullable().optional(),
+  letterSpacing: z22.enum(["tight", "normal", "loose"]).nullable().optional(),
   size: headingSizeSchema.nullable().optional(),
-  lineHeight: z17.enum(["normal", "relaxed", "loose"]).nullable().optional(),
-  italic: z17.boolean().nullable().optional(),
+  lineHeight: z22.enum(["normal", "relaxed", "loose"]).nullable().optional(),
+  italic: z22.boolean().nullable().optional(),
   colorToken: themeColorTokenSchema.nullable().optional()
 });
 var headingTypographyStyleSchema = typographyStyleSchema.extend({
-  case: z17.enum(["uppercase", "normal", "smallCaps"]).nullable(),
-  italic: z17.boolean().nullable(),
+  case: z22.enum(["uppercase", "normal", "smallCaps"]).nullable(),
+  italic: z22.boolean().nullable(),
   colorToken: themeColorTokenSchema.nullable().optional()
 });
-var proseLinkUnderlineStyleSchema = z17.enum(["solid", "dotted", "dashed"]);
-var proseLinkUnderlineThicknessSchema = z17.enum([
+var proseLinkUnderlineStyleSchema = z22.enum(["solid", "dotted", "dashed"]);
+var proseLinkUnderlineThicknessSchema = z22.enum([
   "auto",
   "fromFont",
   "thin",
   "medium",
   "thick"
 ]);
-var proseLinkUnderlineOffsetSchema = z17.enum([
+var proseLinkUnderlineOffsetSchema = z22.enum([
   "auto",
   "tight",
   "normal",
   "loose"
 ]);
-var proseLinkStyleSchema = z17.object({
+var proseLinkStyleSchema = z22.object({
   colorToken: themeColorTokenSchema.optional(),
   hoverColorToken: themeColorTokenSchema.optional(),
-  underline: z17.boolean().optional(),
+  underline: z22.boolean().optional(),
   decorationColorToken: themeColorTokenSchema.optional(),
   hoverDecorationColorToken: themeColorTokenSchema.optional(),
   underlineStyle: proseLinkUnderlineStyleSchema.optional(),
   underlineThickness: proseLinkUnderlineThicknessSchema.optional(),
   underlineOffset: proseLinkUnderlineOffsetSchema.optional()
 });
-var semanticSpacingSchema = z17.enum([
+var semanticSpacingSchema = z22.enum([
   "none",
   "compact",
   "cozy",
@@ -7233,61 +7719,61 @@ var semanticSpacingSchema = z17.enum([
   "comfortable",
   "spacious"
 ]);
-var boxRoundedSchema = z17.enum(["none", "sm", "md", "lg", "xl", "2xl", "full"]);
-var boxBackgroundOverlaySchema = z17.object({
-  type: z17.enum(["none", "color", "gradient"]).nullable().optional(),
+var boxRoundedSchema = z22.enum(["none", "sm", "md", "lg", "xl", "2xl", "full"]);
+var boxBackgroundOverlaySchema = z22.object({
+  type: z22.enum(["none", "color", "gradient"]).nullable().optional(),
   color: tokenOrCssColorValueSchema.nullable().optional(),
-  gradient: z17.string().nullable().optional(),
-  opacity: z17.number().min(0).max(1).nullable().optional()
+  gradient: z22.string().nullable().optional(),
+  opacity: z22.number().min(0).max(1).nullable().optional()
 });
-var boxBackgroundSchema = z17.object({
-  type: z17.enum(["color", "gradient", "image"]).optional(),
-  contentOwner: z17.literal(pageDesignEditorBackgroundOverrideOwner).optional(),
+var boxBackgroundSchema = z22.object({
+  type: z22.enum(["color", "gradient", "image"]).optional(),
+  contentOwner: z22.literal(pageDesignEditorBackgroundOverrideOwner).optional(),
   color: tokenOrCssColorValueSchema.nullable().optional(),
-  gradient: z17.string().nullable().optional(),
-  gradientPresetId: z17.string().min(1).nullable().optional(),
-  image: mediaSchema.nullable().optional(),
-  objectFit: z17.enum(["fill", "fit", "original", "custom"]).nullable().optional(),
-  scale: z17.string().nullable().optional(),
-  position: z17.string().nullable().optional(),
-  opacity: z17.number().min(0).max(1).nullable().optional(),
-  motion: z17.enum(["static", "fixed-frame"]).nullable().optional(),
+  gradient: z22.string().nullable().optional(),
+  gradientPresetId: z22.string().min(1).nullable().optional(),
+  image: mediaSchema2.nullable().optional(),
+  objectFit: z22.enum(["fill", "fit", "original", "custom"]).nullable().optional(),
+  scale: z22.string().nullable().optional(),
+  position: z22.string().nullable().optional(),
+  opacity: z22.number().min(0).max(1).nullable().optional(),
+  motion: z22.enum(["static", "fixed-frame"]).nullable().optional(),
   overlay: boxBackgroundOverlaySchema.nullable().optional(),
   textColor: tokenOrCssColorValueSchema.nullable().optional(),
   headingColor: tokenOrCssColorValueSchema.nullable().optional(),
   linkColor: tokenOrCssColorValueSchema.nullable().optional(),
   supportingColor: tokenOrCssColorValueSchema.nullable().optional()
 });
-var noHeadingDecorationSchema = z17.object({
-  family: z17.literal("none")
+var noHeadingDecorationSchema = z22.object({
+  family: z22.literal("none")
 });
-var visibleHeadingDecorationSchema = z17.object({
-  family: z17.enum(visibleHeadingDecorationFamilyValues),
-  colorToken: z17.enum(headingDecorationColorTokenValues).optional()
+var visibleHeadingDecorationSchema = z22.object({
+  family: z22.enum(visibleHeadingDecorationFamilyValues),
+  colorToken: z22.enum(headingDecorationColorTokenValues).optional()
 });
-var headingDecorationSchema = z17.union([
+var headingDecorationSchema = z22.union([
   noHeadingDecorationSchema,
   visibleHeadingDecorationSchema
 ]);
-var headingDecorationOverrideSchema = z17.union([
-  z17.enum(headingDecorationOverrideValues),
+var headingDecorationOverrideSchema = z22.union([
+  z22.enum(headingDecorationOverrideValues),
   // Legacy authoring value from the earlier model. In the render-time model
   // "on" cannot force a fragment into a block, so it is equivalent to default.
-  z17.literal("on").transform(() => "site-default")
+  z22.literal("on").transform(() => "site-default")
 ]);
-var accordionIconTreatmentSchema = z17.object({
-  iconSet: z17.enum(accordionIconSetValues),
-  colorToken: z17.enum(accordionIconColorTokenValues),
-  openColorToken: z17.enum(accordionIconColorTokenValues).optional(),
-  motion: z17.enum(accordionIconMotionValues)
+var accordionIconTreatmentSchema = z22.object({
+  iconSet: z22.enum(accordionIconSetValues),
+  colorToken: z22.enum(accordionIconColorTokenValues),
+  openColorToken: z22.enum(accordionIconColorTokenValues).optional(),
+  motion: z22.enum(accordionIconMotionValues)
 });
-var sectionStylesOverrideSchema = z17.object({
+var sectionStylesOverrideSchema = z22.object({
   background: boxBackgroundSchema.nullable().optional(),
   spacing: semanticSpacingSchema.nullable().optional(),
-  minHeight: z17.enum(["none", "banner", "hero", "immersive"]).nullable().optional(),
-  tileTreatment: z17.enum(tileTreatmentValues).nullable().optional(),
-  eventListTreatment: z17.enum(eventListTreatmentValues).nullable().optional(),
-  eyebrowTreatment: z17.enum(eyebrowTreatmentValues).nullable().optional(),
+  minHeight: z22.enum(["none", "banner", "hero", "immersive"]).nullable().optional(),
+  tileTreatment: z22.enum(tileTreatmentValues).nullable().optional(),
+  eventListTreatment: z22.enum(eventListTreatmentValues).nullable().optional(),
+  eyebrowTreatment: z22.enum(eyebrowTreatmentValues).nullable().optional(),
   headingDecoration: headingDecorationSchema.nullable().optional(),
   // Author-level opt-out consumed by render-time theme projection. Persisted
   // content may also carry legacy `headingDecoration` / `on` values; those are
@@ -7296,25 +7782,25 @@ var sectionStylesOverrideSchema = z17.object({
   headingDecorationOverride: headingDecorationOverrideSchema.nullable().optional(),
   accordionIconTreatment: accordionIconTreatmentSchema.nullable().optional()
 });
-var containerStylesOverrideSchema = z17.object({
+var containerStylesOverrideSchema = z22.object({
   background: boxBackgroundSchema.nullable().optional(),
   spacing: semanticSpacingSchema.nullable().optional(),
-  raised: z17.boolean().nullable().optional(),
+  raised: z22.boolean().nullable().optional(),
   rounded: boxRoundedSchema.nullable().optional(),
-  fullWidth: z17.boolean().nullable().optional()
+  fullWidth: z22.boolean().nullable().optional()
 });
-var cardBorderOverrideSchema = z17.object({
-  enabled: z17.boolean().nullable().optional(),
-  width: z17.enum(["none", "1", "2", "3"]).nullable().optional(),
+var cardBorderOverrideSchema = z22.object({
+  enabled: z22.boolean().nullable().optional(),
+  width: z22.enum(["none", "1", "2", "3"]).nullable().optional(),
   colorToken: themeColorTokenSchema.nullable().optional()
 });
-var cardStylesOverrideSchema = z17.object({
+var cardStylesOverrideSchema = z22.object({
   background: boxBackgroundSchema.nullable().optional(),
   border: cardBorderOverrideSchema.nullable().optional(),
   spacing: semanticSpacingSchema.nullable().optional(),
-  raised: z17.boolean().nullable().optional(),
+  raised: z22.boolean().nullable().optional(),
   rounded: boxRoundedSchema.nullable().optional(),
-  treatment: z17.enum([
+  treatment: z22.enum([
     "accent-quote",
     "editorial-rule",
     "soft-panel",
@@ -7326,18 +7812,18 @@ var cardStylesOverrideSchema = z17.object({
   // 'none' is boxless. Driven by the block look via testimonialCardTreatment.
   cardVariant: boxStylesCardVariantSchema.nullable().optional()
 });
-var blockStyleOverridesSchema = z17.object({
+var blockStyleOverridesSchema = z22.object({
   sectionStyles: sectionStylesOverrideSchema.nullable().optional(),
   containerStyles: containerStylesOverrideSchema.nullable().optional(),
   cardStyles: cardStylesOverrideSchema.nullable().optional()
 });
-var blockThemeOverrideSchema = z17.object({
-  typography: z17.object({
+var blockThemeOverrideSchema = z22.object({
+  typography: z22.object({
     proseLinkStyle: proseLinkStyleSchema.optional()
   }).optional(),
   styles: blockStyleOverridesSchema.optional()
 });
-var typographyScaleSchema = z17.enum([
+var typographyScaleSchema = z22.enum([
   // New intuitive names
   "compact",
   // ratio 1.2 (was minorThird)
@@ -7350,9 +7836,9 @@ var typographyScaleSchema = z17.enum([
   "majorThird",
   "perfectFourth"
 ]);
-var typographySchema = z17.object({
+var typographySchema = z22.object({
   body: bodyTypographyStyleSchema,
-  headings: z17.object({
+  headings: z22.object({
     default: headingTypographyStyleSchema,
     h1: headingTypographyOverridesSchema,
     h2: headingTypographyOverridesSchema,
@@ -7365,41 +7851,41 @@ var typographySchema = z17.object({
   scale: typographyScaleSchema,
   proseLinkStyle: proseLinkStyleSchema.optional()
 });
-var spaceSchema = z17.enum(["comfortable", "standard", "dense"]);
-var corners = z17.enum(["square", "soft", "rounded", "pill"]);
-var shadow = z17.object({
-  elevation: z17.enum(["none", "low", "medium", "high"]),
-  softness: z17.enum(["crisp", "soft", "hard"]).nullable(),
-  position: z17.enum(["bottom", "bottom-right"]).default("bottom")
+var spaceSchema = z22.enum(["comfortable", "standard", "dense"]);
+var corners = z22.enum(["square", "soft", "rounded", "pill"]);
+var shadow = z22.object({
+  elevation: z22.enum(["none", "low", "medium", "high"]),
+  softness: z22.enum(["crisp", "soft", "hard"]).nullable(),
+  position: z22.enum(["bottom", "bottom-right"]).default("bottom")
 });
-var border = z17.object({
-  width: z17.enum(["none", "hairline", "thin", "thick"]),
-  style: z17.enum(["solid", "dashed"])
+var border = z22.object({
+  width: z22.enum(["none", "hairline", "thin", "thick"]),
+  style: z22.enum(["solid", "dashed"])
 });
-var motion = z17.object({
-  level: z17.enum(["off", "low", "medium", "high"]),
-  easing: z17.enum(["standard", "snappy", "gentle"]).nullable()
+var motion = z22.object({
+  level: z22.enum(["off", "low", "medium", "high"]),
+  easing: z22.enum(["standard", "snappy", "gentle"]).nullable()
 });
-var buttonStyle = z17.object({
+var buttonStyle = z22.object({
   shape: corners
   // Used for --radius-control CSS variable
 });
-var cardStyle = z17.object({
-  elevation: z17.enum(["none", "low", "medium", "high"]),
-  border: z17.enum(["none", "subtle", "defined"]),
+var cardStyle = z22.object({
+  elevation: z22.enum(["none", "low", "medium", "high"]),
+  border: z22.enum(["none", "subtle", "defined"]),
   shape: corners,
-  headerStyle: z17.enum(["plain", "accentBar", "subtleBg"]).nullable(),
-  mediaTreatment: z17.enum(["square", "rounded", "bleed"]).nullable()
+  headerStyle: z22.enum(["plain", "accentBar", "subtleBg"]).nullable(),
+  mediaTreatment: z22.enum(["square", "rounded", "bleed"]).nullable()
 });
-var inputStyle = z17.object({
+var inputStyle = z22.object({
   shape: corners,
-  border: z17.enum(["subtle", "defined", "underline"]),
-  focus: z17.enum(["glow", "ring", "underline"]),
-  label: z17.enum(["inside", "above"])
+  border: z22.enum(["subtle", "defined", "underline"]),
+  focus: z22.enum(["glow", "ring", "underline"]),
+  label: z22.enum(["inside", "above"])
 });
-var headerVariant = z17.enum(["classic", "centered", "transparent", "floating"]);
-var headerPositioning = z17.enum(["static", "sticky", "fixed"]);
-var headerNavStyle = z17.enum([
+var headerVariant = z22.enum(["classic", "centered", "transparent", "floating"]);
+var headerPositioning = z22.enum(["static", "sticky", "fixed"]);
+var headerNavStyle = z22.enum([
   "minimal",
   "underline",
   "underline-grow",
@@ -7408,57 +7894,57 @@ var headerNavStyle = z17.enum([
   "frosted",
   "solid"
 ]);
-var navFontWeight = z17.enum(["regular", "medium", "semibold", "bold"]);
-var headerMaxWidth = z17.enum(["container", "full"]);
-var headerContainerSchema = z17.object({
-  rounded: z17.enum(["none", "sm", "md", "lg", "xl", "2xl"]).default("xl"),
-  border: z17.boolean().default(true),
-  shadow: z17.boolean().default(true),
-  padding: z17.enum(["sm", "md", "lg"]).default("md"),
-  tint: z17.string().nullable().optional(),
-  opacity: z17.number().min(0).max(1).default(0.12)
+var navFontWeight = z22.enum(["regular", "medium", "semibold", "bold"]);
+var headerMaxWidth = z22.enum(["container", "full"]);
+var headerContainerSchema = z22.object({
+  rounded: z22.enum(["none", "sm", "md", "lg", "xl", "2xl"]).default("xl"),
+  border: z22.boolean().default(true),
+  shadow: z22.boolean().default(true),
+  padding: z22.enum(["sm", "md", "lg"]).default("md"),
+  tint: z22.string().nullable().optional(),
+  opacity: z22.number().min(0).max(1).default(0.12)
 }).optional();
 var headerBorderSchema = componentBorderSchema.extend({
-  position: z17.enum(["bottom", "top", "both", "none"]).default("bottom")
+  position: z22.enum(["bottom", "top", "both", "none"]).default("bottom")
 }).optional();
-var logoStyleSchema = z17.object({
-  fontFamily: z17.enum(["heading", "body"]).default("heading"),
-  letterSpacing: z17.enum(["normal", "wide", "wider", "widest"]).default("normal"),
-  gradient: z17.boolean().default(false),
-  brandDisplay: z17.enum(brandDisplayModeValues).optional(),
-  size: z17.enum(logoSizePolicyValues).optional(),
-  accommodation: z17.enum(logoAccommodationPatternValues).optional()
+var logoStyleSchema = z22.object({
+  fontFamily: z22.enum(["heading", "body"]).default("heading"),
+  letterSpacing: z22.enum(["normal", "wide", "wider", "widest"]).default("normal"),
+  gradient: z22.boolean().default(false),
+  brandDisplay: z22.enum(brandDisplayModeValues).optional(),
+  size: z22.enum(logoSizePolicyValues).optional(),
+  accommodation: z22.enum(logoAccommodationPatternValues).optional()
 }).optional();
-var headerLogoTextSchema = z17.object({
-  mobileWrapLines: z17.union([z17.literal(1), z17.literal(2)]).optional(),
-  mobileMaxWidth: z17.enum(["xs", "sm", "md"]).optional(),
-  hideOnShrink: z17.boolean().optional()
+var headerLogoTextSchema = z22.object({
+  mobileWrapLines: z22.union([z22.literal(1), z22.literal(2)]).optional(),
+  mobileMaxWidth: z22.enum(["xs", "sm", "md"]).optional(),
+  hideOnShrink: z22.boolean().optional()
 }).optional();
-var navEffectsSchema = z17.object({
-  underlineGradient: z17.boolean().default(false),
-  glow: z17.boolean().default(false),
-  glowColor: z17.string().optional(),
-  neumorphic: z17.boolean().default(false)
+var navEffectsSchema = z22.object({
+  underlineGradient: z22.boolean().default(false),
+  glow: z22.boolean().default(false),
+  glowColor: z22.string().optional(),
+  neumorphic: z22.boolean().default(false)
 }).optional();
-var dropdownStyleSchema = z17.object({
+var dropdownStyleSchema = z22.object({
   // Container styling
   background: themeColorTokenSchema.default("surface"),
   textColor: themeColorTokenSchema.default("text"),
   borderColor: themeColorTokenSchema.nullable().default("border"),
-  shadow: z17.enum(["none", "sm", "md", "lg"]).default("md"),
-  borderRadius: z17.enum(["none", "sm", "md", "lg"]).default("md"),
+  shadow: z22.enum(["none", "sm", "md", "lg"]).default("md"),
+  borderRadius: z22.enum(["none", "sm", "md", "lg"]).default("md"),
   // Link hover states (explicit control)
   hoverBackground: themeColorTokenSchema.nullable().optional(),
   hoverTextColor: themeColorTokenSchema.nullable().optional(),
   // Typography
-  textTransform: z17.enum(["none", "uppercase", "capitalize"]).default("none"),
-  letterSpacing: z17.enum(["normal", "wide", "wider"]).default("normal"),
-  fontWeight: z17.enum(["regular", "medium", "semibold", "bold"]).optional(),
+  textTransform: z22.enum(["none", "uppercase", "capitalize"]).default("none"),
+  letterSpacing: z22.enum(["normal", "wide", "wider"]).default("normal"),
+  fontWeight: z22.enum(["regular", "medium", "semibold", "bold"]).optional(),
   // optional = inherit from navWeight
-  textSize: z17.enum(["xs", "sm", "base", "lg"]).optional()
+  textSize: z22.enum(["xs", "sm", "base", "lg"]).optional()
   // optional = no override (browser default)
 }).optional();
-var headerCtaGapSchema = z17.enum([
+var headerCtaGapSchema = z22.enum([
   "none",
   "tight",
   "compact",
@@ -7466,7 +7952,7 @@ var headerCtaGapSchema = z17.enum([
   "relaxed",
   "spacious"
 ]);
-var headerCtaTreatmentSchema = z17.enum([
+var headerCtaTreatmentSchema = z22.enum([
   "default",
   "primary",
   "secondary",
@@ -7474,25 +7960,25 @@ var headerCtaTreatmentSchema = z17.enum([
   "outline",
   "ghost"
 ]);
-var navContainerSchema = z17.object({
-  type: z17.enum(["none", "pill", "glass"]).default("none"),
-  tint: z17.string().nullable().optional(),
-  opacity: z17.number().min(0).max(1).default(0.15)
+var navContainerSchema = z22.object({
+  type: z22.enum(["none", "pill", "glass"]).default("none"),
+  tint: z22.string().nullable().optional(),
+  opacity: z22.number().min(0).max(1).default(0.15)
 }).default({ type: "none", tint: null, opacity: 0.15 });
-var headerBackgroundSchema = z17.object({
-  type: z17.enum(["color", "gradient", "image"]),
-  contentOwner: z17.literal(siteChromeBackgroundOverrideOwner).optional(),
+var headerBackgroundSchema = z22.object({
+  type: z22.enum(["color", "gradient", "image"]),
+  contentOwner: z22.literal(siteChromeBackgroundOverrideOwner).optional(),
   color: tokenOrCssColorValueSchema.nullable().optional(),
   gradient: gradientConfigSchema.nullable().optional(),
-  image: mediaSchema.nullable().optional(),
+  image: mediaSchema2.nullable().optional(),
   textColor: tokenOrCssColorValueSchema.nullable().optional()
 });
-var headerSchema = z17.object({
+var headerSchema = z22.object({
   variant: headerVariant,
   positioning: headerPositioning,
-  shrinkOnScroll: z17.boolean(),
+  shrinkOnScroll: z22.boolean(),
   maxWidth: headerMaxWidth,
-  logoOverride: mediaSchema.nullable().optional(),
+  logoOverride: mediaSchema2.nullable().optional(),
   background: headerBackgroundSchema.default({
     type: "color",
     color: "surface"
@@ -7520,16 +8006,16 @@ var headerSchema = z17.object({
   // Optional theme-level CTA variant for header/nav CTA buttons.
   // Internal runtime bridge for the block renderer; prefer ctaTreatment in
   // authored Theme V2 concepts.
-  ctaVariant: z17.string().min(1).optional(),
+  ctaVariant: z22.string().min(1).optional(),
   // Dropdown menu styling (nav dropdowns and mobile drawer)
   dropdownStyle: dropdownStyleSchema
 });
-var footerVariant = z17.enum(["simple", "columns", "split"]);
-var footerMaxWidth = z17.enum(["container", "full"]);
-var footerMode = z17.enum(["default", "blocks", "default+blocks", "none"]);
-var footerNavLayoutMode = z17.enum(["stack", "inline", "inline-wrap"]);
-var footerNavLayoutAlign = z17.enum(["start", "center", "end", "space-between"]);
-var footerSpacing = z17.enum([
+var footerVariant = z22.enum(["simple", "columns", "split"]);
+var footerMaxWidth = z22.enum(["container", "full"]);
+var footerMode = z22.enum(["default", "blocks", "default+blocks", "none"]);
+var footerNavLayoutMode = z22.enum(["stack", "inline", "inline-wrap"]);
+var footerNavLayoutAlign = z22.enum(["start", "center", "end", "space-between"]);
+var footerSpacing = z22.enum([
   "none",
   "tight",
   "compact",
@@ -7537,44 +8023,44 @@ var footerSpacing = z17.enum([
   "relaxed",
   "spacious"
 ]);
-var footerLogoPlacement = z17.enum(["left", "right", "above", "below"]);
-var footerLogoSize = z17.enum(["sm", "md", "lg", "xl"]);
-var footerLogoMaxHeight = z17.enum(["sm", "md", "lg", "xl"]);
-var footerBottomTextLinkStyleSchema = z17.object({
+var footerLogoPlacement = z22.enum(["left", "right", "above", "below"]);
+var footerLogoSize = z22.enum(["sm", "md", "lg", "xl"]);
+var footerLogoMaxHeight = z22.enum(["sm", "md", "lg", "xl"]);
+var footerBottomTextLinkStyleSchema = z22.object({
   colorToken: themeColorTokenSchema.optional(),
   hoverColorToken: themeColorTokenSchema.nullable().optional(),
   decorationColorToken: themeColorTokenSchema.nullable().optional(),
-  underline: z17.boolean().optional()
+  underline: z22.boolean().optional()
 });
-var footerBottomBarSchema = z17.object({
-  enabled: z17.boolean().optional(),
-  fullBleed: z17.boolean().optional(),
+var footerBottomBarSchema = z22.object({
+  enabled: z22.boolean().optional(),
+  fullBleed: z22.boolean().optional(),
   background: headerBackgroundSchema.optional(),
   textColor: themeColorTokenSchema.nullable().optional(),
-  textAlign: z17.enum(["left", "center", "right"]).optional(),
+  textAlign: z22.enum(["left", "center", "right"]).optional(),
   paddingY: footerSpacing.optional(),
   paddingX: footerSpacing.optional(),
-  borderTop: z17.object({
+  borderTop: z22.object({
     colorToken: themeColorTokenSchema.nullable().optional(),
-    width: z17.enum(["none", "thin", "medium", "thick"]).optional()
+    width: z22.enum(["none", "thin", "medium", "thick"]).optional()
   }).optional()
 });
-var footerNavLayoutSchema = z17.object({
+var footerNavLayoutSchema = z22.object({
   layout: footerNavLayoutMode.optional(),
   align: footerNavLayoutAlign.optional(),
   gapX: footerSpacing.optional(),
   gapY: footerSpacing.optional(),
-  columns: z17.number().int().min(1).max(6).optional()
+  columns: z22.number().int().min(1).max(6).optional()
 });
-var footerLogoSchema = z17.object({
-  showLogo: z17.boolean().default(true),
-  showLogoText: z17.boolean().optional(),
+var footerLogoSchema = z22.object({
+  showLogo: z22.boolean().default(true),
+  showLogoText: z22.boolean().optional(),
   placement: footerLogoPlacement.optional(),
   size: footerLogoSize.optional(),
   maxHeight: footerLogoMaxHeight.optional(),
-  align: z17.enum(["start", "center", "end"]).optional()
+  align: z22.enum(["start", "center", "end"]).optional()
 });
-var footerSchema = z17.object({
+var footerSchema = z22.object({
   /**
    * SDK-only footer rendering mode.
    *
@@ -7583,7 +8069,7 @@ var footerSchema = z17.object({
   mode: footerMode.optional(),
   variant: footerVariant,
   maxWidth: footerMaxWidth,
-  showLogoText: z17.boolean().optional(),
+  showLogoText: z22.boolean().optional(),
   background: headerBackgroundSchema.default({
     type: "color",
     color: "surface"
@@ -7601,20 +8087,20 @@ var footerSchema = z17.object({
   logo: footerLogoSchema.optional(),
   bottomBar: footerBottomBarSchema.optional()
 });
-var containerPaddingPresetSchema = z17.enum([
+var containerPaddingPresetSchema = z22.enum([
   "tight",
   "compact",
   "default",
   "relaxed"
 ]);
-var layoutSchema = z17.object({
-  containerPadding: z17.object({
+var layoutSchema = z22.object({
+  containerPadding: z22.object({
     mobile: containerPaddingPresetSchema.optional(),
     tablet: containerPaddingPresetSchema.optional(),
     desktop: containerPaddingPresetSchema.optional()
   }).optional()
 }).optional();
-var heroTypographySizeSchema = z17.enum([
+var heroTypographySizeSchema = z22.enum([
   "sm",
   "base",
   "lg",
@@ -7626,19 +8112,19 @@ var heroTypographySizeSchema = z17.enum([
   "6xl",
   "editorial"
 ]);
-var heroTypographyLineHeightSchema = z17.enum([
+var heroTypographyLineHeightSchema = z22.enum([
   "tight",
   "snug",
   "normal",
   "relaxed"
 ]);
-var heroResponsiveTypographySchema = z17.object({
+var heroResponsiveTypographySchema = z22.object({
   headlineSize: heroTypographySizeSchema.optional(),
   headlineLineHeight: heroTypographyLineHeightSchema.optional(),
   subheadlineSize: heroTypographySizeSchema.optional(),
   subheadlineLineHeight: heroTypographyLineHeightSchema.optional()
 });
-var heroTypographySchema = z17.object({
+var heroTypographySchema = z22.object({
   headlineSize: heroTypographySizeSchema.optional(),
   headlineLineHeight: heroTypographyLineHeightSchema.optional(),
   subheadlineSize: heroTypographySizeSchema.optional(),
@@ -7647,38 +8133,38 @@ var heroTypographySchema = z17.object({
   microHeadlineLineHeight: heroTypographyLineHeightSchema.optional(),
   microSubheadlineSize: heroTypographySizeSchema.optional(),
   microSubheadlineLineHeight: heroTypographyLineHeightSchema.optional(),
-  responsive: z17.object({
+  responsive: z22.object({
     tablet: heroResponsiveTypographySchema.optional(),
     mobile: heroResponsiveTypographySchema.optional()
   }).optional()
 });
-var heroSchema = z17.object({
+var heroSchema = z22.object({
   typography: heroTypographySchema.optional()
 }).optional();
-var bodyTextIntroTypographySizeSchema = z17.enum(["default", "editorial"]);
-var bodyTextSchema = z17.object({
-  intro: z17.object({
+var bodyTextIntroTypographySizeSchema = z22.enum(["default", "editorial"]);
+var bodyTextSchema = z22.object({
+  intro: z22.object({
     paragraphSize: bodyTextIntroTypographySizeSchema.optional(),
     headingSize: bodyTextIntroTypographySizeSchema.optional()
   }).optional()
 }).optional();
-var gradientsSchema = z17.object({
-  button: z17.string().min(1).nullable().optional(),
-  hero: z17.string().min(1).nullable().optional(),
-  background: z17.string().min(1).nullable().optional()
+var gradientsSchema = z22.object({
+  button: z22.string().min(1).nullable().optional(),
+  hero: z22.string().min(1).nullable().optional(),
+  background: z22.string().min(1).nullable().optional()
 });
-var testimonialQuoteTreatmentSchema = z17.object({
-  style: z17.enum(["serif-display", "accent-glyph", "none"]),
-  fontFamily: z17.enum(["heading", "body"]).optional(),
-  scale: z17.enum(["sm", "md", "lg", "xl"]).optional(),
+var testimonialQuoteTreatmentSchema = z22.object({
+  style: z22.enum(["serif-display", "accent-glyph", "none"]),
+  fontFamily: z22.enum(["heading", "body"]).optional(),
+  scale: z22.enum(["sm", "md", "lg", "xl"]).optional(),
   colorToken: themeColorTokenSchema.optional(),
-  opacity: z17.number().min(0).max(1).optional()
+  opacity: z22.number().min(0).max(1).optional()
 });
-var themeSchema = z17.object({
-  name: z17.string().min(1).max(30),
-  description: z17.string().min(1).max(400),
-  rationale: z17.string().min(1).max(400),
-  siteStyleId: z17.string().min(1).transform((value) => asSiteStyleId(value)).optional(),
+var themeSchema = z22.object({
+  name: z22.string().min(1).max(30),
+  description: z22.string().min(1).max(400),
+  rationale: z22.string().min(1).max(400),
+  siteStyleId: z22.string().min(1).transform((value) => asSiteStyleId(value)).optional(),
   axes: axesSchema,
   palette: paletteSchema,
   typography: typographySchema,
@@ -7708,15 +8194,15 @@ var themeSchema = z17.object({
   // Block-specific customization (Tier 3)
   // blockCustomVars: Per-block CSS variable overrides as bare values
   // Example: { "event-registration": { "--step-color": "#6d28d9" } }
-  blockCustomVars: z17.record(
-    z17.string(),
+  blockCustomVars: z22.record(
+    z22.string(),
     // block kind (matches data-block attribute)
-    z17.record(z17.string(), z17.string())
+    z22.record(z22.string(), z22.string())
     // { '--var-name': 'value' }
   ).optional(),
   // Structured block-kind theme overrides (v1: typography prose-link style only)
   // Keyed by block kind (usually data-block value like "hero"; "block.hero" also accepted)
-  blockOverrides: z17.record(z17.string(), blockThemeOverrideSchema).optional(),
+  blockOverrides: z22.record(z22.string(), blockThemeOverrideSchema).optional(),
   // Site-wide heading decoration signature (family + colour). Set once per Look
   // and projected transiently onto eligible block headings at render time.
   // Alignment is inherited from the heading, so no placement is stored.
@@ -7754,11 +8240,11 @@ var themeSchema = z17.object({
    * }
    * ```
    */
-  styleGroups: z17.record(z17.string(), z17.array(z17.string())).optional()
+  styleGroups: z22.record(z22.string(), z22.array(z22.string())).optional()
 });
-var themesTurnSchema = z17.object({
-  message: z17.string().min(1),
-  themes: z17.array(themeSchema).length(3)
+var themesTurnSchema = z22.object({
+  message: z22.string().min(1),
+  themes: z22.array(themeSchema).length(3)
 });
 
 // ../theme-core/src/palette/variants/types.ts
@@ -7768,19 +8254,19 @@ function asPaletteVariantId(value) {
   }
   return value;
 }
-var paletteVariantIdSchema = z18.string().min(1).transform((value) => asPaletteVariantId(value));
+var paletteVariantIdSchema = z23.string().min(1).transform((value) => asPaletteVariantId(value));
 var HEX_COLOR_REGEX = /^#[0-9a-f]{6}$/;
-var hexColorSchema = z18.string().regex(HEX_COLOR_REGEX, "Hex must be #RRGGBB (lowercase)").transform((value) => value);
+var hexColorSchema = z23.string().regex(HEX_COLOR_REGEX, "Hex must be #RRGGBB (lowercase)").transform((value) => value);
 var variantPaletteColorSchema = paletteColorSchema.extend({
   name: paletteTokenNameSchema
 });
-var paletteVariantSchema = z18.object({
+var paletteVariantSchema = z23.object({
   id: paletteVariantIdSchema,
-  name: z18.string().min(1),
-  description: z18.string().min(1),
+  name: z23.string().min(1),
+  description: z23.string().min(1),
   tags: styleTagsSchema,
-  mode: z18.enum(["light", "dark"]),
-  colors: z18.array(variantPaletteColorSchema).min(1)
+  mode: z23.enum(["light", "dark"]),
+  colors: z23.array(variantPaletteColorSchema).min(1)
 });
 function definePaletteVariant(input) {
   return {
@@ -7792,7 +8278,7 @@ function definePaletteVariant(input) {
     colors: input.colors
   };
 }
-var paletteOverridesSchema = z18.object({
+var paletteOverridesSchema = z23.object({
   primary: hexColorSchema.optional(),
   primaryForeground: hexColorSchema.optional(),
   secondary: hexColorSchema.optional(),
@@ -10194,66 +10680,66 @@ var typographyPresetsById = new Map(
 );
 
 // ../theme-core/src/site-styles/designState.ts
-import { z as z19 } from "zod";
+import { z as z24 } 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) => [
+var designResolutionPolicySchema = z24.enum(["generated", "user", "admin", "sdk"]);
+var runtimeStyleFieldNameSchema = z24.enum(themeV2RuntimeStyleFieldNames);
+var nonEmptyRuntimeStyleFieldNamesSchema = z24.array(runtimeStyleFieldNameSchema).min(1).transform((fields) => [
   fields[0],
   ...fields.slice(1)
 ]);
-var heroLegibilityStrategySchema = z19.enum([
+var heroLegibilityStrategySchema = z24.enum([
   "none",
   "scrim-gradient",
   "solid-panel"
 ]);
-var heroCompositionIntentSchema = z19.enum([
+var heroCompositionIntentSchema = z24.enum([
   "center",
   "bottom-left"
 ]);
-var heroTypographyScaleIntentSchema = z19.enum([
+var heroTypographyScaleIntentSchema = z24.enum([
   "quiet",
   "editorial",
   "display",
   "poster"
 ]);
-var sectionHeightIntentSchema = z19.enum([
+var sectionHeightIntentSchema = z24.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"]),
+var imageSurfaceTreatmentIntensitySchema = z24.enum(["soft", "balanced", "strong"]);
+var imageSurfaceMotionSchema = z24.enum(["static", "fixed-frame"]);
+var imageSurfaceTreatmentSchema = z24.discriminatedUnion("kind", [
+  z24.object({ kind: z24.literal("none") }).strict(),
+  z24.object({
+    kind: z24.literal("brand-scrim"),
+    token: z24.enum(["primary", "secondary", "accent"]),
     intensity: imageSurfaceTreatmentIntensitySchema.optional()
   }).strict(),
-  z19.object({
-    kind: z19.literal("brand-wash"),
-    token: z19.enum(["primary", "secondary", "accent"]),
+  z24.object({
+    kind: z24.literal("brand-wash"),
+    token: z24.enum(["primary", "secondary", "accent"]),
     intensity: imageSurfaceTreatmentIntensitySchema.optional()
   }).strict(),
-  z19.object({
-    kind: z19.literal("neutral-scrim"),
+  z24.object({
+    kind: z24.literal("neutral-scrim"),
     intensity: imageSurfaceTreatmentIntensitySchema.optional()
   }).strict(),
-  z19.object({
-    kind: z19.literal("neutral-wash"),
+  z24.object({
+    kind: z24.literal("neutral-wash"),
     intensity: imageSurfaceTreatmentIntensitySchema.optional()
   }).strict(),
-  z19.object({
-    kind: z19.literal("solid-panel"),
+  z24.object({
+    kind: z24.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);
+var testimonialCardTreatmentSchema = z24.enum(["default", "accent-quote"]);
+var tileTreatmentSchema = z24.enum(tileTreatmentValues);
+var eventListTreatmentSchema = z24.enum(eventListTreatmentValues);
+var eyebrowTreatmentSchema = z24.enum(eyebrowTreatmentValues);
 function uniqueNonEmpty(values) {
   const uniqueValues = [...new Set(values)];
   const firstValue = uniqueValues[0];
@@ -10271,27 +10757,27 @@ var userFlushTreatments = uniqueNonEmpty(
 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)
+var contentFrameIntentSchema = z24.discriminatedUnion("kind", [
+  z24.object({ kind: z24.literal("plain") }).strict(),
+  z24.object({
+    kind: z24.literal("panel"),
+    treatment: z24.enum(userPanelTreatments)
   }).strict(),
-  z19.object({
-    kind: z19.literal("flush-panel"),
-    treatment: z19.enum(userFlushTreatments),
-    bleed: z19.enum(userFlushBleeds)
+  z24.object({
+    kind: z24.literal("flush-panel"),
+    treatment: z24.enum(userFlushTreatments),
+    bleed: z24.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),
+var blockDesignPlanSchema = z24.object({
+  blockId: z24.string().min(1).transform(asDesignBlockId),
+  blockKind: z24.string().min(1),
+  purpose: z24.string().min(1),
+  sectionSurface: z24.enum(userDesignOptionCatalog.sectionSurfaces),
   contentFrame: contentFrameIntentSchema,
-  itemSurface: z19.enum(userDesignOptionCatalog.itemSurfaces),
-  transitionAfter: z19.enum(userDesignOptionCatalog.transitions),
-  emphasis: z19.enum(userDesignOptionCatalog.emphases),
+  itemSurface: z24.enum(userDesignOptionCatalog.itemSurfaces),
+  transitionAfter: z24.enum(userDesignOptionCatalog.transitions),
+  emphasis: z24.enum(userDesignOptionCatalog.emphases),
   sectionHeight: sectionHeightIntentSchema.optional(),
   heroLegibility: heroLegibilityStrategySchema.optional(),
   heroComposition: heroCompositionIntentSchema.optional(),
@@ -10303,39 +10789,39 @@ var blockDesignPlanSchema = z19.object({
   eventListTreatment: eventListTreatmentSchema.optional(),
   eyebrowTreatment: eyebrowTreatmentSchema.optional()
 }).strict();
-var styleAuthoritySchema = z19.discriminatedUnion("kind", [
-  z19.object({
-    kind: z19.literal("theme-v2"),
+var styleAuthoritySchema = z24.discriminatedUnion("kind", [
+  z24.object({
+    kind: z24.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()
+    siteStyleId: z24.string().min(1).transform(asSiteStyleId),
+    templateId: z24.string().min(1).transform(asDesignSystemTemplateId),
+    templateVersion: z24.number().int().nonnegative(),
+    resolverVersion: z24.number().int().nonnegative()
   }).strict(),
-  z19.object({
-    kind: z19.literal("legacy-raw"),
-    reason: z19.enum(["pre-theme-v2", "manual-runtime-fields"])
+  z24.object({
+    kind: z24.literal("legacy-raw"),
+    reason: z24.enum(["pre-theme-v2", "manual-runtime-fields"])
   }).strict(),
-  z19.object({
-    kind: z19.literal("advanced-detached"),
-    reason: z19.literal("detached-custom-runtime-fields")
+  z24.object({
+    kind: z24.literal("advanced-detached"),
+    reason: z24.literal("detached-custom-runtime-fields")
   }).strict()
 ]);
-var blockRuntimeStyleAuthoritySchema = z19.object({
-  unit: z19.literal("block-runtime-fields"),
-  blockId: z19.string().min(1).transform(asDesignBlockId),
+var blockRuntimeStyleAuthoritySchema = z24.object({
+  unit: z24.literal("block-runtime-fields"),
+  blockId: z24.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)
+var persistedPageDesignStateV1Schema = z24.object({
+  schemaVersion: z24.literal(themeV2DesignStateSchemaVersion),
+  siteStyleId: z24.string().min(1).transform(asSiteStyleId),
+  templateId: z24.string().min(1).transform(asDesignSystemTemplateId),
+  templateVersion: z24.number().int().nonnegative(),
+  resolverVersion: z24.number().int().nonnegative(),
+  rhythmPresetId: z24.string().min(1),
+  blocks: z24.array(blockDesignPlanSchema),
+  styleAuthorities: z24.array(blockRuntimeStyleAuthoritySchema)
 }).strict();
 
 // ../theme-core/src/site-styles/runtimeCompiler.ts
@@ -11844,7 +12330,7 @@ function findEventByOccurrenceId(events, occurrenceId) {
 function findPreSelectedEvent(input) {
   const occurrenceContext = input.occurrenceContext;
   if (!occurrenceContext) {
-    return null;
+    return input.scopedEvents.length === 1 ? input.scopedEvents[0] ?? null : null;
   }
   const contextDate = getBookingLocalDateKey(toScheduledBookingDateTime({
     startsAt: occurrenceContext.startsAt,
@@ -11877,7 +12363,7 @@ function resolveEventRequiresPayment(input) {
   if (!input.event) {
     return false;
   }
-  return publicEventPricingType(resolveRuntimeEventPricing(input.event)) !== "free";
+  return publicEventPricingType(resolveRuntimeEventPricing(input.event)) === "paid";
 }
 function resolveDiscountContext(input) {
   const selection = input.paymentSelection.method ? input.paymentSelection : null;
@@ -11950,11 +12436,10 @@ function FeedbackMessage({
 }
 
 // ../blocks/src/system/runtime/nodes/booking-form.client.tsx
-import React3, { useRef as useRef7, useState as useState3 } from "react";
+import React3, { useRef as useRef8, useState as useState2 } from "react";
 
 // ../altcha/src/AltchaWidget.tsx
-import { useEffect, useRef } from "react";
-import { jsx as jsx4 } from "react/jsx-runtime";
+import { createElement, useEffect, useRef } from "react";
 function AltchaWidget({
   challengeUrl,
   onSolutionChange,
@@ -11998,7 +12483,7 @@ function AltchaWidget({
       }
     };
   }, [challengeUrl, auto, hidelogo, className, onSolutionChange]);
-  return /* @__PURE__ */ jsx4("div", { ref: containerRef });
+  return createElement("div", { ref: containerRef });
 }
 
 // ../altcha/src/client.ts
@@ -12007,13 +12492,13 @@ function isSpamProtectionEnabled() {
 }
 
 // ../blocks/src/system/runtime/components/booking/SuccessMessage.tsx
-import { Fragment, jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+import { Fragment, jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
 var SuccessMessage = ({
   message,
   resourceName,
   className
 }) => {
-  return /* @__PURE__ */ jsx5(
+  return /* @__PURE__ */ jsx4(
     FeedbackMessage,
     {
       tone: "success",
@@ -12021,7 +12506,7 @@ var SuccessMessage = ({
       role: "alert",
       live: "polite",
       children: /* @__PURE__ */ jsxs3(Fragment, { children: [
-        /* @__PURE__ */ jsx5("p", { className: "ab-text", children: message }),
+        /* @__PURE__ */ jsx4("p", { className: "ab-text", children: message }),
         resourceName ? /* @__PURE__ */ jsxs3("p", { className: "ab-text ab-text--muted", children: [
           "Practitioner: ",
           resourceName
@@ -12037,9 +12522,9 @@ import React2, {
   useEffect as useEffect6,
   useLayoutEffect,
   useMemo as useMemo2,
-  useReducer as useReducer4,
-  useRef as useRef5,
-  useState as useState2
+  useReducer as useReducer5,
+  useRef as useRef6,
+  useState
 } from "react";
 
 // ../../node_modules/.pnpm/altcha-lib@1.4.1/node_modules/altcha-lib/dist/helpers.js
@@ -12240,7 +12725,7 @@ function availableDatesReducer(state, action) {
     case "load-failed":
       return { tag: "error", data: state.data, message: action.message };
     default:
-      return assertNever11(action);
+      return assertNever4(action);
   }
 }
 
@@ -12364,7 +12849,7 @@ function getAvailableSlots(state) {
     case "error":
       return state.slots;
     default:
-      return assertNever11(state);
+      return assertNever4(state);
   }
 }
 function hasLoadedAvailableSlots(state) {
@@ -12378,7 +12863,7 @@ function hasLoadedAvailableSlots(state) {
     case "loaded":
       return true;
     default:
-      return assertNever11(state);
+      return assertNever4(state);
   }
 }
 function isLoadingAvailableSlots(state) {
@@ -12412,7 +12897,7 @@ function availableSlotsReducer(state, action) {
         message: action.message
       };
     default:
-      return assertNever11(action);
+      return assertNever4(action);
   }
 }
 
@@ -12521,7 +13006,7 @@ function bookingSubmissionReducer(state, action) {
     case "feedback-cleared":
       return clearWorkflowFeedback(state);
     default:
-      return assertNever11(action);
+      return assertNever4(action);
   }
 }
 function selectIsSubmitting(state) {
@@ -12565,7 +13050,7 @@ function useBookingSubmission(_siteId) {
         type: "submission-succeeded",
         message: response.type === "checkout_redirect" ? "Redirecting to secure checkout..." : "Booking submitted successfully."
       });
-      return okWith2(response);
+      return okWith(response);
     } catch (error) {
       console.error("Booking submission error:", error);
       const message = error instanceof Error ? error.message : "Failed to book appointment";
@@ -12586,65 +13071,157 @@ function useBookingSubmission(_siteId) {
 }
 
 // ../blocks/src/system/runtime/nodes/event-registration/useDiscountCodeUi.ts
-import { useEffect as useEffect5, useState } from "react";
+import { useEffect as useEffect5, useReducer as useReducer4, useRef as useRef5 } from "react";
+
+// ../blocks/src/system/runtime/nodes/event-registration/useDiscountCodeUi.state.ts
+var initialDiscountCodeUiState = {
+  discountUiOpen: false,
+  discountCode: "",
+  availability: { tag: "disabled" }
+};
+function getDiscountContextKey(context) {
+  if (!context) return "disabled";
+  switch (context.type) {
+    case "event":
+      return [
+        context.type,
+        context.eventSeriesId,
+        context.eventCategoryId ?? "",
+        context.ticketsCount ?? ""
+      ].join(":");
+    case "appointment":
+      return [context.type, context.serviceId].join(":");
+    case "course":
+      return [context.type, context.courseId].join(":");
+    case "pass":
+      return [context.type, context.passId].join(":");
+    case "membership":
+      return [context.type, context.membershipId].join(":");
+    case "product":
+      return [context.type, context.productId, context.productCategoryId ?? ""].join(":");
+  }
+}
+function buildDiscountAvailabilityRequestPlan(options) {
+  if (!options.discountContext) {
+    return { ok: false, key: "disabled" };
+  }
+  const subtotalCents = options.subtotalCents;
+  const key = [
+    getDiscountContextKey(options.discountContext),
+    subtotalCents ?? ""
+  ].join("|");
+  return {
+    ok: true,
+    key,
+    request: {
+      context: options.discountContext,
+      ...subtotalCents !== void 0 ? { subtotalCents } : {}
+    }
+  };
+}
+function discountAvailabilityStateFromResponse(response) {
+  if (!discountAvailabilityHasDiscounts(response)) {
+    return { tag: "unavailable" };
+  }
+  return {
+    tag: "available",
+    manualCodeEntryAllowed: discountAvailabilityAllowsManualEntry(response),
+    autoAppliedDiscount: getAutoAppliedDiscountPreview(response)
+  };
+}
+function discountCodeUiReducer(state, event) {
+  switch (event.type) {
+    case "availability-disabled":
+      return initialDiscountCodeUiState;
+    case "availability-loading":
+      return {
+        ...state,
+        availability: { tag: "loading" }
+      };
+    case "availability-loaded": {
+      const availability = discountAvailabilityStateFromResponse(event.response);
+      if (availability.tag !== "available" || !availability.manualCodeEntryAllowed) {
+        return {
+          ...state,
+          discountUiOpen: false,
+          discountCode: "",
+          availability
+        };
+      }
+      return {
+        ...state,
+        availability
+      };
+    }
+    case "availability-failed":
+      return {
+        ...state,
+        discountUiOpen: false,
+        discountCode: "",
+        availability: { tag: "error" }
+      };
+    case "discount-code-changed":
+      return {
+        ...state,
+        discountCode: event.code
+      };
+    case "discount-ui-open-changed":
+      return {
+        ...state,
+        discountUiOpen: event.isOpen
+      };
+  }
+}
+
+// ../blocks/src/system/runtime/nodes/event-registration/useDiscountCodeUi.ts
+function useStableDiscountAvailabilityRequestPlan(options) {
+  const nextPlan = buildDiscountAvailabilityRequestPlan(options);
+  const planRef = useRef5(nextPlan);
+  if (planRef.current.key !== nextPlan.key) {
+    planRef.current = nextPlan;
+  }
+  return planRef.current;
+}
 function useDiscountCodeUi(options) {
-  const [discountUiOpen, setDiscountUiOpen] = useState(false);
-  const [discountCode, setDiscountCode] = useState("");
-  const [discountsAvailable, setDiscountsAvailable] = useState(false);
-  const [manualCodeEntryAllowed, setManualCodeEntryAllowed] = useState(false);
-  const [autoAppliedDiscount, setAutoAppliedDiscount] = useState(null);
-  const [discountsAvailableLoading, setDiscountsAvailableLoading] = useState(false);
+  const [state, dispatch] = useReducer4(
+    discountCodeUiReducer,
+    initialDiscountCodeUiState
+  );
+  const requestPlan = useStableDiscountAvailabilityRequestPlan(options);
   useEffect5(() => {
     let cancelled = false;
     async function checkDiscountAvailability() {
-      if (!options.discountContext) {
-        setDiscountsAvailable(false);
-        setManualCodeEntryAllowed(false);
-        setAutoAppliedDiscount(null);
-        setDiscountsAvailableLoading(false);
-        setDiscountUiOpen(false);
-        setDiscountCode("");
+      if (!requestPlan.ok) {
+        dispatch({ type: "availability-disabled" });
         return;
       }
-      setDiscountsAvailableLoading(true);
+      dispatch({ type: "availability-loading" });
       try {
-        const res = await options.api.getDiscountsAvailable({
-          context: options.discountContext,
-          subtotalCents: options.subtotalCents
-        });
+        const res = await options.api.getDiscountsAvailable(requestPlan.request);
         if (cancelled) return;
-        setDiscountsAvailable(res.hasDiscounts);
-        setManualCodeEntryAllowed(res.manualCodeEntryAllowed);
-        setAutoAppliedDiscount(res.autoAppliedDiscount);
-        if (!res.hasDiscounts || !res.manualCodeEntryAllowed) {
-          setDiscountUiOpen(false);
-          setDiscountCode("");
-        }
+        dispatch({ type: "availability-loaded", response: res });
       } catch {
         if (cancelled) return;
-        setDiscountsAvailable(false);
-        setManualCodeEntryAllowed(false);
-        setAutoAppliedDiscount(null);
-        setDiscountUiOpen(false);
-        setDiscountCode("");
-      } finally {
-        if (!cancelled) setDiscountsAvailableLoading(false);
+        dispatch({ type: "availability-failed" });
       }
     }
     void checkDiscountAvailability();
     return () => {
       cancelled = true;
     };
-  }, [options.api, options.discountContext, options.subtotalCents]);
+  }, [options.api, requestPlan]);
+  const availability = state.availability;
+  const isAvailable = availability.tag === "available";
+  const manualCodeEntryAllowed = isAvailable ? availability.manualCodeEntryAllowed : false;
   return {
-    discountUiOpen,
-    setDiscountUiOpen,
-    discountCode,
-    setDiscountCode,
-    discountsAvailable,
+    discountUiOpen: state.discountUiOpen,
+    setDiscountUiOpen: (isOpen) => dispatch({ type: "discount-ui-open-changed", isOpen }),
+    discountCode: state.discountCode,
+    setDiscountCode: (code) => dispatch({ type: "discount-code-changed", code }),
+    discountsAvailable: isAvailable,
     manualCodeEntryAllowed,
-    autoAppliedDiscount,
-    discountsAvailableLoading
+    autoAppliedDiscount: isAvailable ? availability.autoAppliedDiscount : null,
+    discountsAvailableLoading: availability.tag === "loading"
   };
 }
 
@@ -12798,8 +13375,10 @@ function buildBookingPaymentOptionViewModel(input) {
         totalAmountCents: input.totalCents,
         config: input.option.config
       });
+      const remainingBalance = Math.max(0, input.totalCents - dueToday);
       const formattedTotal = formatPrice(input.totalCents, input.currency, input.locale);
       const formattedDueToday = formatPrice(dueToday, input.currency, input.locale);
+      const formattedRemainingBalance = formatPrice(remainingBalance, input.currency, input.locale);
       const dueAt = resolveFlexibleBalanceDueAt({
         bookingStartAt: input.bookingStartAt ?? (/* @__PURE__ */ new Date()).toISOString(),
         dueDateRule: input.option.config.dueDateRule
@@ -12816,6 +13395,7 @@ function buildBookingPaymentOptionViewModel(input) {
         summaryRows: [
           { label: "Total", value: formattedTotal },
           { label: "Due today", value: formattedDueToday },
+          { label: "Remaining balance", value: formattedRemainingBalance },
           { label: "Balance due by", value: formatScheduleDate(dueAt, input.locale) },
           {
             label: "Deposit policy",
@@ -12827,7 +13407,7 @@ function buildBookingPaymentOptionViewModel(input) {
       };
     }
     default:
-      return assertNever11(input.option);
+      return assertNever4(input.option);
   }
 }
 function buildInstalmentSchedulePreview(input) {
@@ -12884,7 +13464,7 @@ function buildInstalmentSchedulePreview(input) {
       })));
     }
     default:
-      return assertNever11(input.option.plan);
+      return assertNever4(input.option.plan);
   }
 }
 function getPaymentCadenceLabel(plan) {
@@ -13111,7 +13691,7 @@ function bookingFlowReducer(state, event) {
     case "reset":
       return event.initial;
     default:
-      return assertNever11(event);
+      return assertNever4(event);
   }
 }
 function clearAvailabilityFeedback(feedback) {
@@ -13240,7 +13820,7 @@ function validateBookingStep(input) {
       return Object.keys(errors).length > 0 ? { ok: false, errors: createFieldBookingValidationErrors(errors) } : { ok: true };
     }
     default:
-      return assertNever11(input.stepId);
+      return assertNever4(input.stepId);
   }
 }
 function validateBookingFields(input) {
@@ -13601,7 +14181,7 @@ function resolveAppointmentPackagesModel(input) {
       };
     }
     default:
-      return assertNever11(input.state);
+      return assertNever4(input.state);
   }
 }
 function toHeadlessEligibleAppointmentPackage(appointmentPackage) {
@@ -13665,7 +14245,7 @@ function omitRecordKey(record, key) {
   return rest;
 }
 function readAppointmentBookingOverrideData(value) {
-  if (!isRecord4(value)) return null;
+  if (!isRecord5(value)) return null;
   const services = normalizeBookingServices(value.services);
   return {
     form: normalizeBookingFormConfig(value.form),
@@ -13678,7 +14258,7 @@ function createOverrideInputError(reason, message, warnInDev = false) {
   }
   return { ok: false, reason, message };
 }
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null;
 }
 
@@ -13706,12 +14286,12 @@ function useHeadlessBookingFlow(options) {
     }),
     [defaultResourceId, defaultServiceId, options.initialData]
   );
-  const [state, dispatch] = useReducer4(bookingFlowReducer, initialState);
+  const [state, dispatch] = useReducer5(bookingFlowReducer, initialState);
   const api = useBlockApi();
-  const [resourcesState, setResourcesState] = useState2({ tag: "idle" });
-  const resourcesRequestIdRef = useRef5(0);
-  const [appointmentPackages, setAppointmentPackages] = useState2({ tag: "idle" });
-  const appointmentPackagesRequestIdRef = useRef5(0);
+  const [resourcesState, setResourcesState] = useState({ tag: "idle" });
+  const resourcesRequestIdRef = useRef6(0);
+  const [appointmentPackages, setAppointmentPackages] = useState({ tag: "idle" });
+  const appointmentPackagesRequestIdRef = useRef6(0);
   const selectedServiceId = state.selectedServiceId ?? defaultServiceId;
   const selectedResourceId = state.selectedResourceId ?? defaultResourceId;
   const selectedService = options.services.find((service) => service.id === selectedServiceId) ?? null;
@@ -13948,14 +14528,17 @@ function useHeadlessBookingFlow(options) {
     state.selectedDate,
     state.selectedSlot
   ]);
-  const appointmentDiscountContext = selectedService && (selectedService.priceAmount ?? 0) > 0 ? { type: "appointment", serviceId: selectedService.id } : null;
+  const appointmentDiscountContext = useMemo2(
+    () => selectedService && (selectedService.priceAmount ?? 0) > 0 ? { type: "appointment", serviceId: selectedService.id } : null,
+    [selectedService?.id, selectedService?.priceAmount]
+  );
   const discountUi = useDiscountCodeUi({
     api,
     discountContext: appointmentDiscountContext,
     subtotalCents: selectedService?.priceAmount ?? 0
   });
   const { submit, clearFeedback } = useBookingSubmission(options.siteId);
-  const submittingRef = useRef5(false);
+  const submittingRef = useRef6(false);
   const latestRef = useLatestRef({
     state,
     data,
@@ -14272,7 +14855,7 @@ function resolvePaymentMode(input) {
   return resolveBookingPaymentStep(input);
 }
 function useLatestRef(value) {
-  const ref = useRef5(value);
+  const ref = useRef6(value);
   useLayoutEffect(() => {
     ref.current = value;
   }, [value]);
@@ -14283,7 +14866,7 @@ function useLatestRef(value) {
 import { useMemo as useMemo3 } from "react";
 
 // ../blocks/src/system/runtime/hooks/usePolling.ts
-import { useEffect as useEffect7, useCallback as useCallback4, useReducer as useReducer5, useRef as useRef6 } from "react";
+import { useEffect as useEffect7, useCallback as useCallback4, useReducer as useReducer6, useRef as useRef7 } from "react";
 
 // ../blocks/src/system/runtime/hooks/usePolling.state.ts
 function createInitialPollingState() {
@@ -14340,7 +14923,7 @@ function pollingReducer(state, action) {
         case "timeout":
           return state;
         default:
-          return assertNever11(state);
+          return assertNever4(state);
       }
     case "polling-timed-out":
       return {
@@ -14349,7 +14932,7 @@ function pollingReducer(state, action) {
         error: new Error("Polling timed out")
       };
     default:
-      return assertNever11(action);
+      return assertNever4(action);
   }
 }
 
@@ -14357,17 +14940,17 @@ function pollingReducer(state, action) {
 var DEFAULT_MAX_ATTEMPTS = 10;
 var DEFAULT_POLL_INTERVAL = 1e3;
 function usePolling(config) {
-  const [state, dispatch] = useReducer5(
+  const [state, dispatch] = useReducer6(
     pollingReducer,
     void 0,
     createInitialPollingState
   );
-  const attemptsRef = useRef6(0);
-  const timeoutRef = useRef6(null);
-  const isPollingRef = useRef6(false);
-  const isActiveRef = useRef6(false);
-  const generationRef = useRef6(0);
-  const configRef = useRef6(config);
+  const attemptsRef = useRef7(0);
+  const timeoutRef = useRef7(null);
+  const isPollingRef = useRef7(false);
+  const isActiveRef = useRef7(false);
+  const generationRef = useRef7(0);
+  const configRef = useRef7(config);
   configRef.current = config;
   const cleanup = useCallback4(() => {
     isActiveRef.current = false;
@@ -14491,7 +15074,7 @@ function useAppointmentCheckoutVerification(config) {
 }
 
 // ../blocks/src/system/runtime/components/booking/DatePicker.tsx
-import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
 var DatePicker = ({
   value,
   onChange,
@@ -14506,21 +15089,21 @@ var DatePicker = ({
     return /* @__PURE__ */ jsxs4("div", { className: "ab-stack--sm", children: [
       /* @__PURE__ */ jsxs4("label", { className: "ab-label", children: [
         "Select Date",
-        required && /* @__PURE__ */ jsx6("span", { className: "ab-required", children: "*" })
+        required && /* @__PURE__ */ jsx5("span", { className: "ab-required", children: "*" })
       ] }),
-      /* @__PURE__ */ jsx6("div", { className: "ab-skeleton" }),
-      /* @__PURE__ */ jsx6("p", { className: "ab-text ab-text--muted ab-text--sm", children: "Loading available dates..." })
+      /* @__PURE__ */ jsx5("div", { className: "ab-skeleton" }),
+      /* @__PURE__ */ jsx5("p", { className: "ab-text ab-text--muted ab-text--sm", children: "Loading available dates..." })
     ] });
   }
   if (isEmpty) {
     return /* @__PURE__ */ jsxs4("div", { className: "ab-stack--sm", children: [
       /* @__PURE__ */ jsxs4("label", { className: "ab-label", children: [
         "Select Date",
-        required && /* @__PURE__ */ jsx6("span", { className: "ab-required", children: "*" })
+        required && /* @__PURE__ */ jsx5("span", { className: "ab-required", children: "*" })
       ] }),
-      /* @__PURE__ */ jsx6(FeedbackMessage, { tone: "warning", className: "ab-alert ab-alert--warning", role: "status", children: /* @__PURE__ */ jsxs4("p", { className: "ab-text", children: [
+      /* @__PURE__ */ jsx5(FeedbackMessage, { tone: "warning", className: "ab-alert ab-alert--warning", role: "status", children: /* @__PURE__ */ jsxs4("p", { className: "ab-text", children: [
         "No available dates in this period.",
-        hasMore && onLoadMore && /* @__PURE__ */ jsx6(
+        hasMore && onLoadMore && /* @__PURE__ */ jsx5(
           "button",
           {
             type: "button",
@@ -14535,7 +15118,7 @@ var DatePicker = ({
   return /* @__PURE__ */ jsxs4("div", { className: "ab-stack--sm", children: [
     /* @__PURE__ */ jsxs4("label", { htmlFor: "booking-date", className: "ab-label", children: [
       "Select Date",
-      required && /* @__PURE__ */ jsx6("span", { className: "ab-required", children: "*" })
+      required && /* @__PURE__ */ jsx5("span", { className: "ab-required", children: "*" })
     ] }),
     /* @__PURE__ */ jsxs4(
       "select",
@@ -14546,12 +15129,12 @@ var DatePicker = ({
         required,
         className: "ab-select",
         children: [
-          /* @__PURE__ */ jsx6("option", { value: "", children: "Choose a date..." }),
-          dateOptions.map((date) => /* @__PURE__ */ jsx6("option", { value: date, children: formatDate(date) }, date))
+          /* @__PURE__ */ jsx5("option", { value: "", children: "Choose a date..." }),
+          dateOptions.map((date) => /* @__PURE__ */ jsx5("option", { value: date, children: formatDate(date) }, date))
         ]
       }
     ),
-    hasMore && onLoadMore && /* @__PURE__ */ jsx6(
+    hasMore && onLoadMore && /* @__PURE__ */ jsx5(
       "button",
       {
         type: "button",
@@ -14564,7 +15147,7 @@ var DatePicker = ({
 };
 
 // ../blocks/src/system/runtime/components/booking/TimeSlotSelector.tsx
-import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
 var TimeSlotSelector = ({
   value,
   onChange,
@@ -14575,9 +15158,9 @@ var TimeSlotSelector = ({
   return /* @__PURE__ */ jsxs5("div", { className: "ab-stack--sm", children: [
     /* @__PURE__ */ jsxs5("label", { htmlFor: "booking-slot", className: "ab-label", children: [
       "Select Time",
-      required && /* @__PURE__ */ jsx7("span", { className: "ab-required", children: "*" })
+      required && /* @__PURE__ */ jsx6("span", { className: "ab-required", children: "*" })
     ] }),
-    isLoading ? /* @__PURE__ */ jsx7(FeedbackMessage, { tone: "info", className: "ab-alert ab-alert--info ab-center", role: "status", children: "Loading available times..." }) : slots.length === 0 ? /* @__PURE__ */ jsx7(FeedbackMessage, { tone: "info", className: "ab-alert ab-alert--info ab-center", role: "status", children: "No available times for this date" }) : /* @__PURE__ */ jsxs5(
+    isLoading ? /* @__PURE__ */ jsx6(FeedbackMessage, { tone: "info", className: "ab-alert ab-alert--info ab-center", role: "status", children: "Loading available times..." }) : slots.length === 0 ? /* @__PURE__ */ jsx6(FeedbackMessage, { tone: "info", className: "ab-alert ab-alert--info ab-center", role: "status", children: "No available times for this date" }) : /* @__PURE__ */ jsxs5(
       "select",
       {
         id: "booking-slot",
@@ -14586,8 +15169,8 @@ var TimeSlotSelector = ({
         required,
         className: "ab-select",
         children: [
-          /* @__PURE__ */ jsx7("option", { value: "", children: "Choose a time..." }),
-          slots.map((slot) => /* @__PURE__ */ jsx7("option", { value: slot.startAt, children: formatTime(slot.startAt) }, slot.startAt))
+          /* @__PURE__ */ jsx6("option", { value: "", children: "Choose a time..." }),
+          slots.map((slot) => /* @__PURE__ */ jsx6("option", { value: slot.startAt, children: formatTime(slot.startAt) }, slot.startAt))
         ]
       }
     )
@@ -14596,7 +15179,7 @@ var TimeSlotSelector = ({
 
 // ../blocks/src/system/runtime/shared/components/DiscountCodeDisclosure.tsx
 import { useId } from "react";
-import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
 var BLOCK_DISCOUNT_CODE_DISCLOSURE_CLASSES = {
   "course-registration": {
     root: "cr-discount",
@@ -14672,10 +15255,10 @@ function DiscountCodeDisclosure({
     onApply();
   };
   const feedbackClassName = feedback ? `${classes.feedback} status-${feedback.tone}` : classes.feedback;
-  return /* @__PURE__ */ jsx8("div", { className: classes.root, children: !isOpen ? /* @__PURE__ */ jsx8("button", { type: "button", className: classes.toggle, onClick: onOpen, children: toggleLabel }) : /* @__PURE__ */ jsxs6("div", { className: classes.form, children: [
-    /* @__PURE__ */ jsx8("label", { htmlFor: inputId, className: classes.label, children: label }),
+  return /* @__PURE__ */ jsx7("div", { className: classes.root, children: !isOpen ? /* @__PURE__ */ jsx7("button", { type: "button", className: classes.toggle, onClick: onOpen, children: toggleLabel }) : /* @__PURE__ */ jsxs6("div", { className: classes.form, children: [
+    /* @__PURE__ */ jsx7("label", { htmlFor: inputId, className: classes.label, children: label }),
     /* @__PURE__ */ jsxs6("div", { className: classes.row, children: [
-      /* @__PURE__ */ jsx8(
+      /* @__PURE__ */ jsx7(
         "input",
         {
           id: inputId,
@@ -14688,7 +15271,7 @@ function DiscountCodeDisclosure({
           disabled: disabled || isApplying
         }
       ),
-      onApply ? /* @__PURE__ */ jsx8(
+      onApply ? /* @__PURE__ */ jsx7(
         "button",
         {
           type: "button",
@@ -14698,7 +15281,7 @@ function DiscountCodeDisclosure({
           children: isApplying ? "Applying..." : applyLabel
         }
       ) : null,
-      /* @__PURE__ */ jsx8(
+      /* @__PURE__ */ jsx7(
         "button",
         {
           type: "button",
@@ -14709,8 +15292,8 @@ function DiscountCodeDisclosure({
         }
       )
     ] }),
-    /* @__PURE__ */ jsx8("p", { className: classes.hint, children: hint }),
-    feedback ? /* @__PURE__ */ jsx8(
+    /* @__PURE__ */ jsx7("p", { className: classes.hint, children: hint }),
+    feedback ? /* @__PURE__ */ jsx7(
       "p",
       {
         className: feedbackClassName,
@@ -14722,7 +15305,7 @@ function DiscountCodeDisclosure({
 }
 
 // ../blocks/src/system/runtime/shared/components/FieldValidationMessage.tsx
-import { jsx as jsx9 } from "react/jsx-runtime";
+import { jsx as jsx8 } from "react/jsx-runtime";
 function getFieldValidationControlProps({
   message,
   messageId,
@@ -14741,7 +15324,7 @@ function FieldValidationMessage({
   className,
   live = "assertive"
 }) {
-  return /* @__PURE__ */ jsx9(
+  return /* @__PURE__ */ jsx8(
     "p",
     {
       id,
@@ -14756,7 +15339,7 @@ function FieldValidationMessage({
 }
 
 // ../blocks/src/system/runtime/nodes/booking-form.default-ui.tsx
-import { Fragment as Fragment2, jsx as jsx10, jsxs as jsxs7 } from "react/jsx-runtime";
+import { Fragment as Fragment2, jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
 var paymentOptionLayoutStyle = {
   alignItems: "flex-start",
   display: "flex",
@@ -14785,20 +15368,20 @@ function HeadlessBookingDefaultForm({
     }
   };
   if (!currentStep) {
-    return /* @__PURE__ */ jsx10("div", { className: "rb-text-center rb-py-12", children: /* @__PURE__ */ jsx10("p", { className: "status-muted", children: "No steps available" }) });
+    return /* @__PURE__ */ jsx9("div", { className: "rb-text-center rb-py-12", children: /* @__PURE__ */ jsx9("p", { className: "status-muted", children: "No steps available" }) });
   }
   return /* @__PURE__ */ jsxs7("div", { className: "multi-step-form", children: [
-    /* @__PURE__ */ jsx10("div", { className: "rb-mb-8", children: /* @__PURE__ */ jsx10(
+    /* @__PURE__ */ jsx9("div", { className: "rb-mb-8", children: /* @__PURE__ */ jsx9(
       DefaultBookingProgress,
       {
         steps: booking.steps,
         currentIndex: currentStepIndex
       }
     ) }),
-    /* @__PURE__ */ jsx10("div", { className: "step-content", children: /* @__PURE__ */ jsx10(DefaultBookingStepContent, { booking }) }),
-    /* @__PURE__ */ jsx10(DefaultBookingErrorSummary, { errors: currentStep.errors }),
+    /* @__PURE__ */ jsx9("div", { className: "step-content", children: /* @__PURE__ */ jsx9(DefaultBookingStepContent, { booking }) }),
+    /* @__PURE__ */ jsx9(DefaultBookingErrorSummary, { errors: currentStep.errors }),
     /* @__PURE__ */ jsxs7("div", { className: "rb-flex rb-gap-3 rb-mt-8", children: [
-      !isFirstStep ? /* @__PURE__ */ jsx10(
+      !isFirstStep ? /* @__PURE__ */ jsx9(
         "button",
         {
           type: "button",
@@ -14807,7 +15390,7 @@ function HeadlessBookingDefaultForm({
           children: "Back"
         }
       ) : null,
-      /* @__PURE__ */ jsx10(
+      /* @__PURE__ */ jsx9(
         "button",
         {
           type: "button",
@@ -14821,7 +15404,7 @@ function HeadlessBookingDefaultForm({
             extraClassName: "rb-flex-1"
           }),
           children: isSubmitting ? /* @__PURE__ */ jsxs7(Fragment2, { children: [
-            /* @__PURE__ */ jsx10(
+            /* @__PURE__ */ jsx9(
               SpinnerNode,
               {
                 size: "sm",
@@ -14835,22 +15418,22 @@ function HeadlessBookingDefaultForm({
         }
       )
     ] }),
-    /* @__PURE__ */ jsx10(DefaultBookingDiscount, { booking }),
-    /* @__PURE__ */ jsx10(DefaultBookingFeedback, { booking }),
-    /* @__PURE__ */ jsx10(DefaultBookingAltcha, { booking })
+    /* @__PURE__ */ jsx9(DefaultBookingDiscount, { booking }),
+    /* @__PURE__ */ jsx9(DefaultBookingFeedback, { booking }),
+    /* @__PURE__ */ jsx9(DefaultBookingAltcha, { booking })
   ] });
 }
 function DefaultBookingProgress({
   steps,
   currentIndex
 }) {
-  return /* @__PURE__ */ jsx10("div", { className: "rb-flex rb-items-center rb-justify-between", children: steps.map((step, index) => {
+  return /* @__PURE__ */ jsx9("div", { className: "rb-flex rb-items-center rb-justify-between", children: steps.map((step, index) => {
     const isActive = index === currentIndex;
     const isCompleted = index < currentIndex;
     const isLast = index === steps.length - 1;
     return /* @__PURE__ */ jsxs7("div", { className: "rb-flex rb-items-center rb-flex-1", children: [
       /* @__PURE__ */ jsxs7("div", { className: "rb-flex rb-items-center rb-gap-2 rb-cursor-default", children: [
-        /* @__PURE__ */ jsx10(
+        /* @__PURE__ */ jsx9(
           "div",
           {
             className: `
@@ -14861,7 +15444,7 @@ function DefaultBookingProgress({
             children: isCompleted ? "\u2713" : index + 1
           }
         ),
-        /* @__PURE__ */ jsx10(
+        /* @__PURE__ */ jsx9(
           "span",
           {
             className: `
@@ -14872,7 +15455,7 @@ function DefaultBookingProgress({
           }
         )
       ] }),
-      !isLast ? /* @__PURE__ */ jsx10("div", { className: "step-connector rb-ml-2 rb-mr-2 rb-hidden rb-sm-block" }) : null
+      !isLast ? /* @__PURE__ */ jsx9("div", { className: "step-connector rb-ml-2 rb-mr-2 rb-hidden rb-sm-block" }) : null
     ] }, step.id);
   }) });
 }
@@ -14883,15 +15466,15 @@ function DefaultBookingStepContent({
   if (!stepId) return null;
   switch (stepId) {
     case "service-selection":
-      return /* @__PURE__ */ jsx10(DefaultServiceSelectionStep, { booking });
+      return /* @__PURE__ */ jsx9(DefaultServiceSelectionStep, { booking });
     case "datetime-selection":
-      return /* @__PURE__ */ jsx10(DefaultDateTimeSelectionStep, { booking });
+      return /* @__PURE__ */ jsx9(DefaultDateTimeSelectionStep, { booking });
     case "payment-selection":
-      return /* @__PURE__ */ jsx10(HeadlessBookingPaymentSelectionStep, { booking });
+      return /* @__PURE__ */ jsx9(HeadlessBookingPaymentSelectionStep, { booking });
     case "custom-fields":
-      return /* @__PURE__ */ jsx10(DefaultDynamicFields, { fields: booking.fields.items, booking });
+      return /* @__PURE__ */ jsx9(DefaultDynamicFields, { fields: booking.fields.items, booking });
     default:
-      return assertNever11(stepId);
+      return assertNever4(stepId);
   }
 }
 function DefaultServiceSelectionStep({
@@ -14906,14 +15489,14 @@ function DefaultServiceSelectionStep({
   const allowAnyResource = !booking.resources.requiresSelection;
   return /* @__PURE__ */ jsxs7("div", { className: "ab-stack", children: [
     /* @__PURE__ */ jsxs7("div", { children: [
-      /* @__PURE__ */ jsx10("h2", { className: "ab-title", children: "Select Service" }),
-      /* @__PURE__ */ jsx10("p", { className: "ab-text ab-text--muted", children: "Choose the service you'd like to book" })
+      /* @__PURE__ */ jsx9("h2", { className: "ab-title", children: "Select Service" }),
+      /* @__PURE__ */ jsx9("p", { className: "ab-text ab-text--muted", children: "Choose the service you'd like to book" })
     ] }),
     showServiceSelect ? /* @__PURE__ */ jsxs7("div", { className: "ab-stack--sm", children: [
-      /* @__PURE__ */ jsx10("label", { className: "ab-subtitle", children: "Service" }),
-      /* @__PURE__ */ jsx10("div", { className: "ab-grid", children: services.map((service) => {
+      /* @__PURE__ */ jsx9("label", { className: "ab-subtitle", children: "Service" }),
+      /* @__PURE__ */ jsx9("div", { className: "ab-grid", children: services.map((service) => {
         const isSelected = selectedServiceId === service.id;
-        return /* @__PURE__ */ jsx10(
+        return /* @__PURE__ */ jsx9(
           "button",
           {
             type: "button",
@@ -14921,14 +15504,14 @@ function DefaultServiceSelectionStep({
             className: `ab-card ${isSelected ? "ab-card--selected" : ""}`,
             children: /* @__PURE__ */ jsxs7("div", { className: "ab-row--between", children: [
               /* @__PURE__ */ jsxs7("div", { children: [
-                /* @__PURE__ */ jsx10("div", { className: "ab-subtitle", children: service.title }),
-                service.description ? /* @__PURE__ */ jsx10("div", { className: "ab-text ab-text--muted", children: service.description }) : null,
+                /* @__PURE__ */ jsx9("div", { className: "ab-subtitle", children: service.title }),
+                service.description ? /* @__PURE__ */ jsx9("div", { className: "ab-text ab-text--muted", children: service.description }) : null,
                 service.durationMinutes ? /* @__PURE__ */ jsxs7("div", { className: "ab-text ab-text--muted", children: [
                   service.durationMinutes,
                   " minutes"
                 ] }) : null
               ] }),
-              isSelected ? /* @__PURE__ */ jsx10(SelectedCheck, {}) : null
+              isSelected ? /* @__PURE__ */ jsx9(SelectedCheck, {}) : null
             ] })
           },
           service.id
@@ -14936,41 +15519,41 @@ function DefaultServiceSelectionStep({
       }) })
     ] }) : null,
     booking.resources.state.tag === "loading" ? /* @__PURE__ */ jsxs7("div", { className: "ab-center", children: [
-      /* @__PURE__ */ jsx10(SpinnerNode, { size: "md", srLabel: "Loading practitioners" }),
-      /* @__PURE__ */ jsx10("p", { className: "ab-text ab-text--muted", children: "Loading practitioners..." })
+      /* @__PURE__ */ jsx9(SpinnerNode, { size: "md", srLabel: "Loading practitioners" }),
+      /* @__PURE__ */ jsx9("p", { className: "ab-text ab-text--muted", children: "Loading practitioners..." })
     ] }) : null,
-    booking.resources.state.tag === "error" ? /* @__PURE__ */ jsx10(FeedbackMessage, { tone: "error", className: "ab-alert ab-alert--error", role: "alert", children: booking.resources.state.message }) : null,
-    showResourceSelect && booking.resources.state.tag === "loaded" && resources.length === 0 ? /* @__PURE__ */ jsx10(FeedbackMessage, { tone: "error", className: "ab-alert ab-alert--error", role: "alert", children: "No practitioners are available for this service right now." }) : null,
+    booking.resources.state.tag === "error" ? /* @__PURE__ */ jsx9(FeedbackMessage, { tone: "error", className: "ab-alert ab-alert--error", role: "alert", children: booking.resources.state.message }) : null,
+    showResourceSelect && booking.resources.state.tag === "loaded" && resources.length === 0 ? /* @__PURE__ */ jsx9(FeedbackMessage, { tone: "error", className: "ab-alert ab-alert--error", role: "alert", children: "No practitioners are available for this service right now." }) : null,
     showResourceSelect && booking.resources.state.tag !== "loading" && (allowAnyResource || resources.length > 0) ? /* @__PURE__ */ jsxs7("div", { className: "ab-stack--sm", children: [
       /* @__PURE__ */ jsxs7("label", { className: "ab-subtitle", children: [
         "Practitioner",
         booking.resources.requiresSelection ? "" : " (Optional)"
       ] }),
-      /* @__PURE__ */ jsx10("p", { className: "ab-text ab-text--muted", children: allowAnyResource ? 'Choose a specific practitioner or select "Any Available"' : "Choose the practitioner you'd like to book" }),
+      /* @__PURE__ */ jsx9("p", { className: "ab-text ab-text--muted", children: allowAnyResource ? 'Choose a specific practitioner or select "Any Available"' : "Choose the practitioner you'd like to book" }),
       /* @__PURE__ */ jsxs7("div", { className: "ab-grid", children: [
-        allowAnyResource ? /* @__PURE__ */ jsx10(
+        allowAnyResource ? /* @__PURE__ */ jsx9(
           "button",
           {
             type: "button",
             onClick: () => booking.actions.selectResource(null),
             className: `ab-card ${!selectedResourceId ? "ab-card--selected" : ""}`,
             children: /* @__PURE__ */ jsxs7("div", { className: "ab-row--between", children: [
-              /* @__PURE__ */ jsx10("div", { className: "ab-subtitle", children: "Any Available" }),
-              !selectedResourceId ? /* @__PURE__ */ jsx10(SelectedCheck, {}) : null
+              /* @__PURE__ */ jsx9("div", { className: "ab-subtitle", children: "Any Available" }),
+              !selectedResourceId ? /* @__PURE__ */ jsx9(SelectedCheck, {}) : null
             ] })
           }
         ) : null,
         resources.map((resource) => {
           const isSelected = selectedResourceId === resource.id;
-          return /* @__PURE__ */ jsx10(
+          return /* @__PURE__ */ jsx9(
             "button",
             {
               type: "button",
               onClick: () => booking.actions.selectResource(resource.id),
               className: `ab-card ${isSelected ? "ab-card--selected" : ""}`,
               children: /* @__PURE__ */ jsxs7("div", { className: "ab-row--between", children: [
-                /* @__PURE__ */ jsx10("div", { className: "ab-subtitle", children: resource.label }),
-                isSelected ? /* @__PURE__ */ jsx10(SelectedCheck, {}) : null
+                /* @__PURE__ */ jsx9("div", { className: "ab-subtitle", children: resource.label }),
+                isSelected ? /* @__PURE__ */ jsx9(SelectedCheck, {}) : null
               ] })
             },
             resource.id
@@ -14993,16 +15576,16 @@ function DefaultDateTimeSelectionStep({
   const error = booking.availability.datesState.tag === "error" ? booking.availability.datesState.message : booking.availability.slotsState.tag === "error" ? booking.availability.slotsState.message : null;
   return /* @__PURE__ */ jsxs7("div", { className: "ab-stack", children: [
     singleService ? /* @__PURE__ */ jsxs7("div", { className: "ab-info-box", children: [
-      /* @__PURE__ */ jsx10("h3", { className: "ab-subtitle", children: singleService.title }),
-      singleService.description ? /* @__PURE__ */ jsx10("p", { className: "ab-text ab-text--muted", children: singleService.description }) : null,
+      /* @__PURE__ */ jsx9("h3", { className: "ab-subtitle", children: singleService.title }),
+      singleService.description ? /* @__PURE__ */ jsx9("p", { className: "ab-text ab-text--muted", children: singleService.description }) : null,
       singleService.durationMinutes ? /* @__PURE__ */ jsxs7("p", { className: "ab-text ab-text--muted", children: [
         "Duration: ",
         singleService.durationMinutes,
         " minutes"
       ] }) : null
     ] }) : null,
-    error ? /* @__PURE__ */ jsx10(FeedbackMessage, { tone: "error", className: "ab-alert ab-alert--error", role: "alert", children: error }) : null,
-    /* @__PURE__ */ jsx10(
+    error ? /* @__PURE__ */ jsx9(FeedbackMessage, { tone: "error", className: "ab-alert ab-alert--error", role: "alert", children: error }) : null,
+    /* @__PURE__ */ jsx9(
       DatePicker,
       {
         value: selectedDate,
@@ -15014,7 +15597,7 @@ function DefaultDateTimeSelectionStep({
         onLoadMore: booking.availability.loadMoreDates
       }
     ),
-    selectedDate ? /* @__PURE__ */ jsx10(
+    selectedDate ? /* @__PURE__ */ jsx9(
       TimeSlotSelector,
       {
         value: selectedSlotStart,
@@ -15037,19 +15620,19 @@ function HeadlessBookingPaymentSelectionStep({
   const service = booking.services.selected;
   const viewModel = booking.payment.selection;
   if (booking.payment.kind === "unsupported") {
-    return /* @__PURE__ */ jsx10(FeedbackMessage, { tone: "error", className: "ab-alert ab-alert--error", role: "alert", children: booking.payment.errorMessage });
+    return /* @__PURE__ */ jsx9(FeedbackMessage, { tone: "error", className: "ab-alert ab-alert--error", role: "alert", children: booking.payment.errorMessage });
   }
   if (!service || !viewModel) {
-    return /* @__PURE__ */ jsx10(FeedbackMessage, { tone: "error", className: "ab-alert ab-alert--error", role: "alert", children: "Payment options are unavailable for this service right now." });
+    return /* @__PURE__ */ jsx9(FeedbackMessage, { tone: "error", className: "ab-alert ab-alert--error", role: "alert", children: "Payment options are unavailable for this service right now." });
   }
   const packageOptions = booking.payment.appointmentPackages.items;
   const hasPackageOptions = packageOptions.length > 0;
   return /* @__PURE__ */ jsxs7("div", { className: "ab-stack", children: [
     /* @__PURE__ */ jsxs7("div", { className: "ab-info-box", children: [
-      /* @__PURE__ */ jsx10("h3", { className: "ab-subtitle", children: viewModel.sectionTitle }),
-      /* @__PURE__ */ jsx10("p", { className: "ab-text ab-text--muted", children: service.title })
+      /* @__PURE__ */ jsx9("h3", { className: "ab-subtitle", children: viewModel.sectionTitle }),
+      /* @__PURE__ */ jsx9("p", { className: "ab-text ab-text--muted", children: service.title })
     ] }),
-    booking.payment.appointmentPackages.state.tag === "loading" ? /* @__PURE__ */ jsx10(FeedbackMessage, { tone: "info", className: "ab-alert ab-alert--info", role: "status", children: "Checking package credits..." }) : null,
+    booking.payment.appointmentPackages.state.tag === "loading" ? /* @__PURE__ */ jsx9(FeedbackMessage, { tone: "info", className: "ab-alert ab-alert--info", role: "status", children: "Checking package credits..." }) : null,
     booking.payment.appointmentPackages.state.tag === "error" ? /* @__PURE__ */ jsxs7(FeedbackMessage, { tone: "info", className: "ab-alert ab-alert--info", role: "status", children: [
       booking.payment.appointmentPackages.state.message,
       " You can continue with the normal payment option."
@@ -15057,7 +15640,7 @@ function HeadlessBookingPaymentSelectionStep({
     /* @__PURE__ */ jsxs7("div", { className: "ab-stack", role: "list", "aria-label": "Payment options", children: [
       packageOptions.map((appointmentPackage) => {
         const isSelected = booking.payment.selectedAppointmentPackageId === appointmentPackage.customerPassId;
-        return /* @__PURE__ */ jsx10(
+        return /* @__PURE__ */ jsx9(
           "button",
           {
             type: "button",
@@ -15070,7 +15653,7 @@ function HeadlessBookingPaymentSelectionStep({
               appointmentPackage.customerPassId
             ),
             "aria-pressed": isSelected,
-            children: /* @__PURE__ */ jsx10(
+            children: /* @__PURE__ */ jsx9(
               PaymentOptionContent,
               {
                 id: appointmentPackage.customerPassId,
@@ -15089,12 +15672,12 @@ function HeadlessBookingPaymentSelectionStep({
       viewModel.options.map((option) => {
         const isSelected = !booking.payment.selectedAppointmentPackageId && (booking.payment.selectedCollectionOptionKind === option.kind || viewModel.mode === "single_option");
         if (viewModel.mode === "single_option" && !hasPackageOptions) {
-          return /* @__PURE__ */ jsx10(
+          return /* @__PURE__ */ jsx9(
             "div",
             {
               className: "ab-card",
               style: paymentOptionLayoutStyle,
-              children: /* @__PURE__ */ jsx10(
+              children: /* @__PURE__ */ jsx9(
                 PaymentOptionContent,
                 {
                   id: option.kind,
@@ -15108,7 +15691,7 @@ function HeadlessBookingPaymentSelectionStep({
             option.kind
           );
         }
-        return /* @__PURE__ */ jsx10(
+        return /* @__PURE__ */ jsx9(
           "button",
           {
             type: "button",
@@ -15119,7 +15702,7 @@ function HeadlessBookingPaymentSelectionStep({
             style: paymentOptionLayoutStyle,
             onClick: () => booking.actions.selectPaymentOption(option.kind),
             "aria-pressed": isSelected,
-            children: /* @__PURE__ */ jsx10(
+            children: /* @__PURE__ */ jsx9(
               PaymentOptionContent,
               {
                 id: option.kind,
@@ -15144,21 +15727,21 @@ function PaymentOptionContent({
   title
 }) {
   return /* @__PURE__ */ jsxs7(Fragment2, { children: [
-    /* @__PURE__ */ jsx10("span", { children: title }),
-    /* @__PURE__ */ jsx10("span", { className: "ab-text ab-text--muted", children: description }),
-    /* @__PURE__ */ jsx10("div", { className: "ab-stack", style: summaryStackStyle, children: summaryRows.map((row) => /* @__PURE__ */ jsxs7("span", { className: "ab-text ab-text--muted", children: [
+    /* @__PURE__ */ jsx9("span", { children: title }),
+    /* @__PURE__ */ jsx9("span", { className: "ab-text ab-text--muted", children: description }),
+    /* @__PURE__ */ jsx9("div", { className: "ab-stack", style: summaryStackStyle, children: summaryRows.map((row) => /* @__PURE__ */ jsxs7("span", { className: "ab-text ab-text--muted", children: [
       row.label,
       ": ",
       row.value
     ] }, `${id}-${row.label}`)) }),
-    helperText ? /* @__PURE__ */ jsx10("span", { className: "ab-text ab-text--muted", children: helperText }) : null
+    helperText ? /* @__PURE__ */ jsx9("span", { className: "ab-text ab-text--muted", children: helperText }) : null
   ] });
 }
 function DefaultDynamicFields({
   booking,
   fields
 }) {
-  return /* @__PURE__ */ jsx10("div", { className: "rb-space-y-6", children: fields.map((field) => /* @__PURE__ */ jsx10(DefaultDynamicField, { booking, field }, field.id)) });
+  return /* @__PURE__ */ jsx9("div", { className: "rb-space-y-6", children: fields.map((field) => /* @__PURE__ */ jsx9(DefaultDynamicField, { booking, field }, field.id)) });
 }
 function DefaultDynamicField({
   booking,
@@ -15171,10 +15754,10 @@ function DefaultDynamicField({
   return /* @__PURE__ */ jsxs7("div", { className: "rb-space-y-2", children: [
     /* @__PURE__ */ jsxs7("label", { id: field.labelId, htmlFor: field.inputId, className: "form-label", children: [
       field.label,
-      field.required ? /* @__PURE__ */ jsx10("span", { className: "required-marker", children: "*" }) : null
+      field.required ? /* @__PURE__ */ jsx9("span", { className: "required-marker", children: "*" }) : null
     ] }),
-    field.helpText ? /* @__PURE__ */ jsx10("p", { id: field.helpTextId ?? void 0, className: "rb-caption status-muted", children: field.helpText }) : null,
-    /* @__PURE__ */ jsx10(
+    field.helpText ? /* @__PURE__ */ jsx9("p", { id: field.helpTextId ?? void 0, className: "rb-caption status-muted", children: field.helpText }) : null,
+    /* @__PURE__ */ jsx9(
       DefaultFieldInput,
       {
         field,
@@ -15186,7 +15769,7 @@ function DefaultDynamicField({
         describedBy
       }
     ),
-    error ? /* @__PURE__ */ jsx10(
+    error ? /* @__PURE__ */ jsx9(
       FieldValidationMessage,
       {
         id: errorId ?? `${field.inputId}-error`,
@@ -15220,7 +15803,7 @@ function DefaultFieldInput({
   };
   switch (field.type) {
     case "textarea":
-      return /* @__PURE__ */ jsx10(
+      return /* @__PURE__ */ jsx9(
         "textarea",
         {
           ...commonProps,
@@ -15235,7 +15818,7 @@ function DefaultFieldInput({
       );
     case "select":
       if (field.field.multiple) {
-        return /* @__PURE__ */ jsx10(
+        return /* @__PURE__ */ jsx9(
           "select",
           {
             ...commonProps,
@@ -15248,7 +15831,7 @@ function DefaultFieldInput({
             },
             multiple: true,
             className: "form-select rb-h-32",
-            children: field.field.options?.map((option) => /* @__PURE__ */ jsx10("option", { value: option.value, children: option.label }, option.value))
+            children: field.field.options?.map((option) => /* @__PURE__ */ jsx9("option", { value: option.value, children: option.label }, option.value))
           }
         );
       }
@@ -15260,14 +15843,14 @@ function DefaultFieldInput({
           onChange: (event) => onChange(event.target.value),
           className: "form-select",
           children: [
-            /* @__PURE__ */ jsx10("option", { value: "", children: "Select an option..." }),
-            field.field.options?.map((option) => /* @__PURE__ */ jsx10("option", { value: option.value, children: option.label }, option.value))
+            /* @__PURE__ */ jsx9("option", { value: "", children: "Select an option..." }),
+            field.field.options?.map((option) => /* @__PURE__ */ jsx9("option", { value: option.value, children: option.label }, option.value))
           ]
         }
       );
     case "radio":
-      return /* @__PURE__ */ jsx10("div", { className: "rb-space-y-2", children: field.field.options?.map((option) => /* @__PURE__ */ jsxs7("label", { className: "rb-flex rb-items-center rb-gap-2 rb-cursor-pointer", children: [
-        /* @__PURE__ */ jsx10(
+      return /* @__PURE__ */ jsx9("div", { className: "rb-space-y-2", children: field.field.options?.map((option) => /* @__PURE__ */ jsxs7("label", { className: "rb-flex rb-items-center rb-gap-2 rb-cursor-pointer", children: [
+        /* @__PURE__ */ jsx9(
           "input",
           {
             type: "radio",
@@ -15281,13 +15864,13 @@ function DefaultFieldInput({
             className: "form-radio"
           }
         ),
-        /* @__PURE__ */ jsx10("span", { className: "rb-caption", children: option.label })
+        /* @__PURE__ */ jsx9("span", { className: "rb-caption", children: option.label })
       ] }, option.value)) });
     case "checkbox":
       if (field.field.options && field.field.options.length > 1) {
         const checkedValues = toStringArray(value);
-        return /* @__PURE__ */ jsx10("div", { className: "rb-space-y-2", children: field.field.options.map((option) => /* @__PURE__ */ jsxs7("label", { className: "rb-flex rb-items-center rb-gap-2 rb-cursor-pointer", children: [
-          /* @__PURE__ */ jsx10(
+        return /* @__PURE__ */ jsx9("div", { className: "rb-space-y-2", children: field.field.options.map((option) => /* @__PURE__ */ jsxs7("label", { className: "rb-flex rb-items-center rb-gap-2 rb-cursor-pointer", children: [
+          /* @__PURE__ */ jsx9(
             "input",
             {
               type: "checkbox",
@@ -15304,11 +15887,11 @@ function DefaultFieldInput({
               className: "form-checkbox"
             }
           ),
-          /* @__PURE__ */ jsx10("span", { className: "rb-caption", children: option.label })
+          /* @__PURE__ */ jsx9("span", { className: "rb-caption", children: option.label })
         ] }, option.value)) });
       }
       return /* @__PURE__ */ jsxs7("label", { className: "rb-flex rb-items-center rb-gap-2 rb-cursor-pointer", children: [
-        /* @__PURE__ */ jsx10(
+        /* @__PURE__ */ jsx9(
           "input",
           {
             type: "checkbox",
@@ -15322,11 +15905,11 @@ function DefaultFieldInput({
             className: "form-checkbox"
           }
         ),
-        /* @__PURE__ */ jsx10("span", { className: "rb-caption", children: field.field.placeholder || field.label })
+        /* @__PURE__ */ jsx9("span", { className: "rb-caption", children: field.field.placeholder || field.label })
       ] });
     case "booking_requirement_consent":
       return /* @__PURE__ */ jsxs7("label", { className: "rb-flex rb-items-start rb-gap-2 rb-cursor-pointer", children: [
-        /* @__PURE__ */ jsx10(
+        /* @__PURE__ */ jsx9(
           "input",
           {
             type: "checkbox",
@@ -15340,10 +15923,10 @@ function DefaultFieldInput({
             className: "form-checkbox rb-mt-0.5"
           }
         ),
-        /* @__PURE__ */ jsx10("span", { className: "rb-caption", children: field.field.placeholder || field.label })
+        /* @__PURE__ */ jsx9("span", { className: "rb-caption", children: field.field.placeholder || field.label })
       ] });
     case "number":
-      return /* @__PURE__ */ jsx10(
+      return /* @__PURE__ */ jsx9(
         "input",
         {
           ...commonProps,
@@ -15357,7 +15940,7 @@ function DefaultFieldInput({
         }
       );
     case "date":
-      return /* @__PURE__ */ jsx10(
+      return /* @__PURE__ */ jsx9(
         "input",
         {
           ...commonProps,
@@ -15370,7 +15953,7 @@ function DefaultFieldInput({
         }
       );
     case "time":
-      return /* @__PURE__ */ jsx10(
+      return /* @__PURE__ */ jsx9(
         "input",
         {
           ...commonProps,
@@ -15384,7 +15967,7 @@ function DefaultFieldInput({
     case "email":
     case "tel":
     case "url":
-      return /* @__PURE__ */ jsx10(
+      return /* @__PURE__ */ jsx9(
         "input",
         {
           ...commonProps,
@@ -15409,7 +15992,7 @@ function DefaultBookingDiscount({
   const shouldShowDiscountSection = !booking.payment.selectedAppointmentPackageId && !booking.discount.loading && (booking.discount.manualCodeEntryAllowed || Boolean(booking.discount.autoAppliedDiscount));
   if (!shouldShowDiscountSection) return null;
   return /* @__PURE__ */ jsxs7("div", { className: "rb-mt-6", children: [
-    booking.discount.manualCodeEntryAllowed ? /* @__PURE__ */ jsx10(
+    booking.discount.manualCodeEntryAllowed ? /* @__PURE__ */ jsx9(
       DiscountCodeDisclosure,
       {
         surface: "theme-form",
@@ -15423,7 +16006,7 @@ function DefaultBookingDiscount({
         }
       }
     ) : null,
-    booking.discount.autoAppliedDiscount && booking.discount.code.trim().length === 0 ? /* @__PURE__ */ jsx10(FeedbackMessage, { tone: "info", className: "ab-alert ab-alert--info rb-mt-4", role: "status", children: /* @__PURE__ */ jsxs7("p", { className: "ab-text", children: [
+    booking.discount.autoAppliedDiscount && booking.discount.code.trim().length === 0 ? /* @__PURE__ */ jsx9(FeedbackMessage, { tone: "info", className: "ab-alert ab-alert--info rb-mt-4", role: "status", children: /* @__PURE__ */ jsxs7("p", { className: "ab-text", children: [
       "Discount available: ",
       booking.discount.autoAppliedDiscount.publicLabel,
       " ",
@@ -15436,8 +16019,8 @@ function DefaultBookingFeedback({
 }) {
   if (booking.feedback.kind !== "error") return null;
   return /* @__PURE__ */ jsxs7(FeedbackMessage, { tone: "error", className: "ab-alert ab-alert--error", role: "alert", children: [
-    /* @__PURE__ */ jsx10("p", { className: "ab-text", children: booking.feedback.message }),
-    /* @__PURE__ */ jsx10(
+    /* @__PURE__ */ jsx9("p", { className: "ab-text", children: booking.feedback.message }),
+    /* @__PURE__ */ jsx9(
       "button",
       {
         type: "button",
@@ -15452,7 +16035,7 @@ function DefaultBookingAltcha({
   booking
 }) {
   if (!booking.spamProtection.enabled) return null;
-  return /* @__PURE__ */ jsx10("div", { className: "ab-altcha", children: /* @__PURE__ */ jsx10(
+  return /* @__PURE__ */ jsx9("div", { className: "ab-altcha", children: /* @__PURE__ */ jsx9(
     AltchaWidget,
     {
       challengeUrl: booking.spamProtection.challenge.url,
@@ -15465,12 +16048,12 @@ function DefaultBookingErrorSummary({
 }) {
   if (!hasBookingValidationErrors(errors)) return null;
   return /* @__PURE__ */ jsxs7(FeedbackMessage, { tone: "error", className: "rb-mt-6 alert alert-error", role: "alert", children: [
-    errors.formError ? /* @__PURE__ */ jsx10("p", { className: "rb-caption", children: /* @__PURE__ */ jsx10("strong", { children: errors.formError }) }) : null,
-    Object.entries(errors.fieldErrors).map(([key, message]) => /* @__PURE__ */ jsx10("p", { className: "rb-caption", children: message }, key))
+    errors.formError ? /* @__PURE__ */ jsx9("p", { className: "rb-caption", children: /* @__PURE__ */ jsx9("strong", { children: errors.formError }) }) : null,
+    Object.entries(errors.fieldErrors).map(([key, message]) => /* @__PURE__ */ jsx9("p", { className: "rb-caption", children: message }, key))
   ] });
 }
 function SelectedCheck() {
-  return /* @__PURE__ */ jsx10("div", { className: "ab-check", children: /* @__PURE__ */ jsx10(
+  return /* @__PURE__ */ jsx9("div", { className: "ab-check", children: /* @__PURE__ */ jsx9(
     "svg",
     {
       fill: "none",
@@ -15479,7 +16062,7 @@ function SelectedCheck() {
       strokeWidth: "2",
       viewBox: "0 0 24 24",
       stroke: "currentColor",
-      children: /* @__PURE__ */ jsx10("path", { d: "M5 13l4 4L19 7" })
+      children: /* @__PURE__ */ jsx9("path", { d: "M5 13l4 4L19 7" })
     }
   ) });
 }
@@ -15546,7 +16129,7 @@ function consumeSearchParam(paramName) {
 }
 
 // ../blocks/src/system/runtime/nodes/booking-form.client.tsx
-import { jsx as jsx11, jsxs as jsxs8 } from "react/jsx-runtime";
+import { jsx as jsx10, jsxs as jsxs8 } from "react/jsx-runtime";
 var PORTAL_REBOOK_QUERY_PARAM = "rebook";
 var PORTAL_REBOOK_QUERY_VALUE = "1";
 var REBOOK_COMPLETION_MODE_VERIFIED_CHECKOUT = "verified_checkout";
@@ -15583,8 +16166,8 @@ var BookingFormClient = ({
   const initialServiceId = render.hydration.serviceId ?? defaultServiceId ?? void 0;
   const initialResourceId = render.hydration.resourceId ?? void 0;
   const isPortalRebook = render.hydration.rebookContext?.kind === "portal_rebook";
-  const hasLoggedRebookCompletionRef = useRef7(false);
-  const [redirectState] = useState3(
+  const hasLoggedRebookCompletionRef = useRef8(false);
+  const [redirectState] = useState2(
     () => getBookingRedirectStateFromLocation(getBookingRedirectLocationSnapshot())
   );
   const showSpamProtection = render.hydration.spamProtectionEnabled ?? isSpamProtectionEnabled();
@@ -15664,13 +16247,13 @@ var BookingFormClient = ({
     viewState.kind
   ]);
   if (render.display.state === "missing" || !form || !render.hydration.formId) {
-    return /* @__PURE__ */ jsx11(
+    return /* @__PURE__ */ jsx10(
       FeedbackMessage,
       {
         tone: "error",
         className: `ab-alert ab-alert--error ${render.display.className ?? ""}`.trim(),
         role: "alert",
-        children: /* @__PURE__ */ jsx11("p", { className: "ab-text", children: render.display.message ?? "Booking form not found. Please check your configuration." })
+        children: /* @__PURE__ */ jsx10("p", { className: "ab-text", children: render.display.message ?? "Booking form not found. Please check your configuration." })
       }
     );
   }
@@ -15690,7 +16273,7 @@ var BookingFormClient = ({
     }
   };
   if (viewState.kind === "success") {
-    return /* @__PURE__ */ jsx11(
+    return /* @__PURE__ */ jsx10(
       SuccessMessage,
       {
         message: getBookingSuccessMessage(render.display.successMessage),
@@ -15700,19 +16283,19 @@ var BookingFormClient = ({
     );
   }
   if (viewState.kind === "verifying") {
-    return /* @__PURE__ */ jsx11(
+    return /* @__PURE__ */ jsx10(
       "div",
       {
         id: bookingAnchorId,
         className: render.display.className ?? void 0,
-        children: /* @__PURE__ */ jsx11(FeedbackMessage, { tone: "info", className: "ab-alert ab-alert--info", role: "status", children: /* @__PURE__ */ jsx11("p", { className: "ab-text", children: viewState.message }) })
+        children: /* @__PURE__ */ jsx10(FeedbackMessage, { tone: "info", className: "ab-alert ab-alert--info", role: "status", children: /* @__PURE__ */ jsx10("p", { className: "ab-text", children: viewState.message }) })
       }
     );
   }
   return /* @__PURE__ */ jsxs8("div", { id: bookingAnchorId, className: render.display.className ?? void 0, children: [
-    render.hydration.noticeMessage ? /* @__PURE__ */ jsx11(FeedbackMessage, { tone: "info", className: "ab-alert ab-alert--info rb-mb-4", role: "status", children: /* @__PURE__ */ jsx11("p", { className: "ab-text", children: render.hydration.noticeMessage }) }) : null,
-    viewState.kind === "error" ? /* @__PURE__ */ jsx11(FeedbackMessage, { tone: "error", className: "ab-alert ab-alert--error", role: "alert", children: /* @__PURE__ */ jsx11("p", { className: "ab-text", children: viewState.message }) }) : null,
-    /* @__PURE__ */ jsx11(HeadlessBookingDefaultForm, { booking, onSubmit: handleComplete })
+    render.hydration.noticeMessage ? /* @__PURE__ */ jsx10(FeedbackMessage, { tone: "info", className: "ab-alert ab-alert--info rb-mb-4", role: "status", children: /* @__PURE__ */ jsx10("p", { className: "ab-text", children: render.hydration.noticeMessage }) }) : null,
+    viewState.kind === "error" ? /* @__PURE__ */ jsx10(FeedbackMessage, { tone: "error", className: "ab-alert ab-alert--error", role: "alert", children: /* @__PURE__ */ jsx10("p", { className: "ab-text", children: viewState.message }) }) : null,
+    /* @__PURE__ */ jsx10(HeadlessBookingDefaultForm, { booking, onSubmit: handleComplete })
   ] });
 };
 
@@ -15729,12 +16312,18 @@ function createInitialRegistrationFlowState(hasPreSelectedContext) {
   };
 }
 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;
+  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 && a.collectionOptionKind === b2.collectionOptionKind;
 }
 function withDefaultSelection(selection) {
   if (!selection || !selection.method) {
     return { method: null };
   }
+  if (selection.method === "stripe") {
+    return {
+      ...selection,
+      collectionOptionKind: selection.collectionOptionKind ?? "upfront"
+    };
+  }
   return selection;
 }
 function computeAutoSelection(input) {
@@ -15760,7 +16349,7 @@ function computeAutoSelection(input) {
     }
   }
   if (eligibility.canPayDirectly && eligibility.price) {
-    return { method: "stripe" };
+    return { method: "stripe", collectionOptionKind: "upfront" };
   }
   return { method: null };
 }
@@ -15778,11 +16367,17 @@ function isSelectionValid(input) {
     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);
+      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);
+      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);
+      return ticketsCount === 1 && !!selection.bundleMembershipId && eligibility.availableMemberships.some(
+        (membership) => membership.id === selection.bundleMembershipId
+      );
     default:
       return false;
   }
@@ -15829,9 +16424,15 @@ function registrationFlowReducer(state, action) {
         ticketsCount: Math.max(1, action.ticketsCount)
       });
     case "set-authenticated":
-      return normalizeRegistrationFlowState({ ...state, isAuthenticated: action.isAuthenticated });
+      return normalizeRegistrationFlowState({
+        ...state,
+        isAuthenticated: action.isAuthenticated
+      });
     case "eligibility-updated":
-      return normalizeRegistrationFlowState({ ...state, eligibility: action.eligibility });
+      return normalizeRegistrationFlowState({
+        ...state,
+        eligibility: action.eligibility
+      });
     case "set-manual-payment-selection":
       return normalizeRegistrationFlowState({
         ...state,
@@ -15843,7 +16444,7 @@ function registrationFlowReducer(state, action) {
       return normalizeRegistrationFlowState({
         ...state,
         passOptOut: true,
-        paymentSelection: { method: "stripe" },
+        paymentSelection: { method: "stripe", collectionOptionKind: "upfront" },
         selectionSource: "manual"
       });
     case "event-changed":
@@ -15898,8 +16499,8 @@ function getEventRegistrationOverrideInput(props) {
     };
   }
   const content = props.content ?? {};
-  const data = isRecord5(props.data) ? props.data : {};
-  const events = Array.isArray(data.events) ? data.events.filter(isPublicEventLike) : [];
+  const data = isRecord6(props.data) ? props.data : {};
+  const events = Array.isArray(data.events) ? data.events.map(normalizePublicEventLike).filter((event) => event !== null) : [];
   return {
     ok: true,
     value: {
@@ -15924,20 +16525,22 @@ function getEventRegistrationOverrideInput(props) {
     }
   };
 }
-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 isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isAccessRestriction(value) {
-  return value === "none" || value === "category";
+function normalizePublicEventLike(value) {
+  if (!isRecord6(value)) {
+    return null;
+  }
+  const candidate = {
+    ...value,
+    destination: resolveRuntimeEventDestination(value)
+  };
+  const parsed = publicEventSchema.safeParse(candidate);
+  return parsed.success ? parsed.data : null;
 }
 function isEventRegistrationContentEntryLike(value) {
-  return isRecord5(value) && typeof value.id === "string" && typeof value.slug === "string" && typeof value.contentTypeSlug === "string";
+  return isRecord6(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
@@ -15961,7 +16564,10 @@ function toHeadlessPaymentSelection(selection) {
     case "free":
       return { method: "free" };
     case "stripe":
-      return { method: "stripe" };
+      return {
+        method: "stripe",
+        collectionOptionKind: selection.collectionOptionKind
+      };
     case "pass":
       if (!selection.passId) return { method: "none" };
       return {
@@ -15999,7 +16605,10 @@ function toInternalPaymentSelection(selection) {
     case "free":
       return { method: "free" };
     case "stripe":
-      return { method: "stripe" };
+      return {
+        method: "stripe",
+        collectionOptionKind: selection.collectionOptionKind ?? "upfront"
+      };
     case "pass":
       return {
         method: "pass",
@@ -16029,7 +16638,10 @@ function toInternalPaymentSelection(selection) {
 function resolveEventRegistrationSubmitPlan(input) {
   const selection = input.paymentSelection.method ? input.paymentSelection : void 0;
   if (input.canJoinWaitlist) {
-    return { ok: true, args: withOptionalSelection({ method: "free" }, selection) };
+    return {
+      ok: true,
+      args: withOptionalSelection({ method: "free" }, selection)
+    };
   }
   switch (input.paymentSelection.method) {
     case "pass":
@@ -16044,19 +16656,28 @@ function resolveEventRegistrationSubmitPlan(input) {
       return input.paymentSelection.membershipId ? {
         ok: true,
         args: withOptionalSelection(
-          { method: "membership", membershipId: input.paymentSelection.membershipId },
+          {
+            method: "membership",
+            membershipId: input.paymentSelection.membershipId
+          },
           selection
         )
       } : missingPaymentSelection();
     case "free":
-      return { ok: true, args: withOptionalSelection({ method: "free" }, selection) };
+      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 },
+          {
+            method: "pass_bundle",
+            passId: input.paymentSelection.bundlePassId
+          },
           selection
         )
       } : missingPaymentSelection();
@@ -16072,7 +16693,10 @@ function resolveEventRegistrationSubmitPlan(input) {
         )
       } : missingPaymentSelection();
     case "stripe":
-      return { ok: true, args: withOptionalSelection({ method: "stripe" }, selection) };
+      return {
+        ok: true,
+        args: withOptionalSelection({ method: "stripe" }, selection)
+      };
   }
 }
 function resolveHeadlessEventRegistrationStatus(wizard) {
@@ -16234,7 +16858,7 @@ function findSelectedTicketType(input) {
 }
 
 // ../blocks/src/system/runtime/nodes/event-registration/hooks.ts
-import { useState as useState4, useEffect as useEffect8, useCallback as useCallback5, useRef as useRef8, useReducer as useReducer6 } from "react";
+import { useState as useState3, useEffect as useEffect8, useCallback as useCallback5, useRef as useRef9, useReducer as useReducer7 } from "react";
 
 // ../blocks/src/system/runtime/nodes/event-registration/hooks.state.ts
 var initialEligibilityLookupState = {
@@ -16265,7 +16889,7 @@ function eligibilityLookupReducer(state, action) {
         error: action.message
       };
     default:
-      return assertNever11(action);
+      return assertNever4(action);
   }
 }
 var initialExistingRegistrationLookupState = {
@@ -16287,15 +16911,15 @@ function existingRegistrationLookupReducer(state, action) {
         registration: action.registration
       };
     default:
-      return assertNever11(action);
+      return assertNever4(action);
   }
 }
 
 // ../blocks/src/system/runtime/nodes/event-registration/hooks.ts
 function usePortalAuth() {
   const api = useBlockApi();
-  const [authState, setAuthState] = useState4("checking");
-  const [profile, setProfile] = useState4(null);
+  const [authState, setAuthState] = useState3("checking");
+  const [profile, setProfile] = useState3(null);
   useEffect8(() => {
     let cancelled = false;
     async function checkPortalAuth() {
@@ -16342,11 +16966,11 @@ function usePortalAuth() {
 }
 function useEligibility(params) {
   const api = useBlockApi();
-  const [state, dispatch] = useReducer6(
+  const [state, dispatch] = useReducer7(
     eligibilityLookupReducer,
     initialEligibilityLookupState
   );
-  const requestIdRef = useRef8(0);
+  const requestIdRef = useRef9(0);
   useEffect8(() => {
     let cancelled = false;
     async function fetchEligibility() {
@@ -16401,11 +17025,11 @@ function useExistingEventRegistration({
   occurrenceId
 }) {
   const api = useBlockApi();
-  const [state, dispatch] = useReducer6(
+  const [state, dispatch] = useReducer7(
     existingRegistrationLookupReducer,
     initialExistingRegistrationLookupState
   );
-  const requestIdRef = useRef8(0);
+  const requestIdRef = useRef9(0);
   useEffect8(() => {
     let cancelled = false;
     async function fetchExistingRegistration() {
@@ -16607,8 +17231,100 @@ function cleanupStaleRegistrations() {
   }
 }
 
+// ../blocks/src/system/runtime/nodes/event-registration/eventPaymentOptions.ts
+var DEFAULT_EVENT_DIRECT_PAYMENT_OPTION = {
+  kind: "upfront"
+};
+function buildEventRegistrationPaymentOptionsViewModel(input) {
+  const supportedOptions = selectSupportedEventDirectPaymentOptions(
+    input.paymentTerms
+  );
+  const selection = buildBookingPaymentSelectionViewModel({
+    serviceTitle: input.eventTitle,
+    paymentTerms: { allowedOptions: [...supportedOptions] },
+    priceAmount: input.totalPriceCents,
+    priceCurrency: input.currency,
+    bookingStartAt: input.startsAt,
+    locale: input.locale
+  });
+  return {
+    mode: selection.mode,
+    sectionTitle: selection.sectionTitle,
+    options: selection.options.map(
+      (option) => toEventDirectPaymentOption(option, selection.mode)
+    )
+  };
+}
+function selectSupportedEventDirectPaymentOptions(paymentTerms) {
+  const supported = paymentTerms?.allowedOptions.filter(isSupportedEventDirectPaymentOption) ?? [];
+  return supported.length > 0 ? supported : [DEFAULT_EVENT_DIRECT_PAYMENT_OPTION];
+}
+function isSupportedEventDirectPaymentOption(option) {
+  return option.kind === "upfront" || option.kind === "flexible_balance";
+}
+function toEventDirectPaymentOption(option, mode) {
+  switch (option.kind) {
+    case "upfront":
+      return {
+        ...option,
+        kind: "upfront",
+        label: mode === "choice_required" ? "Pay in full now" : "Pay by card"
+      };
+    case "flexible_balance":
+      return {
+        ...option,
+        kind: "flexible_balance",
+        label: "Pay deposit now"
+      };
+    case "deferred_manual":
+    case "instalment_plan":
+      throw new Error(
+        `Unsupported event registration payment option: ${option.kind}`
+      );
+  }
+}
+function resolveEventRegistrationDirectPaymentSelection(input) {
+  if (input.selection.method !== "stripe") {
+    return { kind: "not-stripe" };
+  }
+  const fallbackOption = input.options[0];
+  if (!fallbackOption) {
+    return { kind: "unavailable" };
+  }
+  const requestedKind = input.selection.collectionOptionKind;
+  const selectedOption = requestedKind == null ? input.options.find((option) => option.kind === "upfront") : input.options.find((option) => option.kind === requestedKind);
+  if (selectedOption) {
+    return {
+      kind: "valid",
+      selection: {
+        method: "stripe",
+        collectionOptionKind: selectedOption.kind
+      }
+    };
+  }
+  return {
+    kind: "invalid",
+    fallbackSelection: {
+      method: "stripe",
+      collectionOptionKind: fallbackOption.kind
+    }
+  };
+}
+function normalizeEventRegistrationDirectPaymentSelection(input) {
+  const selectionState = resolveEventRegistrationDirectPaymentSelection(input);
+  switch (selectionState.kind) {
+    case "valid":
+      return selectionState.selection;
+    case "invalid":
+      return selectionState.fallbackSelection;
+    case "not-stripe":
+    case "unavailable":
+      return input.selection;
+  }
+}
+
 // ../blocks/src/system/runtime/nodes/event-registration/useEventRegistrationWizard.ts
-import { useCallback as useCallback6, useEffect as useEffect11, useMemo as useMemo6, useReducer as useReducer8, useState as useState5 } from "react";
+import { useCallback as useCallback6, useEffect as useEffect11, useMemo as useMemo6, useReducer as useReducer9, useState as useState4 } from "react";
 
 // ../blocks/src/system/runtime/nodes/event-registration/validation.ts
 function validateFormData2(formData) {
@@ -16625,7 +17341,7 @@ function validateFormData2(formData) {
 }
 
 // ../blocks/src/system/runtime/shared/useWaitlistClaim.ts
-import { useEffect as useEffect9, useReducer as useReducer7, useSyncExternalStore } from "react";
+import { useEffect as useEffect9, useReducer as useReducer8, useSyncExternalStore } from "react";
 
 // ../blocks/src/system/runtime/shared/useWaitlistClaim.state.ts
 var DEFAULT_WAITLIST_CLAIM_ERROR = "Failed to resolve waitlist claim";
@@ -16731,7 +17447,7 @@ function useWaitlistClaim() {
     getWaitlistClaimTokenSnapshot,
     () => null
   );
-  const [state, dispatch] = useReducer7(
+  const [state, dispatch] = useReducer8(
     waitlistClaimReducer,
     Boolean(token),
     createInitialWaitlistClaimState
@@ -17055,7 +17771,7 @@ function useEventRegistrationWizard(options) {
     [scopedEvents, options.occurrenceContext]
   );
   const hasPreSelectedContext = !!(options.occurrenceContext || preSelectedEvent);
-  const [flowState, dispatchFlow] = useReducer8(
+  const [flowState, dispatchFlow] = useReducer9(
     registrationFlowReducer,
     hasPreSelectedContext,
     createInitialRegistrationFlowState
@@ -17063,24 +17779,24 @@ function useEventRegistrationWizard(options) {
   const step = flowState.step;
   const ticketsCount = flowState.ticketsCount;
   const paymentSelection = flowState.paymentSelection;
-  const [selectedEvent, setSelectedEvent] = useState5(preSelectedEvent ?? null);
-  const [formData, setFormData] = useState5({ name: "", email: "", phone: "", notes: "" });
-  const [errors, setErrors] = useState5({});
-  const [guests, setGuests] = useState5([]);
-  const [guestErrors, setGuestErrors] = useState5({});
-  const [guestSectionShake, setGuestSectionShake] = useState5(false);
-  const [selectedAttendanceMode, setSelectedAttendanceMode] = useState5(
+  const [selectedEvent, setSelectedEvent] = useState4(preSelectedEvent ?? null);
+  const [formData, setFormData] = useState4({ name: "", email: "", phone: "", notes: "" });
+  const [errors, setErrors] = useState4({});
+  const [guests, setGuests] = useState4([]);
+  const [guestErrors, setGuestErrors] = useState4({});
+  const [guestSectionShake, setGuestSectionShake] = useState4(false);
+  const [selectedAttendanceMode, setSelectedAttendanceMode] = useState4(
     preSelectedEvent?.deliveryMode === "online" ? "online" : preSelectedEvent?.deliveryMode === "in_person" ? "in_person" : null
   );
-  const [selectedTicketTypeId, setSelectedTicketTypeId] = useState5(null);
-  const [registrationResult, setRegistrationResult] = useState5(null);
-  const [errorMessage, setErrorMessage] = useState5("");
-  const [altchaSolution, setAltchaSolution] = useState5(null);
+  const [selectedTicketTypeId, setSelectedTicketTypeId] = useState4(null);
+  const [registrationResult, setRegistrationResult] = useState4(null);
+  const [errorMessage, setErrorMessage] = useState4("");
+  const [altchaSolution, setAltchaSolution] = useState4(null);
   const { authState: portalAuthState, profile: portalProfile } = usePortalAuth();
   const waitlistClaim = useWaitlistClaim();
-  const [showMagicLinkModal, setShowMagicLinkModal] = useState5(false);
-  const [pendingAttendeeId, setPendingAttendeeId] = useState5(null);
-  const [paymentStepState, setPaymentStepState] = useState5({
+  const [showMagicLinkModal, setShowMagicLinkModal] = useState4(false);
+  const [pendingAttendeeId, setPendingAttendeeId] = useState4(null);
+  const [paymentStepState, setPaymentStepState] = useState4({
     status: "loading",
     canContinue: false,
     buttonText: "Continue",
@@ -18277,10 +18993,10 @@ function buildResponsiveScopeRulePatternSource() {
 }
 
 // ../theme-core/src/ThemeScopeCore.tsx
-import { jsx as jsx12, jsxs as jsxs9 } from "react/jsx-runtime";
+import { jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
 
 // ../theme-core/src/ClientThemeScope.tsx
-import { jsx as jsx13 } from "react/jsx-runtime";
+import { jsx as jsx12 } from "react/jsx-runtime";
 
 // ../blocks/src/system/runtime/hooks/useHeadlessEventRegistrationFlow.ts
 import React4, { useCallback as useCallback7, useMemo as useMemo8 } from "react";
@@ -18310,10 +19026,24 @@ function useEventRegistrationController(options) {
     ]
   );
   const currentStep = steps.find((step) => step.state === "active") ?? null;
+  const directPaymentOptions = useMemo8(
+    () => resolveHeadlessDirectPaymentOptions(wizard),
+    [
+      wizard.eligibility,
+      wizard.occurrenceContext,
+      wizard.preSelectedEvent,
+      wizard.selectedEvent,
+      wizard.ticketsCount
+    ]
+  );
   const submit = useCallback7(
     async (submitOptions) => {
+      const paymentSelection = normalizeEventRegistrationDirectPaymentSelection({
+        options: directPaymentOptions,
+        selection: wizard.paymentSelection
+      });
       const plan = resolveEventRegistrationSubmitPlan({
-        paymentSelection: wizard.paymentSelection,
+        paymentSelection,
         eventRequiresPayment: wizard.eventRequiresPayment,
         canJoinWaitlist: wizard.eligibility?.canJoinWaitlist
       });
@@ -18332,7 +19062,7 @@ function useEventRegistrationController(options) {
         submitOptions
       );
     },
-    [wizard]
+    [directPaymentOptions, wizard]
   );
   const next = useCallback7(async () => {
     switch (wizard.step) {
@@ -18418,9 +19148,14 @@ function useEventRegistrationController(options) {
   );
   const selectPayment = useCallback7(
     (selection) => {
-      wizard.handlePaymentSelectionChange(toInternalPaymentSelection(selection));
+      wizard.handlePaymentSelectionChange(
+        normalizeEventRegistrationDirectPaymentSelection({
+          options: directPaymentOptions,
+          selection: toInternalPaymentSelection(selection)
+        })
+      );
     },
-    [wizard]
+    [directPaymentOptions, wizard]
   );
   const showSpamProtection = options.spamProtectionEnabled ?? isSpamProtectionEnabled();
   const spamProtection = showSpamProtection ? {
@@ -18429,7 +19164,7 @@ function useEventRegistrationController(options) {
     challenge: { url: getChallengeUrl(), auto: "onfocus" },
     solution: wizard.altchaSolution
   } : { enabled: false };
-  const payment = resolvePaymentModel(wizard);
+  const payment = resolvePaymentModel(wizard, directPaymentOptions);
   const flow = {
     status: resolveHeadlessEventRegistrationStatus(wizard),
     view: resolveHeadlessEventRegistrationView(wizard),
@@ -18534,12 +19269,22 @@ function resolveExistingRegistrationState(wizard) {
       return { tag: "loaded", value: wizard.existingRegistration };
   }
 }
-function resolvePaymentModel(wizard) {
-  const selection = toHeadlessPaymentSelection(wizard.paymentSelection);
+function resolvePaymentModel(wizard, directPaymentOptions) {
+  const internalSelection = normalizeEventRegistrationDirectPaymentSelection({
+    options: directPaymentOptions,
+    selection: wizard.paymentSelection
+  });
+  const selection = toHeadlessPaymentSelection(internalSelection);
+  const directPaymentSelectionState = resolveEventRegistrationDirectPaymentSelection({
+    options: directPaymentOptions,
+    selection: internalSelection
+  });
   if (wizard.step !== "select-payment") {
     return {
       kind: "hidden",
       selection,
+      directPaymentOptions,
+      directPaymentSelectionState,
       stepState: wizard.paymentStepState
     };
   }
@@ -18547,14 +19292,30 @@ function resolvePaymentModel(wizard) {
   return {
     kind: status,
     selection,
+    directPaymentOptions,
+    directPaymentSelectionState,
     stepState: wizard.paymentStepState,
     eligibility: wizard.eligibility,
     eligibilityError: wizard.eligibilityError
   };
 }
+function resolveHeadlessDirectPaymentOptions(wizard) {
+  const eligibility = wizard.eligibility;
+  if (!eligibility?.eligible || !eligibility.canPayDirectly || !eligibility.price) {
+    return [];
+  }
+  const event = wizard.selectedEvent ?? wizard.preSelectedEvent;
+  return buildEventRegistrationPaymentOptionsViewModel({
+    eventTitle: event?.title ?? "Event",
+    paymentTerms: event?.paymentTerms,
+    totalPriceCents: eligibility.price * wizard.ticketsCount,
+    currency: eligibility.currency,
+    startsAt: wizard.occurrenceContext?.startsAt ?? event?.startsAt
+  }).options;
+}
 
 // ../blocks/src/system/runtime/hooks/useBookingFormConfig.ts
-import { useEffect as useEffect12, useReducer as useReducer9 } from "react";
+import { useEffect as useEffect12, useReducer as useReducer10 } from "react";
 
 // ../blocks/src/system/runtime/hooks/useBookingFormConfig.state.ts
 var EMPTY_SNAPSHOT = Object.freeze({
@@ -18609,7 +19370,7 @@ function bookingFormConfigReducer(state, action) {
         previous: toBookingFormConfigSnapshot(state)
       };
     default:
-      return assertNever11(action);
+      return assertNever4(action);
   }
 }
 function selectBookingFormConfig(state) {
@@ -18635,14 +19396,14 @@ function toBookingFormConfigSnapshot(state) {
         services: state.services
       };
     default:
-      return assertNever11(state);
+      return assertNever4(state);
   }
 }
 
 // ../blocks/src/system/runtime/hooks/useBookingFormConfig.ts
 function useBookingFormConfig(siteId, formId) {
   const api = useBlockApi();
-  const [state, dispatch] = useReducer9(
+  const [state, dispatch] = useReducer10(
     bookingFormConfigReducer,
     void 0,
     createInitialBookingFormConfigState