@riverbankcms/sdk 0.84.1 → 0.85.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';
@@ -12490,8 +12490,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 +13344,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 +13455,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 +13469,7 @@ function backgroundLayer(path25, options = {}) {
     className: styleClassName,
     style: {
       $bind: {
-        from: path25,
+        from: path27,
         transforms: [
           {
             id: "background.resolveStyle",
@@ -13479,20 +13479,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 +13503,7 @@ function createBackgroundImageNode(path25, baseClassName = "rb-absolute rb-z-neg
       },
       style: {
         $bind: {
-          from: path25,
+          from: path27,
           transforms: [{ id: "background.resolveImageStyle" }]
         }
       },
@@ -13515,8 +13515,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 +14356,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 +15351,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({
@@ -18247,8 +18247,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 +18267,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
         }))
       );
     }
@@ -28589,20 +28589,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 +28618,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 +28658,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 +28667,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 +28675,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 +28711,7 @@ function deriveFieldValidationPlan(field, path25 = [field.id]) {
         "select",
         "select",
         field,
-        path25,
+        path27,
         required,
         commonConstraints(required, {
           kind: "selectOption",
@@ -28720,40 +28720,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 +28767,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 +29111,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 +29143,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 +29182,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 +29236,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 +32395,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));
@@ -42213,17 +42213,21 @@ function looksLikeLocalAuthority(authority) {
   const normalized = authority.toLowerCase();
   return normalized === "localhost" || normalized.startsWith("localhost:") || normalized.startsWith("127.") || normalized.startsWith("0.0.0.0") || normalized.includes(".localhost") || normalized.endsWith(".local") || normalized.endsWith(".test");
 }
-function normalizeDashboardUrlBase(input) {
+function normalizeDashboardOrigin(input) {
   const trimmed = input.trim();
   if (!trimmed) return "";
   const withoutTrailingSlash = trimmed.replace(/\/+$/, "");
   const withoutApiSuffix = withoutTrailingSlash.replace(/\/api\/?$/, "");
   if (/^https?:\/\//i.test(withoutApiSuffix)) {
-    return withoutApiSuffix;
+    return new URL(withoutApiSuffix).origin;
   }
   const authority = withoutApiSuffix.replace(/^\/+/, "");
   const protocol = looksLikeLocalAuthority(authority) ? "http" : "https";
-  return `${protocol}://${authority}`;
+  return new URL(`${protocol}://${authority}`).origin;
+}
+function deriveCmsApiUrlFromDashboardUrl(input) {
+  const origin = normalizeDashboardOrigin(input);
+  return origin ? `${origin}/api` : "";
 }
 function getCmsApiUrl() {
   if (typeof window !== "undefined") {
@@ -42235,15 +42239,10 @@ function getCmsApiUrl() {
   }
   const dashboardUrl = process.env.NEXT_PUBLIC_DASHBOARD_URL;
   if (dashboardUrl) {
-    const base = normalizeDashboardUrlBase(dashboardUrl);
-    return `${base}/api`;
-  }
-  const legacyApiUrl = process.env.NEXT_PUBLIC_CMS_API_URL;
-  if (legacyApiUrl) {
-    return legacyApiUrl.replace(/\/$/, "");
+    return deriveCmsApiUrlFromDashboardUrl(dashboardUrl);
   }
   throw new Error(
-    "NEXT_PUBLIC_DASHBOARD_URL is not configured. Set it to your dashboard URL (e.g., http://localhost:4000)"
+    "CMS_API_URL or NEXT_PUBLIC_DASHBOARD_URL is not configured. Set NEXT_PUBLIC_DASHBOARD_URL to your dashboard URL (e.g., http://localhost:4000)"
   );
 }
 function resolveApiBaseUrl() {
@@ -43008,11 +43007,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)
     });
   }
 });
@@ -43046,8 +43045,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":
@@ -43555,8 +43554,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
@@ -43730,7 +43729,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({
@@ -43741,7 +43740,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", [
@@ -43945,7 +43944,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,
@@ -44002,18 +44001,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);
     });
   }
 }
