@riverbankcms/sdk 0.84.2 → 0.88.0

package/dist/server/next.mjs

@@ -784,6 +784,64 @@ var ENDPOINT_DEFINITIONS = {
     auth: "user",
     responseKind: "json"
   },
+  listMailchimpAudiences: {
+    path: "/sites/{siteId}/integrations/mailchimp/audiences",
+    method: "GET",
+    tags: [TAG_TEMPLATES.site],
+    auth: "user",
+    responseKind: "json",
+    errors: ["auth:forbidden", "server:internal_error"]
+  },
+  getMailchimpSignupSyncHealth: {
+    path: "/sites/{siteId}/integrations/mailchimp/signup-sync-health",
+    method: "GET",
+    tags: [TAG_TEMPLATES.site],
+    auth: "user",
+    responseKind: "json",
+    errors: ["auth:forbidden", "server:internal_error"]
+  },
+  getMailchimpConnection: {
+    path: "/sites/{siteId}/integrations/mailchimp/connection",
+    method: "GET",
+    tags: [TAG_TEMPLATES.site],
+    auth: "user",
+    responseKind: "json",
+    errors: ["auth:forbidden", "server:internal_error"]
+  },
+  startMailchimpOAuth: {
+    path: "/sites/{siteId}/integrations/mailchimp/oauth/start",
+    method: "POST",
+    tags: [TAG_TEMPLATES.site],
+    auth: "user",
+    responseKind: "json",
+    demoMutation: DEMO_MUTATION_BLOCKED_DISABLED,
+    errors: ["auth:forbidden", "validation:invalid_input", "server:internal_error"]
+  },
+  refreshMailchimpAudiences: {
+    path: "/sites/{siteId}/integrations/mailchimp/audiences/refresh",
+    method: "POST",
+    tags: [TAG_TEMPLATES.site],
+    auth: "user",
+    responseKind: "json",
+    demoMutation: DEMO_MUTATION_BLOCKED_DISABLED,
+    errors: ["auth:forbidden", "server:internal_error"]
+  },
+  disconnectMailchimp: {
+    path: "/sites/{siteId}/integrations/mailchimp/disconnect",
+    method: "POST",
+    tags: [TAG_TEMPLATES.site],
+    auth: "user",
+    responseKind: "json",
+    demoMutation: DEMO_MUTATION_BLOCKED_DISABLED,
+    errors: ["auth:forbidden", "server:internal_error"]
+  },
+  mailchimpOAuthCallback: {
+    path: "/auth/mailchimp/callback",
+    method: "GET",
+    auth: "public",
+    responseKind: "void",
+    errors: []
+  },
   createNewsletterList: {
     path: "/sites/{siteId}/newsletter/lists",
     method: "POST",
@@ -3008,20 +3066,6 @@ var ENDPOINT_DEFINITIONS = {
     auth: "user",
     responseKind: "json"
   },
-  instagramUploadZip: {
-    path: "/instagram/upload-zip",
-    method: "POST",
-    tags: ["instagram-import"],
-    auth: "user",
-    responseKind: "json"
-  },
-  createInstagramZipUploadUrl: {
-    path: "/instagram/upload-zip-url",
-    method: "POST",
-    tags: ["instagram-import"],
-    auth: "user",
-    responseKind: "json"
-  },
   getAnalyticsReport: {
     path: "/sites/{siteId}/analytics/report",
     method: "GET",
@@ -6420,6 +6464,48 @@ function err(error) {
 // ../core/src/branded.ts
 var unsafeAsMediaAssetId = (id) => id;
 
+// ../core/src/assert-never.ts
+function assertNever(value, message = "Unexpected variant") {
+  throw new Error(`${message}: ${String(value)}`);
+}
+
+// ../core/src/currency-format.ts
+var CURRENCY_LOCALE_BY_CODE = {
+  USD: "en-US",
+  GBP: "en-GB",
+  EUR: "de-DE",
+  AUD: "en-AU",
+  CAD: "en-CA",
+  NZD: "en-NZ",
+  JPY: "ja-JP",
+  CNY: "zh-CN",
+  CHF: "de-CH"
+};
+function resolveCurrencyLocale(currencyCode, override) {
+  return override ?? CURRENCY_LOCALE_BY_CODE[currencyCode] ?? "en";
+}
+function formatCurrencyAmount(amountCents, currency, options) {
+  const currencyCode = currency.toUpperCase();
+  const locale = resolveCurrencyLocale(currencyCode, options?.locale);
+  try {
+    const exactFormatter = new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency: currencyCode
+    });
+    const fractionDigits = options?.decimals === "auto" ? {
+      minimumFractionDigits: 0,
+      maximumFractionDigits: exactFormatter.resolvedOptions().maximumFractionDigits
+    } : {};
+    return new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency: currencyCode,
+      ...fractionDigits
+    }).format(amountCents / 100);
+  } catch {
+    return `${(amountCents / 100).toFixed(2)} ${currencyCode}`;
+  }
+}
+
 // ../core/src/event-pricing.ts
 function publicEventPricingDisplay(pricing) {
   return pricing.display;
@@ -6454,11 +6540,48 @@ function isFreePublicEventPriceDisplay(display) {
       return display.display.kind === "free";
     case "exact":
     case "from":
+    case "range":
     case "mixed":
     case "unavailable":
       return false;
   }
 }
+function formatCoursePriceDisplayLabel(display, options) {
+  switch (display.kind) {
+    case "free":
+    case "unavailable":
+      return "Course";
+    case "exact":
+      return `Course (${formatCurrencyAmount(display.amount, display.currency, options)})`;
+    case "from":
+      return `Course (From ${formatCurrencyAmount(display.amount, display.currency, options)})`;
+    default:
+      return assertNever(display);
+  }
+}
+function formatBookingPriceDisplay(display, options = {}) {
+  switch (display.kind) {
+    case "free":
+      return "Free";
+    case "exact":
+      return formatCurrencyAmount(display.amount, display.currency, options);
+    case "from":
+      return `From ${formatCurrencyAmount(display.amount, display.currency, options)}`;
+    case "range":
+      return `${formatCurrencyAmount(display.minAmount, display.currency, options)} - ${formatCurrencyAmount(display.maxAmount, display.currency, options)}`;
+    case "mixed":
+      return display.paidToAmount > display.paidFromAmount ? `Free / ${formatCurrencyAmount(display.paidFromAmount, display.currency, options)} - ${formatCurrencyAmount(display.paidToAmount, display.currency, options)}` : `Free / ${formatCurrencyAmount(display.paidFromAmount, display.currency, options)}`;
+    case "unavailable":
+      return "Pricing unavailable";
+    case "course":
+      return formatCoursePriceDisplayLabel(display.display, options);
+    default:
+      return assertNever(display);
+  }
+}
+function formatEventPricing(pricing, options = {}) {
+  return formatBookingPriceDisplay(publicEventPricingDisplay(pricing), options);
+}
 
 // ../core/src/booking-date-time.ts
 var DEFAULT_LOCALE = "en-US";
@@ -6704,11 +6827,6 @@ function toLocationCoordinates(value) {
   };
 }
 
