@riverbankcms/sdk 0.84.2 → 0.88.0

package/dist/cli/index.mjs

@@ -2,7 +2,7 @@
 import z42, { z, ZodError } from 'zod';
 import 'react/jsx-runtime';
 import { createJiti } from 'jiti';
-import * as fs10 from 'fs';
+import * as fs11 from 'fs';
 import { existsSync, readFileSync } from 'fs';
 import * as path5 from 'path';
 import { dirname, resolve, isAbsolute } from 'path';
@@ -109,6 +109,57 @@ var init_collections = __esm({
   }
 });
 
+// ../core/src/assert-never.ts
+function assertNever(value, message = "Unexpected variant") {
+  throw new Error(`${message}: ${String(value)}`);
+}
+var init_assert_never = __esm({
+  "../core/src/assert-never.ts"() {
+  }
+});
+
+// ../core/src/currency-format.ts
+function resolveCurrencyLocale(currencyCode, override) {
+  return CURRENCY_LOCALE_BY_CODE[currencyCode] ?? "en";
+}
+function formatCurrencyAmount(amountCents, currency, options) {
+  const currencyCode = currency.toUpperCase();
+  const locale = resolveCurrencyLocale(currencyCode);
+  try {
+    const exactFormatter = new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency: currencyCode
+    });
+    const fractionDigits = options?.decimals === "auto" ? {
+      minimumFractionDigits: 0,
+      maximumFractionDigits: exactFormatter.resolvedOptions().maximumFractionDigits
+    } : {};
+    return new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency: currencyCode,
+      ...fractionDigits
+    }).format(amountCents / 100);
+  } catch {
+    return `${(amountCents / 100).toFixed(2)} ${currencyCode}`;
+  }
+}
+var CURRENCY_LOCALE_BY_CODE;
+var init_currency_format = __esm({
+  "../core/src/currency-format.ts"() {
+    CURRENCY_LOCALE_BY_CODE = {
+      USD: "en-US",
+      GBP: "en-GB",
+      EUR: "de-DE",
+      AUD: "en-AU",
+      CAD: "en-CA",
+      NZD: "en-NZ",
+      JPY: "ja-JP",
+      CNY: "zh-CN",
+      CHF: "de-CH"
+    };
+  }
+});
+
 // ../core/src/event-pricing.ts
 function publicEventPricingType(pricing) {
   switch (pricing.kind) {
@@ -129,6 +180,7 @@ function isFreePublicEventPriceDisplay(display) {
       return display.display.kind === "free";
     case "exact":
     case "from":
+    case "range":
     case "mixed":
     case "unavailable":
       return false;
@@ -343,15 +395,6 @@ var init_business_address = __esm({
   }
 });
 
-// ../core/src/assert-never.ts
-function assertNever(value, message = "Unexpected variant") {
-  throw new Error(`${message}: ${String(value)}`);
-}
-var init_assert_never = __esm({
-  "../core/src/assert-never.ts"() {
-  }
-});
-
 // ../core/src/narrow-result.ts
 var init_narrow_result = __esm({
   "../core/src/narrow-result.ts"() {
@@ -454,12 +497,6 @@ var init_csv_types = __esm({
   }
 });
 
-// ../core/src/currency-format.ts
-var init_currency_format = __esm({
-  "../core/src/currency-format.ts"() {
-  }
-});
-
 // ../core/src/email-format.ts
 var init_email_format = __esm({
   "../core/src/email-format.ts"() {
@@ -12490,8 +12527,8 @@ var init_generatedDesignPipeline = __esm({
   }
 });
 function validateBlockSequence(snapshots, ctx) {
-  for (const issue4 of collectBlockSequenceIssues(snapshots)) {
-    ctx.addIssue(issue4);
+  for (const issue5 of collectBlockSequenceIssues(snapshots)) {
+    ctx.addIssue(issue5);
   }
 }
 function collectBlockSequenceIssues(snapshots) {
@@ -13344,11 +13381,11 @@ function bind(from, options) {
     }
   });
 }
-function when(path25, options) {
+function when(path27, options) {
   return (node) => ({
     ...node,
     $when: {
-      when: { from: path25 },
+      when: { from: path27 },
       ...options?.equals !== void 0 ? { equals: options.equals } : {},
       ...options?.not ? { not: true } : {}
     }
@@ -13455,7 +13492,7 @@ var init_builder2 = __esm({
 });
 
 // ../blocks/src/system/node/fragments/backgroundLayer.ts
-function backgroundLayer(path25, options = {}) {
+function backgroundLayer(path27, options = {}) {
   const {
     styleClassName = "background-style rb-absolute rb-inset-0 rb-z-neg-10 rb-h-full rb-w-full rb-pointer-events-none",
     imageClassName,
@@ -13469,7 +13506,7 @@ function backgroundLayer(path25, options = {}) {
     className: styleClassName,
     style: {
       $bind: {
-        from: path25,
+        from: path27,
         transforms: [
           {
             id: "background.resolveStyle",
@@ -13479,20 +13516,20 @@ function backgroundLayer(path25, options = {}) {
       }
     }
   });
-  const imageLayer = createBackgroundImageNode(path25, imageClassName, {
+  const imageLayer = createBackgroundImageNode(path27, imageClassName, {
     loading: imageLoading,
     fetchPriority: imageFetchPriority
   });
-  const overlayLayer = createBackgroundOverlayNode(path25, overlayClassName);
+  const overlayLayer = createBackgroundOverlayNode(path27, overlayClassName);
   return omitImageLayer ? [styleLayer, overlayLayer] : [styleLayer, imageLayer, overlayLayer];
 }
-function createBackgroundImageNode(path25, baseClassName = "rb-absolute rb-z-neg-10", options = {}) {
-  const imagePath = `${path25}.image`;
+function createBackgroundImageNode(path27, baseClassName = "rb-absolute rb-z-neg-10", options = {}) {
+  const imagePath = `${path27}.image`;
   return media(
     {
       className: {
         $bind: {
-          from: path25,
+          from: path27,
           transforms: [
             {
               id: "background.resolveImageClassName",
@@ -13503,7 +13540,7 @@ function createBackgroundImageNode(path25, baseClassName = "rb-absolute rb-z-neg
       },
       style: {
         $bind: {
-          from: path25,
+          from: path27,
           transforms: [{ id: "background.resolveImageStyle" }]
         }
       },
@@ -13515,8 +13552,8 @@ function createBackgroundImageNode(path25, baseClassName = "rb-absolute rb-z-neg
     bind(imagePath)
   );
 }
-function createBackgroundOverlayNode(path25, className = "background-overlay rb-absolute rb-inset-0 rb-z-neg-10 rb-h-full rb-w-full rb-pointer-events-none") {
-  const overlayPath = `${path25}.overlay`;
+function createBackgroundOverlayNode(path27, className = "background-overlay rb-absolute rb-inset-0 rb-z-neg-10 rb-h-full rb-w-full rb-pointer-events-none") {
+  const overlayPath = `${path27}.overlay`;
   return el("div", {
     className,
     style: {
@@ -14356,10 +14393,10 @@ var init_sectionForegroundStyles = __esm({
 });
 
 // ../blocks/src/system/transforms/registry/boxStyles.ts
-function readPath(source, path25) {
-  if (!source || !path25) return void 0;
-  if (!path25.includes(".")) return source[path25];
-  return path25.split(".").reduce((acc, segment) => {
+function readPath(source, path27) {
+  if (!source || !path27) return void 0;
+  if (!path27.includes(".")) return source[path27];
+  return path27.split(".").reduce((acc, segment) => {
     if (acc && typeof acc === "object" && segment in acc) {
       return acc[segment];
     }
@@ -15351,27 +15388,27 @@ function scopePropValue(value, scope) {
   }
   return value;
 }
-function scopeContentPath(path25, scope) {
+function scopeContentPath(path27, scope) {
   if (!scope || scope.length === 0) {
-    return path25;
+    return path27;
   }
-  if (path25 === "content") {
+  if (path27 === "content") {
     return `content.${scope}`;
   }
-  if (path25.startsWith("content.")) {
-    const remainder = path25.slice("content.".length);
+  if (path27.startsWith("content.")) {
+    const remainder = path27.slice("content.".length);
     return remainder.length > 0 ? `content.${scope}.${remainder}` : `content.${scope}`;
   }
-  if (path25.startsWith("content[")) {
-    return path25.replace(/^content/, `content.${scope}`);
+  if (path27.startsWith("content[")) {
+    return path27.replace(/^content/, `content.${scope}`);
   }
-  if (path25.startsWith("$root.")) {
-    return path25;
+  if (path27.startsWith("$root.")) {
+    return path27;
   }
-  if (path25.includes(".")) {
-    return path25;
+  if (path27.includes(".")) {
+    return path27;
   }
-  return `content.${scope}.${path25}`;
+  return `content.${scope}.${path27}`;
 }
 var FRAGMENT_ID_PATTERN, FIELD_ID_PATTERN, dataLoaderSchema, fragmentDataSchema, fragmentConfigSchema, FragmentConfigError;
 var init_types14 = __esm({
@@ -17955,15 +17992,53 @@ var init_newsletterForm = __esm({
       title: "Newsletter Form",
       description: "Newsletter subscription form with preset field configurations.",
       fields: [
+        {
+          id: "destinationProvider",
+          type: "select",
+          label: "Send signups to",
+          description: "Choose where new subscribers from this form should go.",
+          defaultValue: "riverbank",
+          required: true,
+          ui: { intent: "behavior" },
+          options: [
+            { value: "riverbank", label: "Riverbank newsletter" }
+          ]
+        },
         {
           id: "listId",
           type: "reference",
           label: "Newsletter list",
           description: "Select the list new subscribers should be added to.",
-          required: true,
+          required: false,
           referenceKind: "newsletterList",
           allowManualEntry: false,
-          ui: { intent: "behavior" }
+          ui: {
+            intent: "behavior",
+            visibleWhen: { field: "destinationProvider", equals: "riverbank" }
+          }
+        },
+        {
+          id: "mailchimpAudienceId",
+          type: "reference",
+          label: "Mailchimp audience",
+          description: "Choose the Mailchimp audience for new subscribers.",
+          required: false,
+          referenceKind: "mailchimpAudience",
+          allowManualEntry: false,
+          ui: {
+            intent: "behavior",
+            visibleWhen: { field: "destinationProvider", equals: "mailchimp" }
+          }
+        },
+        {
+          id: "mailchimpTags",
+          type: "text",
+          label: "Mailchimp tags",
+          description: "Optional tags to apply in Mailchimp, separated by commas or semicolons.",
+          ui: {
+            intent: "behavior",
+            visibleWhen: { field: "destinationProvider", equals: "mailchimp" }
+          }
         },
         {
           id: "preset",
@@ -18010,13 +18085,18 @@ var init_newsletterForm = __esm({
           id: "tags",
           type: "text",
           label: "Tags (optional)",
-          description: "Optional tags to apply on subscribe (comma or semicolon separated)."
+          description: "Optional tags to apply on subscribe (comma or semicolon separated).",
+          ui: {
+            intent: "behavior",
+            visibleWhen: { field: "destinationProvider", equals: "riverbank" }
+          }
         }
       ],
       layout: [
         el(
           "newsletter-form",
           withApiBindings({
+            destinationProvider: { $bind: { from: "destinationProvider" } },
             listId: { $bind: { from: "listId" } },
             preset: { $bind: { from: "preset" } },
             includePhone: { $bind: { from: "includePhone" } },
@@ -18247,8 +18327,8 @@ function decodeSuccess(value) {
 function decodeFailure(issues) {
   return { ok: false, issues };
 }
-function zodIssuePath(path25) {
-  return path25.flatMap((segment) => {
+function zodIssuePath(path27) {
+  return path27.flatMap((segment) => {
     if (typeof segment === "string" || typeof segment === "number") {
       return [segment];
     }
@@ -18267,9 +18347,9 @@ function createZodCodec(schema) {
         return decodeSuccess(parsed.data);
       }
       return decodeFailure(
-        parsed.error.issues.map((issue4) => ({
-          path: zodIssuePath(issue4.path),
-          message: issue4.message
+        parsed.error.issues.map((issue5) => ({
+          path: zodIssuePath(issue5.path),
+          message: issue5.message
         }))
       );
     }
@@ -18522,6 +18602,83 @@ var init_media2 = __esm({
     ]);
   }
 });
+function createHardBreakNode() {
+  return { type: "hardBreak" };
+}
+function parseRichTextInlineMarkdown(text2) {
+  const out = [];
+  const pushText = (value, marks) => {
+    if (!value) return;
+    out.push(
+      marks && marks.length > 0 ? { type: "text", text: value, marks } : { type: "text", text: value }
+    );
+  };
+  let rest = text2;
+  while (rest.length > 0) {
+    const start = rest.indexOf("**");
+    if (start === -1) {
+      pushText(rest);
+      break;
+    }
+    const end = rest.indexOf("**", start + 2);
+    if (end === -1) {
+      pushText(rest);
+      break;
+    }
+    pushText(rest.slice(0, start));
+    pushText(rest.slice(start + 2, end), [{ type: "bold" }]);
+    rest = rest.slice(end + 2);
+  }
+  return out;
+}
+function parseRichTextParagraphInlineMarkdown(text2) {
+  return text2.split("\n").flatMap((line, index) => {
+    const lineNodes = parseRichTextInlineMarkdown(line.trim());
+    return index === 0 ? lineNodes : [createHardBreakNode(), ...lineNodes];
+  });
+}
+function createRichTextDocFromMarkdown(markdown) {
+  const normalized = markdown.replace(/\r\n/g, "\n").trim();
+  if (!normalized) return { type: "doc", content: [] };
+  const paragraphs = normalized.split(/\n{2,}/).map((paragraph) => paragraph.trim()).filter(Boolean);
+  return {
+    type: "doc",
+    content: paragraphs.map((paragraph) => {
+      const inline2 = parseRichTextParagraphInlineMarkdown(paragraph);
+      return inline2.length > 0 ? { type: "paragraph", content: inline2 } : { type: "paragraph" };
+    })
+  };
+}
+var TipTapMarkSchema, TipTapNodeSchema, RichTextDocSchema;
+var init_richTextSchema = __esm({
+  "../blocks/src/system/manifest/richTextSchema.ts"() {
+    TipTapMarkSchema = z.object({
+      type: z.string(),
+      attrs: z.record(z.string(), z.unknown()).optional()
+    });
+    TipTapNodeSchema = z.lazy(
+      () => z.object({
+        type: z.string(),
+        content: z.array(TipTapNodeSchema).optional(),
+        text: z.string().optional(),
+        attrs: z.record(z.string(), z.unknown()).optional(),
+        marks: z.array(TipTapMarkSchema).optional()
+      })
+    );
+    z.union([
+      // Canonical: TipTap document directly
+      TipTapNodeSchema,
+      // Legacy (read-tolerance only): wrapped in { doc: {...} }
+      z.object({
+        doc: TipTapNodeSchema
+      })
+    ]);
+    RichTextDocSchema = z.object({
+      type: z.literal("doc"),
+      content: z.array(TipTapNodeSchema)
+    });
+  }
+});
 var bookingDepositRefundPolicySchema, bookingInstalmentPlanSchema, bookingFlexibleBalanceDueDateRuleSchema, bookingFlexibleBalanceConfigSchema, blockBookingPaymentCollectionOptionSchema, blockBookingPaymentTermsSchema;
 var init_bookingPaymentTerms = __esm({
   "../blocks/src/system/blocks/shared/bookingPaymentTerms.ts"() {
@@ -18660,6 +18817,7 @@ var eventPresetSchema, eventScheduleScopeSchema, eventDestinationModeSchema, eve
 var init_schemas2 = __esm({
   "../blocks/src/system/blocks/events/shared/schemas.ts"() {
     init_media2();
+    init_richTextSchema();
     init_bookingPaymentTerms();
     init_schemas();
     eventPresetSchema = z.enum(["event", "class", "workshop", "retreat", "performance"]);
@@ -18692,7 +18850,13 @@ var init_schemas2 = __esm({
       z.object({ kind: z.literal("free"), currency: z.string() }),
       z.object({ kind: z.literal("exact"), amount: z.number(), currency: z.string() }),
       z.object({ kind: z.literal("from"), amount: z.number(), currency: z.string() }),
-      z.object({ kind: z.literal("mixed"), paidFromAmount: z.number(), currency: z.string() }),
+      z.object({ kind: z.literal("range"), minAmount: z.number(), maxAmount: z.number(), currency: z.string() }),
+      z.object({
+        kind: z.literal("mixed"),
+        paidFromAmount: z.number(),
+        paidToAmount: z.number(),
+        currency: z.string()
+      }),
       z.object({ kind: z.literal("unavailable"), currency: z.string() }),
       z.object({ kind: z.literal("course"), display: publicCoursePriceDisplaySchema })
     ]);
@@ -18700,7 +18864,13 @@ var init_schemas2 = __esm({
       z.object({ kind: z.literal("free"), currency: z.string() }),
       z.object({ kind: z.literal("exact"), amount: z.number(), currency: z.string() }),
       z.object({ kind: z.literal("from"), amount: z.number(), currency: z.string() }),
-      z.object({ kind: z.literal("mixed"), paidFromAmount: z.number(), currency: z.string() }),
+      z.object({ kind: z.literal("range"), minAmount: z.number(), maxAmount: z.number(), currency: z.string() }),
+      z.object({
+        kind: z.literal("mixed"),
+        paidFromAmount: z.number(),
+        paidToAmount: z.number(),
+        currency: z.string()
+      }),
       z.object({ kind: z.literal("unavailable"), currency: z.string() })
     ]);
     publicEventAttendanceModeSchema = z.enum(["in_person", "online"]);
@@ -18785,6 +18955,9 @@ var init_schemas2 = __esm({
       seriesId: z.string(),
       title: z.string(),
       description: z.string().nullable(),
+      content: z.object({
+        body: RichTextDocSchema.nullable().optional()
+      }).optional(),
       presentation: z.object({
         cardTitleOverride: z.string().nullable().optional(),
         summary: z.string().nullable().optional(),
@@ -19167,10 +19340,21 @@ function readLegacyPriceDisplay(value, currency) {
         amount: readAmount(value.amount) ?? 0,
         currency: displayCurrency
       } : { kind: "unavailable", currency };
+    case "range": {
+      const minAmount = readAmount(value.minAmount);
+      const maxAmount = readAmount(value.maxAmount);
+      return minAmount !== null && maxAmount !== null ? {
+        kind: "range",
+        minAmount,
+        maxAmount,
+        currency: displayCurrency
+      } : { kind: "unavailable", currency };
+    }
     case "mixed":
       return readAmount(value.paidFromAmount) !== null ? {
         kind: "mixed",
         paidFromAmount: readAmount(value.paidFromAmount) ?? 0,
+        paidToAmount: readAmount(value.paidToAmount) ?? readAmount(value.paidFromAmount) ?? 0,
         currency: displayCurrency
       } : { kind: "unavailable", currency };
     case "unavailable":
@@ -19425,6 +19609,7 @@ var init_event_registration_interactive = __esm({
       successMessage: z.string().optional(),
       waitlistMessage: z.string().optional(),
       buttonVariant: registrationButtonVariantSchema.optional(),
+      overlayEnabled: z.boolean().optional(),
       spamProtectionEnabled: z.boolean().optional(),
       stage: previewStageSchema.optional(),
       supportEmail: z.string().optional()
@@ -19448,6 +19633,7 @@ var init_event_registration_interactive = __esm({
       successMessage: z.string().optional(),
       waitlistMessage: z.string().optional(),
       buttonVariant: registrationButtonVariantSchema.optional(),
+      overlayEnabled: z.boolean().optional(),
       spamProtectionEnabled: z.boolean().optional(),
       supportEmail: z.string().optional()
     });
@@ -19480,6 +19666,7 @@ var init_event_registration_interactive = __esm({
           successMessage: source.successMessage,
           waitlistMessage: source.waitlistMessage,
           buttonVariant: source.buttonVariant,
+          overlayEnabled: source.overlayEnabled,
           spamProtectionEnabled: source.spamProtectionEnabled,
           supportEmail: source.supportEmail
         }
@@ -20503,10 +20690,7 @@ var init_shop_commerce_shared = __esm({
 
 // ../blocks/src/system/runtime/nodes/commerce/shared/display.ts
 function formatCommercePrice(cents, currency) {
-  return new Intl.NumberFormat("en-US", {
-    style: "currency",
-    currency: currency.toUpperCase()
-  }).format(cents / 100);
+  return formatCurrencyAmount(cents, currency);
 }
 function getPassesHeading(passes, explicitHeading) {
   if (explicitHeading) return explicitHeading;
@@ -20700,6 +20884,7 @@ function formatValidity(days) {
 }
 var init_display = __esm({
   "../blocks/src/system/runtime/nodes/commerce/shared/display.ts"() {
+    init_src();
     init_creditProducts();
     init_shop_commerce_shared();
   }
@@ -21162,6 +21347,65 @@ var init_gifting_interactive = __esm({
   }
 });
 
+// ../blocks/src/system/blocks/newsletter-signup-destination.ts
+function parseNewsletterSignupBlockId(value) {
+  const trimmed = parseTrimmedString(value);
+  return trimmed && BLOCK_ID_PATTERN.test(trimmed) ? trimmed : null;
+}
+function parseSignedNewsletterDestinationRef(value) {
+  const trimmed = parseTrimmedString(value);
+  return trimmed && SIGNED_DESTINATION_REF_PATTERN.test(trimmed) ? trimmed : null;
+}
+function parseNewsletterSignupDestinationProvider(value) {
+  return value === "riverbank" || value === "mailchimp" ? value : null;
+}
+function buildNewsletterSignupBlockRef(blockId) {
+  const parsed = parseNewsletterSignupBlockId(blockId);
+  return parsed ? { tag: "block_ref", blockId: parsed } : null;
+}
+function normalizeNewsletterSignupEditorValuesForDestination(values) {
+  const destinationProvider = parseNewsletterSignupDestinationProvider(values.destinationProvider) ?? "riverbank";
+  if (destinationProvider === "mailchimp") {
+    return {
+      destinationProvider,
+      mailchimpAudienceId: values.mailchimpAudienceId,
+      mailchimpTags: values.mailchimpTags
+    };
+  }
+  return {
+    destinationProvider,
+    listId: values.listId,
+    tags: values.tags
+  };
+}
+function deriveNewsletterSignupRuntimeSource(values) {
+  const normalized = normalizeNewsletterSignupEditorValuesForDestination(values);
+  if (normalized.destinationProvider === "mailchimp") {
+    return {
+      destinationProvider: "mailchimp",
+      listId: null,
+      tags: null
+    };
+  }
+  return {
+    destinationProvider: "riverbank",
+    listId: parseTrimmedString(normalized.listId),
+    tags: parseTrimmedString(normalized.tags)
+  };
+}
+function parseTrimmedString(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+var BLOCK_ID_PATTERN, SIGNED_DESTINATION_REF_PATTERN;
+var init_newsletter_signup_destination = __esm({
+  "../blocks/src/system/blocks/newsletter-signup-destination.ts"() {
+    BLOCK_ID_PATTERN = /^[A-Za-z0-9._:-]{1,200}$/;
+    SIGNED_DESTINATION_REF_PATTERN = /^[A-Za-z0-9._~-]{16,1000}$/;
+  }
+});
+
 // ../blocks/src/system/runtime/nodes/newsletter-form.types.ts
 function getPresetFields(preset2, options) {
   const includePhone = Boolean(options?.includePhone);
@@ -21227,13 +21471,29 @@ function buildNewsletterDisplay(source) {
     fields: getPresetFields(preset2, { includePhone })
   };
 }
-var newsletterPresetSchema, newsletterFieldSchema, newsletterSourceSchema, newsletterDisplaySchema, newsletterHydrationSchema, newsletterRenderSchema, newsletterFormBlockRuntime;
+function parseRequiredNewsletterSignupBlockId(value) {
+  const parsed = parseNewsletterSignupBlockId(value);
+  if (!parsed) {
+    throw new Error("Newsletter signup block destination ref requires blockId");
+  }
+  return parsed;
+}
+function parseRequiredSignedNewsletterDestinationRef(value) {
+  const parsed = parseSignedNewsletterDestinationRef(value);
+  if (!parsed) {
+    throw new Error("Newsletter signup signed destination ref requires token");
+  }
+  return parsed;
+}
+var newsletterPresetSchema, newsletterDestinationProviderSchema, newsletterFieldSchema, newsletterSignupBlockIdSchema, signedNewsletterDestinationRefSchema, newsletterPublicDestinationRefSchema, newsletterSourceSchema, newsletterDisplaySchema, newsletterHydrationSchema, newsletterRenderSchema, newsletterFormBlockRuntime;
 var init_newsletter_form_interactive = __esm({
   "../blocks/src/system/runtime/nodes/newsletter-form.interactive.ts"() {
     init_islands();
     init_runtime();
+    init_newsletter_signup_destination();
     init_newsletter_form_types();
     newsletterPresetSchema = z.enum(["emailOnly", "emailName", "emailFirstLast", "emailNameCompany"]);
+    newsletterDestinationProviderSchema = z.enum(["riverbank", "mailchimp"]);
     newsletterFieldSchema = z.object({
       id: z.string(),
       type: z.enum(["email", "text"]),
@@ -21241,10 +21501,24 @@ var init_newsletter_form_interactive = __esm({
       required: z.boolean(),
       placeholder: z.string().optional()
     });
+    newsletterSignupBlockIdSchema = z.string().trim().min(1).transform(parseRequiredNewsletterSignupBlockId);
+    signedNewsletterDestinationRefSchema = z.string().trim().min(1).transform(parseRequiredSignedNewsletterDestinationRef);
+    newsletterPublicDestinationRefSchema = z.discriminatedUnion("tag", [
+      z.object({
+        tag: z.literal("block_ref"),
+        blockId: newsletterSignupBlockIdSchema
+      }),
+      z.object({
+        tag: z.literal("signed_destination_ref"),
+        token: signedNewsletterDestinationRefSchema
+      })
+    ]);
     newsletterSourceSchema = z.object({
+      blockId: z.string().nullable().optional(),
       siteId: z.string().optional(),
       apiBaseUrl: z.string().optional(),
       listId: z.string().nullable().optional(),
+      destinationProvider: newsletterDestinationProviderSchema.nullable().optional(),
       preset: newsletterPresetSchema.optional(),
       includePhone: z.boolean().optional(),
       buttonLabel: z.string().nullable().optional(),
@@ -21263,6 +21537,7 @@ var init_newsletter_form_interactive = __esm({
       fields: z.array(newsletterFieldSchema)
     });
     newsletterHydrationSchema = z.object({
+      destinationRef: newsletterPublicDestinationRefSchema.nullable().optional(),
       listId: z.string().nullable().optional(),
       preset: newsletterPresetSchema,
       includePhone: z.boolean(),
@@ -21283,16 +21558,20 @@ var init_newsletter_form_interactive = __esm({
         source: createZodCodec(newsletterSourceSchema),
         render: createZodCodec(newsletterRenderSchema)
       },
-      buildRender: (source) => ({
-        display: buildNewsletterDisplay(source),
-        hydration: {
-          listId: source.listId,
-          preset: source.preset ?? "emailOnly",
-          includePhone: source.includePhone ?? false,
-          tags: source.tags ?? null,
-          spamProtectionEnabled: source.spamProtectionEnabled
-        }
-      })
+      buildRender: (source) => {
+        const runtimeSource = deriveNewsletterSignupRuntimeSource(source);
+        return {
+          display: buildNewsletterDisplay(source),
+          hydration: {
+            destinationRef: buildNewsletterSignupBlockRef(source.blockId),
+            listId: runtimeSource.listId,
+            preset: source.preset ?? "emailOnly",
+            includePhone: source.includePhone ?? false,
+            tags: runtimeSource.tags,
+            spamProtectionEnabled: source.spamProtectionEnabled
+          }
+        };
+      }
     });
   }
 });
@@ -22309,6 +22588,64 @@ var ENDPOINT_DEFINITIONS = {
     auth: "user",
     responseKind: "json"
   },
+  listMailchimpAudiences: {
+    path: "/sites/{siteId}/integrations/mailchimp/audiences",
+    method: "GET",
+    tags: [TAG_TEMPLATES.site],
+    auth: "user",
+    responseKind: "json",
+    errors: ["auth:forbidden", "server:internal_error"]
+  },
+  getMailchimpSignupSyncHealth: {
+    path: "/sites/{siteId}/integrations/mailchimp/signup-sync-health",
+    method: "GET",
+    tags: [TAG_TEMPLATES.site],
+    auth: "user",
+    responseKind: "json",
+    errors: ["auth:forbidden", "server:internal_error"]
+  },
+  getMailchimpConnection: {
+    path: "/sites/{siteId}/integrations/mailchimp/connection",
+    method: "GET",
+    tags: [TAG_TEMPLATES.site],
+    auth: "user",
+    responseKind: "json",
+    errors: ["auth:forbidden", "server:internal_error"]
+  },
+  startMailchimpOAuth: {
+    path: "/sites/{siteId}/integrations/mailchimp/oauth/start",
+    method: "POST",
+    tags: [TAG_TEMPLATES.site],
+    auth: "user",
+    responseKind: "json",
+    demoMutation: DEMO_MUTATION_BLOCKED_DISABLED,
+    errors: ["auth:forbidden", "validation:invalid_input", "server:internal_error"]
+  },
+  refreshMailchimpAudiences: {
+    path: "/sites/{siteId}/integrations/mailchimp/audiences/refresh",
+    method: "POST",
+    tags: [TAG_TEMPLATES.site],
+    auth: "user",
+    responseKind: "json",
+    demoMutation: DEMO_MUTATION_BLOCKED_DISABLED,
+    errors: ["auth:forbidden", "server:internal_error"]
+  },
+  disconnectMailchimp: {
+    path: "/sites/{siteId}/integrations/mailchimp/disconnect",
+    method: "POST",
+    tags: [TAG_TEMPLATES.site],
+    auth: "user",
+    responseKind: "json",
+    demoMutation: DEMO_MUTATION_BLOCKED_DISABLED,
+    errors: ["auth:forbidden", "server:internal_error"]
+  },
+  mailchimpOAuthCallback: {
+    path: "/auth/mailchimp/callback",
+    method: "GET",
+    auth: "public",
+    responseKind: "void",
+    errors: []
+  },
   createNewsletterList: {
     path: "/sites/{siteId}/newsletter/lists",
     method: "POST",
@@ -24533,20 +24870,6 @@ var ENDPOINT_DEFINITIONS = {
     auth: "user",
     responseKind: "json"
   },
-  instagramUploadZip: {
-    path: "/instagram/upload-zip",
-    method: "POST",
-    tags: ["instagram-import"],
-    auth: "user",
-    responseKind: "json"
-  },
-  createInstagramZipUploadUrl: {
-    path: "/instagram/upload-zip-url",
-    method: "POST",
-    tags: ["instagram-import"],
-    auth: "user",
-    responseKind: "json"
-  },
   getAnalyticsReport: {
     path: "/sites/{siteId}/analytics/report",
     method: "GET",
@@ -28589,20 +28912,20 @@ function validationContext(options = {}) {
     allowIncomplete: isDraft || (options.allowIncomplete ?? false)
   };
 }
-function formatFieldPath(path25) {
-  return path25.map((segment) => String(segment)).join(".");
+function formatFieldPath(path27) {
+  return path27.map((segment) => String(segment)).join(".");
 }
-function toZodIssuePath(path25) {
-  return [...path25];
+function toZodIssuePath(path27) {
+  return [...path27];
 }
-function fieldIssueToMessage(issue4) {
-  switch (issue4.kind) {
+function fieldIssueToMessage(issue5) {
+  switch (issue5.kind) {
     case "required":
       return "This field is required";
     case "wrongType":
-      return `${issue4.label} needs ${issue4.expected}`;
+      return `${issue5.label} needs ${issue5.expected}`;
     case "tooLong":
-      return `Use ${issue4.maximum} characters or fewer`;
+      return `Use ${issue5.maximum} characters or fewer`;
     case "invalidEmail":
       return "Enter a valid email address";
     case "invalidPhone":
@@ -28618,36 +28941,36 @@ function fieldIssueToMessage(issue4) {
     case "invalidDateTime":
       return "Choose a valid date and time";
     case "invalidNumber":
-      return `${issue4.label} needs a number`;
+      return `${issue5.label} needs a number`;
     case "tooSmall":
-      return `${issue4.label} must be ${issue4.minimum} or more`;
+      return `${issue5.label} must be ${issue5.minimum} or more`;
     case "tooLarge":
-      return `${issue4.label} must be ${issue4.maximum} or less`;
+      return `${issue5.label} must be ${issue5.maximum} or less`;
     case "invalidSlug":
-      return `${issue4.label} can only use lowercase letters, numbers, and dashes`;
+      return `${issue5.label} can only use lowercase letters, numbers, and dashes`;
     case "invalidOption":
-      return `Choose one of the available options for ${issue4.label}`;
+      return `Choose one of the available options for ${issue5.label}`;
     case "tooFewItems":
-      return `${issue4.label} must have at least ${issue4.minimum} ${pluralize(issue4.itemLabel, issue4.minimum)}`;
+      return `${issue5.label} must have at least ${issue5.minimum} ${pluralize(issue5.itemLabel, issue5.minimum)}`;
     case "tooManyItems":
-      return `${issue4.label} must have at most ${issue4.maximum} ${pluralize(issue4.itemLabel, issue4.maximum)}`;
+      return `${issue5.label} must have at most ${issue5.maximum} ${pluralize(issue5.itemLabel, issue5.maximum)}`;
     case "invalidRichText":
-      return `${issue4.label} must be valid rich text`;
+      return `${issue5.label} must be valid rich text`;
     case "invalidMedia":
-      return `${issue4.label} must be a valid media item`;
+      return `${issue5.label} must be a valid media item`;
     case "invalidLink":
-      return `${issue4.label} must be a valid link`;
+      return `${issue5.label} must be a valid link`;
     case "invalidReference":
-      return `${issue4.label} must reference a valid item`;
+      return `${issue5.label} must reference a valid item`;
     default:
-      return assertNever2(issue4);
+      return assertNever2(issue5);
   }
 }
 function pluralize(label, count) {
   if (count === 1) return label;
   return label.endsWith("s") ? label : `${label}s`;
 }
-function deriveFieldValidationPlan(field, path25 = [field.id]) {
+function deriveFieldValidationPlan(field, path27 = [field.id]) {
   const required = Boolean(field.required);
   switch (field.type) {
     case "text": {
@@ -28658,7 +28981,7 @@ function deriveFieldValidationPlan(field, path25 = [field.id]) {
         });
         if (typeof field.ui?.min === "number") constraints2.push({ kind: "numberMin", minimum: field.ui.min });
         if (typeof field.ui?.max === "number") constraints2.push({ kind: "numberMax", maximum: field.ui.max });
-        return makePlan("number", "number", field, path25, required, constraints2);
+        return makePlan("number", "number", field, path27, required, constraints2);
       }
       const constraints = commonConstraints(required, {
         kind: field.ui?.widget === "iconPicker" ? "blockIconValue" : "textType"
@@ -28667,7 +28990,7 @@ function deriveFieldValidationPlan(field, path25 = [field.id]) {
       if (inputType === "tel") constraints.push({ kind: "phoneFormat" });
       if (field.ui?.pattern) constraints.push({ kind: "patternFormat", pattern: field.ui.pattern });
       if (typeof field.maxLength === "number") constraints.push({ kind: "maxLength", maximum: field.maxLength });
-      return makePlan("string", "string", field, path25, required, constraints);
+      return makePlan("string", "string", field, path27, required, constraints);
     }
     case "number": {
       const constraints = commonConstraints(required, {
@@ -28675,34 +28998,34 @@ function deriveFieldValidationPlan(field, path25 = [field.id]) {
       });
       if (typeof field.min === "number") constraints.push({ kind: "numberMin", minimum: field.min });
       if (typeof field.max === "number") constraints.push({ kind: "numberMax", maximum: field.max });
-      return makePlan("number", "number", field, path25, required, constraints);
+      return makePlan("number", "number", field, path27, required, constraints);
     }
     case "slug": {
       const constraints = commonConstraints(required, { kind: "textType" }, { kind: "slugFormat" });
       if (typeof field.maxLength === "number") constraints.push({ kind: "maxLength", maximum: field.maxLength });
-      return makePlan("string", "string", field, path25, required, constraints);
+      return makePlan("string", "string", field, path27, required, constraints);
     }
     case "url":
       return makePlan(
         "string",
         "string",
         field,
-        path25,
+        path27,
         required,
         commonConstraints(required, { kind: "textType" }, { kind: "urlFormat", allowRelative: Boolean(field.allowRelative) })
       );
     case "reference":
-      return makePlan("string", "string", field, path25, required, commonConstraints(required, { kind: "referenceText" }));
+      return makePlan("string", "string", field, path27, required, commonConstraints(required, { kind: "referenceText" }));
     case "date":
-      return makePlan("string", "string", field, path25, required, commonConstraints(required, { kind: "textType" }, { kind: "dateFormat" }));
+      return makePlan("string", "string", field, path27, required, commonConstraints(required, { kind: "textType" }, { kind: "dateFormat" }));
     case "time":
-      return makePlan("string", "string", field, path25, required, commonConstraints(required, { kind: "textType" }, { kind: "timeFormat" }));
+      return makePlan("string", "string", field, path27, required, commonConstraints(required, { kind: "textType" }, { kind: "timeFormat" }));
     case "datetime":
       return makePlan(
         "string",
         "string",
         field,
-        path25,
+        path27,
         required,
         commonConstraints(required, { kind: "textType" }, { kind: "datetimeFormat" })
       );
@@ -28711,7 +29034,7 @@ function deriveFieldValidationPlan(field, path25 = [field.id]) {
         "select",
         "select",
         field,
-        path25,
+        path27,
         required,
         commonConstraints(required, {
           kind: "selectOption",
@@ -28720,40 +29043,40 @@ function deriveFieldValidationPlan(field, path25 = [field.id]) {
         })
       );
     case "richText":
-      return makePlan("richText", "object", field, path25, required, commonConstraints(required, { kind: "richTextDoc" }));
+      return makePlan("richText", "object", field, path27, required, commonConstraints(required, { kind: "richTextDoc" }));
     case "media":
     case "file":
-      return makePlan("media", "object", field, path25, required, commonConstraints(required, { kind: "mediaObject" }));
+      return makePlan("media", "object", field, path27, required, commonConstraints(required, { kind: "mediaObject" }));
     case "link":
-      return makePlan("link", "object", field, path25, required, commonConstraints(required, { kind: "linkObject" }));
+      return makePlan("link", "object", field, path27, required, commonConstraints(required, { kind: "linkObject" }));
     case "boolean":
-      return makePlan("boolean", "boolean", field, path25, required, requiredConstraints(required));
+      return makePlan("boolean", "boolean", field, path27, required, requiredConstraints(required));
     case "repeater":
       return {
-        ...makePlan("repeater", "array", field, path25, required, commonConstraints(required, { kind: "arrayType" })),
+        ...makePlan("repeater", "array", field, path27, required, commonConstraints(required, { kind: "arrayType" })),
         ...field.polymorphic && field.itemTypes ? {
-          repeatedItemVariants: deriveRepeatedItemVariants(field, [...path25, 0])
+          repeatedItemVariants: deriveRepeatedItemVariants(field, [...path27, 0])
         } : {
-          repeatedItemPlan: deriveNestedFieldPlans(getRepeaterFields(field), [...path25, 0])
+          repeatedItemPlan: deriveNestedFieldPlans(getRepeaterFields(field), [...path27, 0])
         },
         constraints: withRepeaterItemConstraints(field, commonConstraints(required, { kind: "arrayType" }))
       };
     case "group":
     case "modal":
       return {
-        ...makePlan("group", "object", field, path25, required, requiredConstraints(required)),
-        children: deriveNestedFieldPlans(field.schema?.fields ?? [], path25),
+        ...makePlan("group", "object", field, path27, required, requiredConstraints(required)),
+        children: deriveNestedFieldPlans(field.schema?.fields ?? [], path27),
         allowNullChildren: field.type === "group" && field.ui?.widget === "locationPicker"
       };
     case "tabGroup":
       return {
-        ...makePlan("group", "object", field, path25, required, requiredConstraints(required)),
-        children: field.tabs.flatMap((tab) => deriveNestedFieldPlans(tab.fields, path25))
+        ...makePlan("group", "object", field, path27, required, requiredConstraints(required)),
+        children: field.tabs.flatMap((tab) => deriveNestedFieldPlans(tab.fields, path27))
       };
     case "presetOrCustom":
     case "contentTypeSelect":
     case "entryPicker":
-      return makePlan("passthrough", "unknown", field, path25, false, []);
+      return makePlan("passthrough", "unknown", field, path27, false, []);
     default:
       return assertNever2(field);
   }
@@ -28767,14 +29090,14 @@ function commonConstraints(required, ...specific) {
 function requiredConstraints(required) {
   return required ? [{ kind: "required" }] : [];
 }
-function makePlan(kind, valueKind2, field, path25, required, constraints) {
+function makePlan(kind, valueKind2, field, path27, required, constraints) {
   return {
     kind,
     valueKind: valueKind2,
     fieldId: field.id,
     label: field.label,
     fieldType: field.type,
-    path: path25,
+    path: path27,
     required,
     visibility: fieldVisibility(field),
     constraints
@@ -29111,18 +29434,18 @@ function materializeRepeaterItemPlan(plan, parentPath, index) {
   return rebaseFieldPlanPath(plan, [...parentPath, 0], [...parentPath, index]);
 }
 function rebaseFieldPlanPath(plan, fromPrefix, toPrefix) {
-  const path25 = rebaseFieldPath(plan.path, fromPrefix, toPrefix);
+  const path27 = rebaseFieldPath(plan.path, fromPrefix, toPrefix);
   switch (plan.kind) {
     case "group":
       return {
         ...plan,
-        path: path25,
+        path: path27,
         children: plan.children.map((childPlan) => rebaseFieldPlanPath(childPlan, fromPrefix, toPrefix))
       };
     case "repeater":
       return {
         ...plan,
-        path: path25,
+        path: path27,
         ...plan.repeatedItemVariants ? {
           repeatedItemVariants: plan.repeatedItemVariants.map((variant) => ({
             ...variant,
@@ -29143,20 +29466,20 @@ function rebaseFieldPlanPath(plan, fromPrefix, toPrefix) {
     case "passthrough":
       return {
         ...plan,
-        path: path25
+        path: path27
       };
     default:
       return assertNever2(plan);
   }
 }
-function rebaseFieldPath(path25, fromPrefix, toPrefix) {
-  if (!startsWithFieldPath(path25, fromPrefix)) {
-    throw new Error(`Cannot rebase field path ${formatFieldPath(path25)} from ${formatFieldPath(fromPrefix)}`);
+function rebaseFieldPath(path27, fromPrefix, toPrefix) {
+  if (!startsWithFieldPath(path27, fromPrefix)) {
+    throw new Error(`Cannot rebase field path ${formatFieldPath(path27)} from ${formatFieldPath(fromPrefix)}`);
   }
-  return [...toPrefix, ...path25.slice(fromPrefix.length)];
+  return [...toPrefix, ...path27.slice(fromPrefix.length)];
 }
-function startsWithFieldPath(path25, prefix) {
-  return prefix.every((segment, index) => path25[index] === segment);
+function startsWithFieldPath(path27, prefix) {
+  return prefix.every((segment, index) => path27[index] === segment);
 }
 function issue(plan, kind, extra) {
   return {
@@ -29182,8 +29505,8 @@ function fieldPlanToZod(plan, options = {}) {
 }
 function addFieldIssueToZodContext(zodCtx, validationIssue, rootPath) {
   const message = fieldIssueToMessage(validationIssue);
-  const path25 = relativeZodIssuePath(validationIssue.path, rootPath);
-  const issuePath = path25.length > 0 ? { path: toZodIssuePath(path25) } : {};
+  const path27 = relativeZodIssuePath(validationIssue.path, rootPath);
+  const issuePath = path27.length > 0 ? { path: toZodIssuePath(path27) } : {};
   switch (validationIssue.kind) {
     case "required":
       if (validationIssue.emptyOrigin) {
@@ -29236,8 +29559,8 @@ function addFieldIssueToZodContext(zodCtx, validationIssue, rootPath) {
       assertNever2(validationIssue);
   }
 }
-function relativeZodIssuePath(path25, rootPath) {
-  return startsWithFieldPath(path25, rootPath) ? path25.slice(rootPath.length) : path25;
+function relativeZodIssuePath(path27, rootPath) {
+  return startsWithFieldPath(path27, rootPath) ? path27.slice(rootPath.length) : path27;
 }
 function compilePattern(pattern) {
   try {
@@ -32395,9 +32718,9 @@ function maybeBuildSupabaseTransformUrl(inputUrl, options) {
   const remainder = url.pathname.slice(idx + marker.length);
   const parts = remainder.split("/").filter(Boolean);
   const bucket = parts[0];
-  const path25 = parts.slice(1).join("/");
-  if (!bucket || !path25) return inputUrl;
-  url.pathname = `/storage/v1/render/image/public/${bucket}/${path25}`;
+  const path27 = parts.slice(1).join("/");
+  if (!bucket || !path27) return inputUrl;
+  url.pathname = `/storage/v1/render/image/public/${bucket}/${path27}`;
   url.search = "";
   if (width) url.searchParams.set("width", String(width));
   if (height) url.searchParams.set("height", String(height));
@@ -35102,6 +35425,12 @@ var eventRegistrationManifest = createBlockManifest({
               buttonVariant: {
                 $bind: { from: "content.buttonVariant", fallback: "primary" }
               },
+              overlayEnabled: {
+                $bind: {
+                  from: "$root.eventRegistrationOverlayEnabled",
+                  fallback: false
+                }
+              },
               // Event data from loader
               events: { $bind: { from: "data.events" } },
               // Stage for preview mode (allows registering for draft events)
@@ -41872,6 +42201,7 @@ var SUPPORTED_LOADER_ENDPOINTS = [
 ];
 
 // ../blocks/src/index.ts
+init_richTextSchema();
 init_booking_form_reserved_fields();
 init_colorStyles();
 
@@ -43007,11 +43337,11 @@ siteBannerSettingsSchema.superRefine((value, ctx) => {
     return;
   }
   const analysis = analyzeSiteBannerBody(value.body);
-  for (const issue4 of analysis.issues) {
+  for (const issue5 of analysis.issues) {
     ctx.addIssue({
       code: z.ZodIssueCode.custom,
       path: ["body"],
-      message: siteBannerBodyIssueMessage(issue4)
+      message: siteBannerBodyIssueMessage(issue5)
     });
   }
 });
@@ -43045,8 +43375,8 @@ function analyzeSiteBannerBody(body) {
     issues
   };
 }
-function siteBannerBodyIssueMessage(issue4) {
-  switch (issue4) {
+function siteBannerBodyIssueMessage(issue5) {
+  switch (issue5) {
     case "empty":
       return "Banner message is required when the banner is enabled.";
     case "too-many-paragraphs":
@@ -43554,8 +43884,8 @@ var TEMPLATE_BINDING_META_PATHS = [
   "createdAt",
   "updatedAt"
 ];
-function describeInvalidTemplateBindingMetaPath(path25) {
-  return `Meta path "${path25}" is not valid. Allowed: ${TEMPLATE_BINDING_META_PATHS.join(", ")}`;
+function describeInvalidTemplateBindingMetaPath(path27) {
+  return `Meta path "${path27}" is not valid. Allowed: ${TEMPLATE_BINDING_META_PATHS.join(", ")}`;
 }
 
 // ../content-model/src/routeTemplate.ts
@@ -43729,7 +44059,7 @@ var fieldBindingSchema = z.object({
 var metaBindingSchema = z.object({
   source: z.literal("meta"),
   path: z.enum(TEMPLATE_BINDING_META_PATHS, {
-    error: (issue4) => describeInvalidTemplateBindingMetaPath(String(issue4.input))
+    error: (issue5) => describeInvalidTemplateBindingMetaPath(String(issue5.input))
   })
 });
 var literalBindingSchema = z.object({
@@ -43740,7 +44070,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: (issue4) => describeInvalidBindingTransform(String(issue4.input))
+    error: (issue5) => describeInvalidBindingTransform(String(issue5.input))
   })
 });
 var baseBindingSchema = z.discriminatedUnion("source", [
@@ -43944,7 +44274,7 @@ var contentConfigSchema = contentConfigBaseSchema.superRefine((data, ctx) => {
       });
     }
     const paths = data.pages.map((p) => p.path);
-    const duplicatePaths = paths.filter((path25, i) => paths.indexOf(path25) !== i);
+    const duplicatePaths = paths.filter((path27, i) => paths.indexOf(path27) !== i);
     if (duplicatePaths.length > 0) {
       ctx.addIssue({
         code: z.ZodIssueCode.custom,
@@ -44001,18 +44331,18 @@ function validateLayoutNodeTypes(layout) {
     errors
   };
 }
-function validateNodeTypesRecursive(node, path25, errors) {
+function validateNodeTypesRecursive(node, path27, errors) {
   if (!ALLOWED_NODE_TYPES_SET.has(node.type)) {
     errors.push({
-      path: `${path25}.type`,
+      path: `${path27}.type`,
       type: "invalid_node_type",
       value: node.type,
-      message: `Unknown node type "${node.type}" at ${path25}. Valid types: section, stack, text, etc.`
+      message: `Unknown node type "${node.type}" at ${path27}. Valid types: section, stack, text, etc.`
     });
   }
   if (node.children && Array.isArray(node.children)) {
     node.children.forEach((child, index) => {
-      validateNodeTypesRecursive(child, `${path25}.children[${index}]`, errors);
+      validateNodeTypesRecursive(child, `${path27}.children[${index}]`, errors);
     });
   }
 }
@@ -44024,45 +44354,45 @@ function validateTransformIds(layout) {
     errors
   };
 }
-function validateTransformIdsRecursive(node, path25, errors) {
+function validateTransformIdsRecursive(node, path27, errors) {
   if (node.$bind?.transforms && Array.isArray(node.$bind.transforms)) {
-    validateTransformList(node.$bind.transforms, `${path25}.$bind.transforms`, errors);
+    validateTransformList(node.$bind.transforms, `${path27}.$bind.transforms`, errors);
   }
   if (node.$repeat?.collection?.transforms && Array.isArray(node.$repeat.collection.transforms)) {
-    validateTransformList(node.$repeat.collection.transforms, `${path25}.$repeat.collection.transforms`, errors);
+    validateTransformList(node.$repeat.collection.transforms, `${path27}.$repeat.collection.transforms`, errors);
   }
   if (node.$when?.when?.transforms && Array.isArray(node.$when.when.transforms)) {
-    validateTransformList(node.$when.when.transforms, `${path25}.$when.when.transforms`, errors);
+    validateTransformList(node.$when.when.transforms, `${path27}.$when.when.transforms`, errors);
   }
   if (node.$scopes && Array.isArray(node.$scopes)) {
     node.$scopes.forEach((scope, index) => {
       if (scope.from?.transforms && Array.isArray(scope.from.transforms)) {
-        validateTransformList(scope.from.transforms, `${path25}.$scopes[${index}].from.transforms`, errors);
+        validateTransformList(scope.from.transforms, `${path27}.$scopes[${index}].from.transforms`, errors);
       }
     });
   }
   if (node.props) {
-    validatePropsTransforms(node.props, `${path25}.props`, errors);
+    validatePropsTransforms(node.props, `${path27}.props`, errors);
   }
   if (node.children && Array.isArray(node.children)) {
     node.children.forEach((child, index) => {
-      validateTransformIdsRecursive(child, `${path25}.children[${index}]`, errors);
+      validateTransformIdsRecursive(child, `${path27}.children[${index}]`, errors);
     });
   }
 }
-function validateTransformList(transforms, path25, errors) {
+function validateTransformList(transforms, path27, errors) {
   transforms.forEach((transform, index) => {
     if (!ALLOWED_TRANSFORM_IDS_SET.has(transform.id)) {
       errors.push({
-        path: `${path25}[${index}].id`,
+        path: `${path27}[${index}].id`,
         type: "invalid_transform_id",
         value: transform.id,
-        message: `Unknown transform "${transform.id}" at ${path25}. Valid transforms: string.uppercase, value.fallback, etc.`
+        message: `Unknown transform "${transform.id}" at ${path27}. Valid transforms: string.uppercase, value.fallback, etc.`
       });
     }
   });
 }
-function validatePropsTransforms(props2, path25, errors) {
+function validatePropsTransforms(props2, path27, errors) {
   for (const [key, value] of Object.entries(props2)) {
     if (isBindingObject(value)) {
       const binding = value;
@@ -44070,16 +44400,16 @@ function validatePropsTransforms(props2, path25, errors) {
         binding.$bind.transforms.forEach((transform, index) => {
           if (!ALLOWED_TRANSFORM_IDS_SET.has(transform.id)) {
             errors.push({
-              path: `${path25}.${key}.$bind.transforms[${index}].id`,
+              path: `${path27}.${key}.$bind.transforms[${index}].id`,
               type: "invalid_transform_id",
               value: transform.id,
-              message: `Unknown transform "${transform.id}" at ${path25}.${key}. Valid transforms: string.uppercase, value.fallback, etc.`
+              message: `Unknown transform "${transform.id}" at ${path27}.${key}. Valid transforms: string.uppercase, value.fallback, etc.`
             });
           }
         });
       }
     } else if (value && typeof value === "object" && !Array.isArray(value)) {
-      validatePropsTransforms(value, `${path25}.${key}`, errors);
+      validatePropsTransforms(value, `${path27}.${key}`, errors);
     }
   }
 }
@@ -44125,21 +44455,6 @@ var titleSourceValueSchema = z.union([
   z.array(z.string().min(1)).min(1)
 ]);
 
-// src/data/prefetchBlockData.ts
-var SUPPORTED_LOADER_ENDPOINTS2 = [
-  "listPublishedEntries",
-  "getPublishedEntryPreview",
-  "listPublicEvents",
-  "listPublicCourses",
-  "listPublicTeamMembers",
-  "listPublicProducts",
-  "listPublicPasses",
-  "listPublicMemberships",
-  "getPublicFormById",
-  "getPublicBookingServices",
-  "getPublicEventDetails"
-];
-
 // src/config/validation.ts
 var sdkThemePaletteSchema2 = z.record(z.string(), z.string());
 var sdkThemeConfigSchema2 = z.object({
@@ -44188,7 +44503,7 @@ var siteStyleConfigSchema = z.object({
   sectionOptions: sectionOptionsSchema,
   containerOptions: containerOptionsSchema
 }).optional();
-var sdkLoaderEndpointSchema2 = z.enum(SUPPORTED_LOADER_ENDPOINTS2);
+var sdkLoaderEndpointSchema2 = z.enum(SUPPORTED_LOADER_ENDPOINTS);
 var allowedTransformIds = new Set(builtinTransformDefinitions.map((transform) => transform.id));
 var loaderTransformStepSchema = z.object({
   id: z.string().refine((id) => allowedTransformIds.has(id), {
@@ -44624,8 +44939,8 @@ async function readApiResponse(response, requestInfo, options = {}) {
 function createHttpClient(config2) {
   const baseUrl = `${config2.dashboardUrl}/api/sdk/${config2.siteId}`;
   const timeout = config2.timeout ?? 3e4;
-  async function request(method, path25, options) {
-    let url = `${baseUrl}${path25}`;
+  async function request(method, path27, options) {
+    let url = `${baseUrl}${path27}`;
     if (options?.params && Object.keys(options.params).length > 0) {
       const searchParams = new URLSearchParams(options.params);
       url = `${url}?${searchParams.toString()}`;
@@ -44648,7 +44963,7 @@ function createHttpClient(config2) {
     } catch (error) {
       const requestInfo2 = buildRequestInfo({
         method,
-        path: path25,
+        path: path27,
         url,
         baseUrl,
         dashboardUrl: config2.dashboardUrl,
@@ -44673,7 +44988,7 @@ function createHttpClient(config2) {
     }
     const requestInfo = buildRequestInfo({
       method,
-      path: path25,
+      path: path27,
       url,
       baseUrl,
       dashboardUrl: config2.dashboardUrl,
@@ -44703,17 +45018,17 @@ function createHttpClient(config2) {
     return json.data;
   }
   return {
-    async get(path25, params) {
-      return request("GET", path25, { params });
+    async get(path27, params) {
+      return request("GET", path27, { params });
     },
-    async post(path25, body) {
-      return request("POST", path25, { body });
+    async post(path27, body) {
+      return request("POST", path27, { body });
     },
-    async patch(path25, body) {
-      return request("PATCH", path25, { body });
+    async patch(path27, body) {
+      return request("PATCH", path27, { body });
     },
-    async delete(path25, body) {
-      await request("DELETE", path25, { body });
+    async delete(path27, body) {
+      await request("DELETE", path27, { body });
     }
   };
 }
@@ -46158,12 +46473,12 @@ function collectPushConfigSyncWarnings(sync) {
 async function pushToDashboard(output, dashboardUrl, siteId, apiKey, config2, options) {
   const normalizedDashboardUrl = dashboardUrl.replace(/\/+$/, "");
   const baseUrl = `${normalizedDashboardUrl}/api`;
-  const path25 = `/sites/${siteId}/sdk-config`;
-  const pushUrl = `${baseUrl}${path25}`;
+  const path27 = `/sites/${siteId}/sdk-config`;
+  const pushUrl = `${baseUrl}${path27}`;
   output.info(`Pushing config to ${pushUrl}...`);
   const requestInfo = {
     method: "POST",
-    path: path25,
+    path: path27,
     url: pushUrl,
     baseUrl,
     dashboardUrl: normalizedDashboardUrl,
@@ -46233,9 +46548,9 @@ async function pushConfigAction(output, options) {
     const parseResult = riverbankSiteConfigSchema.safeParse(rawConfig);
     if (!parseResult.success) {
       output.error("Invalid config", {
-        issues: parseResult.error.issues.map((issue4) => ({
-          path: issue4.path.join("."),
-          message: issue4.message
+        issues: parseResult.error.issues.map((issue5) => ({
+          path: issue5.path.join("."),
+          message: issue5.message
         }))
       });
     }
@@ -46942,23 +47257,7 @@ async function writeEvents(contentDir, pulledEvents, options) {
   const eventsMeta = {};
   for (const event of pulledEvents.events) {
     const filePath = path5.join(eventsDir, `${event.identifier}.json`);
-    const eventPayload = {
-      identifier: event.identifier,
-      title: event.title,
-      slug: event.slug,
-      status: event.status,
-      visibility: event.visibility,
-      schedule: event.schedule,
-      capacity: event.capacity,
-      pricing: event.pricing,
-      venueRef: event.venueRef,
-      categoryRef: event.categoryRef,
-      content: event.content,
-      formRef: event.formRef,
-      settings: event.settings,
-      presentation: event.presentation,
-      tags: event.tags
-    };
+    const eventPayload = toWritableLocalEvent(event);
     stripEnvSpecificMediaFieldsInPlace(eventPayload);
     await writeJsonFile(filePath, eventPayload);
     filePaths.push(filePath);
@@ -46978,6 +47277,26 @@ async function writeEvents(contentDir, pulledEvents, options) {
   }
   return { filePaths, metaPath };
 }
+function toWritableLocalEvent(event) {
+  return {
+    identifier: event.identifier,
+    title: event.title,
+    slug: event.slug,
+    status: event.status,
+    visibility: event.visibility,
+    schedule: event.schedule,
+    capacity: event.capacity,
+    pricing: event.pricing,
+    paymentTerms: event.paymentTerms,
+    venueRef: event.venueRef,
+    categoryRef: event.categoryRef,
+    content: event.content,
+    formRef: event.formRef,
+    settings: event.settings,
+    presentation: event.presentation,
+    tags: event.tags
+  };
+}
 async function writeCourses(contentDir, pulledCourses, options) {
   const coursesDir = path5.join(contentDir, "courses");
   const metaDir = path5.join(contentDir, ".meta");
@@ -47315,7 +47634,7 @@ async function readSettings(contentDir) {
     throw new Error(
       `${filePath}: invalid settings.json
 ` + parsed.error.issues.map(
-        (issue4) => `  - ${issue4.path.join(".") || "(root)"}: ${issue4.message}`
+        (issue5) => `  - ${issue5.path.join(".") || "(root)"}: ${issue5.message}`
       ).join("\n")
     );
   }
@@ -49033,11 +49352,11 @@ function findChangedFields(local, remote, prefix = "") {
   const changes = [];
   const allKeys = /* @__PURE__ */ new Set([...Object.keys(local), ...Object.keys(remote)]);
   for (const key of allKeys) {
-    const path25 = prefix ? `${prefix}.${key}` : key;
+    const path27 = prefix ? `${prefix}.${key}` : key;
     const localVal = local[key];
     const remoteVal = remote[key];
     if (!equal(localVal, remoteVal)) {
-      changes.push(path25);
+      changes.push(path27);
     }
   }
   return changes;
@@ -50107,11 +50426,11 @@ function findChangedFieldsWithValues(local, remote, prefix = "") {
   const changes = [];
   const allKeys = /* @__PURE__ */ new Set([...Object.keys(local), ...Object.keys(remote)]);
   for (const key of allKeys) {
-    const path25 = prefix ? `${prefix}.${key}` : key;
+    const path27 = prefix ? `${prefix}.${key}` : key;
     const localVal = local[key];
     const remoteVal = remote[key];
     if (!equal(localVal, remoteVal)) {
-      changes.push({ path: path25, before: remoteVal, after: localVal });
+      changes.push({ path: path27, before: remoteVal, after: localVal });
     }
   }
   return changes;
@@ -50528,6 +50847,117 @@ function maskPullDiffForScope(diff, pullScope) {
   }
   return diff;
 }
+var CANONICAL_EVENT_ENTRY_TYPE = "event";
+var EVENT_MIGRATION_COMMAND = "riverbankcms migrate events";
+var EVENT_PUSH_COMMAND = "riverbankcms push events";
+var EVENT_PULL_COMMAND = "riverbankcms pull events";
+var CANONICAL_ENTRY_POLICIES = [{
+  contentType: CANONICAL_EVENT_ENTRY_TYPE,
+  migrationCommand: EVENT_MIGRATION_COMMAND,
+  commands: {
+    push: EVENT_PUSH_COMMAND,
+    pull: EVENT_PULL_COMMAND
+  }
+}];
+function getCanonicalEntryPolicy(contentType) {
+  const normalizedType = contentType?.trim().toLowerCase();
+  return CANONICAL_ENTRY_POLICIES.find((policy) => policy.contentType === normalizedType) ?? null;
+}
+function buildScopeViolation(input) {
+  const command = input.policy.commands[input.operation];
+  return {
+    contentType: input.policy.contentType,
+    message: "`event` entries are managed through the canonical events surface.",
+    suggestion: `Use "${command}" for event sync. If you still have content/entries/event/*.json files, run "${input.policy.migrationCommand}" to fold legacy event copy into content/events/*.json.`
+  };
+}
+function getCanonicalEntrySyncDecision(input) {
+  const normalizedScope = input.scope.toLowerCase();
+  if (normalizedScope === "entries") {
+    const scopedPolicy = getCanonicalEntryPolicy(input.contentType);
+    if (scopedPolicy) {
+      return {
+        tag: "reject",
+        violation: buildScopeViolation({ policy: scopedPolicy, operation: input.operation })
+      };
+    }
+    if (!input.contentType) {
+      return {
+        tag: "allow-with-canonical-exclusions",
+        policies: CANONICAL_ENTRY_POLICIES
+      };
+    }
+  }
+  if (normalizedScope === "all") {
+    return {
+      tag: "allow-with-canonical-exclusions",
+      policies: CANONICAL_ENTRY_POLICIES
+    };
+  }
+  return { tag: "allow" };
+}
+function shouldExcludeCanonicalEntries(decision) {
+  return decision.tag === "allow-with-canonical-exclusions";
+}
+function filterGenericEntryContentTypes(contentTypes) {
+  return contentTypes.filter((contentType) => !getCanonicalEntryPolicy(contentType));
+}
+function stripCanonicalEventEntriesFromLocalContent(content) {
+  const eventEntries = content.entries.get(CANONICAL_EVENT_ENTRY_TYPE);
+  if (!eventEntries) {
+    return { content, removedEntryCount: 0, removedContentTypes: [] };
+  }
+  const entries = new Map(content.entries);
+  entries.delete(CANONICAL_EVENT_ENTRY_TYPE);
+  return {
+    content: { ...content, entries },
+    removedEntryCount: eventEntries.length,
+    removedContentTypes: [CANONICAL_EVENT_ENTRY_TYPE]
+  };
+}
+function stripCanonicalEventEntriesFromPulledContent(content) {
+  const eventEntries = content.entries[CANONICAL_EVENT_ENTRY_TYPE];
+  if (!eventEntries) {
+    return { content, removedEntryCount: 0, removedContentTypes: [] };
+  }
+  const { [CANONICAL_EVENT_ENTRY_TYPE]: _removed, ...entries } = content.entries;
+  const filteredMetaEntries = Object.fromEntries(
+    Object.entries(content.meta.entries ?? {}).filter(([key]) => {
+      const [contentType] = key.split(":");
+      return contentType !== CANONICAL_EVENT_ENTRY_TYPE;
+    })
+  );
+  return {
+    content: {
+      ...content,
+      entries,
+      meta: {
+        ...content.meta,
+        ...content.meta.entries ? { entries: filteredMetaEntries } : {}
+      }
+    },
+    removedEntryCount: eventEntries.length,
+    removedContentTypes: [CANONICAL_EVENT_ENTRY_TYPE]
+  };
+}
+async function findLegacyEventEntryFiles(contentDir) {
+  const eventEntriesDir = path5.join(contentDir, "entries", CANONICAL_EVENT_ENTRY_TYPE);
+  try {
+    const items = await fs5.readdir(eventEntriesDir, { withFileTypes: true });
+    return items.filter((item) => item.isFile() && item.name.endsWith(".json")).map((item) => path5.join(eventEntriesDir, item.name)).sort();
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+function formatLegacyEventEntryWarning(files) {
+  return {
+    files: files.map((file) => path5.relative(process.cwd(), file)),
+    suggestion: `Generic event entry files are ignored by broad sync. Run "${EVENT_MIGRATION_COMMAND}" to fold legacy event copy into content/events/*.json.`
+  };
+}
 function findChangedTopLevelKeys(a, b) {
   const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
   const changed = [];
@@ -50879,6 +51309,17 @@ async function fetchAllContentPaginated(client, contentTypes, output, baseConten
     }
   };
 }
+async function pullAllContentWithCanonicalEntryPolicy(client, output) {
+  const result = await client.pull.all();
+  if (!result.meta.truncated) {
+    return stripCanonicalEventEntriesFromPulledContent(result).content;
+  }
+  output.warn("Content was truncated due to size limits.");
+  output.info("Fetching complete data via pagination...");
+  const contentTypes = filterGenericEntryContentTypes(Object.keys(result.entries));
+  const paginatedResult = await fetchAllContentPaginated(client, contentTypes, output, result);
+  return stripCanonicalEventEntriesFromPulledContent(paginatedResult).content;
+}
 function createScopedPullContent(meta, overrides) {
   return {
     entries: {},
@@ -51011,6 +51452,30 @@ function shouldPromptForOverwrite(opts) {
   if (opts.force || opts.yes) return false;
   return true;
 }
+function emitCanonicalEntryScopeRejection(output, decision) {
+  if (decision.tag !== "reject") {
+    return false;
+  }
+  process.exitCode = 1;
+  output.result(false, decision.violation.message, {
+    contentType: decision.violation.contentType,
+    suggestion: decision.violation.suggestion
+  });
+  return true;
+}
+async function warnForLocalLegacyEventEntries(input) {
+  if (!shouldExcludeCanonicalEntries(input.decision) || !input.dirExists) {
+    return;
+  }
+  const legacyEventEntryFiles = await findLegacyEventEntryFiles(input.contentDir);
+  if (legacyEventEntryFiles.length === 0) {
+    return;
+  }
+  input.output.warn(
+    "Legacy event entry files detected and ignored by generic entry sync.",
+    formatLegacyEventEntryWarning(legacyEventEntryFiles)
+  );
+}
 var pullCommand = new Command("pull").description("Pull content from CMS").argument("[scope]", "What to pull: entries, pages, navigation, settings, forms, theme, footer, venues, event-categories, events, courses, or all (default)").argument("[type]", "Content type (entries) or page identifier (pages)").argument("[identifier]", 'Entry identifier (when scope is "entries" and type is set)').option("--output <dir>", "Output directory", "./content").option("--force", "Overwrite existing files without prompting").option("--yes", "Skip confirmation prompt (same as --force)").option("--sync-media", "Sync media files from source to target environment").option("--overwrite-media", "When using --sync-media, overwrite target media on checksum mismatch").option("--local-media", "Download media referenced by identifiers to content/media").option("--dry-run", "Show what would be pulled without writing files").option("--json-diff [mode]", "Output diff as JSON (summary or full)", "summary").option("--with-theme", "Also pull theme when pulling all content").option("--name <name>", "Theme name for theme pull / --with-theme (default: current)").option("--no-meta", "Skip writing .meta/ and media manifest files (content files still written)").option("--diff", "Show human-readable field-level diff with before/after values (requires --dry-run)").addHelpText("after", `
 Examples:
   $ riverbankcms pull                         # Pull all content
@@ -51102,6 +51567,20 @@ Media Sync:
           });
           return;
         }
+        const canonicalEntrySyncDecision2 = getCanonicalEntrySyncDecision({
+          scope: pullScope2,
+          contentType: type,
+          operation: "pull"
+        });
+        if (emitCanonicalEntryScopeRejection(output, canonicalEntrySyncDecision2)) {
+          return;
+        }
+        await warnForLocalLegacyEventEntries({
+          output,
+          contentDir,
+          decision: canonicalEntrySyncDecision2,
+          dirExists: await contentDirExists(contentDir)
+        });
         output.info(`[DRY RUN] Fetching content from ${envLabel}...`);
         if (options.withTheme && pullScope2 !== "all") {
           output.warn('--with-theme only applies when pulling all content (use "riverbankcms pull theme" instead)');
@@ -51308,13 +51787,7 @@ Media Sync:
                 { entries: { [type]: pulled.entries } }
               );
             } else {
-              let result = await client.pull.all();
-              if (result.meta.truncated) {
-                output.warn("Content was truncated due to size limits.");
-                output.info("Fetching complete data via pagination...");
-                const contentTypes = Object.keys(result.entries);
-                result = await fetchAllContentPaginated(client, contentTypes, output, result);
-              }
+              const result = await pullAllContentWithCanonicalEntryPolicy(client, output);
               remoteContent = createScopedPullContent(result.meta, { entries: result.entries });
             }
             break;
@@ -51353,13 +51826,7 @@ Media Sync:
                 `[DRY RUN] Would also pull theme to ${path5.join(path5.basename(contentDir), "themes", `${themeName}.json`)}`
               );
             }
-            let result = await client.pull.all();
-            if (result.meta.truncated) {
-              output.warn("Content was truncated due to size limits.");
-              output.info("Fetching complete data via pagination...");
-              const contentTypes = Object.keys(result.entries);
-              result = await fetchAllContentPaginated(client, contentTypes, output, result);
-            }
+            const result = await pullAllContentWithCanonicalEntryPolicy(client, output);
             remoteContent = result;
             break;
           }
@@ -51468,6 +51935,20 @@ Media Sync:
         });
         return;
       }
+      const canonicalEntrySyncDecision = getCanonicalEntrySyncDecision({
+        scope: pullScope,
+        contentType: type,
+        operation: "pull"
+      });
+      if (emitCanonicalEntryScopeRejection(output, canonicalEntrySyncDecision)) {
+        return;
+      }
+      await warnForLocalLegacyEventEntries({
+        output,
+        contentDir,
+        decision: canonicalEntrySyncDecision,
+        dirExists
+      });
       if (shouldPromptForOverwrite({
         pullScope,
         contentDirExists: dirExists,
@@ -51577,13 +52058,7 @@ Media Sync:
             });
           } else {
             output.info("Pulling all entries");
-            let result = await client.pull.all();
-            if (result.meta.truncated) {
-              output.warn("Content was truncated due to size limits.");
-              output.info("Fetching complete data via pagination...");
-              const contentTypes = Object.keys(result.entries);
-              result = await fetchAllContentPaginated(client, contentTypes, output, result);
-            }
+            const result = await pullAllContentWithCanonicalEntryPolicy(client, output);
             const mediaContent = createScopedPullContent(result.meta, { entries: result.entries });
             await applyMediaIdentifiers(mediaContent);
             await syncMediaIfRequested(mediaContent);
@@ -51730,13 +52205,7 @@ Media Sync:
         case "all":
         default: {
           output.info("Pulling all content");
-          let result = await client.pull.all();
-          if (result.meta.truncated) {
-            output.warn("Content was truncated due to size limits.");
-            output.info("Fetching complete data via pagination...");
-            const contentTypes = Object.keys(result.entries);
-            result = await fetchAllContentPaginated(client, contentTypes, output, result);
-          }
+          const result = await pullAllContentWithCanonicalEntryPolicy(client, output);
           result.settingsWarnings?.forEach((warning) => output.warn(warning));
           await applyMediaIdentifiers(result);
           await syncMediaIfRequested(result);
@@ -52118,8 +52587,8 @@ function normalizeLocalContentShape(content) {
 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 issue2(path27, message) {
+  return { path: path27, message };
 }
 function isRecord15(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -52136,27 +52605,27 @@ function isWholeMinuteIsoDateTime(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 path27 = ["ticketTypes", String(index)];
+  if (!isRecord15(raw)) return [issue2(path27, "Ticket type must be an object")];
   const issues = [];
   const identifier = raw.identifier;
   if (typeof identifier !== "string" || !identifierRegex.test(identifier)) {
     issues.push(
       issue2(
-        [...path25, "identifier"],
+        [...path27, "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"));
+    issues.push(issue2([...path27, "name"], "Ticket name is required"));
   }
   const priceAmount = raw.priceAmount;
   if (!isWholeNumber(priceAmount) || priceAmount < 0) {
     issues.push(
       issue2(
-        [...path25, "priceAmount"],
+        [...path27, "priceAmount"],
         "Ticket priceAmount must be a non-negative integer"
       )
     );
@@ -52165,7 +52634,7 @@ function validateTicketType(raw, index, currency) {
   if (priceCurrency !== void 0 && priceCurrency !== null && priceCurrency !== currency) {
     issues.push(
       issue2(
-        [...path25, "priceCurrency"],
+        [...path27, "priceCurrency"],
         "Ticket priceCurrency must match pricing.priceCurrency"
       )
     );
@@ -52174,7 +52643,7 @@ function validateTicketType(raw, index, currency) {
   if (sortOrder !== void 0 && (!isWholeNumber(sortOrder) || sortOrder < 0)) {
     issues.push(
       issue2(
-        [...path25, "sortOrder"],
+        [...path27, "sortOrder"],
         "Ticket sortOrder must be a non-negative integer"
       )
     );
@@ -52183,7 +52652,7 @@ function validateTicketType(raw, index, currency) {
   if (capacityLimit2 !== void 0 && capacityLimit2 !== null && (!isWholeNumber(capacityLimit2) || capacityLimit2 < 1)) {
     issues.push(
       issue2(
-        [...path25, "capacityLimit"],
+        [...path27, "capacityLimit"],
         "Ticket capacityLimit must be a positive integer"
       )
     );
@@ -52192,7 +52661,7 @@ function validateTicketType(raw, index, currency) {
   if (attendanceScope !== void 0 && attendanceScope !== "in_person" && attendanceScope !== "online" && attendanceScope !== "both") {
     issues.push(
       issue2(
-        [...path25, "attendanceScope"],
+        [...path27, "attendanceScope"],
         "Ticket attendanceScope must be in_person, online, or both"
       )
     );
@@ -52201,7 +52670,7 @@ function validateTicketType(raw, index, currency) {
   if (saleStartsAt !== void 0 && saleStartsAt !== null && (typeof saleStartsAt !== "string" || !isWholeMinuteIsoDateTime(saleStartsAt))) {
     issues.push(
       issue2(
-        [...path25, "saleStartsAt"],
+        [...path27, "saleStartsAt"],
         "Ticket saleStartsAt must be an ISO datetime aligned to a whole minute"
       )
     );
@@ -52210,7 +52679,7 @@ function validateTicketType(raw, index, currency) {
   if (saleEndsAt !== void 0 && saleEndsAt !== null && (typeof saleEndsAt !== "string" || !isWholeMinuteIsoDateTime(saleEndsAt))) {
     issues.push(
       issue2(
-        [...path25, "saleEndsAt"],
+        [...path27, "saleEndsAt"],
         "Ticket saleEndsAt must be an ISO datetime aligned to a whole minute"
       )
     );
@@ -52218,7 +52687,7 @@ function validateTicketType(raw, index, currency) {
   if (typeof saleStartsAt === "string" && typeof saleEndsAt === "string" && Date.parse(saleEndsAt) <= Date.parse(saleStartsAt)) {
     issues.push(
       issue2(
-        [...path25, "saleEndsAt"],
+        [...path27, "saleEndsAt"],
         "Ticket saleEndsAt must be after saleStartsAt"
       )
     );
@@ -52227,7 +52696,7 @@ function validateTicketType(raw, index, currency) {
   if (cmsTicketTypeId !== void 0 && cmsTicketTypeId !== null && (typeof cmsTicketTypeId !== "string" || cmsTicketTypeId.length === 0)) {
     issues.push(
       issue2(
-        [...path25, "cmsTicketTypeId"],
+        [...path27, "cmsTicketTypeId"],
         "Ticket cmsTicketTypeId must be a non-empty string"
       )
     );
@@ -52405,11 +52874,239 @@ function classifySdkEventPricing(rawInput) {
   }
 }
 
+// ../api/src/sdk-event-payment-terms.ts
+var supportedKinds = /* @__PURE__ */ new Set([
+  "upfront",
+  "deferred_manual",
+  "flexible_balance"
+]);
+function issue3(path27, message) {
+  return { path: path27, message };
+}
+function isRecord16(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isWholeNumber2(value) {
+  return typeof value === "number" && Number.isInteger(value);
+}
+function isPositiveWholeNumber(value) {
+  return isWholeNumber2(value) && value > 0;
+}
+function isDepositRefundability(value) {
+  return value === "refundable" || value === "non_refundable";
+}
+function isSupportedOptionKind(value) {
+  return typeof value === "string" && supportedKinds.has(value);
+}
+function validateFlexibleBalanceDueDateRule(raw, path27) {
+  if (!isRecord16(raw)) {
+    return [issue3(path27, "Flexible balance dueDateRule must be an object")];
+  }
+  if (raw.kind === "relative_to_start_date") {
+    if (!isPositiveWholeNumber(raw.daysBeforeStart)) {
+      return [
+        issue3(
+          [...path27, "daysBeforeStart"],
+          "Flexible balance daysBeforeStart must be a positive integer"
+        )
+      ];
+    }
+    return {
+      kind: "relative_to_start_date",
+      daysBeforeStart: raw.daysBeforeStart
+    };
+  }
+  if (raw.kind === "fixed_calendar_date") {
+    if (typeof raw.dueAt !== "string" || !Number.isFinite(Date.parse(raw.dueAt))) {
+      return [
+        issue3(
+          [...path27, "dueAt"],
+          "Flexible balance fixed dueAt must be an ISO datetime"
+        )
+      ];
+    }
+    return {
+      kind: "fixed_calendar_date",
+      dueAt: raw.dueAt
+    };
+  }
+  return [
+    issue3(
+      [...path27, "kind"],
+      "Flexible balance dueDateRule kind must be relative_to_start_date or fixed_calendar_date"
+    )
+  ];
+}
+function validateFlexibleBalanceConfig(raw, path27) {
+  if (!isRecord16(raw)) {
+    return [issue3(path27, "Flexible balance config must be an object")];
+  }
+  const issues = [];
+  const upfrontAmountCents = raw.upfrontAmountCents;
+  const depositRefundability = raw.depositRefundability;
+  let validatedUpfrontAmountCents = null;
+  let validatedDepositRefundability = null;
+  if (!isWholeNumber2(upfrontAmountCents) || upfrontAmountCents < 0) {
+    issues.push(
+      issue3(
+        [...path27, "upfrontAmountCents"],
+        "Flexible balance upfrontAmountCents must be a non-negative integer"
+      )
+    );
+  } else {
+    validatedUpfrontAmountCents = upfrontAmountCents;
+  }
+  if (!isDepositRefundability(depositRefundability)) {
+    issues.push(
+      issue3(
+        [...path27, "depositRefundability"],
+        "Flexible balance depositRefundability must be refundable or non_refundable"
+      )
+    );
+  } else {
+    validatedDepositRefundability = depositRefundability;
+  }
+  const dueDateRule = validateFlexibleBalanceDueDateRule(
+    raw.dueDateRule,
+    [...path27, "dueDateRule"]
+  );
+  if (Array.isArray(dueDateRule)) {
+    issues.push(...dueDateRule);
+  }
+  if (issues.length > 0 || Array.isArray(dueDateRule) || validatedUpfrontAmountCents === null || validatedDepositRefundability === null) {
+    return issues;
+  }
+  return {
+    upfrontAmountCents: validatedUpfrontAmountCents,
+    depositRefundability: validatedDepositRefundability,
+    dueDateRule
+  };
+}
+function validateCollectionOption(raw, index) {
+  const path27 = ["allowedOptions", String(index)];
+  if (!isRecord16(raw)) {
+    return [issue3(path27, "Payment option must be an object")];
+  }
+  if (raw.kind === "instalment_plan") {
+    return [
+      issue3(
+        [...path27, "kind"],
+        "Event instalment plans are not supported yet. Use upfront, deferred_manual, or flexible_balance."
+      )
+    ];
+  }
+  if (!isSupportedOptionKind(raw.kind)) {
+    return [
+      issue3(
+        [...path27, "kind"],
+        "Payment option kind must be upfront, deferred_manual, or flexible_balance"
+      )
+    ];
+  }
+  switch (raw.kind) {
+    case "upfront":
+    case "deferred_manual":
+      return { kind: raw.kind };
+    case "flexible_balance": {
+      const config2 = validateFlexibleBalanceConfig(raw.config, [
+        ...path27,
+        "config"
+      ]);
+      if (Array.isArray(config2)) {
+        return config2;
+      }
+      return { kind: "flexible_balance", config: config2 };
+    }
+  }
+}
+function optionCombinationIssues(options) {
+  const issues = [];
+  const seenKinds = /* @__PURE__ */ new Set();
+  options.forEach((option, index) => {
+    if (seenKinds.has(option.kind)) {
+      issues.push(
+        issue3(
+          ["allowedOptions", String(index), "kind"],
+          `Duplicate payment option kind "${option.kind}"`
+        )
+      );
+    }
+    seenKinds.add(option.kind);
+  });
+  if (options.length > 2) {
+    issues.push(
+      issue3(
+        ["allowedOptions"],
+        "Event payment terms can offer one option, or a choice between upfront and one alternative option"
+      )
+    );
+  }
+  if (options.length === 2 && (!seenKinds.has("upfront") || !seenKinds.has("deferred_manual") && !seenKinds.has("flexible_balance"))) {
+    issues.push(
+      issue3(
+        ["allowedOptions"],
+        "Event payment terms with two options must combine upfront with deferred_manual or flexible_balance"
+      )
+    );
+  }
+  return issues;
+}
+function classifySdkEventPaymentTerms(rawInput) {
+  if (rawInput === void 0 || rawInput === null) {
+    return { ok: true, paymentTerms: void 0 };
+  }
+  if (!isRecord16(rawInput)) {
+    return {
+      ok: false,
+      issues: [issue3([], "Event paymentTerms must be an object")]
+    };
+  }
+  if (!Array.isArray(rawInput.allowedOptions)) {
+    return {
+      ok: false,
+      issues: [
+        issue3(["allowedOptions"], "Event paymentTerms.allowedOptions is required")
+      ]
+    };
+  }
+  if (rawInput.allowedOptions.length === 0) {
+    return {
+      ok: false,
+      issues: [
+        issue3(
+          ["allowedOptions"],
+          "Event paymentTerms.allowedOptions must include at least one option"
+        )
+      ]
+    };
+  }
+  const options = [];
+  const issues = [];
+  rawInput.allowedOptions.forEach((option, index) => {
+    const validated = validateCollectionOption(option, index);
+    if (Array.isArray(validated)) {
+      issues.push(...validated);
+      return;
+    }
+    options.push(validated);
+  });
+  issues.push(...optionCombinationIssues(options));
+  if (issues.length > 0) {
+    return { ok: false, issues };
+  }
+  return {
+    ok: true,
+    paymentTerms: {
+      allowedOptions: options
+    }
+  };
+}
+
 // src/cli/commands/push/pushAllExtras.ts
 function nullishToNull(value) {
   return value == null ? null : value;
 }
-function isRecord16(value) {
+function isRecord17(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function stringValue(value, fallback) {
@@ -52424,8 +53121,13 @@ function normalizeEventPricingForCompare(pricing) {
   if (result.ok) return result.pricing;
   return { kind: "free" };
 }
+function normalizeEventPaymentTermsForCompare(paymentTerms) {
+  const result = classifySdkEventPaymentTerms(paymentTerms);
+  if (result.ok) return result.paymentTerms;
+  return void 0;
+}
 function normalizeVenueAddress(value) {
-  const obj = isRecord16(value) ? value : {};
+  const obj = isRecord17(value) ? value : {};
   return {
     line1: nullishToNull(typeof obj.line1 === "string" ? obj.line1 : void 0),
     line2: nullishToNull(typeof obj.line2 === "string" ? obj.line2 : void 0),
@@ -52442,7 +53144,7 @@ function normalizeVenueAddress(value) {
   };
 }
 function normalizeVenueLocation(value) {
-  if (!isRecord16(value)) return null;
+  if (!isRecord17(value)) return null;
   const obj = value;
   const lat = typeof obj.lat === "number" ? obj.lat : null;
   const lng = typeof obj.lng === "number" ? obj.lng : null;
@@ -52450,7 +53152,7 @@ function normalizeVenueLocation(value) {
   return { lat, lng };
 }
 function normalizeVenueForCompare(venue) {
-  const obj = isRecord16(venue) ? venue : {};
+  const obj = isRecord17(venue) ? venue : {};
   return {
     slug: String(obj.slug),
     title: String(obj.title),
@@ -52471,7 +53173,7 @@ function normalizeVenueForCompare(venue) {
   };
 }
 function normalizeEventCategoryForCompare(category) {
-  const obj = isRecord16(category) ? category : {};
+  const obj = isRecord17(category) ? category : {};
   return {
     identifier: String(obj.identifier),
     name: String(obj.name),
@@ -52483,8 +53185,8 @@ function normalizeEventCategoryForCompare(category) {
   };
 }
 function normalizeRemoteEventForCompare(event) {
-  const obj = isRecord16(event) ? event : {};
-  const schedule = isRecord16(obj.schedule) ? obj.schedule : {};
+  const obj = isRecord17(event) ? event : {};
+  const schedule = isRecord17(obj.schedule) ? obj.schedule : {};
   return {
     identifier: String(obj.identifier),
     title: String(obj.title),
@@ -52503,6 +53205,7 @@ function normalizeRemoteEventForCompare(event) {
       typeof obj.capacity === "number" ? obj.capacity : void 0
     ),
     pricing: normalizeEventPricingForCompare(obj.pricing),
+    paymentTerms: normalizeEventPaymentTermsForCompare(obj.paymentTerms),
     venueRef: nullishToNull(
       typeof obj.venueRef === "string" ? obj.venueRef : void 0
     ),
@@ -52512,14 +53215,14 @@ function normalizeRemoteEventForCompare(event) {
     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,
+    content: isRecord17(obj.content) ? obj.content : {},
+    settings: isRecord17(obj.settings) ? obj.settings : {},
+    presentation: isRecord17(obj.presentation) ? obj.presentation : null,
     tags: Array.isArray(obj.tags) ? obj.tags : []
   };
 }
 function normalizeLocalEventAgainstRemoteForCompare(localEvent, remoteEvent) {
-  const local = isRecord16(localEvent) ? localEvent : {};
+  const local = isRecord17(localEvent) ? localEvent : {};
   const base = remoteEvent ? normalizeRemoteEventForCompare(remoteEvent) : normalizeRemoteEventForCompare({
     identifier: local.identifier,
     title: local.title,
@@ -52528,6 +53231,7 @@ function normalizeLocalEventAgainstRemoteForCompare(localEvent, remoteEvent) {
     visibility: local.visibility ?? "private",
     schedule: local.schedule ?? {},
     pricing: local.pricing ?? {},
+    paymentTerms: local.paymentTerms,
     capacity: local.capacity ?? null,
     venueRef: local.venueRef ?? null,
     categoryRef: local.categoryRef ?? null,
@@ -52537,7 +53241,7 @@ function normalizeLocalEventAgainstRemoteForCompare(localEvent, remoteEvent) {
     presentation: local.presentation ?? null,
     tags: local.tags ?? []
   });
-  const schedule = isRecord16(local.schedule) ? local.schedule : {};
+  const schedule = isRecord17(local.schedule) ? local.schedule : {};
   return {
     ...base,
     identifier: stringValue(local.identifier, base.identifier),
@@ -52558,6 +53262,7 @@ function normalizeLocalEventAgainstRemoteForCompare(localEvent, remoteEvent) {
       typeof local.capacity === "number" ? local.capacity : void 0
     ),
     pricing: local.pricing === void 0 ? base.pricing : normalizeEventPricingForCompare(local.pricing),
+    paymentTerms: local.paymentTerms === void 0 ? base.paymentTerms : normalizeEventPaymentTermsForCompare(local.paymentTerms),
     venueRef: local.venueRef === void 0 ? base.venueRef : nullishToNull(
       typeof local.venueRef === "string" ? local.venueRef : void 0
     ),
@@ -52567,9 +53272,9 @@ function normalizeLocalEventAgainstRemoteForCompare(localEvent, remoteEvent) {
     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,
+    content: local.content === void 0 ? base.content : isRecord17(local.content) ? local.content : {},
+    settings: local.settings === void 0 ? base.settings : isRecord17(local.settings) ? local.settings : {},
+    presentation: local.presentation === void 0 ? base.presentation : isRecord17(local.presentation) ? local.presentation : null,
     tags: local.tags === void 0 ? base.tags : Array.isArray(local.tags) ? local.tags : []
   };
 }
@@ -52581,7 +53286,7 @@ function toIsoStringOrOriginal(value) {
 function normalizeCourseSessions(value) {
   if (!Array.isArray(value)) return [];
   return value.map((session) => {
-    const obj = isRecord16(session) ? session : {};
+    const obj = isRecord17(session) ? session : {};
     return {
       startsAt: toIsoStringOrOriginal(obj.startsAt),
       endsAt: toIsoStringOrOriginal(obj.endsAt)
@@ -52593,18 +53298,18 @@ function normalizeCourseSessions(value) {
 }
 function normalizeCourseProgram(value) {
   if (value == null) return null;
-  if (!isRecord16(value)) {
+  if (!isRecord17(value)) {
     return { identifier: null, data: {} };
   }
   return {
     identifier: nullishToNull(
       typeof value.identifier === "string" ? value.identifier : void 0
     ),
-    data: isRecord16(value.data) ? value.data : {}
+    data: isRecord17(value.data) ? value.data : {}
   };
 }
 function normalizeRemoteCourseForCompare(course) {
-  const obj = isRecord16(course) ? course : {};
+  const obj = isRecord17(course) ? course : {};
   return {
     identifier: String(obj.identifier),
     title: String(obj.title),
@@ -52639,7 +53344,7 @@ function normalizeRemoteCourseForCompare(course) {
   };
 }
 function normalizeLocalCourseAgainstRemoteForCompare(localCourse, remoteCourse) {
-  const local = isRecord16(localCourse) ? localCourse : {};
+  const local = isRecord17(localCourse) ? localCourse : {};
   const base = remoteCourse ? normalizeRemoteCourseForCompare(remoteCourse) : normalizeRemoteCourseForCompare({
     identifier: local.identifier,
     title: local.title,
@@ -52660,11 +53365,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 : isRecord16(local.program) ? {
+  const program2 = local.program === void 0 ? base.program : local.program === null ? null : isRecord17(local.program) ? {
     identifier: local.program.identifier === void 0 ? base.program?.identifier ?? null : nullishToNull(
       typeof local.program.identifier === "string" ? local.program.identifier : void 0
     ),
-    data: isRecord16(local.program.data) ? local.program.data : base.program?.data ?? {}
+    data: isRecord17(local.program.data) ? local.program.data : base.program?.data ?? {}
   } : base.program;
   return {
     ...base,
@@ -53333,9 +54038,24 @@ var fixedPriceIntentSchema = z.object({
   kind: z.literal("fixed_price"),
   price: moneyAmountSchema
 }).strict();
+var inlineEventTicketTypeSchema = z.object({
+  identifier: recipeIdentifierSchema,
+  cmsTicketTypeId: z.string().min(1).nullable().optional(),
+  name: z.string().min(1),
+  description: z.string().nullable().optional(),
+  priceAmount: nonNegativeIntegerSchema,
+  priceCurrency: currencySchema.optional(),
+  isActive: z.boolean().optional(),
+  sortOrder: nonNegativeIntegerSchema.optional(),
+  capacityLimit: positiveIntegerSchema.nullable().optional(),
+  attendanceScope: z.enum(["in_person", "online", "both"]).optional(),
+  saleStartsAt: isoDateTimeSchema.nullable().optional(),
+  saleEndsAt: isoDateTimeSchema.nullable().optional()
+}).strict();
 var ticketTypesPricingIntentSchema = z.object({
   kind: z.literal("ticket_types"),
-  currency: currencySchema.optional()
+  currency: currencySchema.optional(),
+  ticketTypes: z.array(inlineEventTicketTypeSchema).readonly().optional()
 }).strict();
 var manualPaymentPricingIntentSchema = z.object({
   kind: z.literal("manual_payment"),
@@ -53780,6 +54500,7 @@ var upsertEventSeriesCommandSchema = z.object({
     occurrences: z.array(eventOccurrenceSchema).min(1).readonly(),
     content: contentSummarySchema.optional(),
     settings: unknownRecordSchema.optional(),
+    paymentTerms: z.unknown().optional(),
     presentation: unknownRecordSchema.nullable().optional(),
     tags: z.array(z.string()).readonly().optional(),
     staffRefs: z.array(staffRefSchema).readonly().optional()
@@ -54899,7 +55620,7 @@ function getSiteCommandLifecycleIntent(command) {
 init_src();
 
 // ../site-commands/src/guards.ts
-function isRecord17(value) {
+function isRecord18(value) {
   return typeof value === "object" && value !== null;
 }
 
@@ -55159,13 +55880,13 @@ function collectOfferingRequires(input, intervals, intervalPath) {
 function optionalRef(ref, field) {
   return ref ? [{ ref, field }] : [];
 }
-function collectVenueRefsFromIntervals(intervals, path25) {
-  return intervals.flatMap((interval, index) => optionalRef(interval.venueRef, `${path25}[${index}].venueRef`));
+function collectVenueRefsFromIntervals(intervals, path27) {
+  return intervals.flatMap((interval, index) => optionalRef(interval.venueRef, `${path27}[${index}].venueRef`));
 }
-function collectNavigationRefs(items, path25) {
+function collectNavigationRefs(items, path27) {
   return items.flatMap((item, index) => {
-    if (!isRecord17(item)) return [];
-    const itemPath = `${path25}[${index}]`;
+    if (!isRecord18(item)) return [];
+    const itemPath = `${path27}[${index}]`;
     const refs = [];
     if (typeof item.pageRef === "string") {
       refs.push({ ref: item.pageRef, field: `${itemPath}.pageRef` });
@@ -55179,26 +55900,26 @@ function collectNavigationRefs(items, path25) {
     return refs;
   });
 }
-function collectBlockRefs(blocks, path25) {
+function collectBlockRefs(blocks, path27) {
   return blocks.flatMap((block, index) => {
-    if (!isRecord17(block)) return [];
-    const blockPath = `${path25}[${index}]`;
+    if (!isRecord18(block)) return [];
+    const blockPath = `${path27}[${index}]`;
     return [
       ...collectNestedRefs(block.props, `${blockPath}.props`),
       ...collectNestedRefs(block.children, `${blockPath}.children`)
     ];
   });
 }
-function collectNestedRefs(value, path25) {
+function collectNestedRefs(value, path27) {
   if (typeof value === "string") {
     const parsed = parseResourceRef(value);
-    return parsed.ok ? [{ ref: value, field: path25 }] : [];
+    return parsed.ok ? [{ ref: value, field: path27 }] : [];
   }
   if (Array.isArray(value)) {
-    return value.flatMap((item, index) => collectNestedRefs(item, `${path25}[${index}]`));
+    return value.flatMap((item, index) => collectNestedRefs(item, `${path27}[${index}]`));
   }
-  if (!isRecord17(value)) return [];
-  return Object.entries(value).flatMap(([key, child]) => collectNestedRefs(child, `${path25}.${key}`));
+  if (!isRecord18(value)) return [];
+  return Object.entries(value).flatMap(([key, child]) => collectNestedRefs(child, `${path27}.${key}`));
 }
 
 // ../site-commands/src/staticExecutionGaps.ts
@@ -55281,7 +56002,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((issue4) => invalidPayloadError(input, issue4)));
+    return err(parsed.error.issues.map((issue5) => invalidPayloadError(input, issue5)));
   }
   return ok(parsed.data);
 }
@@ -55453,9 +56174,9 @@ function deriveIdempotencyKey(input) {
   ].join("|"));
 }
 function findUnknownCommandTypes(input) {
-  if (!isRecord17(input) || !Array.isArray(input.commands)) return [];
+  if (!isRecord18(input) || !Array.isArray(input.commands)) return [];
   return input.commands.flatMap((command, commandIndex) => {
-    if (!isRecord17(command) || typeof command.type !== "string") return [];
+    if (!isRecord18(command) || typeof command.type !== "string") return [];
     if (commandTypeSet.has(command.type)) return [];
     return [{
       code: "unknown_command_type",
@@ -55465,32 +56186,32 @@ function findUnknownCommandTypes(input) {
     }];
   });
 }
-function invalidPayloadError(input, issue4) {
-  const commandIndex = commandIndexForIssuePath(issue4.path);
+function invalidPayloadError(input, issue5) {
+  const commandIndex = commandIndexForIssuePath(issue5.path);
   const commandType = commandTypeForIssue(input, commandIndex);
-  const field = formatIssuePath(issue4.path);
+  const field = formatIssuePath(issue5.path);
   return {
     code: "invalid_command_payload",
     commandIndex,
     commandType,
     field,
-    message: `${field}: ${issue4.message}`
+    message: `${field}: ${issue5.message}`
   };
 }
-function commandIndexForIssuePath(path25) {
-  return path25[0] === "commands" && typeof path25[1] === "number" ? path25[1] : -1;
+function commandIndexForIssuePath(path27) {
+  return path27[0] === "commands" && typeof path27[1] === "number" ? path27[1] : -1;
 }
 function commandTypeForIssue(input, commandIndex) {
-  if (!isRecord17(input) || !isUnknownArray3(input.commands)) return null;
+  if (!isRecord18(input) || !isUnknownArray3(input.commands)) return null;
   const command = input.commands[commandIndex];
-  return isRecord17(command) && typeof command.type === "string" ? command.type : null;
+  return isRecord18(command) && typeof command.type === "string" ? command.type : null;
 }
 function isUnknownArray3(value) {
   return Array.isArray(value);
 }
-function formatIssuePath(path25) {
-  if (path25.length === 0) return "<root>";
-  return path25.reduce((formatted, segment) => {
+function formatIssuePath(path27) {
+  if (path27.length === 0) return "<root>";
+  return path27.reduce((formatted, segment) => {
     if (typeof segment === "number") return `${formatted}[${segment}]`;
     if (formatted.length === 0) return String(segment);
     return `${formatted}.${String(segment)}`;
@@ -55728,11 +56449,12 @@ function indexOfferingCommands(batch) {
 function checkTicketPricedEventsHaveTickets(indexes) {
   return indexes.events.flatMap((event) => {
     const tickets = indexes.ticketsByEventRef.get(event.ref) ?? [];
-    if (event.input.pricing.kind !== "ticket_types" || tickets.length > 0) return [];
+    const inlineTickets = event.input.pricing.kind === "ticket_types" ? event.input.pricing.ticketTypes ?? [] : [];
+    if (event.input.pricing.kind !== "ticket_types" || tickets.length + inlineTickets.length > 0) return [];
     return [commandInvariantViolation(
       event.ref,
       "input.pricing",
-      "Events using ticket_types pricing require at least one upsertEventTicketType command."
+      "Events using ticket_types pricing require at least one inline ticket type or upsertEventTicketType command."
     )];
   });
 }
@@ -55740,7 +56462,10 @@ function checkTicketQuantitiesWithinCapacity(indexes) {
   return indexes.events.flatMap((event) => {
     const capacity2 = limitedCapacityQuantity(event.input.capacity);
     if (capacity2 === void 0) return [];
-    const ticketQuantityTotal = (indexes.ticketsByEventRef.get(event.ref) ?? []).reduce((total, ticket) => total + (ticket.input.quantity ?? 0), 0);
+    const ticketQuantityTotal = (indexes.ticketsByEventRef.get(event.ref) ?? []).reduce((total, ticket) => total + (ticket.input.quantity ?? 0), 0) + (event.input.pricing.kind === "ticket_types" ? (event.input.pricing.ticketTypes ?? []).reduce(
+      (total, ticket) => total + (ticket.capacityLimit ?? 0),
+      0
+    ) : 0);
     if (ticketQuantityTotal <= capacity2) return [];
     return [commandInvariantViolation(
       event.ref,
@@ -56155,8 +56880,8 @@ init_src();
 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 issue4(path27, message) {
+  return { path: path27, message };
 }
 function isValidDateParts(year, month, day) {
   const date = new Date(Date.UTC(year, month - 1, day));
@@ -56220,22 +56945,22 @@ function maxDurationMessage(options) {
 function classifyCanonicalSchedule(input, options) {
   const issues = [];
   if (options.requireCanonicalFields && input.recurrenceRule === void 0) {
-    issues.push(issue3(["recurrenceRule"], "recurrenceRule is required"));
+    issues.push(issue4(["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)"));
+    issues.push(issue4(["defaultStartTime"], "Invalid time format (HH:MM or HH:MM:SS)"));
   }
   if (options.requireCanonicalFields && !input.defaultStartTime) {
-    issues.push(issue3(["defaultStartTime"], "defaultStartTime is required"));
+    issues.push(issue4(["defaultStartTime"], "defaultStartTime is required"));
   }
   if (options.requireCanonicalFields && input.durationMinutes === void 0) {
-    issues.push(issue3(["durationMinutes"], "durationMinutes is required"));
+    issues.push(issue4(["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"));
+      issues.push(issue4(["durationMinutes"], "durationMinutes must be at least 1"));
     } else if (exceedsMaxDuration(input.durationMinutes, options)) {
-      issues.push(issue3(["durationMinutes"], maxDurationMessage(options)));
+      issues.push(issue4(["durationMinutes"], maxDurationMessage(options)));
     }
   }
   if (issues.length > 0) return { ok: false, issues };
@@ -56260,34 +56985,34 @@ function classifySdkEventSchedule(input, options = {}) {
     return classifyCanonicalSchedule(input, options);
   }
   if (hasStartsAt && hasCanonicalStart) {
-    issues.push(issue3(["startsAt"], "Use either startsAt or startDate/defaultStartTime, not both"));
+    issues.push(issue4(["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"));
+    issues.push(issue4(["recurrenceRule"], "startsAt schedules are only supported for one-off events"));
   }
   if (!hasStartsAt) {
-    issues.push(issue3(["startsAt"], "startsAt is required when endsAt is provided"));
+    issues.push(issue4(["startsAt"], "startsAt is required when endsAt is provided"));
   }
   if (!hasEndsAt && !hasDateTimeDuration) {
-    issues.push(issue3(["endsAt"], "Provide either endsAt or durationMinutes with startsAt"));
+    issues.push(issue4(["endsAt"], "Provide either endsAt or durationMinutes with startsAt"));
   }
   if (hasEndsAt && hasDateTimeDuration) {
-    issues.push(issue3(["endsAt"], "Use either endsAt or durationMinutes with startsAt, not both"));
+    issues.push(issue4(["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"));
+    issues.push(issue4(["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"));
+    issues.push(issue4(["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"));
+      issues.push(issue4(["endsAt"], "endsAt must be after startsAt and align to a whole minute"));
     } else if (exceedsMaxDuration(durationMinutes, options)) {
-      issues.push(issue3(["endsAt"], maxDurationMessage(options)));
+      issues.push(issue4(["endsAt"], maxDurationMessage(options)));
     }
     if (issues.length === 0 && durationMinutes !== null) {
       return {
@@ -56306,9 +57031,9 @@ function classifySdkEventSchedule(input, options = {}) {
   }
   if (startsAt && hasDateTimeDuration && input.durationMinutes !== void 0 && input.durationMinutes !== null) {
     if (input.durationMinutes < 1) {
-      issues.push(issue3(["durationMinutes"], "durationMinutes must be at least 1"));
+      issues.push(issue4(["durationMinutes"], "durationMinutes must be at least 1"));
     } else if (exceedsMaxDuration(input.durationMinutes, options)) {
-      issues.push(issue3(["durationMinutes"], maxDurationMessage(options)));
+      issues.push(issue4(["durationMinutes"], maxDurationMessage(options)));
     }
     if (issues.length === 0) {
       const endsAtMs = startsAt.epochMs + input.durationMinutes * 6e4;
@@ -56591,10 +57316,10 @@ function eventSeriesCommand(event) {
       categoryIdentifier: event.categoryRef ?? void 0,
       formIdentifier: event.formRef ?? void 0,
       capacity: capacity(event.capacity),
-      pricing: pricing.value,
-      priceDisplay: event.pricing?.priceDisplay ?? void 0,
-      acceptsPasses: event.pricing?.acceptsPasses ?? void 0,
-      acceptsMemberships: event.pricing?.acceptsMemberships ?? void 0,
+      pricing: pricing.value.pricing,
+      priceDisplay: pricing.value.priceDisplay ?? void 0,
+      acceptsPasses: pricing.value.acceptsPasses,
+      acceptsMemberships: pricing.value.acceptsMemberships,
       occurrences: [occurrence.value],
       content: event.content ? {
         summary: event.content.summary ?? void 0,
@@ -56602,6 +57327,7 @@ function eventSeriesCommand(event) {
         image: event.content.image ?? void 0
       } : void 0,
       settings: event.settings,
+      paymentTerms: event.paymentTerms,
       presentation: event.presentation,
       tags: event.tags
     }
@@ -56685,20 +57411,36 @@ function eventPricing(event) {
   }
   switch (pricing.pricing.kind) {
     case "free":
-      return ok({ kind: "free" });
+      return ok({
+        pricing: { kind: "free" },
+        priceDisplay: pricing.pricing.priceDisplay,
+        acceptsPasses: pricing.pricing.acceptsPasses,
+        acceptsMemberships: pricing.pricing.acceptsMemberships
+      });
     case "fixed_price":
       return ok({
-        kind: "fixed_price",
-        price: {
-          amountCents: pricing.pricing.priceAmount,
-          currency: pricing.pricing.priceCurrency
-        }
+        pricing: {
+          kind: "fixed_price",
+          price: {
+            amountCents: pricing.pricing.priceAmount,
+            currency: pricing.pricing.priceCurrency
+          }
+        },
+        priceDisplay: pricing.pricing.priceDisplay,
+        acceptsPasses: pricing.pricing.acceptsPasses,
+        acceptsMemberships: pricing.pricing.acceptsMemberships
       });
     case "ticket_types":
-      return unsupported(
-        event.identifier,
-        `Event ${event.identifier} uses ticket-type pricing; command-backed event pushes do not support ticket types yet.`
-      );
+      return ok({
+        pricing: {
+          kind: "ticket_types",
+          currency: pricing.pricing.priceCurrency,
+          ticketTypes: pricing.pricing.ticketTypes
+        },
+        priceDisplay: pricing.pricing.priceDisplay,
+        acceptsPasses: pricing.pricing.acceptsPasses,
+        acceptsMemberships: pricing.pricing.acceptsMemberships
+      });
     default:
       return assertNever(pricing.pricing);
   }
@@ -56756,6 +57498,9 @@ function eventSeriesUpsertInput(command) {
     schedule: scheduleFromOccurrence(occurrence),
     capacity: capacityLimit(command.input.capacity),
     pricing: eventPricingInput(command.input),
+    ...command.input.paymentTerms === void 0 ? {} : {
+      paymentTerms: command.input.paymentTerms
+    },
     venueRef: command.input.venueIdentifier ?? (command.input.venueRef ? refSlug(command.input.venueRef) : null),
     categoryRef: command.input.categoryIdentifier ?? (command.input.categoryRef ? refSlug(command.input.categoryRef) : null),
     content: eventContentInput(command.input.content),
@@ -56769,8 +57514,8 @@ function eventContentInput(content) {
   if (!content) return void 0;
   return {
     ...content.summary ? { summary: content.summary } : {},
-    ...typeof content.body === "string" || isRecord18(content.body) ? { body: content.body } : {},
-    ...typeof content.image === "string" || isRecord18(content.image) ? { image: content.image } : {}
+    ...typeof content.body === "string" || isRecord19(content.body) ? { body: content.body } : {},
+    ...typeof content.image === "string" || isRecord19(content.image) ? { image: content.image } : {}
   };
 }
 function courseUpsertInput(command) {
@@ -56817,9 +57562,19 @@ function eventPricingInput(input) {
         acceptsMemberships: input.acceptsMemberships ?? false
       };
     case "ticket_types":
-      throw new Error(
-        "Unsupported ticket-type event command reached SDK mapper."
-      );
+      if (!input.pricing.ticketTypes || input.pricing.ticketTypes.length === 0) {
+        throw new Error(
+          "Ticket-type event command is missing inline ticketTypes."
+        );
+      }
+      return {
+        kind: "ticket_types",
+        priceCurrency: input.pricing.currency ?? "USD",
+        priceDisplay: input.priceDisplay ?? null,
+        acceptsPasses: input.acceptsPasses ?? false,
+        acceptsMemberships: input.acceptsMemberships ?? false,
+        ticketTypes: input.pricing.ticketTypes
+      };
     case "manual_payment":
     case "external":
       throw new Error(
@@ -56941,7 +57696,7 @@ function toUtcIso(date, time) {
   const normalizedTime = time.length === 5 ? `${time}:00` : time;
   return (/* @__PURE__ */ new Date(`${date}T${normalizedTime}Z`)).toISOString();
 }
-function isRecord18(value) {
+function isRecord19(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function unsupported(identifier, message) {
@@ -57783,15 +58538,15 @@ function validateBlockContent(data, manifest, customFields) {
     validator.parse(data);
   } catch (error) {
     if (error instanceof ZodError) {
-      for (const issue4 of error.issues) {
-        const fieldPath = issue4.path.join(".");
-        if (issue4.code === "invalid_type" && issue4.received === "undefined") {
+      for (const issue5 of error.issues) {
+        const fieldPath = issue5.path.join(".");
+        if (issue5.code === "invalid_type" && issue5.received === "undefined") {
           continue;
         }
         warnings.push({
           type: "invalid_content",
           field: fieldPath || "(root)",
-          message: `Invalid content${fieldPath ? ` in "${fieldPath}"` : ""}: ${issue4.message}`
+          message: `Invalid content${fieldPath ? ` in "${fieldPath}"` : ""}: ${issue5.message}`
         });
       }
     }
@@ -59227,7 +59982,7 @@ async function handleThemePushForAllScope(params) {
   }
   const validation = themeSchema2.safeParse(localTheme.theme);
   if (!validation.success) {
-    const errors = validation.error.issues.map((issue4) => `  - ${issue4.path.join(".")}: ${issue4.message}`).join("\n");
+    const errors = validation.error.issues.map((issue5) => `  - ${issue5.path.join(".")}: ${issue5.message}`).join("\n");
     output.warn(
       `Skipping theme push - invalid theme at content/themes/${themeName}.json:
 ${errors}`
@@ -59893,7 +60648,7 @@ function firstNestedContainerChange(localChanges, remoteChanges) {
 }
 function firstSameFieldConflictPath(localChanges, remoteChanges) {
   const remotePaths = new Set(remoteChanges.keys());
-  return [...localChanges.keys()].filter((path25) => remotePaths.has(path25)).sort()[0] ?? null;
+  return [...localChanges.keys()].filter((path27) => remotePaths.has(path27)).sort()[0] ?? null;
 }
 function unsupportedNestedMerge(subject, fieldPath) {
   return {
@@ -59975,37 +60730,37 @@ function valueKind(value) {
   if (typeof value === "object") return "object";
   return "scalar";
 }
-function entryChange(path25, value, containerKind) {
+function entryChange(path27, value, containerKind) {
   switch (containerKind) {
     case "array":
-      if (Array.isArray(value)) return { path: path25, value, containerKind };
+      if (Array.isArray(value)) return { path: path27, value, containerKind };
       break;
     case "object":
       if (value && typeof value === "object" && !Array.isArray(value)) {
-        return { path: path25, value, containerKind };
+        return { path: path27, value, containerKind };
       }
       break;
     case "null":
-      if (value === null || value === void 0) return { path: path25, value, containerKind };
+      if (value === null || value === void 0) return { path: path27, value, containerKind };
       break;
     case "scalar":
-      if (isScalarEntryChangeValue(value)) return { path: path25, value, containerKind };
+      if (isScalarEntryChangeValue(value)) return { path: path27, value, containerKind };
       break;
     default:
       assertNever(containerKind);
   }
-  throw new Error(`Invalid entry merge change at ${path25}.`);
+  throw new Error(`Invalid entry merge change at ${path27}.`);
 }
 function isScalarEntryChangeValue(value) {
   return value === void 0 || value === null || ["boolean", "number", "string"].includes(typeof value);
 }
-function expectStringValue(path25, value) {
+function expectStringValue(path27, value) {
   if (typeof value === "string") return value;
-  throw new Error(`Entry merge expected ${path25} to be a string.`);
+  throw new Error(`Entry merge expected ${path27} to be a string.`);
 }
-function expectBooleanValue(path25, value) {
+function expectBooleanValue(path27, value) {
   if (typeof value === "boolean") return value;
-  throw new Error(`Entry merge expected ${path25} to be a boolean.`);
+  throw new Error(`Entry merge expected ${path27} to be a boolean.`);
 }
 function expectStatusValue(value) {
   if (value === "draft" || value === "published") return value;
@@ -60643,6 +61398,19 @@ async function executePushForEnv(output, target, scope, type, identifier, option
     }
     const pushScope = parsedPushScope;
     const jsonOutput = globalOpts.json ?? false;
+    const canonicalEntrySyncDecision = getCanonicalEntrySyncDecision({
+      scope: pushScope,
+      contentType: type,
+      operation: "push"
+    });
+    if (canonicalEntrySyncDecision.tag === "reject") {
+      process.exitCode = 1;
+      output.result(false, canonicalEntrySyncDecision.violation.message, {
+        contentType: canonicalEntrySyncDecision.violation.contentType,
+        suggestion: canonicalEntrySyncDecision.violation.suggestion
+      });
+      return { success: false };
+    }
     const deleteOrphanedEnabled = options.deleteOrphaned ?? false;
     let deleteMissingEnabled = options.deleteMissing ?? false;
     if (deleteMissingEnabled) {
@@ -60713,7 +61481,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((issue4) => `  - ${issue4.path.join(".")}: ${issue4.message}`).join("\n");
+        const errors = validation.error.issues.map((issue5) => `  - ${issue5.path.join(".")}: ${issue5.message}`).join("\n");
         output.error(
           `Invalid theme file at content/themes/${themeName}.json:
 ${errors}`
@@ -60901,8 +61669,16 @@ ${errors}`
       });
       return { success: false };
     }
+    const legacyEventEntryFiles = shouldExcludeCanonicalEntries(canonicalEntrySyncDecision) ? await findLegacyEventEntryFiles(contentDir) : [];
+    if (legacyEventEntryFiles.length > 0) {
+      output.warn(
+        "Legacy event entry files detected and ignored by generic entry sync.",
+        formatLegacyEventEntryWarning(legacyEventEntryFiles)
+      );
+    }
     output.info("Reading local content...");
-    const localContent = normalizeLocalContentShape(await readAllContent(contentDir));
+    const rawLocalContent = normalizeLocalContentShape(await readAllContent(contentDir));
+    const localContent = shouldExcludeCanonicalEntries(canonicalEntrySyncDecision) ? stripCanonicalEventEntriesFromLocalContent(rawLocalContent).content : rawLocalContent;
     if (options.mergeRemote) {
       return planAndReportRemoteEntryMerge({
         output,
@@ -60944,7 +61720,7 @@ ${errors}`
       return { success: true };
     }
     output.info("Fetching remote content for comparison...");
-    const remoteContent = await client.pull.all();
+    const remoteContent = stripCanonicalEventEntriesFromPulledContent(await client.pull.all()).content;
     if (remoteContent.meta.truncated) {
       output.warn("Warning: Remote content was truncated due to size limits.");
       output.warn(
@@ -61227,7 +62003,7 @@ ${errors}`
     if (metadataFlags.shouldUpdateMetadata && !skipMeta) {
       try {
         output.info("Updating local metadata...");
-        const freshRemote = await client.pull.all();
+        const freshRemote = stripCanonicalEventEntriesFromPulledContent(await client.pull.all()).content;
         const entriesForMeta = {};
         if (metadataFlags.willUpdateEntries && freshRemote.meta.entries) {
           for (const [key, meta] of Object.entries(freshRemote.meta.entries)) {
@@ -63006,7 +63782,7 @@ var THEME_FIELD_CATEGORY_MAP = {
 };
 
 // src/cli/init-docs/zod-to-markdown.ts
-function isRecord19(value) {
+function isRecord20(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isZodTypeAny(value) {
@@ -63134,7 +63910,7 @@ function extractLiteralValue(schema) {
   const typeName = getTypeName(schema);
   if (typeName !== ZodTypeName.ZodLiteral) return void 0;
   const def = schema._def;
-  if (!isRecord19(def)) return void 0;
+  if (!isRecord20(def)) return void 0;
   return String(def.value);
 }
 function extractSchemaInfo(schema, skipFields = []) {
@@ -63204,7 +63980,7 @@ function extractFieldInfo(name, schema) {
   }
   if (typeName === ZodTypeName.ZodRecord) {
     const def = inner._def;
-    const valueSchema = isRecord19(def) ? def.valueType : void 0;
+    const valueSchema = isRecord20(def) ? def.valueType : void 0;
     if (!isZodTypeAny(valueSchema)) {
       info.recordValueType = "unknown";
       return info;
@@ -63219,7 +63995,7 @@ function extractFieldInfo(name, schema) {
       }
     } else if (getTypeName(valueInner) === ZodTypeName.ZodRecord) {
       const nestedDef = valueInner._def;
-      const nestedValueSchema = isRecord19(nestedDef) ? nestedDef.valueType : void 0;
+      const nestedValueSchema = isRecord20(nestedDef) ? nestedDef.valueType : void 0;
       if (!isZodTypeAny(nestedValueSchema)) {
         info.recordValueType = "record<string, unknown>";
         return info;
@@ -63230,7 +64006,7 @@ function extractFieldInfo(name, schema) {
   }
   if (typeName === ZodTypeName.ZodUnion || typeName === ZodTypeName.ZodDiscriminatedUnion) {
     const def = inner._def;
-    const optionsValue = isRecord19(def) ? def.options : void 0;
+    const optionsValue = isRecord20(def) ? def.options : void 0;
     const options = Array.isArray(optionsValue) ? optionsValue.filter(isZodTypeAny) : [];
     const optionTypes = options.map((opt) => {
       const { inner: optInner } = unwrapSchema(opt);
@@ -64395,7 +65171,7 @@ var SimpleCache = class {
 };
 
 // src/version.ts
-var SDK_VERSION = "0.84.2";
+var SDK_VERSION = "0.88.0";
 
 // src/client/error.ts
 var RiverbankApiError = class _RiverbankApiError extends Error {
@@ -65339,14 +66115,14 @@ function createRiverbankClient(config2) {
     );
   }
   async function getPageWithResilienceInternal(params) {
-    const { siteId, path: path25, preview = false, signal } = params;
-    const cacheKey = `page:${siteId}:${path25}:${preview}`;
+    const { siteId, path: path27, preview = false, signal } = params;
+    const cacheKey = `page:${siteId}:${path27}:${preview}`;
     return resilientFetch(
       cacheKey,
       async (sig) => {
         return await apiClient({
           endpoint: "getContentByPath",
-          params: { siteId, path: path25, preview: String(preview) },
+          params: { siteId, path: path27, preview: String(preview) },
           options: { signal: sig }
         });
       },
@@ -65354,7 +66130,7 @@ function createRiverbankClient(config2) {
         preview,
         signal,
         // Prebuild fallback only for published pages (not preview)
-        prebuildFallback: prebuildLoader && !preview ? () => prebuildLoader.loadPage(siteId, path25) : void 0
+        prebuildFallback: prebuildLoader && !preview ? () => prebuildLoader.loadPage(siteId, path27) : void 0
       }
     );
   }
@@ -65549,10 +66325,16 @@ function createRiverbankClient(config2) {
         limit,
         from,
         to,
+        afterStartsAt,
+        afterId,
         stage,
         categoryIds,
         venueId,
+        staffMemberId,
         kind,
+        eventSurface,
+        eventPresets,
+        scheduleScope,
         entryId,
         seriesId,
         includeOccurrenceId,
@@ -65561,7 +66343,7 @@ function createRiverbankClient(config2) {
       if (!siteId) {
         throw new Error("listPublicEvents() requires siteId");
       }
-      const cacheKey = `public-events:${siteId}:${limit ?? ""}:${from ?? ""}:${to ?? ""}:${stage ?? ""}:${categoryIds ?? ""}:${venueId ?? ""}:${kind ?? ""}:${entryId ?? ""}:${seriesId ?? ""}:${includeOccurrenceId ?? ""}`;
+      const cacheKey = `public-events:${siteId}:${limit ?? ""}:${from ?? ""}:${to ?? ""}:${afterStartsAt ?? ""}:${afterId ?? ""}:${stage ?? ""}:${categoryIds ?? ""}:${venueId ?? ""}:${staffMemberId ?? ""}:${kind ?? ""}:${eventSurface ?? ""}:${eventPresets ?? ""}:${scheduleScope ?? ""}:${entryId ?? ""}:${seriesId ?? ""}:${includeOccurrenceId ?? ""}`;
       return resilientFetchData(
         cacheKey,
         async (sig) => {
@@ -65570,10 +66352,16 @@ function createRiverbankClient(config2) {
             ...typeof limit === "number" && { limit: String(limit) },
             ...from && { from },
             ...to && { to },
+            ...afterStartsAt && { afterStartsAt },
+            ...afterId && { afterId },
             ...stage && { stage },
             ...categoryIds && { categoryIds },
             ...venueId && { venueId },
+            ...staffMemberId && { staffMemberId },
             ...kind && { kind },
+            ...eventSurface && { eventSurface },
+            ...eventPresets && { eventPresets },
+            ...scheduleScope && { scheduleScope },
             ...entryId && { entryId },
             ...seriesId && { seriesId },
             ...includeOccurrenceId && { includeOccurrenceId }
@@ -65600,6 +66388,9 @@ function createRiverbankClient(config2) {
         venueId,
         staffMemberId,
         kind,
+        eventSurface,
+        eventPresets,
+        scheduleScope,
         entryId,
         seriesId,
         includeOccurrenceId,
@@ -65608,7 +66399,7 @@ function createRiverbankClient(config2) {
       if (!siteId) {
         throw new Error("getPublicEventDetails() requires siteId");
       }
-      const cacheKey = `public-event-details:${siteId}:${limit ?? ""}:${from ?? ""}:${to ?? ""}:${afterStartsAt ?? ""}:${afterId ?? ""}:${stage ?? ""}:${categoryIds ?? ""}:${venueId ?? ""}:${staffMemberId ?? ""}:${kind ?? ""}:${entryId ?? ""}:${seriesId ?? ""}:${includeOccurrenceId ?? ""}`;
+      const cacheKey = `public-event-details:${siteId}:${limit ?? ""}:${from ?? ""}:${to ?? ""}:${afterStartsAt ?? ""}:${afterId ?? ""}:${stage ?? ""}:${categoryIds ?? ""}:${venueId ?? ""}:${staffMemberId ?? ""}:${kind ?? ""}:${eventSurface ?? ""}:${eventPresets ?? ""}:${scheduleScope ?? ""}:${entryId ?? ""}:${seriesId ?? ""}:${includeOccurrenceId ?? ""}`;
       return resilientFetchData(
         cacheKey,
         async (sig) => {
@@ -65631,6 +66422,9 @@ function createRiverbankClient(config2) {
                     ...venueId && { venueId },
                     ...staffMemberId && { staffMemberId },
                     ...kind && { kind },
+                    ...eventSurface && { eventSurface },
+                    ...eventPresets && { eventPresets },
+                    ...scheduleScope && { scheduleScope },
                     ...entryId && { entryId },
                     ...seriesId && { seriesId },
                     ...includeOccurrenceId && { includeOccurrenceId }
@@ -65796,17 +66590,17 @@ function createRiverbankClient(config2) {
       };
     },
     async checkRedirect(params) {
-      const { siteId, path: path25, signal } = params;
-      if (!siteId || !path25) {
+      const { siteId, path: path27, signal } = params;
+      if (!siteId || !path27) {
         throw new Error("checkRedirect() requires siteId and path");
       }
-      const cacheKey = `redirect:${siteId}:${path25}`;
+      const cacheKey = `redirect:${siteId}:${path27}`;
       return resilientFetchData(
         cacheKey,
         async (sig) => {
           return await apiClient({
             endpoint: "checkRedirect",
-            params: { site: siteId, path: path25 },
+            params: { site: siteId, path: path27 },
             options: { signal: sig }
           });
         },
@@ -65883,13 +66677,13 @@ function pathToFilename(routePath) {
   return routePath.slice(1).replace(/[^a-zA-Z0-9\-\/]/g, "_").replace(/\//g, "-") + ".json";
 }
 function ensureDir4(dirPath) {
-  if (!fs10.existsSync(dirPath)) {
-    fs10.mkdirSync(dirPath, { recursive: true });
+  if (!fs11.existsSync(dirPath)) {
+    fs11.mkdirSync(dirPath, { recursive: true });
   }
 }
 function writeJsonFile3(filePath, data) {
   const content = JSON.stringify(data, null, 2);
-  fs10.writeFileSync(filePath, content, "utf-8");
+  fs11.writeFileSync(filePath, content, "utf-8");
   return Buffer.byteLength(content, "utf-8");
 }
 function calculateChecksum(data) {
@@ -66216,7 +67010,7 @@ async function loadDeployConfig() {
 }
 async function checkWorkingDirectoryClean(git, prebuildOutput) {
   const status = await git.status();
-  const dirtyFiles = status.files.map((f) => f.path).filter((path25) => !path25.startsWith(prebuildOutput));
+  const dirtyFiles = status.files.map((f) => f.path).filter((path27) => !path27.startsWith(prebuildOutput));
   return {
     clean: dirtyFiles.length === 0,
     dirtyFiles
@@ -66487,9 +67281,9 @@ Examples:
     const parseResult = verifyConfigSchema.safeParse(rawConfig);
     if (!parseResult.success) {
       return output.error("Invalid config format", {
-        issues: parseResult.error.issues.map((issue4) => ({
-          path: issue4.path.join("."),
-          message: issue4.message
+        issues: parseResult.error.issues.map((issue5) => ({
+          path: issue5.path.join("."),
+          message: issue5.message
         })),
         suggestion: "Ensure your config exports a valid riverbank config object"
       });
@@ -66747,25 +67541,25 @@ function mapMediaGuardDiagnosticsToAuditIssues(diagnostics) {
     }
   }));
 }
-function extractEmbedReferences(data, path25 = []) {
+function extractEmbedReferences(data, path27 = []) {
   const refs = [];
   if (!data || typeof data !== "object") return refs;
   if (Array.isArray(data)) {
     data.forEach((item, index) => {
-      refs.push(...extractEmbedReferences(item, [...path25, String(index)]));
+      refs.push(...extractEmbedReferences(item, [...path27, String(index)]));
     });
     return refs;
   }
   const obj = data;
   if (obj.kind === "embed" && typeof obj.contentType === "string" && typeof obj.identifier === "string") {
     refs.push({
-      path: path25.join("."),
+      path: path27.join("."),
       contentType: obj.contentType,
       identifier: obj.identifier
     });
   }
   for (const [key, value] of Object.entries(obj)) {
-    refs.push(...extractEmbedReferences(value, [...path25, key]));
+    refs.push(...extractEmbedReferences(value, [...path27, key]));
   }
   return refs;
 }
@@ -67017,8 +67811,8 @@ async function executeAuditForEnv(output, target, options, isJsonOutput) {
         client
       });
       const mediaIssues = mapMediaGuardDiagnosticsToAuditIssues(mediaGuardResult.diagnostics);
-      errors.push(...mediaIssues.filter((issue4) => issue4.severity === "error"));
-      warnings.push(...mediaIssues.filter((issue4) => issue4.severity === "warning"));
+      errors.push(...mediaIssues.filter((issue5) => issue5.severity === "error"));
+      warnings.push(...mediaIssues.filter((issue5) => issue5.severity === "warning"));
     }
     if (!isJsonOutput) {
       output.info("Checking for duplicate page paths...");
@@ -67042,8 +67836,8 @@ async function executeAuditForEnv(output, target, options, isJsonOutput) {
     }
     errors.push(...auditEventReferences(localContent.events, auditCtx));
     const courseRefIssues = auditCourseReferences(localContent.courses, auditCtx);
-    errors.push(...courseRefIssues.filter((issue4) => issue4.severity === "error"));
-    warnings.push(...courseRefIssues.filter((issue4) => issue4.severity === "warning"));
+    errors.push(...courseRefIssues.filter((issue5) => issue5.severity === "error"));
+    warnings.push(...courseRefIssues.filter((issue5) => issue5.severity === "warning"));
     const success = errors.length === 0;
     const result = { success, errors, warnings };
     if (isJsonOutput) {
@@ -67058,14 +67852,14 @@ async function executeAuditForEnv(output, target, options, isJsonOutput) {
       output.info("");
       if (errors.length > 0) {
         output.warn(`Found ${errors.length} error(s):`);
-        for (const issue4 of errors) {
-          output.info(`  [ERROR] ${issue4.message}`);
+        for (const issue5 of errors) {
+          output.info(`  [ERROR] ${issue5.message}`);
         }
       }
       if (warnings.length > 0) {
         output.warn(`Found ${warnings.length} warning(s):`);
-        for (const issue4 of warnings) {
-          output.info(`  [WARN] ${issue4.message}`);
+        for (const issue5 of warnings) {
+          output.info(`  [WARN] ${issue5.message}`);
         }
       }
       if (success && warnings.length === 0) {
@@ -67699,7 +68493,7 @@ function formatThemeSummaryForPrompt(summary) {
 }
 
 // src/manifest/validation/layout-utils.ts
-function collectLayoutNodeInfos(node, path25 = "layout", out = []) {
+function collectLayoutNodeInfos(node, path27 = "layout", out = []) {
   if (!node || typeof node !== "object") return out;
   const n = node;
   const type = typeof n.type === "string" ? n.type : "unknown";
@@ -67708,10 +68502,10 @@ function collectLayoutNodeInfos(node, path25 = "layout", out = []) {
     const b = n.$bind;
     if (typeof b.from === "string") bindFrom = b.from;
   }
-  out.push({ path: path25, type, bindFrom });
+  out.push({ path: path27, type, bindFrom });
   if (Array.isArray(n.children)) {
     for (let i = 0; i < n.children.length; i++) {
-      collectLayoutNodeInfos(n.children[i], `${path25}.children[${i}]`, out);
+      collectLayoutNodeInfos(n.children[i], `${path27}.children[${i}]`, out);
     }
   }
   return out;
@@ -68133,7 +68927,7 @@ function extractNestedHrefBindFromProps(props2) {
   const bind2 = href.$bind;
   return bind2 && typeof bind2 === "object" ? bind2 : null;
 }
-function findMissingLinkHrefs(node, blockId, fields3, path25 = "layout", repeatStack = []) {
+function findMissingLinkHrefs(node, blockId, fields3, path27 = "layout", repeatStack = []) {
   const errors = [];
   if (!node || typeof node !== "object") return errors;
   const n = node;
@@ -68162,21 +68956,21 @@ function findMissingLinkHrefs(node, blockId, fields3, path25 = "layout", repeatS
     if (isBoundToLinkField) {
       if (!hrefBind || !hrefFrom) {
         errors.push({
-          path: path25,
-          message: `Block "${blockId}": ${nodeType} node at ${path25} is bound to a link field but is missing props.href binding`,
+          path: path27,
+          message: `Block "${blockId}": ${nodeType} node at ${path27} is bound to a link field but is missing props.href binding`,
           suggestion: `Add props.href: { "$bind": { "from": "${bindFrom ?? "content.yourLinkField"}", "fallback": null, "transforms": [{ "id": "links.resolve" }] } }`
         });
       } else if (!bindingHasTransform(hrefBind, "links.resolve")) {
         errors.push({
-          path: path25,
-          message: `Block "${blockId}": ${nodeType} node at ${path25} has props.href binding but is missing transforms: [{id:"links.resolve"}]`,
+          path: path27,
+          message: `Block "${blockId}": ${nodeType} node at ${path27} has props.href binding but is missing transforms: [{id:"links.resolve"}]`,
           suggestion: `Set props.href.$bind.transforms to [{ "id": "links.resolve" }].`
         });
       }
       if (bindFrom && bindFieldType === "link" && !bindingHasTransform(bind2, "links.label")) {
         errors.push({
-          path: path25,
-          message: `Block "${blockId}": ${nodeType} node at ${path25} binds label from a link field but is missing links.label transform`,
+          path: path27,
+          message: `Block "${blockId}": ${nodeType} node at ${path27} binds label from a link field but is missing links.label transform`,
           suggestion: `Set node.$bind.transforms to [{ "id": "links.label" }] so the label renders as text.`
         });
       }
@@ -68189,7 +68983,7 @@ function findMissingLinkHrefs(node, blockId, fields3, path25 = "layout", repeatS
           n.children[i],
           blockId,
           fields3,
-          `${path25}.children[${i}]`,
+          `${path27}.children[${i}]`,
           nextRepeatStack
         )
       );
@@ -68197,7 +68991,7 @@ function findMissingLinkHrefs(node, blockId, fields3, path25 = "layout", repeatS
   }
   return errors;
 }
-function detectRedundantLinkLabels(node, blockId, fields3, path25 = "layout", repeatStack = []) {
+function detectRedundantLinkLabels(node, blockId, fields3, path27 = "layout", repeatStack = []) {
   const errors = [];
   if (!node || typeof node !== "object") return errors;
   const n = node;
@@ -68219,7 +69013,7 @@ function detectRedundantLinkLabels(node, blockId, fields3, path25 = "layout", re
     const redundancies = findRedundantLinkTextSiblings(
       children,
       nextRepeatStack,
-      path25
+      path27
     );
     errors.push(
       ...redundancies.map((r) => ({
@@ -68236,7 +69030,7 @@ function detectRedundantLinkLabels(node, blockId, fields3, path25 = "layout", re
           n.children[i],
           blockId,
           fields3,
-          `${path25}.children[${i}]`,
+          `${path27}.children[${i}]`,
           nextRepeatStack
         )
       );
@@ -68475,19 +69269,19 @@ function extractBlockIdFromSelector(selector) {
   const match = selector.match(/\[data-block=(["'])(custom\.[^"']+)\1\]/);
   return match?.[2] ?? null;
 }
-function validateNodeType(nodeType, path25, ctx) {
+function validateNodeType(nodeType, path27, ctx) {
   if (!ALLOWED_NODE_TYPES.includes(
     nodeType
   )) {
     return {
-      path: `${path25}.type`,
-      message: `Block "${ctx.blockId}": Unknown node type "${nodeType}" at ${path25}`,
+      path: `${path27}.type`,
+      message: `Block "${ctx.blockId}": Unknown node type "${nodeType}" at ${path27}`,
       suggestion: `ALLOWED: ${ALLOWED_NODE_TYPES.slice(0, 10).join(", ")}... FIX: Replace "${nodeType}" with a valid node type.`
     };
   }
   return null;
 }
-function validateTransforms(transforms, path25, ctx) {
+function validateTransforms(transforms, path27, ctx) {
   const errors = [];
   for (let i = 0; i < transforms.length; i++) {
     const transform = transforms[i];
@@ -68496,7 +69290,7 @@ function validateTransforms(transforms, path25, ctx) {
         transform.id
       )) {
         errors.push({
-          path: `${path25}.transforms[${i}].id`,
+          path: `${path27}.transforms[${i}].id`,
           message: `Block "${ctx.blockId}": Unknown transform "${transform.id}"`,
           suggestion: `ALLOWED: ${ALLOWED_TRANSFORM_IDS.slice(0, 8).join(", ")}... FIX: Replace with a valid transform ID or remove.`
         });
@@ -68505,7 +69299,7 @@ function validateTransforms(transforms, path25, ctx) {
   }
   return errors;
 }
-function validateBinding(bind2, path25, ctx) {
+function validateBinding(bind2, path27, ctx) {
   const errors = [];
   if ("from" in bind2 && typeof bind2.from === "string") {
     const bindPath = bind2.from;
@@ -68513,7 +69307,7 @@ function validateBinding(bind2, path25, ctx) {
       const fieldId = bindPath.replace("content.", "").split(".")[0] ?? "";
       if (fieldId && !ctx.fieldIds.has(fieldId)) {
         errors.push({
-          path: `${path25}.from`,
+          path: `${path27}.from`,
           message: `Block "${ctx.blockId}": $bind references unknown field "${fieldId}"`,
           suggestion: `DEFINED FIELDS: ${Array.from(ctx.fieldIds).join(", ")}. FIX: Add field { id: '${fieldId}', type: '...' } or use existing field.`
         });
@@ -68521,31 +69315,31 @@ function validateBinding(bind2, path25, ctx) {
     }
   }
   if ("transforms" in bind2 && Array.isArray(bind2.transforms)) {
-    errors.push(...validateTransforms(bind2.transforms, path25, ctx));
+    errors.push(...validateTransforms(bind2.transforms, path27, ctx));
   }
   return errors;
 }
-function validateLayoutDeep(node, blockId, fields3, path25 = "layout") {
+function validateLayoutDeep(node, blockId, fields3, path27 = "layout") {
   const ctx = {
     blockId,
     fieldIds: collectFieldIds(fields3)
   };
-  return validateLayoutNode(node, path25, ctx);
+  return validateLayoutNode(node, path27, ctx);
 }
-function validateLayoutNode(node, path25, ctx) {
+function validateLayoutNode(node, path27, ctx) {
   const errors = [];
   if (!node || typeof node !== "object") {
     return errors;
   }
   const n = node;
   if ("type" in n && typeof n.type === "string") {
-    const typeError = validateNodeType(n.type, path25, ctx);
+    const typeError = validateNodeType(n.type, path27, ctx);
     if (typeError) errors.push(typeError);
   }
   if ("$bind" in n && n.$bind && typeof n.$bind === "object") {
     const bindErrors = validateBinding(
       n.$bind,
-      `${path25}.$bind`,
+      `${path27}.$bind`,
       ctx
     );
     errors.push(...bindErrors);
@@ -68553,7 +69347,7 @@ function validateLayoutNode(node, path25, ctx) {
   if ("props" in n && n.props && typeof n.props === "object") {
     const propsErrors = validatePropsBindings(
       n.props,
-      `${path25}.props`,
+      `${path27}.props`,
       ctx
     );
     errors.push(...propsErrors);
@@ -68562,7 +69356,7 @@ function validateLayoutNode(node, path25, ctx) {
     for (let i = 0; i < n.children.length; i++) {
       const childErrors = validateLayoutNode(
         n.children[i],
-        `${path25}.children[${i}]`,
+        `${path27}.children[${i}]`,
         ctx
       );
       errors.push(...childErrors);
@@ -68570,17 +69364,17 @@ function validateLayoutNode(node, path25, ctx) {
   }
   return errors;
 }
-function validatePropsBindings(props2, path25, ctx) {
+function validatePropsBindings(props2, path27, ctx) {
   const errors = [];
   for (const [key, value] of Object.entries(props2)) {
     if (value && typeof value === "object" && "$bind" in value) {
       const bind2 = value.$bind;
-      const bindErrors = validateBinding(bind2, `${path25}.${key}.$bind`, ctx);
+      const bindErrors = validateBinding(bind2, `${path27}.${key}.$bind`, ctx);
       errors.push(...bindErrors);
     } else if (value && typeof value === "object" && !Array.isArray(value)) {
       const nestedErrors = validatePropsBindings(
         value,
-        `${path25}.${key}`,
+        `${path27}.${key}`,
         ctx
       );
       errors.push(...nestedErrors);
@@ -68713,7 +69507,7 @@ function collectUsedFieldRefs(node) {
   visit(node, []);
   return { topLevel, nestedByRepeater, itemNameByRepeater };
 }
-function findMissingBindings(node, blockId, path25 = "layout") {
+function findMissingBindings(node, blockId, path27 = "layout") {
   const errors = [];
   if (!node || typeof node !== "object") {
     return errors;
@@ -68723,15 +69517,15 @@ function findMissingBindings(node, blockId, path25 = "layout") {
   if ("$repeat" in n && n.$repeat && typeof n.$repeat === "object") {
     if (nodeType && CONTENT_NODE_TYPES.includes(nodeType)) {
       errors.push({
-        path: path25,
-        message: `Block "${blockId}": ${nodeType} node at ${path25} uses $repeat, but content nodes cannot be repeat containers`,
+        path: path27,
+        message: `Block "${blockId}": ${nodeType} node at ${path27} uses $repeat, but content nodes cannot be repeat containers`,
         suggestion: `Move $repeat to a container node (grid/stack/div) and put a ${nodeType} child inside with $bind.from like "item.field".`
       });
     }
     if (!Array.isArray(n.children) || n.children.length === 0) {
       errors.push({
-        path: path25,
-        message: `Block "${blockId}": node at ${path25} uses $repeat but has no children to repeat`,
+        path: path27,
+        message: `Block "${blockId}": node at ${path27} uses $repeat but has no children to repeat`,
         suggestion: 'Add one or more child nodes under children[] that bind to the repeat item (e.g., $bind.from: "item.text").'
       });
     }
@@ -68740,15 +69534,15 @@ function findMissingBindings(node, blockId, path25 = "layout") {
     const hasBind = "$bind" in n && n.$bind && typeof n.$bind === "object" && "from" in n.$bind;
     if (Array.isArray(n.children) && n.children.length > 0) {
       errors.push({
-        path: path25,
-        message: `Block "${blockId}": ${nodeType} node at ${path25} has children, but content nodes must have children: null`,
+        path: path27,
+        message: `Block "${blockId}": ${nodeType} node at ${path27} has children, but content nodes must have children: null`,
         suggestion: `Replace this ${nodeType} with a container node (div/stack/inline) and put the ${nodeType} nodes inside it.`
       });
     }
     if (!hasBind) {
       errors.push({
-        path: `${path25}`,
-        message: `Block "${blockId}": ${nodeType} node at ${path25} has no $bind - it won't display any content`,
+        path: `${path27}`,
+        message: `Block "${blockId}": ${nodeType} node at ${path27} has no $bind - it won't display any content`,
         suggestion: `Add $bind: { from: "content.fieldName" } to connect this ${nodeType} to a field. Example: { "type": "${nodeType}", "$bind": { "from": "content.headline" } }`
       });
     }
@@ -68758,7 +69552,7 @@ function findMissingBindings(node, blockId, path25 = "layout") {
       const childErrors = findMissingBindings(
         n.children[i],
         blockId,
-        `${path25}.children[${i}]`
+        `${path27}.children[${i}]`
       );
       errors.push(...childErrors);
     }
@@ -68775,13 +69569,13 @@ function getMaxDepth(node, currentDepth = 0) {
   );
 }
 var CONTAINER_NODE_TYPES = ["section", "stack", "grid", "div", "inline"];
-function detectPotentialTruncation(node, maxAllowedDepth, currentDepth = 0, path25 = "layout") {
+function detectPotentialTruncation(node, maxAllowedDepth, currentDepth = 0, path27 = "layout") {
   if (!node || typeof node !== "object") return [];
   const n = node;
   const truncatedPaths = [];
   if (currentDepth === maxAllowedDepth && n.children === null) {
     if (CONTAINER_NODE_TYPES.includes(n.type || "")) {
-      truncatedPaths.push(`${path25} (${n.type ?? "node"} at depth ${currentDepth})`);
+      truncatedPaths.push(`${path27} (${n.type ?? "node"} at depth ${currentDepth})`);
     }
   }
   if (n.children && Array.isArray(n.children)) {
@@ -68791,7 +69585,7 @@ function detectPotentialTruncation(node, maxAllowedDepth, currentDepth = 0, path
           child,
           maxAllowedDepth,
           currentDepth + 1,
-          `${path25}.children[${i}]`
+          `${path27}.children[${i}]`
         )
       );
     });
@@ -68811,8 +69605,8 @@ function formatValidationFeedback(errors, output) {
         `The layout reached the maximum depth of ${MAX_LAYOUT_DEPTH} levels.`
       );
       lines.push("These container nodes at the depth limit have no children:");
-      for (const path25 of truncatedPaths) {
-        lines.push(`  \u26A0\uFE0F ${path25}`);
+      for (const path27 of truncatedPaths) {
+        lines.push(`  \u26A0\uFE0F ${path27}`);
       }
       lines.push("");
       lines.push(
@@ -69121,11 +69915,12 @@ Your task: Analyze the HTML/JSX markup and identify ALL pieces of content that s
 
 1. **Use richText for formatted lists and multi-line content:**
    - Opening hours \u2192 single richText with formatted list (not 6 separate text fields)
-   - Address with line breaks \u2192 single richText (not address1, address2, city, postcode)
+   - Address with line breaks \u2192 single richText with hard line breaks / Shift+Enter between lines (not address1, address2, city, postcode)
    - Feature lists, specs, ingredients \u2192 richText with bullet list
 
-   RichText supports: paragraphs, bold, italic, bullet lists, numbered lists, links.
+   RichText supports: paragraphs, hard line breaks, bold, italic, bullet lists, numbered lists, links.
    The CMS editor can format content naturally without rigid field structure.
+   For line-oriented content like addresses, opening hours, and contact details, keep one logical paragraph and use hard line breaks between lines. In the CMS editor, authors create those line breaks with Shift+Enter; Enter creates a new paragraph.
 
 2. **Use repeaters only when items need individual editing/reordering:**
    - Testimonials with avatar + name + quote \u2192 repeater (each item is distinct)
@@ -69137,8 +69932,8 @@ Your task: Analyze the HTML/JSX markup and identify ALL pieces of content that s
    \u274C socialInstagram, socialFacebook, socialTwitter (proliferating similar fields)
    \u274C address1, address2, city, state, zip (5 fields for one address)
 
-   \u2705 openingHours: single richText field with formatted content
-   \u2705 address: single richText field with line breaks
+   \u2705 openingHours: single richText field with formatted content / hard line breaks
+   \u2705 address: single richText field with hard line breaks (Shift+Enter in the editor)
    \u2705 socialLinks: repeater with { platform, url } IF user needs to add/remove links
 
 ## Field Type Rules
@@ -69168,7 +69963,7 @@ Your task: Analyze the HTML/JSX markup and identify ALL pieces of content that s
 
 ### When to use each type:
 - Single value \u2192 simple field (text, richText, media, link)
-- Formatted list where structure is static \u2192 richText (opening hours, address)
+- Formatted list where structure is static \u2192 richText (opening hours, address; use hard line breaks / Shift+Enter for line-oriented text)
 - List where items can be added/removed/reordered \u2192 repeater
 - Related fields that belong together \u2192 group
 
@@ -69274,11 +70069,11 @@ var pass3bOutputSchema = z.object({
   customCssAtRules: z.array(llmMediaAtRuleSchema).nullable(),
   rationale: z.string()
 });
-function getNodeAtPath(layout, path25) {
-  if (path25 === "" || path25 === "root" || path25 === "layout") {
+function getNodeAtPath(layout, path27) {
+  if (path27 === "" || path27 === "root" || path27 === "layout") {
     return layout;
   }
-  let normalizedPath = path25;
+  let normalizedPath = path27;
   if (normalizedPath.startsWith("layout.")) {
     normalizedPath = normalizedPath.slice(7);
   }
@@ -69580,43 +70375,8 @@ Do NOT include [data-block=...] in selectors - we add that automatically.
 var DEFAULT_MANIFEST_MODEL = process.env.RIVERBANK_MANIFEST_MODEL || "gpt-5-mini";
 
 // src/manifest/three-pass-converter.ts
-function parseInlineMarkdown(text2) {
-  const out = [];
-  const pushText = (value, marks) => {
-    if (!value) return;
-    out.push(
-      marks && marks.length > 0 ? { type: "text", text: value, marks } : { type: "text", text: value }
-    );
-  };
-  let rest = text2;
-  while (rest.length > 0) {
-    const start = rest.indexOf("**");
-    if (start === -1) {
-      pushText(rest);
-      break;
-    }
-    const end = rest.indexOf("**", start + 2);
-    if (end === -1) {
-      pushText(rest);
-      break;
-    }
-    pushText(rest.slice(0, start));
-    pushText(rest.slice(start + 2, end), [{ type: "bold" }]);
-    rest = rest.slice(end + 2);
-  }
-  return out;
-}
 function stringToTipTapDoc(text2) {
-  const normalized = text2.replace(/\r\n/g, "\n").trim();
-  if (!normalized) return { type: "doc", content: [] };
-  const paragraphs = normalized.split(/\n{2,}/).map((p) => p.trim()).filter(Boolean);
-  return {
-    type: "doc",
-    content: paragraphs.map((p) => {
-      const inline2 = parseInlineMarkdown(p);
-      return inline2.length > 0 ? { type: "paragraph", content: inline2 } : { type: "paragraph" };
-    })
-  };
+  return createRichTextDocFromMarkdown(text2);
 }
 function coerceRichTextDefaultValue(value) {
   if (value === null || value === void 0) {
@@ -70976,6 +71736,26 @@ var eventPricingInputSchema = z.unknown().superRefine((pricing, ctx) => {
   }
   return result.pricing;
 });
+var eventPaymentTermsInputSchema = z.unknown().superRefine((paymentTerms, ctx) => {
+  const result = classifySdkEventPaymentTerms(paymentTerms);
+  if (!result.ok) {
+    result.issues.forEach((validationIssue) => {
+      ctx.addIssue({
+        code: "custom",
+        path: [...validationIssue.path],
+        message: validationIssue.message
+      });
+    });
+  }
+}).transform((paymentTerms) => {
+  const result = classifySdkEventPaymentTerms(paymentTerms);
+  if (!result.ok) {
+    throw new Error(
+      "Unreachable invalid event paymentTerms after Zod validation"
+    );
+  }
+  return result.paymentTerms;
+});
 var eventUpsertInputSchema = z.object({
   identifier: z.string().min(1).optional(),
   title: z.string().min(1, "title is required"),
@@ -70985,6 +71765,7 @@ var eventUpsertInputSchema = z.object({
   schedule: eventScheduleInputSchema,
   capacity: z.number().int().positive().nullable().optional(),
   pricing: eventPricingInputSchema.optional(),
+  paymentTerms: eventPaymentTermsInputSchema.optional(),
   venueRef: z.string().nullable().optional(),
   categoryRef: z.string().nullable().optional(),
   content: z.record(z.string(), z.unknown()).optional(),
@@ -71068,6 +71849,7 @@ var getCommand5 = createGetCommand({
     schedule: event.schedule,
     capacity: event.capacity,
     pricing: event.pricing,
+    paymentTerms: event.paymentTerms,
     venueRef: event.venueRef,
     categoryRef: event.categoryRef,
     formRef: event.formRef,
@@ -71462,8 +72244,485 @@ async function migrateEntries(options) {
     legacyTitlesMigratedToDataTitle
   };
 }
+var LEGACY_DATA_FIELDS = /* @__PURE__ */ new Set([
+  "title",
+  "slug",
+  "routeSlug",
+  "path",
+  "summary",
+  "body",
+  "image",
+  "cardTitleOverride",
+  "presentation"
+]);
+function isRecord21(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasMeaningfulValue(value) {
+  if (value === void 0 || value === null) return false;
+  if (typeof value === "string") return value.trim().length > 0;
+  if (Array.isArray(value)) return value.length > 0;
+  if (isRecord21(value)) return Object.keys(value).length > 0;
+  return true;
+}
+function normalizeComparable(value) {
+  if (value === void 0 || value === null) return null;
+  if (Array.isArray(value)) return value.map(normalizeComparable);
+  if (!isRecord21(value)) return value;
+  const normalized = {};
+  for (const key of Object.keys(value).sort()) {
+    const normalizedValue = normalizeComparable(value[key]);
+    if (normalizedValue !== null) {
+      normalized[key] = normalizedValue;
+    }
+  }
+  return normalized;
+}
+function valuesMatch(a, b) {
+  return equal(normalizeComparable(a), normalizeComparable(b));
+}
+function slugFromPath(value) {
+  const trimmed = value.trim().replace(/\/+$/, "");
+  const parts = trimmed.split("/").filter(Boolean);
+  return parts.at(-1) ?? trimmed;
+}
+function legacySlugCandidates(legacy) {
+  const candidates = /* @__PURE__ */ new Set();
+  const data = isRecord21(legacy.entry.data) ? legacy.entry.data : {};
+  for (const value of [
+    legacy.entry.slug,
+    data.slug,
+    data.routeSlug,
+    data.path,
+    legacy.entry.identifier,
+    legacy.fileBaseIdentifier
+  ]) {
+    if (typeof value !== "string" || value.trim().length === 0) continue;
+    candidates.add(value.includes("/") ? slugFromPath(value) : value.trim());
+  }
+  return [...candidates];
+}
+async function readLegacyEventEntries(contentDir) {
+  const legacyDir = path5.join(contentDir, "entries", CANONICAL_EVENT_ENTRY_TYPE);
+  const files = await listFiles(legacyDir, ".json");
+  files.sort();
+  const entries = [];
+  for (const filePath of files) {
+    const raw = await readJsonFile(filePath);
+    if (!isRecord21(raw)) {
+      entries.push({
+        tag: "invalid",
+        filePath,
+        reason: "Legacy event entry file must be a JSON object."
+      });
+      continue;
+    }
+    if (!isRecord21(raw.data)) {
+      entries.push({
+        tag: "invalid",
+        filePath,
+        reason: "Legacy event entry file must include an object data field."
+      });
+      continue;
+    }
+    const identifier = typeof raw.identifier === "string" && raw.identifier.trim() ? raw.identifier : path5.basename(filePath, ".json");
+    entries.push({
+      tag: "valid",
+      legacy: {
+        filePath,
+        fileBaseIdentifier: path5.basename(filePath, ".json"),
+        entry: { ...raw, identifier, data: raw.data }
+      }
+    });
+  }
+  return entries;
+}
+async function readCanonicalEventsWithPaths(contentDir) {
+  const eventsDir = path5.join(contentDir, "events");
+  const files = await listFiles(eventsDir, ".json");
+  files.sort();
+  const events = [];
+  for (const filePath of files) {
+    const event = await readJsonFile(filePath);
+    events.push({ event, filePath });
+  }
+  return events;
+}
+function findCandidateEvents(legacy, eventsByIdentifier, eventsBySlug) {
+  const byIdentifier = eventsByIdentifier.get(legacy.entry.identifier);
+  if (byIdentifier) return [byIdentifier];
+  const candidates = /* @__PURE__ */ new Map();
+  for (const slug of legacySlugCandidates(legacy)) {
+    for (const event of eventsBySlug.get(slug) ?? []) {
+      candidates.set(event.identifier, event);
+    }
+  }
+  return [...candidates.values()];
+}
+function mergeValue(input) {
+  if (!hasMeaningfulValue(input.incoming)) {
+    return { tag: "ignored" };
+  }
+  if (!hasMeaningfulValue(input.current)) {
+    return { tag: "changed", event: input.set(input.incoming), field: input.path };
+  }
+  if (valuesMatch(input.current, input.incoming)) {
+    return { tag: "unchanged" };
+  }
+  return { tag: "conflict", field: input.path };
+}
+function mergeLegacyEventIntoCanonical(legacy, event) {
+  const data = legacy.entry.data;
+  const unmappableFields = [];
+  for (const key of Object.keys(data)) {
+    if (!LEGACY_DATA_FIELDS.has(key) && hasMeaningfulValue(data[key])) {
+      unmappableFields.push(`data.${key}`);
+    }
+  }
+  if (legacy.entry.blocks && Object.keys(legacy.entry.blocks).length > 0) {
+    unmappableFields.push("blocks");
+  }
+  if (unmappableFields.length > 0) {
+    return { tag: "unmappable", fields: unmappableFields.sort() };
+  }
+  let mergedEvent = event;
+  const mergedFields = [];
+  const conflicts = [];
+  const compareOnlyFields = [
+    ["title", event.title, data.title],
+    ["slug", event.slug, legacy.entry.slug ?? data.slug ?? data.routeSlug ?? data.path]
+  ];
+  for (const [fieldPath, current, incoming] of compareOnlyFields) {
+    if (!hasMeaningfulValue(incoming)) continue;
+    const normalizedIncoming = fieldPath === "slug" && typeof incoming === "string" ? slugFromPath(incoming) : incoming;
+    if (!valuesMatch(current, normalizedIncoming)) {
+      conflicts.push(fieldPath);
+    }
+  }
+  const mergeTargets = [
+    {
+      path: "content.summary",
+      current: event.content?.summary,
+      incoming: data.summary,
+      set: (value) => ({ ...mergedEvent, content: { ...mergedEvent.content, summary: value } })
+    },
+    {
+      path: "content.body",
+      current: event.content?.body,
+      incoming: data.body,
+      set: (value) => ({
+        ...mergedEvent,
+        content: { ...mergedEvent.content, body: value }
+      })
+    },
+    {
+      path: "content.image",
+      current: event.content?.image,
+      incoming: data.image,
+      set: (value) => ({
+        ...mergedEvent,
+        content: { ...mergedEvent.content, image: value }
+      })
+    },
+    {
+      path: "presentation.cardTitleOverride",
+      current: event.presentation?.cardTitleOverride,
+      incoming: data.cardTitleOverride,
+      set: (value) => ({
+        ...mergedEvent,
+        presentation: {
+          ...mergedEvent.presentation,
+          cardTitleOverride: value
+        }
+      })
+    }
+  ];
+  for (const target of mergeTargets) {
+    const result = mergeValue({ ...target, event: mergedEvent });
+    if (result.tag === "changed") {
+      mergedEvent = result.event;
+      mergedFields.push(result.field);
+    } else if (result.tag === "conflict") {
+      conflicts.push(result.field);
+    }
+  }
+  if (hasMeaningfulValue(data.presentation)) {
+    if (!isRecord21(data.presentation)) {
+      return { tag: "unmappable", fields: ["data.presentation"] };
+    }
+    for (const [key, value] of Object.entries(data.presentation)) {
+      const fieldPath = `presentation.${key}`;
+      const result = mergeValue({
+        event: mergedEvent,
+        path: fieldPath,
+        current: mergedEvent.presentation?.[key],
+        incoming: value,
+        set: (nextValue) => ({
+          ...mergedEvent,
+          presentation: { ...mergedEvent.presentation, [key]: nextValue }
+        })
+      });
+      if (result.tag === "changed") {
+        mergedEvent = result.event;
+        mergedFields.push(result.field);
+      } else if (result.tag === "conflict") {
+        conflicts.push(result.field);
+      }
+    }
+  }
+  return {
+    tag: "merged",
+    event: mergedEvent,
+    fields: mergedFields,
+    conflicts
+  };
+}
+async function planEventMigration(contentDir) {
+  const legacyReadResults = await readLegacyEventEntries(contentDir);
+  const invalidLegacyItems = legacyReadResults.filter((result) => result.tag === "invalid").map((result) => ({
+    tag: "invalidLegacyShape",
+    legacyFilePath: result.filePath,
+    reason: result.reason
+  }));
+  const legacyEntries = legacyReadResults.filter((result) => result.tag === "valid").map((result) => result.legacy);
+  const canonicalEvents = await readCanonicalEventsWithPaths(contentDir);
+  const eventFilePaths = new Map(canonicalEvents.map(({ event, filePath }) => [event.identifier, filePath]));
+  const eventsByIdentifier = new Map(canonicalEvents.map(({ event }) => [event.identifier, event]));
+  const eventsBySlug = /* @__PURE__ */ new Map();
+  for (const { event } of canonicalEvents) {
+    const existing = eventsBySlug.get(event.slug) ?? [];
+    eventsBySlug.set(event.slug, [...existing, event]);
+  }
+  const matches = legacyEntries.map((legacy) => ({
+    legacy,
+    candidates: findCandidateEvents(legacy, eventsByIdentifier, eventsBySlug)
+  }));
+  const eventMatchCounts = /* @__PURE__ */ new Map();
+  for (const match of matches) {
+    if (match.candidates.length === 1) {
+      const candidate = match.candidates[0];
+      if (!candidate) continue;
+      eventMatchCounts.set(candidate.identifier, (eventMatchCounts.get(candidate.identifier) ?? 0) + 1);
+    }
+  }
+  const items = [...invalidLegacyItems];
+  for (const match of matches) {
+    if (match.candidates.length === 0) {
+      items.push({
+        tag: "orphanedLegacy",
+        legacyFilePath: match.legacy.filePath,
+        legacyIdentifier: match.legacy.entry.identifier,
+        reason: "No canonical content/events/*.json payload matched by identifier, slug, or route slug."
+      });
+      continue;
+    }
+    if (match.candidates.length > 1) {
+      items.push({
+        tag: "ambiguousMatch",
+        legacyFilePath: match.legacy.filePath,
+        candidateEventIdentifiers: match.candidates.map((event2) => event2.identifier).sort()
+      });
+      continue;
+    }
+    const event = match.candidates[0];
+    if (!event) {
+      items.push({
+        tag: "orphanedLegacy",
+        legacyFilePath: match.legacy.filePath,
+        legacyIdentifier: match.legacy.entry.identifier,
+        reason: "No canonical content/events/*.json payload matched by identifier, slug, or route slug."
+      });
+      continue;
+    }
+    if ((eventMatchCounts.get(event.identifier) ?? 0) > 1) {
+      items.push({
+        tag: "ambiguousMatch",
+        legacyFilePath: match.legacy.filePath,
+        candidateEventIdentifiers: [event.identifier]
+      });
+      continue;
+    }
+    const mergePlan = mergeLegacyEventIntoCanonical(match.legacy, event);
+    if (mergePlan.tag === "unmappable") {
+      items.push({
+        tag: "unmappableLegacyFields",
+        legacyFilePath: match.legacy.filePath,
+        eventIdentifier: event.identifier,
+        fields: mergePlan.fields
+      });
+      continue;
+    }
+    if (mergePlan.conflicts.length > 0) {
+      items.push({
+        tag: "conflict",
+        legacyFilePath: match.legacy.filePath,
+        eventIdentifier: event.identifier,
+        conflicts: mergePlan.conflicts
+      });
+      continue;
+    }
+    const eventFilePath = eventFilePaths.get(event.identifier) ?? path5.join(contentDir, "events", `${event.identifier}.json`);
+    if (mergePlan.fields.length === 0) {
+      items.push({
+        tag: "archiveLegacyOnly",
+        legacyFilePath: match.legacy.filePath,
+        eventFilePath,
+        eventIdentifier: event.identifier,
+        reason: "Legacy event entry copy already matches canonical event payload."
+      });
+    } else {
+      items.push({
+        tag: "mergeLegacyIntoEvent",
+        legacyFilePath: match.legacy.filePath,
+        eventFilePath,
+        eventIdentifier: event.identifier,
+        mergedEvent: mergePlan.event,
+        mergedFields: mergePlan.fields
+      });
+    }
+  }
+  const blockers = items.filter(isBlockedPlanItem);
+  if (blockers.length > 0) {
+    return { tag: "blocked", contentDir, items, blockers };
+  }
+  return { tag: "writable", contentDir, items: items.filter(isWritablePlanItem) };
+}
+function isWritablePlanItem(item) {
+  return item.tag === "mergeLegacyIntoEvent" || item.tag === "archiveLegacyOnly";
+}
+function isBlockedPlanItem(item) {
+  return !isWritablePlanItem(item);
+}
+async function archiveLegacyFile(contentDir, legacyFilePath) {
+  const archiveDir = path5.join(contentDir, ".legacy", "entries", CANONICAL_EVENT_ENTRY_TYPE);
+  await ensureDir(archiveDir);
+  const destinationPath = path5.join(archiveDir, path5.basename(legacyFilePath));
+  if (!await fileExists(destinationPath)) {
+    await fs5.rename(legacyFilePath, destinationPath);
+    return;
+  }
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const ext = path5.extname(destinationPath);
+  const base = destinationPath.slice(0, -ext.length);
+  await fs5.rename(legacyFilePath, `${base}.${timestamp}${ext}`);
+}
+async function migrateEvents(options) {
+  const plan = await planEventMigration(options.contentDir);
+  const summary = {
+    merged: 0,
+    archiveOnly: 0,
+    conflicts: 0,
+    ambiguous: 0,
+    unmappable: 0,
+    orphaned: 0,
+    invalid: 0
+  };
+  let eventsToWrite = 0;
+  let legacyFilesToArchive = 0;
+  for (const item of plan.items) {
+    switch (item.tag) {
+      case "mergeLegacyIntoEvent":
+        summary.merged += 1;
+        if (plan.tag === "writable" && !options.dryRun) {
+          await writeJsonFile(item.eventFilePath, item.mergedEvent);
+          await archiveLegacyFile(options.contentDir, item.legacyFilePath);
+        }
+        if (plan.tag === "writable") {
+          eventsToWrite += 1;
+          legacyFilesToArchive += 1;
+        }
+        break;
+      case "archiveLegacyOnly":
+        summary.archiveOnly += 1;
+        if (plan.tag === "writable" && !options.dryRun) {
+          await archiveLegacyFile(options.contentDir, item.legacyFilePath);
+        }
+        if (plan.tag === "writable") {
+          legacyFilesToArchive += 1;
+        }
+        break;
+      case "conflict":
+        summary.conflicts += 1;
+        break;
+      case "ambiguousMatch":
+        summary.ambiguous += 1;
+        break;
+      case "unmappableLegacyFields":
+        summary.unmappable += 1;
+        break;
+      case "orphanedLegacy":
+        summary.orphaned += 1;
+        break;
+      case "invalidLegacyShape":
+        summary.invalid += 1;
+        break;
+    }
+  }
+  return {
+    status: plan.tag,
+    legacyFilesFound: plan.items.length,
+    eventsToWrite,
+    legacyFilesToArchive,
+    ...summary,
+    dryRun: options.dryRun ?? false,
+    items: plan.items
+  };
+}
 
 // src/cli/commands/migrate.ts
+function formatEventMigrationItem(item) {
+  switch (item.tag) {
+    case "mergeLegacyIntoEvent":
+      return [
+        "merge",
+        path5.basename(item.legacyFilePath),
+        item.eventIdentifier,
+        item.mergedFields.join(", ")
+      ];
+    case "archiveLegacyOnly":
+      return [
+        "archive",
+        path5.basename(item.legacyFilePath),
+        item.eventIdentifier,
+        item.reason
+      ];
+    case "conflict":
+      return [
+        "conflict",
+        path5.basename(item.legacyFilePath),
+        item.eventIdentifier,
+        item.conflicts.join(", ")
+      ];
+    case "ambiguousMatch":
+      return [
+        "ambiguous",
+        path5.basename(item.legacyFilePath),
+        item.candidateEventIdentifiers.join(", "),
+        "Multiple canonical events matched this legacy entry."
+      ];
+    case "unmappableLegacyFields":
+      return [
+        "unmappable",
+        path5.basename(item.legacyFilePath),
+        item.eventIdentifier ?? "",
+        item.fields.join(", ")
+      ];
+    case "orphanedLegacy":
+      return [
+        "orphaned",
+        path5.basename(item.legacyFilePath),
+        item.legacyIdentifier,
+        item.reason
+      ];
+    case "invalidLegacyShape":
+      return [
+        "invalid",
+        path5.basename(item.legacyFilePath),
+        "",
+        item.reason
+      ];
+  }
+}
 var migrateCommand = new Command("migrate").description("Migrate local SDK content formats").addCommand(
   new Command("entries").description("Migrate entries to canonical file format and remove legacy title fields").argument("[type]", "Content type key to migrate (optional)").option("--content-dir <dir>", "Content directory (overrides config)").option("--dry-run", "Preview changes without writing files").option("--force", "Overwrite existing entry files when migrating legacy formats").option("--yes", "Skip confirmation prompt").addHelpText(
     "after",
@@ -71494,6 +72753,13 @@ Examples:
     try {
       const cliConfig = await loadCliConfig();
       const contentDir = path5.resolve(options.contentDir ?? cliConfig.contentDir);
+      if (type === "event") {
+        process.exitCode = 1;
+        output.result(false, "`event` entries use the canonical events migration.", {
+          suggestion: 'Run "riverbankcms migrate events" to fold content/entries/event/*.json into content/events/*.json.'
+        });
+        return;
+      }
       const confirmed = await confirmAction(
         options.dryRun ? "Preview entry migrations?" : "Migrate local entries to the new file format?",
         { yes: options.yes },
@@ -71530,6 +72796,86 @@ Examples:
       handleCommandError(error, output, { target: "local" });
     }
   })
+).addCommand(
+  new Command("events").description("Migrate legacy event entries into canonical event files").option("--content-dir <dir>", "Content directory (overrides config)").option("--dry-run", "Preview changes without writing files").option("--yes", "Skip confirmation prompt").addHelpText(
+    "after",
+    `
+Description:
+  Folds legacy event entry files into canonical SDK event payloads:
+    content/entries/event/*.json -> content/events/*.json
+
+  Safe migrated legacy files are archived to:
+    content/.legacy/entries/event/*.json
+
+  The migration stops before writing when it finds divergent copy,
+  ambiguous matches, unmappable fields, or orphaned legacy event entries.
+
+Examples:
+  $ riverbankcms migrate events --dry-run
+  $ riverbankcms migrate events --yes
+`
+  ).action(async (options, command) => {
+    const { output, envTargets } = getOutputContext(command);
+    if (envTargets.length > 1) {
+      return output.error("Migrate is local-only and does not support --env=both", {
+        suggestion: "Use --env=local (default)"
+      });
+    }
+    try {
+      const cliConfig = await loadCliConfig();
+      const contentDir = path5.resolve(options.contentDir ?? cliConfig.contentDir);
+      const confirmed = await confirmAction(
+        options.dryRun ? "Preview event entry migration?" : "Migrate legacy event entries into canonical event files?",
+        { yes: options.yes },
+        false
+      );
+      if (!confirmed) {
+        output.info("Migration cancelled.");
+        return;
+      }
+      const result = await migrateEvents({
+        contentDir,
+        dryRun: options.dryRun
+      });
+      if (result.status === "blocked") {
+        process.exitCode = 1;
+        output.result(false, "Event migration blocked; no files were written or archived.", {
+          conflicts: result.conflicts,
+          ambiguous: result.ambiguous,
+          unmappable: result.unmappable,
+          orphaned: result.orphaned,
+          invalid: result.invalid
+        });
+      } else if (options.dryRun) {
+        output.info("[DRY RUN] Event migration preview:");
+      } else {
+        output.success("Event entries migrated successfully");
+      }
+      output.table(
+        ["Metric", "Count"],
+        [
+          ["Legacy event files found", String(result.legacyFilesFound)],
+          ["Events to write", String(result.eventsToWrite)],
+          ["Legacy files to archive", String(result.legacyFilesToArchive)],
+          ["Merge plans", String(result.merged)],
+          ["Archive-only plans", String(result.archiveOnly)],
+          ["Conflicts", String(result.conflicts)],
+          ["Ambiguous matches", String(result.ambiguous)],
+          ["Unmappable files", String(result.unmappable)],
+          ["Orphaned files", String(result.orphaned)],
+          ["Invalid files", String(result.invalid)]
+        ]
+      );
+      if (result.items.length > 0) {
+        output.table(
+          ["Action", "Legacy File", "Event", "Details"],
+          result.items.map(formatEventMigrationItem)
+        );
+      }
+    } catch (error) {
+      handleCommandError(error, output, { target: "local" });
+    }
+  })
 );
 
 // src/cli/commands/style.ts