@@ -44025,45 +44024,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;
@@ -44071,16 +44070,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);
     }
   }
 }
@@ -44625,8 +44624,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()}`;
@@ -44649,7 +44648,7 @@ function createHttpClient(config2) {
     } catch (error) {
       const requestInfo2 = buildRequestInfo({
         method,
-        path: path25,
+        path: path27,
         url,
         baseUrl,
         dashboardUrl: config2.dashboardUrl,
@@ -44674,7 +44673,7 @@ function createHttpClient(config2) {
     }
     const requestInfo = buildRequestInfo({
       method,
-      path: path25,
+      path: path27,
       url,
       baseUrl,
       dashboardUrl: config2.dashboardUrl,
@@ -44704,17 +44703,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 });
     }
   };
 }
@@ -46159,12 +46158,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,
@@ -46234,9 +46233,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
         }))
       });
     }
@@ -46943,23 +46942,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);
@@ -46979,6 +46962,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");
@@ -47316,7 +47319,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")
     );
   }
@@ -49034,11 +49037,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;
@@ -50108,11 +50111,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;
@@ -50529,6 +50532,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 = [];
@@ -50880,6 +50994,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: {},
@@ -51012,6 +51137,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
@@ -51103,6 +51252,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)');
@@ -51309,13 +51472,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;
@@ -51354,13 +51511,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;
           }
@@ -51469,6 +51620,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,
@@ -51578,13 +51743,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);
@@ -51731,13 +51890,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);
@@ -52119,8 +52272,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);
@@ -52137,27 +52290,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"
       )
     );
@@ -52166,7 +52319,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"
       )
     );
@@ -52175,7 +52328,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"
       )
     );
@@ -52184,7 +52337,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"
       )
     );
@@ -52193,7 +52346,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"
       )
     );
@@ -52202,7 +52355,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"
       )
     );
@@ -52211,7 +52364,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"
       )
     );
@@ -52219,7 +52372,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"
       )
     );
@@ -52228,7 +52381,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"
       )
     );
@@ -52406,11 +52559,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) {
@@ -52425,8 +52806,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),
@@ -52443,7 +52829,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;
@@ -52451,7 +52837,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),
@@ -52472,7 +52858,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),
@@ -52484,8 +52870,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),
@@ -52504,6 +52890,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
     ),
@@ -52513,14 +52900,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,
@@ -52529,6 +52916,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,
@@ -52538,7 +52926,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),
@@ -52559,6 +52947,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
     ),
@@ -52568,9 +52957,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 : []
   };
 }
@@ -52582,7 +52971,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)
@@ -52594,18 +52983,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),
@@ -52640,7 +53029,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,
@@ -52661,11 +53050,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,
@@ -53334,9 +53723,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"),
@@ -53781,6 +54185,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()
@@ -54900,7 +55305,7 @@ function getSiteCommandLifecycleIntent(command) {
 init_src();
 
 // ../site-commands/src/guards.ts
-function isRecord17(value) {
+function isRecord18(value) {
   return typeof value === "object" && value !== null;
 }
 
@@ -55160,13 +55565,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` });
@@ -55180,26 +55585,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
@@ -55282,7 +55687,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);
 }
@@ -55454,9 +55859,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",
@@ -55466,32 +55871,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)}`;
@@ -55729,11 +56134,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."
     )];
   });
 }
@@ -55741,7 +56147,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,
@@ -56156,8 +56565,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));
@@ -56221,22 +56630,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 };
@@ -56261,34 +56670,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 {
@@ -56307,9 +56716,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;
@@ -56592,10 +57001,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,
@@ -56603,6 +57012,7 @@ function eventSeriesCommand(event) {
         image: event.content.image ?? void 0
       } : void 0,
       settings: event.settings,
+      paymentTerms: event.paymentTerms,
       presentation: event.presentation,
       tags: event.tags
     }
@@ -56686,20 +57096,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);
   }
@@ -56757,6 +57183,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),
@@ -56770,8 +57199,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) {
@@ -56818,9 +57247,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(
@@ -56942,7 +57381,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) {
@@ -57784,15 +58223,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}`
         });
       }
     }
