@riverbankcms/sdk 0.96.0 → 0.98.0

package/dist/server/routing.mjs

@@ -1064,6 +1064,94 @@ var init_endpoints = __esm({
         responseKind: "json",
         errors: ["resource:not_found", "server:internal_error"]
       },
+      listAppointmentReservations: {
+        path: "/sites/{siteId}/bookings/appointment-reservations",
+        method: "GET",
+        auth: "user",
+        responseKind: "json",
+        errors: []
+      },
+      createAppointmentReservation: {
+        path: "/sites/{siteId}/bookings/appointment-reservations",
+        method: "POST",
+        auth: "user",
+        responseKind: "json",
+        errors: [
+          "validation:invalid_input",
+          "resource:not_found",
+          "resource:conflict",
+          "server:internal_error"
+        ]
+      },
+      getAppointmentReservation: {
+        path: "/sites/{siteId}/bookings/appointment-reservations/{reservationId}",
+        method: "GET",
+        auth: "user",
+        responseKind: "json",
+        errors: ["resource:not_found", "server:internal_error"]
+      },
+      updateAppointmentReservation: {
+        path: "/sites/{siteId}/bookings/appointment-reservations/{reservationId}",
+        method: "PUT",
+        auth: "user",
+        responseKind: "json",
+        errors: [
+          "validation:invalid_input",
+          "resource:not_found",
+          "resource:conflict",
+          "server:internal_error"
+        ]
+      },
+      pauseAppointmentReservation: {
+        path: "/sites/{siteId}/bookings/appointment-reservations/{reservationId}/pause",
+        method: "POST",
+        auth: "user",
+        responseKind: "json",
+        errors: ["resource:not_found", "resource:conflict", "server:internal_error"]
+      },
+      resumeAppointmentReservation: {
+        path: "/sites/{siteId}/bookings/appointment-reservations/{reservationId}/resume",
+        method: "POST",
+        auth: "user",
+        responseKind: "json",
+        errors: ["resource:not_found", "resource:conflict", "server:internal_error"]
+      },
+      endAppointmentReservation: {
+        path: "/sites/{siteId}/bookings/appointment-reservations/{reservationId}/end",
+        method: "POST",
+        auth: "user",
+        responseKind: "json",
+        errors: [
+          "validation:invalid_input",
+          "resource:not_found",
+          "resource:conflict",
+          "server:internal_error"
+        ]
+      },
+      previewAppointmentReservationRun: {
+        path: "/sites/{siteId}/bookings/appointment-reservations/{reservationId}/run-preview",
+        method: "POST",
+        auth: "user",
+        responseKind: "json",
+        errors: [
+          "validation:invalid_input",
+          "resource:not_found",
+          "resource:conflict",
+          "server:internal_error"
+        ]
+      },
+      createAppointmentReservationRun: {
+        path: "/sites/{siteId}/bookings/appointment-reservations/{reservationId}/runs",
+        method: "POST",
+        auth: "user",
+        responseKind: "json",
+        errors: [
+          "validation:invalid_input",
+          "resource:not_found",
+          "resource:conflict",
+          "server:internal_error"
+        ]
+      },
       createTeamMemberProfile: {
         path: "/sites/{siteId}/bookings/resources/{resourceId}/profile",
         method: "POST",
@@ -3520,6 +3608,18 @@ var init_endpoints = __esm({
         responseKind: "json",
         errors: ["validation:invalid_input", "server:internal_error"]
       },
+      resolveRouteDecision: {
+        path: "/sites/{siteId}/route-decision",
+        method: "GET",
+        tags: [
+          TAG_TEMPLATES.siteRoutableContent,
+          TAG_TEMPLATES.siteRedirects,
+          TAG_TEMPLATES.siteRouteOutcomes
+        ],
+        auth: "public",
+        responseKind: "json",
+        errors: ["validation:invalid_input", "server:internal_error"]
+      },
       getPageByPath: {
         path: "/sites/{siteId}/pages",
         method: "GET",
@@ -3658,6 +3758,15 @@ var init_endpoints = __esm({
         auth: "public",
         responseKind: "json"
       },
+      getPublicWeeklySlotAvailability: {
+        path: "/public/bookings/weekly-slot-availability",
+        method: "GET",
+        revalidate: 60,
+        tags: ["site-{siteId}"],
+        auth: "public",
+        responseKind: "json",
+        errors: []
+      },
       createPublicBookingAppointment: {
         path: "/public/bookings/appointments",
         method: "POST",
@@ -7835,7 +7944,7 @@ var init_link = __esm({
 
 // ../blocks/src/system/node/schema.ts
 import { z as z4 } from "zod";
-var transformStepSchema, bindingPathSchema, bindingSchema, repeatSchema, conditionSchema, dataScopeSchema, nodePropsSchema, nodeSchema, nodeTreeSchema, NodeSchema, NodeTreeSchema;
+var transformStepSchema, bindingPathSchema, bindingSchema, repeatSchema, conditionalAuthoringPresenceSchema, conditionSchema, dataScopeSchema, nodePropsSchema, nodeSchema, nodeTreeSchema, NodeSchema, NodeTreeSchema;
 var init_schema = __esm({
   "../blocks/src/system/node/schema.ts"() {
     "use strict";
@@ -7861,10 +7970,20 @@ var init_schema = __esm({
         direction: z4.enum(["asc", "desc"]).default("asc")
       }).optional()
     });
+    conditionalAuthoringPresenceSchema = z4.discriminatedUnion("kind", [
+      z4.object({ kind: z4.literal("visitor-only") }),
+      z4.object({
+        kind: z4.literal("recover-empty-when-active"),
+        placeholder: z4.string().min(1).optional()
+      })
+    ]);
     conditionSchema = z4.object({
       when: bindingSchema,
       equals: z4.unknown().optional(),
-      not: z4.boolean().default(false)
+      not: z4.boolean().default(false),
+      authoringPresence: conditionalAuthoringPresenceSchema.default({
+        kind: "visitor-only"
+      })
     });
     dataScopeSchema = z4.object({
       name: z4.string().min(1),
@@ -7936,6 +8055,7 @@ var init_validation_constants = __esm({
       // Forms
       "form",
       "booking-form",
+      "weekly-slot-availability",
       // Events
       "event-registration",
       "event-spotlight",
@@ -21238,7 +21358,8 @@ function when(path, options) {
     $when: {
       when: { from: path },
       ...options?.equals !== void 0 ? { equals: options.equals } : {},
-      ...options?.not ? { not: true } : {}
+      ...options?.not ? { not: true } : {},
+      ...options?.authoringPresence ? { authoringPresence: options.authoringPresence } : {}
     }
   });
 }
@@ -32276,6 +32397,189 @@ var init_appointment_booking = __esm({
   }
 });
 
+// ../blocks/src/system/blocks/weekly-slot-availability.ts
+import { z as z42 } from "zod";
+var weeklySlotAvailabilityManifest, weeklySlotAvailabilityOptionSchema, weeklySlotAvailabilityDataSchema, weeklySlotAvailabilityBlockDefinition;
+var init_weekly_slot_availability = __esm({
+  "../blocks/src/system/blocks/weekly-slot-availability.ts"() {
+    "use strict";
+    init_builder2();
+    init_builder2();
+    init_styledSection();
+    init_fragments();
+    init_boxStyles();
+    init_defineBlock();
+    init_api_bindings();
+    weeklySlotAvailabilityManifest = createBlockManifest({
+      id: "block.weekly-slot-availability",
+      version: "1.0.0",
+      title: "Weekly Slot Availability",
+      titleSource: "heading",
+      description: "Shows available recurring appointment slot patterns",
+      skipSectionStyles: true,
+      additionalFields: [
+        {
+          id: "serviceId",
+          type: "reference",
+          label: "Appointment service",
+          description: "Choose which appointment service to show availability for",
+          required: true,
+          referenceKind: "appointmentService",
+          allowManualEntry: false,
+          ui: { intent: "behavior" }
+        },
+        {
+          id: "resourceId",
+          type: "reference",
+          label: "Appointment resource",
+          description: "Optionally narrow the availability to one practitioner or room",
+          required: false,
+          referenceKind: "appointmentResource",
+          allowManualEntry: false,
+          ui: { intent: "behavior" }
+        },
+        {
+          id: "horizonWeeks",
+          type: "select",
+          label: "Look ahead",
+          required: false,
+          multiple: false,
+          defaultValue: "4",
+          options: [
+            { value: "1", label: "1 week" },
+            { value: "2", label: "2 weeks" },
+            { value: "4", label: "4 weeks" }
+          ],
+          ui: { intent: "behavior" }
+        },
+        {
+          id: "timezone",
+          type: "text",
+          label: "Timezone",
+          description: "Leave blank to use the visitor timezone when the block loads",
+          required: false,
+          multiline: false,
+          defaultValue: "",
+          maxLength: 64,
+          ui: { intent: "behavior" }
+        },
+        {
+          id: "heading",
+          type: "text",
+          label: "Heading",
+          required: false,
+          multiline: false,
+          defaultValue: "Weekly availability"
+        },
+        {
+          id: "description",
+          type: "richText",
+          label: "Description",
+          required: false
+        },
+        {
+          id: "emptyMessage",
+          type: "text",
+          label: "Empty message",
+          required: false,
+          multiline: true,
+          defaultValue: "No regular weekly openings are currently available.",
+          maxLength: 180
+        },
+        {
+          id: "ctaText",
+          type: "text",
+          label: "Enquiry button text",
+          required: false,
+          multiline: false,
+          defaultValue: "Enquire about this slot",
+          maxLength: 60
+        },
+        {
+          id: "ctaUrl",
+          type: "url",
+          label: "Enquiry URL",
+          required: false,
+          ui: { intent: "behavior" }
+        },
+        sectionStylesField({
+          id: "_sectionStyles",
+          label: "Section styles"
+        })
+      ],
+      styleTokens: { background: "surface", typography: "body", spacing: "md" },
+      behaviours: {
+        supportsThemeSwitching: true,
+        inlineEditing: false,
+        animation: false,
+        paletteHidden: false
+      },
+      category: "interactive",
+      tags: ["booking", "appointment", "calendar", "weekly", "availability"],
+      icon: "CalendarDays",
+      layout: [
+        styledSection({
+          children: sectionContainer([
+            text({ as: "h2" }, bind("content.heading"), when("content.heading")),
+            richText({}, bind("content.description"), when("content.description")),
+            el(
+              "weekly-slot-availability",
+              withApiBindings({
+                serviceId: { $bind: { from: "content.serviceId" } },
+                resourceId: { $bind: { from: "content.resourceId", fallback: null } },
+                horizonWeeks: { $bind: { from: "content.horizonWeeks", fallback: "4" } },
+                timezone: { $bind: { from: "content.timezone", fallback: null } },
+                availability: { $bind: { from: "data.availability", fallback: null } },
+                emptyMessage: { $bind: { from: "content.emptyMessage", fallback: null } },
+                ctaText: { $bind: { from: "content.ctaText", fallback: null } },
+                ctaUrl: { $bind: { from: "content.ctaUrl", fallback: null } }
+              })
+            )
+          ], {
+            gap: "lg"
+          }),
+          baseClass: "",
+          spacing: "spacious"
+        })
+      ]
+    });
+    weeklySlotAvailabilityOptionSchema = z42.object({
+      id: z42.string(),
+      resourceId: z42.string(),
+      weekday: z42.number(),
+      weekdayLabel: z42.string(),
+      startTime: z42.string(),
+      endTime: z42.string(),
+      nextDate: z42.string(),
+      availableWeeks: z42.number()
+    });
+    weeklySlotAvailabilityDataSchema = z42.object({
+      slots: z42.array(weeklySlotAvailabilityOptionSchema),
+      horizonWeeks: z42.number(),
+      timezone: z42.string(),
+      startDate: z42.string(),
+      endDate: z42.string()
+    });
+    weeklySlotAvailabilityBlockDefinition = {
+      manifest: weeklySlotAvailabilityManifest,
+      dataSchemas: { availability: weeklySlotAvailabilityDataSchema.optional() },
+      dataLoaders: {
+        availability: {
+          endpoint: "getPublicWeeklySlotAvailability",
+          params: {
+            siteId: { $bind: { from: "$root.siteId" } },
+            serviceId: { $bind: { from: "content.serviceId" } },
+            resourceId: { $bind: { from: "content.resourceId", fallback: void 0 } },
+            horizonWeeks: { $bind: { from: "content.horizonWeeks", fallback: "4" } },
+            timezone: { $bind: { from: "content.timezone", fallback: void 0 } }
+          },
+          mode: "server"
+        }
+      }
+    };
+  }
+});
+
 // ../blocks/src/system/blocks/events/shared/types.ts
 var init_types15 = __esm({
   "../blocks/src/system/blocks/events/shared/types.ts"() {
@@ -32284,7 +32588,7 @@ var init_types15 = __esm({
 });
 
 // ../blocks/src/lib/media.ts
-import z42 from "zod";
+import z43 from "zod";
 var PUBLIC_DOWNLOAD_MEDIA_TYPES, hotspotSchema2, rotationSchema2, rectSchema2, aspectCropSchema2, transformSchema2, mediaPosterSchema, mediaBaseSchema, imageMediaSchema, videoMediaSchema, audioMediaSchema, documentMediaSchema, spreadsheetMediaSchema, archiveMediaSchema, mediaSchema2;
 var init_media4 = __esm({
   "../blocks/src/lib/media.ts"() {
@@ -32295,66 +32599,66 @@ var init_media4 = __esm({
       "archive",
       "audio"
     ];
-    hotspotSchema2 = z42.object({
-      x: z42.number().min(0).max(1),
-      y: z42.number().min(0).max(1),
-      radius: z42.number().optional()
-    });
-    rotationSchema2 = z42.union([z42.literal(0), z42.literal(90), z42.literal(180), z42.literal(270)]);
-    rectSchema2 = z42.tuple([z42.number(), z42.number(), z42.number(), z42.number()]);
-    aspectCropSchema2 = z42.object({
-      aspect: z42.preprocess((value) => value == null ? void 0 : value, z42.string().optional()),
-      rect: z42.preprocess((value) => value == null ? void 0 : value, rectSchema2.optional()),
-      hotspot: z42.preprocess((value) => value == null ? void 0 : value, hotspotSchema2.optional()),
-      rotation: z42.preprocess((value) => value == null ? void 0 : value, rotationSchema2.optional())
-    });
-    transformSchema2 = z42.object({
-      aspectCrops: z42.preprocess((value) => {
+    hotspotSchema2 = z43.object({
+      x: z43.number().min(0).max(1),
+      y: z43.number().min(0).max(1),
+      radius: z43.number().optional()
+    });
+    rotationSchema2 = z43.union([z43.literal(0), z43.literal(90), z43.literal(180), z43.literal(270)]);
+    rectSchema2 = z43.tuple([z43.number(), z43.number(), z43.number(), z43.number()]);
+    aspectCropSchema2 = z43.object({
+      aspect: z43.preprocess((value) => value == null ? void 0 : value, z43.string().optional()),
+      rect: z43.preprocess((value) => value == null ? void 0 : value, rectSchema2.optional()),
+      hotspot: z43.preprocess((value) => value == null ? void 0 : value, hotspotSchema2.optional()),
+      rotation: z43.preprocess((value) => value == null ? void 0 : value, rotationSchema2.optional())
+    });
+    transformSchema2 = z43.object({
+      aspectCrops: z43.preprocess((value) => {
         if (!value || typeof value !== "object" || Array.isArray(value)) {
           return void 0;
         }
         return value;
-      }, z42.record(z42.string(), aspectCropSchema2.catch({}))).optional(),
+      }, z43.record(z43.string(), aspectCropSchema2.catch({}))).optional(),
       rect: rectSchema2.optional(),
       hotspot: hotspotSchema2.optional(),
       rotation: rotationSchema2.optional()
     });
-    mediaPosterSchema = z42.discriminatedUnion("tag", [
-      z42.object({
-        tag: z42.literal("storage"),
-        assetId: z42.string().optional(),
-        storageBucket: z42.string().min(1),
-        storagePath: z42.string().min(1)
+    mediaPosterSchema = z43.discriminatedUnion("tag", [
+      z43.object({
+        tag: z43.literal("storage"),
+        assetId: z43.string().optional(),
+        storageBucket: z43.string().min(1),
+        storagePath: z43.string().min(1)
       }),
-      z42.object({
-        tag: z42.literal("external-src"),
-        assetId: z42.string().optional(),
-        src: z42.string().url()
+      z43.object({
+        tag: z43.literal("external-src"),
+        assetId: z43.string().optional(),
+        src: z43.string().url()
       })
     ]);
-    mediaBaseSchema = z42.object({
-      purpose: z42.string().optional(),
-      placeholder: z42.boolean().default(true).optional(),
-      assetId: z42.string().optional(),
-      identifier: z42.string().optional(),
-      src: z42.string().optional(),
-      alt: z42.string().optional(),
-      filename: z42.string().optional(),
-      mimeType: z42.string().optional(),
-      width: z42.number().optional(),
-      height: z42.number().optional(),
-      storageBucket: z42.string().optional(),
-      storagePath: z42.string().optional(),
+    mediaBaseSchema = z43.object({
+      purpose: z43.string().optional(),
+      placeholder: z43.boolean().default(true).optional(),
+      assetId: z43.string().optional(),
+      identifier: z43.string().optional(),
+      src: z43.string().optional(),
+      alt: z43.string().optional(),
+      filename: z43.string().optional(),
+      mimeType: z43.string().optional(),
+      width: z43.number().optional(),
+      height: z43.number().optional(),
+      storageBucket: z43.string().optional(),
+      storagePath: z43.string().optional(),
       poster: mediaPosterSchema.optional(),
       transform: transformSchema2.optional()
     });
-    imageMediaSchema = mediaBaseSchema.extend({ type: z42.literal("image") });
-    videoMediaSchema = mediaBaseSchema.extend({ type: z42.literal("video") });
-    audioMediaSchema = mediaBaseSchema.extend({ type: z42.literal("audio") });
-    documentMediaSchema = mediaBaseSchema.extend({ type: z42.literal("document") });
-    spreadsheetMediaSchema = mediaBaseSchema.extend({ type: z42.literal("spreadsheet") });
-    archiveMediaSchema = mediaBaseSchema.extend({ type: z42.literal("archive") });
-    mediaSchema2 = z42.discriminatedUnion("type", [
+    imageMediaSchema = mediaBaseSchema.extend({ type: z43.literal("image") });
+    videoMediaSchema = mediaBaseSchema.extend({ type: z43.literal("video") });
+    audioMediaSchema = mediaBaseSchema.extend({ type: z43.literal("audio") });
+    documentMediaSchema = mediaBaseSchema.extend({ type: z43.literal("document") });
+    spreadsheetMediaSchema = mediaBaseSchema.extend({ type: z43.literal("spreadsheet") });
+    archiveMediaSchema = mediaBaseSchema.extend({ type: z43.literal("archive") });
+    mediaSchema2 = z43.discriminatedUnion("type", [
       imageMediaSchema,
       videoMediaSchema,
       audioMediaSchema,
@@ -32366,186 +32670,186 @@ var init_media4 = __esm({
 });
 
 // ../blocks/src/system/manifest/richTextSchema.ts
-import { z as z43 } from "zod";
+import { z as z44 } 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()
+    TipTapMarkSchema = z44.object({
+      type: z44.string(),
+      attrs: z44.record(z44.string(), z44.unknown()).optional()
+    });
+    TipTapNodeSchema = z44.lazy(
+      () => z44.object({
+        type: z44.string(),
+        content: z44.array(TipTapNodeSchema).optional(),
+        text: z44.string().optional(),
+        attrs: z44.record(z44.string(), z44.unknown()).optional(),
+        marks: z44.array(TipTapMarkSchema).optional()
       })
     );
-    RichTextValueSchema = z43.union([
+    RichTextValueSchema = z44.union([
       // Canonical: TipTap document directly
       TipTapNodeSchema,
       // Legacy (read-tolerance only): wrapped in { doc: {...} }
-      z43.object({
+      z44.object({
         doc: TipTapNodeSchema
       })
     ]);
-    RichTextDocSchema = z43.object({
-      type: z43.literal("doc"),
-      content: z43.array(TipTapNodeSchema)
+    RichTextDocSchema = z44.object({
+      type: z44.literal("doc"),
+      content: z44.array(TipTapNodeSchema)
     });
   }
 });
 
 // ../blocks/src/system/blocks/shared/bookingPaymentTerms.ts
-import { z as z44 } from "zod";
+import { z as z45 } from "zod";
 var bookingDepositRefundPolicySchema, bookingInstalmentPlanSchema, bookingFlexibleBalanceDueDateRuleSchema, bookingFlexibleBalanceConfigSchema, blockBookingPaymentCollectionOptionSchema, blockBookingPaymentTermsSchema;
 var init_bookingPaymentTerms = __esm({
   "../blocks/src/system/blocks/shared/bookingPaymentTerms.ts"() {
     "use strict";
-    bookingDepositRefundPolicySchema = z44.enum([
+    bookingDepositRefundPolicySchema = z45.enum([
       "refundable",
       "non_refundable"
     ]);
-    bookingInstalmentPlanSchema = z44.union([
-      z44.object({
-        kind: z44.literal("deposit_plus_one_remainder"),
-        depositAmountCents: z44.number().int().min(0),
+    bookingInstalmentPlanSchema = z45.union([
+      z45.object({
+        kind: z45.literal("deposit_plus_one_remainder"),
+        depositAmountCents: z45.number().int().min(0),
         depositRefundability: bookingDepositRefundPolicySchema,
-        remainderDueCount: z44.number().int().positive(),
-        intervalUnit: z44.enum(["day", "week", "month"])
+        remainderDueCount: z45.number().int().positive(),
+        intervalUnit: z45.enum(["day", "week", "month"])
       }),
-      z44.object({
-        kind: z44.literal("deposit_plus_scheduled_instalments"),
-        depositAmountCents: z44.number().int().min(0),
+      z45.object({
+        kind: z45.literal("deposit_plus_scheduled_instalments"),
+        depositAmountCents: z45.number().int().min(0),
         depositRefundability: bookingDepositRefundPolicySchema,
-        instalmentCount: z44.number().int().positive(),
-        intervalCount: z44.number().int().positive(),
-        intervalUnit: z44.enum(["day", "week", "month"])
+        instalmentCount: z45.number().int().positive(),
+        intervalCount: z45.number().int().positive(),
+        intervalUnit: z45.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"])
+      z45.object({
+        kind: z45.literal("equal_scheduled_instalments"),
+        instalmentCount: z45.number().int().positive(),
+        intervalCount: z45.number().int().positive(),
+        intervalUnit: z45.enum(["day", "week", "month"])
       })
     ]);
-    bookingFlexibleBalanceDueDateRuleSchema = z44.union([
-      z44.object({
-        kind: z44.literal("relative_to_start_date"),
-        daysBeforeStart: z44.number().int().positive()
+    bookingFlexibleBalanceDueDateRuleSchema = z45.union([
+      z45.object({
+        kind: z45.literal("relative_to_start_date"),
+        daysBeforeStart: z45.number().int().positive()
       }),
-      z44.object({
-        kind: z44.literal("fixed_calendar_date"),
-        dueAt: z44.string().datetime()
+      z45.object({
+        kind: z45.literal("fixed_calendar_date"),
+        dueAt: z45.string().datetime()
       })
     ]);
-    bookingFlexibleBalanceConfigSchema = z44.object({
-      upfrontAmountCents: z44.number().int().min(0),
+    bookingFlexibleBalanceConfigSchema = z45.object({
+      upfrontAmountCents: z45.number().int().min(0),
       dueDateRule: bookingFlexibleBalanceDueDateRuleSchema,
       depositRefundability: bookingDepositRefundPolicySchema
     });
-    blockBookingPaymentCollectionOptionSchema = z44.union([
-      z44.object({
-        kind: z44.literal("upfront")
+    blockBookingPaymentCollectionOptionSchema = z45.union([
+      z45.object({
+        kind: z45.literal("upfront")
       }),
-      z44.object({
-        kind: z44.literal("deferred_manual")
+      z45.object({
+        kind: z45.literal("deferred_manual")
       }),
-      z44.object({
-        kind: z44.literal("instalment_plan"),
+      z45.object({
+        kind: z45.literal("instalment_plan"),
         plan: bookingInstalmentPlanSchema
       }),
-      z44.object({
-        kind: z44.literal("flexible_balance"),
+      z45.object({
+        kind: z45.literal("flexible_balance"),
         config: bookingFlexibleBalanceConfigSchema
       })
     ]);
-    blockBookingPaymentTermsSchema = z44.object({
-      allowedOptions: z44.array(blockBookingPaymentCollectionOptionSchema).min(1)
+    blockBookingPaymentTermsSchema = z45.object({
+      allowedOptions: z45.array(blockBookingPaymentCollectionOptionSchema).min(1)
     });
   }
 });
 
 // ../blocks/src/system/blocks/courses/shared/schemas.ts
-import { z as z45 } from "zod";
+import { z as z46 } 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 = 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", "sliding_scale"]),
-      currency: z45.string(),
-      singlePriceAmount: z45.number().nullable(),
-      slidingMinAmount: z45.number().nullable().optional(),
-      slidingMaxAmount: z45.number().nullable().optional(),
-      slidingSuggestedAmount: z45.number().nullable().optional(),
+    courseVenueSchema = z46.object({
+      id: z46.string(),
+      name: z46.string(),
+      address: z46.string().nullable()
+    });
+    courseSessionSchema = z46.object({
+      id: 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()
+    });
+    courseTeamMemberSummarySchema = z46.object({
+      id: z46.string(),
+      name: z46.string(),
+      roleLabel: z46.string().nullable(),
+      summary: z46.string().nullable(),
+      profilePath: z46.string().nullable()
+    });
+    coursePricingOptionSchema = z46.object({
+      id: z46.string(),
+      name: z46.string(),
+      description: z46.string().nullable(),
+      priceAmount: z46.number(),
+      isActive: z46.boolean(),
+      sortOrder: z46.number(),
+      capacityLimit: z46.number().nullable(),
+      saleStartsAt: z46.string().nullable(),
+      saleEndsAt: z46.string().nullable(),
+      attendanceScope: z46.enum(["in_person", "online", "both"]).nullable().optional()
+    });
+    coursePricingSchema = z46.object({
+      bookingRequirement: z46.enum(["none", "required"]),
+      pricingStrategy: z46.enum(["free", "single", "tiered", "sliding_scale"]),
+      currency: z46.string(),
+      singlePriceAmount: z46.number().nullable(),
+      slidingMinAmount: z46.number().nullable().optional(),
+      slidingMaxAmount: z46.number().nullable().optional(),
+      slidingSuggestedAmount: z46.number().nullable().optional(),
       paymentTerms: blockBookingPaymentTermsSchema,
-      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(),
+      options: z46.array(coursePricingOptionSchema)
+    });
+    publicCourseSchema = z46.object({
+      id: z46.string(),
+      title: z46.string(),
+      slug: z46.string(),
+      description: z46.unknown().nullable(),
+      teamMembers: z46.array(courseTeamMemberSummarySchema).optional(),
+      enrollmentOpen: z46.boolean(),
       pricing: coursePricingSchema.optional(),
-      priceCents: z45.number().nullable(),
-      currency: z45.string(),
+      priceCents: z46.number().nullable(),
+      currency: z46.string(),
       paymentTerms: blockBookingPaymentTermsSchema,
-      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),
+      enrollmentCapacity: z46.number().nullable(),
+      acceptsMemberships: z46.boolean(),
+      status: z46.enum(["active", "draft", "cancelled"]),
+      sessionsCount: z46.number(),
+      enrolledCount: z46.number(),
+      availableSpots: z46.number().nullable(),
+      sessions: z46.array(courseSessionSchema),
       venue: courseVenueSchema.nullable(),
-      contentEntryId: z45.string().nullable()
+      contentEntryId: z46.string().nullable()
     });
-    publicCoursesArraySchema = z45.array(publicCourseSchema);
+    publicCoursesArraySchema = z46.array(publicCourseSchema);
   }
 });
 
 // ../blocks/src/system/blocks/events/shared/schemas.ts
-import { z as z46 } from "zod";
+import { z as z47 } from "zod";
 var eventPresetSchema, eventScheduleScopeSchema, eventDestinationModeSchema, publicEventDestinationSchema, 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"() {
@@ -32554,212 +32858,212 @@ var init_schemas2 = __esm({
     init_richTextSchema();
     init_bookingPaymentTerms();
     init_schemas();
-    eventPresetSchema = z46.enum(["event", "class", "workshop", "retreat", "performance"]);
-    eventScheduleScopeSchema = z46.enum(["recurring", "oneOff"]);
-    eventDestinationModeSchema = z46.enum(["cms-managed", "system-managed"]);
-    publicEventDestinationSchema = z46.discriminatedUnion("kind", [
-      z46.object({
-        kind: z46.literal("native"),
+    eventPresetSchema = z47.enum(["event", "class", "workshop", "retreat", "performance"]);
+    eventScheduleScopeSchema = z47.enum(["recurring", "oneOff"]);
+    eventDestinationModeSchema = z47.enum(["cms-managed", "system-managed"]);
+    publicEventDestinationSchema = z47.discriminatedUnion("kind", [
+      z47.object({
+        kind: z47.literal("native"),
         mode: eventDestinationModeSchema,
-        path: z46.string()
+        path: z47.string()
       }),
-      z46.object({
-        kind: z46.literal("external"),
-        url: z46.string(),
-        label: z46.string()
+      z47.object({
+        kind: z47.literal("external"),
+        url: z47.string(),
+        label: z47.string()
       })
     ]);
-    eventVenueSchema = z46.object({
-      id: z46.string(),
-      name: z46.string(),
-      address: z46.string().nullable(),
-      location: z46.object({
-        lat: z46.number(),
-        lng: z46.number()
+    eventVenueSchema = z47.object({
+      id: z47.string(),
+      name: z47.string(),
+      address: z47.string().nullable(),
+      location: z47.object({
+        lat: z47.number(),
+        lng: z47.number()
       }).nullable()
     });
-    eventCategorySchema = z46.object({
-      id: z46.string(),
-      name: z46.string(),
-      color: z46.string().nullable()
-    });
-    pricingTypeSchema = z46.enum(["free", "paid", "external"]);
-    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() })
+    eventCategorySchema = z47.object({
+      id: z47.string(),
+      name: z47.string(),
+      color: z47.string().nullable()
+    });
+    pricingTypeSchema = z47.enum(["free", "paid", "external"]);
+    accessRestrictionSchema = z47.enum(["none", "category"]);
+    eventPricingModeSchema = z47.enum(["single", "ticket_types"]);
+    publicCoursePriceDisplaySchema = z47.discriminatedUnion("kind", [
+      z47.object({ kind: z47.literal("free"), currency: z47.string() }),
+      z47.object({ kind: z47.literal("exact"), amount: z47.number(), currency: z47.string() }),
+      z47.object({ kind: z47.literal("from"), amount: z47.number(), currency: z47.string() }),
+      z47.object({ kind: z47.literal("unavailable"), currency: z47.string() })
     ]);
-    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()
+    publicEventPriceDisplaySchema = z47.discriminatedUnion("kind", [
+      z47.object({ kind: z47.literal("free"), currency: z47.string() }),
+      z47.object({ kind: z47.literal("exact"), amount: z47.number(), currency: z47.string() }),
+      z47.object({ kind: z47.literal("from"), amount: z47.number(), currency: z47.string() }),
+      z47.object({ kind: z47.literal("range"), minAmount: z47.number(), maxAmount: z47.number(), currency: z47.string() }),
+      z47.object({
+        kind: z47.literal("mixed"),
+        paidFromAmount: z47.number(),
+        paidToAmount: z47.number(),
+        currency: z47.string()
       }),
-      z46.object({ kind: z46.literal("unavailable"), currency: z46.string() }),
-      z46.object({ kind: z46.literal("external"), label: z46.string() }),
-      z46.object({ kind: z46.literal("course"), display: publicCoursePriceDisplaySchema })
+      z47.object({ kind: z47.literal("unavailable"), currency: z47.string() }),
+      z47.object({ kind: z47.literal("external"), label: z47.string() }),
+      z47.object({ kind: z47.literal("course"), display: publicCoursePriceDisplaySchema })
     ]);
-    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()
+    publicEventTicketTypePriceDisplaySchema = z47.union([
+      z47.object({ kind: z47.literal("free"), currency: z47.string() }),
+      z47.object({ kind: z47.literal("exact"), amount: z47.number(), currency: z47.string() }),
+      z47.object({ kind: z47.literal("from"), amount: z47.number(), currency: z47.string() }),
+      z47.object({ kind: z47.literal("range"), minAmount: z47.number(), maxAmount: z47.number(), currency: z47.string() }),
+      z47.object({
+        kind: z47.literal("mixed"),
+        paidFromAmount: z47.number(),
+        paidToAmount: z47.number(),
+        currency: z47.string()
       }),
-      z46.object({ kind: z46.literal("unavailable"), currency: z46.string() })
+      z47.object({ kind: z47.literal("unavailable"), currency: z47.string() })
     ]);
-    publicEventAttendanceModeSchema = z46.enum(["in_person", "online"]);
-    publicEventAttendanceModeAvailabilitySchema = z46.object({
+    publicEventAttendanceModeSchema = z47.enum(["in_person", "online"]);
+    publicEventAttendanceModeAvailabilitySchema = z47.object({
       mode: publicEventAttendanceModeSchema,
-      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()
+      capacity: z47.number().nullable(),
+      registeredCount: z47.number(),
+      availableSpots: z47.number().nullable(),
+      waitlistEnabled: z47.boolean()
+    });
+    publicEventTicketTypeAvailabilitySchema = z47.union([
+      z47.object({
+        kind: z47.literal("available"),
+        remainingCapacity: z47.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()
+      z47.object({
+        kind: z47.literal("unavailable"),
+        reason: z47.enum(["inactive", "not_on_sale_yet", "sale_ended", "sold_out", "event_sold_out"]),
+        remainingCapacity: z47.number().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(),
+    publicEventTicketTypeSchema = z47.object({
+      id: z47.string(),
+      siteId: z47.string(),
+      eventSeriesId: z47.string(),
+      name: z47.string(),
+      description: z47.string().nullable(),
+      priceAmount: z47.number(),
+      isActive: z47.boolean(),
+      sortOrder: z47.number(),
+      capacityMode: z47.enum(["limited", "unlimited"]),
+      capacityLimit: z47.number().nullable(),
+      attendanceScope: z47.enum(["in_person", "online", "both"]).optional(),
+      saleStartsAt: z47.string().nullable(),
+      saleEndsAt: z47.string().nullable(),
       availability: publicEventTicketTypeAvailabilitySchema,
-      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() })
+      createdAt: z47.string(),
+      updatedAt: z47.string()
+    });
+    publicEventPricingSchema = z47.discriminatedUnion("kind", [
+      z47.object({
+        kind: z47.literal("drop_in"),
+        currency: z47.string(),
+        display: z47.object({ kind: z47.literal("free"), currency: z47.string() })
       }),
-      z46.object({
-        kind: z46.literal("free_registration"),
-        currency: z46.string(),
-        display: z46.object({ kind: z46.literal("free"), currency: z46.string() })
+      z47.object({
+        kind: z47.literal("free_registration"),
+        currency: z47.string(),
+        display: z47.object({ kind: z47.literal("free"), currency: z47.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() })
+      z47.object({
+        kind: z47.literal("single_paid"),
+        amount: z47.number(),
+        currency: z47.string(),
+        display: z47.object({ kind: z47.literal("exact"), amount: z47.number(), currency: z47.string() })
       }),
-      z46.object({
-        kind: z46.literal("ticket_types"),
-        currency: z46.string(),
-        ticketTypes: z46.array(publicEventTicketTypeSchema),
+      z47.object({
+        kind: z47.literal("ticket_types"),
+        currency: z47.string(),
+        ticketTypes: z47.array(publicEventTicketTypeSchema),
         display: publicEventTicketTypePriceDisplaySchema
       }),
-      z46.object({
-        kind: z46.literal("sliding_scale"),
-        minAmount: z46.number(),
-        maxAmount: z46.number(),
-        suggestedAmount: z46.number().nullable(),
-        currency: z46.string(),
-        display: z46.object({
-          kind: z46.literal("range"),
-          minAmount: z46.number(),
-          maxAmount: z46.number(),
-          currency: z46.string()
+      z47.object({
+        kind: z47.literal("sliding_scale"),
+        minAmount: z47.number(),
+        maxAmount: z47.number(),
+        suggestedAmount: z47.number().nullable(),
+        currency: z47.string(),
+        display: z47.object({
+          kind: z47.literal("range"),
+          minAmount: z47.number(),
+          maxAmount: z47.number(),
+          currency: z47.string()
         })
       }),
-      z46.object({
-        kind: z46.literal("course"),
-        display: z46.object({ kind: z46.literal("course"), display: publicCoursePriceDisplaySchema })
+      z47.object({
+        kind: z47.literal("course"),
+        display: z47.object({ kind: z47.literal("course"), display: publicCoursePriceDisplaySchema })
       }),
-      z46.object({
-        kind: z46.literal("external"),
-        display: z46.object({ kind: z46.literal("external"), label: z46.string() })
+      z47.object({
+        kind: z47.literal("external"),
+        display: z47.object({ kind: z47.literal("external"), label: z47.string() })
       })
     ]);
-    publicTeamMemberSummarySchema = z46.object({
-      id: z46.string(),
-      name: z46.string(),
-      roleLabel: z46.string().nullable(),
-      summary: z46.string().nullable(),
-      profilePath: z46.string().nullable()
+    publicTeamMemberSummarySchema = z47.object({
+      id: z47.string(),
+      name: z47.string(),
+      roleLabel: z47.string().nullable(),
+      summary: z47.string().nullable(),
+      profilePath: z47.string().nullable()
     });
-    publicEventSchema = z46.object({
-      kind: z46.enum(["event", "course_session"]).optional(),
+    publicEventSchema = z47.object({
+      kind: z47.enum(["event", "course_session"]).optional(),
       eventPreset: eventPresetSchema.optional(),
       eventDestinationMode: eventDestinationModeSchema.optional(),
       scheduleScope: eventScheduleScopeSchema.optional(),
-      id: z46.string(),
-      occurrenceId: z46.string(),
-      seriesId: z46.string(),
-      title: z46.string(),
-      description: z46.string().nullable(),
-      content: z46.object({
+      id: z47.string(),
+      occurrenceId: z47.string(),
+      seriesId: z47.string(),
+      title: z47.string(),
+      description: z47.string().nullable(),
+      content: z47.object({
         body: RichTextDocSchema.nullable().optional()
       }).optional(),
-      presentation: z46.object({
-        cardTitleOverride: z46.string().nullable().optional(),
-        summary: z46.string().nullable().optional(),
+      presentation: z47.object({
+        cardTitleOverride: z47.string().nullable().optional(),
+        summary: z47.string().nullable().optional(),
         image: mediaSchema2.nullable().optional()
       }).optional(),
-      slug: z46.string(),
-      path: z46.string().nullable(),
+      slug: z47.string(),
+      path: z47.string().nullable(),
       destination: publicEventDestinationSchema,
-      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(),
+      requiresRegistration: z47.boolean(),
+      deliveryMode: z47.enum(["in_person", "online", "hybrid"]),
+      attendanceModes: z47.array(publicEventAttendanceModeAvailabilitySchema),
+      startsAt: z47.string(),
+      endsAt: z47.string(),
+      capacity: z47.number().nullable(),
+      registeredCount: z47.number(),
+      availableSpots: z47.number().nullable(),
+      waitlistEnabled: z47.boolean(),
       venue: eventVenueSchema.nullable(),
       eventCategory: eventCategorySchema.nullable(),
-      teamMembers: z46.array(publicTeamMemberSummarySchema).optional(),
-      status: z46.enum(["active", "draft", "archived"]).optional(),
-      timeZone: z46.string(),
+      teamMembers: z47.array(publicTeamMemberSummarySchema).optional(),
+      status: z47.enum(["active", "draft", "archived"]).optional(),
+      timeZone: z47.string(),
       pricing: publicEventPricingSchema,
       paymentTerms: blockBookingPaymentTermsSchema,
       accessRestriction: accessRestrictionSchema,
-      allowedCategoryIds: z46.array(z46.string()),
-      requireGuestDetails: z46.boolean().optional(),
-      acceptsPasses: z46.boolean().optional(),
-      acceptsMemberships: z46.boolean().optional(),
-      course: z46.object({
-        id: z46.string(),
+      allowedCategoryIds: z47.array(z47.string()),
+      requireGuestDetails: z47.boolean().optional(),
+      acceptsPasses: z47.boolean().optional(),
+      acceptsMemberships: z47.boolean().optional(),
+      course: z47.object({
+        id: z47.string(),
         pricing: coursePricingSchema.optional(),
-        priceCents: z46.number().nullable(),
-        currency: z46.string(),
-        enrollmentOpen: z46.boolean()
+        priceCents: z47.number().nullable(),
+        currency: z47.string(),
+        enrollmentOpen: z47.boolean()
       }).nullable().optional()
     });
-    publicEventsArraySchema = z46.array(publicEventSchema);
+    publicEventsArraySchema = z47.array(publicEventSchema);
   }
 });
 
@@ -32984,6 +33288,41 @@ var init_filtering = __esm({
   }
 });
 
+// ../blocks/src/system/blocks/events/shared/layout.ts
+function eventSectionHeaderLayoutNodes() {
+  return [
+    text(
+      { as: "h2" },
+      bind("content.heading"),
+      when("content.heading", {
+        authoringPresence: recoverEmptyHeadingWhenActive
+      })
+    ),
+    richText(
+      { className: "rb-prose rb-max-w-none" },
+      bind("content.description"),
+      when("content.description", {
+        authoringPresence: recoverEmptyDescriptionWhenActive
+      })
+    )
+  ];
+}
+var recoverEmptyHeadingWhenActive, recoverEmptyDescriptionWhenActive;
+var init_layout2 = __esm({
+  "../blocks/src/system/blocks/events/shared/layout.ts"() {
+    "use strict";
+    init_builder2();
+    recoverEmptyHeadingWhenActive = {
+      kind: "recover-empty-when-active",
+      placeholder: "Add heading"
+    };
+    recoverEmptyDescriptionWhenActive = {
+      kind: "recover-empty-when-active",
+      placeholder: "Add description"
+    };
+  }
+});
+
 // ../blocks/src/system/blocks/events/shared/index.ts
 var init_shared3 = __esm({
   "../blocks/src/system/blocks/events/shared/index.ts"() {
@@ -32992,61 +33331,62 @@ var init_shared3 = __esm({
     init_schemas2();
     init_fields();
     init_filtering();
+    init_layout2();
   }
 });
 
 // ../blocks/src/system/blocks/shop.shared.ts
-import { z as z47 } from "zod";
+import { z as z48 } from "zod";
 var publicPassProductSchema, publicPassProductCollectionSchema, publicMembershipProductSchema, publicMembershipProductCollectionSchema;
 var init_shop_shared = __esm({
   "../blocks/src/system/blocks/shop.shared.ts"() {
     "use strict";
-    publicPassProductSchema = z47.object({
-      id: z47.string(),
-      productUseCase: z47.enum(["event_pass", "appointment_package"]).default("event_pass"),
-      name: z47.string(),
-      description: z47.string().nullable(),
-      price: z47.number(),
-      currency: z47.string(),
-      creditsTotal: z47.number(),
-      pricePerCredit: z47.number(),
-      validDays: z47.number().nullable(),
-      eligibleCategoryIds: z47.array(z47.string()),
-      eligibleCategoryNames: z47.array(z47.string())
-    });
-    publicPassProductCollectionSchema = z47.object({
-      passes: z47.array(publicPassProductSchema)
-    });
-    publicMembershipProductSchema = z47.object({
-      id: z47.string(),
-      name: z47.string(),
-      description: z47.string().nullable(),
-      price: z47.number(),
-      currency: z47.string(),
-      billingInterval: z47.enum(["month", "year"]),
-      eligibleCategoryIds: z47.array(z47.string()),
-      eligibleCategoryNames: z47.array(z47.string())
+    publicPassProductSchema = z48.object({
+      id: z48.string(),
+      productUseCase: z48.enum(["event_pass", "appointment_package"]).default("event_pass"),
+      name: z48.string(),
+      description: z48.string().nullable(),
+      price: z48.number(),
+      currency: z48.string(),
+      creditsTotal: z48.number(),
+      pricePerCredit: z48.number(),
+      validDays: z48.number().nullable(),
+      eligibleCategoryIds: z48.array(z48.string()),
+      eligibleCategoryNames: z48.array(z48.string())
+    });
+    publicPassProductCollectionSchema = z48.object({
+      passes: z48.array(publicPassProductSchema)
+    });
+    publicMembershipProductSchema = z48.object({
+      id: z48.string(),
+      name: z48.string(),
+      description: z48.string().nullable(),
+      price: z48.number(),
+      currency: z48.string(),
+      billingInterval: z48.enum(["month", "year"]),
+      eligibleCategoryIds: z48.array(z48.string()),
+      eligibleCategoryNames: z48.array(z48.string())
     });
-    publicMembershipProductCollectionSchema = z47.object({
-      memberships: z47.array(publicMembershipProductSchema)
+    publicMembershipProductCollectionSchema = z48.object({
+      memberships: z48.array(publicMembershipProductSchema)
     });
   }
 });
 
 // ../blocks/src/system/blocks/event-registration.shared.ts
-import { z as z48 } from "zod";
+import { z as z49 } from "zod";
 var occurrenceContextSchema;
 var init_event_registration_shared = __esm({
   "../blocks/src/system/blocks/event-registration.shared.ts"() {
     "use strict";
-    occurrenceContextSchema = z48.object({
-      id: z48.string(),
-      seriesId: z48.string(),
-      startsAt: z48.string(),
-      endsAt: z48.string(),
-      timeZone: z48.string(),
-      capacityOverride: z48.number().nullable().optional(),
-      overrides: z48.record(z48.string(), z48.unknown()).nullable().optional()
+    occurrenceContextSchema = z49.object({
+      id: z49.string(),
+      seriesId: z49.string(),
+      startsAt: z49.string(),
+      endsAt: z49.string(),
+      timeZone: z49.string(),
+      capacityOverride: z49.number().nullable().optional(),
+      overrides: z49.record(z49.string(), z49.unknown()).nullable().optional()
     }).nullable();
   }
 });
@@ -33254,22 +33594,22 @@ var init_pricing = __esm({
 });
 
 // ../blocks/src/system/runtime/nodes/shared/contract-schemas.ts
-import { z as z49 } from "zod";
+import { z as z50 } from "zod";
 var previewStageSchema, registrationButtonVariantSchema, eventButtonVariantSchema, eventLayoutSchema, eventCalendarDisplayModeSchema, eventCalendarDefaultViewSchema, columnOptionSchema, weekStartSchema, filterAutoShowSchema, calendarTabViewsSchema;
 var init_contract_schemas = __esm({
   "../blocks/src/system/runtime/nodes/shared/contract-schemas.ts"() {
     "use strict";
     init_events();
-    previewStageSchema = z49.enum(["preview", "published"]);
-    registrationButtonVariantSchema = z49.enum(["primary", "secondary", "outline"]);
-    eventButtonVariantSchema = z49.enum(["primary", "secondary", "outline", "link"]);
-    eventLayoutSchema = z49.enum(eventCalendarListLayoutValues);
-    eventCalendarDisplayModeSchema = z49.enum(eventCalendarDisplayModeValues);
-    eventCalendarDefaultViewSchema = z49.enum(eventCalendarDefaultViewValues);
-    columnOptionSchema = z49.enum(["2", "3", "4"]);
-    weekStartSchema = z49.enum(["sunday", "monday"]);
-    filterAutoShowSchema = z49.enum(["auto", "always", "never"]);
-    calendarTabViewsSchema = z49.enum(["both", "month", "week"]);
+    previewStageSchema = z50.enum(["preview", "published"]);
+    registrationButtonVariantSchema = z50.enum(["primary", "secondary", "outline"]);
+    eventButtonVariantSchema = z50.enum(["primary", "secondary", "outline", "link"]);
+    eventLayoutSchema = z50.enum(eventCalendarListLayoutValues);
+    eventCalendarDisplayModeSchema = z50.enum(eventCalendarDisplayModeValues);
+    eventCalendarDefaultViewSchema = z50.enum(eventCalendarDefaultViewValues);
+    columnOptionSchema = z50.enum(["2", "3", "4"]);
+    weekStartSchema = z50.enum(["sunday", "monday"]);
+    filterAutoShowSchema = z50.enum(["auto", "always", "never"]);
+    calendarTabViewsSchema = z50.enum(["both", "month", "week"]);
   }
 });
 
@@ -33347,7 +33687,7 @@ var init_registrationEventAdapter = __esm({
 });
 
 // ../blocks/src/system/runtime/nodes/event-registration.interactive.ts
-import { z as z50 } from "zod";
+import { z as z51 } from "zod";
 function buildEventRegistrationDisplay(source) {
   const stepLabels = buildEventRegistrationShellStepLabels(source);
   return {
@@ -33455,72 +33795,72 @@ 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 = z50.object({
-      id: z50.string(),
-      slug: z50.string(),
-      contentTypeSlug: z50.string()
+    contentEntrySchema = z51.object({
+      id: z51.string(),
+      slug: z51.string(),
+      contentTypeSlug: z51.string()
     });
-    eventRegistrationPublicEventSchema = z50.preprocess(
+    eventRegistrationPublicEventSchema = z51.preprocess(
       normalizeEventRegistrationEventInput,
       publicEventSchema
     );
-    eventRegistrationSourceSchema = z50.object({
-      siteId: z50.string().optional(),
-      apiBaseUrl: z50.string().optional(),
-      portalToken: z50.string().nullable().optional(),
-      previewToken: z50.string().nullable().optional(),
+    eventRegistrationSourceSchema = z51.object({
+      siteId: z51.string().optional(),
+      apiBaseUrl: z51.string().optional(),
+      portalToken: z51.string().nullable().optional(),
+      previewToken: z51.string().nullable().optional(),
       occurrenceContext: occurrenceContextSchema.optional(),
       contentEntry: contentEntrySchema.nullable().optional(),
-      events: z50.array(eventRegistrationPublicEventSchema).nullable().optional(),
-      className: z50.string().nullable().optional(),
-      buttonText: z50.string().nullable().optional(),
-      maxTickets: z50.string().nullable().optional(),
-      showVenue: z50.boolean().optional(),
-      showCapacity: z50.boolean().optional(),
-      successMessage: z50.string().optional(),
-      waitlistMessage: z50.string().optional(),
+      events: z51.array(eventRegistrationPublicEventSchema).nullable().optional(),
+      className: z51.string().nullable().optional(),
+      buttonText: z51.string().nullable().optional(),
+      maxTickets: z51.string().nullable().optional(),
+      showVenue: z51.boolean().optional(),
+      showCapacity: z51.boolean().optional(),
+      successMessage: z51.string().optional(),
+      waitlistMessage: z51.string().optional(),
       buttonVariant: registrationButtonVariantSchema.optional(),
-      overlayEnabled: z50.boolean().optional(),
-      spamProtectionEnabled: z50.boolean().optional(),
+      overlayEnabled: z51.boolean().optional(),
+      spamProtectionEnabled: z51.boolean().optional(),
       stage: previewStageSchema.optional(),
-      supportEmail: z50.string().optional(),
+      supportEmail: z51.string().optional(),
       sitePasses: publicPassProductCollectionSchema.nullable().optional(),
       siteMemberships: publicMembershipProductCollectionSchema.nullable().optional()
     });
-    eventRegistrationDisplaySchema = z50.object({
-      kind: z50.literal("event-registration"),
-      state: z50.literal("generic-shell"),
-      className: z50.string().nullable(),
-      titleText: z50.string(),
-      bodyText: z50.string(),
-      stepLabels: z50.array(z50.enum(EVENT_REGISTRATION_SHELL_STEP_LABELS)).min(1),
-      summaryButtonText: z50.string()
+    eventRegistrationDisplaySchema = z51.object({
+      kind: z51.literal("event-registration"),
+      state: z51.literal("generic-shell"),
+      className: z51.string().nullable(),
+      titleText: z51.string(),
+      bodyText: z51.string(),
+      stepLabels: z51.array(z51.enum(EVENT_REGISTRATION_SHELL_STEP_LABELS)).min(1),
+      summaryButtonText: z51.string()
     });
-    eventRegistrationHydrationSchema = z50.object({
+    eventRegistrationHydrationSchema = z51.object({
       occurrenceContext: occurrenceContextSchema.optional(),
       contentEntry: contentEntrySchema.nullable().optional(),
-      events: z50.array(eventRegistrationPublicEventSchema).nullable().optional(),
-      maxTickets: z50.string().optional(),
-      showVenue: z50.boolean().optional(),
-      showCapacity: z50.boolean().optional(),
-      successMessage: z50.string().optional(),
-      waitlistMessage: z50.string().optional(),
+      events: z51.array(eventRegistrationPublicEventSchema).nullable().optional(),
+      maxTickets: z51.string().optional(),
+      showVenue: z51.boolean().optional(),
+      showCapacity: z51.boolean().optional(),
+      successMessage: z51.string().optional(),
+      waitlistMessage: z51.string().optional(),
       buttonVariant: registrationButtonVariantSchema.optional(),
-      overlayEnabled: z50.boolean().optional(),
-      spamProtectionEnabled: z50.boolean().optional(),
-      supportEmail: z50.string().optional(),
+      overlayEnabled: z51.boolean().optional(),
+      spamProtectionEnabled: z51.boolean().optional(),
+      supportEmail: z51.string().optional(),
       sitePasses: publicPassProductCollectionSchema.nullable().optional(),
       siteMemberships: publicMembershipProductCollectionSchema.nullable().optional()
     });
-    eventRegistrationRenderSchema = z50.object({
+    eventRegistrationRenderSchema = z51.object({
       display: eventRegistrationDisplaySchema,
       hydration: eventRegistrationHydrationSchema
     });
-    eventRegistrationIslandMetaCodec = createZodCodec(z50.object({
-      siteId: z50.string().optional(),
-      apiBaseUrl: z50.string().optional(),
-      portalToken: z50.string().nullable().optional(),
-      previewToken: z50.string().nullable().optional(),
+    eventRegistrationIslandMetaCodec = createZodCodec(z51.object({
+      siteId: z51.string().optional(),
+      apiBaseUrl: z51.string().optional(),
+      portalToken: z51.string().nullable().optional(),
+      previewToken: z51.string().nullable().optional(),
       stage: previewStageSchema.optional()
     }));
     eventRegistrationIslandMetaKeys = defineInteractiveIslandMetaKeys(
@@ -33824,7 +34164,7 @@ var init_shared4 = __esm({
 });
 
 // ../blocks/src/system/runtime/nodes/course-registration.interactive.ts
-import { z as z51 } from "zod";
+import { z as z52 } from "zod";
 function buildCourseRegistrationDisplay(source) {
   return {
     kind: "course-registration",
@@ -33842,72 +34182,72 @@ var init_course_registration_interactive = __esm({
     init_islands();
     init_runtime();
     init_contract_schemas();
-    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()
+    contentEntrySchema2 = z52.object({
+      id: z52.string(),
+      slug: z52.string(),
+      contentTypeSlug: z52.string()
+    });
+    courseEntrySubrouteContextSchema = z52.union([
+      z52.object({
+        kind: z52.literal("course-run"),
+        run: z52.object({
+          courseId: z52.string(),
+          seriesId: z52.string(),
+          runSlug: z52.string(),
+          runName: z52.string().nullable()
         })
       }),
-      z51.object({
-        kind: z51.literal("event-occurrence"),
+      z52.object({
+        kind: z52.literal("event-occurrence"),
         occurrence: occurrenceContextSchema
       })
     ]);
-    courseRegistrationSourceSchema = z51.object({
-      siteId: z51.string().optional(),
-      apiBaseUrl: z51.string().optional(),
-      portalToken: z51.string().nullable().optional(),
+    courseRegistrationSourceSchema = z52.object({
+      siteId: z52.string().optional(),
+      apiBaseUrl: z52.string().optional(),
+      portalToken: z52.string().nullable().optional(),
       contentEntry: contentEntrySchema2.nullable().optional(),
       entrySubrouteContext: courseEntrySubrouteContextSchema.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(),
+      courses: z52.array(publicCourseSchema).nullable().optional(),
+      className: z52.string().nullable().optional(),
+      showSessions: z52.boolean().optional(),
+      showPrice: z52.boolean().optional(),
+      showCapacity: z52.boolean().optional(),
+      showVenue: z52.boolean().optional(),
+      successMessage: z52.string().optional(),
+      waitlistMessage: z52.string().optional(),
+      membershipMessage: z52.string().optional(),
+      buttonText: z52.string().nullable().optional(),
       buttonVariant: registrationButtonVariantSchema.optional(),
       stage: previewStageSchema.optional()
     });
-    courseRegistrationDisplaySchema = z51.object({
-      kind: z51.literal("course-registration"),
-      state: z51.literal("shell"),
-      className: z51.string().nullable(),
-      summaryButtonText: z51.string()
+    courseRegistrationDisplaySchema = z52.object({
+      kind: z52.literal("course-registration"),
+      state: z52.literal("shell"),
+      className: z52.string().nullable(),
+      summaryButtonText: z52.string()
     });
-    courseRegistrationHydrationSchema = z51.object({
+    courseRegistrationHydrationSchema = z52.object({
       contentEntry: contentEntrySchema2.nullable().optional(),
       entrySubrouteContext: courseEntrySubrouteContextSchema.nullable().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(),
+      courses: z52.array(publicCourseSchema).nullable().optional(),
+      showSessions: z52.boolean().optional(),
+      showPrice: z52.boolean().optional(),
+      showCapacity: z52.boolean().optional(),
+      showVenue: z52.boolean().optional(),
+      successMessage: z52.string().optional(),
+      waitlistMessage: z52.string().optional(),
+      membershipMessage: z52.string().optional(),
       buttonVariant: registrationButtonVariantSchema.optional()
     });
-    courseRegistrationRenderSchema = z51.object({
+    courseRegistrationRenderSchema = z52.object({
       display: courseRegistrationDisplaySchema,
       hydration: courseRegistrationHydrationSchema
     });
-    courseRegistrationIslandMetaCodec = createZodCodec(z51.object({
-      siteId: z51.string().optional(),
-      apiBaseUrl: z51.string().optional(),
-      portalToken: z51.string().nullable().optional(),
+    courseRegistrationIslandMetaCodec = createZodCodec(z52.object({
+      siteId: z52.string().optional(),
+      apiBaseUrl: z52.string().optional(),
+      portalToken: z52.string().nullable().optional(),
       stage: previewStageSchema.optional()
     }));
     courseRegistrationIslandMetaKeys = defineInteractiveIslandMetaKeys(
@@ -34175,7 +34515,7 @@ var init_course_registration = __esm({
 });
 
 // ../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"() {
@@ -34318,37 +34658,37 @@ 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: publicPassProductCollectionSchema,
           siteMemberships: publicMembershipProductCollectionSchema,
@@ -34571,7 +34911,6 @@ var init_event_spotlight = __esm({
   "../blocks/src/system/blocks/events/event-spotlight.ts"() {
     "use strict";
     init_builder2();
-    init_builder2();
     init_styledSection();
     init_fragments();
     init_boxStyles();
@@ -34627,18 +34966,7 @@ var init_event_spotlight = __esm({
     eventSpotlightLayout = [
       styledSection({
         children: sectionContainer([
-          // Optional heading
-          text(
-            { as: "h2" },
-            bind("content.heading"),
-            when("content.heading")
-          ),
-          // Optional description
-          richText(
-            { className: "rb-prose rb-max-w-none" },
-            bind("content.description"),
-            when("content.description")
-          ),
+          ...eventSectionHeaderLayoutNodes(),
           // Event spotlight component
           el("event-spotlight", {
             events: { $bind: { from: "data.events" } },
@@ -34835,7 +35163,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;
@@ -34856,32 +35184,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"() {
@@ -34894,89 +35222,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()
       })
     );
@@ -35066,7 +35394,6 @@ var init_event_listing = __esm({
   "../blocks/src/system/blocks/events/event-listing.ts"() {
     "use strict";
     init_builder2();
-    init_builder2();
     init_styledSection();
     init_fragments();
     init_boxStyles();
@@ -35231,18 +35558,7 @@ var init_event_listing = __esm({
     eventListingLayout = [
       styledSection({
         children: sectionContainer([
-          // Optional heading
-          text(
-            { as: "h2" },
-            bind("content.heading"),
-            when("content.heading")
-          ),
-          // Optional description
-          richText(
-            { className: "rb-prose rb-max-w-none" },
-            bind("content.description"),
-            when("content.description")
-          ),
+          ...eventSectionHeaderLayoutNodes(),
           // Event listing component with pagination
           el("event-listing", withApiBindings({
             events: { $bind: { from: "data.events" } },
@@ -35360,7 +35676,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 {
@@ -35414,14 +35730,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(),
@@ -35429,38 +35745,38 @@ 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(),
         defaultCalendarView: eventCalendarDefaultViewSchema.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,
@@ -35468,41 +35784,41 @@ var init_EventCalendar_interactive = __esm({
       startOfWeek: weekStartSchema,
       calendarTabViews: calendarTabViewsSchema,
       defaultCalendarView: eventCalendarDefaultViewSchema,
-      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()
       })
     );
@@ -35583,7 +35899,6 @@ var init_event_calendar = __esm({
     "use strict";
     init_schema2();
     init_builder2();
-    init_builder2();
     init_styledSection();
     init_fragments();
     init_boxStyles();
@@ -35596,14 +35911,7 @@ var init_event_calendar = __esm({
       styledSection({
         children: sectionContainer(
           [
-            // Optional heading
-            text({ as: "h2" }, bind("content.heading"), when("content.heading")),
-            // Optional description
-            richText(
-              { className: "rb-prose rb-max-w-none" },
-              bind("content.description"),
-              when("content.description")
-            ),
+            ...eventSectionHeaderLayoutNodes(),
             // Event calendar component (handles all display modes)
             el(
               "event-calendar",
@@ -36356,7 +36664,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",
@@ -36479,13 +36787,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 = [
@@ -36775,7 +37083,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"() {
@@ -37015,18 +37323,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: {
@@ -38256,50 +38564,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)
     });
   }
 });
@@ -38370,7 +38678,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" };
@@ -38409,26 +38717,26 @@ 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)
     });
   }
 });
@@ -38638,7 +38946,7 @@ var init_display = __esm({
 });
 
 // ../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;
 }
@@ -38666,211 +38974,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");
@@ -39276,7 +39584,7 @@ var init_shop = __esm({
 });
 
 // ../blocks/src/system/blocks/product-list.ts
-import { z as z61 } from "zod";
+import { z as z62 } from "zod";
 var productListManifest, productListBlockDefinition, productListDataSchema;
 var init_product_list = __esm({
   "../blocks/src/system/blocks/product-list.ts"() {
@@ -39421,7 +39729,7 @@ var init_product_list = __esm({
         }
       }
     };
-    productListDataSchema = z61.object({
+    productListDataSchema = z62.object({
       products: publicProductsResponseSchema.optional()
     });
   }
@@ -39724,7 +40032,7 @@ var init_checkout = __esm({
 });
 
 // ../blocks/src/system/runtime/nodes/gifting.interactive.ts
-import { z as z62 } from "zod";
+import { z as z63 } from "zod";
 function buildGiftingDisplay(source) {
   return {
     kind: "gifting",
@@ -39743,71 +40051,71 @@ var init_gifting_interactive = __esm({
     "use strict";
     init_islands();
     init_runtime();
-    publicGiftCardOfferSchema = z62.object({
-      id: z62.string(),
-      kind: z62.literal("gift_card"),
-      title: z62.string(),
-      description: z62.string().nullable(),
-      sortOrder: z62.number().int(),
-      giftCard: z62.object({
-        fixedDenominations: z62.array(z62.number().int().positive()),
-        customAmountEnabled: z62.boolean(),
-        customAmountMinCents: z62.number().int().positive(),
-        customAmountMaxCents: z62.number().int().positive()
+    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()
       }),
-      voucher: z62.null()
-    });
-    publicVoucherOfferSchema = z62.object({
-      id: z62.string(),
-      kind: z62.literal("voucher"),
-      title: z62.string(),
-      description: z62.string().nullable(),
-      sortOrder: z62.number().int(),
-      giftCard: z62.null(),
-      voucher: z62.object({
-        purchaseAmountCents: z62.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()
       })
     });
-    publicGiftingOffersResponseSchema = z62.object({
-      currency: z62.string(),
-      giftCards: z62.array(publicGiftCardOfferSchema),
-      vouchers: z62.array(publicVoucherOfferSchema)
+    publicGiftingOffersResponseSchema = z63.object({
+      currency: z63.string(),
+      giftCards: z63.array(publicGiftCardOfferSchema),
+      vouchers: z63.array(publicVoucherOfferSchema)
     });
-    giftingSourceSchema = z62.object({
-      siteId: z62.string().optional(),
-      apiBaseUrl: z62.string().optional(),
+    giftingSourceSchema = z63.object({
+      siteId: z63.string().optional(),
+      apiBaseUrl: z63.string().optional(),
       offers: publicGiftingOffersResponseSchema.nullable().optional(),
-      className: z62.string().nullable().optional(),
-      heading: z62.string().nullable().optional(),
-      intro: z62.string().nullable().optional(),
-      giftCardsHeading: z62.string().nullable().optional(),
-      vouchersHeading: z62.string().nullable().optional(),
-      emptyStateText: z62.string().nullable().optional(),
-      checkoutButtonText: z62.string().nullable().optional(),
-      successMessage: z62.string().nullable().optional()
-    });
-    giftingDisplaySchema = z62.object({
-      kind: z62.literal("gifting"),
-      state: z62.literal("ready"),
-      className: z62.string().nullable(),
-      heading: z62.string(),
-      intro: z62.string().nullable(),
-      giftCardsHeading: z62.string(),
-      vouchersHeading: z62.string(),
-      emptyStateText: z62.string()
-    });
-    giftingHydrationSchema = z62.object({
+      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({
       offers: publicGiftingOffersResponseSchema.nullable(),
-      checkoutButtonText: z62.string(),
-      successMessage: z62.string()
+      checkoutButtonText: z63.string(),
+      successMessage: z63.string()
     });
-    giftingRenderSchema = z62.object({
+    giftingRenderSchema = z63.object({
       display: giftingDisplaySchema,
       hydration: giftingHydrationSchema
     });
-    giftingIslandMetaCodec = createZodCodec(z62.object({
-      siteId: z62.string().optional(),
-      apiBaseUrl: z62.string().optional()
+    giftingIslandMetaCodec = createZodCodec(z63.object({
+      siteId: z63.string().optional(),
+      apiBaseUrl: z63.string().optional()
     }));
     giftingIslandMetaKeys = defineInteractiveIslandMetaKeys(
       "siteId",
@@ -40124,7 +40432,7 @@ var init_newsletter_form_types = __esm({
 });
 
 // ../blocks/src/system/runtime/nodes/newsletter-form.interactive.ts
-import { z as z63 } from "zod";
+import { z as z64 } from "zod";
 function buildNewsletterDisplay(source) {
   const preset2 = source.preset ?? "emailOnly";
   const includePhone = source.includePhone ?? false;
@@ -40159,65 +40467,65 @@ var init_newsletter_form_interactive = __esm({
     init_runtime();
     init_newsletter_signup_destination();
     init_newsletter_form_types();
-    newsletterPresetSchema = z63.enum(["emailOnly", "emailName", "emailFirstLast", "emailNameCompany"]);
-    newsletterDestinationProviderSchema = z63.enum(["riverbank", "mailchimp"]);
-    newsletterFieldSchema = z63.object({
-      id: z63.string(),
-      type: z63.enum(["email", "text"]),
-      label: z63.string(),
-      required: z63.boolean(),
-      placeholder: z63.string().optional()
-    });
-    newsletterSignupBlockIdSchema = z63.string().trim().min(1).transform(parseRequiredNewsletterSignupBlockId);
-    signedNewsletterDestinationRefSchema = z63.string().trim().min(1).transform(parseRequiredSignedNewsletterDestinationRef);
-    newsletterPublicDestinationRefSchema = z63.discriminatedUnion("tag", [
-      z63.object({
-        tag: z63.literal("block_ref"),
+    newsletterPresetSchema = z64.enum(["emailOnly", "emailName", "emailFirstLast", "emailNameCompany"]);
+    newsletterDestinationProviderSchema = z64.enum(["riverbank", "mailchimp"]);
+    newsletterFieldSchema = z64.object({
+      id: z64.string(),
+      type: z64.enum(["email", "text"]),
+      label: z64.string(),
+      required: z64.boolean(),
+      placeholder: z64.string().optional()
+    });
+    newsletterSignupBlockIdSchema = z64.string().trim().min(1).transform(parseRequiredNewsletterSignupBlockId);
+    signedNewsletterDestinationRefSchema = z64.string().trim().min(1).transform(parseRequiredSignedNewsletterDestinationRef);
+    newsletterPublicDestinationRefSchema = z64.discriminatedUnion("tag", [
+      z64.object({
+        tag: z64.literal("block_ref"),
         blockId: newsletterSignupBlockIdSchema
       }),
-      z63.object({
-        tag: z63.literal("signed_destination_ref"),
+      z64.object({
+        tag: z64.literal("signed_destination_ref"),
         token: signedNewsletterDestinationRefSchema
       })
     ]);
-    newsletterSourceSchema = z63.object({
-      blockId: z63.string().nullable().optional(),
-      siteId: z63.string().optional(),
-      apiBaseUrl: z63.string().optional(),
-      listId: z63.string().nullable().optional(),
+    newsletterSourceSchema = z64.object({
+      blockId: z64.string().nullable().optional(),
+      siteId: z64.string().optional(),
+      apiBaseUrl: z64.string().optional(),
+      listId: z64.string().nullable().optional(),
       destinationProvider: newsletterDestinationProviderSchema.nullable().optional(),
       preset: newsletterPresetSchema.optional(),
-      includePhone: z63.boolean().optional(),
-      buttonLabel: z63.string().nullable().optional(),
-      successMessage: z63.string().nullable().optional(),
-      privacyNote: z63.string().nullable().optional(),
-      tags: z63.string().nullable().optional(),
-      spamProtectionEnabled: z63.boolean().optional(),
-      className: z63.string().nullable().optional()
-    });
-    newsletterDisplaySchema = z63.object({
-      kind: z63.literal("newsletter-form"),
-      className: z63.string().nullable(),
-      buttonLabel: z63.string(),
-      successMessage: z63.string().nullable(),
-      privacyNote: z63.string().nullable(),
-      fields: z63.array(newsletterFieldSchema)
-    });
-    newsletterHydrationSchema = z63.object({
+      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({
       destinationRef: newsletterPublicDestinationRefSchema.nullable().optional(),
-      listId: z63.string().nullable().optional(),
+      listId: z64.string().nullable().optional(),
       preset: newsletterPresetSchema,
-      includePhone: z63.boolean(),
-      tags: z63.string().nullable().optional(),
-      spamProtectionEnabled: z63.boolean().optional()
+      includePhone: z64.boolean(),
+      tags: z64.string().nullable().optional(),
+      spamProtectionEnabled: z64.boolean().optional()
     });
-    newsletterRenderSchema = z63.object({
+    newsletterRenderSchema = z64.object({
       display: newsletterDisplaySchema,
       hydration: newsletterHydrationSchema
     });
-    newsletterIslandMetaCodec = createZodCodec(z63.object({
-      siteId: z63.string().optional(),
-      apiBaseUrl: z63.string().optional()
+    newsletterIslandMetaCodec = createZodCodec(z64.object({
+      siteId: z64.string().optional(),
+      apiBaseUrl: z64.string().optional()
     }));
     newsletterIslandMetaKeys = defineInteractiveIslandMetaKeys("siteId", "apiBaseUrl");
     newsletterFormBlockRuntime = defineProgressiveBlockRuntime({
@@ -40344,7 +40652,7 @@ var init_newsletter_signup = __esm({
 });
 
 // ../blocks/src/system/blocks/team-members.ts
-import { z as z64 } from "zod";
+import { z as z65 } 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"() {
@@ -40361,18 +40669,18 @@ var init_team_members = __esm({
     teamMemberPhotoSchema = mediaSchema2.refine((media2) => media2.type === "image", {
       message: "Team member photos must be image media"
     }).nullable();
-    teamMemberDataSchema = z64.object({
-      _type: z64.literal("teamMember"),
-      id: z64.string(),
-      name: z64.string(),
-      role: z64.string().nullable(),
-      roleLabel: z64.string().nullable(),
-      bio: z64.string().nullable(),
-      summary: z64.string().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(),
       photo: teamMemberPhotoSchema,
-      profilePath: z64.string().nullable()
+      profilePath: z65.string().nullable()
     });
-    teamMembersDataSchema = z64.array(teamMemberDataSchema);
+    teamMembersDataSchema = z65.array(teamMemberDataSchema);
     dynamicSourceWhen = { equals: "site_staff" };
     manualSourceWhen = { equals: "site_staff", not: true };
     headingNode = text(
@@ -41180,6 +41488,7 @@ var init_blocks = __esm({
     init_feature_cards();
     init_media_text();
     init_appointment_booking();
+    init_weekly_slot_availability();
     init_event_registration();
     init_course_registration();
     init_event_details();
@@ -41220,6 +41529,7 @@ var init_blocks = __esm({
     init_feature_card_icons();
     init_media_text();
     init_appointment_booking();
+    init_weekly_slot_availability();
     init_event_registration();
     init_event_details();
     init_course_registration();
@@ -41590,6 +41900,10 @@ var init_blocks = __esm({
         flow: conversionFlow,
         layoutProfiles: [layoutProfile({ variantKey: "default", family: "form", weight: "standard" })]
       })),
+      withDesignCapability("block.weekly-slot-availability", weeklySlotAvailabilityBlockDefinition, sectionOnly(), defineBlockDesignMetadata({
+        flow: offeringsFlow,
+        layoutProfiles: [layoutProfile({ variantKey: "default", family: "stack", weight: "standard" })]
+      })),
       withDesignCapability("block.event-registration", eventRegistrationBlockDefinition, sectionOnly(), defineBlockDesignMetadata({
         flow: conversionFlow,
         layoutProfiles: [layoutProfile({ variantKey: "default", family: "form", weight: "standard" })]
@@ -42757,7 +43071,7 @@ var init_componentFactory = __esm({
 });
 
 // ../blocks/src/system/layout/index.ts
-var init_layout2 = __esm({
+var init_layout3 = __esm({
   "../blocks/src/system/layout/index.ts"() {
     "use strict";
     init_repeaterGrid();
@@ -42817,7 +43131,7 @@ var init_system = __esm({
     init_designCapabilities();
     init_fragments2();
     init_icons();
-    init_layout2();
+    init_layout3();
     init_defineBlock();
     init_ai();
     init_link();
@@ -43144,7 +43458,7 @@ var init_generateLayoutCss = __esm({
 });
 
 // ../theme-core/src/layout/index.ts
-var init_layout3 = __esm({
+var init_layout4 = __esm({
   "../theme-core/src/layout/index.ts"() {
     "use strict";
     init_generateLayoutCss();
@@ -43943,7 +44257,7 @@ var init_buildThemeRuntime = __esm({
     init_defaults2();
     init_header();
     init_footer();
-    init_layout3();
+    init_layout4();
     init_status();
     init_progress();
     init_typography2();
@@ -44406,30 +44720,30 @@ var init_Button = __esm({
 });
 
 // ../blocks/src/structure/schema.ts
-import z65 from "zod";
+import z66 from "zod";
 var BlockKind, blockSchema, pagePath, pageOutlineSchema;
 var init_schema4 = __esm({
   "../blocks/src/structure/schema.ts"() {
     "use strict";
-    BlockKind = z65.string();
-    blockSchema = z65.object({
-      id: z65.string().nullable(),
+    BlockKind = z66.string();
+    blockSchema = z66.object({
+      id: z66.string().nullable(),
       // optional ID for reference in toggle ops
       kind: BlockKind,
-      purpose: z65.string().min(1),
+      purpose: z66.string().min(1),
       // Optional content fields used by PageRenderer / block runtime.
-      content: z65.record(z65.string(), z65.unknown()).optional(),
+      content: z66.record(z66.string(), z66.unknown()).optional(),
       // Nullable because some persisted sources store "no draft" as null.
-      draftContent: z65.record(z65.string(), z65.unknown()).nullable().optional(),
+      draftContent: z66.record(z66.string(), z66.unknown()).nullable().optional(),
       // Optional template bindings for reverse field mapping (entry editing)
-      bindings: z65.record(z65.string(), z65.unknown()).optional()
+      bindings: z66.record(z66.string(), z66.unknown()).optional()
     }).passthrough();
-    pagePath = z65.string().regex(/^\/[\S]*$/, 'path must start with "/" and contain no spaces');
-    pageOutlineSchema = z65.object({
-      name: z65.string().min(1),
+    pagePath = z66.string().regex(/^\/[\S]*$/, 'path must start with "/" and contain no spaces');
+    pageOutlineSchema = z66.object({
+      name: z66.string().min(1),
       path: pagePath,
-      purpose: z65.string().min(1),
-      blocks: z65.array(blockSchema).min(1)
+      purpose: z66.string().min(1),
+      blocks: z66.array(blockSchema).min(1)
     });
   }
 });
@@ -44552,7 +44866,7 @@ var init_fonts = __esm({
 });
 
 // ../theme-core/src/runtime/buildThemeRuntimeFromBridge.ts
-import { z as z66 } from "zod";
+import { z as z67 } from "zod";
 var themeBridgeConfigSchema;
 var init_buildThemeRuntimeFromBridge = __esm({
   "../theme-core/src/runtime/buildThemeRuntimeFromBridge.ts"() {
@@ -44567,33 +44881,33 @@ var init_buildThemeRuntimeFromBridge = __esm({
     init_progress();
     init_blocks2();
     init_themeCssVarNames();
-    themeBridgeConfigSchema = z66.object({
-      tokens: z66.record(z66.string(), z66.string()),
-      typography: z66.object({
-        headingFamily: z66.string().optional(),
-        bodyFamily: z66.string().optional(),
-        headingWeight: z66.number().optional(),
-        bodyWeight: z66.number().optional()
+    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()
       }).optional(),
-      spacing: z66.enum(["comfortable", "standard", "dense"]).optional(),
-      corners: z66.enum(["square", "soft", "rounded", "pill"]).optional(),
-      shadows: z66.enum(["none", "low", "medium", "high"]).optional(),
-      components: z66.object({
-        buttons: z66.union([
-          z66.boolean(),
-          z66.object({
-            variants: z66.array(z66.enum(["primary", "secondary", "outline", "ghost"])).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()
           })
         ]).optional(),
-        cards: z66.union([
-          z66.boolean(),
-          z66.object({
-            variants: z66.array(z66.enum(["default", "elevated", "outlined"])).optional()
+        cards: z67.union([
+          z67.boolean(),
+          z67.object({
+            variants: z67.array(z67.enum(["default", "elevated", "outlined"])).optional()
           })
         ]).optional(),
-        inputs: z66.boolean().optional()
+        inputs: z67.boolean().optional()
       }).optional(),
-      overrides: z66.record(z66.string(), z66.string()).optional()
+      overrides: z67.record(z67.string(), z67.string()).optional()
     }).passthrough();
   }
 });
@@ -44847,14 +45161,21 @@ var init_utils5 = __esm({
 
 // ../blocks/src/system/data/prefetchBlockData.ts
 async function prefetchBlockData(page, context, options) {
-  const { apiClient, isValidEndpoint, onError, getCustomBlockLoaders } = options;
+  const {
+    apiClient,
+    isValidEndpoint,
+    onError,
+    getCustomBlockLoaders,
+    getBlockDefinition: getBlockDefinition2 = getBlockDefinition,
+    resolveParamsBindings: resolveParamsBindings2 = resolveParamsBindings
+  } = options;
   const results = {};
   const tasks = [];
   for (const block of page.blocks) {
     const blockId = block.id;
     if (!blockId) continue;
     let loaders;
-    const def = getBlockDefinition(block.kind);
+    const def = getBlockDefinition2(block.kind);
     if (def) {
       loaders = normalizeDataLoaders(def);
     } else if (getCustomBlockLoaders) {
@@ -44877,14 +45198,14 @@ async function prefetchBlockData(page, context, options) {
         continue;
       }
       if (typeof loader.when !== "undefined") {
-        const resolvedWhen = resolveParamsBindings(loader.when, vm, {
+        const resolvedWhen = resolveParamsBindings2(loader.when, vm, {
           blockKind: block.kind
         });
         if (resolvedWhen !== true) {
           continue;
         }
       }
-      const rawParams = resolveParamsBindings(loader.params, vm, {
+      const rawParams = resolveParamsBindings2(loader.params, vm, {
         blockKind: block.kind
       });
       const params = normalizeParams(rawParams);
@@ -44939,7 +45260,8 @@ var init_loaderEndpoints = __esm({
       "listPublicPasses",
       "listPublicMemberships",
       "getPublicFormById",
-      "getPublicBookingServices"
+      "getPublicBookingServices",
+      "getPublicWeeklySlotAvailability"
     ];
   }
 });
@@ -44980,6 +45302,10 @@ function normalizeLoaderParams(endpoint, params, context) {
     ensureSiteId(out, context);
     return out;
   }
+  if (endpoint === "getPublicWeeklySlotAvailability") {
+    ensureSiteId(out, context);
+    return out;
+  }
   if (endpoint === "listPublicEvents") {
     ensureSiteId(out, context);
     return out;
@@ -45064,7 +45390,7 @@ var init_src3 = __esm({
 });
 
 // ../api/src/sdkConfig/contracts.ts
-import { z as z67 } from "zod";
+import { z as z68 } from "zod";
 function unsafeRetypeZodSchema(schema) {
   return schema;
 }
@@ -45073,17 +45399,17 @@ var init_contracts2 = __esm({
   "../api/src/sdkConfig/contracts.ts"() {
     "use strict";
     init_src3();
-    navIdListSchema = z67.preprocess((value) => {
+    navIdListSchema = z68.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;
-    }, z67.array(z67.string()).max(200).optional());
-    dashboardNavVisibilityBaseSchema = z67.object({
-      mode: z67.enum(["augment", "restrict"]).optional(),
+    }, z68.array(z68.string()).max(200).optional());
+    dashboardNavVisibilityBaseSchema = z68.object({
+      mode: z68.enum(["augment", "restrict"]).optional(),
       allowIds: navIdListSchema,
       denyIds: navIdListSchema
     }).strip();
-    dashboardNavVisibilityRolesSchema = z67.object({
+    dashboardNavVisibilityRolesSchema = z68.object({
       administrator: dashboardNavVisibilityBaseSchema.optional(),
       editor: dashboardNavVisibilityBaseSchema.optional(),
       team_member: dashboardNavVisibilityBaseSchema.optional()
@@ -45091,63 +45417,63 @@ var init_contracts2 = __esm({
     dashboardNavVisibilitySchema = dashboardNavVisibilityBaseSchema.extend({
       roles: dashboardNavVisibilityRolesSchema
     }).strip();
-    dashboardNavigationConfigSchema = z67.object({
+    dashboardNavigationConfigSchema = z68.object({
       siteNav: dashboardNavVisibilitySchema.optional(),
       settingsNav: dashboardNavVisibilitySchema.optional()
     }).strip();
-    dashboardConfigSchema = z67.object({
-      previewEditingEnabled: z67.boolean().optional(),
+    dashboardConfigSchema = z68.object({
+      previewEditingEnabled: z68.boolean().optional(),
       navigation: dashboardNavigationConfigSchema.optional()
     }).strip();
     fieldDefinitionInputSchema = unsafeRetypeZodSchema(fieldSchema);
     nodeDefinitionSchema = unsafeRetypeZodSchema(NodeSchema);
-    sdkLoaderEndpointSchema = z67.enum(SUPPORTED_LOADER_ENDPOINTS);
-    loaderFallbackScalarSchema = z67.union([
-      z67.string(),
-      z67.number(),
-      z67.boolean(),
-      z67.null()
+    sdkLoaderEndpointSchema = z68.enum(SUPPORTED_LOADER_ENDPOINTS);
+    loaderFallbackScalarSchema = z68.union([
+      z68.string(),
+      z68.number(),
+      z68.boolean(),
+      z68.null()
     ]);
-    loaderParamBindingSchema = z67.object({
-      $bind: z67.object({
-        from: z67.string().min(1, "Binding path is required"),
+    loaderParamBindingSchema = z68.object({
+      $bind: z68.object({
+        from: z68.string().min(1, "Binding path is required"),
         fallback: loaderFallbackScalarSchema.optional()
       })
     });
-    loaderParamValueSchema = z67.union([
-      z67.string(),
-      z67.number(),
-      z67.boolean(),
+    loaderParamValueSchema = z68.union([
+      z68.string(),
+      z68.number(),
+      z68.boolean(),
       loaderParamBindingSchema
     ]);
-    sdkConfigLoaderSchema = z67.object({
+    sdkConfigLoaderSchema = z68.object({
       endpoint: sdkLoaderEndpointSchema,
-      params: z67.record(z67.string(), loaderParamValueSchema),
-      mode: z67.enum(["server", "client"]).default("server")
+      params: z68.record(z68.string(), loaderParamValueSchema),
+      mode: z68.enum(["server", "client"]).default("server")
     });
-    sdkDataLoadersSchema = z67.record(z67.string(), sdkConfigLoaderSchema).refine((loaders) => Object.keys(loaders).length <= 5, { message: "Maximum 5 data loaders per block" }).optional();
-    sdkCustomBlockIdSchema = z67.string().min(8).regex(/^custom\.[a-z][a-z0-9-]*$/, {
+    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-]*$/, {
       message: "Block ID must start with 'custom.' followed by lowercase letters, numbers, or hyphens"
     }).transform((value) => value);
-    sdkCustomBlockInputSchema = z67.object({
+    sdkCustomBlockInputSchema = z68.object({
       id: sdkCustomBlockIdSchema,
-      title: z67.string().min(1),
-      titleSource: z67.union([z67.string().min(1), z67.array(z67.string().min(1)).min(1)]).optional(),
-      description: z67.string().optional(),
+      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(),
       category: blockCategoryEnum,
-      icon: z67.string().optional(),
-      tags: z67.array(z67.string()).optional(),
+      icon: z68.string().optional(),
+      tags: z68.array(z68.string()).optional(),
       fields: fieldDefinitionInputSchema.array().min(1),
       dataLoaders: sdkDataLoadersSchema,
       layout: NodeSchema.optional(),
-      variants: z67.record(z67.string().min(1), NodeSchema).optional(),
-      defaultVariant: z67.string().min(1).optional(),
-      variantOptions: z67.record(
-        z67.string().min(1),
-        z67.object({
-          label: z67.string().min(1).optional(),
-          description: z67.string().min(1).optional(),
-          icon: z67.string().min(1).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()
         })
       ).optional(),
       previewCustomize: previewCustomizeManifestCurationSchema.optional()
@@ -45158,7 +45484,7 @@ var init_contracts2 = __esm({
           const exists = data.fields.some((field) => field.id === source);
           if (!exists) {
             ctx.addIssue({
-              code: z67.ZodIssueCode.custom,
+              code: z68.ZodIssueCode.custom,
               message: `titleSource must reference a valid field ID (got "${source}")`,
               path: Array.isArray(data.titleSource) ? ["titleSource", index] : ["titleSource"]
             });
@@ -45167,7 +45493,7 @@ var init_contracts2 = __esm({
       }
       if (data.layout && data.variants) {
         ctx.addIssue({
-          code: z67.ZodIssueCode.custom,
+          code: z68.ZodIssueCode.custom,
           message: "Custom block must define either `layout` or `variants`, not both",
           path: ["variants"]
         });
@@ -45176,14 +45502,14 @@ var init_contracts2 = __esm({
         const keys = Object.keys(data.variants);
         if (keys.length === 0) {
           ctx.addIssue({
-            code: z67.ZodIssueCode.custom,
+            code: z68.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: z67.ZodIssueCode.custom,
+            code: z68.ZodIssueCode.custom,
             message: "`defaultVariant` must be a key present in `variants`",
             path: ["defaultVariant"]
           });
@@ -45192,7 +45518,7 @@ var init_contracts2 = __esm({
           for (const key of Object.keys(data.variantOptions)) {
             if (!Object.prototype.hasOwnProperty.call(data.variants, key)) {
               ctx.addIssue({
-                code: z67.ZodIssueCode.custom,
+                code: z68.ZodIssueCode.custom,
                 message: "`variantOptions` key must exist in `variants`",
                 path: ["variantOptions", key]
               });
@@ -45201,78 +45527,78 @@ var init_contracts2 = __esm({
         }
       }
     });
-    sdkBlockFieldExtensionInputSchema = z67.object({
+    sdkBlockFieldExtensionInputSchema = z68.object({
       fields: fieldDefinitionInputSchema.array().min(1)
     });
-    sdkBlockFieldExtensionsInputSchema = z67.record(
-      z67.string().min(1),
+    sdkBlockFieldExtensionsInputSchema = z68.record(
+      z68.string().min(1),
       sdkBlockFieldExtensionInputSchema
     );
-    sdkThemePaletteSchema = z67.record(z67.string(), z67.string());
-    sdkThemeConfigSchema = z67.object({
+    sdkThemePaletteSchema = z68.record(z68.string(), z68.string());
+    sdkThemeConfigSchema = z68.object({
       palette: sdkThemePaletteSchema
     });
-    sdkSectionBackgroundSchema = z67.object({
-      id: z67.string().min(1),
-      label: z67.string().min(1),
-      token: z67.string().min(1)
+    sdkSectionBackgroundSchema = z68.object({
+      id: z68.string().min(1),
+      label: z68.string().min(1),
+      token: z68.string().min(1)
     });
-    sdkSectionOptionsConfigSchema = z67.object({
-      backgroundColor: z67.boolean().optional(),
-      backgroundImage: z67.boolean().optional(),
-      backgroundGradient: z67.boolean().optional(),
-      spacing: z67.union([z67.array(z67.enum(["compact", "default", "spacious"])), z67.boolean()]).optional(),
-      textColor: z67.boolean().optional()
+    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()
     });
-    sdkContainerOptionsConfigSchema = z67.object({
-      maxWidth: z67.union([z67.array(z67.enum(["narrow", "default", "wide", "full"])), z67.boolean()]).optional(),
-      alignment: z67.union([z67.array(z67.enum(["left", "center", "right"])), z67.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()
     });
-    sdkSiteStyleConfigSchema = z67.object({
-      sectionBackgrounds: z67.array(sdkSectionBackgroundSchema).optional(),
+    sdkSiteStyleConfigSchema = z68.object({
+      sectionBackgrounds: z68.array(sdkSectionBackgroundSchema).optional(),
       sectionOptions: sdkSectionOptionsConfigSchema.optional(),
       containerOptions: sdkContainerOptionsConfigSchema.optional()
     });
-    sdkSiteLayoutConfigSchema = z67.object({
-      footerBlocks: z67.array(
-        z67.object({
-          id: z67.string().min(1).optional(),
-          kind: z67.string().min(1),
-          content: z67.record(z67.string(), z67.unknown()).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()
         })
       ).optional()
     });
-    sdkFieldSelectOptionSchema = z67.object({
-      value: z67.string(),
-      label: z67.string()
+    sdkFieldSelectOptionSchema = z68.object({
+      value: z68.string(),
+      label: z68.string()
     });
-    sdkBlockFieldConfigSchema = z67.object({
-      options: z67.array(sdkFieldSelectOptionSchema).optional()
+    sdkBlockFieldConfigSchema = z68.object({
+      options: z68.array(sdkFieldSelectOptionSchema).optional()
     });
-    sdkBlockFieldOptionsMapSchema = z67.record(
-      z67.string().regex(/^(block\.|custom\.)[a-z][a-z0-9-]*$/, {
+    sdkBlockFieldOptionsMapSchema = z68.record(
+      z68.string().regex(/^(block\.|custom\.)[a-z][a-z0-9-]*$/, {
         message: "Block ID must be 'block.*' or 'custom.*' format"
       }),
-      z67.record(z67.string().min(1), sdkBlockFieldConfigSchema)
+      z68.record(z68.string().min(1), sdkBlockFieldConfigSchema)
     ).optional();
-    sdkContentTypeTemplateConfigSchema = z67.object({
-      blocks: z67.array(z67.unknown())
+    sdkContentTypeTemplateConfigSchema = z68.object({
+      blocks: z68.array(z68.unknown())
     }).passthrough();
-    sdkContentTypeOrderingConfigSchema = z67.object({
-      mode: z67.enum(["default", "manual"]).optional()
+    sdkContentTypeOrderingConfigSchema = z68.object({
+      mode: z68.enum(["default", "manual"]).optional()
     }).optional();
-    sdkContentTypeConfigSchema = z67.object({
-      key: z67.string().min(1),
-      fields: z67.array(z67.unknown()),
+    sdkContentTypeConfigSchema = z68.object({
+      key: z68.string().min(1),
+      fields: z68.array(z68.unknown()),
       ordering: sdkContentTypeOrderingConfigSchema,
       template: sdkContentTypeTemplateConfigSchema.nullable().optional()
     }).passthrough();
-    sdkContentConfigSchema = z67.object({
-      contentTypes: z67.array(sdkContentTypeConfigSchema).optional(),
-      pages: z67.array(z67.unknown()).optional(),
-      entries: z67.array(z67.unknown()).optional(),
-      navigationMenus: z67.array(z67.unknown()).optional(),
-      settings: z67.unknown().optional()
+    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()
     }).passthrough();
     SDK_WORKFLOW_ID_MAX_LENGTH = 120;
     SDK_WORKFLOW_TITLE_MAX_LENGTH = 120;
@@ -45287,62 +45613,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 = z67.string().min(1).max(SDK_WORKFLOW_ID_MAX_LENGTH).regex(SDK_WORKFLOW_ID_PATTERN, {
+    sdkWorkflowIdSchema = z68.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 = z67.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 = z67.object({
-      type: z67.literal("manual")
+    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")
     }).strict();
-    sdkWorkflowTriggerFieldSchema = z67.string().trim().min(1).max(SDK_WORKFLOW_TRIGGER_FIELD_MAX_LENGTH).refine((field) => !field.includes("."), {
+    sdkWorkflowTriggerFieldSchema = z68.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 = z67.object({
+    sdkWorkflowFieldChangedConditionSchema = z68.object({
       field: sdkWorkflowTriggerFieldSchema,
-      changed: z67.literal(true)
+      changed: z68.literal(true)
     }).strict();
-    sdkWorkflowFieldEmptyConditionSchema = z67.object({
+    sdkWorkflowFieldEmptyConditionSchema = z68.object({
       field: sdkWorkflowTriggerFieldSchema,
-      isEmpty: z67.boolean()
+      isEmpty: z68.boolean()
     }).strict();
-    sdkWorkflowEntryDraftUpdatedTriggerSchema = z67.object({
-      type: z67.literal("entry.draft.updated"),
-      when: z67.array(
-        z67.union([
+    sdkWorkflowEntryDraftUpdatedTriggerSchema = z68.object({
+      type: z68.literal("entry.draft.updated"),
+      when: z68.array(
+        z68.union([
           sdkWorkflowFieldChangedConditionSchema,
           sdkWorkflowFieldEmptyConditionSchema
         ])
       ).min(1).max(SDK_WORKFLOW_TRIGGER_CONDITION_MAX_COUNT)
     }).strict();
-    sdkWorkflowTriggerSchema = z67.discriminatedUnion("type", [
+    sdkWorkflowTriggerSchema = z68.discriminatedUnion("type", [
       sdkWorkflowManualTriggerSchema,
       sdkWorkflowEntryDraftUpdatedTriggerSchema
     ]);
-    sdkWorkflowConfirmationSchema = z67.object({
-      title: z67.string().trim().min(1).max(SDK_WORKFLOW_CONFIRMATION_TITLE_MAX_LENGTH),
-      body: z67.string().trim().min(1).max(SDK_WORKFLOW_CONFIRMATION_BODY_MAX_LENGTH).optional()
+    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()
     }).strict();
-    sdkWorkflowConfigSchema = z67.object({
+    sdkWorkflowConfigSchema = z68.object({
       id: sdkWorkflowIdSchema,
-      title: z67.string().trim().min(1).max(SDK_WORKFLOW_TITLE_MAX_LENGTH),
-      description: z67.string().trim().min(1).max(SDK_WORKFLOW_DESCRIPTION_MAX_LENGTH).optional(),
-      contentType: z67.string().trim().min(1).max(SDK_WORKFLOW_CONTENT_TYPE_MAX_LENGTH),
+      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),
       endpoint: sdkWorkflowEndpointSchema,
-      triggers: z67.array(sdkWorkflowTriggerSchema).min(1).max(SDK_WORKFLOW_TRIGGER_MAX_COUNT),
+      triggers: z68.array(sdkWorkflowTriggerSchema).min(1).max(SDK_WORKFLOW_TRIGGER_MAX_COUNT),
       confirmation: sdkWorkflowConfirmationSchema.optional()
     }).strict();
-    sdkWorkflowsSchema = z67.array(sdkWorkflowConfigSchema).max(SDK_WORKFLOW_MAX_COUNT, "Maximum 50 workflows per site").refine((workflows) => {
+    sdkWorkflowsSchema = z68.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 = z67.object({
-      siteId: z67.string().uuid(),
-      previewUrl: z67.string().url().optional(),
-      liveUrl: z67.string().url().optional(),
+    riverbankSiteConfigInputSchema = z68.object({
+      siteId: z68.string().uuid(),
+      previewUrl: z68.string().url().optional(),
+      liveUrl: z68.string().url().optional(),
       theme: sdkThemeConfigSchema.optional(),
       styles: sdkSiteStyleConfigSchema.optional(),
       layout: sdkSiteLayoutConfigSchema.optional(),
-      customBlocks: z67.array(sdkCustomBlockInputSchema).max(100, "Maximum 100 custom blocks per site").refine((blocks) => {
+      customBlocks: z68.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(),
@@ -45350,22 +45676,23 @@ var init_contracts2 = __esm({
       blockFieldExtensions: sdkBlockFieldExtensionsInputSchema.optional(),
       workflows: sdkWorkflowsSchema,
       content: sdkContentConfigSchema.optional(),
-      contentDir: z67.string().optional(),
-      sync: z67.object({
-        existingEntries: z67.enum(["skip", "update"]).optional()
+      contentDir: z68.string().optional(),
+      sync: z68.object({
+        existingEntries: z68.enum(["skip", "update"]).optional()
       }).optional(),
-      deploy: z67.object({
-        verifyCommand: z67.string().optional(),
-        prebuildOutput: z67.string().optional()
+      deploy: z68.object({
+        verifyCommand: z68.string().optional(),
+        prebuildOutput: z68.string().optional()
       }).optional(),
-      themeSource: z67.enum(["local", "cms"]).optional(),
-      activeTheme: z67.string().optional(),
-      enablePortal: z67.boolean().optional(),
+      themeSource: z68.enum(["local", "cms"]).optional(),
+      activeTheme: z68.string().optional(),
+      enablePortal: z68.boolean().optional(),
       dashboard: dashboardConfigSchema.optional()
     }).strict();
-    pushSdkConfigBodySchema = z67.object({
+    pushSdkConfigBodySchema = z68.object({
       config: riverbankSiteConfigInputSchema,
-      forceContentTypes: z67.boolean().optional()
+      forceContentTypes: z68.boolean().optional(),
+      mode: z68.enum(["apply", "preview"]).optional()
     }).strict();
   }
 });
@@ -45384,6 +45711,13 @@ var init_incrementalJson = __esm({
   }
 });
 
+// ../api/src/publicExperienceEndpoints.ts
+var init_publicExperienceEndpoints = __esm({
+  "../api/src/publicExperienceEndpoints.ts"() {
+    "use strict";
+  }
+});
+
 // ../api/src/mailchimpIntegration.ts
 var init_mailchimpIntegration = __esm({
   "../api/src/mailchimpIntegration.ts"() {
@@ -45392,7 +45726,7 @@ var init_mailchimpIntegration = __esm({
 });
 
 // ../api/src/siteOnboarding.ts
-import { z as z68 } from "zod";
+import { z as z69 } from "zod";
 var LAUNCH_REQUIREMENT_OVERRIDE_DEFINITIONS, acknowledgeLaunchRequirementRequestSchema, goLiveSiteRequestSchema;
 var init_siteOnboarding = __esm({
   "../api/src/siteOnboarding.ts"() {
@@ -45403,24 +45737,24 @@ var init_siteOnboarding = __esm({
         reason: "launch_anyway"
       }
     };
-    acknowledgeLaunchRequirementRequestSchema = z68.discriminatedUnion(
+    acknowledgeLaunchRequirementRequestSchema = z69.discriminatedUnion(
       "requirementId",
       [
-        z68.object({
-          requirementId: z68.literal("review_generated_site")
+        z69.object({
+          requirementId: z69.literal("review_generated_site")
         }),
-        z68.object({
-          requirementId: z68.literal(
+        z69.object({
+          requirementId: z69.literal(
             LAUNCH_REQUIREMENT_OVERRIDE_DEFINITIONS.configure_appointments.requirementId
           ),
-          overrideReason: z68.literal(
+          overrideReason: z69.literal(
             LAUNCH_REQUIREMENT_OVERRIDE_DEFINITIONS.configure_appointments.reason
           )
         })
       ]
     );
-    goLiveSiteRequestSchema = z68.object({
-      acceptExtraSiteCharge: z68.boolean().optional()
+    goLiveSiteRequestSchema = z69.object({
+      acceptExtraSiteCharge: z69.boolean().optional()
     });
   }
 });
@@ -45609,7 +45943,7 @@ var init_bookingRefundOutcomes = __esm({
 });
 
 // ../api/src/bookingVerticals.ts
-import { z as z69 } from "zod";
+import { z as z70 } from "zod";
 function parseVerticalId(value) {
   return typeof value === "string" && VERTICAL_ID_SET.has(value) ? value : null;
 }
@@ -45790,39 +46124,39 @@ var init_bookingVerticals = __esm({
     VERTICAL_PRESET_ID_SET = new Set(
       VERTICAL_BOOKING_PRESETS.map((presetDefinition) => presetDefinition.id)
     );
-    VerticalIdSchema = z69.string().trim().transform((value, ctx) => {
+    VerticalIdSchema = z70.string().trim().transform((value, ctx) => {
       const parsed = parseVerticalId(value);
       if (!parsed) {
         ctx.addIssue({
-          code: z69.ZodIssueCode.custom,
+          code: z70.ZodIssueCode.custom,
           message: "Unknown booking vertical"
         });
-        return z69.NEVER;
+        return z70.NEVER;
       }
       return parsed;
     });
-    VerticalPresetIdSchema = z69.string().trim().transform((value, ctx) => {
+    VerticalPresetIdSchema = z70.string().trim().transform((value, ctx) => {
       const parsed = parseVerticalPresetId(value);
       if (!parsed) {
         ctx.addIssue({
-          code: z69.ZodIssueCode.custom,
+          code: z70.ZodIssueCode.custom,
           message: "Unknown booking preset"
         });
-        return z69.NEVER;
+        return z70.NEVER;
       }
       return parsed;
     });
-    BookingVerticalConfigSchema = z69.object({
+    BookingVerticalConfigSchema = z70.object({
       verticalId: VerticalIdSchema.nullable(),
-      selectedPresetIds: z69.array(VerticalPresetIdSchema).max(20)
+      selectedPresetIds: z70.array(VerticalPresetIdSchema).max(20)
     }).transform((value, ctx) => {
       const resolved = resolveSiteVerticalBookingConfig(value);
       if (resolved.kind === "invalid") {
         ctx.addIssue({
-          code: z69.ZodIssueCode.custom,
+          code: z70.ZodIssueCode.custom,
           message: `Invalid booking vertical config: ${resolved.issues.join(", ")}`
         });
-        return z69.NEVER;
+        return z70.NEVER;
       }
       return resolved.config;
     });
@@ -45867,7 +46201,7 @@ var init_error_propagation = __esm({
 });
 
 // ../api/src/appointmentSetup.ts
-import { z as z70 } from "zod";
+import { z as z71 } 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"() {
@@ -45875,49 +46209,49 @@ var init_appointmentSetup = __esm({
     init_envelope();
     init_error_propagation();
     APPOINTMENT_SETUP_MAX_MINUTES = 1440;
-    appointmentSetupRefSchema = z70.discriminatedUnion("kind", [
-      z70.object({ kind: z70.literal("existing"), id: z70.string().min(1) }),
-      z70.object({ kind: z70.literal("new"), draftId: z70.string().min(1) })
+    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) })
     ]);
-    appointmentSetupVenueChoiceSchema = z70.discriminatedUnion("kind", [
-      z70.object({ kind: z70.literal("none") }),
-      z70.object({ kind: z70.literal("existing"), venueId: z70.string().min(1) }),
-      z70.object({
-        kind: z70.literal("create"),
-        draftId: z70.string().min(1),
-        title: z70.string().trim().min(1),
-        description: z70.string().nullable(),
-        timezone: z70.string().trim().min(1).nullable(),
-        addressJson: z70.record(z70.string(), z70.unknown()),
-        locationJson: z70.object({ lat: z70.number(), lng: z70.number() }).nullable()
+    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()
       })
     ]);
-    appointmentSetupPaymentDraftSchema = z70.object({
-      priceType: z70.union([z70.literal("free"), z70.literal("paid")])
-    });
-    appointmentSetupServiceAssignmentDraftSchema = z70.discriminatedUnion("kind", [
-      z70.object({ kind: z70.literal("all_practitioners") }),
-      z70.object({
-        kind: z70.literal("selected_practitioners"),
-        resourceRefs: z70.array(appointmentSetupRefSchema)
+    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)
       })
     ]);
-    appointmentSetupServiceDraftSchema = z70.object({
+    appointmentSetupServiceDraftSchema = z71.object({
       ref: appointmentSetupRefSchema,
-      title: z70.string().trim().min(1),
-      description: z70.string().nullable(),
-      durationMinutes: z70.number().int().positive().max(APPOINTMENT_SETUP_MAX_MINUTES),
-      prepMinutes: z70.number().int().nonnegative().max(APPOINTMENT_SETUP_MAX_MINUTES).default(0),
-      cleanupMinutes: z70.number().int().nonnegative().max(APPOINTMENT_SETUP_MAX_MINUTES).default(0),
-      priceAmount: z70.number().int().nonnegative().nullable(),
-      isActive: z70.boolean(),
-      locationType: z70.union([
-        z70.literal("virtual"),
-        z70.literal("in_person"),
-        z70.literal("hybrid")
+      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")
       ]),
       venue: appointmentSetupVenueChoiceSchema,
-      timezone: z70.string().trim().min(1).nullable(),
+      timezone: z71.string().trim().min(1).nullable(),
       payment: appointmentSetupPaymentDraftSchema,
       assignment: appointmentSetupServiceAssignmentDraftSchema
     }).superRefine((service, ctx) => {
@@ -45936,49 +46270,49 @@ var init_appointmentSetup = __esm({
         });
       }
     });
-    appointmentSetupPractitionerDraftSchema = z70.object({
+    appointmentSetupPractitionerDraftSchema = z71.object({
       ref: appointmentSetupRefSchema,
-      displayName: z70.string().trim().min(1),
-      bio: z70.string().nullable(),
-      timezone: z70.string().trim().min(1),
-      colorHex: z70.string().nullable()
-    });
-    appointmentSetupWeeklyWindowDraftSchema = z70.object({
-      weekday: z70.number().int().min(0).max(6),
-      startTime: z70.string(),
-      endTime: z70.string()
-    });
-    appointmentSetupStartTimePolicyDraftSchema = z70.discriminatedUnion("kind", [
-      z70.object({ kind: z70.literal("automatic_spacing") }),
-      z70.object({
-        kind: z70.literal("regular_interval"),
-        intervalMinutes: z70.union([
-          z70.literal(10),
-          z70.literal(15),
-          z70.literal(20),
-          z70.literal(30),
-          z70.literal(45),
-          z70.literal(60)
+      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)
         ])
       })
     ]);
-    appointmentSetupAvailabilityDraftSchema = z70.object({
-      kind: z70.literal("weekly_windows"),
+    appointmentSetupAvailabilityDraftSchema = z71.object({
+      kind: z71.literal("weekly_windows"),
       resourceRef: appointmentSetupRefSchema,
       serviceRef: appointmentSetupRefSchema.nullable(),
-      windows: z70.array(appointmentSetupWeeklyWindowDraftSchema),
+      windows: z71.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 = z70.object({
-      minLeadMinutes: z70.number().int().nonnegative().max(APPOINTMENT_DEFAULT_MIN_LEAD_MINUTES_MAX),
-      maxBookingNoticeMinutes: z70.number().int().nonnegative().max(APPOINTMENT_DEFAULT_MAX_BOOKING_NOTICE_MINUTES_MAX)
-    });
-    applyAppointmentSetupRequestSchema = z70.object({
-      services: z70.array(appointmentSetupServiceDraftSchema),
-      practitioners: z70.array(appointmentSetupPractitionerDraftSchema),
-      availability: z70.array(appointmentSetupAvailabilityDraftSchema),
+    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),
       bookingNotice: appointmentSetupBookingNoticeSchema
     });
   }
@@ -46102,7 +46436,7 @@ var init_eventAttendanceLabels = __esm({
 });
 
 // ../api/src/siteBanner.ts
-import { z as z71 } from "zod";
+import { z as z72 } from "zod";
 function analyzeSiteBannerBody(body) {
   const sanitizedBody = sanitizeSiteBannerBodyInternal(body, { limitParagraphs: false });
   const paragraphs = collectParagraphs(sanitizedBody);
@@ -46285,19 +46619,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 = z71.enum(SITE_BANNER_SCOPE_VALUES);
-    siteBannerToneSchema = z71.enum(SITE_BANNER_TONE_VALUES);
-    siteBannerBodySchema = z71.unknown().transform(unwrapRichTextValue);
-    siteBannerCtaSchema = z71.object({
-      label: z71.string().trim().min(1),
+    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),
       link: linkPayloadSchema
     });
-    siteBannerSettingsSchema = z71.discriminatedUnion("enabled", [
-      z71.object({
-        enabled: z71.literal(false)
+    siteBannerSettingsSchema = z72.discriminatedUnion("enabled", [
+      z72.object({
+        enabled: z72.literal(false)
       }),
-      z71.object({
-        enabled: z71.literal(true),
+      z72.object({
+        enabled: z72.literal(true),
         scope: siteBannerScopeSchema,
         tone: siteBannerToneSchema,
         body: siteBannerBodySchema,
@@ -46311,7 +46645,7 @@ var init_siteBanner = __esm({
       const analysis = analyzeSiteBannerBody(value.body);
       for (const issue of analysis.issues) {
         ctx.addIssue({
-          code: z71.ZodIssueCode.custom,
+          code: z72.ZodIssueCode.custom,
           path: ["body"],
           message: siteBannerBodyIssueMessage(issue)
         });
@@ -46711,75 +47045,75 @@ var init_aiPatch = __esm({
 });
 
 // ../api/src/aiPlayground.ts
-import { z as z72 } from "zod";
+import { z as z73 } from "zod";
 var Rfc6902PatchOp, PlaygroundProposeRequest, MultiPagePatchEnvelope, MultiPageUpdateResponse;
 var init_aiPlayground = __esm({
   "../api/src/aiPlayground.ts"() {
     "use strict";
-    Rfc6902PatchOp = z72.discriminatedUnion("op", [
+    Rfc6902PatchOp = z73.discriminatedUnion("op", [
       // Standard RFC-6902 operations
-      z72.object({
-        op: z72.literal("add"),
-        path: z72.string(),
-        value: z72.unknown()
+      z73.object({
+        op: z73.literal("add"),
+        path: z73.string(),
+        value: z73.unknown()
       }),
-      z72.object({
-        op: z72.literal("remove"),
-        path: z72.string()
+      z73.object({
+        op: z73.literal("remove"),
+        path: z73.string()
       }),
-      z72.object({
-        op: z72.literal("replace"),
-        path: z72.string(),
-        value: z72.unknown()
+      z73.object({
+        op: z73.literal("replace"),
+        path: z73.string(),
+        value: z73.unknown()
       }),
-      z72.object({
-        op: z72.literal("move"),
-        from: z72.string(),
-        path: z72.string()
+      z73.object({
+        op: z73.literal("move"),
+        from: z73.string(),
+        path: z73.string()
       }),
-      z72.object({
-        op: z72.literal("copy"),
-        from: z72.string(),
-        path: z72.string()
+      z73.object({
+        op: z73.literal("copy"),
+        from: z73.string(),
+        path: z73.string()
       }),
       // Block-level operations (Phase 2)
-      z72.object({
-        op: z72.literal("add_block"),
-        blockKind: z72.string(),
-        afterBlockId: z72.string().nullable(),
-        content: z72.record(z72.string(), z72.unknown()),
-        rationale: z72.string()
+      z73.object({
+        op: z73.literal("add_block"),
+        blockKind: z73.string(),
+        afterBlockId: z73.string().nullable(),
+        content: z73.record(z73.string(), z73.unknown()),
+        rationale: z73.string()
       }),
-      z72.object({
-        op: z72.literal("delete_block"),
-        blockId: z72.string(),
-        rationale: z72.string()
+      z73.object({
+        op: z73.literal("delete_block"),
+        blockId: z73.string(),
+        rationale: z73.string()
       }),
-      z72.object({
-        op: z72.literal("reorder_block"),
-        blockId: z72.string(),
-        afterBlockId: z72.string().nullable(),
-        rationale: z72.string()
+      z73.object({
+        op: z73.literal("reorder_block"),
+        blockId: z73.string(),
+        afterBlockId: z73.string().nullable(),
+        rationale: z73.string()
       })
     ]);
-    PlaygroundProposeRequest = z72.object({
-      request: z72.string().min(1).max(2e3)
+    PlaygroundProposeRequest = z73.object({
+      request: z73.string().min(1).max(2e3)
     });
-    MultiPagePatchEnvelope = z72.object({
-      pageId: z72.string(),
-      blockId: z72.string().optional(),
+    MultiPagePatchEnvelope = z73.object({
+      pageId: z73.string(),
+      blockId: z73.string().optional(),
       // Not present for page-level ops
-      blockKind: z72.string().optional(),
-      blockPurpose: z72.string().optional().nullable(),
-      ops: z72.array(Rfc6902PatchOp),
-      rationale: z72.string(),
-      currentContent: z72.record(z72.string(), z72.unknown()).optional()
+      blockKind: z73.string().optional(),
+      blockPurpose: z73.string().optional().nullable(),
+      ops: z73.array(Rfc6902PatchOp),
+      rationale: z73.string(),
+      currentContent: z73.record(z73.string(), z73.unknown()).optional()
     });
-    MultiPageUpdateResponse = z72.object({
-      patches: z72.array(MultiPagePatchEnvelope),
-      assistantMessage: z72.string(),
-      pagesModified: z72.number(),
-      toolCallsUsed: z72.number()
+    MultiPageUpdateResponse = z73.object({
+      patches: z73.array(MultiPagePatchEnvelope),
+      assistantMessage: z73.string(),
+      pagesModified: z73.number(),
+      toolCallsUsed: z73.number()
     });
   }
 });
@@ -46850,6 +47184,7 @@ var init_src5 = __esm({
     init_contracts2();
     init_sdkContracts();
     init_incrementalJson();
+    init_publicExperienceEndpoints();
     init_mailchimpIntegration();
     init_launchReadiness();
     init_url();
@@ -47154,6 +47489,15 @@ async function getPublicBookingServices({ client, params }) {
     ids: readStringParam(params, "ids")
   });
 }
+async function getPublicWeeklySlotAvailability({ client, params }) {
+  return await client.getPublicWeeklySlotAvailability({
+    siteId: requireStringParam(params, "siteId", "getPublicWeeklySlotAvailability"),
+    serviceId: requireStringParam(params, "serviceId", "getPublicWeeklySlotAvailability"),
+    resourceId: readStringParam(params, "resourceId"),
+    horizonWeeks: parsePositiveIntegerParam(params, "horizonWeeks"),
+    timezone: readStringParam(params, "timezone")
+  });
+}
 async function prefetchBlockData2(page, context, client, options) {
   const { customBlocks } = options ?? {};
   const customBlockMap = new Map(
@@ -47219,7 +47563,8 @@ var init_prefetchBlockData2 = __esm({
       listPublicPasses,
       listPublicMemberships,
       getPublicFormById,
-      getPublicBookingServices
+      getPublicBookingServices,
+      getPublicWeeklySlotAvailability
     };
   }
 });
@@ -47377,7 +47722,16 @@ __export(loadPage_exports, {
   loadPage: () => loadPage
 });
 async function loadPage(params) {
-  const { client, siteId, path, pageId, preview = false, dataLoaderOverrides, searchParams, forceSite } = params;
+  const {
+    client,
+    siteId,
+    path,
+    pageId,
+    preview = false,
+    dataLoaderOverrides,
+    searchParams,
+    forceSite
+  } = params;
   const [site, pageResponse] = await Promise.all([
     client.getSite({ id: siteId, ...forceSite ? { force: true } : {} }),
     client.getPage({ siteId, path, preview })
@@ -47387,6 +47741,11 @@ async function loadPage(params) {
       "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."
     );
   }
+  if ("pageSurface" in pageResponse) {
+    throw new Error(
+      "This path resolves to a page surface, not a page. Use loadContent() instead, which handles pages, entries, and page surfaces."
+    );
+  }
   const { page: pageData } = pageResponse;
   const support = buildSiteRenderSupport(
     site,
@@ -47416,7 +47775,11 @@ async function loadPage(params) {
   );
   let resolvedData = configData;
   if (dataLoaderOverrides && Object.keys(dataLoaderOverrides).length > 0) {
-    const codeData = await executeCodeLoaders(pageOutline, prefetchContext, dataLoaderOverrides);
+    const codeData = await executeCodeLoaders(
+      pageOutline,
+      prefetchContext,
+      dataLoaderOverrides
+    );
     resolvedData = mergeLoaderResults(configData, codeData);
   }
   return {