-// ../core/src/assert-never.ts
-function assertNever(value, message = "Unexpected variant") {
-  throw new Error(`${message}: ${String(value)}`);
-}
-
 // ../core/src/planner.ts
 var systemPlanningClock = {
   now: () => Date.now()
@@ -26932,15 +27050,53 @@ var newsletterFormFragment = defineFragment({
   title: "Newsletter Form",
   description: "Newsletter subscription form with preset field configurations.",
   fields: [
+    {
+      id: "destinationProvider",
+      type: "select",
+      label: "Send signups to",
+      description: "Choose where new subscribers from this form should go.",
+      defaultValue: "riverbank",
+      required: true,
+      ui: { intent: "behavior" },
+      options: [
+        { value: "riverbank", label: "Riverbank newsletter" }
+      ]
+    },
     {
       id: "listId",
       type: "reference",
       label: "Newsletter list",
       description: "Select the list new subscribers should be added to.",
-      required: true,
+      required: false,
       referenceKind: "newsletterList",
       allowManualEntry: false,
-      ui: { intent: "behavior" }
+      ui: {
+        intent: "behavior",
+        visibleWhen: { field: "destinationProvider", equals: "riverbank" }
+      }
+    },
+    {
+      id: "mailchimpAudienceId",
+      type: "reference",
+      label: "Mailchimp audience",
+      description: "Choose the Mailchimp audience for new subscribers.",
+      required: false,
+      referenceKind: "mailchimpAudience",
+      allowManualEntry: false,
+      ui: {
+        intent: "behavior",
+        visibleWhen: { field: "destinationProvider", equals: "mailchimp" }
+      }
+    },
+    {
+      id: "mailchimpTags",
+      type: "text",
+      label: "Mailchimp tags",
+      description: "Optional tags to apply in Mailchimp, separated by commas or semicolons.",
+      ui: {
+        intent: "behavior",
+        visibleWhen: { field: "destinationProvider", equals: "mailchimp" }
+      }
     },
     {
       id: "preset",
@@ -26987,13 +27143,18 @@ var newsletterFormFragment = defineFragment({
       id: "tags",
       type: "text",
       label: "Tags (optional)",
-      description: "Optional tags to apply on subscribe (comma or semicolon separated)."
+      description: "Optional tags to apply on subscribe (comma or semicolon separated).",
+      ui: {
+        intent: "behavior",
+        visibleWhen: { field: "destinationProvider", equals: "riverbank" }
+      }
     }
   ],
   layout: [
     el(
       "newsletter-form",
       withApiBindings({
+        destinationProvider: { $bind: { from: "destinationProvider" } },
         listId: { $bind: { from: "listId" } },
         preset: { $bind: { from: "preset" } },
         includePhone: { $bind: { from: "includePhone" } },
@@ -32916,10 +33077,10 @@ var appointmentBookingBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/event-registration.ts
-import { z as z49 } from "zod";
+import { z as z50 } from "zod";
 
 // ../blocks/src/system/blocks/events/shared/schemas.ts
-import { z as z45 } from "zod";
+import { z as z46 } from "zod";
 
 // ../blocks/src/lib/media.ts
 import z42 from "zod";
@@ -32997,296 +33158,393 @@ var mediaSchema2 = z42.discriminatedUnion("type", [
   archiveMediaSchema
 ]);
 
-// ../blocks/src/system/blocks/shared/bookingPaymentTerms.ts
+// ../blocks/src/system/manifest/richTextSchema.ts
 import { z as z43 } from "zod";
-var bookingDepositRefundPolicySchema = z43.enum([
+var TipTapMarkSchema = z43.object({
+  type: z43.string(),
+  attrs: z43.record(z43.string(), z43.unknown()).optional()
+});
+var TipTapNodeSchema = z43.lazy(
+  () => z43.object({
+    type: z43.string(),
+    content: z43.array(TipTapNodeSchema).optional(),
+    text: z43.string().optional(),
+    attrs: z43.record(z43.string(), z43.unknown()).optional(),
+    marks: z43.array(TipTapMarkSchema).optional()
+  })
+);
+var RichTextValueSchema = z43.union([
+  // Canonical: TipTap document directly
+  TipTapNodeSchema,
+  // Legacy (read-tolerance only): wrapped in { doc: {...} }
+  z43.object({
+    doc: TipTapNodeSchema
+  })
+]);
+var RichTextDocSchema = z43.object({
+  type: z43.literal("doc"),
+  content: z43.array(TipTapNodeSchema)
+});
+function unwrapRichTextRoot(value) {
+  if (!isRecord4(value)) return value;
+  if (!("doc" in value)) return value;
+  const inner = value.doc;
+  if (isRecord4(inner) && inner.type === "doc") return inner;
+  return value;
+}
+function createHardBreakNode() {
+  return { type: "hardBreak" };
+}
+function parseRichTextInlineMarkdown(text2) {
+  const out = [];
+  const pushText = (value, marks) => {
+    if (!value) return;
+    out.push(
+      marks && marks.length > 0 ? { type: "text", text: value, marks } : { type: "text", text: value }
+    );
+  };
+  let rest = text2;
+  while (rest.length > 0) {
+    const start = rest.indexOf("**");
+    if (start === -1) {
+      pushText(rest);
+      break;
+    }
+    const end = rest.indexOf("**", start + 2);
+    if (end === -1) {
+      pushText(rest);
+      break;
+    }
+    pushText(rest.slice(0, start));
+    pushText(rest.slice(start + 2, end), [{ type: "bold" }]);
+    rest = rest.slice(end + 2);
+  }
+  return out;
+}
+function parseRichTextParagraphInlineMarkdown(text2) {
+  return text2.split("\n").flatMap((line, index) => {
+    const lineNodes = parseRichTextInlineMarkdown(line.trim());
+    return index === 0 ? lineNodes : [createHardBreakNode(), ...lineNodes];
+  });
+}
+function createRichTextDocFromMarkdown(markdown) {
+  const normalized = markdown.replace(/\r\n/g, "\n").trim();
+  if (!normalized) return { type: "doc", content: [] };
+  const paragraphs = normalized.split(/\n{2,}/).map((paragraph) => paragraph.trim()).filter(Boolean);
+  return {
+    type: "doc",
+    content: paragraphs.map((paragraph) => {
+      const inline2 = parseRichTextParagraphInlineMarkdown(paragraph);
+      return inline2.length > 0 ? { type: "paragraph", content: inline2 } : { type: "paragraph" };
+    })
+  };
+}
+
+// ../blocks/src/system/blocks/shared/bookingPaymentTerms.ts
+import { z as z44 } from "zod";
+var bookingDepositRefundPolicySchema = z44.enum([
   "refundable",
   "non_refundable"
 ]);
-var bookingInstalmentPlanSchema = z43.union([
-  z43.object({
-    kind: z43.literal("deposit_plus_one_remainder"),
-    depositAmountCents: z43.number().int().min(0),
+var bookingInstalmentPlanSchema = z44.union([
+  z44.object({
+    kind: z44.literal("deposit_plus_one_remainder"),
+    depositAmountCents: z44.number().int().min(0),
     depositRefundability: bookingDepositRefundPolicySchema,
-    remainderDueCount: z43.number().int().positive(),
-    intervalUnit: z43.enum(["day", "week", "month"])
+    remainderDueCount: z44.number().int().positive(),
+    intervalUnit: z44.enum(["day", "week", "month"])
   }),
-  z43.object({
-    kind: z43.literal("deposit_plus_scheduled_instalments"),
-    depositAmountCents: z43.number().int().min(0),
+  z44.object({
+    kind: z44.literal("deposit_plus_scheduled_instalments"),
+    depositAmountCents: z44.number().int().min(0),
     depositRefundability: bookingDepositRefundPolicySchema,
-    instalmentCount: z43.number().int().positive(),
-    intervalCount: z43.number().int().positive(),
-    intervalUnit: z43.enum(["day", "week", "month"])
+    instalmentCount: z44.number().int().positive(),
+    intervalCount: z44.number().int().positive(),
+    intervalUnit: z44.enum(["day", "week", "month"])
   }),
-  z43.object({
-    kind: z43.literal("equal_scheduled_instalments"),
-    instalmentCount: z43.number().int().positive(),
-    intervalCount: z43.number().int().positive(),
-    intervalUnit: z43.enum(["day", "week", "month"])
+  z44.object({
+    kind: z44.literal("equal_scheduled_instalments"),
+    instalmentCount: z44.number().int().positive(),
+    intervalCount: z44.number().int().positive(),
+    intervalUnit: z44.enum(["day", "week", "month"])
   })
 ]);
-var bookingFlexibleBalanceDueDateRuleSchema = z43.union([
-  z43.object({
-    kind: z43.literal("relative_to_start_date"),
-    daysBeforeStart: z43.number().int().positive()
+var bookingFlexibleBalanceDueDateRuleSchema = z44.union([
+  z44.object({
+    kind: z44.literal("relative_to_start_date"),
+    daysBeforeStart: z44.number().int().positive()
   }),
-  z43.object({
-    kind: z43.literal("fixed_calendar_date"),
-    dueAt: z43.string().datetime()
+  z44.object({
+    kind: z44.literal("fixed_calendar_date"),
+    dueAt: z44.string().datetime()
   })
 ]);
-var bookingFlexibleBalanceConfigSchema = z43.object({
-  upfrontAmountCents: z43.number().int().min(0),
+var bookingFlexibleBalanceConfigSchema = z44.object({
+  upfrontAmountCents: z44.number().int().min(0),
   dueDateRule: bookingFlexibleBalanceDueDateRuleSchema,
   depositRefundability: bookingDepositRefundPolicySchema
 });
-var blockBookingPaymentCollectionOptionSchema = z43.union([
-  z43.object({
-    kind: z43.literal("upfront")
+var blockBookingPaymentCollectionOptionSchema = z44.union([
+  z44.object({
+    kind: z44.literal("upfront")
   }),
-  z43.object({
-    kind: z43.literal("deferred_manual")
+  z44.object({
+    kind: z44.literal("deferred_manual")
   }),
-  z43.object({
-    kind: z43.literal("instalment_plan"),
+  z44.object({
+    kind: z44.literal("instalment_plan"),
     plan: bookingInstalmentPlanSchema
   }),
-  z43.object({
-    kind: z43.literal("flexible_balance"),
+  z44.object({
+    kind: z44.literal("flexible_balance"),
     config: bookingFlexibleBalanceConfigSchema
   })
 ]);
-var blockBookingPaymentTermsSchema = z43.object({
-  allowedOptions: z43.array(blockBookingPaymentCollectionOptionSchema).min(1)
+var blockBookingPaymentTermsSchema = z44.object({
+  allowedOptions: z44.array(blockBookingPaymentCollectionOptionSchema).min(1)
 });
 
 // ../blocks/src/system/blocks/courses/shared/schemas.ts
-import { z as z44 } from "zod";
-var courseVenueSchema = z44.object({
-  id: z44.string(),
-  name: z44.string(),
-  address: z44.string().nullable()
+import { z as z45 } from "zod";
+var courseVenueSchema = z45.object({
+  id: z45.string(),
+  name: z45.string(),
+  address: z45.string().nullable()
 });
-var courseSessionSchema = z44.object({
-  id: z44.string(),
-  startsAt: z44.string(),
-  endsAt: z44.string(),
-  timeZone: z44.string(),
-  capacityOverride: z44.number().nullable().optional(),
-  overrides: z44.record(z44.string(), z44.unknown()).nullable().optional()
+var courseSessionSchema = z45.object({
+  id: z45.string(),
+  startsAt: z45.string(),
+  endsAt: z45.string(),
+  timeZone: z45.string(),
+  capacityOverride: z45.number().nullable().optional(),
+  overrides: z45.record(z45.string(), z45.unknown()).nullable().optional()
 });
-var courseTeamMemberSummarySchema = z44.object({
-  id: z44.string(),
-  name: z44.string(),
-  roleLabel: z44.string().nullable(),
-  summary: z44.string().nullable(),
-  profilePath: z44.string().nullable()
+var courseTeamMemberSummarySchema = z45.object({
+  id: z45.string(),
+  name: z45.string(),
+  roleLabel: z45.string().nullable(),
+  summary: z45.string().nullable(),
+  profilePath: z45.string().nullable()
 });
-var coursePricingOptionSchema = z44.object({
-  id: z44.string(),
-  name: z44.string(),
-  description: z44.string().nullable(),
-  priceAmount: z44.number(),
-  isActive: z44.boolean(),
-  sortOrder: z44.number(),
-  capacityLimit: z44.number().nullable(),
-  saleStartsAt: z44.string().nullable(),
-  saleEndsAt: z44.string().nullable(),
-  attendanceScope: z44.enum(["in_person", "online", "both"]).nullable().optional()
+var coursePricingOptionSchema = z45.object({
+  id: z45.string(),
+  name: z45.string(),
+  description: z45.string().nullable(),
+  priceAmount: z45.number(),
+  isActive: z45.boolean(),
+  sortOrder: z45.number(),
+  capacityLimit: z45.number().nullable(),
+  saleStartsAt: z45.string().nullable(),
+  saleEndsAt: z45.string().nullable(),
+  attendanceScope: z45.enum(["in_person", "online", "both"]).nullable().optional()
 });
-var coursePricingSchema = z44.object({
-  bookingRequirement: z44.enum(["none", "required"]),
-  pricingStrategy: z44.enum(["free", "single", "tiered"]),
-  currency: z44.string(),
-  singlePriceAmount: z44.number().nullable(),
+var coursePricingSchema = z45.object({
+  bookingRequirement: z45.enum(["none", "required"]),
+  pricingStrategy: z45.enum(["free", "single", "tiered"]),
+  currency: z45.string(),
+  singlePriceAmount: z45.number().nullable(),
   paymentTerms: blockBookingPaymentTermsSchema,
-  options: z44.array(coursePricingOptionSchema)
+  options: z45.array(coursePricingOptionSchema)
 });
-var publicCourseSchema = z44.object({
-  id: z44.string(),
-  title: z44.string(),
-  slug: z44.string(),
-  description: z44.unknown().nullable(),
-  teamMembers: z44.array(courseTeamMemberSummarySchema).optional(),
-  enrollmentOpen: z44.boolean(),
+var publicCourseSchema = z45.object({
+  id: z45.string(),
+  title: z45.string(),
+  slug: z45.string(),
+  description: z45.unknown().nullable(),
+  teamMembers: z45.array(courseTeamMemberSummarySchema).optional(),
+  enrollmentOpen: z45.boolean(),
   pricing: coursePricingSchema.optional(),
-  priceCents: z44.number().nullable(),
-  currency: z44.string(),
+  priceCents: z45.number().nullable(),
+  currency: z45.string(),
   paymentTerms: blockBookingPaymentTermsSchema,
-  enrollmentCapacity: z44.number().nullable(),
-  acceptsMemberships: z44.boolean(),
-  status: z44.enum(["active", "draft", "cancelled"]),
-  sessionsCount: z44.number(),
-  enrolledCount: z44.number(),
-  availableSpots: z44.number().nullable(),
-  sessions: z44.array(courseSessionSchema),
+  enrollmentCapacity: z45.number().nullable(),
+  acceptsMemberships: z45.boolean(),
+  status: z45.enum(["active", "draft", "cancelled"]),
+  sessionsCount: z45.number(),
+  enrolledCount: z45.number(),
+  availableSpots: z45.number().nullable(),
+  sessions: z45.array(courseSessionSchema),
   venue: courseVenueSchema.nullable(),
-  contentEntryId: z44.string().nullable()
+  contentEntryId: z45.string().nullable()
 });
-var publicCoursesArraySchema = z44.array(publicCourseSchema);
+var publicCoursesArraySchema = z45.array(publicCourseSchema);
 
 // ../blocks/src/system/blocks/events/shared/schemas.ts
-var eventPresetSchema = z45.enum(["event", "class", "workshop", "retreat", "performance"]);
-var eventScheduleScopeSchema = z45.enum(["recurring", "oneOff"]);
-var eventDestinationModeSchema = z45.enum(["cms-managed", "system-managed"]);
-var eventVenueSchema = z45.object({
-  id: z45.string(),
-  name: z45.string(),
-  address: z45.string().nullable(),
-  location: z45.object({
-    lat: z45.number(),
-    lng: z45.number()
+var eventPresetSchema = z46.enum(["event", "class", "workshop", "retreat", "performance"]);
+var eventScheduleScopeSchema = z46.enum(["recurring", "oneOff"]);
+var eventDestinationModeSchema = z46.enum(["cms-managed", "system-managed"]);
+var eventVenueSchema = z46.object({
+  id: z46.string(),
+  name: z46.string(),
+  address: z46.string().nullable(),
+  location: z46.object({
+    lat: z46.number(),
+    lng: z46.number()
   }).nullable()
 });
-var eventCategorySchema = z45.object({
-  id: z45.string(),
-  name: z45.string(),
-  color: z45.string().nullable()
+var eventCategorySchema = z46.object({
+  id: z46.string(),
+  name: z46.string(),
+  color: z46.string().nullable()
 });
-var pricingTypeSchema = z45.enum(["free", "paid"]);
-var accessRestrictionSchema = z45.enum(["none", "category"]);
-var eventPricingModeSchema = z45.enum(["single", "ticket_types"]);
-var publicCoursePriceDisplaySchema = z45.discriminatedUnion("kind", [
-  z45.object({ kind: z45.literal("free"), currency: z45.string() }),
-  z45.object({ kind: z45.literal("exact"), amount: z45.number(), currency: z45.string() }),
-  z45.object({ kind: z45.literal("from"), amount: z45.number(), currency: z45.string() }),
-  z45.object({ kind: z45.literal("unavailable"), currency: z45.string() })
+var pricingTypeSchema = z46.enum(["free", "paid"]);
+var accessRestrictionSchema = z46.enum(["none", "category"]);
+var eventPricingModeSchema = z46.enum(["single", "ticket_types"]);
+var publicCoursePriceDisplaySchema = z46.discriminatedUnion("kind", [
+  z46.object({ kind: z46.literal("free"), currency: z46.string() }),
+  z46.object({ kind: z46.literal("exact"), amount: z46.number(), currency: z46.string() }),
+  z46.object({ kind: z46.literal("from"), amount: z46.number(), currency: z46.string() }),
+  z46.object({ kind: z46.literal("unavailable"), currency: z46.string() })
 ]);
-var publicEventPriceDisplaySchema = z45.discriminatedUnion("kind", [
-  z45.object({ kind: z45.literal("free"), currency: z45.string() }),
-  z45.object({ kind: z45.literal("exact"), amount: z45.number(), currency: z45.string() }),
-  z45.object({ kind: z45.literal("from"), amount: z45.number(), currency: z45.string() }),
-  z45.object({ kind: z45.literal("mixed"), paidFromAmount: z45.number(), currency: z45.string() }),
-  z45.object({ kind: z45.literal("unavailable"), currency: z45.string() }),
-  z45.object({ kind: z45.literal("course"), display: publicCoursePriceDisplaySchema })
+var publicEventPriceDisplaySchema = z46.discriminatedUnion("kind", [
+  z46.object({ kind: z46.literal("free"), currency: z46.string() }),
+  z46.object({ kind: z46.literal("exact"), amount: z46.number(), currency: z46.string() }),
+  z46.object({ kind: z46.literal("from"), amount: z46.number(), currency: z46.string() }),
+  z46.object({ kind: z46.literal("range"), minAmount: z46.number(), maxAmount: z46.number(), currency: z46.string() }),
+  z46.object({
+    kind: z46.literal("mixed"),
+    paidFromAmount: z46.number(),
+    paidToAmount: z46.number(),
+    currency: z46.string()
+  }),
+  z46.object({ kind: z46.literal("unavailable"), currency: z46.string() }),
+  z46.object({ kind: z46.literal("course"), display: publicCoursePriceDisplaySchema })
 ]);
-var publicEventTicketTypePriceDisplaySchema = z45.union([
-  z45.object({ kind: z45.literal("free"), currency: z45.string() }),
-  z45.object({ kind: z45.literal("exact"), amount: z45.number(), currency: z45.string() }),
-  z45.object({ kind: z45.literal("from"), amount: z45.number(), currency: z45.string() }),
-  z45.object({ kind: z45.literal("mixed"), paidFromAmount: z45.number(), currency: z45.string() }),
-  z45.object({ kind: z45.literal("unavailable"), currency: z45.string() })
+var publicEventTicketTypePriceDisplaySchema = z46.union([
+  z46.object({ kind: z46.literal("free"), currency: z46.string() }),
+  z46.object({ kind: z46.literal("exact"), amount: z46.number(), currency: z46.string() }),
+  z46.object({ kind: z46.literal("from"), amount: z46.number(), currency: z46.string() }),
+  z46.object({ kind: z46.literal("range"), minAmount: z46.number(), maxAmount: z46.number(), currency: z46.string() }),
+  z46.object({
+    kind: z46.literal("mixed"),
+    paidFromAmount: z46.number(),
+    paidToAmount: z46.number(),
+    currency: z46.string()
+  }),
+  z46.object({ kind: z46.literal("unavailable"), currency: z46.string() })
 ]);
-var publicEventAttendanceModeSchema = z45.enum(["in_person", "online"]);
-var publicEventAttendanceModeAvailabilitySchema = z45.object({
+var publicEventAttendanceModeSchema = z46.enum(["in_person", "online"]);
+var publicEventAttendanceModeAvailabilitySchema = z46.object({
   mode: publicEventAttendanceModeSchema,
-  capacity: z45.number().nullable(),
-  registeredCount: z45.number(),
-  availableSpots: z45.number().nullable(),
-  waitlistEnabled: z45.boolean()
+  capacity: z46.number().nullable(),
+  registeredCount: z46.number(),
+  availableSpots: z46.number().nullable(),
+  waitlistEnabled: z46.boolean()
 });
-var publicEventTicketTypeAvailabilitySchema = z45.union([
-  z45.object({
-    kind: z45.literal("available"),
-    remainingCapacity: z45.number().nullable()
+var publicEventTicketTypeAvailabilitySchema = z46.union([
+  z46.object({
+    kind: z46.literal("available"),
+    remainingCapacity: z46.number().nullable()
   }),
-  z45.object({
-    kind: z45.literal("unavailable"),
-    reason: z45.enum(["inactive", "not_on_sale_yet", "sale_ended", "sold_out", "event_sold_out"]),
-    remainingCapacity: z45.number().nullable()
+  z46.object({
+    kind: z46.literal("unavailable"),
+    reason: z46.enum(["inactive", "not_on_sale_yet", "sale_ended", "sold_out", "event_sold_out"]),
+    remainingCapacity: z46.number().nullable()
   })
 ]);
-var publicEventTicketTypeSchema = z45.object({
-  id: z45.string(),
-  siteId: z45.string(),
-  eventSeriesId: z45.string(),
-  name: z45.string(),
-  description: z45.string().nullable(),
-  priceAmount: z45.number(),
-  isActive: z45.boolean(),
-  sortOrder: z45.number(),
-  capacityMode: z45.enum(["limited", "unlimited"]),
-  capacityLimit: z45.number().nullable(),
-  attendanceScope: z45.enum(["in_person", "online", "both"]).optional(),
-  saleStartsAt: z45.string().nullable(),
-  saleEndsAt: z45.string().nullable(),
+var publicEventTicketTypeSchema = z46.object({
+  id: z46.string(),
+  siteId: z46.string(),
+  eventSeriesId: z46.string(),
+  name: z46.string(),
+  description: z46.string().nullable(),
+  priceAmount: z46.number(),
+  isActive: z46.boolean(),
+  sortOrder: z46.number(),
+  capacityMode: z46.enum(["limited", "unlimited"]),
+  capacityLimit: z46.number().nullable(),
+  attendanceScope: z46.enum(["in_person", "online", "both"]).optional(),
+  saleStartsAt: z46.string().nullable(),
+  saleEndsAt: z46.string().nullable(),
   availability: publicEventTicketTypeAvailabilitySchema,
-  createdAt: z45.string(),
-  updatedAt: z45.string()
+  createdAt: z46.string(),
+  updatedAt: z46.string()
 });
-var publicEventPricingSchema = z45.discriminatedUnion("kind", [
-  z45.object({
-    kind: z45.literal("drop_in"),
-    currency: z45.string(),
-    display: z45.object({ kind: z45.literal("free"), currency: z45.string() })
+var publicEventPricingSchema = z46.discriminatedUnion("kind", [
+  z46.object({
+    kind: z46.literal("drop_in"),
+    currency: z46.string(),
+    display: z46.object({ kind: z46.literal("free"), currency: z46.string() })
   }),
-  z45.object({
-    kind: z45.literal("free_registration"),
-    currency: z45.string(),
-    display: z45.object({ kind: z45.literal("free"), currency: z45.string() })
+  z46.object({
+    kind: z46.literal("free_registration"),
+    currency: z46.string(),
+    display: z46.object({ kind: z46.literal("free"), currency: z46.string() })
   }),
-  z45.object({
-    kind: z45.literal("single_paid"),
-    amount: z45.number(),
-    currency: z45.string(),
-    display: z45.object({ kind: z45.literal("exact"), amount: z45.number(), currency: z45.string() })
+  z46.object({
+    kind: z46.literal("single_paid"),
+    amount: z46.number(),
+    currency: z46.string(),
+    display: z46.object({ kind: z46.literal("exact"), amount: z46.number(), currency: z46.string() })
   }),
-  z45.object({
-    kind: z45.literal("ticket_types"),
-    currency: z45.string(),
-    ticketTypes: z45.array(publicEventTicketTypeSchema),
+  z46.object({
+    kind: z46.literal("ticket_types"),
+    currency: z46.string(),
+    ticketTypes: z46.array(publicEventTicketTypeSchema),
     display: publicEventTicketTypePriceDisplaySchema
   }),
-  z45.object({
-    kind: z45.literal("course"),
-    display: z45.object({ kind: z45.literal("course"), display: publicCoursePriceDisplaySchema })
+  z46.object({
+    kind: z46.literal("course"),
+    display: z46.object({ kind: z46.literal("course"), display: publicCoursePriceDisplaySchema })
   })
 ]);
-var publicTeamMemberSummarySchema = z45.object({
-  id: z45.string(),
-  name: z45.string(),
-  roleLabel: z45.string().nullable(),
-  summary: z45.string().nullable(),
-  profilePath: z45.string().nullable()
+var publicTeamMemberSummarySchema = z46.object({
+  id: z46.string(),
+  name: z46.string(),
+  roleLabel: z46.string().nullable(),
+  summary: z46.string().nullable(),
+  profilePath: z46.string().nullable()
 });
-var publicEventSchema = z45.object({
-  kind: z45.enum(["event", "course_session"]).optional(),
+var publicEventSchema = z46.object({
+  kind: z46.enum(["event", "course_session"]).optional(),
   eventPreset: eventPresetSchema.optional(),
   eventDestinationMode: eventDestinationModeSchema.optional(),
   scheduleScope: eventScheduleScopeSchema.optional(),
-  id: z45.string(),
-  occurrenceId: z45.string(),
-  seriesId: z45.string(),
-  title: z45.string(),
-  description: z45.string().nullable(),
-  presentation: z45.object({
-    cardTitleOverride: z45.string().nullable().optional(),
-    summary: z45.string().nullable().optional(),
+  id: z46.string(),
+  occurrenceId: z46.string(),
+  seriesId: z46.string(),
+  title: z46.string(),
+  description: z46.string().nullable(),
+  content: z46.object({
+    body: RichTextDocSchema.nullable().optional()
+  }).optional(),
+  presentation: z46.object({
+    cardTitleOverride: z46.string().nullable().optional(),
+    summary: z46.string().nullable().optional(),
     image: mediaSchema2.nullable().optional()
   }).optional(),
-  slug: z45.string(),
-  path: z45.string(),
-  requiresRegistration: z45.boolean(),
-  deliveryMode: z45.enum(["in_person", "online", "hybrid"]),
-  attendanceModes: z45.array(publicEventAttendanceModeAvailabilitySchema),
-  startsAt: z45.string(),
-  endsAt: z45.string(),
-  capacity: z45.number().nullable(),
-  registeredCount: z45.number(),
-  availableSpots: z45.number().nullable(),
-  waitlistEnabled: z45.boolean(),
+  slug: z46.string(),
+  path: z46.string(),
+  requiresRegistration: z46.boolean(),
+  deliveryMode: z46.enum(["in_person", "online", "hybrid"]),
+  attendanceModes: z46.array(publicEventAttendanceModeAvailabilitySchema),
+  startsAt: z46.string(),
+  endsAt: z46.string(),
+  capacity: z46.number().nullable(),
+  registeredCount: z46.number(),
+  availableSpots: z46.number().nullable(),
+  waitlistEnabled: z46.boolean(),
   venue: eventVenueSchema.nullable(),
   eventCategory: eventCategorySchema.nullable(),
-  teamMembers: z45.array(publicTeamMemberSummarySchema).optional(),
-  status: z45.enum(["active", "draft", "archived"]).optional(),
-  timeZone: z45.string(),
+  teamMembers: z46.array(publicTeamMemberSummarySchema).optional(),
+  status: z46.enum(["active", "draft", "archived"]).optional(),
+  timeZone: z46.string(),
   pricing: publicEventPricingSchema,
   paymentTerms: blockBookingPaymentTermsSchema,
   accessRestriction: accessRestrictionSchema,
-  allowedCategoryIds: z45.array(z45.string()),
-  requireGuestDetails: z45.boolean().optional(),
-  acceptsPasses: z45.boolean().optional(),
-  acceptsMemberships: z45.boolean().optional(),
-  course: z45.object({
-    id: z45.string(),
+  allowedCategoryIds: z46.array(z46.string()),
+  requireGuestDetails: z46.boolean().optional(),
+  acceptsPasses: z46.boolean().optional(),
+  acceptsMemberships: z46.boolean().optional(),
+  course: z46.object({
+    id: z46.string(),
     pricing: coursePricingSchema.optional(),
-    priceCents: z45.number().nullable(),
-    currency: z45.string(),
-    enrollmentOpen: z45.boolean()
+    priceCents: z46.number().nullable(),
+    currency: z46.string(),
+    enrollmentOpen: z46.boolean()
   }).nullable().optional()
 });
-var publicEventsArraySchema = z45.array(publicEventSchema);
+var publicEventsArraySchema = z46.array(publicEventSchema);
 
 // ../blocks/src/system/blocks/events/shared/fields.ts
 var cardVariantOptions2 = cardVariantRoleValues.map((value) => ({
@@ -33490,19 +33748,19 @@ function normalizeEventStaffMemberId(value) {
 }
 
 // ../blocks/src/system/blocks/event-registration.shared.ts
-import { z as z46 } from "zod";
-var occurrenceContextSchema = z46.object({
-  id: z46.string(),
-  seriesId: z46.string(),
-  startsAt: z46.string(),
-  endsAt: z46.string(),
-  timeZone: z46.string(),
-  capacityOverride: z46.number().nullable().optional(),
-  overrides: z46.record(z46.string(), z46.unknown()).nullable().optional()
+import { z as z47 } from "zod";
+var occurrenceContextSchema = z47.object({
+  id: z47.string(),
+  seriesId: z47.string(),
+  startsAt: z47.string(),
+  endsAt: z47.string(),
+  timeZone: z47.string(),
+  capacityOverride: z47.number().nullable().optional(),
+  overrides: z47.record(z47.string(), z47.unknown()).nullable().optional()
 }).nullable();
 
 // ../blocks/src/system/runtime/nodes/event-registration.interactive.ts
-import { z as z48 } from "zod";
+import { z as z49 } from "zod";
 
 // ../blocks/src/system/constants/events.ts
 var EVENT_CONTENT_TYPE_SLUGS = ["event", "events"];
@@ -33600,10 +33858,21 @@ function readLegacyPriceDisplay(value, currency) {
         amount: readAmount(value.amount) ?? 0,
         currency: displayCurrency
       } : { kind: "unavailable", currency };
+    case "range": {
+      const minAmount = readAmount(value.minAmount);
+      const maxAmount = readAmount(value.maxAmount);
+      return minAmount !== null && maxAmount !== null ? {
+        kind: "range",
+        minAmount,
+        maxAmount,
+        currency: displayCurrency
+      } : { kind: "unavailable", currency };
+    }
     case "mixed":
       return readAmount(value.paidFromAmount) !== null ? {
         kind: "mixed",
         paidFromAmount: readAmount(value.paidFromAmount) ?? 0,
+        paidToAmount: readAmount(value.paidToAmount) ?? readAmount(value.paidFromAmount) ?? 0,
         currency: displayCurrency
       } : { kind: "unavailable", currency };
     case "unavailable":
@@ -33645,16 +33914,16 @@ function readAmount(value) {
 }
 
 // ../blocks/src/system/runtime/nodes/shared/contract-schemas.ts
-import { z as z47 } from "zod";
-var previewStageSchema = z47.enum(["preview", "published"]);
-var registrationButtonVariantSchema = z47.enum(["primary", "secondary", "outline"]);
-var eventButtonVariantSchema = z47.enum(["primary", "secondary", "outline", "link"]);
-var eventLayoutSchema = z47.enum(eventCalendarListLayoutValues);
-var eventCalendarDisplayModeSchema = z47.enum(eventCalendarDisplayModeValues);
-var columnOptionSchema = z47.enum(["2", "3", "4"]);
-var weekStartSchema = z47.enum(["sunday", "monday"]);
-var filterAutoShowSchema = z47.enum(["auto", "always", "never"]);
-var calendarTabViewsSchema = z47.enum(["both", "month", "week"]);
+import { z as z48 } from "zod";
+var previewStageSchema = z48.enum(["preview", "published"]);
+var registrationButtonVariantSchema = z48.enum(["primary", "secondary", "outline"]);
+var eventButtonVariantSchema = z48.enum(["primary", "secondary", "outline", "link"]);
+var eventLayoutSchema = z48.enum(eventCalendarListLayoutValues);
+var eventCalendarDisplayModeSchema = z48.enum(eventCalendarDisplayModeValues);
+var columnOptionSchema = z48.enum(["2", "3", "4"]);
+var weekStartSchema = z48.enum(["sunday", "monday"]);
+var filterAutoShowSchema = z48.enum(["auto", "always", "never"]);
+var calendarTabViewsSchema = z48.enum(["both", "month", "week"]);
 
 // ../blocks/src/system/runtime/nodes/event-registration/wizardSteps.ts
 function getWizardStepsForContext(hasPreSelectedContext, needsPaymentStep) {
@@ -33714,66 +33983,68 @@ function toRegistrationEvents(events) {
 // ../blocks/src/system/runtime/nodes/event-registration.interactive.ts
 var EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS = ["Date", "Tickets", "Details"];
 var EVENT_REGISTRATION_SHELL_STEP_LABELS = ["Event", "Date", "Tickets", "Details", "Payment"];
-var contentEntrySchema = z48.object({
-  id: z48.string(),
-  slug: z48.string(),
-  contentTypeSlug: z48.string()
+var contentEntrySchema = z49.object({
+  id: z49.string(),
+  slug: z49.string(),
+  contentTypeSlug: z49.string()
 });
-var eventRegistrationPublicEventSchema = z48.preprocess(
+var eventRegistrationPublicEventSchema = z49.preprocess(
   normalizeEventRegistrationEventInput,
   publicEventSchema
 );
-var eventRegistrationSourceSchema = z48.object({
-  siteId: z48.string().optional(),
-  apiBaseUrl: z48.string().optional(),
-  portalToken: z48.string().nullable().optional(),
-  previewToken: z48.string().nullable().optional(),
+var eventRegistrationSourceSchema = z49.object({
+  siteId: z49.string().optional(),
+  apiBaseUrl: z49.string().optional(),
+  portalToken: z49.string().nullable().optional(),
+  previewToken: z49.string().nullable().optional(),
   occurrenceContext: occurrenceContextSchema.optional(),
   contentEntry: contentEntrySchema.nullable().optional(),
-  events: z48.array(eventRegistrationPublicEventSchema).nullable().optional(),
-  className: z48.string().nullable().optional(),
-  buttonText: z48.string().nullable().optional(),
-  maxTickets: z48.string().nullable().optional(),
-  showVenue: z48.boolean().optional(),
-  showCapacity: z48.boolean().optional(),
-  successMessage: z48.string().optional(),
-  waitlistMessage: z48.string().optional(),
+  events: z49.array(eventRegistrationPublicEventSchema).nullable().optional(),
+  className: z49.string().nullable().optional(),
+  buttonText: z49.string().nullable().optional(),
+  maxTickets: z49.string().nullable().optional(),
+  showVenue: z49.boolean().optional(),
+  showCapacity: z49.boolean().optional(),
+  successMessage: z49.string().optional(),
+  waitlistMessage: z49.string().optional(),
   buttonVariant: registrationButtonVariantSchema.optional(),
-  spamProtectionEnabled: z48.boolean().optional(),
+  overlayEnabled: z49.boolean().optional(),
+  spamProtectionEnabled: z49.boolean().optional(),
   stage: previewStageSchema.optional(),
-  supportEmail: z48.string().optional()
+  supportEmail: z49.string().optional()
 });
-var eventRegistrationDisplaySchema = z48.object({
-  kind: z48.literal("event-registration"),
-  state: z48.literal("generic-shell"),
-  className: z48.string().nullable(),
-  titleText: z48.string(),
-  bodyText: z48.string(),
-  stepLabels: z48.array(z48.enum(EVENT_REGISTRATION_SHELL_STEP_LABELS)).min(1),
-  summaryButtonText: z48.string()
+var eventRegistrationDisplaySchema = z49.object({
+  kind: z49.literal("event-registration"),
+  state: z49.literal("generic-shell"),
+  className: z49.string().nullable(),
+  titleText: z49.string(),
+  bodyText: z49.string(),
+  stepLabels: z49.array(z49.enum(EVENT_REGISTRATION_SHELL_STEP_LABELS)).min(1),
+  summaryButtonText: z49.string()
 });
-var eventRegistrationHydrationSchema = z48.object({
+var eventRegistrationHydrationSchema = z49.object({
   occurrenceContext: occurrenceContextSchema.optional(),
   contentEntry: contentEntrySchema.nullable().optional(),
-  events: z48.array(eventRegistrationPublicEventSchema).nullable().optional(),
-  maxTickets: z48.string().optional(),
-  showVenue: z48.boolean().optional(),
-  showCapacity: z48.boolean().optional(),
-  successMessage: z48.string().optional(),
-  waitlistMessage: z48.string().optional(),
+  events: z49.array(eventRegistrationPublicEventSchema).nullable().optional(),
+  maxTickets: z49.string().optional(),
+  showVenue: z49.boolean().optional(),
+  showCapacity: z49.boolean().optional(),
+  successMessage: z49.string().optional(),
+  waitlistMessage: z49.string().optional(),
   buttonVariant: registrationButtonVariantSchema.optional(),
-  spamProtectionEnabled: z48.boolean().optional(),
-  supportEmail: z48.string().optional()
+  overlayEnabled: z49.boolean().optional(),
+  spamProtectionEnabled: z49.boolean().optional(),
+  supportEmail: z49.string().optional()
 });
-var eventRegistrationRenderSchema = z48.object({
+var eventRegistrationRenderSchema = z49.object({
   display: eventRegistrationDisplaySchema,
   hydration: eventRegistrationHydrationSchema
 });
-var eventRegistrationIslandMetaCodec = createZodCodec(z48.object({
-  siteId: z48.string().optional(),
-  apiBaseUrl: z48.string().optional(),
-  portalToken: z48.string().nullable().optional(),
-  previewToken: z48.string().nullable().optional(),
+var eventRegistrationIslandMetaCodec = createZodCodec(z49.object({
+  siteId: z49.string().optional(),
+  apiBaseUrl: z49.string().optional(),
+  portalToken: z49.string().nullable().optional(),
+  previewToken: z49.string().nullable().optional(),
   stage: previewStageSchema.optional()
 }));
 var eventRegistrationIslandMetaKeys = defineInteractiveIslandMetaKeys(
@@ -33877,6 +34148,7 @@ var eventRegistrationBlockRuntime = defineClientOwnedBlockRuntime({
       successMessage: source.successMessage,
       waitlistMessage: source.waitlistMessage,
       buttonVariant: source.buttonVariant,
+      overlayEnabled: source.overlayEnabled,
       spamProtectionEnabled: source.spamProtectionEnabled,
       supportEmail: source.supportEmail
     }
@@ -34066,6 +34338,12 @@ var eventRegistrationManifest = createBlockManifest({
               buttonVariant: {
                 $bind: { from: "content.buttonVariant", fallback: "primary" }
               },
+              overlayEnabled: {
+                $bind: {
+                  from: "$root.eventRegistrationOverlayEnabled",
+                  fallback: false
+                }
+              },
               // Event data from loader
               events: { $bind: { from: "data.events" } },
               // Stage for preview mode (allows registering for draft events)
@@ -34086,7 +34364,7 @@ var eventRegistrationBlockDefinition = {
   manifest: eventRegistrationManifest,
   runtime: eventRegistrationBlockRuntime,
   dataSchemas: {
-    events: z49.array(publicEventSchema).optional(),
+    events: z50.array(publicEventSchema).optional(),
     occurrenceContext: occurrenceContextSchema.optional()
   },
   dataLoaders: {
@@ -34213,29 +34491,7 @@ function resolveCoursePricingState(course, selectedPricingOptionId, nowInput = {
   }
 }
 function formatCoursePriceDisplay(display, locale) {
-  switch (display.kind) {
-    case "free":
-      return "Free";
-    case "unavailable":
-      return "Pricing unavailable";
-    case "exact":
-      return formatCourseCurrencyAmount(display.amount, display.currency, { locale });
-    case "from":
-      return `From ${formatCourseCurrencyAmount(display.amount, display.currency, { locale })}`;
-  }
-}
-function formatCourseCurrencyAmount(amount, currency, options) {
-  const {
-    locale = "en-US",
-    minimumFractionDigits,
-    maximumFractionDigits
-  } = options ?? {};
-  return new Intl.NumberFormat(locale, {
-    style: "currency",
-    currency: currency.toUpperCase(),
-    ...minimumFractionDigits === void 0 ? {} : { minimumFractionDigits },
-    ...maximumFractionDigits === void 0 ? {} : { maximumFractionDigits }
-  }).format(amount / 100);
+  return formatBookingPriceDisplay(display, { decimals: "exact", locale });
 }
 function formatCoursePriceAmount(amount, currency, locale) {
   return formatCoursePriceDisplay(
@@ -34245,73 +34501,73 @@ function formatCoursePriceAmount(amount, currency, locale) {
 }
 
 // ../blocks/src/system/runtime/nodes/course-registration.interactive.ts
-import { z as z50 } from "zod";
-var contentEntrySchema2 = z50.object({
-  id: z50.string(),
-  slug: z50.string(),
-  contentTypeSlug: z50.string()
+import { z as z51 } from "zod";
+var contentEntrySchema2 = z51.object({
+  id: z51.string(),
+  slug: z51.string(),
+  contentTypeSlug: z51.string()
 });
-var courseEntrySubrouteContextSchema = z50.union([
-  z50.object({
-    kind: z50.literal("course-run"),
-    run: z50.object({
-      courseId: z50.string(),
-      seriesId: z50.string(),
-      runSlug: z50.string(),
-      runName: z50.string().nullable()
+var courseEntrySubrouteContextSchema = z51.union([
+  z51.object({
+    kind: z51.literal("course-run"),
+    run: z51.object({
+      courseId: z51.string(),
+      seriesId: z51.string(),
+      runSlug: z51.string(),
+      runName: z51.string().nullable()
     })
   }),
-  z50.object({
-    kind: z50.literal("event-occurrence"),
+  z51.object({
+    kind: z51.literal("event-occurrence"),
     occurrence: occurrenceContextSchema
   })
 ]);
-var courseRegistrationSourceSchema = z50.object({
-  siteId: z50.string().optional(),
-  apiBaseUrl: z50.string().optional(),
-  portalToken: z50.string().nullable().optional(),
+var courseRegistrationSourceSchema = z51.object({
+  siteId: z51.string().optional(),
+  apiBaseUrl: z51.string().optional(),
+  portalToken: z51.string().nullable().optional(),
   contentEntry: contentEntrySchema2.nullable().optional(),
   entrySubrouteContext: courseEntrySubrouteContextSchema.nullable().optional(),
-  courses: z50.array(publicCourseSchema).nullable().optional(),
-  className: z50.string().nullable().optional(),
-  showSessions: z50.boolean().optional(),
-  showPrice: z50.boolean().optional(),
-  showCapacity: z50.boolean().optional(),
-  showVenue: z50.boolean().optional(),
-  successMessage: z50.string().optional(),
-  waitlistMessage: z50.string().optional(),
-  membershipMessage: z50.string().optional(),
-  buttonText: z50.string().nullable().optional(),
+  courses: z51.array(publicCourseSchema).nullable().optional(),
+  className: z51.string().nullable().optional(),
+  showSessions: z51.boolean().optional(),
+  showPrice: z51.boolean().optional(),
+  showCapacity: z51.boolean().optional(),
+  showVenue: z51.boolean().optional(),
+  successMessage: z51.string().optional(),
+  waitlistMessage: z51.string().optional(),
+  membershipMessage: z51.string().optional(),
+  buttonText: z51.string().nullable().optional(),
   buttonVariant: registrationButtonVariantSchema.optional(),
   stage: previewStageSchema.optional()
 });
-var courseRegistrationDisplaySchema = z50.object({
-  kind: z50.literal("course-registration"),
-  state: z50.literal("shell"),
-  className: z50.string().nullable(),
-  summaryButtonText: z50.string()
+var courseRegistrationDisplaySchema = z51.object({
+  kind: z51.literal("course-registration"),
+  state: z51.literal("shell"),
+  className: z51.string().nullable(),
+  summaryButtonText: z51.string()
 });
-var courseRegistrationHydrationSchema = z50.object({
+var courseRegistrationHydrationSchema = z51.object({
   contentEntry: contentEntrySchema2.nullable().optional(),
   entrySubrouteContext: courseEntrySubrouteContextSchema.nullable().optional(),
-  courses: z50.array(publicCourseSchema).nullable().optional(),
-  showSessions: z50.boolean().optional(),
-  showPrice: z50.boolean().optional(),
-  showCapacity: z50.boolean().optional(),
-  showVenue: z50.boolean().optional(),
-  successMessage: z50.string().optional(),
-  waitlistMessage: z50.string().optional(),
-  membershipMessage: z50.string().optional(),
+  courses: z51.array(publicCourseSchema).nullable().optional(),
+  showSessions: z51.boolean().optional(),
+  showPrice: z51.boolean().optional(),
+  showCapacity: z51.boolean().optional(),
+  showVenue: z51.boolean().optional(),
+  successMessage: z51.string().optional(),
+  waitlistMessage: z51.string().optional(),
+  membershipMessage: z51.string().optional(),
   buttonVariant: registrationButtonVariantSchema.optional()
 });
-var courseRegistrationRenderSchema = z50.object({
+var courseRegistrationRenderSchema = z51.object({
   display: courseRegistrationDisplaySchema,
   hydration: courseRegistrationHydrationSchema
 });
-var courseRegistrationIslandMetaCodec = createZodCodec(z50.object({
-  siteId: z50.string().optional(),
-  apiBaseUrl: z50.string().optional(),
-  portalToken: z50.string().nullable().optional(),
+var courseRegistrationIslandMetaCodec = createZodCodec(z51.object({
+  siteId: z51.string().optional(),
+  apiBaseUrl: z51.string().optional(),
+  portalToken: z51.string().nullable().optional(),
   stage: previewStageSchema.optional()
 }));
 var courseRegistrationIslandMetaKeys = defineInteractiveIslandMetaKeys(
@@ -34584,32 +34840,32 @@ var courseRegistrationBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/event-details.ts
-import { z as z52 } from "zod";
+import { z as z53 } from "zod";
 
 // ../blocks/src/system/blocks/shop.shared.ts
-import { z as z51 } from "zod";
-var publicPassProductSchema = z51.object({
-  id: z51.string(),
-  productUseCase: z51.enum(["event_pass", "appointment_package"]).default("event_pass"),
-  name: z51.string(),
-  description: z51.string().nullable(),
-  price: z51.number(),
-  currency: z51.string(),
-  creditsTotal: z51.number(),
-  pricePerCredit: z51.number(),
-  validDays: z51.number().nullable(),
-  eligibleCategoryIds: z51.array(z51.string()),
-  eligibleCategoryNames: z51.array(z51.string())
+import { z as z52 } from "zod";
+var publicPassProductSchema = z52.object({
+  id: z52.string(),
+  productUseCase: z52.enum(["event_pass", "appointment_package"]).default("event_pass"),
+  name: z52.string(),
+  description: z52.string().nullable(),
+  price: z52.number(),
+  currency: z52.string(),
+  creditsTotal: z52.number(),
+  pricePerCredit: z52.number(),
+  validDays: z52.number().nullable(),
+  eligibleCategoryIds: z52.array(z52.string()),
+  eligibleCategoryNames: z52.array(z52.string())
 });
-var publicMembershipProductSchema = z51.object({
-  id: z51.string(),
-  name: z51.string(),
-  description: z51.string().nullable(),
-  price: z51.number(),
-  currency: z51.string(),
-  billingInterval: z51.enum(["month", "year"]),
-  eligibleCategoryIds: z51.array(z51.string()),
-  eligibleCategoryNames: z51.array(z51.string())
+var publicMembershipProductSchema = z52.object({
+  id: z52.string(),
+  name: z52.string(),
+  description: z52.string().nullable(),
+  price: z52.number(),
+  currency: z52.string(),
+  billingInterval: z52.enum(["month", "year"]),
+  eligibleCategoryIds: z52.array(z52.string()),
+  eligibleCategoryNames: z52.array(z52.string())
 });
 
 // ../blocks/src/system/blocks/event-details.ts
@@ -34744,40 +35000,40 @@ var eventDetailsManifest = createBlockManifest({
     })
   ]
 });
-var occurrenceContextSchema2 = z52.object({
-  id: z52.string(),
-  seriesId: z52.string(),
-  startsAt: z52.string(),
-  endsAt: z52.string(),
-  timeZone: z52.string(),
-  capacityOverride: z52.number().nullable().optional(),
-  overrides: z52.record(z52.string(), z52.unknown()).nullable().optional()
+var occurrenceContextSchema2 = z53.object({
+  id: z53.string(),
+  seriesId: z53.string(),
+  startsAt: z53.string(),
+  endsAt: z53.string(),
+  timeZone: z53.string(),
+  capacityOverride: z53.number().nullable().optional(),
+  overrides: z53.record(z53.string(), z53.unknown()).nullable().optional()
 }).nullable();
-var eventAutoApplyDiscountPreviewBaseSchema = z52.object({
-  id: z52.string(),
-  publicLabel: z52.string(),
-  description: z52.string().nullable(),
-  minTicketsRequired: z52.number().nullable()
+var eventAutoApplyDiscountPreviewBaseSchema = z53.object({
+  id: z53.string(),
+  publicLabel: z53.string(),
+  description: z53.string().nullable(),
+  minTicketsRequired: z53.number().nullable()
 });
-var eventAutoApplyDiscountPreviewSchema = z52.discriminatedUnion("discountType", [
+var eventAutoApplyDiscountPreviewSchema = z53.discriminatedUnion("discountType", [
   eventAutoApplyDiscountPreviewBaseSchema.extend({
-    discountType: z52.literal("percent"),
-    discountPercent: z52.number(),
-    discountAmountCents: z52.null()
+    discountType: z53.literal("percent"),
+    discountPercent: z53.number(),
+    discountAmountCents: z53.null()
   }),
   eventAutoApplyDiscountPreviewBaseSchema.extend({
-    discountType: z52.literal("fixed"),
-    discountPercent: z52.null(),
-    discountAmountCents: z52.number()
+    discountType: z53.literal("fixed"),
+    discountPercent: z53.null(),
+    discountAmountCents: z53.number()
   })
 ]);
 var eventDetailsBlockDefinition = {
   manifest: eventDetailsManifest,
   dataSchemas: {
-    eventDetailsData: z52.object({
+    eventDetailsData: z53.object({
       events: publicEventsArraySchema,
-      sitePasses: z52.object({ passes: z52.array(publicPassProductSchema) }),
-      siteMemberships: z52.object({ memberships: z52.array(publicMembershipProductSchema) }),
+      sitePasses: z53.object({ passes: z53.array(publicPassProductSchema) }),
+      siteMemberships: z53.object({ memberships: z53.array(publicMembershipProductSchema) }),
       autoApplyDiscount: eventAutoApplyDiscountPreviewSchema.nullable().optional().default(null)
     }).optional(),
     occurrenceContext: occurrenceContextSchema2.optional()
@@ -35101,7 +35357,7 @@ var eventSpotlightBlockDefinition = {
 };
 
 // ../blocks/src/system/runtime/nodes/events/EventListing.interactive.ts
-import { z as z54 } from "zod";
+import { z as z55 } from "zod";
 
 // ../calendar/src/grid.ts
 var DAY_NAMES = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
@@ -35267,15 +35523,15 @@ function getLocalMinuteOfDay(isoTimestamp, timeZone) {
   const date = new Date(isoTimestamp);
   if (Number.isNaN(date.getTime())) return NaN;
   if (!isValidTimeZone2(timeZone)) return NaN;
-  const parts = new Intl.DateTimeFormat("en-US", {
+  const parts = new Intl.DateTimeFormat("en-GB", {
     timeZone,
     hour: "2-digit",
     minute: "2-digit",
-    hour12: false,
     hourCycle: "h23"
   }).formatToParts(date);
-  const hour = Number(parts.find((part) => part.type === "hour")?.value);
+  const hourPart = Number(parts.find((part) => part.type === "hour")?.value);
   const minute = Number(parts.find((part) => part.type === "minute")?.value);
+  const hour = hourPart === 24 ? 0 : hourPart;
   if (Number.isNaN(hour) || Number.isNaN(minute)) return NaN;
   return hour * MINUTES_PER_HOUR + minute;
 }
@@ -35707,45 +35963,8 @@ function groupEventsByDate(events) {
   }
   return map;
 }
-function formatCompactCurrencyAmount(amount, currency) {
-  return formatCourseCurrencyAmount(amount, currency, {
-    minimumFractionDigits: 0,
-    maximumFractionDigits: 2
-  });
-}
-function formatCourseEventPriceDisplay(display) {
-  if (display.kind !== "course") {
-    return "Course";
-  }
-  if (display.display.kind === "exact" || display.display.kind === "from") {
-    const amountLabel = formatCompactCurrencyAmount(
-      display.display.amount,
-      display.display.currency
-    );
-    return display.display.kind === "from" ? `Course (From ${amountLabel})` : `Course (${amountLabel})`;
-  }
-  return "Course";
-}
-function formatPublicEventPriceDisplay(display) {
-  switch (display.kind) {
-    case "free":
-      return "Free";
-    case "exact":
-      return formatCompactCurrencyAmount(display.amount, display.currency);
-    case "from":
-      return `From ${formatCompactCurrencyAmount(display.amount, display.currency)}`;
-    case "mixed":
-      return `Free / From ${formatCompactCurrencyAmount(display.paidFromAmount, display.currency)}`;
-    case "unavailable":
-      return "Pricing unavailable";
-    case "course":
-      return formatCourseEventPriceDisplay(display);
-  }
-}
 function formatEventPrice(event) {
-  return formatPublicEventPriceDisplay(
-    publicEventPricingDisplay(resolveRuntimeEventPricing(event))
-  );
+  return formatEventPricing(resolveRuntimeEventPricing(event), { decimals: "auto" });
 }
 function resolveEventCta(event, buttonText) {
   const { isFull: isSoldOut } = getEventAvailability(event);
@@ -37323,16 +37542,16 @@ function DateTimeTile({ startsAt, endsAt, timeZone }) {
 }
 
 // ../blocks/src/system/runtime/nodes/events/shared/listOptions.ts
-import { z as z53 } from "zod";
+import { z as z54 } from "zod";
 var eventPageSizeValues = [3, 6, 10, 12, 20, 24, 30];
-var eventPageSizeSchema = z53.union([
-  z53.literal(3),
-  z53.literal(6),
-  z53.literal(10),
-  z53.literal(12),
-  z53.literal(20),
-  z53.literal(24),
-  z53.literal(30)
+var eventPageSizeSchema = z54.union([
+  z54.literal(3),
+  z54.literal(6),
+  z54.literal(10),
+  z54.literal(12),
+  z54.literal(20),
+  z54.literal(24),
+  z54.literal(30)
 ]);
 var eventPageSizeSet = new Set(eventPageSizeValues);
 function resolveEventPageSize(value, fallback2 = 12) {
@@ -37342,15 +37561,15 @@ function resolveEventPageSize(value, fallback2 = 12) {
 function resolveEventCalendarListPageSize(input) {
   return resolveEventPageSize(input.eventsPerPage);
 }
-var eventListPaginationActionSchema = z53.discriminatedUnion("kind", [
-  z53.object({
-    kind: z53.literal("loadMore"),
-    label: z53.string()
+var eventListPaginationActionSchema = z54.discriminatedUnion("kind", [
+  z54.object({
+    kind: z54.literal("loadMore"),
+    label: z54.string()
   }),
-  z53.object({
-    kind: z53.literal("seeAllLink"),
-    label: z53.string(),
-    href: z53.string()
+  z54.object({
+    kind: z54.literal("seeAllLink"),
+    label: z54.string(),
+    href: z54.string()
   })
 ]);
 function resolveEventListPaginationAction(input) {
@@ -37363,89 +37582,89 @@ function resolveEventListPaginationAction(input) {
 }
 
 // ../blocks/src/system/runtime/nodes/events/EventListing.interactive.ts
-var legacyEventCardVariantSchema = z54.enum(["variant1", "variant2"]);
-var eventCardVariantInputSchema = z54.union([
+var legacyEventCardVariantSchema = z55.enum(["variant1", "variant2"]);
+var eventCardVariantInputSchema = z55.union([
   cardVariantRoleSchema,
   legacyEventCardVariantSchema
 ]);
-var cardOrientationSchema = z54.enum(["vertical", "horizontal"]);
-var eventBlockKindSchema = z54.enum(eventBlockKindValues);
-var eventSurfaceScopeSchema = z54.enum(eventSurfaceScopeValues);
-var eventScheduleScopeSchema2 = z54.enum(eventScheduleScopeValues);
-var eventListingSourceSchema = z54.object({
-  events: z54.array(publicEventSchema).nullable().optional(),
-  siteId: z54.string(),
-  apiBaseUrl: z54.string().optional(),
+var cardOrientationSchema = z55.enum(["vertical", "horizontal"]);
+var eventBlockKindSchema = z55.enum(eventBlockKindValues);
+var eventSurfaceScopeSchema = z55.enum(eventSurfaceScopeValues);
+var eventScheduleScopeSchema2 = z55.enum(eventScheduleScopeValues);
+var eventListingSourceSchema = z55.object({
+  events: z55.array(publicEventSchema).nullable().optional(),
+  siteId: z55.string(),
+  apiBaseUrl: z55.string().optional(),
   stage: previewStageSchema.optional(),
   layout: eventLayoutSchema.optional(),
   columns: columnOptionSchema.optional(),
-  eventsPerPage: z54.string().optional(),
-  paginationMode: z54.enum(["loadMore", "seeAllLink"]).optional(),
-  seeAllUrl: z54.string().optional(),
-  loadMoreText: z54.string().optional(),
+  eventsPerPage: z55.string().optional(),
+  paginationMode: z55.enum(["loadMore", "seeAllLink"]).optional(),
+  seeAllUrl: z55.string().optional(),
+  loadMoreText: z55.string().optional(),
   cardVariant: eventCardVariantInputSchema.optional(),
   buttonVariant: eventButtonVariantSchema.optional(),
-  buttonText: z54.string().optional(),
-  showVenue: z54.boolean().optional(),
-  showMap: z54.boolean().optional(),
-  showCapacity: z54.boolean().optional(),
-  emptyMessage: z54.string().optional(),
-  className: z54.string().optional(),
-  showFilters: z54.boolean().nullable().optional(),
+  buttonText: z55.string().optional(),
+  showVenue: z55.boolean().optional(),
+  showMap: z55.boolean().optional(),
+  showCapacity: z55.boolean().optional(),
+  emptyMessage: z55.string().optional(),
+  className: z55.string().optional(),
+  showFilters: z55.boolean().nullable().optional(),
   showCategoryFilter: filterAutoShowSchema.optional(),
-  showVenueFilter: z54.boolean().nullable().optional(),
-  showStaffFilter: z54.boolean().nullable().optional(),
+  showVenueFilter: z55.boolean().nullable().optional(),
+  showStaffFilter: z55.boolean().nullable().optional(),
   eventKind: eventBlockKindSchema.nullable().optional(),
   eventSurface: eventSurfaceScopeSchema.nullable().optional(),
-  filterEventPresets: z54.union([z54.string(), z54.array(z54.string())]).nullable().optional(),
+  filterEventPresets: z55.union([z55.string(), z55.array(z55.string())]).nullable().optional(),
   scheduleScope: eventScheduleScopeSchema2.nullable().optional(),
-  filterCategoryIds: z54.string().nullable().optional(),
-  filterStaffMemberId: z54.string().nullable().optional(),
-  filterVenueId: z54.string().nullable().optional()
+  filterCategoryIds: z55.string().nullable().optional(),
+  filterStaffMemberId: z55.string().nullable().optional(),
+  filterVenueId: z55.string().nullable().optional()
 });
-var eventListingDisplaySchema = z54.object({
-  kind: z54.literal("event-listing"),
-  state: z54.enum(["loading", "empty", "ready"]),
+var eventListingDisplaySchema = z55.object({
+  kind: z55.literal("event-listing"),
+  state: z55.enum(["loading", "empty", "ready"]),
   listLayout: eventLayoutSchema,
-  className: z54.string().nullable(),
-  emptyMessage: z54.string(),
-  loadingMessage: z54.string(),
-  containerClass: z54.string(),
+  className: z55.string().nullable(),
+  emptyMessage: z55.string(),
+  loadingMessage: z55.string(),
+  containerClass: z55.string(),
   cardVariant: cardVariantRoleSchema,
   buttonVariant: eventButtonVariantSchema,
-  buttonText: z54.string(),
-  showVenue: z54.boolean(),
-  showMap: z54.boolean(),
-  showCapacity: z54.boolean(),
+  buttonText: z55.string(),
+  showVenue: z55.boolean(),
+  showMap: z55.boolean(),
+  showCapacity: z55.boolean(),
   orientation: cardOrientationSchema,
-  events: z54.array(publicEventSchema)
+  events: z55.array(publicEventSchema)
 });
-var eventListingHydrationSchema = z54.object({
-  siteId: z54.string(),
+var eventListingHydrationSchema = z55.object({
+  siteId: z55.string(),
   stage: previewStageSchema.optional(),
   eventsPerPage: eventPageSizeSchema,
   paginationAction: eventListPaginationActionSchema,
-  showFilters: z54.boolean(),
+  showFilters: z55.boolean(),
   showCategoryFilter: filterAutoShowSchema,
-  showVenueFilter: z54.boolean(),
-  showStaffFilter: z54.boolean(),
+  showVenueFilter: z55.boolean(),
+  showStaffFilter: z55.boolean(),
   eventKind: eventBlockKindSchema,
   eventSurface: eventSurfaceScopeSchema,
-  filterEventPresets: z54.string().nullable(),
+  filterEventPresets: z55.string().nullable(),
   scheduleScope: eventScheduleScopeSchema2,
-  filterCategoryIds: z54.string().nullable().optional(),
-  filterStaffMemberId: z54.string().nullable().optional(),
-  filterVenueId: z54.string().nullable().optional(),
-  fetchInitialEventsOnMount: z54.boolean()
+  filterCategoryIds: z55.string().nullable().optional(),
+  filterStaffMemberId: z55.string().nullable().optional(),
+  filterVenueId: z55.string().nullable().optional(),
+  fetchInitialEventsOnMount: z55.boolean()
 });
-var eventListingRenderSchema = z54.object({
+var eventListingRenderSchema = z55.object({
   display: eventListingDisplaySchema,
   hydration: eventListingHydrationSchema
 });
 var eventListingIslandMetaCodec = createZodCodec(
-  z54.object({
-    siteId: z54.string(),
-    apiBaseUrl: z54.string().optional(),
+  z55.object({
+    siteId: z55.string(),
+    apiBaseUrl: z55.string().optional(),
     stage: previewStageSchema.optional()
   })
 );
@@ -37824,15 +38043,15 @@ var eventListingBlockDefinition = {
 };
 
 // ../blocks/src/system/runtime/nodes/events/EventCalendar.interactive.ts
-import { z as z55 } from "zod";
-var eventBlockKindSchema2 = z55.enum(eventBlockKindValues);
-var eventSurfaceScopeSchema2 = z55.enum(eventSurfaceScopeValues);
-var eventScheduleScopeSchema3 = z55.enum(eventScheduleScopeValues);
-var eventCalendarSourceSchema = z55.object(
+import { z as z56 } from "zod";
+var eventBlockKindSchema2 = z56.enum(eventBlockKindValues);
+var eventSurfaceScopeSchema2 = z56.enum(eventSurfaceScopeValues);
+var eventScheduleScopeSchema3 = z56.enum(eventScheduleScopeValues);
+var eventCalendarSourceSchema = z56.object(
   {
-    events: z55.array(publicEventSchema).nullable().optional(),
-    siteId: z55.string(),
-    apiBaseUrl: z55.string().optional(),
+    events: z56.array(publicEventSchema).nullable().optional(),
+    siteId: z56.string(),
+    apiBaseUrl: z56.string().optional(),
     stage: previewStageSchema.optional(),
     variant: eventCalendarDisplayModeSchema.nullable().optional(),
     displayMode: eventCalendarDisplayModeSchema.nullable().optional(),
@@ -37840,78 +38059,78 @@ var eventCalendarSourceSchema = z55.object(
     listColumns: columnOptionSchema.optional(),
     layout: eventLayoutSchema.optional(),
     columns: columnOptionSchema.optional(),
-    eventsPerPage: z55.string().optional(),
-    paginationMode: z55.enum(["loadMore", "seeAllLink"]).optional(),
-    seeAllUrl: z55.string().optional(),
-    loadMoreText: z55.string().optional(),
+    eventsPerPage: z56.string().optional(),
+    paginationMode: z56.enum(["loadMore", "seeAllLink"]).optional(),
+    seeAllUrl: z56.string().optional(),
+    loadMoreText: z56.string().optional(),
     startOfWeek: weekStartSchema.optional(),
     calendarTabViews: calendarTabViewsSchema.optional(),
-    showFilters: z55.boolean().nullable().optional(),
+    showFilters: z56.boolean().nullable().optional(),
     showCategoryFilter: filterAutoShowSchema.optional(),
-    showVenueFilter: z55.boolean().nullable().optional(),
-    showStaffFilter: z55.boolean().nullable().optional(),
+    showVenueFilter: z56.boolean().nullable().optional(),
+    showStaffFilter: z56.boolean().nullable().optional(),
     kind: eventBlockKindSchema2.nullable().optional(),
     eventSurface: eventSurfaceScopeSchema2.nullable().optional(),
-    filterEventPresets: z55.union([z55.string(), z55.array(z55.string())]).nullable().optional(),
+    filterEventPresets: z56.union([z56.string(), z56.array(z56.string())]).nullable().optional(),
     scheduleScope: eventScheduleScopeSchema3.nullable().optional(),
-    filterCategoryIds: z55.union([z55.string(), z55.array(z55.string())]).nullable().optional(),
-    filterStaffMemberId: z55.string().nullable().optional(),
-    filterVenueId: z55.string().nullable().optional(),
+    filterCategoryIds: z56.union([z56.string(), z56.array(z56.string())]).nullable().optional(),
+    filterStaffMemberId: z56.string().nullable().optional(),
+    filterVenueId: z56.string().nullable().optional(),
     buttonVariant: eventButtonVariantSchema.optional(),
-    buttonText: z55.string().optional(),
-    showVenue: z55.boolean().nullable().optional(),
-    showMap: z55.boolean().nullable().optional(),
-    showCapacity: z55.boolean().nullable().optional(),
-    emptyMessage: z55.string().optional(),
-    className: z55.string().optional()
+    buttonText: z56.string().optional(),
+    showVenue: z56.boolean().nullable().optional(),
+    showMap: z56.boolean().nullable().optional(),
+    showCapacity: z56.boolean().nullable().optional(),
+    emptyMessage: z56.string().optional(),
+    className: z56.string().optional()
   }
 );
-var eventCalendarDisplaySchema = z55.object({
-  kind: z55.literal("event-calendar"),
+var eventCalendarDisplaySchema = z56.object({
+  kind: z56.literal("event-calendar"),
   displayMode: eventCalendarDisplayModeSchema,
-  className: z55.string().nullable(),
-  events: z55.array(publicEventSchema),
+  className: z56.string().nullable(),
+  events: z56.array(publicEventSchema),
   listLayout: eventLayoutSchema,
   listColumns: columnOptionSchema,
   eventsPerPage: eventPageSizeSchema,
   paginationAction: eventListPaginationActionSchema,
   startOfWeek: weekStartSchema,
   calendarTabViews: calendarTabViewsSchema,
-  showFilters: z55.boolean(),
+  showFilters: z56.boolean(),
   showCategoryFilter: filterAutoShowSchema,
-  showVenueFilter: z55.boolean(),
-  showStaffFilter: z55.boolean(),
+  showVenueFilter: z56.boolean(),
+  showStaffFilter: z56.boolean(),
   eventKind: eventBlockKindSchema2,
   eventSurface: eventSurfaceScopeSchema2,
-  filterEventPresets: z55.string().nullable(),
+  filterEventPresets: z56.string().nullable(),
   scheduleScope: eventScheduleScopeSchema3,
-  filterCategoryIds: z55.string().nullable(),
-  filterStaffMemberId: z55.string().nullable(),
-  filterVenueId: z55.string().nullable(),
+  filterCategoryIds: z56.string().nullable(),
+  filterStaffMemberId: z56.string().nullable(),
+  filterVenueId: z56.string().nullable(),
   buttonVariant: eventButtonVariantSchema,
-  buttonText: z55.string(),
-  showVenue: z55.boolean(),
-  showMap: z55.boolean(),
-  showCapacity: z55.boolean(),
-  emptyMessage: z55.string()
+  buttonText: z56.string(),
+  showVenue: z56.boolean(),
+  showMap: z56.boolean(),
+  showCapacity: z56.boolean(),
+  emptyMessage: z56.string()
 });
-var eventCalendarHydrationSchema = z55.object({
-  siteId: z55.string(),
+var eventCalendarHydrationSchema = z56.object({
+  siteId: z56.string(),
   stage: previewStageSchema.optional(),
-  prefetchedEvents: z55.boolean(),
+  prefetchedEvents: z56.boolean(),
   eventKind: eventBlockKindSchema2,
   eventSurface: eventSurfaceScopeSchema2,
-  filterEventPresets: z55.string().nullable(),
+  filterEventPresets: z56.string().nullable(),
   scheduleScope: eventScheduleScopeSchema3
 });
-var eventCalendarRenderSchema = z55.object({
+var eventCalendarRenderSchema = z56.object({
   display: eventCalendarDisplaySchema,
   hydration: eventCalendarHydrationSchema
 });
 var eventCalendarIslandMetaCodec = createZodCodec(
-  z55.object({
-    siteId: z55.string(),
-    apiBaseUrl: z55.string().optional(),
+  z56.object({
+    siteId: z56.string(),
+    apiBaseUrl: z56.string().optional(),
     stage: previewStageSchema.optional()
   })
 );
@@ -38653,7 +38872,7 @@ var eventCalendarBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/offerings-preview/index.ts
-import { z as z56 } from "zod";
+import { z as z57 } from "zod";
 
 // ../blocks/src/system/blocks/offerings-preview/model.ts
 var OFFERINGS_PREVIEW_DEFAULT_ITEM_LIMIT = "3";
@@ -38975,13 +39194,13 @@ function normalizeTextOverride(value) {
 }
 
 // ../blocks/src/system/blocks/offerings-preview/index.ts
-var publicRouteCandidatesSchema = z56.object({
-  routes: z56.array(z56.object({
-    entityId: z56.string(),
-    path: z56.string(),
-    title: z56.string(),
-    kind: z56.enum(["page", "content"]),
-    contentTypeKey: z56.string().nullable().optional()
+var publicRouteCandidatesSchema = z57.object({
+  routes: z57.array(z57.object({
+    entityId: z57.string(),
+    path: z57.string(),
+    title: z57.string(),
+    kind: z57.enum(["page", "content"]),
+    contentTypeKey: z57.string().nullable().optional()
   }))
 });
 var groupOverrideFields = [
@@ -39379,7 +39598,7 @@ function isRecord8(value) {
 }
 
 // ../blocks/src/system/blocks/embed.ts
-import { z as z57 } from "zod";
+import { z as z58 } from "zod";
 var embedFields = [
   // Section heading
   parseFieldDefinition({
@@ -39610,18 +39829,18 @@ var embedManifest = createBlockManifest({
     spacing: "lg"
   }
 });
-var embedEntrySchema = z57.object({
-  id: z57.string(),
-  identifier: z57.string(),
-  title: z57.string(),
-  slug: z57.string().nullable().optional(),
-  content: z57.record(z57.string(), z57.unknown()).optional(),
-  publishedAt: z57.string().nullable().optional()
+var embedEntrySchema = z58.object({
+  id: z58.string(),
+  identifier: z58.string(),
+  title: z58.string(),
+  slug: z58.string().nullable().optional(),
+  content: z58.record(z58.string(), z58.unknown()).optional(),
+  publishedAt: z58.string().nullable().optional()
 });
 var embedBlockDefinition = {
   manifest: embedManifest,
   dataSchemas: {
-    entries: z57.array(embedEntrySchema).optional()
+    entries: z58.array(embedEntrySchema).optional()
   },
   dataLoaders: {
     entries: {
@@ -40805,52 +41024,52 @@ var fileDownloadBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/shop.ts
-import { z as z61 } from "zod";
+import { z as z62 } from "zod";
 
 // ../blocks/src/system/runtime/nodes/shop.interactive.ts
-import { z as z60 } from "zod";
+import { z as z61 } from "zod";
 
 // ../blocks/src/system/blocks/products/shared.ts
-import { z as z58 } from "zod";
-var publicProductVariantSchema = z58.object({
-  id: z58.string(),
-  title: z58.string(),
-  sku: z58.string().nullable(),
-  priceCents: z58.number(),
-  stockQuantity: z58.number().nullable(),
-  soldOut: z58.boolean()
+import { z as z59 } from "zod";
+var publicProductVariantSchema = z59.object({
+  id: z59.string(),
+  title: z59.string(),
+  sku: z59.string().nullable(),
+  priceCents: z59.number(),
+  stockQuantity: z59.number().nullable(),
+  soldOut: z59.boolean()
 });
-var publicProductSchema = z58.object({
-  id: z58.string(),
-  contentEntryId: z58.string().nullable(),
-  title: z58.string(),
-  slug: z58.string(),
-  path: z58.string().nullable(),
-  status: z58.enum(["draft", "active"]),
-  priceCents: z58.number(),
-  currency: z58.string(),
-  productType: z58.enum(["physical", "digital"]),
-  requiresShipping: z58.boolean(),
-  hasVariants: z58.boolean(),
-  trackInventory: z58.boolean(),
-  soldOut: z58.boolean(),
-  category: z58.object({
-    id: z58.string(),
-    name: z58.string(),
-    slug: z58.string()
+var publicProductSchema = z59.object({
+  id: z59.string(),
+  contentEntryId: z59.string().nullable(),
+  title: z59.string(),
+  slug: z59.string(),
+  path: z59.string().nullable(),
+  status: z59.enum(["draft", "active"]),
+  priceCents: z59.number(),
+  currency: z59.string(),
+  productType: z59.enum(["physical", "digital"]),
+  requiresShipping: z59.boolean(),
+  hasVariants: z59.boolean(),
+  trackInventory: z59.boolean(),
+  soldOut: z59.boolean(),
+  category: z59.object({
+    id: z59.string(),
+    name: z59.string(),
+    slug: z59.string()
   }).nullable(),
-  summary: z58.string().nullable(),
-  body: z58.unknown().nullable(),
-  gallery: z58.array(
-    z58.object({
-      url: z58.string(),
-      alt: z58.string().nullable()
+  summary: z59.string().nullable(),
+  body: z59.unknown().nullable(),
+  gallery: z59.array(
+    z59.object({
+      url: z59.string(),
+      alt: z59.string().nullable()
     })
   ),
-  variants: z58.array(publicProductVariantSchema)
+  variants: z59.array(publicProductVariantSchema)
 });
-var publicProductsResponseSchema = z58.object({
-  products: z58.array(publicProductSchema)
+var publicProductsResponseSchema = z59.object({
+  products: z59.array(publicProductSchema)
 });
 
 // ../blocks/src/system/runtime/api/creditProducts.ts
@@ -40914,27 +41133,27 @@ function deriveCreditProductLabels(products, options = {}) {
 }
 
 // ../blocks/src/system/runtime/nodes/shop-commerce.shared.ts
-import { z as z59 } from "zod";
-var storedProductCartItemSchema = z59.object({
-  kind: z59.literal("product"),
-  productId: z59.string().min(1),
-  productCategoryId: z59.string().min(1).optional().nullable(),
-  variantId: z59.string().min(1).optional().nullable(),
-  title: z59.string().min(1),
-  variantTitle: z59.string().optional().nullable(),
-  quantity: z59.number().finite(),
-  unitPriceCents: z59.number().finite(),
-  currency: z59.string().min(1),
-  imageUrl: z59.string().optional().nullable(),
-  soldOut: z59.boolean().optional()
+import { z as z60 } from "zod";
+var storedProductCartItemSchema = z60.object({
+  kind: z60.literal("product"),
+  productId: z60.string().min(1),
+  productCategoryId: z60.string().min(1).optional().nullable(),
+  variantId: z60.string().min(1).optional().nullable(),
+  title: z60.string().min(1),
+  variantTitle: z60.string().optional().nullable(),
+  quantity: z60.number().finite(),
+  unitPriceCents: z60.number().finite(),
+  currency: z60.string().min(1),
+  imageUrl: z60.string().optional().nullable(),
+  soldOut: z60.boolean().optional()
 });
-var storedPassCartItemSchema = z59.object({
-  kind: z59.literal("pass"),
-  passId: z59.string().min(1),
-  title: z59.string().min(1),
-  quantity: z59.number().finite().optional(),
-  unitPriceCents: z59.number().finite(),
-  currency: z59.string().min(1)
+var storedPassCartItemSchema = z60.object({
+  kind: z60.literal("pass"),
+  passId: z60.string().min(1),
+  title: z60.string().min(1),
+  quantity: z60.number().finite().optional(),
+  unitPriceCents: z60.number().finite(),
+  currency: z60.string().min(1)
 });
 function deriveCommerceCheckoutState(state) {
   if (state.items.length === 0) {
@@ -40973,10 +41192,7 @@ function resolveSelectedProduct(products, contentEntry, productSlug) {
 
 // ../blocks/src/system/runtime/nodes/commerce/shared/display.ts
 function formatCommercePrice(cents, currency) {
-  return new Intl.NumberFormat("en-US", {
-    style: "currency",
-    currency: currency.toUpperCase()
-  }).format(cents / 100);
+  return formatCurrencyAmount(cents, currency);
 }
 function getPassesHeading(passes, explicitHeading) {
   if (explicitHeading) return explicitHeading;
@@ -41171,214 +41387,214 @@ function formatValidity(days) {
 }
 
 // ../blocks/src/system/runtime/nodes/shop.interactive.ts
-var shopModeSchema = z60.enum(["passes-memberships", "product-list", "product-detail", "cart", "checkout"]);
-var contentEntrySchema3 = z60.object({
-  id: z60.string().nullable().optional(),
-  slug: z60.string().nullable().optional()
+var shopModeSchema = z61.enum(["passes-memberships", "product-list", "product-detail", "cart", "checkout"]);
+var contentEntrySchema3 = z61.object({
+  id: z61.string().nullable().optional(),
+  slug: z61.string().nullable().optional()
 }).nullable();
-var shopSourceSchema = z60.object({
-  className: z60.string().nullable().optional(),
+var shopSourceSchema = z61.object({
+  className: z61.string().nullable().optional(),
   mode: shopModeSchema.optional(),
-  heading: z60.string().nullable().optional(),
-  productSlug: z60.string().nullable().optional(),
-  showPasses: z60.boolean().optional(),
-  showMemberships: z60.boolean().optional(),
-  layout: z60.enum(["grid", "list"]).optional(),
-  columns: z60.string().optional(),
-  showDescriptions: z60.boolean().optional(),
-  showSummary: z60.boolean().optional(),
-  showBody: z60.boolean().optional(),
-  showPrices: z60.boolean().optional(),
-  showValidityPeriod: z60.boolean().optional(),
-  showPricePerCredit: z60.boolean().nullable().optional(),
-  passesHeading: z60.string().optional(),
-  membershipsHeading: z60.string().optional(),
-  buyButtonText: z60.string().optional(),
-  addButtonText: z60.string().optional(),
-  passPurchaseMode: z60.enum(["add_to_cart", "buy_now"]).optional(),
-  subscribeButtonText: z60.string().optional(),
-  emptyStateText: z60.string().optional(),
-  checkoutButtonText: z60.string().optional(),
-  clearButtonText: z60.string().optional(),
-  submitButtonText: z60.string().optional(),
+  heading: z61.string().nullable().optional(),
+  productSlug: z61.string().nullable().optional(),
+  showPasses: z61.boolean().optional(),
+  showMemberships: z61.boolean().optional(),
+  layout: z61.enum(["grid", "list"]).optional(),
+  columns: z61.string().optional(),
+  showDescriptions: z61.boolean().optional(),
+  showSummary: z61.boolean().optional(),
+  showBody: z61.boolean().optional(),
+  showPrices: z61.boolean().optional(),
+  showValidityPeriod: z61.boolean().optional(),
+  showPricePerCredit: z61.boolean().nullable().optional(),
+  passesHeading: z61.string().optional(),
+  membershipsHeading: z61.string().optional(),
+  buyButtonText: z61.string().optional(),
+  addButtonText: z61.string().optional(),
+  passPurchaseMode: z61.enum(["add_to_cart", "buy_now"]).optional(),
+  subscribeButtonText: z61.string().optional(),
+  emptyStateText: z61.string().optional(),
+  checkoutButtonText: z61.string().optional(),
+  clearButtonText: z61.string().optional(),
+  submitButtonText: z61.string().optional(),
   contentEntry: contentEntrySchema3.optional(),
-  passes: z60.array(publicPassProductSchema).nullable().optional(),
-  memberships: z60.array(publicMembershipProductSchema).nullable().optional(),
-  products: z60.array(publicProductSchema).nullable().optional(),
-  siteId: z60.string().optional(),
-  apiBaseUrl: z60.string().optional(),
+  passes: z61.array(publicPassProductSchema).nullable().optional(),
+  memberships: z61.array(publicMembershipProductSchema).nullable().optional(),
+  products: z61.array(publicProductSchema).nullable().optional(),
+  siteId: z61.string().optional(),
+  apiBaseUrl: z61.string().optional(),
   stage: previewStageSchema.optional()
 });
-var productVariantOptionDisplaySchema = z60.object({
-  id: z60.string(),
-  label: z60.string(),
-  soldOut: z60.boolean()
+var productVariantOptionDisplaySchema = z61.object({
+  id: z61.string(),
+  label: z61.string(),
+  soldOut: z61.boolean()
 });
-var productCardDisplaySchema = z60.object({
-  productId: z60.string(),
-  title: z60.string(),
-  path: z60.string().nullable(),
-  summary: z60.string().nullable(),
-  priceLabel: z60.string().nullable(),
-  image: z60.object({
-    url: z60.string(),
-    alt: z60.string().nullable()
+var productCardDisplaySchema = z61.object({
+  productId: z61.string(),
+  title: z61.string(),
+  path: z61.string().nullable(),
+  summary: z61.string().nullable(),
+  priceLabel: z61.string().nullable(),
+  image: z61.object({
+    url: z61.string(),
+    alt: z61.string().nullable()
   }).nullable(),
-  variantOptions: z60.array(productVariantOptionDisplaySchema),
-  selectedVariantId: z60.string().nullable(),
-  selectionLabel: z60.string(),
-  actionLabel: z60.string(),
-  soldOut: z60.boolean()
+  variantOptions: z61.array(productVariantOptionDisplaySchema),
+  selectedVariantId: z61.string().nullable(),
+  selectionLabel: z61.string(),
+  actionLabel: z61.string(),
+  soldOut: z61.boolean()
 });
-var productListDisplaySchema = z60.object({
-  kind: z60.literal("product-list"),
-  state: z60.enum(["empty", "ready"]),
-  heading: z60.string().nullable(),
-  className: z60.string().nullable(),
-  layout: z60.enum(["grid", "list"]),
-  columns: z60.string(),
-  emptyMessage: z60.string(),
-  cards: z60.array(productCardDisplaySchema)
+var productListDisplaySchema = z61.object({
+  kind: z61.literal("product-list"),
+  state: z61.enum(["empty", "ready"]),
+  heading: z61.string().nullable(),
+  className: z61.string().nullable(),
+  layout: z61.enum(["grid", "list"]),
+  columns: z61.string(),
+  emptyMessage: z61.string(),
+  cards: z61.array(productCardDisplaySchema)
 });
-var productDetailDisplaySchema = z60.discriminatedUnion("state", [
-  z60.object({
-    kind: z60.literal("product-detail"),
-    state: z60.literal("empty"),
-    heading: z60.string().nullable(),
-    className: z60.string().nullable(),
-    emptyMessage: z60.string()
+var productDetailDisplaySchema = z61.discriminatedUnion("state", [
+  z61.object({
+    kind: z61.literal("product-detail"),
+    state: z61.literal("empty"),
+    heading: z61.string().nullable(),
+    className: z61.string().nullable(),
+    emptyMessage: z61.string()
   }),
-  z60.object({
-    kind: z60.literal("product-detail"),
-    state: z60.literal("ready"),
-    heading: z60.string().nullable(),
-    className: z60.string().nullable(),
-    title: z60.string(),
-    priceLabel: z60.string(),
-    summary: z60.string().nullable(),
-    categoryLabel: z60.string().nullable(),
-    gallery: z60.array(z60.object({
-      url: z60.string(),
-      alt: z60.string().nullable()
+  z61.object({
+    kind: z61.literal("product-detail"),
+    state: z61.literal("ready"),
+    heading: z61.string().nullable(),
+    className: z61.string().nullable(),
+    title: z61.string(),
+    priceLabel: z61.string(),
+    summary: z61.string().nullable(),
+    categoryLabel: z61.string().nullable(),
+    gallery: z61.array(z61.object({
+      url: z61.string(),
+      alt: z61.string().nullable()
     })),
-    variantOptions: z60.array(productVariantOptionDisplaySchema),
-    selectedVariantId: z60.string().nullable(),
-    selectionLabel: z60.string(),
-    actionLabel: z60.string(),
-    soldOut: z60.boolean(),
-    body: z60.unknown().nullable()
+    variantOptions: z61.array(productVariantOptionDisplaySchema),
+    selectedVariantId: z61.string().nullable(),
+    selectionLabel: z61.string(),
+    actionLabel: z61.string(),
+    soldOut: z61.boolean(),
+    body: z61.unknown().nullable()
   })
 ]);
-var passCardDisplaySchema = z60.object({
-  id: z60.string(),
-  title: z60.string(),
-  description: z60.string().nullable(),
-  priceLabel: z60.string(),
-  creditsLabel: z60.string(),
-  perCreditLabel: z60.string().nullable(),
-  validityLabel: z60.string().nullable(),
-  actionLabel: z60.string()
+var passCardDisplaySchema = z61.object({
+  id: z61.string(),
+  title: z61.string(),
+  description: z61.string().nullable(),
+  priceLabel: z61.string(),
+  creditsLabel: z61.string(),
+  perCreditLabel: z61.string().nullable(),
+  validityLabel: z61.string().nullable(),
+  actionLabel: z61.string()
 });
-var membershipCardDisplaySchema = z60.object({
-  id: z60.string(),
-  title: z60.string(),
-  description: z60.string().nullable(),
-  priceLabel: z60.string(),
-  intervalLabel: z60.string(),
-  actionLabel: z60.string()
+var membershipCardDisplaySchema = z61.object({
+  id: z61.string(),
+  title: z61.string(),
+  description: z61.string().nullable(),
+  priceLabel: z61.string(),
+  intervalLabel: z61.string(),
+  actionLabel: z61.string()
 });
-var passesMembershipsDisplaySchema = z60.object({
-  kind: z60.literal("passes-memberships"),
-  state: z60.enum(["empty", "ready"]),
-  className: z60.string().nullable(),
-  layout: z60.enum(["grid", "list"]),
-  columns: z60.string(),
-  emptyMessage: z60.string(),
-  passesHeading: z60.string(),
-  membershipsHeading: z60.string(),
-  passes: z60.array(passCardDisplaySchema),
-  memberships: z60.array(membershipCardDisplaySchema)
+var passesMembershipsDisplaySchema = z61.object({
+  kind: z61.literal("passes-memberships"),
+  state: z61.enum(["empty", "ready"]),
+  className: z61.string().nullable(),
+  layout: z61.enum(["grid", "list"]),
+  columns: z61.string(),
+  emptyMessage: z61.string(),
+  passesHeading: z61.string(),
+  membershipsHeading: z61.string(),
+  passes: z61.array(passCardDisplaySchema),
+  memberships: z61.array(membershipCardDisplaySchema)
 });
-var cartLineDisplaySchema = z60.object({
-  key: z60.string(),
-  title: z60.string(),
-  priceLabel: z60.string(),
-  quantity: z60.number(),
-  quantityEditable: z60.boolean()
+var cartLineDisplaySchema = z61.object({
+  key: z61.string(),
+  title: z61.string(),
+  priceLabel: z61.string(),
+  quantity: z61.number(),
+  quantityEditable: z61.boolean()
 });
-var cartDisplaySchema = z60.object({
-  kind: z60.literal("cart"),
-  state: z60.enum(["empty", "ready"]),
-  heading: z60.string().nullable(),
-  className: z60.string().nullable(),
-  emptyMessage: z60.string(),
-  supportText: z60.string().nullable(),
-  items: z60.array(cartLineDisplaySchema),
-  subtotalLabel: z60.string().nullable(),
-  checkoutButtonText: z60.string(),
-  clearButtonText: z60.string()
+var cartDisplaySchema = z61.object({
+  kind: z61.literal("cart"),
+  state: z61.enum(["empty", "ready"]),
+  heading: z61.string().nullable(),
+  className: z61.string().nullable(),
+  emptyMessage: z61.string(),
+  supportText: z61.string().nullable(),
+  items: z61.array(cartLineDisplaySchema),
+  subtotalLabel: z61.string().nullable(),
+  checkoutButtonText: z61.string(),
+  clearButtonText: z61.string()
 });
-var checkoutDisplaySchema = z60.object({
-  kind: z60.literal("checkout"),
-  state: z60.enum(["empty", "blocked", "ready"]),
-  heading: z60.string().nullable(),
-  className: z60.string().nullable(),
-  message: z60.string().nullable(),
-  submitButtonText: z60.string()
+var checkoutDisplaySchema = z61.object({
+  kind: z61.literal("checkout"),
+  state: z61.enum(["empty", "blocked", "ready"]),
+  heading: z61.string().nullable(),
+  className: z61.string().nullable(),
+  message: z61.string().nullable(),
+  submitButtonText: z61.string()
 });
-var passesMembershipsHydrationSchema = z60.object({
-  passes: z60.array(publicPassProductSchema),
-  memberships: z60.array(publicMembershipProductSchema),
-  passPurchaseMode: z60.enum(["add_to_cart", "buy_now"])
+var passesMembershipsHydrationSchema = z61.object({
+  passes: z61.array(publicPassProductSchema),
+  memberships: z61.array(publicMembershipProductSchema),
+  passPurchaseMode: z61.enum(["add_to_cart", "buy_now"])
 });
-var productListHydrationSchema = z60.object({
-  products: z60.array(publicProductSchema),
-  showSummary: z60.boolean(),
-  showPrices: z60.boolean(),
-  addButtonText: z60.string()
+var productListHydrationSchema = z61.object({
+  products: z61.array(publicProductSchema),
+  showSummary: z61.boolean(),
+  showPrices: z61.boolean(),
+  addButtonText: z61.string()
 });
-var productDetailHydrationSchema = z60.object({
-  products: z60.array(publicProductSchema),
-  productId: z60.string().nullable(),
-  showSummary: z60.boolean(),
-  showBody: z60.boolean(),
-  addButtonText: z60.string()
+var productDetailHydrationSchema = z61.object({
+  products: z61.array(publicProductSchema),
+  productId: z61.string().nullable(),
+  showSummary: z61.boolean(),
+  showBody: z61.boolean(),
+  addButtonText: z61.string()
 });
-var cartHydrationSchema = z60.object({
-  emptyStateText: z60.string(),
-  checkoutButtonText: z60.string(),
-  clearButtonText: z60.string()
+var cartHydrationSchema = z61.object({
+  emptyStateText: z61.string(),
+  checkoutButtonText: z61.string(),
+  clearButtonText: z61.string()
 });
-var checkoutHydrationSchema = z60.object({
-  emptyStateText: z60.string(),
-  submitButtonText: z60.string()
+var checkoutHydrationSchema = z61.object({
+  emptyStateText: z61.string(),
+  submitButtonText: z61.string()
 });
-var passesMembershipsRenderSchema = z60.object({
+var passesMembershipsRenderSchema = z61.object({
   display: passesMembershipsDisplaySchema,
   hydration: passesMembershipsHydrationSchema
 });
-var productListRenderSchema = z60.object({
+var productListRenderSchema = z61.object({
   display: productListDisplaySchema,
   hydration: productListHydrationSchema
 });
-var productDetailRenderSchema = z60.object({
+var productDetailRenderSchema = z61.object({
   display: productDetailDisplaySchema,
   hydration: productDetailHydrationSchema
 });
-var cartRenderSchema = z60.object({
+var cartRenderSchema = z61.object({
   display: cartDisplaySchema,
   hydration: cartHydrationSchema
 });
-var checkoutRenderSchema = z60.object({
+var checkoutRenderSchema = z61.object({
   display: checkoutDisplaySchema,
   hydration: checkoutHydrationSchema
 });
 function resolveShowPricePerCredit(source) {
   return source.showPricePerCredit ?? true;
 }
-var shopIslandMetaCodec = createZodCodec(z60.object({
-  siteId: z60.string().optional(),
-  apiBaseUrl: z60.string().optional(),
+var shopIslandMetaCodec = createZodCodec(z61.object({
+  siteId: z61.string().optional(),
+  apiBaseUrl: z61.string().optional(),
   stage: previewStageSchema.optional()
 }));
 var shopIslandMetaKeys = defineInteractiveIslandMetaKeys("siteId", "apiBaseUrl", "stage");
@@ -41831,9 +42047,9 @@ var shopBlockDefinition = {
   runtime: shopBlockRuntime,
   dataSchemas: {
     // listPublicPasses returns { passes: [...] }
-    passes: z61.object({ passes: z61.array(publicPassProductSchema) }).optional(),
+    passes: z62.object({ passes: z62.array(publicPassProductSchema) }).optional(),
     // listPublicMemberships returns { memberships: [...] }
-    memberships: z61.object({ memberships: z61.array(publicMembershipProductSchema) }).optional()
+    memberships: z62.object({ memberships: z62.array(publicMembershipProductSchema) }).optional()
   },
   dataLoaders: {
     // Load passes for display
@@ -41856,7 +42072,7 @@ var shopBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/product-list.ts
-import { z as z62 } from "zod";
+import { z as z63 } from "zod";
 var productListManifest = createBlockManifest({
   id: "block.product-list",
   version: "1.0.0",
@@ -41989,7 +42205,7 @@ var productListBlockDefinition = {
     }
   }
 };
-var productListDataSchema = z62.object({
+var productListDataSchema = z63.object({
   products: publicProductsResponseSchema.optional()
 });
 
@@ -42250,72 +42466,72 @@ var checkoutBlockDefinition = {
 };
 
 // ../blocks/src/system/runtime/nodes/gifting.interactive.ts
-import { z as z63 } from "zod";
-var publicGiftCardOfferSchema = z63.object({
-  id: z63.string(),
-  kind: z63.literal("gift_card"),
-  title: z63.string(),
-  description: z63.string().nullable(),
-  sortOrder: z63.number().int(),
-  giftCard: z63.object({
-    fixedDenominations: z63.array(z63.number().int().positive()),
-    customAmountEnabled: z63.boolean(),
-    customAmountMinCents: z63.number().int().positive(),
-    customAmountMaxCents: z63.number().int().positive()
+import { z as z64 } from "zod";
+var publicGiftCardOfferSchema = z64.object({
+  id: z64.string(),
+  kind: z64.literal("gift_card"),
+  title: z64.string(),
+  description: z64.string().nullable(),
+  sortOrder: z64.number().int(),
+  giftCard: z64.object({
+    fixedDenominations: z64.array(z64.number().int().positive()),
+    customAmountEnabled: z64.boolean(),
+    customAmountMinCents: z64.number().int().positive(),
+    customAmountMaxCents: z64.number().int().positive()
   }),
-  voucher: z63.null()
+  voucher: z64.null()
 });
-var publicVoucherOfferSchema = z63.object({
-  id: z63.string(),
-  kind: z63.literal("voucher"),
-  title: z63.string(),
-  description: z63.string().nullable(),
-  sortOrder: z63.number().int(),
-  giftCard: z63.null(),
-  voucher: z63.object({
-    purchaseAmountCents: z63.number().int().positive()
+var publicVoucherOfferSchema = z64.object({
+  id: z64.string(),
+  kind: z64.literal("voucher"),
+  title: z64.string(),
+  description: z64.string().nullable(),
+  sortOrder: z64.number().int(),
+  giftCard: z64.null(),
+  voucher: z64.object({
+    purchaseAmountCents: z64.number().int().positive()
   })
 });
-var publicGiftingOffersResponseSchema = z63.object({
-  currency: z63.string(),
-  giftCards: z63.array(publicGiftCardOfferSchema),
-  vouchers: z63.array(publicVoucherOfferSchema)
+var publicGiftingOffersResponseSchema = z64.object({
+  currency: z64.string(),
+  giftCards: z64.array(publicGiftCardOfferSchema),
+  vouchers: z64.array(publicVoucherOfferSchema)
 });
-var giftingSourceSchema = z63.object({
-  siteId: z63.string().optional(),
-  apiBaseUrl: z63.string().optional(),
+var giftingSourceSchema = z64.object({
+  siteId: z64.string().optional(),
+  apiBaseUrl: z64.string().optional(),
   offers: publicGiftingOffersResponseSchema.nullable().optional(),
-  className: z63.string().nullable().optional(),
-  heading: z63.string().nullable().optional(),
-  intro: z63.string().nullable().optional(),
-  giftCardsHeading: z63.string().nullable().optional(),
-  vouchersHeading: z63.string().nullable().optional(),
-  emptyStateText: z63.string().nullable().optional(),
-  checkoutButtonText: z63.string().nullable().optional(),
-  successMessage: z63.string().nullable().optional()
+  className: z64.string().nullable().optional(),
+  heading: z64.string().nullable().optional(),
+  intro: z64.string().nullable().optional(),
+  giftCardsHeading: z64.string().nullable().optional(),
+  vouchersHeading: z64.string().nullable().optional(),
+  emptyStateText: z64.string().nullable().optional(),
+  checkoutButtonText: z64.string().nullable().optional(),
+  successMessage: z64.string().nullable().optional()
 });
-var giftingDisplaySchema = z63.object({
-  kind: z63.literal("gifting"),
-  state: z63.literal("ready"),
-  className: z63.string().nullable(),
-  heading: z63.string(),
-  intro: z63.string().nullable(),
-  giftCardsHeading: z63.string(),
-  vouchersHeading: z63.string(),
-  emptyStateText: z63.string()
+var giftingDisplaySchema = z64.object({
+  kind: z64.literal("gifting"),
+  state: z64.literal("ready"),
+  className: z64.string().nullable(),
+  heading: z64.string(),
+  intro: z64.string().nullable(),
+  giftCardsHeading: z64.string(),
+  vouchersHeading: z64.string(),
+  emptyStateText: z64.string()
 });
-var giftingHydrationSchema = z63.object({
+var giftingHydrationSchema = z64.object({
   offers: publicGiftingOffersResponseSchema.nullable(),
-  checkoutButtonText: z63.string(),
-  successMessage: z63.string()
+  checkoutButtonText: z64.string(),
+  successMessage: z64.string()
 });
-var giftingRenderSchema = z63.object({
+var giftingRenderSchema = z64.object({
   display: giftingDisplaySchema,
   hydration: giftingHydrationSchema
 });
-var giftingIslandMetaCodec = createZodCodec(z63.object({
-  siteId: z63.string().optional(),
-  apiBaseUrl: z63.string().optional()
+var giftingIslandMetaCodec = createZodCodec(z64.object({
+  siteId: z64.string().optional(),
+  apiBaseUrl: z64.string().optional()
 }));
 var giftingIslandMetaKeys = defineInteractiveIslandMetaKeys(
   "siteId",
@@ -42497,7 +42713,89 @@ var giftingBlockDefinition = {
 };
 
 // ../blocks/src/system/runtime/nodes/newsletter-form.interactive.ts
-import { z as z64 } from "zod";
+import { z as z65 } from "zod";
+
+// ../blocks/src/system/blocks/newsletter-signup-destination.ts
+function parseNewsletterSignupBlockId(value) {
+  const trimmed = parseTrimmedString(value);
+  return trimmed && BLOCK_ID_PATTERN.test(trimmed) ? trimmed : null;
+}
+function parseSignedNewsletterDestinationRef(value) {
+  const trimmed = parseTrimmedString(value);
+  return trimmed && SIGNED_DESTINATION_REF_PATTERN.test(trimmed) ? trimmed : null;
+}
+function parseNewsletterSignupDestinationProvider(value) {
+  return value === "riverbank" || value === "mailchimp" ? value : null;
+}
+function buildNewsletterSignupBlockRef(blockId) {
+  const parsed = parseNewsletterSignupBlockId(blockId);
+  return parsed ? { tag: "block_ref", blockId: parsed } : null;
+}
+function normalizeNewsletterSignupEditorValuesForDestination(values) {
+  const destinationProvider = parseNewsletterSignupDestinationProvider(values.destinationProvider) ?? "riverbank";
+  if (destinationProvider === "mailchimp") {
+    return {
+      destinationProvider,
+      mailchimpAudienceId: values.mailchimpAudienceId,
+      mailchimpTags: values.mailchimpTags
+    };
+  }
+  return {
+    destinationProvider,
+    listId: values.listId,
+    tags: values.tags
+  };
+}
+function deriveNewsletterSignupRuntimeSource(values) {
+  const normalized = normalizeNewsletterSignupEditorValuesForDestination(values);
+  if (normalized.destinationProvider === "mailchimp") {
+    return {
+      destinationProvider: "mailchimp",
+      listId: null,
+      tags: null
+    };
+  }
+  return {
+    destinationProvider: "riverbank",
+    listId: parseTrimmedString(normalized.listId),
+    tags: parseTrimmedString(normalized.tags)
+  };
+}
+function sanitizeNewsletterSignupPublicContent(content) {
+  if (!isRecord9(content)) return content;
+  const provider = parseNewsletterSignupDestinationProvider(content.destinationProvider) ?? getProviderFromExplicitDestination(content.destination);
+  const {
+    destination: _destination,
+    destinationProvider: _destinationProvider,
+    mailchimpAudienceId: _mailchimpAudienceId,
+    mailchimpTags: _mailchimpTags,
+    listId,
+    tags: tags2,
+    ...publicContent
+  } = content;
+  const mutablePublicContent = { ...publicContent };
+  if (provider !== "mailchimp") {
+    if ("listId" in content) mutablePublicContent.listId = listId;
+    if ("tags" in content) mutablePublicContent.tags = tags2;
+  }
+  return mutablePublicContent;
+}
+function getProviderFromExplicitDestination(destination) {
+  if (!isRecord9(destination) || typeof destination.tag !== "string") return null;
+  if (destination.tag === "riverbank_list") return "riverbank";
+  if (destination.tag === "mailchimp_audience") return "mailchimp";
+  return null;
+}
+var BLOCK_ID_PATTERN = /^[A-Za-z0-9._:-]{1,200}$/;
+var SIGNED_DESTINATION_REF_PATTERN = /^[A-Za-z0-9._~-]{16,1000}$/;
+function parseTrimmedString(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function isRecord9(value) {
+  return typeof value === "object" && value !== null;
+}
 
 // ../blocks/src/system/runtime/nodes/newsletter-form.types.ts
 function getPresetFields(preset2, options) {
@@ -42550,49 +42848,65 @@ function withOptionalPhone(fields3, includePhone) {
 }
 
 // ../blocks/src/system/runtime/nodes/newsletter-form.interactive.ts
-var newsletterPresetSchema = z64.enum(["emailOnly", "emailName", "emailFirstLast", "emailNameCompany"]);
-var newsletterFieldSchema = z64.object({
-  id: z64.string(),
-  type: z64.enum(["email", "text"]),
-  label: z64.string(),
-  required: z64.boolean(),
-  placeholder: z64.string().optional()
+var newsletterPresetSchema = z65.enum(["emailOnly", "emailName", "emailFirstLast", "emailNameCompany"]);
+var newsletterDestinationProviderSchema = z65.enum(["riverbank", "mailchimp"]);
+var newsletterFieldSchema = z65.object({
+  id: z65.string(),
+  type: z65.enum(["email", "text"]),
+  label: z65.string(),
+  required: z65.boolean(),
+  placeholder: z65.string().optional()
 });
-var newsletterSourceSchema = z64.object({
-  siteId: z64.string().optional(),
-  apiBaseUrl: z64.string().optional(),
-  listId: z64.string().nullable().optional(),
+var newsletterSignupBlockIdSchema = z65.string().trim().min(1).transform(parseRequiredNewsletterSignupBlockId);
+var signedNewsletterDestinationRefSchema = z65.string().trim().min(1).transform(parseRequiredSignedNewsletterDestinationRef);
+var newsletterPublicDestinationRefSchema = z65.discriminatedUnion("tag", [
+  z65.object({
+    tag: z65.literal("block_ref"),
+    blockId: newsletterSignupBlockIdSchema
+  }),
+  z65.object({
+    tag: z65.literal("signed_destination_ref"),
+    token: signedNewsletterDestinationRefSchema
+  })
+]);
+var newsletterSourceSchema = z65.object({
+  blockId: z65.string().nullable().optional(),
+  siteId: z65.string().optional(),
+  apiBaseUrl: z65.string().optional(),
+  listId: z65.string().nullable().optional(),
+  destinationProvider: newsletterDestinationProviderSchema.nullable().optional(),
   preset: newsletterPresetSchema.optional(),
-  includePhone: z64.boolean().optional(),
-  buttonLabel: z64.string().nullable().optional(),
-  successMessage: z64.string().nullable().optional(),
-  privacyNote: z64.string().nullable().optional(),
-  tags: z64.string().nullable().optional(),
-  spamProtectionEnabled: z64.boolean().optional(),
-  className: z64.string().nullable().optional()
+  includePhone: z65.boolean().optional(),
+  buttonLabel: z65.string().nullable().optional(),
+  successMessage: z65.string().nullable().optional(),
+  privacyNote: z65.string().nullable().optional(),
+  tags: z65.string().nullable().optional(),
+  spamProtectionEnabled: z65.boolean().optional(),
+  className: z65.string().nullable().optional()
 });
-var newsletterDisplaySchema = z64.object({
-  kind: z64.literal("newsletter-form"),
-  className: z64.string().nullable(),
-  buttonLabel: z64.string(),
-  successMessage: z64.string().nullable(),
-  privacyNote: z64.string().nullable(),
-  fields: z64.array(newsletterFieldSchema)
+var newsletterDisplaySchema = z65.object({
+  kind: z65.literal("newsletter-form"),
+  className: z65.string().nullable(),
+  buttonLabel: z65.string(),
+  successMessage: z65.string().nullable(),
+  privacyNote: z65.string().nullable(),
+  fields: z65.array(newsletterFieldSchema)
 });
-var newsletterHydrationSchema = z64.object({
-  listId: z64.string().nullable().optional(),
+var newsletterHydrationSchema = z65.object({
+  destinationRef: newsletterPublicDestinationRefSchema.nullable().optional(),
+  listId: z65.string().nullable().optional(),
   preset: newsletterPresetSchema,
-  includePhone: z64.boolean(),
-  tags: z64.string().nullable().optional(),
-  spamProtectionEnabled: z64.boolean().optional()
+  includePhone: z65.boolean(),
+  tags: z65.string().nullable().optional(),
+  spamProtectionEnabled: z65.boolean().optional()
 });
-var newsletterRenderSchema = z64.object({
+var newsletterRenderSchema = z65.object({
   display: newsletterDisplaySchema,
   hydration: newsletterHydrationSchema
 });
-var newsletterIslandMetaCodec = createZodCodec(z64.object({
-  siteId: z64.string().optional(),
-  apiBaseUrl: z64.string().optional()
+var newsletterIslandMetaCodec = createZodCodec(z65.object({
+  siteId: z65.string().optional(),
+  apiBaseUrl: z65.string().optional()
 }));
 var newsletterIslandMetaKeys = defineInteractiveIslandMetaKeys("siteId", "apiBaseUrl");
 function buildNewsletterDisplay(source) {
@@ -42613,16 +42927,20 @@ var newsletterFormBlockRuntime = defineProgressiveBlockRuntime({
     source: createZodCodec(newsletterSourceSchema),
     render: createZodCodec(newsletterRenderSchema)
   },
-  buildRender: (source) => ({
-    display: buildNewsletterDisplay(source),
-    hydration: {
-      listId: source.listId,
-      preset: source.preset ?? "emailOnly",
-      includePhone: source.includePhone ?? false,
-      tags: source.tags ?? null,
-      spamProtectionEnabled: source.spamProtectionEnabled
-    }
-  })
+  buildRender: (source) => {
+    const runtimeSource = deriveNewsletterSignupRuntimeSource(source);
+    return {
+      display: buildNewsletterDisplay(source),
+      hydration: {
+        destinationRef: buildNewsletterSignupBlockRef(source.blockId),
+        listId: runtimeSource.listId,
+        preset: source.preset ?? "emailOnly",
+        includePhone: source.includePhone ?? false,
+        tags: runtimeSource.tags,
+        spamProtectionEnabled: source.spamProtectionEnabled
+      }
+    };
+  }
 });
 var newsletterFormInteractiveIslandPropsCodec = createInteractiveIslandCodec({
   runtime: newsletterFormBlockRuntime,
@@ -42645,6 +42963,20 @@ function buildNewsletterFormInteractiveIslandProps(props2) {
     source: props2
   });
 }
+function parseRequiredNewsletterSignupBlockId(value) {
+  const parsed = parseNewsletterSignupBlockId(value);
+  if (!parsed) {
+    throw new Error("Newsletter signup block destination ref requires blockId");
+  }
+  return parsed;
+}
+function parseRequiredSignedNewsletterDestinationRef(value) {
+  const parsed = parseSignedNewsletterDestinationRef(value);
+  if (!parsed) {
+    throw new Error("Newsletter signup signed destination ref requires token");
+  }
+  return parsed;
+}
 
 // ../blocks/src/system/blocks/newsletter-signup.ts
 var stackedComposition = composeFragments([
@@ -42724,23 +43056,23 @@ var newsletterSignupBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/team-members.ts
-import { z as z65 } from "zod";
+import { z as z66 } from "zod";
 var ITEM_NAME2 = "member";
 var teamMemberPhotoSchema = mediaSchema2.refine((media2) => media2.type === "image", {
   message: "Team member photos must be image media"
 }).nullable();
-var teamMemberDataSchema = z65.object({
-  _type: z65.literal("teamMember"),
-  id: z65.string(),
-  name: z65.string(),
-  role: z65.string().nullable(),
-  roleLabel: z65.string().nullable(),
-  bio: z65.string().nullable(),
-  summary: z65.string().nullable(),
+var teamMemberDataSchema = z66.object({
+  _type: z66.literal("teamMember"),
+  id: z66.string(),
+  name: z66.string(),
+  role: z66.string().nullable(),
+  roleLabel: z66.string().nullable(),
+  bio: z66.string().nullable(),
+  summary: z66.string().nullable(),
   photo: teamMemberPhotoSchema,
-  profilePath: z65.string().nullable()
+  profilePath: z66.string().nullable()
 });
-var teamMembersDataSchema = z65.array(teamMemberDataSchema);
+var teamMembersDataSchema = z66.array(teamMemberDataSchema);
 var dynamicSourceWhen = { equals: "site_staff" };
 var manualSourceWhen = { equals: "site_staff", not: true };
 var headingNode = text(
@@ -44675,7 +45007,7 @@ import React4 from "react";
 // ../blocks/src/system/data/linkedContentEntries.ts
 var LINKED_CONTENT_ENTRY_META_KEY = "__rbLinkedContentEntry";
 function coerceLinkedContentEntriesPayload(payload) {
-  if (!isRecord9(payload)) return payload;
+  if (!isRecord10(payload)) return payload;
   const response = payload;
   if (!Array.isArray(response.entries)) return payload;
   const contentType = parsePublicContentTypeMeta(response.contentType);
@@ -44683,16 +45015,16 @@ function coerceLinkedContentEntriesPayload(payload) {
   return response.entries.map((entry) => enrichLinkedContentEntry(entry, contentType));
 }
 function getLinkedContentEntryMeta(value) {
-  if (!isRecord9(value)) return null;
+  if (!isRecord10(value)) return null;
   const candidate = value[LINKED_CONTENT_ENTRY_META_KEY];
   return isLinkedContentEntryMeta(candidate) ? candidate : null;
 }
 function buildLinkedContentEditTarget(input) {
   const { entry, sourceBlockId, sourceBlockKind, itemIndex } = input;
-  if (!isRecord9(entry)) return null;
+  if (!isRecord10(entry)) return null;
   const meta = getLinkedContentEntryMeta(entry);
   if (!meta || meta.support.kind !== "supported") return null;
-  const content = isRecord9(entry.content) ? entry.content : {};
+  const content = isRecord10(entry.content) ? entry.content : {};
   return {
     kind: "linked-content-entry",
     entryId: meta.entryId,
@@ -44742,12 +45074,12 @@ function resolveLinkedEntryInlineFieldEligibility(input) {
   };
 }
 function enrichLinkedContentEntry(entry, contentType) {
-  if (!isRecord9(entry)) return entry;
+  if (!isRecord10(entry)) return entry;
   const entryId = typeof entry.id === "string" ? entry.id : null;
   if (!entryId) return entry;
   const title = typeof entry.title === "string" && entry.title.trim().length > 0 ? entry.title : entryId;
   const optimisticHash = typeof entry.optimisticHash === "string" && entry.optimisticHash.length > 0 ? entry.optimisticHash : null;
-  const content = isRecord9(entry.content) ? entry.content : {};
+  const content = isRecord10(entry.content) ? entry.content : {};
   const meta = {
     kind: "linked-content-entry",
     entryId,
@@ -44843,7 +45175,7 @@ function capitalize(value) {
   return value.charAt(0).toUpperCase() + value.slice(1).toLowerCase();
 }
 function parsePublicContentTypeMeta(value) {
-  if (!isRecord9(value)) return null;
+  if (!isRecord10(value)) return null;
   if (typeof value.key !== "string" || value.key.trim().length === 0) return null;
   return {
     key: value.key,
@@ -44853,7 +45185,7 @@ function parsePublicContentTypeMeta(value) {
   };
 }
 function parsePublicContentTypeLinkedEntryEditing(value) {
-  if (!isRecord9(value) || typeof value.kind !== "string") return null;
+  if (!isRecord10(value) || typeof value.kind !== "string") return null;
   switch (value.kind) {
     case "generic":
       return { kind: "generic" };
@@ -44867,7 +45199,7 @@ function parsePublicContentTypeLinkedEntryEditing(value) {
   }
 }
 function parsePublicContentTypeFieldMeta(value) {
-  if (!isRecord9(value)) return [];
+  if (!isRecord10(value)) return [];
   if (typeof value.id !== "string" || typeof value.type !== "string") return [];
   return [{
     id: value.id,
@@ -44882,14 +45214,14 @@ function parseStringArray(value) {
   return value.filter((item) => typeof item === "string");
 }
 function isLinkedContentEntryMeta(value) {
-  if (!isRecord9(value)) return false;
+  if (!isRecord10(value)) return false;
   if (value.kind !== "linked-content-entry") return false;
   if (typeof value.entryId !== "string") return false;
   if (typeof value.contentTypeKey !== "string") return false;
   if (typeof value.contentTypeLabel !== "string") return false;
   if (typeof value.title !== "string") return false;
   if (!(value.optimisticHash === null || typeof value.optimisticHash === "string")) return false;
-  if (!isRecord9(value.contentType)) return false;
+  if (!isRecord10(value.contentType)) return false;
   if (!isLinkedEntryFieldSourceArray(value.fieldSources)) return false;
   return isLinkedContentEditSupport(value.support);
 }
@@ -44897,7 +45229,7 @@ function isLinkedEntryFieldSourceArray(value) {
   return Array.isArray(value) && value.every(isLinkedEntryFieldSource);
 }
 function isLinkedEntryFieldSource(value) {
-  if (!isRecord9(value)) return false;
+  if (!isRecord10(value)) return false;
   if (typeof value.displayPath !== "string") return false;
   switch (value.kind) {
     case "content-field":
@@ -44923,7 +45255,7 @@ function isLinkedEntryInlineFieldReadOnlyReason(value) {
   }
 }
 function isLinkedContentEditSupport(value) {
-  if (!isRecord9(value) || typeof value.kind !== "string") return false;
+  if (!isRecord10(value) || typeof value.kind !== "string") return false;
   switch (value.kind) {
     case "supported":
       return true;
@@ -44935,7 +45267,7 @@ function isLinkedContentEditSupport(value) {
       return false;
   }
 }
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -45267,6 +45599,8 @@ function renderDoc(node, key, imageResolveContext) {
       return /* @__PURE__ */ jsx15("blockquote", { children }, key);
     case "horizontalRule":
       return /* @__PURE__ */ jsx15("hr", {}, key);
+    case "hardBreak":
+      return /* @__PURE__ */ jsx15("br", {}, key);
     case "image": {
       const attrs = node.attrs ?? {};
       const src = typeof attrs.src === "string" ? attrs.src.trim() : "";
@@ -45323,84 +45657,11 @@ function Text({
   return /* @__PURE__ */ jsx16(Comp, { className, ...dataAttributes, children });
 }
 
-// ../blocks/src/system/manifest/richTextSchema.ts
-import { z as z66 } from "zod";
-var TipTapMarkSchema = z66.object({
-  type: z66.string(),
-  attrs: z66.record(z66.string(), z66.unknown()).optional()
-});
-var TipTapNodeSchema = z66.lazy(
-  () => z66.object({
-    type: z66.string(),
-    content: z66.array(TipTapNodeSchema).optional(),
-    text: z66.string().optional(),
-    attrs: z66.record(z66.string(), z66.unknown()).optional(),
-    marks: z66.array(TipTapMarkSchema).optional()
-  })
-);
-var RichTextValueSchema = z66.union([
-  // Canonical: TipTap document directly
-  TipTapNodeSchema,
-  // Legacy (read-tolerance only): wrapped in { doc: {...} }
-  z66.object({
-    doc: TipTapNodeSchema
-  })
-]);
-var RichTextDocSchema = z66.object({
-  type: z66.literal("doc"),
-  content: z66.array(TipTapNodeSchema)
-});
-function unwrapRichTextRoot(value) {
-  if (!isRecord4(value)) return value;
-  if (!("doc" in value)) return value;
-  const inner = value.doc;
-  if (isRecord4(inner) && inner.type === "doc") return inner;
-  return value;
-}
-
 // ../blocks/src/system/runtime/nodes/richText-coerce.ts
-function parseInlineMarkdown(text2) {
-  const out = [];
-  const pushText = (value, marks) => {
-    if (!value) return;
-    out.push(
-      marks && marks.length > 0 ? { type: "text", text: value, marks } : { type: "text", text: value }
-    );
-  };
-  let rest = text2;
-  while (rest.length > 0) {
-    const start = rest.indexOf("**");
-    if (start === -1) {
-      pushText(rest);
-      break;
-    }
-    const end = rest.indexOf("**", start + 2);
-    if (end === -1) {
-      pushText(rest);
-      break;
-    }
-    pushText(rest.slice(0, start));
-    pushText(rest.slice(start + 2, end), [{ type: "bold" }]);
-    rest = rest.slice(end + 2);
-  }
-  return out;
-}
-function markdownToTipTapDoc(markdown) {
-  const normalized = markdown.replace(/\r\n/g, "\n").trim();
-  if (!normalized) return { type: "doc", content: [] };
-  const paragraphs = normalized.split(/\n{2,}/).map((p) => p.trim()).filter(Boolean);
-  return {
-    type: "doc",
-    content: paragraphs.map((p) => {
-      const inline2 = parseInlineMarkdown(p);
-      return inline2.length > 0 ? { type: "paragraph", content: inline2 } : { type: "paragraph" };
-    })
-  };
-}
 function coerceRichTextDoc(value) {
   const raw = unwrapRichTextRoot(value);
   if (typeof raw === "string") {
-    return markdownToTipTapDoc(raw);
+    return createRichTextDocFromMarkdown(raw);
   }
   if (isRecord4(raw) && typeof raw.type === "string") {
     return raw;
@@ -46462,12 +46723,12 @@ function toTrimmedString(value) {
   return trimmed ? trimmed : void 0;
 }
 function normalizeBookingFormConfig(form2) {
-  if (!isRecord10(form2)) return null;
+  if (!isRecord11(form2)) return null;
   const id = readNonEmptyString(form2.id);
   const name = readNonEmptyString(form2.name);
   if (!id || !name) return null;
-  const schemaSource = isRecord10(form2.schema) ? form2.schema : isRecord10(form2.schemaJson) ? form2.schemaJson : null;
-  const settingsSource = isRecord10(form2.settings) ? form2.settings : isRecord10(form2.settingsJson) ? form2.settingsJson : null;
+  const schemaSource = isRecord11(form2.schema) ? form2.schema : isRecord11(form2.schemaJson) ? form2.schemaJson : null;
+  const settingsSource = isRecord11(form2.settings) ? form2.settings : isRecord11(form2.settingsJson) ? form2.settingsJson : null;
   return {
     id,
     name,
@@ -46491,10 +46752,10 @@ function normalizeBookingServices(services) {
   if (Array.isArray(services)) {
     return services.filter(isBookingFormService).map(normalizeService);
   }
-  if (isRecord10(services) && "services" in services) {
+  if (isRecord11(services) && "services" in services) {
     return Array.isArray(services.services) ? services.services.filter(isBookingFormService).map(normalizeService) : [];
   }
-  return isRecord10(services) ? Object.values(services).filter(isBookingFormService).map(normalizeService) : [];
+  return isRecord11(services) ? Object.values(services).filter(isBookingFormService).map(normalizeService) : [];
 }
 function normalizeBookingSchema(value) {
   if (!value) return void 0;
@@ -46506,7 +46767,7 @@ function normalizeBookingSchema(value) {
   };
 }
 function readBookingFormField(value) {
-  if (!isRecord10(value)) return null;
+  if (!isRecord11(value)) return null;
   const id = readNonEmptyString(value.id);
   const label = readNonEmptyString(value.label);
   const type = readBookingFieldType(value.type);
@@ -46552,7 +46813,7 @@ function readBookingFieldOptions(value) {
   return options.length > 0 ? options : void 0;
 }
 function readBookingFieldOption(value) {
-  if (!isRecord10(value)) return null;
+  if (!isRecord11(value)) return null;
   const optionValue = readNonEmptyString(value.value);
   const label = readNonEmptyString(value.label);
   return optionValue && label ? { value: optionValue, label } : null;
@@ -46569,7 +46830,7 @@ function normalizeBookingSettings(value) {
   };
 }
 function isBookingFormService(value) {
-  return isRecord10(value) && typeof value.id === "string" && typeof value.siteId === "string" && typeof value.title === "string";
+  return isRecord11(value) && typeof value.id === "string" && typeof value.siteId === "string" && typeof value.title === "string";
 }
 function readNonEmptyString(value) {
   if (typeof value !== "string") return null;
@@ -46587,7 +46848,7 @@ function readStringArray(value) {
   const strings = value.filter((item) => typeof item === "string");
   return strings.length > 0 ? strings : void 0;
 }
-function isRecord10(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null;
 }
 
@@ -47008,6 +47269,32 @@ function TeamMemberName({
 }) {
   return profilePath ? /* @__PURE__ */ jsx29("a", { href: profilePath, className: "rb-hover-opacity-80", children: /* @__PURE__ */ jsx29("strong", { children: name }) }) : /* @__PURE__ */ jsx29("strong", { children: name });
 }
+function formatTicketTypePrice(ticketType, currency) {
+  return formatCurrencyAmount(ticketType.priceAmount, currency, { decimals: "auto" });
+}
+function getActiveTicketTypes(event) {
+  return event.pricing.kind === "ticket_types" ? event.pricing.ticketTypes.filter((ticketType) => ticketType.isActive).sort((left, right) => left.sortOrder - right.sortOrder) : [];
+}
+function TicketTypePriceList({
+  ticketTypes,
+  currency
+}) {
+  if (ticketTypes.length === 0) return null;
+  return /* @__PURE__ */ jsx29("div", { className: "rb-mt-3 rb-flex rb-flex-col rb-gap-2", children: ticketTypes.map((ticketType) => /* @__PURE__ */ jsxs16(
+    "div",
+    {
+      className: "rb-flex rb-items-start rb-justify-between rb-gap-4",
+      children: [
+        /* @__PURE__ */ jsxs16("div", { children: [
+          /* @__PURE__ */ jsx29("p", { children: ticketType.name }),
+          ticketType.description ? /* @__PURE__ */ jsx29("p", { className: "rb-caption status-muted", children: ticketType.description }) : null
+        ] }),
+        /* @__PURE__ */ jsx29("p", { children: /* @__PURE__ */ jsx29("strong", { children: formatTicketTypePrice(ticketType, currency) }) })
+      ]
+    },
+    ticketType.id
+  )) });
+}
 function EventDetailsView({
   selection,
   showVenue,
@@ -47042,6 +47329,7 @@ function EventDetailsView({
   const shouldShowCoursePricing = showCost && !isDropIn && coursePricing !== null;
   const shouldShowEventCost = showCost && isPaid && !isDropIn && coursePricing === null;
   const eventCostLabel = shouldShowEventCost ? formatEventPrice(selected) : null;
+  const ticketTypes = shouldShowEventCost ? getActiveTicketTypes(selected) : [];
   const acceptedItems = [];
   if (showAcceptedPasses) {
     acceptedItems.push(...applicablePasses.map((p) => p.name));
@@ -47098,6 +47386,7 @@ function EventDetailsView({
           /* @__PURE__ */ jsx29("div", { className: "rb-label rb-mb-2", children: "Cost" }),
           /* @__PURE__ */ jsx29("p", { children: /* @__PURE__ */ jsx29("strong", { children: eventCostLabel }) }),
           autoApplyDiscount ? /* @__PURE__ */ jsx29("p", { className: "rb-caption rb-mt-1", children: formatAutoApplyDiscountLine(autoApplyDiscount, eventPricingCurrency) }) : null,
+          /* @__PURE__ */ jsx29(TicketTypePriceList, { ticketTypes, currency: eventPricingCurrency }),
           hasAcceptedItems ? /* @__PURE__ */ jsxs16("p", { className: "rb-caption rb-mt-1", children: [
             "You can also attend with: ",
             acceptedItems.join(", ")
@@ -49228,6 +49517,7 @@ function EventRegistrationSSR({
   successMessage,
   waitlistMessage,
   buttonVariant,
+  overlayEnabled,
   spamProtectionEnabled,
   stage,
   supportEmail,
@@ -49249,6 +49539,7 @@ function EventRegistrationSSR({
     successMessage,
     waitlistMessage,
     buttonVariant,
+    overlayEnabled,
     spamProtectionEnabled,
     stage,
     supportEmail
@@ -49513,6 +49804,7 @@ function NewsletterFormSSR({
   siteId,
   apiBaseUrl,
   listId,
+  destinationProvider,
   preset: preset2 = "emailOnly",
   includePhone,
   buttonLabel = "Subscribe",
@@ -49523,9 +49815,11 @@ function NewsletterFormSSR({
   className
 }) {
   const islandProps = buildNewsletterFormInteractiveIslandProps({
+    blockId,
     siteId,
     apiBaseUrl,
     listId,
+    destinationProvider,
     preset: preset2,
     includePhone,
     buttonLabel,
@@ -49905,14 +50199,14 @@ function isDecoratedHeadingBlockKind(blockKind) {
   return blockKind === "block.intro" || blockKind === "block.feature-cards" || blockKind === "block.testimonials" || blockKind === "block.faq";
 }
 function readVariant(blockContent) {
-  if (!isRecord11(blockContent)) return void 0;
+  if (!isRecord12(blockContent)) return void 0;
   const variant = blockContent.variant;
   return typeof variant === "string" ? variant : void 0;
 }
 function isFaqDecoratedVariant(variant) {
   return variant === "default" || variant === "question-columns";
 }
-function isRecord11(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function buildHeadingDecorationWrapperClassName(className) {
@@ -55290,6 +55584,7 @@ var MemoBlockSection = React6.memo(
             apiBaseUrl: dataContext?.apiBaseUrl ?? null,
             portalToken: dataContext?.portalToken ?? null,
             bookingOfferingPresets: dataContext?.bookingOfferingPresets ?? [],
+            eventRegistrationOverlayEnabled: dataContext?.eventRegistrationOverlayEnabled ?? false,
             ...routes ? { routes } : {},
             // Identifier maps for CTA link resolution at render time
             ...dataContext?.pagesByIdentifier ? { pagesByIdentifier: dataContext.pagesByIdentifier } : {},
@@ -58670,6 +58965,7 @@ var containerResponsiveThemeCss = `/*
  */
 
 :where(.theme-scope) :where([data-block="event-registration"]) {
+  --rb-modal-overlay-bg: rgb(var(--tb-text, 0 0 0) / 0.6);
   --rb-event-tile-bg: var(--er-event-card-bg);
   --rb-event-tile-border: var(--er-border);
   --rb-event-tile-border-width: var(--er-event-card-border-width);
@@ -60339,6 +60635,239 @@ var containerResponsiveThemeCss = `/*
   background: rgba(var(--tb-text), 0.05);
 }
 
+/* In-flow booking teaser (sits at the block's position in the page) */
+:where(.theme-scope) :where([data-block="event-registration"]) .er-booking-teaser {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  justify-content: space-between;
+  gap: 1rem 1.5rem;
+  padding: 1.25rem 1.5rem;
+  border: 1px solid var(--er-border);
+  border-radius: var(--rb-block-radius);
+  background: var(--er-event-card-bg);
+  color: var(--er-on-surface);
+}
+
+:where(.theme-scope) :where([data-block="event-registration"]) .er-booking-teaser__info {
+  display: flex;
+  flex-direction: column;
+  gap: 0.25rem;
+  min-width: 0;
+}
+
+:where(.theme-scope) :where([data-block="event-registration"]) .er-booking-teaser__title {
+  font-size: 1.0625rem;
+  font-weight: 700;
+  line-height: 1.2;
+}
+
+:where(.theme-scope) :where([data-block="event-registration"]) .er-booking-teaser__meta {
+  font-size: 0.9375rem;
+  line-height: 1.3;
+  opacity: 0.75;
+}
+
+:where(.theme-scope) :where([data-block="event-registration"]) .er-booking-teaser__tickets {
+  display: flex;
+  flex-direction: column;
+  gap: 0.375rem;
+  margin-top: 0.5rem;
+  padding-top: 0.625rem;
+  border-top: 1px solid var(--er-border);
+}
+
+:where(.theme-scope) :where([data-block="event-registration"]) .er-booking-teaser__ticket {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 1rem;
+  font-size: 0.9375rem;
+  line-height: 1.35;
+}
+
+:where(.theme-scope) :where([data-block="event-registration"]) .er-booking-teaser__ticket-name {
+  min-width: 0;
+}
+
+:where(.theme-scope) :where([data-block="event-registration"]) .er-booking-teaser__cta {
+  flex: 0 0 auto;
+}
+
+/* Fixed, full-width sticky booking bar (content-agnostic; sits above page flow) */
+:where(.theme-scope) :where([data-block="event-registration"]) .er-booking-bar {
+  position: fixed;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  z-index: 12000;
+  padding: 0.75rem max(1rem, env(safe-area-inset-right)) max(0.75rem, env(safe-area-inset-bottom)) max(1rem, env(safe-area-inset-left));
+  background: rgb(var(--tb-background));
+  border-top: 1px solid var(--er-border);
+  box-shadow: 0 -10px 30px rgba(var(--tb-shadow), 0.16);
+}
+
+:where(.theme-scope) :where([data-block="event-registration"]) .er-booking-bar__inner {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 1rem;
+  width: 100%;
+  max-width: 72rem;
+  margin-inline: auto;
+}
+
+:where(.theme-scope) :where([data-block="event-registration"]) .er-booking-bar__info {
+  display: flex;
+  flex-direction: column;
+  gap: 0.125rem;
+  min-width: 0;
+}
+
+:where(.theme-scope) :where([data-block="event-registration"]) .er-booking-bar__title {
+  font-size: 0.95rem;
+  font-weight: 700;
+  line-height: 1.2;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+:where(.theme-scope) :where([data-block="event-registration"]) .er-booking-bar__meta {
+  font-size: 0.8125rem;
+  line-height: 1.25;
+  opacity: 0.75;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+:where(.theme-scope) :where([data-block="event-registration"]) .er-booking-bar__cta {
+  flex: 0 0 auto;
+}
+
+:where(.theme-scope) :where([data-block="event-registration"]) .er-booking-overlay {
+  position: fixed;
+  inset: 0;
+  height: 100dvh;
+  z-index: 14000;
+  display: flex;
+  align-items: stretch;
+  justify-content: stretch;
+  background: var(--rb-modal-overlay-bg);
+}
+
+:where(.theme-scope) :where([data-block="event-registration"]) .er-booking-overlay__panel {
+  position: relative;
+  z-index: 1;
+  display: flex;
+  flex-direction: column;
+  width: 100%;
+  height: 100dvh;
+  min-height: 0;
+  overflow: hidden;
+  background: rgb(var(--tb-background));
+  color: var(--er-on-surface);
+}
+
+:where(.theme-scope) :where([data-block="event-registration"]) .er-booking-overlay__header {
+  flex: 0 0 auto;
+  z-index: 2;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 1rem;
+  padding: 1rem;
+  background: rgb(var(--tb-background));
+  border-bottom: 1px solid var(--er-border);
+}
+
+:where(.theme-scope) :where([data-block="event-registration"]) .er-booking-overlay__title {
+  margin: 0;
+  font-size: 1rem;
+  line-height: 1.25;
+  font-weight: 700;
+}
+
+:where(.theme-scope) :where([data-block="event-registration"]) .er-booking-overlay__close {
+  width: 2rem;
+  height: 2rem;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  border: 1px solid var(--er-border);
+  border-radius: 999px;
+  background: transparent;
+  color: rgb(var(--tb-text));
+  font-size: 1.25rem;
+  line-height: 1;
+  cursor: pointer;
+}
+
+:where(.theme-scope) :where([data-block="event-registration"]) .er-container--overlay {
+  max-width: none;
+  border: 0;
+  border-radius: 0;
+  padding: 0;
+  background: transparent;
+  display: flex;
+  flex: 1 1 auto;
+  min-height: 0;
+  overflow: hidden;
+}
+
+:where(.theme-scope) :where([data-block="event-registration"]) .er-container--overlay .er-payment-layout {
+  flex: 1 1 auto;
+  min-height: 0;
+  height: 100%;
+  gap: 0;
+  grid-template-rows: minmax(0, 1fr) auto;
+  grid-template-areas:
+    "main"
+    "footer";
+}
+
+:where(.theme-scope) :where([data-block="event-registration"]) .er-container--overlay .er-payment-layout-main {
+  min-height: 0;
+  overflow: auto;
+  padding: 1rem;
+}
+
+:where(.theme-scope) :where([data-block="event-registration"]) .er-container--overlay .er-payment-layout-footer {
+  position: relative;
+  z-index: 3;
+  padding: 0.875rem 1rem max(0.875rem, env(safe-area-inset-bottom));
+  background: rgb(var(--tb-background));
+  border-top: 1px solid var(--er-border);
+  box-shadow: 0 -12px 26px rgba(var(--tb-shadow), 0.12);
+}
+
+:where(.theme-scope) :where([data-block="event-registration"]) .er-container--overlay .er-actions {
+  margin-top: 0;
+}
+
+@container rb-site (min-width: 768px) {
+@scope ([data-rb-responsive-mode="container"]) to (:scope [data-rb-responsive-mode]) {
+:where(.theme-scope) :where([data-block="event-registration"]) .er-booking-overlay {
+    justify-content: flex-end;
+  }
+
+  :where(.theme-scope) :where([data-block="event-registration"]) .er-booking-overlay__panel {
+    width: min(32rem, 100vw);
+    min-height: 100%;
+    box-shadow: -16px 0 40px rgba(var(--tb-shadow), 0.22);
+  }
+
+  :where(.theme-scope) :where([data-block="event-registration"]) .er-container--overlay .er-payment-layout-main {
+    padding: 1.25rem;
+  }
+
+  :where(.theme-scope) :where([data-block="event-registration"]) .er-container--overlay .er-payment-layout-footer {
+    padding: 0.875rem 1.25rem max(0.875rem, env(safe-area-inset-bottom));
+  }
+}
+}
+
 /* Magic Link Form */
 :where(.theme-scope) :where([data-block="event-registration"]) .er-magic-link-form {
   display: flex;
@@ -67626,7 +68155,7 @@ function preset(id, verticalId, canonicalBehaviour, label, pluralLabel, descript
 }
 
 // ../api/src/utils/isRecord.ts
-function isRecord12(value) {
+function isRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -67933,7 +68462,7 @@ function sanitizeMarks(marks) {
     if (mark.type === "bold" || mark.type === "strong" || mark.type === "italic" || mark.type === "em") {
       return [{ type: mark.type }];
     }
-    if (mark.type === "link" && isRecord12(mark.attrs) && typeof mark.attrs.href === "string") {
+    if (mark.type === "link" && isRecord13(mark.attrs) && typeof mark.attrs.href === "string") {
       const attrs = { href: mark.attrs.href };
       if (typeof mark.attrs.target === "string" && mark.attrs.target.trim().length > 0) {
         attrs.target = mark.attrs.target;
@@ -67948,10 +68477,10 @@ function sanitizeMarks(marks) {
   return sanitized.length > 0 ? sanitized : void 0;
 }
 function unwrapRichTextValue(value) {
-  if (isRecord12(value) && isRecord12(value.doc)) {
+  if (isRecord13(value) && isRecord13(value.doc)) {
     return unwrapRichTextValue(value.doc);
   }
-  if (isRecord12(value) && value.type === "doc") {
+  if (isRecord13(value) && value.type === "doc") {
     return {
       type: "doc",
       content: Array.isArray(value.content) ? value.content.filter(isTipTapNodeLike).map(coerceTipTapNode) : []
@@ -67960,7 +68489,7 @@ function unwrapRichTextValue(value) {
   return EMPTY_SITE_BANNER_BODY;
 }
 function isTipTapNodeLike(value) {
-  return isRecord12(value) && typeof value.type === "string";
+  return isRecord13(value) && typeof value.type === "string";
 }
 function coerceTipTapNode(value) {
   return {
@@ -67968,9 +68497,9 @@ function coerceTipTapNode(value) {
     ...Array.isArray(value.content) ? { content: value.content.filter(isTipTapNodeLike).map(coerceTipTapNode) } : {},
     ...typeof value.text === "string" ? { text: value.text } : {},
     ...Array.isArray(value.marks) ? {
-      marks: value.marks.filter((mark) => isRecord12(mark) && typeof mark.type === "string").map((mark) => ({
+      marks: value.marks.filter((mark) => isRecord13(mark) && typeof mark.type === "string").map((mark) => ({
         type: mark.type,
-        ...isRecord12(mark.attrs) ? { attrs: mark.attrs } : {}
+        ...isRecord13(mark.attrs) ? { attrs: mark.attrs } : {}
       }))
     } : {}
   };
@@ -68150,21 +68679,8 @@ var MultiPageUpdateResponse = z76.object({
 });
 
 // src/data/prefetchBlockData.ts
-var SUPPORTED_LOADER_ENDPOINTS2 = [
-  "listPublishedEntries",
-  "getPublishedEntryPreview",
-  "listPublicEvents",
-  "listPublicCourses",
-  "listPublicTeamMembers",
-  "listPublicProducts",
-  "listPublicPasses",
-  "listPublicMemberships",
-  "getPublicFormById",
-  "getPublicBookingServices",
-  "getPublicEventDetails"
-];
 function isSupportedLoaderEndpoint2(endpoint) {
-  return SUPPORTED_LOADER_ENDPOINTS2.includes(endpoint);
+  return SUPPORTED_LOADER_ENDPOINTS.includes(endpoint);
 }
 var ENTRY_REF_KEYS = [
   "identifier",
@@ -68173,7 +68689,7 @@ var ENTRY_REF_KEYS = [
   "entryId",
   "slug"
 ];
-function isRecord13(value) {
+function isRecord14(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function extractManualEntryRef(item) {
@@ -68181,7 +68697,7 @@ function extractManualEntryRef(item) {
     const trimmed = item.trim();
     return trimmed.length > 0 ? trimmed : null;
   }
-  if (!isRecord13(item)) return null;
+  if (!isRecord14(item)) return null;
   for (const key of ENTRY_REF_KEYS) {
     const raw = item[key];
     if (typeof raw === "string" && raw.trim().length > 0) {
@@ -68229,6 +68745,194 @@ function parseManualEntryRefs(...values) {
   }
   return void 0;
 }
+var loaderAdapters = {
+  listPublishedEntries: listPublishedEntries2,
+  getPublishedEntryPreview,
+  listPublicEvents,
+  getPublicEventDetails,
+  listPublicCourses,
+  listPublicRouteCandidates,
+  listPublicTeamMembers,
+  listPublicProducts,
+  listPublicPasses,
+  listPublicMemberships,
+  getPublicFormById,
+  getPublicBookingServices
+};
+function readStringParam(params, key) {
+  const value = params[key];
+  return value && value.length > 0 ? value : void 0;
+}
+function requireStringParam(params, key, endpoint) {
+  const value = readStringParam(params, key);
+  if (!value) {
+    throw new Error(`${endpoint} requires ${key} param`);
+  }
+  return value;
+}
+function parsePositiveIntegerParam(params, key) {
+  const value = params[key];
+  const parsed = value === void 0 ? void 0 : Number.parseInt(value, 10);
+  return typeof parsed === "number" && Number.isInteger(parsed) && parsed > 0 ? parsed : void 0;
+}
+function parseEntryOrder(value) {
+  if (value === void 0) return void 0;
+  switch (value) {
+    case "order":
+      return "manual";
+    case "newest":
+    case "oldest":
+    case "title":
+      return value;
+    default:
+      return void 0;
+  }
+}
+function parsePublicEventKind(value) {
+  if (value === void 0) return void 0;
+  switch (value) {
+    case "all":
+    case "courses":
+    case "events":
+      return value;
+    default:
+      return void 0;
+  }
+}
+async function listPublishedEntries2({ client, params }) {
+  const siteId = requireStringParam(params, "siteId", "listPublishedEntries");
+  const type = requireStringParam(params, "type", "listPublishedEntries");
+  const stage = readStringParam(params, "stage");
+  const mode = readStringParam(params, "mode");
+  const parsedEntryRefs = mode === "manual" ? parseManualEntryRefs(params.identifiers, params.entryRefs, params.entryIds) : void 0;
+  if (mode === "manual" && (!parsedEntryRefs || parsedEntryRefs.length === 0)) {
+    return { entries: [] };
+  }
+  if (mode === "manual" && parsedEntryRefs) {
+    return await client.getEntriesByIdentifiers({
+      siteId,
+      contentType: type,
+      identifiers: parsedEntryRefs,
+      preview: stage === "preview"
+    });
+  }
+  return await client.getEntries({
+    siteId,
+    contentType: type,
+    limit: parsePositiveIntegerParam(params, "limit"),
+    order: parseEntryOrder(readStringParam(params, "orderBy")),
+    preview: stage === "preview"
+  });
+}
+async function getPublishedEntryPreview({ client, params }) {
+  return await client.getEntry({
+    siteId: requireStringParam(params, "siteId", "getPublishedEntryPreview"),
+    contentType: requireStringParam(params, "type", "getPublishedEntryPreview"),
+    slug: requireStringParam(params, "slug", "getPublishedEntryPreview")
+  });
+}
+async function listPublicEvents({ client, params }) {
+  return await client.listPublicEvents({
+    siteId: requireStringParam(params, "siteId", "listPublicEvents"),
+    limit: parsePositiveIntegerParam(params, "limit"),
+    from: readStringParam(params, "from"),
+    to: readStringParam(params, "to"),
+    afterStartsAt: readStringParam(params, "afterStartsAt"),
+    afterId: readStringParam(params, "afterId"),
+    stage: readStringParam(params, "stage"),
+    categoryIds: readStringParam(params, "categoryIds"),
+    venueId: readStringParam(params, "venueId"),
+    staffMemberId: readStringParam(params, "staffMemberId"),
+    kind: parsePublicEventKind(readStringParam(params, "kind")),
+    eventSurface: readStringParam(params, "eventSurface"),
+    eventPresets: readStringParam(params, "eventPresets"),
+    scheduleScope: readStringParam(params, "scheduleScope"),
+    entryId: readStringParam(params, "entryId"),
+    seriesId: readStringParam(params, "seriesId"),
+    includeOccurrenceId: readStringParam(params, "includeOccurrenceId")
+  });
+}
+async function getPublicEventDetails({ client, params }) {
+  return await client.getPublicEventDetails({
+    siteId: requireStringParam(params, "siteId", "getPublicEventDetails"),
+    limit: parsePositiveIntegerParam(params, "limit"),
+    from: readStringParam(params, "from"),
+    to: readStringParam(params, "to"),
+    afterStartsAt: readStringParam(params, "afterStartsAt"),
+    afterId: readStringParam(params, "afterId"),
+    stage: readStringParam(params, "stage"),
+    categoryIds: readStringParam(params, "categoryIds"),
+    venueId: readStringParam(params, "venueId"),
+    staffMemberId: readStringParam(params, "staffMemberId"),
+    kind: readStringParam(params, "kind"),
+    eventSurface: readStringParam(params, "eventSurface"),
+    eventPresets: readStringParam(params, "eventPresets"),
+    scheduleScope: readStringParam(params, "scheduleScope"),
+    entryId: readStringParam(params, "entryId"),
+    seriesId: readStringParam(params, "seriesId"),
+    includeOccurrenceId: readStringParam(params, "includeOccurrenceId")
+  });
+}
+async function listPublicCourses({ client, params }) {
+  return await client.listPublicCourses({
+    siteId: requireStringParam(params, "siteId", "listPublicCourses"),
+    limit: parsePositiveIntegerParam(params, "limit"),
+    stage: readStringParam(params, "stage")
+  });
+}
+async function listPublicRouteCandidates({ client, params }) {
+  const siteId = requireStringParam(params, "siteId", "listPublicRouteCandidates");
+  const response = await client.getAllPublishedRoutes({ siteId });
+  return {
+    routes: response.items.flatMap((item) => {
+      if (!item.path) return [];
+      return [{
+        entityId: item.entityId,
+        path: item.path,
+        title: item.title,
+        kind: item.entityType,
+        contentTypeKey: item.contentTypeKey ?? null
+      }];
+    })
+  };
+}
+async function listPublicTeamMembers({ client, params }) {
+  return await client.listPublicTeamMembers({
+    siteId: requireStringParam(params, "siteId", "listPublicTeamMembers"),
+    stage: readStringParam(params, "stage")
+  });
+}
+async function listPublicProducts({ client, params }) {
+  return await client.listPublicProducts({
+    siteId: requireStringParam(params, "siteId", "listPublicProducts"),
+    stage: readStringParam(params, "stage") === "preview" ? "preview" : "published",
+    categorySelector: parsePublicProductCategorySelector(params.categorySelector)
+  });
+}
+async function listPublicPasses({ client, params }) {
+  return await client.listPublicPasses({
+    siteId: requireStringParam(params, "siteId", "listPublicPasses"),
+    categories: readStringParam(params, "categories")
+  });
+}
+async function listPublicMemberships({ client, params }) {
+  return await client.listPublicMemberships({
+    siteId: requireStringParam(params, "siteId", "listPublicMemberships"),
+    categories: readStringParam(params, "categories")
+  });
+}
+async function getPublicFormById({ client, params }) {
+  return await client.getPublicFormById({
+    formId: requireStringParam(params, "formId", "getPublicFormById"),
+    siteId: requireStringParam(params, "siteId", "getPublicFormById")
+  });
+}
+async function getPublicBookingServices({ client, params }) {
+  return await client.getPublicBookingServices({
+    siteId: requireStringParam(params, "siteId", "getPublicBookingServices"),
+    ids: readStringParam(params, "ids")
+  });
+}
 async function prefetchBlockData2(page, context, client, options) {
   const { customBlocks } = options ?? {};
   const customBlockMap = new Map(
@@ -68238,189 +68942,11 @@ async function prefetchBlockData2(page, context, client, options) {
     apiClient: async ({ endpoint, params }) => {
       if (!isSupportedLoaderEndpoint2(endpoint)) {
         throw new Error(
-          `Unsupported loader endpoint: ${endpoint}. SDK only supports: ${SUPPORTED_LOADER_ENDPOINTS2.join(", ")}`
+          `Unsupported loader endpoint: ${endpoint}. SDK only supports: ${SUPPORTED_LOADER_ENDPOINTS.join(", ")}`
         );
       }
       const resolvedParams = normalizeLoaderParams(endpoint, params, context);
-      switch (endpoint) {
-        case "listPublishedEntries": {
-          const {
-            siteId,
-            type,
-            orderBy,
-            limit,
-            stage,
-            mode,
-            entryIds,
-            identifiers,
-            entryRefs
-          } = resolvedParams ?? {};
-          if (!siteId || !type) {
-            throw new Error("listPublishedEntries requires siteId and type params");
-          }
-          const parsedLimit = typeof limit === "string" ? Number.parseInt(limit, 10) : typeof limit === "number" ? limit : void 0;
-          const order = orderBy === "order" ? "manual" : orderBy === "newest" || orderBy === "oldest" || orderBy === "title" ? orderBy : void 0;
-          const parsedEntryRefs = mode === "manual" ? parseManualEntryRefs(identifiers, entryRefs, entryIds) : void 0;
-          if (mode === "manual" && (!parsedEntryRefs || parsedEntryRefs.length === 0)) {
-            return { entries: [] };
-          }
-          if (mode === "manual" && parsedEntryRefs) {
-            return await client.getEntriesByIdentifiers({
-              siteId,
-              contentType: type,
-              identifiers: parsedEntryRefs,
-              preview: stage === "preview"
-            });
-          }
-          return await client.getEntries({
-            siteId,
-            contentType: type,
-            limit: parsedLimit,
-            order,
-            preview: stage === "preview"
-          });
-        }
-        case "getPublishedEntryPreview": {
-          const { siteId, type, slug } = resolvedParams ?? {};
-          if (!siteId || !type || !slug) {
-            throw new Error("getPublishedEntryPreview requires siteId, type, and slug params");
-          }
-          return await client.getEntry({ siteId, contentType: type, slug });
-        }
-        case "listPublicEvents": {
-          const {
-            siteId,
-            limit,
-            from,
-            to,
-            stage,
-            categoryIds,
-            venueId,
-            kind,
-            entryId,
-            seriesId,
-            includeOccurrenceId
-          } = resolvedParams ?? {};
-          if (!siteId) {
-            throw new Error("listPublicEvents requires siteId param");
-          }
-          const parsedLimit = typeof limit === "string" ? Number.parseInt(limit, 10) : typeof limit === "number" ? limit : void 0;
-          return await client.listPublicEvents({
-            siteId,
-            limit: parsedLimit,
-            from,
-            to,
-            stage,
-            categoryIds: typeof categoryIds === "string" ? categoryIds : void 0,
-            venueId: typeof venueId === "string" ? venueId : void 0,
-            kind: kind === "all" || kind === "courses" || kind === "events" ? kind : void 0,
-            entryId: typeof entryId === "string" ? entryId : void 0,
-            seriesId: typeof seriesId === "string" ? seriesId : void 0,
-            includeOccurrenceId: typeof includeOccurrenceId === "string" ? includeOccurrenceId : void 0
-          });
-        }
-        case "getPublicEventDetails": {
-          const {
-            siteId,
-            limit,
-            from,
-            to,
-            afterStartsAt,
-            afterId,
-            stage,
-            categoryIds,
-            venueId,
-            staffMemberId,
-            kind,
-            entryId,
-            seriesId,
-            includeOccurrenceId
-          } = resolvedParams ?? {};
-          if (!siteId) {
-            throw new Error("getPublicEventDetails requires siteId param");
-          }
-          const parsedLimit = typeof limit === "string" ? Number.parseInt(limit, 10) : typeof limit === "number" ? limit : void 0;
-          return await client.getPublicEventDetails({
-            siteId,
-            limit: parsedLimit,
-            from: typeof from === "string" ? from : void 0,
-            to: typeof to === "string" ? to : void 0,
-            afterStartsAt: typeof afterStartsAt === "string" ? afterStartsAt : void 0,
-            afterId: typeof afterId === "string" ? afterId : void 0,
-            stage: typeof stage === "string" ? stage : void 0,
-            categoryIds: typeof categoryIds === "string" ? categoryIds : void 0,
-            venueId: typeof venueId === "string" ? venueId : void 0,
-            staffMemberId: typeof staffMemberId === "string" ? staffMemberId : void 0,
-            kind: typeof kind === "string" ? kind : void 0,
-            entryId: typeof entryId === "string" ? entryId : void 0,
-            seriesId: typeof seriesId === "string" ? seriesId : void 0,
-            includeOccurrenceId: typeof includeOccurrenceId === "string" ? includeOccurrenceId : void 0
-          });
-        }
-        case "listPublicCourses": {
-          const { siteId, limit, stage } = resolvedParams ?? {};
-          if (!siteId) {
-            throw new Error("listPublicCourses requires siteId param");
-          }
-          const parsedLimit = typeof limit === "string" ? Number.parseInt(limit, 10) : typeof limit === "number" ? limit : void 0;
-          return await client.listPublicCourses({ siteId, limit: parsedLimit, stage });
-        }
-        case "listPublicTeamMembers": {
-          const { siteId, stage } = resolvedParams ?? {};
-          if (!siteId) {
-            throw new Error("listPublicTeamMembers requires siteId param");
-          }
-          return await client.listPublicTeamMembers({
-            siteId,
-            stage: typeof stage === "string" ? stage : void 0
-          });
-        }
-        case "listPublicProducts": {
-          const { siteId, stage, categorySelector } = resolvedParams ?? {};
-          if (!siteId) {
-            throw new Error("listPublicProducts requires siteId param");
-          }
-          return await client.listPublicProducts({
-            siteId,
-            stage: stage === "preview" ? "preview" : "published",
-            categorySelector: parsePublicProductCategorySelector(categorySelector)
-          });
-        }
-        case "getPublicFormById": {
-          const { formId, siteId } = resolvedParams ?? {};
-          if (!formId) {
-            throw new Error("getPublicFormById requires formId param");
-          }
-          if (!siteId) {
-            throw new Error("getPublicFormById requires siteId param");
-          }
-          return await client.getPublicFormById({ formId, siteId });
-        }
-        case "getPublicBookingServices": {
-          const { siteId, ids } = resolvedParams ?? {};
-          if (!siteId) {
-            throw new Error("getPublicBookingServices requires siteId param");
-          }
-          return await client.getPublicBookingServices({ siteId, ids });
-        }
-        case "listPublicPasses": {
-          const { siteId, categories } = resolvedParams ?? {};
-          if (!siteId) {
-            throw new Error("listPublicPasses requires siteId param");
-          }
-          return await client.listPublicPasses({ siteId, categories });
-        }
-        case "listPublicMemberships": {
-          const { siteId, categories } = resolvedParams ?? {};
-          if (!siteId) {
-            throw new Error("listPublicMemberships requires siteId param");
-          }
-          return await client.listPublicMemberships({ siteId, categories });
-        }
-        default: {
-          throw new Error("Unhandled endpoint");
-        }
-      }
+      return await loaderAdapters[endpoint]({ client, params: resolvedParams });
     },
     isValidEndpoint: isSupportedLoaderEndpoint2,
     onError: (error, { block, loader }) => {
@@ -68676,6 +69202,76 @@ function resolveSiteCustomBlocks(site) {
   return void 0;
 }
 
+// src/rendering/helpers/pageRuntimeSupport.ts
+function buildSiteRenderSupport(site, mediaAssets) {
+  const customBlocks = resolveSiteCustomBlocks(site);
+  return {
+    theme: site.theme,
+    site: site.site,
+    sdkConfig: site.sdkConfig ?? null,
+    bookingOfferingPresets: site.bookingOfferingPresets ?? [],
+    ...customBlocks ? { customBlocks } : {},
+    supabaseUrl: site.supabaseUrl,
+    routeMap: site.routes,
+    pagesByIdentifier: site.pagesByIdentifier,
+    entriesByIdentifier: site.entriesByIdentifier,
+    ...mediaAssets ? { mediaAssets } : {}
+  };
+}
+function collectMediaAssetSidecar(mediaAssets) {
+  return Array.isArray(mediaAssets) && mediaAssets.length > 0 ? mediaAssets : void 0;
+}
+function convertPageResponseBlock(block) {
+  if (!isRecord15(block)) {
+    throw new Error("Invalid block format in page API response");
+  }
+  if (typeof block.id !== "string" && block.id !== null) {
+    throw new Error(`Invalid block id in page: expected string or null, got ${typeof block.id}`);
+  }
+  if (typeof block.kind !== "string") {
+    throw new Error(`Invalid block kind in page: expected string, got ${typeof block.kind}`);
+  }
+  if (typeof block.purpose !== "string") {
+    throw new Error(`Invalid block purpose in page: expected string, got ${typeof block.purpose}`);
+  }
+  return {
+    id: block.id,
+    kind: block.kind,
+    purpose: block.purpose,
+    content: sanitizeSdkRuntimeBlockContent(block.kind, readContentRecord(block.content) ?? {}),
+    draftContent: sanitizeNullableSdkRuntimeBlockContent(
+      block.kind,
+      readNestedContentRecord(block.draftContent)
+    )
+  };
+}
+function buildPageOutline(input) {
+  return {
+    name: input.name,
+    path: input.path ?? input.fallbackPath,
+    purpose: input.purpose,
+    blocks: input.blocks.map(convertPageResponseBlock)
+  };
+}
+function isRecord15(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readContentRecord(value) {
+  return isRecord15(value) ? value : void 0;
+}
+function readNestedContentRecord(value) {
+  if (!isRecord15(value)) return null;
+  return readContentRecord(value.data) ?? null;
+}
+function sanitizeSdkRuntimeBlockContent(blockKind, content) {
+  if (blockKind !== "block.newsletter-signup") return content;
+  const sanitized = sanitizeNewsletterSignupPublicContent(content);
+  return isRecord15(sanitized) ? sanitized : {};
+}
+function sanitizeNullableSdkRuntimeBlockContent(blockKind, content) {
+  return content ? sanitizeSdkRuntimeBlockContent(blockKind, content) : null;
+}
+
 // ../content-model/src/routeTemplate.ts
 var ROUTE_TEMPLATE_SLUG_SEGMENT = "{slug}";
 var InvalidRouteTemplateError = class extends Error {
@@ -68821,8 +69417,10 @@ async function loadContent(params) {
   }
   const site = siteResult.value;
   const contentResponse = contentResult.value;
-  const customBlocks = resolveSiteCustomBlocks(site);
-  const mediaAssets = Array.isArray(contentResponse.mediaAssets) && contentResponse.mediaAssets.length > 0 ? contentResponse.mediaAssets : void 0;
+  const support = buildSiteRenderSupport(
+    site,
+    collectMediaAssetSidecar(contentResponse.mediaAssets)
+  );
   if (isEntryResponse(contentResponse)) {
     const entryData = contentResponse.entry;
     const draftContent = entryData.draftContent;
@@ -68848,13 +69446,14 @@ async function loadContent(params) {
       entry,
       { siteId, preview },
       client,
-      { customBlocks }
+      { customBlocks: support.customBlocks }
     );
     return {
       type: "entry",
       entry,
       templatePage,
       resolvedData: resolvedData2,
+      bookingOfferingPresets: support.bookingOfferingPresets,
       dataContext: {
         contentEntry: {
           ...entry.content ?? {},
@@ -68866,29 +69465,29 @@ async function loadContent(params) {
           _contentTypeSlug: entry.type
         }
       },
-      theme: site.theme,
+      theme: support.theme,
       siteId,
-      ...customBlocks ? { customBlocks } : {},
-      site: site.site,
-      sdkConfig: site.sdkConfig ?? null,
-      supabaseUrl: site.supabaseUrl,
-      routeMap: site.routes,
-      pagesByIdentifier: site.pagesByIdentifier,
-      entriesByIdentifier: site.entriesByIdentifier,
-      ...mediaAssets ? { mediaAssets } : {}
+      ...support.customBlocks ? { customBlocks: support.customBlocks } : {},
+      site: support.site,
+      sdkConfig: support.sdkConfig,
+      supabaseUrl: support.supabaseUrl,
+      routeMap: support.routeMap,
+      pagesByIdentifier: support.pagesByIdentifier,
+      entriesByIdentifier: support.entriesByIdentifier,
+      ...support.mediaAssets ? { mediaAssets: support.mediaAssets } : {}
     };
   }
   const { page: pageData } = contentResponse;
   const pageRecord = pageData;
   const canonicalPagePath = pageData.path ?? pageRecord.path ?? "/";
   const draftPagePath = pageRecord.draftPath ?? pageRecord.path ?? canonicalPagePath;
-  const blocks = pageData.blocks.map((block) => validateAndConvertBlock(block, "page"));
-  const pageOutline = {
+  const pageOutline = buildPageOutline({
     name: pageData.name,
     path: canonicalPagePath,
+    fallbackPath: "/",
     purpose: pageData.purpose,
-    blocks
-  };
+    blocks: pageData.blocks
+  });
   const resolvedData = await prefetchBlockData2(
     pageOutline,
     {
@@ -68897,7 +69496,7 @@ async function loadContent(params) {
       previewStage: preview ? "preview" : "published"
     },
     client,
-    { customBlocks }
+    { customBlocks: support.customBlocks }
   );
   return {
     type: "page",
@@ -68918,56 +69517,23 @@ async function loadContent(params) {
       ogImageId: pageRecord.ogImageId ?? null
     },
     page: pageOutline,
-    theme: site.theme,
+    theme: support.theme,
     siteId,
-    ...customBlocks ? { customBlocks } : {},
+    ...support.customBlocks ? { customBlocks: support.customBlocks } : {},
     resolvedData,
-    site: site.site,
-    sdkConfig: site.sdkConfig ?? null,
-    supabaseUrl: site.supabaseUrl,
-    routeMap: site.routes,
-    pagesByIdentifier: site.pagesByIdentifier,
-    entriesByIdentifier: site.entriesByIdentifier,
-    ...mediaAssets ? { mediaAssets } : {}
+    bookingOfferingPresets: support.bookingOfferingPresets,
+    site: support.site,
+    sdkConfig: support.sdkConfig,
+    supabaseUrl: support.supabaseUrl,
+    routeMap: support.routeMap,
+    pagesByIdentifier: support.pagesByIdentifier,
+    entriesByIdentifier: support.entriesByIdentifier,
+    ...support.mediaAssets ? { mediaAssets: support.mediaAssets } : {}
   };
 }
 function isEntryResponse(response) {
   return "entry" in response;
 }
-function validateAndConvertBlock(block, source) {
-  if (!block || typeof block !== "object") {
-    throw new Error(`Invalid block format in ${source} API response`);
-  }
-  const blockRecord = block;
-  const kindField = source === "template" ? "blockKind" : "kind";
-  const kindValue = blockRecord[kindField];
-  if (typeof blockRecord.id !== "string" && blockRecord.id !== null) {
-    throw new Error(`Invalid block id in ${source}: expected string or null, got ${typeof blockRecord.id}`);
-  }
-  if (typeof kindValue !== "string") {
-    throw new Error(`Invalid block ${kindField} in ${source}: expected string, got ${typeof kindValue}`);
-  }
-  if (source === "page") {
-    if (typeof blockRecord.purpose !== "string") {
-      throw new Error(`Invalid block purpose in ${source}: expected string, got ${typeof blockRecord.purpose}`);
-    }
-    const content2 = blockRecord.content ?? {};
-    return {
-      id: blockRecord.id,
-      kind: kindValue,
-      purpose: blockRecord.purpose,
-      content: content2
-    };
-  }
-  const scope = blockRecord.scope;
-  const content = blockRecord.content ?? {};
-  return {
-    id: blockRecord.id,
-    kind: kindValue,
-    purpose: scope === "entry" ? "entry-content" : "template-layout",
-    content
-  };
-}
 async function processEntryTemplate(templates, entrySlots, entry, context, client, options) {
   const template = templates?.[0];
   if (!template || !template.blocks?.length) {
@@ -69011,7 +69577,10 @@ async function processEntryTemplate(templates, entrySlots, entry, context, clien
   return { templatePage, resolvedData };
 }
 function resolveTemplateBlock(block, bindingContext) {
-  const rawContent = block.content ?? {};
+  const rawContent = sanitizeSdkRuntimeBlockContent(
+    block.blockKind,
+    block.content ?? {}
+  );
   const baseContent = normalizeBindingOutput2(rawContent);
   if (block.scope === "template") {
     return {
@@ -69214,6 +69783,7 @@ function PageContent({
   themeTokens: providedTokens,
   siteId,
   resolvedData,
+  bookingOfferingPresets,
   routeMap,
   pagesByIdentifier,
   entriesByIdentifier,
@@ -69246,6 +69816,7 @@ function PageContent({
         portalToken,
         previewToken,
         resolvedData,
+        bookingOfferingPresets: bookingOfferingPresets ?? [],
         routes: routeMap,
         pagesByIdentifier,
         entriesByIdentifier,
@@ -69283,15 +69854,15 @@ function Page(props2) {
 var lazyBlockOverrideSymbol = /* @__PURE__ */ Symbol.for("riverbankcms.sdk.lazyBlockOverride");
 
 // src/rendering/overrideResolution.ts
-function isRecord14(value) {
+function isRecord16(value) {
   return typeof value === "object" && value !== null;
 }
 function isBlockOutlineLike(value) {
   const id = value.id;
-  return typeof value.kind === "string" && (typeof id === "string" || id === null) && (typeof value.purpose === "string" || isRecord14(value.content) || isRecord14(value.draftContent) || isRecord14(value.bindings));
+  return typeof value.kind === "string" && (typeof id === "string" || id === null) && (typeof value.purpose === "string" || isRecord16(value.content) || isRecord16(value.draftContent) || isRecord16(value.bindings));
 }
 function collectBlockKindsFromValue(value, usedKinds, seen) {
-  if (!isRecord14(value)) return;
+  if (!isRecord16(value)) return;
   if (seen.has(value)) return;
   seen.add(value);
   if (isBlockOutlineLike(value)) {
@@ -69340,7 +69911,7 @@ function selectOverrideKeysForUsedKinds(usedKinds, entries) {
   return selectedKeys;
 }
 function isLazyRegistration(registration) {
-  return isRecord14(registration) && registration[lazyBlockOverrideSymbol] === true;
+  return isRecord16(registration) && registration[lazyBlockOverrideSymbol] === true;
 }
 async function resolveOverrideComponent(registration) {
   if (isLazyRegistration(registration)) {
@@ -70342,7 +70913,7 @@ var CircuitOpenError = class extends Error {
 };
 
 // src/version.ts
-var SDK_VERSION = "0.84.2";
+var SDK_VERSION = "0.88.0";
 
 // src/next/content-load-failure.ts
 var SdkContentLoadError = RiverbankContentLoadError;
@@ -70712,6 +71283,7 @@ function createCatchAllPage(options) {
           apiBaseUrl,
           portalToken,
           resolvedData: content.resolvedData,
+          bookingOfferingPresets: content.bookingOfferingPresets,
           blockOverrides: resolvedBlockOverrides,
           sdkConfig: content.sdkConfig,
           supabaseUrl: content.supabaseUrl,
@@ -70739,6 +71311,7 @@ function createCatchAllPage(options) {
           apiBaseUrl,
           portalToken,
           resolvedData: content.resolvedData,
+          bookingOfferingPresets: content.bookingOfferingPresets,
           blockOverrides: resolvedBlockOverrides,
           sdkConfig: content.sdkConfig,
           supabaseUrl: content.supabaseUrl,
@@ -71716,10 +72289,16 @@ function createRiverbankClient(config) {
         limit,
         from,
         to,
+        afterStartsAt,
+        afterId,
         stage,
         categoryIds,
         venueId,
+        staffMemberId,
         kind,
+        eventSurface,
+        eventPresets,
+        scheduleScope,
         entryId,
         seriesId,
         includeOccurrenceId,
@@ -71728,7 +72307,7 @@ function createRiverbankClient(config) {
       if (!siteId) {
         throw new Error("listPublicEvents() requires siteId");
       }
-      const cacheKey = `public-events:${siteId}:${limit ?? ""}:${from ?? ""}:${to ?? ""}:${stage ?? ""}:${categoryIds ?? ""}:${venueId ?? ""}:${kind ?? ""}:${entryId ?? ""}:${seriesId ?? ""}:${includeOccurrenceId ?? ""}`;
+      const cacheKey = `public-events:${siteId}:${limit ?? ""}:${from ?? ""}:${to ?? ""}:${afterStartsAt ?? ""}:${afterId ?? ""}:${stage ?? ""}:${categoryIds ?? ""}:${venueId ?? ""}:${staffMemberId ?? ""}:${kind ?? ""}:${eventSurface ?? ""}:${eventPresets ?? ""}:${scheduleScope ?? ""}:${entryId ?? ""}:${seriesId ?? ""}:${includeOccurrenceId ?? ""}`;
       return resilientFetchData(
         cacheKey,
         async (sig) => {
@@ -71737,10 +72316,16 @@ function createRiverbankClient(config) {
             ...typeof limit === "number" && { limit: String(limit) },
             ...from && { from },
             ...to && { to },
+            ...afterStartsAt && { afterStartsAt },
+            ...afterId && { afterId },
             ...stage && { stage },
             ...categoryIds && { categoryIds },
             ...venueId && { venueId },
+            ...staffMemberId && { staffMemberId },
             ...kind && { kind },
+            ...eventSurface && { eventSurface },
+            ...eventPresets && { eventPresets },
+            ...scheduleScope && { scheduleScope },
             ...entryId && { entryId },
             ...seriesId && { seriesId },
             ...includeOccurrenceId && { includeOccurrenceId }
@@ -71767,6 +72352,9 @@ function createRiverbankClient(config) {
         venueId,
         staffMemberId,
         kind,
+        eventSurface,
+        eventPresets,
+        scheduleScope,
         entryId,
         seriesId,
         includeOccurrenceId,
@@ -71775,7 +72363,7 @@ function createRiverbankClient(config) {
       if (!siteId) {
         throw new Error("getPublicEventDetails() requires siteId");
       }
-      const cacheKey = `public-event-details:${siteId}:${limit ?? ""}:${from ?? ""}:${to ?? ""}:${afterStartsAt ?? ""}:${afterId ?? ""}:${stage ?? ""}:${categoryIds ?? ""}:${venueId ?? ""}:${staffMemberId ?? ""}:${kind ?? ""}:${entryId ?? ""}:${seriesId ?? ""}:${includeOccurrenceId ?? ""}`;
+      const cacheKey = `public-event-details:${siteId}:${limit ?? ""}:${from ?? ""}:${to ?? ""}:${afterStartsAt ?? ""}:${afterId ?? ""}:${stage ?? ""}:${categoryIds ?? ""}:${venueId ?? ""}:${staffMemberId ?? ""}:${kind ?? ""}:${eventSurface ?? ""}:${eventPresets ?? ""}:${scheduleScope ?? ""}:${entryId ?? ""}:${seriesId ?? ""}:${includeOccurrenceId ?? ""}`;
       return resilientFetchData(
         cacheKey,
         async (sig) => {
@@ -71798,6 +72386,9 @@ function createRiverbankClient(config) {
                     ...venueId && { venueId },
                     ...staffMemberId && { staffMemberId },
                     ...kind && { kind },
+                    ...eventSurface && { eventSurface },
+                    ...eventPresets && { eventPresets },
+                    ...scheduleScope && { scheduleScope },
                     ...entryId && { entryId },
                     ...seriesId && { seriesId },
                     ...includeOccurrenceId && { includeOccurrenceId }