@riverbankcms/sdk 0.96.0 → 0.98.0

package/dist/server/server.mjs

@@ -1092,6 +1092,94 @@ var ENDPOINT_DEFINITIONS = {
     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",
@@ -3548,6 +3636,18 @@ var ENDPOINT_DEFINITIONS = {
     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",
@@ -3686,6 +3786,15 @@ var ENDPOINT_DEFINITIONS = {
     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",
@@ -7184,7 +7293,7 @@ var SimpleCache = class {
 };
 
 // src/version.ts
-var SDK_VERSION = "0.96.0";
+var SDK_VERSION = "0.98.0";
 
 // src/client/error.ts
 var RiverbankApiError = class _RiverbankApiError extends Error {
@@ -7346,11 +7455,13 @@ var PUBLIC_ENDPOINT_NAMES2 = [
   "getSite",
   "getContentByPath",
   "resolveRouteOutcome",
+  "resolveRouteDecision",
   "listPublishedEntries",
   "getPublishedEntryPreview",
   "getPublicFormById",
   "listPublicForms",
   "getPublicBookingServices",
+  "getPublicWeeklySlotAvailability",
   "getPublicChallenge",
   "listPublicEvents",
   "batchBlockLoaders",
@@ -7393,6 +7504,17 @@ var API_ENDPOINTS2 = Object.freeze({
     auth: "public",
     responseKind: "json"
   },
+  resolveRouteDecision: {
+    path: "/sites/{siteId}/route-decision",
+    method: "GET",
+    tags: [
+      "riverbank:site:{siteId}:routable-content",
+      "riverbank:site:{siteId}:redirects",
+      "riverbank:site:{siteId}:route-outcomes"
+    ],
+    auth: "public",
+    responseKind: "json"
+  },
   listPublishedEntries: {
     path: "/public/content/{siteId}/{type}/entries",
     method: "GET",
@@ -7433,6 +7555,14 @@ var API_ENDPOINTS2 = Object.freeze({
     auth: "public",
     responseKind: "json"
   },
+  getPublicWeeklySlotAvailability: {
+    path: "/public/bookings/weekly-slot-availability",
+    method: "GET",
+    revalidate: 60,
+    tags: ["site-{siteId}"],
+    auth: "public",
+    responseKind: "json"
+  },
   getPublicChallenge: {
     path: "/public/challenge",
     method: "GET",
@@ -7560,6 +7690,10 @@ var RUNTIME_CACHE_DURABILITY_OVERRIDES = {
     kind: "memory-only",
     reason: "durable_rollout_pending"
   },
+  resolveRouteDecision: {
+    kind: "memory-only",
+    reason: "durable_rollout_pending"
+  },
   listPublishedEntries: {
     kind: "memory-only",
     reason: "durable_rollout_pending"
@@ -7580,6 +7714,10 @@ var RUNTIME_CACHE_DURABILITY_OVERRIDES = {
     kind: "live-only",
     reason: "safety_sensitive_booking"
   },
+  getPublicWeeklySlotAvailability: {
+    kind: "live-only",
+    reason: "safety_sensitive_booking"
+  },
   getPublicChallenge: {
     kind: "live-only",
     reason: "challenge_endpoint"
@@ -7794,7 +7932,8 @@ function deriveGetContentByPathKey(params) {
   }
   const normalizedParams = {
     siteId: normalizeScalar(siteId),
-    path: normalizeRuntimePublicPath(params.path)
+    path: normalizeRuntimePublicPath(params.path),
+    ...params.contentContract === "native" ? { contentContract: "native" } : {}
   };
   return {
     ok: true,
@@ -8763,19 +8902,30 @@ function createRiverbankClient(config) {
     );
   }
   async function getPageWithResilienceInternal(params) {
-    const { siteId, path, preview = false, signal } = params;
+    const {
+      siteId,
+      path,
+      preview = false,
+      signal,
+      contentContract = "compat"
+    } = params;
     const publishedRuntimeCache = planPublishedRuntimeCache({
       endpoint: "getContentByPath",
-      params: { siteId, path, preview },
+      params: { siteId, path, preview, contentContract },
       siteId
     });
-    const cacheKey = publishedRuntimeCache?.cacheKey ?? `page:${siteId}:${path}:${preview}`;
+    const cacheKey = publishedRuntimeCache?.cacheKey ?? `page:${siteId}:${path}:${preview}:${contentContract}`;
     return resilientFetch(
       cacheKey,
       async (sig) => {
         return await apiClient({
           endpoint: "getContentByPath",
-          params: { siteId, path, preview: String(preview) },
+          params: {
+            siteId,
+            path,
+            preview: String(preview),
+            ...contentContract === "native" ? { contentContract } : {}
+          },
           options: { signal: sig }
         });
       },
@@ -8784,7 +8934,7 @@ function createRiverbankClient(config) {
         signal,
         publishedRuntimeCache,
         // Prebuild fallback only for published pages (not preview)
-        prebuildFallback: prebuildLoader && !preview ? () => prebuildLoader.loadPage(siteId, path) : void 0
+        prebuildFallback: prebuildLoader && !preview && contentContract !== "native" ? () => prebuildLoader.loadPage(siteId, path) : void 0
       }
     );
   }
@@ -8973,6 +9123,38 @@ function createRiverbankClient(config) {
         { signal }
       );
     },
+    async getPublicWeeklySlotAvailability(params) {
+      const { siteId, serviceId, resourceId, horizonWeeks, timezone, signal } = params;
+      if (!siteId || !serviceId) {
+        throw new Error("getPublicWeeklySlotAvailability() requires siteId and serviceId");
+      }
+      const cacheKey = [
+        "public-weekly-slot-availability",
+        siteId,
+        serviceId,
+        resourceId ?? "",
+        horizonWeeks ?? "",
+        timezone ?? ""
+      ].join(":");
+      return resilientFetchData(
+        cacheKey,
+        async (sig) => {
+          const apiParams = {
+            siteId,
+            serviceId,
+            ...resourceId && { resourceId },
+            ...horizonWeeks !== void 0 && { horizonWeeks: String(horizonWeeks) },
+            ...timezone && { timezone }
+          };
+          return await apiClient({
+            endpoint: "getPublicWeeklySlotAvailability",
+            params: apiParams,
+            options: { signal: sig }
+          });
+        },
+        { signal }
+      );
+    },
     async listPublicEvents(params) {
       const {
         siteId,
@@ -9274,6 +9456,19 @@ function createRiverbankClient(config) {
         })
       );
     },
+    async resolveRouteDecision(params) {
+      const { siteId, path, preview = false, signal } = params;
+      if (!siteId || !path) {
+        throw new Error("resolveRouteDecision() requires siteId and path");
+      }
+      return unwrapResponse(
+        await apiClient({
+          endpoint: "resolveRouteDecision",
+          params: { siteId, path, preview: String(preview) },
+          options: { signal }
+        })
+      );
+    },
     async getAllPublishedRoutes(params) {
       const { siteId, signal } = params;
       if (!siteId) {
@@ -9669,7 +9864,7 @@ var navigationLinkInputSchema = z2.discriminatedUnion(
 );
 
 // ../api/src/sdkConfig/contracts.ts
-import { z as z64 } from "zod";
+import { z as z65 } from "zod";
 
 // ../blocks/src/system/manifest/augmentManifest.ts
 function augmentManifest(manifest) {
@@ -9838,10 +10033,20 @@ var repeatSchema = z3.object({
     direction: z3.enum(["asc", "desc"]).default("asc")
   }).optional()
 });
+var conditionalAuthoringPresenceSchema = z3.discriminatedUnion("kind", [
+  z3.object({ kind: z3.literal("visitor-only") }),
+  z3.object({
+    kind: z3.literal("recover-empty-when-active"),
+    placeholder: z3.string().min(1).optional()
+  })
+]);
 var conditionSchema = z3.object({
   when: bindingSchema,
   equals: z3.unknown().optional(),
-  not: z3.boolean().default(false)
+  not: z3.boolean().default(false),
+  authoringPresence: conditionalAuthoringPresenceSchema.default({
+    kind: "visitor-only"
+  })
 });
 var dataScopeSchema = z3.object({
   name: z3.string().min(1),
@@ -20994,7 +21199,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 } : {}
     }
   });
 }
@@ -30835,77 +31041,247 @@ var appointmentBookingBlockDefinition = {
   }
 };
 
+// ../blocks/src/system/blocks/weekly-slot-availability.ts
+import { z as z40 } from "zod";
+var 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"
+    })
+  ]
+});
+var weeklySlotAvailabilityOptionSchema = z40.object({
+  id: z40.string(),
+  resourceId: z40.string(),
+  weekday: z40.number(),
+  weekdayLabel: z40.string(),
+  startTime: z40.string(),
+  endTime: z40.string(),
+  nextDate: z40.string(),
+  availableWeeks: z40.number()
+});
+var weeklySlotAvailabilityDataSchema = z40.object({
+  slots: z40.array(weeklySlotAvailabilityOptionSchema),
+  horizonWeeks: z40.number(),
+  timezone: z40.string(),
+  startDate: z40.string(),
+  endDate: z40.string()
+});
+var 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/schemas.ts
-import { z as z44 } from "zod";
+import { z as z45 } from "zod";
 
 // ../blocks/src/lib/media.ts
-import z40 from "zod";
+import z41 from "zod";
 var PUBLIC_DOWNLOAD_MEDIA_TYPES = [
   "document",
   "spreadsheet",
   "archive",
   "audio"
 ];
-var hotspotSchema2 = z40.object({
-  x: z40.number().min(0).max(1),
-  y: z40.number().min(0).max(1),
-  radius: z40.number().optional()
-});
-var rotationSchema2 = z40.union([z40.literal(0), z40.literal(90), z40.literal(180), z40.literal(270)]);
-var rectSchema2 = z40.tuple([z40.number(), z40.number(), z40.number(), z40.number()]);
-var aspectCropSchema2 = z40.object({
-  aspect: z40.preprocess((value) => value == null ? void 0 : value, z40.string().optional()),
-  rect: z40.preprocess((value) => value == null ? void 0 : value, rectSchema2.optional()),
-  hotspot: z40.preprocess((value) => value == null ? void 0 : value, hotspotSchema2.optional()),
-  rotation: z40.preprocess((value) => value == null ? void 0 : value, rotationSchema2.optional())
-});
-var transformSchema2 = z40.object({
-  aspectCrops: z40.preprocess((value) => {
+var hotspotSchema2 = z41.object({
+  x: z41.number().min(0).max(1),
+  y: z41.number().min(0).max(1),
+  radius: z41.number().optional()
+});
+var rotationSchema2 = z41.union([z41.literal(0), z41.literal(90), z41.literal(180), z41.literal(270)]);
+var rectSchema2 = z41.tuple([z41.number(), z41.number(), z41.number(), z41.number()]);
+var aspectCropSchema2 = z41.object({
+  aspect: z41.preprocess((value) => value == null ? void 0 : value, z41.string().optional()),
+  rect: z41.preprocess((value) => value == null ? void 0 : value, rectSchema2.optional()),
+  hotspot: z41.preprocess((value) => value == null ? void 0 : value, hotspotSchema2.optional()),
+  rotation: z41.preprocess((value) => value == null ? void 0 : value, rotationSchema2.optional())
+});
+var transformSchema2 = z41.object({
+  aspectCrops: z41.preprocess((value) => {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
       return void 0;
     }
     return value;
-  }, z40.record(z40.string(), aspectCropSchema2.catch({}))).optional(),
+  }, z41.record(z41.string(), aspectCropSchema2.catch({}))).optional(),
   rect: rectSchema2.optional(),
   hotspot: hotspotSchema2.optional(),
   rotation: rotationSchema2.optional()
 });
-var mediaPosterSchema = z40.discriminatedUnion("tag", [
-  z40.object({
-    tag: z40.literal("storage"),
-    assetId: z40.string().optional(),
-    storageBucket: z40.string().min(1),
-    storagePath: z40.string().min(1)
+var mediaPosterSchema = z41.discriminatedUnion("tag", [
+  z41.object({
+    tag: z41.literal("storage"),
+    assetId: z41.string().optional(),
+    storageBucket: z41.string().min(1),
+    storagePath: z41.string().min(1)
   }),
-  z40.object({
-    tag: z40.literal("external-src"),
-    assetId: z40.string().optional(),
-    src: z40.string().url()
+  z41.object({
+    tag: z41.literal("external-src"),
+    assetId: z41.string().optional(),
+    src: z41.string().url()
   })
 ]);
-var mediaBaseSchema = z40.object({
-  purpose: z40.string().optional(),
-  placeholder: z40.boolean().default(true).optional(),
-  assetId: z40.string().optional(),
-  identifier: z40.string().optional(),
-  src: z40.string().optional(),
-  alt: z40.string().optional(),
-  filename: z40.string().optional(),
-  mimeType: z40.string().optional(),
-  width: z40.number().optional(),
-  height: z40.number().optional(),
-  storageBucket: z40.string().optional(),
-  storagePath: z40.string().optional(),
+var mediaBaseSchema = z41.object({
+  purpose: z41.string().optional(),
+  placeholder: z41.boolean().default(true).optional(),
+  assetId: z41.string().optional(),
+  identifier: z41.string().optional(),
+  src: z41.string().optional(),
+  alt: z41.string().optional(),
+  filename: z41.string().optional(),
+  mimeType: z41.string().optional(),
+  width: z41.number().optional(),
+  height: z41.number().optional(),
+  storageBucket: z41.string().optional(),
+  storagePath: z41.string().optional(),
   poster: mediaPosterSchema.optional(),
   transform: transformSchema2.optional()
 });
-var imageMediaSchema = mediaBaseSchema.extend({ type: z40.literal("image") });
-var videoMediaSchema = mediaBaseSchema.extend({ type: z40.literal("video") });
-var audioMediaSchema = mediaBaseSchema.extend({ type: z40.literal("audio") });
-var documentMediaSchema = mediaBaseSchema.extend({ type: z40.literal("document") });
-var spreadsheetMediaSchema = mediaBaseSchema.extend({ type: z40.literal("spreadsheet") });
-var archiveMediaSchema = mediaBaseSchema.extend({ type: z40.literal("archive") });
-var mediaSchema2 = z40.discriminatedUnion("type", [
+var imageMediaSchema = mediaBaseSchema.extend({ type: z41.literal("image") });
+var videoMediaSchema = mediaBaseSchema.extend({ type: z41.literal("video") });
+var audioMediaSchema = mediaBaseSchema.extend({ type: z41.literal("audio") });
+var documentMediaSchema = mediaBaseSchema.extend({ type: z41.literal("document") });
+var spreadsheetMediaSchema = mediaBaseSchema.extend({ type: z41.literal("spreadsheet") });
+var archiveMediaSchema = mediaBaseSchema.extend({ type: z41.literal("archive") });
+var mediaSchema2 = z41.discriminatedUnion("type", [
   imageMediaSchema,
   videoMediaSchema,
   audioMediaSchema,
@@ -30915,31 +31291,31 @@ var mediaSchema2 = z40.discriminatedUnion("type", [
 ]);
 
 // ../blocks/src/system/manifest/richTextSchema.ts
-import { z as z41 } from "zod";
-var TipTapMarkSchema = z41.object({
-  type: z41.string(),
-  attrs: z41.record(z41.string(), z41.unknown()).optional()
-});
-var TipTapNodeSchema = z41.lazy(
-  () => z41.object({
-    type: z41.string(),
-    content: z41.array(TipTapNodeSchema).optional(),
-    text: z41.string().optional(),
-    attrs: z41.record(z41.string(), z41.unknown()).optional(),
-    marks: z41.array(TipTapMarkSchema).optional()
+import { z as z42 } from "zod";
+var TipTapMarkSchema = z42.object({
+  type: z42.string(),
+  attrs: z42.record(z42.string(), z42.unknown()).optional()
+});
+var TipTapNodeSchema = z42.lazy(
+  () => z42.object({
+    type: z42.string(),
+    content: z42.array(TipTapNodeSchema).optional(),
+    text: z42.string().optional(),
+    attrs: z42.record(z42.string(), z42.unknown()).optional(),
+    marks: z42.array(TipTapMarkSchema).optional()
   })
 );
-var RichTextValueSchema = z41.union([
+var RichTextValueSchema = z42.union([
   // Canonical: TipTap document directly
   TipTapNodeSchema,
   // Legacy (read-tolerance only): wrapped in { doc: {...} }
-  z41.object({
+  z42.object({
     doc: TipTapNodeSchema
   })
 ]);
-var RichTextDocSchema = z41.object({
-  type: z41.literal("doc"),
-  content: z41.array(TipTapNodeSchema)
+var RichTextDocSchema = z42.object({
+  type: z42.literal("doc"),
+  content: z42.array(TipTapNodeSchema)
 });
 function unwrapRichTextRoot(value) {
   if (!isRecord3(value)) return value;
@@ -30950,344 +31326,344 @@ function unwrapRichTextRoot(value) {
 }
 
 // ../blocks/src/system/blocks/shared/bookingPaymentTerms.ts
-import { z as z42 } from "zod";
-var bookingDepositRefundPolicySchema = z42.enum([
+import { z as z43 } from "zod";
+var bookingDepositRefundPolicySchema = z43.enum([
   "refundable",
   "non_refundable"
 ]);
-var bookingInstalmentPlanSchema = z42.union([
-  z42.object({
-    kind: z42.literal("deposit_plus_one_remainder"),
-    depositAmountCents: z42.number().int().min(0),
+var bookingInstalmentPlanSchema = z43.union([
+  z43.object({
+    kind: z43.literal("deposit_plus_one_remainder"),
+    depositAmountCents: z43.number().int().min(0),
     depositRefundability: bookingDepositRefundPolicySchema,
-    remainderDueCount: z42.number().int().positive(),
-    intervalUnit: z42.enum(["day", "week", "month"])
+    remainderDueCount: z43.number().int().positive(),
+    intervalUnit: z43.enum(["day", "week", "month"])
   }),
-  z42.object({
-    kind: z42.literal("deposit_plus_scheduled_instalments"),
-    depositAmountCents: z42.number().int().min(0),
+  z43.object({
+    kind: z43.literal("deposit_plus_scheduled_instalments"),
+    depositAmountCents: z43.number().int().min(0),
     depositRefundability: bookingDepositRefundPolicySchema,
-    instalmentCount: z42.number().int().positive(),
-    intervalCount: z42.number().int().positive(),
-    intervalUnit: z42.enum(["day", "week", "month"])
+    instalmentCount: z43.number().int().positive(),
+    intervalCount: z43.number().int().positive(),
+    intervalUnit: z43.enum(["day", "week", "month"])
   }),
-  z42.object({
-    kind: z42.literal("equal_scheduled_instalments"),
-    instalmentCount: z42.number().int().positive(),
-    intervalCount: z42.number().int().positive(),
-    intervalUnit: z42.enum(["day", "week", "month"])
+  z43.object({
+    kind: z43.literal("equal_scheduled_instalments"),
+    instalmentCount: z43.number().int().positive(),
+    intervalCount: z43.number().int().positive(),
+    intervalUnit: z43.enum(["day", "week", "month"])
   })
 ]);
-var bookingFlexibleBalanceDueDateRuleSchema = z42.union([
-  z42.object({
-    kind: z42.literal("relative_to_start_date"),
-    daysBeforeStart: z42.number().int().positive()
+var bookingFlexibleBalanceDueDateRuleSchema = z43.union([
+  z43.object({
+    kind: z43.literal("relative_to_start_date"),
+    daysBeforeStart: z43.number().int().positive()
   }),
-  z42.object({
-    kind: z42.literal("fixed_calendar_date"),
-    dueAt: z42.string().datetime()
+  z43.object({
+    kind: z43.literal("fixed_calendar_date"),
+    dueAt: z43.string().datetime()
   })
 ]);
-var bookingFlexibleBalanceConfigSchema = z42.object({
-  upfrontAmountCents: z42.number().int().min(0),
+var bookingFlexibleBalanceConfigSchema = z43.object({
+  upfrontAmountCents: z43.number().int().min(0),
   dueDateRule: bookingFlexibleBalanceDueDateRuleSchema,
   depositRefundability: bookingDepositRefundPolicySchema
 });
-var blockBookingPaymentCollectionOptionSchema = z42.union([
-  z42.object({
-    kind: z42.literal("upfront")
+var blockBookingPaymentCollectionOptionSchema = z43.union([
+  z43.object({
+    kind: z43.literal("upfront")
   }),
-  z42.object({
-    kind: z42.literal("deferred_manual")
+  z43.object({
+    kind: z43.literal("deferred_manual")
   }),
-  z42.object({
-    kind: z42.literal("instalment_plan"),
+  z43.object({
+    kind: z43.literal("instalment_plan"),
     plan: bookingInstalmentPlanSchema
   }),
-  z42.object({
-    kind: z42.literal("flexible_balance"),
+  z43.object({
+    kind: z43.literal("flexible_balance"),
     config: bookingFlexibleBalanceConfigSchema
   })
 ]);
-var blockBookingPaymentTermsSchema = z42.object({
-  allowedOptions: z42.array(blockBookingPaymentCollectionOptionSchema).min(1)
+var blockBookingPaymentTermsSchema = z43.object({
+  allowedOptions: z43.array(blockBookingPaymentCollectionOptionSchema).min(1)
 });
 
 // ../blocks/src/system/blocks/courses/shared/schemas.ts
-import { z as z43 } from "zod";
-var courseVenueSchema = z43.object({
-  id: z43.string(),
-  name: z43.string(),
-  address: z43.string().nullable()
-});
-var courseSessionSchema = z43.object({
-  id: z43.string(),
-  startsAt: z43.string(),
-  endsAt: z43.string(),
-  timeZone: z43.string(),
-  capacityOverride: z43.number().nullable().optional(),
-  overrides: z43.record(z43.string(), z43.unknown()).nullable().optional()
-});
-var courseTeamMemberSummarySchema = z43.object({
-  id: z43.string(),
-  name: z43.string(),
-  roleLabel: z43.string().nullable(),
-  summary: z43.string().nullable(),
-  profilePath: z43.string().nullable()
-});
-var coursePricingOptionSchema = z43.object({
-  id: z43.string(),
-  name: z43.string(),
-  description: z43.string().nullable(),
-  priceAmount: z43.number(),
-  isActive: z43.boolean(),
-  sortOrder: z43.number(),
-  capacityLimit: z43.number().nullable(),
-  saleStartsAt: z43.string().nullable(),
-  saleEndsAt: z43.string().nullable(),
-  attendanceScope: z43.enum(["in_person", "online", "both"]).nullable().optional()
-});
-var coursePricingSchema = z43.object({
-  bookingRequirement: z43.enum(["none", "required"]),
-  pricingStrategy: z43.enum(["free", "single", "tiered", "sliding_scale"]),
-  currency: z43.string(),
-  singlePriceAmount: z43.number().nullable(),
-  slidingMinAmount: z43.number().nullable().optional(),
-  slidingMaxAmount: z43.number().nullable().optional(),
-  slidingSuggestedAmount: z43.number().nullable().optional(),
+import { z as z44 } from "zod";
+var courseVenueSchema = z44.object({
+  id: z44.string(),
+  name: z44.string(),
+  address: z44.string().nullable()
+});
+var courseSessionSchema = z44.object({
+  id: z44.string(),
+  startsAt: z44.string(),
+  endsAt: z44.string(),
+  timeZone: z44.string(),
+  capacityOverride: z44.number().nullable().optional(),
+  overrides: z44.record(z44.string(), z44.unknown()).nullable().optional()
+});
+var courseTeamMemberSummarySchema = z44.object({
+  id: z44.string(),
+  name: z44.string(),
+  roleLabel: z44.string().nullable(),
+  summary: z44.string().nullable(),
+  profilePath: z44.string().nullable()
+});
+var coursePricingOptionSchema = z44.object({
+  id: z44.string(),
+  name: z44.string(),
+  description: z44.string().nullable(),
+  priceAmount: z44.number(),
+  isActive: z44.boolean(),
+  sortOrder: z44.number(),
+  capacityLimit: z44.number().nullable(),
+  saleStartsAt: z44.string().nullable(),
+  saleEndsAt: z44.string().nullable(),
+  attendanceScope: z44.enum(["in_person", "online", "both"]).nullable().optional()
+});
+var coursePricingSchema = z44.object({
+  bookingRequirement: z44.enum(["none", "required"]),
+  pricingStrategy: z44.enum(["free", "single", "tiered", "sliding_scale"]),
+  currency: z44.string(),
+  singlePriceAmount: z44.number().nullable(),
+  slidingMinAmount: z44.number().nullable().optional(),
+  slidingMaxAmount: z44.number().nullable().optional(),
+  slidingSuggestedAmount: z44.number().nullable().optional(),
   paymentTerms: blockBookingPaymentTermsSchema,
-  options: z43.array(coursePricingOptionSchema)
-});
-var publicCourseSchema = z43.object({
-  id: z43.string(),
-  title: z43.string(),
-  slug: z43.string(),
-  description: z43.unknown().nullable(),
-  teamMembers: z43.array(courseTeamMemberSummarySchema).optional(),
-  enrollmentOpen: z43.boolean(),
+  options: z44.array(coursePricingOptionSchema)
+});
+var publicCourseSchema = z44.object({
+  id: z44.string(),
+  title: z44.string(),
+  slug: z44.string(),
+  description: z44.unknown().nullable(),
+  teamMembers: z44.array(courseTeamMemberSummarySchema).optional(),
+  enrollmentOpen: z44.boolean(),
   pricing: coursePricingSchema.optional(),
-  priceCents: z43.number().nullable(),
-  currency: z43.string(),
+  priceCents: z44.number().nullable(),
+  currency: z44.string(),
   paymentTerms: blockBookingPaymentTermsSchema,
-  enrollmentCapacity: z43.number().nullable(),
-  acceptsMemberships: z43.boolean(),
-  status: z43.enum(["active", "draft", "cancelled"]),
-  sessionsCount: z43.number(),
-  enrolledCount: z43.number(),
-  availableSpots: z43.number().nullable(),
-  sessions: z43.array(courseSessionSchema),
+  enrollmentCapacity: z44.number().nullable(),
+  acceptsMemberships: z44.boolean(),
+  status: z44.enum(["active", "draft", "cancelled"]),
+  sessionsCount: z44.number(),
+  enrolledCount: z44.number(),
+  availableSpots: z44.number().nullable(),
+  sessions: z44.array(courseSessionSchema),
   venue: courseVenueSchema.nullable(),
-  contentEntryId: z43.string().nullable()
+  contentEntryId: z44.string().nullable()
 });
-var publicCoursesArraySchema = z43.array(publicCourseSchema);
+var publicCoursesArraySchema = z44.array(publicCourseSchema);
 
 // ../blocks/src/system/blocks/events/shared/schemas.ts
-var eventPresetSchema = z44.enum(["event", "class", "workshop", "retreat", "performance"]);
-var eventScheduleScopeSchema = z44.enum(["recurring", "oneOff"]);
-var eventDestinationModeSchema = z44.enum(["cms-managed", "system-managed"]);
-var publicEventDestinationSchema = z44.discriminatedUnion("kind", [
-  z44.object({
-    kind: z44.literal("native"),
+var eventPresetSchema = z45.enum(["event", "class", "workshop", "retreat", "performance"]);
+var eventScheduleScopeSchema = z45.enum(["recurring", "oneOff"]);
+var eventDestinationModeSchema = z45.enum(["cms-managed", "system-managed"]);
+var publicEventDestinationSchema = z45.discriminatedUnion("kind", [
+  z45.object({
+    kind: z45.literal("native"),
     mode: eventDestinationModeSchema,
-    path: z44.string()
+    path: z45.string()
   }),
-  z44.object({
-    kind: z44.literal("external"),
-    url: z44.string(),
-    label: z44.string()
+  z45.object({
+    kind: z45.literal("external"),
+    url: z45.string(),
+    label: z45.string()
   })
 ]);
-var eventVenueSchema = z44.object({
-  id: z44.string(),
-  name: z44.string(),
-  address: z44.string().nullable(),
-  location: z44.object({
-    lat: z44.number(),
-    lng: z44.number()
+var eventVenueSchema = z45.object({
+  id: z45.string(),
+  name: z45.string(),
+  address: z45.string().nullable(),
+  location: z45.object({
+    lat: z45.number(),
+    lng: z45.number()
   }).nullable()
 });
-var eventCategorySchema = z44.object({
-  id: z44.string(),
-  name: z44.string(),
-  color: z44.string().nullable()
-});
-var pricingTypeSchema = z44.enum(["free", "paid", "external"]);
-var accessRestrictionSchema = z44.enum(["none", "category"]);
-var eventPricingModeSchema = z44.enum(["single", "ticket_types"]);
-var publicCoursePriceDisplaySchema = z44.discriminatedUnion("kind", [
-  z44.object({ kind: z44.literal("free"), currency: z44.string() }),
-  z44.object({ kind: z44.literal("exact"), amount: z44.number(), currency: z44.string() }),
-  z44.object({ kind: z44.literal("from"), amount: z44.number(), currency: z44.string() }),
-  z44.object({ kind: z44.literal("unavailable"), currency: z44.string() })
+var eventCategorySchema = z45.object({
+  id: z45.string(),
+  name: z45.string(),
+  color: z45.string().nullable()
+});
+var pricingTypeSchema = z45.enum(["free", "paid", "external"]);
+var accessRestrictionSchema = z45.enum(["none", "category"]);
+var eventPricingModeSchema = z45.enum(["single", "ticket_types"]);
+var publicCoursePriceDisplaySchema = z45.discriminatedUnion("kind", [
+  z45.object({ kind: z45.literal("free"), currency: z45.string() }),
+  z45.object({ kind: z45.literal("exact"), amount: z45.number(), currency: z45.string() }),
+  z45.object({ kind: z45.literal("from"), amount: z45.number(), currency: z45.string() }),
+  z45.object({ kind: z45.literal("unavailable"), currency: z45.string() })
 ]);
-var publicEventPriceDisplaySchema = z44.discriminatedUnion("kind", [
-  z44.object({ kind: z44.literal("free"), currency: z44.string() }),
-  z44.object({ kind: z44.literal("exact"), amount: z44.number(), currency: z44.string() }),
-  z44.object({ kind: z44.literal("from"), amount: z44.number(), currency: z44.string() }),
-  z44.object({ kind: z44.literal("range"), minAmount: z44.number(), maxAmount: z44.number(), currency: z44.string() }),
-  z44.object({
-    kind: z44.literal("mixed"),
-    paidFromAmount: z44.number(),
-    paidToAmount: z44.number(),
-    currency: z44.string()
+var publicEventPriceDisplaySchema = z45.discriminatedUnion("kind", [
+  z45.object({ kind: z45.literal("free"), currency: z45.string() }),
+  z45.object({ kind: z45.literal("exact"), amount: z45.number(), currency: z45.string() }),
+  z45.object({ kind: z45.literal("from"), amount: z45.number(), currency: z45.string() }),
+  z45.object({ kind: z45.literal("range"), minAmount: z45.number(), maxAmount: z45.number(), currency: z45.string() }),
+  z45.object({
+    kind: z45.literal("mixed"),
+    paidFromAmount: z45.number(),
+    paidToAmount: z45.number(),
+    currency: z45.string()
   }),
-  z44.object({ kind: z44.literal("unavailable"), currency: z44.string() }),
-  z44.object({ kind: z44.literal("external"), label: z44.string() }),
-  z44.object({ kind: z44.literal("course"), display: publicCoursePriceDisplaySchema })
+  z45.object({ kind: z45.literal("unavailable"), currency: z45.string() }),
+  z45.object({ kind: z45.literal("external"), label: z45.string() }),
+  z45.object({ kind: z45.literal("course"), display: publicCoursePriceDisplaySchema })
 ]);
-var publicEventTicketTypePriceDisplaySchema = z44.union([
-  z44.object({ kind: z44.literal("free"), currency: z44.string() }),
-  z44.object({ kind: z44.literal("exact"), amount: z44.number(), currency: z44.string() }),
-  z44.object({ kind: z44.literal("from"), amount: z44.number(), currency: z44.string() }),
-  z44.object({ kind: z44.literal("range"), minAmount: z44.number(), maxAmount: z44.number(), currency: z44.string() }),
-  z44.object({
-    kind: z44.literal("mixed"),
-    paidFromAmount: z44.number(),
-    paidToAmount: z44.number(),
-    currency: z44.string()
+var publicEventTicketTypePriceDisplaySchema = z45.union([
+  z45.object({ kind: z45.literal("free"), currency: z45.string() }),
+  z45.object({ kind: z45.literal("exact"), amount: z45.number(), currency: z45.string() }),
+  z45.object({ kind: z45.literal("from"), amount: z45.number(), currency: z45.string() }),
+  z45.object({ kind: z45.literal("range"), minAmount: z45.number(), maxAmount: z45.number(), currency: z45.string() }),
+  z45.object({
+    kind: z45.literal("mixed"),
+    paidFromAmount: z45.number(),
+    paidToAmount: z45.number(),
+    currency: z45.string()
   }),
-  z44.object({ kind: z44.literal("unavailable"), currency: z44.string() })
+  z45.object({ kind: z45.literal("unavailable"), currency: z45.string() })
 ]);
-var publicEventAttendanceModeSchema = z44.enum(["in_person", "online"]);
-var publicEventAttendanceModeAvailabilitySchema = z44.object({
+var publicEventAttendanceModeSchema = z45.enum(["in_person", "online"]);
+var publicEventAttendanceModeAvailabilitySchema = z45.object({
   mode: publicEventAttendanceModeSchema,
-  capacity: z44.number().nullable(),
-  registeredCount: z44.number(),
-  availableSpots: z44.number().nullable(),
-  waitlistEnabled: z44.boolean()
-});
-var publicEventTicketTypeAvailabilitySchema = z44.union([
-  z44.object({
-    kind: z44.literal("available"),
-    remainingCapacity: z44.number().nullable()
+  capacity: z45.number().nullable(),
+  registeredCount: z45.number(),
+  availableSpots: z45.number().nullable(),
+  waitlistEnabled: z45.boolean()
+});
+var publicEventTicketTypeAvailabilitySchema = z45.union([
+  z45.object({
+    kind: z45.literal("available"),
+    remainingCapacity: z45.number().nullable()
   }),
-  z44.object({
-    kind: z44.literal("unavailable"),
-    reason: z44.enum(["inactive", "not_on_sale_yet", "sale_ended", "sold_out", "event_sold_out"]),
-    remainingCapacity: z44.number().nullable()
+  z45.object({
+    kind: z45.literal("unavailable"),
+    reason: z45.enum(["inactive", "not_on_sale_yet", "sale_ended", "sold_out", "event_sold_out"]),
+    remainingCapacity: z45.number().nullable()
   })
 ]);
-var publicEventTicketTypeSchema = z44.object({
-  id: z44.string(),
-  siteId: z44.string(),
-  eventSeriesId: z44.string(),
-  name: z44.string(),
-  description: z44.string().nullable(),
-  priceAmount: z44.number(),
-  isActive: z44.boolean(),
-  sortOrder: z44.number(),
-  capacityMode: z44.enum(["limited", "unlimited"]),
-  capacityLimit: z44.number().nullable(),
-  attendanceScope: z44.enum(["in_person", "online", "both"]).optional(),
-  saleStartsAt: z44.string().nullable(),
-  saleEndsAt: z44.string().nullable(),
+var publicEventTicketTypeSchema = z45.object({
+  id: z45.string(),
+  siteId: z45.string(),
+  eventSeriesId: z45.string(),
+  name: z45.string(),
+  description: z45.string().nullable(),
+  priceAmount: z45.number(),
+  isActive: z45.boolean(),
+  sortOrder: z45.number(),
+  capacityMode: z45.enum(["limited", "unlimited"]),
+  capacityLimit: z45.number().nullable(),
+  attendanceScope: z45.enum(["in_person", "online", "both"]).optional(),
+  saleStartsAt: z45.string().nullable(),
+  saleEndsAt: z45.string().nullable(),
   availability: publicEventTicketTypeAvailabilitySchema,
-  createdAt: z44.string(),
-  updatedAt: z44.string()
-});
-var publicEventPricingSchema = z44.discriminatedUnion("kind", [
-  z44.object({
-    kind: z44.literal("drop_in"),
-    currency: z44.string(),
-    display: z44.object({ kind: z44.literal("free"), currency: z44.string() })
+  createdAt: z45.string(),
+  updatedAt: z45.string()
+});
+var publicEventPricingSchema = z45.discriminatedUnion("kind", [
+  z45.object({
+    kind: z45.literal("drop_in"),
+    currency: z45.string(),
+    display: z45.object({ kind: z45.literal("free"), currency: z45.string() })
   }),
-  z44.object({
-    kind: z44.literal("free_registration"),
-    currency: z44.string(),
-    display: z44.object({ kind: z44.literal("free"), currency: z44.string() })
+  z45.object({
+    kind: z45.literal("free_registration"),
+    currency: z45.string(),
+    display: z45.object({ kind: z45.literal("free"), currency: z45.string() })
   }),
-  z44.object({
-    kind: z44.literal("single_paid"),
-    amount: z44.number(),
-    currency: z44.string(),
-    display: z44.object({ kind: z44.literal("exact"), amount: z44.number(), currency: z44.string() })
+  z45.object({
+    kind: z45.literal("single_paid"),
+    amount: z45.number(),
+    currency: z45.string(),
+    display: z45.object({ kind: z45.literal("exact"), amount: z45.number(), currency: z45.string() })
   }),
-  z44.object({
-    kind: z44.literal("ticket_types"),
-    currency: z44.string(),
-    ticketTypes: z44.array(publicEventTicketTypeSchema),
+  z45.object({
+    kind: z45.literal("ticket_types"),
+    currency: z45.string(),
+    ticketTypes: z45.array(publicEventTicketTypeSchema),
     display: publicEventTicketTypePriceDisplaySchema
   }),
-  z44.object({
-    kind: z44.literal("sliding_scale"),
-    minAmount: z44.number(),
-    maxAmount: z44.number(),
-    suggestedAmount: z44.number().nullable(),
-    currency: z44.string(),
-    display: z44.object({
-      kind: z44.literal("range"),
-      minAmount: z44.number(),
-      maxAmount: z44.number(),
-      currency: z44.string()
+  z45.object({
+    kind: z45.literal("sliding_scale"),
+    minAmount: z45.number(),
+    maxAmount: z45.number(),
+    suggestedAmount: z45.number().nullable(),
+    currency: z45.string(),
+    display: z45.object({
+      kind: z45.literal("range"),
+      minAmount: z45.number(),
+      maxAmount: z45.number(),
+      currency: z45.string()
     })
   }),
-  z44.object({
-    kind: z44.literal("course"),
-    display: z44.object({ kind: z44.literal("course"), display: publicCoursePriceDisplaySchema })
+  z45.object({
+    kind: z45.literal("course"),
+    display: z45.object({ kind: z45.literal("course"), display: publicCoursePriceDisplaySchema })
   }),
-  z44.object({
-    kind: z44.literal("external"),
-    display: z44.object({ kind: z44.literal("external"), label: z44.string() })
+  z45.object({
+    kind: z45.literal("external"),
+    display: z45.object({ kind: z45.literal("external"), label: z45.string() })
   })
 ]);
-var publicTeamMemberSummarySchema = z44.object({
-  id: z44.string(),
-  name: z44.string(),
-  roleLabel: z44.string().nullable(),
-  summary: z44.string().nullable(),
-  profilePath: z44.string().nullable()
+var publicTeamMemberSummarySchema = z45.object({
+  id: z45.string(),
+  name: z45.string(),
+  roleLabel: z45.string().nullable(),
+  summary: z45.string().nullable(),
+  profilePath: z45.string().nullable()
 });
-var publicEventSchema = z44.object({
-  kind: z44.enum(["event", "course_session"]).optional(),
+var publicEventSchema = z45.object({
+  kind: z45.enum(["event", "course_session"]).optional(),
   eventPreset: eventPresetSchema.optional(),
   eventDestinationMode: eventDestinationModeSchema.optional(),
   scheduleScope: eventScheduleScopeSchema.optional(),
-  id: z44.string(),
-  occurrenceId: z44.string(),
-  seriesId: z44.string(),
-  title: z44.string(),
-  description: z44.string().nullable(),
-  content: z44.object({
+  id: z45.string(),
+  occurrenceId: z45.string(),
+  seriesId: z45.string(),
+  title: z45.string(),
+  description: z45.string().nullable(),
+  content: z45.object({
     body: RichTextDocSchema.nullable().optional()
   }).optional(),
-  presentation: z44.object({
-    cardTitleOverride: z44.string().nullable().optional(),
-    summary: z44.string().nullable().optional(),
+  presentation: z45.object({
+    cardTitleOverride: z45.string().nullable().optional(),
+    summary: z45.string().nullable().optional(),
     image: mediaSchema2.nullable().optional()
   }).optional(),
-  slug: z44.string(),
-  path: z44.string().nullable(),
+  slug: z45.string(),
+  path: z45.string().nullable(),
   destination: publicEventDestinationSchema,
-  requiresRegistration: z44.boolean(),
-  deliveryMode: z44.enum(["in_person", "online", "hybrid"]),
-  attendanceModes: z44.array(publicEventAttendanceModeAvailabilitySchema),
-  startsAt: z44.string(),
-  endsAt: z44.string(),
-  capacity: z44.number().nullable(),
-  registeredCount: z44.number(),
-  availableSpots: z44.number().nullable(),
-  waitlistEnabled: z44.boolean(),
+  requiresRegistration: z45.boolean(),
+  deliveryMode: z45.enum(["in_person", "online", "hybrid"]),
+  attendanceModes: z45.array(publicEventAttendanceModeAvailabilitySchema),
+  startsAt: z45.string(),
+  endsAt: z45.string(),
+  capacity: z45.number().nullable(),
+  registeredCount: z45.number(),
+  availableSpots: z45.number().nullable(),
+  waitlistEnabled: z45.boolean(),
   venue: eventVenueSchema.nullable(),
   eventCategory: eventCategorySchema.nullable(),
-  teamMembers: z44.array(publicTeamMemberSummarySchema).optional(),
-  status: z44.enum(["active", "draft", "archived"]).optional(),
-  timeZone: z44.string(),
+  teamMembers: z45.array(publicTeamMemberSummarySchema).optional(),
+  status: z45.enum(["active", "draft", "archived"]).optional(),
+  timeZone: z45.string(),
   pricing: publicEventPricingSchema,
   paymentTerms: blockBookingPaymentTermsSchema,
   accessRestriction: accessRestrictionSchema,
-  allowedCategoryIds: z44.array(z44.string()),
-  requireGuestDetails: z44.boolean().optional(),
-  acceptsPasses: z44.boolean().optional(),
-  acceptsMemberships: z44.boolean().optional(),
-  course: z44.object({
-    id: z44.string(),
+  allowedCategoryIds: z45.array(z45.string()),
+  requireGuestDetails: z45.boolean().optional(),
+  acceptsPasses: z45.boolean().optional(),
+  acceptsMemberships: z45.boolean().optional(),
+  course: z45.object({
+    id: z45.string(),
     pricing: coursePricingSchema.optional(),
-    priceCents: z44.number().nullable(),
-    currency: z44.string(),
-    enrollmentOpen: z44.boolean()
+    priceCents: z45.number().nullable(),
+    currency: z45.string(),
+    enrollmentOpen: z45.boolean()
   }).nullable().optional()
 });
-var publicEventsArraySchema = z44.array(publicEventSchema);
+var publicEventsArraySchema = z45.array(publicEventSchema);
 
 // ../blocks/src/system/blocks/events/shared/fields.ts
 var cardVariantOptions2 = cardVariantRoleValues.map((value) => ({
@@ -31490,52 +31866,80 @@ function normalizeEventStaffMemberId(value) {
   return trimmed ? trimmed : null;
 }
 
+// ../blocks/src/system/blocks/events/shared/layout.ts
+var recoverEmptyHeadingWhenActive = {
+  kind: "recover-empty-when-active",
+  placeholder: "Add heading"
+};
+var recoverEmptyDescriptionWhenActive = {
+  kind: "recover-empty-when-active",
+  placeholder: "Add description"
+};
+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
+      })
+    )
+  ];
+}
+
 // ../blocks/src/system/blocks/shop.shared.ts
-import { z as z45 } from "zod";
-var publicPassProductSchema = z45.object({
-  id: z45.string(),
-  productUseCase: z45.enum(["event_pass", "appointment_package"]).default("event_pass"),
-  name: z45.string(),
-  description: z45.string().nullable(),
-  price: z45.number(),
-  currency: z45.string(),
-  creditsTotal: z45.number(),
-  pricePerCredit: z45.number(),
-  validDays: z45.number().nullable(),
-  eligibleCategoryIds: z45.array(z45.string()),
-  eligibleCategoryNames: z45.array(z45.string())
-});
-var publicPassProductCollectionSchema = z45.object({
-  passes: z45.array(publicPassProductSchema)
-});
-var publicMembershipProductSchema = z45.object({
-  id: z45.string(),
-  name: z45.string(),
-  description: z45.string().nullable(),
-  price: z45.number(),
-  currency: z45.string(),
-  billingInterval: z45.enum(["month", "year"]),
-  eligibleCategoryIds: z45.array(z45.string()),
-  eligibleCategoryNames: z45.array(z45.string())
+import { z as z46 } from "zod";
+var publicPassProductSchema = z46.object({
+  id: z46.string(),
+  productUseCase: z46.enum(["event_pass", "appointment_package"]).default("event_pass"),
+  name: z46.string(),
+  description: z46.string().nullable(),
+  price: z46.number(),
+  currency: z46.string(),
+  creditsTotal: z46.number(),
+  pricePerCredit: z46.number(),
+  validDays: z46.number().nullable(),
+  eligibleCategoryIds: z46.array(z46.string()),
+  eligibleCategoryNames: z46.array(z46.string())
+});
+var publicPassProductCollectionSchema = z46.object({
+  passes: z46.array(publicPassProductSchema)
+});
+var publicMembershipProductSchema = z46.object({
+  id: z46.string(),
+  name: z46.string(),
+  description: z46.string().nullable(),
+  price: z46.number(),
+  currency: z46.string(),
+  billingInterval: z46.enum(["month", "year"]),
+  eligibleCategoryIds: z46.array(z46.string()),
+  eligibleCategoryNames: z46.array(z46.string())
 });
-var publicMembershipProductCollectionSchema = z45.object({
-  memberships: z45.array(publicMembershipProductSchema)
+var publicMembershipProductCollectionSchema = z46.object({
+  memberships: z46.array(publicMembershipProductSchema)
 });
 
 // ../blocks/src/system/blocks/event-registration.shared.ts
-import { z as z46 } from "zod";
-var occurrenceContextSchema = z46.object({
-  id: z46.string(),
-  seriesId: z46.string(),
-  startsAt: z46.string(),
-  endsAt: z46.string(),
-  timeZone: z46.string(),
-  capacityOverride: z46.number().nullable().optional(),
-  overrides: z46.record(z46.string(), z46.unknown()).nullable().optional()
+import { z as z47 } from "zod";
+var occurrenceContextSchema = z47.object({
+  id: z47.string(),
+  seriesId: z47.string(),
+  startsAt: z47.string(),
+  endsAt: z47.string(),
+  timeZone: z47.string(),
+  capacityOverride: z47.number().nullable().optional(),
+  overrides: z47.record(z47.string(), z47.unknown()).nullable().optional()
 }).nullable();
 
 // ../blocks/src/system/runtime/nodes/event-registration.interactive.ts
-import { z as z48 } from "zod";
+import { z as z49 } from "zod";
 
 // ../blocks/src/system/constants/events.ts
 var EVENT_CONTENT_TYPE_SLUGS = ["event", "events"];
@@ -31722,17 +32126,17 @@ function readAmount(value) {
 }
 
 // ../blocks/src/system/runtime/nodes/shared/contract-schemas.ts
-import { z as z47 } from "zod";
-var previewStageSchema = z47.enum(["preview", "published"]);
-var registrationButtonVariantSchema = z47.enum(["primary", "secondary", "outline"]);
-var eventButtonVariantSchema = z47.enum(["primary", "secondary", "outline", "link"]);
-var eventLayoutSchema = z47.enum(eventCalendarListLayoutValues);
-var eventCalendarDisplayModeSchema = z47.enum(eventCalendarDisplayModeValues);
-var eventCalendarDefaultViewSchema = z47.enum(eventCalendarDefaultViewValues);
-var columnOptionSchema = z47.enum(["2", "3", "4"]);
-var weekStartSchema = z47.enum(["sunday", "monday"]);
-var filterAutoShowSchema = z47.enum(["auto", "always", "never"]);
-var calendarTabViewsSchema = z47.enum(["both", "month", "week"]);
+import { z as z48 } from "zod";
+var previewStageSchema = z48.enum(["preview", "published"]);
+var registrationButtonVariantSchema = z48.enum(["primary", "secondary", "outline"]);
+var eventButtonVariantSchema = z48.enum(["primary", "secondary", "outline", "link"]);
+var eventLayoutSchema = z48.enum(eventCalendarListLayoutValues);
+var eventCalendarDisplayModeSchema = z48.enum(eventCalendarDisplayModeValues);
+var eventCalendarDefaultViewSchema = z48.enum(eventCalendarDefaultViewValues);
+var columnOptionSchema = z48.enum(["2", "3", "4"]);
+var weekStartSchema = z48.enum(["sunday", "monday"]);
+var filterAutoShowSchema = z48.enum(["auto", "always", "never"]);
+var calendarTabViewsSchema = z48.enum(["both", "month", "week"]);
 
 // ../blocks/src/system/runtime/nodes/event-registration/wizardSteps.ts
 function getWizardStepsForContext(hasPreSelectedContext, needsPaymentStep) {
@@ -31792,72 +32196,72 @@ function toRegistrationEvents(events) {
 // ../blocks/src/system/runtime/nodes/event-registration.interactive.ts
 var EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS = ["Date", "Tickets", "Details"];
 var EVENT_REGISTRATION_SHELL_STEP_LABELS = ["Event", "Date", "Tickets", "Details", "Payment"];
-var contentEntrySchema = z48.object({
-  id: z48.string(),
-  slug: z48.string(),
-  contentTypeSlug: z48.string()
+var contentEntrySchema = z49.object({
+  id: z49.string(),
+  slug: z49.string(),
+  contentTypeSlug: z49.string()
 });
-var eventRegistrationPublicEventSchema = z48.preprocess(
+var eventRegistrationPublicEventSchema = z49.preprocess(
   normalizeEventRegistrationEventInput,
   publicEventSchema
 );
-var eventRegistrationSourceSchema = z48.object({
-  siteId: z48.string().optional(),
-  apiBaseUrl: z48.string().optional(),
-  portalToken: z48.string().nullable().optional(),
-  previewToken: z48.string().nullable().optional(),
+var eventRegistrationSourceSchema = z49.object({
+  siteId: z49.string().optional(),
+  apiBaseUrl: z49.string().optional(),
+  portalToken: z49.string().nullable().optional(),
+  previewToken: z49.string().nullable().optional(),
   occurrenceContext: occurrenceContextSchema.optional(),
   contentEntry: contentEntrySchema.nullable().optional(),
-  events: z48.array(eventRegistrationPublicEventSchema).nullable().optional(),
-  className: z48.string().nullable().optional(),
-  buttonText: z48.string().nullable().optional(),
-  maxTickets: z48.string().nullable().optional(),
-  showVenue: z48.boolean().optional(),
-  showCapacity: z48.boolean().optional(),
-  successMessage: z48.string().optional(),
-  waitlistMessage: z48.string().optional(),
+  events: z49.array(eventRegistrationPublicEventSchema).nullable().optional(),
+  className: z49.string().nullable().optional(),
+  buttonText: z49.string().nullable().optional(),
+  maxTickets: z49.string().nullable().optional(),
+  showVenue: z49.boolean().optional(),
+  showCapacity: z49.boolean().optional(),
+  successMessage: z49.string().optional(),
+  waitlistMessage: z49.string().optional(),
   buttonVariant: registrationButtonVariantSchema.optional(),
-  overlayEnabled: z48.boolean().optional(),
-  spamProtectionEnabled: z48.boolean().optional(),
+  overlayEnabled: z49.boolean().optional(),
+  spamProtectionEnabled: z49.boolean().optional(),
   stage: previewStageSchema.optional(),
-  supportEmail: z48.string().optional(),
+  supportEmail: z49.string().optional(),
   sitePasses: publicPassProductCollectionSchema.nullable().optional(),
   siteMemberships: publicMembershipProductCollectionSchema.nullable().optional()
 });
-var eventRegistrationDisplaySchema = z48.object({
-  kind: z48.literal("event-registration"),
-  state: z48.literal("generic-shell"),
-  className: z48.string().nullable(),
-  titleText: z48.string(),
-  bodyText: z48.string(),
-  stepLabels: z48.array(z48.enum(EVENT_REGISTRATION_SHELL_STEP_LABELS)).min(1),
-  summaryButtonText: z48.string()
+var eventRegistrationDisplaySchema = z49.object({
+  kind: z49.literal("event-registration"),
+  state: z49.literal("generic-shell"),
+  className: z49.string().nullable(),
+  titleText: z49.string(),
+  bodyText: z49.string(),
+  stepLabels: z49.array(z49.enum(EVENT_REGISTRATION_SHELL_STEP_LABELS)).min(1),
+  summaryButtonText: z49.string()
 });
-var eventRegistrationHydrationSchema = z48.object({
+var eventRegistrationHydrationSchema = z49.object({
   occurrenceContext: occurrenceContextSchema.optional(),
   contentEntry: contentEntrySchema.nullable().optional(),
-  events: z48.array(eventRegistrationPublicEventSchema).nullable().optional(),
-  maxTickets: z48.string().optional(),
-  showVenue: z48.boolean().optional(),
-  showCapacity: z48.boolean().optional(),
-  successMessage: z48.string().optional(),
-  waitlistMessage: z48.string().optional(),
+  events: z49.array(eventRegistrationPublicEventSchema).nullable().optional(),
+  maxTickets: z49.string().optional(),
+  showVenue: z49.boolean().optional(),
+  showCapacity: z49.boolean().optional(),
+  successMessage: z49.string().optional(),
+  waitlistMessage: z49.string().optional(),
   buttonVariant: registrationButtonVariantSchema.optional(),
-  overlayEnabled: z48.boolean().optional(),
-  spamProtectionEnabled: z48.boolean().optional(),
-  supportEmail: z48.string().optional(),
+  overlayEnabled: z49.boolean().optional(),
+  spamProtectionEnabled: z49.boolean().optional(),
+  supportEmail: z49.string().optional(),
   sitePasses: publicPassProductCollectionSchema.nullable().optional(),
   siteMemberships: publicMembershipProductCollectionSchema.nullable().optional()
 });
-var eventRegistrationRenderSchema = z48.object({
+var eventRegistrationRenderSchema = z49.object({
   display: eventRegistrationDisplaySchema,
   hydration: eventRegistrationHydrationSchema
 });
-var eventRegistrationIslandMetaCodec = createZodCodec(z48.object({
-  siteId: z48.string().optional(),
-  apiBaseUrl: z48.string().optional(),
-  portalToken: z48.string().nullable().optional(),
-  previewToken: z48.string().nullable().optional(),
+var eventRegistrationIslandMetaCodec = createZodCodec(z49.object({
+  siteId: z49.string().optional(),
+  apiBaseUrl: z49.string().optional(),
+  portalToken: z49.string().nullable().optional(),
+  previewToken: z49.string().nullable().optional(),
   stage: previewStageSchema.optional()
 }));
 var eventRegistrationIslandMetaKeys = defineInteractiveIslandMetaKeys(
@@ -32208,73 +32612,73 @@ var eventRegistrationBlockDefinition = {
 };
 
 // ../blocks/src/system/runtime/nodes/course-registration.interactive.ts
-import { z as z49 } from "zod";
-var contentEntrySchema2 = z49.object({
-  id: z49.string(),
-  slug: z49.string(),
-  contentTypeSlug: z49.string()
-});
-var courseEntrySubrouteContextSchema = z49.union([
-  z49.object({
-    kind: z49.literal("course-run"),
-    run: z49.object({
-      courseId: z49.string(),
-      seriesId: z49.string(),
-      runSlug: z49.string(),
-      runName: z49.string().nullable()
+import { z as z50 } from "zod";
+var contentEntrySchema2 = z50.object({
+  id: z50.string(),
+  slug: z50.string(),
+  contentTypeSlug: z50.string()
+});
+var courseEntrySubrouteContextSchema = z50.union([
+  z50.object({
+    kind: z50.literal("course-run"),
+    run: z50.object({
+      courseId: z50.string(),
+      seriesId: z50.string(),
+      runSlug: z50.string(),
+      runName: z50.string().nullable()
     })
   }),
-  z49.object({
-    kind: z49.literal("event-occurrence"),
+  z50.object({
+    kind: z50.literal("event-occurrence"),
     occurrence: occurrenceContextSchema
   })
 ]);
-var courseRegistrationSourceSchema = z49.object({
-  siteId: z49.string().optional(),
-  apiBaseUrl: z49.string().optional(),
-  portalToken: z49.string().nullable().optional(),
+var courseRegistrationSourceSchema = z50.object({
+  siteId: z50.string().optional(),
+  apiBaseUrl: z50.string().optional(),
+  portalToken: z50.string().nullable().optional(),
   contentEntry: contentEntrySchema2.nullable().optional(),
   entrySubrouteContext: courseEntrySubrouteContextSchema.nullable().optional(),
-  courses: z49.array(publicCourseSchema).nullable().optional(),
-  className: z49.string().nullable().optional(),
-  showSessions: z49.boolean().optional(),
-  showPrice: z49.boolean().optional(),
-  showCapacity: z49.boolean().optional(),
-  showVenue: z49.boolean().optional(),
-  successMessage: z49.string().optional(),
-  waitlistMessage: z49.string().optional(),
-  membershipMessage: z49.string().optional(),
-  buttonText: z49.string().nullable().optional(),
+  courses: z50.array(publicCourseSchema).nullable().optional(),
+  className: z50.string().nullable().optional(),
+  showSessions: z50.boolean().optional(),
+  showPrice: z50.boolean().optional(),
+  showCapacity: z50.boolean().optional(),
+  showVenue: z50.boolean().optional(),
+  successMessage: z50.string().optional(),
+  waitlistMessage: z50.string().optional(),
+  membershipMessage: z50.string().optional(),
+  buttonText: z50.string().nullable().optional(),
   buttonVariant: registrationButtonVariantSchema.optional(),
   stage: previewStageSchema.optional()
 });
-var courseRegistrationDisplaySchema = z49.object({
-  kind: z49.literal("course-registration"),
-  state: z49.literal("shell"),
-  className: z49.string().nullable(),
-  summaryButtonText: z49.string()
+var courseRegistrationDisplaySchema = z50.object({
+  kind: z50.literal("course-registration"),
+  state: z50.literal("shell"),
+  className: z50.string().nullable(),
+  summaryButtonText: z50.string()
 });
-var courseRegistrationHydrationSchema = z49.object({
+var courseRegistrationHydrationSchema = z50.object({
   contentEntry: contentEntrySchema2.nullable().optional(),
   entrySubrouteContext: courseEntrySubrouteContextSchema.nullable().optional(),
-  courses: z49.array(publicCourseSchema).nullable().optional(),
-  showSessions: z49.boolean().optional(),
-  showPrice: z49.boolean().optional(),
-  showCapacity: z49.boolean().optional(),
-  showVenue: z49.boolean().optional(),
-  successMessage: z49.string().optional(),
-  waitlistMessage: z49.string().optional(),
-  membershipMessage: z49.string().optional(),
+  courses: z50.array(publicCourseSchema).nullable().optional(),
+  showSessions: z50.boolean().optional(),
+  showPrice: z50.boolean().optional(),
+  showCapacity: z50.boolean().optional(),
+  showVenue: z50.boolean().optional(),
+  successMessage: z50.string().optional(),
+  waitlistMessage: z50.string().optional(),
+  membershipMessage: z50.string().optional(),
   buttonVariant: registrationButtonVariantSchema.optional()
 });
-var courseRegistrationRenderSchema = z49.object({
+var courseRegistrationRenderSchema = z50.object({
   display: courseRegistrationDisplaySchema,
   hydration: courseRegistrationHydrationSchema
 });
-var courseRegistrationIslandMetaCodec = createZodCodec(z49.object({
-  siteId: z49.string().optional(),
-  apiBaseUrl: z49.string().optional(),
-  portalToken: z49.string().nullable().optional(),
+var courseRegistrationIslandMetaCodec = createZodCodec(z50.object({
+  siteId: z50.string().optional(),
+  apiBaseUrl: z50.string().optional(),
+  portalToken: z50.string().nullable().optional(),
   stage: previewStageSchema.optional()
 }));
 var courseRegistrationIslandMetaKeys = defineInteractiveIslandMetaKeys(
@@ -32534,7 +32938,7 @@ var courseRegistrationBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/event-details.ts
-import { z as z50 } from "zod";
+import { z as z51 } from "zod";
 var eventDetailsManifest = createBlockManifest({
   id: "block.event-details",
   version: "1.0.0",
@@ -32666,37 +33070,37 @@ var eventDetailsManifest = createBlockManifest({
     })
   ]
 });
-var occurrenceContextSchema2 = z50.object({
-  id: z50.string(),
-  seriesId: z50.string(),
-  startsAt: z50.string(),
-  endsAt: z50.string(),
-  timeZone: z50.string(),
-  capacityOverride: z50.number().nullable().optional(),
-  overrides: z50.record(z50.string(), z50.unknown()).nullable().optional()
+var occurrenceContextSchema2 = z51.object({
+  id: z51.string(),
+  seriesId: z51.string(),
+  startsAt: z51.string(),
+  endsAt: z51.string(),
+  timeZone: z51.string(),
+  capacityOverride: z51.number().nullable().optional(),
+  overrides: z51.record(z51.string(), z51.unknown()).nullable().optional()
 }).nullable();
-var eventAutoApplyDiscountPreviewBaseSchema = z50.object({
-  id: z50.string(),
-  publicLabel: z50.string(),
-  description: z50.string().nullable(),
-  minTicketsRequired: z50.number().nullable()
+var eventAutoApplyDiscountPreviewBaseSchema = z51.object({
+  id: z51.string(),
+  publicLabel: z51.string(),
+  description: z51.string().nullable(),
+  minTicketsRequired: z51.number().nullable()
 });
-var eventAutoApplyDiscountPreviewSchema = z50.discriminatedUnion("discountType", [
+var eventAutoApplyDiscountPreviewSchema = z51.discriminatedUnion("discountType", [
   eventAutoApplyDiscountPreviewBaseSchema.extend({
-    discountType: z50.literal("percent"),
-    discountPercent: z50.number(),
-    discountAmountCents: z50.null()
+    discountType: z51.literal("percent"),
+    discountPercent: z51.number(),
+    discountAmountCents: z51.null()
   }),
   eventAutoApplyDiscountPreviewBaseSchema.extend({
-    discountType: z50.literal("fixed"),
-    discountPercent: z50.null(),
-    discountAmountCents: z50.number()
+    discountType: z51.literal("fixed"),
+    discountPercent: z51.null(),
+    discountAmountCents: z51.number()
   })
 ]);
 var eventDetailsBlockDefinition = {
   manifest: eventDetailsManifest,
   dataSchemas: {
-    eventDetailsData: z50.object({
+    eventDetailsData: z51.object({
       events: publicEventsArraySchema,
       sitePasses: publicPassProductCollectionSchema,
       siteMemberships: publicMembershipProductCollectionSchema,
@@ -32951,18 +33355,7 @@ var eventSpotlightFields = [
 var 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" } },
@@ -33023,7 +33416,7 @@ var eventSpotlightBlockDefinition = {
 };
 
 // ../blocks/src/system/runtime/nodes/events/EventListing.interactive.ts
-import { z as z52 } from "zod";
+import { z as z53 } from "zod";
 
 // ../blocks/src/system/runtime/nodes/events/shared/utils.ts
 var COLUMN_CLASSES = {
@@ -33131,16 +33524,16 @@ function computeMediaTransformStyle(value, style, targetAspectRatio, options) {
 }
 
 // ../blocks/src/system/runtime/nodes/events/shared/listOptions.ts
-import { z as z51 } from "zod";
+import { z as z52 } from "zod";
 var eventPageSizeValues = [3, 6, 10, 12, 20, 24, 30];
-var eventPageSizeSchema = z51.union([
-  z51.literal(3),
-  z51.literal(6),
-  z51.literal(10),
-  z51.literal(12),
-  z51.literal(20),
-  z51.literal(24),
-  z51.literal(30)
+var eventPageSizeSchema = z52.union([
+  z52.literal(3),
+  z52.literal(6),
+  z52.literal(10),
+  z52.literal(12),
+  z52.literal(20),
+  z52.literal(24),
+  z52.literal(30)
 ]);
 var eventPageSizeSet = new Set(eventPageSizeValues);
 function resolveEventPageSize(value, fallback = 12) {
@@ -33150,15 +33543,15 @@ function resolveEventPageSize(value, fallback = 12) {
 function resolveEventCalendarListPageSize(input) {
   return resolveEventPageSize(input.eventsPerPage);
 }
-var eventListPaginationActionSchema = z51.discriminatedUnion("kind", [
-  z51.object({
-    kind: z51.literal("loadMore"),
-    label: z51.string()
+var eventListPaginationActionSchema = z52.discriminatedUnion("kind", [
+  z52.object({
+    kind: z52.literal("loadMore"),
+    label: z52.string()
   }),
-  z51.object({
-    kind: z51.literal("seeAllLink"),
-    label: z51.string(),
-    href: z51.string()
+  z52.object({
+    kind: z52.literal("seeAllLink"),
+    label: z52.string(),
+    href: z52.string()
   })
 ]);
 function resolveEventListPaginationAction(input) {
@@ -33171,89 +33564,89 @@ function resolveEventListPaginationAction(input) {
 }
 
 // ../blocks/src/system/runtime/nodes/events/EventListing.interactive.ts
-var legacyEventCardVariantSchema = z52.enum(["variant1", "variant2"]);
-var eventCardVariantInputSchema = z52.union([
+var legacyEventCardVariantSchema = z53.enum(["variant1", "variant2"]);
+var eventCardVariantInputSchema = z53.union([
   cardVariantRoleSchema,
   legacyEventCardVariantSchema
 ]);
-var cardOrientationSchema = z52.enum(["vertical", "horizontal"]);
-var eventBlockKindSchema = z52.enum(eventBlockKindValues);
-var eventSurfaceScopeSchema = z52.enum(eventSurfaceScopeValues);
-var eventScheduleScopeSchema2 = z52.enum(eventScheduleScopeValues);
-var eventListingSourceSchema = z52.object({
-  events: z52.array(publicEventSchema).nullable().optional(),
-  siteId: z52.string(),
-  apiBaseUrl: z52.string().optional(),
+var cardOrientationSchema = z53.enum(["vertical", "horizontal"]);
+var eventBlockKindSchema = z53.enum(eventBlockKindValues);
+var eventSurfaceScopeSchema = z53.enum(eventSurfaceScopeValues);
+var eventScheduleScopeSchema2 = z53.enum(eventScheduleScopeValues);
+var eventListingSourceSchema = z53.object({
+  events: z53.array(publicEventSchema).nullable().optional(),
+  siteId: z53.string(),
+  apiBaseUrl: z53.string().optional(),
   stage: previewStageSchema.optional(),
   layout: eventLayoutSchema.optional(),
   columns: columnOptionSchema.optional(),
-  eventsPerPage: z52.string().optional(),
-  paginationMode: z52.enum(["loadMore", "seeAllLink"]).optional(),
-  seeAllUrl: z52.string().optional(),
-  loadMoreText: z52.string().optional(),
+  eventsPerPage: z53.string().optional(),
+  paginationMode: z53.enum(["loadMore", "seeAllLink"]).optional(),
+  seeAllUrl: z53.string().optional(),
+  loadMoreText: z53.string().optional(),
   cardVariant: eventCardVariantInputSchema.optional(),
   buttonVariant: eventButtonVariantSchema.optional(),
-  buttonText: z52.string().optional(),
-  showVenue: z52.boolean().optional(),
-  showMap: z52.boolean().optional(),
-  showCapacity: z52.boolean().optional(),
-  emptyMessage: z52.string().optional(),
-  className: z52.string().optional(),
-  showFilters: z52.boolean().nullable().optional(),
+  buttonText: z53.string().optional(),
+  showVenue: z53.boolean().optional(),
+  showMap: z53.boolean().optional(),
+  showCapacity: z53.boolean().optional(),
+  emptyMessage: z53.string().optional(),
+  className: z53.string().optional(),
+  showFilters: z53.boolean().nullable().optional(),
   showCategoryFilter: filterAutoShowSchema.optional(),
-  showVenueFilter: z52.boolean().nullable().optional(),
-  showStaffFilter: z52.boolean().nullable().optional(),
+  showVenueFilter: z53.boolean().nullable().optional(),
+  showStaffFilter: z53.boolean().nullable().optional(),
   eventKind: eventBlockKindSchema.nullable().optional(),
   eventSurface: eventSurfaceScopeSchema.nullable().optional(),
-  filterEventPresets: z52.union([z52.string(), z52.array(z52.string())]).nullable().optional(),
+  filterEventPresets: z53.union([z53.string(), z53.array(z53.string())]).nullable().optional(),
   scheduleScope: eventScheduleScopeSchema2.nullable().optional(),
-  filterCategoryIds: z52.string().nullable().optional(),
-  filterStaffMemberId: z52.string().nullable().optional(),
-  filterVenueId: z52.string().nullable().optional()
+  filterCategoryIds: z53.string().nullable().optional(),
+  filterStaffMemberId: z53.string().nullable().optional(),
+  filterVenueId: z53.string().nullable().optional()
 });
-var eventListingDisplaySchema = z52.object({
-  kind: z52.literal("event-listing"),
-  state: z52.enum(["loading", "empty", "ready"]),
+var eventListingDisplaySchema = z53.object({
+  kind: z53.literal("event-listing"),
+  state: z53.enum(["loading", "empty", "ready"]),
   listLayout: eventLayoutSchema,
-  className: z52.string().nullable(),
-  emptyMessage: z52.string(),
-  loadingMessage: z52.string(),
-  containerClass: z52.string(),
+  className: z53.string().nullable(),
+  emptyMessage: z53.string(),
+  loadingMessage: z53.string(),
+  containerClass: z53.string(),
   cardVariant: cardVariantRoleSchema,
   buttonVariant: eventButtonVariantSchema,
-  buttonText: z52.string(),
-  showVenue: z52.boolean(),
-  showMap: z52.boolean(),
-  showCapacity: z52.boolean(),
+  buttonText: z53.string(),
+  showVenue: z53.boolean(),
+  showMap: z53.boolean(),
+  showCapacity: z53.boolean(),
   orientation: cardOrientationSchema,
-  events: z52.array(publicEventSchema)
+  events: z53.array(publicEventSchema)
 });
-var eventListingHydrationSchema = z52.object({
-  siteId: z52.string(),
+var eventListingHydrationSchema = z53.object({
+  siteId: z53.string(),
   stage: previewStageSchema.optional(),
   eventsPerPage: eventPageSizeSchema,
   paginationAction: eventListPaginationActionSchema,
-  showFilters: z52.boolean(),
+  showFilters: z53.boolean(),
   showCategoryFilter: filterAutoShowSchema,
-  showVenueFilter: z52.boolean(),
-  showStaffFilter: z52.boolean(),
+  showVenueFilter: z53.boolean(),
+  showStaffFilter: z53.boolean(),
   eventKind: eventBlockKindSchema,
   eventSurface: eventSurfaceScopeSchema,
-  filterEventPresets: z52.string().nullable(),
+  filterEventPresets: z53.string().nullable(),
   scheduleScope: eventScheduleScopeSchema2,
-  filterCategoryIds: z52.string().nullable().optional(),
-  filterStaffMemberId: z52.string().nullable().optional(),
-  filterVenueId: z52.string().nullable().optional(),
-  fetchInitialEventsOnMount: z52.boolean()
+  filterCategoryIds: z53.string().nullable().optional(),
+  filterStaffMemberId: z53.string().nullable().optional(),
+  filterVenueId: z53.string().nullable().optional(),
+  fetchInitialEventsOnMount: z53.boolean()
 });
-var eventListingRenderSchema = z52.object({
+var eventListingRenderSchema = z53.object({
   display: eventListingDisplaySchema,
   hydration: eventListingHydrationSchema
 });
 var eventListingIslandMetaCodec = createZodCodec(
-  z52.object({
-    siteId: z52.string(),
-    apiBaseUrl: z52.string().optional(),
+  z53.object({
+    siteId: z53.string(),
+    apiBaseUrl: z53.string().optional(),
     stage: previewStageSchema.optional()
   })
 );
@@ -33493,18 +33886,7 @@ var eventListingAdditionalFields = [
 var 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" } },
@@ -33620,15 +34002,15 @@ var eventListingBlockDefinition = {
 };
 
 // ../blocks/src/system/runtime/nodes/events/EventCalendar.interactive.ts
-import { z as z53 } from "zod";
-var eventBlockKindSchema2 = z53.enum(eventBlockKindValues);
-var eventSurfaceScopeSchema2 = z53.enum(eventSurfaceScopeValues);
-var eventScheduleScopeSchema3 = z53.enum(eventScheduleScopeValues);
-var eventCalendarSourceSchema = z53.object(
+import { z as z54 } from "zod";
+var eventBlockKindSchema2 = z54.enum(eventBlockKindValues);
+var eventSurfaceScopeSchema2 = z54.enum(eventSurfaceScopeValues);
+var eventScheduleScopeSchema3 = z54.enum(eventScheduleScopeValues);
+var eventCalendarSourceSchema = z54.object(
   {
-    events: z53.array(publicEventSchema).nullable().optional(),
-    siteId: z53.string(),
-    apiBaseUrl: z53.string().optional(),
+    events: z54.array(publicEventSchema).nullable().optional(),
+    siteId: z54.string(),
+    apiBaseUrl: z54.string().optional(),
     stage: previewStageSchema.optional(),
     variant: eventCalendarDisplayModeSchema.nullable().optional(),
     displayMode: eventCalendarDisplayModeSchema.nullable().optional(),
@@ -33636,38 +34018,38 @@ var eventCalendarSourceSchema = z53.object(
     listColumns: columnOptionSchema.optional(),
     layout: eventLayoutSchema.optional(),
     columns: columnOptionSchema.optional(),
-    eventsPerPage: z53.string().optional(),
-    paginationMode: z53.enum(["loadMore", "seeAllLink"]).optional(),
-    seeAllUrl: z53.string().optional(),
-    loadMoreText: z53.string().optional(),
+    eventsPerPage: z54.string().optional(),
+    paginationMode: z54.enum(["loadMore", "seeAllLink"]).optional(),
+    seeAllUrl: z54.string().optional(),
+    loadMoreText: z54.string().optional(),
     startOfWeek: weekStartSchema.optional(),
     calendarTabViews: calendarTabViewsSchema.optional(),
     defaultCalendarView: eventCalendarDefaultViewSchema.optional(),
-    showFilters: z53.boolean().nullable().optional(),
+    showFilters: z54.boolean().nullable().optional(),
     showCategoryFilter: filterAutoShowSchema.optional(),
-    showVenueFilter: z53.boolean().nullable().optional(),
-    showStaffFilter: z53.boolean().nullable().optional(),
+    showVenueFilter: z54.boolean().nullable().optional(),
+    showStaffFilter: z54.boolean().nullable().optional(),
     kind: eventBlockKindSchema2.nullable().optional(),
     eventSurface: eventSurfaceScopeSchema2.nullable().optional(),
-    filterEventPresets: z53.union([z53.string(), z53.array(z53.string())]).nullable().optional(),
+    filterEventPresets: z54.union([z54.string(), z54.array(z54.string())]).nullable().optional(),
     scheduleScope: eventScheduleScopeSchema3.nullable().optional(),
-    filterCategoryIds: z53.union([z53.string(), z53.array(z53.string())]).nullable().optional(),
-    filterStaffMemberId: z53.string().nullable().optional(),
-    filterVenueId: z53.string().nullable().optional(),
+    filterCategoryIds: z54.union([z54.string(), z54.array(z54.string())]).nullable().optional(),
+    filterStaffMemberId: z54.string().nullable().optional(),
+    filterVenueId: z54.string().nullable().optional(),
     buttonVariant: eventButtonVariantSchema.optional(),
-    buttonText: z53.string().optional(),
-    showVenue: z53.boolean().nullable().optional(),
-    showMap: z53.boolean().nullable().optional(),
-    showCapacity: z53.boolean().nullable().optional(),
-    emptyMessage: z53.string().optional(),
-    className: z53.string().optional()
+    buttonText: z54.string().optional(),
+    showVenue: z54.boolean().nullable().optional(),
+    showMap: z54.boolean().nullable().optional(),
+    showCapacity: z54.boolean().nullable().optional(),
+    emptyMessage: z54.string().optional(),
+    className: z54.string().optional()
   }
 );
-var eventCalendarDisplaySchema = z53.object({
-  kind: z53.literal("event-calendar"),
+var eventCalendarDisplaySchema = z54.object({
+  kind: z54.literal("event-calendar"),
   displayMode: eventCalendarDisplayModeSchema,
-  className: z53.string().nullable(),
-  events: z53.array(publicEventSchema),
+  className: z54.string().nullable(),
+  events: z54.array(publicEventSchema),
   listLayout: eventLayoutSchema,
   listColumns: columnOptionSchema,
   eventsPerPage: eventPageSizeSchema,
@@ -33675,41 +34057,41 @@ var eventCalendarDisplaySchema = z53.object({
   startOfWeek: weekStartSchema,
   calendarTabViews: calendarTabViewsSchema,
   defaultCalendarView: eventCalendarDefaultViewSchema,
-  showFilters: z53.boolean(),
+  showFilters: z54.boolean(),
   showCategoryFilter: filterAutoShowSchema,
-  showVenueFilter: z53.boolean(),
-  showStaffFilter: z53.boolean(),
+  showVenueFilter: z54.boolean(),
+  showStaffFilter: z54.boolean(),
   eventKind: eventBlockKindSchema2,
   eventSurface: eventSurfaceScopeSchema2,
-  filterEventPresets: z53.string().nullable(),
+  filterEventPresets: z54.string().nullable(),
   scheduleScope: eventScheduleScopeSchema3,
-  filterCategoryIds: z53.string().nullable(),
-  filterStaffMemberId: z53.string().nullable(),
-  filterVenueId: z53.string().nullable(),
+  filterCategoryIds: z54.string().nullable(),
+  filterStaffMemberId: z54.string().nullable(),
+  filterVenueId: z54.string().nullable(),
   buttonVariant: eventButtonVariantSchema,
-  buttonText: z53.string(),
-  showVenue: z53.boolean(),
-  showMap: z53.boolean(),
-  showCapacity: z53.boolean(),
-  emptyMessage: z53.string()
-});
-var eventCalendarHydrationSchema = z53.object({
-  siteId: z53.string(),
+  buttonText: z54.string(),
+  showVenue: z54.boolean(),
+  showMap: z54.boolean(),
+  showCapacity: z54.boolean(),
+  emptyMessage: z54.string()
+});
+var eventCalendarHydrationSchema = z54.object({
+  siteId: z54.string(),
   stage: previewStageSchema.optional(),
-  prefetchedEvents: z53.boolean(),
+  prefetchedEvents: z54.boolean(),
   eventKind: eventBlockKindSchema2,
   eventSurface: eventSurfaceScopeSchema2,
-  filterEventPresets: z53.string().nullable(),
+  filterEventPresets: z54.string().nullable(),
   scheduleScope: eventScheduleScopeSchema3
 });
-var eventCalendarRenderSchema = z53.object({
+var eventCalendarRenderSchema = z54.object({
   display: eventCalendarDisplaySchema,
   hydration: eventCalendarHydrationSchema
 });
 var eventCalendarIslandMetaCodec = createZodCodec(
-  z53.object({
-    siteId: z53.string(),
-    apiBaseUrl: z53.string().optional(),
+  z54.object({
+    siteId: z54.string(),
+    apiBaseUrl: z54.string().optional(),
     stage: previewStageSchema.optional()
   })
 );
@@ -33829,14 +34211,7 @@ var eventCalendarLayout = [
   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",
@@ -34481,7 +34856,7 @@ var eventCalendarBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/offerings-preview/index.ts
-import { z as z54 } from "zod";
+import { z as z55 } from "zod";
 
 // ../blocks/src/system/blocks/offerings-preview/model.ts
 var OFFERINGS_PREVIEW_DEFAULT_ITEM_LIMIT = "3";
@@ -34573,13 +34948,13 @@ function isRecord7(value) {
 }
 
 // ../blocks/src/system/blocks/offerings-preview/index.ts
-var publicRouteCandidatesSchema = z54.object({
-  routes: z54.array(z54.object({
-    entityId: z54.string(),
-    path: z54.string(),
-    title: z54.string(),
-    kind: z54.enum(["page", "content"]),
-    contentTypeKey: z54.string().nullable().optional()
+var publicRouteCandidatesSchema = z55.object({
+  routes: z55.array(z55.object({
+    entityId: z55.string(),
+    path: z55.string(),
+    title: z55.string(),
+    kind: z55.enum(["page", "content"]),
+    contentTypeKey: z55.string().nullable().optional()
   }))
 });
 var groupOverrideFields = [
@@ -34977,7 +35352,7 @@ function isRecord8(value) {
 }
 
 // ../blocks/src/system/blocks/embed.ts
-import { z as z55 } from "zod";
+import { z as z56 } from "zod";
 var embedFields = [
   // Section heading
   parseFieldDefinition({
@@ -35208,18 +35583,18 @@ var embedManifest = createBlockManifest({
     spacing: "lg"
   }
 });
-var embedEntrySchema = z55.object({
-  id: z55.string(),
-  identifier: z55.string(),
-  title: z55.string(),
-  slug: z55.string().nullable().optional(),
-  content: z55.record(z55.string(), z55.unknown()).optional(),
-  publishedAt: z55.string().nullable().optional()
+var embedEntrySchema = z56.object({
+  id: z56.string(),
+  identifier: z56.string(),
+  title: z56.string(),
+  slug: z56.string().nullable().optional(),
+  content: z56.record(z56.string(), z56.unknown()).optional(),
+  publishedAt: z56.string().nullable().optional()
 });
 var embedBlockDefinition = {
   manifest: embedManifest,
   dataSchemas: {
-    entries: z55.array(embedEntrySchema).optional()
+    entries: z56.array(embedEntrySchema).optional()
   },
   dataLoaders: {
     entries: {
@@ -36403,49 +36778,49 @@ var fileDownloadBlockDefinition = {
 };
 
 // ../blocks/src/system/runtime/nodes/shop.interactive.ts
-import { z as z58 } from "zod";
+import { z as z59 } from "zod";
 
 // ../blocks/src/system/blocks/products/shared.ts
-import { z as z56 } from "zod";
-var publicProductVariantSchema = z56.object({
-  id: z56.string(),
-  title: z56.string(),
-  sku: z56.string().nullable(),
-  priceCents: z56.number(),
-  stockQuantity: z56.number().nullable(),
-  soldOut: z56.boolean()
-});
-var publicProductSchema = z56.object({
-  id: z56.string(),
-  contentEntryId: z56.string().nullable(),
-  title: z56.string(),
-  slug: z56.string(),
-  path: z56.string().nullable(),
-  status: z56.enum(["draft", "active"]),
-  priceCents: z56.number(),
-  currency: z56.string(),
-  productType: z56.enum(["physical", "digital"]),
-  requiresShipping: z56.boolean(),
-  hasVariants: z56.boolean(),
-  trackInventory: z56.boolean(),
-  soldOut: z56.boolean(),
-  category: z56.object({
-    id: z56.string(),
-    name: z56.string(),
-    slug: z56.string()
+import { z as z57 } from "zod";
+var publicProductVariantSchema = z57.object({
+  id: z57.string(),
+  title: z57.string(),
+  sku: z57.string().nullable(),
+  priceCents: z57.number(),
+  stockQuantity: z57.number().nullable(),
+  soldOut: z57.boolean()
+});
+var publicProductSchema = z57.object({
+  id: z57.string(),
+  contentEntryId: z57.string().nullable(),
+  title: z57.string(),
+  slug: z57.string(),
+  path: z57.string().nullable(),
+  status: z57.enum(["draft", "active"]),
+  priceCents: z57.number(),
+  currency: z57.string(),
+  productType: z57.enum(["physical", "digital"]),
+  requiresShipping: z57.boolean(),
+  hasVariants: z57.boolean(),
+  trackInventory: z57.boolean(),
+  soldOut: z57.boolean(),
+  category: z57.object({
+    id: z57.string(),
+    name: z57.string(),
+    slug: z57.string()
   }).nullable(),
-  summary: z56.string().nullable(),
-  body: z56.unknown().nullable(),
-  gallery: z56.array(
-    z56.object({
-      url: z56.string(),
-      alt: z56.string().nullable()
+  summary: z57.string().nullable(),
+  body: z57.unknown().nullable(),
+  gallery: z57.array(
+    z57.object({
+      url: z57.string(),
+      alt: z57.string().nullable()
     })
   ),
-  variants: z56.array(publicProductVariantSchema)
+  variants: z57.array(publicProductVariantSchema)
 });
-var publicProductsResponseSchema = z56.object({
-  products: z56.array(publicProductSchema)
+var publicProductsResponseSchema = z57.object({
+  products: z57.array(publicProductSchema)
 });
 
 // ../blocks/src/system/runtime/api/creditProducts.ts
@@ -36509,27 +36884,27 @@ function deriveCreditProductLabels(products, options = {}) {
 }
 
 // ../blocks/src/system/runtime/nodes/shop-commerce.shared.ts
-import { z as z57 } from "zod";
-var storedProductCartItemSchema = z57.object({
-  kind: z57.literal("product"),
-  productId: z57.string().min(1),
-  productCategoryId: z57.string().min(1).optional().nullable(),
-  variantId: z57.string().min(1).optional().nullable(),
-  title: z57.string().min(1),
-  variantTitle: z57.string().optional().nullable(),
-  quantity: z57.number().finite(),
-  unitPriceCents: z57.number().finite(),
-  currency: z57.string().min(1),
-  imageUrl: z57.string().optional().nullable(),
-  soldOut: z57.boolean().optional()
-});
-var storedPassCartItemSchema = z57.object({
-  kind: z57.literal("pass"),
-  passId: z57.string().min(1),
-  title: z57.string().min(1),
-  quantity: z57.number().finite().optional(),
-  unitPriceCents: z57.number().finite(),
-  currency: z57.string().min(1)
+import { z as z58 } from "zod";
+var storedProductCartItemSchema = z58.object({
+  kind: z58.literal("product"),
+  productId: z58.string().min(1),
+  productCategoryId: z58.string().min(1).optional().nullable(),
+  variantId: z58.string().min(1).optional().nullable(),
+  title: z58.string().min(1),
+  variantTitle: z58.string().optional().nullable(),
+  quantity: z58.number().finite(),
+  unitPriceCents: z58.number().finite(),
+  currency: z58.string().min(1),
+  imageUrl: z58.string().optional().nullable(),
+  soldOut: z58.boolean().optional()
+});
+var storedPassCartItemSchema = z58.object({
+  kind: z58.literal("pass"),
+  passId: z58.string().min(1),
+  title: z58.string().min(1),
+  quantity: z58.number().finite().optional(),
+  unitPriceCents: z58.number().finite(),
+  currency: z58.string().min(1)
 });
 function deriveCommerceCheckoutState(state) {
   if (state.items.length === 0) {
@@ -36763,214 +37138,214 @@ function formatValidity(days) {
 }
 
 // ../blocks/src/system/runtime/nodes/shop.interactive.ts
-var shopModeSchema = z58.enum(["passes-memberships", "product-list", "product-detail", "cart", "checkout"]);
-var contentEntrySchema3 = z58.object({
-  id: z58.string().nullable().optional(),
-  slug: z58.string().nullable().optional()
+var shopModeSchema = z59.enum(["passes-memberships", "product-list", "product-detail", "cart", "checkout"]);
+var contentEntrySchema3 = z59.object({
+  id: z59.string().nullable().optional(),
+  slug: z59.string().nullable().optional()
 }).nullable();
-var shopSourceSchema = z58.object({
-  className: z58.string().nullable().optional(),
+var shopSourceSchema = z59.object({
+  className: z59.string().nullable().optional(),
   mode: shopModeSchema.optional(),
-  heading: z58.string().nullable().optional(),
-  productSlug: z58.string().nullable().optional(),
-  showPasses: z58.boolean().optional(),
-  showMemberships: z58.boolean().optional(),
-  layout: z58.enum(["grid", "list"]).optional(),
-  columns: z58.string().optional(),
-  showDescriptions: z58.boolean().optional(),
-  showSummary: z58.boolean().optional(),
-  showBody: z58.boolean().optional(),
-  showPrices: z58.boolean().optional(),
-  showValidityPeriod: z58.boolean().optional(),
-  showPricePerCredit: z58.boolean().nullable().optional(),
-  passesHeading: z58.string().optional(),
-  membershipsHeading: z58.string().optional(),
-  buyButtonText: z58.string().optional(),
-  addButtonText: z58.string().optional(),
-  passPurchaseMode: z58.enum(["add_to_cart", "buy_now"]).optional(),
-  subscribeButtonText: z58.string().optional(),
-  emptyStateText: z58.string().optional(),
-  checkoutButtonText: z58.string().optional(),
-  clearButtonText: z58.string().optional(),
-  submitButtonText: z58.string().optional(),
+  heading: z59.string().nullable().optional(),
+  productSlug: z59.string().nullable().optional(),
+  showPasses: z59.boolean().optional(),
+  showMemberships: z59.boolean().optional(),
+  layout: z59.enum(["grid", "list"]).optional(),
+  columns: z59.string().optional(),
+  showDescriptions: z59.boolean().optional(),
+  showSummary: z59.boolean().optional(),
+  showBody: z59.boolean().optional(),
+  showPrices: z59.boolean().optional(),
+  showValidityPeriod: z59.boolean().optional(),
+  showPricePerCredit: z59.boolean().nullable().optional(),
+  passesHeading: z59.string().optional(),
+  membershipsHeading: z59.string().optional(),
+  buyButtonText: z59.string().optional(),
+  addButtonText: z59.string().optional(),
+  passPurchaseMode: z59.enum(["add_to_cart", "buy_now"]).optional(),
+  subscribeButtonText: z59.string().optional(),
+  emptyStateText: z59.string().optional(),
+  checkoutButtonText: z59.string().optional(),
+  clearButtonText: z59.string().optional(),
+  submitButtonText: z59.string().optional(),
   contentEntry: contentEntrySchema3.optional(),
-  passes: z58.array(publicPassProductSchema).nullable().optional(),
-  memberships: z58.array(publicMembershipProductSchema).nullable().optional(),
-  products: z58.array(publicProductSchema).nullable().optional(),
-  siteId: z58.string().optional(),
-  apiBaseUrl: z58.string().optional(),
+  passes: z59.array(publicPassProductSchema).nullable().optional(),
+  memberships: z59.array(publicMembershipProductSchema).nullable().optional(),
+  products: z59.array(publicProductSchema).nullable().optional(),
+  siteId: z59.string().optional(),
+  apiBaseUrl: z59.string().optional(),
   stage: previewStageSchema.optional()
 });
-var productVariantOptionDisplaySchema = z58.object({
-  id: z58.string(),
-  label: z58.string(),
-  soldOut: z58.boolean()
-});
-var productCardDisplaySchema = z58.object({
-  productId: z58.string(),
-  title: z58.string(),
-  path: z58.string().nullable(),
-  summary: z58.string().nullable(),
-  priceLabel: z58.string().nullable(),
-  image: z58.object({
-    url: z58.string(),
-    alt: z58.string().nullable()
+var productVariantOptionDisplaySchema = z59.object({
+  id: z59.string(),
+  label: z59.string(),
+  soldOut: z59.boolean()
+});
+var productCardDisplaySchema = z59.object({
+  productId: z59.string(),
+  title: z59.string(),
+  path: z59.string().nullable(),
+  summary: z59.string().nullable(),
+  priceLabel: z59.string().nullable(),
+  image: z59.object({
+    url: z59.string(),
+    alt: z59.string().nullable()
   }).nullable(),
-  variantOptions: z58.array(productVariantOptionDisplaySchema),
-  selectedVariantId: z58.string().nullable(),
-  selectionLabel: z58.string(),
-  actionLabel: z58.string(),
-  soldOut: z58.boolean()
-});
-var productListDisplaySchema = z58.object({
-  kind: z58.literal("product-list"),
-  state: z58.enum(["empty", "ready"]),
-  heading: z58.string().nullable(),
-  className: z58.string().nullable(),
-  layout: z58.enum(["grid", "list"]),
-  columns: z58.string(),
-  emptyMessage: z58.string(),
-  cards: z58.array(productCardDisplaySchema)
-});
-var productDetailDisplaySchema = z58.discriminatedUnion("state", [
-  z58.object({
-    kind: z58.literal("product-detail"),
-    state: z58.literal("empty"),
-    heading: z58.string().nullable(),
-    className: z58.string().nullable(),
-    emptyMessage: z58.string()
+  variantOptions: z59.array(productVariantOptionDisplaySchema),
+  selectedVariantId: z59.string().nullable(),
+  selectionLabel: z59.string(),
+  actionLabel: z59.string(),
+  soldOut: z59.boolean()
+});
+var productListDisplaySchema = z59.object({
+  kind: z59.literal("product-list"),
+  state: z59.enum(["empty", "ready"]),
+  heading: z59.string().nullable(),
+  className: z59.string().nullable(),
+  layout: z59.enum(["grid", "list"]),
+  columns: z59.string(),
+  emptyMessage: z59.string(),
+  cards: z59.array(productCardDisplaySchema)
+});
+var productDetailDisplaySchema = z59.discriminatedUnion("state", [
+  z59.object({
+    kind: z59.literal("product-detail"),
+    state: z59.literal("empty"),
+    heading: z59.string().nullable(),
+    className: z59.string().nullable(),
+    emptyMessage: z59.string()
   }),
-  z58.object({
-    kind: z58.literal("product-detail"),
-    state: z58.literal("ready"),
-    heading: z58.string().nullable(),
-    className: z58.string().nullable(),
-    title: z58.string(),
-    priceLabel: z58.string(),
-    summary: z58.string().nullable(),
-    categoryLabel: z58.string().nullable(),
-    gallery: z58.array(z58.object({
-      url: z58.string(),
-      alt: z58.string().nullable()
+  z59.object({
+    kind: z59.literal("product-detail"),
+    state: z59.literal("ready"),
+    heading: z59.string().nullable(),
+    className: z59.string().nullable(),
+    title: z59.string(),
+    priceLabel: z59.string(),
+    summary: z59.string().nullable(),
+    categoryLabel: z59.string().nullable(),
+    gallery: z59.array(z59.object({
+      url: z59.string(),
+      alt: z59.string().nullable()
     })),
-    variantOptions: z58.array(productVariantOptionDisplaySchema),
-    selectedVariantId: z58.string().nullable(),
-    selectionLabel: z58.string(),
-    actionLabel: z58.string(),
-    soldOut: z58.boolean(),
-    body: z58.unknown().nullable()
+    variantOptions: z59.array(productVariantOptionDisplaySchema),
+    selectedVariantId: z59.string().nullable(),
+    selectionLabel: z59.string(),
+    actionLabel: z59.string(),
+    soldOut: z59.boolean(),
+    body: z59.unknown().nullable()
   })
 ]);
-var passCardDisplaySchema = z58.object({
-  id: z58.string(),
-  title: z58.string(),
-  description: z58.string().nullable(),
-  priceLabel: z58.string(),
-  creditsLabel: z58.string(),
-  perCreditLabel: z58.string().nullable(),
-  validityLabel: z58.string().nullable(),
-  actionLabel: z58.string()
-});
-var membershipCardDisplaySchema = z58.object({
-  id: z58.string(),
-  title: z58.string(),
-  description: z58.string().nullable(),
-  priceLabel: z58.string(),
-  intervalLabel: z58.string(),
-  actionLabel: z58.string()
-});
-var passesMembershipsDisplaySchema = z58.object({
-  kind: z58.literal("passes-memberships"),
-  state: z58.enum(["empty", "ready"]),
-  className: z58.string().nullable(),
-  layout: z58.enum(["grid", "list"]),
-  columns: z58.string(),
-  emptyMessage: z58.string(),
-  passesHeading: z58.string(),
-  membershipsHeading: z58.string(),
-  passes: z58.array(passCardDisplaySchema),
-  memberships: z58.array(membershipCardDisplaySchema)
-});
-var cartLineDisplaySchema = z58.object({
-  key: z58.string(),
-  title: z58.string(),
-  priceLabel: z58.string(),
-  quantity: z58.number(),
-  quantityEditable: z58.boolean()
-});
-var cartDisplaySchema = z58.object({
-  kind: z58.literal("cart"),
-  state: z58.enum(["empty", "ready"]),
-  heading: z58.string().nullable(),
-  className: z58.string().nullable(),
-  emptyMessage: z58.string(),
-  supportText: z58.string().nullable(),
-  items: z58.array(cartLineDisplaySchema),
-  subtotalLabel: z58.string().nullable(),
-  checkoutButtonText: z58.string(),
-  clearButtonText: z58.string()
-});
-var checkoutDisplaySchema = z58.object({
-  kind: z58.literal("checkout"),
-  state: z58.enum(["empty", "blocked", "ready"]),
-  heading: z58.string().nullable(),
-  className: z58.string().nullable(),
-  message: z58.string().nullable(),
-  submitButtonText: z58.string()
-});
-var passesMembershipsHydrationSchema = z58.object({
-  passes: z58.array(publicPassProductSchema),
-  memberships: z58.array(publicMembershipProductSchema),
-  passPurchaseMode: z58.enum(["add_to_cart", "buy_now"])
-});
-var productListHydrationSchema = z58.object({
-  products: z58.array(publicProductSchema),
-  showSummary: z58.boolean(),
-  showPrices: z58.boolean(),
-  addButtonText: z58.string()
-});
-var productDetailHydrationSchema = z58.object({
-  products: z58.array(publicProductSchema),
-  productId: z58.string().nullable(),
-  showSummary: z58.boolean(),
-  showBody: z58.boolean(),
-  addButtonText: z58.string()
-});
-var cartHydrationSchema = z58.object({
-  emptyStateText: z58.string(),
-  checkoutButtonText: z58.string(),
-  clearButtonText: z58.string()
-});
-var checkoutHydrationSchema = z58.object({
-  emptyStateText: z58.string(),
-  submitButtonText: z58.string()
-});
-var passesMembershipsRenderSchema = z58.object({
+var passCardDisplaySchema = z59.object({
+  id: z59.string(),
+  title: z59.string(),
+  description: z59.string().nullable(),
+  priceLabel: z59.string(),
+  creditsLabel: z59.string(),
+  perCreditLabel: z59.string().nullable(),
+  validityLabel: z59.string().nullable(),
+  actionLabel: z59.string()
+});
+var membershipCardDisplaySchema = z59.object({
+  id: z59.string(),
+  title: z59.string(),
+  description: z59.string().nullable(),
+  priceLabel: z59.string(),
+  intervalLabel: z59.string(),
+  actionLabel: z59.string()
+});
+var passesMembershipsDisplaySchema = z59.object({
+  kind: z59.literal("passes-memberships"),
+  state: z59.enum(["empty", "ready"]),
+  className: z59.string().nullable(),
+  layout: z59.enum(["grid", "list"]),
+  columns: z59.string(),
+  emptyMessage: z59.string(),
+  passesHeading: z59.string(),
+  membershipsHeading: z59.string(),
+  passes: z59.array(passCardDisplaySchema),
+  memberships: z59.array(membershipCardDisplaySchema)
+});
+var cartLineDisplaySchema = z59.object({
+  key: z59.string(),
+  title: z59.string(),
+  priceLabel: z59.string(),
+  quantity: z59.number(),
+  quantityEditable: z59.boolean()
+});
+var cartDisplaySchema = z59.object({
+  kind: z59.literal("cart"),
+  state: z59.enum(["empty", "ready"]),
+  heading: z59.string().nullable(),
+  className: z59.string().nullable(),
+  emptyMessage: z59.string(),
+  supportText: z59.string().nullable(),
+  items: z59.array(cartLineDisplaySchema),
+  subtotalLabel: z59.string().nullable(),
+  checkoutButtonText: z59.string(),
+  clearButtonText: z59.string()
+});
+var checkoutDisplaySchema = z59.object({
+  kind: z59.literal("checkout"),
+  state: z59.enum(["empty", "blocked", "ready"]),
+  heading: z59.string().nullable(),
+  className: z59.string().nullable(),
+  message: z59.string().nullable(),
+  submitButtonText: z59.string()
+});
+var passesMembershipsHydrationSchema = z59.object({
+  passes: z59.array(publicPassProductSchema),
+  memberships: z59.array(publicMembershipProductSchema),
+  passPurchaseMode: z59.enum(["add_to_cart", "buy_now"])
+});
+var productListHydrationSchema = z59.object({
+  products: z59.array(publicProductSchema),
+  showSummary: z59.boolean(),
+  showPrices: z59.boolean(),
+  addButtonText: z59.string()
+});
+var productDetailHydrationSchema = z59.object({
+  products: z59.array(publicProductSchema),
+  productId: z59.string().nullable(),
+  showSummary: z59.boolean(),
+  showBody: z59.boolean(),
+  addButtonText: z59.string()
+});
+var cartHydrationSchema = z59.object({
+  emptyStateText: z59.string(),
+  checkoutButtonText: z59.string(),
+  clearButtonText: z59.string()
+});
+var checkoutHydrationSchema = z59.object({
+  emptyStateText: z59.string(),
+  submitButtonText: z59.string()
+});
+var passesMembershipsRenderSchema = z59.object({
   display: passesMembershipsDisplaySchema,
   hydration: passesMembershipsHydrationSchema
 });
-var productListRenderSchema = z58.object({
+var productListRenderSchema = z59.object({
   display: productListDisplaySchema,
   hydration: productListHydrationSchema
 });
-var productDetailRenderSchema = z58.object({
+var productDetailRenderSchema = z59.object({
   display: productDetailDisplaySchema,
   hydration: productDetailHydrationSchema
 });
-var cartRenderSchema = z58.object({
+var cartRenderSchema = z59.object({
   display: cartDisplaySchema,
   hydration: cartHydrationSchema
 });
-var checkoutRenderSchema = z58.object({
+var checkoutRenderSchema = z59.object({
   display: checkoutDisplaySchema,
   hydration: checkoutHydrationSchema
 });
 function resolveShowPricePerCredit(source) {
   return source.showPricePerCredit ?? true;
 }
-var shopIslandMetaCodec = createZodCodec(z58.object({
-  siteId: z58.string().optional(),
-  apiBaseUrl: z58.string().optional(),
+var shopIslandMetaCodec = createZodCodec(z59.object({
+  siteId: z59.string().optional(),
+  apiBaseUrl: z59.string().optional(),
   stage: previewStageSchema.optional()
 }));
 var shopIslandMetaKeys = defineInteractiveIslandMetaKeys("siteId", "apiBaseUrl", "stage");
@@ -37373,7 +37748,7 @@ var shopBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/product-list.ts
-import { z as z59 } from "zod";
+import { z as z60 } from "zod";
 var productListManifest = createBlockManifest({
   id: "block.product-list",
   version: "1.0.0",
@@ -37506,7 +37881,7 @@ var productListBlockDefinition = {
     }
   }
 };
-var productListDataSchema = z59.object({
+var productListDataSchema = z60.object({
   products: publicProductsResponseSchema.optional()
 });
 
@@ -37767,72 +38142,72 @@ var checkoutBlockDefinition = {
 };
 
 // ../blocks/src/system/runtime/nodes/gifting.interactive.ts
-import { z as z60 } from "zod";
-var publicGiftCardOfferSchema = z60.object({
-  id: z60.string(),
-  kind: z60.literal("gift_card"),
-  title: z60.string(),
-  description: z60.string().nullable(),
-  sortOrder: z60.number().int(),
-  giftCard: z60.object({
-    fixedDenominations: z60.array(z60.number().int().positive()),
-    customAmountEnabled: z60.boolean(),
-    customAmountMinCents: z60.number().int().positive(),
-    customAmountMaxCents: z60.number().int().positive()
+import { z as z61 } from "zod";
+var publicGiftCardOfferSchema = z61.object({
+  id: z61.string(),
+  kind: z61.literal("gift_card"),
+  title: z61.string(),
+  description: z61.string().nullable(),
+  sortOrder: z61.number().int(),
+  giftCard: z61.object({
+    fixedDenominations: z61.array(z61.number().int().positive()),
+    customAmountEnabled: z61.boolean(),
+    customAmountMinCents: z61.number().int().positive(),
+    customAmountMaxCents: z61.number().int().positive()
   }),
-  voucher: z60.null()
-});
-var publicVoucherOfferSchema = z60.object({
-  id: z60.string(),
-  kind: z60.literal("voucher"),
-  title: z60.string(),
-  description: z60.string().nullable(),
-  sortOrder: z60.number().int(),
-  giftCard: z60.null(),
-  voucher: z60.object({
-    purchaseAmountCents: z60.number().int().positive()
+  voucher: z61.null()
+});
+var publicVoucherOfferSchema = z61.object({
+  id: z61.string(),
+  kind: z61.literal("voucher"),
+  title: z61.string(),
+  description: z61.string().nullable(),
+  sortOrder: z61.number().int(),
+  giftCard: z61.null(),
+  voucher: z61.object({
+    purchaseAmountCents: z61.number().int().positive()
   })
 });
-var publicGiftingOffersResponseSchema = z60.object({
-  currency: z60.string(),
-  giftCards: z60.array(publicGiftCardOfferSchema),
-  vouchers: z60.array(publicVoucherOfferSchema)
+var publicGiftingOffersResponseSchema = z61.object({
+  currency: z61.string(),
+  giftCards: z61.array(publicGiftCardOfferSchema),
+  vouchers: z61.array(publicVoucherOfferSchema)
 });
-var giftingSourceSchema = z60.object({
-  siteId: z60.string().optional(),
-  apiBaseUrl: z60.string().optional(),
+var giftingSourceSchema = z61.object({
+  siteId: z61.string().optional(),
+  apiBaseUrl: z61.string().optional(),
   offers: publicGiftingOffersResponseSchema.nullable().optional(),
-  className: z60.string().nullable().optional(),
-  heading: z60.string().nullable().optional(),
-  intro: z60.string().nullable().optional(),
-  giftCardsHeading: z60.string().nullable().optional(),
-  vouchersHeading: z60.string().nullable().optional(),
-  emptyStateText: z60.string().nullable().optional(),
-  checkoutButtonText: z60.string().nullable().optional(),
-  successMessage: z60.string().nullable().optional()
-});
-var giftingDisplaySchema = z60.object({
-  kind: z60.literal("gifting"),
-  state: z60.literal("ready"),
-  className: z60.string().nullable(),
-  heading: z60.string(),
-  intro: z60.string().nullable(),
-  giftCardsHeading: z60.string(),
-  vouchersHeading: z60.string(),
-  emptyStateText: z60.string()
-});
-var giftingHydrationSchema = z60.object({
+  className: z61.string().nullable().optional(),
+  heading: z61.string().nullable().optional(),
+  intro: z61.string().nullable().optional(),
+  giftCardsHeading: z61.string().nullable().optional(),
+  vouchersHeading: z61.string().nullable().optional(),
+  emptyStateText: z61.string().nullable().optional(),
+  checkoutButtonText: z61.string().nullable().optional(),
+  successMessage: z61.string().nullable().optional()
+});
+var giftingDisplaySchema = z61.object({
+  kind: z61.literal("gifting"),
+  state: z61.literal("ready"),
+  className: z61.string().nullable(),
+  heading: z61.string(),
+  intro: z61.string().nullable(),
+  giftCardsHeading: z61.string(),
+  vouchersHeading: z61.string(),
+  emptyStateText: z61.string()
+});
+var giftingHydrationSchema = z61.object({
   offers: publicGiftingOffersResponseSchema.nullable(),
-  checkoutButtonText: z60.string(),
-  successMessage: z60.string()
+  checkoutButtonText: z61.string(),
+  successMessage: z61.string()
 });
-var giftingRenderSchema = z60.object({
+var giftingRenderSchema = z61.object({
   display: giftingDisplaySchema,
   hydration: giftingHydrationSchema
 });
-var giftingIslandMetaCodec = createZodCodec(z60.object({
-  siteId: z60.string().optional(),
-  apiBaseUrl: z60.string().optional()
+var giftingIslandMetaCodec = createZodCodec(z61.object({
+  siteId: z61.string().optional(),
+  apiBaseUrl: z61.string().optional()
 }));
 var giftingIslandMetaKeys = defineInteractiveIslandMetaKeys(
   "siteId",
@@ -38003,7 +38378,7 @@ var giftingBlockDefinition = {
 };
 
 // ../blocks/src/system/runtime/nodes/newsletter-form.interactive.ts
-import { z as z61 } from "zod";
+import { z as z62 } from "zod";
 
 // ../blocks/src/system/blocks/newsletter-signup-destination.ts
 function parseNewsletterSignupBlockId(value) {
@@ -38138,65 +38513,65 @@ function withOptionalPhone(fields3, includePhone) {
 }
 
 // ../blocks/src/system/runtime/nodes/newsletter-form.interactive.ts
-var newsletterPresetSchema = z61.enum(["emailOnly", "emailName", "emailFirstLast", "emailNameCompany"]);
-var newsletterDestinationProviderSchema = z61.enum(["riverbank", "mailchimp"]);
-var newsletterFieldSchema = z61.object({
-  id: z61.string(),
-  type: z61.enum(["email", "text"]),
-  label: z61.string(),
-  required: z61.boolean(),
-  placeholder: z61.string().optional()
-});
-var newsletterSignupBlockIdSchema = z61.string().trim().min(1).transform(parseRequiredNewsletterSignupBlockId);
-var signedNewsletterDestinationRefSchema = z61.string().trim().min(1).transform(parseRequiredSignedNewsletterDestinationRef);
-var newsletterPublicDestinationRefSchema = z61.discriminatedUnion("tag", [
-  z61.object({
-    tag: z61.literal("block_ref"),
+var newsletterPresetSchema = z62.enum(["emailOnly", "emailName", "emailFirstLast", "emailNameCompany"]);
+var newsletterDestinationProviderSchema = z62.enum(["riverbank", "mailchimp"]);
+var newsletterFieldSchema = z62.object({
+  id: z62.string(),
+  type: z62.enum(["email", "text"]),
+  label: z62.string(),
+  required: z62.boolean(),
+  placeholder: z62.string().optional()
+});
+var newsletterSignupBlockIdSchema = z62.string().trim().min(1).transform(parseRequiredNewsletterSignupBlockId);
+var signedNewsletterDestinationRefSchema = z62.string().trim().min(1).transform(parseRequiredSignedNewsletterDestinationRef);
+var newsletterPublicDestinationRefSchema = z62.discriminatedUnion("tag", [
+  z62.object({
+    tag: z62.literal("block_ref"),
     blockId: newsletterSignupBlockIdSchema
   }),
-  z61.object({
-    tag: z61.literal("signed_destination_ref"),
+  z62.object({
+    tag: z62.literal("signed_destination_ref"),
     token: signedNewsletterDestinationRefSchema
   })
 ]);
-var newsletterSourceSchema = z61.object({
-  blockId: z61.string().nullable().optional(),
-  siteId: z61.string().optional(),
-  apiBaseUrl: z61.string().optional(),
-  listId: z61.string().nullable().optional(),
+var newsletterSourceSchema = z62.object({
+  blockId: z62.string().nullable().optional(),
+  siteId: z62.string().optional(),
+  apiBaseUrl: z62.string().optional(),
+  listId: z62.string().nullable().optional(),
   destinationProvider: newsletterDestinationProviderSchema.nullable().optional(),
   preset: newsletterPresetSchema.optional(),
-  includePhone: z61.boolean().optional(),
-  buttonLabel: z61.string().nullable().optional(),
-  successMessage: z61.string().nullable().optional(),
-  privacyNote: z61.string().nullable().optional(),
-  tags: z61.string().nullable().optional(),
-  spamProtectionEnabled: z61.boolean().optional(),
-  className: z61.string().nullable().optional()
-});
-var newsletterDisplaySchema = z61.object({
-  kind: z61.literal("newsletter-form"),
-  className: z61.string().nullable(),
-  buttonLabel: z61.string(),
-  successMessage: z61.string().nullable(),
-  privacyNote: z61.string().nullable(),
-  fields: z61.array(newsletterFieldSchema)
-});
-var newsletterHydrationSchema = z61.object({
+  includePhone: z62.boolean().optional(),
+  buttonLabel: z62.string().nullable().optional(),
+  successMessage: z62.string().nullable().optional(),
+  privacyNote: z62.string().nullable().optional(),
+  tags: z62.string().nullable().optional(),
+  spamProtectionEnabled: z62.boolean().optional(),
+  className: z62.string().nullable().optional()
+});
+var newsletterDisplaySchema = z62.object({
+  kind: z62.literal("newsletter-form"),
+  className: z62.string().nullable(),
+  buttonLabel: z62.string(),
+  successMessage: z62.string().nullable(),
+  privacyNote: z62.string().nullable(),
+  fields: z62.array(newsletterFieldSchema)
+});
+var newsletterHydrationSchema = z62.object({
   destinationRef: newsletterPublicDestinationRefSchema.nullable().optional(),
-  listId: z61.string().nullable().optional(),
+  listId: z62.string().nullable().optional(),
   preset: newsletterPresetSchema,
-  includePhone: z61.boolean(),
-  tags: z61.string().nullable().optional(),
-  spamProtectionEnabled: z61.boolean().optional()
+  includePhone: z62.boolean(),
+  tags: z62.string().nullable().optional(),
+  spamProtectionEnabled: z62.boolean().optional()
 });
-var newsletterRenderSchema = z61.object({
+var newsletterRenderSchema = z62.object({
   display: newsletterDisplaySchema,
   hydration: newsletterHydrationSchema
 });
-var newsletterIslandMetaCodec = createZodCodec(z61.object({
-  siteId: z61.string().optional(),
-  apiBaseUrl: z61.string().optional()
+var newsletterIslandMetaCodec = createZodCodec(z62.object({
+  siteId: z62.string().optional(),
+  apiBaseUrl: z62.string().optional()
 }));
 var newsletterIslandMetaKeys = defineInteractiveIslandMetaKeys("siteId", "apiBaseUrl");
 function buildNewsletterDisplay(source) {
@@ -38335,23 +38710,23 @@ var newsletterSignupBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/team-members.ts
-import { z as z62 } from "zod";
+import { z as z63 } from "zod";
 var ITEM_NAME2 = "member";
 var teamMemberPhotoSchema = mediaSchema2.refine((media2) => media2.type === "image", {
   message: "Team member photos must be image media"
 }).nullable();
-var teamMemberDataSchema = z62.object({
-  _type: z62.literal("teamMember"),
-  id: z62.string(),
-  name: z62.string(),
-  role: z62.string().nullable(),
-  roleLabel: z62.string().nullable(),
-  bio: z62.string().nullable(),
-  summary: z62.string().nullable(),
+var teamMemberDataSchema = z63.object({
+  _type: z63.literal("teamMember"),
+  id: z63.string(),
+  name: z63.string(),
+  role: z63.string().nullable(),
+  roleLabel: z63.string().nullable(),
+  bio: z63.string().nullable(),
+  summary: z63.string().nullable(),
   photo: teamMemberPhotoSchema,
-  profilePath: z62.string().nullable()
+  profilePath: z63.string().nullable()
 });
-var teamMembersDataSchema = z62.array(teamMemberDataSchema);
+var teamMembersDataSchema = z63.array(teamMemberDataSchema);
 var dynamicSourceWhen = { equals: "site_staff" };
 var manualSourceWhen = { equals: "site_staff", not: true };
 var headingNode = text(
@@ -39457,6 +39832,10 @@ var systemBlockDefinitionsRaw = [
     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" })]
@@ -41140,34 +41519,34 @@ import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
 var MAX_FONT_UPLOAD_BYTES = 5 * 1024 * 1024;
 
 // ../theme-core/src/runtime/buildThemeRuntimeFromBridge.ts
-import { z as z63 } from "zod";
-var themeBridgeConfigSchema = z63.object({
-  tokens: z63.record(z63.string(), z63.string()),
-  typography: z63.object({
-    headingFamily: z63.string().optional(),
-    bodyFamily: z63.string().optional(),
-    headingWeight: z63.number().optional(),
-    bodyWeight: z63.number().optional()
+import { z as z64 } from "zod";
+var themeBridgeConfigSchema = z64.object({
+  tokens: z64.record(z64.string(), z64.string()),
+  typography: z64.object({
+    headingFamily: z64.string().optional(),
+    bodyFamily: z64.string().optional(),
+    headingWeight: z64.number().optional(),
+    bodyWeight: z64.number().optional()
   }).optional(),
-  spacing: z63.enum(["comfortable", "standard", "dense"]).optional(),
-  corners: z63.enum(["square", "soft", "rounded", "pill"]).optional(),
-  shadows: z63.enum(["none", "low", "medium", "high"]).optional(),
-  components: z63.object({
-    buttons: z63.union([
-      z63.boolean(),
-      z63.object({
-        variants: z63.array(z63.enum(["primary", "secondary", "outline", "ghost"])).optional()
+  spacing: z64.enum(["comfortable", "standard", "dense"]).optional(),
+  corners: z64.enum(["square", "soft", "rounded", "pill"]).optional(),
+  shadows: z64.enum(["none", "low", "medium", "high"]).optional(),
+  components: z64.object({
+    buttons: z64.union([
+      z64.boolean(),
+      z64.object({
+        variants: z64.array(z64.enum(["primary", "secondary", "outline", "ghost"])).optional()
       })
     ]).optional(),
-    cards: z63.union([
-      z63.boolean(),
-      z63.object({
-        variants: z63.array(z63.enum(["default", "elevated", "outlined"])).optional()
+    cards: z64.union([
+      z64.boolean(),
+      z64.object({
+        variants: z64.array(z64.enum(["default", "elevated", "outlined"])).optional()
       })
     ]).optional(),
-    inputs: z63.boolean().optional()
+    inputs: z64.boolean().optional()
   }).optional(),
-  overrides: z63.record(z63.string(), z63.string()).optional()
+  overrides: z64.record(z64.string(), z64.string()).optional()
 }).passthrough();
 
 // ../theme-core/src/siteChrome.tsx
@@ -41385,14 +41764,21 @@ function coercePayload(payload) {
 
 // ../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) {
@@ -41415,14 +41801,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);
@@ -41465,7 +41851,8 @@ var SUPPORTED_LOADER_ENDPOINTS = [
   "listPublicPasses",
   "listPublicMemberships",
   "getPublicFormById",
-  "getPublicBookingServices"
+  "getPublicBookingServices",
+  "getPublicWeeklySlotAvailability"
 ];
 
 // ../blocks/src/system/data/normalizeLoaderParams.ts
@@ -41504,6 +41891,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;
@@ -41536,17 +41927,17 @@ function normalizeLoaderParams(endpoint, params, context) {
 function unsafeRetypeZodSchema(schema) {
   return schema;
 }
-var navIdListSchema = z64.preprocess((value) => {
+var navIdListSchema = z65.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;
-}, z64.array(z64.string()).max(200).optional());
-var dashboardNavVisibilityBaseSchema = z64.object({
-  mode: z64.enum(["augment", "restrict"]).optional(),
+}, z65.array(z65.string()).max(200).optional());
+var dashboardNavVisibilityBaseSchema = z65.object({
+  mode: z65.enum(["augment", "restrict"]).optional(),
   allowIds: navIdListSchema,
   denyIds: navIdListSchema
 }).strip();
-var dashboardNavVisibilityRolesSchema = z64.object({
+var dashboardNavVisibilityRolesSchema = z65.object({
   administrator: dashboardNavVisibilityBaseSchema.optional(),
   editor: dashboardNavVisibilityBaseSchema.optional(),
   team_member: dashboardNavVisibilityBaseSchema.optional()
@@ -41554,63 +41945,63 @@ var dashboardNavVisibilityRolesSchema = z64.object({
 var dashboardNavVisibilitySchema = dashboardNavVisibilityBaseSchema.extend({
   roles: dashboardNavVisibilityRolesSchema
 }).strip();
-var dashboardNavigationConfigSchema = z64.object({
+var dashboardNavigationConfigSchema = z65.object({
   siteNav: dashboardNavVisibilitySchema.optional(),
   settingsNav: dashboardNavVisibilitySchema.optional()
 }).strip();
-var dashboardConfigSchema = z64.object({
-  previewEditingEnabled: z64.boolean().optional(),
+var dashboardConfigSchema = z65.object({
+  previewEditingEnabled: z65.boolean().optional(),
   navigation: dashboardNavigationConfigSchema.optional()
 }).strip();
 var fieldDefinitionInputSchema = unsafeRetypeZodSchema(fieldSchema);
 var nodeDefinitionSchema = unsafeRetypeZodSchema(NodeSchema);
-var sdkLoaderEndpointSchema = z64.enum(SUPPORTED_LOADER_ENDPOINTS);
-var loaderFallbackScalarSchema = z64.union([
-  z64.string(),
-  z64.number(),
-  z64.boolean(),
-  z64.null()
+var sdkLoaderEndpointSchema = z65.enum(SUPPORTED_LOADER_ENDPOINTS);
+var loaderFallbackScalarSchema = z65.union([
+  z65.string(),
+  z65.number(),
+  z65.boolean(),
+  z65.null()
 ]);
-var loaderParamBindingSchema = z64.object({
-  $bind: z64.object({
-    from: z64.string().min(1, "Binding path is required"),
+var loaderParamBindingSchema = z65.object({
+  $bind: z65.object({
+    from: z65.string().min(1, "Binding path is required"),
     fallback: loaderFallbackScalarSchema.optional()
   })
 });
-var loaderParamValueSchema = z64.union([
-  z64.string(),
-  z64.number(),
-  z64.boolean(),
+var loaderParamValueSchema = z65.union([
+  z65.string(),
+  z65.number(),
+  z65.boolean(),
   loaderParamBindingSchema
 ]);
-var sdkConfigLoaderSchema = z64.object({
+var sdkConfigLoaderSchema = z65.object({
   endpoint: sdkLoaderEndpointSchema,
-  params: z64.record(z64.string(), loaderParamValueSchema),
-  mode: z64.enum(["server", "client"]).default("server")
+  params: z65.record(z65.string(), loaderParamValueSchema),
+  mode: z65.enum(["server", "client"]).default("server")
 });
-var sdkDataLoadersSchema = z64.record(z64.string(), sdkConfigLoaderSchema).refine((loaders) => Object.keys(loaders).length <= 5, { message: "Maximum 5 data loaders per block" }).optional();
-var sdkCustomBlockIdSchema = z64.string().min(8).regex(/^custom\.[a-z][a-z0-9-]*$/, {
+var sdkDataLoadersSchema = z65.record(z65.string(), sdkConfigLoaderSchema).refine((loaders) => Object.keys(loaders).length <= 5, { message: "Maximum 5 data loaders per block" }).optional();
+var sdkCustomBlockIdSchema = z65.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);
-var sdkCustomBlockInputSchema = z64.object({
+var sdkCustomBlockInputSchema = z65.object({
   id: sdkCustomBlockIdSchema,
-  title: z64.string().min(1),
-  titleSource: z64.union([z64.string().min(1), z64.array(z64.string().min(1)).min(1)]).optional(),
-  description: z64.string().optional(),
+  title: z65.string().min(1),
+  titleSource: z65.union([z65.string().min(1), z65.array(z65.string().min(1)).min(1)]).optional(),
+  description: z65.string().optional(),
   category: blockCategoryEnum,
-  icon: z64.string().optional(),
-  tags: z64.array(z64.string()).optional(),
+  icon: z65.string().optional(),
+  tags: z65.array(z65.string()).optional(),
   fields: fieldDefinitionInputSchema.array().min(1),
   dataLoaders: sdkDataLoadersSchema,
   layout: NodeSchema.optional(),
-  variants: z64.record(z64.string().min(1), NodeSchema).optional(),
-  defaultVariant: z64.string().min(1).optional(),
-  variantOptions: z64.record(
-    z64.string().min(1),
-    z64.object({
-      label: z64.string().min(1).optional(),
-      description: z64.string().min(1).optional(),
-      icon: z64.string().min(1).optional()
+  variants: z65.record(z65.string().min(1), NodeSchema).optional(),
+  defaultVariant: z65.string().min(1).optional(),
+  variantOptions: z65.record(
+    z65.string().min(1),
+    z65.object({
+      label: z65.string().min(1).optional(),
+      description: z65.string().min(1).optional(),
+      icon: z65.string().min(1).optional()
     })
   ).optional(),
   previewCustomize: previewCustomizeManifestCurationSchema.optional()
@@ -41621,7 +42012,7 @@ var sdkCustomBlockInputSchema = z64.object({
       const exists = data.fields.some((field) => field.id === source);
       if (!exists) {
         ctx.addIssue({
-          code: z64.ZodIssueCode.custom,
+          code: z65.ZodIssueCode.custom,
           message: `titleSource must reference a valid field ID (got "${source}")`,
           path: Array.isArray(data.titleSource) ? ["titleSource", index] : ["titleSource"]
         });
@@ -41630,7 +42021,7 @@ var sdkCustomBlockInputSchema = z64.object({
   }
   if (data.layout && data.variants) {
     ctx.addIssue({
-      code: z64.ZodIssueCode.custom,
+      code: z65.ZodIssueCode.custom,
       message: "Custom block must define either `layout` or `variants`, not both",
       path: ["variants"]
     });
@@ -41639,14 +42030,14 @@ var sdkCustomBlockInputSchema = z64.object({
     const keys = Object.keys(data.variants);
     if (keys.length === 0) {
       ctx.addIssue({
-        code: z64.ZodIssueCode.custom,
+        code: z65.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: z64.ZodIssueCode.custom,
+        code: z65.ZodIssueCode.custom,
         message: "`defaultVariant` must be a key present in `variants`",
         path: ["defaultVariant"]
       });
@@ -41655,7 +42046,7 @@ var sdkCustomBlockInputSchema = z64.object({
       for (const key of Object.keys(data.variantOptions)) {
         if (!Object.prototype.hasOwnProperty.call(data.variants, key)) {
           ctx.addIssue({
-            code: z64.ZodIssueCode.custom,
+            code: z65.ZodIssueCode.custom,
             message: "`variantOptions` key must exist in `variants`",
             path: ["variantOptions", key]
           });
@@ -41664,78 +42055,78 @@ var sdkCustomBlockInputSchema = z64.object({
     }
   }
 });
-var sdkBlockFieldExtensionInputSchema = z64.object({
+var sdkBlockFieldExtensionInputSchema = z65.object({
   fields: fieldDefinitionInputSchema.array().min(1)
 });
-var sdkBlockFieldExtensionsInputSchema = z64.record(
-  z64.string().min(1),
+var sdkBlockFieldExtensionsInputSchema = z65.record(
+  z65.string().min(1),
   sdkBlockFieldExtensionInputSchema
 );
-var sdkThemePaletteSchema = z64.record(z64.string(), z64.string());
-var sdkThemeConfigSchema = z64.object({
+var sdkThemePaletteSchema = z65.record(z65.string(), z65.string());
+var sdkThemeConfigSchema = z65.object({
   palette: sdkThemePaletteSchema
 });
-var sdkSectionBackgroundSchema = z64.object({
-  id: z64.string().min(1),
-  label: z64.string().min(1),
-  token: z64.string().min(1)
+var sdkSectionBackgroundSchema = z65.object({
+  id: z65.string().min(1),
+  label: z65.string().min(1),
+  token: z65.string().min(1)
 });
-var sdkSectionOptionsConfigSchema = z64.object({
-  backgroundColor: z64.boolean().optional(),
-  backgroundImage: z64.boolean().optional(),
-  backgroundGradient: z64.boolean().optional(),
-  spacing: z64.union([z64.array(z64.enum(["compact", "default", "spacious"])), z64.boolean()]).optional(),
-  textColor: z64.boolean().optional()
+var sdkSectionOptionsConfigSchema = z65.object({
+  backgroundColor: z65.boolean().optional(),
+  backgroundImage: z65.boolean().optional(),
+  backgroundGradient: z65.boolean().optional(),
+  spacing: z65.union([z65.array(z65.enum(["compact", "default", "spacious"])), z65.boolean()]).optional(),
+  textColor: z65.boolean().optional()
 });
-var sdkContainerOptionsConfigSchema = z64.object({
-  maxWidth: z64.union([z64.array(z64.enum(["narrow", "default", "wide", "full"])), z64.boolean()]).optional(),
-  alignment: z64.union([z64.array(z64.enum(["left", "center", "right"])), z64.boolean()]).optional()
+var sdkContainerOptionsConfigSchema = z65.object({
+  maxWidth: z65.union([z65.array(z65.enum(["narrow", "default", "wide", "full"])), z65.boolean()]).optional(),
+  alignment: z65.union([z65.array(z65.enum(["left", "center", "right"])), z65.boolean()]).optional()
 });
-var sdkSiteStyleConfigSchema = z64.object({
-  sectionBackgrounds: z64.array(sdkSectionBackgroundSchema).optional(),
+var sdkSiteStyleConfigSchema = z65.object({
+  sectionBackgrounds: z65.array(sdkSectionBackgroundSchema).optional(),
   sectionOptions: sdkSectionOptionsConfigSchema.optional(),
   containerOptions: sdkContainerOptionsConfigSchema.optional()
 });
-var sdkSiteLayoutConfigSchema = z64.object({
-  footerBlocks: z64.array(
-    z64.object({
-      id: z64.string().min(1).optional(),
-      kind: z64.string().min(1),
-      content: z64.record(z64.string(), z64.unknown()).optional()
+var sdkSiteLayoutConfigSchema = z65.object({
+  footerBlocks: z65.array(
+    z65.object({
+      id: z65.string().min(1).optional(),
+      kind: z65.string().min(1),
+      content: z65.record(z65.string(), z65.unknown()).optional()
     })
   ).optional()
 });
-var sdkFieldSelectOptionSchema = z64.object({
-  value: z64.string(),
-  label: z64.string()
+var sdkFieldSelectOptionSchema = z65.object({
+  value: z65.string(),
+  label: z65.string()
 });
-var sdkBlockFieldConfigSchema = z64.object({
-  options: z64.array(sdkFieldSelectOptionSchema).optional()
+var sdkBlockFieldConfigSchema = z65.object({
+  options: z65.array(sdkFieldSelectOptionSchema).optional()
 });
-var sdkBlockFieldOptionsMapSchema = z64.record(
-  z64.string().regex(/^(block\.|custom\.)[a-z][a-z0-9-]*$/, {
+var sdkBlockFieldOptionsMapSchema = z65.record(
+  z65.string().regex(/^(block\.|custom\.)[a-z][a-z0-9-]*$/, {
     message: "Block ID must be 'block.*' or 'custom.*' format"
   }),
-  z64.record(z64.string().min(1), sdkBlockFieldConfigSchema)
+  z65.record(z65.string().min(1), sdkBlockFieldConfigSchema)
 ).optional();
-var sdkContentTypeTemplateConfigSchema = z64.object({
-  blocks: z64.array(z64.unknown())
+var sdkContentTypeTemplateConfigSchema = z65.object({
+  blocks: z65.array(z65.unknown())
 }).passthrough();
-var sdkContentTypeOrderingConfigSchema = z64.object({
-  mode: z64.enum(["default", "manual"]).optional()
+var sdkContentTypeOrderingConfigSchema = z65.object({
+  mode: z65.enum(["default", "manual"]).optional()
 }).optional();
-var sdkContentTypeConfigSchema = z64.object({
-  key: z64.string().min(1),
-  fields: z64.array(z64.unknown()),
+var sdkContentTypeConfigSchema = z65.object({
+  key: z65.string().min(1),
+  fields: z65.array(z65.unknown()),
   ordering: sdkContentTypeOrderingConfigSchema,
   template: sdkContentTypeTemplateConfigSchema.nullable().optional()
 }).passthrough();
-var sdkContentConfigSchema = z64.object({
-  contentTypes: z64.array(sdkContentTypeConfigSchema).optional(),
-  pages: z64.array(z64.unknown()).optional(),
-  entries: z64.array(z64.unknown()).optional(),
-  navigationMenus: z64.array(z64.unknown()).optional(),
-  settings: z64.unknown().optional()
+var sdkContentConfigSchema = z65.object({
+  contentTypes: z65.array(sdkContentTypeConfigSchema).optional(),
+  pages: z65.array(z65.unknown()).optional(),
+  entries: z65.array(z65.unknown()).optional(),
+  navigationMenus: z65.array(z65.unknown()).optional(),
+  settings: z65.unknown().optional()
 }).passthrough();
 var SDK_WORKFLOW_ID_MAX_LENGTH = 120;
 var SDK_WORKFLOW_TITLE_MAX_LENGTH = 120;
@@ -41750,62 +42141,62 @@ var SDK_WORKFLOW_CONFIRMATION_TITLE_MAX_LENGTH = 120;
 var SDK_WORKFLOW_CONFIRMATION_BODY_MAX_LENGTH = 500;
 var SDK_WORKFLOW_ID_PATTERN = /^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/;
 var SDK_WORKFLOW_ENDPOINT_PATTERN = /^\//;
-var sdkWorkflowIdSchema = z64.string().min(1).max(SDK_WORKFLOW_ID_MAX_LENGTH).regex(SDK_WORKFLOW_ID_PATTERN, {
+var sdkWorkflowIdSchema = z65.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"
 });
-var sdkWorkflowEndpointSchema = z64.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 "/"' });
-var sdkWorkflowManualTriggerSchema = z64.object({
-  type: z64.literal("manual")
+var sdkWorkflowEndpointSchema = z65.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 "/"' });
+var sdkWorkflowManualTriggerSchema = z65.object({
+  type: z65.literal("manual")
 }).strict();
-var sdkWorkflowTriggerFieldSchema = z64.string().trim().min(1).max(SDK_WORKFLOW_TRIGGER_FIELD_MAX_LENGTH).refine((field) => !field.includes("."), {
+var sdkWorkflowTriggerFieldSchema = z65.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"
 });
-var sdkWorkflowFieldChangedConditionSchema = z64.object({
+var sdkWorkflowFieldChangedConditionSchema = z65.object({
   field: sdkWorkflowTriggerFieldSchema,
-  changed: z64.literal(true)
+  changed: z65.literal(true)
 }).strict();
-var sdkWorkflowFieldEmptyConditionSchema = z64.object({
+var sdkWorkflowFieldEmptyConditionSchema = z65.object({
   field: sdkWorkflowTriggerFieldSchema,
-  isEmpty: z64.boolean()
+  isEmpty: z65.boolean()
 }).strict();
-var sdkWorkflowEntryDraftUpdatedTriggerSchema = z64.object({
-  type: z64.literal("entry.draft.updated"),
-  when: z64.array(
-    z64.union([
+var sdkWorkflowEntryDraftUpdatedTriggerSchema = z65.object({
+  type: z65.literal("entry.draft.updated"),
+  when: z65.array(
+    z65.union([
       sdkWorkflowFieldChangedConditionSchema,
       sdkWorkflowFieldEmptyConditionSchema
     ])
   ).min(1).max(SDK_WORKFLOW_TRIGGER_CONDITION_MAX_COUNT)
 }).strict();
-var sdkWorkflowTriggerSchema = z64.discriminatedUnion("type", [
+var sdkWorkflowTriggerSchema = z65.discriminatedUnion("type", [
   sdkWorkflowManualTriggerSchema,
   sdkWorkflowEntryDraftUpdatedTriggerSchema
 ]);
-var sdkWorkflowConfirmationSchema = z64.object({
-  title: z64.string().trim().min(1).max(SDK_WORKFLOW_CONFIRMATION_TITLE_MAX_LENGTH),
-  body: z64.string().trim().min(1).max(SDK_WORKFLOW_CONFIRMATION_BODY_MAX_LENGTH).optional()
+var sdkWorkflowConfirmationSchema = z65.object({
+  title: z65.string().trim().min(1).max(SDK_WORKFLOW_CONFIRMATION_TITLE_MAX_LENGTH),
+  body: z65.string().trim().min(1).max(SDK_WORKFLOW_CONFIRMATION_BODY_MAX_LENGTH).optional()
 }).strict();
-var sdkWorkflowConfigSchema = z64.object({
+var sdkWorkflowConfigSchema = z65.object({
   id: sdkWorkflowIdSchema,
-  title: z64.string().trim().min(1).max(SDK_WORKFLOW_TITLE_MAX_LENGTH),
-  description: z64.string().trim().min(1).max(SDK_WORKFLOW_DESCRIPTION_MAX_LENGTH).optional(),
-  contentType: z64.string().trim().min(1).max(SDK_WORKFLOW_CONTENT_TYPE_MAX_LENGTH),
+  title: z65.string().trim().min(1).max(SDK_WORKFLOW_TITLE_MAX_LENGTH),
+  description: z65.string().trim().min(1).max(SDK_WORKFLOW_DESCRIPTION_MAX_LENGTH).optional(),
+  contentType: z65.string().trim().min(1).max(SDK_WORKFLOW_CONTENT_TYPE_MAX_LENGTH),
   endpoint: sdkWorkflowEndpointSchema,
-  triggers: z64.array(sdkWorkflowTriggerSchema).min(1).max(SDK_WORKFLOW_TRIGGER_MAX_COUNT),
+  triggers: z65.array(sdkWorkflowTriggerSchema).min(1).max(SDK_WORKFLOW_TRIGGER_MAX_COUNT),
   confirmation: sdkWorkflowConfirmationSchema.optional()
 }).strict();
-var sdkWorkflowsSchema = z64.array(sdkWorkflowConfigSchema).max(SDK_WORKFLOW_MAX_COUNT, "Maximum 50 workflows per site").refine((workflows) => {
+var sdkWorkflowsSchema = z65.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();
-var riverbankSiteConfigInputSchema = z64.object({
-  siteId: z64.string().uuid(),
-  previewUrl: z64.string().url().optional(),
-  liveUrl: z64.string().url().optional(),
+var riverbankSiteConfigInputSchema = z65.object({
+  siteId: z65.string().uuid(),
+  previewUrl: z65.string().url().optional(),
+  liveUrl: z65.string().url().optional(),
   theme: sdkThemeConfigSchema.optional(),
   styles: sdkSiteStyleConfigSchema.optional(),
   layout: sdkSiteLayoutConfigSchema.optional(),
-  customBlocks: z64.array(sdkCustomBlockInputSchema).max(100, "Maximum 100 custom blocks per site").refine((blocks) => {
+  customBlocks: z65.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(),
@@ -41813,50 +42204,51 @@ var riverbankSiteConfigInputSchema = z64.object({
   blockFieldExtensions: sdkBlockFieldExtensionsInputSchema.optional(),
   workflows: sdkWorkflowsSchema,
   content: sdkContentConfigSchema.optional(),
-  contentDir: z64.string().optional(),
-  sync: z64.object({
-    existingEntries: z64.enum(["skip", "update"]).optional()
+  contentDir: z65.string().optional(),
+  sync: z65.object({
+    existingEntries: z65.enum(["skip", "update"]).optional()
   }).optional(),
-  deploy: z64.object({
-    verifyCommand: z64.string().optional(),
-    prebuildOutput: z64.string().optional()
+  deploy: z65.object({
+    verifyCommand: z65.string().optional(),
+    prebuildOutput: z65.string().optional()
   }).optional(),
-  themeSource: z64.enum(["local", "cms"]).optional(),
-  activeTheme: z64.string().optional(),
-  enablePortal: z64.boolean().optional(),
+  themeSource: z65.enum(["local", "cms"]).optional(),
+  activeTheme: z65.string().optional(),
+  enablePortal: z65.boolean().optional(),
   dashboard: dashboardConfigSchema.optional()
 }).strict();
-var pushSdkConfigBodySchema = z64.object({
+var pushSdkConfigBodySchema = z65.object({
   config: riverbankSiteConfigInputSchema,
-  forceContentTypes: z64.boolean().optional()
+  forceContentTypes: z65.boolean().optional(),
+  mode: z65.enum(["apply", "preview"]).optional()
 }).strict();
 
 // ../api/src/siteOnboarding.ts
-import { z as z65 } from "zod";
+import { z as z66 } from "zod";
 var LAUNCH_REQUIREMENT_OVERRIDE_DEFINITIONS = {
   configure_appointments: {
     requirementId: "configure_appointments",
     reason: "launch_anyway"
   }
 };
-var acknowledgeLaunchRequirementRequestSchema = z65.discriminatedUnion(
+var acknowledgeLaunchRequirementRequestSchema = z66.discriminatedUnion(
   "requirementId",
   [
-    z65.object({
-      requirementId: z65.literal("review_generated_site")
+    z66.object({
+      requirementId: z66.literal("review_generated_site")
     }),
-    z65.object({
-      requirementId: z65.literal(
+    z66.object({
+      requirementId: z66.literal(
         LAUNCH_REQUIREMENT_OVERRIDE_DEFINITIONS.configure_appointments.requirementId
       ),
-      overrideReason: z65.literal(
+      overrideReason: z66.literal(
         LAUNCH_REQUIREMENT_OVERRIDE_DEFINITIONS.configure_appointments.reason
       )
     })
   ]
 );
-var goLiveSiteRequestSchema = z65.object({
-  acceptExtraSiteCharge: z65.boolean().optional()
+var goLiveSiteRequestSchema = z66.object({
+  acceptExtraSiteCharge: z66.boolean().optional()
 });
 
 // ../api/src/customerMembershipOutcomes.ts
@@ -41936,7 +42328,7 @@ var COURSE_ENROLLMENT_REFUND_FAILED_CODES = [
 ];
 
 // ../api/src/bookingVerticals.ts
-import { z as z66 } from "zod";
+import { z as z67 } from "zod";
 var VERTICAL_IDS = [
   "yoga_wellness",
   "fitness_pt",
@@ -42101,39 +42493,39 @@ function getSiteVerticalConfigIssues(rawConfig, config) {
   }
   return [...issues];
 }
-var VerticalIdSchema = z66.string().trim().transform((value, ctx) => {
+var VerticalIdSchema = z67.string().trim().transform((value, ctx) => {
   const parsed = parseVerticalId(value);
   if (!parsed) {
     ctx.addIssue({
-      code: z66.ZodIssueCode.custom,
+      code: z67.ZodIssueCode.custom,
       message: "Unknown booking vertical"
     });
-    return z66.NEVER;
+    return z67.NEVER;
   }
   return parsed;
 });
-var VerticalPresetIdSchema = z66.string().trim().transform((value, ctx) => {
+var VerticalPresetIdSchema = z67.string().trim().transform((value, ctx) => {
   const parsed = parseVerticalPresetId(value);
   if (!parsed) {
     ctx.addIssue({
-      code: z66.ZodIssueCode.custom,
+      code: z67.ZodIssueCode.custom,
       message: "Unknown booking preset"
     });
-    return z66.NEVER;
+    return z67.NEVER;
   }
   return parsed;
 });
-var BookingVerticalConfigSchema = z66.object({
+var BookingVerticalConfigSchema = z67.object({
   verticalId: VerticalIdSchema.nullable(),
-  selectedPresetIds: z66.array(VerticalPresetIdSchema).max(20)
+  selectedPresetIds: z67.array(VerticalPresetIdSchema).max(20)
 }).transform((value, ctx) => {
   const resolved = resolveSiteVerticalBookingConfig(value);
   if (resolved.kind === "invalid") {
     ctx.addIssue({
-      code: z66.ZodIssueCode.custom,
+      code: z67.ZodIssueCode.custom,
       message: `Invalid booking vertical config: ${resolved.issues.join(", ")}`
     });
-    return z66.NEVER;
+    return z67.NEVER;
   }
   return resolved.config;
 });
@@ -42160,51 +42552,51 @@ function isRecord11(value) {
 }
 
 // ../api/src/appointmentSetup.ts
-import { z as z67 } from "zod";
+import { z as z68 } from "zod";
 var APPOINTMENT_SETUP_MAX_MINUTES = 1440;
-var appointmentSetupRefSchema = z67.discriminatedUnion("kind", [
-  z67.object({ kind: z67.literal("existing"), id: z67.string().min(1) }),
-  z67.object({ kind: z67.literal("new"), draftId: z67.string().min(1) })
+var appointmentSetupRefSchema = z68.discriminatedUnion("kind", [
+  z68.object({ kind: z68.literal("existing"), id: z68.string().min(1) }),
+  z68.object({ kind: z68.literal("new"), draftId: z68.string().min(1) })
 ]);
-var appointmentSetupVenueChoiceSchema = z67.discriminatedUnion("kind", [
-  z67.object({ kind: z67.literal("none") }),
-  z67.object({ kind: z67.literal("existing"), venueId: z67.string().min(1) }),
-  z67.object({
-    kind: z67.literal("create"),
-    draftId: z67.string().min(1),
-    title: z67.string().trim().min(1),
-    description: z67.string().nullable(),
-    timezone: z67.string().trim().min(1).nullable(),
-    addressJson: z67.record(z67.string(), z67.unknown()),
-    locationJson: z67.object({ lat: z67.number(), lng: z67.number() }).nullable()
+var appointmentSetupVenueChoiceSchema = z68.discriminatedUnion("kind", [
+  z68.object({ kind: z68.literal("none") }),
+  z68.object({ kind: z68.literal("existing"), venueId: z68.string().min(1) }),
+  z68.object({
+    kind: z68.literal("create"),
+    draftId: z68.string().min(1),
+    title: z68.string().trim().min(1),
+    description: z68.string().nullable(),
+    timezone: z68.string().trim().min(1).nullable(),
+    addressJson: z68.record(z68.string(), z68.unknown()),
+    locationJson: z68.object({ lat: z68.number(), lng: z68.number() }).nullable()
   })
 ]);
-var appointmentSetupPaymentDraftSchema = z67.object({
-  priceType: z67.union([z67.literal("free"), z67.literal("paid")])
-});
-var appointmentSetupServiceAssignmentDraftSchema = z67.discriminatedUnion("kind", [
-  z67.object({ kind: z67.literal("all_practitioners") }),
-  z67.object({
-    kind: z67.literal("selected_practitioners"),
-    resourceRefs: z67.array(appointmentSetupRefSchema)
+var appointmentSetupPaymentDraftSchema = z68.object({
+  priceType: z68.union([z68.literal("free"), z68.literal("paid")])
+});
+var appointmentSetupServiceAssignmentDraftSchema = z68.discriminatedUnion("kind", [
+  z68.object({ kind: z68.literal("all_practitioners") }),
+  z68.object({
+    kind: z68.literal("selected_practitioners"),
+    resourceRefs: z68.array(appointmentSetupRefSchema)
   })
 ]);
-var appointmentSetupServiceDraftSchema = z67.object({
+var appointmentSetupServiceDraftSchema = z68.object({
   ref: appointmentSetupRefSchema,
-  title: z67.string().trim().min(1),
-  description: z67.string().nullable(),
-  durationMinutes: z67.number().int().positive().max(APPOINTMENT_SETUP_MAX_MINUTES),
-  prepMinutes: z67.number().int().nonnegative().max(APPOINTMENT_SETUP_MAX_MINUTES).default(0),
-  cleanupMinutes: z67.number().int().nonnegative().max(APPOINTMENT_SETUP_MAX_MINUTES).default(0),
-  priceAmount: z67.number().int().nonnegative().nullable(),
-  isActive: z67.boolean(),
-  locationType: z67.union([
-    z67.literal("virtual"),
-    z67.literal("in_person"),
-    z67.literal("hybrid")
+  title: z68.string().trim().min(1),
+  description: z68.string().nullable(),
+  durationMinutes: z68.number().int().positive().max(APPOINTMENT_SETUP_MAX_MINUTES),
+  prepMinutes: z68.number().int().nonnegative().max(APPOINTMENT_SETUP_MAX_MINUTES).default(0),
+  cleanupMinutes: z68.number().int().nonnegative().max(APPOINTMENT_SETUP_MAX_MINUTES).default(0),
+  priceAmount: z68.number().int().nonnegative().nullable(),
+  isActive: z68.boolean(),
+  locationType: z68.union([
+    z68.literal("virtual"),
+    z68.literal("in_person"),
+    z68.literal("hybrid")
   ]),
   venue: appointmentSetupVenueChoiceSchema,
-  timezone: z67.string().trim().min(1).nullable(),
+  timezone: z68.string().trim().min(1).nullable(),
   payment: appointmentSetupPaymentDraftSchema,
   assignment: appointmentSetupServiceAssignmentDraftSchema
 }).superRefine((service, ctx) => {
@@ -42223,49 +42615,49 @@ var appointmentSetupServiceDraftSchema = z67.object({
     });
   }
 });
-var appointmentSetupPractitionerDraftSchema = z67.object({
+var appointmentSetupPractitionerDraftSchema = z68.object({
   ref: appointmentSetupRefSchema,
-  displayName: z67.string().trim().min(1),
-  bio: z67.string().nullable(),
-  timezone: z67.string().trim().min(1),
-  colorHex: z67.string().nullable()
-});
-var appointmentSetupWeeklyWindowDraftSchema = z67.object({
-  weekday: z67.number().int().min(0).max(6),
-  startTime: z67.string(),
-  endTime: z67.string()
-});
-var appointmentSetupStartTimePolicyDraftSchema = z67.discriminatedUnion("kind", [
-  z67.object({ kind: z67.literal("automatic_spacing") }),
-  z67.object({
-    kind: z67.literal("regular_interval"),
-    intervalMinutes: z67.union([
-      z67.literal(10),
-      z67.literal(15),
-      z67.literal(20),
-      z67.literal(30),
-      z67.literal(45),
-      z67.literal(60)
+  displayName: z68.string().trim().min(1),
+  bio: z68.string().nullable(),
+  timezone: z68.string().trim().min(1),
+  colorHex: z68.string().nullable()
+});
+var appointmentSetupWeeklyWindowDraftSchema = z68.object({
+  weekday: z68.number().int().min(0).max(6),
+  startTime: z68.string(),
+  endTime: z68.string()
+});
+var appointmentSetupStartTimePolicyDraftSchema = z68.discriminatedUnion("kind", [
+  z68.object({ kind: z68.literal("automatic_spacing") }),
+  z68.object({
+    kind: z68.literal("regular_interval"),
+    intervalMinutes: z68.union([
+      z68.literal(10),
+      z68.literal(15),
+      z68.literal(20),
+      z68.literal(30),
+      z68.literal(45),
+      z68.literal(60)
     ])
   })
 ]);
-var appointmentSetupAvailabilityDraftSchema = z67.object({
-  kind: z67.literal("weekly_windows"),
+var appointmentSetupAvailabilityDraftSchema = z68.object({
+  kind: z68.literal("weekly_windows"),
   resourceRef: appointmentSetupRefSchema,
   serviceRef: appointmentSetupRefSchema.nullable(),
-  windows: z67.array(appointmentSetupWeeklyWindowDraftSchema),
+  windows: z68.array(appointmentSetupWeeklyWindowDraftSchema),
   startTimePolicy: appointmentSetupStartTimePolicyDraftSchema.optional()
 });
 var APPOINTMENT_DEFAULT_MIN_LEAD_MINUTES_MAX = 28 * 24 * 60;
 var APPOINTMENT_DEFAULT_MAX_BOOKING_NOTICE_MINUTES_MAX = 10 * 365 * 24 * 60;
-var appointmentSetupBookingNoticeSchema = z67.object({
-  minLeadMinutes: z67.number().int().nonnegative().max(APPOINTMENT_DEFAULT_MIN_LEAD_MINUTES_MAX),
-  maxBookingNoticeMinutes: z67.number().int().nonnegative().max(APPOINTMENT_DEFAULT_MAX_BOOKING_NOTICE_MINUTES_MAX)
-});
-var applyAppointmentSetupRequestSchema = z67.object({
-  services: z67.array(appointmentSetupServiceDraftSchema),
-  practitioners: z67.array(appointmentSetupPractitionerDraftSchema),
-  availability: z67.array(appointmentSetupAvailabilityDraftSchema),
+var appointmentSetupBookingNoticeSchema = z68.object({
+  minLeadMinutes: z68.number().int().nonnegative().max(APPOINTMENT_DEFAULT_MIN_LEAD_MINUTES_MAX),
+  maxBookingNoticeMinutes: z68.number().int().nonnegative().max(APPOINTMENT_DEFAULT_MAX_BOOKING_NOTICE_MINUTES_MAX)
+});
+var applyAppointmentSetupRequestSchema = z68.object({
+  services: z68.array(appointmentSetupServiceDraftSchema),
+  practitioners: z68.array(appointmentSetupPractitionerDraftSchema),
+  availability: z68.array(appointmentSetupAvailabilityDraftSchema),
   bookingNotice: appointmentSetupBookingNoticeSchema
 });
 
@@ -42298,24 +42690,24 @@ var STAFF_CANCELLATION_CONTEXT_CATEGORIES = [
 ];
 
 // ../api/src/siteBanner.ts
-import { z as z68 } from "zod";
+import { z as z69 } from "zod";
 var SITE_BANNER_SCOPE_VALUES = ["homepage", "all-pages"];
 var SITE_BANNER_TONE_VALUES = ["announcement", "promotion", "notice", "warning"];
 var SITE_BANNER_MAX_TEXT_LENGTH = 320;
 var SITE_BANNER_MAX_PARAGRAPHS = 2;
-var siteBannerScopeSchema = z68.enum(SITE_BANNER_SCOPE_VALUES);
-var siteBannerToneSchema = z68.enum(SITE_BANNER_TONE_VALUES);
-var siteBannerBodySchema = z68.unknown().transform(unwrapRichTextValue);
-var siteBannerCtaSchema = z68.object({
-  label: z68.string().trim().min(1),
+var siteBannerScopeSchema = z69.enum(SITE_BANNER_SCOPE_VALUES);
+var siteBannerToneSchema = z69.enum(SITE_BANNER_TONE_VALUES);
+var siteBannerBodySchema = z69.unknown().transform(unwrapRichTextValue);
+var siteBannerCtaSchema = z69.object({
+  label: z69.string().trim().min(1),
   link: linkPayloadSchema
 });
-var siteBannerSettingsSchema = z68.discriminatedUnion("enabled", [
-  z68.object({
-    enabled: z68.literal(false)
+var siteBannerSettingsSchema = z69.discriminatedUnion("enabled", [
+  z69.object({
+    enabled: z69.literal(false)
   }),
-  z68.object({
-    enabled: z68.literal(true),
+  z69.object({
+    enabled: z69.literal(true),
     scope: siteBannerScopeSchema,
     tone: siteBannerToneSchema,
     body: siteBannerBodySchema,
@@ -42329,7 +42721,7 @@ var siteBannerSettingsInputSchema = siteBannerSettingsSchema.superRefine((value,
   const analysis = analyzeSiteBannerBody(value.body);
   for (const issue of analysis.issues) {
     ctx.addIssue({
-      code: z68.ZodIssueCode.custom,
+      code: z69.ZodIssueCode.custom,
       path: ["body"],
       message: siteBannerBodyIssueMessage(issue)
     });
@@ -42556,71 +42948,71 @@ function unsafeAsNavigationMenuIdentifier(identifier) {
 var MAIN_NAVIGATION_MENU_IDENTIFIER = unsafeAsNavigationMenuIdentifier("main");
 
 // ../api/src/aiPlayground.ts
-import { z as z69 } from "zod";
-var Rfc6902PatchOp = z69.discriminatedUnion("op", [
+import { z as z70 } from "zod";
+var Rfc6902PatchOp = z70.discriminatedUnion("op", [
   // Standard RFC-6902 operations
-  z69.object({
-    op: z69.literal("add"),
-    path: z69.string(),
-    value: z69.unknown()
+  z70.object({
+    op: z70.literal("add"),
+    path: z70.string(),
+    value: z70.unknown()
   }),
-  z69.object({
-    op: z69.literal("remove"),
-    path: z69.string()
+  z70.object({
+    op: z70.literal("remove"),
+    path: z70.string()
   }),
-  z69.object({
-    op: z69.literal("replace"),
-    path: z69.string(),
-    value: z69.unknown()
+  z70.object({
+    op: z70.literal("replace"),
+    path: z70.string(),
+    value: z70.unknown()
   }),
-  z69.object({
-    op: z69.literal("move"),
-    from: z69.string(),
-    path: z69.string()
+  z70.object({
+    op: z70.literal("move"),
+    from: z70.string(),
+    path: z70.string()
   }),
-  z69.object({
-    op: z69.literal("copy"),
-    from: z69.string(),
-    path: z69.string()
+  z70.object({
+    op: z70.literal("copy"),
+    from: z70.string(),
+    path: z70.string()
   }),
   // Block-level operations (Phase 2)
-  z69.object({
-    op: z69.literal("add_block"),
-    blockKind: z69.string(),
-    afterBlockId: z69.string().nullable(),
-    content: z69.record(z69.string(), z69.unknown()),
-    rationale: z69.string()
+  z70.object({
+    op: z70.literal("add_block"),
+    blockKind: z70.string(),
+    afterBlockId: z70.string().nullable(),
+    content: z70.record(z70.string(), z70.unknown()),
+    rationale: z70.string()
   }),
-  z69.object({
-    op: z69.literal("delete_block"),
-    blockId: z69.string(),
-    rationale: z69.string()
+  z70.object({
+    op: z70.literal("delete_block"),
+    blockId: z70.string(),
+    rationale: z70.string()
   }),
-  z69.object({
-    op: z69.literal("reorder_block"),
-    blockId: z69.string(),
-    afterBlockId: z69.string().nullable(),
-    rationale: z69.string()
+  z70.object({
+    op: z70.literal("reorder_block"),
+    blockId: z70.string(),
+    afterBlockId: z70.string().nullable(),
+    rationale: z70.string()
   })
 ]);
-var PlaygroundProposeRequest = z69.object({
-  request: z69.string().min(1).max(2e3)
+var PlaygroundProposeRequest = z70.object({
+  request: z70.string().min(1).max(2e3)
 });
-var MultiPagePatchEnvelope = z69.object({
-  pageId: z69.string(),
-  blockId: z69.string().optional(),
+var MultiPagePatchEnvelope = z70.object({
+  pageId: z70.string(),
+  blockId: z70.string().optional(),
   // Not present for page-level ops
-  blockKind: z69.string().optional(),
-  blockPurpose: z69.string().optional().nullable(),
-  ops: z69.array(Rfc6902PatchOp),
-  rationale: z69.string(),
-  currentContent: z69.record(z69.string(), z69.unknown()).optional()
+  blockKind: z70.string().optional(),
+  blockPurpose: z70.string().optional().nullable(),
+  ops: z70.array(Rfc6902PatchOp),
+  rationale: z70.string(),
+  currentContent: z70.record(z70.string(), z70.unknown()).optional()
 });
-var MultiPageUpdateResponse = z69.object({
-  patches: z69.array(MultiPagePatchEnvelope),
-  assistantMessage: z69.string(),
-  pagesModified: z69.number(),
-  toolCallsUsed: z69.number()
+var MultiPageUpdateResponse = z70.object({
+  patches: z70.array(MultiPagePatchEnvelope),
+  assistantMessage: z70.string(),
+  pagesModified: z70.number(),
+  toolCallsUsed: z70.number()
 });
 
 // src/data/prefetchBlockData.ts
@@ -42702,7 +43094,8 @@ var loaderAdapters = {
   listPublicPasses,
   listPublicMemberships,
   getPublicFormById,
-  getPublicBookingServices
+  getPublicBookingServices,
+  getPublicWeeklySlotAvailability
 };
 function readStringParam(params, key) {
   const value = params[key];
@@ -42878,6 +43271,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(
@@ -43051,7 +43453,16 @@ function sanitizeNullableSdkRuntimeBlockContent(blockKind, content) {
 
 // src/rendering/helpers/loadPage.ts
 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 })
@@ -43061,6 +43472,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,
@@ -43090,7 +43506,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 {
@@ -43110,13 +43530,17 @@ async function loadPage(params) {
   };
 }
 
-// ../blocks/src/bindings/types.ts
-var TRANSFORMS = {
+// ../field-primitives/src/bindings/index.ts
+var BINDING_TRANSFORMS = {
   RICHTEXT_FIRST_PARAGRAPH: "richtext.firstParagraph",
   DATE_FORMAT_SHORT: "date.formatShort",
   DATE_FORMAT_LONG: "date.formatLong",
   TEXT_INLINE_TEXT: "text.inlineText"
 };
+var BINDING_TRANSFORM_VALUES = Object.values(BINDING_TRANSFORMS);
+
+// ../blocks/src/bindings/types.ts
+var TRANSFORMS = BINDING_TRANSFORMS;
 var BINDING_SOURCES = ["field", "meta", "literal", "transform", "fallback"];
 
 // ../blocks/src/bindings/index.ts
@@ -43332,7 +43756,12 @@ function isDocWrapper(value) {
   return isRecord3(doc) && typeof doc.type === "string" && doc.type === "doc";
 }
 
+// src/contracts/bindings.ts
+var BINDING_TRANSFORM_VALUES2 = BINDING_TRANSFORM_VALUES;
+var BINDING_TRANSFORM_LIST = BINDING_TRANSFORM_VALUES2.join(", ");
+
 // src/rendering/helpers/bindings.ts
+var isRecord14 = isRecord3;
 var normalizeBindingOutput2 = normalizeBindingOutput;
 var applyBindingsToContent2 = applyBindingsToContent;
 
@@ -43378,14 +43807,30 @@ function getRejectedReason(result) {
   return result.reason;
 }
 async function loadContent(params) {
-  const { client, siteId, path, preview = false, forceSite } = params;
+  const {
+    client,
+    siteId,
+    path,
+    preview = false,
+    forceSite,
+    contentContract = "compat"
+  } = params;
   const [siteResult, contentResult] = await Promise.allSettled([
     client.getSite({ id: siteId, ...forceSite ? { force: true } : {} }),
-    client.getPage({ siteId, path, preview })
+    client.getPage({
+      siteId,
+      path,
+      preview,
+      ...contentContract === "native" ? { contentContract } : {}
+    })
   ]);
   if (siteResult.status === "rejected" || contentResult.status === "rejected") {
-    const failures = [siteResult, contentResult].filter((result) => result.status === "rejected").map(getRejectedReason);
-    const upstreamFailure = failures.find((error) => !isContentLoadNotFoundError(error));
+    const failures = [siteResult, contentResult].filter(
+      (result) => result.status === "rejected"
+    ).map(getRejectedReason);
+    const upstreamFailure = failures.find(
+      (error) => !isContentLoadNotFoundError(error)
+    );
     throw upstreamFailure ?? failures[0];
   }
   const site = siteResult.value;
@@ -43399,13 +43844,7 @@ async function loadContent(params) {
   });
 }
 async function loadContentFromContentResponse(params) {
-  const {
-    client,
-    siteId,
-    site,
-    contentResponse,
-    preview = false
-  } = params;
+  const { client, siteId, site, contentResponse, preview = false } = params;
   const support = buildSiteRenderSupport(
     site,
     collectMediaAssetSidecar(contentResponse.mediaAssets)
@@ -43466,6 +43905,77 @@ async function loadContentFromContentResponse(params) {
       ...support.mediaAssets ? { mediaAssets: support.mediaAssets } : {}
     };
   }
+  if (isPageSurfaceResponse(contentResponse)) {
+    const pageSurfaceData = contentResponse.pageSurface;
+    const pageSurface = {
+      id: pageSurfaceData.id,
+      routeId: pageSurfaceData.routeId,
+      readinessState: pageSurfaceData.readinessState,
+      subject: pageSurfaceData.subject,
+      title: pageSurfaceData.title,
+      slug: pageSurfaceData.slug,
+      path: pageSurfaceData.path,
+      status: pageSurfaceData.status,
+      publishAt: pageSurfaceData.publishAt,
+      content: pageSurfaceData.content,
+      metaTitle: preview ? pageSurfaceData.draftMetaTitle ?? pageSurfaceData.metaTitle : pageSurfaceData.metaTitle,
+      metaDescription: preview ? pageSurfaceData.draftMetaDescription ?? pageSurfaceData.metaDescription : pageSurfaceData.metaDescription,
+      createdAt: pageSurfaceData.createdAt,
+      updatedAt: pageSurfaceData.updatedAt,
+      contentSource: pageSurfaceData.contentSource
+    };
+    const { templatePage, resolvedData: resolvedData2 } = await processTemplatePage({
+      templates: contentResponse.templates,
+      slotContent: contentResponse.surfaceSlots,
+      bindingContext: {
+        fields: pageSurface.content && typeof pageSurface.content === "object" ? pageSurface.content : {},
+        meta: {
+          id: pageSurface.id,
+          title: pageSurface.title,
+          slug: pageSurface.slug,
+          path: pageSurface.path,
+          publishAt: pageSurface.publishAt,
+          status: pageSurface.status,
+          createdAt: pageSurface.createdAt,
+          updatedAt: pageSurface.updatedAt
+        }
+      },
+      pageName: pageSurface.title || "Page Surface Template",
+      pagePath: pageSurface.path || "/",
+      pagePurpose: "page-surface-template",
+      context: { siteId, preview },
+      client,
+      options: { customBlocks: support.customBlocks }
+    });
+    return {
+      type: "pageSurface",
+      pageSurface,
+      templatePage,
+      resolvedData: resolvedData2,
+      bookingOfferingPresets: support.bookingOfferingPresets,
+      dataContext: {
+        pageSurface: {
+          ...pageSurface.content ?? {},
+          id: pageSurface.id,
+          slug: pageSurface.slug,
+          subject: pageSurface.subject,
+          _pageSurfaceId: pageSurface.id,
+          _pageSurfaceSlug: pageSurface.slug
+        },
+        subject: pageSurface.subject
+      },
+      theme: support.theme,
+      siteId,
+      ...support.customBlocks ? { customBlocks: support.customBlocks } : {},
+      site: support.site,
+      sdkConfig: support.sdkConfig,
+      supabaseUrl: support.supabaseUrl,
+      routeMap: support.routeMap,
+      pagesByIdentifier: support.pagesByIdentifier,
+      entriesByIdentifier: support.entriesByIdentifier,
+      ...support.mediaAssets ? { mediaAssets: support.mediaAssets } : {}
+    };
+  }
   const { page: pageData } = contentResponse;
   const pageRecord = pageData;
   const canonicalPagePath = pageData.path ?? pageRecord.path ?? "/";
@@ -43523,45 +44033,60 @@ async function loadContentFromContentResponse(params) {
 function isEntryResponse(response) {
   return "entry" in response;
 }
+function isPageSurfaceResponse(response) {
+  return response.type === "pageSurface";
+}
 async function processEntryTemplate(templates, entrySlots, entry, context, client, options) {
-  const template = templates?.[0];
+  return processTemplatePage({
+    templates,
+    slotContent: entrySlots,
+    bindingContext: {
+      fields: entry.content && typeof entry.content === "object" ? entry.content : {},
+      meta: {
+        id: entry.id,
+        title: entry.title,
+        slug: entry.slug,
+        path: entry.path,
+        publishAt: entry.publishAt,
+        status: entry.status,
+        createdAt: entry.createdAt,
+        updatedAt: entry.updatedAt
+      }
+    },
+    pageName: "Entry Template",
+    pagePath: entry.path || "/",
+    pagePurpose: "entry-template",
+    context,
+    client,
+    options
+  });
+}
+async function processTemplatePage(input) {
+  const template = input.templates?.[0];
   if (!template || !template.blocks?.length) {
     return { templatePage: null, resolvedData: {} };
   }
-  const bindingContext = {
-    fields: entry.content && typeof entry.content === "object" ? entry.content : {},
-    meta: {
-      id: entry.id,
-      title: entry.title,
-      slug: entry.slug,
-      path: entry.path,
-      publishAt: entry.publishAt,
-      status: entry.status,
-      createdAt: entry.createdAt,
-      updatedAt: entry.updatedAt
-    }
-  };
   const blocks = template.blocks.flatMap(
-    (block) => resolveTemplateBlockSequence(block, bindingContext, entrySlots)
+    (block) => resolveTemplateBlockSequence(block, input.bindingContext, input.slotContent)
   );
   if (blocks.length === 0) {
     return { templatePage: null, resolvedData: {} };
   }
   const templatePage = {
-    name: template.name || "Entry Template",
-    path: entry.path || "/",
-    purpose: "entry-template",
+    name: template.name || input.pageName,
+    path: input.pagePath,
+    purpose: input.pagePurpose,
     blocks
   };
   const resolvedData = await prefetchBlockData2(
     templatePage,
     {
-      siteId: context.siteId,
+      siteId: input.context.siteId,
       pageId: template.id,
-      previewStage: context.preview ? "preview" : "published"
+      previewStage: input.context.preview ? "preview" : "published"
     },
-    client,
-    { customBlocks: options?.customBlocks }
+    input.client,
+    { customBlocks: input.options?.customBlocks }
   );
   return { templatePage, resolvedData };
 }
@@ -43581,7 +44106,9 @@ function resolveTemplateBlock(block, bindingContext) {
   }
   const bindings = block.bindings ?? {};
   const hasBindings = typeof bindings === "object" && Object.keys(bindings).length > 0;
-  const resolvedContent = hasBindings ? normalizeBindingOutput2(applyBindingsToContent2(baseContent, bindings, bindingContext)) : baseContent;
+  const resolvedContent = hasBindings ? normalizeBindingOutput2(
+    applyBindingsToContent2(baseContent, bindings, bindingContext)
+  ) : baseContent;
   return {
     id: block.id,
     kind: block.blockKind,
@@ -43589,12 +44116,12 @@ function resolveTemplateBlock(block, bindingContext) {
     content: resolvedContent
   };
 }
-function resolveTemplateBlockSequence(block, bindingContext, entrySlots) {
+function resolveTemplateBlockSequence(block, bindingContext, slotContent) {
   const slotKey = readEntrySlotKey(block);
   if (slotKey) {
     return selectBlocksForDeclaredEntrySlot({
       declaredSlotKey: slotKey,
-      entrySlots: entrySlots ?? []
+      entrySlots: slotContent ?? []
     }).map(mapEntrySlotBlock);
   }
   if (block.blockKind === SYSTEM_ENTRY_SLOT_BLOCK_KIND) {
@@ -43616,7 +44143,7 @@ function mapEntrySlotBlock(block) {
     kind: block.kind,
     purpose: block.purpose,
     orderIndex: block.orderIndex ?? null,
-    content: normalizeBindingOutput2(block.content ?? {}),
+    content: normalizeEntrySlotBlockContent(block.content),
     draftContent: normalizeNullableEntrySlotContent(block.draftContent),
     publishedContent: normalizeNullableEntrySlotContent(block.publishedContent)
   };
@@ -43629,7 +44156,11 @@ function mapEntrySlotBlock(block) {
   };
 }
 function normalizeNullableEntrySlotContent(content) {
-  return content == null ? null : normalizeBindingOutput2(content);
+  return content == null ? null : normalizeEntrySlotBlockContent(content);
+}
+function normalizeEntrySlotBlockContent(content) {
+  const normalized = normalizeBindingOutput2(content ?? {});
+  return isRecord14(normalized) ? normalized : {};
 }
 export {
   createRiverbankClient,