@riverbankcms/sdk 0.85.0 → 0.88.0

package/dist/server/page-converter.mjs

@@ -56,6 +56,43 @@ function err(error) {
   return { ok: false, error };
 }
 
+// ../core/src/currency-format.ts
+var CURRENCY_LOCALE_BY_CODE = {
+  USD: "en-US",
+  GBP: "en-GB",
+  EUR: "de-DE",
+  AUD: "en-AU",
+  CAD: "en-CA",
+  NZD: "en-NZ",
+  JPY: "ja-JP",
+  CNY: "zh-CN",
+  CHF: "de-CH"
+};
+function resolveCurrencyLocale(currencyCode, override) {
+  return override ?? CURRENCY_LOCALE_BY_CODE[currencyCode] ?? "en";
+}
+function formatCurrencyAmount(amountCents, currency, options) {
+  const currencyCode = currency.toUpperCase();
+  const locale = resolveCurrencyLocale(currencyCode, options?.locale);
+  try {
+    const exactFormatter = new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency: currencyCode
+    });
+    const fractionDigits = options?.decimals === "auto" ? {
+      minimumFractionDigits: 0,
+      maximumFractionDigits: exactFormatter.resolvedOptions().maximumFractionDigits
+    } : {};
+    return new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency: currencyCode,
+      ...fractionDigits
+    }).format(amountCents / 100);
+  } catch {
+    return `${(amountCents / 100).toFixed(2)} ${currencyCode}`;
+  }
+}
+
 // ../core/src/event-pricing.ts
 function publicEventPricingType(pricing) {
   switch (pricing.kind) {
@@ -76,6 +113,7 @@ function isFreePublicEventPriceDisplay(display) {
       return display.display.kind === "free";
     case "exact":
     case "from":
+    case "range":
     case "mixed":
     case "unavailable":
       return false;
@@ -14528,15 +14566,53 @@ var newsletterFormFragment = defineFragment({
   title: "Newsletter Form",
   description: "Newsletter subscription form with preset field configurations.",
   fields: [
+    {
+      id: "destinationProvider",
+      type: "select",
+      label: "Send signups to",
+      description: "Choose where new subscribers from this form should go.",
+      defaultValue: "riverbank",
+      required: true,
+      ui: { intent: "behavior" },
+      options: [
+        { value: "riverbank", label: "Riverbank newsletter" }
+      ]
+    },
     {
       id: "listId",
       type: "reference",
       label: "Newsletter list",
       description: "Select the list new subscribers should be added to.",
-      required: true,
+      required: false,
       referenceKind: "newsletterList",
       allowManualEntry: false,
-      ui: { intent: "behavior" }
+      ui: {
+        intent: "behavior",
+        visibleWhen: { field: "destinationProvider", equals: "riverbank" }
+      }
+    },
+    {
+      id: "mailchimpAudienceId",
+      type: "reference",
+      label: "Mailchimp audience",
+      description: "Choose the Mailchimp audience for new subscribers.",
+      required: false,
+      referenceKind: "mailchimpAudience",
+      allowManualEntry: false,
+      ui: {
+        intent: "behavior",
+        visibleWhen: { field: "destinationProvider", equals: "mailchimp" }
+      }
+    },
+    {
+      id: "mailchimpTags",
+      type: "text",
+      label: "Mailchimp tags",
+      description: "Optional tags to apply in Mailchimp, separated by commas or semicolons.",
+      ui: {
+        intent: "behavior",
+        visibleWhen: { field: "destinationProvider", equals: "mailchimp" }
+      }
     },
     {
       id: "preset",
@@ -14583,13 +14659,18 @@ var newsletterFormFragment = defineFragment({
       id: "tags",
       type: "text",
       label: "Tags (optional)",
-      description: "Optional tags to apply on subscribe (comma or semicolon separated)."
+      description: "Optional tags to apply on subscribe (comma or semicolon separated).",
+      ui: {
+        intent: "behavior",
+        visibleWhen: { field: "destinationProvider", equals: "riverbank" }
+      }
     }
   ],
   layout: [
     el(
       "newsletter-form",
       withApiBindings({
+        destinationProvider: { $bind: { from: "destinationProvider" } },
         listId: { $bind: { from: "listId" } },
         preset: { $bind: { from: "preset" } },
         includePhone: { $bind: { from: "includePhone" } },
@@ -18969,10 +19050,10 @@ var appointmentBookingBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/event-registration.ts
-import { z as z39 } from "zod";
+import { z as z40 } from "zod";
 
 // ../blocks/src/system/blocks/events/shared/schemas.ts
-import { z as z35 } from "zod";
+import { z as z36 } from "zod";
 
 // ../blocks/src/lib/media.ts
 import z32 from "zod";
@@ -19050,296 +19131,386 @@ var mediaSchema2 = z32.discriminatedUnion("type", [
   archiveMediaSchema
 ]);
 
-// ../blocks/src/system/blocks/shared/bookingPaymentTerms.ts
+// ../blocks/src/system/manifest/richTextSchema.ts
 import { z as z33 } from "zod";
-var bookingDepositRefundPolicySchema = z33.enum([
+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()
+  })
+);
+var RichTextValueSchema = z33.union([
+  // Canonical: TipTap document directly
+  TipTapNodeSchema,
+  // Legacy (read-tolerance only): wrapped in { doc: {...} }
+  z33.object({
+    doc: TipTapNodeSchema
+  })
+]);
+var RichTextDocSchema = z33.object({
+  type: z33.literal("doc"),
+  content: z33.array(TipTapNodeSchema)
+});
+function createHardBreakNode() {
+  return { type: "hardBreak" };
+}
+function parseRichTextInlineMarkdown(text2) {
+  const out = [];
+  const pushText = (value, marks) => {
+    if (!value) return;
+    out.push(
+      marks && marks.length > 0 ? { type: "text", text: value, marks } : { type: "text", text: value }
+    );
+  };
+  let rest = text2;
+  while (rest.length > 0) {
+    const start = rest.indexOf("**");
+    if (start === -1) {
+      pushText(rest);
+      break;
+    }
+    const end = rest.indexOf("**", start + 2);
+    if (end === -1) {
+      pushText(rest);
+      break;
+    }
+    pushText(rest.slice(0, start));
+    pushText(rest.slice(start + 2, end), [{ type: "bold" }]);
+    rest = rest.slice(end + 2);
+  }
+  return out;
+}
+function parseRichTextParagraphInlineMarkdown(text2) {
+  return text2.split("\n").flatMap((line, index) => {
+    const lineNodes = parseRichTextInlineMarkdown(line.trim());
+    return index === 0 ? lineNodes : [createHardBreakNode(), ...lineNodes];
+  });
+}
+function createRichTextDocFromMarkdown(markdown) {
+  const normalized = markdown.replace(/\r\n/g, "\n").trim();
+  if (!normalized) return { type: "doc", content: [] };
+  const paragraphs = normalized.split(/\n{2,}/).map((paragraph) => paragraph.trim()).filter(Boolean);
+  return {
+    type: "doc",
+    content: paragraphs.map((paragraph) => {
+      const inline2 = parseRichTextParagraphInlineMarkdown(paragraph);
+      return inline2.length > 0 ? { type: "paragraph", content: inline2 } : { type: "paragraph" };
+    })
+  };
+}
+
+// ../blocks/src/system/blocks/shared/bookingPaymentTerms.ts
+import { z as z34 } from "zod";
+var bookingDepositRefundPolicySchema = z34.enum([
   "refundable",
   "non_refundable"
 ]);
-var bookingInstalmentPlanSchema = z33.union([
-  z33.object({
-    kind: z33.literal("deposit_plus_one_remainder"),
-    depositAmountCents: z33.number().int().min(0),
+var bookingInstalmentPlanSchema = z34.union([
+  z34.object({
+    kind: z34.literal("deposit_plus_one_remainder"),
+    depositAmountCents: z34.number().int().min(0),
     depositRefundability: bookingDepositRefundPolicySchema,
-    remainderDueCount: z33.number().int().positive(),
-    intervalUnit: z33.enum(["day", "week", "month"])
+    remainderDueCount: z34.number().int().positive(),
+    intervalUnit: z34.enum(["day", "week", "month"])
   }),
-  z33.object({
-    kind: z33.literal("deposit_plus_scheduled_instalments"),
-    depositAmountCents: z33.number().int().min(0),
+  z34.object({
+    kind: z34.literal("deposit_plus_scheduled_instalments"),
+    depositAmountCents: z34.number().int().min(0),
     depositRefundability: bookingDepositRefundPolicySchema,
-    instalmentCount: z33.number().int().positive(),
-    intervalCount: z33.number().int().positive(),
-    intervalUnit: z33.enum(["day", "week", "month"])
+    instalmentCount: z34.number().int().positive(),
+    intervalCount: z34.number().int().positive(),
+    intervalUnit: z34.enum(["day", "week", "month"])
   }),
-  z33.object({
-    kind: z33.literal("equal_scheduled_instalments"),
-    instalmentCount: z33.number().int().positive(),
-    intervalCount: z33.number().int().positive(),
-    intervalUnit: z33.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"])
   })
 ]);
-var bookingFlexibleBalanceDueDateRuleSchema = z33.union([
-  z33.object({
-    kind: z33.literal("relative_to_start_date"),
-    daysBeforeStart: z33.number().int().positive()
+var bookingFlexibleBalanceDueDateRuleSchema = z34.union([
+  z34.object({
+    kind: z34.literal("relative_to_start_date"),
+    daysBeforeStart: z34.number().int().positive()
   }),
-  z33.object({
-    kind: z33.literal("fixed_calendar_date"),
-    dueAt: z33.string().datetime()
+  z34.object({
+    kind: z34.literal("fixed_calendar_date"),
+    dueAt: z34.string().datetime()
   })
 ]);
-var bookingFlexibleBalanceConfigSchema = z33.object({
-  upfrontAmountCents: z33.number().int().min(0),
+var bookingFlexibleBalanceConfigSchema = z34.object({
+  upfrontAmountCents: z34.number().int().min(0),
   dueDateRule: bookingFlexibleBalanceDueDateRuleSchema,
   depositRefundability: bookingDepositRefundPolicySchema
 });
-var blockBookingPaymentCollectionOptionSchema = z33.union([
-  z33.object({
-    kind: z33.literal("upfront")
+var blockBookingPaymentCollectionOptionSchema = z34.union([
+  z34.object({
+    kind: z34.literal("upfront")
   }),
-  z33.object({
-    kind: z33.literal("deferred_manual")
+  z34.object({
+    kind: z34.literal("deferred_manual")
   }),
-  z33.object({
-    kind: z33.literal("instalment_plan"),
+  z34.object({
+    kind: z34.literal("instalment_plan"),
     plan: bookingInstalmentPlanSchema
   }),
-  z33.object({
-    kind: z33.literal("flexible_balance"),
+  z34.object({
+    kind: z34.literal("flexible_balance"),
     config: bookingFlexibleBalanceConfigSchema
   })
 ]);
-var blockBookingPaymentTermsSchema = z33.object({
-  allowedOptions: z33.array(blockBookingPaymentCollectionOptionSchema).min(1)
+var blockBookingPaymentTermsSchema = z34.object({
+  allowedOptions: z34.array(blockBookingPaymentCollectionOptionSchema).min(1)
 });
 
 // ../blocks/src/system/blocks/courses/shared/schemas.ts
-import { z as z34 } from "zod";
-var courseVenueSchema = z34.object({
-  id: z34.string(),
-  name: z34.string(),
-  address: z34.string().nullable()
-});
-var courseSessionSchema = z34.object({
-  id: z34.string(),
-  startsAt: z34.string(),
-  endsAt: z34.string(),
-  timeZone: z34.string(),
-  capacityOverride: z34.number().nullable().optional(),
-  overrides: z34.record(z34.string(), z34.unknown()).nullable().optional()
-});
-var courseTeamMemberSummarySchema = z34.object({
-  id: z34.string(),
-  name: z34.string(),
-  roleLabel: z34.string().nullable(),
-  summary: z34.string().nullable(),
-  profilePath: z34.string().nullable()
-});
-var coursePricingOptionSchema = z34.object({
-  id: z34.string(),
-  name: z34.string(),
-  description: z34.string().nullable(),
-  priceAmount: z34.number(),
-  isActive: z34.boolean(),
-  sortOrder: z34.number(),
-  capacityLimit: z34.number().nullable(),
-  saleStartsAt: z34.string().nullable(),
-  saleEndsAt: z34.string().nullable(),
-  attendanceScope: z34.enum(["in_person", "online", "both"]).nullable().optional()
-});
-var coursePricingSchema = z34.object({
-  bookingRequirement: z34.enum(["none", "required"]),
-  pricingStrategy: z34.enum(["free", "single", "tiered"]),
-  currency: z34.string(),
-  singlePriceAmount: z34.number().nullable(),
+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"]),
+  currency: z35.string(),
+  singlePriceAmount: z35.number().nullable(),
   paymentTerms: blockBookingPaymentTermsSchema,
-  options: z34.array(coursePricingOptionSchema)
-});
-var publicCourseSchema = z34.object({
-  id: z34.string(),
-  title: z34.string(),
-  slug: z34.string(),
-  description: z34.unknown().nullable(),
-  teamMembers: z34.array(courseTeamMemberSummarySchema).optional(),
-  enrollmentOpen: z34.boolean(),
+  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(),
   pricing: coursePricingSchema.optional(),
-  priceCents: z34.number().nullable(),
-  currency: z34.string(),
+  priceCents: z35.number().nullable(),
+  currency: z35.string(),
   paymentTerms: blockBookingPaymentTermsSchema,
-  enrollmentCapacity: z34.number().nullable(),
-  acceptsMemberships: z34.boolean(),
-  status: z34.enum(["active", "draft", "cancelled"]),
-  sessionsCount: z34.number(),
-  enrolledCount: z34.number(),
-  availableSpots: z34.number().nullable(),
-  sessions: z34.array(courseSessionSchema),
+  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),
   venue: courseVenueSchema.nullable(),
-  contentEntryId: z34.string().nullable()
+  contentEntryId: z35.string().nullable()
 });
-var publicCoursesArraySchema = z34.array(publicCourseSchema);
+var publicCoursesArraySchema = z35.array(publicCourseSchema);
 
 // ../blocks/src/system/blocks/events/shared/schemas.ts
-var eventPresetSchema = z35.enum(["event", "class", "workshop", "retreat", "performance"]);
-var eventScheduleScopeSchema = z35.enum(["recurring", "oneOff"]);
-var eventDestinationModeSchema = z35.enum(["cms-managed", "system-managed"]);
-var eventVenueSchema = z35.object({
-  id: z35.string(),
-  name: z35.string(),
-  address: z35.string().nullable(),
-  location: z35.object({
-    lat: z35.number(),
-    lng: z35.number()
+var eventPresetSchema = z36.enum(["event", "class", "workshop", "retreat", "performance"]);
+var eventScheduleScopeSchema = z36.enum(["recurring", "oneOff"]);
+var eventDestinationModeSchema = z36.enum(["cms-managed", "system-managed"]);
+var eventVenueSchema = z36.object({
+  id: z36.string(),
+  name: z36.string(),
+  address: z36.string().nullable(),
+  location: z36.object({
+    lat: z36.number(),
+    lng: z36.number()
   }).nullable()
 });
-var eventCategorySchema = z35.object({
-  id: z35.string(),
-  name: z35.string(),
-  color: z35.string().nullable()
-});
-var pricingTypeSchema = z35.enum(["free", "paid"]);
-var accessRestrictionSchema = z35.enum(["none", "category"]);
-var eventPricingModeSchema = z35.enum(["single", "ticket_types"]);
-var publicCoursePriceDisplaySchema = z35.discriminatedUnion("kind", [
-  z35.object({ kind: z35.literal("free"), currency: z35.string() }),
-  z35.object({ kind: z35.literal("exact"), amount: z35.number(), currency: z35.string() }),
-  z35.object({ kind: z35.literal("from"), amount: z35.number(), currency: z35.string() }),
-  z35.object({ kind: z35.literal("unavailable"), currency: z35.string() })
+var eventCategorySchema = z36.object({
+  id: z36.string(),
+  name: z36.string(),
+  color: z36.string().nullable()
+});
+var pricingTypeSchema = z36.enum(["free", "paid"]);
+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 publicEventPriceDisplaySchema = z35.discriminatedUnion("kind", [
-  z35.object({ kind: z35.literal("free"), currency: z35.string() }),
-  z35.object({ kind: z35.literal("exact"), amount: z35.number(), currency: z35.string() }),
-  z35.object({ kind: z35.literal("from"), amount: z35.number(), currency: z35.string() }),
-  z35.object({ kind: z35.literal("mixed"), paidFromAmount: z35.number(), currency: z35.string() }),
-  z35.object({ kind: z35.literal("unavailable"), currency: z35.string() }),
-  z35.object({ kind: z35.literal("course"), display: publicCoursePriceDisplaySchema })
+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()
+  }),
+  z36.object({ kind: z36.literal("unavailable"), currency: z36.string() }),
+  z36.object({ kind: z36.literal("course"), display: publicCoursePriceDisplaySchema })
 ]);
-var publicEventTicketTypePriceDisplaySchema = z35.union([
-  z35.object({ kind: z35.literal("free"), currency: z35.string() }),
-  z35.object({ kind: z35.literal("exact"), amount: z35.number(), currency: z35.string() }),
-  z35.object({ kind: z35.literal("from"), amount: z35.number(), currency: z35.string() }),
-  z35.object({ kind: z35.literal("mixed"), paidFromAmount: z35.number(), currency: z35.string() }),
-  z35.object({ kind: z35.literal("unavailable"), currency: z35.string() })
+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()
+  }),
+  z36.object({ kind: z36.literal("unavailable"), currency: z36.string() })
 ]);
-var publicEventAttendanceModeSchema = z35.enum(["in_person", "online"]);
-var publicEventAttendanceModeAvailabilitySchema = z35.object({
+var publicEventAttendanceModeSchema = z36.enum(["in_person", "online"]);
+var publicEventAttendanceModeAvailabilitySchema = z36.object({
   mode: publicEventAttendanceModeSchema,
-  capacity: z35.number().nullable(),
-  registeredCount: z35.number(),
-  availableSpots: z35.number().nullable(),
-  waitlistEnabled: z35.boolean()
-});
-var publicEventTicketTypeAvailabilitySchema = z35.union([
-  z35.object({
-    kind: z35.literal("available"),
-    remainingCapacity: z35.number().nullable()
+  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()
   }),
-  z35.object({
-    kind: z35.literal("unavailable"),
-    reason: z35.enum(["inactive", "not_on_sale_yet", "sale_ended", "sold_out", "event_sold_out"]),
-    remainingCapacity: z35.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()
   })
 ]);
-var publicEventTicketTypeSchema = z35.object({
-  id: z35.string(),
-  siteId: z35.string(),
-  eventSeriesId: z35.string(),
-  name: z35.string(),
-  description: z35.string().nullable(),
-  priceAmount: z35.number(),
-  isActive: z35.boolean(),
-  sortOrder: z35.number(),
-  capacityMode: z35.enum(["limited", "unlimited"]),
-  capacityLimit: z35.number().nullable(),
-  attendanceScope: z35.enum(["in_person", "online", "both"]).optional(),
-  saleStartsAt: z35.string().nullable(),
-  saleEndsAt: z35.string().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(),
   availability: publicEventTicketTypeAvailabilitySchema,
-  createdAt: z35.string(),
-  updatedAt: z35.string()
-});
-var publicEventPricingSchema = z35.discriminatedUnion("kind", [
-  z35.object({
-    kind: z35.literal("drop_in"),
-    currency: z35.string(),
-    display: z35.object({ kind: z35.literal("free"), currency: z35.string() })
+  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() })
   }),
-  z35.object({
-    kind: z35.literal("free_registration"),
-    currency: z35.string(),
-    display: z35.object({ kind: z35.literal("free"), currency: z35.string() })
+  z36.object({
+    kind: z36.literal("free_registration"),
+    currency: z36.string(),
+    display: z36.object({ kind: z36.literal("free"), currency: z36.string() })
   }),
-  z35.object({
-    kind: z35.literal("single_paid"),
-    amount: z35.number(),
-    currency: z35.string(),
-    display: z35.object({ kind: z35.literal("exact"), amount: z35.number(), currency: z35.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() })
   }),
-  z35.object({
-    kind: z35.literal("ticket_types"),
-    currency: z35.string(),
-    ticketTypes: z35.array(publicEventTicketTypeSchema),
+  z36.object({
+    kind: z36.literal("ticket_types"),
+    currency: z36.string(),
+    ticketTypes: z36.array(publicEventTicketTypeSchema),
     display: publicEventTicketTypePriceDisplaySchema
   }),
-  z35.object({
-    kind: z35.literal("course"),
-    display: z35.object({ kind: z35.literal("course"), display: publicCoursePriceDisplaySchema })
+  z36.object({
+    kind: z36.literal("course"),
+    display: z36.object({ kind: z36.literal("course"), display: publicCoursePriceDisplaySchema })
   })
 ]);
-var publicTeamMemberSummarySchema = z35.object({
-  id: z35.string(),
-  name: z35.string(),
-  roleLabel: z35.string().nullable(),
-  summary: z35.string().nullable(),
-  profilePath: z35.string().nullable()
+var publicTeamMemberSummarySchema = z36.object({
+  id: z36.string(),
+  name: z36.string(),
+  roleLabel: z36.string().nullable(),
+  summary: z36.string().nullable(),
+  profilePath: z36.string().nullable()
 });
-var publicEventSchema = z35.object({
-  kind: z35.enum(["event", "course_session"]).optional(),
+var publicEventSchema = z36.object({
+  kind: z36.enum(["event", "course_session"]).optional(),
   eventPreset: eventPresetSchema.optional(),
   eventDestinationMode: eventDestinationModeSchema.optional(),
   scheduleScope: eventScheduleScopeSchema.optional(),
-  id: z35.string(),
-  occurrenceId: z35.string(),
-  seriesId: z35.string(),
-  title: z35.string(),
-  description: z35.string().nullable(),
-  presentation: z35.object({
-    cardTitleOverride: z35.string().nullable().optional(),
-    summary: z35.string().nullable().optional(),
+  id: z36.string(),
+  occurrenceId: z36.string(),
+  seriesId: z36.string(),
+  title: z36.string(),
+  description: z36.string().nullable(),
+  content: z36.object({
+    body: RichTextDocSchema.nullable().optional()
+  }).optional(),
+  presentation: z36.object({
+    cardTitleOverride: z36.string().nullable().optional(),
+    summary: z36.string().nullable().optional(),
     image: mediaSchema2.nullable().optional()
   }).optional(),
-  slug: z35.string(),
-  path: z35.string(),
-  requiresRegistration: z35.boolean(),
-  deliveryMode: z35.enum(["in_person", "online", "hybrid"]),
-  attendanceModes: z35.array(publicEventAttendanceModeAvailabilitySchema),
-  startsAt: z35.string(),
-  endsAt: z35.string(),
-  capacity: z35.number().nullable(),
-  registeredCount: z35.number(),
-  availableSpots: z35.number().nullable(),
-  waitlistEnabled: z35.boolean(),
+  slug: z36.string(),
+  path: z36.string(),
+  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(),
   venue: eventVenueSchema.nullable(),
   eventCategory: eventCategorySchema.nullable(),
-  teamMembers: z35.array(publicTeamMemberSummarySchema).optional(),
-  status: z35.enum(["active", "draft", "archived"]).optional(),
-  timeZone: z35.string(),
+  teamMembers: z36.array(publicTeamMemberSummarySchema).optional(),
+  status: z36.enum(["active", "draft", "archived"]).optional(),
+  timeZone: z36.string(),
   pricing: publicEventPricingSchema,
   paymentTerms: blockBookingPaymentTermsSchema,
   accessRestriction: accessRestrictionSchema,
-  allowedCategoryIds: z35.array(z35.string()),
-  requireGuestDetails: z35.boolean().optional(),
-  acceptsPasses: z35.boolean().optional(),
-  acceptsMemberships: z35.boolean().optional(),
-  course: z35.object({
-    id: z35.string(),
+  allowedCategoryIds: z36.array(z36.string()),
+  requireGuestDetails: z36.boolean().optional(),
+  acceptsPasses: z36.boolean().optional(),
+  acceptsMemberships: z36.boolean().optional(),
+  course: z36.object({
+    id: z36.string(),
     pricing: coursePricingSchema.optional(),
-    priceCents: z35.number().nullable(),
-    currency: z35.string(),
-    enrollmentOpen: z35.boolean()
+    priceCents: z36.number().nullable(),
+    currency: z36.string(),
+    enrollmentOpen: z36.boolean()
   }).nullable().optional()
 });
-var publicEventsArraySchema = z35.array(publicEventSchema);
+var publicEventsArraySchema = z36.array(publicEventSchema);
 
 // ../blocks/src/system/blocks/events/shared/fields.ts
 var cardVariantOptions2 = cardVariantRoleValues.map((value) => ({
@@ -19543,19 +19714,19 @@ function normalizeEventStaffMemberId(value) {
 }
 
 // ../blocks/src/system/blocks/event-registration.shared.ts
-import { z as z36 } from "zod";
-var occurrenceContextSchema = z36.object({
-  id: z36.string(),
-  seriesId: 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()
+import { z as z37 } from "zod";
+var occurrenceContextSchema = z37.object({
+  id: z37.string(),
+  seriesId: z37.string(),
+  startsAt: z37.string(),
+  endsAt: z37.string(),
+  timeZone: z37.string(),
+  capacityOverride: z37.number().nullable().optional(),
+  overrides: z37.record(z37.string(), z37.unknown()).nullable().optional()
 }).nullable();
 
 // ../blocks/src/system/runtime/nodes/event-registration.interactive.ts
-import { z as z38 } from "zod";
+import { z as z39 } from "zod";
 
 // ../blocks/src/system/constants/events.ts
 var EVENT_CONTENT_TYPE_SLUGS = ["event", "events"];
@@ -19653,10 +19824,21 @@ function readLegacyPriceDisplay(value, currency) {
         amount: readAmount(value.amount) ?? 0,
         currency: displayCurrency
       } : { kind: "unavailable", currency };
+    case "range": {
+      const minAmount = readAmount(value.minAmount);
+      const maxAmount = readAmount(value.maxAmount);
+      return minAmount !== null && maxAmount !== null ? {
+        kind: "range",
+        minAmount,
+        maxAmount,
+        currency: displayCurrency
+      } : { kind: "unavailable", currency };
+    }
     case "mixed":
       return readAmount(value.paidFromAmount) !== null ? {
         kind: "mixed",
         paidFromAmount: readAmount(value.paidFromAmount) ?? 0,
+        paidToAmount: readAmount(value.paidToAmount) ?? readAmount(value.paidFromAmount) ?? 0,
         currency: displayCurrency
       } : { kind: "unavailable", currency };
     case "unavailable":
@@ -19698,16 +19880,16 @@ function readAmount(value) {
 }
 
 // ../blocks/src/system/runtime/nodes/shared/contract-schemas.ts
-import { z as z37 } from "zod";
-var previewStageSchema = z37.enum(["preview", "published"]);
-var registrationButtonVariantSchema = z37.enum(["primary", "secondary", "outline"]);
-var eventButtonVariantSchema = z37.enum(["primary", "secondary", "outline", "link"]);
-var eventLayoutSchema = z37.enum(eventCalendarListLayoutValues);
-var eventCalendarDisplayModeSchema = z37.enum(eventCalendarDisplayModeValues);
-var columnOptionSchema = z37.enum(["2", "3", "4"]);
-var weekStartSchema = z37.enum(["sunday", "monday"]);
-var filterAutoShowSchema = z37.enum(["auto", "always", "never"]);
-var calendarTabViewsSchema = z37.enum(["both", "month", "week"]);
+import { z as z38 } from "zod";
+var previewStageSchema = z38.enum(["preview", "published"]);
+var registrationButtonVariantSchema = z38.enum(["primary", "secondary", "outline"]);
+var eventButtonVariantSchema = z38.enum(["primary", "secondary", "outline", "link"]);
+var eventLayoutSchema = z38.enum(eventCalendarListLayoutValues);
+var eventCalendarDisplayModeSchema = z38.enum(eventCalendarDisplayModeValues);
+var columnOptionSchema = z38.enum(["2", "3", "4"]);
+var weekStartSchema = z38.enum(["sunday", "monday"]);
+var filterAutoShowSchema = z38.enum(["auto", "always", "never"]);
+var calendarTabViewsSchema = z38.enum(["both", "month", "week"]);
 
 // ../blocks/src/system/runtime/nodes/event-registration/wizardSteps.ts
 function getWizardStepsForContext(hasPreSelectedContext, needsPaymentStep) {
@@ -19767,66 +19949,68 @@ function toRegistrationEvents(events) {
 // ../blocks/src/system/runtime/nodes/event-registration.interactive.ts
 var EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS = ["Date", "Tickets", "Details"];
 var EVENT_REGISTRATION_SHELL_STEP_LABELS = ["Event", "Date", "Tickets", "Details", "Payment"];
-var contentEntrySchema = z38.object({
-  id: z38.string(),
-  slug: z38.string(),
-  contentTypeSlug: z38.string()
+var contentEntrySchema = z39.object({
+  id: z39.string(),
+  slug: z39.string(),
+  contentTypeSlug: z39.string()
 });
-var eventRegistrationPublicEventSchema = z38.preprocess(
+var eventRegistrationPublicEventSchema = z39.preprocess(
   normalizeEventRegistrationEventInput,
   publicEventSchema
 );
-var eventRegistrationSourceSchema = z38.object({
-  siteId: z38.string().optional(),
-  apiBaseUrl: z38.string().optional(),
-  portalToken: z38.string().nullable().optional(),
-  previewToken: z38.string().nullable().optional(),
+var eventRegistrationSourceSchema = z39.object({
+  siteId: z39.string().optional(),
+  apiBaseUrl: z39.string().optional(),
+  portalToken: z39.string().nullable().optional(),
+  previewToken: z39.string().nullable().optional(),
   occurrenceContext: occurrenceContextSchema.optional(),
   contentEntry: contentEntrySchema.nullable().optional(),
-  events: z38.array(eventRegistrationPublicEventSchema).nullable().optional(),
-  className: z38.string().nullable().optional(),
-  buttonText: z38.string().nullable().optional(),
-  maxTickets: z38.string().nullable().optional(),
-  showVenue: z38.boolean().optional(),
-  showCapacity: z38.boolean().optional(),
-  successMessage: z38.string().optional(),
-  waitlistMessage: z38.string().optional(),
+  events: z39.array(eventRegistrationPublicEventSchema).nullable().optional(),
+  className: z39.string().nullable().optional(),
+  buttonText: z39.string().nullable().optional(),
+  maxTickets: z39.string().nullable().optional(),
+  showVenue: z39.boolean().optional(),
+  showCapacity: z39.boolean().optional(),
+  successMessage: z39.string().optional(),
+  waitlistMessage: z39.string().optional(),
   buttonVariant: registrationButtonVariantSchema.optional(),
-  spamProtectionEnabled: z38.boolean().optional(),
+  overlayEnabled: z39.boolean().optional(),
+  spamProtectionEnabled: z39.boolean().optional(),
   stage: previewStageSchema.optional(),
-  supportEmail: z38.string().optional()
-});
-var eventRegistrationDisplaySchema = z38.object({
-  kind: z38.literal("event-registration"),
-  state: z38.literal("generic-shell"),
-  className: z38.string().nullable(),
-  titleText: z38.string(),
-  bodyText: z38.string(),
-  stepLabels: z38.array(z38.enum(EVENT_REGISTRATION_SHELL_STEP_LABELS)).min(1),
-  summaryButtonText: z38.string()
-});
-var eventRegistrationHydrationSchema = z38.object({
+  supportEmail: z39.string().optional()
+});
+var eventRegistrationDisplaySchema = z39.object({
+  kind: z39.literal("event-registration"),
+  state: z39.literal("generic-shell"),
+  className: z39.string().nullable(),
+  titleText: z39.string(),
+  bodyText: z39.string(),
+  stepLabels: z39.array(z39.enum(EVENT_REGISTRATION_SHELL_STEP_LABELS)).min(1),
+  summaryButtonText: z39.string()
+});
+var eventRegistrationHydrationSchema = z39.object({
   occurrenceContext: occurrenceContextSchema.optional(),
   contentEntry: contentEntrySchema.nullable().optional(),
-  events: z38.array(eventRegistrationPublicEventSchema).nullable().optional(),
-  maxTickets: z38.string().optional(),
-  showVenue: z38.boolean().optional(),
-  showCapacity: z38.boolean().optional(),
-  successMessage: z38.string().optional(),
-  waitlistMessage: z38.string().optional(),
+  events: z39.array(eventRegistrationPublicEventSchema).nullable().optional(),
+  maxTickets: z39.string().optional(),
+  showVenue: z39.boolean().optional(),
+  showCapacity: z39.boolean().optional(),
+  successMessage: z39.string().optional(),
+  waitlistMessage: z39.string().optional(),
   buttonVariant: registrationButtonVariantSchema.optional(),
-  spamProtectionEnabled: z38.boolean().optional(),
-  supportEmail: z38.string().optional()
+  overlayEnabled: z39.boolean().optional(),
+  spamProtectionEnabled: z39.boolean().optional(),
+  supportEmail: z39.string().optional()
 });
-var eventRegistrationRenderSchema = z38.object({
+var eventRegistrationRenderSchema = z39.object({
   display: eventRegistrationDisplaySchema,
   hydration: eventRegistrationHydrationSchema
 });
-var eventRegistrationIslandMetaCodec = createZodCodec(z38.object({
-  siteId: z38.string().optional(),
-  apiBaseUrl: z38.string().optional(),
-  portalToken: z38.string().nullable().optional(),
-  previewToken: z38.string().nullable().optional(),
+var eventRegistrationIslandMetaCodec = createZodCodec(z39.object({
+  siteId: z39.string().optional(),
+  apiBaseUrl: z39.string().optional(),
+  portalToken: z39.string().nullable().optional(),
+  previewToken: z39.string().nullable().optional(),
   stage: previewStageSchema.optional()
 }));
 var eventRegistrationIslandMetaKeys = defineInteractiveIslandMetaKeys(
@@ -19930,6 +20114,7 @@ var eventRegistrationBlockRuntime = defineClientOwnedBlockRuntime({
       successMessage: source.successMessage,
       waitlistMessage: source.waitlistMessage,
       buttonVariant: source.buttonVariant,
+      overlayEnabled: source.overlayEnabled,
       spamProtectionEnabled: source.spamProtectionEnabled,
       supportEmail: source.supportEmail
     }
@@ -20105,6 +20290,12 @@ var eventRegistrationManifest = createBlockManifest({
               buttonVariant: {
                 $bind: { from: "content.buttonVariant", fallback: "primary" }
               },
+              overlayEnabled: {
+                $bind: {
+                  from: "$root.eventRegistrationOverlayEnabled",
+                  fallback: false
+                }
+              },
               // Event data from loader
               events: { $bind: { from: "data.events" } },
               // Stage for preview mode (allows registering for draft events)
@@ -20125,7 +20316,7 @@ var eventRegistrationBlockDefinition = {
   manifest: eventRegistrationManifest,
   runtime: eventRegistrationBlockRuntime,
   dataSchemas: {
-    events: z39.array(publicEventSchema).optional(),
+    events: z40.array(publicEventSchema).optional(),
     occurrenceContext: occurrenceContextSchema.optional()
   },
   dataLoaders: {
@@ -20149,73 +20340,73 @@ var eventRegistrationBlockDefinition = {
 };
 
 // ../blocks/src/system/runtime/nodes/course-registration.interactive.ts
-import { z as z40 } from "zod";
-var contentEntrySchema2 = z40.object({
-  id: z40.string(),
-  slug: z40.string(),
-  contentTypeSlug: z40.string()
-});
-var courseEntrySubrouteContextSchema = z40.union([
-  z40.object({
-    kind: z40.literal("course-run"),
-    run: z40.object({
-      courseId: z40.string(),
-      seriesId: z40.string(),
-      runSlug: z40.string(),
-      runName: z40.string().nullable()
+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()
     })
   }),
-  z40.object({
-    kind: z40.literal("event-occurrence"),
+  z41.object({
+    kind: z41.literal("event-occurrence"),
     occurrence: occurrenceContextSchema
   })
 ]);
-var courseRegistrationSourceSchema = z40.object({
-  siteId: z40.string().optional(),
-  apiBaseUrl: z40.string().optional(),
-  portalToken: z40.string().nullable().optional(),
+var courseRegistrationSourceSchema = z41.object({
+  siteId: z41.string().optional(),
+  apiBaseUrl: z41.string().optional(),
+  portalToken: z41.string().nullable().optional(),
   contentEntry: contentEntrySchema2.nullable().optional(),
   entrySubrouteContext: courseEntrySubrouteContextSchema.nullable().optional(),
-  courses: z40.array(publicCourseSchema).nullable().optional(),
-  className: z40.string().nullable().optional(),
-  showSessions: z40.boolean().optional(),
-  showPrice: z40.boolean().optional(),
-  showCapacity: z40.boolean().optional(),
-  showVenue: z40.boolean().optional(),
-  successMessage: z40.string().optional(),
-  waitlistMessage: z40.string().optional(),
-  membershipMessage: z40.string().optional(),
-  buttonText: z40.string().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(),
   buttonVariant: registrationButtonVariantSchema.optional(),
   stage: previewStageSchema.optional()
 });
-var courseRegistrationDisplaySchema = z40.object({
-  kind: z40.literal("course-registration"),
-  state: z40.literal("shell"),
-  className: z40.string().nullable(),
-  summaryButtonText: z40.string()
+var courseRegistrationDisplaySchema = z41.object({
+  kind: z41.literal("course-registration"),
+  state: z41.literal("shell"),
+  className: z41.string().nullable(),
+  summaryButtonText: z41.string()
 });
-var courseRegistrationHydrationSchema = z40.object({
+var courseRegistrationHydrationSchema = z41.object({
   contentEntry: contentEntrySchema2.nullable().optional(),
   entrySubrouteContext: courseEntrySubrouteContextSchema.nullable().optional(),
-  courses: z40.array(publicCourseSchema).nullable().optional(),
-  showSessions: z40.boolean().optional(),
-  showPrice: z40.boolean().optional(),
-  showCapacity: z40.boolean().optional(),
-  showVenue: z40.boolean().optional(),
-  successMessage: z40.string().optional(),
-  waitlistMessage: z40.string().optional(),
-  membershipMessage: z40.string().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(),
   buttonVariant: registrationButtonVariantSchema.optional()
 });
-var courseRegistrationRenderSchema = z40.object({
+var courseRegistrationRenderSchema = z41.object({
   display: courseRegistrationDisplaySchema,
   hydration: courseRegistrationHydrationSchema
 });
-var courseRegistrationIslandMetaCodec = createZodCodec(z40.object({
-  siteId: z40.string().optional(),
-  apiBaseUrl: z40.string().optional(),
-  portalToken: z40.string().nullable().optional(),
+var courseRegistrationIslandMetaCodec = createZodCodec(z41.object({
+  siteId: z41.string().optional(),
+  apiBaseUrl: z41.string().optional(),
+  portalToken: z41.string().nullable().optional(),
   stage: previewStageSchema.optional()
 }));
 var courseRegistrationIslandMetaKeys = defineInteractiveIslandMetaKeys(
@@ -20475,32 +20666,32 @@ var courseRegistrationBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/event-details.ts
-import { z as z42 } from "zod";
+import { z as z43 } from "zod";
 
 // ../blocks/src/system/blocks/shop.shared.ts
-import { z as z41 } from "zod";
-var publicPassProductSchema = z41.object({
-  id: z41.string(),
-  productUseCase: z41.enum(["event_pass", "appointment_package"]).default("event_pass"),
-  name: z41.string(),
-  description: z41.string().nullable(),
-  price: z41.number(),
-  currency: z41.string(),
-  creditsTotal: z41.number(),
-  pricePerCredit: z41.number(),
-  validDays: z41.number().nullable(),
-  eligibleCategoryIds: z41.array(z41.string()),
-  eligibleCategoryNames: z41.array(z41.string())
-});
-var publicMembershipProductSchema = z41.object({
-  id: z41.string(),
-  name: z41.string(),
-  description: z41.string().nullable(),
-  price: z41.number(),
-  currency: z41.string(),
-  billingInterval: z41.enum(["month", "year"]),
-  eligibleCategoryIds: z41.array(z41.string()),
-  eligibleCategoryNames: z41.array(z41.string())
+import { z as z42 } from "zod";
+var publicPassProductSchema = z42.object({
+  id: z42.string(),
+  productUseCase: z42.enum(["event_pass", "appointment_package"]).default("event_pass"),
+  name: z42.string(),
+  description: z42.string().nullable(),
+  price: z42.number(),
+  currency: z42.string(),
+  creditsTotal: z42.number(),
+  pricePerCredit: z42.number(),
+  validDays: z42.number().nullable(),
+  eligibleCategoryIds: z42.array(z42.string()),
+  eligibleCategoryNames: z42.array(z42.string())
+});
+var publicMembershipProductSchema = z42.object({
+  id: z42.string(),
+  name: z42.string(),
+  description: z42.string().nullable(),
+  price: z42.number(),
+  currency: z42.string(),
+  billingInterval: z42.enum(["month", "year"]),
+  eligibleCategoryIds: z42.array(z42.string()),
+  eligibleCategoryNames: z42.array(z42.string())
 });
 
 // ../blocks/src/system/blocks/event-details.ts
@@ -20635,40 +20826,40 @@ 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: z42.object({ passes: z42.array(publicPassProductSchema) }),
-      siteMemberships: z42.object({ memberships: z42.array(publicMembershipProductSchema) }),
+      sitePasses: z43.object({ passes: z43.array(publicPassProductSchema) }),
+      siteMemberships: z43.object({ memberships: z43.array(publicMembershipProductSchema) }),
       autoApplyDiscount: eventAutoApplyDiscountPreviewSchema.nullable().optional().default(null)
     }).optional(),
     occurrenceContext: occurrenceContextSchema2.optional()
@@ -20992,7 +21183,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 = {
@@ -21024,16 +21215,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) {
@@ -21043,15 +21234,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) {
@@ -21064,89 +21255,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()
   })
 );
@@ -21513,15 +21704,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(),
@@ -21529,78 +21720,78 @@ 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(),
-    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,
   paginationAction: eventListPaginationActionSchema,
   startOfWeek: weekStartSchema,
   calendarTabViews: calendarTabViewsSchema,
-  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()
   })
 );
@@ -22309,7 +22500,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";
@@ -22401,13 +22592,13 @@ function isRecord4(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 = [
@@ -22805,7 +22996,7 @@ function isRecord5(value) {
 }
 
 // ../blocks/src/system/blocks/embed.ts
-import { z as z47 } from "zod";
+import { z as z48 } from "zod";
 var embedFields = [
   // Section heading
   parseFieldDefinition({
@@ -23036,18 +23227,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: {
@@ -24231,52 +24422,52 @@ var fileDownloadBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/shop.ts
-import { z as z51 } from "zod";
+import { z as z52 } from "zod";
 
 // ../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
@@ -24340,27 +24531,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) {
@@ -24399,10 +24590,7 @@ function resolveSelectedProduct(products, contentEntry, productSlug) {
 
 // ../blocks/src/system/runtime/nodes/commerce/shared/display.ts
 function formatCommercePrice(cents, currency) {
-  return new Intl.NumberFormat("en-US", {
-    style: "currency",
-    currency: currency.toUpperCase()
-  }).format(cents / 100);
+  return formatCurrencyAmount(cents, currency);
 }
 function getPassesHeading(passes, explicitHeading) {
   if (explicitHeading) return explicitHeading;
@@ -24597,214 +24785,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");
@@ -25182,9 +25370,9 @@ var shopBlockDefinition = {
   runtime: shopBlockRuntime,
   dataSchemas: {
     // listPublicPasses returns { passes: [...] }
-    passes: z51.object({ passes: z51.array(publicPassProductSchema) }).optional(),
+    passes: z52.object({ passes: z52.array(publicPassProductSchema) }).optional(),
     // listPublicMemberships returns { memberships: [...] }
-    memberships: z51.object({ memberships: z51.array(publicMembershipProductSchema) }).optional()
+    memberships: z52.object({ memberships: z52.array(publicMembershipProductSchema) }).optional()
   },
   dataLoaders: {
     // Load passes for display
@@ -25207,7 +25395,7 @@ var shopBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/product-list.ts
-import { z as z52 } from "zod";
+import { z as z53 } from "zod";
 var productListManifest = createBlockManifest({
   id: "block.product-list",
   version: "1.0.0",
@@ -25340,7 +25528,7 @@ var productListBlockDefinition = {
     }
   }
 };
-var productListDataSchema = z52.object({
+var productListDataSchema = z53.object({
   products: publicProductsResponseSchema.optional()
 });
 
@@ -25601,72 +25789,72 @@ var checkoutBlockDefinition = {
 };
 
 // ../blocks/src/system/runtime/nodes/gifting.interactive.ts
-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()
+import { z as z54 } from "zod";
+var publicGiftCardOfferSchema = z54.object({
+  id: z54.string(),
+  kind: z54.literal("gift_card"),
+  title: z54.string(),
+  description: z54.string().nullable(),
+  sortOrder: z54.number().int(),
+  giftCard: z54.object({
+    fixedDenominations: z54.array(z54.number().int().positive()),
+    customAmountEnabled: z54.boolean(),
+    customAmountMinCents: z54.number().int().positive(),
+    customAmountMaxCents: z54.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()
+  voucher: z54.null()
+});
+var publicVoucherOfferSchema = z54.object({
+  id: z54.string(),
+  kind: z54.literal("voucher"),
+  title: z54.string(),
+  description: z54.string().nullable(),
+  sortOrder: z54.number().int(),
+  giftCard: z54.null(),
+  voucher: z54.object({
+    purchaseAmountCents: z54.number().int().positive()
   })
 });
-var publicGiftingOffersResponseSchema = z53.object({
-  currency: z53.string(),
-  giftCards: z53.array(publicGiftCardOfferSchema),
-  vouchers: z53.array(publicVoucherOfferSchema)
+var publicGiftingOffersResponseSchema = z54.object({
+  currency: z54.string(),
+  giftCards: z54.array(publicGiftCardOfferSchema),
+  vouchers: z54.array(publicVoucherOfferSchema)
 });
-var giftingSourceSchema = z53.object({
-  siteId: z53.string().optional(),
-  apiBaseUrl: z53.string().optional(),
+var giftingSourceSchema = z54.object({
+  siteId: z54.string().optional(),
+  apiBaseUrl: z54.string().optional(),
   offers: publicGiftingOffersResponseSchema.nullable().optional(),
-  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({
+  className: z54.string().nullable().optional(),
+  heading: z54.string().nullable().optional(),
+  intro: z54.string().nullable().optional(),
+  giftCardsHeading: z54.string().nullable().optional(),
+  vouchersHeading: z54.string().nullable().optional(),
+  emptyStateText: z54.string().nullable().optional(),
+  checkoutButtonText: z54.string().nullable().optional(),
+  successMessage: z54.string().nullable().optional()
+});
+var giftingDisplaySchema = z54.object({
+  kind: z54.literal("gifting"),
+  state: z54.literal("ready"),
+  className: z54.string().nullable(),
+  heading: z54.string(),
+  intro: z54.string().nullable(),
+  giftCardsHeading: z54.string(),
+  vouchersHeading: z54.string(),
+  emptyStateText: z54.string()
+});
+var giftingHydrationSchema = z54.object({
   offers: publicGiftingOffersResponseSchema.nullable(),
-  checkoutButtonText: z53.string(),
-  successMessage: z53.string()
+  checkoutButtonText: z54.string(),
+  successMessage: z54.string()
 });
-var giftingRenderSchema = z53.object({
+var giftingRenderSchema = z54.object({
   display: giftingDisplaySchema,
   hydration: giftingHydrationSchema
 });
-var giftingIslandMetaCodec = createZodCodec(z53.object({
-  siteId: z53.string().optional(),
-  apiBaseUrl: z53.string().optional()
+var giftingIslandMetaCodec = createZodCodec(z54.object({
+  siteId: z54.string().optional(),
+  apiBaseUrl: z54.string().optional()
 }));
 var giftingIslandMetaKeys = defineInteractiveIslandMetaKeys(
   "siteId",
@@ -25837,7 +26025,61 @@ var giftingBlockDefinition = {
 };
 
 // ../blocks/src/system/runtime/nodes/newsletter-form.interactive.ts
-import { z as z54 } from "zod";
+import { z as z55 } from "zod";
+
+// ../blocks/src/system/blocks/newsletter-signup-destination.ts
+function parseNewsletterSignupBlockId(value) {
+  const trimmed = parseTrimmedString(value);
+  return trimmed && BLOCK_ID_PATTERN.test(trimmed) ? trimmed : null;
+}
+function parseSignedNewsletterDestinationRef(value) {
+  const trimmed = parseTrimmedString(value);
+  return trimmed && SIGNED_DESTINATION_REF_PATTERN.test(trimmed) ? trimmed : null;
+}
+function parseNewsletterSignupDestinationProvider(value) {
+  return value === "riverbank" || value === "mailchimp" ? value : null;
+}
+function buildNewsletterSignupBlockRef(blockId) {
+  const parsed = parseNewsletterSignupBlockId(blockId);
+  return parsed ? { tag: "block_ref", blockId: parsed } : null;
+}
+function normalizeNewsletterSignupEditorValuesForDestination(values) {
+  const destinationProvider = parseNewsletterSignupDestinationProvider(values.destinationProvider) ?? "riverbank";
+  if (destinationProvider === "mailchimp") {
+    return {
+      destinationProvider,
+      mailchimpAudienceId: values.mailchimpAudienceId,
+      mailchimpTags: values.mailchimpTags
+    };
+  }
+  return {
+    destinationProvider,
+    listId: values.listId,
+    tags: values.tags
+  };
+}
+function deriveNewsletterSignupRuntimeSource(values) {
+  const normalized = normalizeNewsletterSignupEditorValuesForDestination(values);
+  if (normalized.destinationProvider === "mailchimp") {
+    return {
+      destinationProvider: "mailchimp",
+      listId: null,
+      tags: null
+    };
+  }
+  return {
+    destinationProvider: "riverbank",
+    listId: parseTrimmedString(normalized.listId),
+    tags: parseTrimmedString(normalized.tags)
+  };
+}
+var BLOCK_ID_PATTERN = /^[A-Za-z0-9._:-]{1,200}$/;
+var SIGNED_DESTINATION_REF_PATTERN = /^[A-Za-z0-9._~-]{16,1000}$/;
+function parseTrimmedString(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
 
 // ../blocks/src/system/runtime/nodes/newsletter-form.types.ts
 function getPresetFields(preset, options) {
@@ -25890,49 +26132,65 @@ function withOptionalPhone(fields3, includePhone) {
 }
 
 // ../blocks/src/system/runtime/nodes/newsletter-form.interactive.ts
-var newsletterPresetSchema = z54.enum(["emailOnly", "emailName", "emailFirstLast", "emailNameCompany"]);
-var newsletterFieldSchema = z54.object({
-  id: z54.string(),
-  type: z54.enum(["email", "text"]),
-  label: z54.string(),
-  required: z54.boolean(),
-  placeholder: z54.string().optional()
-});
-var newsletterSourceSchema = z54.object({
-  siteId: z54.string().optional(),
-  apiBaseUrl: z54.string().optional(),
-  listId: z54.string().nullable().optional(),
+var newsletterPresetSchema = z55.enum(["emailOnly", "emailName", "emailFirstLast", "emailNameCompany"]);
+var newsletterDestinationProviderSchema = z55.enum(["riverbank", "mailchimp"]);
+var newsletterFieldSchema = z55.object({
+  id: z55.string(),
+  type: z55.enum(["email", "text"]),
+  label: z55.string(),
+  required: z55.boolean(),
+  placeholder: z55.string().optional()
+});
+var newsletterSignupBlockIdSchema = z55.string().trim().min(1).transform(parseRequiredNewsletterSignupBlockId);
+var signedNewsletterDestinationRefSchema = z55.string().trim().min(1).transform(parseRequiredSignedNewsletterDestinationRef);
+var newsletterPublicDestinationRefSchema = z55.discriminatedUnion("tag", [
+  z55.object({
+    tag: z55.literal("block_ref"),
+    blockId: newsletterSignupBlockIdSchema
+  }),
+  z55.object({
+    tag: z55.literal("signed_destination_ref"),
+    token: signedNewsletterDestinationRefSchema
+  })
+]);
+var newsletterSourceSchema = z55.object({
+  blockId: z55.string().nullable().optional(),
+  siteId: z55.string().optional(),
+  apiBaseUrl: z55.string().optional(),
+  listId: z55.string().nullable().optional(),
+  destinationProvider: newsletterDestinationProviderSchema.nullable().optional(),
   preset: newsletterPresetSchema.optional(),
-  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({
-  listId: z54.string().nullable().optional(),
+  includePhone: z55.boolean().optional(),
+  buttonLabel: z55.string().nullable().optional(),
+  successMessage: z55.string().nullable().optional(),
+  privacyNote: z55.string().nullable().optional(),
+  tags: z55.string().nullable().optional(),
+  spamProtectionEnabled: z55.boolean().optional(),
+  className: z55.string().nullable().optional()
+});
+var newsletterDisplaySchema = z55.object({
+  kind: z55.literal("newsletter-form"),
+  className: z55.string().nullable(),
+  buttonLabel: z55.string(),
+  successMessage: z55.string().nullable(),
+  privacyNote: z55.string().nullable(),
+  fields: z55.array(newsletterFieldSchema)
+});
+var newsletterHydrationSchema = z55.object({
+  destinationRef: newsletterPublicDestinationRefSchema.nullable().optional(),
+  listId: z55.string().nullable().optional(),
   preset: newsletterPresetSchema,
-  includePhone: z54.boolean(),
-  tags: z54.string().nullable().optional(),
-  spamProtectionEnabled: z54.boolean().optional()
+  includePhone: z55.boolean(),
+  tags: z55.string().nullable().optional(),
+  spamProtectionEnabled: z55.boolean().optional()
 });
-var newsletterRenderSchema = z54.object({
+var newsletterRenderSchema = z55.object({
   display: newsletterDisplaySchema,
   hydration: newsletterHydrationSchema
 });
-var newsletterIslandMetaCodec = createZodCodec(z54.object({
-  siteId: z54.string().optional(),
-  apiBaseUrl: z54.string().optional()
+var newsletterIslandMetaCodec = createZodCodec(z55.object({
+  siteId: z55.string().optional(),
+  apiBaseUrl: z55.string().optional()
 }));
 var newsletterIslandMetaKeys = defineInteractiveIslandMetaKeys("siteId", "apiBaseUrl");
 function buildNewsletterDisplay(source) {
@@ -25953,16 +26211,20 @@ var newsletterFormBlockRuntime = defineProgressiveBlockRuntime({
     source: createZodCodec(newsletterSourceSchema),
     render: createZodCodec(newsletterRenderSchema)
   },
-  buildRender: (source) => ({
-    display: buildNewsletterDisplay(source),
-    hydration: {
-      listId: source.listId,
-      preset: source.preset ?? "emailOnly",
-      includePhone: source.includePhone ?? false,
-      tags: source.tags ?? null,
-      spamProtectionEnabled: source.spamProtectionEnabled
-    }
-  })
+  buildRender: (source) => {
+    const runtimeSource = deriveNewsletterSignupRuntimeSource(source);
+    return {
+      display: buildNewsletterDisplay(source),
+      hydration: {
+        destinationRef: buildNewsletterSignupBlockRef(source.blockId),
+        listId: runtimeSource.listId,
+        preset: source.preset ?? "emailOnly",
+        includePhone: source.includePhone ?? false,
+        tags: runtimeSource.tags,
+        spamProtectionEnabled: source.spamProtectionEnabled
+      }
+    };
+  }
 });
 var newsletterFormInteractiveIslandPropsCodec = createInteractiveIslandCodec({
   runtime: newsletterFormBlockRuntime,
@@ -25974,6 +26236,20 @@ var newsletterFormInteractiveIslandPropsCodec = createInteractiveIslandCodec({
     apiBaseUrl: value.apiBaseUrl
   })
 });
+function parseRequiredNewsletterSignupBlockId(value) {
+  const parsed = parseNewsletterSignupBlockId(value);
+  if (!parsed) {
+    throw new Error("Newsletter signup block destination ref requires blockId");
+  }
+  return parsed;
+}
+function parseRequiredSignedNewsletterDestinationRef(value) {
+  const parsed = parseSignedNewsletterDestinationRef(value);
+  if (!parsed) {
+    throw new Error("Newsletter signup signed destination ref requires token");
+  }
+  return parsed;
+}
 
 // ../blocks/src/system/blocks/newsletter-signup.ts
 var stackedComposition = composeFragments([
@@ -26053,23 +26329,23 @@ var newsletterSignupBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/team-members.ts
-import { z as z55 } from "zod";
+import { z as z56 } 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 = 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(),
+var teamMemberDataSchema = z56.object({
+  _type: z56.literal("teamMember"),
+  id: z56.string(),
+  name: z56.string(),
+  role: z56.string().nullable(),
+  roleLabel: z56.string().nullable(),
+  bio: z56.string().nullable(),
+  summary: z56.string().nullable(),
   photo: teamMemberPhotoSchema,
-  profilePath: z55.string().nullable()
+  profilePath: z56.string().nullable()
 });
-var teamMembersDataSchema = z55.array(teamMemberDataSchema);
+var teamMembersDataSchema = z56.array(teamMemberDataSchema);
 var dynamicSourceWhen = { equals: "site_staff" };
 var manualSourceWhen = { equals: "site_staff", not: true };
 var headingNode = text(
@@ -27376,6 +27652,788 @@ function listBlockDescriptors() {
   }));
 }
 
+// ../theme-core/src/navigation/presets.ts
+var NAV_LINK_PRESETS = {
+  /**
+   * Minimal - subtle color change on hover
+   */
+  minimal: {
+    name: "Minimal",
+    typography: "body",
+    fontWeight: "medium",
+    textTransform: "none",
+    italic: false,
+    colorToken: "text",
+    hoverColorToken: "primary",
+    padding: "none",
+    borderRadius: "none",
+    effects: {
+      hover: [
+        { effectId: "text-color-change", options: { hoverColorToken: "primary" } }
+      ]
+    }
+  },
+  /**
+   * Underline - static underline appears on hover
+   */
+  underline: {
+    name: "Underline",
+    typography: "body",
+    fontWeight: "medium",
+    textTransform: "none",
+    italic: false,
+    colorToken: "text",
+    padding: "none",
+    borderRadius: "none",
+    effects: {
+      hover: [{ effectId: "nav-underline", options: { style: "static" } }]
+    }
+  },
+  /**
+   * Underline Grow - animated underline grows from center on hover
+   */
+  "underline-grow": {
+    name: "Underline Grow",
+    typography: "body",
+    fontWeight: "medium",
+    textTransform: "none",
+    italic: false,
+    colorToken: "text",
+    padding: "none",
+    borderRadius: "none",
+    effects: {
+      hover: [{ effectId: "nav-underline", options: { style: "grow" } }]
+    }
+  },
+  /**
+   * Capsule - pill-shaped background on hover
+   */
+  capsule: {
+    name: "Capsule",
+    typography: "body",
+    fontWeight: "medium",
+    textTransform: "none",
+    italic: false,
+    colorToken: "text",
+    padding: "compact",
+    borderRadius: "full",
+    effects: {
+      hover: [
+        {
+          effectId: "background-on-hover-alpha",
+          options: { colorToken: "primary", opacity: 10 }
+        }
+      ],
+      active: [
+        {
+          effectId: "background-on-hover-alpha",
+          options: { colorToken: "primary", opacity: 15 }
+        }
+      ]
+    }
+  },
+  /**
+   * Solid - solid background color on hover
+   */
+  solid: {
+    name: "Solid",
+    typography: "body",
+    fontWeight: "medium",
+    textTransform: "none",
+    italic: false,
+    colorToken: "text",
+    padding: "compact",
+    borderRadius: "none",
+    effects: {
+      hover: [
+        {
+          effectId: "background-on-hover",
+          options: { colorToken: "primary", textColorToken: "primaryForeground" }
+        }
+      ],
+      active: [
+        {
+          effectId: "background-on-hover",
+          options: { colorToken: "primary", textColorToken: "primaryForeground" }
+        }
+      ]
+    }
+  },
+  /**
+   * Scale - gentle scale-up on hover
+   */
+  scale: {
+    name: "Scale",
+    typography: "body",
+    fontWeight: "medium",
+    textTransform: "none",
+    italic: false,
+    colorToken: "text",
+    padding: "none",
+    borderRadius: "none",
+    effects: {
+      hover: [{ effectId: "scale-up", options: { scale: 1.05 } }]
+    }
+  },
+  /**
+   * Frosted - semi-transparent glass-like background
+   */
+  frosted: {
+    name: "Frosted",
+    typography: "body",
+    fontWeight: "medium",
+    textTransform: "none",
+    italic: false,
+    colorToken: "text",
+    padding: "compact",
+    borderRadius: "md",
+    effects: {
+      base: [{ effectId: "nav-frosted-base" }],
+      hover: [{ effectId: "nav-frosted-hover" }],
+      active: [{ effectId: "nav-frosted-active" }]
+    }
+  }
+};
+var NAV_LINK_PRESET_IDS = Object.keys(NAV_LINK_PRESETS);
+
+// ../theme-core/src/header/navDropdownSizing.ts
+var NAV_DROPDOWN_MIN_WIDTH_REM = 12;
+var NAV_DROPDOWN_MAX_WIDTH_REM = 22;
+var NAV_DROPDOWN_VIEWPORT_GUTTER_REM = 1;
+var NAV_DROPDOWN_SHIFT_PROPERTY = "--nav-dropdown-shift-x";
+var NAV_DROPDOWN_MAX_WIDTH_CSS = `min(${NAV_DROPDOWN_MAX_WIDTH_REM}rem, calc(100vw - ${NAV_DROPDOWN_VIEWPORT_GUTTER_REM * 2}rem))`;
+var NAV_DROPDOWN_CONTAINER_RAIL_CSS_RULES = [
+  `min-width: ${NAV_DROPDOWN_MIN_WIDTH_REM}rem;`,
+  `width: max-content;`,
+  `max-width: ${NAV_DROPDOWN_MAX_WIDTH_CSS};`,
+  `transform: translateX(var(${NAV_DROPDOWN_SHIFT_PROPERTY}, 0px));`
+];
+
+// ../theme-core/src/layout/generateLayoutCss.ts
+var classicWaveTransitionMask = svgDataUrl(
+  "<svg viewBox='0 0 1440 72' xmlns='http://www.w3.org/2000/svg' preserveAspectRatio='none'><path d='M0 72V46C130 55 260 24 420 30C590 36 690 62 860 42C1035 21 1160 47 1305 36C1365 31 1415 33 1440 38V72H0Z' fill='white'/></svg>"
+);
+var balancedWaveTransitionMask = svgDataUrl(
+  "<svg viewBox='0 0 1440 72' xmlns='http://www.w3.org/2000/svg' preserveAspectRatio='none'><path d='M0 72V42C120 24 240 24 360 42C480 60 600 60 720 42C840 24 960 24 1080 42C1200 60 1320 60 1440 42V72H0Z' fill='white'/></svg>"
+);
+var gentleWaveTransitionMask = svgDataUrl(
+  "<svg viewBox='0 0 1440 72' xmlns='http://www.w3.org/2000/svg' preserveAspectRatio='none'><path d='M0 72V43C180 32 300 32 480 43C660 54 780 54 960 43C1140 32 1260 32 1440 43V72H0Z' fill='white'/></svg>"
+);
+var boldWaveTransitionMask = svgDataUrl(
+  "<svg viewBox='0 0 1440 72' xmlns='http://www.w3.org/2000/svg' preserveAspectRatio='none'><path d='M0 72V44C90 14 270 14 360 44C450 74 630 74 720 44C810 14 990 14 1080 44C1170 74 1350 74 1440 44V72H0Z' fill='white'/></svg>"
+);
+var driftWaveTransitionMask = svgDataUrl(
+  "<svg viewBox='0 0 1440 72' xmlns='http://www.w3.org/2000/svg' preserveAspectRatio='none'><path d='M0 72V39C115 31 205 54 340 48C505 41 610 16 760 33C920 51 1015 64 1160 44C1280 27 1375 35 1440 50V72H0Z' fill='white'/></svg>"
+);
+function svgDataUrl(svg) {
+  return `data:image/svg+xml,${encodeURIComponent(svg)}`;
+}
+
+// ../theme-core/src/blocks/vars/event-registration.ts
+function generateEventRegistrationVars({
+  themeId
+}) {
+  const root = `:where([data-theme-scope="${themeId}"]) :where([data-block="event-registration"])`;
+  return `
+${root} {
+  /* Event selection cards should remain surfaced form controls even when the
+     theme defines a more opinionated shared tile treatment elsewhere. */
+  --er-event-card-bg: rgb(var(--tb-surface));
+  --er-event-card-border-width: var(--rb-border-width, 1px);
+  --er-event-card-hover-opacity: 1;
+  --er-control-bg: rgb(var(--tb-background, var(--tb-surface)));
+  --er-control-text: rgb(var(--tb-foreground, var(--tb-text)));
+  --er-radius: var(--rb-block-radius);
+  --er-surface-muted: rgba(var(--tb-muted, 241 245 249), 0.42);
+  --er-shell-line: rgba(var(--tb-mutedText, 100 116 139), 0.22);
+
+  /* Step indicator */
+  --er-step-active: rgb(var(--tb-primary));
+  --er-step-inactive: rgb(var(--tb-mutedText));
+  --er-step-completed: rgb(var(--tb-success));
+  --er-step-text: rgb(255 255 255);
+  --er-step-text-active: rgb(var(--tb-primaryText, 255 255 255));
+  --er-step-connector: rgba(var(--tb-border), 0.5);
+
+  /* Step title */
+  --er-step-title-size: 1.5rem;
+
+  /* State backgrounds with alpha */
+  --er-success-bg: rgba(var(--tb-success), 0.1);
+  --er-success-text: rgb(var(--tb-success));
+  --er-info-bg: rgba(var(--tb-primary), 0.1);
+  --er-info-text: rgb(var(--tb-primary));
+  --er-error-bg: rgba(var(--tb-destructive, 239 68 68), 0.1);
+  --er-error-text: rgb(var(--tb-destructive, 239 68 68));
+  --er-waitlist-bg: rgba(var(--tb-warning), 0.1);
+  --er-waitlist-text: rgb(var(--tb-warning));
+
+  /* Capacity badges */
+  --er-capacity-available-bg: rgba(var(--tb-success), 0.1);
+  --er-capacity-available-text: rgb(var(--tb-success));
+  --er-capacity-low-bg: rgba(var(--tb-warning), 0.1);
+  --er-capacity-low-text: rgb(var(--tb-warning));
+  --er-capacity-soldout-bg: rgba(var(--tb-destructive, 239 68 68), 0.1);
+  --er-capacity-soldout-text: rgb(var(--tb-destructive, 239 68 68));
+
+  /* Borders */
+  --er-border: rgb(var(--tb-border));
+  --er-border-hover: rgba(var(--tb-primary), 0.5);
+  --er-border-selected: rgb(var(--tb-primary));
+  --er-border-error: rgb(var(--tb-destructive, 239 68 68));
+
+  /* Input focus */
+  --er-focus-ring: rgba(var(--tb-primary), 0.3);
+
+  /* Required marker */
+  --er-required: rgb(var(--tb-destructive, 239 68 68));
+
+  /* Payment option cards */
+  --er-payment-border: rgb(var(--tb-border));
+  --er-payment-border-hover: rgba(var(--tb-primary), 0.5);
+  --er-payment-border-selected: rgb(var(--tb-primary));
+  --er-payment-bg-selected: rgba(var(--tb-primary), 0.08);
+
+  /* Checkmark indicator */
+  --er-check-bg: rgb(var(--tb-primary));
+  --er-check-text: rgb(var(--tb-primaryText, 255 255 255));
+
+  /* Order summary */
+  --er-summary-bg: rgba(var(--tb-primary), 0.1);
+  --er-summary-border: rgb(var(--tb-border));
+}
+`;
+}
+
+// ../theme-core/src/blocks/vars/event-card-vars.ts
+function getEventCardCssVars(indent = "  ") {
+  const lines = [
+    "--rb-event-card-media-height: 20rem;",
+    "--rb-event-card-image-hover-scale: 1.08;",
+    "--rb-event-card-image-transition-duration: 700ms;",
+    "--rb-event-card-hover-translate-y: 0px;",
+    "--rb-event-card-overlay-color: rgb(var(--tb-primary));",
+    "--rb-event-card-overlay-opacity: 0;",
+    "--rb-event-card-overlay-hover-opacity: 0;",
+    "--rb-event-card-overlay-blend-mode: multiply;",
+    "--rb-event-card-horizontal-image-width: 33.333%;",
+    "--rb-event-card-horizontal-gap: 1rem;"
+  ];
+  return lines.map((line) => `${indent}${line}`).join("\n");
+}
+
+// ../theme-core/src/blocks/vars/event-calendar.ts
+function generateEventCalendarVars({
+  themeId
+}) {
+  const root = `:where([data-theme-scope="${themeId}"]) :where([data-block="event-calendar"])`;
+  return `
+${root} {
+  /* Day cell states */
+  --ec-today-bg: rgba(var(--tb-primary), 0.05);
+  --ec-today-text: rgb(var(--tb-primary));
+  --ec-other-month-opacity: 0.4;
+
+  /* Event items - subtle style (legacy) */
+  --ec-event-bg: rgba(var(--tb-primary), 0.1);
+  --ec-event-hover-bg: rgba(var(--tb-primary), 0.2);
+
+  /* Event items - solid style (default) */
+  --ec-event-solid-bg: rgb(var(--tb-primary));
+  --ec-event-solid-hover-bg: rgb(var(--tb-primary-600, var(--tb-primary)));
+  --ec-event-solid-text: rgb(var(--tb-neutral-50, 255 255 255));
+
+  /* Navigation */
+  --ec-nav-hover-bg: rgba(var(--tb-text), 0.1);
+
+  /* Day headers */
+  --ec-header-bg: rgba(var(--tb-text), 0.05);
+  --ec-header-opacity: 0.7;
+
+  /* Borders */
+  --ec-border: rgb(var(--tb-border));
+  --ec-border-subtle: rgba(var(--tb-border), 0.5);
+
+  /* Surface and text (for inputs/dropdowns) */
+  --ec-surface: rgb(var(--tb-surface));
+  --ec-text: rgb(var(--tb-text));
+
+  /* Text colors */
+  --ec-day-number-opacity: 0.7;
+  --ec-time-opacity: 0.7;
+  --ec-more-opacity: 0.6;
+  --ec-empty-opacity: 0.6;
+
+  /* Tab bar (List/Calendar tabs in Combined mode) */
+  --ec-tab-border-width: 1px;
+  --ec-tab-border-color: var(--ec-border);
+  --ec-tab-active-border-width: 2px;
+  --ec-tab-active-color: rgb(var(--tb-primary));
+  --rb-tab-border-width: var(--ec-tab-border-width);
+  --rb-tab-border-color: var(--ec-tab-border-color);
+  --rb-tab-active-border-width: var(--ec-tab-active-border-width);
+  --rb-tab-active-color: var(--ec-tab-active-color);
+  --rb-tab-text: var(--ec-text);
+  --rb-tab-opacity: 0.7;
+
+  /* Modal */
+  --ec-modal-overlay-bg: rgba(0, 0, 0, 0.5);
+  --ec-modal-bg: rgb(var(--tb-surface, 255 255 255));
+  --ec-modal-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.25);
+
+  /* Event cards (list/spotlight views rendered inside event-calendar) */
+${getEventCardCssVars("  ")}
+}
+`;
+}
+
+// ../theme-core/src/blocks/vars/event-cards.ts
+function generateEventCardVarsForBlock(themeId, blockKind) {
+  const root = `:where([data-theme-scope="${themeId}"]) :where([data-block="${blockKind}"])`;
+  return `
+${root} {
+${getEventCardCssVars("  ")}
+}
+`;
+}
+function generateEventListingVars({ themeId }) {
+  return generateEventCardVarsForBlock(themeId, "event-listing");
+}
+function generateEventSpotlightVars({ themeId }) {
+  return generateEventCardVarsForBlock(themeId, "event-spotlight");
+}
+function generateEventCombinedVars({ themeId }) {
+  return generateEventCardVarsForBlock(themeId, "event-combined");
+}
+
+// ../theme-core/src/blocks/vars/appointment-booking.ts
+function generateAppointmentBookingVars({
+  themeId
+}) {
+  const root = `:where([data-theme-scope="${themeId}"]) :where([data-block="appointment-booking"])`;
+  return `
+${root} {
+  /* Selection cards (service/resource/time) */
+  --ab-card-border: rgb(var(--tb-border));
+  --ab-card-border-hover: rgba(var(--tb-primary), 0.5);
+  --ab-card-border-selected: rgb(var(--tb-primary));
+  --ab-card-bg-selected: rgba(var(--tb-primary), 0.05);
+
+  /* Checkmark indicator */
+  --ab-check-bg: rgb(var(--tb-primary));
+  --ab-check-text: rgb(var(--tb-background));
+
+  /* State backgrounds */
+  --ab-success-bg: rgba(var(--tb-success), 0.1);
+  --ab-success-text: rgb(var(--tb-success));
+  --ab-error-bg: rgba(var(--tb-destructive), 0.1);
+  --ab-error-text: rgb(var(--tb-destructive));
+  --ab-warning-bg: rgba(var(--tb-warning), 0.1);
+  --ab-warning-text: rgb(var(--tb-warning));
+  --ab-info-bg: rgba(var(--tb-info), 0.1);
+  --ab-info-text: rgb(var(--tb-info));
+
+  /* Loading/muted states */
+  --ab-muted-bg: rgba(var(--tb-text), 0.05);
+  --ab-muted-text: rgba(var(--tb-text), 0.6);
+  --ab-spinner-color: rgb(var(--tb-primary));
+
+  /* Form elements */
+  --ab-input-border: rgb(var(--tb-border));
+  --ab-input-focus-ring: rgba(var(--tb-primary), 0.3);
+
+  /* Buttons */
+  --ab-btn-primary-bg: rgb(var(--tb-primary));
+  --ab-btn-primary-text: rgb(var(--tb-background));
+  --ab-btn-primary-hover: rgba(var(--tb-primary), 0.9);
+  --ab-btn-secondary-border: rgb(var(--tb-border));
+  --ab-btn-secondary-hover: rgba(var(--tb-text), 0.05);
+
+  /* Text opacity levels */
+  --ab-text-muted-opacity: 0.6;
+  --ab-text-faint-opacity: 0.4;
+}
+`;
+}
+
+// ../theme-core/src/blocks/vars/form-block.ts
+function generateFormBlockVars({
+  themeId
+}) {
+  const root = `:where([data-theme-scope="${themeId}"]) :where([data-block="form"])`;
+  return `
+${root} {
+  /* Success state */
+  --fb-success-bg: rgba(var(--tb-success), 0.1);
+  --fb-success-text: rgb(var(--tb-success));
+  --fb-success-border: rgba(var(--tb-success), 0.3);
+
+  /* Error state */
+  --fb-error-bg: rgba(var(--tb-destructive), 0.1);
+  --fb-error-text: rgb(var(--tb-destructive));
+  --fb-error-border: rgba(var(--tb-destructive), 0.3);
+
+  /* Empty state */
+  --fb-empty-bg: rgb(var(--tb-surface));
+  --fb-empty-border: rgb(var(--tb-border));
+  --fb-empty-text: rgb(var(--tb-mutedText));
+
+  /* Submit button inherits from button system */
+}
+`;
+}
+
+// ../theme-core/src/runtime/themeCssVarNames.ts
+var THEME_RADIUS_CSS_VARS = {
+  block: "--rb-block-radius",
+  button: "--rb-button-radius",
+  input: "--rb-input-radius",
+  legacyCard: "--radius-card",
+  legacyControl: "--radius-control"
+};
+
+// ../theme-core/src/blocks/vars/customer-portal.ts
+function generateCustomerPortalVars({
+  themeId
+}) {
+  const root = `:where([data-theme-scope="${themeId}"]) :where([data-block="customer-portal"])`;
+  return `
+${root} {
+  /* Container */
+  --cp-bg: rgb(var(--tb-surface));
+  --cp-text: rgb(var(--tb-text));
+  --cp-muted: rgb(var(--tb-mutedText));
+  --cp-border: rgb(var(--tb-border));
+  --cp-shadow: var(--shadow-elev);
+  --cp-primary: rgb(var(--tb-primary));
+  --cp-primary-hover: rgb(var(--tb-primary-700, var(--tb-primary)));
+  --cp-error: rgb(var(--tb-destructive));
+  --cp-card-radius: var(${THEME_RADIUS_CSS_VARS.block}, var(${THEME_RADIUS_CSS_VARS.legacyCard}, 0.75rem));
+  --cp-control-radius: var(${THEME_RADIUS_CSS_VARS.input}, var(${THEME_RADIUS_CSS_VARS.legacyControl}, 0.5rem));
+
+  /* Shared tab bar (underline style) */
+  --rb-tab-border-width: 1px;
+  --rb-tab-border-color: rgb(var(--tb-border));
+  --rb-tab-active-border-width: 2px;
+  --rb-tab-active-color: rgb(var(--tb-primary));
+  --rb-tab-text: rgb(var(--tb-text));
+  --rb-tab-opacity: 0.7;
+
+  /* Badge - Success (active, confirmed) */
+  --cp-badge-success-bg: rgba(var(--tb-success), 0.1);
+  --cp-badge-success-text: rgb(var(--tb-success));
+
+  /* Badge - Warning (paused, low credits, waitlist) */
+  --cp-badge-warning-bg: rgba(var(--tb-warning), 0.1);
+  --cp-badge-warning-text: rgb(var(--tb-warning));
+
+  /* Badge - Error (canceled, expired, past_due) */
+  --cp-badge-error-bg: rgba(var(--tb-destructive), 0.1);
+  --cp-badge-error-text: rgb(var(--tb-destructive));
+
+  /* Badge - Info (trialing, scheduled) */
+  --cp-badge-info-bg: rgba(var(--tb-primary), 0.1);
+  --cp-badge-info-text: rgb(var(--tb-primary));
+
+  /* Badge - Default (neutral states) */
+  --cp-badge-default-bg: rgba(var(--tb-mutedText), 0.1);
+  --cp-badge-default-text: rgb(var(--tb-mutedText));
+
+  /* Progress bar (for credit display) */
+  --cp-progress-bg: rgb(var(--tb-border));
+  --cp-progress-fill: rgb(var(--tb-primary));
+
+  /* Card styling */
+  --cp-card-bg: rgb(var(--tb-surface));
+  --cp-card-border: rgb(var(--tb-border));
+
+  /* Alert/notification */
+  --cp-alert-success-bg: rgba(var(--tb-success), 0.1);
+  --cp-alert-success-text: rgb(var(--tb-success));
+  --cp-alert-success-border: rgb(var(--tb-success));
+  --cp-alert-error-bg: rgba(var(--tb-destructive), 0.1);
+  --cp-alert-error-text: rgb(var(--tb-destructive));
+  --cp-alert-error-border: rgb(var(--tb-destructive));
+
+  /* Modal (shared rb-modal classes) */
+  --rb-modal-overlay-bg: rgb(var(--tb-text, 0 0 0) / 0.35);
+  --rb-modal-bg: var(--cp-card-bg);
+  --rb-modal-border: var(--cp-card-border);
+  --rb-modal-shadow: var(--shadow-lg, var(--shadow-elev));
+  --rb-modal-radius: var(--cp-card-radius);
+  --rb-modal-max-width: 560px;
+
+  /* Header */
+  --cp-header-bg: transparent;
+  --cp-header-border: rgb(var(--tb-border));
+
+  /* Section */
+  --cp-section-bg: transparent;
+}
+`;
+}
+
+// ../theme-core/src/blocks/vars/testimonials.ts
+var QUOTE_SCALE_SIZE = {
+  sm: "2.5rem",
+  md: "3.5rem",
+  // 4.375rem == 3.5rem * 1.25, matching the legacy accent-quote mark size.
+  lg: "4.375rem",
+  xl: "clamp(3.5rem, 2rem + 4vw, 5.5rem)"
+};
+function resolveTestimonialQuoteVars(treatment) {
+  if (!treatment) {
+    return {
+      size: QUOTE_SCALE_SIZE.md,
+      opacity: "0.08",
+      color: "rgb(var(--tb-primary))",
+      font: "inherit",
+      weight: "700",
+      display: "block"
+    };
+  }
+  if (treatment.style === "none") {
+    return {
+      size: QUOTE_SCALE_SIZE.md,
+      opacity: "0",
+      color: "rgb(var(--tb-primary))",
+      font: "inherit",
+      weight: "700",
+      display: "none"
+    };
+  }
+  const base = treatment.style === "serif-display" ? {
+    fontFamily: "heading",
+    scale: "xl",
+    colorToken: "primary",
+    opacity: 1
+  } : {
+    // accent-glyph
+    fontFamily: "body",
+    scale: "lg",
+    colorToken: "secondary",
+    opacity: 1
+  };
+  const fontFamily = treatment.fontFamily ?? base.fontFamily;
+  const scale = treatment.scale ?? base.scale;
+  const colorToken = treatment.colorToken ?? base.colorToken;
+  const opacity = treatment.opacity ?? base.opacity;
+  return {
+    size: QUOTE_SCALE_SIZE[scale],
+    opacity: String(opacity),
+    color: rgbColorValue(colorToken),
+    font: fontFamily === "heading" ? "var(--font-heading)" : "var(--font-body, inherit)",
+    // Heading-font display marks render at the family's natural weight (Forum
+    // ships a single 400) to avoid synthetic bold; glyph marks stay heavy.
+    weight: fontFamily === "heading" ? "400" : "700",
+    display: "block"
+  };
+}
+function generateTestimonialsVars({
+  themeId,
+  theme
+}) {
+  const root = `:where([data-theme-scope="${themeId}"]) :where([data-block="testimonials"])`;
+  const quote = resolveTestimonialQuoteVars(theme.testimonialQuote);
+  return `
+${root} {
+  --rb-testimonial-avatar-size: 3rem;
+  --rb-testimonial-avatar-border-radius: 9999px;
+  --rb-testimonial-quote-size: ${quote.size};
+  --rb-testimonial-quote-opacity: ${quote.opacity};
+  --rb-testimonial-quote-color: ${quote.color};
+  --rb-testimonial-quote-font: ${quote.font};
+  --rb-testimonial-quote-weight: ${quote.weight};
+  --rb-testimonial-quote-display: ${quote.display};
+
+  /* Carousel arrows: use the secondary chip so accent-band sections retain contrast. */
+  --rb-testimonial-carousel-arrow-bg: rgb(var(--tb-secondary));
+  --rb-testimonial-carousel-arrow-bg-hover: color-mix(in oklab, rgb(var(--tb-secondary)), rgb(var(--tb-text)) 14%);
+  --rb-testimonial-carousel-arrow-color: rgb(var(--tb-onSecondary));
+  --rb-testimonial-carousel-arrow-border-color: rgba(var(--tb-onSecondary), 0.22);
+  --rb-testimonial-carousel-arrow-size: 2.75rem;
+  --rb-testimonial-carousel-arrow-icon-size: 1.25rem;
+  --rb-testimonial-carousel-arrow-icon-stroke-width: 2.5;
+
+  /* Layout tuning */
+  --rb-testimonial-carousel-shadow-pad: 0.5rem;
+}
+`;
+}
+
+// ../theme-core/src/blocks/vars/course-details.ts
+function generateCourseDetailsVars({
+  themeId
+}) {
+  const root = `:where([data-theme-scope="${themeId}"]) :where([data-block="course-details"])`;
+  return `
+${root} {
+  /* Enrollment status */
+  --cd-enrollment-open-text: rgb(var(--tb-success));
+  --cd-enrollment-closed-text: rgb(var(--tb-mutedText));
+
+  /* Capacity indicator */
+  --cd-capacity-available-text: rgb(var(--tb-success));
+  --cd-capacity-low-text: rgb(var(--tb-warning));
+  --cd-capacity-full-text: rgb(var(--tb-destructive, 239 68 68));
+
+  /* Price styling */
+  --cd-price-free-text: rgb(var(--tb-success));
+}
+`;
+}
+
+// ../theme-core/src/blocks/vars/course-registration.ts
+function generateCourseRegistrationVars({
+  themeId
+}) {
+  const root = `:where([data-theme-scope="${themeId}"]) :where([data-block="course-registration"])`;
+  return `
+${root} {
+  /* Step indicator */
+  --cr-step-active: rgb(var(--tb-primary));
+  --cr-step-inactive: rgb(var(--tb-mutedText));
+  --cr-step-completed: rgb(var(--tb-success));
+  --cr-step-text: rgb(255 255 255);
+  --cr-step-text-active: rgb(var(--tb-primaryText, 255 255 255));
+  --cr-step-connector: rgba(var(--tb-border), 0.5);
+
+  /* Step title */
+  --cr-step-title-size: 1.5rem;
+
+  /* State backgrounds with alpha */
+  --cr-success-bg: rgba(var(--tb-success), 0.1);
+  --cr-success-text: rgb(var(--tb-success));
+  --cr-error-bg: rgba(var(--tb-destructive, 239 68 68), 0.1);
+  --cr-error-text: rgb(var(--tb-destructive, 239 68 68));
+  --cr-waitlist-bg: rgba(var(--tb-warning), 0.1);
+  --cr-waitlist-text: rgb(var(--tb-warning));
+
+  /* Capacity badges */
+  --cr-capacity-available-bg: rgba(var(--tb-success), 0.1);
+  --cr-capacity-available-text: rgb(var(--tb-success));
+  --cr-capacity-low-bg: rgba(var(--tb-warning), 0.1);
+  --cr-capacity-low-text: rgb(var(--tb-warning));
+  --cr-capacity-soldout-bg: rgba(var(--tb-destructive, 239 68 68), 0.1);
+  --cr-capacity-soldout-text: rgb(var(--tb-destructive, 239 68 68));
+
+  /* Borders */
+  --cr-border: rgb(var(--tb-border));
+  --cr-border-hover: rgba(var(--tb-primary), 0.5);
+  --cr-border-selected: rgb(var(--tb-primary));
+  --cr-border-error: rgb(var(--tb-destructive, 239 68 68));
+
+  /* Input focus */
+  --cr-focus-ring: rgba(var(--tb-primary), 0.3);
+
+  /* Required marker */
+  --cr-required: rgb(var(--tb-destructive, 239 68 68));
+
+  /* Payment option cards */
+  --cr-payment-border: rgb(var(--tb-border));
+  --cr-payment-border-hover: rgba(var(--tb-primary), 0.5);
+  --cr-payment-border-selected: rgb(var(--tb-primary));
+  --cr-payment-bg-selected: rgba(var(--tb-primary), 0.08);
+
+  /* Checkmark indicator */
+  --cr-check-bg: rgb(var(--tb-primary));
+  --cr-check-text: rgb(var(--tb-primaryText, 255 255 255));
+
+  /* Summary */
+  --cr-summary-bg: rgba(var(--tb-primary), 0.1);
+  --cr-summary-border: rgb(var(--tb-border));
+}
+`;
+}
+
+// ../theme-core/src/blocks/registry.ts
+var blockVarRegistry = /* @__PURE__ */ new Map();
+blockVarRegistry.set("event-registration", generateEventRegistrationVars);
+blockVarRegistry.set("event-calendar", generateEventCalendarVars);
+blockVarRegistry.set("event-listing", generateEventListingVars);
+blockVarRegistry.set("event-spotlight", generateEventSpotlightVars);
+blockVarRegistry.set("event-combined", generateEventCombinedVars);
+blockVarRegistry.set("appointment-booking", generateAppointmentBookingVars);
+blockVarRegistry.set("form", generateFormBlockVars);
+blockVarRegistry.set("customer-portal", generateCustomerPortalVars);
+blockVarRegistry.set("testimonials", generateTestimonialsVars);
+blockVarRegistry.set("course-details", generateCourseDetailsVars);
+blockVarRegistry.set("course-registration", generateCourseRegistrationVars);
+
+// ../theme-core/src/responsiveMode.ts
+var THEME_RESPONSIVE_MODE_ATTR = "data-rb-responsive-mode";
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var RESPONSIVE_SCOPE_RULE_PATTERN = new RegExp(
+  buildResponsiveScopeRulePatternSource(),
+  "g"
+);
+var RESPONSIVE_SCOPE_RULE_AT_PATTERN = new RegExp(
+  buildResponsiveScopeRulePatternSource(),
+  "y"
+);
+function buildResponsiveScopeRulePatternSource() {
+  return [
+    "@scope",
+    "\\(\\[",
+    escapeRegExp(THEME_RESPONSIVE_MODE_ATTR),
+    '="(?:viewport|container)"\\]\\)',
+    "to",
+    "\\((?::scope )?\\[",
+    escapeRegExp(THEME_RESPONSIVE_MODE_ATTR),
+    "\\]\\)",
+    "\\{"
+  ].join("\\s*");
+}
+
+// ../theme-core/src/ThemeScopeCore.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+
+// ../theme-core/src/ThemeScope.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+
+// ../theme-core/src/ThemeFontLoader.tsx
+import * as React from "react";
+import { Fragment, jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+
+// ../theme-core/src/fonts/uploadFormat.ts
+var MAX_FONT_UPLOAD_BYTES = 5 * 1024 * 1024;
+
+// ../theme-core/src/runtime/buildThemeRuntimeFromBridge.ts
+import { z as z57 } from "zod";
+var themeBridgeConfigSchema = z57.object({
+  tokens: z57.record(z57.string(), z57.string()),
+  typography: z57.object({
+    headingFamily: z57.string().optional(),
+    bodyFamily: z57.string().optional(),
+    headingWeight: z57.number().optional(),
+    bodyWeight: z57.number().optional()
+  }).optional(),
+  spacing: z57.enum(["comfortable", "standard", "dense"]).optional(),
+  corners: z57.enum(["square", "soft", "rounded", "pill"]).optional(),
+  shadows: z57.enum(["none", "low", "medium", "high"]).optional(),
+  components: z57.object({
+    buttons: z57.union([
+      z57.boolean(),
+      z57.object({
+        variants: z57.array(z57.enum(["primary", "secondary", "outline", "ghost"])).optional()
+      })
+    ]).optional(),
+    cards: z57.union([
+      z57.boolean(),
+      z57.object({
+        variants: z57.array(z57.enum(["default", "elevated", "outlined"])).optional()
+      })
+    ]).optional(),
+    inputs: z57.boolean().optional()
+  }).optional(),
+  overrides: z57.record(z57.string(), z57.string()).optional()
+}).passthrough();
+
+// ../theme-core/src/siteChrome.tsx
+import { Fragment as Fragment2, jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+
 // src/page-converter/block-summaries.ts
 function buildFieldSummary(input) {
   const nested = input.fields?.map((f) => buildFieldSummary(f));
@@ -27579,11 +28637,11 @@ function resolveModelForPass(passId, tierOverrides, passOverrides, globalModel)
 }
 
 // src/page-converter/passes/pass1-segmentation-matching.ts
-import { z as z60 } from "zod";
+import { z as z62 } from "zod";
 
 // src/manifest/passes/pass1-fields.ts
-import { z as z56 } from "zod";
-var simpleFieldTypeEnum = z56.enum([
+import { z as z58 } from "zod";
+var simpleFieldTypeEnum = z58.enum([
   "text",
   "richText",
   "media",
@@ -27592,7 +28650,7 @@ var simpleFieldTypeEnum = z56.enum([
   "select",
   "number"
 ]);
-var fieldTypeEnum = z56.enum([
+var fieldTypeEnum = z58.enum([
   "text",
   "richText",
   "media",
@@ -27603,109 +28661,109 @@ var fieldTypeEnum = z56.enum([
   "repeater",
   "group"
 ]);
-var linkDefaultValue = z56.object({
-  label: z56.string().describe("The visible link text")
+var linkDefaultValue = z58.object({
+  label: z58.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 = z58.object({
+  src: z58.string().describe("Image/video source URL"),
+  alt: z58.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 = z58.object({
+  id: z58.string().min(1).describe("camelCase field ID"),
   type: simpleFieldTypeEnum,
-  label: z56.string().min(1),
-  required: z56.boolean().nullable()
+  label: z58.string().min(1),
+  required: z58.boolean().nullable()
 });
-var simpleFieldSchema = z56.object({
-  id: z56.string().min(1).describe("camelCase field ID (e.g., headline, ctaButton)"),
+var simpleFieldSchema = z58.object({
+  id: z58.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: z58.string().min(1),
+  required: z58.boolean(),
+  multiline: z58.boolean().nullable().describe("For text fields: true if multiple lines"),
+  defaultValue: z58.union([
+    z58.string(),
+    z58.number(),
+    z58.boolean(),
     linkDefaultValue,
     mediaDefaultValue,
-    z56.null()
+    z58.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: z58.string().describe("Brief description of where this appears in the HTML")
+});
+var repeaterFieldSchema2 = z58.object({
+  id: z58.string().min(1).describe("camelCase field ID (e.g., socialLinks, features)"),
+  type: z58.literal("repeater"),
+  label: z58.string().min(1),
+  required: z58.boolean(),
+  itemLabel: z58.string().min(1).describe('Singular label for each item (e.g., "Link", "Feature")'),
+  itemFields: z58.array(nestedFieldSchema).min(1).describe("Fields for each item in the repeater"),
+  htmlContext: z58.string().describe("Brief description of where this appears in the HTML")
+});
+var groupFieldSchema2 = z58.object({
+  id: z58.string().min(1).describe("camelCase field ID (e.g., contactInfo, seoSettings)"),
+  type: z58.literal("group"),
+  label: z58.string().min(1),
+  required: z58.boolean(),
+  groupFields: z58.array(nestedFieldSchema).min(1).describe("Fields within the group"),
+  htmlContext: z58.string().describe("Brief description of where this appears in the HTML")
+});
+var extractedFieldSchema = z58.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 = z58.object({
+  identifier: z58.string().regex(/^[a-z0-9-]+$/).describe("Unique slug-safe identifier (e.g., wine-tasting-evening)"),
+  title: z58.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: z58.object({}).passthrough().describe("Entry data matching the content type schema")
+});
+var newContentTypeSchema = z58.object({
+  key: z58.string().regex(/^[a-z][a-z0-9-]*$/).describe("Content type key (e.g., testimonial, team-member)"),
+  name: z58.string().min(1).describe("Human-readable name"),
+  description: z58.string().nullable().describe("Description of this content type"),
+  fields: z58.array(z58.object({
+    id: z58.string().min(1),
+    type: z58.string().min(1),
+    label: z58.string().min(1),
+    required: z58.boolean().nullable(),
+    description: z58.string().nullable()
   })).min(1),
-  isRouted: z56.boolean().describe("Whether entries have their own pages")
+  isRouted: z58.boolean().describe("Whether entries have their own pages")
 });
-var contentTypeApproachSchema = z56.discriminatedUnion("approach", [
+var contentTypeApproachSchema = z58.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")
+  z58.object({
+    approach: z58.literal("existingContentType"),
+    contentTypeKey: z58.string().min(1).describe("Key of the existing content type to use"),
+    entries: z58.array(extractedEntrySchema).min(1).describe("Extracted entries"),
+    rationale: z58.string().describe("Why this content type fits")
   }),
   // Create a new content type
-  z56.object({
-    approach: z56.literal("newContentType"),
+  z58.object({
+    approach: z58.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: z58.array(extractedEntrySchema).min(1).describe("Extracted entries"),
+    rationale: z58.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")
+  z58.object({
+    approach: z58.literal("repeater"),
+    rationale: z58.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")
+  z58.object({
+    approach: z58.literal("none"),
+    rationale: z58.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 = z58.object({
+  blockId: z58.string().regex(/^custom\.[a-z][a-z0-9-]*$/).describe("Block ID like custom.hero-section"),
+  blockTitle: z58.string().min(1),
+  blockDescription: z58.string().nullable(),
+  category: z58.enum(["marketing", "content", "blog", "media", "layout", "interactive"]),
+  fields: z58.array(extractedFieldSchema).min(1),
   /**
    * Content type decision for list-like content.
    * When content types are available, the LLM may decide to use content entries
@@ -27773,11 +28831,12 @@ Your task: Analyze the HTML/JSX markup and identify ALL pieces of content that s
 
 1. **Use richText for formatted lists and multi-line content:**
    - Opening hours \u2192 single richText with formatted list (not 6 separate text fields)
-   - Address with line breaks \u2192 single richText (not address1, address2, city, postcode)
+   - Address with line breaks \u2192 single richText with hard line breaks / Shift+Enter between lines (not address1, address2, city, postcode)
    - Feature lists, specs, ingredients \u2192 richText with bullet list
 
-   RichText supports: paragraphs, bold, italic, bullet lists, numbered lists, links.
+   RichText supports: paragraphs, hard line breaks, bold, italic, bullet lists, numbered lists, links.
    The CMS editor can format content naturally without rigid field structure.
+   For line-oriented content like addresses, opening hours, and contact details, keep one logical paragraph and use hard line breaks between lines. In the CMS editor, authors create those line breaks with Shift+Enter; Enter creates a new paragraph.
 
 2. **Use repeaters only when items need individual editing/reordering:**
    - Testimonials with avatar + name + quote \u2192 repeater (each item is distinct)
@@ -27789,8 +28848,8 @@ Your task: Analyze the HTML/JSX markup and identify ALL pieces of content that s
    \u274C socialInstagram, socialFacebook, socialTwitter (proliferating similar fields)
    \u274C address1, address2, city, state, zip (5 fields for one address)
 
-   \u2705 openingHours: single richText field with formatted content
-   \u2705 address: single richText field with line breaks
+   \u2705 openingHours: single richText field with formatted content / hard line breaks
+   \u2705 address: single richText field with hard line breaks (Shift+Enter in the editor)
    \u2705 socialLinks: repeater with { platform, url } IF user needs to add/remove links
 
 ## Field Type Rules
@@ -27820,7 +28879,7 @@ Your task: Analyze the HTML/JSX markup and identify ALL pieces of content that s
 
 ### When to use each type:
 - Single value \u2192 simple field (text, richText, media, link)
-- Formatted list where structure is static \u2192 richText (opening hours, address)
+- Formatted list where structure is static \u2192 richText (opening hours, address; use hard line breaks / Shift+Enter for line-oriented text)
 - List where items can be added/removed/reordered \u2192 repeater
 - Related fields that belong together \u2192 group
 
@@ -27947,10 +29006,10 @@ async function getJsonFromAiText(ai, config, userMessage, schema) {
 }
 
 // src/manifest/passes/pass3-styling.ts
-import { z as z59 } from "zod";
+import { z as z61 } from "zod";
 
 // src/manifest/validation/output-schema.ts
-import { z as z58 } from "zod";
+import { z as z60 } from "zod";
 
 // src/manifest/validation/layout-utils.ts
 function collectLayoutNodeInfos(node, path2 = "layout", out = []) {
@@ -27991,14 +29050,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 z59 } from "zod";
+var titleSourceValueSchema = z59.union([
+  z59.string().min(1),
+  z59.array(z59.string().min(1)).min(1)
 ]);
 
 // src/manifest/validation/output-schema.ts
-var blockCategoryEnum2 = z58.enum([
+var blockCategoryEnum2 = z60.enum([
   "marketing",
   "content",
   "blog",
@@ -28006,53 +29065,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 = z60.object({
+  name: z60.string(),
+  hex: z60.string()
+});
+var llmThemePrimitive = z60.union([
+  z60.string(),
+  z60.number(),
+  z60.boolean(),
+  z60.null()
 ]);
-var llmThemePatchValue = z58.union([
+var llmThemePatchValue = z60.union([
   llmThemePrimitive,
   llmColorValue,
-  z58.array(llmColorValue),
-  z58.array(llmThemePrimitive)
+  z60.array(llmColorValue),
+  z60.array(llmThemePrimitive)
 ]);
-var llmThemePatchOpSchema = z58.discriminatedUnion("op", [
-  z58.object({
-    op: z58.literal("add"),
-    path: z58.string().min(1),
+var llmThemePatchOpSchema = z60.discriminatedUnion("op", [
+  z60.object({
+    op: z60.literal("add"),
+    path: z60.string().min(1),
     value: llmThemePatchValue
   }),
-  z58.object({
-    op: z58.literal("replace"),
-    path: z58.string().min(1),
+  z60.object({
+    op: z60.literal("replace"),
+    path: z60.string().min(1),
     value: llmThemePatchValue
   }),
-  z58.object({ op: z58.literal("remove"), path: z58.string().min(1) })
+  z60.object({ op: z60.literal("remove"), path: z60.string().min(1) })
 ]);
-var llmCssDeclaration = z58.object({
-  property: z58.string(),
-  value: z58.string()
+var llmCssDeclaration = z60.object({
+  property: z60.string(),
+  value: z60.string()
 });
-var llmCustomCssRuleSchema = z58.object({
-  id: z58.string().min(1),
-  selector: z58.string().min(1),
-  declarations: z58.array(llmCssDeclaration)
+var llmCustomCssRuleSchema = z60.object({
+  id: z60.string().min(1),
+  selector: z60.string().min(1),
+  declarations: z60.array(llmCssDeclaration)
 });
-var llmNestedRuleSchema = z58.object({
-  selector: z58.string().min(1),
-  declarations: z58.array(llmCssDeclaration)
+var llmNestedRuleSchema = z60.object({
+  selector: z60.string().min(1),
+  declarations: z60.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 = z60.object({
+  id: z60.string().min(1),
+  type: z60.literal("media"),
+  query: z60.string().min(1),
+  rules: z60.array(llmNestedRuleSchema)
 });
 function normalizeDeclarationsArrayToRecord(declarations) {
   const record = {};
@@ -28082,85 +29141,85 @@ function normalizeLlmMediaAtRule(atRule) {
     rules: atRule.rules.map(normalizeLlmNestedRule)
   };
 }
-var jsonPrimitiveSchema = z58.union([
-  z58.string(),
-  z58.number(),
-  z58.boolean(),
-  z58.null()
+var jsonPrimitiveSchema = z60.union([
+  z60.string(),
+  z60.number(),
+  z60.boolean(),
+  z60.null()
 ]);
-var jsonValueSchema = z58.union([
+var jsonValueSchema = z60.union([
   jsonPrimitiveSchema,
-  z58.array(jsonPrimitiveSchema)
+  z60.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 = z60.object({
+  id: z60.string().min(1),
+  label: z60.string().min(1),
+  description: z60.string().nullable(),
+  required: z60.boolean(),
   defaultValue: jsonValueSchema.nullable()
 });
 var llmTextFieldSchema = llmBaseFieldSchema.extend({
-  type: z58.literal("text"),
-  multiline: z58.boolean(),
-  maxLength: z58.number().int().positive().nullable()
+  type: z60.literal("text"),
+  multiline: z60.boolean(),
+  maxLength: z60.number().int().positive().nullable()
 });
 var llmRichTextFieldSchema = llmBaseFieldSchema.extend({
-  type: z58.literal("richText")
+  type: z60.literal("richText")
 });
 var llmMediaFieldSchema = llmBaseFieldSchema.extend({
-  type: z58.literal("media"),
-  mediaKinds: z58.array(z58.enum(["image", "video", "audio"])).nullable()
+  type: z60.literal("media"),
+  mediaKinds: z60.array(z60.enum(["image", "video", "audio"])).nullable()
 });
 var llmFileFieldSchema = llmBaseFieldSchema.extend({
-  type: z58.literal("file"),
-  fileKinds: z58.array(z58.enum(["document", "spreadsheet", "archive", "audio"])).nullable()
+  type: z60.literal("file"),
+  fileKinds: z60.array(z60.enum(["document", "spreadsheet", "archive", "audio"])).nullable()
 });
 var llmBooleanFieldSchema = llmBaseFieldSchema.extend({
-  type: z58.literal("boolean")
+  type: z60.literal("boolean")
 });
 var llmLinkFieldSchema = llmBaseFieldSchema.extend({
-  type: z58.literal("link")
+  type: z60.literal("link")
 });
 var llmSelectFieldSchema = llmBaseFieldSchema.extend({
-  type: z58.literal("select"),
-  options: z58.array(
-    z58.object({
-      value: z58.string(),
-      label: z58.string()
+  type: z60.literal("select"),
+  options: z60.array(
+    z60.object({
+      value: z60.string(),
+      label: z60.string()
     })
   ),
-  multiple: z58.boolean().nullable()
+  multiple: z60.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: z60.literal("number")
+});
+var llmNestedFieldSchema = z60.object({
+  id: z60.string(),
+  type: z60.string(),
+  label: z60.string(),
+  required: z60.boolean().nullable(),
+  multiline: z60.boolean().nullable(),
   defaultValue: jsonValueSchema.nullable()
 }).passthrough();
-var llmNestedFieldsSchema = z58.array(llmNestedFieldSchema);
+var llmNestedFieldsSchema = z60.array(llmNestedFieldSchema);
 var llmGroupFieldSchema = llmBaseFieldSchema.extend({
-  type: z58.literal("group"),
-  schema: z58.object({
+  type: z60.literal("group"),
+  schema: z60.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: z60.literal("repeater"),
+  itemLabel: z60.string(),
+  itemLabelSource: z60.string().nullable(),
+  minItems: z60.number().int().min(0),
+  maxItems: z60.number().int().positive().nullable(),
+  allowConversion: z60.boolean(),
+  schema: z60.object({
     fields: llmNestedFieldsSchema
   })
 });
-var llmFieldSchema = z58.union([
+var llmFieldSchema = z60.union([
   llmTextFieldSchema,
   llmRichTextFieldSchema,
   llmMediaFieldSchema,
@@ -28172,66 +29231,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 = z60.object({
+  from: z60.string(),
+  fallback: z60.string().nullable(),
+  transforms: z60.array(
+    z60.object({
+      id: z60.string()
     })
   ).nullable()
 });
-var llmRepeatSchema = z58.object({
-  collection: z58.object({ from: z58.string() }),
-  itemName: z58.string()
+var llmRepeatSchema = z60.object({
+  collection: z60.object({ from: z60.string() }),
+  itemName: z60.string()
 });
-var llmPropsSchema = z58.object({}).passthrough().nullable();
+var llmPropsSchema = z60.object({}).passthrough().nullable();
 function buildLlmNodeSchema(maxDepth) {
-  const nodeBase = z58.object({
-    type: z58.string(),
+  const nodeBase = z60.object({
+    type: z60.string(),
     props: llmPropsSchema,
     $bind: llmBindingSchema.nullable(),
     $repeat: llmRepeatSchema.nullable(),
-    $when: z58.object({
-      condition: z58.object({ from: z58.string() })
+    $when: z60.object({
+      condition: z60.object({ from: z60.string() })
     }).nullable()
   });
-  let schema = nodeBase.extend({ children: z58.null() });
+  let schema = nodeBase.extend({ children: z60.null() });
   for (let i = 0; i < maxDepth; i++) {
-    schema = nodeBase.extend({ children: z58.array(schema).nullable() });
+    schema = nodeBase.extend({ children: z60.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 = z60.object({
+  id: z60.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: z60.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: z60.string().nullable(),
   category: blockCategoryEnum2,
-  icon: z58.string().nullable(),
-  tags: z58.array(z58.string()).nullable(),
+  icon: z60.string().nullable(),
+  tags: z60.array(z60.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 = z60.object({
+  blocks: z60.array(llmCustomBlockSchema).min(1, "At least one block is required").max(10, "Maximum 10 blocks per conversion"),
+  themePatch: z60.array(llmThemePatchOpSchema).nullable(),
+  customCssRules: z60.array(llmCustomCssRuleSchema).nullable(),
+  customCssAtRules: z60.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: z60.string().nullable()
 });
 function collectValidationErrors(output) {
   const errors = [];
@@ -29194,20 +30253,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 = z61.object({
+  classNamePatches: z61.array(
+    z61.object({
+      nodePath: z61.string(),
       // "" for root, "children[0]", "children[0].children[1]" etc.
-      className: z59.string().min(1)
+      className: z61.string().min(1)
     })
   ),
-  rationale: z59.string()
+  rationale: z61.string()
 });
-var pass3bOutputSchema = z59.object({
-  customCssRules: z59.array(llmCustomCssRuleSchema).nullable(),
-  customCssAtRules: z59.array(llmMediaAtRuleSchema).nullable(),
-  rationale: z59.string()
+var pass3bOutputSchema = z61.object({
+  customCssRules: z61.array(llmCustomCssRuleSchema).nullable(),
+  customCssAtRules: z61.array(llmMediaAtRuleSchema).nullable(),
+  rationale: z61.string()
 });
 function getNodeAtPath(layout, path2) {
   if (path2 === "" || path2 === "root" || path2 === "layout") {
@@ -29514,38 +30573,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 = z62.enum(["header", "content", "footer"]);
+var blockCategoryEnum3 = z62.enum(["marketing", "content", "blog", "media", "layout", "interactive"]);
+var baseSectionSchema = z62.object({
+  html: z62.string().min(1),
+  purpose: z62.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: z62.literal("builtin"),
+  matchedBlock: z62.string().min(1),
+  matchScore: z62.number().min(0).max(100),
+  matchRationale: z62.string().min(1)
 });
 var customMatchSchema = baseSectionSchema.extend({
-  decision: z60.literal("custom"),
-  customBlockSuggestion: z60.object({
-    title: z60.string().min(1),
+  decision: z62.literal("custom"),
+  customBlockSuggestion: z62.object({
+    title: z62.string().min(1),
     category: blockCategoryEnum3
   })
 });
-var sectionMatchSchema = z60.discriminatedUnion("decision", [
+var sectionMatchSchema = z62.discriminatedUnion("decision", [
   builtinMatchSchema,
   customMatchSchema
 ]);
-var skippedContentSchema = z60.object({
-  description: z60.string(),
-  reason: z60.string()
+var skippedContentSchema = z62.object({
+  description: z62.string(),
+  reason: z62.string()
 });
-var combinedPassSchema = z60.object({
-  sections: z60.array(sectionMatchSchema).min(1),
-  skippedContent: z60.array(skippedContentSchema).nullable(),
-  rationale: z60.string()
+var combinedPassSchema = z62.object({
+  sections: z62.array(sectionMatchSchema).min(1),
+  skippedContent: z62.array(skippedContentSchema).nullable(),
+  rationale: z62.string()
 });
 function buildSystemPrompt(availableBlocks, matchThreshold) {
   const blockCatalog = availableBlocks.map((b) => {
@@ -29752,10 +30811,10 @@ async function segmentAndMatchBlocks(html, availableBlocks, ctx) {
 }
 
 // src/page-converter/passes/pass2-population.ts
-import { z as z62 } from "zod";
+import { z as z64 } from "zod";
 
 // src/manifest/three-pass-converter.ts
-import { z as z61 } from "zod";
+import { z as z63 } from "zod";
 
 // src/manifest/prompt/theme-summary.ts
 var WEIGHT_MAP = {
@@ -29915,43 +30974,8 @@ function formatThemeSummaryForPrompt(summary) {
 }
 
 // src/manifest/three-pass-converter.ts
-function parseInlineMarkdown(text2) {
-  const out = [];
-  const pushText = (value, marks) => {
-    if (!value) return;
-    out.push(
-      marks && marks.length > 0 ? { type: "text", text: value, marks } : { type: "text", text: value }
-    );
-  };
-  let rest = text2;
-  while (rest.length > 0) {
-    const start = rest.indexOf("**");
-    if (start === -1) {
-      pushText(rest);
-      break;
-    }
-    const end = rest.indexOf("**", start + 2);
-    if (end === -1) {
-      pushText(rest);
-      break;
-    }
-    pushText(rest.slice(0, start));
-    pushText(rest.slice(start + 2, end), [{ type: "bold" }]);
-    rest = rest.slice(end + 2);
-  }
-  return out;
-}
 function stringToTipTapDoc(text2) {
-  const normalized = text2.replace(/\r\n/g, "\n").trim();
-  if (!normalized) return { type: "doc", content: [] };
-  const paragraphs = normalized.split(/\n{2,}/).map((p) => p.trim()).filter(Boolean);
-  return {
-    type: "doc",
-    content: paragraphs.map((p) => {
-      const inline2 = parseInlineMarkdown(p);
-      return inline2.length > 0 ? { type: "paragraph", content: inline2 } : { type: "paragraph" };
-    })
-  };
+  return createRichTextDocFromMarkdown(text2);
 }
 function coerceRichTextDefaultValue(value) {
   if (value === null || value === void 0) {
@@ -30091,9 +31115,9 @@ function mapPass1FieldToOutputField(field) {
     maxLength: null
   };
 }
-var pass2OutputSchema = z61.object({
+var pass2OutputSchema = z63.object({
   layout: llmNodeSchema,
-  rationale: z61.string().describe("Explain which node binds to which field")
+  rationale: z63.string().describe("Explain which node binds to which field")
 });
 function buildPass2SystemPrompt(fields3, contentTypeApproach) {
   const fieldList = fields3.map((f) => {
@@ -30953,9 +31977,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 = z64.object({
+  content: z64.unknown(),
+  rationale: z64.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"]);