@@ -59228,7 +59667,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}`
@@ -59894,7 +60333,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 {
@@ -59976,37 +60415,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;
@@ -60644,6 +61083,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) {
@@ -60714,7 +61166,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}`
@@ -60902,8 +61354,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,
@@ -60945,7 +61405,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(
@@ -61228,7 +61688,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)) {
@@ -63007,7 +63467,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) {
@@ -63135,7 +63595,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 = []) {
@@ -63205,7 +63665,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;
@@ -63220,7 +63680,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;
@@ -63231,7 +63691,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);
@@ -64396,7 +64856,7 @@ var SimpleCache = class {
 };
 
 // src/version.ts
-var SDK_VERSION = "0.84.1";
+var SDK_VERSION = "0.85.0";
 
 // src/client/error.ts
 var RiverbankApiError = class _RiverbankApiError extends Error {
@@ -65340,14 +65800,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 }
         });
       },
@@ -65355,7 +65815,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
       }
     );
   }
@@ -65797,17 +66257,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 }
           });
         },
@@ -65884,13 +66344,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) {
@@ -66217,7 +66677,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
@@ -66488,9 +66948,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"
       });
@@ -66748,25 +67208,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;
 }
@@ -67018,8 +67478,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...");
@@ -67043,8 +67503,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) {
@@ -67059,14 +67519,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) {
@@ -67700,7 +68160,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";
@@ -67709,10 +68169,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;
@@ -68134,7 +68594,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;
@@ -68163,21 +68623,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.`
         });
       }
@@ -68190,7 +68650,7 @@ function findMissingLinkHrefs(node, blockId, fields3, path25 = "layout", repeatS
           n.children[i],
           blockId,
           fields3,
-          `${path25}.children[${i}]`,
+          `${path27}.children[${i}]`,
           nextRepeatStack
         )
       );
@@ -68198,7 +68658,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;
@@ -68220,7 +68680,7 @@ function detectRedundantLinkLabels(node, blockId, fields3, path25 = "layout", re
     const redundancies = findRedundantLinkTextSiblings(
       children,
       nextRepeatStack,
-      path25
+      path27
     );
     errors.push(
       ...redundancies.map((r) => ({
@@ -68237,7 +68697,7 @@ function detectRedundantLinkLabels(node, blockId, fields3, path25 = "layout", re
           n.children[i],
           blockId,
           fields3,
-          `${path25}.children[${i}]`,
+          `${path27}.children[${i}]`,
           nextRepeatStack
         )
       );
@@ -68476,19 +68936,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];
@@ -68497,7 +68957,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.`
         });
@@ -68506,7 +68966,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;
@@ -68514,7 +68974,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.`
         });
@@ -68522,31 +68982,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);
@@ -68554,7 +69014,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);
@@ -68563,7 +69023,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);
@@ -68571,17 +69031,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);
@@ -68714,7 +69174,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;
@@ -68724,15 +69184,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").'
       });
     }
@@ -68741,15 +69201,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" } }`
       });
     }
@@ -68759,7 +69219,7 @@ function findMissingBindings(node, blockId, path25 = "layout") {
       const childErrors = findMissingBindings(
         n.children[i],
         blockId,
-        `${path25}.children[${i}]`
+        `${path27}.children[${i}]`
       );
       errors.push(...childErrors);
     }
@@ -68776,13 +69236,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)) {
@@ -68792,7 +69252,7 @@ function detectPotentialTruncation(node, maxAllowedDepth, currentDepth = 0, path
           child,
           maxAllowedDepth,
           currentDepth + 1,
-          `${path25}.children[${i}]`
+          `${path27}.children[${i}]`
         )
       );
     });
@@ -68812,8 +69272,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(
@@ -69275,11 +69735,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);
   }
@@ -70977,6 +71437,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"),
@@ -70986,6 +71466,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(),
@@ -71069,6 +71550,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,
@@ -71463,8 +71945,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",
@@ -71495,6 +72454,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 },
@@ -71531,6 +72497,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