@riverbankcms/sdk 0.98.0 → 0.99.0

package/dist/cli/index.mjs

@@ -4,14 +4,14 @@ import 'react/jsx-runtime';
 import { createJiti } from 'jiti';
 import * as fs11 from 'fs';
 import { existsSync, readFileSync } from 'fs';
-import * as path20 from 'path';
+import * as path21 from 'path';
 import { dirname, resolve, isAbsolute } from 'path';
 import { fileURLToPath } from 'url';
 import { config } from 'dotenv';
 import { Command } from 'commander';
 import 'react';
 import * as fs2 from 'fs/promises';
-import { unlink, writeFile } from 'fs/promises';
+import { writeFile, unlink } from 'fs/promises';
 import * as readline from 'readline';
 import prompts from 'prompts';
 import * as crypto2 from 'crypto';
@@ -5337,6 +5337,12 @@ var init_resolver = __esm({
   }
 });
 
+// ../theme-core/src/interactive/generateBaseCSS.ts
+var init_generateBaseCSS = __esm({
+  "../theme-core/src/interactive/generateBaseCSS.ts"() {
+  }
+});
+
 // ../theme-core/src/buttons/effects/presets/background.ts
 var init_background = __esm({
   "../theme-core/src/buttons/effects/presets/background.ts"() {
@@ -5452,6 +5458,7 @@ var init_generateButtonCss = __esm({
     init_types4();
     init_classNames();
     init_resolver();
+    init_generateBaseCSS();
     init_generateEffectsCSS();
     init_constants();
     init_generateDefaultButtonSystem();
@@ -5987,15 +5994,16 @@ var init_joy_stamp = __esm({
           // 700, matching the mockup's chunky button labels.
           typography: "heading",
           fontWeight: 700,
+          fontSize: "text-lg",
           borderWidth: 2,
           hoverTransform: "none",
           hoverColor: "none"
         },
         sizes: {
-          sm: { padding: "0.625rem 1.25rem", fontSize: "text-sm" },
-          md: { padding: "0.875rem 1.75rem", fontSize: "text-base" },
-          lg: { padding: "1.125rem 2.25rem", fontSize: "text-lg" },
-          xl: { padding: "1.25rem 2.75rem", fontSize: "text-xl" }
+          sm: { padding: "0.625rem 1.25rem", fontSize: "text-base" },
+          md: { padding: "0.875rem 1.75rem", fontSize: "text-lg" },
+          lg: { padding: "1.125rem 2.25rem", fontSize: "text-xl" },
+          xl: { padding: "1.25rem 2.75rem", fontSize: "text-2xl" }
         },
         variants: [
           {
@@ -6576,12 +6584,19 @@ var init_generateDefaultCardSystem = __esm({
   }
 });
 
+// ../theme-core/src/status/contextualColors.ts
+var init_contextualColors = __esm({
+  "../theme-core/src/status/contextualColors.ts"() {
+  }
+});
+
 // ../theme-core/src/cards/generateCardCss.ts
 var init_generateCardCss = __esm({
   "../theme-core/src/cards/generateCardCss.ts"() {
     init_resolver();
     init_constants2();
     init_generateDefaultCardSystem();
+    init_contextualColors();
   }
 });
 
@@ -13477,11 +13492,11 @@ function bind(from, options) {
     }
   });
 }
-function when(path32, options) {
+function when(path33, options) {
   return (node) => ({
     ...node,
     $when: {
-      when: { from: path32 },
+      when: { from: path33 },
       ...options?.equals !== void 0 ? { equals: options.equals } : {},
       ...options?.not ? { not: true } : {},
       ...options?.authoringPresence ? { authoringPresence: options.authoringPresence } : {}
@@ -13589,7 +13604,7 @@ var init_builder2 = __esm({
 });
 
 // ../blocks/src/system/node/fragments/backgroundLayer.ts
-function backgroundLayer(path32, options = {}) {
+function backgroundLayer(path33, 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,
@@ -13603,7 +13618,7 @@ function backgroundLayer(path32, options = {}) {
     className: styleClassName,
     style: {
       $bind: {
-        from: path32,
+        from: path33,
         transforms: [
           {
             id: "background.resolveStyle",
@@ -13613,20 +13628,20 @@ function backgroundLayer(path32, options = {}) {
       }
     }
   });
-  const imageLayer = createBackgroundImageNode(path32, imageClassName, {
+  const imageLayer = createBackgroundImageNode(path33, imageClassName, {
     loading: imageLoading,
     fetchPriority: imageFetchPriority
   });
-  const overlayLayer = createBackgroundOverlayNode(path32, overlayClassName);
+  const overlayLayer = createBackgroundOverlayNode(path33, overlayClassName);
   return omitImageLayer ? [styleLayer, overlayLayer] : [styleLayer, imageLayer, overlayLayer];
 }
-function createBackgroundImageNode(path32, baseClassName = "rb-absolute rb-z-neg-10", options = {}) {
-  const imagePath = `${path32}.image`;
+function createBackgroundImageNode(path33, baseClassName = "rb-absolute rb-z-neg-10", options = {}) {
+  const imagePath = `${path33}.image`;
   return media(
     {
       className: {
         $bind: {
-          from: path32,
+          from: path33,
           transforms: [
             {
               id: "background.resolveImageClassName",
@@ -13637,7 +13652,7 @@ function createBackgroundImageNode(path32, baseClassName = "rb-absolute rb-z-neg
       },
       style: {
         $bind: {
-          from: path32,
+          from: path33,
           transforms: [{ id: "background.resolveImageStyle" }]
         }
       },
@@ -13649,8 +13664,8 @@ function createBackgroundImageNode(path32, baseClassName = "rb-absolute rb-z-neg
     bind(imagePath)
   );
 }
-function createBackgroundOverlayNode(path32, className = "background-overlay rb-absolute rb-inset-0 rb-z-neg-10 rb-h-full rb-w-full rb-pointer-events-none") {
-  const overlayPath = `${path32}.overlay`;
+function createBackgroundOverlayNode(path33, className = "background-overlay rb-absolute rb-inset-0 rb-z-neg-10 rb-h-full rb-w-full rb-pointer-events-none") {
+  const overlayPath = `${path33}.overlay`;
   return el("div", {
     className,
     style: {
@@ -14490,10 +14505,10 @@ var init_sectionForegroundStyles = __esm({
 });
 
 // ../blocks/src/system/transforms/registry/boxStyles.ts
-function readPath(source, path32) {
-  if (!source || !path32) return void 0;
-  if (!path32.includes(".")) return source[path32];
-  return path32.split(".").reduce((acc, segment) => {
+function readPath(source, path33) {
+  if (!source || !path33) return void 0;
+  if (!path33.includes(".")) return source[path33];
+  return path33.split(".").reduce((acc, segment) => {
     if (acc && typeof acc === "object" && segment in acc) {
       return acc[segment];
     }
@@ -15485,27 +15500,27 @@ function scopePropValue(value, scope) {
   }
   return value;
 }
-function scopeContentPath(path32, scope) {
+function scopeContentPath(path33, scope) {
   if (!scope || scope.length === 0) {
-    return path32;
+    return path33;
   }
-  if (path32 === "content") {
+  if (path33 === "content") {
     return `content.${scope}`;
   }
-  if (path32.startsWith("content.")) {
-    const remainder = path32.slice("content.".length);
+  if (path33.startsWith("content.")) {
+    const remainder = path33.slice("content.".length);
     return remainder.length > 0 ? `content.${scope}.${remainder}` : `content.${scope}`;
   }
-  if (path32.startsWith("content[")) {
-    return path32.replace(/^content/, `content.${scope}`);
+  if (path33.startsWith("content[")) {
+    return path33.replace(/^content/, `content.${scope}`);
   }
-  if (path32.startsWith("$root.")) {
-    return path32;
+  if (path33.startsWith("$root.")) {
+    return path33;
   }
-  if (path32.includes(".")) {
-    return path32;
+  if (path33.includes(".")) {
+    return path33;
   }
-  return `content.${scope}.${path32}`;
+  return `content.${scope}.${path33}`;
 }
 var FRAGMENT_ID_PATTERN, FIELD_ID_PATTERN, dataLoaderSchema, fragmentDataSchema, fragmentConfigSchema, FragmentConfigError;
 var init_types14 = __esm({
@@ -18432,8 +18447,8 @@ function decodeSuccess(value) {
 function decodeFailure(issues) {
   return { ok: false, issues };
 }
-function zodIssuePath(path32) {
-  return path32.flatMap((segment) => {
+function zodIssuePath(path33) {
+  return path33.flatMap((segment) => {
     if (typeof segment === "string" || typeof segment === "number") {
       return [segment];
     }
@@ -27719,6 +27734,14 @@ var ENDPOINT_DEFINITIONS = {
     responseKind: "json",
     errors: []
   },
+  adminResolveSiteBillingManualReview: {
+    path: "/admin/sites/{siteId}/billing/manual-reviews/{reviewId}/resolve",
+    method: "POST",
+    tags: ["admin", "site-{siteId}", "billing"],
+    auth: "admin",
+    responseKind: "json",
+    errors: []
+  },
   // Admin GSC/SEO endpoints
   adminGscVerifyStart: {
     path: "/admin/seo/gsc/properties/verify/start",
@@ -29396,8 +29419,8 @@ function strictValidationContext(options = {}) {
     allowNull: options.allowNull ?? false
   };
 }
-function formatFieldPath(path32) {
-  return path32.map((segment) => String(segment)).join(".");
+function formatFieldPath(path33) {
+  return path33.map((segment) => String(segment)).join(".");
 }
 function parseFieldPathKey(key) {
   if (!key) return [];
@@ -29460,7 +29483,7 @@ function pluralize(label, count) {
   if (count === 1) return label;
   return label.endsWith("s") ? label : `${label}s`;
 }
-function deriveFieldValidationPlan(field, path32 = [field.id]) {
+function deriveFieldValidationPlan(field, path33 = [field.id]) {
   const required = Boolean(field.required);
   switch (field.type) {
     case "text": {
@@ -29471,7 +29494,7 @@ function deriveFieldValidationPlan(field, path32 = [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, path32, required, constraints2);
+        return makePlan("number", "number", field, path33, required, constraints2);
       }
       const constraints = commonConstraints(required, {
         kind: field.ui?.widget === "iconPicker" ? "blockIconValue" : "textType"
@@ -29480,7 +29503,7 @@ function deriveFieldValidationPlan(field, path32 = [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, path32, required, constraints);
+      return makePlan("string", "string", field, path33, required, constraints);
     }
     case "number": {
       const constraints = commonConstraints(required, {
@@ -29488,34 +29511,34 @@ function deriveFieldValidationPlan(field, path32 = [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, path32, required, constraints);
+      return makePlan("number", "number", field, path33, 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, path32, required, constraints);
+      return makePlan("string", "string", field, path33, required, constraints);
     }
     case "url":
       return makePlan(
         "string",
         "string",
         field,
-        path32,
+        path33,
         required,
         commonConstraints(required, { kind: "textType" }, { kind: "urlFormat", allowRelative: Boolean(field.allowRelative) })
       );
     case "reference":
-      return makePlan("string", "string", field, path32, required, commonConstraints(required, { kind: "referenceText" }));
+      return makePlan("string", "string", field, path33, required, commonConstraints(required, { kind: "referenceText" }));
     case "date":
-      return makePlan("string", "string", field, path32, required, commonConstraints(required, { kind: "textType" }, { kind: "dateFormat" }));
+      return makePlan("string", "string", field, path33, required, commonConstraints(required, { kind: "textType" }, { kind: "dateFormat" }));
     case "time":
-      return makePlan("string", "string", field, path32, required, commonConstraints(required, { kind: "textType" }, { kind: "timeFormat" }));
+      return makePlan("string", "string", field, path33, required, commonConstraints(required, { kind: "textType" }, { kind: "timeFormat" }));
     case "datetime":
       return makePlan(
         "string",
         "string",
         field,
-        path32,
+        path33,
         required,
         commonConstraints(required, { kind: "textType" }, { kind: "datetimeFormat" })
       );
@@ -29524,7 +29547,7 @@ function deriveFieldValidationPlan(field, path32 = [field.id]) {
         "select",
         "select",
         field,
-        path32,
+        path33,
         required,
         commonConstraints(required, {
           kind: "selectOption",
@@ -29533,53 +29556,53 @@ function deriveFieldValidationPlan(field, path32 = [field.id]) {
         })
       );
     case "richText":
-      return makePlan("richText", "object", field, path32, required, commonConstraints(required, { kind: "richTextDoc" }));
+      return makePlan("richText", "object", field, path33, required, commonConstraints(required, { kind: "richTextDoc" }));
     case "inlineText": {
       const constraints = commonConstraints(required, { kind: "inlineText" });
       if (typeof field.maxLength === "number") {
         constraints.push({ kind: "maxPlainTextLength", maximum: field.maxLength });
       }
       return {
-        ...makePlan("inlineText", "array", field, path32, required, constraints),
+        ...makePlan("inlineText", "array", field, path33, required, constraints),
         ...field.plainTextField ? { plainTextFallbackPath: parseFieldPathKey(field.plainTextField) } : {}
       };
     }
     case "media":
     case "file":
       return {
-        ...makePlan("media", "object", field, path32, required, commonConstraints(required, { kind: "mediaObject" })),
+        ...makePlan("media", "object", field, path33, required, commonConstraints(required, { kind: "mediaObject" })),
         legacyStringType: legacyStringMediaTypeForField(field)
       };
     case "link":
-      return makePlan("link", "object", field, path32, required, commonConstraints(required, { kind: "linkObject" }));
+      return makePlan("link", "object", field, path33, required, commonConstraints(required, { kind: "linkObject" }));
     case "boolean":
-      return makePlan("boolean", "boolean", field, path32, required, requiredConstraints(required));
+      return makePlan("boolean", "boolean", field, path33, required, requiredConstraints(required));
     case "repeater":
       return {
-        ...makePlan("repeater", "array", field, path32, required, commonConstraints(required, { kind: "arrayType" })),
+        ...makePlan("repeater", "array", field, path33, required, commonConstraints(required, { kind: "arrayType" })),
         ...field.polymorphic && field.itemTypes ? {
-          repeatedItemVariants: deriveRepeatedItemVariants(field, [...path32, 0])
+          repeatedItemVariants: deriveRepeatedItemVariants(field, [...path33, 0])
         } : {
-          repeatedItemPlan: deriveNestedFieldPlans(getRepeaterFields(field), [...path32, 0])
+          repeatedItemPlan: deriveNestedFieldPlans(getRepeaterFields(field), [...path33, 0])
         },
         constraints: withRepeaterItemConstraints(field, commonConstraints(required, { kind: "arrayType" }))
       };
     case "group":
     case "modal":
       return {
-        ...makePlan("group", "object", field, path32, required, requiredConstraints(required)),
-        children: deriveNestedFieldPlans(field.schema?.fields ?? [], path32),
+        ...makePlan("group", "object", field, path33, required, requiredConstraints(required)),
+        children: deriveNestedFieldPlans(field.schema?.fields ?? [], path33),
         allowNullChildren: field.type === "group" && field.ui?.widget === "locationPicker"
       };
     case "tabGroup":
       return {
-        ...makePlan("group", "object", field, path32, required, requiredConstraints(required)),
-        children: field.tabs.flatMap((tab) => deriveNestedFieldPlans(tab.fields, path32))
+        ...makePlan("group", "object", field, path33, required, requiredConstraints(required)),
+        children: field.tabs.flatMap((tab) => deriveNestedFieldPlans(tab.fields, path33))
       };
     case "presetOrCustom":
     case "contentTypeSelect":
     case "entryPicker":
-      return makePlan("passthrough", "unknown", field, path32, false, []);
+      return makePlan("passthrough", "unknown", field, path33, false, []);
     default:
       return assertNever2(field);
   }
@@ -29593,14 +29616,14 @@ function commonConstraints(required, ...specific) {
 function requiredConstraints(required) {
   return required ? [{ kind: "required" }] : [];
 }
-function makePlan(kind, valueKind, field, path32, required, constraints) {
+function makePlan(kind, valueKind, field, path33, required, constraints) {
   return {
     kind,
     valueKind,
     fieldId: field.id,
     label: field.label,
     fieldType: field.type,
-    path: path32,
+    path: path33,
     required,
     visibility: fieldVisibility(field),
     constraints
@@ -29776,8 +29799,8 @@ function normalizeInlineTextFallbacks(plans, values, ctx) {
     values[plan.fieldId] = normalizeFieldValue(plan, plainTextToInlineText(fallback), ctx);
   }
 }
-function getAtFieldPath(source, path32) {
-  return path32.reduce((current, segment) => {
+function getAtFieldPath(source, path33) {
+  return path33.reduce((current, segment) => {
     if (!current || typeof current !== "object" || Array.isArray(current)) return void 0;
     return current[String(segment)];
   }, source);
@@ -29968,18 +29991,18 @@ function materializeRepeaterItemPlan(plan, parentPath, index) {
   return rebaseFieldPlanPath(plan, [...parentPath, 0], [...parentPath, index]);
 }
 function rebaseFieldPlanPath(plan, fromPrefix, toPrefix) {
-  const path32 = rebaseFieldPath(plan.path, fromPrefix, toPrefix);
+  const path33 = rebaseFieldPath(plan.path, fromPrefix, toPrefix);
   switch (plan.kind) {
     case "group":
       return {
         ...plan,
-        path: path32,
+        path: path33,
         children: plan.children.map((childPlan) => rebaseFieldPlanPath(childPlan, fromPrefix, toPrefix))
       };
     case "repeater":
       return {
         ...plan,
-        path: path32,
+        path: path33,
         ...plan.repeatedItemVariants ? {
           repeatedItemVariants: plan.repeatedItemVariants.map((variant) => ({
             ...variant,
@@ -30001,7 +30024,7 @@ function rebaseFieldPlanPath(plan, fromPrefix, toPrefix) {
     case "passthrough":
       return {
         ...plan,
-        path: path32
+        path: path33
       };
     default:
       return assertNever2(plan);
@@ -30019,14 +30042,14 @@ function validateInlineTextPlan(plan, value) {
   }
   return [];
 }
-function rebaseFieldPath(path32, fromPrefix, toPrefix) {
-  if (!startsWithFieldPath(path32, fromPrefix)) {
-    throw new Error(`Cannot rebase field path ${formatFieldPath(path32)} from ${formatFieldPath(fromPrefix)}`);
+function rebaseFieldPath(path33, fromPrefix, toPrefix) {
+  if (!startsWithFieldPath(path33, fromPrefix)) {
+    throw new Error(`Cannot rebase field path ${formatFieldPath(path33)} from ${formatFieldPath(fromPrefix)}`);
   }
-  return [...toPrefix, ...path32.slice(fromPrefix.length)];
+  return [...toPrefix, ...path33.slice(fromPrefix.length)];
 }
-function startsWithFieldPath(path32, prefix) {
-  return prefix.every((segment, index) => path32[index] === segment);
+function startsWithFieldPath(path33, prefix) {
+  return prefix.every((segment, index) => path33[index] === segment);
 }
 function issue(plan, kind, extra) {
   return {
@@ -33200,9 +33223,9 @@ function maybeBuildSupabaseTransformUrl(inputUrl, options) {
   const remainder = url.pathname.slice(idx + marker.length);
   const parts = remainder.split("/").filter(Boolean);
   const bucket = parts[0];
-  const path32 = parts.slice(1).join("/");
-  if (!bucket || !path32) return inputUrl;
-  url.pathname = `/storage/v1/render/image/public/${bucket}/${path32}`;
+  const path33 = parts.slice(1).join("/");
+  if (!bucket || !path33) return inputUrl;
+  url.pathname = `/storage/v1/render/image/public/${bucket}/${path33}`;
   url.search = "";
   if (width) url.searchParams.set("width", String(width));
   if (height) url.searchParams.set("height", String(height));
@@ -42262,6 +42285,7 @@ init_resolver();
 init_types11();
 init_expandPalette();
 init_colorConversion();
+init_generateBaseCSS();
 init_generateEffectsCSS();
 
 // ../theme-core/src/header/generateHeaderCss.ts
@@ -42275,6 +42299,12 @@ init_resolver();
 // ../theme-core/src/layout/generateLayoutCss.ts
 init_breakpoints();
 
+// ../theme-core/src/status/generateStatusCss.ts
+init_contextualColors();
+
+// ../theme-core/src/status/index.ts
+init_contextualColors();
+
 // ../theme-core/src/runtime/buildThemeRuntime.ts
 init_tokens2();
 
@@ -42350,6 +42380,34 @@ ${root} {
   /* Order summary */
   --er-summary-bg: rgba(var(--tb-primary), 0.1);
   --er-summary-border: rgb(var(--tb-border));
+
+  /* Shared registration-surface mappings (issue 1174).
+     Route the shared --rb-reg-* contract through this block's documented
+     Tier 3 vars so existing --er-* overrides keep working unchanged. */
+  --rb-reg-radius: var(--er-radius);
+  --rb-reg-border: var(--er-border);
+  --rb-reg-border-hover: var(--er-border-hover);
+  --rb-reg-border-selected: var(--er-border-selected);
+  --rb-reg-bg-selected: var(--er-payment-bg-selected);
+  --rb-reg-option-bg: var(--er-control-bg);
+  --rb-reg-option-hover-shadow: 0 8px 18px rgba(var(--tb-shadow, 15 23 42), 0.08);
+  --rb-reg-surface-bg: rgb(var(--tb-surface));
+  --rb-reg-on-surface: var(--er-on-surface);
+  --rb-reg-on-surface-muted: var(--er-on-surface-muted);
+  --rb-reg-on-surface-subtle: var(--er-on-surface-subtle);
+  --rb-reg-on-surface-faint: var(--er-on-surface-faint);
+  --rb-reg-check-bg: var(--er-check-bg);
+  --rb-reg-check-text: var(--er-check-text);
+  --rb-reg-step-active: var(--er-step-active);
+  --rb-reg-step-completed: var(--er-step-completed);
+  --rb-reg-step-inactive: var(--er-step-inactive);
+  --rb-reg-step-text: var(--er-step-text);
+  --rb-reg-step-text-active: var(--er-step-text-active);
+  --rb-reg-step-connector: var(--er-step-connector);
+  --rb-reg-summary-bg: var(--er-surface-muted);
+  --rb-reg-summary-border: var(--er-border);
+  --rb-reg-focus-ring: var(--er-focus-ring);
+  --rb-reg-shell-line: var(--er-shell-line);
 }
 `;
 }
@@ -42482,25 +42540,40 @@ ${root} {
   --ab-info-bg: rgba(var(--tb-info), 0.1);
   --ab-info-text: rgb(var(--tb-info));
 
-  /* Loading/muted states */
+  /* Muted summary state */
   --ab-muted-bg: rgba(var(--tb-text), 0.05);
-  --ab-muted-text: rgba(var(--tb-text), 0.6);
-  --ab-spinner-color: rgb(var(--tb-primary));
 
-  /* Form elements */
-  --ab-input-border: rgb(var(--tb-border));
+  /* Focus ring used by shared registration-surface controls */
   --ab-input-focus-ring: rgba(var(--tb-primary), 0.3);
 
-  /* Buttons */
-  --ab-btn-primary-bg: rgb(var(--tb-primary));
-  --ab-btn-primary-text: rgb(var(--tb-background));
-  --ab-btn-primary-hover: rgba(var(--tb-primary), 0.9);
-  --ab-btn-secondary-border: rgb(var(--tb-border));
-  --ab-btn-secondary-hover: rgba(var(--tb-text), 0.05);
-
-  /* Text opacity levels */
-  --ab-text-muted-opacity: 0.6;
-  --ab-text-faint-opacity: 0.4;
+  /* Shared registration-surface mappings (issue 1174).
+     Route the shared --rb-reg-* contract through this block's Tier 3 vars
+     (palette tokens where no --ab-* var exists) so --ab-* overrides keep
+     working as the block adopts the shared classes. */
+  --rb-reg-radius: var(--ab-card-radius, var(--rb-block-radius));
+  --rb-reg-border: var(--ab-card-border);
+  --rb-reg-border-hover: var(--ab-card-border-hover);
+  --rb-reg-border-selected: var(--ab-card-border-selected);
+  --rb-reg-bg-selected: var(--ab-card-bg-selected);
+  --rb-reg-option-bg: transparent;
+  --rb-reg-option-hover-shadow: 0 8px 18px rgba(var(--tb-shadow, 15 23 42), 0.08);
+  --rb-reg-surface-bg: rgb(var(--tb-surface));
+  --rb-reg-on-surface: rgb(var(--tb-onSurface, var(--tb-text)));
+  --rb-reg-on-surface-muted: rgba(var(--tb-onSurface, var(--tb-text)), 0.7);
+  --rb-reg-on-surface-subtle: rgba(var(--tb-onSurface, var(--tb-text)), 0.6);
+  --rb-reg-on-surface-faint: rgba(var(--tb-onSurface, var(--tb-text)), 0.5);
+  --rb-reg-check-bg: var(--ab-check-bg);
+  --rb-reg-check-text: var(--ab-check-text);
+  --rb-reg-step-active: rgb(var(--tb-primary));
+  --rb-reg-step-completed: rgb(var(--tb-success));
+  --rb-reg-step-inactive: rgb(var(--tb-mutedText));
+  --rb-reg-step-text: rgb(255 255 255);
+  --rb-reg-step-text-active: rgb(var(--tb-primaryText, 255 255 255));
+  --rb-reg-step-connector: rgba(var(--tb-border), 0.5);
+  --rb-reg-summary-bg: var(--ab-muted-bg);
+  --rb-reg-summary-border: var(--ab-card-border);
+  --rb-reg-focus-ring: var(--ab-input-focus-ring);
+  --rb-reg-shell-line: rgba(var(--tb-mutedText, 100 116 139), 0.22);
 }
 `;
 }
@@ -42791,6 +42864,35 @@ ${root} {
   /* Summary */
   --cr-summary-bg: rgba(var(--tb-primary), 0.1);
   --cr-summary-border: rgb(var(--tb-border));
+
+  /* Shared registration-surface mappings (issue 1174).
+     Route the shared --rb-reg-* contract through this block's Tier 3 vars
+     (palette tokens where no --cr-* var exists) so existing --cr-* overrides
+     keep working unchanged. */
+  --rb-reg-radius: var(--rb-block-radius);
+  --rb-reg-border: var(--cr-border);
+  --rb-reg-border-hover: var(--cr-border-hover);
+  --rb-reg-border-selected: var(--cr-border-selected);
+  --rb-reg-bg-selected: var(--cr-payment-bg-selected);
+  --rb-reg-option-bg: rgb(var(--tb-background));
+  --rb-reg-option-hover-shadow: 0 8px 18px rgba(var(--tb-shadow, 15 23 42), 0.08);
+  --rb-reg-surface-bg: rgb(var(--tb-surface));
+  --rb-reg-on-surface: var(--cr-on-surface);
+  --rb-reg-on-surface-muted: rgba(var(--tb-onSurface, var(--tb-text)), 0.7);
+  --rb-reg-on-surface-subtle: rgba(var(--tb-onSurface, var(--tb-text)), 0.6);
+  --rb-reg-on-surface-faint: rgba(var(--tb-onSurface, var(--tb-text)), 0.5);
+  --rb-reg-check-bg: var(--cr-check-bg);
+  --rb-reg-check-text: var(--cr-check-text);
+  --rb-reg-step-active: var(--cr-step-active);
+  --rb-reg-step-completed: var(--cr-step-completed);
+  --rb-reg-step-inactive: var(--cr-step-inactive);
+  --rb-reg-step-text: var(--cr-step-text);
+  --rb-reg-step-text-active: var(--cr-step-text-active);
+  --rb-reg-step-connector: var(--cr-step-connector);
+  --rb-reg-summary-bg: var(--cr-summary-bg);
+  --rb-reg-summary-border: var(--cr-summary-border);
+  --rb-reg-focus-ring: var(--cr-focus-ring);
+  --rb-reg-shell-line: rgba(var(--tb-mutedText, 100 116 139), 0.22);
 }
 `;
 }
@@ -44690,8 +44792,8 @@ var TEMPLATE_BINDING_META_PATHS = [
   "createdAt",
   "updatedAt"
 ];
-function describeInvalidTemplateBindingMetaPath(path32) {
-  return `Meta path "${path32}" is not valid. Allowed: ${TEMPLATE_BINDING_META_PATHS.join(", ")}`;
+function describeInvalidTemplateBindingMetaPath(path33) {
+  return `Meta path "${path33}" is not valid. Allowed: ${TEMPLATE_BINDING_META_PATHS.join(", ")}`;
 }
 
 // ../content-model/src/routeTemplate.ts
@@ -45103,7 +45205,7 @@ var contentConfigSchema = contentConfigBaseSchema.superRefine((data, ctx) => {
       });
     }
     const paths = data.pages.map((p) => p.path);
-    const duplicatePaths = paths.filter((path32, i) => paths.indexOf(path32) !== i);
+    const duplicatePaths = paths.filter((path33, i) => paths.indexOf(path33) !== i);
     if (duplicatePaths.length > 0) {
       ctx.addIssue({
         code: z.ZodIssueCode.custom,
@@ -45160,18 +45262,18 @@ function validateLayoutNodeTypes(layout) {
     errors
   };
 }
-function validateNodeTypesRecursive(node, path32, errors) {
+function validateNodeTypesRecursive(node, path33, errors) {
   if (!ALLOWED_NODE_TYPES_SET.has(node.type)) {
     errors.push({
-      path: `${path32}.type`,
+      path: `${path33}.type`,
       type: "invalid_node_type",
       value: node.type,
-      message: `Unknown node type "${node.type}" at ${path32}. Valid types: section, stack, text, etc.`
+      message: `Unknown node type "${node.type}" at ${path33}. Valid types: section, stack, text, etc.`
     });
   }
   if (node.children && Array.isArray(node.children)) {
     node.children.forEach((child, index) => {
-      validateNodeTypesRecursive(child, `${path32}.children[${index}]`, errors);
+      validateNodeTypesRecursive(child, `${path33}.children[${index}]`, errors);
     });
   }
 }
@@ -45183,45 +45285,45 @@ function validateTransformIds(layout) {
     errors
   };
 }
-function validateTransformIdsRecursive(node, path32, errors) {
+function validateTransformIdsRecursive(node, path33, errors) {
   if (node.$bind?.transforms && Array.isArray(node.$bind.transforms)) {
-    validateTransformList(node.$bind.transforms, `${path32}.$bind.transforms`, errors);
+    validateTransformList(node.$bind.transforms, `${path33}.$bind.transforms`, errors);
   }
   if (node.$repeat?.collection?.transforms && Array.isArray(node.$repeat.collection.transforms)) {
-    validateTransformList(node.$repeat.collection.transforms, `${path32}.$repeat.collection.transforms`, errors);
+    validateTransformList(node.$repeat.collection.transforms, `${path33}.$repeat.collection.transforms`, errors);
   }
   if (node.$when?.when?.transforms && Array.isArray(node.$when.when.transforms)) {
-    validateTransformList(node.$when.when.transforms, `${path32}.$when.when.transforms`, errors);
+    validateTransformList(node.$when.when.transforms, `${path33}.$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, `${path32}.$scopes[${index}].from.transforms`, errors);
+        validateTransformList(scope.from.transforms, `${path33}.$scopes[${index}].from.transforms`, errors);
       }
     });
   }
   if (node.props) {
-    validatePropsTransforms(node.props, `${path32}.props`, errors);
+    validatePropsTransforms(node.props, `${path33}.props`, errors);
   }
   if (node.children && Array.isArray(node.children)) {
     node.children.forEach((child, index) => {
-      validateTransformIdsRecursive(child, `${path32}.children[${index}]`, errors);
+      validateTransformIdsRecursive(child, `${path33}.children[${index}]`, errors);
     });
   }
 }
-function validateTransformList(transforms, path32, errors) {
+function validateTransformList(transforms, path33, errors) {
   transforms.forEach((transform, index) => {
     if (!ALLOWED_TRANSFORM_IDS_SET.has(transform.id)) {
       errors.push({
-        path: `${path32}[${index}].id`,
+        path: `${path33}[${index}].id`,
         type: "invalid_transform_id",
         value: transform.id,
-        message: `Unknown transform "${transform.id}" at ${path32}. Valid transforms: string.uppercase, value.fallback, etc.`
+        message: `Unknown transform "${transform.id}" at ${path33}. Valid transforms: string.uppercase, value.fallback, etc.`
       });
     }
   });
 }
-function validatePropsTransforms(props2, path32, errors) {
+function validatePropsTransforms(props2, path33, errors) {
   for (const [key, value] of Object.entries(props2)) {
     if (isBindingObject(value)) {
       const binding = value;
@@ -45229,16 +45331,16 @@ function validatePropsTransforms(props2, path32, errors) {
         binding.$bind.transforms.forEach((transform, index) => {
           if (!ALLOWED_TRANSFORM_IDS_SET.has(transform.id)) {
             errors.push({
-              path: `${path32}.${key}.$bind.transforms[${index}].id`,
+              path: `${path33}.${key}.$bind.transforms[${index}].id`,
               type: "invalid_transform_id",
               value: transform.id,
-              message: `Unknown transform "${transform.id}" at ${path32}.${key}. Valid transforms: string.uppercase, value.fallback, etc.`
+              message: `Unknown transform "${transform.id}" at ${path33}.${key}. Valid transforms: string.uppercase, value.fallback, etc.`
             });
           }
         });
       }
     } else if (value && typeof value === "object" && !Array.isArray(value)) {
-      validatePropsTransforms(value, `${path32}.${key}`, errors);
+      validatePropsTransforms(value, `${path33}.${key}`, errors);
     }
   }
 }
@@ -45791,8 +45893,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, path32, options) {
-    let url = `${baseUrl}${path32}`;
+  async function request(method, path33, options) {
+    let url = `${baseUrl}${path33}`;
     if (options?.params && Object.keys(options.params).length > 0) {
       const searchParams = new URLSearchParams(options.params);
       url = `${url}?${searchParams.toString()}`;
@@ -45815,7 +45917,7 @@ function createHttpClient(config2) {
     } catch (error) {
       const requestInfo2 = buildRequestInfo({
         method,
-        path: path32,
+        path: path33,
         url,
         baseUrl,
         dashboardUrl: config2.dashboardUrl,
@@ -45840,7 +45942,7 @@ function createHttpClient(config2) {
     }
     const requestInfo = buildRequestInfo({
       method,
-      path: path32,
+      path: path33,
       url,
       baseUrl,
       dashboardUrl: config2.dashboardUrl,
@@ -45870,17 +45972,17 @@ function createHttpClient(config2) {
     return json.data;
   }
   return {
-    async get(path32, params) {
-      return request("GET", path32, { params });
+    async get(path33, params) {
+      return request("GET", path33, { params });
     },
-    async post(path32, body) {
-      return request("POST", path32, { body });
+    async post(path33, body) {
+      return request("POST", path33, { body });
     },
-    async patch(path32, body) {
-      return request("PATCH", path32, { body });
+    async patch(path33, body) {
+      return request("PATCH", path33, { body });
     },
-    async delete(path32, body) {
-      await request("DELETE", path32, { body });
+    async delete(path33, body) {
+      await request("DELETE", path33, { body });
     }
   };
 }
@@ -46983,7 +47085,7 @@ function formatDateShort(isoDate) {
 }
 async function parseJsonData(options) {
   if (options.file) {
-    const filePath = path20.resolve(options.file);
+    const filePath = path21.resolve(options.file);
     const content = await fs2.readFile(filePath, "utf-8");
     return JSON.parse(content);
   }
@@ -47361,12 +47463,12 @@ function formatPushConfigActionFailure() {
 async function pushToDashboard(output, dashboardUrl, siteId, apiKey, config2, options) {
   const normalizedDashboardUrl = dashboardUrl.replace(/\/+$/, "");
   const baseUrl = `${normalizedDashboardUrl}/api`;
-  const path32 = `/sites/${siteId}/sdk-config`;
-  const pushUrl = `${baseUrl}${path32}`;
+  const path33 = `/sites/${siteId}/sdk-config`;
+  const pushUrl = `${baseUrl}${path33}`;
   output.info(`${options?.dryRun ? "Previewing" : "Pushing"} config at ${pushUrl}...`);
   const requestInfo = {
     method: "POST",
-    path: path32,
+    path: path33,
     url: pushUrl,
     baseUrl,
     dashboardUrl: normalizedDashboardUrl,
@@ -47773,6 +47875,18 @@ function stripEnvSpecificMediaFieldsInPlace(value) {
     stripEnvSpecificMediaFieldsInPlace(entry);
   }
 }
+
+// src/cli/merge-remote/entryLocal.ts
+function pulledEntryToLocalEntry(entry) {
+  return {
+    identifier: entry.identifier,
+    data: entry.data,
+    status: entry.status,
+    hasUnpublishedChanges: entry.hasUnpublishedChanges,
+    ...entry.slug !== void 0 ? { slug: entry.slug } : {},
+    ...entry.blocks !== void 0 ? { blocks: entry.blocks } : {}
+  };
+}
 async function fileExists(filePath) {
   try {
     await fs2.access(filePath);
@@ -47792,7 +47906,7 @@ async function isDirectory(dirPath) {
 async function listFiles(dirPath, extension) {
   try {
     const files = await fs2.readdir(dirPath);
-    return files.filter((f) => f.endsWith(extension)).map((f) => path20.join(dirPath, f));
+    return files.filter((f) => f.endsWith(extension)).map((f) => path21.join(dirPath, f));
   } catch (error) {
     const nodeError = error;
     if (nodeError.code === "ENOENT") {
@@ -47811,9 +47925,9 @@ async function writeJsonFile(filePath, data) {
 }
 async function writeJsonFileAtomic(filePath, data) {
   const content = JSON.stringify(data, null, 2) + "\n";
-  const tmpPath = path20.join(
-    path20.dirname(filePath),
-    `.${path20.basename(filePath)}.${process.pid}.${Date.now()}.tmp`
+  const tmpPath = path21.join(
+    path21.dirname(filePath),
+    `.${path21.basename(filePath)}.${process.pid}.${Date.now()}.tmp`
   );
   try {
     await fs2.writeFile(tmpPath, content, "utf-8");
@@ -47833,80 +47947,101 @@ async function ensureDir(dirPath) {
   }
 }
 
-// src/cli/merge-remote/entryLocal.ts
-function pulledEntryToLocalEntry(entry) {
+// src/cli/merge-remote/sharedBaseSnapshots.ts
+function baseSnapshotRoot(contentDir, baseKind) {
+  return path21.join(contentDir, ".riverbank", "merge-remote", baseKind);
+}
+function baseSnapshotStoredTarget(target) {
   return {
-    identifier: entry.identifier,
-    data: entry.data,
-    status: entry.status,
-    hasUnpublishedChanges: entry.hasUnpublishedChanges,
-    ...entry.slug !== void 0 ? { slug: entry.slug } : {},
-    ...entry.blocks !== void 0 ? { blocks: entry.blocks } : {}
+    env: target.env,
+    siteIdHash: siteIdHash(target.siteId)
   };
 }
+function siteScopedSnapshotDir(input) {
+  return path21.join(input.rootDir, input.target.env, siteIdHash(input.target.siteId), input.leafDir);
+}
+async function writeBaseSnapshots(input) {
+  await ensureLocalOnlySnapshotRoot(input.contentDir);
+  await ensureDir(input.snapshotDir);
+  const writtenFileNames = [];
+  for (const item of input.items) {
+    const snapshot = input.toSnapshot(item);
+    const fileName = input.fileNameForSnapshot(snapshot);
+    writtenFileNames.push(fileName);
+    await writeJsonFile(path21.join(input.snapshotDir, fileName), snapshot);
+  }
+  if (input.cleanupMissing !== false) {
+    await removeMissingSnapshotFiles(
+      input.snapshotDir,
+      new Set(writtenFileNames)
+    );
+  }
+  return {
+    rootDir: input.rootDir,
+    count: input.items.length
+  };
+}
+async function readBaseSnapshot(snapshotPath) {
+  try {
+    return await readJsonFile(snapshotPath);
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+function encodeSnapshotPathPart(value) {
+  return encodeURIComponent(value).replace(/\./gu, "%2E");
+}
+async function ensureLocalOnlySnapshotRoot(contentDir) {
+  const localRoot = path21.join(contentDir, ".riverbank");
+  await ensureDir(localRoot);
+  await writeFile(path21.join(localRoot, ".gitignore"), "*\n!.gitignore\n", "utf-8");
+}
+async function removeMissingSnapshotFiles(snapshotDir, expectedFileNames) {
+  for (const existingFile of await listFiles(snapshotDir, ".json")) {
+    if (!expectedFileNames.has(path21.basename(existingFile))) {
+      await unlink(existingFile);
+    }
+  }
+}
+function siteIdHash(siteId) {
+  return createHash("sha256").update(siteId).digest("hex").slice(0, 16);
+}
 
 // src/cli/merge-remote/entrySnapshots.ts
 var SNAPSHOT_VERSION = "entry-base.v1";
 function entryBaseSnapshotRoot(contentDir) {
-  return path20.join(contentDir, ".riverbank", "merge-remote", "entry-bases");
+  return baseSnapshotRoot(contentDir, "entry-bases");
 }
 function entryBaseSnapshotPath(input) {
-  return path20.join(
-    entryBaseSnapshotRoot(input.contentDir),
-    input.target.env,
-    siteIdHash(input.target.siteId),
-    "entries",
-    encodePathPart(input.subject.contentType),
-    `${encodePathPart(input.subject.identifier)}.json`
+  return path21.join(
+    entrySnapshotTypeDir(input),
+    `${entrySnapshotFileName(input.subject.identifier)}`
   );
 }
 async function writeEntryBaseSnapshots(input) {
-  await ensureLocalOnlySnapshotRoot(input.contentDir);
-  const typeDir = path20.dirname(entryBaseSnapshotPath({
+  const typeDir = entrySnapshotTypeDir({
     contentDir: input.contentDir,
     target: input.target,
-    subject: {
-      contentType: input.contentType,
-      identifier: "__placeholder__"
-    }
-  }));
-  await ensureDir(typeDir);
-  for (const entry of input.entries) {
-    const snapshot = toEntryBaseSnapshot({
+    subject: { contentType: input.contentType }
+  });
+  return writeBaseSnapshots({
+    contentDir: input.contentDir,
+    rootDir: entryBaseSnapshotRoot(input.contentDir),
+    snapshotDir: typeDir,
+    items: input.entries,
+    toSnapshot: (entry) => toEntryBaseSnapshot({
       target: input.target,
       contentType: input.contentType,
       entry,
       meta: input.meta
-    });
-    await writeJsonFile(
-      entryBaseSnapshotPath({
-        contentDir: input.contentDir,
-        target: input.target,
-        subject: snapshot.subject
-      }),
-      snapshot
-    );
-  }
-  if (input.cleanupMissing !== false) {
-    const expectedFiles = new Set(input.entries.map((entry) => `${encodePathPart(entry.identifier)}.json`));
-    for (const existingFile of await listFiles(typeDir, ".json")) {
-      if (!expectedFiles.has(path20.basename(existingFile))) {
-        await unlink(existingFile);
-      }
-    }
-  }
-  return {
-    rootDir: entryBaseSnapshotRoot(input.contentDir),
-    count: input.entries.length
-  };
+    }),
+    fileNameForSnapshot: (snapshot) => entrySnapshotFileName(snapshot.subject.identifier),
+    cleanupMissing: input.cleanupMissing
+  });
 }
 async function readEntryBaseSnapshot(input) {
-  try {
-    return await readJsonFile(entryBaseSnapshotPath(input));
-  } catch (error) {
-    if (error.code === "ENOENT") return null;
-    throw error;
-  }
+  return readBaseSnapshot(entryBaseSnapshotPath(input));
 }
 function toEntryBaseSnapshot(input) {
   const remoteVersion = input.meta.entries[input.entry.identifier];
@@ -47915,10 +48050,7 @@ function toEntryBaseSnapshot(input) {
   }
   return {
     version: SNAPSHOT_VERSION,
-    target: {
-      env: input.target.env,
-      siteIdHash: siteIdHash(input.target.siteId)
-    },
+    target: baseSnapshotStoredTarget(input.target),
     subject: {
       contentType: input.contentType,
       identifier: input.entry.identifier
@@ -47928,16 +48060,18 @@ function toEntryBaseSnapshot(input) {
     entry: pulledEntryToLocalEntry(input.entry)
   };
 }
-async function ensureLocalOnlySnapshotRoot(contentDir) {
-  const localRoot = path20.join(contentDir, ".riverbank");
-  await ensureDir(localRoot);
-  await writeFile(path20.join(localRoot, ".gitignore"), "*\n!.gitignore\n", "utf-8");
-}
-function siteIdHash(siteId) {
-  return createHash("sha256").update(siteId).digest("hex").slice(0, 16);
+function entrySnapshotTypeDir(input) {
+  return path21.join(
+    siteScopedSnapshotDir({
+      rootDir: entryBaseSnapshotRoot(input.contentDir),
+      target: input.target,
+      leafDir: "entries"
+    }),
+    encodeSnapshotPathPart(input.subject.contentType)
+  );
 }
-function encodePathPart(value) {
-  return encodeURIComponent(value).replace(/\./gu, "%2E");
+function entrySnapshotFileName(identifier) {
+  return `${encodeSnapshotPathPart(identifier)}.json`;
 }
 
 // src/cli/merge-remote/pageLocal.ts
@@ -47963,68 +48097,40 @@ function pulledPageToLocalPage(page) {
 // src/cli/merge-remote/pageSnapshots.ts
 var SNAPSHOT_VERSION2 = "page-base.v1";
 function pageBaseSnapshotRoot(contentDir) {
-  return path20.join(contentDir, ".riverbank", "merge-remote", "page-bases");
+  return baseSnapshotRoot(contentDir, "page-bases");
 }
 function pageBaseSnapshotPath(input) {
-  return path20.join(
-    pageBaseSnapshotRoot(input.contentDir),
-    input.target.env,
-    siteIdHash2(input.target.siteId),
-    "pages",
-    `${encodePathPart2(input.subject.identifier)}.json`
+  return path21.join(
+    pageSnapshotDir(input),
+    pageSnapshotFileName(input.subject.identifier)
   );
 }
 async function writePageBaseSnapshots(input) {
-  await ensureLocalOnlySnapshotRoot2(input.contentDir);
-  const pagesDir = path20.dirname(pageBaseSnapshotPath({
+  const pagesDir = pageSnapshotDir({
     contentDir: input.contentDir,
-    target: input.target,
-    subject: { identifier: "__placeholder__" }
-  }));
-  await ensureDir(pagesDir);
-  for (const page of input.pages) {
-    const snapshot = toPageBaseSnapshot({
+    target: input.target
+  });
+  return writeBaseSnapshots({
+    contentDir: input.contentDir,
+    rootDir: pageBaseSnapshotRoot(input.contentDir),
+    snapshotDir: pagesDir,
+    items: input.pages,
+    toSnapshot: (page) => toPageBaseSnapshot({
       target: input.target,
       page,
       meta: input.meta
-    });
-    await writeJsonFile(
-      pageBaseSnapshotPath({
-        contentDir: input.contentDir,
-        target: input.target,
-        subject: snapshot.subject
-      }),
-      snapshot
-    );
-  }
-  if (input.cleanupMissing !== false) {
-    const expectedFiles = new Set(input.pages.map((page) => `${encodePathPart2(page.identifier)}.json`));
-    for (const existingFile of await listFiles(pagesDir, ".json")) {
-      if (!expectedFiles.has(path20.basename(existingFile))) {
-        await unlink(existingFile);
-      }
-    }
-  }
-  return {
-    rootDir: pageBaseSnapshotRoot(input.contentDir),
-    count: input.pages.length
-  };
+    }),
+    fileNameForSnapshot: (snapshot) => pageSnapshotFileName(snapshot.subject.identifier),
+    cleanupMissing: input.cleanupMissing
+  });
 }
 async function readPageBaseSnapshot(input) {
-  try {
-    return await readJsonFile(pageBaseSnapshotPath(input));
-  } catch (error) {
-    if (error.code === "ENOENT") return null;
-    throw error;
-  }
+  return readBaseSnapshot(pageBaseSnapshotPath(input));
 }
 function toPageBaseSnapshot(input) {
   return {
     version: SNAPSHOT_VERSION2,
-    target: {
-      env: input.target.env,
-      siteIdHash: siteIdHash2(input.target.siteId)
-    },
+    target: baseSnapshotStoredTarget(input.target),
     subject: {
       identifier: input.page.identifier
     },
@@ -48037,22 +48143,21 @@ function toPageBaseSnapshot(input) {
     page: pulledPageToLocalPage(input.page)
   };
 }
-async function ensureLocalOnlySnapshotRoot2(contentDir) {
-  const localRoot = path20.join(contentDir, ".riverbank");
-  await ensureDir(localRoot);
-  await writeFile(path20.join(localRoot, ".gitignore"), "*\n!.gitignore\n", "utf-8");
-}
-function siteIdHash2(siteId) {
-  return createHash("sha256").update(siteId).digest("hex").slice(0, 16);
+function pageSnapshotDir(input) {
+  return siteScopedSnapshotDir({
+    rootDir: pageBaseSnapshotRoot(input.contentDir),
+    target: input.target,
+    leafDir: "pages"
+  });
 }
-function encodePathPart2(value) {
-  return encodeURIComponent(value).replace(/\./gu, "%2E");
+function pageSnapshotFileName(identifier) {
+  return `${encodeSnapshotPathPart(identifier)}.json`;
 }
 function entryTypeDirPath(contentDir, contentType) {
-  return path20.join(contentDir, "entries", contentType);
+  return path21.join(contentDir, "entries", contentType);
 }
 function entryFilePath(input) {
-  return path20.join(entryTypeDirPath(input.contentDir, input.contentType), `${input.identifier}.json`);
+  return path21.join(entryTypeDirPath(input.contentDir, input.contentType), `${input.identifier}.json`);
 }
 var TARGET_MARKER_FILE = "_target.json";
 var metadataTargetMarkerSchema = z.object({
@@ -48069,23 +48174,23 @@ function metadataTargetFromEnvironment(env, environment) {
   };
 }
 function legacyMetadataDir(contentDir) {
-  return path20.join(contentDir, ".meta");
+  return path21.join(contentDir, ".meta");
 }
 function scopedMetadataDir(contentDir, target) {
-  return path20.join(contentDir, ".meta", target.env);
+  return path21.join(contentDir, ".meta", target.env);
 }
 function metadataFilePath(contentDir, fileName, target) {
   const dir = target ? scopedMetadataDir(contentDir, target) : legacyMetadataDir(contentDir);
-  return path20.join(dir, fileName);
+  return path21.join(dir, fileName);
 }
 function legacyMetadataFilePath(contentDir, fileName) {
-  return path20.join(legacyMetadataDir(contentDir), fileName);
+  return path21.join(legacyMetadataDir(contentDir), fileName);
 }
 async function ensureMetadataDir(contentDir, target) {
   const dir = target ? scopedMetadataDir(contentDir, target) : legacyMetadataDir(contentDir);
   await ensureDir(dir);
   if (target) {
-    await writeJsonFile(path20.join(dir, TARGET_MARKER_FILE), markerFromTarget(target));
+    await writeJsonFile(path21.join(dir, TARGET_MARKER_FILE), markerFromTarget(target));
   }
   return dir;
 }
@@ -48141,7 +48246,7 @@ async function resolveMetadataReadPath(contentDir, fileName, target) {
   if (await hasMismatchedTargetMarker(scopedDir, target)) {
     return null;
   }
-  const scopedPath = await existingFilePath(path20.join(scopedDir, fileName), "scoped");
+  const scopedPath = await existingFilePath(path21.join(scopedDir, fileName), "scoped");
   if (scopedPath) return scopedPath;
   return existingFilePath(legacyMetadataFilePath(contentDir, fileName), "legacy");
 }
@@ -48165,7 +48270,7 @@ async function existingFilePath(filePath, source) {
 async function hasMismatchedTargetMarker(dir, target) {
   let parsed;
   try {
-    const content = await fs2.readFile(path20.join(dir, TARGET_MARKER_FILE), "utf-8");
+    const content = await fs2.readFile(path21.join(dir, TARGET_MARKER_FILE), "utf-8");
     const result = metadataTargetMarkerSchema.safeParse(JSON.parse(content));
     if (!result.success) return false;
     parsed = result.data;
@@ -48201,7 +48306,7 @@ function parseThemeMeta(value) {
   return { pulledAt: value.pulledAt, themes: value.themes };
 }
 async function writeEntries(contentDir, pulledEntries, options) {
-  const entriesDir = path20.join(contentDir, "entries");
+  const entriesDir = path21.join(contentDir, "entries");
   const { contentType, entries, meta } = pulledEntries;
   const typeDir = entryTypeDirPath(contentDir, contentType);
   await ensureDir(typeDir);
@@ -48215,13 +48320,13 @@ async function writeEntries(contentDir, pulledEntries, options) {
     const existingFiles = await listFiles(typeDir, ".json");
     const newIdentifiers = new Set(entries.map((e) => `${e.identifier}.json`));
     for (const existingFile of existingFiles) {
-      const filename = path20.basename(existingFile);
+      const filename = path21.basename(existingFile);
       if (!newIdentifiers.has(filename)) {
         await fs2.unlink(existingFile);
       }
     }
   }
-  const oldFormatFile = path20.join(entriesDir, `${contentType}.json`);
+  const oldFormatFile = path21.join(entriesDir, `${contentType}.json`);
   try {
     await fs2.unlink(oldFormatFile);
   } catch (error) {
@@ -48273,12 +48378,12 @@ async function writeEntries(contentDir, pulledEntries, options) {
   return { dirPath: typeDir, metaPath, count: entries.length };
 }
 async function writePages(contentDir, pulledPages, options) {
-  const pagesDir = path20.join(contentDir, "pages");
+  const pagesDir = path21.join(contentDir, "pages");
   await ensureDir(pagesDir);
   const filePaths = [];
   const pagesMeta = {};
   for (const page of pulledPages.pages) {
-    const filePath = path20.join(pagesDir, `${page.identifier}.json`);
+    const filePath = path21.join(pagesDir, `${page.identifier}.json`);
     const localPage = convertPulledPagesToLocal([page])[0];
     if (!localPage) continue;
     stripEnvSpecificMediaFieldsInPlace(localPage);
@@ -48320,7 +48425,7 @@ async function writePages(contentDir, pulledPages, options) {
 }
 async function writeNavigation(contentDir, pulledNavigation, options) {
   await ensureDir(contentDir);
-  const filePath = path20.join(contentDir, "navigation.json");
+  const filePath = path21.join(contentDir, "navigation.json");
   const localNavigation = convertPulledNavigationToLocal(pulledNavigation.menus);
   stripEnvSpecificMediaFieldsInPlace(localNavigation);
   await writeJsonFile(filePath, localNavigation);
@@ -48342,7 +48447,7 @@ async function writeNavigation(contentDir, pulledNavigation, options) {
 }
 async function writeSettings(contentDir, pulledSettings, options) {
   await ensureDir(contentDir);
-  const filePath = path20.join(contentDir, "settings.json");
+  const filePath = path21.join(contentDir, "settings.json");
   stripEnvSpecificMediaFieldsInPlace(pulledSettings.settings);
   await writeJsonFile(filePath, pulledSettings.settings);
   if (!options?.skipMeta) {
@@ -48354,12 +48459,12 @@ async function writeSettings(contentDir, pulledSettings, options) {
   return filePath;
 }
 async function writeForms(contentDir, pulledForms, options) {
-  const formsDir = path20.join(contentDir, "forms");
+  const formsDir = path21.join(contentDir, "forms");
   await ensureDir(formsDir);
   const filePaths = [];
   const formsMeta = {};
   for (const form2 of pulledForms.forms) {
-    const filePath = path20.join(formsDir, `${form2.slug}.json`);
+    const filePath = path21.join(formsDir, `${form2.slug}.json`);
     const formPayload = {
       slug: form2.slug,
       name: form2.name,
@@ -48384,9 +48489,9 @@ async function writeForms(contentDir, pulledForms, options) {
   return { filePaths, metaPath };
 }
 async function writeTheme(contentDir, theme, themeName) {
-  const themesDir = path20.join(contentDir, "themes");
+  const themesDir = path21.join(contentDir, "themes");
   await ensureDir(themesDir);
-  const filePath = path20.join(themesDir, `${themeName}.json`);
+  const filePath = path21.join(themesDir, `${themeName}.json`);
   await writeJsonFile(filePath, theme);
   return filePath;
 }
@@ -48417,12 +48522,12 @@ async function writePulledTheme(contentDir, pulledTheme, themeName = "current",
   return { filePath, metaPath };
 }
 async function writeVenues(contentDir, pulledVenues, options) {
-  const venuesDir = path20.join(contentDir, "venues");
+  const venuesDir = path21.join(contentDir, "venues");
   await ensureDir(venuesDir);
   const filePaths = [];
   const venuesMeta = {};
   for (const venue of pulledVenues.venues) {
-    const filePath = path20.join(venuesDir, `${venue.slug}.json`);
+    const filePath = path21.join(venuesDir, `${venue.slug}.json`);
     await writeJsonFile(filePath, {
       slug: venue.slug,
       title: venue.title,
@@ -48449,12 +48554,12 @@ async function writeVenues(contentDir, pulledVenues, options) {
   return { filePaths, metaPath };
 }
 async function writeEventCategories(contentDir, pulledCategories, options) {
-  const categoriesDir = path20.join(contentDir, "event-categories");
+  const categoriesDir = path21.join(contentDir, "event-categories");
   await ensureDir(categoriesDir);
   const filePaths = [];
   const categoriesMeta = {};
   for (const category of pulledCategories.eventCategories) {
-    const filePath = path20.join(categoriesDir, `${category.identifier}.json`);
+    const filePath = path21.join(categoriesDir, `${category.identifier}.json`);
     await writeJsonFile(filePath, {
       identifier: category.identifier,
       name: category.name,
@@ -48478,12 +48583,12 @@ async function writeEventCategories(contentDir, pulledCategories, options) {
   return { filePaths, metaPath };
 }
 async function writeEvents(contentDir, pulledEvents, options) {
-  const eventsDir = path20.join(contentDir, "events");
+  const eventsDir = path21.join(contentDir, "events");
   await ensureDir(eventsDir);
   const filePaths = [];
   const eventsMeta = {};
   for (const event of pulledEvents.events) {
-    const filePath = path20.join(eventsDir, `${event.identifier}.json`);
+    const filePath = path21.join(eventsDir, `${event.identifier}.json`);
     const eventPayload = toWritableLocalEvent(event);
     stripEnvSpecificMediaFieldsInPlace(eventPayload);
     await writeJsonFile(filePath, eventPayload);
@@ -48530,12 +48635,12 @@ function toWritableLocalEvent(event) {
   };
 }
 async function writeCourses(contentDir, pulledCourses, options) {
-  const coursesDir = path20.join(contentDir, "courses");
+  const coursesDir = path21.join(contentDir, "courses");
   await ensureDir(coursesDir);
   const filePaths = [];
   const coursesMeta = {};
   for (const course of pulledCourses.courses) {
-    const filePath = path20.join(coursesDir, `${course.identifier}.json`);
+    const filePath = path21.join(coursesDir, `${course.identifier}.json`);
     const coursePayload = {
       identifier: course.identifier,
       title: course.title,
@@ -48573,7 +48678,7 @@ async function writeCourses(contentDir, pulledCourses, options) {
 }
 async function writeFooter(contentDir, pulledFooter, options) {
   await ensureDir(contentDir);
-  const filePath = path20.join(contentDir, "footer.json");
+  const filePath = path21.join(contentDir, "footer.json");
   const localFooter = pulledFooter.footer ? convertPulledFooterToLocal(pulledFooter.footer) : {};
   stripEnvSpecificMediaFieldsInPlace(localFooter);
   await writeJsonFile(filePath, localFooter);
@@ -48648,7 +48753,7 @@ async function updateMetadataAfterPush(contentDir, remoteContent, options) {
   }
 }
 var MANIFEST_VERSION = 2;
-var getManifestPath = (contentDir) => path20.join(contentDir, "media", ".manifest.json");
+var getManifestPath = (contentDir) => path21.join(contentDir, "media", ".manifest.json");
 var ensureDir2 = async (dirPath) => {
   try {
     await fs2.mkdir(dirPath, { recursive: true });
@@ -48707,7 +48812,7 @@ async function readMediaManifest(contentDir) {
   return createEmptyMediaManifest();
 }
 async function writeMediaManifest(contentDir, manifest) {
-  const mediaDir = path20.join(contentDir, "media");
+  const mediaDir = path21.join(contentDir, "media");
   await ensureDir2(mediaDir);
   const updatedManifest = {
     ...manifest,
@@ -48760,12 +48865,12 @@ async function readEntriesFromDirectory(dirPath) {
   return entries;
 }
 async function findLegacyEntryFiles(contentDir) {
-  const entriesDir = path20.join(contentDir, "entries");
+  const entriesDir = path21.join(contentDir, "entries");
   const legacyFiles = [];
   try {
     const items = await fs2.readdir(entriesDir);
     for (const item of items) {
-      const itemPath = path20.join(entriesDir, item);
+      const itemPath = path21.join(entriesDir, item);
       if (item.endsWith(".json") && !await isDirectory(itemPath)) {
         legacyFiles.push(itemPath);
       }
@@ -48776,7 +48881,7 @@ async function findLegacyEntryFiles(contentDir) {
   return legacyFiles;
 }
 async function readEntries(contentDir, contentType, metadataTarget) {
-  const entriesDir = path20.join(contentDir, "entries");
+  const entriesDir = path21.join(contentDir, "entries");
   const result = /* @__PURE__ */ new Map();
   const legacyFiles = await findLegacyEntryFiles(contentDir);
   if (legacyFiles.length > 0) {
@@ -48790,7 +48895,7 @@ async function readEntries(contentDir, contentType, metadataTarget) {
       for (const item of items) {
         if (item.isDirectory()) {
           const entries = await readEntriesFromDirectory(
-            path20.join(entriesDir, item.name)
+            path21.join(entriesDir, item.name)
           );
           await applyEntryMetadata(contentDir, item.name, entries, metadataTarget);
           if (entries.length > 0) {
@@ -48832,7 +48937,7 @@ async function applyEntryMetadata(contentDir, contentType, entries, metadataTarg
   });
 }
 async function readPages(contentDir) {
-  const pagesDir = path20.join(contentDir, "pages");
+  const pagesDir = path21.join(contentDir, "pages");
   const pages = [];
   const files = await listFiles(pagesDir, ".json");
   for (const filePath of files) {
@@ -48846,14 +48951,14 @@ async function readPages(contentDir) {
   return pages;
 }
 async function readNavigation(contentDir) {
-  const filePath = path20.join(contentDir, "navigation.json");
+  const filePath = path21.join(contentDir, "navigation.json");
   if (!await fileExists(filePath)) {
     return null;
   }
   return readJsonFile(filePath);
 }
 async function readSettings(contentDir) {
-  const filePath = path20.join(contentDir, "settings.json");
+  const filePath = path21.join(contentDir, "settings.json");
   if (!await fileExists(filePath)) {
     return null;
   }
@@ -48870,7 +48975,7 @@ async function readSettings(contentDir) {
   return parsed.data;
 }
 async function readForms(contentDir) {
-  const formsDir = path20.join(contentDir, "forms");
+  const formsDir = path21.join(contentDir, "forms");
   const forms = [];
   const files = await listFiles(formsDir, ".json");
   for (const filePath of files) {
@@ -48884,7 +48989,7 @@ async function readForms(contentDir) {
   return forms;
 }
 async function readVenues(contentDir) {
-  const venuesDir = path20.join(contentDir, "venues");
+  const venuesDir = path21.join(contentDir, "venues");
   const venues = [];
   const files = await listFiles(venuesDir, ".json");
   for (const filePath of files) {
@@ -48898,7 +49003,7 @@ async function readVenues(contentDir) {
   return venues;
 }
 async function readEventCategories(contentDir) {
-  const categoriesDir = path20.join(contentDir, "event-categories");
+  const categoriesDir = path21.join(contentDir, "event-categories");
   const categories = [];
   const files = await listFiles(categoriesDir, ".json");
   for (const filePath of files) {
@@ -48915,7 +49020,7 @@ async function readEvents(contentDir) {
   return (await readEventsWithFilePaths(contentDir)).map(({ filePath: _filePath, ...event }) => event);
 }
 async function readEventsWithFilePaths(contentDir) {
-  const eventsDir = path20.join(contentDir, "events");
+  const eventsDir = path21.join(contentDir, "events");
   const events = [];
   const files = await listFiles(eventsDir, ".json");
   for (const filePath of files) {
@@ -48929,7 +49034,7 @@ async function readEventsWithFilePaths(contentDir) {
   return events;
 }
 async function readCourses(contentDir) {
-  const coursesDir = path20.join(contentDir, "courses");
+  const coursesDir = path21.join(contentDir, "courses");
   const courses = [];
   const files = await listFiles(coursesDir, ".json");
   for (const filePath of files) {
@@ -48943,8 +49048,8 @@ async function readCourses(contentDir) {
   return courses;
 }
 async function readTheme(contentDir, themeName) {
-  const themesDir = path20.join(contentDir, "themes");
-  const filePath = path20.join(themesDir, `${themeName}.json`);
+  const themesDir = path21.join(contentDir, "themes");
+  const filePath = path21.join(themesDir, `${themeName}.json`);
   if (!await fileExists(filePath)) {
     return null;
   }
@@ -48952,13 +49057,13 @@ async function readTheme(contentDir, themeName) {
   return { name: themeName, theme };
 }
 async function readThemes(contentDir) {
-  const themesDir = path20.join(contentDir, "themes");
+  const themesDir = path21.join(contentDir, "themes");
   const themes = [];
   const files = await listFiles(themesDir, ".json");
   for (const filePath of files) {
     try {
       const theme = await readJsonFile(filePath);
-      const name = path20.basename(filePath, ".json");
+      const name = path21.basename(filePath, ".json");
       themes.push({ name, theme });
     } catch (error) {
       console.warn(`Warning: Could not parse ${filePath}:`, error);
@@ -48967,7 +49072,7 @@ async function readThemes(contentDir) {
   return themes;
 }
 async function readFooter(contentDir) {
-  const filePath = path20.join(contentDir, "footer.json");
+  const filePath = path21.join(contentDir, "footer.json");
   if (!await fileExists(filePath)) {
     return null;
   }
@@ -49517,7 +49622,7 @@ var EXTENSIONS_BY_MIME = {
   "application/pdf": ".pdf"
 };
 function getMimeType(filename) {
-  const ext = path20.extname(filename).toLowerCase();
+  const ext = path21.extname(filename).toLowerCase();
   return MIME_TYPES[ext] ?? "application/octet-stream";
 }
 function getExtensionForMimeType(mimeType) {
@@ -49545,10 +49650,10 @@ var listMediaDirFiles = async (mediaDir) => {
   }
 };
 var findMatchingFilename = async (contentDir, identifier, manifest) => {
-  const mediaDir = path20.join(contentDir, MEDIA_DIR_NAME);
+  const mediaDir = path21.join(contentDir, MEDIA_DIR_NAME);
   const manifestEntry = manifest.assets[identifier];
   if (manifestEntry?.filename) {
-    const candidatePath = path20.join(mediaDir, manifestEntry.filename);
+    const candidatePath = path21.join(mediaDir, manifestEntry.filename);
     if (await fileExists2(candidatePath)) {
       return manifestEntry.filename;
     }
@@ -49556,7 +49661,7 @@ var findMatchingFilename = async (contentDir, identifier, manifest) => {
   const files = await listMediaDirFiles(mediaDir);
   const matches = files.filter((name) => {
     if (name.startsWith(".")) return false;
-    const parsed = path20.parse(name);
+    const parsed = path21.parse(name);
     return parsed.name === identifier;
   });
   if (matches.length > 1) {
@@ -49567,8 +49672,8 @@ var findMatchingFilename = async (contentDir, identifier, manifest) => {
 async function loadLocalMediaFile(contentDir, identifier, manifest) {
   const filename = await findMatchingFilename(contentDir, identifier, manifest);
   if (!filename) return null;
-  const mediaDir = path20.join(contentDir, MEDIA_DIR_NAME);
-  const filePath = path20.join(mediaDir, filename);
+  const mediaDir = path21.join(contentDir, MEDIA_DIR_NAME);
+  const filePath = path21.join(mediaDir, filename);
   const data = await fs2.readFile(filePath);
   const checksum = sha256(data);
   const mimeType = getMimeType(filename);
@@ -49581,9 +49686,9 @@ async function loadLocalMediaFile(contentDir, identifier, manifest) {
   return { identifier, filename, filePath, mimeType, checksum, data };
 }
 async function writeLocalMediaFile(contentDir, filename, data) {
-  const mediaDir = path20.join(contentDir, MEDIA_DIR_NAME);
+  const mediaDir = path21.join(contentDir, MEDIA_DIR_NAME);
   await fs2.mkdir(mediaDir, { recursive: true });
-  const filePath = path20.join(mediaDir, filename);
+  const filePath = path21.join(mediaDir, filename);
   await fs2.writeFile(filePath, data);
   return filePath;
 }
@@ -49768,7 +49873,7 @@ var parseFilenameFromUrl = (src) => {
   }
 };
 var ensureFilenameExtension = (filename, mimeType) => {
-  if (path20.extname(filename)) return filename;
+  if (path21.extname(filename)) return filename;
   const ext = getExtensionForMimeType(mimeType);
   return ext ? `${filename}${ext}` : filename;
 };
@@ -49833,7 +49938,7 @@ var importRichTextImageSrcToIdentifier = async (options) => {
   throw new Error("Unable to assign a unique identifier for rich text image import");
 };
 var buildLocalFilename = (identifier, asset) => {
-  const extensionFromFilename = path20.extname(asset.filename ?? "");
+  const extensionFromFilename = path21.extname(asset.filename ?? "");
   const extension = extensionFromFilename || getExtensionForMimeType(asset.mimeType) || "";
   return extension ? `${identifier}${extension}` : identifier;
 };
@@ -50679,11 +50784,11 @@ async function syncLocalMediaForPull(options) {
       continue;
     }
     const localFilename = buildLocalFilename(value.identifier, resolvedAsset);
-    const localFilePath = path20.join(contentDir, "media", localFilename);
+    const localFilePath = path21.join(contentDir, "media", localFilename);
     const existingEntry = manifest.assets[value.identifier];
     const previousFilename = existingEntry?.filename;
     if (previousFilename && previousFilename !== localFilename) {
-      const previousPath = path20.join(contentDir, "media", previousFilename);
+      const previousPath = path21.join(contentDir, "media", previousFilename);
       if (await localMediaFileExists(previousPath)) {
         await fs2.unlink(previousPath).catch(() => {
         });
@@ -50771,10 +50876,10 @@ function itemSegment(key) {
 function collectSortedKeys(local, remote) {
   return Array.from(/* @__PURE__ */ new Set([...Object.keys(remote), ...Object.keys(local)])).sort((a, b) => a.localeCompare(b));
 }
-function arrayIdentityMap(items, path32, identifyArrayItem) {
+function arrayIdentityMap(items, path33, identifyArrayItem) {
   const result = /* @__PURE__ */ new Map();
   for (let index = 0; index < items.length; index++) {
-    const key = identifyArrayItem({ path: path32, item: items[index], index });
+    const key = identifyArrayItem({ path: path33, item: items[index], index });
     if (!key || result.has(key)) return null;
     result.set(key, { item: items[index], index });
   }
@@ -50800,8 +50905,8 @@ function isSensitivePropertyKey(key) {
   const normalized = key.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
   return /(^|[_-])(secret|token|password|credential|api_key|webhook_secret|mgmt_api_key|management_api_key)s?($|[_-])/.test(normalized);
 }
-function hasSensitivePropertyPath(path32) {
-  return path32.some((segment) => segment.type === "property" && isSensitivePropertyKey(segment.key));
+function hasSensitivePropertyPath(path33) {
+  return path33.some((segment) => segment.type === "property" && isSensitivePropertyKey(segment.key));
 }
 function sameMultiset(left, right) {
   if (left.length !== right.length) return false;
@@ -50819,19 +50924,19 @@ function sameMultiset(left, right) {
   }
   return counts.size === 0;
 }
-function diffValues(local, remote, path32, options) {
+function diffValues(local, remote, path33, options) {
   const normalizedLocal = normalizeComparable(local);
   const normalizedRemote = normalizeComparable(remote);
   if (equal2(normalizedLocal, normalizedRemote)) return [];
   if (Array.isArray(normalizedLocal) && Array.isArray(normalizedRemote)) {
-    return diffArrays(normalizedLocal, normalizedRemote, path32, options);
+    return diffArrays(normalizedLocal, normalizedRemote, path33, options);
   }
   if (isRecord19(normalizedLocal) && isRecord19(normalizedRemote)) {
     const diffs = [];
     for (const key of collectSortedKeys(normalizedLocal, normalizedRemote)) {
       const localHasKey = Object.prototype.hasOwnProperty.call(normalizedLocal, key);
       const remoteHasKey = Object.prototype.hasOwnProperty.call(normalizedRemote, key);
-      const nextPath = [...path32, propertySegment(key)];
+      const nextPath = [...path33, propertySegment(key)];
       if (!remoteHasKey && localHasKey) {
         diffs.push({ kind: "added", path: nextPath, before: void 0, after: normalizedLocal[key] });
         continue;
@@ -50844,25 +50949,25 @@ function diffValues(local, remote, path32, options) {
     }
     return diffs;
   }
-  return [{ kind: "changed", path: path32, before: normalizedRemote, after: normalizedLocal }];
+  return [{ kind: "changed", path: path33, before: normalizedRemote, after: normalizedLocal }];
 }
-function diffArrays(local, remote, path32, options) {
+function diffArrays(local, remote, path33, options) {
   const identifyArrayItem = options.identifyArrayItem;
   if (identifyArrayItem) {
-    const localById = arrayIdentityMap(local, path32, identifyArrayItem);
-    const remoteById = arrayIdentityMap(remote, path32, identifyArrayItem);
+    const localById = arrayIdentityMap(local, path33, identifyArrayItem);
+    const remoteById = arrayIdentityMap(remote, path33, identifyArrayItem);
     if (localById && remoteById) {
       const diffs = [];
       const localOrder = Array.from(localById.keys());
       const remoteOrder = Array.from(remoteById.keys());
       if (localOrder.length === remoteOrder.length && localOrder.every((key) => remoteById.has(key)) && !equal2(localOrder, remoteOrder)) {
-        diffs.push({ kind: "list_reordered", path: path32, before: remoteOrder, after: localOrder });
+        diffs.push({ kind: "list_reordered", path: path33, before: remoteOrder, after: localOrder });
       }
       const ids = Array.from(/* @__PURE__ */ new Set([...remoteOrder, ...localOrder])).sort((a, b) => a.localeCompare(b));
       for (const id of ids) {
         const localItem = localById.get(id);
         const remoteItem = remoteById.get(id);
-        const nextPath = [...path32, itemSegment(id)];
+        const nextPath = [...path33, itemSegment(id)];
         if (!remoteItem && localItem) {
           diffs.push({ kind: "added", path: nextPath, before: void 0, after: localItem.item });
           continue;
@@ -50879,24 +50984,24 @@ function diffArrays(local, remote, path32, options) {
     }
   }
   if (sameMultiset(local, remote)) {
-    return [{ kind: "list_reordered", path: path32, before: remote, after: local }];
+    return [{ kind: "list_reordered", path: path33, before: remote, after: local }];
   }
   if (local.length === remote.length) {
     const diffs = [];
     for (let index = 0; index < local.length; index++) {
-      diffs.push(...diffValues(local[index], remote[index], [...path32, indexSegment(index)], options));
+      diffs.push(...diffValues(local[index], remote[index], [...path33, indexSegment(index)], options));
     }
-    return diffs.length > 0 ? diffs : [{ kind: "changed", path: path32, before: remote, after: local }];
+    return diffs.length > 0 ? diffs : [{ kind: "changed", path: path33, before: remote, after: local }];
   }
-  return [{ kind: "changed", path: path32, before: remote, after: local }];
+  return [{ kind: "changed", path: path33, before: remote, after: local }];
 }
 function buildFieldDiffs(local, remote, options = {}) {
   return diffValues(local, remote, [], options);
 }
-function formatFieldPath2(path32) {
-  if (path32.length === 0) return "(root)";
+function formatFieldPath2(path33) {
+  if (path33.length === 0) return "(root)";
   let result = "";
-  for (const segment of path32) {
+  for (const segment of path33) {
     switch (segment.type) {
       case "property":
         result += result ? `.${segment.key}` : segment.key;
@@ -50971,11 +51076,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 path32 = prefix ? `${prefix}.${key}` : key;
+    const path33 = prefix ? `${prefix}.${key}` : key;
     const localVal = local[key];
     const remoteVal = remote[key];
     if (!equal2(localVal, remoteVal)) {
-      changes.push(path32);
+      changes.push(path33);
     }
   }
   return changes;
@@ -52556,10 +52661,10 @@ function stripCanonicalEventEntriesFromPulledContent(content) {
   };
 }
 async function findLegacyEventEntryFiles(contentDir) {
-  const eventEntriesDir = path20.join(contentDir, "entries", CANONICAL_EVENT_ENTRY_TYPE);
+  const eventEntriesDir = path21.join(contentDir, "entries", CANONICAL_EVENT_ENTRY_TYPE);
   try {
     const items = await fs2.readdir(eventEntriesDir, { withFileTypes: true });
-    return items.filter((item) => item.isFile() && item.name.endsWith(".json")).map((item) => path20.join(eventEntriesDir, item.name)).sort();
+    return items.filter((item) => item.isFile() && item.name.endsWith(".json")).map((item) => path21.join(eventEntriesDir, item.name)).sort();
   } catch (error) {
     if (error.code === "ENOENT") {
       return [];
@@ -52569,7 +52674,7 @@ async function findLegacyEventEntryFiles(contentDir) {
 }
 function formatLegacyEventEntryWarning(files) {
   return {
-    files: files.map((file) => path20.relative(process.cwd(), file)),
+    files: files.map((file) => path21.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.`
   };
 }
@@ -53155,7 +53260,7 @@ Media Sync:
         });
         return;
       }
-      const contentDir = path20.resolve(options.output ?? "./content");
+      const contentDir = path21.resolve(options.output ?? "./content");
       const envLabel = isRemote ? "REMOTE" : "LOCAL";
       const environment = loadEnvironment(isRemote);
       const metadataTarget = metadataTargetFromEnvironment(isRemote ? "remote" : "local", environment);
@@ -53226,7 +53331,7 @@ Media Sync:
             process.exitCode = 0;
             return;
           }
-          const fileRel = path20.join(path20.basename(contentDir), "themes", `${themeName}.json`);
+          const fileRel = path21.join(path21.basename(contentDir), "themes", `${themeName}.json`);
           if (resolvedJsonDiffMode) {
             output.json({
               mode: resolvedJsonDiffMode,
@@ -53263,7 +53368,7 @@ Media Sync:
             process.exitCode = 0;
             return;
           }
-          const fileRel = path20.join(path20.basename(contentDir), "footer.json");
+          const fileRel = path21.join(path21.basename(contentDir), "footer.json");
           if (resolvedJsonDiffMode) {
             output.json({
               mode: resolvedJsonDiffMode,
@@ -53470,7 +53575,7 @@ Media Sync:
             if (options.withTheme) {
               const themeName = options.name ?? "current";
               output.info(
-                `[DRY RUN] Would also pull theme to ${path20.join(path20.basename(contentDir), "themes", `${themeName}.json`)}`
+                `[DRY RUN] Would also pull theme to ${path21.join(path21.basename(contentDir), "themes", `${themeName}.json`)}`
               );
             }
             const result = await pullAllContentWithCanonicalEntryPolicy(client, output);
@@ -53611,7 +53716,7 @@ Media Sync:
         const response = await prompts({
           type: "confirm",
           name: "overwrite",
-          message: `Content directory '${path20.basename(contentDir)}' already exists. Overwrite?`,
+          message: `Content directory '${path21.basename(contentDir)}' already exists. Overwrite?`,
           initial: false
         });
         if (!response.overwrite) {
@@ -54346,8 +54451,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(path32, message) {
-  return { path: path32, message };
+function issue2(path33, message) {
+  return { path: path33, message };
 }
 function isRecord20(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -54364,27 +54469,27 @@ function isWholeMinuteIsoDateTime(value) {
   return Number.isFinite(epochMs) && epochMs % 6e4 === 0;
 }
 function validateTicketType(raw, index, currency) {
-  const path32 = ["ticketTypes", String(index)];
-  if (!isRecord20(raw)) return [issue2(path32, "Ticket type must be an object")];
+  const path33 = ["ticketTypes", String(index)];
+  if (!isRecord20(raw)) return [issue2(path33, "Ticket type must be an object")];
   const issues = [];
   const identifier = raw.identifier;
   if (typeof identifier !== "string" || !identifierRegex.test(identifier)) {
     issues.push(
       issue2(
-        [...path32, "identifier"],
+        [...path33, "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([...path32, "name"], "Ticket name is required"));
+    issues.push(issue2([...path33, "name"], "Ticket name is required"));
   }
   const priceAmount = raw.priceAmount;
   if (!isWholeNumber(priceAmount) || priceAmount < 0) {
     issues.push(
       issue2(
-        [...path32, "priceAmount"],
+        [...path33, "priceAmount"],
         "Ticket priceAmount must be a non-negative integer"
       )
     );
@@ -54393,7 +54498,7 @@ function validateTicketType(raw, index, currency) {
   if (priceCurrency !== void 0 && priceCurrency !== null && priceCurrency !== currency) {
     issues.push(
       issue2(
-        [...path32, "priceCurrency"],
+        [...path33, "priceCurrency"],
         "Ticket priceCurrency must match pricing.priceCurrency"
       )
     );
@@ -54402,7 +54507,7 @@ function validateTicketType(raw, index, currency) {
   if (sortOrder !== void 0 && (!isWholeNumber(sortOrder) || sortOrder < 0)) {
     issues.push(
       issue2(
-        [...path32, "sortOrder"],
+        [...path33, "sortOrder"],
         "Ticket sortOrder must be a non-negative integer"
       )
     );
@@ -54411,7 +54516,7 @@ function validateTicketType(raw, index, currency) {
   if (capacityLimit2 !== void 0 && capacityLimit2 !== null && (!isWholeNumber(capacityLimit2) || capacityLimit2 < 1)) {
     issues.push(
       issue2(
-        [...path32, "capacityLimit"],
+        [...path33, "capacityLimit"],
         "Ticket capacityLimit must be a positive integer"
       )
     );
@@ -54420,7 +54525,7 @@ function validateTicketType(raw, index, currency) {
   if (attendanceScope !== void 0 && attendanceScope !== "in_person" && attendanceScope !== "online" && attendanceScope !== "both") {
     issues.push(
       issue2(
-        [...path32, "attendanceScope"],
+        [...path33, "attendanceScope"],
         "Ticket attendanceScope must be in_person, online, or both"
       )
     );
@@ -54429,7 +54534,7 @@ function validateTicketType(raw, index, currency) {
   if (saleStartsAt !== void 0 && saleStartsAt !== null && (typeof saleStartsAt !== "string" || !isWholeMinuteIsoDateTime(saleStartsAt))) {
     issues.push(
       issue2(
-        [...path32, "saleStartsAt"],
+        [...path33, "saleStartsAt"],
         "Ticket saleStartsAt must be an ISO datetime aligned to a whole minute"
       )
     );
@@ -54438,7 +54543,7 @@ function validateTicketType(raw, index, currency) {
   if (saleEndsAt !== void 0 && saleEndsAt !== null && (typeof saleEndsAt !== "string" || !isWholeMinuteIsoDateTime(saleEndsAt))) {
     issues.push(
       issue2(
-        [...path32, "saleEndsAt"],
+        [...path33, "saleEndsAt"],
         "Ticket saleEndsAt must be an ISO datetime aligned to a whole minute"
       )
     );
@@ -54446,7 +54551,7 @@ function validateTicketType(raw, index, currency) {
   if (typeof saleStartsAt === "string" && typeof saleEndsAt === "string" && Date.parse(saleEndsAt) <= Date.parse(saleStartsAt)) {
     issues.push(
       issue2(
-        [...path32, "saleEndsAt"],
+        [...path33, "saleEndsAt"],
         "Ticket saleEndsAt must be after saleStartsAt"
       )
     );
@@ -54455,7 +54560,7 @@ function validateTicketType(raw, index, currency) {
   if (cmsTicketTypeId !== void 0 && cmsTicketTypeId !== null && (typeof cmsTicketTypeId !== "string" || cmsTicketTypeId.length === 0)) {
     issues.push(
       issue2(
-        [...path32, "cmsTicketTypeId"],
+        [...path33, "cmsTicketTypeId"],
         "Ticket cmsTicketTypeId must be a non-empty string"
       )
     );
@@ -54639,8 +54744,8 @@ var supportedKinds = /* @__PURE__ */ new Set([
   "deferred_manual",
   "flexible_balance"
 ]);
-function issue3(path32, message) {
-  return { path: path32, message };
+function issue3(path33, message) {
+  return { path: path33, message };
 }
 function isRecord21(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -54657,15 +54762,15 @@ function isDepositRefundability(value) {
 function isSupportedOptionKind(value) {
   return typeof value === "string" && supportedKinds.has(value);
 }
-function validateFlexibleBalanceDueDateRule(raw, path32) {
+function validateFlexibleBalanceDueDateRule(raw, path33) {
   if (!isRecord21(raw)) {
-    return [issue3(path32, "Flexible balance dueDateRule must be an object")];
+    return [issue3(path33, "Flexible balance dueDateRule must be an object")];
   }
   if (raw.kind === "relative_to_start_date") {
     if (!isPositiveWholeNumber(raw.daysBeforeStart)) {
       return [
         issue3(
-          [...path32, "daysBeforeStart"],
+          [...path33, "daysBeforeStart"],
           "Flexible balance daysBeforeStart must be a positive integer"
         )
       ];
@@ -54679,7 +54784,7 @@ function validateFlexibleBalanceDueDateRule(raw, path32) {
     if (typeof raw.dueAt !== "string" || !Number.isFinite(Date.parse(raw.dueAt))) {
       return [
         issue3(
-          [...path32, "dueAt"],
+          [...path33, "dueAt"],
           "Flexible balance fixed dueAt must be an ISO datetime"
         )
       ];
@@ -54691,14 +54796,14 @@ function validateFlexibleBalanceDueDateRule(raw, path32) {
   }
   return [
     issue3(
-      [...path32, "kind"],
+      [...path33, "kind"],
       "Flexible balance dueDateRule kind must be relative_to_start_date or fixed_calendar_date"
     )
   ];
 }
-function validateFlexibleBalanceConfig(raw, path32) {
+function validateFlexibleBalanceConfig(raw, path33) {
   if (!isRecord21(raw)) {
-    return [issue3(path32, "Flexible balance config must be an object")];
+    return [issue3(path33, "Flexible balance config must be an object")];
   }
   const issues = [];
   const upfrontAmountCents = raw.upfrontAmountCents;
@@ -54708,7 +54813,7 @@ function validateFlexibleBalanceConfig(raw, path32) {
   if (!isWholeNumber2(upfrontAmountCents) || upfrontAmountCents < 0) {
     issues.push(
       issue3(
-        [...path32, "upfrontAmountCents"],
+        [...path33, "upfrontAmountCents"],
         "Flexible balance upfrontAmountCents must be a non-negative integer"
       )
     );
@@ -54718,7 +54823,7 @@ function validateFlexibleBalanceConfig(raw, path32) {
   if (!isDepositRefundability(depositRefundability)) {
     issues.push(
       issue3(
-        [...path32, "depositRefundability"],
+        [...path33, "depositRefundability"],
         "Flexible balance depositRefundability must be refundable or non_refundable"
       )
     );
@@ -54727,7 +54832,7 @@ function validateFlexibleBalanceConfig(raw, path32) {
   }
   const dueDateRule = validateFlexibleBalanceDueDateRule(
     raw.dueDateRule,
-    [...path32, "dueDateRule"]
+    [...path33, "dueDateRule"]
   );
   if (Array.isArray(dueDateRule)) {
     issues.push(...dueDateRule);
@@ -54742,14 +54847,14 @@ function validateFlexibleBalanceConfig(raw, path32) {
   };
 }
 function validateCollectionOption(raw, index) {
-  const path32 = ["allowedOptions", String(index)];
+  const path33 = ["allowedOptions", String(index)];
   if (!isRecord21(raw)) {
-    return [issue3(path32, "Payment option must be an object")];
+    return [issue3(path33, "Payment option must be an object")];
   }
   if (raw.kind === "instalment_plan") {
     return [
       issue3(
-        [...path32, "kind"],
+        [...path33, "kind"],
         "Event instalment plans are not supported yet. Use upfront, deferred_manual, or flexible_balance."
       )
     ];
@@ -54757,7 +54862,7 @@ function validateCollectionOption(raw, index) {
   if (!isSupportedOptionKind(raw.kind)) {
     return [
       issue3(
-        [...path32, "kind"],
+        [...path33, "kind"],
         "Payment option kind must be upfront, deferred_manual, or flexible_balance"
       )
     ];
@@ -54768,7 +54873,7 @@ function validateCollectionOption(raw, index) {
       return { kind: raw.kind };
     case "flexible_balance": {
       const config2 = validateFlexibleBalanceConfig(raw.config, [
-        ...path32,
+        ...path33,
         "config"
       ]);
       if (Array.isArray(config2)) {
@@ -55502,7 +55607,7 @@ function groupStaleItems(staleItems) {
   ];
 }
 async function writeStaleEntries(contentDir, remoteContent, contentType, items, output, options) {
-  const entriesDir = path20.join(contentDir, "entries", contentType);
+  const entriesDir = path21.join(contentDir, "entries", contentType);
   await ensureDir(entriesDir);
   const remoteEntries = remoteContent.entries[contentType] ?? [];
   const staleIds = new Set(items.map((i) => i.identifier));
@@ -55510,7 +55615,7 @@ async function writeStaleEntries(contentDir, remoteContent, contentType, items,
     if (!staleIds.has(remoteEntry.identifier)) continue;
     const entryData = mapEntryForOutput(remoteEntry);
     stripEnvSpecificMediaFieldsInPlace(entryData);
-    const filePath = path20.join(entriesDir, `${remoteEntry.identifier}.json`);
+    const filePath = path21.join(entriesDir, `${remoteEntry.identifier}.json`);
     await writeJsonFile(filePath, entryData);
     output.info(`  Refreshed entry: ${contentType}/${remoteEntry.identifier}`);
   }
@@ -55535,13 +55640,13 @@ async function writeStaleEntries(contentDir, remoteContent, contentType, items,
   }
 }
 async function writeStalePages(contentDir, remoteContent, items, output, options) {
-  const pagesDir = path20.join(contentDir, "pages");
+  const pagesDir = path21.join(contentDir, "pages");
   await ensureDir(pagesDir);
   const staleIds = new Set(items.map((i) => i.identifier));
   for (const remotePage of remoteContent.pages) {
     if (!staleIds.has(remotePage.identifier)) continue;
     stripEnvSpecificMediaFieldsInPlace(remotePage);
-    const filePath = path20.join(pagesDir, `${remotePage.identifier}.json`);
+    const filePath = path21.join(pagesDir, `${remotePage.identifier}.json`);
     await writeJsonFile(filePath, remotePage);
     output.info(`  Refreshed page: ${remotePage.identifier}`);
   }
@@ -57703,13 +57808,13 @@ function collectOfferingRequires(input, intervals, intervalPath) {
 function optionalRef(ref, field) {
   return ref !== void 0 && ref.length > 0 ? [{ ref, field }] : [];
 }
-function collectVenueRefsFromIntervals(intervals, path32) {
-  return intervals.flatMap((interval, index) => optionalRef(interval.venueRef, `${path32}[${index}].venueRef`));
+function collectVenueRefsFromIntervals(intervals, path33) {
+  return intervals.flatMap((interval, index) => optionalRef(interval.venueRef, `${path33}[${index}].venueRef`));
 }
-function collectNavigationRefs(items, path32) {
+function collectNavigationRefs(items, path33) {
   return items.flatMap((item, index) => {
     if (!isRecord23(item)) return [];
-    const itemPath = `${path32}[${index}]`;
+    const itemPath = `${path33}[${index}]`;
     const refs = [];
     if (typeof item.pageRef === "string") {
       refs.push({ ref: item.pageRef, field: `${itemPath}.pageRef` });
@@ -57723,26 +57828,26 @@ function collectNavigationRefs(items, path32) {
     return refs;
   });
 }
-function collectBlockRefs(blocks, path32) {
+function collectBlockRefs(blocks, path33) {
   return blocks.flatMap((block, index) => {
     if (!isRecord23(block)) return [];
-    const blockPath = `${path32}[${index}]`;
+    const blockPath = `${path33}[${index}]`;
     return [
       ...collectNestedRefs(block.props, `${blockPath}.props`),
       ...collectNestedRefs(block.children, `${blockPath}.children`)
     ];
   });
 }
-function collectNestedRefs(value, path32) {
+function collectNestedRefs(value, path33) {
   if (typeof value === "string") {
     const parsed = parseResourceRef(value);
-    return parsed.ok ? [{ ref: value, field: path32 }] : [];
+    return parsed.ok ? [{ ref: value, field: path33 }] : [];
   }
   if (Array.isArray(value)) {
-    return value.flatMap((item, index) => collectNestedRefs(item, `${path32}[${index}]`));
+    return value.flatMap((item, index) => collectNestedRefs(item, `${path33}[${index}]`));
   }
   if (!isRecord23(value)) return [];
-  return Object.entries(value).flatMap(([key, child]) => collectNestedRefs(child, `${path32}.${key}`));
+  return Object.entries(value).flatMap(([key, child]) => collectNestedRefs(child, `${path33}.${key}`));
 }
 
 // ../site-commands/src/staticExecutionGaps.ts
@@ -58021,8 +58126,8 @@ function invalidPayloadError(input, issue5) {
     message: `${field}: ${issue5.message}`
   };
 }
-function commandIndexForIssuePath(path32) {
-  return path32[0] === "commands" && typeof path32[1] === "number" ? path32[1] : -1;
+function commandIndexForIssuePath(path33) {
+  return path33[0] === "commands" && typeof path33[1] === "number" ? path33[1] : -1;
 }
 function commandTypeForIssue(input, commandIndex) {
   if (!isRecord23(input) || !isUnknownArray3(input.commands)) return null;
@@ -58032,9 +58137,9 @@ function commandTypeForIssue(input, commandIndex) {
 function isUnknownArray3(value) {
   return Array.isArray(value);
 }
-function formatIssuePath(path32) {
-  if (path32.length === 0) return "<root>";
-  return path32.reduce((formatted, segment) => {
+function formatIssuePath(path33) {
+  if (path33.length === 0) return "<root>";
+  return path33.reduce((formatted, segment) => {
     if (typeof segment === "number") return `${formatted}[${segment}]`;
     if (formatted.length === 0) return String(segment);
     return `${formatted}.${String(segment)}`;
@@ -58763,8 +58868,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 issue4(path32, message) {
-  return { path: path32, message };
+function issue4(path33, message) {
+  return { path: path33, message };
 }
 function isValidDateParts(year, month, day) {
   const date = new Date(Date.UTC(year, month - 1, day));
@@ -61647,7 +61752,7 @@ async function executeFooterPush(input) {
     );
   }
   const cliConfig = await loadCliConfigForEnv(target);
-  const contentDir = path20.resolve(options.contentDir ?? cliConfig.contentDir);
+  const contentDir = path21.resolve(options.contentDir ?? cliConfig.contentDir);
   if (!await contentDirExists(contentDir)) {
     return output.error(`Content directory not found: ${contentDir}`, {
       suggestion: 'Run "riverbankcms pull footer" first to download footer'
@@ -62520,7 +62625,7 @@ function findDuplicateLocalEventIdentifiers(events) {
   return [...filePathsByIdentifier.entries()].filter(([, filePaths]) => filePaths.length > 1).map(([identifier, filePaths]) => ({ identifier, filePaths }));
 }
 function formatDuplicateEventFilePath(contentDir, filePath) {
-  return path20.relative(contentDir, filePath) || filePath;
+  return path21.relative(contentDir, filePath) || filePath;
 }
 function normalizeLocalPath(value) {
   const [withoutHash] = value.split("#");
@@ -62820,7 +62925,7 @@ function firstNestedContainerChange(localChanges, remoteChanges) {
 }
 function firstSameFieldConflictPath(localChanges, remoteChanges) {
   const remotePaths = new Set(remoteChanges.keys());
-  return [...localChanges.keys()].filter((path32) => remotePaths.has(path32)).sort()[0] ?? null;
+  return [...localChanges.keys()].filter((path33) => remotePaths.has(path33)).sort()[0] ?? null;
 }
 function scalarMergeChanges(changes, label) {
   return [...changes.values()].map((change) => {
@@ -62836,24 +62941,24 @@ function mergeValueKind(value) {
   if (typeof value === "object") return "object";
   return "scalar";
 }
-function mergeChange(path32, value, containerKind) {
+function mergeChange(path33, value, containerKind) {
   switch (containerKind) {
     case "array":
-      if (Array.isArray(value)) return { path: path32, value, containerKind };
+      if (Array.isArray(value)) return { path: path33, value, containerKind };
       break;
     case "object":
       if (value && typeof value === "object" && !Array.isArray(value)) {
-        return { path: path32, value, containerKind };
+        return { path: path33, value, containerKind };
       }
       break;
     case "null":
-      if (value === null || value === void 0) return { path: path32, value, containerKind };
+      if (value === null || value === void 0) return { path: path33, value, containerKind };
       break;
     case "scalar":
-      if (isScalarMergeChangeValue(value)) return { path: path32, value, containerKind };
+      if (isScalarMergeChangeValue(value)) return { path: path33, value, containerKind };
       break;
   }
-  throw new Error(`Invalid merge change at ${path32}.`);
+  throw new Error(`Invalid merge change at ${path33}.`);
 }
 function isScalarMergeChangeValue(value) {
   return value === void 0 || value === null || ["boolean", "number", "string"].includes(typeof value);
@@ -63067,44 +63172,73 @@ function setPath(target, pathParts, value) {
   }
   setPath(target[head], rest, value);
 }
-function expectStringValue(path32, value) {
+function expectStringValue(path33, value) {
   if (typeof value === "string") return value;
-  throw new Error(`Entry merge expected ${path32} to be a string.`);
+  throw new Error(`Entry merge expected ${path33} to be a string.`);
 }
-function expectBooleanValue(path32, value) {
+function expectBooleanValue(path33, value) {
   if (typeof value === "boolean") return value;
-  throw new Error(`Entry merge expected ${path32} to be a boolean.`);
+  throw new Error(`Entry merge expected ${path33} to be a boolean.`);
 }
 function expectStatusValue(value) {
   if (value === "draft" || value === "published") return value;
   throw new Error("Entry merge expected status to be draft or published.");
 }
 
+// src/cli/merge-remote/sharedMergePlan.ts
+async function buildRemoteMergePlanWithConfig(config2) {
+  const decisions = await Promise.all(config2.subjects().map(async (subject) => {
+    const baseSnapshot = await config2.readBaseSnapshot(subject);
+    return config2.planDecision({
+      subject,
+      base: baseSnapshot ? config2.valueFromBaseSnapshot(baseSnapshot) : null,
+      local: config2.localValue(subject),
+      remote: config2.remoteValue(subject)
+    });
+  }));
+  return {
+    decisions,
+    summary: config2.summarize(decisions)
+  };
+}
+function summarizeMergeDecisions(decisions, initialSummary, summaryKeyByDecisionKind) {
+  const summary = { ...initialSummary };
+  for (const decision of decisions) {
+    const summaryKey = summaryKeyByDecisionKind[decision.kind];
+    incrementSummaryField(summary, summaryKey);
+  }
+  return summary;
+}
+function incrementSummaryField(summary, summaryKey) {
+  const currentValue = summary[summaryKey];
+  if (typeof currentValue !== "number") {
+    throw new Error(`Merge summary field ${String(summaryKey)} is not numeric.`);
+  }
+  summary[summaryKey] = currentValue + 1;
+}
+
 // src/cli/merge-remote/entryMergePlan.ts
-init_src();
 async function buildRemoteEntryMergePlan(input) {
-  const subjects = subjectsForScope(input.scope, input.localEntries, input.remoteEntries);
-  const decisions = await Promise.all(subjects.map(async (subject) => {
-    const baseSnapshot = await readEntryBaseSnapshot({
+  const plan = await buildRemoteMergePlanWithConfig({
+    subjects: () => subjectsForScope(input.scope, input.localEntries, input.remoteEntries),
+    readBaseSnapshot: (subject) => readEntryBaseSnapshot({
       contentDir: input.contentDir,
       target: input.target,
       subject
-    });
-    return planEntryMerge({
-      subject,
-      base: baseSnapshot?.entry ?? null,
-      local: localEntryForSubject(input.localEntries, subject),
-      remote: remoteEntryForSubject(input.remoteEntries, subject)
-    });
-  }));
+    }),
+    valueFromBaseSnapshot: (snapshot) => snapshot.entry,
+    localValue: (subject) => localEntryForSubject(input.localEntries, subject),
+    remoteValue: (subject) => remoteEntryForSubject(input.remoteEntries, subject),
+    planDecision: planEntryMerge,
+    summarize: summarizeEntryMergeDecisions
+  });
   return {
     scope: input.scope,
-    decisions,
-    summary: summarizeEntryMergeDecisions(decisions)
+    ...plan
   };
 }
 function summarizeEntryMergeDecisions(decisions) {
-  const summary = {
+  return summarizeMergeDecisions(decisions, {
     unchanged: 0,
     bootstrapBase: 0,
     preserveRemote: 0,
@@ -63113,39 +63247,18 @@ function summarizeEntryMergeDecisions(decisions) {
     applyLocalDelete: 0,
     autoMerge: 0,
     conflicts: 0
-  };
-  for (const decision of decisions) {
-    switch (decision.kind) {
-      case "unchanged":
-        summary.unchanged++;
-        break;
-      case "bootstrap_base":
-        summary.bootstrapBase++;
-        break;
-      case "preserve_remote":
-        summary.preserveRemote++;
-        break;
-      case "apply_local_create":
-        summary.applyLocalCreate++;
-        break;
-      case "apply_local_update":
-        summary.applyLocalUpdate++;
-        break;
-      case "apply_local_delete":
-        summary.applyLocalDelete++;
-        break;
-      case "auto_merge":
-        summary.autoMerge++;
-        break;
-      case "conflict":
-        summary.conflicts++;
-        break;
-      default:
-        assertNever(decision);
-    }
-  }
-  return summary;
-}
+  }, entrySummaryKeyByDecisionKind);
+}
+var entrySummaryKeyByDecisionKind = {
+  unchanged: "unchanged",
+  bootstrap_base: "bootstrapBase",
+  preserve_remote: "preserveRemote",
+  apply_local_create: "applyLocalCreate",
+  apply_local_update: "applyLocalUpdate",
+  apply_local_delete: "applyLocalDelete",
+  auto_merge: "autoMerge",
+  conflict: "conflicts"
+};
 function entryMergePushScope(input) {
   if (input.identifier && !input.contentType) {
     throw new Error("Entry merge scope requires contentType when identifier is provided.");
@@ -63203,87 +63316,64 @@ function remoteEntryForSubject(entriesByType, subject) {
   return pulledEntryToLocalEntry(remoteEntry);
 }
 
-// src/cli/merge-remote/entryMergeReport.ts
-function remoteEntryMergeJsonReport(input) {
+// src/cli/merge-remote/sharedMergeReport.ts
+function remoteMergeJsonReport(input) {
   return {
     kind: "push",
-    scope: "entries",
+    scope: input.config.scope,
     mergeRemote: true,
     dryRun: input.dryRun,
-    summary: input.plan.summary,
-    decisions: input.plan.decisions.map(decisionReport)
+    summary: input.summary,
+    decisions: input.decisions.map(
+      (decision) => decisionReport(input.config, decision)
+    )
   };
 }
-function writeRemoteEntryMergeHumanReport(output, plan, options) {
+function writeRemoteMergeHumanReport(output, config2, input) {
   output.info(`
-${options.dryRun ? "[DRY RUN] " : ""}Remote-aware entry merge plan:`);
-  output.info(formatSummary(plan));
-  const conflicts = plan.decisions.filter((decision) => decision.kind === "conflict");
+${input.dryRun ? "[DRY RUN] " : ""}${config2.title}`);
+  output.info(config2.summaryLines(input.summary).join("\n"));
+  const conflicts = input.decisions.filter(isConflictDecision);
   if (conflicts.length > 0) {
     output.info("\nConflicts:");
     for (const decision of conflicts) {
-      if (decision.kind !== "conflict") continue;
       output.info(
-        `  - ${decision.subject.contentType}/${decision.subject.identifier}: ${decision.conflict.message}`
+        `  - ${config2.subjectLabel(decision.subject)}: ${decision.conflict.message}`
       );
     }
   }
-  const changes = plan.decisions.filter((decision) => decision.kind !== "unchanged" && decision.kind !== "conflict");
+  const changes = input.decisions.filter((decision) => decision.kind !== "unchanged" && decision.kind !== "conflict");
   if (changes.length > 0) {
     output.info("\nDecisions:");
     for (const decision of changes) {
-      output.info(`  - ${formatDecisionLine(decision)}`);
+      output.info(`  - ${formatDecisionLine(config2, decision)}`);
     }
   }
 }
-function formatSummary(plan) {
-  const { summary } = plan;
-  return [
-    `  Local creates: ${summary.applyLocalCreate}`,
-    `  Local updates: ${summary.applyLocalUpdate}`,
-    `  Local deletes: ${summary.applyLocalDelete}`,
-    `  Auto-merges: ${summary.autoMerge}`,
-    `  Remote preserved: ${summary.preserveRemote}`,
-    `  Base bootstraps: ${summary.bootstrapBase}`,
-    `  Unchanged: ${summary.unchanged}`,
-    `  Conflicts: ${summary.conflicts}`
-  ].join("\n");
-}
-function formatDecisionLine(decision) {
-  const subject = `${decision.subject.contentType}/${decision.subject.identifier}`;
-  switch (decision.kind) {
-    case "auto_merge":
-      return `${subject}: auto-merge local [${decision.localFieldPaths.join(", ")}] with remote [${decision.remoteFieldPaths.join(", ")}]`;
-    case "conflict":
-      return `${subject}: conflict (${decision.conflict.code})`;
-    case "apply_local_create":
-      return `${subject}: apply local create`;
-    case "apply_local_update":
-      return `${subject}: apply local update`;
-    case "apply_local_delete":
-      return `${subject}: apply local delete`;
-    case "preserve_remote":
-      return `${subject}: preserve remote`;
-    case "bootstrap_base":
-      return `${subject}: bootstrap missing base`;
-    case "unchanged":
-      return `${subject}: unchanged`;
+function formatDecisionLine(config2, decision) {
+  const subject = config2.subjectLabel(decision.subject);
+  if (isAutoMergeDecision(decision)) {
+    return `${subject}: auto-merge local [${decision.localFieldPaths.join(", ")}] with remote [${decision.remoteFieldPaths.join(", ")}]`;
+  }
+  if (isConflictDecision(decision)) {
+    return `${subject}: conflict (${decision.conflict.code})`;
   }
+  const label = config2.decisionLabels[decision.kind];
+  return `${subject}: ${label}`;
 }
-function decisionReport(decision) {
+function decisionReport(config2, decision) {
   const base = {
     kind: decision.kind,
-    contentType: decision.subject.contentType,
-    identifier: decision.subject.identifier
+    ...config2.subjectJson(decision.subject)
   };
-  if (decision.kind === "auto_merge") {
+  if (isAutoMergeDecision(decision)) {
     return {
       ...base,
       localFieldPaths: decision.localFieldPaths,
       remoteFieldPaths: decision.remoteFieldPaths
     };
   }
-  if (decision.kind === "conflict") {
+  if (isConflictDecision(decision)) {
     return {
       ...base,
       conflict: {
@@ -63295,6 +63385,56 @@ function decisionReport(decision) {
   }
   return base;
 }
+function isAutoMergeDecision(decision) {
+  return decision.kind === "auto_merge";
+}
+function isConflictDecision(decision) {
+  return decision.kind === "conflict";
+}
+
+// src/cli/merge-remote/entryMergeReport.ts
+var entryDecisionLabels = {
+  apply_local_create: "apply local create",
+  apply_local_update: "apply local update",
+  apply_local_delete: "apply local delete",
+  preserve_remote: "preserve remote",
+  bootstrap_base: "bootstrap missing base"
+};
+var entryMergeReportConfig = {
+  scope: "entries",
+  title: "Remote-aware entry merge plan:",
+  summaryLines: (summary) => [
+    `  Local creates: ${summary.applyLocalCreate}`,
+    `  Local updates: ${summary.applyLocalUpdate}`,
+    `  Local deletes: ${summary.applyLocalDelete}`,
+    `  Auto-merges: ${summary.autoMerge}`,
+    `  Remote preserved: ${summary.preserveRemote}`,
+    `  Base bootstraps: ${summary.bootstrapBase}`,
+    `  Unchanged: ${summary.unchanged}`,
+    `  Conflicts: ${summary.conflicts}`
+  ],
+  subjectLabel: (subject) => `${subject.contentType}/${subject.identifier}`,
+  subjectJson: (subject) => ({
+    contentType: subject.contentType,
+    identifier: subject.identifier
+  }),
+  decisionLabels: entryDecisionLabels
+};
+function remoteEntryMergeJsonReport(input) {
+  return remoteMergeJsonReport({
+    config: entryMergeReportConfig,
+    decisions: input.plan.decisions,
+    dryRun: input.dryRun,
+    summary: input.plan.summary
+  });
+}
+function writeRemoteEntryMergeHumanReport(output, plan, options) {
+  writeRemoteMergeHumanReport(output, entryMergeReportConfig, {
+    decisions: plan.decisions,
+    dryRun: options.dryRun,
+    summary: plan.summary
+  });
+}
 
 // src/cli/merge-remote/entryRemote.ts
 var DEFAULT_PAGE_LIMIT2 = 100;
@@ -63586,9 +63726,6 @@ async function unlinkIfExists(filePath) {
   }
 }
 
-// src/cli/merge-remote/pageMergePlan.ts
-init_src();
-
 // src/cli/merge-remote/pageMerge.ts
 function planPageMerge(input) {
   const { subject, base, local, remote } = input;
@@ -63801,13 +63938,13 @@ function setPagePath(page, pathParts, value) {
       throw new Error(`Unsupported page merge path: ${pathParts.join(".")}`);
   }
 }
-function expectStringValue2(path32, value) {
+function expectStringValue2(path33, value) {
   if (typeof value === "string") return value;
-  throw new Error(`Page merge expected ${path32} to be a string.`);
+  throw new Error(`Page merge expected ${path33} to be a string.`);
 }
-function expectBooleanValue2(path32, value) {
+function expectBooleanValue2(path33, value) {
   if (typeof value === "boolean") return value;
-  throw new Error(`Page merge expected ${path32} to be a boolean.`);
+  throw new Error(`Page merge expected ${path33} to be a boolean.`);
 }
 function expectStatusValue2(value) {
   if (value === "draft" || value === "published") return value;
@@ -63816,28 +63953,26 @@ function expectStatusValue2(value) {
 
 // src/cli/merge-remote/pageMergePlan.ts
 async function buildRemotePageMergePlan(input) {
-  const subjects = subjectsForScope2(input.scope, input.localPages, input.remotePages);
-  const decisions = await Promise.all(subjects.map(async (subject) => {
-    const baseSnapshot = await readPageBaseSnapshot({
+  const plan = await buildRemoteMergePlanWithConfig({
+    subjects: () => subjectsForScope2(input.scope, input.localPages, input.remotePages),
+    readBaseSnapshot: (subject) => readPageBaseSnapshot({
       contentDir: input.contentDir,
       target: input.target,
       subject
-    });
-    return planPageMerge({
-      subject,
-      base: baseSnapshot?.page ?? null,
-      local: localPageForSubject(input.localPages, subject),
-      remote: remotePageForSubject(input.remotePages, subject)
-    });
-  }));
+    }),
+    valueFromBaseSnapshot: (snapshot) => snapshot.page,
+    localValue: (subject) => localPageForSubject(input.localPages, subject),
+    remoteValue: (subject) => remotePageForSubject(input.remotePages, subject),
+    planDecision: planPageMerge,
+    summarize: summarizePageMergeDecisions
+  });
   return {
     scope: input.scope,
-    decisions,
-    summary: summarizePageMergeDecisions(decisions)
+    ...plan
   };
 }
 function summarizePageMergeDecisions(decisions) {
-  const summary = {
+  return summarizeMergeDecisions(decisions, {
     unchanged: 0,
     bootstrapBase: 0,
     preserveRemote: 0,
@@ -63845,36 +63980,17 @@ function summarizePageMergeDecisions(decisions) {
     applyLocalUpdate: 0,
     autoMerge: 0,
     conflicts: 0
-  };
-  for (const decision of decisions) {
-    switch (decision.kind) {
-      case "unchanged":
-        summary.unchanged++;
-        break;
-      case "bootstrap_base":
-        summary.bootstrapBase++;
-        break;
-      case "preserve_remote":
-        summary.preserveRemote++;
-        break;
-      case "apply_local_create":
-        summary.applyLocalCreate++;
-        break;
-      case "apply_local_update":
-        summary.applyLocalUpdate++;
-        break;
-      case "auto_merge":
-        summary.autoMerge++;
-        break;
-      case "conflict":
-        summary.conflicts++;
-        break;
-      default:
-        assertNever(decision);
-    }
-  }
-  return summary;
-}
+  }, pageSummaryKeyByDecisionKind);
+}
+var pageSummaryKeyByDecisionKind = {
+  unchanged: "unchanged",
+  bootstrap_base: "bootstrapBase",
+  preserve_remote: "preserveRemote",
+  apply_local_create: "applyLocalCreate",
+  apply_local_update: "applyLocalUpdate",
+  auto_merge: "autoMerge",
+  conflict: "conflicts"
+};
 function pageMergePushScope(input) {
   if (input.identifier) {
     return {
@@ -63906,41 +64022,16 @@ function remotePageForSubject(pages, subject) {
 }
 
 // src/cli/merge-remote/pageMergeReport.ts
-function remotePageMergeJsonReport(input) {
-  return {
-    kind: "push",
-    scope: "pages",
-    mergeRemote: true,
-    dryRun: input.dryRun,
-    summary: input.plan.summary,
-    decisions: input.plan.decisions.map(decisionReport2)
-  };
-}
-function writeRemotePageMergeHumanReport(output, plan, options) {
-  output.info(`
-${options.dryRun ? "[DRY RUN] " : ""}Remote-aware page merge plan:`);
-  output.info(formatSummary2(plan));
-  const conflicts = plan.decisions.filter((decision) => decision.kind === "conflict");
-  if (conflicts.length > 0) {
-    output.info("\nConflicts:");
-    for (const decision of conflicts) {
-      if (decision.kind !== "conflict") continue;
-      output.info(
-        `  - ${decision.subject.identifier}: ${decision.conflict.message}`
-      );
-    }
-  }
-  const changes = plan.decisions.filter((decision) => decision.kind !== "unchanged" && decision.kind !== "conflict");
-  if (changes.length > 0) {
-    output.info("\nDecisions:");
-    for (const decision of changes) {
-      output.info(`  - ${formatDecisionLine2(decision)}`);
-    }
-  }
-}
-function formatSummary2(plan) {
-  const { summary } = plan;
-  return [
+var pageDecisionLabels = {
+  apply_local_create: "apply local create",
+  apply_local_update: "apply local update",
+  preserve_remote: "preserve remote",
+  bootstrap_base: "bootstrap missing base"
+};
+var pageMergeReportConfig = {
+  scope: "pages",
+  title: "Remote-aware page merge plan:",
+  summaryLines: (summary) => [
     `  Local creates: ${summary.applyLocalCreate}`,
     `  Local updates: ${summary.applyLocalUpdate}`,
     `  Auto-merges: ${summary.autoMerge}`,
@@ -63948,50 +64039,27 @@ function formatSummary2(plan) {
     `  Base bootstraps: ${summary.bootstrapBase}`,
     `  Unchanged: ${summary.unchanged}`,
     `  Conflicts: ${summary.conflicts}`
-  ].join("\n");
-}
-function formatDecisionLine2(decision) {
-  const subject = decision.subject.identifier;
-  switch (decision.kind) {
-    case "auto_merge":
-      return `${subject}: auto-merge local [${decision.localFieldPaths.join(", ")}] with remote [${decision.remoteFieldPaths.join(", ")}]`;
-    case "conflict":
-      return `${subject}: conflict (${decision.conflict.code})`;
-    case "apply_local_create":
-      return `${subject}: apply local create`;
-    case "apply_local_update":
-      return `${subject}: apply local update`;
-    case "preserve_remote":
-      return `${subject}: preserve remote`;
-    case "bootstrap_base":
-      return `${subject}: bootstrap missing base`;
-    case "unchanged":
-      return `${subject}: unchanged`;
-  }
+  ],
+  subjectLabel: (subject) => subject.identifier,
+  subjectJson: (subject) => ({
+    identifier: subject.identifier
+  }),
+  decisionLabels: pageDecisionLabels
+};
+function remotePageMergeJsonReport(input) {
+  return remoteMergeJsonReport({
+    config: pageMergeReportConfig,
+    decisions: input.plan.decisions,
+    dryRun: input.dryRun,
+    summary: input.plan.summary
+  });
 }
-function decisionReport2(decision) {
-  const base = {
-    kind: decision.kind,
-    identifier: decision.subject.identifier
-  };
-  if (decision.kind === "auto_merge") {
-    return {
-      ...base,
-      localFieldPaths: decision.localFieldPaths,
-      remoteFieldPaths: decision.remoteFieldPaths
-    };
-  }
-  if (decision.kind === "conflict") {
-    return {
-      ...base,
-      conflict: {
-        code: decision.conflict.code,
-        ..."fieldPath" in decision.conflict ? { fieldPath: decision.conflict.fieldPath } : {},
-        message: decision.conflict.message
-      }
-    };
-  }
-  return base;
+function writeRemotePageMergeHumanReport(output, plan, options) {
+  writeRemoteMergeHumanReport(output, pageMergeReportConfig, {
+    decisions: plan.decisions,
+    dryRun: options.dryRun,
+    summary: plan.summary
+  });
 }
 
 // src/cli/merge-remote/pageMergePush.ts
@@ -64151,7 +64219,7 @@ function emptyPulledContent(overrides) {
 async function executeScopedPush(output, isRemote, options, globalOpts, scopeLabel, pullCommand2, shouldDeleteOrphans, pushFn, scopedOptions) {
   const target = isRemote ? "remote" : "local";
   const cliConfig = await loadCliConfigForEnv(target);
-  const contentDir = path20.resolve(options.contentDir ?? cliConfig.contentDir);
+  const contentDir = path21.resolve(options.contentDir ?? cliConfig.contentDir);
   if (!await contentDirExists(contentDir)) {
     return output.error(`Content directory not found: ${contentDir}`, {
       suggestion: `Run "riverbankcms pull ${pullCommand2}" first to download ${scopeLabel}`
@@ -64389,7 +64457,7 @@ async function executePushForEnv(output, target, scope, type, identifier, option
         );
       }
       const cliConfig2 = await loadCliConfigForEnv(target);
-      const contentDir2 = path20.resolve(options.contentDir ?? cliConfig2.contentDir);
+      const contentDir2 = path21.resolve(options.contentDir ?? cliConfig2.contentDir);
       if (!await contentDirExists(contentDir2)) {
         return output.error(`Content directory not found: ${contentDir2}`, {
           suggestion: 'Run "riverbankcms pull theme" first to download theme'
@@ -64556,7 +64624,7 @@ ${errors}`
       });
     }
     const cliConfig = await loadCliConfigForEnv(target);
-    const contentDir = path20.resolve(options.contentDir ?? cliConfig.contentDir);
+    const contentDir = path21.resolve(options.contentDir ?? cliConfig.contentDir);
     if (!await contentDirExists(contentDir)) {
       return output.error(`Content directory not found: ${contentDir}`, {
         suggestion: 'Run "riverbankcms pull" first to download content, or specify a different directory with --content-dir'
@@ -64607,7 +64675,7 @@ ${errors}`
     if (legacyFiles.length > 0) {
       process.exitCode = 1;
       output.result(false, "Legacy entry file format detected (one file per content type).", {
-        files: legacyFiles.map((f) => path20.basename(f)),
+        files: legacyFiles.map((f) => path21.basename(f)),
         suggestion: 'Run "riverbankcms migrate entries" to convert to content/entries/<type>/<identifier>.json (preserves local edits), or run "riverbankcms pull entries" to re-pull content in the new format.'
       });
       return { success: false };
@@ -65246,7 +65314,7 @@ function summarizePushAllExtras(local, remote, deleteOrphaned) {
   return dirty;
 }
 function verificationContentDir(options, cliConfig) {
-  return path20.resolve(options.contentDir ?? cliConfig.contentDir);
+  return path21.resolve(options.contentDir ?? cliConfig.contentDir);
 }
 async function loadGenericComparison(input) {
   const cliConfig = await loadCliConfigForEnv(input.target);
@@ -65432,15 +65500,27 @@ function emitPushVerificationResult(output, result, jsonOutput) {
 }
 
 // src/cli/commands/push.ts
-var pushCommand = new Command("push").description("Push content to CMS").argument(
-  "[scope]",
-  "What to push: entries, pages, navigation, forms, settings, footer, theme, venues, event-categories, events, courses, or all (default)"
-).argument("[type]", "Content type (entries), page identifier (pages), or theme name (theme)").argument("[identifier]", 'Entry identifier (when scope is "entries" and type is set)').option("--content-dir <dir>", "Content directory (overrides config)").option("--dry-run", "Show what would be pushed without making changes").option("--yes", "Skip confirmation prompt (required for --env=remote or --env=both)").option("--force", "Push even if remote content is newer (skip stale check)").option("--force-update-asset", "Replace CMS media when identifiers conflict (local media sync only)").option("--allow-truncated", "Push even if remote content was truncated (may cause incomplete sync)").option("--json-diff [mode]", "Output JSON diff (summary or full)", "summary").option("--with-config", "Push SDK schema/config before dependent file content").option("--with-theme", "Also push theme when pushing all content").option("--sync-media", "Sync media files from local to remote environment").option("--overwrite-media", "When using --sync-media, overwrite target media on checksum mismatch").option("--allow-missing-media", "For event pushes, report missing local media but continue pushing event config").option(
-  "--delete-missing",
-  "[Deprecated: use --delete-orphaned] Delete CMS entries not in local file (single content type only)"
-).option("--delete-orphaned", "Delete remote items not present in local files (entries, events, courses, venues, event-categories)").option("--auto-pull-stale", "Automatically pull stale content and retry push").option("--merge-remote", "Plan an entries/pages three-way merge that preserves remote edits").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)").option("--verify-noop", "After an applied push, re-fetch the target and fail if changes remain").addHelpText(
-  "after",
-  `
+function getProductionPushCommandDeps() {
+  return {
+    getOutputContext,
+    runForEnvironments,
+    allEnvSucceeded,
+    executePushForEnv,
+    verifyPushNoopForEnv,
+    emitPushVerificationResult,
+    isPushVerificationClean
+  };
+}
+function createPushCommand(deps = getProductionPushCommandDeps()) {
+  return new Command("push").description("Push content to CMS").argument(
+    "[scope]",
+    "What to push: entries, pages, navigation, forms, settings, footer, theme, venues, event-categories, events, courses, or all (default)"
+  ).argument("[type]", "Content type (entries), page identifier (pages), or theme name (theme)").argument("[identifier]", 'Entry identifier (when scope is "entries" and type is set)').option("--content-dir <dir>", "Content directory (overrides config)").option("--dry-run", "Show what would be pushed without making changes").option("--yes", "Skip confirmation prompt (required for --env=remote or --env=both)").option("--force", "Push even if remote content is newer (skip stale check)").option("--force-update-asset", "Replace CMS media when identifiers conflict (local media sync only)").option("--allow-truncated", "Push even if remote content was truncated (may cause incomplete sync)").option("--json-diff [mode]", "Output JSON diff (summary or full)", "summary").option("--with-config", "Push SDK schema/config before dependent file content").option("--with-theme", "Also push theme when pushing all content").option("--sync-media", "Sync media files from local to remote environment").option("--overwrite-media", "When using --sync-media, overwrite target media on checksum mismatch").option("--allow-missing-media", "For event pushes, report missing local media but continue pushing event config").option(
+    "--delete-missing",
+    "[Deprecated: use --delete-orphaned] Delete CMS entries not in local file (single content type only)"
+  ).option("--delete-orphaned", "Delete remote items not present in local files (entries, events, courses, venues, event-categories)").option("--auto-pull-stale", "Automatically pull stale content and retry push").option("--merge-remote", "Plan an entries/pages three-way merge that preserves remote edits").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)").option("--verify-noop", "After an applied push, re-fetch the target and fail if changes remain").addHelpText(
+    "after",
+    `
 Examples:
   $ riverbankcms push                         # Push all content to local
   $ riverbankcms push --env=remote --yes      # Push to production
@@ -65514,124 +65594,126 @@ Media Sync:
   $ riverbankcms push --sync-media                    # Sync all content + media
   $ riverbankcms push entries blog --sync-media       # Sync blog entries + their media
 `
-).action(
-  async (scope, type, identifier, options, command) => {
-    const { output, envTargets, globalOpts } = getOutputContext(command);
-    const jsonDiffMode = options.jsonDiff ? options.jsonDiff === "summary" || options.jsonDiff === "full" ? options.jsonDiff : null : void 0;
-    if (options.jsonDiff && !jsonDiffMode) {
-      output.error("Invalid value for --json-diff. Use summary or full.");
-      return;
-    }
-    if (options.diff && !options.dryRun) {
-      output.error("--diff requires --dry-run.");
-      return;
-    }
-    if (options.diff && options.jsonDiff) {
-      output.error("--diff and --json-diff are mutually exclusive.");
-      return;
-    }
-    if (options.diff && globalOpts.json) {
-      output.error("--diff and --json are mutually exclusive.");
-      return;
-    }
-    if (options.verifyNoop && options.dryRun) {
-      output.error("--verify-noop cannot be combined with --dry-run.");
-      return;
-    }
-    if (options.mergeRemote && envTargets.length > 1) {
-      process.exitCode = 1;
-      output.result(false, "--merge-remote does not support --env=both in v1.", {
-        suggestion: "Run one remote entries merge at a time with --env=remote."
-      });
-      return;
-    }
-    if (envTargets.length > 1) {
-      const results = await runForEnvironments(
-        envTargets,
-        async (target2) => {
-          const isRemote2 = target2 === "remote";
-          let dryRun2 = options.dryRun ?? false;
-          if (isRemote2 && !options.yes) {
-            dryRun2 = true;
-            output.info(`Remote push defaults to dry-run mode. Use --yes to apply changes.`);
-          }
-          if (options.verifyNoop && dryRun2) {
-            output.error("--verify-noop requires an applied push. Remove --dry-run or pass --yes for remote targets.");
-            return { success: false };
-          }
-          output.info(`
+  ).action(
+    async (scope, type, identifier, options, command) => {
+      const { output, envTargets, globalOpts } = deps.getOutputContext(command);
+      const jsonDiffMode = options.jsonDiff ? options.jsonDiff === "summary" || options.jsonDiff === "full" ? options.jsonDiff : null : void 0;
+      if (options.jsonDiff && !jsonDiffMode) {
+        output.error("Invalid value for --json-diff. Use summary or full.");
+        return;
+      }
+      if (options.diff && !options.dryRun) {
+        output.error("--diff requires --dry-run.");
+        return;
+      }
+      if (options.diff && options.jsonDiff) {
+        output.error("--diff and --json-diff are mutually exclusive.");
+        return;
+      }
+      if (options.diff && globalOpts.json) {
+        output.error("--diff and --json are mutually exclusive.");
+        return;
+      }
+      if (options.verifyNoop && options.dryRun) {
+        output.error("--verify-noop cannot be combined with --dry-run.");
+        return;
+      }
+      if (options.mergeRemote && envTargets.length > 1) {
+        process.exitCode = 1;
+        output.result(false, "--merge-remote does not support --env=both in v1.", {
+          suggestion: "Run one remote entries merge at a time with --env=remote."
+        });
+        return;
+      }
+      if (envTargets.length > 1) {
+        const results = await deps.runForEnvironments(
+          envTargets,
+          async (target2) => {
+            const isRemote2 = target2 === "remote";
+            let dryRun2 = options.dryRun ?? false;
+            if (isRemote2 && !options.yes) {
+              dryRun2 = true;
+              output.info(`Remote push defaults to dry-run mode. Use --yes to apply changes.`);
+            }
+            if (options.verifyNoop && dryRun2) {
+              output.error("--verify-noop requires an applied push. Remove --dry-run or pass --yes for remote targets.");
+              return { success: false };
+            }
+            output.info(`
 --- Pushing to ${target2} environment ---`);
-          const pushResult = await executePushForEnv(
-            output,
-            target2,
-            scope,
-            type,
-            identifier,
-            { ...options, dryRun: dryRun2, jsonDiffMode },
-            globalOpts
-          );
-          if (!pushResult.success || !options.verifyNoop) {
-            return pushResult;
+            const pushResult = await deps.executePushForEnv(
+              output,
+              target2,
+              scope,
+              type,
+              identifier,
+              { ...options, dryRun: dryRun2, jsonDiffMode },
+              globalOpts
+            );
+            if (!pushResult.success || !options.verifyNoop) {
+              return pushResult;
+            }
+            const verification = await deps.verifyPushNoopForEnv({
+              target: target2,
+              scope,
+              type,
+              identifier,
+              options
+            });
+            deps.emitPushVerificationResult(output, verification, globalOpts.json ?? false);
+            return { success: deps.isPushVerificationClean(verification) };
+          },
+          output,
+          {
+            isResultSuccess: (result2) => result2.success,
+            formatFailure: () => "Push completed with failures"
           }
-          const verification = await verifyPushNoopForEnv({
-            target: target2,
-            scope,
-            type,
-            identifier,
-            options
-          });
-          emitPushVerificationResult(output, verification, globalOpts.json ?? false);
-          return { success: isPushVerificationClean(verification) };
-        },
-        output,
-        {
-          isResultSuccess: (result2) => result2.success,
-          formatFailure: () => "Push completed with failures"
+        );
+        if (!deps.allEnvSucceeded(results)) {
+          process.exit(1);
         }
-      );
-      if (!allEnvSucceeded(results)) {
-        process.exit(1);
+        return;
       }
-      return;
-    }
-    const target = envTargets[0] ?? "local";
-    const isRemote = target === "remote";
-    let dryRun = options.dryRun ?? false;
-    if (isRemote && !options.yes) {
-      dryRun = true;
-      output.info("Remote push defaults to dry-run mode. Use --yes to apply changes.");
-    }
-    if (options.verifyNoop && dryRun) {
-      output.error("--verify-noop requires an applied push. Remove --dry-run or pass --yes for remote targets.");
-      return;
-    }
-    const result = await executePushForEnv(
-      output,
-      target,
-      scope,
-      type,
-      identifier,
-      { ...options, dryRun, jsonDiffMode },
-      globalOpts
-    );
-    if (!result.success) {
-      process.exit(1);
-    }
-    if (options.verifyNoop) {
-      const verification = await verifyPushNoopForEnv({
+      const target = envTargets[0] ?? "local";
+      const isRemote = target === "remote";
+      let dryRun = options.dryRun ?? false;
+      if (isRemote && !options.yes) {
+        dryRun = true;
+        output.info("Remote push defaults to dry-run mode. Use --yes to apply changes.");
+      }
+      if (options.verifyNoop && dryRun) {
+        output.error("--verify-noop requires an applied push. Remove --dry-run or pass --yes for remote targets.");
+        return;
+      }
+      const result = await deps.executePushForEnv(
+        output,
         target,
         scope,
         type,
         identifier,
-        options
-      });
-      emitPushVerificationResult(output, verification, globalOpts.json ?? false);
-      if (!isPushVerificationClean(verification)) {
+        { ...options, dryRun, jsonDiffMode },
+        globalOpts
+      );
+      if (!result.success) {
         process.exit(1);
       }
+      if (options.verifyNoop) {
+        const verification = await deps.verifyPushNoopForEnv({
+          target,
+          scope,
+          type,
+          identifier,
+          options
+        });
+        deps.emitPushVerificationResult(output, verification, globalOpts.json ?? false);
+        if (!deps.isPushVerificationClean(verification)) {
+          process.exit(1);
+        }
+      }
     }
-  }
-);
+  );
+}
+var pushCommand = createPushCommand();
 
 // src/cli/media/write-guard.ts
 var MEDIA_GUARD_BYPASS_ENV_VAR = "RIVERBANK_SKIP_MEDIA_GUARD";
@@ -68057,41 +68139,41 @@ function formatVisibleWhen(visibleWhen) {
 // src/cli/init-docs/index.ts
 var AGENTS_START = "<!-- RIVERBANK-CONTEXT-START -->";
 var AGENTS_END = "<!-- RIVERBANK-CONTEXT-END -->";
-var currentDir2 = path20.dirname(fileURLToPath(import.meta.url));
+var currentDir2 = path21.dirname(fileURLToPath(import.meta.url));
 function getContentDir() {
   const isBundled = currentDir2.includes("/dist/cli") || currentDir2.endsWith("/dist/cli");
   if (isBundled) {
-    return path20.join(currentDir2, "init-docs", "content");
+    return path21.join(currentDir2, "init-docs", "content");
   }
-  return path20.join(currentDir2, "content");
+  return path21.join(currentDir2, "content");
 }
 function loadTemplate(name) {
   const contentDir = getContentDir();
-  const filePath = path20.join(contentDir, `${name}.md`);
+  const filePath = path21.join(contentDir, `${name}.md`);
   return readFileSync(filePath, "utf-8");
 }
 async function initDocs(options) {
   const { rootDir, configPath, agentsPath } = options;
-  const docsDir = path20.join(rootDir, "docs");
-  const contextDir = path20.join(rootDir, "context");
-  const workflowsDir = path20.join(docsDir, "workflows");
-  const siteWorkflowsDir = path20.join(docsDir, "site-workflows");
-  const knowledgeDir = path20.join(contextDir, "knowledge");
-  const brandDir = path20.join(contextDir, "brand");
+  const docsDir = path21.join(rootDir, "docs");
+  const contextDir = path21.join(rootDir, "context");
+  const workflowsDir = path21.join(docsDir, "workflows");
+  const siteWorkflowsDir = path21.join(docsDir, "site-workflows");
+  const knowledgeDir = path21.join(contextDir, "knowledge");
+  const brandDir = path21.join(contextDir, "brand");
   await ensureDir3(workflowsDir);
   await ensureDir3(siteWorkflowsDir);
   await ensureDir3(knowledgeDir);
   await ensureDir3(brandDir);
   await writeFileIfMissing(
-    path20.join(docsDir, "getting-started.md"),
+    path21.join(docsDir, "getting-started.md"),
     loadTemplate("getting-started")
   );
   await writeFileIfMissing(
-    path20.join(docsDir, "cli-reference.md"),
+    path21.join(docsDir, "cli-reference.md"),
     loadTemplate("cli-reference")
   );
   await writeFileIfMissing(
-    path20.join(docsDir, "content-management.md"),
+    path21.join(docsDir, "content-management.md"),
     loadTemplate("content-management")
   );
   const coreWorkflows = [
@@ -68112,46 +68194,46 @@ async function initDocs(options) {
   await Promise.all(
     coreWorkflows.map(
       ({ filename, template }) => fs2.writeFile(
-        path20.join(workflowsDir, filename),
+        path21.join(workflowsDir, filename),
         loadTemplate(template),
         "utf-8"
       )
     )
   );
   await writeFileIfMissing(
-    path20.join(siteWorkflowsDir, "README.md"),
+    path21.join(siteWorkflowsDir, "README.md"),
     loadTemplate("site-workflows-readme")
   );
   await writeFileIfMissing(
-    path20.join(contextDir, "brief.md"),
+    path21.join(contextDir, "brief.md"),
     loadTemplate("context-brief")
   );
   await writeFileIfMissing(
-    path20.join(knowledgeDir, "README.md"),
+    path21.join(knowledgeDir, "README.md"),
     loadTemplate("context-knowledge")
   );
   await writeFileIfMissing(
-    path20.join(brandDir, "README.md"),
+    path21.join(brandDir, "README.md"),
     loadTemplate("context-brand")
   );
   const { config: config2, errorMessage } = await loadConfig(configPath, options.output);
   await upsertGeneratedDoc(
-    path20.join(docsDir, "schema.md"),
+    path21.join(docsDir, "schema.md"),
     buildSchemaTemplate({ config: config2, errorMessage }),
     buildSchemaGeneratedSection({ config: config2, errorMessage })
   );
   await upsertGeneratedDoc(
-    path20.join(docsDir, "block-types.md"),
+    path21.join(docsDir, "block-types.md"),
     buildBlockTypesTemplate(),
     buildBlockTypesGeneratedSection()
   );
   await upsertGeneratedDoc(
-    path20.join(docsDir, "block-types-site.md"),
+    path21.join(docsDir, "block-types-site.md"),
     buildSiteBlockTypesTemplate({ config: config2, errorMessage }),
     buildSiteBlockTypesGeneratedSection({ config: config2, errorMessage })
   );
   await upsertGeneratedDoc(
-    path20.join(docsDir, "theme-schema.md"),
+    path21.join(docsDir, "theme-schema.md"),
     buildThemeSchemaTemplate(),
     buildThemeSchemaGeneratedSection()
   );
@@ -68238,9 +68320,9 @@ async function upsertAgentsSection(filePath) {
 // src/cli/commands/init-docs.ts
 async function runInitDocs(options, command) {
   const { output, isJsonOutput } = createCommandContext(command);
-  const rootDir = path20.resolve(options.path ?? ".riverbank");
-  const configPath = path20.resolve(options.config ?? path20.join(process.cwd(), "riverbank.config.ts"));
-  const agentsPath = path20.resolve(process.cwd(), "AGENTS.md");
+  const rootDir = path21.resolve(options.path ?? ".riverbank");
+  const configPath = path21.resolve(options.config ?? path21.join(process.cwd(), "riverbank.config.ts"));
+  const agentsPath = path21.resolve(process.cwd(), "AGENTS.md");
   await initDocs({
     rootDir,
     configPath,
@@ -68435,7 +68517,7 @@ var SimpleCache = class {
 };
 
 // src/version.ts
-var SDK_VERSION = "0.98.0";
+var SDK_VERSION = "0.99.0";
 
 // src/client/error.ts
 var RiverbankApiError = class _RiverbankApiError extends Error {
@@ -69636,7 +69718,14 @@ function resolveAuth(config2) {
     'Authentication configuration is required. Provide either `auth` (recommended) or `apiKey` (deprecated). For public endpoints without auth, use: { auth: { type: "none" } }'
   );
 }
+var defaultRiverbankClientDeps = {
+  createBearerAPIClient,
+  createInternalAPIClient
+};
 function createRiverbankClient(config2) {
+  return createRiverbankClientWithDeps(defaultRiverbankClientDeps, config2);
+}
+function createRiverbankClientWithDeps(deps, config2) {
   if (!config2.baseUrl) {
     throw new Error(
       "baseUrl is required when creating a Riverbank client. Expected format: https://dashboard.example.com/api (must include /api path)"
@@ -69679,7 +69768,7 @@ function createRiverbankClient(config2) {
       keyType = "preview";
       break;
   }
-  const baseApiClient = authConfig.type === "none" ? createInternalAPIClient(config2.baseUrl) : authConfig.type === "api-key" ? createBearerAPIClient(authConfig.key, config2.baseUrl) : createBearerAPIClient(authConfig.token, config2.baseUrl);
+  const baseApiClient = authConfig.type === "none" ? deps.createInternalAPIClient(config2.baseUrl) : authConfig.type === "api-key" ? deps.createBearerAPIClient(authConfig.key, config2.baseUrl) : deps.createBearerAPIClient(authConfig.token, config2.baseUrl);
   const apiClient = withDefaultHeaders(baseApiClient, config2.defaultHeaders);
   const cache = new SimpleCache({
     maxSize: cacheMaxSize,
@@ -70046,17 +70135,17 @@ function createRiverbankClient(config2) {
   async function getPageWithResilienceInternal(params) {
     const {
       siteId,
-      path: path32,
+      path: path33,
       preview = false,
       signal,
       contentContract = "compat"
     } = params;
     const publishedRuntimeCache = planPublishedRuntimeCache({
       endpoint: "getContentByPath",
-      params: { siteId, path: path32, preview, contentContract },
+      params: { siteId, path: path33, preview, contentContract },
       siteId
     });
-    const cacheKey = publishedRuntimeCache?.cacheKey ?? `page:${siteId}:${path32}:${preview}:${contentContract}`;
+    const cacheKey = publishedRuntimeCache?.cacheKey ?? `page:${siteId}:${path33}:${preview}:${contentContract}`;
     return resilientFetch(
       cacheKey,
       async (sig) => {
@@ -70064,7 +70153,7 @@ function createRiverbankClient(config2) {
           endpoint: "getContentByPath",
           params: {
             siteId,
-            path: path32,
+            path: path33,
             preview: String(preview),
             ...contentContract === "native" ? { contentContract } : {}
           },
@@ -70076,7 +70165,7 @@ function createRiverbankClient(config2) {
         signal,
         publishedRuntimeCache,
         // Prebuild fallback only for published pages (not preview)
-        prebuildFallback: prebuildLoader && !preview && contentContract !== "native" ? () => prebuildLoader.loadPage(siteId, path32) : void 0
+        prebuildFallback: prebuildLoader && !preview && contentContract !== "native" ? () => prebuildLoader.loadPage(siteId, path33) : void 0
       }
     );
   }
@@ -70568,17 +70657,17 @@ function createRiverbankClient(config2) {
       };
     },
     async checkRedirect(params) {
-      const { siteId, path: path32, signal } = params;
-      if (!siteId || !path32) {
+      const { siteId, path: path33, signal } = params;
+      if (!siteId || !path33) {
         throw new Error("checkRedirect() requires siteId and path");
       }
-      const cacheKey = `redirect:${siteId}:${path32}`;
+      const cacheKey = `redirect:${siteId}:${path33}`;
       return resilientFetchData(
         cacheKey,
         async (sig) => {
           return await apiClient({
             endpoint: "checkRedirect",
-            params: { site: siteId, path: path32 },
+            params: { site: siteId, path: path33 },
             options: { signal: sig }
           });
         },
@@ -70586,27 +70675,27 @@ function createRiverbankClient(config2) {
       );
     },
     async resolveRouteOutcome(params) {
-      const { siteId, path: path32, preview = false, signal } = params;
-      if (!siteId || !path32) {
+      const { siteId, path: path33, preview = false, signal } = params;
+      if (!siteId || !path33) {
         throw new Error("resolveRouteOutcome() requires siteId and path");
       }
       return unwrapResponse(
         await apiClient({
           endpoint: "resolveRouteOutcome",
-          params: { siteId, path: path32, preview: String(preview) },
+          params: { siteId, path: path33, preview: String(preview) },
           options: { signal }
         })
       );
     },
     async resolveRouteDecision(params) {
-      const { siteId, path: path32, preview = false, signal } = params;
-      if (!siteId || !path32) {
+      const { siteId, path: path33, preview = false, signal } = params;
+      if (!siteId || !path33) {
         throw new Error("resolveRouteDecision() requires siteId and path");
       }
       return unwrapResponse(
         await apiClient({
           endpoint: "resolveRouteDecision",
-          params: { siteId, path: path32, preview: String(preview) },
+          params: { siteId, path: path33, preview: String(preview) },
           options: { signal }
         })
       );
@@ -70718,7 +70807,7 @@ async function fetchAllEntries(client, siteId, contentType, onProgress) {
 async function prebuildSite(client, siteId, outputDir) {
   const site = await client.getSite({ id: siteId });
   const filename = "site.json";
-  const filePath = path20.join(outputDir, filename);
+  const filePath = path21.join(outputDir, filename);
   const cacheFile = {
     data: site,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -70727,7 +70816,7 @@ async function prebuildSite(client, siteId, outputDir) {
   return { files: [filename], size, siteData: site };
 }
 async function prebuildPages(client, siteId, routes, outputDir, onProgress) {
-  const pagesDir = path20.join(outputDir, "pages");
+  const pagesDir = path21.join(outputDir, "pages");
   ensureDir4(pagesDir);
   const files = [];
   const pathMappings = {};
@@ -70747,7 +70836,7 @@ async function prebuildPages(client, siteId, routes, outputDir, onProgress) {
     try {
       const pageData = await client.getPage({ siteId, path: pagePath, preview: false });
       const filename = pathToFilename(pagePath);
-      const filePath = path20.join(pagesDir, filename);
+      const filePath = path21.join(pagesDir, filename);
       const cacheFile = {
         data: pageData,
         path: pagePath,
@@ -70772,13 +70861,13 @@ async function prebuildPages(client, siteId, routes, outputDir, onProgress) {
     totalCount: pageIndex.length,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  const indexPath = path20.join(pagesDir, "_index.json");
+  const indexPath = path21.join(pagesDir, "_index.json");
   totalSize += writeJsonFile3(indexPath, indexFile);
   files.push("pages/_index.json");
   return { files, size: totalSize, pathMappings };
 }
 async function prebuildEntries(client, siteId, contentTypes, outputDir, onProgress) {
-  const entriesDir = path20.join(outputDir, "entries");
+  const entriesDir = path21.join(outputDir, "entries");
   ensureDir4(entriesDir);
   const files = [];
   let totalSize = 0;
@@ -70799,7 +70888,7 @@ async function prebuildEntries(client, siteId, contentTypes, outputDir, onProgre
         });
       }
     );
-    const typeDir = path20.join(entriesDir, contentType);
+    const typeDir = path21.join(entriesDir, contentType);
     ensureDir4(typeDir);
     const cacheFile = {
       entries,
@@ -70808,14 +70897,14 @@ async function prebuildEntries(client, siteId, contentTypes, outputDir, onProgre
       generatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     const filename = `entries/${contentType}/all.json`;
-    const filePath = path20.join(entriesDir, contentType, "all.json");
+    const filePath = path21.join(entriesDir, contentType, "all.json");
     totalSize += writeJsonFile3(filePath, cacheFile);
     files.push(filename);
   }
   return { files, size: totalSize };
 }
 async function prebuildNavigation(siteData, outputDir, onProgress) {
-  const navDir = path20.join(outputDir, "navigation");
+  const navDir = path21.join(outputDir, "navigation");
   ensureDir4(navDir);
   const files = [];
   let totalSize = 0;
@@ -70836,13 +70925,13 @@ async function prebuildNavigation(siteData, outputDir, onProgress) {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   const filename = "navigation/menus.json";
-  const filePath = path20.join(navDir, "menus.json");
+  const filePath = path21.join(navDir, "menus.json");
   totalSize += writeJsonFile3(filePath, cacheFile);
   files.push(filename);
   return { files, size: totalSize };
 }
 async function prebuildForms(client, siteId, outputDir, onProgress) {
-  const formsDir = path20.join(outputDir, "forms");
+  const formsDir = path21.join(outputDir, "forms");
   ensureDir4(formsDir);
   const files = [];
   let totalSize = 0;
@@ -70867,7 +70956,7 @@ async function prebuildForms(client, siteId, outputDir, onProgress) {
       generatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     const filename = "forms/forms.json";
-    const filePath = path20.join(formsDir, "forms.json");
+    const filePath = path21.join(formsDir, "forms.json");
     totalSize += writeJsonFile3(filePath, cacheFile);
     files.push(filename);
   } catch (error) {
@@ -70985,7 +71074,7 @@ async function prebuildCache(options) {
   };
   const checksum = calculateChecksum(manifest);
   manifest.checksum = checksum;
-  const manifestPath = path20.join(outputDir, MANIFEST_FILENAME);
+  const manifestPath = path21.join(outputDir, MANIFEST_FILENAME);
   writeJsonFile3(manifestPath, manifest);
   return {
     success: errors.length === 0,
@@ -71014,7 +71103,7 @@ async function loadDeployConfig() {
 }
 async function checkWorkingDirectoryClean(git, prebuildOutput) {
   const status = await git.status();
-  const dirtyFiles = status.files.map((f) => f.path).filter((path32) => !path32.startsWith(prebuildOutput));
+  const dirtyFiles = status.files.map((f) => f.path).filter((path33) => !path33.startsWith(prebuildOutput));
   return {
     clean: dirtyFiles.length === 0,
     dirtyFiles
@@ -71545,25 +71634,25 @@ function mapMediaGuardDiagnosticsToAuditIssues(diagnostics) {
     }
   }));
 }
-function extractEmbedReferences(data, path32 = []) {
+function extractEmbedReferences(data, path33 = []) {
   const refs = [];
   if (!data || typeof data !== "object") return refs;
   if (Array.isArray(data)) {
     data.forEach((item, index) => {
-      refs.push(...extractEmbedReferences(item, [...path32, String(index)]));
+      refs.push(...extractEmbedReferences(item, [...path33, String(index)]));
     });
     return refs;
   }
   const obj = data;
   if (obj.kind === "embed" && typeof obj.contentType === "string" && typeof obj.identifier === "string") {
     refs.push({
-      path: path32.join("."),
+      path: path33.join("."),
       contentType: obj.contentType,
       identifier: obj.identifier
     });
   }
   for (const [key, value] of Object.entries(obj)) {
-    refs.push(...extractEmbedReferences(value, [...path32, key]));
+    refs.push(...extractEmbedReferences(value, [...path33, key]));
   }
   return refs;
 }
@@ -71744,7 +71833,7 @@ async function executeAuditForEnv(output, target, options, isJsonOutput) {
   const warnings = [];
   try {
     const cliConfig = await loadCliConfig();
-    const contentDir = path20.resolve(options.contentDir ?? cliConfig.contentDir);
+    const contentDir = path21.resolve(options.contentDir ?? cliConfig.contentDir);
     if (!await contentDirExists(contentDir)) {
       errors.push({
         severity: "error",
@@ -72066,7 +72155,7 @@ async function executeCompareLocalVsCms(output, target, scope, contentType, opti
   const isRemote = target === "remote";
   try {
     const cliConfig = await loadCliConfig();
-    const contentDir = path20.resolve(options.contentDir ?? cliConfig.contentDir);
+    const contentDir = path21.resolve(options.contentDir ?? cliConfig.contentDir);
     if (!await contentDirExists(contentDir)) {
       output.error(`Content directory not found: ${contentDir}`, {
         suggestion: 'Run "riverbankcms pull" first to download content'
@@ -72312,7 +72401,7 @@ function createDebugWriter(debugDir) {
     };
   }
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const runDir = path20.join(debugDir, `manifest-${timestamp}`);
+  const runDir = path21.join(debugDir, `manifest-${timestamp}`);
   let dirCreated = false;
   async function ensureDir5() {
     if (!dirCreated) {
@@ -72325,14 +72414,14 @@ function createDebugWriter(debugDir) {
     async writeText(filename, content) {
       try {
         await ensureDir5();
-        await fs2.writeFile(path20.join(runDir, filename), content, "utf-8");
+        await fs2.writeFile(path21.join(runDir, filename), content, "utf-8");
       } catch {
       }
     },
     async writeJson(filename, value) {
       try {
         await ensureDir5();
-        await fs2.writeFile(path20.join(runDir, filename), JSON.stringify(value, null, 2), "utf-8");
+        await fs2.writeFile(path21.join(runDir, filename), JSON.stringify(value, null, 2), "utf-8");
       } catch {
       }
     }
@@ -72497,7 +72586,7 @@ function formatThemeSummaryForPrompt(summary) {
 }
 
 // src/manifest/validation/layout-utils.ts
-function collectLayoutNodeInfos(node, path32 = "layout", out = []) {
+function collectLayoutNodeInfos(node, path33 = "layout", out = []) {
   if (!node || typeof node !== "object") return out;
   const n = node;
   const type = typeof n.type === "string" ? n.type : "unknown";
@@ -72506,10 +72595,10 @@ function collectLayoutNodeInfos(node, path32 = "layout", out = []) {
     const b = n.$bind;
     if (typeof b.from === "string") bindFrom = b.from;
   }
-  out.push({ path: path32, type, bindFrom });
+  out.push({ path: path33, type, bindFrom });
   if (Array.isArray(n.children)) {
     for (let i = 0; i < n.children.length; i++) {
-      collectLayoutNodeInfos(n.children[i], `${path32}.children[${i}]`, out);
+      collectLayoutNodeInfos(n.children[i], `${path33}.children[${i}]`, out);
     }
   }
   return out;
@@ -72931,7 +73020,7 @@ function extractNestedHrefBindFromProps(props2) {
   const bind2 = href.$bind;
   return bind2 && typeof bind2 === "object" ? bind2 : null;
 }
-function findMissingLinkHrefs(node, blockId, fields3, path32 = "layout", repeatStack = []) {
+function findMissingLinkHrefs(node, blockId, fields3, path33 = "layout", repeatStack = []) {
   const errors = [];
   if (!node || typeof node !== "object") return errors;
   const n = node;
@@ -72960,21 +73049,21 @@ function findMissingLinkHrefs(node, blockId, fields3, path32 = "layout", repeatS
     if (isBoundToLinkField) {
       if (!hrefBind || !hrefFrom) {
         errors.push({
-          path: path32,
-          message: `Block "${blockId}": ${nodeType} node at ${path32} is bound to a link field but is missing props.href binding`,
+          path: path33,
+          message: `Block "${blockId}": ${nodeType} node at ${path33} 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: path32,
-          message: `Block "${blockId}": ${nodeType} node at ${path32} has props.href binding but is missing transforms: [{id:"links.resolve"}]`,
+          path: path33,
+          message: `Block "${blockId}": ${nodeType} node at ${path33} 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: path32,
-          message: `Block "${blockId}": ${nodeType} node at ${path32} binds label from a link field but is missing links.label transform`,
+          path: path33,
+          message: `Block "${blockId}": ${nodeType} node at ${path33} 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.`
         });
       }
@@ -72987,7 +73076,7 @@ function findMissingLinkHrefs(node, blockId, fields3, path32 = "layout", repeatS
           n.children[i],
           blockId,
           fields3,
-          `${path32}.children[${i}]`,
+          `${path33}.children[${i}]`,
           nextRepeatStack
         )
       );
@@ -72995,7 +73084,7 @@ function findMissingLinkHrefs(node, blockId, fields3, path32 = "layout", repeatS
   }
   return errors;
 }
-function detectRedundantLinkLabels(node, blockId, fields3, path32 = "layout", repeatStack = []) {
+function detectRedundantLinkLabels(node, blockId, fields3, path33 = "layout", repeatStack = []) {
   const errors = [];
   if (!node || typeof node !== "object") return errors;
   const n = node;
@@ -73017,7 +73106,7 @@ function detectRedundantLinkLabels(node, blockId, fields3, path32 = "layout", re
     const redundancies = findRedundantLinkTextSiblings(
       children,
       nextRepeatStack,
-      path32
+      path33
     );
     errors.push(
       ...redundancies.map((r) => ({
@@ -73034,7 +73123,7 @@ function detectRedundantLinkLabels(node, blockId, fields3, path32 = "layout", re
           n.children[i],
           blockId,
           fields3,
-          `${path32}.children[${i}]`,
+          `${path33}.children[${i}]`,
           nextRepeatStack
         )
       );
@@ -73273,19 +73362,19 @@ function extractBlockIdFromSelector(selector) {
   const match = selector.match(/\[data-block=(["'])(custom\.[^"']+)\1\]/);
   return match?.[2] ?? null;
 }
-function validateNodeType(nodeType, path32, ctx) {
+function validateNodeType(nodeType, path33, ctx) {
   if (!ALLOWED_NODE_TYPES.includes(
     nodeType
   )) {
     return {
-      path: `${path32}.type`,
-      message: `Block "${ctx.blockId}": Unknown node type "${nodeType}" at ${path32}`,
+      path: `${path33}.type`,
+      message: `Block "${ctx.blockId}": Unknown node type "${nodeType}" at ${path33}`,
       suggestion: `ALLOWED: ${ALLOWED_NODE_TYPES.slice(0, 10).join(", ")}... FIX: Replace "${nodeType}" with a valid node type.`
     };
   }
   return null;
 }
-function validateTransforms(transforms, path32, ctx) {
+function validateTransforms(transforms, path33, ctx) {
   const errors = [];
   for (let i = 0; i < transforms.length; i++) {
     const transform = transforms[i];
@@ -73294,7 +73383,7 @@ function validateTransforms(transforms, path32, ctx) {
         transform.id
       )) {
         errors.push({
-          path: `${path32}.transforms[${i}].id`,
+          path: `${path33}.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.`
         });
@@ -73303,7 +73392,7 @@ function validateTransforms(transforms, path32, ctx) {
   }
   return errors;
 }
-function validateBinding(bind2, path32, ctx) {
+function validateBinding(bind2, path33, ctx) {
   const errors = [];
   if ("from" in bind2 && typeof bind2.from === "string") {
     const bindPath = bind2.from;
@@ -73311,7 +73400,7 @@ function validateBinding(bind2, path32, ctx) {
       const fieldId = bindPath.replace("content.", "").split(".")[0] ?? "";
       if (fieldId && !ctx.fieldIds.has(fieldId)) {
         errors.push({
-          path: `${path32}.from`,
+          path: `${path33}.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.`
         });
@@ -73319,31 +73408,31 @@ function validateBinding(bind2, path32, ctx) {
     }
   }
   if ("transforms" in bind2 && Array.isArray(bind2.transforms)) {
-    errors.push(...validateTransforms(bind2.transforms, path32, ctx));
+    errors.push(...validateTransforms(bind2.transforms, path33, ctx));
   }
   return errors;
 }
-function validateLayoutDeep(node, blockId, fields3, path32 = "layout") {
+function validateLayoutDeep(node, blockId, fields3, path33 = "layout") {
   const ctx = {
     blockId,
     fieldIds: collectFieldIds(fields3)
   };
-  return validateLayoutNode(node, path32, ctx);
+  return validateLayoutNode(node, path33, ctx);
 }
-function validateLayoutNode(node, path32, ctx) {
+function validateLayoutNode(node, path33, 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, path32, ctx);
+    const typeError = validateNodeType(n.type, path33, ctx);
     if (typeError) errors.push(typeError);
   }
   if ("$bind" in n && n.$bind && typeof n.$bind === "object") {
     const bindErrors = validateBinding(
       n.$bind,
-      `${path32}.$bind`,
+      `${path33}.$bind`,
       ctx
     );
     errors.push(...bindErrors);
@@ -73351,7 +73440,7 @@ function validateLayoutNode(node, path32, ctx) {
   if ("props" in n && n.props && typeof n.props === "object") {
     const propsErrors = validatePropsBindings(
       n.props,
-      `${path32}.props`,
+      `${path33}.props`,
       ctx
     );
     errors.push(...propsErrors);
@@ -73360,7 +73449,7 @@ function validateLayoutNode(node, path32, ctx) {
     for (let i = 0; i < n.children.length; i++) {
       const childErrors = validateLayoutNode(
         n.children[i],
-        `${path32}.children[${i}]`,
+        `${path33}.children[${i}]`,
         ctx
       );
       errors.push(...childErrors);
@@ -73368,17 +73457,17 @@ function validateLayoutNode(node, path32, ctx) {
   }
   return errors;
 }
-function validatePropsBindings(props2, path32, ctx) {
+function validatePropsBindings(props2, path33, 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, `${path32}.${key}.$bind`, ctx);
+      const bindErrors = validateBinding(bind2, `${path33}.${key}.$bind`, ctx);
       errors.push(...bindErrors);
     } else if (value && typeof value === "object" && !Array.isArray(value)) {
       const nestedErrors = validatePropsBindings(
         value,
-        `${path32}.${key}`,
+        `${path33}.${key}`,
         ctx
       );
       errors.push(...nestedErrors);
@@ -73511,7 +73600,7 @@ function collectUsedFieldRefs(node) {
   visit(node, []);
   return { topLevel, nestedByRepeater, itemNameByRepeater };
 }
-function findMissingBindings(node, blockId, path32 = "layout") {
+function findMissingBindings(node, blockId, path33 = "layout") {
   const errors = [];
   if (!node || typeof node !== "object") {
     return errors;
@@ -73521,15 +73610,15 @@ function findMissingBindings(node, blockId, path32 = "layout") {
   if ("$repeat" in n && n.$repeat && typeof n.$repeat === "object") {
     if (nodeType && CONTENT_NODE_TYPES.includes(nodeType)) {
       errors.push({
-        path: path32,
-        message: `Block "${blockId}": ${nodeType} node at ${path32} uses $repeat, but content nodes cannot be repeat containers`,
+        path: path33,
+        message: `Block "${blockId}": ${nodeType} node at ${path33} 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: path32,
-        message: `Block "${blockId}": node at ${path32} uses $repeat but has no children to repeat`,
+        path: path33,
+        message: `Block "${blockId}": node at ${path33} 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").'
       });
     }
@@ -73538,15 +73627,15 @@ function findMissingBindings(node, blockId, path32 = "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: path32,
-        message: `Block "${blockId}": ${nodeType} node at ${path32} has children, but content nodes must have children: null`,
+        path: path33,
+        message: `Block "${blockId}": ${nodeType} node at ${path33} 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: `${path32}`,
-        message: `Block "${blockId}": ${nodeType} node at ${path32} has no $bind - it won't display any content`,
+        path: `${path33}`,
+        message: `Block "${blockId}": ${nodeType} node at ${path33} 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" } }`
       });
     }
@@ -73556,7 +73645,7 @@ function findMissingBindings(node, blockId, path32 = "layout") {
       const childErrors = findMissingBindings(
         n.children[i],
         blockId,
-        `${path32}.children[${i}]`
+        `${path33}.children[${i}]`
       );
       errors.push(...childErrors);
     }
@@ -73573,13 +73662,13 @@ function getMaxDepth(node, currentDepth = 0) {
   );
 }
 var CONTAINER_NODE_TYPES = ["section", "stack", "grid", "div", "inline"];
-function detectPotentialTruncation(node, maxAllowedDepth, currentDepth = 0, path32 = "layout") {
+function detectPotentialTruncation(node, maxAllowedDepth, currentDepth = 0, path33 = "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(`${path32} (${n.type ?? "node"} at depth ${currentDepth})`);
+      truncatedPaths.push(`${path33} (${n.type ?? "node"} at depth ${currentDepth})`);
     }
   }
   if (n.children && Array.isArray(n.children)) {
@@ -73589,7 +73678,7 @@ function detectPotentialTruncation(node, maxAllowedDepth, currentDepth = 0, path
           child,
           maxAllowedDepth,
           currentDepth + 1,
-          `${path32}.children[${i}]`
+          `${path33}.children[${i}]`
         )
       );
     });
@@ -73609,8 +73698,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 path32 of truncatedPaths) {
-        lines.push(`  \u26A0\uFE0F ${path32}`);
+      for (const path33 of truncatedPaths) {
+        lines.push(`  \u26A0\uFE0F ${path33}`);
       }
       lines.push("");
       lines.push(
@@ -74073,11 +74162,11 @@ var pass3bOutputSchema = z.object({
   customCssAtRules: z.array(llmMediaAtRuleSchema).nullable(),
   rationale: z.string()
 });
-function getNodeAtPath(layout, path32) {
-  if (path32 === "" || path32 === "root" || path32 === "layout") {
+function getNodeAtPath(layout, path33) {
+  if (path33 === "" || path33 === "root" || path33 === "layout") {
     return layout;
   }
-  let normalizedPath = path32;
+  let normalizedPath = path33;
   if (normalizedPath.startsWith("layout.")) {
     normalizedPath = normalizedPath.slice(7);
   }
@@ -75477,7 +75566,7 @@ The generated manifest can be added to your riverbank.config.ts customBlocks arr
   const { output } = getOutputContext(command);
   try {
     output.info("Reading input files...");
-    const htmlPath = path20.resolve(options.html);
+    const htmlPath = path21.resolve(options.html);
     let html;
     try {
       html = await fs2.readFile(htmlPath, "utf-8");
@@ -75486,7 +75575,7 @@ The generated manifest can be added to your riverbank.config.ts customBlocks arr
         suggestion: "Check that the file exists and is readable"
       });
     }
-    const themePath = path20.resolve(options.theme);
+    const themePath = path21.resolve(options.theme);
     let themeData;
     try {
       const themeJson = await fs2.readFile(themePath, "utf-8");
@@ -75511,7 +75600,7 @@ The generated manifest can be added to your riverbank.config.ts customBlocks arr
     }
     let css;
     if (options.css) {
-      const cssPath = path20.resolve(options.css);
+      const cssPath = path21.resolve(options.css);
       try {
         css = await fs2.readFile(cssPath, "utf-8");
       } catch {
@@ -75526,7 +75615,7 @@ The generated manifest can be added to your riverbank.config.ts customBlocks arr
       return output.error("--retries must be a number between 1 and 10");
     }
     const expectedBlockCount = options.blocks;
-    const debugDir = options.debug ? path20.resolve(options.debug) : void 0;
+    const debugDir = options.debug ? path21.resolve(options.debug) : void 0;
     let ai;
     try {
       ai = await loadAiRuntime(options.aiRuntime);
@@ -75569,7 +75658,7 @@ The generated manifest can be added to your riverbank.config.ts customBlocks arr
     }
     const jsonOutput = JSON.stringify(result.output, null, 2);
     if (options.output) {
-      const outputPath = path20.resolve(options.output);
+      const outputPath = path21.resolve(options.output);
       await fs2.writeFile(outputPath, jsonOutput, "utf-8");
       output.success(`Manifest written to ${outputPath}`);
       output.info(`Generated ${result.output.blocks.length} block(s)`);
@@ -75595,7 +75684,7 @@ The generated manifest can be added to your riverbank.config.ts customBlocks arr
 var validateCommand = new Command("validate").description("Validate a manifest JSON file").requiredOption("--file <file>", "Manifest JSON file to validate").action(async (options, command) => {
   const { output } = getOutputContext(command);
   try {
-    const filePath = path20.resolve(options.file);
+    const filePath = path21.resolve(options.file);
     let data;
     try {
       const json = await fs2.readFile(filePath, "utf-8");
@@ -76116,13 +76205,13 @@ function migrateLegacyEntryTitleInPlace(entry) {
   return { updated: true, migratedToDataTitle };
 }
 async function backupLegacyFile(contentDir, legacyFilePath, dryRun) {
-  const backupDir = path20.join(contentDir, ".legacy", "entries");
-  const destPath = path20.join(backupDir, path20.basename(legacyFilePath));
+  const backupDir = path21.join(contentDir, ".legacy", "entries");
+  const destPath = path21.join(backupDir, path21.basename(legacyFilePath));
   if (dryRun) return false;
   await ensureDir(backupDir);
   if (await fileExists(destPath)) {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const ext = path20.extname(destPath);
+    const ext = path21.extname(destPath);
     const base = destPath.slice(0, -ext.length);
     await fs2.rename(legacyFilePath, `${base}.${timestamp}${ext}`);
     return true;
@@ -76145,7 +76234,7 @@ async function migrateLegacyEntriesFile(contentDir, legacyFilePath, options) {
   if (options.contentType && options.contentType !== contentType) {
     return { entriesWritten: 0, backedUp: false, legacyTitlesMigrated: 0, legacyTitleFilesUpdated: 0 };
   }
-  const typeDir = path20.join(contentDir, "entries", contentType);
+  const typeDir = path21.join(contentDir, "entries", contentType);
   if (!options.dryRun) {
     await ensureDir(typeDir);
   }
@@ -76166,7 +76255,7 @@ async function migrateLegacyEntriesFile(contentDir, legacyFilePath, options) {
     const { updated, migratedToDataTitle } = migrateLegacyEntryTitleInPlace(entryUnknown);
     if (updated) legacyTitleFilesUpdated += 1;
     if (migratedToDataTitle) legacyTitlesMigrated += 1;
-    const entryPath = path20.join(typeDir, `${identifier}.json`);
+    const entryPath = path21.join(typeDir, `${identifier}.json`);
     if (await fileExists(entryPath)) {
       if (!options.force) {
         const existing = await readJsonFile(entryPath);
@@ -76207,9 +76296,9 @@ async function migrateLegacyTitlesInDirectory(typeDir, options) {
   return { scanned, updatedFiles, titlesMigrated };
 }
 async function migrateEntries(options) {
-  const entriesDir = path20.join(options.contentDir, "entries");
+  const entriesDir = path21.join(options.contentDir, "entries");
   const legacyFiles = await findLegacyEntryFiles(options.contentDir);
-  const filteredLegacyFiles = options.contentType ? legacyFiles.filter((f) => path20.basename(f, ".json") === options.contentType) : legacyFiles;
+  const filteredLegacyFiles = options.contentType ? legacyFiles.filter((f) => path21.basename(f, ".json") === options.contentType) : legacyFiles;
   let legacyFilesMigrated = 0;
   let legacyFilesBackedUp = 0;
   let entriesWritten = 0;
@@ -76233,7 +76322,7 @@ async function migrateEntries(options) {
     for (const item of items) {
       if (!item.isDirectory()) continue;
       if (options.contentType && item.name !== options.contentType) continue;
-      const typeDir = path20.join(entriesDir, item.name);
+      const typeDir = path21.join(entriesDir, item.name);
       const res = await migrateLegacyTitlesInDirectory(typeDir, { dryRun: options.dryRun });
       entryFilesScanned += res.scanned;
       legacyTitleFilesUpdated += res.updatedFiles;
@@ -76309,7 +76398,7 @@ function legacySlugCandidates(legacy) {
   return [...candidates];
 }
 async function readLegacyEventEntries(contentDir) {
-  const legacyDir = path20.join(contentDir, "entries", CANONICAL_EVENT_ENTRY_TYPE);
+  const legacyDir = path21.join(contentDir, "entries", CANONICAL_EVENT_ENTRY_TYPE);
   const files = await listFiles(legacyDir, ".json");
   files.sort();
   const entries = [];
@@ -76331,12 +76420,12 @@ async function readLegacyEventEntries(contentDir) {
       });
       continue;
     }
-    const identifier = typeof raw.identifier === "string" && raw.identifier.trim() ? raw.identifier : path20.basename(filePath, ".json");
+    const identifier = typeof raw.identifier === "string" && raw.identifier.trim() ? raw.identifier : path21.basename(filePath, ".json");
     entries.push({
       tag: "valid",
       legacy: {
         filePath,
-        fileBaseIdentifier: path20.basename(filePath, ".json"),
+        fileBaseIdentifier: path21.basename(filePath, ".json"),
         entry: { ...raw, identifier, data: raw.data }
       }
     });
@@ -76344,7 +76433,7 @@ async function readLegacyEventEntries(contentDir) {
   return entries;
 }
 async function readCanonicalEventsWithPaths(contentDir) {
-  const eventsDir = path20.join(contentDir, "events");
+  const eventsDir = path21.join(contentDir, "events");
   const files = await listFiles(eventsDir, ".json");
   files.sort();
   const events = [];
@@ -76621,7 +76710,7 @@ async function planEventMigration(contentDir) {
       });
       continue;
     }
-    const eventFilePath = eventFilePaths.get(event.identifier) ?? path20.join(contentDir, "events", `${event.identifier}.json`);
+    const eventFilePath = eventFilePaths.get(event.identifier) ?? path21.join(contentDir, "events", `${event.identifier}.json`);
     if (mergePlan.fields.length === 0) {
       items.push({
         tag: "archiveLegacyOnly",
@@ -76654,15 +76743,15 @@ function isBlockedPlanItem(item) {
   return !isWritablePlanItem(item);
 }
 async function archiveLegacyFile(contentDir, legacyFilePath) {
-  const archiveDir = path20.join(contentDir, ".legacy", "entries", CANONICAL_EVENT_ENTRY_TYPE);
+  const archiveDir = path21.join(contentDir, ".legacy", "entries", CANONICAL_EVENT_ENTRY_TYPE);
   await ensureDir(archiveDir);
-  const destinationPath = path20.join(archiveDir, path20.basename(legacyFilePath));
+  const destinationPath = path21.join(archiveDir, path21.basename(legacyFilePath));
   if (!await fileExists(destinationPath)) {
     await fs2.rename(legacyFilePath, destinationPath);
     return;
   }
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const ext = path20.extname(destinationPath);
+  const ext = path21.extname(destinationPath);
   const base = destinationPath.slice(0, -ext.length);
   await fs2.rename(legacyFilePath, `${base}.${timestamp}${ext}`);
 }
@@ -76735,49 +76824,49 @@ function formatEventMigrationItem(item) {
     case "mergeLegacyIntoEvent":
       return [
         "merge",
-        path20.basename(item.legacyFilePath),
+        path21.basename(item.legacyFilePath),
         item.eventIdentifier,
         item.mergedFields.join(", ")
       ];
     case "archiveLegacyOnly":
       return [
         "archive",
-        path20.basename(item.legacyFilePath),
+        path21.basename(item.legacyFilePath),
         item.eventIdentifier,
         item.reason
       ];
     case "conflict":
       return [
         "conflict",
-        path20.basename(item.legacyFilePath),
+        path21.basename(item.legacyFilePath),
         item.eventIdentifier,
         item.conflicts.join(", ")
       ];
     case "ambiguousMatch":
       return [
         "ambiguous",
-        path20.basename(item.legacyFilePath),
+        path21.basename(item.legacyFilePath),
         item.candidateEventIdentifiers.join(", "),
         "Multiple canonical events matched this legacy entry."
       ];
     case "unmappableLegacyFields":
       return [
         "unmappable",
-        path20.basename(item.legacyFilePath),
+        path21.basename(item.legacyFilePath),
         item.eventIdentifier ?? "",
         item.fields.join(", ")
       ];
     case "orphanedLegacy":
       return [
         "orphaned",
-        path20.basename(item.legacyFilePath),
+        path21.basename(item.legacyFilePath),
         item.legacyIdentifier,
         item.reason
       ];
     case "invalidLegacyShape":
       return [
         "invalid",
-        path20.basename(item.legacyFilePath),
+        path21.basename(item.legacyFilePath),
         "",
         item.reason
       ];
@@ -76812,7 +76901,7 @@ Examples:
     }
     try {
       const cliConfig = await loadCliConfig();
-      const contentDir = path20.resolve(options.contentDir ?? cliConfig.contentDir);
+      const contentDir = path21.resolve(options.contentDir ?? cliConfig.contentDir);
       if (type === "event") {
         process.exitCode = 1;
         output.result(false, "`event` entries use the canonical events migration.", {
@@ -76883,7 +76972,7 @@ Examples:
     }
     try {
       const cliConfig = await loadCliConfig();
-      const contentDir = path20.resolve(options.contentDir ?? cliConfig.contentDir);
+      const contentDir = path21.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 },
@@ -77150,7 +77239,7 @@ function planHumanResultOutput(input) {
     details.push(`Endpoint: ${result.plannedEndpoint.name} (${result.plannedEndpoint.url})`);
   }
   if (envWrite) {
-    details.push(`Env: ${envPatchLabel(envWrite.plan.tag)} at ${path20.relative(process.cwd(), envWrite.path)}`);
+    details.push(`Env: ${envPatchLabel(envWrite.plan.tag)} at ${path21.relative(process.cwd(), envWrite.path)}`);
   } else if (hasSecret(result) && writeEnv) {
     details.push("Env: no local env file changes were made");
   }
@@ -77193,7 +77282,7 @@ Examples:
       dryRun: options.dryRun,
       vercel: options.vercel
     });
-    const envPath = path20.resolve(process.cwd(), ".env.local");
+    const envPath = path21.resolve(process.cwd(), ".env.local");
     const envWrite = hasSecret(result) && writeEnv && !result.dryRun ? await writeEnvSecret(envPath, result.secret) : null;
     if (ctx.isJsonOutput) {
       ctx.output.json({
@@ -77274,8 +77363,8 @@ function parseContentFieldPath(value) {
   }
   return { ok: true, path: segments };
 }
-function formatContentFieldPath(path32) {
-  return formatFieldPath2(path32);
+function formatContentFieldPath(path33) {
+  return formatFieldPath2(path33);
 }
 function planPageContentEdit(page, operation) {
   if (page.identifier !== operation.pageIdentifier) {
@@ -77339,8 +77428,8 @@ function changedPlan(operation, before, after) {
     before,
     after,
     changes: buildFieldChanges(pageDiffRecord(after), pageDiffRecord(before), {
-      identifyArrayItem: ({ path: path32, item }) => {
-        const last = path32[path32.length - 1];
+      identifyArrayItem: ({ path: path33, item }) => {
+        const last = path33[path33.length - 1];
         if (last?.type !== "property" || last.key !== "blocks") return null;
         return blockIdentifier(item);
       }
@@ -77394,15 +77483,15 @@ function normalizeBlockPositions(blocks) {
     block.position = index;
   });
 }
-function setFieldPath(target, path32, value) {
+function setFieldPath(target, path33, value) {
   let current = target;
-  for (let index = 0; index < path32.length; index++) {
-    const segment = path32[index];
-    const isLast = index === path32.length - 1;
+  for (let index = 0; index < path33.length; index++) {
+    const segment = path33[index];
+    const isLast = index === path33.length - 1;
     if (!segment) return { ok: false, error: "Invalid empty path segment." };
     if (segment.type === "property") {
       if (!isRecord28(current)) {
-        return { ok: false, error: `Cannot set ${formatContentFieldPath(path32)} because ${segment.key} is not inside an object.` };
+        return { ok: false, error: `Cannot set ${formatContentFieldPath(path33)} because ${segment.key} is not inside an object.` };
       }
       if (isLast) {
         current[segment.key] = value;
@@ -77552,12 +77641,12 @@ function renderEditPlan(output, plan, options) {
   }
 }
 async function resolveContentDir(contentDir) {
-  if (contentDir) return path20.resolve(contentDir);
+  if (contentDir) return path21.resolve(contentDir);
   const cliConfig = await loadCliConfig();
-  return path20.resolve(cliConfig.contentDir);
+  return path21.resolve(cliConfig.contentDir);
 }
 function pageFilePath(contentDir, pageIdentifier) {
-  return path20.join(contentDir, "pages", `${pageIdentifier}.json`);
+  return path21.join(contentDir, "pages", `${pageIdentifier}.json`);
 }
 function createCommandOutput(command) {
   return createOutput(command.optsWithGlobals());