@riverbankcms/sdk 0.84.2 → 0.88.0

package/dist/server/routing.mjs

@@ -778,6 +778,64 @@ var init_endpoints = __esm({
         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",
@@ -3002,20 +3060,6 @@ var init_endpoints = __esm({
         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",
@@ -6484,6 +6528,59 @@ var init_collections = __esm({
   }
 });
 
+// ../core/src/assert-never.ts
+function assertNever(value, message = "Unexpected variant") {
+  throw new Error(`${message}: ${String(value)}`);
+}
+var init_assert_never = __esm({
+  "../core/src/assert-never.ts"() {
+    "use strict";
+  }
+});
+
+// ../core/src/currency-format.ts
+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}`;
+  }
+}
+var CURRENCY_LOCALE_BY_CODE;
+var init_currency_format = __esm({
+  "../core/src/currency-format.ts"() {
+    "use strict";
+    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"
+    };
+  }
+});
+
 // ../core/src/event-pricing.ts
 function publicEventPricingType(pricing) {
   switch (pricing.kind) {
@@ -6504,6 +6601,7 @@ function isFreePublicEventPriceDisplay(display) {
       return display.display.kind === "free";
     case "exact":
     case "from":
+    case "range":
     case "mixed":
     case "unavailable":
       return false;
@@ -6728,16 +6826,6 @@ var init_business_address = __esm({
   }
 });
 
-// ../core/src/assert-never.ts
-function assertNever(value, message = "Unexpected variant") {
-  throw new Error(`${message}: ${String(value)}`);
-}
-var init_assert_never = __esm({
-  "../core/src/assert-never.ts"() {
-    "use strict";
-  }
-});
-
 // ../core/src/narrow-result.ts
 var init_narrow_result = __esm({
   "../core/src/narrow-result.ts"() {
@@ -6857,13 +6945,6 @@ var init_csv_types = __esm({
   }
 });
 
-// ../core/src/currency-format.ts
-var init_currency_format = __esm({
-  "../core/src/currency-format.ts"() {
-    "use strict";
-  }
-});
-
 // ../core/src/email-format.ts
 var init_email_format = __esm({
   "../core/src/email-format.ts"() {
@@ -25501,15 +25582,53 @@ var init_newsletterForm = __esm({
       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",
@@ -25556,13 +25675,18 @@ var init_newsletterForm = __esm({
           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" } },
@@ -31912,317 +32036,367 @@ var init_media4 = __esm({
   }
 });
 
-// ../blocks/src/system/blocks/shared/bookingPaymentTerms.ts
+// ../blocks/src/system/manifest/richTextSchema.ts
 import { z as z43 } from "zod";
+var TipTapMarkSchema, TipTapNodeSchema, RichTextValueSchema, RichTextDocSchema;
+var init_richTextSchema = __esm({
+  "../blocks/src/system/manifest/richTextSchema.ts"() {
+    "use strict";
+    TipTapMarkSchema = z43.object({
+      type: z43.string(),
+      attrs: z43.record(z43.string(), z43.unknown()).optional()
+    });
+    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()
+      })
+    );
+    RichTextValueSchema = z43.union([
+      // Canonical: TipTap document directly
+      TipTapNodeSchema,
+      // Legacy (read-tolerance only): wrapped in { doc: {...} }
+      z43.object({
+        doc: TipTapNodeSchema
+      })
+    ]);
+    RichTextDocSchema = z43.object({
+      type: z43.literal("doc"),
+      content: z43.array(TipTapNodeSchema)
+    });
+  }
+});
+
+// ../blocks/src/system/blocks/shared/bookingPaymentTerms.ts
+import { z as z44 } from "zod";
 var bookingDepositRefundPolicySchema, bookingInstalmentPlanSchema, bookingFlexibleBalanceDueDateRuleSchema, bookingFlexibleBalanceConfigSchema, blockBookingPaymentCollectionOptionSchema, blockBookingPaymentTermsSchema;
 var init_bookingPaymentTerms = __esm({
   "../blocks/src/system/blocks/shared/bookingPaymentTerms.ts"() {
     "use strict";
-    bookingDepositRefundPolicySchema = z43.enum([
+    bookingDepositRefundPolicySchema = z44.enum([
       "refundable",
       "non_refundable"
     ]);
-    bookingInstalmentPlanSchema = z43.union([
-      z43.object({
-        kind: z43.literal("deposit_plus_one_remainder"),
-        depositAmountCents: z43.number().int().min(0),
+    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"])
       })
     ]);
-    bookingFlexibleBalanceDueDateRuleSchema = z43.union([
-      z43.object({
-        kind: z43.literal("relative_to_start_date"),
-        daysBeforeStart: z43.number().int().positive()
+    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()
       })
     ]);
-    bookingFlexibleBalanceConfigSchema = z43.object({
-      upfrontAmountCents: z43.number().int().min(0),
+    bookingFlexibleBalanceConfigSchema = z44.object({
+      upfrontAmountCents: z44.number().int().min(0),
       dueDateRule: bookingFlexibleBalanceDueDateRuleSchema,
       depositRefundability: bookingDepositRefundPolicySchema
     });
-    blockBookingPaymentCollectionOptionSchema = z43.union([
-      z43.object({
-        kind: z43.literal("upfront")
+    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
       })
     ]);
-    blockBookingPaymentTermsSchema = z43.object({
-      allowedOptions: z43.array(blockBookingPaymentCollectionOptionSchema).min(1)
+    blockBookingPaymentTermsSchema = z44.object({
+      allowedOptions: z44.array(blockBookingPaymentCollectionOptionSchema).min(1)
     });
   }
 });
 
 // ../blocks/src/system/blocks/courses/shared/schemas.ts
-import { z as z44 } from "zod";
+import { z as z45 } from "zod";
 var courseVenueSchema, courseSessionSchema, courseTeamMemberSummarySchema, coursePricingOptionSchema, coursePricingSchema, publicCourseSchema, publicCoursesArraySchema;
 var init_schemas = __esm({
   "../blocks/src/system/blocks/courses/shared/schemas.ts"() {
     "use strict";
     init_bookingPaymentTerms();
-    courseVenueSchema = z44.object({
-      id: z44.string(),
-      name: z44.string(),
-      address: z44.string().nullable()
-    });
-    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()
-    });
-    courseTeamMemberSummarySchema = z44.object({
-      id: z44.string(),
-      name: z44.string(),
-      roleLabel: z44.string().nullable(),
-      summary: z44.string().nullable(),
-      profilePath: z44.string().nullable()
-    });
-    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()
-    });
-    coursePricingSchema = z44.object({
-      bookingRequirement: z44.enum(["none", "required"]),
-      pricingStrategy: z44.enum(["free", "single", "tiered"]),
-      currency: z44.string(),
-      singlePriceAmount: z44.number().nullable(),
+    courseVenueSchema = z45.object({
+      id: z45.string(),
+      name: z45.string(),
+      address: z45.string().nullable()
+    });
+    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()
+    });
+    courseTeamMemberSummarySchema = z45.object({
+      id: z45.string(),
+      name: z45.string(),
+      roleLabel: z45.string().nullable(),
+      summary: z45.string().nullable(),
+      profilePath: z45.string().nullable()
+    });
+    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()
+    });
+    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)
-    });
-    publicCourseSchema = z44.object({
-      id: z44.string(),
-      title: z44.string(),
-      slug: z44.string(),
-      description: z44.unknown().nullable(),
-      teamMembers: z44.array(courseTeamMemberSummarySchema).optional(),
-      enrollmentOpen: z44.boolean(),
+      options: z45.array(coursePricingOptionSchema)
+    });
+    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()
     });
-    publicCoursesArraySchema = z44.array(publicCourseSchema);
+    publicCoursesArraySchema = z45.array(publicCourseSchema);
   }
 });
 
 // ../blocks/src/system/blocks/events/shared/schemas.ts
-import { z as z45 } from "zod";
+import { z as z46 } from "zod";
 var eventPresetSchema, eventScheduleScopeSchema, eventDestinationModeSchema, eventVenueSchema, eventCategorySchema, pricingTypeSchema, accessRestrictionSchema, eventPricingModeSchema, publicCoursePriceDisplaySchema, publicEventPriceDisplaySchema, publicEventTicketTypePriceDisplaySchema, publicEventAttendanceModeSchema, publicEventAttendanceModeAvailabilitySchema, publicEventTicketTypeAvailabilitySchema, publicEventTicketTypeSchema, publicEventPricingSchema, publicTeamMemberSummarySchema, publicEventSchema, publicEventsArraySchema;
 var init_schemas2 = __esm({
   "../blocks/src/system/blocks/events/shared/schemas.ts"() {
     "use strict";
     init_media4();
+    init_richTextSchema();
     init_bookingPaymentTerms();
     init_schemas();
-    eventPresetSchema = z45.enum(["event", "class", "workshop", "retreat", "performance"]);
-    eventScheduleScopeSchema = z45.enum(["recurring", "oneOff"]);
-    eventDestinationModeSchema = z45.enum(["cms-managed", "system-managed"]);
-    eventVenueSchema = z45.object({
-      id: z45.string(),
-      name: z45.string(),
-      address: z45.string().nullable(),
-      location: z45.object({
-        lat: z45.number(),
-        lng: z45.number()
+    eventPresetSchema = z46.enum(["event", "class", "workshop", "retreat", "performance"]);
+    eventScheduleScopeSchema = z46.enum(["recurring", "oneOff"]);
+    eventDestinationModeSchema = z46.enum(["cms-managed", "system-managed"]);
+    eventVenueSchema = z46.object({
+      id: z46.string(),
+      name: z46.string(),
+      address: z46.string().nullable(),
+      location: z46.object({
+        lat: z46.number(),
+        lng: z46.number()
       }).nullable()
     });
-    eventCategorySchema = z45.object({
-      id: z45.string(),
-      name: z45.string(),
-      color: z45.string().nullable()
-    });
-    pricingTypeSchema = z45.enum(["free", "paid"]);
-    accessRestrictionSchema = z45.enum(["none", "category"]);
-    eventPricingModeSchema = z45.enum(["single", "ticket_types"]);
-    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() })
+    eventCategorySchema = z46.object({
+      id: z46.string(),
+      name: z46.string(),
+      color: z46.string().nullable()
+    });
+    pricingTypeSchema = z46.enum(["free", "paid"]);
+    accessRestrictionSchema = z46.enum(["none", "category"]);
+    eventPricingModeSchema = z46.enum(["single", "ticket_types"]);
+    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() })
     ]);
-    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 })
+    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 })
     ]);
-    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() })
+    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() })
     ]);
-    publicEventAttendanceModeSchema = z45.enum(["in_person", "online"]);
-    publicEventAttendanceModeAvailabilitySchema = z45.object({
+    publicEventAttendanceModeSchema = z46.enum(["in_person", "online"]);
+    publicEventAttendanceModeAvailabilitySchema = z46.object({
       mode: publicEventAttendanceModeSchema,
-      capacity: z45.number().nullable(),
-      registeredCount: z45.number(),
-      availableSpots: z45.number().nullable(),
-      waitlistEnabled: z45.boolean()
-    });
-    publicEventTicketTypeAvailabilitySchema = z45.union([
-      z45.object({
-        kind: z45.literal("available"),
-        remainingCapacity: z45.number().nullable()
+      capacity: z46.number().nullable(),
+      registeredCount: z46.number(),
+      availableSpots: z46.number().nullable(),
+      waitlistEnabled: z46.boolean()
+    });
+    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()
       })
     ]);
-    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(),
+    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()
-    });
-    publicEventPricingSchema = z45.discriminatedUnion("kind", [
-      z45.object({
-        kind: z45.literal("drop_in"),
-        currency: z45.string(),
-        display: z45.object({ kind: z45.literal("free"), currency: z45.string() })
+      createdAt: z46.string(),
+      updatedAt: z46.string()
+    });
+    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 })
       })
     ]);
-    publicTeamMemberSummarySchema = z45.object({
-      id: z45.string(),
-      name: z45.string(),
-      roleLabel: z45.string().nullable(),
-      summary: z45.string().nullable(),
-      profilePath: z45.string().nullable()
+    publicTeamMemberSummarySchema = z46.object({
+      id: z46.string(),
+      name: z46.string(),
+      roleLabel: z46.string().nullable(),
+      summary: z46.string().nullable(),
+      profilePath: z46.string().nullable()
     });
-    publicEventSchema = z45.object({
-      kind: z45.enum(["event", "course_session"]).optional(),
+    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()
     });
-    publicEventsArraySchema = z45.array(publicEventSchema);
+    publicEventsArraySchema = z46.array(publicEventSchema);
   }
 });
 
@@ -32459,19 +32633,19 @@ var init_shared3 = __esm({
 });
 
 // ../blocks/src/system/blocks/event-registration.shared.ts
-import { z as z46 } from "zod";
+import { z as z47 } from "zod";
 var occurrenceContextSchema;
 var init_event_registration_shared = __esm({
   "../blocks/src/system/blocks/event-registration.shared.ts"() {
     "use strict";
-    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()
+    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();
   }
 });
@@ -32577,10 +32751,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":
@@ -32629,21 +32814,21 @@ var init_pricing = __esm({
 });
 
 // ../blocks/src/system/runtime/nodes/shared/contract-schemas.ts
-import { z as z47 } from "zod";
+import { z as z48 } from "zod";
 var previewStageSchema, registrationButtonVariantSchema, eventButtonVariantSchema, eventLayoutSchema, eventCalendarDisplayModeSchema, columnOptionSchema, weekStartSchema, filterAutoShowSchema, calendarTabViewsSchema;
 var init_contract_schemas = __esm({
   "../blocks/src/system/runtime/nodes/shared/contract-schemas.ts"() {
     "use strict";
     init_events();
-    previewStageSchema = z47.enum(["preview", "published"]);
-    registrationButtonVariantSchema = z47.enum(["primary", "secondary", "outline"]);
-    eventButtonVariantSchema = z47.enum(["primary", "secondary", "outline", "link"]);
-    eventLayoutSchema = z47.enum(eventCalendarListLayoutValues);
-    eventCalendarDisplayModeSchema = z47.enum(eventCalendarDisplayModeValues);
-    columnOptionSchema = z47.enum(["2", "3", "4"]);
-    weekStartSchema = z47.enum(["sunday", "monday"]);
-    filterAutoShowSchema = z47.enum(["auto", "always", "never"]);
-    calendarTabViewsSchema = z47.enum(["both", "month", "week"]);
+    previewStageSchema = z48.enum(["preview", "published"]);
+    registrationButtonVariantSchema = z48.enum(["primary", "secondary", "outline"]);
+    eventButtonVariantSchema = z48.enum(["primary", "secondary", "outline", "link"]);
+    eventLayoutSchema = z48.enum(eventCalendarListLayoutValues);
+    eventCalendarDisplayModeSchema = z48.enum(eventCalendarDisplayModeValues);
+    columnOptionSchema = z48.enum(["2", "3", "4"]);
+    weekStartSchema = z48.enum(["sunday", "monday"]);
+    filterAutoShowSchema = z48.enum(["auto", "always", "never"]);
+    calendarTabViewsSchema = z48.enum(["both", "month", "week"]);
   }
 });
 
@@ -32721,7 +32906,7 @@ var init_registrationEventAdapter = __esm({
 });
 
 // ../blocks/src/system/runtime/nodes/event-registration.interactive.ts
-import { z as z48 } from "zod";
+import { z as z49 } from "zod";
 function buildEventRegistrationDisplay(source) {
   const stepLabels = buildEventRegistrationShellStepLabels(source);
   return {
@@ -32826,66 +33011,68 @@ var init_event_registration_interactive = __esm({
     init_registrationEventAdapter();
     EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS = ["Date", "Tickets", "Details"];
     EVENT_REGISTRATION_SHELL_STEP_LABELS = ["Event", "Date", "Tickets", "Details", "Payment"];
-    contentEntrySchema = z48.object({
-      id: z48.string(),
-      slug: z48.string(),
-      contentTypeSlug: z48.string()
+    contentEntrySchema = z49.object({
+      id: z49.string(),
+      slug: z49.string(),
+      contentTypeSlug: z49.string()
     });
-    eventRegistrationPublicEventSchema = z48.preprocess(
+    eventRegistrationPublicEventSchema = z49.preprocess(
       normalizeEventRegistrationEventInput,
       publicEventSchema
     );
-    eventRegistrationSourceSchema = z48.object({
-      siteId: z48.string().optional(),
-      apiBaseUrl: z48.string().optional(),
-      portalToken: z48.string().nullable().optional(),
-      previewToken: z48.string().nullable().optional(),
+    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()
-    });
-    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()
-    });
-    eventRegistrationHydrationSchema = z48.object({
+      supportEmail: z49.string().optional()
+    });
+    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()
+    });
+    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()
     });
-    eventRegistrationRenderSchema = z48.object({
+    eventRegistrationRenderSchema = z49.object({
       display: eventRegistrationDisplaySchema,
       hydration: eventRegistrationHydrationSchema
     });
-    eventRegistrationIslandMetaCodec = createZodCodec(z48.object({
-      siteId: z48.string().optional(),
-      apiBaseUrl: z48.string().optional(),
-      portalToken: z48.string().nullable().optional(),
-      previewToken: z48.string().nullable().optional(),
+    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()
     }));
     eventRegistrationIslandMetaKeys = defineInteractiveIslandMetaKeys(
@@ -32913,6 +33100,7 @@ var init_event_registration_interactive = __esm({
           successMessage: source.successMessage,
           waitlistMessage: source.waitlistMessage,
           buttonVariant: source.buttonVariant,
+          overlayEnabled: source.overlayEnabled,
           spamProtectionEnabled: source.spamProtectionEnabled,
           supportEmail: source.supportEmail
         }
@@ -32935,7 +33123,7 @@ var init_event_registration_interactive = __esm({
 });
 
 // ../blocks/src/system/blocks/event-registration.ts
-import { z as z49 } from "zod";
+import { z as z50 } from "zod";
 var eventRegistrationManifest, eventRegistrationBlockDefinition;
 var init_event_registration = __esm({
   "../blocks/src/system/blocks/event-registration.ts"() {
@@ -33092,6 +33280,12 @@ var init_event_registration = __esm({
                   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)
@@ -33112,7 +33306,7 @@ var init_event_registration = __esm({
       manifest: eventRegistrationManifest,
       runtime: eventRegistrationBlockRuntime,
       dataSchemas: {
-        events: z49.array(publicEventSchema).optional(),
+        events: z50.array(publicEventSchema).optional(),
         occurrenceContext: occurrenceContextSchema.optional()
       },
       dataLoaders: {
@@ -33162,7 +33356,7 @@ var init_shared4 = __esm({
 });
 
 // ../blocks/src/system/runtime/nodes/course-registration.interactive.ts
-import { z as z50 } from "zod";
+import { z as z51 } from "zod";
 function buildCourseRegistrationDisplay(source) {
   return {
     kind: "course-registration",
@@ -33180,72 +33374,72 @@ var init_course_registration_interactive = __esm({
     init_islands();
     init_runtime();
     init_contract_schemas();
-    contentEntrySchema2 = z50.object({
-      id: z50.string(),
-      slug: z50.string(),
-      contentTypeSlug: z50.string()
-    });
-    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()
+    contentEntrySchema2 = z51.object({
+      id: z51.string(),
+      slug: z51.string(),
+      contentTypeSlug: z51.string()
+    });
+    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
       })
     ]);
-    courseRegistrationSourceSchema = z50.object({
-      siteId: z50.string().optional(),
-      apiBaseUrl: z50.string().optional(),
-      portalToken: z50.string().nullable().optional(),
+    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()
     });
-    courseRegistrationDisplaySchema = z50.object({
-      kind: z50.literal("course-registration"),
-      state: z50.literal("shell"),
-      className: z50.string().nullable(),
-      summaryButtonText: z50.string()
+    courseRegistrationDisplaySchema = z51.object({
+      kind: z51.literal("course-registration"),
+      state: z51.literal("shell"),
+      className: z51.string().nullable(),
+      summaryButtonText: z51.string()
     });
-    courseRegistrationHydrationSchema = z50.object({
+    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()
     });
-    courseRegistrationRenderSchema = z50.object({
+    courseRegistrationRenderSchema = z51.object({
       display: courseRegistrationDisplaySchema,
       hydration: courseRegistrationHydrationSchema
     });
-    courseRegistrationIslandMetaCodec = createZodCodec(z50.object({
-      siteId: z50.string().optional(),
-      apiBaseUrl: z50.string().optional(),
-      portalToken: z50.string().nullable().optional(),
+    courseRegistrationIslandMetaCodec = createZodCodec(z51.object({
+      siteId: z51.string().optional(),
+      apiBaseUrl: z51.string().optional(),
+      portalToken: z51.string().nullable().optional(),
       stage: previewStageSchema.optional()
     }));
     courseRegistrationIslandMetaKeys = defineInteractiveIslandMetaKeys(
@@ -33513,39 +33707,39 @@ var init_course_registration = __esm({
 });
 
 // ../blocks/src/system/blocks/shop.shared.ts
-import { z as z51 } from "zod";
+import { z as z52 } from "zod";
 var publicPassProductSchema, publicMembershipProductSchema;
 var init_shop_shared = __esm({
   "../blocks/src/system/blocks/shop.shared.ts"() {
     "use strict";
-    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())
-    });
-    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())
+    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())
+    });
+    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
-import { z as z52 } from "zod";
+import { z as z53 } from "zod";
 var eventDetailsManifest, occurrenceContextSchema2, eventAutoApplyDiscountPreviewBaseSchema, eventAutoApplyDiscountPreviewSchema, eventDetailsBlockDefinition;
 var init_event_details = __esm({
   "../blocks/src/system/blocks/event-details.ts"() {
@@ -33688,40 +33882,40 @@ var init_event_details = __esm({
         })
       ]
     });
-    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()
+    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();
-    eventAutoApplyDiscountPreviewBaseSchema = z52.object({
-      id: z52.string(),
-      publicLabel: z52.string(),
-      description: z52.string().nullable(),
-      minTicketsRequired: z52.number().nullable()
+    eventAutoApplyDiscountPreviewBaseSchema = z53.object({
+      id: z53.string(),
+      publicLabel: z53.string(),
+      description: z53.string().nullable(),
+      minTicketsRequired: z53.number().nullable()
     });
-    eventAutoApplyDiscountPreviewSchema = z52.discriminatedUnion("discountType", [
+    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()
       })
     ]);
     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()
@@ -34205,7 +34399,7 @@ var init_shared5 = __esm({
 });
 
 // ../blocks/src/system/runtime/nodes/events/shared/listOptions.ts
-import { z as z53 } from "zod";
+import { z as z54 } from "zod";
 function resolveEventPageSize(value, fallback = 12) {
   const candidate = typeof value === "number" ? value : typeof value === "string" && value.trim() !== "" ? Number(value.trim()) : null;
   return candidate != null && Number.isInteger(candidate) && eventPageSizeSet.has(candidate) ? candidate : fallback;
@@ -34226,32 +34420,32 @@ var init_listOptions = __esm({
   "../blocks/src/system/runtime/nodes/events/shared/listOptions.ts"() {
     "use strict";
     eventPageSizeValues = [3, 6, 10, 12, 20, 24, 30];
-    eventPageSizeSchema = z53.union([
-      z53.literal(3),
-      z53.literal(6),
-      z53.literal(10),
-      z53.literal(12),
-      z53.literal(20),
-      z53.literal(24),
-      z53.literal(30)
+    eventPageSizeSchema = z54.union([
+      z54.literal(3),
+      z54.literal(6),
+      z54.literal(10),
+      z54.literal(12),
+      z54.literal(20),
+      z54.literal(24),
+      z54.literal(30)
     ]);
     eventPageSizeSet = new Set(eventPageSizeValues);
-    eventListPaginationActionSchema = z53.discriminatedUnion("kind", [
-      z53.object({
-        kind: z53.literal("loadMore"),
-        label: z53.string()
+    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()
       })
     ]);
   }
 });
 
 // ../blocks/src/system/runtime/nodes/events/EventListing.interactive.ts
-import { z as z54 } from "zod";
+import { z as z55 } from "zod";
 var legacyEventCardVariantSchema, eventCardVariantInputSchema, cardOrientationSchema, eventBlockKindSchema, eventSurfaceScopeSchema, eventScheduleScopeSchema2, eventListingSourceSchema, eventListingDisplaySchema, eventListingHydrationSchema, eventListingRenderSchema, eventListingIslandMetaCodec, eventListingBlockRuntime, eventListingIslandMetaKeys, eventListingInteractiveIslandPropsCodec;
 var init_EventListing_interactive = __esm({
   "../blocks/src/system/runtime/nodes/events/EventListing.interactive.ts"() {
@@ -34264,89 +34458,89 @@ var init_EventListing_interactive = __esm({
     init_shared5();
     init_contract_schemas();
     init_listOptions();
-    legacyEventCardVariantSchema = z54.enum(["variant1", "variant2"]);
-    eventCardVariantInputSchema = z54.union([
+    legacyEventCardVariantSchema = z55.enum(["variant1", "variant2"]);
+    eventCardVariantInputSchema = z55.union([
       cardVariantRoleSchema,
       legacyEventCardVariantSchema
     ]);
-    cardOrientationSchema = z54.enum(["vertical", "horizontal"]);
-    eventBlockKindSchema = z54.enum(eventBlockKindValues);
-    eventSurfaceScopeSchema = z54.enum(eventSurfaceScopeValues);
-    eventScheduleScopeSchema2 = z54.enum(eventScheduleScopeValues);
-    eventListingSourceSchema = z54.object({
-      events: z54.array(publicEventSchema).nullable().optional(),
-      siteId: z54.string(),
-      apiBaseUrl: z54.string().optional(),
+    cardOrientationSchema = z55.enum(["vertical", "horizontal"]);
+    eventBlockKindSchema = z55.enum(eventBlockKindValues);
+    eventSurfaceScopeSchema = z55.enum(eventSurfaceScopeValues);
+    eventScheduleScopeSchema2 = z55.enum(eventScheduleScopeValues);
+    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()
     });
-    eventListingDisplaySchema = z54.object({
-      kind: z54.literal("event-listing"),
-      state: z54.enum(["loading", "empty", "ready"]),
+    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)
     });
-    eventListingHydrationSchema = z54.object({
-      siteId: z54.string(),
+    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()
     });
-    eventListingRenderSchema = z54.object({
+    eventListingRenderSchema = z55.object({
       display: eventListingDisplaySchema,
       hydration: eventListingHydrationSchema
     });
     eventListingIslandMetaCodec = createZodCodec(
-      z54.object({
-        siteId: z54.string(),
-        apiBaseUrl: z54.string().optional(),
+      z55.object({
+        siteId: z55.string(),
+        apiBaseUrl: z55.string().optional(),
         stage: previewStageSchema.optional()
       })
     );
@@ -34730,7 +34924,7 @@ var init_event_listing = __esm({
 });
 
 // ../blocks/src/system/runtime/nodes/events/EventCalendar.interactive.ts
-import { z as z55 } from "zod";
+import { z as z56 } from "zod";
 function buildEventCalendarDisplay(source) {
   const listLayout = source.listLayout ?? source.layout ?? "stack";
   return {
@@ -34783,14 +34977,14 @@ var init_EventCalendar_interactive = __esm({
     init_runtime();
     init_contract_schemas();
     init_listOptions();
-    eventBlockKindSchema2 = z55.enum(eventBlockKindValues);
-    eventSurfaceScopeSchema2 = z55.enum(eventSurfaceScopeValues);
-    eventScheduleScopeSchema3 = z55.enum(eventScheduleScopeValues);
-    eventCalendarSourceSchema = z55.object(
+    eventBlockKindSchema2 = z56.enum(eventBlockKindValues);
+    eventSurfaceScopeSchema2 = z56.enum(eventSurfaceScopeValues);
+    eventScheduleScopeSchema3 = z56.enum(eventScheduleScopeValues);
+    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(),
@@ -34798,78 +34992,78 @@ var init_EventCalendar_interactive = __esm({
         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()
       }
     );
-    eventCalendarDisplaySchema = z55.object({
-      kind: z55.literal("event-calendar"),
+    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()
-    });
-    eventCalendarHydrationSchema = z55.object({
-      siteId: z55.string(),
+      buttonText: z56.string(),
+      showVenue: z56.boolean(),
+      showMap: z56.boolean(),
+      showCapacity: z56.boolean(),
+      emptyMessage: z56.string()
+    });
+    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
     });
-    eventCalendarRenderSchema = z55.object({
+    eventCalendarRenderSchema = z56.object({
       display: eventCalendarDisplaySchema,
       hydration: eventCalendarHydrationSchema
     });
     eventCalendarIslandMetaCodec = createZodCodec(
-      z55.object({
-        siteId: z55.string(),
-        apiBaseUrl: z55.string().optional(),
+      z56.object({
+        siteId: z56.string(),
+        apiBaseUrl: z56.string().optional(),
         stage: previewStageSchema.optional()
       })
     );
@@ -35661,7 +35855,7 @@ var init_model = __esm({
 });
 
 // ../blocks/src/system/blocks/offerings-preview/index.ts
-import { z as z56 } from "zod";
+import { z as z57 } from "zod";
 function eventPresetLoader(preset2) {
   return {
     endpoint: "listPublicEvents",
@@ -35784,13 +35978,13 @@ var init_offerings_preview = __esm({
     init_shared3();
     init_shared4();
     init_model();
-    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()
+    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()
       }))
     });
     groupOverrideFields = [
@@ -36080,7 +36274,7 @@ var init_offerings_preview = __esm({
 });
 
 // ../blocks/src/system/blocks/embed.ts
-import { z as z57 } from "zod";
+import { z as z58 } from "zod";
 var embedFields, embedLayout2, embedManifest, embedEntrySchema, embedBlockDefinition;
 var init_embed = __esm({
   "../blocks/src/system/blocks/embed.ts"() {
@@ -36320,18 +36514,18 @@ var init_embed = __esm({
         spacing: "lg"
       }
     });
-    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()
+    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()
     });
     embedBlockDefinition = {
       manifest: embedManifest,
       dataSchemas: {
-        entries: z57.array(embedEntrySchema).optional()
+        entries: z58.array(embedEntrySchema).optional()
       },
       dataLoaders: {
         entries: {
@@ -37561,50 +37755,50 @@ var init_file_download = __esm({
 });
 
 // ../blocks/src/system/blocks/products/shared.ts
-import { z as z58 } from "zod";
+import { z as z59 } from "zod";
 var publicProductVariantSchema, publicProductSchema, publicProductsResponseSchema;
 var init_shared6 = __esm({
   "../blocks/src/system/blocks/products/shared.ts"() {
     "use strict";
-    publicProductVariantSchema = z58.object({
-      id: z58.string(),
-      title: z58.string(),
-      sku: z58.string().nullable(),
-      priceCents: z58.number(),
-      stockQuantity: z58.number().nullable(),
-      soldOut: z58.boolean()
-    });
-    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()
+    publicProductVariantSchema = z59.object({
+      id: z59.string(),
+      title: z59.string(),
+      sku: z59.string().nullable(),
+      priceCents: z59.number(),
+      stockQuantity: z59.number().nullable(),
+      soldOut: z59.boolean()
+    });
+    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)
     });
-    publicProductsResponseSchema = z58.object({
-      products: z58.array(publicProductSchema)
+    publicProductsResponseSchema = z59.object({
+      products: z59.array(publicProductSchema)
     });
   }
 });
@@ -37675,7 +37869,7 @@ var init_creditProducts = __esm({
 });
 
 // ../blocks/src/system/runtime/nodes/shop-commerce.shared.ts
-import { z as z59 } from "zod";
+import { z as z60 } from "zod";
 function deriveCommerceCheckoutState(state) {
   if (state.items.length === 0) {
     return { kind: "empty" };
@@ -37714,36 +37908,33 @@ var storedProductCartItemSchema, storedPassCartItemSchema;
 var init_shop_commerce_shared = __esm({
   "../blocks/src/system/runtime/nodes/shop-commerce.shared.ts"() {
     "use strict";
-    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()
+    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()
     });
-    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)
+    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)
     });
   }
 });
 
 // ../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;
@@ -37939,13 +38130,14 @@ function formatValidity(days) {
 var init_display = __esm({
   "../blocks/src/system/runtime/nodes/commerce/shared/display.ts"() {
     "use strict";
+    init_src();
     init_creditProducts();
     init_shop_commerce_shared();
   }
 });
 
 // ../blocks/src/system/runtime/nodes/shop.interactive.ts
-import { z as z60 } from "zod";
+import { z as z61 } from "zod";
 function resolveShowPricePerCredit(source) {
   return source.showPricePerCredit ?? true;
 }
@@ -37973,211 +38165,211 @@ var init_shop_interactive = __esm({
     init_islands();
     init_runtime();
     init_contract_schemas();
-    shopModeSchema = z60.enum(["passes-memberships", "product-list", "product-detail", "cart", "checkout"]);
-    contentEntrySchema3 = z60.object({
-      id: z60.string().nullable().optional(),
-      slug: z60.string().nullable().optional()
+    shopModeSchema = z61.enum(["passes-memberships", "product-list", "product-detail", "cart", "checkout"]);
+    contentEntrySchema3 = z61.object({
+      id: z61.string().nullable().optional(),
+      slug: z61.string().nullable().optional()
     }).nullable();
-    shopSourceSchema = z60.object({
-      className: z60.string().nullable().optional(),
+    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()
     });
-    productVariantOptionDisplaySchema = z60.object({
-      id: z60.string(),
-      label: z60.string(),
-      soldOut: z60.boolean()
-    });
-    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()
+    productVariantOptionDisplaySchema = z61.object({
+      id: z61.string(),
+      label: z61.string(),
+      soldOut: z61.boolean()
+    });
+    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()
-    });
-    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)
-    });
-    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()
+      variantOptions: z61.array(productVariantOptionDisplaySchema),
+      selectedVariantId: z61.string().nullable(),
+      selectionLabel: z61.string(),
+      actionLabel: z61.string(),
+      soldOut: z61.boolean()
+    });
+    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)
+    });
+    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()
       })
     ]);
-    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()
-    });
-    membershipCardDisplaySchema = z60.object({
-      id: z60.string(),
-      title: z60.string(),
-      description: z60.string().nullable(),
-      priceLabel: z60.string(),
-      intervalLabel: z60.string(),
-      actionLabel: z60.string()
-    });
-    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)
-    });
-    cartLineDisplaySchema = z60.object({
-      key: z60.string(),
-      title: z60.string(),
-      priceLabel: z60.string(),
-      quantity: z60.number(),
-      quantityEditable: z60.boolean()
-    });
-    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()
-    });
-    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()
-    });
-    passesMembershipsHydrationSchema = z60.object({
-      passes: z60.array(publicPassProductSchema),
-      memberships: z60.array(publicMembershipProductSchema),
-      passPurchaseMode: z60.enum(["add_to_cart", "buy_now"])
-    });
-    productListHydrationSchema = z60.object({
-      products: z60.array(publicProductSchema),
-      showSummary: z60.boolean(),
-      showPrices: z60.boolean(),
-      addButtonText: z60.string()
-    });
-    productDetailHydrationSchema = z60.object({
-      products: z60.array(publicProductSchema),
-      productId: z60.string().nullable(),
-      showSummary: z60.boolean(),
-      showBody: z60.boolean(),
-      addButtonText: z60.string()
-    });
-    cartHydrationSchema = z60.object({
-      emptyStateText: z60.string(),
-      checkoutButtonText: z60.string(),
-      clearButtonText: z60.string()
-    });
-    checkoutHydrationSchema = z60.object({
-      emptyStateText: z60.string(),
-      submitButtonText: z60.string()
-    });
-    passesMembershipsRenderSchema = z60.object({
+    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()
+    });
+    membershipCardDisplaySchema = z61.object({
+      id: z61.string(),
+      title: z61.string(),
+      description: z61.string().nullable(),
+      priceLabel: z61.string(),
+      intervalLabel: z61.string(),
+      actionLabel: z61.string()
+    });
+    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)
+    });
+    cartLineDisplaySchema = z61.object({
+      key: z61.string(),
+      title: z61.string(),
+      priceLabel: z61.string(),
+      quantity: z61.number(),
+      quantityEditable: z61.boolean()
+    });
+    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()
+    });
+    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()
+    });
+    passesMembershipsHydrationSchema = z61.object({
+      passes: z61.array(publicPassProductSchema),
+      memberships: z61.array(publicMembershipProductSchema),
+      passPurchaseMode: z61.enum(["add_to_cart", "buy_now"])
+    });
+    productListHydrationSchema = z61.object({
+      products: z61.array(publicProductSchema),
+      showSummary: z61.boolean(),
+      showPrices: z61.boolean(),
+      addButtonText: z61.string()
+    });
+    productDetailHydrationSchema = z61.object({
+      products: z61.array(publicProductSchema),
+      productId: z61.string().nullable(),
+      showSummary: z61.boolean(),
+      showBody: z61.boolean(),
+      addButtonText: z61.string()
+    });
+    cartHydrationSchema = z61.object({
+      emptyStateText: z61.string(),
+      checkoutButtonText: z61.string(),
+      clearButtonText: z61.string()
+    });
+    checkoutHydrationSchema = z61.object({
+      emptyStateText: z61.string(),
+      submitButtonText: z61.string()
+    });
+    passesMembershipsRenderSchema = z61.object({
       display: passesMembershipsDisplaySchema,
       hydration: passesMembershipsHydrationSchema
     });
-    productListRenderSchema = z60.object({
+    productListRenderSchema = z61.object({
       display: productListDisplaySchema,
       hydration: productListHydrationSchema
     });
-    productDetailRenderSchema = z60.object({
+    productDetailRenderSchema = z61.object({
       display: productDetailDisplaySchema,
       hydration: productDetailHydrationSchema
     });
-    cartRenderSchema = z60.object({
+    cartRenderSchema = z61.object({
       display: cartDisplaySchema,
       hydration: cartHydrationSchema
     });
-    checkoutRenderSchema = z60.object({
+    checkoutRenderSchema = z61.object({
       display: checkoutDisplaySchema,
       hydration: checkoutHydrationSchema
     });
-    shopIslandMetaCodec = createZodCodec(z60.object({
-      siteId: z60.string().optional(),
-      apiBaseUrl: z60.string().optional(),
+    shopIslandMetaCodec = createZodCodec(z61.object({
+      siteId: z61.string().optional(),
+      apiBaseUrl: z61.string().optional(),
       stage: previewStageSchema.optional()
     }));
     shopIslandMetaKeys = defineInteractiveIslandMetaKeys("siteId", "apiBaseUrl", "stage");
@@ -38349,7 +38541,7 @@ var init_shop_interactive = __esm({
 });
 
 // ../blocks/src/system/blocks/shop.ts
-import { z as z61 } from "zod";
+import { z as z62 } from "zod";
 var shopManifest, shopBlockDefinition;
 var init_shop = __esm({
   "../blocks/src/system/blocks/shop.ts"() {
@@ -38557,9 +38749,9 @@ var init_shop = __esm({
       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
@@ -38584,7 +38776,7 @@ var init_shop = __esm({
 });
 
 // ../blocks/src/system/blocks/product-list.ts
-import { z as z62 } from "zod";
+import { z as z63 } from "zod";
 var productListManifest, productListBlockDefinition, productListDataSchema;
 var init_product_list = __esm({
   "../blocks/src/system/blocks/product-list.ts"() {
@@ -38729,7 +38921,7 @@ var init_product_list = __esm({
         }
       }
     };
-    productListDataSchema = z62.object({
+    productListDataSchema = z63.object({
       products: publicProductsResponseSchema.optional()
     });
   }
@@ -39032,7 +39224,7 @@ var init_checkout = __esm({
 });
 
 // ../blocks/src/system/runtime/nodes/gifting.interactive.ts
-import { z as z63 } from "zod";
+import { z as z64 } from "zod";
 function buildGiftingDisplay(source) {
   return {
     kind: "gifting",
@@ -39051,71 +39243,71 @@ var init_gifting_interactive = __esm({
     "use strict";
     init_islands();
     init_runtime();
-    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()
+    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()
-    });
-    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()
+      voucher: z64.null()
+    });
+    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()
       })
     });
-    publicGiftingOffersResponseSchema = z63.object({
-      currency: z63.string(),
-      giftCards: z63.array(publicGiftCardOfferSchema),
-      vouchers: z63.array(publicVoucherOfferSchema)
+    publicGiftingOffersResponseSchema = z64.object({
+      currency: z64.string(),
+      giftCards: z64.array(publicGiftCardOfferSchema),
+      vouchers: z64.array(publicVoucherOfferSchema)
     });
-    giftingSourceSchema = z63.object({
-      siteId: z63.string().optional(),
-      apiBaseUrl: z63.string().optional(),
+    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()
-    });
-    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()
-    });
-    giftingHydrationSchema = z63.object({
+      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()
+    });
+    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()
+    });
+    giftingHydrationSchema = z64.object({
       offers: publicGiftingOffersResponseSchema.nullable(),
-      checkoutButtonText: z63.string(),
-      successMessage: z63.string()
+      checkoutButtonText: z64.string(),
+      successMessage: z64.string()
     });
-    giftingRenderSchema = z63.object({
+    giftingRenderSchema = z64.object({
       display: giftingDisplaySchema,
       hydration: giftingHydrationSchema
     });
-    giftingIslandMetaCodec = createZodCodec(z63.object({
-      siteId: z63.string().optional(),
-      apiBaseUrl: z63.string().optional()
+    giftingIslandMetaCodec = createZodCodec(z64.object({
+      siteId: z64.string().optional(),
+      apiBaseUrl: z64.string().optional()
     }));
     giftingIslandMetaKeys = defineInteractiveIslandMetaKeys(
       "siteId",
@@ -39288,6 +39480,94 @@ var init_gifting = __esm({
   }
 });
 
+// ../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 (!isRecord7(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 (!isRecord7(destination) || typeof destination.tag !== "string") return null;
+  if (destination.tag === "riverbank_list") return "riverbank";
+  if (destination.tag === "mailchimp_audience") return "mailchimp";
+  return null;
+}
+function parseTrimmedString(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function isRecord7(value) {
+  return typeof value === "object" && value !== null;
+}
+var BLOCK_ID_PATTERN, SIGNED_DESTINATION_REF_PATTERN;
+var init_newsletter_signup_destination = __esm({
+  "../blocks/src/system/blocks/newsletter-signup-destination.ts"() {
+    "use strict";
+    BLOCK_ID_PATTERN = /^[A-Za-z0-9._:-]{1,200}$/;
+    SIGNED_DESTINATION_REF_PATTERN = /^[A-Za-z0-9._~-]{16,1000}$/;
+  }
+});
+
 // ../blocks/src/system/runtime/nodes/newsletter-form.types.ts
 function getPresetFields(preset2, options) {
   const includePhone = Boolean(options?.includePhone);
@@ -39344,7 +39624,7 @@ var init_newsletter_form_types = __esm({
 });
 
 // ../blocks/src/system/runtime/nodes/newsletter-form.interactive.ts
-import { z as z64 } from "zod";
+import { z as z65 } from "zod";
 function buildNewsletterDisplay(source) {
   const preset2 = source.preset ?? "emailOnly";
   const includePhone = source.includePhone ?? false;
@@ -39357,56 +39637,87 @@ function buildNewsletterDisplay(source) {
     fields: getPresetFields(preset2, { includePhone })
   };
 }
-var newsletterPresetSchema, newsletterFieldSchema, newsletterSourceSchema, newsletterDisplaySchema, newsletterHydrationSchema, newsletterRenderSchema, newsletterIslandMetaCodec, newsletterIslandMetaKeys, newsletterFormBlockRuntime, newsletterFormInteractiveIslandPropsCodec;
+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;
+}
+var newsletterPresetSchema, newsletterDestinationProviderSchema, newsletterFieldSchema, newsletterSignupBlockIdSchema, signedNewsletterDestinationRefSchema, newsletterPublicDestinationRefSchema, newsletterSourceSchema, newsletterDisplaySchema, newsletterHydrationSchema, newsletterRenderSchema, newsletterIslandMetaCodec, newsletterIslandMetaKeys, newsletterFormBlockRuntime, newsletterFormInteractiveIslandPropsCodec;
 var init_newsletter_form_interactive = __esm({
   "../blocks/src/system/runtime/nodes/newsletter-form.interactive.ts"() {
     "use strict";
     init_islands();
     init_runtime();
+    init_newsletter_signup_destination();
     init_newsletter_form_types();
-    newsletterPresetSchema = z64.enum(["emailOnly", "emailName", "emailFirstLast", "emailNameCompany"]);
-    newsletterFieldSchema = z64.object({
-      id: z64.string(),
-      type: z64.enum(["email", "text"]),
-      label: z64.string(),
-      required: z64.boolean(),
-      placeholder: z64.string().optional()
-    });
-    newsletterSourceSchema = z64.object({
-      siteId: z64.string().optional(),
-      apiBaseUrl: z64.string().optional(),
-      listId: z64.string().nullable().optional(),
+    newsletterPresetSchema = z65.enum(["emailOnly", "emailName", "emailFirstLast", "emailNameCompany"]);
+    newsletterDestinationProviderSchema = z65.enum(["riverbank", "mailchimp"]);
+    newsletterFieldSchema = z65.object({
+      id: z65.string(),
+      type: z65.enum(["email", "text"]),
+      label: z65.string(),
+      required: z65.boolean(),
+      placeholder: z65.string().optional()
+    });
+    newsletterSignupBlockIdSchema = z65.string().trim().min(1).transform(parseRequiredNewsletterSignupBlockId);
+    signedNewsletterDestinationRefSchema = z65.string().trim().min(1).transform(parseRequiredSignedNewsletterDestinationRef);
+    newsletterPublicDestinationRefSchema = z65.discriminatedUnion("tag", [
+      z65.object({
+        tag: z65.literal("block_ref"),
+        blockId: newsletterSignupBlockIdSchema
+      }),
+      z65.object({
+        tag: z65.literal("signed_destination_ref"),
+        token: signedNewsletterDestinationRefSchema
+      })
+    ]);
+    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()
-    });
-    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)
-    });
-    newsletterHydrationSchema = z64.object({
-      listId: 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()
+    });
+    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)
+    });
+    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()
     });
-    newsletterRenderSchema = z64.object({
+    newsletterRenderSchema = z65.object({
       display: newsletterDisplaySchema,
       hydration: newsletterHydrationSchema
     });
-    newsletterIslandMetaCodec = createZodCodec(z64.object({
-      siteId: z64.string().optional(),
-      apiBaseUrl: z64.string().optional()
+    newsletterIslandMetaCodec = createZodCodec(z65.object({
+      siteId: z65.string().optional(),
+      apiBaseUrl: z65.string().optional()
     }));
     newsletterIslandMetaKeys = defineInteractiveIslandMetaKeys("siteId", "apiBaseUrl");
     newsletterFormBlockRuntime = defineProgressiveBlockRuntime({
@@ -39415,16 +39726,20 @@ var init_newsletter_form_interactive = __esm({
         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
+          }
+        };
+      }
     });
     newsletterFormInteractiveIslandPropsCodec = createInteractiveIslandCodec({
       runtime: newsletterFormBlockRuntime,
@@ -39449,6 +39764,7 @@ var init_newsletter_signup = __esm({
     init_defineBlock();
     init_fragments2();
     init_newsletter_form_interactive();
+    init_newsletter_signup_destination();
     stackedComposition = composeFragments([
       { fragment: newsletterCopyFragment },
       { fragment: newsletterFormFragment }
@@ -39528,7 +39844,7 @@ var init_newsletter_signup = __esm({
 });
 
 // ../blocks/src/system/blocks/team-members.ts
-import { z as z65 } from "zod";
+import { z as z66 } from "zod";
 var ITEM_NAME2, teamMemberPhotoSchema, teamMemberDataSchema, teamMembersDataSchema, dynamicSourceWhen, manualSourceWhen, headingNode, wrapVariant3, teamMemberStackLayout, manualGridMembersNode, dynamicGridMembersNode, gridVariant, manualStackMembersNode, dynamicStackMembersNode, stackVariant, teamMembersManifest, teamMembersBlockDefinition;
 var init_team_members = __esm({
   "../blocks/src/system/blocks/team-members.ts"() {
@@ -39545,18 +39861,18 @@ var init_team_members = __esm({
     teamMemberPhotoSchema = mediaSchema2.refine((media2) => media2.type === "image", {
       message: "Team member photos must be image media"
     }).nullable();
-    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(),
+    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()
     });
-    teamMembersDataSchema = z65.array(teamMemberDataSchema);
+    teamMembersDataSchema = z66.array(teamMemberDataSchema);
     dynamicSourceWhen = { equals: "site_staff" };
     manualSourceWhen = { equals: "site_staff", not: true };
     headingNode = text(
@@ -41670,7 +41986,7 @@ var init_transforms = __esm({
 
 // ../blocks/src/system/data/linkedContentEntries.ts
 function coerceLinkedContentEntriesPayload(payload) {
-  if (!isRecord7(payload)) return payload;
+  if (!isRecord8(payload)) return payload;
   const response = payload;
   if (!Array.isArray(response.entries)) return payload;
   const contentType = parsePublicContentTypeMeta(response.contentType);
@@ -41678,12 +41994,12 @@ function coerceLinkedContentEntriesPayload(payload) {
   return response.entries.map((entry) => enrichLinkedContentEntry(entry, contentType));
 }
 function enrichLinkedContentEntry(entry, contentType) {
-  if (!isRecord7(entry)) return entry;
+  if (!isRecord8(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 = isRecord7(entry.content) ? entry.content : {};
+  const content = isRecord8(entry.content) ? entry.content : {};
   const meta = {
     kind: "linked-content-entry",
     entryId,
@@ -41776,7 +42092,7 @@ function capitalize(value) {
   return value.charAt(0).toUpperCase() + value.slice(1).toLowerCase();
 }
 function parsePublicContentTypeMeta(value) {
-  if (!isRecord7(value)) return null;
+  if (!isRecord8(value)) return null;
   if (typeof value.key !== "string" || value.key.trim().length === 0) return null;
   return {
     key: value.key,
@@ -41786,7 +42102,7 @@ function parsePublicContentTypeMeta(value) {
   };
 }
 function parsePublicContentTypeLinkedEntryEditing(value) {
-  if (!isRecord7(value) || typeof value.kind !== "string") return null;
+  if (!isRecord8(value) || typeof value.kind !== "string") return null;
   switch (value.kind) {
     case "generic":
       return { kind: "generic" };
@@ -41800,7 +42116,7 @@ function parsePublicContentTypeLinkedEntryEditing(value) {
   }
 }
 function parsePublicContentTypeFieldMeta(value) {
-  if (!isRecord7(value)) return [];
+  if (!isRecord8(value)) return [];
   if (typeof value.id !== "string" || typeof value.type !== "string") return [];
   return [{
     id: value.id,
@@ -41814,7 +42130,7 @@ function parseStringArray(value) {
   if (!Array.isArray(value)) return null;
   return value.filter((item) => typeof item === "string");
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var LINKED_CONTENT_ENTRY_META_KEY;
@@ -43607,30 +43923,30 @@ var init_Button = __esm({
 });
 
 // ../blocks/src/structure/schema.ts
-import z66 from "zod";
+import z67 from "zod";
 var BlockKind, blockSchema, pagePath, pageOutlineSchema;
 var init_schema4 = __esm({
   "../blocks/src/structure/schema.ts"() {
     "use strict";
-    BlockKind = z66.string();
-    blockSchema = z66.object({
-      id: z66.string().nullable(),
+    BlockKind = z67.string();
+    blockSchema = z67.object({
+      id: z67.string().nullable(),
       // optional ID for reference in toggle ops
       kind: BlockKind,
-      purpose: z66.string().min(1),
+      purpose: z67.string().min(1),
       // Optional content fields used by PageRenderer / block runtime.
-      content: z66.record(z66.string(), z66.unknown()).optional(),
+      content: z67.record(z67.string(), z67.unknown()).optional(),
       // Nullable because some persisted sources store "no draft" as null.
-      draftContent: z66.record(z66.string(), z66.unknown()).nullable().optional(),
+      draftContent: z67.record(z67.string(), z67.unknown()).nullable().optional(),
       // Optional template bindings for reverse field mapping (entry editing)
-      bindings: z66.record(z66.string(), z66.unknown()).optional()
+      bindings: z67.record(z67.string(), z67.unknown()).optional()
     }).passthrough();
-    pagePath = z66.string().regex(/^\/[\S]*$/, 'path must start with "/" and contain no spaces');
-    pageOutlineSchema = z66.object({
-      name: z66.string().min(1),
+    pagePath = z67.string().regex(/^\/[\S]*$/, 'path must start with "/" and contain no spaces');
+    pageOutlineSchema = z67.object({
+      name: z67.string().min(1),
       path: pagePath,
-      purpose: z66.string().min(1),
-      blocks: z66.array(blockSchema).min(1)
+      purpose: z67.string().min(1),
+      blocks: z67.array(blockSchema).min(1)
     });
   }
 });
@@ -43742,7 +44058,7 @@ var init_fonts = __esm({
 });
 
 // ../theme-core/src/runtime/buildThemeRuntimeFromBridge.ts
-import { z as z67 } from "zod";
+import { z as z68 } from "zod";
 var themeBridgeConfigSchema;
 var init_buildThemeRuntimeFromBridge = __esm({
   "../theme-core/src/runtime/buildThemeRuntimeFromBridge.ts"() {
@@ -43757,33 +44073,33 @@ var init_buildThemeRuntimeFromBridge = __esm({
     init_progress();
     init_blocks2();
     init_themeCssVarNames();
-    themeBridgeConfigSchema = z67.object({
-      tokens: z67.record(z67.string(), z67.string()),
-      typography: z67.object({
-        headingFamily: z67.string().optional(),
-        bodyFamily: z67.string().optional(),
-        headingWeight: z67.number().optional(),
-        bodyWeight: z67.number().optional()
+    themeBridgeConfigSchema = z68.object({
+      tokens: z68.record(z68.string(), z68.string()),
+      typography: z68.object({
+        headingFamily: z68.string().optional(),
+        bodyFamily: z68.string().optional(),
+        headingWeight: z68.number().optional(),
+        bodyWeight: z68.number().optional()
       }).optional(),
-      spacing: z67.enum(["comfortable", "standard", "dense"]).optional(),
-      corners: z67.enum(["square", "soft", "rounded", "pill"]).optional(),
-      shadows: z67.enum(["none", "low", "medium", "high"]).optional(),
-      components: z67.object({
-        buttons: z67.union([
-          z67.boolean(),
-          z67.object({
-            variants: z67.array(z67.enum(["primary", "secondary", "outline", "ghost"])).optional()
+      spacing: z68.enum(["comfortable", "standard", "dense"]).optional(),
+      corners: z68.enum(["square", "soft", "rounded", "pill"]).optional(),
+      shadows: z68.enum(["none", "low", "medium", "high"]).optional(),
+      components: z68.object({
+        buttons: z68.union([
+          z68.boolean(),
+          z68.object({
+            variants: z68.array(z68.enum(["primary", "secondary", "outline", "ghost"])).optional()
           })
         ]).optional(),
-        cards: z67.union([
-          z67.boolean(),
-          z67.object({
-            variants: z67.array(z67.enum(["default", "elevated", "outlined"])).optional()
+        cards: z68.union([
+          z68.boolean(),
+          z68.object({
+            variants: z68.array(z68.enum(["default", "elevated", "outlined"])).optional()
           })
         ]).optional(),
-        inputs: z67.boolean().optional()
+        inputs: z68.boolean().optional()
       }).optional(),
-      overrides: z67.record(z67.string(), z67.string()).optional()
+      overrides: z68.record(z68.string(), z68.string()).optional()
     }).passthrough();
   }
 });
@@ -44253,7 +44569,7 @@ var init_src3 = __esm({
 });
 
 // ../api/src/sdkConfig/contracts.ts
-import { z as z68 } from "zod";
+import { z as z69 } from "zod";
 function unsafeRetypeZodSchema(schema) {
   return schema;
 }
@@ -44262,17 +44578,17 @@ var init_contracts2 = __esm({
   "../api/src/sdkConfig/contracts.ts"() {
     "use strict";
     init_src3();
-    navIdListSchema = z68.preprocess((value) => {
+    navIdListSchema = z69.preprocess((value) => {
       if (!Array.isArray(value)) return void 0;
       const filtered = value.filter((v) => typeof v === "string" && v.trim().length > 0);
       return filtered.length > 0 ? filtered : void 0;
-    }, z68.array(z68.string()).max(200).optional());
-    dashboardNavVisibilityBaseSchema = z68.object({
-      mode: z68.enum(["augment", "restrict"]).optional(),
+    }, z69.array(z69.string()).max(200).optional());
+    dashboardNavVisibilityBaseSchema = z69.object({
+      mode: z69.enum(["augment", "restrict"]).optional(),
       allowIds: navIdListSchema,
       denyIds: navIdListSchema
     }).strip();
-    dashboardNavVisibilityRolesSchema = z68.object({
+    dashboardNavVisibilityRolesSchema = z69.object({
       administrator: dashboardNavVisibilityBaseSchema.optional(),
       editor: dashboardNavVisibilityBaseSchema.optional(),
       team_member: dashboardNavVisibilityBaseSchema.optional()
@@ -44280,63 +44596,63 @@ var init_contracts2 = __esm({
     dashboardNavVisibilitySchema = dashboardNavVisibilityBaseSchema.extend({
       roles: dashboardNavVisibilityRolesSchema
     }).strip();
-    dashboardNavigationConfigSchema = z68.object({
+    dashboardNavigationConfigSchema = z69.object({
       siteNav: dashboardNavVisibilitySchema.optional(),
       settingsNav: dashboardNavVisibilitySchema.optional()
     }).strip();
-    dashboardConfigSchema = z68.object({
-      previewEditingEnabled: z68.boolean().optional(),
+    dashboardConfigSchema = z69.object({
+      previewEditingEnabled: z69.boolean().optional(),
       navigation: dashboardNavigationConfigSchema.optional()
     }).strip();
     fieldDefinitionInputSchema = unsafeRetypeZodSchema(fieldSchema);
     nodeDefinitionSchema = unsafeRetypeZodSchema(NodeSchema);
-    sdkLoaderEndpointSchema = z68.enum(SUPPORTED_LOADER_ENDPOINTS);
-    loaderFallbackScalarSchema = z68.union([
-      z68.string(),
-      z68.number(),
-      z68.boolean(),
-      z68.null()
+    sdkLoaderEndpointSchema = z69.enum(SUPPORTED_LOADER_ENDPOINTS);
+    loaderFallbackScalarSchema = z69.union([
+      z69.string(),
+      z69.number(),
+      z69.boolean(),
+      z69.null()
     ]);
-    loaderParamBindingSchema = z68.object({
-      $bind: z68.object({
-        from: z68.string().min(1, "Binding path is required"),
+    loaderParamBindingSchema = z69.object({
+      $bind: z69.object({
+        from: z69.string().min(1, "Binding path is required"),
         fallback: loaderFallbackScalarSchema.optional()
       })
     });
-    loaderParamValueSchema = z68.union([
-      z68.string(),
-      z68.number(),
-      z68.boolean(),
+    loaderParamValueSchema = z69.union([
+      z69.string(),
+      z69.number(),
+      z69.boolean(),
       loaderParamBindingSchema
     ]);
-    sdkConfigLoaderSchema = z68.object({
+    sdkConfigLoaderSchema = z69.object({
       endpoint: sdkLoaderEndpointSchema,
-      params: z68.record(z68.string(), loaderParamValueSchema),
-      mode: z68.enum(["server", "client"]).default("server")
+      params: z69.record(z69.string(), loaderParamValueSchema),
+      mode: z69.enum(["server", "client"]).default("server")
     });
-    sdkDataLoadersSchema = z68.record(z68.string(), sdkConfigLoaderSchema).refine((loaders) => Object.keys(loaders).length <= 5, { message: "Maximum 5 data loaders per block" }).optional();
-    sdkCustomBlockIdSchema = z68.string().min(8).regex(/^custom\.[a-z][a-z0-9-]*$/, {
+    sdkDataLoadersSchema = z69.record(z69.string(), sdkConfigLoaderSchema).refine((loaders) => Object.keys(loaders).length <= 5, { message: "Maximum 5 data loaders per block" }).optional();
+    sdkCustomBlockIdSchema = z69.string().min(8).regex(/^custom\.[a-z][a-z0-9-]*$/, {
       message: "Block ID must start with 'custom.' followed by lowercase letters, numbers, or hyphens"
     }).transform((value) => value);
-    sdkCustomBlockInputSchema = z68.object({
+    sdkCustomBlockInputSchema = z69.object({
       id: sdkCustomBlockIdSchema,
-      title: z68.string().min(1),
-      titleSource: z68.union([z68.string().min(1), z68.array(z68.string().min(1)).min(1)]).optional(),
-      description: z68.string().optional(),
+      title: z69.string().min(1),
+      titleSource: z69.union([z69.string().min(1), z69.array(z69.string().min(1)).min(1)]).optional(),
+      description: z69.string().optional(),
       category: blockCategoryEnum,
-      icon: z68.string().optional(),
-      tags: z68.array(z68.string()).optional(),
+      icon: z69.string().optional(),
+      tags: z69.array(z69.string()).optional(),
       fields: fieldDefinitionInputSchema.array().min(1),
       dataLoaders: sdkDataLoadersSchema,
       layout: NodeSchema.optional(),
-      variants: z68.record(z68.string().min(1), NodeSchema).optional(),
-      defaultVariant: z68.string().min(1).optional(),
-      variantOptions: z68.record(
-        z68.string().min(1),
-        z68.object({
-          label: z68.string().min(1).optional(),
-          description: z68.string().min(1).optional(),
-          icon: z68.string().min(1).optional()
+      variants: z69.record(z69.string().min(1), NodeSchema).optional(),
+      defaultVariant: z69.string().min(1).optional(),
+      variantOptions: z69.record(
+        z69.string().min(1),
+        z69.object({
+          label: z69.string().min(1).optional(),
+          description: z69.string().min(1).optional(),
+          icon: z69.string().min(1).optional()
         })
       ).optional(),
       previewCustomize: previewCustomizeManifestCurationSchema.optional()
@@ -44347,7 +44663,7 @@ var init_contracts2 = __esm({
           const exists = data.fields.some((field) => field.id === source);
           if (!exists) {
             ctx.addIssue({
-              code: z68.ZodIssueCode.custom,
+              code: z69.ZodIssueCode.custom,
               message: `titleSource must reference a valid field ID (got "${source}")`,
               path: Array.isArray(data.titleSource) ? ["titleSource", index] : ["titleSource"]
             });
@@ -44356,7 +44672,7 @@ var init_contracts2 = __esm({
       }
       if (data.layout && data.variants) {
         ctx.addIssue({
-          code: z68.ZodIssueCode.custom,
+          code: z69.ZodIssueCode.custom,
           message: "Custom block must define either `layout` or `variants`, not both",
           path: ["variants"]
         });
@@ -44365,14 +44681,14 @@ var init_contracts2 = __esm({
         const keys = Object.keys(data.variants);
         if (keys.length === 0) {
           ctx.addIssue({
-            code: z68.ZodIssueCode.custom,
+            code: z69.ZodIssueCode.custom,
             message: "`variants` must contain at least one variant key",
             path: ["variants"]
           });
         }
         if (data.defaultVariant && !Object.prototype.hasOwnProperty.call(data.variants, data.defaultVariant)) {
           ctx.addIssue({
-            code: z68.ZodIssueCode.custom,
+            code: z69.ZodIssueCode.custom,
             message: "`defaultVariant` must be a key present in `variants`",
             path: ["defaultVariant"]
           });
@@ -44381,7 +44697,7 @@ var init_contracts2 = __esm({
           for (const key of Object.keys(data.variantOptions)) {
             if (!Object.prototype.hasOwnProperty.call(data.variants, key)) {
               ctx.addIssue({
-                code: z68.ZodIssueCode.custom,
+                code: z69.ZodIssueCode.custom,
                 message: "`variantOptions` key must exist in `variants`",
                 path: ["variantOptions", key]
               });
@@ -44390,78 +44706,78 @@ var init_contracts2 = __esm({
         }
       }
     });
-    sdkBlockFieldExtensionInputSchema = z68.object({
+    sdkBlockFieldExtensionInputSchema = z69.object({
       fields: fieldDefinitionInputSchema.array().min(1)
     });
-    sdkBlockFieldExtensionsInputSchema = z68.record(
-      z68.string().min(1),
+    sdkBlockFieldExtensionsInputSchema = z69.record(
+      z69.string().min(1),
       sdkBlockFieldExtensionInputSchema
     );
-    sdkThemePaletteSchema = z68.record(z68.string(), z68.string());
-    sdkThemeConfigSchema = z68.object({
+    sdkThemePaletteSchema = z69.record(z69.string(), z69.string());
+    sdkThemeConfigSchema = z69.object({
       palette: sdkThemePaletteSchema
     });
-    sdkSectionBackgroundSchema = z68.object({
-      id: z68.string().min(1),
-      label: z68.string().min(1),
-      token: z68.string().min(1)
+    sdkSectionBackgroundSchema = z69.object({
+      id: z69.string().min(1),
+      label: z69.string().min(1),
+      token: z69.string().min(1)
     });
-    sdkSectionOptionsConfigSchema = z68.object({
-      backgroundColor: z68.boolean().optional(),
-      backgroundImage: z68.boolean().optional(),
-      backgroundGradient: z68.boolean().optional(),
-      spacing: z68.union([z68.array(z68.enum(["compact", "default", "spacious"])), z68.boolean()]).optional(),
-      textColor: z68.boolean().optional()
+    sdkSectionOptionsConfigSchema = z69.object({
+      backgroundColor: z69.boolean().optional(),
+      backgroundImage: z69.boolean().optional(),
+      backgroundGradient: z69.boolean().optional(),
+      spacing: z69.union([z69.array(z69.enum(["compact", "default", "spacious"])), z69.boolean()]).optional(),
+      textColor: z69.boolean().optional()
     });
-    sdkContainerOptionsConfigSchema = z68.object({
-      maxWidth: z68.union([z68.array(z68.enum(["narrow", "default", "wide", "full"])), z68.boolean()]).optional(),
-      alignment: z68.union([z68.array(z68.enum(["left", "center", "right"])), z68.boolean()]).optional()
+    sdkContainerOptionsConfigSchema = z69.object({
+      maxWidth: z69.union([z69.array(z69.enum(["narrow", "default", "wide", "full"])), z69.boolean()]).optional(),
+      alignment: z69.union([z69.array(z69.enum(["left", "center", "right"])), z69.boolean()]).optional()
     });
-    sdkSiteStyleConfigSchema = z68.object({
-      sectionBackgrounds: z68.array(sdkSectionBackgroundSchema).optional(),
+    sdkSiteStyleConfigSchema = z69.object({
+      sectionBackgrounds: z69.array(sdkSectionBackgroundSchema).optional(),
       sectionOptions: sdkSectionOptionsConfigSchema.optional(),
       containerOptions: sdkContainerOptionsConfigSchema.optional()
     });
-    sdkSiteLayoutConfigSchema = z68.object({
-      footerBlocks: z68.array(
-        z68.object({
-          id: z68.string().min(1).optional(),
-          kind: z68.string().min(1),
-          content: z68.record(z68.string(), z68.unknown()).optional()
+    sdkSiteLayoutConfigSchema = z69.object({
+      footerBlocks: z69.array(
+        z69.object({
+          id: z69.string().min(1).optional(),
+          kind: z69.string().min(1),
+          content: z69.record(z69.string(), z69.unknown()).optional()
         })
       ).optional()
     });
-    sdkFieldSelectOptionSchema = z68.object({
-      value: z68.string(),
-      label: z68.string()
+    sdkFieldSelectOptionSchema = z69.object({
+      value: z69.string(),
+      label: z69.string()
     });
-    sdkBlockFieldConfigSchema = z68.object({
-      options: z68.array(sdkFieldSelectOptionSchema).optional()
+    sdkBlockFieldConfigSchema = z69.object({
+      options: z69.array(sdkFieldSelectOptionSchema).optional()
     });
-    sdkBlockFieldOptionsMapSchema = z68.record(
-      z68.string().regex(/^(block\.|custom\.)[a-z][a-z0-9-]*$/, {
+    sdkBlockFieldOptionsMapSchema = z69.record(
+      z69.string().regex(/^(block\.|custom\.)[a-z][a-z0-9-]*$/, {
         message: "Block ID must be 'block.*' or 'custom.*' format"
       }),
-      z68.record(z68.string().min(1), sdkBlockFieldConfigSchema)
+      z69.record(z69.string().min(1), sdkBlockFieldConfigSchema)
     ).optional();
-    sdkContentTypeTemplateConfigSchema = z68.object({
-      blocks: z68.array(z68.unknown())
+    sdkContentTypeTemplateConfigSchema = z69.object({
+      blocks: z69.array(z69.unknown())
     }).passthrough();
-    sdkContentTypeOrderingConfigSchema = z68.object({
-      mode: z68.enum(["default", "manual"]).optional()
+    sdkContentTypeOrderingConfigSchema = z69.object({
+      mode: z69.enum(["default", "manual"]).optional()
     }).optional();
-    sdkContentTypeConfigSchema = z68.object({
-      key: z68.string().min(1),
-      fields: z68.array(z68.unknown()),
+    sdkContentTypeConfigSchema = z69.object({
+      key: z69.string().min(1),
+      fields: z69.array(z69.unknown()),
       ordering: sdkContentTypeOrderingConfigSchema,
       template: sdkContentTypeTemplateConfigSchema.nullable().optional()
     }).passthrough();
-    sdkContentConfigSchema = z68.object({
-      contentTypes: z68.array(sdkContentTypeConfigSchema).optional(),
-      pages: z68.array(z68.unknown()).optional(),
-      entries: z68.array(z68.unknown()).optional(),
-      navigationMenus: z68.array(z68.unknown()).optional(),
-      settings: z68.unknown().optional()
+    sdkContentConfigSchema = z69.object({
+      contentTypes: z69.array(sdkContentTypeConfigSchema).optional(),
+      pages: z69.array(z69.unknown()).optional(),
+      entries: z69.array(z69.unknown()).optional(),
+      navigationMenus: z69.array(z69.unknown()).optional(),
+      settings: z69.unknown().optional()
     }).passthrough();
     SDK_WORKFLOW_ID_MAX_LENGTH = 120;
     SDK_WORKFLOW_TITLE_MAX_LENGTH = 120;
@@ -44476,62 +44792,62 @@ var init_contracts2 = __esm({
     SDK_WORKFLOW_CONFIRMATION_BODY_MAX_LENGTH = 500;
     SDK_WORKFLOW_ID_PATTERN = /^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/;
     SDK_WORKFLOW_ENDPOINT_PATTERN = /^\//;
-    sdkWorkflowIdSchema = z68.string().min(1).max(SDK_WORKFLOW_ID_MAX_LENGTH).regex(SDK_WORKFLOW_ID_PATTERN, {
+    sdkWorkflowIdSchema = z69.string().min(1).max(SDK_WORKFLOW_ID_MAX_LENGTH).regex(SDK_WORKFLOW_ID_PATTERN, {
       message: "Workflow ID must start with a lowercase letter and use lowercase letters, numbers, dots, underscores, or hyphens"
     });
-    sdkWorkflowEndpointSchema = z68.string().min(1).max(SDK_WORKFLOW_ENDPOINT_MAX_LENGTH).regex(SDK_WORKFLOW_ENDPOINT_PATTERN, { message: 'Workflow endpoint must be a site-relative path starting with "/"' });
-    sdkWorkflowManualTriggerSchema = z68.object({
-      type: z68.literal("manual")
+    sdkWorkflowEndpointSchema = z69.string().min(1).max(SDK_WORKFLOW_ENDPOINT_MAX_LENGTH).regex(SDK_WORKFLOW_ENDPOINT_PATTERN, { message: 'Workflow endpoint must be a site-relative path starting with "/"' });
+    sdkWorkflowManualTriggerSchema = z69.object({
+      type: z69.literal("manual")
     }).strict();
-    sdkWorkflowTriggerFieldSchema = z68.string().trim().min(1).max(SDK_WORKFLOW_TRIGGER_FIELD_MAX_LENGTH).refine((field) => !field.includes("."), {
+    sdkWorkflowTriggerFieldSchema = z69.string().trim().min(1).max(SDK_WORKFLOW_TRIGGER_FIELD_MAX_LENGTH).refine((field) => !field.includes("."), {
       message: "Workflow trigger fields must be top-level content field IDs, not paths"
     });
-    sdkWorkflowFieldChangedConditionSchema = z68.object({
+    sdkWorkflowFieldChangedConditionSchema = z69.object({
       field: sdkWorkflowTriggerFieldSchema,
-      changed: z68.literal(true)
+      changed: z69.literal(true)
     }).strict();
-    sdkWorkflowFieldEmptyConditionSchema = z68.object({
+    sdkWorkflowFieldEmptyConditionSchema = z69.object({
       field: sdkWorkflowTriggerFieldSchema,
-      isEmpty: z68.boolean()
+      isEmpty: z69.boolean()
     }).strict();
-    sdkWorkflowEntryDraftUpdatedTriggerSchema = z68.object({
-      type: z68.literal("entry.draft.updated"),
-      when: z68.array(
-        z68.union([
+    sdkWorkflowEntryDraftUpdatedTriggerSchema = z69.object({
+      type: z69.literal("entry.draft.updated"),
+      when: z69.array(
+        z69.union([
           sdkWorkflowFieldChangedConditionSchema,
           sdkWorkflowFieldEmptyConditionSchema
         ])
       ).min(1).max(SDK_WORKFLOW_TRIGGER_CONDITION_MAX_COUNT)
     }).strict();
-    sdkWorkflowTriggerSchema = z68.discriminatedUnion("type", [
+    sdkWorkflowTriggerSchema = z69.discriminatedUnion("type", [
       sdkWorkflowManualTriggerSchema,
       sdkWorkflowEntryDraftUpdatedTriggerSchema
     ]);
-    sdkWorkflowConfirmationSchema = z68.object({
-      title: z68.string().trim().min(1).max(SDK_WORKFLOW_CONFIRMATION_TITLE_MAX_LENGTH),
-      body: z68.string().trim().min(1).max(SDK_WORKFLOW_CONFIRMATION_BODY_MAX_LENGTH).optional()
+    sdkWorkflowConfirmationSchema = z69.object({
+      title: z69.string().trim().min(1).max(SDK_WORKFLOW_CONFIRMATION_TITLE_MAX_LENGTH),
+      body: z69.string().trim().min(1).max(SDK_WORKFLOW_CONFIRMATION_BODY_MAX_LENGTH).optional()
     }).strict();
-    sdkWorkflowConfigSchema = z68.object({
+    sdkWorkflowConfigSchema = z69.object({
       id: sdkWorkflowIdSchema,
-      title: z68.string().trim().min(1).max(SDK_WORKFLOW_TITLE_MAX_LENGTH),
-      description: z68.string().trim().min(1).max(SDK_WORKFLOW_DESCRIPTION_MAX_LENGTH).optional(),
-      contentType: z68.string().trim().min(1).max(SDK_WORKFLOW_CONTENT_TYPE_MAX_LENGTH),
+      title: z69.string().trim().min(1).max(SDK_WORKFLOW_TITLE_MAX_LENGTH),
+      description: z69.string().trim().min(1).max(SDK_WORKFLOW_DESCRIPTION_MAX_LENGTH).optional(),
+      contentType: z69.string().trim().min(1).max(SDK_WORKFLOW_CONTENT_TYPE_MAX_LENGTH),
       endpoint: sdkWorkflowEndpointSchema,
-      triggers: z68.array(sdkWorkflowTriggerSchema).min(1).max(SDK_WORKFLOW_TRIGGER_MAX_COUNT),
+      triggers: z69.array(sdkWorkflowTriggerSchema).min(1).max(SDK_WORKFLOW_TRIGGER_MAX_COUNT),
       confirmation: sdkWorkflowConfirmationSchema.optional()
     }).strict();
-    sdkWorkflowsSchema = z68.array(sdkWorkflowConfigSchema).max(SDK_WORKFLOW_MAX_COUNT, "Maximum 50 workflows per site").refine((workflows) => {
+    sdkWorkflowsSchema = z69.array(sdkWorkflowConfigSchema).max(SDK_WORKFLOW_MAX_COUNT, "Maximum 50 workflows per site").refine((workflows) => {
       const ids = workflows.map((workflow) => workflow.id);
       return ids.length === new Set(ids).size;
     }, { message: "Workflow IDs must be unique" }).optional();
-    riverbankSiteConfigInputSchema = z68.object({
-      siteId: z68.string().uuid(),
-      previewUrl: z68.string().url().optional(),
-      liveUrl: z68.string().url().optional(),
+    riverbankSiteConfigInputSchema = z69.object({
+      siteId: z69.string().uuid(),
+      previewUrl: z69.string().url().optional(),
+      liveUrl: z69.string().url().optional(),
       theme: sdkThemeConfigSchema.optional(),
       styles: sdkSiteStyleConfigSchema.optional(),
       layout: sdkSiteLayoutConfigSchema.optional(),
-      customBlocks: z68.array(sdkCustomBlockInputSchema).max(100, "Maximum 100 custom blocks per site").refine((blocks) => {
+      customBlocks: z69.array(sdkCustomBlockInputSchema).max(100, "Maximum 100 custom blocks per site").refine((blocks) => {
         const ids = blocks.map((b) => b.id);
         return ids.length === new Set(ids).size;
       }, { message: "Block IDs must be unique" }).optional(),
@@ -44539,22 +44855,22 @@ var init_contracts2 = __esm({
       blockFieldExtensions: sdkBlockFieldExtensionsInputSchema.optional(),
       workflows: sdkWorkflowsSchema,
       content: sdkContentConfigSchema.optional(),
-      contentDir: z68.string().optional(),
-      sync: z68.object({
-        existingEntries: z68.enum(["skip", "update"]).optional()
+      contentDir: z69.string().optional(),
+      sync: z69.object({
+        existingEntries: z69.enum(["skip", "update"]).optional()
       }).optional(),
-      deploy: z68.object({
-        verifyCommand: z68.string().optional(),
-        prebuildOutput: z68.string().optional()
+      deploy: z69.object({
+        verifyCommand: z69.string().optional(),
+        prebuildOutput: z69.string().optional()
       }).optional(),
-      themeSource: z68.enum(["local", "cms"]).optional(),
-      activeTheme: z68.string().optional(),
-      enablePortal: z68.boolean().optional(),
+      themeSource: z69.enum(["local", "cms"]).optional(),
+      activeTheme: z69.string().optional(),
+      enablePortal: z69.boolean().optional(),
       dashboard: dashboardConfigSchema.optional()
     }).strict();
-    pushSdkConfigBodySchema = z68.object({
+    pushSdkConfigBodySchema = z69.object({
       config: riverbankSiteConfigInputSchema,
-      forceContentTypes: z68.boolean().optional()
+      forceContentTypes: z69.boolean().optional()
     }).strict();
   }
 });
@@ -44573,8 +44889,15 @@ var init_incrementalJson = __esm({
   }
 });
 
+// ../api/src/mailchimpIntegration.ts
+var init_mailchimpIntegration = __esm({
+  "../api/src/mailchimpIntegration.ts"() {
+    "use strict";
+  }
+});
+
 // ../api/src/siteOnboarding.ts
-import { z as z69 } from "zod";
+import { z as z70 } from "zod";
 var LAUNCH_REQUIREMENT_OVERRIDE_DEFINITIONS, acknowledgeLaunchRequirementRequestSchema, goLiveSiteRequestSchema;
 var init_siteOnboarding = __esm({
   "../api/src/siteOnboarding.ts"() {
@@ -44585,24 +44908,24 @@ var init_siteOnboarding = __esm({
         reason: "launch_anyway"
       }
     };
-    acknowledgeLaunchRequirementRequestSchema = z69.discriminatedUnion(
+    acknowledgeLaunchRequirementRequestSchema = z70.discriminatedUnion(
       "requirementId",
       [
-        z69.object({
-          requirementId: z69.literal("review_generated_site")
+        z70.object({
+          requirementId: z70.literal("review_generated_site")
         }),
-        z69.object({
-          requirementId: z69.literal(
+        z70.object({
+          requirementId: z70.literal(
             LAUNCH_REQUIREMENT_OVERRIDE_DEFINITIONS.configure_appointments.requirementId
           ),
-          overrideReason: z69.literal(
+          overrideReason: z70.literal(
             LAUNCH_REQUIREMENT_OVERRIDE_DEFINITIONS.configure_appointments.reason
           )
         })
       ]
     );
-    goLiveSiteRequestSchema = z69.object({
-      acceptExtraSiteCharge: z69.boolean().optional()
+    goLiveSiteRequestSchema = z70.object({
+      acceptExtraSiteCharge: z70.boolean().optional()
     });
   }
 });
@@ -44756,7 +45079,7 @@ var init_bookingRefundOutcomes = __esm({
 });
 
 // ../api/src/bookingVerticals.ts
-import { z as z70 } from "zod";
+import { z as z71 } from "zod";
 function parseVerticalId(value) {
   return typeof value === "string" && VERTICAL_ID_SET.has(value) ? value : null;
 }
@@ -44937,39 +45260,39 @@ var init_bookingVerticals = __esm({
     VERTICAL_PRESET_ID_SET = new Set(
       VERTICAL_BOOKING_PRESETS.map((presetDefinition) => presetDefinition.id)
     );
-    VerticalIdSchema = z70.string().trim().transform((value, ctx) => {
+    VerticalIdSchema = z71.string().trim().transform((value, ctx) => {
       const parsed = parseVerticalId(value);
       if (!parsed) {
         ctx.addIssue({
-          code: z70.ZodIssueCode.custom,
+          code: z71.ZodIssueCode.custom,
           message: "Unknown booking vertical"
         });
-        return z70.NEVER;
+        return z71.NEVER;
       }
       return parsed;
     });
-    VerticalPresetIdSchema = z70.string().trim().transform((value, ctx) => {
+    VerticalPresetIdSchema = z71.string().trim().transform((value, ctx) => {
       const parsed = parseVerticalPresetId(value);
       if (!parsed) {
         ctx.addIssue({
-          code: z70.ZodIssueCode.custom,
+          code: z71.ZodIssueCode.custom,
           message: "Unknown booking preset"
         });
-        return z70.NEVER;
+        return z71.NEVER;
       }
       return parsed;
     });
-    BookingVerticalConfigSchema = z70.object({
+    BookingVerticalConfigSchema = z71.object({
       verticalId: VerticalIdSchema.nullable(),
-      selectedPresetIds: z70.array(VerticalPresetIdSchema).max(20)
+      selectedPresetIds: z71.array(VerticalPresetIdSchema).max(20)
     }).transform((value, ctx) => {
       const resolved = resolveSiteVerticalBookingConfig(value);
       if (resolved.kind === "invalid") {
         ctx.addIssue({
-          code: z70.ZodIssueCode.custom,
+          code: z71.ZodIssueCode.custom,
           message: `Invalid booking vertical config: ${resolved.issues.join(", ")}`
         });
-        return z70.NEVER;
+        return z71.NEVER;
       }
       return resolved.config;
     });
@@ -44988,7 +45311,7 @@ var init_event_destination_policy = __esm({
 });
 
 // ../api/src/utils/isRecord.ts
-function isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var init_isRecord = __esm({
@@ -45007,7 +45330,7 @@ var init_error_propagation = __esm({
 });
 
 // ../api/src/appointmentSetup.ts
-import { z as z71 } from "zod";
+import { z as z72 } from "zod";
 var APPOINTMENT_SETUP_MAX_MINUTES, appointmentSetupRefSchema, appointmentSetupVenueChoiceSchema, appointmentSetupPaymentDraftSchema, appointmentSetupServiceAssignmentDraftSchema, appointmentSetupServiceDraftSchema, appointmentSetupPractitionerDraftSchema, appointmentSetupWeeklyWindowDraftSchema, appointmentSetupStartTimePolicyDraftSchema, appointmentSetupAvailabilityDraftSchema, APPOINTMENT_DEFAULT_MIN_LEAD_MINUTES_MAX, APPOINTMENT_DEFAULT_MAX_BOOKING_NOTICE_MINUTES_MAX, appointmentSetupBookingNoticeSchema, applyAppointmentSetupRequestSchema;
 var init_appointmentSetup = __esm({
   "../api/src/appointmentSetup.ts"() {
@@ -45015,49 +45338,49 @@ var init_appointmentSetup = __esm({
     init_envelope();
     init_error_propagation();
     APPOINTMENT_SETUP_MAX_MINUTES = 1440;
-    appointmentSetupRefSchema = z71.discriminatedUnion("kind", [
-      z71.object({ kind: z71.literal("existing"), id: z71.string().min(1) }),
-      z71.object({ kind: z71.literal("new"), draftId: z71.string().min(1) })
+    appointmentSetupRefSchema = z72.discriminatedUnion("kind", [
+      z72.object({ kind: z72.literal("existing"), id: z72.string().min(1) }),
+      z72.object({ kind: z72.literal("new"), draftId: z72.string().min(1) })
     ]);
-    appointmentSetupVenueChoiceSchema = z71.discriminatedUnion("kind", [
-      z71.object({ kind: z71.literal("none") }),
-      z71.object({ kind: z71.literal("existing"), venueId: z71.string().min(1) }),
-      z71.object({
-        kind: z71.literal("create"),
-        draftId: z71.string().min(1),
-        title: z71.string().trim().min(1),
-        description: z71.string().nullable(),
-        timezone: z71.string().trim().min(1).nullable(),
-        addressJson: z71.record(z71.string(), z71.unknown()),
-        locationJson: z71.object({ lat: z71.number(), lng: z71.number() }).nullable()
+    appointmentSetupVenueChoiceSchema = z72.discriminatedUnion("kind", [
+      z72.object({ kind: z72.literal("none") }),
+      z72.object({ kind: z72.literal("existing"), venueId: z72.string().min(1) }),
+      z72.object({
+        kind: z72.literal("create"),
+        draftId: z72.string().min(1),
+        title: z72.string().trim().min(1),
+        description: z72.string().nullable(),
+        timezone: z72.string().trim().min(1).nullable(),
+        addressJson: z72.record(z72.string(), z72.unknown()),
+        locationJson: z72.object({ lat: z72.number(), lng: z72.number() }).nullable()
       })
     ]);
-    appointmentSetupPaymentDraftSchema = z71.object({
-      priceType: z71.union([z71.literal("free"), z71.literal("paid")])
-    });
-    appointmentSetupServiceAssignmentDraftSchema = z71.discriminatedUnion("kind", [
-      z71.object({ kind: z71.literal("all_practitioners") }),
-      z71.object({
-        kind: z71.literal("selected_practitioners"),
-        resourceRefs: z71.array(appointmentSetupRefSchema)
+    appointmentSetupPaymentDraftSchema = z72.object({
+      priceType: z72.union([z72.literal("free"), z72.literal("paid")])
+    });
+    appointmentSetupServiceAssignmentDraftSchema = z72.discriminatedUnion("kind", [
+      z72.object({ kind: z72.literal("all_practitioners") }),
+      z72.object({
+        kind: z72.literal("selected_practitioners"),
+        resourceRefs: z72.array(appointmentSetupRefSchema)
       })
     ]);
-    appointmentSetupServiceDraftSchema = z71.object({
+    appointmentSetupServiceDraftSchema = z72.object({
       ref: appointmentSetupRefSchema,
-      title: z71.string().trim().min(1),
-      description: z71.string().nullable(),
-      durationMinutes: z71.number().int().positive().max(APPOINTMENT_SETUP_MAX_MINUTES),
-      prepMinutes: z71.number().int().nonnegative().max(APPOINTMENT_SETUP_MAX_MINUTES).default(0),
-      cleanupMinutes: z71.number().int().nonnegative().max(APPOINTMENT_SETUP_MAX_MINUTES).default(0),
-      priceAmount: z71.number().int().nonnegative().nullable(),
-      isActive: z71.boolean(),
-      locationType: z71.union([
-        z71.literal("virtual"),
-        z71.literal("in_person"),
-        z71.literal("hybrid")
+      title: z72.string().trim().min(1),
+      description: z72.string().nullable(),
+      durationMinutes: z72.number().int().positive().max(APPOINTMENT_SETUP_MAX_MINUTES),
+      prepMinutes: z72.number().int().nonnegative().max(APPOINTMENT_SETUP_MAX_MINUTES).default(0),
+      cleanupMinutes: z72.number().int().nonnegative().max(APPOINTMENT_SETUP_MAX_MINUTES).default(0),
+      priceAmount: z72.number().int().nonnegative().nullable(),
+      isActive: z72.boolean(),
+      locationType: z72.union([
+        z72.literal("virtual"),
+        z72.literal("in_person"),
+        z72.literal("hybrid")
       ]),
       venue: appointmentSetupVenueChoiceSchema,
-      timezone: z71.string().trim().min(1).nullable(),
+      timezone: z72.string().trim().min(1).nullable(),
       payment: appointmentSetupPaymentDraftSchema,
       assignment: appointmentSetupServiceAssignmentDraftSchema
     }).superRefine((service, ctx) => {
@@ -45076,49 +45399,49 @@ var init_appointmentSetup = __esm({
         });
       }
     });
-    appointmentSetupPractitionerDraftSchema = z71.object({
+    appointmentSetupPractitionerDraftSchema = z72.object({
       ref: appointmentSetupRefSchema,
-      displayName: z71.string().trim().min(1),
-      bio: z71.string().nullable(),
-      timezone: z71.string().trim().min(1),
-      colorHex: z71.string().nullable()
-    });
-    appointmentSetupWeeklyWindowDraftSchema = z71.object({
-      weekday: z71.number().int().min(0).max(6),
-      startTime: z71.string(),
-      endTime: z71.string()
-    });
-    appointmentSetupStartTimePolicyDraftSchema = z71.discriminatedUnion("kind", [
-      z71.object({ kind: z71.literal("automatic_spacing") }),
-      z71.object({
-        kind: z71.literal("regular_interval"),
-        intervalMinutes: z71.union([
-          z71.literal(10),
-          z71.literal(15),
-          z71.literal(20),
-          z71.literal(30),
-          z71.literal(45),
-          z71.literal(60)
+      displayName: z72.string().trim().min(1),
+      bio: z72.string().nullable(),
+      timezone: z72.string().trim().min(1),
+      colorHex: z72.string().nullable()
+    });
+    appointmentSetupWeeklyWindowDraftSchema = z72.object({
+      weekday: z72.number().int().min(0).max(6),
+      startTime: z72.string(),
+      endTime: z72.string()
+    });
+    appointmentSetupStartTimePolicyDraftSchema = z72.discriminatedUnion("kind", [
+      z72.object({ kind: z72.literal("automatic_spacing") }),
+      z72.object({
+        kind: z72.literal("regular_interval"),
+        intervalMinutes: z72.union([
+          z72.literal(10),
+          z72.literal(15),
+          z72.literal(20),
+          z72.literal(30),
+          z72.literal(45),
+          z72.literal(60)
         ])
       })
     ]);
-    appointmentSetupAvailabilityDraftSchema = z71.object({
-      kind: z71.literal("weekly_windows"),
+    appointmentSetupAvailabilityDraftSchema = z72.object({
+      kind: z72.literal("weekly_windows"),
       resourceRef: appointmentSetupRefSchema,
       serviceRef: appointmentSetupRefSchema.nullable(),
-      windows: z71.array(appointmentSetupWeeklyWindowDraftSchema),
+      windows: z72.array(appointmentSetupWeeklyWindowDraftSchema),
       startTimePolicy: appointmentSetupStartTimePolicyDraftSchema.optional()
     });
     APPOINTMENT_DEFAULT_MIN_LEAD_MINUTES_MAX = 28 * 24 * 60;
     APPOINTMENT_DEFAULT_MAX_BOOKING_NOTICE_MINUTES_MAX = 10 * 365 * 24 * 60;
-    appointmentSetupBookingNoticeSchema = z71.object({
-      minLeadMinutes: z71.number().int().nonnegative().max(APPOINTMENT_DEFAULT_MIN_LEAD_MINUTES_MAX),
-      maxBookingNoticeMinutes: z71.number().int().nonnegative().max(APPOINTMENT_DEFAULT_MAX_BOOKING_NOTICE_MINUTES_MAX)
-    });
-    applyAppointmentSetupRequestSchema = z71.object({
-      services: z71.array(appointmentSetupServiceDraftSchema),
-      practitioners: z71.array(appointmentSetupPractitionerDraftSchema),
-      availability: z71.array(appointmentSetupAvailabilityDraftSchema),
+    appointmentSetupBookingNoticeSchema = z72.object({
+      minLeadMinutes: z72.number().int().nonnegative().max(APPOINTMENT_DEFAULT_MIN_LEAD_MINUTES_MAX),
+      maxBookingNoticeMinutes: z72.number().int().nonnegative().max(APPOINTMENT_DEFAULT_MAX_BOOKING_NOTICE_MINUTES_MAX)
+    });
+    applyAppointmentSetupRequestSchema = z72.object({
+      services: z72.array(appointmentSetupServiceDraftSchema),
+      practitioners: z72.array(appointmentSetupPractitionerDraftSchema),
+      availability: z72.array(appointmentSetupAvailabilityDraftSchema),
       bookingNotice: appointmentSetupBookingNoticeSchema
     });
   }
@@ -45233,7 +45556,7 @@ var init_eventAttendanceLabels = __esm({
 });
 
 // ../api/src/siteBanner.ts
-import { z as z72 } from "zod";
+import { z as z73 } from "zod";
 function analyzeSiteBannerBody(body) {
   const sanitizedBody = sanitizeSiteBannerBodyInternal(body, { limitParagraphs: false });
   const paragraphs = collectParagraphs(sanitizedBody);
@@ -45352,7 +45675,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" && isRecord8(mark.attrs) && typeof mark.attrs.href === "string") {
+    if (mark.type === "link" && isRecord9(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;
@@ -45367,10 +45690,10 @@ function sanitizeMarks(marks) {
   return sanitized.length > 0 ? sanitized : void 0;
 }
 function unwrapRichTextValue(value) {
-  if (isRecord8(value) && isRecord8(value.doc)) {
+  if (isRecord9(value) && isRecord9(value.doc)) {
     return unwrapRichTextValue(value.doc);
   }
-  if (isRecord8(value) && value.type === "doc") {
+  if (isRecord9(value) && value.type === "doc") {
     return {
       type: "doc",
       content: Array.isArray(value.content) ? value.content.filter(isTipTapNodeLike).map(coerceTipTapNode) : []
@@ -45379,7 +45702,7 @@ function unwrapRichTextValue(value) {
   return EMPTY_SITE_BANNER_BODY;
 }
 function isTipTapNodeLike(value) {
-  return isRecord8(value) && typeof value.type === "string";
+  return isRecord9(value) && typeof value.type === "string";
 }
 function coerceTipTapNode(value) {
   return {
@@ -45387,9 +45710,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) => isRecord8(mark) && typeof mark.type === "string").map((mark) => ({
+      marks: value.marks.filter((mark) => isRecord9(mark) && typeof mark.type === "string").map((mark) => ({
         type: mark.type,
-        ...isRecord8(mark.attrs) ? { attrs: mark.attrs } : {}
+        ...isRecord9(mark.attrs) ? { attrs: mark.attrs } : {}
       }))
     } : {}
   };
@@ -45416,19 +45739,19 @@ var init_siteBanner = __esm({
     SITE_BANNER_TONE_VALUES = ["announcement", "promotion", "notice", "warning"];
     SITE_BANNER_MAX_TEXT_LENGTH = 320;
     SITE_BANNER_MAX_PARAGRAPHS = 2;
-    siteBannerScopeSchema = z72.enum(SITE_BANNER_SCOPE_VALUES);
-    siteBannerToneSchema = z72.enum(SITE_BANNER_TONE_VALUES);
-    siteBannerBodySchema = z72.unknown().transform(unwrapRichTextValue);
-    siteBannerCtaSchema = z72.object({
-      label: z72.string().trim().min(1),
+    siteBannerScopeSchema = z73.enum(SITE_BANNER_SCOPE_VALUES);
+    siteBannerToneSchema = z73.enum(SITE_BANNER_TONE_VALUES);
+    siteBannerBodySchema = z73.unknown().transform(unwrapRichTextValue);
+    siteBannerCtaSchema = z73.object({
+      label: z73.string().trim().min(1),
       link: linkPayloadSchema
     });
-    siteBannerSettingsSchema = z72.discriminatedUnion("enabled", [
-      z72.object({
-        enabled: z72.literal(false)
+    siteBannerSettingsSchema = z73.discriminatedUnion("enabled", [
+      z73.object({
+        enabled: z73.literal(false)
       }),
-      z72.object({
-        enabled: z72.literal(true),
+      z73.object({
+        enabled: z73.literal(true),
         scope: siteBannerScopeSchema,
         tone: siteBannerToneSchema,
         body: siteBannerBodySchema,
@@ -45442,7 +45765,7 @@ var init_siteBanner = __esm({
       const analysis = analyzeSiteBannerBody(value.body);
       for (const issue of analysis.issues) {
         ctx.addIssue({
-          code: z72.ZodIssueCode.custom,
+          code: z73.ZodIssueCode.custom,
           path: ["body"],
           message: siteBannerBodyIssueMessage(issue)
         });
@@ -45832,75 +46155,75 @@ var init_aiPatch = __esm({
 });
 
 // ../api/src/aiPlayground.ts
-import { z as z73 } from "zod";
+import { z as z74 } from "zod";
 var Rfc6902PatchOp, PlaygroundProposeRequest, MultiPagePatchEnvelope, MultiPageUpdateResponse;
 var init_aiPlayground = __esm({
   "../api/src/aiPlayground.ts"() {
     "use strict";
-    Rfc6902PatchOp = z73.discriminatedUnion("op", [
+    Rfc6902PatchOp = z74.discriminatedUnion("op", [
       // Standard RFC-6902 operations
-      z73.object({
-        op: z73.literal("add"),
-        path: z73.string(),
-        value: z73.unknown()
+      z74.object({
+        op: z74.literal("add"),
+        path: z74.string(),
+        value: z74.unknown()
       }),
-      z73.object({
-        op: z73.literal("remove"),
-        path: z73.string()
+      z74.object({
+        op: z74.literal("remove"),
+        path: z74.string()
       }),
-      z73.object({
-        op: z73.literal("replace"),
-        path: z73.string(),
-        value: z73.unknown()
+      z74.object({
+        op: z74.literal("replace"),
+        path: z74.string(),
+        value: z74.unknown()
       }),
-      z73.object({
-        op: z73.literal("move"),
-        from: z73.string(),
-        path: z73.string()
+      z74.object({
+        op: z74.literal("move"),
+        from: z74.string(),
+        path: z74.string()
       }),
-      z73.object({
-        op: z73.literal("copy"),
-        from: z73.string(),
-        path: z73.string()
+      z74.object({
+        op: z74.literal("copy"),
+        from: z74.string(),
+        path: z74.string()
       }),
       // Block-level operations (Phase 2)
-      z73.object({
-        op: z73.literal("add_block"),
-        blockKind: z73.string(),
-        afterBlockId: z73.string().nullable(),
-        content: z73.record(z73.string(), z73.unknown()),
-        rationale: z73.string()
+      z74.object({
+        op: z74.literal("add_block"),
+        blockKind: z74.string(),
+        afterBlockId: z74.string().nullable(),
+        content: z74.record(z74.string(), z74.unknown()),
+        rationale: z74.string()
       }),
-      z73.object({
-        op: z73.literal("delete_block"),
-        blockId: z73.string(),
-        rationale: z73.string()
+      z74.object({
+        op: z74.literal("delete_block"),
+        blockId: z74.string(),
+        rationale: z74.string()
       }),
-      z73.object({
-        op: z73.literal("reorder_block"),
-        blockId: z73.string(),
-        afterBlockId: z73.string().nullable(),
-        rationale: z73.string()
+      z74.object({
+        op: z74.literal("reorder_block"),
+        blockId: z74.string(),
+        afterBlockId: z74.string().nullable(),
+        rationale: z74.string()
       })
     ]);
-    PlaygroundProposeRequest = z73.object({
-      request: z73.string().min(1).max(2e3)
+    PlaygroundProposeRequest = z74.object({
+      request: z74.string().min(1).max(2e3)
     });
-    MultiPagePatchEnvelope = z73.object({
-      pageId: z73.string(),
-      blockId: z73.string().optional(),
+    MultiPagePatchEnvelope = z74.object({
+      pageId: z74.string(),
+      blockId: z74.string().optional(),
       // Not present for page-level ops
-      blockKind: z73.string().optional(),
-      blockPurpose: z73.string().optional().nullable(),
-      ops: z73.array(Rfc6902PatchOp),
-      rationale: z73.string(),
-      currentContent: z73.record(z73.string(), z73.unknown()).optional()
+      blockKind: z74.string().optional(),
+      blockPurpose: z74.string().optional().nullable(),
+      ops: z74.array(Rfc6902PatchOp),
+      rationale: z74.string(),
+      currentContent: z74.record(z74.string(), z74.unknown()).optional()
     });
-    MultiPageUpdateResponse = z73.object({
-      patches: z73.array(MultiPagePatchEnvelope),
-      assistantMessage: z73.string(),
-      pagesModified: z73.number(),
-      toolCallsUsed: z73.number()
+    MultiPageUpdateResponse = z74.object({
+      patches: z74.array(MultiPagePatchEnvelope),
+      assistantMessage: z74.string(),
+      pagesModified: z74.number(),
+      toolCallsUsed: z74.number()
     });
   }
 });
@@ -45971,6 +46294,7 @@ var init_src5 = __esm({
     init_contracts2();
     init_sdkContracts();
     init_incrementalJson();
+    init_mailchimpIntegration();
     init_launchReadiness();
     init_url();
     init_envelope();
@@ -46039,9 +46363,9 @@ var init_src5 = __esm({
 
 // src/data/prefetchBlockData.ts
 function isSupportedLoaderEndpoint2(endpoint) {
-  return SUPPORTED_LOADER_ENDPOINTS2.includes(endpoint);
+  return SUPPORTED_LOADER_ENDPOINTS.includes(endpoint);
 }
-function isRecord9(value) {
+function isRecord10(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function extractManualEntryRef(item) {
@@ -46049,7 +46373,7 @@ function extractManualEntryRef(item) {
     const trimmed = item.trim();
     return trimmed.length > 0 ? trimmed : null;
   }
-  if (!isRecord9(item)) return null;
+  if (!isRecord10(item)) return null;
   for (const key of ENTRY_REF_KEYS) {
     const raw = item[key];
     if (typeof raw === "string" && raw.trim().length > 0) {
@@ -46097,6 +46421,180 @@ function parseManualEntryRefs(...values) {
   }
   return void 0;
 }
+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(
@@ -46106,189 +46604,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 }) => {
@@ -46315,26 +46635,12 @@ async function prefetchBlockData2(page, context, client, options) {
     }
   });
 }
-var SUPPORTED_LOADER_ENDPOINTS2, ENTRY_REF_KEYS;
+var ENTRY_REF_KEYS, loaderAdapters;
 var init_prefetchBlockData2 = __esm({
   "src/data/prefetchBlockData.ts"() {
     "use strict";
     init_src5();
     init_data();
-    init_data();
-    SUPPORTED_LOADER_ENDPOINTS2 = [
-      "listPublishedEntries",
-      "getPublishedEntryPreview",
-      "listPublicEvents",
-      "listPublicCourses",
-      "listPublicTeamMembers",
-      "listPublicProducts",
-      "listPublicPasses",
-      "listPublicMemberships",
-      "getPublicFormById",
-      "getPublicBookingServices",
-      "getPublicEventDetails"
-    ];
     ENTRY_REF_KEYS = [
       "identifier",
       "entryIdentifier",
@@ -46342,6 +46648,20 @@ var init_prefetchBlockData2 = __esm({
       "entryId",
       "slug"
     ];
+    loaderAdapters = {
+      listPublishedEntries: listPublishedEntries2,
+      getPublishedEntryPreview,
+      listPublicEvents,
+      getPublicEventDetails,
+      listPublicCourses,
+      listPublicRouteCandidates,
+      listPublicTeamMembers,
+      listPublicProducts,
+      listPublicPasses,
+      listPublicMemberships,
+      getPublicFormById,
+      getPublicBookingServices
+    };
   }
 });
 
@@ -46415,6 +46735,83 @@ var init_siteCustomBlocks = __esm({
   }
 });
 
+// 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 (!isRecord11(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 isRecord11(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readContentRecord(value) {
+  return isRecord11(value) ? value : void 0;
+}
+function readNestedContentRecord(value) {
+  if (!isRecord11(value)) return null;
+  return readContentRecord(value.data) ?? null;
+}
+function sanitizeSdkRuntimeBlockContent(blockKind, content) {
+  if (blockKind !== "block.newsletter-signup") return content;
+  const sanitized = sanitizeNewsletterSignupPublicContent(content);
+  return isRecord11(sanitized) ? sanitized : {};
+}
+function sanitizeNullableSdkRuntimeBlockContent(blockKind, content) {
+  return content ? sanitizeSdkRuntimeBlockContent(blockKind, content) : null;
+}
+var init_pageRuntimeSupport = __esm({
+  "src/rendering/helpers/pageRuntimeSupport.ts"() {
+    "use strict";
+    init_newsletter_signup();
+    init_siteCustomBlocks();
+  }
+});
+
 // src/rendering/helpers/loadPage.ts
 var loadPage_exports = {};
 __export(loadPage_exports, {
@@ -46426,45 +46823,23 @@ async function loadPage(params) {
     client.getSite({ id: siteId, ...forceSite ? { force: true } : {} }),
     client.getPage({ siteId, path, preview })
   ]);
-  const customBlocks = resolveSiteCustomBlocks(site);
   if ("entry" in pageResponse) {
     throw new Error(
       "This path resolves to a content entry, not a page. Use loadContent() instead, which handles both pages and entries. For entries, loadContent() returns the raw entry data for custom rendering."
     );
   }
   const { page: pageData } = pageResponse;
-  const mediaAssets = Array.isArray(pageResponse.mediaAssets) && pageResponse.mediaAssets.length > 0 ? toMediaAssetSidecar(pageResponse.mediaAssets) : void 0;
-  const blocks = pageData.blocks.map((block) => {
-    if (!block || typeof block !== "object") {
-      throw new Error("Invalid block format in API response");
-    }
-    if (typeof block.id !== "string" && block.id !== null) {
-      throw new Error(`Invalid block id: expected string or null, got ${typeof block.id}`);
-    }
-    if (typeof block.kind !== "string") {
-      throw new Error(`Invalid block kind: expected string, got ${typeof block.kind}`);
-    }
-    if (typeof block.purpose !== "string") {
-      throw new Error(`Invalid block purpose: expected string, got ${typeof block.purpose}`);
-    }
-    const typedBlock = block;
-    return {
-      id: typedBlock.id,
-      kind: typedBlock.kind,
-      purpose: typedBlock.purpose,
-      // Include content for PageRenderer's getRenderableContent()
-      content: typedBlock.content ?? {},
-      // Include draftContent if available (for preview mode)
-      draftContent: typedBlock.draftContent?.data ?? null
-    };
-  });
-  const canonicalPagePath = pageData.path ?? path;
-  const pageOutline = {
+  const support = buildSiteRenderSupport(
+    site,
+    collectMediaAssetSidecar(pageResponse.mediaAssets)
+  );
+  const pageOutline = buildPageOutline({
     name: pageData.name,
-    path: canonicalPagePath,
+    path: pageData.path,
+    fallbackPath: path,
     purpose: pageData.purpose,
-    blocks
-  };
+    blocks: pageData.blocks
+  });
   const prefetchContext = {
     siteId,
     pageId: pageId ?? pageData.id,
@@ -46477,7 +46852,7 @@ async function loadPage(params) {
     client,
     {
       // Pass custom blocks so their config-based loaders are discovered
-      customBlocks
+      customBlocks: support.customBlocks
     }
   );
   let resolvedData = configData;
@@ -46487,28 +46862,26 @@ async function loadPage(params) {
   }
   return {
     page: pageOutline,
-    theme: site.theme,
-    sdkConfig: site.sdkConfig ?? null,
+    theme: support.theme,
+    sdkConfig: support.sdkConfig,
     siteId,
     resolvedData,
-    supabaseUrl: site.supabaseUrl,
-    ...mediaAssets ? { mediaAssets } : {},
-    ...customBlocks ? { customBlocks } : {},
+    bookingOfferingPresets: support.bookingOfferingPresets,
+    supabaseUrl: support.supabaseUrl,
+    ...support.mediaAssets ? { mediaAssets: support.mediaAssets } : {},
+    ...support.customBlocks ? { customBlocks: support.customBlocks } : {},
     // Maps for CTA link resolution (e.g., { kind: 'page', identifier: 'about' })
-    routeMap: site.routes,
-    pagesByIdentifier: site.pagesByIdentifier,
-    entriesByIdentifier: site.entriesByIdentifier
+    routeMap: support.routeMap,
+    pagesByIdentifier: support.pagesByIdentifier,
+    entriesByIdentifier: support.entriesByIdentifier
   };
 }
-function toMediaAssetSidecar(mediaAssets) {
-  return mediaAssets ?? [];
-}
 var init_loadPage = __esm({
   "src/rendering/helpers/loadPage.ts"() {
     "use strict";
     init_prefetchBlockData2();
     init_executeCodeLoaders();
-    init_siteCustomBlocks();
+    init_pageRuntimeSupport();
   }
 });