@riverbankcms/sdk 0.82.0 → 0.84.1

package/dist/cli/index.mjs

@@ -110,6 +110,30 @@ var init_collections = __esm({
 });
 
 // ../core/src/event-pricing.ts
+function publicEventPricingType(pricing) {
+  switch (pricing.kind) {
+    case "drop_in":
+    case "free_registration":
+      return "free";
+    case "single_paid":
+    case "ticket_types":
+    case "course":
+      return isFreePublicEventPriceDisplay(pricing.display) ? "free" : "paid";
+  }
+}
+function isFreePublicEventPriceDisplay(display) {
+  switch (display.kind) {
+    case "free":
+      return true;
+    case "course":
+      return display.display.kind === "free";
+    case "exact":
+    case "from":
+    case "mixed":
+    case "unavailable":
+      return false;
+  }
+}
 var init_event_pricing = __esm({
   "../core/src/event-pricing.ts"() {
   }
@@ -140,8 +164,139 @@ var init_booking_instalments = __esm({
 });
 
 // ../core/src/booking-date-time.ts
+function isValidTimeZone(timeZone) {
+  try {
+    new Intl.DateTimeFormat(DEFAULT_LOCALE, { timeZone }).format(/* @__PURE__ */ new Date());
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getSafeTimeZone(timeZone) {
+  const normalized = typeof timeZone === "string" ? timeZone.trim() : "";
+  return normalized && isValidTimeZone(normalized) ? normalized : FALLBACK_TIMEZONE;
+}
+function parseStrictBookingTimeZone(timeZone) {
+  const normalized = timeZone.trim();
+  if (!normalized || !isValidTimeZone(normalized)) {
+    return null;
+  }
+  return normalized;
+}
+function formatParseError(error) {
+  switch (error.reason) {
+    case "invalid_starts_at":
+      return `Expected a valid UTC/offset-aware ISO datetime in startsAt, received "${error.value}"`;
+    case "invalid_ends_at":
+      return `Expected a valid UTC/offset-aware ISO datetime in endsAt, received "${error.value ?? ""}"`;
+    case "invalid_time_zone":
+      return `Expected a valid IANA timezone in timeZone, received "${error.value}"`;
+  }
+}
+function formatToPartsLookup(date, locale, timeZone, format) {
+  return new Map(
+    new Intl.DateTimeFormat(locale, {
+      ...format,
+      timeZone
+    }).formatToParts(date).map((part) => [part.type, part.value])
+  );
+}
+function getZonedDateTimeParts(date, timeZone) {
+  const parts = formatToPartsLookup(date, "en-GB", timeZone, {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: false
+  });
+  const read = (type) => Number(parts.get(type) ?? "");
+  return {
+    year: read("year"),
+    month: read("month"),
+    day: read("day"),
+    hour: read("hour"),
+    minute: read("minute"),
+    second: read("second")
+  };
+}
+function formatDateKey(date) {
+  const year = String(date.year).padStart(4, "0");
+  const month = String(date.month).padStart(2, "0");
+  const day = String(date.day).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function parseUtcIsoDateTimeString(value) {
+  const normalized = value.trim();
+  const hasUtcSuffix = normalized.endsWith("Z");
+  const hasExplicitOffset = /[+-]\d{2}:\d{2}$/u.test(normalized);
+  if (!hasUtcSuffix && !hasExplicitOffset) {
+    return err("missing-timezone-offset");
+  }
+  const date = new Date(normalized);
+  if (Number.isNaN(date.getTime())) {
+    return err("invalid-date-time");
+  }
+  return ok(date.toISOString());
+}
+function toUtcIsoDateTimeString(value) {
+  const parsed = parseUtcIsoDateTimeString(value);
+  if (!parsed.ok) {
+    const message = parsed.error === "missing-timezone-offset" ? `Expected an offset-aware ISO datetime, received "${value}"` : `Expected a valid ISO datetime, received "${value}"`;
+    throw new Error(message);
+  }
+  return parsed.value;
+}
+function parseScheduledBookingDateTime(input) {
+  try {
+    const startsAt = toUtcIsoDateTimeString(input.startsAt);
+    const timeZone = parseStrictBookingTimeZone(input.timeZone);
+    if (!timeZone) {
+      return {
+        ok: false,
+        field: "timeZone",
+        reason: "invalid_time_zone",
+        value: input.timeZone
+      };
+    }
+    return {
+      ok: true,
+      value: {
+        startsAt,
+        timeZone,
+        locale: input.locale
+      }
+    };
+  } catch {
+    return {
+      ok: false,
+      field: "startsAt",
+      reason: "invalid_starts_at",
+      value: input.startsAt
+    };
+  }
+}
+function toScheduledBookingDateTime(input) {
+  const result = parseScheduledBookingDateTime(input);
+  if (result.ok) {
+    return result.value;
+  }
+  throw new Error(formatParseError(result));
+}
+function getBookingLocalDateKey(input) {
+  return formatDateKey(getLocalScheduleDate(new Date(input.startsAt), input.timeZone));
+}
+function getLocalScheduleDate(date, timeZone) {
+  const parts = getZonedDateTimeParts(date, getSafeTimeZone(timeZone));
+  return { year: parts.year, month: parts.month, day: parts.day };
+}
+var DEFAULT_LOCALE, FALLBACK_TIMEZONE;
 var init_booking_date_time = __esm({
   "../core/src/booking-date-time.ts"() {
+    init_result();
+    DEFAULT_LOCALE = "en-US";
+    FALLBACK_TIMEZONE = "UTC";
   }
 });
 
@@ -1279,7 +1434,7 @@ function createSdkSelectField(input) {
     })
   );
 }
-var visibilityLevels, MEDIA_KINDS, DISPLAY_MEDIA_KINDS, PUBLIC_FILE_FIELD_KINDS, siteOptionSources, mediaDeliverySchema, selectOptionSchema, selectSourceSchema, uiSchema, baseFieldSchema, textFieldSchema, richTextFieldSchema, mediaFieldSchema, fileFieldSchema, booleanFieldSchema, dateFieldSchema, timeFieldSchema, dateTimeFieldSchema, slugFieldSchema, urlFieldSchema, linkFieldSchema, selectFieldSchema, referenceFieldSchema, itemTypeSchema, repeaterFieldSchema, groupFieldSchema, modalFieldSchema, numberFieldSchema, tabDefinitionSchema, tabGroupFieldSchema, presetOptionSchema, presetOrCustomFieldSchema, contentTypeSelectFieldSchema, entryPickerFieldSchema, _fieldSchemaInternal, fieldSchema, slotSchema, typographyTokens, colorTokens, spacingTokens, radiusTokens, styleTokenSchema, behaviourSchema, quickFieldPrioritySchema, previewCustomizeManifestCurationSchema, blockCategoryEnum;
+var visibilityLevels, MEDIA_KINDS, DISPLAY_MEDIA_KINDS, PUBLIC_FILE_FIELD_KINDS, siteOptionSources, mediaDeliverySchema, selectOptionSchema, selectSourceSchema, visibleWhenPredicateSchema, visibleWhenSchema, uiSchema, baseFieldSchema, textFieldSchema, richTextFieldSchema, mediaFieldSchema, fileFieldSchema, booleanFieldSchema, dateFieldSchema, timeFieldSchema, dateTimeFieldSchema, slugFieldSchema, urlFieldSchema, linkFieldSchema, selectFieldSchema, referenceFieldSchema, itemTypeSchema, repeaterFieldSchema, groupFieldSchema, modalFieldSchema, numberFieldSchema, tabDefinitionSchema, tabGroupFieldSchema, presetOptionSchema, presetOrCustomFieldSchema, contentTypeSelectFieldSchema, entryPickerFieldSchema, _fieldSchemaInternal, fieldSchema, slotSchema, typographyTokens, colorTokens, spacingTokens, radiusTokens, styleTokenSchema, behaviourSchema, quickFieldPrioritySchema, previewCustomizeManifestCurationSchema, blockCategoryEnum;
 var init_schema2 = __esm({
   "../blocks/src/system/manifest/schema.ts"() {
     init_src2();
@@ -1337,6 +1492,21 @@ var init_schema2 = __esm({
         kind: z.literal("sdk")
       })
     ]);
+    visibleWhenPredicateSchema = z.object({
+      field: z.string().min(1),
+      equals: z.any().optional(),
+      notEquals: z.any().optional(),
+      oneOf: z.array(z.any()).optional(),
+      notIn: z.array(z.any()).optional(),
+      minItems: z.number().int().nonnegative().optional(),
+      maxItems: z.number().int().nonnegative().optional()
+    });
+    visibleWhenSchema = z.union([
+      visibleWhenPredicateSchema,
+      z.object({
+        allOf: z.array(visibleWhenPredicateSchema).min(1)
+      })
+    ]);
     uiSchema = z.object({
       widget: z.string().optional(),
       // Container/widget presets (used by Group/Repeater widgets themselves, not for widget selection)
@@ -1369,13 +1539,7 @@ var init_schema2 = __esm({
       showValue: z.boolean().optional(),
       pattern: z.string().optional(),
       placeholder: z.string().optional(),
-      visibleWhen: z.object({
-        field: z.string().min(1),
-        equals: z.any().optional(),
-        notEquals: z.any().optional(),
-        oneOf: z.array(z.any()).optional(),
-        notIn: z.array(z.any()).optional()
-      }).optional(),
+      visibleWhen: visibleWhenSchema.optional(),
       // Modal configuration for modal and group fields
       modalConfig: z.object({
         buttonLabel: z.string().optional(),
@@ -2106,6 +2270,7 @@ var init_types2 = __esm({
     ];
     eyebrowTreatmentValues = [
       "plain",
+      "accent",
       "pill",
       "accent-pill",
       "pill-bounce",
@@ -5735,6 +5900,101 @@ var init_joy_stamp = __esm({
   }
 });
 
+// ../theme-core/src/buttons/personalities/ornate-ritual.ts
+var ornateRitual;
+var init_ornate_ritual = __esm({
+  "../theme-core/src/buttons/personalities/ornate-ritual.ts"() {
+    init_types5();
+    ornateRitual = defineButtonPersonality({
+      id: "ornate-ritual",
+      name: "Ornate Ritual",
+      description: "Ceremonial framed buttons with jewel-toned fills and quiet color-change hover states.",
+      tags: { tone: "classic", energy: "vibrant", motion: "subtle", era: "organic" },
+      buttonSystem: {
+        global: {
+          cornerStyle: "rounded",
+          shadow: "none",
+          textTransform: "uppercase",
+          fontWeight: 600,
+          borderWidth: 1,
+          hoverTransform: "none",
+          hoverColor: "none",
+          letterSpacing: "loose"
+        },
+        sizes: {
+          sm: { padding: "0.5625rem 1.25rem", fontSize: "text-xs" },
+          md: { padding: "0.75rem 1.75rem", fontSize: "text-xs" },
+          lg: { padding: "0.875rem 2.25rem", fontSize: "text-sm" },
+          xl: { padding: "1rem 2.75rem", fontSize: "text-base" }
+        },
+        variants: [
+          {
+            id: "primary",
+            name: "Primary",
+            enabled: true,
+            priority: 1,
+            background: { type: "solid", colorToken: "primary" },
+            textColorToken: "primaryForeground",
+            borderRadius: "rounded-md",
+            border: { widthClass: "border", colorToken: "primary" },
+            shadow: { elevation: "none", softness: null, position: "bottom" },
+            effects: {
+              hover: [{ effectId: "background-on-hover", options: { colorToken: "primary-100" } }],
+              active: [{ effectId: "scale-down", options: { scale: "0.98" } }]
+            }
+          },
+          {
+            id: "secondary",
+            name: "Secondary",
+            enabled: true,
+            priority: 2,
+            background: { type: "solid", colorToken: "secondary" },
+            textColorToken: "primaryForeground",
+            borderRadius: "rounded-md",
+            border: { widthClass: "border", colorToken: "primary" },
+            shadow: { elevation: "none", softness: null, position: "bottom" },
+            effects: {
+              hover: [{ effectId: "background-on-hover", options: { colorToken: "surface" } }]
+            }
+          },
+          {
+            id: "outline",
+            name: "Outline",
+            enabled: true,
+            priority: 3,
+            background: { type: "transparent" },
+            textColorToken: "primary",
+            borderRadius: "rounded-md",
+            border: { widthClass: "border", colorToken: "primary" },
+            shadow: { elevation: "none", softness: null, position: "bottom" },
+            effects: {
+              hover: [{ effectId: "background-on-hover", options: { colorToken: "muted" } }]
+            }
+          },
+          {
+            id: "ghost",
+            name: "Ghost",
+            enabled: true,
+            priority: 3,
+            background: { type: "transparent" },
+            textColorToken: "accent",
+            borderRadius: "rounded-none",
+            sizes: {
+              sm: { padding: "0.375rem 0", fontSize: "text-xs" },
+              md: { padding: "0.5rem 0", fontSize: "text-sm" },
+              lg: { padding: "0.625rem 0", fontSize: "text-base" },
+              xl: { padding: "0.75rem 0", fontSize: "text-lg" }
+            },
+            effects: {
+              base: [{ effectId: "border-bottom-grow", options: { height: 1, colorToken: "accent", origin: "left" } }]
+            }
+          }
+        ]
+      }
+    });
+  }
+});
+
 // ../theme-core/src/buttons/personalities/pebble.ts
 var pebble;
 var init_pebble = __esm({
@@ -6029,6 +6289,7 @@ var init_personalities = __esm({
     init_editorial_link();
     init_ink_stamp();
     init_joy_stamp();
+    init_ornate_ritual();
     init_pebble();
     init_showtime_pill();
     init_soft_pill();
@@ -6042,7 +6303,8 @@ var init_personalities = __esm({
       inkStamp,
       brushedWash,
       showtimePill,
-      joyStamp
+      joyStamp,
+      ornateRitual
     ];
     personalitiesById = new Map(
       buttonPersonalities.map((p) => [p.id, p])
@@ -6776,7 +7038,7 @@ function rgbColorValue(token) {
   if (alpha === void 0) {
     return `rgb(var(${cssVar}))`;
   }
-  return `rgba(var(${cssVar}), ${alpha})`;
+  return `rgb(var(${cssVar}) / ${alpha})`;
 }
 function backgroundColorStyle(token) {
   return { backgroundColor: rgbColorValue(token) };
@@ -7920,7 +8182,7 @@ var init_warm_neutral = __esm({
 });
 
 // ../theme-core/src/palette/variants/warm-dark.ts
-var warmDarkEmber;
+var warmDarkEmber, warmDarkKirtanGold;
 var init_warm_dark = __esm({
   "../theme-core/src/palette/variants/warm-dark.ts"() {
     init_types12();
@@ -7946,6 +8208,28 @@ var init_warm_dark = __esm({
         { name: "border", hex: "#894e31" }
       ]
     });
+    warmDarkKirtanGold = definePaletteVariant({
+      id: "warm-dark-kirtan-gold",
+      name: "Warm Dark \u2014 Kirtan Gold",
+      description: "Deep plum ground with pale gold primary, rose accent, and soft devotional text.",
+      tags: { tone: "bold", energy: "calm", era: "editorial" },
+      mode: "dark",
+      colors: [
+        { name: "primary", hex: "#ffcdb2" },
+        { name: "secondary", hex: "#b5838d" },
+        { name: "accent", hex: "#e5989b" },
+        { name: "success", hex: "#8fbf8f" },
+        { name: "warning", hex: "#f2b86b" },
+        { name: "destructive", hex: "#d96b6b" },
+        { name: "background", hex: "#403944" },
+        { name: "surface", hex: "#403944" },
+        { name: "surfaceAlt", hex: "#372f3b" },
+        { name: "muted", hex: "#4d4550" },
+        { name: "text", hex: "#e6d2d5" },
+        { name: "primaryForeground", hex: "#403944" },
+        { name: "border", hex: "#8d747a" }
+      ]
+    });
   }
 });
 
@@ -7983,7 +8267,8 @@ var init_variants = __esm({
       softNaturalWatercolor,
       softNaturalLilac,
       // Warm-dark family (dark mode)
-      warmDarkEmber
+      warmDarkEmber,
+      warmDarkKirtanGold
     ];
     paletteVariantsById = new Map(
       paletteVariants.map((v) => [v.id, v])
@@ -9596,8 +9881,69 @@ var init_headerLooks = __esm({
 function asFooterLookId(value) {
   return value;
 }
+function asFooterLayoutId(value) {
+  return value;
+}
+function asFooterStyleId(value) {
+  return value;
+}
+function identityQuietFooter(theme) {
+  return {
+    ...theme.footer,
+    variant: "simple",
+    maxWidth: "container",
+    background: {
+      type: "color",
+      color: "surface"
+    },
+    navStyle: "minimal",
+    navWeight: "regular",
+    navColor: "text",
+    navLinkStyle: {
+      typography: "body",
+      fontWeight: "regular",
+      textTransform: "none",
+      italic: false,
+      colorToken: "text",
+      hoverColorToken: "primary",
+      padding: "none",
+      borderRadius: "none"
+    },
+    navLayout: {
+      layout: "inline-wrap",
+      align: "start",
+      gapX: "default",
+      gapY: "tight"
+    },
+    logo: {
+      showLogo: true,
+      showLogoText: true,
+      placement: "left",
+      size: "sm",
+      align: "start"
+    },
+    bottomBar: {
+      enabled: false,
+      fullBleed: false,
+      textAlign: "left",
+      paddingX: "default",
+      paddingY: "compact",
+      borderTop: {
+        width: "none"
+      }
+    }
+  };
+}
 function mutedGroundingFooter(theme) {
-  return theme.footer;
+  return {
+    ...identityQuietFooter(theme),
+    background: theme.footer.background,
+    navStyle: theme.footer.navStyle,
+    navColor: theme.footer.navColor,
+    navWeight: theme.footer.navWeight,
+    navLinkStyle: theme.footer.navLinkStyle,
+    bottomTextLinkStyle: theme.footer.bottomTextLinkStyle
+  };
 }
 function brandTwoBandFooter(theme) {
   return {
@@ -9702,6 +10048,53 @@ function centeredCalmFooter(theme) {
     }
   };
 }
+function splitEditorialFooter(theme) {
+  return {
+    ...theme.footer,
+    variant: "split",
+    maxWidth: "container",
+    background: {
+      type: "color",
+      color: "surface"
+    },
+    navStyle: "minimal",
+    navWeight: "regular",
+    navColor: "text",
+    navLinkStyle: {
+      typography: "body",
+      fontWeight: "regular",
+      textTransform: "none",
+      italic: false,
+      colorToken: "text",
+      hoverColorToken: "primary",
+      padding: "none",
+      borderRadius: "none"
+    },
+    navLayout: {
+      layout: "inline-wrap",
+      align: "start",
+      gapX: "relaxed",
+      gapY: "tight"
+    },
+    logo: {
+      showLogo: true,
+      showLogoText: true,
+      placement: "right",
+      size: "sm",
+      align: "end"
+    },
+    bottomBar: {
+      enabled: true,
+      fullBleed: false,
+      textAlign: "left",
+      paddingX: "default",
+      paddingY: "compact",
+      borderTop: {
+        width: "thin"
+      }
+    }
+  };
+}
 function editorialColumnsFooter(theme) {
   return {
     ...theme.footer,
@@ -9746,31 +10139,108 @@ function editorialColumnsFooter(theme) {
 function findFooterLook(id) {
   return footerLooksById.get(id);
 }
-var footerLookCatalog, footerLooksById;
+var footerLayoutCatalog, footerStyleCatalog, footerLookCatalog, footerLooksById;
 var init_footerLooks = __esm({
   "../theme-core/src/site-styles/footerLooks.ts"() {
     init_customizableSurfaces();
     init_types2();
+    footerLayoutCatalog = defineExactCatalog()([
+      {
+        id: asFooterLayoutId("identity"),
+        label: "Identity",
+        description: "Logo, site text, address, and legal copy without relying on footer navigation."
+      },
+      {
+        id: asFooterLayoutId("centered"),
+        label: "Centered",
+        description: "A calm centered stack for identity, short copy, and optional compact navigation.",
+        maxRecommendedNavDensity: "sparse"
+      },
+      {
+        id: asFooterLayoutId("split"),
+        label: "Split",
+        description: "Navigation and brand signoff separated into a wider split footer.",
+        requiresFooterNav: true,
+        maxRecommendedNavDensity: "balanced"
+      },
+      {
+        id: asFooterLayoutId("columns"),
+        label: "Columns",
+        description: "Grouped footer navigation columns with a supporting bottom line.",
+        requiresFooterNav: true,
+        requiresFooterNavGroups: true
+      }
+    ]);
+    footerStyleCatalog = defineExactCatalog()([
+      {
+        id: asFooterStyleId("quiet"),
+        label: "Quiet",
+        description: "Lightweight, practical footer treatment."
+      },
+      {
+        id: asFooterStyleId("calm"),
+        label: "Calm",
+        description: "Soft centered treatment with restrained dividers."
+      },
+      {
+        id: asFooterStyleId("editorial"),
+        label: "Editorial",
+        description: "Text-forward treatment with fine-line structure."
+      },
+      {
+        id: asFooterStyleId("brand-band"),
+        label: "Brand band",
+        description: "High-contrast brand treatment with a stronger bottom bar."
+      }
+    ]);
+    new Map(
+      footerLayoutCatalog.map((layout) => [layout.id, layout])
+    );
+    new Map(
+      footerStyleCatalog.map((style) => [style.id, style])
+    );
     footerLookCatalog = defineExactCatalog()([
+      {
+        id: asFooterLookId("footer-identity-quiet"),
+        label: "Identity footer",
+        layoutId: asFooterLayoutId("identity"),
+        styleId: asFooterStyleId("quiet"),
+        compile: identityQuietFooter
+      },
       {
         id: asFooterLookId("footer-muted-grounding"),
         label: "Muted grounding footer",
+        layoutId: asFooterLayoutId("identity"),
+        styleId: asFooterStyleId("quiet"),
+        hiddenFromLayoutStyleControls: true,
         compile: mutedGroundingFooter
       },
       {
         id: asFooterLookId("footer-centered-calm"),
         label: "Centered calm footer",
+        layoutId: asFooterLayoutId("centered"),
+        styleId: asFooterStyleId("calm"),
         compile: centeredCalmFooter
       },
+      {
+        id: asFooterLookId("footer-split-editorial"),
+        label: "Split editorial footer",
+        layoutId: asFooterLayoutId("split"),
+        styleId: asFooterStyleId("editorial"),
+        compile: splitEditorialFooter
+      },
       {
         id: asFooterLookId("footer-editorial-columns"),
         label: "Editorial columns footer",
+        layoutId: asFooterLayoutId("columns"),
+        styleId: asFooterStyleId("editorial"),
         compile: editorialColumnsFooter
       },
       {
         id: asFooterLookId("site-footer-brand-two-band"),
         label: "Two-band brand footer",
-        maxRecommendedNavDensity: "balanced",
+        layoutId: asFooterLayoutId("split"),
+        styleId: asFooterStyleId("brand-band"),
         allowedContentPresence: ["default-footer", "default-and-blocks"],
         compile: brandTwoBandFooter
       }
@@ -9861,7 +10331,7 @@ function defineTypographyPreset(preset2) {
 function findTypographyPreset(id) {
   return typographyPresetsById.get(id);
 }
-var bodyReadablePolicy, headingFlexiblePolicy, displayHeadingPolicy, modernSansTypography, warmRoundedTypography, editorialSerifTypography, classicSerifTypography, luxeContrastTypography, boldDisplayTypography, originalJoyTypography, typographyPresets, typographyPresetsById;
+var bodyReadablePolicy, headingFlexiblePolicy, displayHeadingPolicy, modernSansTypography, warmRoundedTypography, editorialSerifTypography, classicSerifTypography, luxeContrastTypography, kirtanOrnateTypography, boldDisplayTypography, originalJoyTypography, typographyPresets, typographyPresetsById;
 var init_typographyPresets = __esm({
   "../theme-core/src/site-styles/typographyPresets.ts"() {
     bodyReadablePolicy = {
@@ -9993,6 +10463,30 @@ var init_typographyPresets = __esm({
       },
       scale: "spacious"
     };
+    kirtanOrnateTypography = {
+      body: {
+        family: "Jost, system-ui, sans-serif",
+        size: "md",
+        weight: "regular",
+        lineHeight: "relaxed",
+        letterSpacing: "normal"
+      },
+      headings: {
+        default: {
+          family: "Marcellus, Georgia, serif",
+          weight: "regular",
+          lineHeight: "normal",
+          letterSpacing: "normal",
+          colorToken: "primary",
+          italic: null,
+          case: null
+        },
+        h1: { size: "2xl", weight: "regular", lineHeight: "normal", letterSpacing: "normal", italic: null },
+        h2: { size: "xl", weight: "regular", lineHeight: "normal", letterSpacing: "normal", italic: null },
+        h3: { size: "md", weight: "regular", lineHeight: "relaxed", letterSpacing: "normal", italic: null }
+      },
+      scale: "spacious"
+    };
     boldDisplayTypography = {
       body: {
         family: "Manrope, system-ui, sans-serif",
@@ -10027,16 +10521,16 @@ var init_typographyPresets = __esm({
       },
       headings: {
         default: {
-          family: "Bricolage Grotesque, system-ui, sans-serif",
-          weight: "bold",
+          family: "Lobster, cursive",
+          weight: "regular",
           lineHeight: "normal",
-          letterSpacing: "tight",
+          letterSpacing: "normal",
           italic: null,
           case: null
         },
-        h1: { size: "2xl", weight: "bold", lineHeight: "normal", letterSpacing: "tight", italic: null },
-        h2: { size: "xl", weight: "bold", lineHeight: "normal", letterSpacing: "tight", italic: null },
-        h3: { size: "lg", weight: "bold", lineHeight: "normal", letterSpacing: "tight", italic: null }
+        h1: { size: "2xl", weight: "regular", lineHeight: "normal", letterSpacing: "normal", italic: null },
+        h2: { size: "xl", weight: "regular", lineHeight: "normal", letterSpacing: "normal", italic: null },
+        h3: { size: "lg", weight: "regular", lineHeight: "normal", letterSpacing: "normal", italic: null }
       },
       scale: "balanced"
     };
@@ -10101,6 +10595,32 @@ var init_typographyPresets = __esm({
         slotPolicies: { body: bodyReadablePolicy, heading: displayHeadingPolicy },
         typography: luxeContrastTypography
       }),
+      defineTypographyPreset({
+        id: "typography-preset:kirtan-ornate",
+        name: "Kirtan Ornate",
+        description: "Marcellus devotional headings over a refined Jost body, matching dark ceremonial layouts.",
+        defaultFonts: { body: "Jost, system-ui, sans-serif", heading: "Marcellus, Georgia, serif" },
+        recommendedFonts: {
+          body: ["Jost", "Manrope", "Inter"],
+          heading: ["Marcellus", "Cormorant Garamond", "Playfair Display"]
+        },
+        slotPolicies: { body: bodyReadablePolicy, heading: displayHeadingPolicy },
+        typography: kirtanOrnateTypography,
+        heroTypography: {
+          headlineSize: "6xl",
+          headlineLineHeight: "normal",
+          subheadlineSize: "xl",
+          subheadlineLineHeight: "relaxed",
+          microHeadlineSize: "5xl",
+          microHeadlineLineHeight: "normal",
+          microSubheadlineSize: "lg",
+          microSubheadlineLineHeight: "relaxed",
+          responsive: {
+            tablet: { headlineSize: "5xl" },
+            mobile: { headlineSize: "4xl", subheadlineSize: "lg" }
+          }
+        }
+      }),
       defineTypographyPreset({
         id: "typography-preset:bold-display",
         name: "Bold Display",
@@ -10130,11 +10650,11 @@ var init_typographyPresets = __esm({
       defineTypographyPreset({
         id: "typography-preset:original-joy",
         name: "Original Joy",
-        description: "Bold Bricolage Grotesque display headings over a clean DM Sans body, editorial and warm.",
-        defaultFonts: { body: "DM Sans, system-ui, sans-serif", heading: "Bricolage Grotesque, system-ui, sans-serif" },
+        description: "Lobster display headings over a clean DM Sans body, expressive and warm.",
+        defaultFonts: { body: "DM Sans, system-ui, sans-serif", heading: "Lobster, cursive" },
         recommendedFonts: {
           body: ["DM Sans", "Inter", "Manrope"],
-          heading: ["Bricolage Grotesque", "Space Grotesk", "Archivo"]
+          heading: ["Lobster", "Bricolage Grotesque", "Space Grotesk"]
         },
         slotPolicies: { body: bodyReadablePolicy, heading: displayHeadingPolicy },
         typography: originalJoyTypography,
@@ -10159,6 +10679,228 @@ var init_typographyPresets = __esm({
     );
   }
 });
+function uniqueNonEmpty(values) {
+  const uniqueValues = [...new Set(values)];
+  const firstValue = uniqueValues[0];
+  if (!firstValue) {
+    throw new Error("Expected at least one Theme V2 design state option.");
+  }
+  return [firstValue, ...uniqueValues.slice(1)];
+}
+var themeV2DesignStateSchemaVersion, designResolutionPolicySchema, runtimeStyleFieldNameSchema, nonEmptyRuntimeStyleFieldNamesSchema, heroLegibilityStrategySchema, heroCompositionIntentSchema, heroTypographyScaleIntentSchema, sectionHeightIntentSchema, imageSurfaceTreatmentIntensitySchema, imageSurfaceMotionSchema, imageSurfaceTreatmentSchema, testimonialCardTreatmentSchema, tileTreatmentSchema, eventListTreatmentSchema, eyebrowTreatmentSchema, userPanelTreatments, userFlushTreatments, userFlushBleeds, contentFrameIntentSchema, blockDesignPlanSchema, styleAuthoritySchema, blockRuntimeStyleAuthoritySchema;
+var init_designState = __esm({
+  "../theme-core/src/site-styles/designState.ts"() {
+    init_sourceCatalogs();
+    init_types2();
+    init_schemaVersionedJson();
+    init_rawStyleFields();
+    init_rawStyleFields();
+    themeV2DesignStateSchemaVersion = 1;
+    designResolutionPolicySchema = z.enum(["generated", "user", "admin", "sdk"]);
+    runtimeStyleFieldNameSchema = z.enum(themeV2RuntimeStyleFieldNames);
+    nonEmptyRuntimeStyleFieldNamesSchema = z.array(runtimeStyleFieldNameSchema).min(1).transform((fields3) => [
+      fields3[0],
+      ...fields3.slice(1)
+    ]);
+    heroLegibilityStrategySchema = z.enum([
+      "none",
+      "scrim-gradient",
+      "solid-panel"
+    ]);
+    heroCompositionIntentSchema = z.enum([
+      "center",
+      "bottom-left"
+    ]);
+    heroTypographyScaleIntentSchema = z.enum([
+      "quiet",
+      "editorial",
+      "display",
+      "poster"
+    ]);
+    sectionHeightIntentSchema = z.enum([
+      "default",
+      "banner",
+      "hero",
+      "immersive"
+    ]);
+    imageSurfaceTreatmentIntensitySchema = z.enum(["soft", "balanced", "strong"]);
+    imageSurfaceMotionSchema = z.enum(["static", "fixed-frame"]);
+    imageSurfaceTreatmentSchema = z.discriminatedUnion("kind", [
+      z.object({ kind: z.literal("none") }).strict(),
+      z.object({
+        kind: z.literal("brand-scrim"),
+        token: z.enum(["primary", "secondary", "accent"]),
+        intensity: imageSurfaceTreatmentIntensitySchema.optional()
+      }).strict(),
+      z.object({
+        kind: z.literal("brand-wash"),
+        token: z.enum(["primary", "secondary", "accent"]),
+        intensity: imageSurfaceTreatmentIntensitySchema.optional()
+      }).strict(),
+      z.object({
+        kind: z.literal("neutral-scrim"),
+        intensity: imageSurfaceTreatmentIntensitySchema.optional()
+      }).strict(),
+      z.object({
+        kind: z.literal("neutral-wash"),
+        intensity: imageSurfaceTreatmentIntensitySchema.optional()
+      }).strict(),
+      z.object({
+        kind: z.literal("solid-panel"),
+        intensity: imageSurfaceTreatmentIntensitySchema.optional()
+      }).strict()
+    ]);
+    testimonialCardTreatmentSchema = z.enum(["default", "accent-quote"]);
+    tileTreatmentSchema = z.enum(tileTreatmentValues);
+    eventListTreatmentSchema = z.enum(eventListTreatmentValues);
+    eyebrowTreatmentSchema = z.enum(eyebrowTreatmentValues);
+    userPanelTreatments = uniqueNonEmpty(
+      userDesignOptionCatalog.contentFrames.filter((frame) => frame.kind === "panel").map((frame) => frame.treatment)
+    );
+    userFlushTreatments = uniqueNonEmpty(
+      userDesignOptionCatalog.contentFrames.filter((frame) => frame.kind === "flush-panel").map((frame) => frame.treatment)
+    );
+    userFlushBleeds = uniqueNonEmpty(
+      userDesignOptionCatalog.contentFrames.filter((frame) => frame.kind === "flush-panel").map((frame) => frame.bleed)
+    );
+    contentFrameIntentSchema = z.discriminatedUnion("kind", [
+      z.object({ kind: z.literal("plain") }).strict(),
+      z.object({
+        kind: z.literal("panel"),
+        treatment: z.enum(userPanelTreatments)
+      }).strict(),
+      z.object({
+        kind: z.literal("flush-panel"),
+        treatment: z.enum(userFlushTreatments),
+        bleed: z.enum(userFlushBleeds)
+      }).strict()
+    ]);
+    blockDesignPlanSchema = z.object({
+      blockId: z.string().min(1).transform(asDesignBlockId),
+      blockKind: z.string().min(1),
+      purpose: z.string().min(1),
+      sectionSurface: z.enum(userDesignOptionCatalog.sectionSurfaces),
+      contentFrame: contentFrameIntentSchema,
+      itemSurface: z.enum(userDesignOptionCatalog.itemSurfaces),
+      transitionAfter: z.enum(userDesignOptionCatalog.transitions),
+      emphasis: z.enum(userDesignOptionCatalog.emphases),
+      sectionHeight: sectionHeightIntentSchema.optional(),
+      heroLegibility: heroLegibilityStrategySchema.optional(),
+      heroComposition: heroCompositionIntentSchema.optional(),
+      heroTypographyScale: heroTypographyScaleIntentSchema.optional(),
+      imageSurfaceTreatment: imageSurfaceTreatmentSchema.optional(),
+      imageSurfaceMotion: imageSurfaceMotionSchema.optional(),
+      testimonialCardTreatment: testimonialCardTreatmentSchema.optional(),
+      tileTreatment: tileTreatmentSchema.optional(),
+      eventListTreatment: eventListTreatmentSchema.optional(),
+      eyebrowTreatment: eyebrowTreatmentSchema.optional()
+    }).strict();
+    styleAuthoritySchema = z.discriminatedUnion("kind", [
+      z.object({
+        kind: z.literal("theme-v2"),
+        source: designResolutionPolicySchema,
+        siteStyleId: z.string().min(1).transform(asSiteStyleId),
+        templateId: z.string().min(1).transform(asDesignSystemTemplateId),
+        templateVersion: z.number().int().nonnegative(),
+        resolverVersion: z.number().int().nonnegative()
+      }).strict(),
+      z.object({
+        kind: z.literal("legacy-raw"),
+        reason: z.enum(["pre-theme-v2", "manual-runtime-fields"])
+      }).strict(),
+      z.object({
+        kind: z.literal("advanced-detached"),
+        reason: z.literal("detached-custom-runtime-fields")
+      }).strict()
+    ]);
+    blockRuntimeStyleAuthoritySchema = z.object({
+      unit: z.literal("block-runtime-fields"),
+      blockId: z.string().min(1).transform(asDesignBlockId),
+      fields: nonEmptyRuntimeStyleFieldNamesSchema,
+      authority: styleAuthoritySchema
+    }).strict();
+    z.object({
+      schemaVersion: z.literal(themeV2DesignStateSchemaVersion),
+      siteStyleId: z.string().min(1).transform(asSiteStyleId),
+      templateId: z.string().min(1).transform(asDesignSystemTemplateId),
+      templateVersion: z.number().int().nonnegative(),
+      resolverVersion: z.number().int().nonnegative(),
+      rhythmPresetId: z.string().min(1),
+      blocks: z.array(blockDesignPlanSchema),
+      styleAuthorities: z.array(blockRuntimeStyleAuthoritySchema)
+    }).strict();
+  }
+});
+
+// ../theme-core/src/site-styles/runtimeCompiler.ts
+function defineDesignRuntimeRules(rules) {
+  return rules;
+}
+function uniformSectionForeground(token) {
+  return {
+    textColor: token,
+    headingColor: token,
+    linkColor: token,
+    supportingColor: token
+  };
+}
+var defaultDesignRuntimeRules;
+var init_runtimeCompiler = __esm({
+  "../theme-core/src/site-styles/runtimeCompiler.ts"() {
+    init_schema3();
+    init_modern_minimal();
+    init_expandPalette();
+    init_personalities();
+    init_variants();
+    init_designState();
+    init_types2();
+    init_accessibleSurfaces();
+    defaultDesignRuntimeRules = defineDesignRuntimeRules({
+      sectionSurfaces: {
+        base: {},
+        "muted-band": {
+          background: {
+            type: "color",
+            color: "muted"
+          }
+        },
+        "accent-band": {
+          background: {
+            type: "color",
+            color: "primary"
+          }
+        },
+        "brand-depth-band": {
+          background: {
+            type: "color",
+            color: "primary-800"
+          }
+        },
+        "hero-image": {
+          background: {
+            type: "image",
+            opacity: 1,
+            position: "center center",
+            ...uniformSectionForeground("text")
+          }
+        }
+      },
+      heroLegibility: {
+        "scrim-gradient": {
+          type: "gradient",
+          gradient: "linear-gradient(180deg, rgba(255,255,255,0.38) 0%, rgba(244,241,234,0.62) 90%)",
+          opacity: 1
+        },
+        "solid-panel": {
+          type: "color",
+          color: "surface",
+          opacity: 0.88
+        }
+      },
+      transitionClassName: (transition, fromSurface, toSurface) => transition === "none" ? null : `site-style-transition-${transition}-from-${fromSurface}-to-${toSurface}`
+    });
+  }
+});
 
 // ../theme-core/src/site-styles/curatedSiteStyles.ts
 function uniqueContentFrameKinds() {
@@ -10217,6 +10959,7 @@ function defineCuratedSiteStyle(input) {
     // clean/minimal styles default to none.
     headingDecoration: input.headingDecoration ?? noHeadingDecoration,
     ...input.themeOverrides ? { themeOverrides: input.themeOverrides } : {},
+    ...input.designRuntimeRules ? { designRuntimeRules: input.designRuntimeRules } : {},
     ...input.defaultBlockVariants ? { defaultBlockVariants: input.defaultBlockVariants } : {},
     recommendedAppearancePresetIds: (input.recommendedAppearancePresetIds ?? []).map(asAppearancePresetId),
     defaultHeaderSelection: input.defaultHeaderSelection ? {
@@ -10401,7 +11144,7 @@ function defaultTypographyPresetChoicesForRecipe(recipe) {
 function getCuratedSiteStyle(id) {
   return curatedSiteStylesById.get(id) ?? null;
 }
-var SOFT_EARTH_SITE_STYLE_ID_VALUE, SOFT_EARTH_SITE_STYLE_ID, curatedSiteStyleIdValues, quietBudget, balancedBudget, expressiveBudget, expressiveUnderlineInputs, generatedContentFrameKinds, curatedSiteStyles, curatedSiteStylesById;
+var SOFT_EARTH_SITE_STYLE_ID_VALUE, SOFT_EARTH_SITE_STYLE_ID, curatedSiteStyleIdValues, quietBudget, balancedBudget, expressiveBudget, kirtanOrnateDesignRuntimeRules, expressiveUnderlineInputs, ornateDarkInputs, generatedContentFrameKinds, curatedSiteStyles, curatedSiteStylesById;
 var init_curatedSiteStyles = __esm({
   "../theme-core/src/site-styles/curatedSiteStyles.ts"() {
     init_personalities();
@@ -10415,6 +11158,7 @@ var init_curatedSiteStyles = __esm({
     init_sourceCatalogs();
     init_types2();
     init_typographyPresets();
+    init_runtimeCompiler();
     SOFT_EARTH_SITE_STYLE_ID_VALUE = "site-style:soft-earth";
     SOFT_EARTH_SITE_STYLE_ID = asSiteStyleId(SOFT_EARTH_SITE_STYLE_ID_VALUE);
     curatedSiteStyleIdValues = [
@@ -10432,6 +11176,7 @@ var init_curatedSiteStyles = __esm({
       SOFT_EARTH_SITE_STYLE_ID_VALUE,
       "site-style:bold-launch",
       "site-style:south-west-twerk-school",
+      "site-style:kirtan-ornate",
       "site-style:original-joy"
     ];
     quietBudget = {
@@ -10458,6 +11203,50 @@ var init_curatedSiteStyles = __esm({
       mediaDensity: "high",
       decorativeRepetition: "medium"
     };
+    kirtanOrnateDesignRuntimeRules = defineDesignRuntimeRules({
+      ...defaultDesignRuntimeRules,
+      defaultEyebrowTreatment: "accent",
+      sectionSurfaces: {
+        ...defaultDesignRuntimeRules.sectionSurfaces,
+        "muted-band": {
+          background: {
+            type: "color",
+            color: "muted"
+          },
+          foreground: {
+            textColor: "text",
+            headingColor: "primary",
+            linkColor: "primary",
+            supportingColor: "text"
+          }
+        },
+        "brand-depth-band": {
+          background: {
+            type: "color",
+            color: "primary-800"
+          },
+          foreground: {
+            textColor: "text",
+            headingColor: "primary",
+            linkColor: "primary",
+            supportingColor: "text"
+          }
+        },
+        "hero-image": {
+          background: {
+            type: "image",
+            opacity: 1,
+            position: "center center"
+          },
+          foreground: {
+            textColor: "text",
+            headingColor: "primary",
+            linkColor: "primary",
+            supportingColor: "text"
+          }
+        }
+      }
+    });
     expressiveUnderlineInputs = {
       base: {
         background: { type: "transparent" },
@@ -10495,6 +11284,43 @@ var init_curatedSiteStyles = __esm({
         opacity: 0.6
       }
     };
+    ornateDarkInputs = {
+      base: {
+        background: { type: "solid", colorToken: "surfaceAlt" },
+        textColorToken: "text",
+        border: {
+          widthClass: "border",
+          colorToken: "primary/45",
+          style: "all"
+        },
+        corners: "square",
+        shadow: null,
+        spacing: "medium",
+        fontSize: "base"
+      },
+      label: {
+        textColorToken: "primary",
+        fontWeight: "semibold",
+        fontSize: "xs",
+        textTransform: "uppercase",
+        letterSpacing: "wider",
+        opacity: 1
+      },
+      focus: {
+        ringColorToken: "primary/18",
+        ringWidth: "2",
+        borderColorToken: "primary/70"
+      },
+      error: {
+        borderColorToken: "destructive",
+        textColorToken: "destructive"
+      },
+      disabled: {
+        backgroundColorToken: "muted",
+        textColorToken: "mutedText",
+        opacity: 0.6
+      }
+    };
     generatedContentFrameKinds = uniqueContentFrameKinds();
     curatedSiteStyles = [
       defineCuratedSiteStyle({
@@ -11265,6 +12091,80 @@ var init_curatedSiteStyles = __esm({
           paletteChoice("high-contrast-ink")
         ]
       }),
+      defineCuratedSiteStyle({
+        id: "site-style:kirtan-ornate",
+        name: "Kirtan Ornate",
+        headingDecoration: { family: "short-center-rule", colorToken: "accent" },
+        description: "Ceremonial, jewel-toned, and devotional: ornate frames, warm contrast, and composed rhythm for intimate music gatherings.",
+        generationBrief: "Use a deep plum ground with pale gold as the main brand color, rose accent details, cream text, spacious split hero sections, devotional editorial headings, compact event lists, and framed conversion sections. The mood should feel soulful and ceremonial, not gothic or theatrical.",
+        selectionKeywordRules: [
+          { kind: "word", value: "kirtan" },
+          { kind: "word", value: "chanting" },
+          { kind: "word", value: "ceremony" },
+          { kind: "word", value: "devotional" }
+        ],
+        tokenRecipes: {
+          palette: "brand-led",
+          contrast: "strong",
+          radius: "soft",
+          shadow: "subtle",
+          typography: "serif-editorial",
+          spacing: "airy",
+          motion: "subtle"
+        },
+        compositionBudget: expressiveBudget,
+        typographyPresetChoices: [
+          typographyChoice("typography-preset:kirtan-ornate"),
+          typographyChoice("typography-preset:luxe-contrast"),
+          typographyChoice("typography-preset:editorial-serif")
+        ],
+        defaultTypographyPresetId: "typography-preset:kirtan-ornate",
+        themeOverrides: {
+          accordions: warmInsetAccordionSystem,
+          cards: originalJoyCardSystem,
+          testimonialQuote: serifDisplayQuote,
+          bodyText: {
+            intro: {
+              paragraphSize: "editorial",
+              headingSize: "editorial"
+            }
+          },
+          inputs: ornateDarkInputs
+        },
+        designRuntimeRules: kirtanOrnateDesignRuntimeRules,
+        recommendedAppearancePresetIds: [
+          "hero-brand-scrim-fixed-frame",
+          "media-text-quiet-story",
+          "events-lined-panel",
+          "schedule-details-brand-depth",
+          "testimonials-statement-cards",
+          "contact-form-panel"
+        ],
+        defaultHeaderSelection: { layoutId: "floating", styleId: "minimal-surface" },
+        recommendedHeaderLayoutChoices: [headerLayoutChoice("floating")],
+        recommendedHeaderStyleChoicesByLayout: {
+          floating: [
+            headerStyleChoice("minimal-surface"),
+            headerStyleChoice("split-glass"),
+            headerStyleChoice("glass")
+          ]
+        },
+        recommendedHeaderLookIds: ["minimal-transparent"],
+        recommendedFooterLookIds: [
+          "site-footer-brand-two-band",
+          "footer-muted-grounding"
+        ],
+        buttonPersonalityChoices: [
+          buttonChoice("ornate-ritual"),
+          buttonChoice("joy-stamp"),
+          buttonChoice("ink-stamp")
+        ],
+        paletteVariantChoices: [
+          paletteChoice("warm-dark-kirtan-gold"),
+          paletteChoice("warm-dark-ember"),
+          paletteChoice("brand-led-burgundy-gold")
+        ]
+      }),
       defineCuratedSiteStyle({
         id: "site-style:original-joy",
         name: "Original Joy",
@@ -11400,170 +12300,6 @@ var init_resolver2 = __esm({
     init_types2();
   }
 });
-function uniqueNonEmpty(values) {
-  const uniqueValues = [...new Set(values)];
-  const firstValue = uniqueValues[0];
-  if (!firstValue) {
-    throw new Error("Expected at least one Theme V2 design state option.");
-  }
-  return [firstValue, ...uniqueValues.slice(1)];
-}
-var themeV2DesignStateSchemaVersion, designResolutionPolicySchema, runtimeStyleFieldNameSchema, nonEmptyRuntimeStyleFieldNamesSchema, heroLegibilityStrategySchema, heroCompositionIntentSchema, heroTypographyScaleIntentSchema, sectionHeightIntentSchema, imageSurfaceTreatmentIntensitySchema, imageSurfaceMotionSchema, imageSurfaceTreatmentSchema, testimonialCardTreatmentSchema, tileTreatmentSchema, eventListTreatmentSchema, eyebrowTreatmentSchema, userPanelTreatments, userFlushTreatments, userFlushBleeds, contentFrameIntentSchema, blockDesignPlanSchema, styleAuthoritySchema, blockRuntimeStyleAuthoritySchema;
-var init_designState = __esm({
-  "../theme-core/src/site-styles/designState.ts"() {
-    init_sourceCatalogs();
-    init_types2();
-    init_schemaVersionedJson();
-    init_rawStyleFields();
-    init_rawStyleFields();
-    themeV2DesignStateSchemaVersion = 1;
-    designResolutionPolicySchema = z.enum(["generated", "user", "admin", "sdk"]);
-    runtimeStyleFieldNameSchema = z.enum(themeV2RuntimeStyleFieldNames);
-    nonEmptyRuntimeStyleFieldNamesSchema = z.array(runtimeStyleFieldNameSchema).min(1).transform((fields3) => [
-      fields3[0],
-      ...fields3.slice(1)
-    ]);
-    heroLegibilityStrategySchema = z.enum([
-      "none",
-      "scrim-gradient",
-      "solid-panel"
-    ]);
-    heroCompositionIntentSchema = z.enum([
-      "center",
-      "bottom-left"
-    ]);
-    heroTypographyScaleIntentSchema = z.enum([
-      "quiet",
-      "editorial",
-      "display",
-      "poster"
-    ]);
-    sectionHeightIntentSchema = z.enum([
-      "default",
-      "banner",
-      "hero",
-      "immersive"
-    ]);
-    imageSurfaceTreatmentIntensitySchema = z.enum(["soft", "balanced", "strong"]);
-    imageSurfaceMotionSchema = z.enum(["static", "fixed-frame"]);
-    imageSurfaceTreatmentSchema = z.discriminatedUnion("kind", [
-      z.object({ kind: z.literal("none") }).strict(),
-      z.object({
-        kind: z.literal("brand-scrim"),
-        token: z.enum(["primary", "secondary", "accent"]),
-        intensity: imageSurfaceTreatmentIntensitySchema.optional()
-      }).strict(),
-      z.object({
-        kind: z.literal("brand-wash"),
-        token: z.enum(["primary", "secondary", "accent"]),
-        intensity: imageSurfaceTreatmentIntensitySchema.optional()
-      }).strict(),
-      z.object({
-        kind: z.literal("neutral-scrim"),
-        intensity: imageSurfaceTreatmentIntensitySchema.optional()
-      }).strict(),
-      z.object({
-        kind: z.literal("neutral-wash"),
-        intensity: imageSurfaceTreatmentIntensitySchema.optional()
-      }).strict(),
-      z.object({
-        kind: z.literal("solid-panel"),
-        intensity: imageSurfaceTreatmentIntensitySchema.optional()
-      }).strict()
-    ]);
-    testimonialCardTreatmentSchema = z.enum(["default", "accent-quote"]);
-    tileTreatmentSchema = z.enum(tileTreatmentValues);
-    eventListTreatmentSchema = z.enum(eventListTreatmentValues);
-    eyebrowTreatmentSchema = z.enum(eyebrowTreatmentValues);
-    userPanelTreatments = uniqueNonEmpty(
-      userDesignOptionCatalog.contentFrames.filter((frame) => frame.kind === "panel").map((frame) => frame.treatment)
-    );
-    userFlushTreatments = uniqueNonEmpty(
-      userDesignOptionCatalog.contentFrames.filter((frame) => frame.kind === "flush-panel").map((frame) => frame.treatment)
-    );
-    userFlushBleeds = uniqueNonEmpty(
-      userDesignOptionCatalog.contentFrames.filter((frame) => frame.kind === "flush-panel").map((frame) => frame.bleed)
-    );
-    contentFrameIntentSchema = z.discriminatedUnion("kind", [
-      z.object({ kind: z.literal("plain") }).strict(),
-      z.object({
-        kind: z.literal("panel"),
-        treatment: z.enum(userPanelTreatments)
-      }).strict(),
-      z.object({
-        kind: z.literal("flush-panel"),
-        treatment: z.enum(userFlushTreatments),
-        bleed: z.enum(userFlushBleeds)
-      }).strict()
-    ]);
-    blockDesignPlanSchema = z.object({
-      blockId: z.string().min(1).transform(asDesignBlockId),
-      blockKind: z.string().min(1),
-      purpose: z.string().min(1),
-      sectionSurface: z.enum(userDesignOptionCatalog.sectionSurfaces),
-      contentFrame: contentFrameIntentSchema,
-      itemSurface: z.enum(userDesignOptionCatalog.itemSurfaces),
-      transitionAfter: z.enum(userDesignOptionCatalog.transitions),
-      emphasis: z.enum(userDesignOptionCatalog.emphases),
-      sectionHeight: sectionHeightIntentSchema.optional(),
-      heroLegibility: heroLegibilityStrategySchema.optional(),
-      heroComposition: heroCompositionIntentSchema.optional(),
-      heroTypographyScale: heroTypographyScaleIntentSchema.optional(),
-      imageSurfaceTreatment: imageSurfaceTreatmentSchema.optional(),
-      imageSurfaceMotion: imageSurfaceMotionSchema.optional(),
-      testimonialCardTreatment: testimonialCardTreatmentSchema.optional(),
-      tileTreatment: tileTreatmentSchema.optional(),
-      eventListTreatment: eventListTreatmentSchema.optional(),
-      eyebrowTreatment: eyebrowTreatmentSchema.optional()
-    }).strict();
-    styleAuthoritySchema = z.discriminatedUnion("kind", [
-      z.object({
-        kind: z.literal("theme-v2"),
-        source: designResolutionPolicySchema,
-        siteStyleId: z.string().min(1).transform(asSiteStyleId),
-        templateId: z.string().min(1).transform(asDesignSystemTemplateId),
-        templateVersion: z.number().int().nonnegative(),
-        resolverVersion: z.number().int().nonnegative()
-      }).strict(),
-      z.object({
-        kind: z.literal("legacy-raw"),
-        reason: z.enum(["pre-theme-v2", "manual-runtime-fields"])
-      }).strict(),
-      z.object({
-        kind: z.literal("advanced-detached"),
-        reason: z.literal("detached-custom-runtime-fields")
-      }).strict()
-    ]);
-    blockRuntimeStyleAuthoritySchema = z.object({
-      unit: z.literal("block-runtime-fields"),
-      blockId: z.string().min(1).transform(asDesignBlockId),
-      fields: nonEmptyRuntimeStyleFieldNamesSchema,
-      authority: styleAuthoritySchema
-    }).strict();
-    z.object({
-      schemaVersion: z.literal(themeV2DesignStateSchemaVersion),
-      siteStyleId: z.string().min(1).transform(asSiteStyleId),
-      templateId: z.string().min(1).transform(asDesignSystemTemplateId),
-      templateVersion: z.number().int().nonnegative(),
-      resolverVersion: z.number().int().nonnegative(),
-      rhythmPresetId: z.string().min(1),
-      blocks: z.array(blockDesignPlanSchema),
-      styleAuthorities: z.array(blockRuntimeStyleAuthoritySchema)
-    }).strict();
-  }
-});
-var init_runtimeCompiler = __esm({
-  "../theme-core/src/site-styles/runtimeCompiler.ts"() {
-    init_schema3();
-    init_modern_minimal();
-    init_expandPalette();
-    init_personalities();
-    init_variants();
-    init_designState();
-    init_types2();
-    init_accessibleSurfaces();
-  }
-});
 
 // ../theme-core/src/site-styles/siteStyleThemeCompiler.ts
 var init_siteStyleThemeCompiler = __esm({
@@ -11745,6 +12481,7 @@ var init_generatedDesignPipeline = __esm({
     init_designState();
     init_generatedSchemas();
     init_siteStyleBlockPolicies();
+    init_curatedSiteStyles();
     init_lookResolution();
     init_headerOpeningSection();
     init_resolver2();
@@ -11753,8 +12490,8 @@ var init_generatedDesignPipeline = __esm({
   }
 });
 function validateBlockSequence(snapshots, ctx) {
-  for (const issue2 of collectBlockSequenceIssues(snapshots)) {
-    ctx.addIssue(issue2);
+  for (const issue4 of collectBlockSequenceIssues(snapshots)) {
+    ctx.addIssue(issue4);
   }
 }
 function collectBlockSequenceIssues(snapshots) {
@@ -13428,7 +14165,7 @@ function buildFooterNavAll(common) {
   return stack(
     { className: common.className, gap: common.gap, align: "stretch" },
     [item],
-    when(collectionPath)
+    whenCollectionHasItems(collectionPath)
   );
 }
 function buildFooterNavLinksOnly(common) {
@@ -13461,7 +14198,7 @@ function buildFooterNavLinksOnly(common) {
   return stack(
     { className: common.className, gap: common.gap, align: "stretch" },
     [item],
-    when(collectionPath)
+    whenCollectionHasItems(collectionPath)
   );
 }
 function buildFooterNavFlatten(common) {
@@ -13510,7 +14247,7 @@ function buildFooterNavFlatten(common) {
   return stack(
     { className: common.className, gap: common.gap, align: "stretch" },
     [item],
-    when(collectionPath)
+    whenCollectionHasItems(collectionPath)
   );
 }
 function footerNav(opts) {
@@ -13532,9 +14269,21 @@ function footerNav(opts) {
   if (mode === "flatten") return buildFooterNavFlatten(common);
   return buildFooterNavAll(common);
 }
+var whenCollectionHasItems;
 var init_footerNav = __esm({
   "../blocks/src/system/node/fragments/footerNav.ts"() {
     init_builder2();
+    whenCollectionHasItems = (collectionPath) => (node) => ({
+      ...node,
+      $when: {
+        when: {
+          from: collectionPath,
+          transforms: [{ id: "array.length" }]
+        },
+        equals: 0,
+        not: true
+      }
+    });
   }
 });
 
@@ -16427,8 +17176,23 @@ var init_heroLayoutControls = __esm({
     heroLayoutControlsFragment = defineFragment({
       id: "heroLayoutControls",
       title: "Hero Layout",
-      description: "Alignment and content width controls for hero layouts.",
+      description: "Title scale, alignment, and content width controls for hero layouts.",
       fields: [
+        {
+          id: "titleSize",
+          type: "select",
+          label: "Title size",
+          description: "Adjust the visual scale of the hero title.",
+          required: false,
+          ui: { intent: "display" },
+          options: [
+            { value: "auto", label: "Auto" },
+            { value: "quiet", label: "Normal" },
+            { value: "editorial", label: "Large" },
+            { value: "display", label: "Huge" },
+            { value: "poster", label: "Poster" }
+          ]
+        },
         {
           id: "contentAlignment",
           type: "select",
@@ -17503,9 +18267,9 @@ function createZodCodec(schema) {
         return decodeSuccess(parsed.data);
       }
       return decodeFailure(
-        parsed.error.issues.map((issue2) => ({
-          path: zodIssuePath(issue2.path),
-          message: issue2.message
+        parsed.error.issues.map((issue4) => ({
+          path: zodIssuePath(issue4.path),
+          message: issue4.message
         }))
       );
     }
@@ -18310,9 +19074,14 @@ function isEventCalendarDisplayMode(value) {
 function isEventCalendarListLayout(value) {
   return typeof value === "string" && eventCalendarListLayoutValues.includes(value);
 }
-var eventCalendarDisplayModeValues, eventCalendarListLayoutValues, eventCalendarListLayoutOptions;
+function isEventContentType(slug) {
+  if (!slug) return false;
+  return EVENT_CONTENT_TYPE_SLUGS.includes(slug);
+}
+var EVENT_CONTENT_TYPE_SLUGS, eventCalendarDisplayModeValues, eventCalendarListLayoutValues, eventCalendarListLayoutOptions;
 var init_events = __esm({
   "../blocks/src/system/constants/events.ts"() {
+    EVENT_CONTENT_TYPE_SLUGS = ["event", "events"];
     eventCalendarDisplayModeValues = ["combined", "month", "week", "list", "timetable"];
     eventCalendarListLayoutValues = ["stack", "grid", "compact"];
     eventCalendarListLayoutOptions = [
@@ -18322,6 +19091,131 @@ var init_events = __esm({
     ];
   }
 });
+
+// ../blocks/src/system/runtime/nodes/events/shared/pricing.ts
+function resolveRuntimeEventPricing(event) {
+  if (isPublicEventPricing(event.pricing)) {
+    return event.pricing;
+  }
+  const legacy = event;
+  const currency = readCurrency(legacy.currency);
+  if (event.requiresRegistration === false) {
+    return {
+      kind: "drop_in",
+      currency,
+      display: { kind: "free", currency }
+    };
+  }
+  if (legacy.pricingMode === "ticket_types") {
+    const ticketTypes = Array.isArray(legacy.ticketTypes) ? legacy.ticketTypes.filter(isPublicEventTicketType) : [];
+    return {
+      kind: "ticket_types",
+      currency,
+      ticketTypes,
+      display: readTicketTypePriceDisplay(legacy.priceDisplay, currency)
+    };
+  }
+  const amount = typeof legacy.price === "number" ? legacy.price : 0;
+  if (legacy.pricingType === "paid" && amount > 0) {
+    return {
+      kind: "single_paid",
+      amount,
+      currency,
+      display: { kind: "exact", amount, currency }
+    };
+  }
+  return {
+    kind: "free_registration",
+    currency,
+    display: { kind: "free", currency }
+  };
+}
+function readCurrency(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : DEFAULT_EVENT_CURRENCY;
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPublicEventPricing(value) {
+  if (!isRecord4(value) || typeof value.kind !== "string") return false;
+  return value.kind === "drop_in" || value.kind === "free_registration" || value.kind === "single_paid" || value.kind === "ticket_types" || value.kind === "course";
+}
+function isPublicEventTicketType(value) {
+  return isRecord4(value) && typeof value.id === "string";
+}
+function readTicketTypePriceDisplay(value, currency) {
+  const display = readLegacyPriceDisplay(value, currency);
+  return display.kind === "course" ? { kind: "unavailable", currency } : display;
+}
+function readLegacyPriceDisplay(value, currency) {
+  if (!isRecord4(value) || typeof value.kind !== "string") {
+    return { kind: "unavailable", currency };
+  }
+  const displayCurrency = readCurrency(value.currency);
+  switch (value.kind) {
+    case "free":
+      return { kind: "free", currency: displayCurrency };
+    case "exact":
+      return readAmount(value.amount) !== null ? {
+        kind: "exact",
+        amount: readAmount(value.amount) ?? 0,
+        currency: displayCurrency
+      } : { kind: "unavailable", currency };
+    case "from":
+      return readAmount(value.amount) !== null ? {
+        kind: "from",
+        amount: readAmount(value.amount) ?? 0,
+        currency: displayCurrency
+      } : { kind: "unavailable", currency };
+    case "mixed":
+      return readAmount(value.paidFromAmount) !== null ? {
+        kind: "mixed",
+        paidFromAmount: readAmount(value.paidFromAmount) ?? 0,
+        currency: displayCurrency
+      } : { kind: "unavailable", currency };
+    case "unavailable":
+      return { kind: "unavailable", currency: displayCurrency };
+    case "course":
+      return isRecord4(value.display) ? {
+        kind: "course",
+        display: readCoursePriceDisplay(value.display, displayCurrency)
+      } : {
+        kind: "course",
+        display: { kind: "unavailable", currency: displayCurrency }
+      };
+    default:
+      return { kind: "unavailable", currency };
+  }
+}
+function readCoursePriceDisplay(value, currency) {
+  switch (value.kind) {
+    case "free":
+      return { kind: "free", currency: readCurrency(value.currency) };
+    case "exact":
+      return readAmount(value.amount) !== null ? {
+        kind: "exact",
+        amount: readAmount(value.amount) ?? 0,
+        currency: readCurrency(value.currency)
+      } : { kind: "unavailable", currency };
+    case "from":
+      return readAmount(value.amount) !== null ? {
+        kind: "from",
+        amount: readAmount(value.amount) ?? 0,
+        currency: readCurrency(value.currency)
+      } : { kind: "unavailable", currency };
+    default:
+      return { kind: "unavailable", currency };
+  }
+}
+function readAmount(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+var DEFAULT_EVENT_CURRENCY;
+var init_pricing = __esm({
+  "../blocks/src/system/runtime/nodes/events/shared/pricing.ts"() {
+    DEFAULT_EVENT_CURRENCY = "USD";
+  }
+});
 var previewStageSchema, registrationButtonVariantSchema, eventButtonVariantSchema, eventLayoutSchema, eventCalendarDisplayModeSchema, columnOptionSchema, weekStartSchema, filterAutoShowSchema, calendarTabViewsSchema;
 var init_contract_schemas = __esm({
   "../blocks/src/system/runtime/nodes/shared/contract-schemas.ts"() {
@@ -18337,27 +19231,184 @@ var init_contract_schemas = __esm({
     calendarTabViewsSchema = z.enum(["both", "month", "week"]);
   }
 });
+
+// ../blocks/src/system/runtime/nodes/event-registration/wizardSteps.ts
+function getWizardStepsForContext(hasPreSelectedContext, needsPaymentStep) {
+  const baseSteps = hasPreSelectedContext ? ["select-tickets", "enter-details"] : ["select-event", "select-tickets", "enter-details"];
+  if (!needsPaymentStep) {
+    return baseSteps;
+  }
+  return [...baseSteps, "select-payment"];
+}
+var init_wizardSteps = __esm({
+  "../blocks/src/system/runtime/nodes/event-registration/wizardSteps.ts"() {
+  }
+});
+
+// ../blocks/src/system/runtime/nodes/event-registration/registrationDerivations.ts
+function eventMatchesOccurrenceId(event, occurrenceId) {
+  return event.registrationOccurrenceId === occurrenceId || event.publicEventId === occurrenceId;
+}
+function findPreSelectedEvent(input) {
+  const occurrenceContext = input.occurrenceContext;
+  if (!occurrenceContext) {
+    return null;
+  }
+  const contextDate = getBookingLocalDateKey(toScheduledBookingDateTime({
+    startsAt: occurrenceContext.startsAt,
+    timeZone: occurrenceContext.timeZone
+  }));
+  return input.scopedEvents.find(
+    (event) => eventMatchesOccurrenceId(event, occurrenceContext.id) || getBookingLocalDateKey(toScheduledBookingDateTime({
+      startsAt: event.startsAt,
+      timeZone: event.timeZone
+    })) === contextDate
+  ) ?? null;
+}
+function resolveEventRequiresPayment(input) {
+  if (input.eligibility) {
+    return input.eligibility.requiresPayment;
+  }
+  if (!input.event) {
+    return false;
+  }
+  return publicEventPricingType(resolveRuntimeEventPricing(input.event)) !== "free";
+}
+var init_registrationDerivations = __esm({
+  "../blocks/src/system/runtime/nodes/event-registration/registrationDerivations.ts"() {
+    init_src();
+    init_pricing();
+  }
+});
+
+// ../blocks/src/system/runtime/nodes/event-registration/registrationEventAdapter.ts
+function toRegistrationEvent(event) {
+  return {
+    ...event,
+    pricing: resolveRuntimeEventPricing(event),
+    publicEventId: event.id,
+    registrationOccurrenceId: event.occurrenceId
+  };
+}
+function toRegistrationEvents(events) {
+  return events.map(toRegistrationEvent);
+}
+var init_registrationEventAdapter = __esm({
+  "../blocks/src/system/runtime/nodes/event-registration/registrationEventAdapter.ts"() {
+    init_pricing();
+  }
+});
 function buildEventRegistrationDisplay(source) {
+  const stepLabels = buildEventRegistrationShellStepLabels(source);
   return {
     kind: "event-registration",
-    state: "shell",
+    state: "generic-shell",
     className: source.className ?? null,
+    titleText: "Event registration",
+    bodyText: buildEventRegistrationShellBodyText(stepLabels),
+    stepLabels,
     summaryButtonText: source.buttonText?.trim() || "Register"
   };
 }
-var contentEntrySchema, eventRegistrationSourceSchema, eventRegistrationDisplaySchema, eventRegistrationHydrationSchema, eventRegistrationRenderSchema, eventRegistrationBlockRuntime;
+function buildEventRegistrationShellStepLabels(source) {
+  const scopedEvents = scopeEventRegistrationEvents(source);
+  if (scopedEvents.length === 0) {
+    return EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS;
+  }
+  const preSelectedEvent = findPreSelectedEvent({
+    scopedEvents,
+    occurrenceContext: source.occurrenceContext
+  });
+  const hasPreSelectedContext = Boolean(source.occurrenceContext || preSelectedEvent);
+  const needsPaymentStep = hasPreSelectedContext && preSelectedEvent ? resolveEventRequiresPayment({
+    eligibility: null,
+    event: preSelectedEvent
+  }) : false;
+  return getWizardStepsForContext(hasPreSelectedContext, needsPaymentStep).map((step) => shellLabelForRegistrationStep(step, scopedEvents));
+}
+function scopeEventRegistrationEvents(source) {
+  const events = toRegistrationEvents(source.events ?? []);
+  if (source.occurrenceContext?.seriesId) {
+    return events.filter((event) => event.seriesId === source.occurrenceContext?.seriesId);
+  }
+  const entrySlug = source.contentEntry?.slug;
+  const entryContentType = source.contentEntry?.contentTypeSlug;
+  if (entrySlug && entryContentType && isEventContentType(entryContentType)) {
+    return events.filter((event) => event.slug === entrySlug);
+  }
+  return events;
+}
+function shellLabelForRegistrationStep(step, events) {
+  switch (step) {
+    case "select-event":
+      return isDateSelection(events) ? "Date" : "Event";
+    case "select-tickets":
+      return "Tickets";
+    case "enter-details":
+      return "Details";
+    case "select-payment":
+      return "Payment";
+    case "error":
+    case "success":
+    case "submitting":
+    case "redirecting":
+    case "verifying-payment":
+    case "verifying-timeout":
+    case "payment-failed":
+      return "Details";
+  }
+}
+function isDateSelection(events) {
+  const firstSeriesId = events[0]?.seriesId;
+  return Boolean(
+    events.length > 1 && firstSeriesId && events.every((event) => event.seriesId === firstSeriesId)
+  );
+}
+function buildEventRegistrationShellBodyText(stepLabels) {
+  if (stepLabels.includes("Payment")) {
+    return "Preparing tickets, details, and payment options.";
+  }
+  if (stepLabels[0] === "Tickets") {
+    return "Preparing tickets and booking details.";
+  }
+  return "Preparing dates, tickets, and booking details.";
+}
+function normalizeEventRegistrationEventInput(value) {
+  if (!isRecord5(value)) {
+    return value;
+  }
+  return {
+    ...value,
+    pricing: resolveRuntimeEventPricing(value)
+  };
+}
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS, EVENT_REGISTRATION_SHELL_STEP_LABELS, contentEntrySchema, eventRegistrationPublicEventSchema, eventRegistrationSourceSchema, eventRegistrationDisplaySchema, eventRegistrationHydrationSchema, eventRegistrationRenderSchema, eventRegistrationBlockRuntime;
 var init_event_registration_interactive = __esm({
   "../blocks/src/system/runtime/nodes/event-registration.interactive.ts"() {
     init_schemas2();
     init_event_registration_shared();
+    init_events();
+    init_pricing();
     init_islands();
     init_runtime();
     init_contract_schemas();
+    init_wizardSteps();
+    init_registrationDerivations();
+    init_registrationEventAdapter();
+    EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS = ["Date", "Tickets", "Details"];
+    EVENT_REGISTRATION_SHELL_STEP_LABELS = ["Event", "Date", "Tickets", "Details", "Payment"];
     contentEntrySchema = z.object({
       id: z.string(),
       slug: z.string(),
       contentTypeSlug: z.string()
     });
+    eventRegistrationPublicEventSchema = z.preprocess(
+      normalizeEventRegistrationEventInput,
+      publicEventSchema
+    );
     eventRegistrationSourceSchema = z.object({
       siteId: z.string().optional(),
       apiBaseUrl: z.string().optional(),
@@ -18365,7 +19416,7 @@ var init_event_registration_interactive = __esm({
       previewToken: z.string().nullable().optional(),
       occurrenceContext: occurrenceContextSchema.optional(),
       contentEntry: contentEntrySchema.nullable().optional(),
-      events: z.array(publicEventSchema).nullable().optional(),
+      events: z.array(eventRegistrationPublicEventSchema).nullable().optional(),
       className: z.string().nullable().optional(),
       buttonText: z.string().nullable().optional(),
       maxTickets: z.string().nullable().optional(),
@@ -18380,14 +19431,17 @@ var init_event_registration_interactive = __esm({
     });
     eventRegistrationDisplaySchema = z.object({
       kind: z.literal("event-registration"),
-      state: z.literal("shell"),
+      state: z.literal("generic-shell"),
       className: z.string().nullable(),
+      titleText: z.string(),
+      bodyText: z.string(),
+      stepLabels: z.array(z.enum(EVENT_REGISTRATION_SHELL_STEP_LABELS)).min(1),
       summaryButtonText: z.string()
     });
     eventRegistrationHydrationSchema = z.object({
       occurrenceContext: occurrenceContextSchema.optional(),
       contentEntry: contentEntrySchema.nullable().optional(),
-      events: z.array(publicEventSchema).nullable().optional(),
+      events: z.array(eventRegistrationPublicEventSchema).nullable().optional(),
       maxTickets: z.string().optional(),
       showVenue: z.boolean().optional(),
       showCapacity: z.boolean().optional(),
@@ -18441,7 +19495,7 @@ var init_types16 = __esm({
 });
 
 // ../blocks/src/system/blocks/courses/shared/pricing.ts
-var init_pricing = __esm({
+var init_pricing2 = __esm({
   "../blocks/src/system/blocks/courses/shared/pricing.ts"() {
   }
 });
@@ -18451,7 +19505,7 @@ var init_shared3 = __esm({
   "../blocks/src/system/blocks/courses/shared/index.ts"() {
     init_types16();
     init_schemas();
-    init_pricing();
+    init_pricing2();
   }
 });
 function buildCourseRegistrationDisplay(source) {
@@ -23747,6 +24801,46 @@ var ENDPOINT_DEFINITIONS = {
     auth: "user",
     responseKind: "json"
   },
+  listEntrySlotBlocks: {
+    path: "/sites/{siteId}/content/{type}/{entryId}/slots/{slotKey}/blocks",
+    method: "GET",
+    tags: ["site-{siteId}", "content-entry-{entryId}", "entry-slot-{slotKey}", "blocks"],
+    auth: "user",
+    responseKind: "json",
+    errors: ["resource:not_found"]
+  },
+  listEntryPageContentSlots: {
+    path: "/sites/{siteId}/content/{type}/{entryId}/slots",
+    method: "GET",
+    tags: ["site-{siteId}", "content-entry-{entryId}", "entry-slots", "blocks"],
+    auth: "user",
+    responseKind: "json",
+    errors: ["resource:not_found"]
+  },
+  createEntrySlotBlock: {
+    path: "/sites/{siteId}/content/{type}/{entryId}/slots/{slotKey}/blocks",
+    method: "POST",
+    tags: ["site-{siteId}", "content-entry-{entryId}", "entry-slot-{slotKey}", "blocks"],
+    auth: "user",
+    responseKind: "json",
+    errors: ["validation:invalid_input", "resource:not_found"]
+  },
+  reorderEntrySlotBlocks: {
+    path: "/sites/{siteId}/content/{type}/{entryId}/slots/{slotKey}/blocks/reorder",
+    method: "POST",
+    tags: ["site-{siteId}", "content-entry-{entryId}", "entry-slot-{slotKey}", "blocks"],
+    auth: "user",
+    responseKind: "json",
+    errors: ["validation:invalid_input", "resource:not_found"]
+  },
+  deleteEntrySlotBlock: {
+    path: "/sites/{siteId}/content/{type}/{entryId}/slots/{slotKey}/blocks/{blockId}",
+    method: "DELETE",
+    tags: ["site-{siteId}", "content-entry-{entryId}", "entry-slot-{slotKey}", "blocks"],
+    auth: "user",
+    responseKind: "json",
+    errors: ["resource:not_found"]
+  },
   createBlock: {
     path: "/sites/{siteId}/pages/{pageId}/blocks",
     method: "POST",
@@ -27501,14 +28595,14 @@ function formatFieldPath(path25) {
 function toZodIssuePath(path25) {
   return [...path25];
 }
-function fieldIssueToMessage(issue2) {
-  switch (issue2.kind) {
+function fieldIssueToMessage(issue4) {
+  switch (issue4.kind) {
     case "required":
       return "This field is required";
     case "wrongType":
-      return `${issue2.label} needs ${issue2.expected}`;
+      return `${issue4.label} needs ${issue4.expected}`;
     case "tooLong":
-      return `Use ${issue2.maximum} characters or fewer`;
+      return `Use ${issue4.maximum} characters or fewer`;
     case "invalidEmail":
       return "Enter a valid email address";
     case "invalidPhone":
@@ -27524,29 +28618,29 @@ function fieldIssueToMessage(issue2) {
     case "invalidDateTime":
       return "Choose a valid date and time";
     case "invalidNumber":
-      return `${issue2.label} needs a number`;
+      return `${issue4.label} needs a number`;
     case "tooSmall":
-      return `${issue2.label} must be ${issue2.minimum} or more`;
+      return `${issue4.label} must be ${issue4.minimum} or more`;
     case "tooLarge":
-      return `${issue2.label} must be ${issue2.maximum} or less`;
+      return `${issue4.label} must be ${issue4.maximum} or less`;
     case "invalidSlug":
-      return `${issue2.label} can only use lowercase letters, numbers, and dashes`;
+      return `${issue4.label} can only use lowercase letters, numbers, and dashes`;
     case "invalidOption":
-      return `Choose one of the available options for ${issue2.label}`;
+      return `Choose one of the available options for ${issue4.label}`;
     case "tooFewItems":
-      return `${issue2.label} must have at least ${issue2.minimum} ${pluralize(issue2.itemLabel, issue2.minimum)}`;
+      return `${issue4.label} must have at least ${issue4.minimum} ${pluralize(issue4.itemLabel, issue4.minimum)}`;
     case "tooManyItems":
-      return `${issue2.label} must have at most ${issue2.maximum} ${pluralize(issue2.itemLabel, issue2.maximum)}`;
+      return `${issue4.label} must have at most ${issue4.maximum} ${pluralize(issue4.itemLabel, issue4.maximum)}`;
     case "invalidRichText":
-      return `${issue2.label} must be valid rich text`;
+      return `${issue4.label} must be valid rich text`;
     case "invalidMedia":
-      return `${issue2.label} must be a valid media item`;
+      return `${issue4.label} must be a valid media item`;
     case "invalidLink":
-      return `${issue2.label} must be a valid link`;
+      return `${issue4.label} must be a valid link`;
     case "invalidReference":
-      return `${issue2.label} must reference a valid item`;
+      return `${issue4.label} must reference a valid item`;
     default:
-      return assertNever2(issue2);
+      return assertNever2(issue4);
   }
 }
 function pluralize(label, count) {
@@ -28185,8 +29279,8 @@ function isValidTimeString(value) {
 function isValidDateTimeInstantString(value) {
   const match = DATETIME_PATTERN.exec(value);
   if (!match?.groups) return false;
-  const datePart = match.groups.date;
-  if (!datePart || !isValidDateString(datePart)) return false;
+  const datePart2 = match.groups.date;
+  if (!datePart2 || !isValidDateString(datePart2)) return false;
   return !Number.isNaN(Date.parse(value));
 }
 function isValidCalendarDate(year, month, day) {
@@ -28333,6 +29427,33 @@ function declareNoBlockDesignCapability(reason) {
 
 // ../blocks/src/system/blocks/hero.ts
 init_boxStyles();
+
+// ../blocks/src/system/fields/imageShape.ts
+var standardImageShapeOptions = [
+  { value: "default", label: "Default" },
+  { value: "square", label: "Square corners" },
+  { value: "rounded", label: "Rounded corners" },
+  { value: "circle", label: "Circle" },
+  { value: "arch", label: "Arch" }
+];
+function createImageShapeField(options = {}) {
+  return {
+    id: options.id ?? "imageShape",
+    type: "select",
+    label: options.label ?? "Image shape",
+    ...options.description ? { description: options.description } : {},
+    required: false,
+    defaultValue: options.defaultValue ?? "default",
+    multiple: false,
+    options: [...standardImageShapeOptions],
+    ui: {
+      intent: options.uiIntent ?? "display",
+      ...options.visibleWhen ? { visibleWhen: options.visibleWhen } : {}
+    }
+  };
+}
+
+// ../blocks/src/system/blocks/hero.ts
 init_fragments();
 init_styledSection();
 init_defineBlock();
@@ -28400,7 +29521,18 @@ function heroSplitImagePane() {
   return stack(
     {
       gap: "none",
-      className: "rb-relative rb-overflow-hidden rb-rounded-3xl",
+      className: {
+        $bind: {
+          from: "content.imageShape",
+          transforms: [
+            {
+              id: "ui.imageShapeClassName",
+              options: { baseClass: "rb-relative rb-overflow-hidden rb-rounded-3xl" }
+            }
+          ],
+          fallback: "rb-relative rb-overflow-hidden rb-rounded-3xl"
+        }
+      },
       style: {
         minHeight: "clamp(18rem, 36vw, 34rem)"
       }
@@ -28518,6 +29650,12 @@ var heroConfig = {
       label: "Content card",
       renderInHeader: true,
       intent: "style"
+    }),
+    createImageShapeField({
+      id: "imageShape",
+      label: "Image shape",
+      defaultValue: "default",
+      uiIntent: "display"
     })
   ],
   layout: classicLayout,
@@ -28532,6 +29670,15 @@ var heroConfig = {
   description: "Hero section with headline, subtitle, and repeatable CTAs.",
   tags: ["header", "banner", "landing", "introduction", "welcome", "splash", "headline"],
   icon: "Sparkles",
+  previewCustomize: {
+    quickFieldPriority: [
+      "titleSize",
+      "contentAlignment",
+      "contentMaxWidth",
+      "verticalAlignment",
+      "imageShape"
+    ]
+  },
   styleTokens: {
     typography: "display",
     spacing: "xl"
@@ -28551,7 +29698,8 @@ var standardAspectRatioOptions = [
   { value: "16/9", label: "16:9 (Landscape)" },
   { value: "4/3", label: "4:3 (Standard)" },
   { value: "1/1", label: "1:1 (Square)" },
-  { value: "3/4", label: "3:4 (Portrait)" }
+  { value: "3/4", label: "3:4 (Portrait)" },
+  { value: "9/16", label: "9:16 (Tall portrait)" }
 ];
 function createAspectRatioField(options = {}) {
   return {
@@ -29522,6 +30670,263 @@ var formBlockDefinition = {
   runtime: formBlockRuntime
 };
 
+// ../blocks/src/system/blocks/contact-newsletter.ts
+init_fragments();
+init_styledSection();
+init_builder2();
+init_defineBlock();
+init_api_bindings();
+var contactNewsletterLayout = styledSection({
+  children: sectionContainer([
+    el(
+      "div",
+      { className: "contact-newsletter-grid" },
+      [
+        el(
+          "div",
+          { className: "contact-newsletter-column contact-newsletter-contact" },
+          [
+            el(
+              "div",
+              { className: "contact-newsletter-copy" },
+              [
+                text(
+                  {
+                    as: "h2",
+                    className: "form-copy-title"
+                  },
+                  when("contactTitle"),
+                  bind("contactTitle")
+                ),
+                richText(
+                  {
+                    className: "form-copy-intro rb-prose rb-max-w-none"
+                  },
+                  when("contactIntro"),
+                  bind("contactIntro")
+                )
+              ]
+            ),
+            el(
+              "form",
+              withApiBindings({
+                spamProtectionEnabled: { $bind: { from: "$root.spamProtectionEnabled" } },
+                submitLabel: { $bind: { from: "contactSubmitLabel" } },
+                successMessage: { $bind: { from: "contactSuccessMessage" } }
+              }),
+              [],
+              bind("data.form")
+            )
+          ]
+        ),
+        el(
+          "div",
+          { className: "contact-newsletter-column contact-newsletter-info contact-newsletter-newsletter" },
+          [
+            el(
+              "div",
+              { className: "contact-newsletter-copy" },
+              [
+                text(
+                  {
+                    as: "h2",
+                    className: "newsletter-copy-title"
+                  },
+                  when("newsletterTitle"),
+                  bind("newsletterTitle")
+                ),
+                richText(
+                  {
+                    className: "newsletter-copy-subtitle rb-prose rb-max-w-none"
+                  },
+                  when("newsletterSubtitle"),
+                  bind("newsletterSubtitle")
+                )
+              ]
+            ),
+            el(
+              "newsletter-form",
+              withApiBindings({
+                listId: { $bind: { from: "listId" } },
+                preset: { $bind: { from: "preset" } },
+                includePhone: { $bind: { from: "includePhone" } },
+                buttonLabel: { $bind: { from: "newsletterButtonLabel" } },
+                successMessage: { $bind: { from: "newsletterSuccessMessage" } },
+                privacyNote: { $bind: { from: "newsletterPrivacyNote" } },
+                tags: { $bind: { from: "newsletterTags" } },
+                spamProtectionEnabled: { $bind: { from: "$root.spamProtectionEnabled" } }
+              }),
+              []
+            )
+          ]
+        )
+      ]
+    )
+  ], {
+    className: "contact-newsletter-container"
+  }),
+  baseClass: "",
+  spacing: "medium",
+  background: "surface"
+});
+var contactNewsletterManifest = createBlockManifest({
+  id: "block.contact-newsletter",
+  title: "Contact + Newsletter",
+  titleSource: "contactTitle",
+  description: "Two-column newsletter signup and contact form section.",
+  category: "interactive",
+  layout: contactNewsletterLayout,
+  defaultVariant: "default",
+  variants: {
+    default: contactNewsletterLayout
+  },
+  variantOptions: {
+    default: {
+      label: "Two column",
+      description: "Newsletter and contact form side by side.",
+      icon: "Columns2"
+    }
+  },
+  additionalFields: [
+    {
+      id: "newsletterTitle",
+      type: "text",
+      label: "Newsletter title",
+      defaultValue: "Stay connected"
+    },
+    {
+      id: "newsletterSubtitle",
+      type: "richText",
+      label: "Newsletter intro"
+    },
+    {
+      id: "listId",
+      type: "reference",
+      label: "Newsletter list",
+      description: "Select the list new subscribers should be added to.",
+      required: true,
+      referenceKind: "newsletterList",
+      allowManualEntry: false,
+      ui: { intent: "behavior" }
+    },
+    {
+      id: "preset",
+      type: "select",
+      label: "Newsletter fields",
+      defaultValue: "emailOnly",
+      ui: { intent: "display" },
+      options: [
+        { value: "emailOnly", label: "Email only" },
+        { value: "emailName", label: "Email + Name" },
+        { value: "emailFirstLast", label: "Email + First/Last Name" },
+        { value: "emailNameCompany", label: "Email + Name + Company (B2B)" }
+      ]
+    },
+    {
+      id: "includePhone",
+      type: "boolean",
+      label: "Include phone field",
+      defaultValue: false,
+      ui: { intent: "display" }
+    },
+    {
+      id: "newsletterButtonLabel",
+      type: "text",
+      label: "Newsletter button label",
+      defaultValue: "Subscribe",
+      ui: { intent: "display" }
+    },
+    {
+      id: "newsletterSuccessMessage",
+      type: "text",
+      label: "Newsletter success message",
+      defaultValue: "Thanks for subscribing!",
+      ui: { intent: "behavior" }
+    },
+    {
+      id: "newsletterPrivacyNote",
+      type: "text",
+      label: "Privacy note",
+      ui: { intent: "display" }
+    },
+    {
+      id: "newsletterTags",
+      type: "text",
+      label: "Newsletter tags",
+      description: "Optional tags to apply on subscribe, separated by comma or semicolon.",
+      ui: { intent: "behavior" }
+    },
+    {
+      id: "contactTitle",
+      type: "text",
+      label: "Contact title",
+      defaultValue: "Get in touch"
+    },
+    {
+      id: "contactIntro",
+      type: "richText",
+      label: "Contact intro"
+    },
+    {
+      id: "formSlug",
+      type: "reference",
+      label: "Contact form",
+      description: "Pick a saved form to render.",
+      required: true,
+      referenceKind: "form",
+      allowManualEntry: false,
+      ui: { intent: "behavior" }
+    },
+    {
+      id: "contactSubmitLabel",
+      type: "text",
+      label: "Contact button label",
+      defaultValue: "Send message",
+      ui: { intent: "display" }
+    },
+    {
+      id: "contactSuccessMessage",
+      type: "text",
+      label: "Contact success message",
+      defaultValue: "Thanks - we received your message.",
+      ui: { intent: "behavior" }
+    }
+  ],
+  styleTokens: {
+    background: "surface",
+    typography: "body",
+    spacing: "md"
+  },
+  behaviours: {
+    supportsThemeSwitching: true,
+    inlineEditing: true,
+    animation: false,
+    paletteHidden: false
+  },
+  tags: [
+    "contact",
+    "newsletter",
+    "signup",
+    "email",
+    "form",
+    "lead-capture"
+  ],
+  icon: "MailPlus"
+});
+var contactNewsletterBlockDefinition = {
+  manifest: contactNewsletterManifest,
+  dataSchemas: { form: formDataSchema.optional() },
+  dataLoaders: {
+    form: {
+      endpoint: "getPublicFormById",
+      params: {
+        formSlug: { $bind: { from: "formSlug" } }
+      },
+      mode: "server"
+    }
+  }
+};
+
 // ../blocks/src/system/blocks/faq.ts
 init_fragments();
 init_styledSection();
@@ -29762,6 +31167,7 @@ var joinClasses3 = (parts) => parts.filter(
 ).join(" ").replace(/\s+/g, " ").trim();
 var eyebrowTreatmentClassMap = {
   plain: "",
+  accent: "rb-eyebrow-treatment-accent",
   pill: "rb-eyebrow-treatment-pill",
   "accent-pill": "rb-eyebrow-treatment-pill rb-eyebrow-treatment-accent",
   "pill-bounce": "rb-eyebrow-treatment-pill rb-eyebrow-treatment-pill-bounce",
@@ -29788,6 +31194,13 @@ var imageGalleryCornerClassMap = {
   "2xl": "rb-rounded-2xl",
   "3xl": "rb-rounded-3xl"
 };
+var imageShapeClassMap = {
+  default: "",
+  square: "rb-media-shape-square",
+  rounded: "rb-media-shape-rounded",
+  circle: "rb-media-shape-circle",
+  arch: "rb-media-shape-arch"
+};
 var parseRatio = (raw) => {
   if (typeof raw !== "string") return null;
   const value = raw.trim();
@@ -29932,6 +31345,10 @@ function resolveHeroContentMaxWidth(content) {
   return "default";
 }
 function resolveHeroTypographyScale(content) {
+  const titleSize = readString(content, "titleSize");
+  if (titleSize === "quiet" || titleSize === "editorial" || titleSize === "display" || titleSize === "poster") {
+    return titleSize;
+  }
   const raw = readHeroLayoutString(
     content,
     "typographyScale",
@@ -30173,6 +31590,16 @@ var uiTransforms = [
   heroGridClassFromVerticalAlignmentTransform,
   imageFragmentClassTransform,
   imageFragmentSizeTransform,
+  {
+    id: "ui.imageShapeClassName",
+    kind: "string",
+    summary: "Apply a constrained media shape class",
+    run: (value, options) => {
+      const baseClass = typeof options?.baseClass === "string" ? options.baseClass : "";
+      const shape = typeof value === "string" ? value.trim() : "default";
+      return joinClasses3([baseClass, imageShapeClassMap[shape] ?? ""]);
+    }
+  },
   conditionalClassTransform,
   twoColumnContainerClassTransform,
   twoColumnFlexBasisTransform,
@@ -31514,6 +32941,21 @@ var siteHeaderManifest = createBlockManifest({
   id: "block.site-header",
   title: "Site Header",
   category: "layout",
+  additionalFields: [
+    {
+      id: "mode",
+      type: "select",
+      label: "Header display",
+      required: false,
+      multiple: false,
+      defaultValue: "default",
+      options: [
+        { value: "default", label: "Show header" },
+        { value: "hidden", label: "Hide header" }
+      ],
+      ui: { intent: "display" }
+    }
+  ],
   // Skip section styles - this block uses theme-based styling
   skipSectionStyles: true,
   // Block manages its own wrapper - enables sticky positioning
@@ -32960,6 +34402,9 @@ var mediaTextManifest = createBlockManifest({
   category: "layout",
   includeContainerStyles: true,
   titleSource: "title",
+  previewCustomize: {
+    quickFieldPriority: ["imagePosition", "ratio", "imageShape", "titleAlignment", "aspectRatio"]
+  },
   additionalFields: [
     {
       id: "images",
@@ -32998,7 +34443,7 @@ var mediaTextManifest = createBlockManifest({
     {
       id: "titleAlignment",
       type: "select",
-      label: "Title alignment",
+      label: "Content alignment",
       required: false,
       defaultValue: "left",
       multiple: false,
@@ -33056,7 +34501,18 @@ var mediaTextManifest = createBlockManifest({
         transition: "slide"
       },
       ui: { intent: "behavior" }
-    }),
+    }).map((field) => ({
+      ...field,
+      ui: {
+        ...field.ui ?? {},
+        visibleWhen: field.id === "carouselAutoplayDelay" ? {
+          allOf: [
+            { field: "images", minItems: 2 },
+            { field: "carouselAutoplay", equals: true }
+          ]
+        } : { field: "images", minItems: 2 }
+      }
+    })),
     createAspectRatioField({
       id: "aspectRatio",
       label: "Media aspect ratio",
@@ -33064,6 +34520,12 @@ var mediaTextManifest = createBlockManifest({
       defaultValue: "auto",
       visibleWhen: { field: "images", notEquals: null }
     }),
+    createImageShapeField({
+      id: "imageShape",
+      label: "Media shape",
+      defaultValue: "default",
+      visibleWhen: { field: "images", notEquals: null }
+    }),
     {
       id: "text",
       type: "richText",
@@ -33097,6 +34559,30 @@ var mediaTextManifest = createBlockManifest({
         ...options?.not ? { not: true } : {}
       }
     });
+    const bodyClassNameFromAlignment = {
+      $bind: {
+        from: "content.titleAlignment",
+        transforms: [
+          {
+            id: "ui.bodyClassFromAlignment",
+            options: { base: "rb-prose rb-max-w-none" }
+          }
+        ],
+        fallback: "rb-prose rb-max-w-none"
+      }
+    };
+    const titleClassNameFromAlignment = {
+      $bind: {
+        from: "content.titleAlignment",
+        transforms: [
+          {
+            id: "ui.headingClassFromAlignment",
+            options: { base: "" }
+          }
+        ],
+        fallback: ""
+      }
+    };
     const defaultTextColumn = el("div", {}, [
       styledCard(
         [
@@ -33121,8 +34607,55 @@ var mediaTextManifest = createBlockManifest({
         bind("content.text")
       )
     ]);
+    const bioTextColumn = el(
+      "div",
+      { className: "rb-flex rb-h-full rb-w-full rb-max-w-prose rb-flex-col rb-justify-center rb-gap-5" },
+      [
+        text(
+          {
+            as: "h2",
+            className: titleClassNameFromAlignment
+          },
+          when("content.title"),
+          bind("content.title")
+        ),
+        styledCard(
+          [
+            richText(
+              {
+                className: bodyClassNameFromAlignment
+              },
+              bind("content.text")
+            )
+          ],
+          {
+            stylesFrom: "content._textCardStyles",
+            backgroundFrom: "content._textCardStyles.background"
+          },
+          when("content.wrapTextInCard")
+        ),
+        richText(
+          {
+            className: bodyClassNameFromAlignment
+          },
+          when("content.wrapTextInCard", { not: true }),
+          bind("content.text")
+        )
+      ]
+    );
     const defaultImageCommonProps = {
-      className: "rb-w-full rb-h-auto rb-object-cover",
+      className: {
+        $bind: {
+          from: "content.imageShape",
+          transforms: [
+            {
+              id: "ui.imageShapeClassName",
+              options: { baseClass: "rb-w-full rb-h-auto rb-object-cover" }
+            }
+          ],
+          fallback: "rb-w-full rb-h-auto rb-object-cover"
+        }
+      },
       style: {
         aspectRatio: { $bind: { from: "content.aspectRatio" } }
       }
@@ -33163,6 +34696,27 @@ var mediaTextManifest = createBlockManifest({
       ],
       whenImagesLength(0, { not: true })
     );
+    const bioImagesLayout = el(
+      "div",
+      {},
+      [
+        responsiveTwoColumn({
+          image: el("div", {}, [
+            el("div", {}, [defaultSingleImage], whenImagesLength(1)),
+            el("div", {}, [defaultCarouselImages], whenImagesLength(1, { not: true }))
+          ]),
+          text: bioTextColumn,
+          ratioFrom: "content.ratio",
+          imagePositionFrom: "content.imagePosition",
+          containerClassName: "rb-flex rb-flex-col rb-md-flex-row rb-md-items-center",
+          gapFrom: "content.gap",
+          gapFallback: "comfortable",
+          imageWrapperClassName: "rb-w-full rb-shrink-0",
+          textWrapperClassName: "rb-w-full rb-min-w-0 rb-flex-1 rb-self-stretch"
+        })
+      ],
+      whenImagesLength(0, { not: true })
+    );
     const defaultTextOnlyLayout = el(
       "div",
       {},
@@ -33192,7 +34746,45 @@ var mediaTextManifest = createBlockManifest({
       ],
       whenImagesLength(0)
     );
+    const bioTextOnlyLayout = el(
+      "div",
+      { className: "rb-flex rb-w-full rb-max-w-prose rb-flex-col rb-gap-5" },
+      [
+        text(
+          {
+            as: "h2",
+            className: titleClassNameFromAlignment
+          },
+          when("content.title"),
+          bind("content.title")
+        ),
+        styledCard(
+          [
+            richText(
+              {
+                className: bodyClassNameFromAlignment
+              },
+              bind("content.text")
+            )
+          ],
+          {
+            stylesFrom: "content._textCardStyles",
+            backgroundFrom: "content._textCardStyles.background"
+          },
+          when("content.wrapTextInCard")
+        ),
+        richText(
+          {
+            className: bodyClassNameFromAlignment
+          },
+          when("content.wrapTextInCard", { not: true }),
+          bind("content.text")
+        )
+      ],
+      whenImagesLength(0)
+    );
     const defaultInner = el("div", {}, [defaultImagesLayout, defaultTextOnlyLayout]);
+    const bioInner = el("div", {}, [bioImagesLayout, bioTextOnlyLayout]);
     const defaultLayout2 = styledSection({
       children: styledContainer({
         rootType: "stack",
@@ -33201,18 +34793,7 @@ var mediaTextManifest = createBlockManifest({
           text(
             {
               as: "h2",
-              className: {
-                $bind: {
-                  from: "content.titleAlignment",
-                  transforms: [
-                    {
-                      id: "ui.headingClassFromAlignment",
-                      options: { base: "" }
-                    }
-                  ],
-                  fallback: ""
-                }
-              }
+              className: titleClassNameFromAlignment
             },
             when("content.title"),
             bind("content.title")
@@ -33224,14 +34805,28 @@ var mediaTextManifest = createBlockManifest({
       baseClass: "",
       spacing: "medium"
     });
+    const bioLayout = styledSection({
+      children: styledContainer({
+        rootType: "stack",
+        rootProps: { gap: "lg" },
+        children: [bioInner]
+      }),
+      baseClass: "",
+      spacing: "medium"
+    });
     return {
       layout: defaultLayout2,
       variants: {
-        default: defaultLayout2
+        default: defaultLayout2,
+        bio: bioLayout
       },
       defaultVariant: "default",
       variantOptions: {
-        default: { label: "Default" }
+        default: { label: "Default" },
+        bio: {
+          label: "Bio",
+          description: "Vertically centered title and copy beside media."
+        }
       }
     };
   })(),
@@ -35046,7 +36641,7 @@ function inferLegacyOfferingsPreviewGroupOrder(overrides) {
   return keys.length >= 2 ? keys : [];
 }
 function normalizeOfferingsPreviewContentForWrite(value) {
-  if (!isRecord4(value)) return null;
+  if (!isRecord6(value)) return null;
   const groupOrderValue = value.groupOrder;
   if (Array.isArray(groupOrderValue)) {
     const normalized = normalizeOfferingsPreviewGroupOrder(groupOrderValue);
@@ -35059,7 +36654,7 @@ function normalizeOfferingsPreviewContentForWrite(value) {
     return { ...value, groupOrder: [] };
   }
   const legacyOrder = inferLegacyOfferingsPreviewGroupOrder(
-    Array.isArray(value.groupOverrides) ? value.groupOverrides.filter(isRecord4) : []
+    Array.isArray(value.groupOverrides) ? value.groupOverrides.filter(isRecord6) : []
   );
   return legacyOrder.length > 0 ? { ...value, groupOrder: legacyOrder } : value;
 }
@@ -35073,7 +36668,7 @@ function uniqueOfferingsPreviewSourceKeys(values) {
   }
   return keys;
 }
-function isRecord4(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -35440,7 +37035,7 @@ function isOfferingsPreviewItemLimit(value) {
   return value === "1" || value === "2" || value === "3" || value === "4" || value === "5" || value === "6" || value === null;
 }
 function normalizeOfferingsPreviewGroupOverride(value) {
-  if (!isRecord5(value)) return [];
+  if (!isRecord7(value)) return [];
   const override = {};
   if (isOfferingsPreviewSourceKey(value.sourceKey) || value.sourceKey === null) {
     override.sourceKey = value.sourceKey;
@@ -35472,12 +37067,12 @@ function isButtonVariant(value) {
   return value === "primary" || value === "secondary" || value === "outline" || value === "link" || value === null;
 }
 function normalizeCardStylesContent(value) {
-  return isRecord5(value) || value === null ? value : void 0;
+  return isRecord7(value) || value === null ? value : void 0;
 }
 function normalizeSectionStylesContent(value) {
-  return isRecord5(value) || value === null ? value : void 0;
+  return isRecord7(value) || value === null ? value : void 0;
 }
-function isRecord5(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -38386,11 +39981,13 @@ var heroImageSurfaceMotions = [
 ];
 var standardEyebrowTreatments = [
   "plain",
+  "accent",
   "pill",
   "accent-pill"
 ];
 var animatedEyebrowTreatments = [
   "plain",
+  "accent",
   "pill",
   "accent-pill",
   "pill-bounce",
@@ -38691,6 +40288,17 @@ var systemBlockDefinitionsRaw = [
       layoutProfile({ variantKey: "two-column", family: "split", weight: "standard" })
     ]
   })),
+  withDesignCapability("block.contact-newsletter", contactNewsletterBlockDefinition, sectionOnly(), defineBlockDesignMetadata({
+    flow: conversionFlow,
+    layoutProfiles: [
+      layoutProfile({
+        variantKey: "default",
+        family: "split",
+        weight: "featured",
+        bias: "soft"
+      })
+    ]
+  })),
   withDesignCapability("block.faq", faqBlockDefinition, withEyebrowCapability(declareBlockDesignCapability({
     sectionSurfaces: "supported",
     contentFrames: ["plain", "panel"],
@@ -38782,6 +40390,12 @@ var systemBlockDefinitionsRaw = [
         family: "media-text",
         weight: "featured",
         bias: "soft"
+      }),
+      layoutProfile({
+        variantKey: "bio",
+        family: "media-text",
+        weight: "featured",
+        bias: "soft"
       })
     ]
   })),
@@ -39617,6 +41231,7 @@ init_colorStyles();
 // ../theme-core/src/inputs/generateInputCss.ts
 init_types9();
 init_constants();
+init_colorStyles();
 
 // ../theme-core/src/header/generateHeaderCss.ts
 init_resolver();
@@ -39653,6 +41268,11 @@ ${root} {
   --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));
@@ -41250,7 +42870,7 @@ function preset(id, verticalId, canonicalBehaviour, label, pluralLabel, descript
 }
 
 // ../api/src/utils/isRecord.ts
-function isRecord6(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var APPOINTMENT_SETUP_MAX_MINUTES = 1440;
@@ -41388,11 +43008,11 @@ siteBannerSettingsSchema.superRefine((value, ctx) => {
     return;
   }
   const analysis = analyzeSiteBannerBody(value.body);
-  for (const issue2 of analysis.issues) {
+  for (const issue4 of analysis.issues) {
     ctx.addIssue({
       code: z.ZodIssueCode.custom,
       path: ["body"],
-      message: siteBannerBodyIssueMessage(issue2)
+      message: siteBannerBodyIssueMessage(issue4)
     });
   }
 });
@@ -41426,8 +43046,8 @@ function analyzeSiteBannerBody(body) {
     issues
   };
 }
-function siteBannerBodyIssueMessage(issue2) {
-  switch (issue2) {
+function siteBannerBodyIssueMessage(issue4) {
+  switch (issue4) {
     case "empty":
       return "Banner message is required when the banner is enabled.";
     case "too-many-paragraphs":
@@ -41523,7 +43143,7 @@ function sanitizeMarks(marks) {
     if (mark.type === "bold" || mark.type === "strong" || mark.type === "italic" || mark.type === "em") {
       return [{ type: mark.type }];
     }
-    if (mark.type === "link" && isRecord6(mark.attrs) && typeof mark.attrs.href === "string") {
+    if (mark.type === "link" && isRecord8(mark.attrs) && typeof mark.attrs.href === "string") {
       const attrs = { href: mark.attrs.href };
       if (typeof mark.attrs.target === "string" && mark.attrs.target.trim().length > 0) {
         attrs.target = mark.attrs.target;
@@ -41538,10 +43158,10 @@ function sanitizeMarks(marks) {
   return sanitized.length > 0 ? sanitized : void 0;
 }
 function unwrapRichTextValue(value) {
-  if (isRecord6(value) && isRecord6(value.doc)) {
+  if (isRecord8(value) && isRecord8(value.doc)) {
     return unwrapRichTextValue(value.doc);
   }
-  if (isRecord6(value) && value.type === "doc") {
+  if (isRecord8(value) && value.type === "doc") {
     return {
       type: "doc",
       content: Array.isArray(value.content) ? value.content.filter(isTipTapNodeLike).map(coerceTipTapNode) : []
@@ -41550,7 +43170,7 @@ function unwrapRichTextValue(value) {
   return EMPTY_SITE_BANNER_BODY;
 }
 function isTipTapNodeLike(value) {
-  return isRecord6(value) && typeof value.type === "string";
+  return isRecord8(value) && typeof value.type === "string";
 }
 function coerceTipTapNode(value) {
   return {
@@ -41558,9 +43178,9 @@ function coerceTipTapNode(value) {
     ...Array.isArray(value.content) ? { content: value.content.filter(isTipTapNodeLike).map(coerceTipTapNode) } : {},
     ...typeof value.text === "string" ? { text: value.text } : {},
     ...Array.isArray(value.marks) ? {
-      marks: value.marks.filter((mark) => isRecord6(mark) && typeof mark.type === "string").map((mark) => ({
+      marks: value.marks.filter((mark) => isRecord8(mark) && typeof mark.type === "string").map((mark) => ({
         type: mark.type,
-        ...isRecord6(mark.attrs) ? { attrs: mark.attrs } : {}
+        ...isRecord8(mark.attrs) ? { attrs: mark.attrs } : {}
       }))
     } : {}
   };
@@ -41676,7 +43296,7 @@ function collectCartLinkStats(items, depth = 0) {
   return result;
 }
 function isNavigationMenuValidationItem(value) {
-  if (!isRecord6(value)) return false;
+  if (!isRecord8(value)) return false;
   return typeof value.label === "string";
 }
 
@@ -41901,6 +43521,7 @@ var SYSTEM_BLOCK_KINDS = [
   "block.site-footer",
   // Form/booking blocks
   "block.form",
+  "block.contact-newsletter",
   "block.appointment-booking",
   "block.event-registration",
   "block.event-details",
@@ -42109,7 +43730,7 @@ var fieldBindingSchema = z.object({
 var metaBindingSchema = z.object({
   source: z.literal("meta"),
   path: z.enum(TEMPLATE_BINDING_META_PATHS, {
-    error: (issue2) => describeInvalidTemplateBindingMetaPath(String(issue2.input))
+    error: (issue4) => describeInvalidTemplateBindingMetaPath(String(issue4.input))
   })
 });
 var literalBindingSchema = z.object({
@@ -42120,7 +43741,7 @@ var transformBindingSchema = z.object({
   source: z.literal("transform"),
   path: z.string().min(1, "Transform path is required"),
   transform: z.enum(BINDING_TRANSFORM_VALUES, {
-    error: (issue2) => describeInvalidBindingTransform(String(issue2.input))
+    error: (issue4) => describeInvalidBindingTransform(String(issue4.input))
   })
 });
 var baseBindingSchema = z.discriminatedUnion("source", [
@@ -42924,20 +44545,20 @@ var ManagementApiError = class extends Error {
 function is404Error(error) {
   return error instanceof ManagementApiError && error.statusCode === 404;
 }
-function isRecord7(value) {
+function isRecord9(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function isFieldError(value) {
-  return isRecord7(value) && typeof value.field === "string" && typeof value.code === "string" && typeof value.message === "string";
+  return isRecord9(value) && typeof value.field === "string" && typeof value.code === "string" && typeof value.message === "string";
 }
 function parseApiResponse(value) {
-  if (!isRecord7(value)) return null;
+  if (!isRecord9(value)) return null;
   if (value.success === true) {
     return { success: true, data: value.data };
   }
   if (value.success === false) {
     const error = value.error;
-    if (!isRecord7(error) || typeof error.code !== "string" || typeof error.message !== "string") {
+    if (!isRecord9(error) || typeof error.code !== "string" || typeof error.message !== "string") {
       return { success: false, error: { code: "sdk:http-error", message: "Request failed", details: error } };
     }
     const fieldErrorsRaw = error.fieldErrors;
@@ -44174,8 +45795,8 @@ function mapEntryForOutput(entry) {
     data: entry.data,
     status: entry.status,
     hasUnpublishedChanges: entry.hasUnpublishedChanges,
-    title: entry.title,
-    manualOrder: entry.manualOrder
+    manualOrder: entry.manualOrder,
+    blocks: entry.blocks
   };
   if (entry.slug !== void 0) {
     result.slug = entry.slug;
@@ -44466,7 +46087,7 @@ function createListCommand(config2) {
 
 // src/cli/push-config.ts
 var DEFAULT_CONFIG_PATH = "./riverbank.config.ts";
-function isRecord8(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null;
 }
 function parseErrorDetails(value) {
@@ -44474,10 +46095,10 @@ function parseErrorDetails(value) {
   if (typeof value === "string") {
     return { message: value };
   }
-  if (!isRecord8(value)) return {};
+  if (!isRecord10(value)) return {};
   const message = typeof value.message === "string" ? value.message : void 0;
   const fieldErrorsRaw = value.fieldErrors;
-  const fieldErrors = Array.isArray(fieldErrorsRaw) ? fieldErrorsRaw.filter(isRecord8).map((d) => ({
+  const fieldErrors = Array.isArray(fieldErrorsRaw) ? fieldErrorsRaw.filter(isRecord10).map((d) => ({
     field: typeof d.field === "string" ? d.field : "",
     message: typeof d.message === "string" ? d.message : ""
   })).filter((d) => d.field.length > 0 && d.message.length > 0) : void 0;
@@ -44489,12 +46110,12 @@ function formatFieldErrors(fieldErrors) {
 }
 function getDashboardErrorMessage(responseJson, fallback) {
   if (!responseJson) return fallback;
-  if (isRecord8(responseJson) && responseJson.success === false && "error" in responseJson) {
+  if (isRecord10(responseJson) && responseJson.success === false && "error" in responseJson) {
     const parsed = parseErrorDetails(responseJson.error);
     const msg = parsed.message ?? fallback;
     return msg + formatFieldErrors(parsed.fieldErrors);
   }
-  if (isRecord8(responseJson) && "error" in responseJson) {
+  if (isRecord10(responseJson) && "error" in responseJson) {
     const parsed = parseErrorDetails(responseJson.error);
     const msg = parsed.message ?? fallback;
     return msg + formatFieldErrors(parsed.fieldErrors);
@@ -44613,9 +46234,9 @@ async function pushConfigAction(output, options) {
     const parseResult = riverbankSiteConfigSchema.safeParse(rawConfig);
     if (!parseResult.success) {
       output.error("Invalid config", {
-        issues: parseResult.error.issues.map((issue2) => ({
-          path: issue2.path.join("."),
-          message: issue2.message
+        issues: parseResult.error.issues.map((issue4) => ({
+          path: issue4.path.join("."),
+          message: issue4.message
         }))
       });
     }
@@ -44819,7 +46440,7 @@ function duplicateNavigationIdentityMessage(error) {
 
 // src/cli/media/portable.ts
 var ENV_SPECIFIC_MEDIA_KEYS = ["assetId", "storagePath", "storageBucket"];
-var isRecord9 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord11 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var isMediaObject = (value) => value.type === "image" || value.type === "video";
 function stripEnvSpecificMediaFieldsInPlace(value) {
   if (value === null || value === void 0) return;
@@ -44829,7 +46450,7 @@ function stripEnvSpecificMediaFieldsInPlace(value) {
     }
     return;
   }
-  if (!isRecord9(value)) return;
+  if (!isRecord11(value)) return;
   if (isMediaObject(value)) {
     const hasCmsRef = typeof value.identifier === "string" || typeof value.assetId === "string" || typeof value.storagePath === "string" || typeof value.storageBucket === "string";
     for (const key of ENV_SPECIFIC_MEDIA_KEYS) {
@@ -44840,7 +46461,7 @@ function stripEnvSpecificMediaFieldsInPlace(value) {
     }
     delete value.mimeType;
   }
-  if (value.type === "image" && isRecord9(value.attrs)) {
+  if (value.type === "image" && isRecord11(value.attrs)) {
     const attrs = value.attrs;
     const hasIdentifier = typeof attrs.identifier === "string" && attrs.identifier.trim().length > 0;
     if (hasIdentifier) {
@@ -44905,7 +46526,8 @@ function pulledEntryToLocalEntry(entry) {
     data: entry.data,
     status: entry.status,
     hasUnpublishedChanges: entry.hasUnpublishedChanges,
-    ...entry.slug !== void 0 ? { slug: entry.slug } : {}
+    ...entry.slug !== void 0 ? { slug: entry.slug } : {},
+    ...entry.blocks !== void 0 ? { blocks: entry.blocks } : {}
   };
 }
 
@@ -45011,11 +46633,11 @@ function entryFilePath(input) {
 }
 
 // src/cli/content/writer.ts
-function isRecord10(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseThemeMeta(value) {
-  if (!isRecord10(value) || typeof value.pulledAt !== "string" || !isRecord10(value.themes)) {
+  if (!isRecord12(value) || typeof value.pulledAt !== "string" || !isRecord12(value.themes)) {
     return null;
   }
   return { pulledAt: value.pulledAt, themes: value.themes };
@@ -45627,7 +47249,9 @@ async function readEntries(contentDir, contentType) {
       const items = await fs5.readdir(entriesDir, { withFileTypes: true });
       for (const item of items) {
         if (item.isDirectory()) {
-          const entries = await readEntriesFromDirectory(path5.join(entriesDir, item.name));
+          const entries = await readEntriesFromDirectory(
+            path5.join(entriesDir, item.name)
+          );
           await applyManualOrderMetadata(contentDir, item.name, entries);
           if (entries.length > 0) {
             result.set(item.name, entries);
@@ -45644,7 +47268,9 @@ async function applyManualOrderMetadata(contentDir, contentType, entries) {
   const meta = await readEntriesMeta(contentDir, contentType);
   const order = meta?.manualOrder;
   if (!order?.length) return;
-  const orderByIdentifier = new Map(order.map((identifier, index) => [identifier, index]));
+  const orderByIdentifier = new Map(
+    order.map((identifier, index) => [identifier, index])
+  );
   for (const entry of entries) {
     const manualOrder = orderByIdentifier.get(entry.identifier);
     if (manualOrder !== void 0) {
@@ -45689,7 +47315,9 @@ async function readSettings(contentDir) {
   if (!parsed.success) {
     throw new Error(
       `${filePath}: invalid settings.json
-` + parsed.error.issues.map((issue2) => `  - ${issue2.path.join(".") || "(root)"}: ${issue2.message}`).join("\n")
+` + parsed.error.issues.map(
+        (issue4) => `  - ${issue4.path.join(".") || "(root)"}: ${issue4.message}`
+      ).join("\n")
     );
   }
   return parsed.data;
@@ -45809,7 +47437,18 @@ async function readFooter(contentDir) {
   return raw;
 }
 async function readAllContent(contentDir) {
-  const [entries, pages, navigation, settings, forms, footer, venues, eventCategories, events, courses] = await Promise.all([
+  const [
+    entries,
+    pages,
+    navigation,
+    settings,
+    forms,
+    footer,
+    venues,
+    eventCategories,
+    events,
+    courses
+  ] = await Promise.all([
     readEntries(contentDir),
     readPages(contentDir),
     readNavigation(contentDir),
@@ -45821,7 +47460,18 @@ async function readAllContent(contentDir) {
     readEvents(contentDir),
     readCourses(contentDir)
   ]);
-  return { entries, pages, navigation, settings, forms, footer, venues, eventCategories, events, courses };
+  return {
+    entries,
+    pages,
+    navigation,
+    settings,
+    forms,
+    footer,
+    venues,
+    eventCategories,
+    events,
+    courses
+  };
 }
 async function contentDirExists(contentDir) {
   return fileExists(contentDir);
@@ -46401,9 +48051,9 @@ async function localMediaFileExists(filePath) {
 }
 
 // src/cli/media/identifiers.ts
-var isRecord11 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord13 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var isMediaValue = (value) => {
-  if (!isRecord11(value)) return false;
+  if (!isRecord13(value)) return false;
   const type = value.type;
   if (type !== "image" && type !== "video" && type !== "audio" && type !== "document" && type !== "spreadsheet" && type !== "archive") return false;
   return typeof value.identifier === "string" || typeof value.assetId === "string" || typeof value.storagePath === "string" || typeof value.src === "string";
@@ -46418,7 +48068,7 @@ var walkMediaValues = (value, location2, handler) => {
     });
     return;
   }
-  if (isRecord11(value)) {
+  if (isRecord13(value)) {
     Object.entries(value).forEach(([key, entry]) => {
       walkMediaValues(entry, location2 ? `${location2}.${key}` : key, handler);
     });
@@ -46428,6 +48078,15 @@ var walkLocalContentMedia = (content, handler) => {
   for (const [contentType, entries] of content.entries ?? []) {
     for (const entry of entries) {
       walkMediaValues(entry.data, `entries.${contentType}.${entry.identifier}.data`, handler);
+      for (const [slotKey, blocks] of Object.entries(entry.blocks ?? {})) {
+        for (const block of blocks) {
+          walkMediaValues(
+            block.content,
+            `entries.${contentType}.${entry.identifier}.blocks.${slotKey}.${block.identifier ?? "unidentified"}.content`,
+            handler
+          );
+        }
+      }
     }
   }
   for (const page of content.pages ?? []) {
@@ -46468,6 +48127,15 @@ var walkPulledContentMedia = (content, handler) => {
   for (const [contentType, entries] of Object.entries(content.entries)) {
     for (const entry of entries) {
       walkMediaValues(entry.data, `entries.${contentType}.${entry.identifier}.data`, handler);
+      for (const [slotKey, blocks] of Object.entries(entry.blocks ?? {})) {
+        for (const block of blocks) {
+          walkMediaValues(
+            block.content,
+            `entries.${contentType}.${entry.identifier}.blocks.${slotKey}.${block.identifier ?? "unidentified"}.content`,
+            handler
+          );
+        }
+      }
     }
   }
   for (const page of content.pages) {
@@ -46526,7 +48194,7 @@ var normalizeMediaValueToIdentifierOnly = (value, identifier, asset) => {
 };
 
 // src/cli/media/rich-text.ts
-var isRecord12 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord14 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 function collectRichTextImageAttrs(value, out = [], location2 = "") {
   if (Array.isArray(value)) {
     value.forEach(
@@ -46534,8 +48202,8 @@ function collectRichTextImageAttrs(value, out = [], location2 = "") {
     );
     return out;
   }
-  if (!isRecord12(value)) return out;
-  if (value.type === "image" && isRecord12(value.attrs)) {
+  if (!isRecord14(value)) return out;
+  if (value.type === "image" && isRecord14(value.attrs)) {
     out.push({ attrs: value.attrs, location: location2 ? `${location2}.attrs` : "attrs" });
   }
   for (const [key, child] of Object.entries(value)) {
@@ -49166,7 +50834,7 @@ async function writeAllEntries(contentDir, entriesByType, pulledAt, entriesMeta,
     }
     const { dirPath, count } = await writeEntries(contentDir, {
       contentType,
-      entries,
+      entries: entries.map(mapEntryForOutput),
       meta: { pulledAt, entries: ctMeta },
       pagination: { limit: entries.length, total: entries.length}
     }, writerOptions);
@@ -49181,7 +50849,7 @@ async function fetchAllContentPaginated(client, contentTypes, output, baseConten
   for (const contentType of contentTypes) {
     output.info(`Fetching ${contentType} entries...`);
     const result = await pullEntriesWithPagination(client, contentType, output);
-    allEntries[contentType] = result.entries.map(mapEntryForOutput);
+    allEntries[contentType] = result.entries;
     for (const [id, meta] of Object.entries(result.meta.entries || {})) {
       allMeta[`${contentType}:${id}`] = meta;
     }
@@ -50446,10 +52114,303 @@ function normalizeLocalContentShape(content) {
     courses: Array.isArray(value.courses) ? value.courses : []
   };
 }
+
+// ../api/src/sdk-event-pricing.ts
+var identifierRegex = /^[a-z0-9][a-z0-9-]*$/;
+var currencyRegex = /^[A-Z]{3}$/;
+var isoDateTimeRegex = /^\d{4}-\d{2}-\d{2}T.+/;
+function issue2(path25, message) {
+  return { path: path25, message };
+}
+function isRecord15(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isCurrency(value) {
+  return typeof value === "string" && currencyRegex.test(value);
+}
+function isWholeNumber(value) {
+  return typeof value === "number" && Number.isInteger(value);
+}
+function isWholeMinuteIsoDateTime(value) {
+  if (!isoDateTimeRegex.test(value)) return false;
+  const epochMs = Date.parse(value);
+  return Number.isFinite(epochMs) && epochMs % 6e4 === 0;
+}
+function validateTicketType(raw, index, currency) {
+  const path25 = ["ticketTypes", String(index)];
+  if (!isRecord15(raw)) return [issue2(path25, "Ticket type must be an object")];
+  const issues = [];
+  const identifier = raw.identifier;
+  if (typeof identifier !== "string" || !identifierRegex.test(identifier)) {
+    issues.push(
+      issue2(
+        [...path25, "identifier"],
+        "Ticket identifier must use lowercase letters, numbers, and hyphens"
+      )
+    );
+  }
+  const name = raw.name;
+  if (typeof name !== "string" || name.trim().length === 0) {
+    issues.push(issue2([...path25, "name"], "Ticket name is required"));
+  }
+  const priceAmount = raw.priceAmount;
+  if (!isWholeNumber(priceAmount) || priceAmount < 0) {
+    issues.push(
+      issue2(
+        [...path25, "priceAmount"],
+        "Ticket priceAmount must be a non-negative integer"
+      )
+    );
+  }
+  const priceCurrency = raw.priceCurrency;
+  if (priceCurrency !== void 0 && priceCurrency !== null && priceCurrency !== currency) {
+    issues.push(
+      issue2(
+        [...path25, "priceCurrency"],
+        "Ticket priceCurrency must match pricing.priceCurrency"
+      )
+    );
+  }
+  const sortOrder = raw.sortOrder;
+  if (sortOrder !== void 0 && (!isWholeNumber(sortOrder) || sortOrder < 0)) {
+    issues.push(
+      issue2(
+        [...path25, "sortOrder"],
+        "Ticket sortOrder must be a non-negative integer"
+      )
+    );
+  }
+  const capacityLimit2 = raw.capacityLimit;
+  if (capacityLimit2 !== void 0 && capacityLimit2 !== null && (!isWholeNumber(capacityLimit2) || capacityLimit2 < 1)) {
+    issues.push(
+      issue2(
+        [...path25, "capacityLimit"],
+        "Ticket capacityLimit must be a positive integer"
+      )
+    );
+  }
+  const attendanceScope = raw.attendanceScope;
+  if (attendanceScope !== void 0 && attendanceScope !== "in_person" && attendanceScope !== "online" && attendanceScope !== "both") {
+    issues.push(
+      issue2(
+        [...path25, "attendanceScope"],
+        "Ticket attendanceScope must be in_person, online, or both"
+      )
+    );
+  }
+  const saleStartsAt = raw.saleStartsAt;
+  if (saleStartsAt !== void 0 && saleStartsAt !== null && (typeof saleStartsAt !== "string" || !isWholeMinuteIsoDateTime(saleStartsAt))) {
+    issues.push(
+      issue2(
+        [...path25, "saleStartsAt"],
+        "Ticket saleStartsAt must be an ISO datetime aligned to a whole minute"
+      )
+    );
+  }
+  const saleEndsAt = raw.saleEndsAt;
+  if (saleEndsAt !== void 0 && saleEndsAt !== null && (typeof saleEndsAt !== "string" || !isWholeMinuteIsoDateTime(saleEndsAt))) {
+    issues.push(
+      issue2(
+        [...path25, "saleEndsAt"],
+        "Ticket saleEndsAt must be an ISO datetime aligned to a whole minute"
+      )
+    );
+  }
+  if (typeof saleStartsAt === "string" && typeof saleEndsAt === "string" && Date.parse(saleEndsAt) <= Date.parse(saleStartsAt)) {
+    issues.push(
+      issue2(
+        [...path25, "saleEndsAt"],
+        "Ticket saleEndsAt must be after saleStartsAt"
+      )
+    );
+  }
+  const cmsTicketTypeId = raw.cmsTicketTypeId;
+  if (cmsTicketTypeId !== void 0 && cmsTicketTypeId !== null && (typeof cmsTicketTypeId !== "string" || cmsTicketTypeId.length === 0)) {
+    issues.push(
+      issue2(
+        [...path25, "cmsTicketTypeId"],
+        "Ticket cmsTicketTypeId must be a non-empty string"
+      )
+    );
+  }
+  if (issues.length > 0) return issues;
+  return {
+    identifier,
+    ...cmsTicketTypeId ? { cmsTicketTypeId } : {},
+    name,
+    description: typeof raw.description === "string" ? raw.description : null,
+    priceAmount,
+    isActive: typeof raw.isActive === "boolean" ? raw.isActive : true,
+    sortOrder: isWholeNumber(sortOrder) ? sortOrder : index,
+    capacityLimit: isWholeNumber(capacityLimit2) ? capacityLimit2 : null,
+    attendanceScope: attendanceScope === "in_person" || attendanceScope === "online" || attendanceScope === "both" ? attendanceScope : "both",
+    saleStartsAt: typeof saleStartsAt === "string" ? saleStartsAt : null,
+    saleEndsAt: typeof saleEndsAt === "string" ? saleEndsAt : null
+  };
+}
+function validateTicketTypes(rawTicketTypes, currency) {
+  if (!Array.isArray(rawTicketTypes) || rawTicketTypes.length === 0) {
+    return [
+      issue2(
+        ["ticketTypes"],
+        "Ticket-type pricing requires at least one ticket type"
+      )
+    ];
+  }
+  const issues = [];
+  const ticketTypes = [];
+  const seenIdentifiers = /* @__PURE__ */ new Set();
+  rawTicketTypes.forEach((rawTicketType, index) => {
+    const rawIdentifier = isRecord15(rawTicketType) ? rawTicketType.identifier : void 0;
+    const hasValidIdentifier = typeof rawIdentifier === "string" && identifierRegex.test(rawIdentifier);
+    const isDuplicateIdentifier = hasValidIdentifier && seenIdentifiers.has(rawIdentifier);
+    if (isDuplicateIdentifier) {
+      issues.push(
+        issue2(
+          ["ticketTypes", String(index), "identifier"],
+          `Duplicate ticket identifier "${rawIdentifier}"`
+        )
+      );
+    } else if (hasValidIdentifier) {
+      seenIdentifiers.add(rawIdentifier);
+    }
+    const parsed = validateTicketType(rawTicketType, index, currency);
+    if (Array.isArray(parsed)) {
+      issues.push(...parsed);
+      return;
+    }
+    if (isDuplicateIdentifier) {
+      return;
+    }
+    ticketTypes.push(parsed);
+  });
+  if (issues.length > 0) return issues;
+  return sortSdkEventTicketTypes(ticketTypes);
+}
+function isPricingIssueArray(value) {
+  const first = value[0];
+  return first !== void 0 && "message" in first;
+}
+function sortSdkEventTicketTypes(ticketTypes) {
+  return [...ticketTypes].sort((left, right) => {
+    const leftOrder = left.sortOrder ?? Number.MAX_SAFE_INTEGER;
+    const rightOrder = right.sortOrder ?? Number.MAX_SAFE_INTEGER;
+    if (leftOrder !== rightOrder) return leftOrder - rightOrder;
+    const identifierCompare = left.identifier.localeCompare(right.identifier);
+    if (identifierCompare !== 0) return identifierCompare;
+    return left.name.localeCompare(right.name);
+  });
+}
+function classifySdkEventPricing(rawInput) {
+  if (rawInput === void 0 || rawInput === null) {
+    return { ok: true, pricing: { kind: "free" } };
+  }
+  if (!isRecord15(rawInput)) {
+    return { ok: false, issues: [issue2([], "Pricing must be an object")] };
+  }
+  const record = rawInput;
+  const kind = typeof record.kind === "string" ? record.kind : record.pricingMode === "ticket_types" ? "ticket_types" : record.pricingMode === "fixed_price" ? "fixed_price" : record.pricingMode === "free" ? "free" : record.requiresPayment || typeof record.priceAmount === "number" && record.priceAmount > 0 ? "fixed_price" : "free";
+  const acceptsPasses = typeof record.acceptsPasses === "boolean" ? record.acceptsPasses : void 0;
+  const acceptsMemberships = typeof record.acceptsMemberships === "boolean" ? record.acceptsMemberships : void 0;
+  const priceDisplay = typeof record.priceDisplay === "string" ? record.priceDisplay : null;
+  switch (kind) {
+    case "free":
+      return {
+        ok: true,
+        pricing: {
+          kind: "free",
+          priceDisplay,
+          ...acceptsPasses !== void 0 ? { acceptsPasses } : {},
+          ...acceptsMemberships !== void 0 ? { acceptsMemberships } : {}
+        }
+      };
+    case "fixed_price": {
+      const issues = [];
+      const priceAmount = record.priceAmount;
+      if (!isWholeNumber(priceAmount) || priceAmount < 0) {
+        issues.push(
+          issue2(
+            ["priceAmount"],
+            "Fixed-price events require a non-negative integer priceAmount"
+          )
+        );
+      }
+      const rawPriceCurrency = record.priceCurrency;
+      const priceCurrency = rawPriceCurrency === void 0 || rawPriceCurrency === null ? "USD" : isCurrency(rawPriceCurrency) ? rawPriceCurrency : null;
+      if (rawPriceCurrency !== void 0 && rawPriceCurrency !== null && !isCurrency(rawPriceCurrency)) {
+        issues.push(
+          issue2(
+            ["priceCurrency"],
+            "priceCurrency must be a 3-letter uppercase currency code"
+          )
+        );
+      }
+      if (issues.length > 0) return { ok: false, issues };
+      if (!isWholeNumber(priceAmount) || priceCurrency === null) {
+        return {
+          ok: false,
+          issues: [issue2(["priceAmount"], "Invalid fixed-price event pricing")]
+        };
+      }
+      return {
+        ok: true,
+        pricing: {
+          kind: "fixed_price",
+          priceAmount,
+          priceCurrency,
+          priceDisplay,
+          ...acceptsPasses !== void 0 ? { acceptsPasses } : {},
+          ...acceptsMemberships !== void 0 ? { acceptsMemberships } : {}
+        }
+      };
+    }
+    case "ticket_types": {
+      const priceCurrency = record.priceCurrency;
+      if (!isCurrency(priceCurrency)) {
+        return {
+          ok: false,
+          issues: [
+            issue2(
+              ["priceCurrency"],
+              "Ticket-type pricing requires a 3-letter uppercase priceCurrency"
+            )
+          ]
+        };
+      }
+      const ticketTypes = record.ticketTypes === void 0 || record.ticketTypes === null ? [] : validateTicketTypes(record.ticketTypes, priceCurrency);
+      if (isPricingIssueArray(ticketTypes)) {
+        return { ok: false, issues: ticketTypes };
+      }
+      return {
+        ok: true,
+        pricing: {
+          kind: "ticket_types",
+          priceCurrency,
+          priceDisplay,
+          ...acceptsPasses !== void 0 ? { acceptsPasses } : {},
+          ...acceptsMemberships !== void 0 ? { acceptsMemberships } : {},
+          ticketTypes
+        }
+      };
+    }
+    default:
+      return {
+        ok: false,
+        issues: [
+          issue2(
+            ["kind"],
+            "Pricing kind must be free, fixed_price, or ticket_types"
+          )
+        ]
+      };
+  }
+}
+
+// src/cli/commands/push/pushAllExtras.ts
 function nullishToNull(value) {
   return value == null ? null : value;
 }
-function isRecord13(value) {
+function isRecord16(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function stringValue(value, fallback) {
@@ -50459,8 +52420,13 @@ function stringValue(value, fallback) {
   }
   return fallback;
 }
+function normalizeEventPricingForCompare(pricing) {
+  const result = classifySdkEventPricing(pricing);
+  if (result.ok) return result.pricing;
+  return { kind: "free" };
+}
 function normalizeVenueAddress(value) {
-  const obj = isRecord13(value) ? value : {};
+  const obj = isRecord16(value) ? value : {};
   return {
     line1: nullishToNull(typeof obj.line1 === "string" ? obj.line1 : void 0),
     line2: nullishToNull(typeof obj.line2 === "string" ? obj.line2 : void 0),
@@ -50477,7 +52443,7 @@ function normalizeVenueAddress(value) {
   };
 }
 function normalizeVenueLocation(value) {
-  if (!isRecord13(value)) return null;
+  if (!isRecord16(value)) return null;
   const obj = value;
   const lat = typeof obj.lat === "number" ? obj.lat : null;
   const lng = typeof obj.lng === "number" ? obj.lng : null;
@@ -50485,32 +52451,41 @@ function normalizeVenueLocation(value) {
   return { lat, lng };
 }
 function normalizeVenueForCompare(venue) {
-  const obj = isRecord13(venue) ? venue : {};
+  const obj = isRecord16(venue) ? venue : {};
   return {
     slug: String(obj.slug),
     title: String(obj.title),
-    description: nullishToNull(typeof obj.description === "string" ? obj.description : void 0),
-    timezone: nullishToNull(typeof obj.timezone === "string" ? obj.timezone : void 0),
-    capacity: nullishToNull(typeof obj.capacity === "number" ? obj.capacity : void 0),
+    description: nullishToNull(
+      typeof obj.description === "string" ? obj.description : void 0
+    ),
+    timezone: nullishToNull(
+      typeof obj.timezone === "string" ? obj.timezone : void 0
+    ),
+    capacity: nullishToNull(
+      typeof obj.capacity === "number" ? obj.capacity : void 0
+    ),
     address: normalizeVenueAddress(obj.address),
     location: normalizeVenueLocation(obj.location),
-    mapEmbed: nullishToNull(typeof obj.mapEmbed === "string" ? obj.mapEmbed : void 0)
+    mapEmbed: nullishToNull(
+      typeof obj.mapEmbed === "string" ? obj.mapEmbed : void 0
+    )
   };
 }
 function normalizeEventCategoryForCompare(category) {
-  const obj = isRecord13(category) ? category : {};
+  const obj = isRecord16(category) ? category : {};
   return {
     identifier: String(obj.identifier),
     name: String(obj.name),
-    description: nullishToNull(typeof obj.description === "string" ? obj.description : void 0),
+    description: nullishToNull(
+      typeof obj.description === "string" ? obj.description : void 0
+    ),
     color: nullishToNull(typeof obj.color === "string" ? obj.color : void 0),
     sortOrder: typeof obj.sortOrder === "number" ? obj.sortOrder : 0
   };
 }
 function normalizeRemoteEventForCompare(event) {
-  const obj = isRecord13(event) ? event : {};
-  const schedule = isRecord13(obj.schedule) ? obj.schedule : {};
-  const pricing = isRecord13(obj.pricing) ? obj.pricing : {};
+  const obj = isRecord16(event) ? event : {};
+  const schedule = isRecord16(obj.schedule) ? obj.schedule : {};
   return {
     identifier: String(obj.identifier),
     title: String(obj.title),
@@ -50521,36 +52496,31 @@ function normalizeRemoteEventForCompare(event) {
       recurrenceRule: nullishToNull(
         schedule.recurrenceRule
       ),
-      startDate: nullishToNull(
-        schedule.startDate
-      ),
+      startDate: nullishToNull(schedule.startDate),
       defaultStartTime: stringValue(schedule.defaultStartTime, "09:00:00"),
       durationMinutes: typeof schedule.durationMinutes === "number" ? schedule.durationMinutes : 60
     },
-    capacity: nullishToNull(typeof obj.capacity === "number" ? obj.capacity : void 0),
-    pricing: {
-      requiresPayment: Boolean(pricing.requiresPayment ?? false),
-      priceAmount: nullishToNull(pricing.priceAmount),
-      priceCurrency: nullishToNull(
-        pricing.priceCurrency
-      ),
-      priceDisplay: nullishToNull(
-        pricing.priceDisplay
-      ),
-      acceptsPasses: Boolean(pricing.acceptsPasses ?? true),
-      acceptsMemberships: Boolean(pricing.acceptsMemberships ?? true)
-    },
-    venueRef: nullishToNull(typeof obj.venueRef === "string" ? obj.venueRef : void 0),
-    categoryRef: nullishToNull(typeof obj.categoryRef === "string" ? obj.categoryRef : void 0),
-    formRef: nullishToNull(typeof obj.formRef === "string" ? obj.formRef : void 0),
-    content: isRecord13(obj.content) ? obj.content : {},
-    settings: isRecord13(obj.settings) ? obj.settings : {},
-    presentation: isRecord13(obj.presentation) ? obj.presentation : null,
+    capacity: nullishToNull(
+      typeof obj.capacity === "number" ? obj.capacity : void 0
+    ),
+    pricing: normalizeEventPricingForCompare(obj.pricing),
+    venueRef: nullishToNull(
+      typeof obj.venueRef === "string" ? obj.venueRef : void 0
+    ),
+    categoryRef: nullishToNull(
+      typeof obj.categoryRef === "string" ? obj.categoryRef : void 0
+    ),
+    formRef: nullishToNull(
+      typeof obj.formRef === "string" ? obj.formRef : void 0
+    ),
+    content: isRecord16(obj.content) ? obj.content : {},
+    settings: isRecord16(obj.settings) ? obj.settings : {},
+    presentation: isRecord16(obj.presentation) ? obj.presentation : null,
     tags: Array.isArray(obj.tags) ? obj.tags : []
   };
 }
 function normalizeLocalEventAgainstRemoteForCompare(localEvent, remoteEvent) {
-  const local = isRecord13(localEvent) ? localEvent : {};
+  const local = isRecord16(localEvent) ? localEvent : {};
   const base = remoteEvent ? normalizeRemoteEventForCompare(remoteEvent) : normalizeRemoteEventForCompare({
     identifier: local.identifier,
     title: local.title,
@@ -50568,8 +52538,7 @@ function normalizeLocalEventAgainstRemoteForCompare(localEvent, remoteEvent) {
     presentation: local.presentation ?? null,
     tags: local.tags ?? []
   });
-  const schedule = isRecord13(local.schedule) ? local.schedule : {};
-  const pricing = isRecord13(local.pricing) ? local.pricing : {};
+  const schedule = isRecord16(local.schedule) ? local.schedule : {};
   return {
     ...base,
     identifier: stringValue(local.identifier, base.identifier),
@@ -50580,24 +52549,28 @@ function normalizeLocalEventAgainstRemoteForCompare(localEvent, remoteEvent) {
     schedule: {
       recurrenceRule: schedule.recurrenceRule === void 0 ? base.schedule.recurrenceRule : nullishToNull(schedule.recurrenceRule),
       startDate: schedule.startDate === void 0 ? base.schedule.startDate : nullishToNull(schedule.startDate),
-      defaultStartTime: schedule.defaultStartTime === void 0 ? base.schedule.defaultStartTime : stringValue(schedule.defaultStartTime, base.schedule.defaultStartTime),
+      defaultStartTime: schedule.defaultStartTime === void 0 ? base.schedule.defaultStartTime : stringValue(
+        schedule.defaultStartTime,
+        base.schedule.defaultStartTime
+      ),
       durationMinutes: schedule.durationMinutes === void 0 ? base.schedule.durationMinutes : typeof schedule.durationMinutes === "number" ? schedule.durationMinutes : base.schedule.durationMinutes
     },
-    capacity: local.capacity === void 0 ? base.capacity : nullishToNull(typeof local.capacity === "number" ? local.capacity : void 0),
-    pricing: {
-      requiresPayment: pricing.requiresPayment === void 0 ? base.pricing.requiresPayment : Boolean(pricing.requiresPayment),
-      priceAmount: pricing.priceAmount === void 0 ? base.pricing.priceAmount : nullishToNull(pricing.priceAmount),
-      priceCurrency: pricing.priceCurrency === void 0 ? base.pricing.priceCurrency : nullishToNull(pricing.priceCurrency),
-      priceDisplay: pricing.priceDisplay === void 0 ? base.pricing.priceDisplay : nullishToNull(pricing.priceDisplay),
-      acceptsPasses: pricing.acceptsPasses === void 0 ? base.pricing.acceptsPasses : Boolean(pricing.acceptsPasses),
-      acceptsMemberships: pricing.acceptsMemberships === void 0 ? base.pricing.acceptsMemberships : Boolean(pricing.acceptsMemberships)
-    },
-    venueRef: local.venueRef === void 0 ? base.venueRef : nullishToNull(typeof local.venueRef === "string" ? local.venueRef : void 0),
-    categoryRef: local.categoryRef === void 0 ? base.categoryRef : nullishToNull(typeof local.categoryRef === "string" ? local.categoryRef : void 0),
-    formRef: local.formRef === void 0 ? base.formRef : nullishToNull(typeof local.formRef === "string" ? local.formRef : void 0),
-    content: local.content === void 0 ? base.content : isRecord13(local.content) ? local.content : {},
-    settings: local.settings === void 0 ? base.settings : isRecord13(local.settings) ? local.settings : {},
-    presentation: local.presentation === void 0 ? base.presentation : isRecord13(local.presentation) ? local.presentation : null,
+    capacity: local.capacity === void 0 ? base.capacity : nullishToNull(
+      typeof local.capacity === "number" ? local.capacity : void 0
+    ),
+    pricing: local.pricing === void 0 ? base.pricing : normalizeEventPricingForCompare(local.pricing),
+    venueRef: local.venueRef === void 0 ? base.venueRef : nullishToNull(
+      typeof local.venueRef === "string" ? local.venueRef : void 0
+    ),
+    categoryRef: local.categoryRef === void 0 ? base.categoryRef : nullishToNull(
+      typeof local.categoryRef === "string" ? local.categoryRef : void 0
+    ),
+    formRef: local.formRef === void 0 ? base.formRef : nullishToNull(
+      typeof local.formRef === "string" ? local.formRef : void 0
+    ),
+    content: local.content === void 0 ? base.content : isRecord16(local.content) ? local.content : {},
+    settings: local.settings === void 0 ? base.settings : isRecord16(local.settings) ? local.settings : {},
+    presentation: local.presentation === void 0 ? base.presentation : isRecord16(local.presentation) ? local.presentation : null,
     tags: local.tags === void 0 ? base.tags : Array.isArray(local.tags) ? local.tags : []
   };
 }
@@ -50609,7 +52582,7 @@ function toIsoStringOrOriginal(value) {
 function normalizeCourseSessions(value) {
   if (!Array.isArray(value)) return [];
   return value.map((session) => {
-    const obj = isRecord13(session) ? session : {};
+    const obj = isRecord16(session) ? session : {};
     return {
       startsAt: toIsoStringOrOriginal(obj.startsAt),
       endsAt: toIsoStringOrOriginal(obj.endsAt)
@@ -50621,41 +52594,53 @@ function normalizeCourseSessions(value) {
 }
 function normalizeCourseProgram(value) {
   if (value == null) return null;
-  if (!isRecord13(value)) {
+  if (!isRecord16(value)) {
     return { identifier: null, data: {} };
   }
   return {
     identifier: nullishToNull(
       typeof value.identifier === "string" ? value.identifier : void 0
     ),
-    data: isRecord13(value.data) ? value.data : {}
+    data: isRecord16(value.data) ? value.data : {}
   };
 }
 function normalizeRemoteCourseForCompare(course) {
-  const obj = isRecord13(course) ? course : {};
+  const obj = isRecord16(course) ? course : {};
   return {
     identifier: String(obj.identifier),
     title: String(obj.title),
     slug: String(obj.slug),
     status: obj.status === "active" || obj.status === "cancelled" || obj.status === "completed" ? obj.status : "draft",
     visibility: obj.visibility === "public" || obj.visibility === "private" || obj.visibility === "unlisted" ? obj.visibility : "public",
-    venueRef: nullishToNull(typeof obj.venueRef === "string" ? obj.venueRef : void 0),
-    categoryRef: nullishToNull(typeof obj.categoryRef === "string" ? obj.categoryRef : void 0),
-    formRef: nullishToNull(typeof obj.formRef === "string" ? obj.formRef : void 0),
-    capacity: nullishToNull(typeof obj.capacity === "number" ? obj.capacity : void 0),
+    venueRef: nullishToNull(
+      typeof obj.venueRef === "string" ? obj.venueRef : void 0
+    ),
+    categoryRef: nullishToNull(
+      typeof obj.categoryRef === "string" ? obj.categoryRef : void 0
+    ),
+    formRef: nullishToNull(
+      typeof obj.formRef === "string" ? obj.formRef : void 0
+    ),
+    capacity: nullishToNull(
+      typeof obj.capacity === "number" ? obj.capacity : void 0
+    ),
     enrollmentCapacity: nullishToNull(
       typeof obj.enrollmentCapacity === "number" ? obj.enrollmentCapacity : void 0
     ),
     acceptsMemberships: Boolean(obj.acceptsMemberships ?? false),
-    priceCents: nullishToNull(typeof obj.priceCents === "number" ? obj.priceCents : void 0),
+    priceCents: nullishToNull(
+      typeof obj.priceCents === "number" ? obj.priceCents : void 0
+    ),
     currency: typeof obj.currency === "string" && obj.currency.trim().length > 0 ? obj.currency.toUpperCase() : "GBP",
     sessions: normalizeCourseSessions(obj.sessions),
-    programRef: nullishToNull(typeof obj.programRef === "string" ? obj.programRef : void 0),
+    programRef: nullishToNull(
+      typeof obj.programRef === "string" ? obj.programRef : void 0
+    ),
     program: normalizeCourseProgram(obj.program)
   };
 }
 function normalizeLocalCourseAgainstRemoteForCompare(localCourse, remoteCourse) {
-  const local = isRecord13(localCourse) ? localCourse : {};
+  const local = isRecord16(localCourse) ? localCourse : {};
   const base = remoteCourse ? normalizeRemoteCourseForCompare(remoteCourse) : normalizeRemoteCourseForCompare({
     identifier: local.identifier,
     title: local.title,
@@ -50676,11 +52661,11 @@ function normalizeLocalCourseAgainstRemoteForCompare(localCourse, remoteCourse)
   });
   const status = local.status === void 0 ? base.status : local.status === "active" || local.status === "cancelled" || local.status === "completed" ? local.status : "draft";
   const visibility = local.visibility === void 0 ? base.visibility : local.visibility === "public" || local.visibility === "private" || local.visibility === "unlisted" ? local.visibility : "public";
-  const program2 = local.program === void 0 ? base.program : local.program === null ? null : isRecord13(local.program) ? {
+  const program2 = local.program === void 0 ? base.program : local.program === null ? null : isRecord16(local.program) ? {
     identifier: local.program.identifier === void 0 ? base.program?.identifier ?? null : nullishToNull(
       typeof local.program.identifier === "string" ? local.program.identifier : void 0
     ),
-    data: isRecord13(local.program.data) ? local.program.data : base.program?.data ?? {}
+    data: isRecord16(local.program.data) ? local.program.data : base.program?.data ?? {}
   } : base.program;
   return {
     ...base,
@@ -50689,18 +52674,30 @@ function normalizeLocalCourseAgainstRemoteForCompare(localCourse, remoteCourse)
     slug: stringValue(local.slug, base.slug),
     status,
     visibility,
-    venueRef: local.venueRef === void 0 ? base.venueRef : nullishToNull(typeof local.venueRef === "string" ? local.venueRef : void 0),
-    categoryRef: local.categoryRef === void 0 ? base.categoryRef : nullishToNull(typeof local.categoryRef === "string" ? local.categoryRef : void 0),
-    formRef: local.formRef === void 0 ? base.formRef : nullishToNull(typeof local.formRef === "string" ? local.formRef : void 0),
-    capacity: local.capacity === void 0 ? base.capacity : nullishToNull(typeof local.capacity === "number" ? local.capacity : void 0),
+    venueRef: local.venueRef === void 0 ? base.venueRef : nullishToNull(
+      typeof local.venueRef === "string" ? local.venueRef : void 0
+    ),
+    categoryRef: local.categoryRef === void 0 ? base.categoryRef : nullishToNull(
+      typeof local.categoryRef === "string" ? local.categoryRef : void 0
+    ),
+    formRef: local.formRef === void 0 ? base.formRef : nullishToNull(
+      typeof local.formRef === "string" ? local.formRef : void 0
+    ),
+    capacity: local.capacity === void 0 ? base.capacity : nullishToNull(
+      typeof local.capacity === "number" ? local.capacity : void 0
+    ),
     enrollmentCapacity: local.enrollmentCapacity === void 0 ? base.enrollmentCapacity : nullishToNull(
       typeof local.enrollmentCapacity === "number" ? local.enrollmentCapacity : void 0
     ),
     acceptsMemberships: local.acceptsMemberships === void 0 ? base.acceptsMemberships : Boolean(local.acceptsMemberships),
-    priceCents: local.priceCents === void 0 ? base.priceCents : nullishToNull(typeof local.priceCents === "number" ? local.priceCents : void 0),
+    priceCents: local.priceCents === void 0 ? base.priceCents : nullishToNull(
+      typeof local.priceCents === "number" ? local.priceCents : void 0
+    ),
     currency: local.currency === void 0 ? base.currency : typeof local.currency === "string" && local.currency.trim().length > 0 ? local.currency.toUpperCase() : base.currency,
     sessions: local.sessions === void 0 ? base.sessions : normalizeCourseSessions(local.sessions),
-    programRef: local.programRef === void 0 ? base.programRef : nullishToNull(typeof local.programRef === "string" ? local.programRef : void 0),
+    programRef: local.programRef === void 0 ? base.programRef : nullishToNull(
+      typeof local.programRef === "string" ? local.programRef : void 0
+    ),
     program: program2
   };
 }
@@ -50717,26 +52714,15 @@ function detectOrphans(changes, localIds, remoteMap) {
 }
 function calculatePushAllExtraChanges(local, remote, options) {
   const deleteOrphaned = options?.deleteOrphaned ?? false;
-  const remoteVenues = new Map(
-    (remote.venues ?? []).map((v) => [v.slug, v])
-  );
+  const remoteVenues = new Map((remote.venues ?? []).map((v) => [v.slug, v]));
   const remoteCategories = new Map(
-    (remote.eventCategories ?? []).map((c) => [
-      c.identifier,
-      c
-    ])
+    (remote.eventCategories ?? []).map((c) => [c.identifier, c])
   );
   const remoteEvents = new Map(
-    (remote.events ?? []).map((e) => [
-      e.identifier,
-      e
-    ])
+    (remote.events ?? []).map((e) => [e.identifier, e])
   );
   const remoteCourses = new Map(
-    (remote.courses ?? []).map((course) => [
-      course.identifier,
-      course
-    ])
+    (remote.courses ?? []).map((course) => [course.identifier, course])
   );
   const venues = {
     toPush: /* @__PURE__ */ new Set(),
@@ -50801,7 +52787,10 @@ function calculatePushAllExtraChanges(local, remote, options) {
       events.toPush.add(identifier);
       continue;
     }
-    const localNorm = normalizeLocalEventAgainstRemoteForCompare(event, remoteEvent);
+    const localNorm = normalizeLocalEventAgainstRemoteForCompare(
+      event,
+      remoteEvent
+    );
     const remoteNorm = normalizeRemoteEventForCompare(remoteEvent);
     if (!equal(localNorm, remoteNorm)) {
       events.update++;
@@ -50825,7 +52814,10 @@ function calculatePushAllExtraChanges(local, remote, options) {
       courses.toPush.add(identifier);
       continue;
     }
-    const localNorm = normalizeLocalCourseAgainstRemoteForCompare(course, remoteCourse);
+    const localNorm = normalizeLocalCourseAgainstRemoteForCompare(
+      course,
+      remoteCourse
+    );
     const remoteNorm = normalizeRemoteCourseForCompare(remoteCourse);
     if (!equal(localNorm, remoteNorm)) {
       courses.update++;
@@ -50835,10 +52827,26 @@ function calculatePushAllExtraChanges(local, remote, options) {
     }
   }
   if (deleteOrphaned) {
-    detectOrphans(venues, local.venues.map((v) => String(v.slug)), remoteVenues);
-    detectOrphans(eventCategories, local.eventCategories.map((c) => String(c.identifier)), remoteCategories);
-    detectOrphans(events, local.events.map((e) => String(e.identifier)), remoteEvents);
-    detectOrphans(courses, local.courses.map((course) => String(course.identifier)), remoteCourses);
+    detectOrphans(
+      venues,
+      local.venues.map((v) => String(v.slug)),
+      remoteVenues
+    );
+    detectOrphans(
+      eventCategories,
+      local.eventCategories.map((c) => String(c.identifier)),
+      remoteCategories
+    );
+    detectOrphans(
+      events,
+      local.events.map((e) => String(e.identifier)),
+      remoteEvents
+    );
+    detectOrphans(
+      courses,
+      local.courses.map((course) => String(course.identifier)),
+      remoteCourses
+    );
   }
   return {
     venues,
@@ -51264,6 +53272,12 @@ var appointmentResourceRefSchema = resourceRefSchema("appointment-resource");
 var appointmentAvailabilityRefSchema = resourceRefSchema("availability");
 var unknownRecordSchema = z.record(z.string(), z.unknown());
 var stringArraySchema = z.array(z.string()).readonly();
+var entrySlotBlockSchema = z.object({
+  identifier: z.string().nullable().optional(),
+  kind: z.string().min(1),
+  content: unknownRecordSchema
+}).strict();
+var entrySlotBlocksSchema = z.record(z.string(), z.array(entrySlotBlockSchema));
 var positiveIntegerSchema = z.number().int().positive();
 var nonNegativeIntegerSchema = z.number().int().nonnegative();
 var recipeIdentifierSchema = z.string().regex(
@@ -51642,6 +53656,7 @@ var upsertContentEntryCommandSchema = z.object({
     title: z.string().min(1).optional(),
     manualOrder: z.number().int().min(0).optional(),
     data: unknownRecordSchema.optional(),
+    blocks: entrySlotBlocksSchema.optional(),
     linkedSubjectRef: contentEntryRefSchema.optional(),
     mediaRefs: z.array(mediaRefSchema).readonly().optional()
   }).strict()
@@ -52885,7 +54900,7 @@ function getSiteCommandLifecycleIntent(command) {
 init_src();
 
 // ../site-commands/src/guards.ts
-function isRecord14(value) {
+function isRecord17(value) {
   return typeof value === "object" && value !== null;
 }
 
@@ -53150,7 +55165,7 @@ function collectVenueRefsFromIntervals(intervals, path25) {
 }
 function collectNavigationRefs(items, path25) {
   return items.flatMap((item, index) => {
-    if (!isRecord14(item)) return [];
+    if (!isRecord17(item)) return [];
     const itemPath = `${path25}[${index}]`;
     const refs = [];
     if (typeof item.pageRef === "string") {
@@ -53167,7 +55182,7 @@ function collectNavigationRefs(items, path25) {
 }
 function collectBlockRefs(blocks, path25) {
   return blocks.flatMap((block, index) => {
-    if (!isRecord14(block)) return [];
+    if (!isRecord17(block)) return [];
     const blockPath = `${path25}[${index}]`;
     return [
       ...collectNestedRefs(block.props, `${blockPath}.props`),
@@ -53183,7 +55198,7 @@ function collectNestedRefs(value, path25) {
   if (Array.isArray(value)) {
     return value.flatMap((item, index) => collectNestedRefs(item, `${path25}[${index}]`));
   }
-  if (!isRecord14(value)) return [];
+  if (!isRecord17(value)) return [];
   return Object.entries(value).flatMap(([key, child]) => collectNestedRefs(child, `${path25}.${key}`));
 }
 
@@ -53267,7 +55282,7 @@ function parseCommandBatch(input) {
   if (unknownTypeErrors.length > 0) return err(unknownTypeErrors);
   const parsed = siteCommandBatchSchema.safeParse(input);
   if (!parsed.success) {
-    return err(parsed.error.issues.map((issue2) => invalidPayloadError(input, issue2)));
+    return err(parsed.error.issues.map((issue4) => invalidPayloadError(input, issue4)));
   }
   return ok(parsed.data);
 }
@@ -53439,9 +55454,9 @@ function deriveIdempotencyKey(input) {
   ].join("|"));
 }
 function findUnknownCommandTypes(input) {
-  if (!isRecord14(input) || !Array.isArray(input.commands)) return [];
+  if (!isRecord17(input) || !Array.isArray(input.commands)) return [];
   return input.commands.flatMap((command, commandIndex) => {
-    if (!isRecord14(command) || typeof command.type !== "string") return [];
+    if (!isRecord17(command) || typeof command.type !== "string") return [];
     if (commandTypeSet.has(command.type)) return [];
     return [{
       code: "unknown_command_type",
@@ -53451,25 +55466,25 @@ function findUnknownCommandTypes(input) {
     }];
   });
 }
-function invalidPayloadError(input, issue2) {
-  const commandIndex = commandIndexForIssuePath(issue2.path);
+function invalidPayloadError(input, issue4) {
+  const commandIndex = commandIndexForIssuePath(issue4.path);
   const commandType = commandTypeForIssue(input, commandIndex);
-  const field = formatIssuePath(issue2.path);
+  const field = formatIssuePath(issue4.path);
   return {
     code: "invalid_command_payload",
     commandIndex,
     commandType,
     field,
-    message: `${field}: ${issue2.message}`
+    message: `${field}: ${issue4.message}`
   };
 }
 function commandIndexForIssuePath(path25) {
   return path25[0] === "commands" && typeof path25[1] === "number" ? path25[1] : -1;
 }
 function commandTypeForIssue(input, commandIndex) {
-  if (!isRecord14(input) || !isUnknownArray3(input.commands)) return null;
+  if (!isRecord17(input) || !isUnknownArray3(input.commands)) return null;
   const command = input.commands[commandIndex];
-  return isRecord14(command) && typeof command.type === "string" ? command.type : null;
+  return isRecord17(command) && typeof command.type === "string" ? command.type : null;
 }
 function isUnknownArray3(value) {
   return Array.isArray(value);
@@ -54136,6 +56151,186 @@ function reportSubjectForCommandRef(subjectsByCommandRef, commandRef) {
 
 // src/cli/site-commands/datedOfferingCommands.ts
 init_src();
+
+// ../api/src/sdk-event-schedule.ts
+var timeRegex = /^([01]\d|2[0-3]):([0-5]\d)(:([0-5]\d))?$/;
+var explicitOffsetDateTimeRegex = /^(\d{4})-(\d{2})-(\d{2})T([01]\d|2[0-3]):([0-5]\d)(?::([0-5]\d))?(\.\d{1,3})?(Z|[+-]([01]\d|2[0-3]):[0-5]\d)$/;
+var localDateTimeRegex = /^(\d{4})-(\d{2})-(\d{2})T([01]\d|2[0-3]):([0-5]\d)(?::([0-5]\d))?(\.\d{1,3})?$/;
+function issue3(path25, message) {
+  return { path: path25, message };
+}
+function isValidDateParts(year, month, day) {
+  const date = new Date(Date.UTC(year, month - 1, day));
+  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+}
+function isZeroFraction(fraction) {
+  return fraction === void 0 || /^\.0+$/.test(fraction);
+}
+function datePart(year, month, day) {
+  return `${year}-${month}-${day}`;
+}
+function timePart(hours, minutes, seconds = "00") {
+  return `${hours}:${minutes}:${seconds}`;
+}
+function parseSdkEventDateTime(value) {
+  const explicitMatch = explicitOffsetDateTimeRegex.exec(value);
+  if (explicitMatch) {
+    const [, yearRaw2, monthRaw2, dayRaw2, hours2, minutes2, seconds2 = "00", fraction2] = explicitMatch;
+    if (!yearRaw2 || !monthRaw2 || !dayRaw2 || !hours2 || !minutes2) return null;
+    const year2 = Number(yearRaw2);
+    const month2 = Number(monthRaw2);
+    const day2 = Number(dayRaw2);
+    if (!isValidDateParts(year2, month2, day2) || !isZeroFraction(fraction2)) return null;
+    const epochMs2 = Date.parse(value);
+    if (!Number.isFinite(epochMs2)) return null;
+    return {
+      epochMs: epochMs2,
+      date: datePart(yearRaw2, monthRaw2, dayRaw2),
+      time: timePart(hours2, minutes2, seconds2),
+      iso: new Date(epochMs2).toISOString()
+    };
+  }
+  const localMatch = localDateTimeRegex.exec(value);
+  if (!localMatch) return null;
+  const [, yearRaw, monthRaw, dayRaw, hours, minutes, seconds = "00", fraction] = localMatch;
+  if (!yearRaw || !monthRaw || !dayRaw || !hours || !minutes) return null;
+  const year = Number(yearRaw);
+  const month = Number(monthRaw);
+  const day = Number(dayRaw);
+  if (!isValidDateParts(year, month, day) || !isZeroFraction(fraction)) return null;
+  const epochMs = Date.UTC(year, month - 1, day, Number(hours), Number(minutes), Number(seconds));
+  return {
+    epochMs,
+    date: datePart(yearRaw, monthRaw, dayRaw),
+    time: timePart(hours, minutes, seconds),
+    iso: new Date(epochMs).toISOString()
+  };
+}
+function durationMinutesBetween(startsAt, endsAt) {
+  if (endsAt.epochMs <= startsAt.epochMs) return null;
+  const durationMs = endsAt.epochMs - startsAt.epochMs;
+  if (durationMs % 6e4 !== 0) return null;
+  return durationMs / 6e4;
+}
+function exceedsMaxDuration(durationMinutes, options) {
+  return options.maxDurationMinutes !== void 0 && durationMinutes > options.maxDurationMinutes;
+}
+function maxDurationMessage(options) {
+  return options.maxDurationDays === void 0 ? "Duration is above the allowed maximum" : `Duration must be ${options.maxDurationDays} days or less`;
+}
+function classifyCanonicalSchedule(input, options) {
+  const issues = [];
+  if (options.requireCanonicalFields && input.recurrenceRule === void 0) {
+    issues.push(issue3(["recurrenceRule"], "recurrenceRule is required"));
+  }
+  if (input.defaultStartTime !== void 0 && input.defaultStartTime !== null && !timeRegex.test(input.defaultStartTime)) {
+    issues.push(issue3(["defaultStartTime"], "Invalid time format (HH:MM or HH:MM:SS)"));
+  }
+  if (options.requireCanonicalFields && !input.defaultStartTime) {
+    issues.push(issue3(["defaultStartTime"], "defaultStartTime is required"));
+  }
+  if (options.requireCanonicalFields && input.durationMinutes === void 0) {
+    issues.push(issue3(["durationMinutes"], "durationMinutes is required"));
+  }
+  if (input.durationMinutes !== void 0 && input.durationMinutes !== null) {
+    if (input.durationMinutes < 1) {
+      issues.push(issue3(["durationMinutes"], "durationMinutes must be at least 1"));
+    } else if (exceedsMaxDuration(input.durationMinutes, options)) {
+      issues.push(issue3(["durationMinutes"], maxDurationMessage(options)));
+    }
+  }
+  if (issues.length > 0) return { ok: false, issues };
+  return {
+    ok: true,
+    kind: "canonical",
+    canonical: {
+      recurrenceRule: input.recurrenceRule ?? null,
+      startDate: input.startDate,
+      defaultStartTime: input.defaultStartTime ?? "09:00:00",
+      durationMinutes: input.durationMinutes ?? 60
+    }
+  };
+}
+function classifySdkEventSchedule(input, options = {}) {
+  const issues = [];
+  const hasStartsAt = input.startsAt !== void 0 && input.startsAt !== null;
+  const hasEndsAt = input.endsAt !== void 0 && input.endsAt !== null;
+  const hasDateTimeDuration = hasStartsAt && input.durationMinutes !== void 0 && input.durationMinutes !== null;
+  const hasCanonicalStart = input.startDate !== void 0 || input.defaultStartTime !== void 0;
+  if (!hasStartsAt && !hasEndsAt) {
+    return classifyCanonicalSchedule(input, options);
+  }
+  if (hasStartsAt && hasCanonicalStart) {
+    issues.push(issue3(["startsAt"], "Use either startsAt or startDate/defaultStartTime, not both"));
+  }
+  if (input.recurrenceRule) {
+    issues.push(issue3(["recurrenceRule"], "startsAt schedules are only supported for one-off events"));
+  }
+  if (!hasStartsAt) {
+    issues.push(issue3(["startsAt"], "startsAt is required when endsAt is provided"));
+  }
+  if (!hasEndsAt && !hasDateTimeDuration) {
+    issues.push(issue3(["endsAt"], "Provide either endsAt or durationMinutes with startsAt"));
+  }
+  if (hasEndsAt && hasDateTimeDuration) {
+    issues.push(issue3(["endsAt"], "Use either endsAt or durationMinutes with startsAt, not both"));
+  }
+  const startsAt = typeof input.startsAt === "string" ? parseSdkEventDateTime(input.startsAt) : null;
+  const endsAt = typeof input.endsAt === "string" ? parseSdkEventDateTime(input.endsAt) : null;
+  if (hasStartsAt && !startsAt) {
+    issues.push(issue3(["startsAt"], "Invalid datetime format. Use ISO datetime format, e.g. 2026-06-01T10:00:00Z"));
+  }
+  if (hasEndsAt && !endsAt) {
+    issues.push(issue3(["endsAt"], "Invalid datetime format. Use ISO datetime format, e.g. 2026-06-07T10:00:00Z"));
+  }
+  if (startsAt && endsAt) {
+    const durationMinutes = durationMinutesBetween(startsAt, endsAt);
+    if (durationMinutes === null) {
+      issues.push(issue3(["endsAt"], "endsAt must be after startsAt and align to a whole minute"));
+    } else if (exceedsMaxDuration(durationMinutes, options)) {
+      issues.push(issue3(["endsAt"], maxDurationMessage(options)));
+    }
+    if (issues.length === 0 && durationMinutes !== null) {
+      return {
+        ok: true,
+        kind: "start-end",
+        canonical: {
+          recurrenceRule: null,
+          startDate: startsAt.date,
+          defaultStartTime: startsAt.time,
+          durationMinutes
+        },
+        startsAtIso: startsAt.iso,
+        endsAtIso: endsAt.iso
+      };
+    }
+  }
+  if (startsAt && hasDateTimeDuration && input.durationMinutes !== void 0 && input.durationMinutes !== null) {
+    if (input.durationMinutes < 1) {
+      issues.push(issue3(["durationMinutes"], "durationMinutes must be at least 1"));
+    } else if (exceedsMaxDuration(input.durationMinutes, options)) {
+      issues.push(issue3(["durationMinutes"], maxDurationMessage(options)));
+    }
+    if (issues.length === 0) {
+      const endsAtMs = startsAt.epochMs + input.durationMinutes * 6e4;
+      return {
+        ok: true,
+        kind: "start-duration",
+        canonical: {
+          recurrenceRule: null,
+          startDate: startsAt.date,
+          defaultStartTime: startsAt.time,
+          durationMinutes: input.durationMinutes
+        },
+        startsAtIso: startsAt.iso,
+        endsAtIso: new Date(endsAtMs).toISOString()
+      };
+    }
+  }
+  return { ok: false, issues };
+}
+
+// src/cli/site-commands/datedOfferingCommands.ts
 var datedOfferingSiteCommandTypes = [
   "upsertVenue",
   "deleteVenue",
@@ -54151,72 +56346,105 @@ function compileDatedOfferingPushCommands(input) {
   for (const venue of input.venues?.items ?? []) {
     const command = venueCommand(venue.item);
     if (!command.ok) return command;
-    commandBindings.push(commandBinding(command.value, {
-      scopeCommand: "venues",
-      scopeName: "venues",
-      itemLabelSingular: "venue",
-      identifier: venue.item.slug,
-      counter: venue.exists ? "updated" : "created"
-    }));
+    commandBindings.push(
+      commandBinding(command.value, {
+        scopeCommand: "venues",
+        scopeName: "venues",
+        itemLabelSingular: "venue",
+        identifier: venue.item.slug,
+        counter: venue.exists ? "updated" : "created"
+      })
+    );
   }
   for (const category of input.eventCategories?.items ?? []) {
-    commandBindings.push(commandBinding(eventCategoryCommand(category.item), {
-      scopeCommand: "event-categories",
-      scopeName: "event categories",
-      itemLabelSingular: "event category",
-      identifier: category.item.identifier,
-      counter: category.exists ? "updated" : "created"
-    }));
+    commandBindings.push(
+      commandBinding(eventCategoryCommand(category.item), {
+        scopeCommand: "event-categories",
+        scopeName: "event categories",
+        itemLabelSingular: "event category",
+        identifier: category.item.identifier,
+        counter: category.exists ? "updated" : "created"
+      })
+    );
   }
   for (const event of input.events?.items ?? []) {
     const command = eventSeriesCommand(event.item);
     if (!command.ok) return command;
-    commandBindings.push(commandBinding(command.value, {
-      scopeCommand: "events",
-      scopeName: "events",
-      itemLabelSingular: "event",
-      identifier: event.item.identifier,
-      counter: event.exists ? "updated" : "created"
-    }));
+    commandBindings.push(
+      commandBinding(command.value, {
+        scopeCommand: "events",
+        scopeName: "events",
+        itemLabelSingular: "event",
+        identifier: event.item.identifier,
+        counter: event.exists ? "updated" : "created"
+      })
+    );
   }
   for (const course of input.courses?.items ?? []) {
     const command = courseCommand(course.item);
     if (!command.ok) return command;
-    commandBindings.push(commandBinding(command.value, {
-      scopeCommand: "courses",
-      scopeName: "courses",
-      itemLabelSingular: "course",
-      identifier: course.item.identifier,
-      counter: course.exists ? "updated" : "created"
-    }));
+    commandBindings.push(
+      commandBinding(command.value, {
+        scopeCommand: "courses",
+        scopeName: "courses",
+        itemLabelSingular: "course",
+        identifier: course.item.identifier,
+        counter: course.exists ? "updated" : "created"
+      })
+    );
   }
   for (const identifier of input.delete?.events ?? []) {
-    commandBindings.push(commandBinding({
-      type: "deleteEventSeries",
-      ref: createCommandRef("delete-event", [identifier]),
-      input: { identifier }
-    }, deleteSubject("events", "events", "event", identifier)));
+    commandBindings.push(
+      commandBinding(
+        {
+          type: "deleteEventSeries",
+          ref: createCommandRef("delete-event", [identifier]),
+          input: { identifier }
+        },
+        deleteSubject("events", "events", "event", identifier)
+      )
+    );
   }
   for (const identifier of input.delete?.courses ?? []) {
-    commandBindings.push(commandBinding({
-      type: "deleteCourse",
-      ref: createCommandRef("delete-course", [identifier]),
-      input: { identifier }
-    }, deleteSubject("courses", "courses", "course", identifier)));
+    commandBindings.push(
+      commandBinding(
+        {
+          type: "deleteCourse",
+          ref: createCommandRef("delete-course", [identifier]),
+          input: { identifier }
+        },
+        deleteSubject("courses", "courses", "course", identifier)
+      )
+    );
   }
   for (const slug of input.delete?.venues ?? []) {
-    commandBindings.push(commandBinding({
-      type: "deleteVenue",
-      ref: createCommandRef("delete-venue", [slug]),
-      input: { slug }
-    }, deleteSubject("venues", "venues", "venue", slug)));
+    commandBindings.push(
+      commandBinding(
+        {
+          type: "deleteVenue",
+          ref: createCommandRef("delete-venue", [slug]),
+          input: { slug }
+        },
+        deleteSubject("venues", "venues", "venue", slug)
+      )
+    );
   }
   for (const identifier of input.delete?.eventCategories ?? []) {
-    commandBindings.push(commandBinding({
-      type: "deleteEventCategory",
-      ref: createCommandRef("delete-event-category", [identifier]),
-      input: { identifier }
-    }, deleteSubject("event-categories", "event categories", "event category", identifier)));
+    commandBindings.push(
+      commandBinding(
+        {
+          type: "deleteEventCategory",
+          ref: createCommandRef("delete-event-category", [identifier]),
+          input: { identifier }
+        },
+        deleteSubject(
+          "event-categories",
+          "event categories",
+          "event category",
+          identifier
+        )
+      )
+    );
   }
   const planned = planCliCommandBatchForBindings({
     ...input,
@@ -54281,10 +56509,16 @@ function deleteSubject(scopeCommand, scopeName, itemLabelSingular, identifier) {
 }
 function venueCommand(venue) {
   if (!venue.timezone) {
-    return unsupported(venue.slug, `Venue ${venue.slug} is missing timezone; command-backed venue pushes require an IANA timezone.`);
+    return unsupported(
+      venue.slug,
+      `Venue ${venue.slug} is missing timezone; command-backed venue pushes require an IANA timezone.`
+    );
   }
   if (venue.location && (typeof venue.location.lat !== "number" || typeof venue.location.lng !== "number")) {
-    return unsupported(venue.slug, `Venue ${venue.slug} has an incomplete location; command-backed venue pushes require both lat and lng.`);
+    return unsupported(
+      venue.slug,
+      `Venue ${venue.slug} has an incomplete location; command-backed venue pushes require both lat and lng.`
+    );
   }
   const location2 = venue.location && typeof venue.location.lat === "number" && typeof venue.location.lng === "number" ? {
     latitude: venue.location.lat,
@@ -54327,10 +56561,16 @@ function eventCategoryCommand(category) {
 }
 function eventSeriesCommand(event) {
   if (event.identifier !== event.slug) {
-    return unsupported(event.identifier, `Event identifier "${event.identifier}" must match slug "${event.slug}".`);
+    return unsupported(
+      event.identifier,
+      `Event identifier "${event.identifier}" must match slug "${event.slug}".`
+    );
   }
   if (event.schedule?.recurrenceRule) {
-    return unsupported(event.identifier, `Event ${event.identifier} uses recurrenceRule; command-backed SDK pushes currently support one-off events only.`);
+    return unsupported(
+      event.identifier,
+      `Event ${event.identifier} uses recurrenceRule; command-backed SDK pushes currently support one-off events only.`
+    );
   }
   const occurrence = eventOccurrence(event);
   if (!occurrence.ok) return occurrence;
@@ -54354,8 +56594,8 @@ function eventSeriesCommand(event) {
       capacity: capacity(event.capacity),
       pricing: pricing.value,
       priceDisplay: event.pricing?.priceDisplay ?? void 0,
-      acceptsPasses: event.pricing?.acceptsPasses,
-      acceptsMemberships: event.pricing?.acceptsMemberships,
+      acceptsPasses: event.pricing?.acceptsPasses ?? void 0,
+      acceptsMemberships: event.pricing?.acceptsMemberships ?? void 0,
       occurrences: [occurrence.value],
       content: event.content ? {
         summary: event.content.summary ?? void 0,
@@ -54370,7 +56610,10 @@ function eventSeriesCommand(event) {
 }
 function courseCommand(course) {
   if (course.identifier !== course.slug) {
-    return unsupported(course.identifier, `Course identifier "${course.identifier}" must match slug "${course.slug}".`);
+    return unsupported(
+      course.identifier,
+      `Course identifier "${course.identifier}" must match slug "${course.slug}".`
+    );
   }
   const pricing = coursePricing(course);
   if (!pricing.ok) return pricing;
@@ -54402,39 +56645,74 @@ function courseCommand(course) {
   });
 }
 function eventOccurrence(event) {
+  const scheduleClassification = classifySdkEventSchedule(event.schedule ?? {});
+  if (!scheduleClassification.ok) {
+    return unsupported(
+      event.identifier,
+      `Event ${event.identifier} has an invalid schedule: ${scheduleClassification.issues.map((validationIssue) => validationIssue.message).join("; ")}`
+    );
+  }
+  if (scheduleClassification.kind === "start-end" || scheduleClassification.kind === "start-duration") {
+    return ok({
+      startAt: scheduleClassification.startsAtIso,
+      endAt: scheduleClassification.endsAtIso
+    });
+  }
   const startDate = event.schedule?.startDate;
   if (!startDate) {
-    return unsupported(event.identifier, `Event ${event.identifier} is missing schedule.startDate; command-backed event pushes require a concrete occurrence.`);
+    return unsupported(
+      event.identifier,
+      `Event ${event.identifier} is missing schedule.startDate; command-backed event pushes require a concrete occurrence.`
+    );
   }
   const startTime = event.schedule?.defaultStartTime ?? "09:00:00";
   const durationMinutes = event.schedule?.durationMinutes ?? 60;
   const startAt = toUtcIso(startDate, startTime);
-  const endAt = new Date(Date.parse(startAt) + durationMinutes * 6e4).toISOString();
+  const endAt = new Date(
+    Date.parse(startAt) + durationMinutes * 6e4
+  ).toISOString();
   return ok({
     startAt,
     endAt
   });
 }
 function eventPricing(event) {
-  const pricing = event.pricing;
-  if (!pricing?.requiresPayment) return ok({ kind: "free" });
-  const amount = pricing.priceAmount;
-  if (typeof amount !== "number" || amount < 0) {
-    return unsupported(event.identifier, `Event ${event.identifier} requires payment but has no valid priceAmount.`);
+  const pricing = classifySdkEventPricing(event.pricing);
+  if (!pricing.ok) {
+    return unsupported(
+      event.identifier,
+      `Event ${event.identifier} has invalid pricing: ${pricing.issues[0]?.message ?? "invalid pricing"}.`
+    );
+  }
+  switch (pricing.pricing.kind) {
+    case "free":
+      return ok({ kind: "free" });
+    case "fixed_price":
+      return ok({
+        kind: "fixed_price",
+        price: {
+          amountCents: pricing.pricing.priceAmount,
+          currency: pricing.pricing.priceCurrency
+        }
+      });
+    case "ticket_types":
+      return unsupported(
+        event.identifier,
+        `Event ${event.identifier} uses ticket-type pricing; command-backed event pushes do not support ticket types yet.`
+      );
+    default:
+      return assertNever(pricing.pricing);
   }
-  return ok({
-    kind: "fixed_price",
-    price: {
-      amountCents: amount,
-      currency: pricing.priceCurrency
-    }
-  });
 }
 function coursePricing(course) {
   const amount = course.priceCents;
-  if (amount === void 0 || amount === null || amount === 0) return ok({ kind: "free" });
+  if (amount === void 0 || amount === null || amount === 0)
+    return ok({ kind: "free" });
   if (amount < 0) {
-    return unsupported(course.identifier, `Course ${course.identifier} has invalid priceCents.`);
+    return unsupported(
+      course.identifier,
+      `Course ${course.identifier} has invalid priceCents.`
+    );
   }
   return ok({
     kind: "fixed_price",
@@ -54468,7 +56746,8 @@ function venueUpsertInput(command) {
 }
 function eventSeriesUpsertInput(command) {
   const occurrence = command.input.occurrences[0];
-  if (!occurrence) throw new Error(`Event command ${command.ref} has no occurrence.`);
+  if (!occurrence)
+    throw new Error(`Event command ${command.ref} has no occurrence.`);
   return {
     identifier: command.input.slug,
     title: command.input.title,
@@ -54491,8 +56770,8 @@ function eventContentInput(content) {
   if (!content) return void 0;
   return {
     ...content.summary ? { summary: content.summary } : {},
-    ...typeof content.body === "string" || isRecord15(content.body) ? { body: content.body } : {},
-    ...typeof content.image === "string" || isRecord15(content.image) ? { image: content.image } : {}
+    ...typeof content.body === "string" || isRecord18(content.body) ? { body: content.body } : {},
+    ...typeof content.image === "string" || isRecord18(content.image) ? { image: content.image } : {}
   };
 }
 function courseUpsertInput(command) {
@@ -54524,34 +56803,29 @@ function eventPricingInput(input) {
   switch (input.pricing.kind) {
     case "free":
       return {
-        requiresPayment: false,
-        priceAmount: null,
-        priceCurrency: null,
+        kind: "free",
         priceDisplay: input.priceDisplay ?? null,
         acceptsPasses: input.acceptsPasses ?? false,
         acceptsMemberships: input.acceptsMemberships ?? false
       };
     case "fixed_price":
       return {
-        requiresPayment: input.pricing.price.amountCents > 0,
+        kind: "fixed_price",
         priceAmount: input.pricing.price.amountCents,
-        priceCurrency: input.pricing.price.currency ?? null,
+        priceCurrency: input.pricing.price.currency ?? "USD",
         priceDisplay: input.priceDisplay ?? null,
         acceptsPasses: input.acceptsPasses ?? false,
         acceptsMemberships: input.acceptsMemberships ?? false
       };
     case "ticket_types":
-      return {
-        requiresPayment: false,
-        priceAmount: null,
-        priceCurrency: input.pricing.currency ?? null,
-        priceDisplay: input.priceDisplay ?? null,
-        acceptsPasses: input.acceptsPasses ?? false,
-        acceptsMemberships: input.acceptsMemberships ?? false
-      };
+      throw new Error(
+        "Unsupported ticket-type event command reached SDK mapper."
+      );
     case "manual_payment":
     case "external":
-      throw new Error(`Unsupported event pricing mode reached SDK mapper: ${input.pricing.kind}`);
+      throw new Error(
+        `Unsupported event pricing mode reached SDK mapper: ${input.pricing.kind}`
+      );
     default:
       return assertNever(input.pricing);
   }
@@ -54567,7 +56841,9 @@ function coursePricingInput(pricing) {
       };
     case "manual_payment":
     case "external":
-      throw new Error(`Unsupported course pricing mode reached SDK mapper: ${pricing.kind}`);
+      throw new Error(
+        `Unsupported course pricing mode reached SDK mapper: ${pricing.kind}`
+      );
     default:
       return assertNever(pricing);
   }
@@ -54657,14 +56933,16 @@ function scheduleFromOccurrence(occurrence) {
     recurrenceRule: null,
     startDate: occurrence.startAt.slice(0, 10),
     defaultStartTime: occurrence.startAt.slice(11, 19),
-    durationMinutes: Math.round((Date.parse(occurrence.endAt) - Date.parse(occurrence.startAt)) / 6e4)
+    durationMinutes: Math.round(
+      (Date.parse(occurrence.endAt) - Date.parse(occurrence.startAt)) / 6e4
+    )
   };
 }
 function toUtcIso(date, time) {
   const normalizedTime = time.length === 5 ? `${time}:00` : time;
   return (/* @__PURE__ */ new Date(`${date}T${normalizedTime}Z`)).toISOString();
 }
-function isRecord15(value) {
+function isRecord18(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function unsupported(identifier, message) {
@@ -54777,7 +57055,8 @@ async function executeEntryCommandPlan(input) {
             contentType: command.input.contentTypeKey,
             data: command.input.data ?? {},
             slug: command.input.slug,
-            manualOrder: command.input.manualOrder
+            manualOrder: command.input.manualOrder,
+            blocks: command.input.blocks
           });
           return;
         }
@@ -54902,7 +57181,8 @@ function entryCommandsForDiff(input) {
         ...localEntry.slug ? { slug: localEntry.slug } : {},
         ...typeof localEntry.manualOrder === "number" ? { manualOrder: localEntry.manualOrder } : {},
         ...optionalTitle(localEntry.data),
-        data: localEntry.data
+        data: localEntry.data,
+        ...localEntry.blocks ? { blocks: localEntry.blocks } : {}
       }
     };
     commandBindings.push({
@@ -55504,15 +57784,15 @@ function validateBlockContent(data, manifest, customFields) {
     validator.parse(data);
   } catch (error) {
     if (error instanceof ZodError) {
-      for (const issue2 of error.issues) {
-        const fieldPath = issue2.path.join(".");
-        if (issue2.code === "invalid_type" && issue2.received === "undefined") {
+      for (const issue4 of error.issues) {
+        const fieldPath = issue4.path.join(".");
+        if (issue4.code === "invalid_type" && issue4.received === "undefined") {
           continue;
         }
         warnings.push({
           type: "invalid_content",
           field: fieldPath || "(root)",
-          message: `Invalid content${fieldPath ? ` in "${fieldPath}"` : ""}: ${issue2.message}`
+          message: `Invalid content${fieldPath ? ` in "${fieldPath}"` : ""}: ${issue4.message}`
         });
       }
     }
@@ -56948,7 +59228,7 @@ async function handleThemePushForAllScope(params) {
   }
   const validation = themeSchema2.safeParse(localTheme.theme);
   if (!validation.success) {
-    const errors = validation.error.issues.map((issue2) => `  - ${issue2.path.join(".")}: ${issue2.message}`).join("\n");
+    const errors = validation.error.issues.map((issue4) => `  - ${issue4.path.join(".")}: ${issue4.message}`).join("\n");
     output.warn(
       `Skipping theme push - invalid theme at content/themes/${themeName}.json:
 ${errors}`
@@ -57557,9 +59837,14 @@ function entriesEqual(left, right) {
 function contentFields(entry) {
   const data = structuredClone(entry.data);
   stripEnvSpecificMediaFieldsInPlace(data);
+  const blocks = entry.blocks ? structuredClone(entry.blocks) : void 0;
+  if (blocks) {
+    stripEnvSpecificMediaFieldsInPlace(blocks);
+  }
   return {
     identifier: entry.identifier,
     data: sortRecord(data),
+    ...blocks ? { blocks: sortRecord(blocks) } : {},
     ...entry.slug !== void 0 ? { slug: entry.slug } : {}
   };
 }
@@ -58429,7 +60714,7 @@ ${available.map((t) => `  - ${t.name} (content/themes/${t.name}.json)`).join("\n
       }
       const validation = themeSchema.safeParse(localTheme.theme);
       if (!validation.success) {
-        const errors = validation.error.issues.map((issue2) => `  - ${issue2.path.join(".")}: ${issue2.message}`).join("\n");
+        const errors = validation.error.issues.map((issue4) => `  - ${issue4.path.join(".")}: ${issue4.message}`).join("\n");
         output.error(
           `Invalid theme file at content/themes/${themeName}.json:
 ${errors}`
@@ -59588,7 +61873,8 @@ async function applyOneOffEntryCommand(command, client) {
         identifier: entryIdentifierForCommand(command),
         contentType: command.input.contentTypeKey,
         data: command.input.data ?? {},
-        slug: command.input.slug
+        slug: command.input.slug,
+        blocks: command.input.blocks
       });
     case "publishContentEntry":
       await client.entries.publish(
@@ -60721,7 +63007,7 @@ var THEME_FIELD_CATEGORY_MAP = {
 };
 
 // src/cli/init-docs/zod-to-markdown.ts
-function isRecord16(value) {
+function isRecord19(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isZodTypeAny(value) {
@@ -60849,7 +63135,7 @@ function extractLiteralValue(schema) {
   const typeName = getTypeName(schema);
   if (typeName !== ZodTypeName.ZodLiteral) return void 0;
   const def = schema._def;
-  if (!isRecord16(def)) return void 0;
+  if (!isRecord19(def)) return void 0;
   return String(def.value);
 }
 function extractSchemaInfo(schema, skipFields = []) {
@@ -60919,7 +63205,7 @@ function extractFieldInfo(name, schema) {
   }
   if (typeName === ZodTypeName.ZodRecord) {
     const def = inner._def;
-    const valueSchema = isRecord16(def) ? def.valueType : void 0;
+    const valueSchema = isRecord19(def) ? def.valueType : void 0;
     if (!isZodTypeAny(valueSchema)) {
       info.recordValueType = "unknown";
       return info;
@@ -60934,7 +63220,7 @@ function extractFieldInfo(name, schema) {
       }
     } else if (getTypeName(valueInner) === ZodTypeName.ZodRecord) {
       const nestedDef = valueInner._def;
-      const nestedValueSchema = isRecord16(nestedDef) ? nestedDef.valueType : void 0;
+      const nestedValueSchema = isRecord19(nestedDef) ? nestedDef.valueType : void 0;
       if (!isZodTypeAny(nestedValueSchema)) {
         info.recordValueType = "record<string, unknown>";
         return info;
@@ -60945,7 +63231,7 @@ function extractFieldInfo(name, schema) {
   }
   if (typeName === ZodTypeName.ZodUnion || typeName === ZodTypeName.ZodDiscriminatedUnion) {
     const def = inner._def;
-    const optionsValue = isRecord16(def) ? def.options : void 0;
+    const optionsValue = isRecord19(def) ? def.options : void 0;
     const options = Array.isArray(optionsValue) ? optionsValue.filter(isZodTypeAny) : [];
     const optionTypes = options.map((opt) => {
       const { inner: optInner } = unwrapSchema(opt);
@@ -61781,7 +64067,8 @@ async function initDocs(options) {
     { filename: "cmsify-page.md", template: "workflow-cmsify-page" },
     { filename: "editor-workflows.md", template: "workflow-editor-workflows" },
     { filename: "preview-mode.md", template: "workflow-preview-mode" },
-    { filename: "isr-revalidation.md", template: "workflow-isr-revalidation" }
+    { filename: "isr-revalidation.md", template: "workflow-isr-revalidation" },
+    { filename: "agent-safe-sync.md", template: "workflow-agent-safe-sync" }
   ];
   await Promise.all(
     coreWorkflows.map(
@@ -62109,7 +64396,7 @@ var SimpleCache = class {
 };
 
 // src/version.ts
-var SDK_VERSION = "0.82.0";
+var SDK_VERSION = "0.84.1";
 
 // src/client/error.ts
 var RiverbankApiError = class _RiverbankApiError extends Error {
@@ -64201,9 +66488,9 @@ Examples:
     const parseResult = verifyConfigSchema.safeParse(rawConfig);
     if (!parseResult.success) {
       return output.error("Invalid config format", {
-        issues: parseResult.error.issues.map((issue2) => ({
-          path: issue2.path.join("."),
-          message: issue2.message
+        issues: parseResult.error.issues.map((issue4) => ({
+          path: issue4.path.join("."),
+          message: issue4.message
         })),
         suggestion: "Ensure your config exports a valid riverbank config object"
       });
@@ -64731,8 +67018,8 @@ async function executeAuditForEnv(output, target, options, isJsonOutput) {
         client
       });
       const mediaIssues = mapMediaGuardDiagnosticsToAuditIssues(mediaGuardResult.diagnostics);
-      errors.push(...mediaIssues.filter((issue2) => issue2.severity === "error"));
-      warnings.push(...mediaIssues.filter((issue2) => issue2.severity === "warning"));
+      errors.push(...mediaIssues.filter((issue4) => issue4.severity === "error"));
+      warnings.push(...mediaIssues.filter((issue4) => issue4.severity === "warning"));
     }
     if (!isJsonOutput) {
       output.info("Checking for duplicate page paths...");
@@ -64756,8 +67043,8 @@ async function executeAuditForEnv(output, target, options, isJsonOutput) {
     }
     errors.push(...auditEventReferences(localContent.events, auditCtx));
     const courseRefIssues = auditCourseReferences(localContent.courses, auditCtx);
-    errors.push(...courseRefIssues.filter((issue2) => issue2.severity === "error"));
-    warnings.push(...courseRefIssues.filter((issue2) => issue2.severity === "warning"));
+    errors.push(...courseRefIssues.filter((issue4) => issue4.severity === "error"));
+    warnings.push(...courseRefIssues.filter((issue4) => issue4.severity === "warning"));
     const success = errors.length === 0;
     const result = { success, errors, warnings };
     if (isJsonOutput) {
@@ -64772,14 +67059,14 @@ async function executeAuditForEnv(output, target, options, isJsonOutput) {
       output.info("");
       if (errors.length > 0) {
         output.warn(`Found ${errors.length} error(s):`);
-        for (const issue2 of errors) {
-          output.info(`  [ERROR] ${issue2.message}`);
+        for (const issue4 of errors) {
+          output.info(`  [ERROR] ${issue4.message}`);
         }
       }
       if (warnings.length > 0) {
         output.warn(`Found ${warnings.length} warning(s):`);
-        for (const issue2 of warnings) {
-          output.info(`  [WARN] ${issue2.message}`);
+        for (const issue4 of warnings) {
+          output.info(`  [WARN] ${issue4.message}`);
         }
       }
       if (success && warnings.length === 0) {
@@ -68629,27 +70916,76 @@ var envStatusCommand = new Command("status").description("Show which environment
   })
 );
 var envCommand = new Command("env").description("Environment configuration and status").addCommand(envStatusCommand);
+var eventScheduleInputSchema = z.object({
+  recurrenceRule: z.string().nullable().optional(),
+  startDate: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).nullable().optional(),
+  defaultStartTime: z.string().min(1).optional(),
+  durationMinutes: z.number().int().positive().optional(),
+  startsAt: z.string().min(1).optional(),
+  endsAt: z.string().min(1).optional()
+}).superRefine((schedule, ctx) => {
+  const result = classifySdkEventSchedule(schedule, {
+    requireCanonicalFields: true
+  });
+  if (!result.ok) {
+    result.issues.forEach((validationIssue) => {
+      ctx.addIssue({
+        code: "custom",
+        path: [...validationIssue.path],
+        message: validationIssue.message
+      });
+    });
+  }
+}).transform((schedule) => {
+  const result = classifySdkEventSchedule(schedule, {
+    requireCanonicalFields: true
+  });
+  if (!result.ok) {
+    throw new Error("Unreachable invalid event schedule after Zod validation");
+  }
+  if (result.kind === "start-end") {
+    const { startsAt, endsAt } = schedule;
+    if (typeof startsAt !== "string" || typeof endsAt !== "string") {
+      throw new Error("Unreachable invalid start/end event schedule after Zod validation");
+    }
+    return { startsAt, endsAt };
+  }
+  if (result.kind === "start-duration") {
+    const { startsAt, durationMinutes } = schedule;
+    if (typeof startsAt !== "string" || typeof durationMinutes !== "number") {
+      throw new Error("Unreachable invalid start/duration event schedule after Zod validation");
+    }
+    return { startsAt, durationMinutes };
+  }
+  return result.canonical;
+});
+var eventPricingInputSchema = z.unknown().superRefine((pricing, ctx) => {
+  const result = classifySdkEventPricing(pricing);
+  if (!result.ok) {
+    result.issues.forEach((validationIssue) => {
+      ctx.addIssue({
+        code: "custom",
+        path: [...validationIssue.path],
+        message: validationIssue.message
+      });
+    });
+  }
+}).transform((pricing) => {
+  const result = classifySdkEventPricing(pricing);
+  if (!result.ok) {
+    throw new Error("Unreachable invalid event pricing after Zod validation");
+  }
+  return result.pricing;
+});
 var eventUpsertInputSchema = z.object({
   identifier: z.string().min(1).optional(),
   title: z.string().min(1, "title is required"),
   slug: z.string().min(1).optional(),
   status: z.enum(["draft", "active", "archived", "cancelled", "completed"]).optional(),
   visibility: z.enum(["private", "public", "unlisted"]).optional(),
-  schedule: z.object({
-    recurrenceRule: z.string().nullable(),
-    startDate: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).nullable().optional(),
-    defaultStartTime: z.string().min(1),
-    durationMinutes: z.number().int().positive()
-  }),
+  schedule: eventScheduleInputSchema,
   capacity: z.number().int().positive().nullable().optional(),
-  pricing: z.object({
-    requiresPayment: z.boolean().optional(),
-    priceAmount: z.number().nullable().optional(),
-    priceCurrency: z.string().nullable().optional(),
-    priceDisplay: z.string().nullable().optional(),
-    acceptsPasses: z.boolean().optional(),
-    acceptsMemberships: z.boolean().optional()
-  }).optional(),
+  pricing: eventPricingInputSchema.optional(),
   venueRef: z.string().nullable().optional(),
   categoryRef: z.string().nullable().optional(),
   content: z.record(z.string(), z.unknown()).optional(),
@@ -68683,7 +71019,13 @@ function toEventUpsertInput(identifier, raw) {
   return payload;
 }
 function buildCancelledEventUpsertInput(current) {
-  const { id: _id, createdAt: _createdAt, updatedAt: _updatedAt, contentUpdatedAt: _contentUpdatedAt, ...rest } = current;
+  const {
+    id: _id,
+    createdAt: _createdAt,
+    updatedAt: _updatedAt,
+    contentUpdatedAt: _contentUpdatedAt,
+    ...rest
+  } = current;
   return {
     ...rest,
     status: "cancelled"
@@ -68693,23 +71035,25 @@ function canCancelEventStatus(status) {
   return status === "draft" || status === "active";
 }
 var upsertCommand5 = new Command("upsert").description("Create or update an event series").argument("<identifier>", "Event identifier").option("--data <json>", "Event payload as JSON string").option("--file <path>", "Path to JSON file with event payload").action(
-  withErrorHandling(async (identifier, options, command) => {
-    const { output, client } = createCommandContext(command);
-    const raw = await parseJsonData(options);
-    if (raw.status === "completed") {
-      output.warn(
-        `Event ${identifier}: status "completed" is read-only; omitting status on upsert.`
-      );
+  withErrorHandling(
+    async (identifier, options, command) => {
+      const { output, client } = createCommandContext(command);
+      const raw = await parseJsonData(options);
+      if (raw.status === "completed") {
+        output.warn(
+          `Event ${identifier}: status "completed" is read-only; omitting status on upsert.`
+        );
+      }
+      const input = toEventUpsertInput(identifier, raw);
+      output.info(`Upserting event: ${identifier}`);
+      const event = await client.events.upsert(input);
+      output.success(`Event upserted: ${event.identifier}`, {
+        id: event.id,
+        status: event.status,
+        visibility: event.visibility
+      });
     }
-    const input = toEventUpsertInput(identifier, raw);
-    output.info(`Upserting event: ${identifier}`);
-    const event = await client.events.upsert(input);
-    output.success(`Event upserted: ${event.identifier}`, {
-      id: event.id,
-      status: event.status,
-      visibility: event.visibility
-    });
-  })
+  )
 );
 var getCommand5 = createGetCommand({
   resourceName: "event",
@@ -68753,31 +71097,35 @@ var deleteCommand3 = new Command("delete").description("Delete an event series")
   )
 );
 var cancelCommand = new Command("cancel").description("Cancel an event series").argument("<identifier>", "Event identifier").action(
-  withErrorHandling(async (identifier, _options, command) => {
-    const { output, client } = createCommandContext(command);
-    const current = await client.events.get(identifier);
-    if (!current) {
-      return output.error(`Event not found: ${identifier}`);
-    }
-    if (current.status === "cancelled") {
-      output.success(`Event already cancelled: ${identifier}`);
-      return;
-    }
-    if (!canCancelEventStatus(current.status)) {
-      return output.error(
-        `Event ${identifier} cannot be cancelled from status "${current.status}".`
-      );
-    }
-    try {
-      await client.events.upsert(buildCancelledEventUpsertInput(current));
-      output.success(`Event cancelled: ${identifier}`);
-    } catch (error) {
-      if (error instanceof ManagementApiError && error.statusCode === 404) {
-        return output.error(`Event ${identifier} was removed before cancellation. Pull and retry.`);
+  withErrorHandling(
+    async (identifier, _options, command) => {
+      const { output, client } = createCommandContext(command);
+      const current = await client.events.get(identifier);
+      if (!current) {
+        return output.error(`Event not found: ${identifier}`);
+      }
+      if (current.status === "cancelled") {
+        output.success(`Event already cancelled: ${identifier}`);
+        return;
+      }
+      if (!canCancelEventStatus(current.status)) {
+        return output.error(
+          `Event ${identifier} cannot be cancelled from status "${current.status}".`
+        );
+      }
+      try {
+        await client.events.upsert(buildCancelledEventUpsertInput(current));
+        output.success(`Event cancelled: ${identifier}`);
+      } catch (error) {
+        if (error instanceof ManagementApiError && error.statusCode === 404) {
+          return output.error(
+            `Event ${identifier} was removed before cancellation. Pull and retry.`
+          );
+        }
+        throw error;
       }
-      throw error;
     }
-  })
+  )
 );
 var eventCommand = new Command("event").description("Manage events").addHelpText(
   "after",