@riverbankcms/sdk 0.95.0 → 0.98.0

package/dist/server/page-converter.mjs

@@ -324,10 +324,20 @@ var repeatSchema = z.object({
     direction: z.enum(["asc", "desc"]).default("asc")
   }).optional()
 });
+var conditionalAuthoringPresenceSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("visitor-only") }),
+  z.object({
+    kind: z.literal("recover-empty-when-active"),
+    placeholder: z.string().min(1).optional()
+  })
+]);
 var conditionSchema = z.object({
   when: bindingSchema,
   equals: z.unknown().optional(),
-  not: z.boolean().default(false)
+  not: z.boolean().default(false),
+  authoringPresence: conditionalAuthoringPresenceSchema.default({
+    kind: "visitor-only"
+  })
 });
 var dataScopeSchema = z.object({
   name: z.string().min(1),
@@ -388,6 +398,7 @@ var ALLOWED_NODE_TYPES = [
   // Forms
   "form",
   "booking-form",
+  "weekly-slot-availability",
   // Events
   "event-registration",
   "event-spotlight",
@@ -717,6 +728,11 @@ var textFieldSchema = baseFieldSchema.extend({
 var richTextFieldSchema = baseFieldSchema.extend({
   type: z2.literal("richText")
 });
+var inlineTextFieldSchema = baseFieldSchema.extend({
+  type: z2.literal("inlineText"),
+  maxLength: z2.number().int().positive().optional(),
+  plainTextField: z2.string().min(1).optional()
+});
 var mediaFieldSchema = baseFieldSchema.extend({
   type: z2.literal("media"),
   // Keep full MEDIA_KINDS parse compatibility for pre-file-field manifests.
@@ -1039,6 +1055,7 @@ function getFieldSchemaInternal() {
   _fieldSchemaInternal = z2.discriminatedUnion("type", [
     textFieldSchema,
     richTextFieldSchema,
+    inlineTextFieldSchema,
     mediaFieldSchema,
     fileFieldSchema,
     booleanFieldSchema,
@@ -11246,7 +11263,8 @@ function when(path2, options) {
     $when: {
       when: { from: path2 },
       ...options?.equals !== void 0 ? { equals: options.equals } : {},
-      ...options?.not ? { not: true } : {}
+      ...options?.not ? { not: true } : {},
+      ...options?.authoringPresence ? { authoringPresence: options.authoringPresence } : {}
     }
   });
 }
@@ -12744,8 +12762,16 @@ var heroCopyFragment = defineFragment({
       id: "headline",
       type: "text",
       label: "Headline",
+      maxLength: 120,
+      ui: { hidden: true }
+    },
+    {
+      id: "headlineInline",
+      type: "inlineText",
+      label: "Headline",
       required: true,
-      maxLength: 120
+      maxLength: 120,
+      plainTextField: "headline"
     },
     {
       id: "subheadline",
@@ -12770,9 +12796,12 @@ var heroCopyFragment = defineFragment({
         as: "h1",
         // heading-display: uses fluid typography from theme (--fs-h1-display-fluid)
         // Color in blocks-static/index.css (.hero-headline)
-        className: "hero-headline heading-display"
+        className: "hero-headline heading-display",
+        // Resolved against top-level block content; keep this beside the sibling headline field.
+        inlineTextFallbackPath: "headline",
+        maxLength: 120
       },
-      bind("content.headline")
+      bind("content.headlineInline")
     ),
     text(
       {
@@ -19029,77 +19058,247 @@ var appointmentBookingBlockDefinition = {
   }
 };
 
+// ../blocks/src/system/blocks/weekly-slot-availability.ts
+import { z as z32 } 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 = z32.object({
+  id: z32.string(),
+  resourceId: z32.string(),
+  weekday: z32.number(),
+  weekdayLabel: z32.string(),
+  startTime: z32.string(),
+  endTime: z32.string(),
+  nextDate: z32.string(),
+  availableWeeks: z32.number()
+});
+var weeklySlotAvailabilityDataSchema = z32.object({
+  slots: z32.array(weeklySlotAvailabilityOptionSchema),
+  horizonWeeks: z32.number(),
+  timezone: z32.string(),
+  startDate: z32.string(),
+  endDate: z32.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 z36 } from "zod";
+import { z as z37 } from "zod";
 
 // ../blocks/src/lib/media.ts
-import z32 from "zod";
+import z33 from "zod";
 var PUBLIC_DOWNLOAD_MEDIA_TYPES = [
   "document",
   "spreadsheet",
   "archive",
   "audio"
 ];
-var hotspotSchema2 = z32.object({
-  x: z32.number().min(0).max(1),
-  y: z32.number().min(0).max(1),
-  radius: z32.number().optional()
-});
-var rotationSchema2 = z32.union([z32.literal(0), z32.literal(90), z32.literal(180), z32.literal(270)]);
-var rectSchema2 = z32.tuple([z32.number(), z32.number(), z32.number(), z32.number()]);
-var aspectCropSchema2 = z32.object({
-  aspect: z32.preprocess((value) => value == null ? void 0 : value, z32.string().optional()),
-  rect: z32.preprocess((value) => value == null ? void 0 : value, rectSchema2.optional()),
-  hotspot: z32.preprocess((value) => value == null ? void 0 : value, hotspotSchema2.optional()),
-  rotation: z32.preprocess((value) => value == null ? void 0 : value, rotationSchema2.optional())
-});
-var transformSchema2 = z32.object({
-  aspectCrops: z32.preprocess((value) => {
+var hotspotSchema2 = z33.object({
+  x: z33.number().min(0).max(1),
+  y: z33.number().min(0).max(1),
+  radius: z33.number().optional()
+});
+var rotationSchema2 = z33.union([z33.literal(0), z33.literal(90), z33.literal(180), z33.literal(270)]);
+var rectSchema2 = z33.tuple([z33.number(), z33.number(), z33.number(), z33.number()]);
+var aspectCropSchema2 = z33.object({
+  aspect: z33.preprocess((value) => value == null ? void 0 : value, z33.string().optional()),
+  rect: z33.preprocess((value) => value == null ? void 0 : value, rectSchema2.optional()),
+  hotspot: z33.preprocess((value) => value == null ? void 0 : value, hotspotSchema2.optional()),
+  rotation: z33.preprocess((value) => value == null ? void 0 : value, rotationSchema2.optional())
+});
+var transformSchema2 = z33.object({
+  aspectCrops: z33.preprocess((value) => {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
       return void 0;
     }
     return value;
-  }, z32.record(z32.string(), aspectCropSchema2.catch({}))).optional(),
+  }, z33.record(z33.string(), aspectCropSchema2.catch({}))).optional(),
   rect: rectSchema2.optional(),
   hotspot: hotspotSchema2.optional(),
   rotation: rotationSchema2.optional()
 });
-var mediaPosterSchema = z32.discriminatedUnion("tag", [
-  z32.object({
-    tag: z32.literal("storage"),
-    assetId: z32.string().optional(),
-    storageBucket: z32.string().min(1),
-    storagePath: z32.string().min(1)
+var mediaPosterSchema = z33.discriminatedUnion("tag", [
+  z33.object({
+    tag: z33.literal("storage"),
+    assetId: z33.string().optional(),
+    storageBucket: z33.string().min(1),
+    storagePath: z33.string().min(1)
   }),
-  z32.object({
-    tag: z32.literal("external-src"),
-    assetId: z32.string().optional(),
-    src: z32.string().url()
+  z33.object({
+    tag: z33.literal("external-src"),
+    assetId: z33.string().optional(),
+    src: z33.string().url()
   })
 ]);
-var mediaBaseSchema = z32.object({
-  purpose: z32.string().optional(),
-  placeholder: z32.boolean().default(true).optional(),
-  assetId: z32.string().optional(),
-  identifier: z32.string().optional(),
-  src: z32.string().optional(),
-  alt: z32.string().optional(),
-  filename: z32.string().optional(),
-  mimeType: z32.string().optional(),
-  width: z32.number().optional(),
-  height: z32.number().optional(),
-  storageBucket: z32.string().optional(),
-  storagePath: z32.string().optional(),
+var mediaBaseSchema = z33.object({
+  purpose: z33.string().optional(),
+  placeholder: z33.boolean().default(true).optional(),
+  assetId: z33.string().optional(),
+  identifier: z33.string().optional(),
+  src: z33.string().optional(),
+  alt: z33.string().optional(),
+  filename: z33.string().optional(),
+  mimeType: z33.string().optional(),
+  width: z33.number().optional(),
+  height: z33.number().optional(),
+  storageBucket: z33.string().optional(),
+  storagePath: z33.string().optional(),
   poster: mediaPosterSchema.optional(),
   transform: transformSchema2.optional()
 });
-var imageMediaSchema = mediaBaseSchema.extend({ type: z32.literal("image") });
-var videoMediaSchema = mediaBaseSchema.extend({ type: z32.literal("video") });
-var audioMediaSchema = mediaBaseSchema.extend({ type: z32.literal("audio") });
-var documentMediaSchema = mediaBaseSchema.extend({ type: z32.literal("document") });
-var spreadsheetMediaSchema = mediaBaseSchema.extend({ type: z32.literal("spreadsheet") });
-var archiveMediaSchema = mediaBaseSchema.extend({ type: z32.literal("archive") });
-var mediaSchema2 = z32.discriminatedUnion("type", [
+var imageMediaSchema = mediaBaseSchema.extend({ type: z33.literal("image") });
+var videoMediaSchema = mediaBaseSchema.extend({ type: z33.literal("video") });
+var audioMediaSchema = mediaBaseSchema.extend({ type: z33.literal("audio") });
+var documentMediaSchema = mediaBaseSchema.extend({ type: z33.literal("document") });
+var spreadsheetMediaSchema = mediaBaseSchema.extend({ type: z33.literal("spreadsheet") });
+var archiveMediaSchema = mediaBaseSchema.extend({ type: z33.literal("archive") });
+var mediaSchema2 = z33.discriminatedUnion("type", [
   imageMediaSchema,
   videoMediaSchema,
   audioMediaSchema,
@@ -19109,31 +19308,31 @@ var mediaSchema2 = z32.discriminatedUnion("type", [
 ]);
 
 // ../blocks/src/system/manifest/richTextSchema.ts
-import { z as z33 } from "zod";
-var TipTapMarkSchema = z33.object({
-  type: z33.string(),
-  attrs: z33.record(z33.string(), z33.unknown()).optional()
-});
-var TipTapNodeSchema = z33.lazy(
-  () => z33.object({
-    type: z33.string(),
-    content: z33.array(TipTapNodeSchema).optional(),
-    text: z33.string().optional(),
-    attrs: z33.record(z33.string(), z33.unknown()).optional(),
-    marks: z33.array(TipTapMarkSchema).optional()
+import { z as z34 } from "zod";
+var TipTapMarkSchema = z34.object({
+  type: z34.string(),
+  attrs: z34.record(z34.string(), z34.unknown()).optional()
+});
+var TipTapNodeSchema = z34.lazy(
+  () => z34.object({
+    type: z34.string(),
+    content: z34.array(TipTapNodeSchema).optional(),
+    text: z34.string().optional(),
+    attrs: z34.record(z34.string(), z34.unknown()).optional(),
+    marks: z34.array(TipTapMarkSchema).optional()
   })
 );
-var RichTextValueSchema = z33.union([
+var RichTextValueSchema = z34.union([
   // Canonical: TipTap document directly
   TipTapNodeSchema,
   // Legacy (read-tolerance only): wrapped in { doc: {...} }
-  z33.object({
+  z34.object({
     doc: TipTapNodeSchema
   })
 ]);
-var RichTextDocSchema = z33.object({
-  type: z33.literal("doc"),
-  content: z33.array(TipTapNodeSchema)
+var RichTextDocSchema = z34.object({
+  type: z34.literal("doc"),
+  content: z34.array(TipTapNodeSchema)
 });
 function createHardBreakNode() {
   return { type: "hardBreak" };
@@ -19184,344 +19383,344 @@ function createRichTextDocFromMarkdown(markdown) {
 }
 
 // ../blocks/src/system/blocks/shared/bookingPaymentTerms.ts
-import { z as z34 } from "zod";
-var bookingDepositRefundPolicySchema = z34.enum([
+import { z as z35 } from "zod";
+var bookingDepositRefundPolicySchema = z35.enum([
   "refundable",
   "non_refundable"
 ]);
-var bookingInstalmentPlanSchema = z34.union([
-  z34.object({
-    kind: z34.literal("deposit_plus_one_remainder"),
-    depositAmountCents: z34.number().int().min(0),
+var bookingInstalmentPlanSchema = z35.union([
+  z35.object({
+    kind: z35.literal("deposit_plus_one_remainder"),
+    depositAmountCents: z35.number().int().min(0),
     depositRefundability: bookingDepositRefundPolicySchema,
-    remainderDueCount: z34.number().int().positive(),
-    intervalUnit: z34.enum(["day", "week", "month"])
+    remainderDueCount: z35.number().int().positive(),
+    intervalUnit: z35.enum(["day", "week", "month"])
   }),
-  z34.object({
-    kind: z34.literal("deposit_plus_scheduled_instalments"),
-    depositAmountCents: z34.number().int().min(0),
+  z35.object({
+    kind: z35.literal("deposit_plus_scheduled_instalments"),
+    depositAmountCents: z35.number().int().min(0),
     depositRefundability: bookingDepositRefundPolicySchema,
-    instalmentCount: z34.number().int().positive(),
-    intervalCount: z34.number().int().positive(),
-    intervalUnit: z34.enum(["day", "week", "month"])
+    instalmentCount: z35.number().int().positive(),
+    intervalCount: z35.number().int().positive(),
+    intervalUnit: z35.enum(["day", "week", "month"])
   }),
-  z34.object({
-    kind: z34.literal("equal_scheduled_instalments"),
-    instalmentCount: z34.number().int().positive(),
-    intervalCount: z34.number().int().positive(),
-    intervalUnit: z34.enum(["day", "week", "month"])
+  z35.object({
+    kind: z35.literal("equal_scheduled_instalments"),
+    instalmentCount: z35.number().int().positive(),
+    intervalCount: z35.number().int().positive(),
+    intervalUnit: z35.enum(["day", "week", "month"])
   })
 ]);
-var bookingFlexibleBalanceDueDateRuleSchema = z34.union([
-  z34.object({
-    kind: z34.literal("relative_to_start_date"),
-    daysBeforeStart: z34.number().int().positive()
+var bookingFlexibleBalanceDueDateRuleSchema = z35.union([
+  z35.object({
+    kind: z35.literal("relative_to_start_date"),
+    daysBeforeStart: z35.number().int().positive()
   }),
-  z34.object({
-    kind: z34.literal("fixed_calendar_date"),
-    dueAt: z34.string().datetime()
+  z35.object({
+    kind: z35.literal("fixed_calendar_date"),
+    dueAt: z35.string().datetime()
   })
 ]);
-var bookingFlexibleBalanceConfigSchema = z34.object({
-  upfrontAmountCents: z34.number().int().min(0),
+var bookingFlexibleBalanceConfigSchema = z35.object({
+  upfrontAmountCents: z35.number().int().min(0),
   dueDateRule: bookingFlexibleBalanceDueDateRuleSchema,
   depositRefundability: bookingDepositRefundPolicySchema
 });
-var blockBookingPaymentCollectionOptionSchema = z34.union([
-  z34.object({
-    kind: z34.literal("upfront")
+var blockBookingPaymentCollectionOptionSchema = z35.union([
+  z35.object({
+    kind: z35.literal("upfront")
   }),
-  z34.object({
-    kind: z34.literal("deferred_manual")
+  z35.object({
+    kind: z35.literal("deferred_manual")
   }),
-  z34.object({
-    kind: z34.literal("instalment_plan"),
+  z35.object({
+    kind: z35.literal("instalment_plan"),
     plan: bookingInstalmentPlanSchema
   }),
-  z34.object({
-    kind: z34.literal("flexible_balance"),
+  z35.object({
+    kind: z35.literal("flexible_balance"),
     config: bookingFlexibleBalanceConfigSchema
   })
 ]);
-var blockBookingPaymentTermsSchema = z34.object({
-  allowedOptions: z34.array(blockBookingPaymentCollectionOptionSchema).min(1)
+var blockBookingPaymentTermsSchema = z35.object({
+  allowedOptions: z35.array(blockBookingPaymentCollectionOptionSchema).min(1)
 });
 
 // ../blocks/src/system/blocks/courses/shared/schemas.ts
-import { z as z35 } from "zod";
-var courseVenueSchema = z35.object({
-  id: z35.string(),
-  name: z35.string(),
-  address: z35.string().nullable()
-});
-var courseSessionSchema = z35.object({
-  id: z35.string(),
-  startsAt: z35.string(),
-  endsAt: z35.string(),
-  timeZone: z35.string(),
-  capacityOverride: z35.number().nullable().optional(),
-  overrides: z35.record(z35.string(), z35.unknown()).nullable().optional()
-});
-var courseTeamMemberSummarySchema = z35.object({
-  id: z35.string(),
-  name: z35.string(),
-  roleLabel: z35.string().nullable(),
-  summary: z35.string().nullable(),
-  profilePath: z35.string().nullable()
-});
-var coursePricingOptionSchema = z35.object({
-  id: z35.string(),
-  name: z35.string(),
-  description: z35.string().nullable(),
-  priceAmount: z35.number(),
-  isActive: z35.boolean(),
-  sortOrder: z35.number(),
-  capacityLimit: z35.number().nullable(),
-  saleStartsAt: z35.string().nullable(),
-  saleEndsAt: z35.string().nullable(),
-  attendanceScope: z35.enum(["in_person", "online", "both"]).nullable().optional()
-});
-var coursePricingSchema = z35.object({
-  bookingRequirement: z35.enum(["none", "required"]),
-  pricingStrategy: z35.enum(["free", "single", "tiered", "sliding_scale"]),
-  currency: z35.string(),
-  singlePriceAmount: z35.number().nullable(),
-  slidingMinAmount: z35.number().nullable().optional(),
-  slidingMaxAmount: z35.number().nullable().optional(),
-  slidingSuggestedAmount: z35.number().nullable().optional(),
+import { z as z36 } from "zod";
+var courseVenueSchema = z36.object({
+  id: z36.string(),
+  name: z36.string(),
+  address: z36.string().nullable()
+});
+var courseSessionSchema = z36.object({
+  id: z36.string(),
+  startsAt: z36.string(),
+  endsAt: z36.string(),
+  timeZone: z36.string(),
+  capacityOverride: z36.number().nullable().optional(),
+  overrides: z36.record(z36.string(), z36.unknown()).nullable().optional()
+});
+var courseTeamMemberSummarySchema = z36.object({
+  id: z36.string(),
+  name: z36.string(),
+  roleLabel: z36.string().nullable(),
+  summary: z36.string().nullable(),
+  profilePath: z36.string().nullable()
+});
+var coursePricingOptionSchema = z36.object({
+  id: z36.string(),
+  name: z36.string(),
+  description: z36.string().nullable(),
+  priceAmount: z36.number(),
+  isActive: z36.boolean(),
+  sortOrder: z36.number(),
+  capacityLimit: z36.number().nullable(),
+  saleStartsAt: z36.string().nullable(),
+  saleEndsAt: z36.string().nullable(),
+  attendanceScope: z36.enum(["in_person", "online", "both"]).nullable().optional()
+});
+var coursePricingSchema = z36.object({
+  bookingRequirement: z36.enum(["none", "required"]),
+  pricingStrategy: z36.enum(["free", "single", "tiered", "sliding_scale"]),
+  currency: z36.string(),
+  singlePriceAmount: z36.number().nullable(),
+  slidingMinAmount: z36.number().nullable().optional(),
+  slidingMaxAmount: z36.number().nullable().optional(),
+  slidingSuggestedAmount: z36.number().nullable().optional(),
   paymentTerms: blockBookingPaymentTermsSchema,
-  options: z35.array(coursePricingOptionSchema)
-});
-var publicCourseSchema = z35.object({
-  id: z35.string(),
-  title: z35.string(),
-  slug: z35.string(),
-  description: z35.unknown().nullable(),
-  teamMembers: z35.array(courseTeamMemberSummarySchema).optional(),
-  enrollmentOpen: z35.boolean(),
+  options: z36.array(coursePricingOptionSchema)
+});
+var publicCourseSchema = z36.object({
+  id: z36.string(),
+  title: z36.string(),
+  slug: z36.string(),
+  description: z36.unknown().nullable(),
+  teamMembers: z36.array(courseTeamMemberSummarySchema).optional(),
+  enrollmentOpen: z36.boolean(),
   pricing: coursePricingSchema.optional(),
-  priceCents: z35.number().nullable(),
-  currency: z35.string(),
+  priceCents: z36.number().nullable(),
+  currency: z36.string(),
   paymentTerms: blockBookingPaymentTermsSchema,
-  enrollmentCapacity: z35.number().nullable(),
-  acceptsMemberships: z35.boolean(),
-  status: z35.enum(["active", "draft", "cancelled"]),
-  sessionsCount: z35.number(),
-  enrolledCount: z35.number(),
-  availableSpots: z35.number().nullable(),
-  sessions: z35.array(courseSessionSchema),
+  enrollmentCapacity: z36.number().nullable(),
+  acceptsMemberships: z36.boolean(),
+  status: z36.enum(["active", "draft", "cancelled"]),
+  sessionsCount: z36.number(),
+  enrolledCount: z36.number(),
+  availableSpots: z36.number().nullable(),
+  sessions: z36.array(courseSessionSchema),
   venue: courseVenueSchema.nullable(),
-  contentEntryId: z35.string().nullable()
+  contentEntryId: z36.string().nullable()
 });
-var publicCoursesArraySchema = z35.array(publicCourseSchema);
+var publicCoursesArraySchema = z36.array(publicCourseSchema);
 
 // ../blocks/src/system/blocks/events/shared/schemas.ts
-var eventPresetSchema = z36.enum(["event", "class", "workshop", "retreat", "performance"]);
-var eventScheduleScopeSchema = z36.enum(["recurring", "oneOff"]);
-var eventDestinationModeSchema = z36.enum(["cms-managed", "system-managed"]);
-var publicEventDestinationSchema = z36.discriminatedUnion("kind", [
-  z36.object({
-    kind: z36.literal("native"),
+var eventPresetSchema = z37.enum(["event", "class", "workshop", "retreat", "performance"]);
+var eventScheduleScopeSchema = z37.enum(["recurring", "oneOff"]);
+var eventDestinationModeSchema = z37.enum(["cms-managed", "system-managed"]);
+var publicEventDestinationSchema = z37.discriminatedUnion("kind", [
+  z37.object({
+    kind: z37.literal("native"),
     mode: eventDestinationModeSchema,
-    path: z36.string()
+    path: z37.string()
   }),
-  z36.object({
-    kind: z36.literal("external"),
-    url: z36.string(),
-    label: z36.string()
+  z37.object({
+    kind: z37.literal("external"),
+    url: z37.string(),
+    label: z37.string()
   })
 ]);
-var eventVenueSchema = z36.object({
-  id: z36.string(),
-  name: z36.string(),
-  address: z36.string().nullable(),
-  location: z36.object({
-    lat: z36.number(),
-    lng: z36.number()
+var eventVenueSchema = z37.object({
+  id: z37.string(),
+  name: z37.string(),
+  address: z37.string().nullable(),
+  location: z37.object({
+    lat: z37.number(),
+    lng: z37.number()
   }).nullable()
 });
-var eventCategorySchema = z36.object({
-  id: z36.string(),
-  name: z36.string(),
-  color: z36.string().nullable()
-});
-var pricingTypeSchema = z36.enum(["free", "paid", "external"]);
-var accessRestrictionSchema = z36.enum(["none", "category"]);
-var eventPricingModeSchema = z36.enum(["single", "ticket_types"]);
-var publicCoursePriceDisplaySchema = z36.discriminatedUnion("kind", [
-  z36.object({ kind: z36.literal("free"), currency: z36.string() }),
-  z36.object({ kind: z36.literal("exact"), amount: z36.number(), currency: z36.string() }),
-  z36.object({ kind: z36.literal("from"), amount: z36.number(), currency: z36.string() }),
-  z36.object({ kind: z36.literal("unavailable"), currency: z36.string() })
+var eventCategorySchema = z37.object({
+  id: z37.string(),
+  name: z37.string(),
+  color: z37.string().nullable()
+});
+var pricingTypeSchema = z37.enum(["free", "paid", "external"]);
+var accessRestrictionSchema = z37.enum(["none", "category"]);
+var eventPricingModeSchema = z37.enum(["single", "ticket_types"]);
+var publicCoursePriceDisplaySchema = z37.discriminatedUnion("kind", [
+  z37.object({ kind: z37.literal("free"), currency: z37.string() }),
+  z37.object({ kind: z37.literal("exact"), amount: z37.number(), currency: z37.string() }),
+  z37.object({ kind: z37.literal("from"), amount: z37.number(), currency: z37.string() }),
+  z37.object({ kind: z37.literal("unavailable"), currency: z37.string() })
 ]);
-var publicEventPriceDisplaySchema = z36.discriminatedUnion("kind", [
-  z36.object({ kind: z36.literal("free"), currency: z36.string() }),
-  z36.object({ kind: z36.literal("exact"), amount: z36.number(), currency: z36.string() }),
-  z36.object({ kind: z36.literal("from"), amount: z36.number(), currency: z36.string() }),
-  z36.object({ kind: z36.literal("range"), minAmount: z36.number(), maxAmount: z36.number(), currency: z36.string() }),
-  z36.object({
-    kind: z36.literal("mixed"),
-    paidFromAmount: z36.number(),
-    paidToAmount: z36.number(),
-    currency: z36.string()
+var publicEventPriceDisplaySchema = z37.discriminatedUnion("kind", [
+  z37.object({ kind: z37.literal("free"), currency: z37.string() }),
+  z37.object({ kind: z37.literal("exact"), amount: z37.number(), currency: z37.string() }),
+  z37.object({ kind: z37.literal("from"), amount: z37.number(), currency: z37.string() }),
+  z37.object({ kind: z37.literal("range"), minAmount: z37.number(), maxAmount: z37.number(), currency: z37.string() }),
+  z37.object({
+    kind: z37.literal("mixed"),
+    paidFromAmount: z37.number(),
+    paidToAmount: z37.number(),
+    currency: z37.string()
   }),
-  z36.object({ kind: z36.literal("unavailable"), currency: z36.string() }),
-  z36.object({ kind: z36.literal("external"), label: z36.string() }),
-  z36.object({ kind: z36.literal("course"), display: publicCoursePriceDisplaySchema })
+  z37.object({ kind: z37.literal("unavailable"), currency: z37.string() }),
+  z37.object({ kind: z37.literal("external"), label: z37.string() }),
+  z37.object({ kind: z37.literal("course"), display: publicCoursePriceDisplaySchema })
 ]);
-var publicEventTicketTypePriceDisplaySchema = z36.union([
-  z36.object({ kind: z36.literal("free"), currency: z36.string() }),
-  z36.object({ kind: z36.literal("exact"), amount: z36.number(), currency: z36.string() }),
-  z36.object({ kind: z36.literal("from"), amount: z36.number(), currency: z36.string() }),
-  z36.object({ kind: z36.literal("range"), minAmount: z36.number(), maxAmount: z36.number(), currency: z36.string() }),
-  z36.object({
-    kind: z36.literal("mixed"),
-    paidFromAmount: z36.number(),
-    paidToAmount: z36.number(),
-    currency: z36.string()
+var publicEventTicketTypePriceDisplaySchema = z37.union([
+  z37.object({ kind: z37.literal("free"), currency: z37.string() }),
+  z37.object({ kind: z37.literal("exact"), amount: z37.number(), currency: z37.string() }),
+  z37.object({ kind: z37.literal("from"), amount: z37.number(), currency: z37.string() }),
+  z37.object({ kind: z37.literal("range"), minAmount: z37.number(), maxAmount: z37.number(), currency: z37.string() }),
+  z37.object({
+    kind: z37.literal("mixed"),
+    paidFromAmount: z37.number(),
+    paidToAmount: z37.number(),
+    currency: z37.string()
   }),
-  z36.object({ kind: z36.literal("unavailable"), currency: z36.string() })
+  z37.object({ kind: z37.literal("unavailable"), currency: z37.string() })
 ]);
-var publicEventAttendanceModeSchema = z36.enum(["in_person", "online"]);
-var publicEventAttendanceModeAvailabilitySchema = z36.object({
+var publicEventAttendanceModeSchema = z37.enum(["in_person", "online"]);
+var publicEventAttendanceModeAvailabilitySchema = z37.object({
   mode: publicEventAttendanceModeSchema,
-  capacity: z36.number().nullable(),
-  registeredCount: z36.number(),
-  availableSpots: z36.number().nullable(),
-  waitlistEnabled: z36.boolean()
-});
-var publicEventTicketTypeAvailabilitySchema = z36.union([
-  z36.object({
-    kind: z36.literal("available"),
-    remainingCapacity: z36.number().nullable()
+  capacity: z37.number().nullable(),
+  registeredCount: z37.number(),
+  availableSpots: z37.number().nullable(),
+  waitlistEnabled: z37.boolean()
+});
+var publicEventTicketTypeAvailabilitySchema = z37.union([
+  z37.object({
+    kind: z37.literal("available"),
+    remainingCapacity: z37.number().nullable()
   }),
-  z36.object({
-    kind: z36.literal("unavailable"),
-    reason: z36.enum(["inactive", "not_on_sale_yet", "sale_ended", "sold_out", "event_sold_out"]),
-    remainingCapacity: z36.number().nullable()
+  z37.object({
+    kind: z37.literal("unavailable"),
+    reason: z37.enum(["inactive", "not_on_sale_yet", "sale_ended", "sold_out", "event_sold_out"]),
+    remainingCapacity: z37.number().nullable()
   })
 ]);
-var publicEventTicketTypeSchema = z36.object({
-  id: z36.string(),
-  siteId: z36.string(),
-  eventSeriesId: z36.string(),
-  name: z36.string(),
-  description: z36.string().nullable(),
-  priceAmount: z36.number(),
-  isActive: z36.boolean(),
-  sortOrder: z36.number(),
-  capacityMode: z36.enum(["limited", "unlimited"]),
-  capacityLimit: z36.number().nullable(),
-  attendanceScope: z36.enum(["in_person", "online", "both"]).optional(),
-  saleStartsAt: z36.string().nullable(),
-  saleEndsAt: z36.string().nullable(),
+var publicEventTicketTypeSchema = z37.object({
+  id: z37.string(),
+  siteId: z37.string(),
+  eventSeriesId: z37.string(),
+  name: z37.string(),
+  description: z37.string().nullable(),
+  priceAmount: z37.number(),
+  isActive: z37.boolean(),
+  sortOrder: z37.number(),
+  capacityMode: z37.enum(["limited", "unlimited"]),
+  capacityLimit: z37.number().nullable(),
+  attendanceScope: z37.enum(["in_person", "online", "both"]).optional(),
+  saleStartsAt: z37.string().nullable(),
+  saleEndsAt: z37.string().nullable(),
   availability: publicEventTicketTypeAvailabilitySchema,
-  createdAt: z36.string(),
-  updatedAt: z36.string()
-});
-var publicEventPricingSchema = z36.discriminatedUnion("kind", [
-  z36.object({
-    kind: z36.literal("drop_in"),
-    currency: z36.string(),
-    display: z36.object({ kind: z36.literal("free"), currency: z36.string() })
+  createdAt: z37.string(),
+  updatedAt: z37.string()
+});
+var publicEventPricingSchema = z37.discriminatedUnion("kind", [
+  z37.object({
+    kind: z37.literal("drop_in"),
+    currency: z37.string(),
+    display: z37.object({ kind: z37.literal("free"), currency: z37.string() })
   }),
-  z36.object({
-    kind: z36.literal("free_registration"),
-    currency: z36.string(),
-    display: z36.object({ kind: z36.literal("free"), currency: z36.string() })
+  z37.object({
+    kind: z37.literal("free_registration"),
+    currency: z37.string(),
+    display: z37.object({ kind: z37.literal("free"), currency: z37.string() })
   }),
-  z36.object({
-    kind: z36.literal("single_paid"),
-    amount: z36.number(),
-    currency: z36.string(),
-    display: z36.object({ kind: z36.literal("exact"), amount: z36.number(), currency: z36.string() })
+  z37.object({
+    kind: z37.literal("single_paid"),
+    amount: z37.number(),
+    currency: z37.string(),
+    display: z37.object({ kind: z37.literal("exact"), amount: z37.number(), currency: z37.string() })
   }),
-  z36.object({
-    kind: z36.literal("ticket_types"),
-    currency: z36.string(),
-    ticketTypes: z36.array(publicEventTicketTypeSchema),
+  z37.object({
+    kind: z37.literal("ticket_types"),
+    currency: z37.string(),
+    ticketTypes: z37.array(publicEventTicketTypeSchema),
     display: publicEventTicketTypePriceDisplaySchema
   }),
-  z36.object({
-    kind: z36.literal("sliding_scale"),
-    minAmount: z36.number(),
-    maxAmount: z36.number(),
-    suggestedAmount: z36.number().nullable(),
-    currency: z36.string(),
-    display: z36.object({
-      kind: z36.literal("range"),
-      minAmount: z36.number(),
-      maxAmount: z36.number(),
-      currency: z36.string()
+  z37.object({
+    kind: z37.literal("sliding_scale"),
+    minAmount: z37.number(),
+    maxAmount: z37.number(),
+    suggestedAmount: z37.number().nullable(),
+    currency: z37.string(),
+    display: z37.object({
+      kind: z37.literal("range"),
+      minAmount: z37.number(),
+      maxAmount: z37.number(),
+      currency: z37.string()
     })
   }),
-  z36.object({
-    kind: z36.literal("course"),
-    display: z36.object({ kind: z36.literal("course"), display: publicCoursePriceDisplaySchema })
+  z37.object({
+    kind: z37.literal("course"),
+    display: z37.object({ kind: z37.literal("course"), display: publicCoursePriceDisplaySchema })
   }),
-  z36.object({
-    kind: z36.literal("external"),
-    display: z36.object({ kind: z36.literal("external"), label: z36.string() })
+  z37.object({
+    kind: z37.literal("external"),
+    display: z37.object({ kind: z37.literal("external"), label: z37.string() })
   })
 ]);
-var publicTeamMemberSummarySchema = z36.object({
-  id: z36.string(),
-  name: z36.string(),
-  roleLabel: z36.string().nullable(),
-  summary: z36.string().nullable(),
-  profilePath: z36.string().nullable()
+var publicTeamMemberSummarySchema = z37.object({
+  id: z37.string(),
+  name: z37.string(),
+  roleLabel: z37.string().nullable(),
+  summary: z37.string().nullable(),
+  profilePath: z37.string().nullable()
 });
-var publicEventSchema = z36.object({
-  kind: z36.enum(["event", "course_session"]).optional(),
+var publicEventSchema = z37.object({
+  kind: z37.enum(["event", "course_session"]).optional(),
   eventPreset: eventPresetSchema.optional(),
   eventDestinationMode: eventDestinationModeSchema.optional(),
   scheduleScope: eventScheduleScopeSchema.optional(),
-  id: z36.string(),
-  occurrenceId: z36.string(),
-  seriesId: z36.string(),
-  title: z36.string(),
-  description: z36.string().nullable(),
-  content: z36.object({
+  id: z37.string(),
+  occurrenceId: z37.string(),
+  seriesId: z37.string(),
+  title: z37.string(),
+  description: z37.string().nullable(),
+  content: z37.object({
     body: RichTextDocSchema.nullable().optional()
   }).optional(),
-  presentation: z36.object({
-    cardTitleOverride: z36.string().nullable().optional(),
-    summary: z36.string().nullable().optional(),
+  presentation: z37.object({
+    cardTitleOverride: z37.string().nullable().optional(),
+    summary: z37.string().nullable().optional(),
     image: mediaSchema2.nullable().optional()
   }).optional(),
-  slug: z36.string(),
-  path: z36.string().nullable(),
+  slug: z37.string(),
+  path: z37.string().nullable(),
   destination: publicEventDestinationSchema,
-  requiresRegistration: z36.boolean(),
-  deliveryMode: z36.enum(["in_person", "online", "hybrid"]),
-  attendanceModes: z36.array(publicEventAttendanceModeAvailabilitySchema),
-  startsAt: z36.string(),
-  endsAt: z36.string(),
-  capacity: z36.number().nullable(),
-  registeredCount: z36.number(),
-  availableSpots: z36.number().nullable(),
-  waitlistEnabled: z36.boolean(),
+  requiresRegistration: z37.boolean(),
+  deliveryMode: z37.enum(["in_person", "online", "hybrid"]),
+  attendanceModes: z37.array(publicEventAttendanceModeAvailabilitySchema),
+  startsAt: z37.string(),
+  endsAt: z37.string(),
+  capacity: z37.number().nullable(),
+  registeredCount: z37.number(),
+  availableSpots: z37.number().nullable(),
+  waitlistEnabled: z37.boolean(),
   venue: eventVenueSchema.nullable(),
   eventCategory: eventCategorySchema.nullable(),
-  teamMembers: z36.array(publicTeamMemberSummarySchema).optional(),
-  status: z36.enum(["active", "draft", "archived"]).optional(),
-  timeZone: z36.string(),
+  teamMembers: z37.array(publicTeamMemberSummarySchema).optional(),
+  status: z37.enum(["active", "draft", "archived"]).optional(),
+  timeZone: z37.string(),
   pricing: publicEventPricingSchema,
   paymentTerms: blockBookingPaymentTermsSchema,
   accessRestriction: accessRestrictionSchema,
-  allowedCategoryIds: z36.array(z36.string()),
-  requireGuestDetails: z36.boolean().optional(),
-  acceptsPasses: z36.boolean().optional(),
-  acceptsMemberships: z36.boolean().optional(),
-  course: z36.object({
-    id: z36.string(),
+  allowedCategoryIds: z37.array(z37.string()),
+  requireGuestDetails: z37.boolean().optional(),
+  acceptsPasses: z37.boolean().optional(),
+  acceptsMemberships: z37.boolean().optional(),
+  course: z37.object({
+    id: z37.string(),
     pricing: coursePricingSchema.optional(),
-    priceCents: z36.number().nullable(),
-    currency: z36.string(),
-    enrollmentOpen: z36.boolean()
+    priceCents: z37.number().nullable(),
+    currency: z37.string(),
+    enrollmentOpen: z37.boolean()
   }).nullable().optional()
 });
-var publicEventsArraySchema = z36.array(publicEventSchema);
+var publicEventsArraySchema = z37.array(publicEventSchema);
 
 // ../blocks/src/system/blocks/events/shared/fields.ts
 var cardVariantOptions2 = cardVariantRoleValues.map((value) => ({
@@ -19724,52 +19923,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 z37 } from "zod";
-var publicPassProductSchema = z37.object({
-  id: z37.string(),
-  productUseCase: z37.enum(["event_pass", "appointment_package"]).default("event_pass"),
-  name: z37.string(),
-  description: z37.string().nullable(),
-  price: z37.number(),
-  currency: z37.string(),
-  creditsTotal: z37.number(),
-  pricePerCredit: z37.number(),
-  validDays: z37.number().nullable(),
-  eligibleCategoryIds: z37.array(z37.string()),
-  eligibleCategoryNames: z37.array(z37.string())
-});
-var publicPassProductCollectionSchema = z37.object({
-  passes: z37.array(publicPassProductSchema)
-});
-var publicMembershipProductSchema = z37.object({
-  id: z37.string(),
-  name: z37.string(),
-  description: z37.string().nullable(),
-  price: z37.number(),
-  currency: z37.string(),
-  billingInterval: z37.enum(["month", "year"]),
-  eligibleCategoryIds: z37.array(z37.string()),
-  eligibleCategoryNames: z37.array(z37.string())
+import { z as z38 } from "zod";
+var publicPassProductSchema = z38.object({
+  id: z38.string(),
+  productUseCase: z38.enum(["event_pass", "appointment_package"]).default("event_pass"),
+  name: z38.string(),
+  description: z38.string().nullable(),
+  price: z38.number(),
+  currency: z38.string(),
+  creditsTotal: z38.number(),
+  pricePerCredit: z38.number(),
+  validDays: z38.number().nullable(),
+  eligibleCategoryIds: z38.array(z38.string()),
+  eligibleCategoryNames: z38.array(z38.string())
+});
+var publicPassProductCollectionSchema = z38.object({
+  passes: z38.array(publicPassProductSchema)
+});
+var publicMembershipProductSchema = z38.object({
+  id: z38.string(),
+  name: z38.string(),
+  description: z38.string().nullable(),
+  price: z38.number(),
+  currency: z38.string(),
+  billingInterval: z38.enum(["month", "year"]),
+  eligibleCategoryIds: z38.array(z38.string()),
+  eligibleCategoryNames: z38.array(z38.string())
 });
-var publicMembershipProductCollectionSchema = z37.object({
-  memberships: z37.array(publicMembershipProductSchema)
+var publicMembershipProductCollectionSchema = z38.object({
+  memberships: z38.array(publicMembershipProductSchema)
 });
 
 // ../blocks/src/system/blocks/event-registration.shared.ts
-import { z as z38 } from "zod";
-var occurrenceContextSchema = z38.object({
-  id: z38.string(),
-  seriesId: z38.string(),
-  startsAt: z38.string(),
-  endsAt: z38.string(),
-  timeZone: z38.string(),
-  capacityOverride: z38.number().nullable().optional(),
-  overrides: z38.record(z38.string(), z38.unknown()).nullable().optional()
+import { z as z39 } from "zod";
+var occurrenceContextSchema = z39.object({
+  id: z39.string(),
+  seriesId: z39.string(),
+  startsAt: z39.string(),
+  endsAt: z39.string(),
+  timeZone: z39.string(),
+  capacityOverride: z39.number().nullable().optional(),
+  overrides: z39.record(z39.string(), z39.unknown()).nullable().optional()
 }).nullable();
 
 // ../blocks/src/system/runtime/nodes/event-registration.interactive.ts
-import { z as z40 } from "zod";
+import { z as z41 } from "zod";
 
 // ../blocks/src/system/constants/events.ts
 var EVENT_CONTENT_TYPE_SLUGS = ["event", "events"];
@@ -19956,17 +20183,17 @@ function readAmount(value) {
 }
 
 // ../blocks/src/system/runtime/nodes/shared/contract-schemas.ts
-import { z as z39 } from "zod";
-var previewStageSchema = z39.enum(["preview", "published"]);
-var registrationButtonVariantSchema = z39.enum(["primary", "secondary", "outline"]);
-var eventButtonVariantSchema = z39.enum(["primary", "secondary", "outline", "link"]);
-var eventLayoutSchema = z39.enum(eventCalendarListLayoutValues);
-var eventCalendarDisplayModeSchema = z39.enum(eventCalendarDisplayModeValues);
-var eventCalendarDefaultViewSchema = z39.enum(eventCalendarDefaultViewValues);
-var columnOptionSchema = z39.enum(["2", "3", "4"]);
-var weekStartSchema = z39.enum(["sunday", "monday"]);
-var filterAutoShowSchema = z39.enum(["auto", "always", "never"]);
-var calendarTabViewsSchema = z39.enum(["both", "month", "week"]);
+import { z as z40 } from "zod";
+var previewStageSchema = z40.enum(["preview", "published"]);
+var registrationButtonVariantSchema = z40.enum(["primary", "secondary", "outline"]);
+var eventButtonVariantSchema = z40.enum(["primary", "secondary", "outline", "link"]);
+var eventLayoutSchema = z40.enum(eventCalendarListLayoutValues);
+var eventCalendarDisplayModeSchema = z40.enum(eventCalendarDisplayModeValues);
+var eventCalendarDefaultViewSchema = z40.enum(eventCalendarDefaultViewValues);
+var columnOptionSchema = z40.enum(["2", "3", "4"]);
+var weekStartSchema = z40.enum(["sunday", "monday"]);
+var filterAutoShowSchema = z40.enum(["auto", "always", "never"]);
+var calendarTabViewsSchema = z40.enum(["both", "month", "week"]);
 
 // ../blocks/src/system/runtime/nodes/event-registration/wizardSteps.ts
 function getWizardStepsForContext(hasPreSelectedContext, needsPaymentStep) {
@@ -20026,72 +20253,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 = z40.object({
-  id: z40.string(),
-  slug: z40.string(),
-  contentTypeSlug: z40.string()
+var contentEntrySchema = z41.object({
+  id: z41.string(),
+  slug: z41.string(),
+  contentTypeSlug: z41.string()
 });
-var eventRegistrationPublicEventSchema = z40.preprocess(
+var eventRegistrationPublicEventSchema = z41.preprocess(
   normalizeEventRegistrationEventInput,
   publicEventSchema
 );
-var eventRegistrationSourceSchema = z40.object({
-  siteId: z40.string().optional(),
-  apiBaseUrl: z40.string().optional(),
-  portalToken: z40.string().nullable().optional(),
-  previewToken: z40.string().nullable().optional(),
+var eventRegistrationSourceSchema = z41.object({
+  siteId: z41.string().optional(),
+  apiBaseUrl: z41.string().optional(),
+  portalToken: z41.string().nullable().optional(),
+  previewToken: z41.string().nullable().optional(),
   occurrenceContext: occurrenceContextSchema.optional(),
   contentEntry: contentEntrySchema.nullable().optional(),
-  events: z40.array(eventRegistrationPublicEventSchema).nullable().optional(),
-  className: z40.string().nullable().optional(),
-  buttonText: z40.string().nullable().optional(),
-  maxTickets: z40.string().nullable().optional(),
-  showVenue: z40.boolean().optional(),
-  showCapacity: z40.boolean().optional(),
-  successMessage: z40.string().optional(),
-  waitlistMessage: z40.string().optional(),
+  events: z41.array(eventRegistrationPublicEventSchema).nullable().optional(),
+  className: z41.string().nullable().optional(),
+  buttonText: z41.string().nullable().optional(),
+  maxTickets: z41.string().nullable().optional(),
+  showVenue: z41.boolean().optional(),
+  showCapacity: z41.boolean().optional(),
+  successMessage: z41.string().optional(),
+  waitlistMessage: z41.string().optional(),
   buttonVariant: registrationButtonVariantSchema.optional(),
-  overlayEnabled: z40.boolean().optional(),
-  spamProtectionEnabled: z40.boolean().optional(),
+  overlayEnabled: z41.boolean().optional(),
+  spamProtectionEnabled: z41.boolean().optional(),
   stage: previewStageSchema.optional(),
-  supportEmail: z40.string().optional(),
+  supportEmail: z41.string().optional(),
   sitePasses: publicPassProductCollectionSchema.nullable().optional(),
   siteMemberships: publicMembershipProductCollectionSchema.nullable().optional()
 });
-var eventRegistrationDisplaySchema = z40.object({
-  kind: z40.literal("event-registration"),
-  state: z40.literal("generic-shell"),
-  className: z40.string().nullable(),
-  titleText: z40.string(),
-  bodyText: z40.string(),
-  stepLabels: z40.array(z40.enum(EVENT_REGISTRATION_SHELL_STEP_LABELS)).min(1),
-  summaryButtonText: z40.string()
+var eventRegistrationDisplaySchema = z41.object({
+  kind: z41.literal("event-registration"),
+  state: z41.literal("generic-shell"),
+  className: z41.string().nullable(),
+  titleText: z41.string(),
+  bodyText: z41.string(),
+  stepLabels: z41.array(z41.enum(EVENT_REGISTRATION_SHELL_STEP_LABELS)).min(1),
+  summaryButtonText: z41.string()
 });
-var eventRegistrationHydrationSchema = z40.object({
+var eventRegistrationHydrationSchema = z41.object({
   occurrenceContext: occurrenceContextSchema.optional(),
   contentEntry: contentEntrySchema.nullable().optional(),
-  events: z40.array(eventRegistrationPublicEventSchema).nullable().optional(),
-  maxTickets: z40.string().optional(),
-  showVenue: z40.boolean().optional(),
-  showCapacity: z40.boolean().optional(),
-  successMessage: z40.string().optional(),
-  waitlistMessage: z40.string().optional(),
+  events: z41.array(eventRegistrationPublicEventSchema).nullable().optional(),
+  maxTickets: z41.string().optional(),
+  showVenue: z41.boolean().optional(),
+  showCapacity: z41.boolean().optional(),
+  successMessage: z41.string().optional(),
+  waitlistMessage: z41.string().optional(),
   buttonVariant: registrationButtonVariantSchema.optional(),
-  overlayEnabled: z40.boolean().optional(),
-  spamProtectionEnabled: z40.boolean().optional(),
-  supportEmail: z40.string().optional(),
+  overlayEnabled: z41.boolean().optional(),
+  spamProtectionEnabled: z41.boolean().optional(),
+  supportEmail: z41.string().optional(),
   sitePasses: publicPassProductCollectionSchema.nullable().optional(),
   siteMemberships: publicMembershipProductCollectionSchema.nullable().optional()
 });
-var eventRegistrationRenderSchema = z40.object({
+var eventRegistrationRenderSchema = z41.object({
   display: eventRegistrationDisplaySchema,
   hydration: eventRegistrationHydrationSchema
 });
-var eventRegistrationIslandMetaCodec = createZodCodec(z40.object({
-  siteId: z40.string().optional(),
-  apiBaseUrl: z40.string().optional(),
-  portalToken: z40.string().nullable().optional(),
-  previewToken: z40.string().nullable().optional(),
+var eventRegistrationIslandMetaCodec = createZodCodec(z41.object({
+  siteId: z41.string().optional(),
+  apiBaseUrl: z41.string().optional(),
+  portalToken: z41.string().nullable().optional(),
+  previewToken: z41.string().nullable().optional(),
   stage: previewStageSchema.optional()
 }));
 var eventRegistrationIslandMetaKeys = defineInteractiveIslandMetaKeys(
@@ -20442,73 +20669,73 @@ var eventRegistrationBlockDefinition = {
 };
 
 // ../blocks/src/system/runtime/nodes/course-registration.interactive.ts
-import { z as z41 } from "zod";
-var contentEntrySchema2 = z41.object({
-  id: z41.string(),
-  slug: z41.string(),
-  contentTypeSlug: z41.string()
-});
-var courseEntrySubrouteContextSchema = z41.union([
-  z41.object({
-    kind: z41.literal("course-run"),
-    run: z41.object({
-      courseId: z41.string(),
-      seriesId: z41.string(),
-      runSlug: z41.string(),
-      runName: z41.string().nullable()
+import { z as z42 } from "zod";
+var contentEntrySchema2 = z42.object({
+  id: z42.string(),
+  slug: z42.string(),
+  contentTypeSlug: z42.string()
+});
+var courseEntrySubrouteContextSchema = z42.union([
+  z42.object({
+    kind: z42.literal("course-run"),
+    run: z42.object({
+      courseId: z42.string(),
+      seriesId: z42.string(),
+      runSlug: z42.string(),
+      runName: z42.string().nullable()
     })
   }),
-  z41.object({
-    kind: z41.literal("event-occurrence"),
+  z42.object({
+    kind: z42.literal("event-occurrence"),
     occurrence: occurrenceContextSchema
   })
 ]);
-var courseRegistrationSourceSchema = z41.object({
-  siteId: z41.string().optional(),
-  apiBaseUrl: z41.string().optional(),
-  portalToken: z41.string().nullable().optional(),
+var courseRegistrationSourceSchema = z42.object({
+  siteId: z42.string().optional(),
+  apiBaseUrl: z42.string().optional(),
+  portalToken: z42.string().nullable().optional(),
   contentEntry: contentEntrySchema2.nullable().optional(),
   entrySubrouteContext: courseEntrySubrouteContextSchema.nullable().optional(),
-  courses: z41.array(publicCourseSchema).nullable().optional(),
-  className: z41.string().nullable().optional(),
-  showSessions: z41.boolean().optional(),
-  showPrice: z41.boolean().optional(),
-  showCapacity: z41.boolean().optional(),
-  showVenue: z41.boolean().optional(),
-  successMessage: z41.string().optional(),
-  waitlistMessage: z41.string().optional(),
-  membershipMessage: z41.string().optional(),
-  buttonText: z41.string().nullable().optional(),
+  courses: z42.array(publicCourseSchema).nullable().optional(),
+  className: z42.string().nullable().optional(),
+  showSessions: z42.boolean().optional(),
+  showPrice: z42.boolean().optional(),
+  showCapacity: z42.boolean().optional(),
+  showVenue: z42.boolean().optional(),
+  successMessage: z42.string().optional(),
+  waitlistMessage: z42.string().optional(),
+  membershipMessage: z42.string().optional(),
+  buttonText: z42.string().nullable().optional(),
   buttonVariant: registrationButtonVariantSchema.optional(),
   stage: previewStageSchema.optional()
 });
-var courseRegistrationDisplaySchema = z41.object({
-  kind: z41.literal("course-registration"),
-  state: z41.literal("shell"),
-  className: z41.string().nullable(),
-  summaryButtonText: z41.string()
+var courseRegistrationDisplaySchema = z42.object({
+  kind: z42.literal("course-registration"),
+  state: z42.literal("shell"),
+  className: z42.string().nullable(),
+  summaryButtonText: z42.string()
 });
-var courseRegistrationHydrationSchema = z41.object({
+var courseRegistrationHydrationSchema = z42.object({
   contentEntry: contentEntrySchema2.nullable().optional(),
   entrySubrouteContext: courseEntrySubrouteContextSchema.nullable().optional(),
-  courses: z41.array(publicCourseSchema).nullable().optional(),
-  showSessions: z41.boolean().optional(),
-  showPrice: z41.boolean().optional(),
-  showCapacity: z41.boolean().optional(),
-  showVenue: z41.boolean().optional(),
-  successMessage: z41.string().optional(),
-  waitlistMessage: z41.string().optional(),
-  membershipMessage: z41.string().optional(),
+  courses: z42.array(publicCourseSchema).nullable().optional(),
+  showSessions: z42.boolean().optional(),
+  showPrice: z42.boolean().optional(),
+  showCapacity: z42.boolean().optional(),
+  showVenue: z42.boolean().optional(),
+  successMessage: z42.string().optional(),
+  waitlistMessage: z42.string().optional(),
+  membershipMessage: z42.string().optional(),
   buttonVariant: registrationButtonVariantSchema.optional()
 });
-var courseRegistrationRenderSchema = z41.object({
+var courseRegistrationRenderSchema = z42.object({
   display: courseRegistrationDisplaySchema,
   hydration: courseRegistrationHydrationSchema
 });
-var courseRegistrationIslandMetaCodec = createZodCodec(z41.object({
-  siteId: z41.string().optional(),
-  apiBaseUrl: z41.string().optional(),
-  portalToken: z41.string().nullable().optional(),
+var courseRegistrationIslandMetaCodec = createZodCodec(z42.object({
+  siteId: z42.string().optional(),
+  apiBaseUrl: z42.string().optional(),
+  portalToken: z42.string().nullable().optional(),
   stage: previewStageSchema.optional()
 }));
 var courseRegistrationIslandMetaKeys = defineInteractiveIslandMetaKeys(
@@ -20768,7 +20995,7 @@ var courseRegistrationBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/event-details.ts
-import { z as z42 } from "zod";
+import { z as z43 } from "zod";
 var eventDetailsManifest = createBlockManifest({
   id: "block.event-details",
   version: "1.0.0",
@@ -20900,37 +21127,37 @@ var eventDetailsManifest = createBlockManifest({
     })
   ]
 });
-var occurrenceContextSchema2 = z42.object({
-  id: z42.string(),
-  seriesId: z42.string(),
-  startsAt: z42.string(),
-  endsAt: z42.string(),
-  timeZone: z42.string(),
-  capacityOverride: z42.number().nullable().optional(),
-  overrides: z42.record(z42.string(), z42.unknown()).nullable().optional()
+var occurrenceContextSchema2 = z43.object({
+  id: z43.string(),
+  seriesId: 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()
 }).nullable();
-var eventAutoApplyDiscountPreviewBaseSchema = z42.object({
-  id: z42.string(),
-  publicLabel: z42.string(),
-  description: z42.string().nullable(),
-  minTicketsRequired: z42.number().nullable()
+var eventAutoApplyDiscountPreviewBaseSchema = z43.object({
+  id: z43.string(),
+  publicLabel: z43.string(),
+  description: z43.string().nullable(),
+  minTicketsRequired: z43.number().nullable()
 });
-var eventAutoApplyDiscountPreviewSchema = z42.discriminatedUnion("discountType", [
+var eventAutoApplyDiscountPreviewSchema = z43.discriminatedUnion("discountType", [
   eventAutoApplyDiscountPreviewBaseSchema.extend({
-    discountType: z42.literal("percent"),
-    discountPercent: z42.number(),
-    discountAmountCents: z42.null()
+    discountType: z43.literal("percent"),
+    discountPercent: z43.number(),
+    discountAmountCents: z43.null()
   }),
   eventAutoApplyDiscountPreviewBaseSchema.extend({
-    discountType: z42.literal("fixed"),
-    discountPercent: z42.null(),
-    discountAmountCents: z42.number()
+    discountType: z43.literal("fixed"),
+    discountPercent: z43.null(),
+    discountAmountCents: z43.number()
   })
 ]);
 var eventDetailsBlockDefinition = {
   manifest: eventDetailsManifest,
   dataSchemas: {
-    eventDetailsData: z42.object({
+    eventDetailsData: z43.object({
       events: publicEventsArraySchema,
       sitePasses: publicPassProductCollectionSchema,
       siteMemberships: publicMembershipProductCollectionSchema,
@@ -21185,18 +21412,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" } },
@@ -21257,7 +21473,7 @@ var eventSpotlightBlockDefinition = {
 };
 
 // ../blocks/src/system/runtime/nodes/events/EventListing.interactive.ts
-import { z as z44 } from "zod";
+import { z as z45 } from "zod";
 
 // ../blocks/src/system/runtime/nodes/events/shared/utils.ts
 var COLUMN_CLASSES = {
@@ -21289,16 +21505,16 @@ function getCardOrientation(layout) {
 }
 
 // ../blocks/src/system/runtime/nodes/events/shared/listOptions.ts
-import { z as z43 } from "zod";
+import { z as z44 } from "zod";
 var eventPageSizeValues = [3, 6, 10, 12, 20, 24, 30];
-var eventPageSizeSchema = z43.union([
-  z43.literal(3),
-  z43.literal(6),
-  z43.literal(10),
-  z43.literal(12),
-  z43.literal(20),
-  z43.literal(24),
-  z43.literal(30)
+var eventPageSizeSchema = z44.union([
+  z44.literal(3),
+  z44.literal(6),
+  z44.literal(10),
+  z44.literal(12),
+  z44.literal(20),
+  z44.literal(24),
+  z44.literal(30)
 ]);
 var eventPageSizeSet = new Set(eventPageSizeValues);
 function resolveEventPageSize(value, fallback = 12) {
@@ -21308,15 +21524,15 @@ function resolveEventPageSize(value, fallback = 12) {
 function resolveEventCalendarListPageSize(input) {
   return resolveEventPageSize(input.eventsPerPage);
 }
-var eventListPaginationActionSchema = z43.discriminatedUnion("kind", [
-  z43.object({
-    kind: z43.literal("loadMore"),
-    label: z43.string()
+var eventListPaginationActionSchema = z44.discriminatedUnion("kind", [
+  z44.object({
+    kind: z44.literal("loadMore"),
+    label: z44.string()
   }),
-  z43.object({
-    kind: z43.literal("seeAllLink"),
-    label: z43.string(),
-    href: z43.string()
+  z44.object({
+    kind: z44.literal("seeAllLink"),
+    label: z44.string(),
+    href: z44.string()
   })
 ]);
 function resolveEventListPaginationAction(input) {
@@ -21329,89 +21545,89 @@ function resolveEventListPaginationAction(input) {
 }
 
 // ../blocks/src/system/runtime/nodes/events/EventListing.interactive.ts
-var legacyEventCardVariantSchema = z44.enum(["variant1", "variant2"]);
-var eventCardVariantInputSchema = z44.union([
+var legacyEventCardVariantSchema = z45.enum(["variant1", "variant2"]);
+var eventCardVariantInputSchema = z45.union([
   cardVariantRoleSchema,
   legacyEventCardVariantSchema
 ]);
-var cardOrientationSchema = z44.enum(["vertical", "horizontal"]);
-var eventBlockKindSchema = z44.enum(eventBlockKindValues);
-var eventSurfaceScopeSchema = z44.enum(eventSurfaceScopeValues);
-var eventScheduleScopeSchema2 = z44.enum(eventScheduleScopeValues);
-var eventListingSourceSchema = z44.object({
-  events: z44.array(publicEventSchema).nullable().optional(),
-  siteId: z44.string(),
-  apiBaseUrl: z44.string().optional(),
+var cardOrientationSchema = z45.enum(["vertical", "horizontal"]);
+var eventBlockKindSchema = z45.enum(eventBlockKindValues);
+var eventSurfaceScopeSchema = z45.enum(eventSurfaceScopeValues);
+var eventScheduleScopeSchema2 = z45.enum(eventScheduleScopeValues);
+var eventListingSourceSchema = z45.object({
+  events: z45.array(publicEventSchema).nullable().optional(),
+  siteId: z45.string(),
+  apiBaseUrl: z45.string().optional(),
   stage: previewStageSchema.optional(),
   layout: eventLayoutSchema.optional(),
   columns: columnOptionSchema.optional(),
-  eventsPerPage: z44.string().optional(),
-  paginationMode: z44.enum(["loadMore", "seeAllLink"]).optional(),
-  seeAllUrl: z44.string().optional(),
-  loadMoreText: z44.string().optional(),
+  eventsPerPage: z45.string().optional(),
+  paginationMode: z45.enum(["loadMore", "seeAllLink"]).optional(),
+  seeAllUrl: z45.string().optional(),
+  loadMoreText: z45.string().optional(),
   cardVariant: eventCardVariantInputSchema.optional(),
   buttonVariant: eventButtonVariantSchema.optional(),
-  buttonText: z44.string().optional(),
-  showVenue: z44.boolean().optional(),
-  showMap: z44.boolean().optional(),
-  showCapacity: z44.boolean().optional(),
-  emptyMessage: z44.string().optional(),
-  className: z44.string().optional(),
-  showFilters: z44.boolean().nullable().optional(),
+  buttonText: z45.string().optional(),
+  showVenue: z45.boolean().optional(),
+  showMap: z45.boolean().optional(),
+  showCapacity: z45.boolean().optional(),
+  emptyMessage: z45.string().optional(),
+  className: z45.string().optional(),
+  showFilters: z45.boolean().nullable().optional(),
   showCategoryFilter: filterAutoShowSchema.optional(),
-  showVenueFilter: z44.boolean().nullable().optional(),
-  showStaffFilter: z44.boolean().nullable().optional(),
+  showVenueFilter: z45.boolean().nullable().optional(),
+  showStaffFilter: z45.boolean().nullable().optional(),
   eventKind: eventBlockKindSchema.nullable().optional(),
   eventSurface: eventSurfaceScopeSchema.nullable().optional(),
-  filterEventPresets: z44.union([z44.string(), z44.array(z44.string())]).nullable().optional(),
+  filterEventPresets: z45.union([z45.string(), z45.array(z45.string())]).nullable().optional(),
   scheduleScope: eventScheduleScopeSchema2.nullable().optional(),
-  filterCategoryIds: z44.string().nullable().optional(),
-  filterStaffMemberId: z44.string().nullable().optional(),
-  filterVenueId: z44.string().nullable().optional()
+  filterCategoryIds: z45.string().nullable().optional(),
+  filterStaffMemberId: z45.string().nullable().optional(),
+  filterVenueId: z45.string().nullable().optional()
 });
-var eventListingDisplaySchema = z44.object({
-  kind: z44.literal("event-listing"),
-  state: z44.enum(["loading", "empty", "ready"]),
+var eventListingDisplaySchema = z45.object({
+  kind: z45.literal("event-listing"),
+  state: z45.enum(["loading", "empty", "ready"]),
   listLayout: eventLayoutSchema,
-  className: z44.string().nullable(),
-  emptyMessage: z44.string(),
-  loadingMessage: z44.string(),
-  containerClass: z44.string(),
+  className: z45.string().nullable(),
+  emptyMessage: z45.string(),
+  loadingMessage: z45.string(),
+  containerClass: z45.string(),
   cardVariant: cardVariantRoleSchema,
   buttonVariant: eventButtonVariantSchema,
-  buttonText: z44.string(),
-  showVenue: z44.boolean(),
-  showMap: z44.boolean(),
-  showCapacity: z44.boolean(),
+  buttonText: z45.string(),
+  showVenue: z45.boolean(),
+  showMap: z45.boolean(),
+  showCapacity: z45.boolean(),
   orientation: cardOrientationSchema,
-  events: z44.array(publicEventSchema)
+  events: z45.array(publicEventSchema)
 });
-var eventListingHydrationSchema = z44.object({
-  siteId: z44.string(),
+var eventListingHydrationSchema = z45.object({
+  siteId: z45.string(),
   stage: previewStageSchema.optional(),
   eventsPerPage: eventPageSizeSchema,
   paginationAction: eventListPaginationActionSchema,
-  showFilters: z44.boolean(),
+  showFilters: z45.boolean(),
   showCategoryFilter: filterAutoShowSchema,
-  showVenueFilter: z44.boolean(),
-  showStaffFilter: z44.boolean(),
+  showVenueFilter: z45.boolean(),
+  showStaffFilter: z45.boolean(),
   eventKind: eventBlockKindSchema,
   eventSurface: eventSurfaceScopeSchema,
-  filterEventPresets: z44.string().nullable(),
+  filterEventPresets: z45.string().nullable(),
   scheduleScope: eventScheduleScopeSchema2,
-  filterCategoryIds: z44.string().nullable().optional(),
-  filterStaffMemberId: z44.string().nullable().optional(),
-  filterVenueId: z44.string().nullable().optional(),
-  fetchInitialEventsOnMount: z44.boolean()
+  filterCategoryIds: z45.string().nullable().optional(),
+  filterStaffMemberId: z45.string().nullable().optional(),
+  filterVenueId: z45.string().nullable().optional(),
+  fetchInitialEventsOnMount: z45.boolean()
 });
-var eventListingRenderSchema = z44.object({
+var eventListingRenderSchema = z45.object({
   display: eventListingDisplaySchema,
   hydration: eventListingHydrationSchema
 });
 var eventListingIslandMetaCodec = createZodCodec(
-  z44.object({
-    siteId: z44.string(),
-    apiBaseUrl: z44.string().optional(),
+  z45.object({
+    siteId: z45.string(),
+    apiBaseUrl: z45.string().optional(),
     stage: previewStageSchema.optional()
   })
 );
@@ -21651,18 +21867,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" } },
@@ -21778,15 +21983,15 @@ var eventListingBlockDefinition = {
 };
 
 // ../blocks/src/system/runtime/nodes/events/EventCalendar.interactive.ts
-import { z as z45 } from "zod";
-var eventBlockKindSchema2 = z45.enum(eventBlockKindValues);
-var eventSurfaceScopeSchema2 = z45.enum(eventSurfaceScopeValues);
-var eventScheduleScopeSchema3 = z45.enum(eventScheduleScopeValues);
-var eventCalendarSourceSchema = z45.object(
+import { z as z46 } from "zod";
+var eventBlockKindSchema2 = z46.enum(eventBlockKindValues);
+var eventSurfaceScopeSchema2 = z46.enum(eventSurfaceScopeValues);
+var eventScheduleScopeSchema3 = z46.enum(eventScheduleScopeValues);
+var eventCalendarSourceSchema = z46.object(
   {
-    events: z45.array(publicEventSchema).nullable().optional(),
-    siteId: z45.string(),
-    apiBaseUrl: z45.string().optional(),
+    events: z46.array(publicEventSchema).nullable().optional(),
+    siteId: z46.string(),
+    apiBaseUrl: z46.string().optional(),
     stage: previewStageSchema.optional(),
     variant: eventCalendarDisplayModeSchema.nullable().optional(),
     displayMode: eventCalendarDisplayModeSchema.nullable().optional(),
@@ -21794,38 +21999,38 @@ var eventCalendarSourceSchema = z45.object(
     listColumns: columnOptionSchema.optional(),
     layout: eventLayoutSchema.optional(),
     columns: columnOptionSchema.optional(),
-    eventsPerPage: z45.string().optional(),
-    paginationMode: z45.enum(["loadMore", "seeAllLink"]).optional(),
-    seeAllUrl: z45.string().optional(),
-    loadMoreText: z45.string().optional(),
+    eventsPerPage: z46.string().optional(),
+    paginationMode: z46.enum(["loadMore", "seeAllLink"]).optional(),
+    seeAllUrl: z46.string().optional(),
+    loadMoreText: z46.string().optional(),
     startOfWeek: weekStartSchema.optional(),
     calendarTabViews: calendarTabViewsSchema.optional(),
     defaultCalendarView: eventCalendarDefaultViewSchema.optional(),
-    showFilters: z45.boolean().nullable().optional(),
+    showFilters: z46.boolean().nullable().optional(),
     showCategoryFilter: filterAutoShowSchema.optional(),
-    showVenueFilter: z45.boolean().nullable().optional(),
-    showStaffFilter: z45.boolean().nullable().optional(),
+    showVenueFilter: z46.boolean().nullable().optional(),
+    showStaffFilter: z46.boolean().nullable().optional(),
     kind: eventBlockKindSchema2.nullable().optional(),
     eventSurface: eventSurfaceScopeSchema2.nullable().optional(),
-    filterEventPresets: z45.union([z45.string(), z45.array(z45.string())]).nullable().optional(),
+    filterEventPresets: z46.union([z46.string(), z46.array(z46.string())]).nullable().optional(),
     scheduleScope: eventScheduleScopeSchema3.nullable().optional(),
-    filterCategoryIds: z45.union([z45.string(), z45.array(z45.string())]).nullable().optional(),
-    filterStaffMemberId: z45.string().nullable().optional(),
-    filterVenueId: z45.string().nullable().optional(),
+    filterCategoryIds: z46.union([z46.string(), z46.array(z46.string())]).nullable().optional(),
+    filterStaffMemberId: z46.string().nullable().optional(),
+    filterVenueId: z46.string().nullable().optional(),
     buttonVariant: eventButtonVariantSchema.optional(),
-    buttonText: z45.string().optional(),
-    showVenue: z45.boolean().nullable().optional(),
-    showMap: z45.boolean().nullable().optional(),
-    showCapacity: z45.boolean().nullable().optional(),
-    emptyMessage: z45.string().optional(),
-    className: z45.string().optional()
+    buttonText: z46.string().optional(),
+    showVenue: z46.boolean().nullable().optional(),
+    showMap: z46.boolean().nullable().optional(),
+    showCapacity: z46.boolean().nullable().optional(),
+    emptyMessage: z46.string().optional(),
+    className: z46.string().optional()
   }
 );
-var eventCalendarDisplaySchema = z45.object({
-  kind: z45.literal("event-calendar"),
+var eventCalendarDisplaySchema = z46.object({
+  kind: z46.literal("event-calendar"),
   displayMode: eventCalendarDisplayModeSchema,
-  className: z45.string().nullable(),
-  events: z45.array(publicEventSchema),
+  className: z46.string().nullable(),
+  events: z46.array(publicEventSchema),
   listLayout: eventLayoutSchema,
   listColumns: columnOptionSchema,
   eventsPerPage: eventPageSizeSchema,
@@ -21833,41 +22038,41 @@ var eventCalendarDisplaySchema = z45.object({
   startOfWeek: weekStartSchema,
   calendarTabViews: calendarTabViewsSchema,
   defaultCalendarView: eventCalendarDefaultViewSchema,
-  showFilters: z45.boolean(),
+  showFilters: z46.boolean(),
   showCategoryFilter: filterAutoShowSchema,
-  showVenueFilter: z45.boolean(),
-  showStaffFilter: z45.boolean(),
+  showVenueFilter: z46.boolean(),
+  showStaffFilter: z46.boolean(),
   eventKind: eventBlockKindSchema2,
   eventSurface: eventSurfaceScopeSchema2,
-  filterEventPresets: z45.string().nullable(),
+  filterEventPresets: z46.string().nullable(),
   scheduleScope: eventScheduleScopeSchema3,
-  filterCategoryIds: z45.string().nullable(),
-  filterStaffMemberId: z45.string().nullable(),
-  filterVenueId: z45.string().nullable(),
+  filterCategoryIds: z46.string().nullable(),
+  filterStaffMemberId: z46.string().nullable(),
+  filterVenueId: z46.string().nullable(),
   buttonVariant: eventButtonVariantSchema,
-  buttonText: z45.string(),
-  showVenue: z45.boolean(),
-  showMap: z45.boolean(),
-  showCapacity: z45.boolean(),
-  emptyMessage: z45.string()
-});
-var eventCalendarHydrationSchema = z45.object({
-  siteId: z45.string(),
+  buttonText: z46.string(),
+  showVenue: z46.boolean(),
+  showMap: z46.boolean(),
+  showCapacity: z46.boolean(),
+  emptyMessage: z46.string()
+});
+var eventCalendarHydrationSchema = z46.object({
+  siteId: z46.string(),
   stage: previewStageSchema.optional(),
-  prefetchedEvents: z45.boolean(),
+  prefetchedEvents: z46.boolean(),
   eventKind: eventBlockKindSchema2,
   eventSurface: eventSurfaceScopeSchema2,
-  filterEventPresets: z45.string().nullable(),
+  filterEventPresets: z46.string().nullable(),
   scheduleScope: eventScheduleScopeSchema3
 });
-var eventCalendarRenderSchema = z45.object({
+var eventCalendarRenderSchema = z46.object({
   display: eventCalendarDisplaySchema,
   hydration: eventCalendarHydrationSchema
 });
 var eventCalendarIslandMetaCodec = createZodCodec(
-  z45.object({
-    siteId: z45.string(),
-    apiBaseUrl: z45.string().optional(),
+  z46.object({
+    siteId: z46.string(),
+    apiBaseUrl: z46.string().optional(),
     stage: previewStageSchema.optional()
   })
 );
@@ -21987,14 +22192,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",
@@ -22639,7 +22837,7 @@ var eventCalendarBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/offerings-preview/index.ts
-import { z as z46 } from "zod";
+import { z as z47 } from "zod";
 
 // ../blocks/src/system/blocks/offerings-preview/model.ts
 var OFFERINGS_PREVIEW_DEFAULT_ITEM_LIMIT = "3";
@@ -22731,13 +22929,13 @@ function isRecord5(value) {
 }
 
 // ../blocks/src/system/blocks/offerings-preview/index.ts
-var publicRouteCandidatesSchema = z46.object({
-  routes: z46.array(z46.object({
-    entityId: z46.string(),
-    path: z46.string(),
-    title: z46.string(),
-    kind: z46.enum(["page", "content"]),
-    contentTypeKey: z46.string().nullable().optional()
+var publicRouteCandidatesSchema = z47.object({
+  routes: z47.array(z47.object({
+    entityId: z47.string(),
+    path: z47.string(),
+    title: z47.string(),
+    kind: z47.enum(["page", "content"]),
+    contentTypeKey: z47.string().nullable().optional()
   }))
 });
 var groupOverrideFields = [
@@ -23135,7 +23333,7 @@ function isRecord6(value) {
 }
 
 // ../blocks/src/system/blocks/embed.ts
-import { z as z47 } from "zod";
+import { z as z48 } from "zod";
 var embedFields = [
   // Section heading
   parseFieldDefinition({
@@ -23366,18 +23564,18 @@ var embedManifest = createBlockManifest({
     spacing: "lg"
   }
 });
-var embedEntrySchema = z47.object({
-  id: z47.string(),
-  identifier: z47.string(),
-  title: z47.string(),
-  slug: z47.string().nullable().optional(),
-  content: z47.record(z47.string(), z47.unknown()).optional(),
-  publishedAt: z47.string().nullable().optional()
+var embedEntrySchema = z48.object({
+  id: z48.string(),
+  identifier: z48.string(),
+  title: z48.string(),
+  slug: z48.string().nullable().optional(),
+  content: z48.record(z48.string(), z48.unknown()).optional(),
+  publishedAt: z48.string().nullable().optional()
 });
 var embedBlockDefinition = {
   manifest: embedManifest,
   dataSchemas: {
-    entries: z47.array(embedEntrySchema).optional()
+    entries: z48.array(embedEntrySchema).optional()
   },
   dataLoaders: {
     entries: {
@@ -24561,49 +24759,49 @@ var fileDownloadBlockDefinition = {
 };
 
 // ../blocks/src/system/runtime/nodes/shop.interactive.ts
-import { z as z50 } from "zod";
+import { z as z51 } from "zod";
 
 // ../blocks/src/system/blocks/products/shared.ts
-import { z as z48 } from "zod";
-var publicProductVariantSchema = z48.object({
-  id: z48.string(),
-  title: z48.string(),
-  sku: z48.string().nullable(),
-  priceCents: z48.number(),
-  stockQuantity: z48.number().nullable(),
-  soldOut: z48.boolean()
-});
-var publicProductSchema = z48.object({
-  id: z48.string(),
-  contentEntryId: z48.string().nullable(),
-  title: z48.string(),
-  slug: z48.string(),
-  path: z48.string().nullable(),
-  status: z48.enum(["draft", "active"]),
-  priceCents: z48.number(),
-  currency: z48.string(),
-  productType: z48.enum(["physical", "digital"]),
-  requiresShipping: z48.boolean(),
-  hasVariants: z48.boolean(),
-  trackInventory: z48.boolean(),
-  soldOut: z48.boolean(),
-  category: z48.object({
-    id: z48.string(),
-    name: z48.string(),
-    slug: z48.string()
+import { z as z49 } from "zod";
+var publicProductVariantSchema = z49.object({
+  id: z49.string(),
+  title: z49.string(),
+  sku: z49.string().nullable(),
+  priceCents: z49.number(),
+  stockQuantity: z49.number().nullable(),
+  soldOut: z49.boolean()
+});
+var publicProductSchema = z49.object({
+  id: z49.string(),
+  contentEntryId: z49.string().nullable(),
+  title: z49.string(),
+  slug: z49.string(),
+  path: z49.string().nullable(),
+  status: z49.enum(["draft", "active"]),
+  priceCents: z49.number(),
+  currency: z49.string(),
+  productType: z49.enum(["physical", "digital"]),
+  requiresShipping: z49.boolean(),
+  hasVariants: z49.boolean(),
+  trackInventory: z49.boolean(),
+  soldOut: z49.boolean(),
+  category: z49.object({
+    id: z49.string(),
+    name: z49.string(),
+    slug: z49.string()
   }).nullable(),
-  summary: z48.string().nullable(),
-  body: z48.unknown().nullable(),
-  gallery: z48.array(
-    z48.object({
-      url: z48.string(),
-      alt: z48.string().nullable()
+  summary: z49.string().nullable(),
+  body: z49.unknown().nullable(),
+  gallery: z49.array(
+    z49.object({
+      url: z49.string(),
+      alt: z49.string().nullable()
     })
   ),
-  variants: z48.array(publicProductVariantSchema)
+  variants: z49.array(publicProductVariantSchema)
 });
-var publicProductsResponseSchema = z48.object({
-  products: z48.array(publicProductSchema)
+var publicProductsResponseSchema = z49.object({
+  products: z49.array(publicProductSchema)
 });
 
 // ../blocks/src/system/runtime/api/creditProducts.ts
@@ -24667,27 +24865,27 @@ function deriveCreditProductLabels(products, options = {}) {
 }
 
 // ../blocks/src/system/runtime/nodes/shop-commerce.shared.ts
-import { z as z49 } from "zod";
-var storedProductCartItemSchema = z49.object({
-  kind: z49.literal("product"),
-  productId: z49.string().min(1),
-  productCategoryId: z49.string().min(1).optional().nullable(),
-  variantId: z49.string().min(1).optional().nullable(),
-  title: z49.string().min(1),
-  variantTitle: z49.string().optional().nullable(),
-  quantity: z49.number().finite(),
-  unitPriceCents: z49.number().finite(),
-  currency: z49.string().min(1),
-  imageUrl: z49.string().optional().nullable(),
-  soldOut: z49.boolean().optional()
-});
-var storedPassCartItemSchema = z49.object({
-  kind: z49.literal("pass"),
-  passId: z49.string().min(1),
-  title: z49.string().min(1),
-  quantity: z49.number().finite().optional(),
-  unitPriceCents: z49.number().finite(),
-  currency: z49.string().min(1)
+import { z as z50 } from "zod";
+var storedProductCartItemSchema = z50.object({
+  kind: z50.literal("product"),
+  productId: z50.string().min(1),
+  productCategoryId: z50.string().min(1).optional().nullable(),
+  variantId: z50.string().min(1).optional().nullable(),
+  title: z50.string().min(1),
+  variantTitle: z50.string().optional().nullable(),
+  quantity: z50.number().finite(),
+  unitPriceCents: z50.number().finite(),
+  currency: z50.string().min(1),
+  imageUrl: z50.string().optional().nullable(),
+  soldOut: z50.boolean().optional()
+});
+var storedPassCartItemSchema = z50.object({
+  kind: z50.literal("pass"),
+  passId: z50.string().min(1),
+  title: z50.string().min(1),
+  quantity: z50.number().finite().optional(),
+  unitPriceCents: z50.number().finite(),
+  currency: z50.string().min(1)
 });
 function deriveCommerceCheckoutState(state) {
   if (state.items.length === 0) {
@@ -24921,214 +25119,214 @@ function formatValidity(days) {
 }
 
 // ../blocks/src/system/runtime/nodes/shop.interactive.ts
-var shopModeSchema = z50.enum(["passes-memberships", "product-list", "product-detail", "cart", "checkout"]);
-var contentEntrySchema3 = z50.object({
-  id: z50.string().nullable().optional(),
-  slug: z50.string().nullable().optional()
+var shopModeSchema = z51.enum(["passes-memberships", "product-list", "product-detail", "cart", "checkout"]);
+var contentEntrySchema3 = z51.object({
+  id: z51.string().nullable().optional(),
+  slug: z51.string().nullable().optional()
 }).nullable();
-var shopSourceSchema = z50.object({
-  className: z50.string().nullable().optional(),
+var shopSourceSchema = z51.object({
+  className: z51.string().nullable().optional(),
   mode: shopModeSchema.optional(),
-  heading: z50.string().nullable().optional(),
-  productSlug: z50.string().nullable().optional(),
-  showPasses: z50.boolean().optional(),
-  showMemberships: z50.boolean().optional(),
-  layout: z50.enum(["grid", "list"]).optional(),
-  columns: z50.string().optional(),
-  showDescriptions: z50.boolean().optional(),
-  showSummary: z50.boolean().optional(),
-  showBody: z50.boolean().optional(),
-  showPrices: z50.boolean().optional(),
-  showValidityPeriod: z50.boolean().optional(),
-  showPricePerCredit: z50.boolean().nullable().optional(),
-  passesHeading: z50.string().optional(),
-  membershipsHeading: z50.string().optional(),
-  buyButtonText: z50.string().optional(),
-  addButtonText: z50.string().optional(),
-  passPurchaseMode: z50.enum(["add_to_cart", "buy_now"]).optional(),
-  subscribeButtonText: z50.string().optional(),
-  emptyStateText: z50.string().optional(),
-  checkoutButtonText: z50.string().optional(),
-  clearButtonText: z50.string().optional(),
-  submitButtonText: z50.string().optional(),
+  heading: z51.string().nullable().optional(),
+  productSlug: z51.string().nullable().optional(),
+  showPasses: z51.boolean().optional(),
+  showMemberships: z51.boolean().optional(),
+  layout: z51.enum(["grid", "list"]).optional(),
+  columns: z51.string().optional(),
+  showDescriptions: z51.boolean().optional(),
+  showSummary: z51.boolean().optional(),
+  showBody: z51.boolean().optional(),
+  showPrices: z51.boolean().optional(),
+  showValidityPeriod: z51.boolean().optional(),
+  showPricePerCredit: z51.boolean().nullable().optional(),
+  passesHeading: z51.string().optional(),
+  membershipsHeading: z51.string().optional(),
+  buyButtonText: z51.string().optional(),
+  addButtonText: z51.string().optional(),
+  passPurchaseMode: z51.enum(["add_to_cart", "buy_now"]).optional(),
+  subscribeButtonText: z51.string().optional(),
+  emptyStateText: z51.string().optional(),
+  checkoutButtonText: z51.string().optional(),
+  clearButtonText: z51.string().optional(),
+  submitButtonText: z51.string().optional(),
   contentEntry: contentEntrySchema3.optional(),
-  passes: z50.array(publicPassProductSchema).nullable().optional(),
-  memberships: z50.array(publicMembershipProductSchema).nullable().optional(),
-  products: z50.array(publicProductSchema).nullable().optional(),
-  siteId: z50.string().optional(),
-  apiBaseUrl: z50.string().optional(),
+  passes: z51.array(publicPassProductSchema).nullable().optional(),
+  memberships: z51.array(publicMembershipProductSchema).nullable().optional(),
+  products: z51.array(publicProductSchema).nullable().optional(),
+  siteId: z51.string().optional(),
+  apiBaseUrl: z51.string().optional(),
   stage: previewStageSchema.optional()
 });
-var productVariantOptionDisplaySchema = z50.object({
-  id: z50.string(),
-  label: z50.string(),
-  soldOut: z50.boolean()
-});
-var productCardDisplaySchema = z50.object({
-  productId: z50.string(),
-  title: z50.string(),
-  path: z50.string().nullable(),
-  summary: z50.string().nullable(),
-  priceLabel: z50.string().nullable(),
-  image: z50.object({
-    url: z50.string(),
-    alt: z50.string().nullable()
+var productVariantOptionDisplaySchema = z51.object({
+  id: z51.string(),
+  label: z51.string(),
+  soldOut: z51.boolean()
+});
+var productCardDisplaySchema = z51.object({
+  productId: z51.string(),
+  title: z51.string(),
+  path: z51.string().nullable(),
+  summary: z51.string().nullable(),
+  priceLabel: z51.string().nullable(),
+  image: z51.object({
+    url: z51.string(),
+    alt: z51.string().nullable()
   }).nullable(),
-  variantOptions: z50.array(productVariantOptionDisplaySchema),
-  selectedVariantId: z50.string().nullable(),
-  selectionLabel: z50.string(),
-  actionLabel: z50.string(),
-  soldOut: z50.boolean()
-});
-var productListDisplaySchema = z50.object({
-  kind: z50.literal("product-list"),
-  state: z50.enum(["empty", "ready"]),
-  heading: z50.string().nullable(),
-  className: z50.string().nullable(),
-  layout: z50.enum(["grid", "list"]),
-  columns: z50.string(),
-  emptyMessage: z50.string(),
-  cards: z50.array(productCardDisplaySchema)
-});
-var productDetailDisplaySchema = z50.discriminatedUnion("state", [
-  z50.object({
-    kind: z50.literal("product-detail"),
-    state: z50.literal("empty"),
-    heading: z50.string().nullable(),
-    className: z50.string().nullable(),
-    emptyMessage: z50.string()
+  variantOptions: z51.array(productVariantOptionDisplaySchema),
+  selectedVariantId: z51.string().nullable(),
+  selectionLabel: z51.string(),
+  actionLabel: z51.string(),
+  soldOut: z51.boolean()
+});
+var productListDisplaySchema = z51.object({
+  kind: z51.literal("product-list"),
+  state: z51.enum(["empty", "ready"]),
+  heading: z51.string().nullable(),
+  className: z51.string().nullable(),
+  layout: z51.enum(["grid", "list"]),
+  columns: z51.string(),
+  emptyMessage: z51.string(),
+  cards: z51.array(productCardDisplaySchema)
+});
+var productDetailDisplaySchema = z51.discriminatedUnion("state", [
+  z51.object({
+    kind: z51.literal("product-detail"),
+    state: z51.literal("empty"),
+    heading: z51.string().nullable(),
+    className: z51.string().nullable(),
+    emptyMessage: z51.string()
   }),
-  z50.object({
-    kind: z50.literal("product-detail"),
-    state: z50.literal("ready"),
-    heading: z50.string().nullable(),
-    className: z50.string().nullable(),
-    title: z50.string(),
-    priceLabel: z50.string(),
-    summary: z50.string().nullable(),
-    categoryLabel: z50.string().nullable(),
-    gallery: z50.array(z50.object({
-      url: z50.string(),
-      alt: z50.string().nullable()
+  z51.object({
+    kind: z51.literal("product-detail"),
+    state: z51.literal("ready"),
+    heading: z51.string().nullable(),
+    className: z51.string().nullable(),
+    title: z51.string(),
+    priceLabel: z51.string(),
+    summary: z51.string().nullable(),
+    categoryLabel: z51.string().nullable(),
+    gallery: z51.array(z51.object({
+      url: z51.string(),
+      alt: z51.string().nullable()
     })),
-    variantOptions: z50.array(productVariantOptionDisplaySchema),
-    selectedVariantId: z50.string().nullable(),
-    selectionLabel: z50.string(),
-    actionLabel: z50.string(),
-    soldOut: z50.boolean(),
-    body: z50.unknown().nullable()
+    variantOptions: z51.array(productVariantOptionDisplaySchema),
+    selectedVariantId: z51.string().nullable(),
+    selectionLabel: z51.string(),
+    actionLabel: z51.string(),
+    soldOut: z51.boolean(),
+    body: z51.unknown().nullable()
   })
 ]);
-var passCardDisplaySchema = z50.object({
-  id: z50.string(),
-  title: z50.string(),
-  description: z50.string().nullable(),
-  priceLabel: z50.string(),
-  creditsLabel: z50.string(),
-  perCreditLabel: z50.string().nullable(),
-  validityLabel: z50.string().nullable(),
-  actionLabel: z50.string()
-});
-var membershipCardDisplaySchema = z50.object({
-  id: z50.string(),
-  title: z50.string(),
-  description: z50.string().nullable(),
-  priceLabel: z50.string(),
-  intervalLabel: z50.string(),
-  actionLabel: z50.string()
-});
-var passesMembershipsDisplaySchema = z50.object({
-  kind: z50.literal("passes-memberships"),
-  state: z50.enum(["empty", "ready"]),
-  className: z50.string().nullable(),
-  layout: z50.enum(["grid", "list"]),
-  columns: z50.string(),
-  emptyMessage: z50.string(),
-  passesHeading: z50.string(),
-  membershipsHeading: z50.string(),
-  passes: z50.array(passCardDisplaySchema),
-  memberships: z50.array(membershipCardDisplaySchema)
-});
-var cartLineDisplaySchema = z50.object({
-  key: z50.string(),
-  title: z50.string(),
-  priceLabel: z50.string(),
-  quantity: z50.number(),
-  quantityEditable: z50.boolean()
-});
-var cartDisplaySchema = z50.object({
-  kind: z50.literal("cart"),
-  state: z50.enum(["empty", "ready"]),
-  heading: z50.string().nullable(),
-  className: z50.string().nullable(),
-  emptyMessage: z50.string(),
-  supportText: z50.string().nullable(),
-  items: z50.array(cartLineDisplaySchema),
-  subtotalLabel: z50.string().nullable(),
-  checkoutButtonText: z50.string(),
-  clearButtonText: z50.string()
-});
-var checkoutDisplaySchema = z50.object({
-  kind: z50.literal("checkout"),
-  state: z50.enum(["empty", "blocked", "ready"]),
-  heading: z50.string().nullable(),
-  className: z50.string().nullable(),
-  message: z50.string().nullable(),
-  submitButtonText: z50.string()
-});
-var passesMembershipsHydrationSchema = z50.object({
-  passes: z50.array(publicPassProductSchema),
-  memberships: z50.array(publicMembershipProductSchema),
-  passPurchaseMode: z50.enum(["add_to_cart", "buy_now"])
-});
-var productListHydrationSchema = z50.object({
-  products: z50.array(publicProductSchema),
-  showSummary: z50.boolean(),
-  showPrices: z50.boolean(),
-  addButtonText: z50.string()
-});
-var productDetailHydrationSchema = z50.object({
-  products: z50.array(publicProductSchema),
-  productId: z50.string().nullable(),
-  showSummary: z50.boolean(),
-  showBody: z50.boolean(),
-  addButtonText: z50.string()
-});
-var cartHydrationSchema = z50.object({
-  emptyStateText: z50.string(),
-  checkoutButtonText: z50.string(),
-  clearButtonText: z50.string()
-});
-var checkoutHydrationSchema = z50.object({
-  emptyStateText: z50.string(),
-  submitButtonText: z50.string()
-});
-var passesMembershipsRenderSchema = z50.object({
+var passCardDisplaySchema = z51.object({
+  id: z51.string(),
+  title: z51.string(),
+  description: z51.string().nullable(),
+  priceLabel: z51.string(),
+  creditsLabel: z51.string(),
+  perCreditLabel: z51.string().nullable(),
+  validityLabel: z51.string().nullable(),
+  actionLabel: z51.string()
+});
+var membershipCardDisplaySchema = z51.object({
+  id: z51.string(),
+  title: z51.string(),
+  description: z51.string().nullable(),
+  priceLabel: z51.string(),
+  intervalLabel: z51.string(),
+  actionLabel: z51.string()
+});
+var passesMembershipsDisplaySchema = z51.object({
+  kind: z51.literal("passes-memberships"),
+  state: z51.enum(["empty", "ready"]),
+  className: z51.string().nullable(),
+  layout: z51.enum(["grid", "list"]),
+  columns: z51.string(),
+  emptyMessage: z51.string(),
+  passesHeading: z51.string(),
+  membershipsHeading: z51.string(),
+  passes: z51.array(passCardDisplaySchema),
+  memberships: z51.array(membershipCardDisplaySchema)
+});
+var cartLineDisplaySchema = z51.object({
+  key: z51.string(),
+  title: z51.string(),
+  priceLabel: z51.string(),
+  quantity: z51.number(),
+  quantityEditable: z51.boolean()
+});
+var cartDisplaySchema = z51.object({
+  kind: z51.literal("cart"),
+  state: z51.enum(["empty", "ready"]),
+  heading: z51.string().nullable(),
+  className: z51.string().nullable(),
+  emptyMessage: z51.string(),
+  supportText: z51.string().nullable(),
+  items: z51.array(cartLineDisplaySchema),
+  subtotalLabel: z51.string().nullable(),
+  checkoutButtonText: z51.string(),
+  clearButtonText: z51.string()
+});
+var checkoutDisplaySchema = z51.object({
+  kind: z51.literal("checkout"),
+  state: z51.enum(["empty", "blocked", "ready"]),
+  heading: z51.string().nullable(),
+  className: z51.string().nullable(),
+  message: z51.string().nullable(),
+  submitButtonText: z51.string()
+});
+var passesMembershipsHydrationSchema = z51.object({
+  passes: z51.array(publicPassProductSchema),
+  memberships: z51.array(publicMembershipProductSchema),
+  passPurchaseMode: z51.enum(["add_to_cart", "buy_now"])
+});
+var productListHydrationSchema = z51.object({
+  products: z51.array(publicProductSchema),
+  showSummary: z51.boolean(),
+  showPrices: z51.boolean(),
+  addButtonText: z51.string()
+});
+var productDetailHydrationSchema = z51.object({
+  products: z51.array(publicProductSchema),
+  productId: z51.string().nullable(),
+  showSummary: z51.boolean(),
+  showBody: z51.boolean(),
+  addButtonText: z51.string()
+});
+var cartHydrationSchema = z51.object({
+  emptyStateText: z51.string(),
+  checkoutButtonText: z51.string(),
+  clearButtonText: z51.string()
+});
+var checkoutHydrationSchema = z51.object({
+  emptyStateText: z51.string(),
+  submitButtonText: z51.string()
+});
+var passesMembershipsRenderSchema = z51.object({
   display: passesMembershipsDisplaySchema,
   hydration: passesMembershipsHydrationSchema
 });
-var productListRenderSchema = z50.object({
+var productListRenderSchema = z51.object({
   display: productListDisplaySchema,
   hydration: productListHydrationSchema
 });
-var productDetailRenderSchema = z50.object({
+var productDetailRenderSchema = z51.object({
   display: productDetailDisplaySchema,
   hydration: productDetailHydrationSchema
 });
-var cartRenderSchema = z50.object({
+var cartRenderSchema = z51.object({
   display: cartDisplaySchema,
   hydration: cartHydrationSchema
 });
-var checkoutRenderSchema = z50.object({
+var checkoutRenderSchema = z51.object({
   display: checkoutDisplaySchema,
   hydration: checkoutHydrationSchema
 });
 function resolveShowPricePerCredit(source) {
   return source.showPricePerCredit ?? true;
 }
-var shopIslandMetaCodec = createZodCodec(z50.object({
-  siteId: z50.string().optional(),
-  apiBaseUrl: z50.string().optional(),
+var shopIslandMetaCodec = createZodCodec(z51.object({
+  siteId: z51.string().optional(),
+  apiBaseUrl: z51.string().optional(),
   stage: previewStageSchema.optional()
 }));
 var shopIslandMetaKeys = defineInteractiveIslandMetaKeys("siteId", "apiBaseUrl", "stage");
@@ -25531,7 +25729,7 @@ var shopBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/product-list.ts
-import { z as z51 } from "zod";
+import { z as z52 } from "zod";
 var productListManifest = createBlockManifest({
   id: "block.product-list",
   version: "1.0.0",
@@ -25664,7 +25862,7 @@ var productListBlockDefinition = {
     }
   }
 };
-var productListDataSchema = z51.object({
+var productListDataSchema = z52.object({
   products: publicProductsResponseSchema.optional()
 });
 
@@ -25925,72 +26123,72 @@ var checkoutBlockDefinition = {
 };
 
 // ../blocks/src/system/runtime/nodes/gifting.interactive.ts
-import { z as z52 } from "zod";
-var publicGiftCardOfferSchema = z52.object({
-  id: z52.string(),
-  kind: z52.literal("gift_card"),
-  title: z52.string(),
-  description: z52.string().nullable(),
-  sortOrder: z52.number().int(),
-  giftCard: z52.object({
-    fixedDenominations: z52.array(z52.number().int().positive()),
-    customAmountEnabled: z52.boolean(),
-    customAmountMinCents: z52.number().int().positive(),
-    customAmountMaxCents: z52.number().int().positive()
+import { z as z53 } from "zod";
+var publicGiftCardOfferSchema = z53.object({
+  id: z53.string(),
+  kind: z53.literal("gift_card"),
+  title: z53.string(),
+  description: z53.string().nullable(),
+  sortOrder: z53.number().int(),
+  giftCard: z53.object({
+    fixedDenominations: z53.array(z53.number().int().positive()),
+    customAmountEnabled: z53.boolean(),
+    customAmountMinCents: z53.number().int().positive(),
+    customAmountMaxCents: z53.number().int().positive()
   }),
-  voucher: z52.null()
-});
-var publicVoucherOfferSchema = z52.object({
-  id: z52.string(),
-  kind: z52.literal("voucher"),
-  title: z52.string(),
-  description: z52.string().nullable(),
-  sortOrder: z52.number().int(),
-  giftCard: z52.null(),
-  voucher: z52.object({
-    purchaseAmountCents: z52.number().int().positive()
+  voucher: z53.null()
+});
+var publicVoucherOfferSchema = z53.object({
+  id: z53.string(),
+  kind: z53.literal("voucher"),
+  title: z53.string(),
+  description: z53.string().nullable(),
+  sortOrder: z53.number().int(),
+  giftCard: z53.null(),
+  voucher: z53.object({
+    purchaseAmountCents: z53.number().int().positive()
   })
 });
-var publicGiftingOffersResponseSchema = z52.object({
-  currency: z52.string(),
-  giftCards: z52.array(publicGiftCardOfferSchema),
-  vouchers: z52.array(publicVoucherOfferSchema)
+var publicGiftingOffersResponseSchema = z53.object({
+  currency: z53.string(),
+  giftCards: z53.array(publicGiftCardOfferSchema),
+  vouchers: z53.array(publicVoucherOfferSchema)
 });
-var giftingSourceSchema = z52.object({
-  siteId: z52.string().optional(),
-  apiBaseUrl: z52.string().optional(),
+var giftingSourceSchema = z53.object({
+  siteId: z53.string().optional(),
+  apiBaseUrl: z53.string().optional(),
   offers: publicGiftingOffersResponseSchema.nullable().optional(),
-  className: z52.string().nullable().optional(),
-  heading: z52.string().nullable().optional(),
-  intro: z52.string().nullable().optional(),
-  giftCardsHeading: z52.string().nullable().optional(),
-  vouchersHeading: z52.string().nullable().optional(),
-  emptyStateText: z52.string().nullable().optional(),
-  checkoutButtonText: z52.string().nullable().optional(),
-  successMessage: z52.string().nullable().optional()
-});
-var giftingDisplaySchema = z52.object({
-  kind: z52.literal("gifting"),
-  state: z52.literal("ready"),
-  className: z52.string().nullable(),
-  heading: z52.string(),
-  intro: z52.string().nullable(),
-  giftCardsHeading: z52.string(),
-  vouchersHeading: z52.string(),
-  emptyStateText: z52.string()
-});
-var giftingHydrationSchema = z52.object({
+  className: z53.string().nullable().optional(),
+  heading: z53.string().nullable().optional(),
+  intro: z53.string().nullable().optional(),
+  giftCardsHeading: z53.string().nullable().optional(),
+  vouchersHeading: z53.string().nullable().optional(),
+  emptyStateText: z53.string().nullable().optional(),
+  checkoutButtonText: z53.string().nullable().optional(),
+  successMessage: z53.string().nullable().optional()
+});
+var giftingDisplaySchema = z53.object({
+  kind: z53.literal("gifting"),
+  state: z53.literal("ready"),
+  className: z53.string().nullable(),
+  heading: z53.string(),
+  intro: z53.string().nullable(),
+  giftCardsHeading: z53.string(),
+  vouchersHeading: z53.string(),
+  emptyStateText: z53.string()
+});
+var giftingHydrationSchema = z53.object({
   offers: publicGiftingOffersResponseSchema.nullable(),
-  checkoutButtonText: z52.string(),
-  successMessage: z52.string()
+  checkoutButtonText: z53.string(),
+  successMessage: z53.string()
 });
-var giftingRenderSchema = z52.object({
+var giftingRenderSchema = z53.object({
   display: giftingDisplaySchema,
   hydration: giftingHydrationSchema
 });
-var giftingIslandMetaCodec = createZodCodec(z52.object({
-  siteId: z52.string().optional(),
-  apiBaseUrl: z52.string().optional()
+var giftingIslandMetaCodec = createZodCodec(z53.object({
+  siteId: z53.string().optional(),
+  apiBaseUrl: z53.string().optional()
 }));
 var giftingIslandMetaKeys = defineInteractiveIslandMetaKeys(
   "siteId",
@@ -26161,7 +26359,7 @@ var giftingBlockDefinition = {
 };
 
 // ../blocks/src/system/runtime/nodes/newsletter-form.interactive.ts
-import { z as z53 } from "zod";
+import { z as z54 } from "zod";
 
 // ../blocks/src/system/blocks/newsletter-signup-destination.ts
 function parseNewsletterSignupBlockId(value) {
@@ -26268,65 +26466,65 @@ function withOptionalPhone(fields3, includePhone) {
 }
 
 // ../blocks/src/system/runtime/nodes/newsletter-form.interactive.ts
-var newsletterPresetSchema = z53.enum(["emailOnly", "emailName", "emailFirstLast", "emailNameCompany"]);
-var newsletterDestinationProviderSchema = z53.enum(["riverbank", "mailchimp"]);
-var newsletterFieldSchema = z53.object({
-  id: z53.string(),
-  type: z53.enum(["email", "text"]),
-  label: z53.string(),
-  required: z53.boolean(),
-  placeholder: z53.string().optional()
-});
-var newsletterSignupBlockIdSchema = z53.string().trim().min(1).transform(parseRequiredNewsletterSignupBlockId);
-var signedNewsletterDestinationRefSchema = z53.string().trim().min(1).transform(parseRequiredSignedNewsletterDestinationRef);
-var newsletterPublicDestinationRefSchema = z53.discriminatedUnion("tag", [
-  z53.object({
-    tag: z53.literal("block_ref"),
+var newsletterPresetSchema = z54.enum(["emailOnly", "emailName", "emailFirstLast", "emailNameCompany"]);
+var newsletterDestinationProviderSchema = z54.enum(["riverbank", "mailchimp"]);
+var newsletterFieldSchema = z54.object({
+  id: z54.string(),
+  type: z54.enum(["email", "text"]),
+  label: z54.string(),
+  required: z54.boolean(),
+  placeholder: z54.string().optional()
+});
+var newsletterSignupBlockIdSchema = z54.string().trim().min(1).transform(parseRequiredNewsletterSignupBlockId);
+var signedNewsletterDestinationRefSchema = z54.string().trim().min(1).transform(parseRequiredSignedNewsletterDestinationRef);
+var newsletterPublicDestinationRefSchema = z54.discriminatedUnion("tag", [
+  z54.object({
+    tag: z54.literal("block_ref"),
     blockId: newsletterSignupBlockIdSchema
   }),
-  z53.object({
-    tag: z53.literal("signed_destination_ref"),
+  z54.object({
+    tag: z54.literal("signed_destination_ref"),
     token: signedNewsletterDestinationRefSchema
   })
 ]);
-var newsletterSourceSchema = z53.object({
-  blockId: z53.string().nullable().optional(),
-  siteId: z53.string().optional(),
-  apiBaseUrl: z53.string().optional(),
-  listId: z53.string().nullable().optional(),
+var newsletterSourceSchema = z54.object({
+  blockId: z54.string().nullable().optional(),
+  siteId: z54.string().optional(),
+  apiBaseUrl: z54.string().optional(),
+  listId: z54.string().nullable().optional(),
   destinationProvider: newsletterDestinationProviderSchema.nullable().optional(),
   preset: newsletterPresetSchema.optional(),
-  includePhone: z53.boolean().optional(),
-  buttonLabel: z53.string().nullable().optional(),
-  successMessage: z53.string().nullable().optional(),
-  privacyNote: z53.string().nullable().optional(),
-  tags: z53.string().nullable().optional(),
-  spamProtectionEnabled: z53.boolean().optional(),
-  className: z53.string().nullable().optional()
-});
-var newsletterDisplaySchema = z53.object({
-  kind: z53.literal("newsletter-form"),
-  className: z53.string().nullable(),
-  buttonLabel: z53.string(),
-  successMessage: z53.string().nullable(),
-  privacyNote: z53.string().nullable(),
-  fields: z53.array(newsletterFieldSchema)
-});
-var newsletterHydrationSchema = z53.object({
+  includePhone: z54.boolean().optional(),
+  buttonLabel: z54.string().nullable().optional(),
+  successMessage: z54.string().nullable().optional(),
+  privacyNote: z54.string().nullable().optional(),
+  tags: z54.string().nullable().optional(),
+  spamProtectionEnabled: z54.boolean().optional(),
+  className: z54.string().nullable().optional()
+});
+var newsletterDisplaySchema = z54.object({
+  kind: z54.literal("newsletter-form"),
+  className: z54.string().nullable(),
+  buttonLabel: z54.string(),
+  successMessage: z54.string().nullable(),
+  privacyNote: z54.string().nullable(),
+  fields: z54.array(newsletterFieldSchema)
+});
+var newsletterHydrationSchema = z54.object({
   destinationRef: newsletterPublicDestinationRefSchema.nullable().optional(),
-  listId: z53.string().nullable().optional(),
+  listId: z54.string().nullable().optional(),
   preset: newsletterPresetSchema,
-  includePhone: z53.boolean(),
-  tags: z53.string().nullable().optional(),
-  spamProtectionEnabled: z53.boolean().optional()
+  includePhone: z54.boolean(),
+  tags: z54.string().nullable().optional(),
+  spamProtectionEnabled: z54.boolean().optional()
 });
-var newsletterRenderSchema = z53.object({
+var newsletterRenderSchema = z54.object({
   display: newsletterDisplaySchema,
   hydration: newsletterHydrationSchema
 });
-var newsletterIslandMetaCodec = createZodCodec(z53.object({
-  siteId: z53.string().optional(),
-  apiBaseUrl: z53.string().optional()
+var newsletterIslandMetaCodec = createZodCodec(z54.object({
+  siteId: z54.string().optional(),
+  apiBaseUrl: z54.string().optional()
 }));
 var newsletterIslandMetaKeys = defineInteractiveIslandMetaKeys("siteId", "apiBaseUrl");
 function buildNewsletterDisplay(source) {
@@ -26465,23 +26663,23 @@ var newsletterSignupBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/team-members.ts
-import { z as z54 } from "zod";
+import { z as z55 } 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 = z54.object({
-  _type: z54.literal("teamMember"),
-  id: z54.string(),
-  name: z54.string(),
-  role: z54.string().nullable(),
-  roleLabel: z54.string().nullable(),
-  bio: z54.string().nullable(),
-  summary: z54.string().nullable(),
+var teamMemberDataSchema = z55.object({
+  _type: z55.literal("teamMember"),
+  id: z55.string(),
+  name: z55.string(),
+  role: z55.string().nullable(),
+  roleLabel: z55.string().nullable(),
+  bio: z55.string().nullable(),
+  summary: z55.string().nullable(),
   photo: teamMemberPhotoSchema,
-  profilePath: z54.string().nullable()
+  profilePath: z55.string().nullable()
 });
-var teamMembersDataSchema = z54.array(teamMemberDataSchema);
+var teamMembersDataSchema = z55.array(teamMemberDataSchema);
 var dynamicSourceWhen = { equals: "site_staff" };
 var manualSourceWhen = { equals: "site_staff", not: true };
 var headingNode = text(
@@ -27587,6 +27785,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" })]
@@ -28532,34 +28734,34 @@ import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
 var MAX_FONT_UPLOAD_BYTES = 5 * 1024 * 1024;
 
 // ../theme-core/src/runtime/buildThemeRuntimeFromBridge.ts
-import { z as z55 } from "zod";
-var themeBridgeConfigSchema = z55.object({
-  tokens: z55.record(z55.string(), z55.string()),
-  typography: z55.object({
-    headingFamily: z55.string().optional(),
-    bodyFamily: z55.string().optional(),
-    headingWeight: z55.number().optional(),
-    bodyWeight: z55.number().optional()
+import { z as z56 } from "zod";
+var themeBridgeConfigSchema = z56.object({
+  tokens: z56.record(z56.string(), z56.string()),
+  typography: z56.object({
+    headingFamily: z56.string().optional(),
+    bodyFamily: z56.string().optional(),
+    headingWeight: z56.number().optional(),
+    bodyWeight: z56.number().optional()
   }).optional(),
-  spacing: z55.enum(["comfortable", "standard", "dense"]).optional(),
-  corners: z55.enum(["square", "soft", "rounded", "pill"]).optional(),
-  shadows: z55.enum(["none", "low", "medium", "high"]).optional(),
-  components: z55.object({
-    buttons: z55.union([
-      z55.boolean(),
-      z55.object({
-        variants: z55.array(z55.enum(["primary", "secondary", "outline", "ghost"])).optional()
+  spacing: z56.enum(["comfortable", "standard", "dense"]).optional(),
+  corners: z56.enum(["square", "soft", "rounded", "pill"]).optional(),
+  shadows: z56.enum(["none", "low", "medium", "high"]).optional(),
+  components: z56.object({
+    buttons: z56.union([
+      z56.boolean(),
+      z56.object({
+        variants: z56.array(z56.enum(["primary", "secondary", "outline", "ghost"])).optional()
       })
     ]).optional(),
-    cards: z55.union([
-      z55.boolean(),
-      z55.object({
-        variants: z55.array(z55.enum(["default", "elevated", "outlined"])).optional()
+    cards: z56.union([
+      z56.boolean(),
+      z56.object({
+        variants: z56.array(z56.enum(["default", "elevated", "outlined"])).optional()
       })
     ]).optional(),
-    inputs: z55.boolean().optional()
+    inputs: z56.boolean().optional()
   }).optional(),
-  overrides: z55.record(z55.string(), z55.string()).optional()
+  overrides: z56.record(z56.string(), z56.string()).optional()
 }).passthrough();
 
 // ../theme-core/src/siteChrome.tsx
@@ -28768,11 +28970,11 @@ function resolveModelForPass(passId, tierOverrides, passOverrides, globalModel)
 }
 
 // src/page-converter/passes/pass1-segmentation-matching.ts
-import { z as z60 } from "zod";
+import { z as z61 } from "zod";
 
 // src/manifest/passes/pass1-fields.ts
-import { z as z56 } from "zod";
-var simpleFieldTypeEnum = z56.enum([
+import { z as z57 } from "zod";
+var simpleFieldTypeEnum = z57.enum([
   "text",
   "richText",
   "media",
@@ -28781,7 +28983,7 @@ var simpleFieldTypeEnum = z56.enum([
   "select",
   "number"
 ]);
-var fieldTypeEnum = z56.enum([
+var fieldTypeEnum = z57.enum([
   "text",
   "richText",
   "media",
@@ -28792,109 +28994,109 @@ var fieldTypeEnum = z56.enum([
   "repeater",
   "group"
 ]);
-var linkDefaultValue = z56.object({
-  label: z56.string().describe("The visible link text")
+var linkDefaultValue = z57.object({
+  label: z57.string().describe("The visible link text")
 });
-var mediaDefaultValue = z56.object({
-  src: z56.string().describe("Image/video source URL"),
-  alt: z56.string().describe("Alt text for accessibility (empty string if none)")
+var mediaDefaultValue = z57.object({
+  src: z57.string().describe("Image/video source URL"),
+  alt: z57.string().describe("Alt text for accessibility (empty string if none)")
 });
-var nestedFieldSchema = z56.object({
-  id: z56.string().min(1).describe("camelCase field ID"),
+var nestedFieldSchema = z57.object({
+  id: z57.string().min(1).describe("camelCase field ID"),
   type: simpleFieldTypeEnum,
-  label: z56.string().min(1),
-  required: z56.boolean().nullable()
+  label: z57.string().min(1),
+  required: z57.boolean().nullable()
 });
-var simpleFieldSchema = z56.object({
-  id: z56.string().min(1).describe("camelCase field ID (e.g., headline, ctaButton)"),
+var simpleFieldSchema = z57.object({
+  id: z57.string().min(1).describe("camelCase field ID (e.g., headline, ctaButton)"),
   type: simpleFieldTypeEnum,
-  label: z56.string().min(1),
-  required: z56.boolean(),
-  multiline: z56.boolean().nullable().describe("For text fields: true if multiple lines"),
-  defaultValue: z56.union([
-    z56.string(),
-    z56.number(),
-    z56.boolean(),
+  label: z57.string().min(1),
+  required: z57.boolean(),
+  multiline: z57.boolean().nullable().describe("For text fields: true if multiple lines"),
+  defaultValue: z57.union([
+    z57.string(),
+    z57.number(),
+    z57.boolean(),
     linkDefaultValue,
     mediaDefaultValue,
-    z56.null()
+    z57.null()
   ]).describe("Default content extracted from HTML"),
-  htmlContext: z56.string().describe("Brief description of where this appears in the HTML")
-});
-var repeaterFieldSchema2 = z56.object({
-  id: z56.string().min(1).describe("camelCase field ID (e.g., socialLinks, features)"),
-  type: z56.literal("repeater"),
-  label: z56.string().min(1),
-  required: z56.boolean(),
-  itemLabel: z56.string().min(1).describe('Singular label for each item (e.g., "Link", "Feature")'),
-  itemFields: z56.array(nestedFieldSchema).min(1).describe("Fields for each item in the repeater"),
-  htmlContext: z56.string().describe("Brief description of where this appears in the HTML")
-});
-var groupFieldSchema2 = z56.object({
-  id: z56.string().min(1).describe("camelCase field ID (e.g., contactInfo, seoSettings)"),
-  type: z56.literal("group"),
-  label: z56.string().min(1),
-  required: z56.boolean(),
-  groupFields: z56.array(nestedFieldSchema).min(1).describe("Fields within the group"),
-  htmlContext: z56.string().describe("Brief description of where this appears in the HTML")
-});
-var extractedFieldSchema = z56.union([
+  htmlContext: z57.string().describe("Brief description of where this appears in the HTML")
+});
+var repeaterFieldSchema2 = z57.object({
+  id: z57.string().min(1).describe("camelCase field ID (e.g., socialLinks, features)"),
+  type: z57.literal("repeater"),
+  label: z57.string().min(1),
+  required: z57.boolean(),
+  itemLabel: z57.string().min(1).describe('Singular label for each item (e.g., "Link", "Feature")'),
+  itemFields: z57.array(nestedFieldSchema).min(1).describe("Fields for each item in the repeater"),
+  htmlContext: z57.string().describe("Brief description of where this appears in the HTML")
+});
+var groupFieldSchema2 = z57.object({
+  id: z57.string().min(1).describe("camelCase field ID (e.g., contactInfo, seoSettings)"),
+  type: z57.literal("group"),
+  label: z57.string().min(1),
+  required: z57.boolean(),
+  groupFields: z57.array(nestedFieldSchema).min(1).describe("Fields within the group"),
+  htmlContext: z57.string().describe("Brief description of where this appears in the HTML")
+});
+var extractedFieldSchema = z57.union([
   simpleFieldSchema,
   repeaterFieldSchema2,
   groupFieldSchema2
 ]);
-var extractedEntrySchema = z56.object({
-  identifier: z56.string().regex(/^[a-z0-9-]+$/).describe("Unique slug-safe identifier (e.g., wine-tasting-evening)"),
-  title: z56.string().min(1).describe("Entry title"),
+var extractedEntrySchema = z57.object({
+  identifier: z57.string().regex(/^[a-z0-9-]+$/).describe("Unique slug-safe identifier (e.g., wine-tasting-evening)"),
+  title: z57.string().min(1).describe("Entry title"),
   // Use passthrough() instead of record() - generates additionalProperties:true without propertyNames
   // which OpenAI's structured output accepts
-  data: z56.object({}).passthrough().describe("Entry data matching the content type schema")
-});
-var newContentTypeSchema = z56.object({
-  key: z56.string().regex(/^[a-z][a-z0-9-]*$/).describe("Content type key (e.g., testimonial, team-member)"),
-  name: z56.string().min(1).describe("Human-readable name"),
-  description: z56.string().nullable().describe("Description of this content type"),
-  fields: z56.array(z56.object({
-    id: z56.string().min(1),
-    type: z56.string().min(1),
-    label: z56.string().min(1),
-    required: z56.boolean().nullable(),
-    description: z56.string().nullable()
+  data: z57.object({}).passthrough().describe("Entry data matching the content type schema")
+});
+var newContentTypeSchema = z57.object({
+  key: z57.string().regex(/^[a-z][a-z0-9-]*$/).describe("Content type key (e.g., testimonial, team-member)"),
+  name: z57.string().min(1).describe("Human-readable name"),
+  description: z57.string().nullable().describe("Description of this content type"),
+  fields: z57.array(z57.object({
+    id: z57.string().min(1),
+    type: z57.string().min(1),
+    label: z57.string().min(1),
+    required: z57.boolean().nullable(),
+    description: z57.string().nullable()
   })).min(1),
-  isRouted: z56.boolean().describe("Whether entries have their own pages")
+  isRouted: z57.boolean().describe("Whether entries have their own pages")
 });
-var contentTypeApproachSchema = z56.discriminatedUnion("approach", [
+var contentTypeApproachSchema = z57.discriminatedUnion("approach", [
   // Use an existing content type
-  z56.object({
-    approach: z56.literal("existingContentType"),
-    contentTypeKey: z56.string().min(1).describe("Key of the existing content type to use"),
-    entries: z56.array(extractedEntrySchema).min(1).describe("Extracted entries"),
-    rationale: z56.string().describe("Why this content type fits")
+  z57.object({
+    approach: z57.literal("existingContentType"),
+    contentTypeKey: z57.string().min(1).describe("Key of the existing content type to use"),
+    entries: z57.array(extractedEntrySchema).min(1).describe("Extracted entries"),
+    rationale: z57.string().describe("Why this content type fits")
   }),
   // Create a new content type
-  z56.object({
-    approach: z56.literal("newContentType"),
+  z57.object({
+    approach: z57.literal("newContentType"),
     contentType: newContentTypeSchema,
-    entries: z56.array(extractedEntrySchema).min(1).describe("Extracted entries"),
-    rationale: z56.string().describe("Why a new content type is needed")
+    entries: z57.array(extractedEntrySchema).min(1).describe("Extracted entries"),
+    rationale: z57.string().describe("Why a new content type is needed")
   }),
   // Use repeater field (page-specific data)
-  z56.object({
-    approach: z56.literal("repeater"),
-    rationale: z56.string().describe("Why repeater is preferred over content type")
+  z57.object({
+    approach: z57.literal("repeater"),
+    rationale: z57.string().describe("Why repeater is preferred over content type")
   }),
   // No list data - standard field extraction
-  z56.object({
-    approach: z56.literal("none"),
-    rationale: z56.string().describe("Why this is not list data")
+  z57.object({
+    approach: z57.literal("none"),
+    rationale: z57.string().describe("Why this is not list data")
   })
 ]);
-var pass1OutputSchema = z56.object({
-  blockId: z56.string().regex(/^custom\.[a-z][a-z0-9-]*$/).describe("Block ID like custom.hero-section"),
-  blockTitle: z56.string().min(1),
-  blockDescription: z56.string().nullable(),
-  category: z56.enum(["marketing", "content", "blog", "media", "layout", "interactive"]),
-  fields: z56.array(extractedFieldSchema).min(1),
+var pass1OutputSchema = z57.object({
+  blockId: z57.string().regex(/^custom\.[a-z][a-z0-9-]*$/).describe("Block ID like custom.hero-section"),
+  blockTitle: z57.string().min(1),
+  blockDescription: z57.string().nullable(),
+  category: z57.enum(["marketing", "content", "blog", "media", "layout", "interactive"]),
+  fields: z57.array(extractedFieldSchema).min(1),
   /**
    * Content type decision for list-like content.
    * When content types are available, the LLM may decide to use content entries
@@ -29137,10 +29339,10 @@ async function getJsonFromAiText(ai, config, userMessage, schema) {
 }
 
 // src/manifest/passes/pass3-styling.ts
-import { z as z59 } from "zod";
+import { z as z60 } from "zod";
 
 // src/manifest/validation/output-schema.ts
-import { z as z58 } from "zod";
+import { z as z59 } from "zod";
 
 // src/manifest/validation/layout-utils.ts
 function collectLayoutNodeInfos(node, path2 = "layout", out = []) {
@@ -29181,14 +29383,14 @@ function collectLayoutClassNames(node, out = /* @__PURE__ */ new Set()) {
 }
 
 // src/zod/titleSourceSchema.ts
-import { z as z57 } from "zod";
-var titleSourceValueSchema = z57.union([
-  z57.string().min(1),
-  z57.array(z57.string().min(1)).min(1)
+import { z as z58 } from "zod";
+var titleSourceValueSchema = z58.union([
+  z58.string().min(1),
+  z58.array(z58.string().min(1)).min(1)
 ]);
 
 // src/manifest/validation/output-schema.ts
-var blockCategoryEnum2 = z58.enum([
+var blockCategoryEnum2 = z59.enum([
   "marketing",
   "content",
   "blog",
@@ -29196,53 +29398,53 @@ var blockCategoryEnum2 = z58.enum([
   "layout",
   "interactive"
 ]);
-var llmColorValue = z58.object({
-  name: z58.string(),
-  hex: z58.string()
-});
-var llmThemePrimitive = z58.union([
-  z58.string(),
-  z58.number(),
-  z58.boolean(),
-  z58.null()
+var llmColorValue = z59.object({
+  name: z59.string(),
+  hex: z59.string()
+});
+var llmThemePrimitive = z59.union([
+  z59.string(),
+  z59.number(),
+  z59.boolean(),
+  z59.null()
 ]);
-var llmThemePatchValue = z58.union([
+var llmThemePatchValue = z59.union([
   llmThemePrimitive,
   llmColorValue,
-  z58.array(llmColorValue),
-  z58.array(llmThemePrimitive)
+  z59.array(llmColorValue),
+  z59.array(llmThemePrimitive)
 ]);
-var llmThemePatchOpSchema = z58.discriminatedUnion("op", [
-  z58.object({
-    op: z58.literal("add"),
-    path: z58.string().min(1),
+var llmThemePatchOpSchema = z59.discriminatedUnion("op", [
+  z59.object({
+    op: z59.literal("add"),
+    path: z59.string().min(1),
     value: llmThemePatchValue
   }),
-  z58.object({
-    op: z58.literal("replace"),
-    path: z58.string().min(1),
+  z59.object({
+    op: z59.literal("replace"),
+    path: z59.string().min(1),
     value: llmThemePatchValue
   }),
-  z58.object({ op: z58.literal("remove"), path: z58.string().min(1) })
+  z59.object({ op: z59.literal("remove"), path: z59.string().min(1) })
 ]);
-var llmCssDeclaration = z58.object({
-  property: z58.string(),
-  value: z58.string()
+var llmCssDeclaration = z59.object({
+  property: z59.string(),
+  value: z59.string()
 });
-var llmCustomCssRuleSchema = z58.object({
-  id: z58.string().min(1),
-  selector: z58.string().min(1),
-  declarations: z58.array(llmCssDeclaration)
+var llmCustomCssRuleSchema = z59.object({
+  id: z59.string().min(1),
+  selector: z59.string().min(1),
+  declarations: z59.array(llmCssDeclaration)
 });
-var llmNestedRuleSchema = z58.object({
-  selector: z58.string().min(1),
-  declarations: z58.array(llmCssDeclaration)
+var llmNestedRuleSchema = z59.object({
+  selector: z59.string().min(1),
+  declarations: z59.array(llmCssDeclaration)
 });
-var llmMediaAtRuleSchema = z58.object({
-  id: z58.string().min(1),
-  type: z58.literal("media"),
-  query: z58.string().min(1),
-  rules: z58.array(llmNestedRuleSchema)
+var llmMediaAtRuleSchema = z59.object({
+  id: z59.string().min(1),
+  type: z59.literal("media"),
+  query: z59.string().min(1),
+  rules: z59.array(llmNestedRuleSchema)
 });
 function normalizeDeclarationsArrayToRecord(declarations) {
   const record = {};
@@ -29272,85 +29474,85 @@ function normalizeLlmMediaAtRule(atRule) {
     rules: atRule.rules.map(normalizeLlmNestedRule)
   };
 }
-var jsonPrimitiveSchema = z58.union([
-  z58.string(),
-  z58.number(),
-  z58.boolean(),
-  z58.null()
+var jsonPrimitiveSchema = z59.union([
+  z59.string(),
+  z59.number(),
+  z59.boolean(),
+  z59.null()
 ]);
-var jsonValueSchema = z58.union([
+var jsonValueSchema = z59.union([
   jsonPrimitiveSchema,
-  z58.array(jsonPrimitiveSchema)
+  z59.array(jsonPrimitiveSchema)
 ]);
-var llmBaseFieldSchema = z58.object({
-  id: z58.string().min(1),
-  label: z58.string().min(1),
-  description: z58.string().nullable(),
-  required: z58.boolean(),
+var llmBaseFieldSchema = z59.object({
+  id: z59.string().min(1),
+  label: z59.string().min(1),
+  description: z59.string().nullable(),
+  required: z59.boolean(),
   defaultValue: jsonValueSchema.nullable()
 });
 var llmTextFieldSchema = llmBaseFieldSchema.extend({
-  type: z58.literal("text"),
-  multiline: z58.boolean(),
-  maxLength: z58.number().int().positive().nullable()
+  type: z59.literal("text"),
+  multiline: z59.boolean(),
+  maxLength: z59.number().int().positive().nullable()
 });
 var llmRichTextFieldSchema = llmBaseFieldSchema.extend({
-  type: z58.literal("richText")
+  type: z59.literal("richText")
 });
 var llmMediaFieldSchema = llmBaseFieldSchema.extend({
-  type: z58.literal("media"),
-  mediaKinds: z58.array(z58.enum(["image", "video", "audio"])).nullable()
+  type: z59.literal("media"),
+  mediaKinds: z59.array(z59.enum(["image", "video", "audio"])).nullable()
 });
 var llmFileFieldSchema = llmBaseFieldSchema.extend({
-  type: z58.literal("file"),
-  fileKinds: z58.array(z58.enum(["document", "spreadsheet", "archive", "audio"])).nullable()
+  type: z59.literal("file"),
+  fileKinds: z59.array(z59.enum(["document", "spreadsheet", "archive", "audio"])).nullable()
 });
 var llmBooleanFieldSchema = llmBaseFieldSchema.extend({
-  type: z58.literal("boolean")
+  type: z59.literal("boolean")
 });
 var llmLinkFieldSchema = llmBaseFieldSchema.extend({
-  type: z58.literal("link")
+  type: z59.literal("link")
 });
 var llmSelectFieldSchema = llmBaseFieldSchema.extend({
-  type: z58.literal("select"),
-  options: z58.array(
-    z58.object({
-      value: z58.string(),
-      label: z58.string()
+  type: z59.literal("select"),
+  options: z59.array(
+    z59.object({
+      value: z59.string(),
+      label: z59.string()
     })
   ),
-  multiple: z58.boolean().nullable()
+  multiple: z59.boolean().nullable()
 });
 var llmNumberFieldSchema = llmBaseFieldSchema.extend({
-  type: z58.literal("number")
-});
-var llmNestedFieldSchema = z58.object({
-  id: z58.string(),
-  type: z58.string(),
-  label: z58.string(),
-  required: z58.boolean().nullable(),
-  multiline: z58.boolean().nullable(),
+  type: z59.literal("number")
+});
+var llmNestedFieldSchema = z59.object({
+  id: z59.string(),
+  type: z59.string(),
+  label: z59.string(),
+  required: z59.boolean().nullable(),
+  multiline: z59.boolean().nullable(),
   defaultValue: jsonValueSchema.nullable()
 }).passthrough();
-var llmNestedFieldsSchema = z58.array(llmNestedFieldSchema);
+var llmNestedFieldsSchema = z59.array(llmNestedFieldSchema);
 var llmGroupFieldSchema = llmBaseFieldSchema.extend({
-  type: z58.literal("group"),
-  schema: z58.object({
+  type: z59.literal("group"),
+  schema: z59.object({
     fields: llmNestedFieldsSchema
   })
 });
 var llmRepeaterFieldSchema = llmBaseFieldSchema.extend({
-  type: z58.literal("repeater"),
-  itemLabel: z58.string(),
-  itemLabelSource: z58.string().nullable(),
-  minItems: z58.number().int().min(0),
-  maxItems: z58.number().int().positive().nullable(),
-  allowConversion: z58.boolean(),
-  schema: z58.object({
+  type: z59.literal("repeater"),
+  itemLabel: z59.string(),
+  itemLabelSource: z59.string().nullable(),
+  minItems: z59.number().int().min(0),
+  maxItems: z59.number().int().positive().nullable(),
+  allowConversion: z59.boolean(),
+  schema: z59.object({
     fields: llmNestedFieldsSchema
   })
 });
-var llmFieldSchema = z58.union([
+var llmFieldSchema = z59.union([
   llmTextFieldSchema,
   llmRichTextFieldSchema,
   llmMediaFieldSchema,
@@ -29362,66 +29564,66 @@ var llmFieldSchema = z58.union([
   llmGroupFieldSchema,
   llmRepeaterFieldSchema
 ]);
-var llmBindingSchema = z58.object({
-  from: z58.string(),
-  fallback: z58.string().nullable(),
-  transforms: z58.array(
-    z58.object({
-      id: z58.string()
+var llmBindingSchema = z59.object({
+  from: z59.string(),
+  fallback: z59.string().nullable(),
+  transforms: z59.array(
+    z59.object({
+      id: z59.string()
     })
   ).nullable()
 });
-var llmRepeatSchema = z58.object({
-  collection: z58.object({ from: z58.string() }),
-  itemName: z58.string()
+var llmRepeatSchema = z59.object({
+  collection: z59.object({ from: z59.string() }),
+  itemName: z59.string()
 });
-var llmPropsSchema = z58.object({}).passthrough().nullable();
+var llmPropsSchema = z59.object({}).passthrough().nullable();
 function buildLlmNodeSchema(maxDepth) {
-  const nodeBase = z58.object({
-    type: z58.string(),
+  const nodeBase = z59.object({
+    type: z59.string(),
     props: llmPropsSchema,
     $bind: llmBindingSchema.nullable(),
     $repeat: llmRepeatSchema.nullable(),
-    $when: z58.object({
-      condition: z58.object({ from: z58.string() })
+    $when: z59.object({
+      condition: z59.object({ from: z59.string() })
     }).nullable()
   });
-  let schema = nodeBase.extend({ children: z58.null() });
+  let schema = nodeBase.extend({ children: z59.null() });
   for (let i = 0; i < maxDepth; i++) {
-    schema = nodeBase.extend({ children: z58.array(schema).nullable() });
+    schema = nodeBase.extend({ children: z59.array(schema).nullable() });
   }
   return schema;
 }
 var MAX_LAYOUT_DEPTH = 6;
 var llmNodeSchema = buildLlmNodeSchema(MAX_LAYOUT_DEPTH);
-var llmCustomBlockSchema = z58.object({
-  id: z58.string().min(8).regex(/^custom\.[a-z][a-z0-9-]*$/, {
+var llmCustomBlockSchema = z59.object({
+  id: z59.string().min(8).regex(/^custom\.[a-z][a-z0-9-]*$/, {
     message: "Block ID must start with 'custom.' followed by lowercase letters, numbers, or hyphens"
   }),
-  title: z58.string().min(1, "Title is required"),
+  title: z59.string().min(1, "Title is required"),
   // Keep in sync with `sdkCustomBlockSchema` and the system manifest schema:
   // - `null` used by OpenAI structured output for "optional" values
   // - array allows multi-part titles (e.g. ["navLabel", "title"])
   titleSource: titleSourceValueSchema.nullable(),
-  description: z58.string().nullable(),
+  description: z59.string().nullable(),
   category: blockCategoryEnum2,
-  icon: z58.string().nullable(),
-  tags: z58.array(z58.string()).nullable(),
+  icon: z59.string().nullable(),
+  tags: z59.array(z59.string()).nullable(),
   // Use LLM-specific field schema (no z.any() for OpenAI compatibility)
   fields: llmFieldSchema.array().min(1, "Custom blocks must have at least one field"),
   // Use LLM-specific node schema (no z.any() for OpenAI compatibility)
   layout: llmNodeSchema
 });
-var htmlToManifestOutputSchema = z58.object({
-  blocks: z58.array(llmCustomBlockSchema).min(1, "At least one block is required").max(10, "Maximum 10 blocks per conversion"),
-  themePatch: z58.array(llmThemePatchOpSchema).nullable(),
-  customCssRules: z58.array(llmCustomCssRuleSchema).nullable(),
-  customCssAtRules: z58.array(llmMediaAtRuleSchema).nullable(),
+var htmlToManifestOutputSchema = z59.object({
+  blocks: z59.array(llmCustomBlockSchema).min(1, "At least one block is required").max(10, "Maximum 10 blocks per conversion"),
+  themePatch: z59.array(llmThemePatchOpSchema).nullable(),
+  customCssRules: z59.array(llmCustomCssRuleSchema).nullable(),
+  customCssAtRules: z59.array(llmMediaAtRuleSchema).nullable(),
   /**
    * Explanation of fixes made when retrying after validation errors.
    * Should explain what changes were made and why.
    */
-  fixRationale: z58.string().nullable()
+  fixRationale: z59.string().nullable()
 });
 function collectValidationErrors(output) {
   const errors = [];
@@ -30384,20 +30586,20 @@ function formatValidationFeedback(errors, output) {
 }
 
 // src/manifest/passes/pass3-styling.ts
-var pass3aOutputSchema = z59.object({
-  classNamePatches: z59.array(
-    z59.object({
-      nodePath: z59.string(),
+var pass3aOutputSchema = z60.object({
+  classNamePatches: z60.array(
+    z60.object({
+      nodePath: z60.string(),
       // "" for root, "children[0]", "children[0].children[1]" etc.
-      className: z59.string().min(1)
+      className: z60.string().min(1)
     })
   ),
-  rationale: z59.string()
+  rationale: z60.string()
 });
-var pass3bOutputSchema = z59.object({
-  customCssRules: z59.array(llmCustomCssRuleSchema).nullable(),
-  customCssAtRules: z59.array(llmMediaAtRuleSchema).nullable(),
-  rationale: z59.string()
+var pass3bOutputSchema = z60.object({
+  customCssRules: z60.array(llmCustomCssRuleSchema).nullable(),
+  customCssAtRules: z60.array(llmMediaAtRuleSchema).nullable(),
+  rationale: z60.string()
 });
 function getNodeAtPath(layout, path2) {
   if (path2 === "" || path2 === "root" || path2 === "layout") {
@@ -30704,38 +30906,38 @@ Do NOT include [data-block=...] in selectors - we add that automatically.
 
 // src/page-converter/passes/pass1-segmentation-matching.ts
 var SIZE_WARNING_BYTES = 100 * 1024;
-var sectionTypeEnum = z60.enum(["header", "content", "footer"]);
-var blockCategoryEnum3 = z60.enum(["marketing", "content", "blog", "media", "layout", "interactive"]);
-var baseSectionSchema = z60.object({
-  html: z60.string().min(1),
-  purpose: z60.string().min(1),
+var sectionTypeEnum = z61.enum(["header", "content", "footer"]);
+var blockCategoryEnum3 = z61.enum(["marketing", "content", "blog", "media", "layout", "interactive"]);
+var baseSectionSchema = z61.object({
+  html: z61.string().min(1),
+  purpose: z61.string().min(1),
   sectionType: sectionTypeEnum
 });
 var builtinMatchSchema = baseSectionSchema.extend({
-  decision: z60.literal("builtin"),
-  matchedBlock: z60.string().min(1),
-  matchScore: z60.number().min(0).max(100),
-  matchRationale: z60.string().min(1)
+  decision: z61.literal("builtin"),
+  matchedBlock: z61.string().min(1),
+  matchScore: z61.number().min(0).max(100),
+  matchRationale: z61.string().min(1)
 });
 var customMatchSchema = baseSectionSchema.extend({
-  decision: z60.literal("custom"),
-  customBlockSuggestion: z60.object({
-    title: z60.string().min(1),
+  decision: z61.literal("custom"),
+  customBlockSuggestion: z61.object({
+    title: z61.string().min(1),
     category: blockCategoryEnum3
   })
 });
-var sectionMatchSchema = z60.discriminatedUnion("decision", [
+var sectionMatchSchema = z61.discriminatedUnion("decision", [
   builtinMatchSchema,
   customMatchSchema
 ]);
-var skippedContentSchema = z60.object({
-  description: z60.string(),
-  reason: z60.string()
+var skippedContentSchema = z61.object({
+  description: z61.string(),
+  reason: z61.string()
 });
-var combinedPassSchema = z60.object({
-  sections: z60.array(sectionMatchSchema).min(1),
-  skippedContent: z60.array(skippedContentSchema).nullable(),
-  rationale: z60.string()
+var combinedPassSchema = z61.object({
+  sections: z61.array(sectionMatchSchema).min(1),
+  skippedContent: z61.array(skippedContentSchema).nullable(),
+  rationale: z61.string()
 });
 function buildSystemPrompt(availableBlocks, matchThreshold) {
   const blockCatalog = availableBlocks.map((b) => {
@@ -30942,10 +31144,10 @@ async function segmentAndMatchBlocks(html, availableBlocks, ctx) {
 }
 
 // src/page-converter/passes/pass2-population.ts
-import { z as z62 } from "zod";
+import { z as z63 } from "zod";
 
 // src/manifest/three-pass-converter.ts
-import { z as z61 } from "zod";
+import { z as z62 } from "zod";
 
 // src/manifest/prompt/theme-summary.ts
 var WEIGHT_MAP = {
@@ -31246,9 +31448,9 @@ function mapPass1FieldToOutputField(field) {
     maxLength: null
   };
 }
-var pass2OutputSchema = z61.object({
+var pass2OutputSchema = z62.object({
   layout: llmNodeSchema,
-  rationale: z61.string().describe("Explain which node binds to which field")
+  rationale: z62.string().describe("Explain which node binds to which field")
 });
 function buildPass2SystemPrompt(fields3, contentTypeApproach) {
   const fieldList = fields3.map((f) => {
@@ -32108,9 +32310,9 @@ async function convertHtmlToManifest(input, options) {
 }
 
 // src/page-converter/passes/pass2-population.ts
-var builtinContentSchema = z62.object({
-  content: z62.unknown(),
-  rationale: z62.string()
+var builtinContentSchema = z63.object({
+  content: z63.unknown(),
+  rationale: z63.string()
 });
 var SECTION_STYLES_ALLOWED_KEYS = /* @__PURE__ */ new Set(["background", "spacing"]);
 var BOX_STYLES_ALLOWED_KEYS = /* @__PURE__ */ new Set(["background", "spacing", "raised", "rounded", "border", "fullWidth"]);