@riverbankcms/sdk 0.70.2 → 0.70.4

package/dist/cli/index.mjs

@@ -916,6 +916,9 @@ var init_repeaterGrid = __esm({
     DEFAULT_REPEATER_GRID_COLUMN_FIELD_ID = "gridColumn";
   }
 });
+function isDisplayMediaKind(kind) {
+  return DISPLAY_MEDIA_KINDS.includes(kind);
+}
 function assertNeverSelectSource(value) {
   throw new Error(`Unhandled select source: ${JSON.stringify(value)}`);
 }
@@ -927,6 +930,7 @@ function getFieldSchemaInternal() {
     textFieldSchema,
     richTextFieldSchema,
     mediaFieldSchema,
+    fileFieldSchema,
     booleanFieldSchema,
     numberFieldSchema,
     dateFieldSchema,
@@ -993,13 +997,32 @@ function createSdkSelectField(input) {
     })
   );
 }
-var visibilityLevels, siteOptionSources, mediaDeliverySchema, selectOptionSchema, selectSourceSchema, uiSchema, baseFieldSchema, textFieldSchema, richTextFieldSchema, mediaFieldSchema, booleanFieldSchema, dateFieldSchema, timeFieldSchema, dateTimeFieldSchema, slugFieldSchema, urlFieldSchema, linkFieldSchema, selectFieldSchema, referenceFieldSchema, itemTypeSchema, repeaterFieldSchema, groupFieldSchema, modalFieldSchema, numberFieldSchema, tabDefinitionSchema, tabGroupFieldSchema, presetOptionSchema, presetOrCustomFieldSchema, contentTypeSelectFieldSchema, entryPickerFieldSchema, _fieldSchemaInternal, fieldSchema, slotSchema, typographyTokens, colorTokens, spacingTokens, radiusTokens, styleTokenSchema, behaviourSchema, blockCategoryEnum;
+var visibilityLevels, MEDIA_KINDS, DISPLAY_MEDIA_KINDS, PUBLIC_FILE_FIELD_KINDS, siteOptionSources, mediaDeliverySchema, selectOptionSchema, selectSourceSchema, uiSchema, baseFieldSchema, textFieldSchema, richTextFieldSchema, mediaFieldSchema, fileFieldSchema, booleanFieldSchema, dateFieldSchema, timeFieldSchema, dateTimeFieldSchema, slugFieldSchema, urlFieldSchema, linkFieldSchema, selectFieldSchema, referenceFieldSchema, itemTypeSchema, repeaterFieldSchema, groupFieldSchema, modalFieldSchema, numberFieldSchema, tabDefinitionSchema, tabGroupFieldSchema, presetOptionSchema, presetOrCustomFieldSchema, contentTypeSelectFieldSchema, entryPickerFieldSchema, _fieldSchemaInternal, fieldSchema, slotSchema, typographyTokens, colorTokens, spacingTokens, radiusTokens, styleTokenSchema, behaviourSchema, blockCategoryEnum;
 var init_schema2 = __esm({
   "../blocks/src/system/manifest/schema.ts"() {
     init_src2();
     init_node();
     init_repeaterGrid();
     visibilityLevels = ["admin", "designer", "author"];
+    MEDIA_KINDS = [
+      "image",
+      "video",
+      "audio",
+      "document",
+      "spreadsheet",
+      "archive"
+    ];
+    DISPLAY_MEDIA_KINDS = [
+      "image",
+      "video",
+      "audio"
+    ];
+    PUBLIC_FILE_FIELD_KINDS = [
+      "document",
+      "spreadsheet",
+      "archive",
+      "audio"
+    ];
     siteOptionSources = [
       "eventCategories",
       "venues",
@@ -1160,11 +1183,19 @@ var init_schema2 = __esm({
     });
     mediaFieldSchema = baseFieldSchema.extend({
       type: z.literal("media"),
-      mediaKinds: z.array(
-        z.enum(["image", "video", "audio", "document", "spreadsheet", "archive"])
-      ).default(["image"]),
+      // Keep full MEDIA_KINDS parse compatibility for pre-file-field manifests.
+      // New authoring surfaces should use `file.fileKinds` for document/archive
+      // style assets, but old saved schemas must not fail to open.
+      mediaKinds: z.array(z.enum(MEDIA_KINDS)).default(["image"]).transform((kinds) => {
+        const displayKinds = kinds.filter(isDisplayMediaKind);
+        return displayKinds.length > 0 ? displayKinds : ["image"];
+      }),
       aspectRatio: z.string().optional()
     });
+    fileFieldSchema = baseFieldSchema.extend({
+      type: z.literal("file"),
+      fileKinds: z.array(z.enum(PUBLIC_FILE_FIELD_KINDS)).default([...PUBLIC_FILE_FIELD_KINDS])
+    });
     booleanFieldSchema = baseFieldSchema.extend({
       type: z.literal("boolean")
     });
@@ -3402,7 +3433,10 @@ var init_soft_pill = __esm({
 });
 
 // ../theme-core/src/buttons/personalities/index.ts
-var buttonPersonalities;
+function findButtonPersonality(id) {
+  return personalitiesById.get(id);
+}
+var buttonPersonalities, personalitiesById;
 var init_personalities = __esm({
   "../theme-core/src/buttons/personalities/index.ts"() {
     init_brushed_wash();
@@ -3422,7 +3456,7 @@ var init_personalities = __esm({
       brushedWash,
       showtimePill
     ];
-    new Map(
+    personalitiesById = new Map(
       buttonPersonalities.map((p) => [p.id, p])
     );
   }
@@ -5115,7 +5149,10 @@ var init_warm_neutral = __esm({
 });
 
 // ../theme-core/src/palette/variants/index.ts
-var paletteVariants;
+function findPaletteVariant(id) {
+  return paletteVariantsById.get(id);
+}
+var paletteVariants, paletteVariantsById;
 var init_variants = __esm({
   "../theme-core/src/palette/variants/index.ts"() {
     init_brand_led();
@@ -5142,7 +5179,7 @@ var init_variants = __esm({
       softNaturalStone,
       softNaturalWatercolor
     ];
-    new Map(
+    paletteVariantsById = new Map(
       paletteVariants.map((v) => [v.id, v])
     );
   }
@@ -5407,7 +5444,10 @@ function floatingGlassHeader(theme) {
     }
   };
 }
-var headerLookCatalog;
+function findHeaderLook(id) {
+  return headerLooksById.get(id);
+}
+var headerLookCatalog, headerLooksById;
 var init_headerLooks = __esm({
   "../theme-core/src/site-styles/headerLooks.ts"() {
     init_headerCtaVariants();
@@ -5487,7 +5527,7 @@ var init_headerLooks = __esm({
         compile: floatingGlassHeader
       }
     ];
-    new Map(
+    headerLooksById = new Map(
       headerLookCatalog.map((look) => [look.id, look])
     );
   }
@@ -5556,7 +5596,10 @@ function brandTwoBandFooter(theme) {
     }
   };
 }
-var footerLookCatalog;
+function findFooterLook(id) {
+  return footerLooksById.get(id);
+}
+var footerLookCatalog, footerLooksById;
 var init_footerLooks = __esm({
   "../theme-core/src/site-styles/footerLooks.ts"() {
     init_customizableSurfaces();
@@ -5575,7 +5618,7 @@ var init_footerLooks = __esm({
         compile: brandTwoBandFooter
       }
     ];
-    new Map(
+    footerLooksById = new Map(
       footerLookCatalog.map((look) => [look.id, look])
     );
   }
@@ -9257,13 +9300,19 @@ function defineFragment(config2) {
 function scopeFragmentFields(fragment, scope) {
   const normalizedScope = scope.trim();
   if (!normalizedScope) {
-    return fragment.fields.map((field) => cloneFieldDefinition2(field));
+    return fragment.fields.map(
+      (field) => cloneFieldDefinition2(field)
+    );
   }
-  return fragment.fields.map((field) => prefixFieldId(field, normalizedScope));
+  return fragment.fields.map(
+    (field) => prefixFieldId(field, normalizedScope)
+  );
 }
 function scopeFragmentLayout(fragment, scope) {
   const normalizedScope = scope.trim();
-  return fragment.layout.map((node) => cloneAndScopeNode(node, normalizedScope));
+  return fragment.layout.map(
+    (node) => cloneAndScopeNode(node, normalizedScope)
+  );
 }
 function validateFieldDefinitions(fields3, fragmentId) {
   const seen = /* @__PURE__ */ new Set();
@@ -9345,7 +9394,9 @@ function cloneAndScopeNode(node, scope) {
     ...node
   };
   if (node.children) {
-    cloned.children = node.children.map((child) => cloneAndScopeNode(child, scope));
+    cloned.children = node.children.map(
+      (child) => cloneAndScopeNode(child, scope)
+    );
   }
   if (node.props) {
     cloned.props = scopePropBindings(node.props, scope);
@@ -9371,7 +9422,9 @@ function scopeBinding(binding, scope) {
   const cloned = {
     ...binding,
     transforms: binding.transforms?.map(
-      (step) => ({ ...step })
+      (step) => ({
+        ...step
+      })
     ) ?? []
   };
   cloned.from = scopeContentPath(binding.from, scope);
@@ -9415,7 +9468,9 @@ function scopePropValue(value, scope) {
       };
     }
     const result = {};
-    for (const [key, entry] of Object.entries(value)) {
+    for (const [key, entry] of Object.entries(
+      value
+    )) {
       result[key] = scopePropValue(entry, scope);
     }
     return result;
@@ -9461,13 +9516,18 @@ var init_types13 = __esm({
       loader: dataLoaderSchema.optional()
     });
     fragmentConfigSchema = z.object({
-      id: z.string().min(1, "Fragment id is required").regex(FRAGMENT_ID_PATTERN, "Fragment id must be alphanumeric with optional . _ - separators"),
+      id: z.string().min(1, "Fragment id is required").regex(
+        FRAGMENT_ID_PATTERN,
+        "Fragment id must be alphanumeric with optional . _ - separators"
+      ),
       title: z.string().optional(),
       description: z.string().optional(),
       category: z.enum(["content", "media", "interactive", "layout"]).optional(),
       icon: z.string().optional(),
       fields: fieldSchema.array().default([]),
-      layout: z.union([NodeSchema, NodeSchema.array()]).transform((value) => Array.isArray(value) ? value : [value]),
+      layout: z.union([NodeSchema, NodeSchema.array()]).transform(
+        (value) => Array.isArray(value) ? value : [value]
+      ),
       data: fragmentDataSchema.optional()
     });
     FragmentConfigError = class extends Error {
@@ -9937,34 +9997,35 @@ var init_ctaRow2 = __esm({
 });
 
 // ../blocks/src/system/fragments/library/heroCtaRow.ts
-var heroCtaRowFragment;
+var heroCtaFields, heroCtaRowFragment;
 var init_heroCtaRow = __esm({
   "../blocks/src/system/fragments/library/heroCtaRow.ts"() {
     init_types13();
     init_fragments();
     init_ctas();
+    heroCtaFields = [
+      createCtasRepeater({
+        label: "Calls to action",
+        itemLabel: "CTA",
+        maxItems: 3,
+        button: {
+          variants: [
+            { value: "default", label: "Default" },
+            { value: "primary", label: "Primary" },
+            { value: "secondary", label: "Secondary" },
+            { value: "outline", label: "Outline" }
+          ],
+          defaultVariant: "default",
+          includeSize: true,
+          defaultSize: "lg"
+        }
+      })
+    ];
     heroCtaRowFragment = defineFragment({
       id: "heroCtaRow",
       title: "Hero CTAs",
       description: "Repeatable hero calls to action rendered inline.",
-      fields: [
-        createCtasRepeater({
-          label: "Calls to action",
-          itemLabel: "CTA",
-          maxItems: 3,
-          button: {
-            variants: [
-              { value: "default", label: "Default" },
-              { value: "primary", label: "Primary" },
-              { value: "secondary", label: "Secondary" },
-              { value: "outline", label: "Outline" }
-            ],
-            defaultVariant: "default",
-            includeSize: true,
-            defaultSize: "lg"
-          }
-        })
-      ],
+      fields: heroCtaFields,
       layout: [
         ctaRow({
           collectionPath: "content.ctas",
@@ -12557,8 +12618,7 @@ var init_media2 = __esm({
       "document",
       "spreadsheet",
       "archive",
-      "audio",
-      "video"
+      "audio"
     ];
     hotspotSchema2 = z41.object({
       x: z41.number().min(0).max(1),
@@ -24611,6 +24671,7 @@ function deriveFieldValidationPlan(field, path24 = [field.id]) {
     case "richText":
       return makePlan("richText", "object", field, path24, required, commonConstraints(required, { kind: "richTextDoc" }));
     case "media":
+    case "file":
       return makePlan("media", "object", field, path24, required, commonConstraints(required, { kind: "mediaObject" }));
     case "link":
       return makePlan("link", "object", field, path24, required, commonConstraints(required, { kind: "linkObject" }));
@@ -29307,104 +29368,107 @@ init_fragments();
 init_boxStyles();
 init_defineBlock();
 init_shared3();
-var eventSpotlightManifest = createBlockManifest({
+var eventSpotlightFields = [
+  ...sectionHeaderFields("Upcoming Events"),
+  {
+    id: "maxEvents",
+    type: "select",
+    label: "Events to display",
+    description: "Number of events to show",
+    required: false,
+    multiple: false,
+    defaultValue: "3",
+    options: [
+      { value: "1", label: "1 event" },
+      { value: "2", label: "2 events" },
+      { value: "3", label: "3 events" },
+      { value: "4", label: "4 events" },
+      { value: "5", label: "5 events" },
+      { value: "6", label: "6 events" }
+    ],
+    ui: { intent: "display" }
+  },
+  {
+    id: "ctaLabel",
+    type: "text",
+    label: "Section button text",
+    description: "Optional button shown below the spotlight cards",
+    required: false,
+    multiline: false,
+    maxLength: 40,
+    ui: { intent: "content" }
+  },
+  {
+    id: "ctaUrl",
+    type: "link",
+    label: "Section button destination",
+    required: false,
+    ui: { intent: "display" }
+  },
+  layoutField,
+  columnsField(["2", "3"]),
+  ...cardStylingFields,
+  ...eventDisplayFields,
+  emptyStateField,
+  sectionStylesField({
+    id: "_sectionStyles",
+    label: "Section styles"
+  })
+];
+var eventSpotlightLayout = [
+  styledSection({
+    children: sectionContainer([
+      // Optional heading
+      text(
+        { as: "h2" },
+        bind("content.heading"),
+        when("content.heading")
+      ),
+      // Optional description
+      richText(
+        { className: "rb-prose rb-max-w-none" },
+        bind("content.description"),
+        when("content.description")
+      ),
+      // Event spotlight component
+      el("event-spotlight", {
+        events: { $bind: { from: "data.events" } },
+        layout: { $bind: { from: "content.layout", fallback: "grid" } },
+        columns: { $bind: { from: "content.columns", fallback: "3" } },
+        cardVariant: { $bind: { from: "content.cardVariant", fallback: "default" } },
+        buttonVariant: { $bind: { from: "content.buttonVariant", fallback: "primary" } },
+        buttonText: { $bind: { from: "content.buttonText", fallback: "View event" } },
+        ctaLabel: { $bind: { from: "content.ctaLabel" } },
+        ctaUrl: { $bind: { from: "content.ctaUrl", transforms: [{ id: "links.resolve" }] } },
+        showVenue: { $bind: { from: "content.showVenue" } },
+        showMap: { $bind: { from: "content.showMap" } },
+        showCapacity: { $bind: { from: "content.showCapacity" } },
+        emptyMessage: { $bind: { from: "content.emptyMessage" } }
+      })
+    ], {
+      gap: "lg"
+    }),
+    // sectionContainer (rb-container) already provides horizontal padding
+    baseClass: "",
+    spacing: "comfortable"
+  })
+];
+var eventSpotlightConfig = {
   id: "block.event-spotlight",
   version: "1.1.0",
   title: "Event Spotlight",
   titleSource: "heading",
   description: "Feature a few upcoming events on your homepage",
   skipSectionStyles: true,
-  additionalFields: [
-    ...sectionHeaderFields("Upcoming Events"),
-    {
-      id: "maxEvents",
-      type: "select",
-      label: "Events to display",
-      description: "Number of events to show",
-      required: false,
-      multiple: false,
-      defaultValue: "3",
-      options: [
-        { value: "1", label: "1 event" },
-        { value: "2", label: "2 events" },
-        { value: "3", label: "3 events" },
-        { value: "4", label: "4 events" },
-        { value: "5", label: "5 events" },
-        { value: "6", label: "6 events" }
-      ],
-      ui: { intent: "display" }
-    },
-    {
-      id: "ctaLabel",
-      type: "text",
-      label: "Section button text",
-      description: "Optional button shown below the spotlight cards",
-      required: false,
-      multiline: false,
-      maxLength: 40,
-      ui: { intent: "content" }
-    },
-    {
-      id: "ctaUrl",
-      type: "link",
-      label: "Section button destination",
-      required: false,
-      ui: { intent: "display" }
-    },
-    layoutField,
-    columnsField(["2", "3"]),
-    ...cardStylingFields,
-    ...eventDisplayFields,
-    emptyStateField,
-    sectionStylesField({
-      id: "_sectionStyles",
-      label: "Section styles"
-    })
-  ],
+  additionalFields: eventSpotlightFields,
   styleTokens: { background: "surface", typography: "body", spacing: "md" },
   behaviours: { supportsThemeSwitching: true, inlineEditing: false, animation: false, paletteHidden: false },
   category: "content",
   tags: ["events", "featured", "homepage", "spotlight", "upcoming"],
   icon: "Star",
-  layout: [
-    styledSection({
-      children: sectionContainer([
-        // Optional heading
-        text(
-          { as: "h2" },
-          bind("content.heading"),
-          when("content.heading")
-        ),
-        // Optional description
-        richText(
-          { className: "rb-prose rb-max-w-none" },
-          bind("content.description"),
-          when("content.description")
-        ),
-        // Event spotlight component
-        el("event-spotlight", {
-          events: { $bind: { from: "data.events" } },
-          layout: { $bind: { from: "content.layout", fallback: "grid" } },
-          columns: { $bind: { from: "content.columns", fallback: "3" } },
-          cardVariant: { $bind: { from: "content.cardVariant", fallback: "default" } },
-          buttonVariant: { $bind: { from: "content.buttonVariant", fallback: "primary" } },
-          buttonText: { $bind: { from: "content.buttonText", fallback: "View event" } },
-          ctaLabel: { $bind: { from: "content.ctaLabel" } },
-          ctaUrl: { $bind: { from: "content.ctaUrl", transforms: [{ id: "links.resolve" }] } },
-          showVenue: { $bind: { from: "content.showVenue" } },
-          showMap: { $bind: { from: "content.showMap" } },
-          showCapacity: { $bind: { from: "content.showCapacity" } },
-          emptyMessage: { $bind: { from: "content.emptyMessage" } }
-        })
-      ], {
-        gap: "lg"
-      }),
-      // sectionContainer (rb-container) already provides horizontal padding
-      baseClass: "",
-      spacing: "comfortable"
-    })
-  ]
-});
+  layout: eventSpotlightLayout
+};
+var eventSpotlightManifest = createBlockManifest(eventSpotlightConfig);
 var eventSpotlightBlockDefinition = {
   manifest: eventSpotlightManifest,
   dataSchemas: {
@@ -30818,18 +30882,18 @@ var fileDownloadManifest = createBlockManifest({
   title: "File Download",
   titleSource: ["title", "file.filename"],
   category: "media",
-  description: "Add a simple public download link for a document, ZIP, audio, or video file.",
+  description: "Add a simple public download link for a document, ZIP, or audio file.",
   tags: ["file", "download", "document", "zip", "media"],
   icon: "Download",
   includeContainerStyles: true,
   additionalFields: [
     {
       id: "file",
-      type: "media",
+      type: "file",
       label: "Download file",
       description: "Choose the file visitors can download.",
       required: false,
-      mediaKinds: [...PUBLIC_DOWNLOAD_MEDIA_TYPES],
+      fileKinds: [...PUBLIC_DOWNLOAD_MEDIA_TYPES],
       ui: { intent: "content" }
     },
     {
@@ -37529,14 +37593,14 @@ function createCommandContext(command) {
       "This command does not support --env=both. Use --env=local or --env=remote."
     );
   }
-  const primaryTarget = envTargets[0];
-  const env = loadEnvironment(primaryTarget === "remote");
+  const targetEnv = envTargets[0] ?? "local";
+  const env = loadEnvironment(targetEnv === "remote");
   const client = createManagementClient({
     dashboardUrl: env.dashboardUrl,
     managementApiKey: env.managementApiKey,
     siteId: env.siteId
   });
-  return { output, client, isRemote, isJsonOutput, envTargets };
+  return { output, client, isRemote, isJsonOutput, targetEnv, siteId: env.siteId, envTargets };
 }
 function getOutputContext(command) {
   const globalOpts = command.optsWithGlobals();
@@ -37582,6 +37646,14 @@ function withErrorHandling(action) {
     }
   };
 }
+function withCommandContext(action) {
+  return withErrorHandling(async (...allArgs) => {
+    const command = allArgs[allArgs.length - 1];
+    const actionArgs = allArgs.slice(0, -1);
+    const ctx = createCommandContext(command);
+    await action(ctx, ...actionArgs);
+  });
+}
 function withConfirmation(getMessage, action) {
   return async (...allArgs) => {
     const command = allArgs[allArgs.length - 1];
@@ -37616,40 +37688,6 @@ function withConfirmation(getMessage, action) {
 function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
-function createPublishCommand(config2) {
-  const cmd = new Command("publish").description(`Publish a ${config2.resourceName}`);
-  for (const arg of config2.args) {
-    cmd.argument(`<${arg}>`, `${capitalize(arg.replace("-", " "))}`);
-  }
-  return cmd.action(
-    withErrorHandling(async (...actionArgs) => {
-      const args = actionArgs.slice(0, config2.args.length);
-      const command = actionArgs[actionArgs.length - 1];
-      const { output, client } = createCommandContext(command);
-      const label = args.join("/");
-      output.info(`Publishing ${config2.resourceName}: ${label}`);
-      await config2.action(client, ...args);
-      output.success(`${capitalize(config2.resourceName)} published: ${label}`);
-    })
-  );
-}
-function createUnpublishCommand(config2) {
-  const cmd = new Command("unpublish").description(`Unpublish a ${config2.resourceName}`);
-  for (const arg of config2.args) {
-    cmd.argument(`<${arg}>`, `${capitalize(arg.replace("-", " "))}`);
-  }
-  return cmd.action(
-    withErrorHandling(async (...actionArgs) => {
-      const args = actionArgs.slice(0, config2.args.length);
-      const command = actionArgs[actionArgs.length - 1];
-      const { output, client } = createCommandContext(command);
-      const label = args.join("/");
-      output.info(`Unpublishing ${config2.resourceName}: ${label}`);
-      await config2.action(client, ...args);
-      output.success(`${capitalize(config2.resourceName)} unpublished: ${label}`);
-    })
-  );
-}
 function createGetCommand(config2) {
   const cmd = new Command("get").description(`Get a single ${config2.resourceName}`);
   for (const arg of config2.args) {
@@ -37715,6 +37753,7 @@ function createListCommand(config2) {
 }
 
 // src/cli/push-config.ts
+var DEFAULT_CONFIG_PATH = "./riverbank.config.ts";
 function isRecord5(value) {
   return typeof value === "object" && value !== null;
 }
@@ -37850,6 +37889,13 @@ async function pushConfigAction(output, options) {
   let siteIdForErrorContext;
   try {
     process.env.RIVERBANK_ENV = options.isRemote ? "remote" : "local";
+    if (!isJsonOutput) {
+      output.info("push-config target", {
+        env: process.env.RIVERBANK_ENV,
+        dashboardUrl: options.dashboard,
+        configPath: options.config ?? DEFAULT_CONFIG_PATH
+      });
+    }
     const rawConfig = await loadConfigFile(options.config);
     if (!isJsonOutput) output.info("Validating config...");
     const parseResult = riverbankSiteConfigSchema.safeParse(rawConfig);
@@ -37962,7 +38008,7 @@ function resolveManagementApiKey(output, cliOption, isRemote) {
   }
   return apiKey;
 }
-var pushConfigCommand = new Command("push-config").description("Push SDK config to dashboard").option("--api-key <key>", "Management API key (or set RIVERBANK_*_MGMT_API_KEY)").option("--dashboard <url>", "Dashboard URL (or set RIVERBANK_*_DASHBOARD_URL env var)").option("--config <path>", "Path to config file (default: ./riverbank.config.ts)").option(
+var pushConfigCommand = new Command("push-config").description("Push SDK config to dashboard").option("--api-key <key>", "Management API key (or set RIVERBANK_*_MGMT_API_KEY)").option("--dashboard <url>", "Dashboard URL (or set RIVERBANK_*_DASHBOARD_URL env var)").option("--config <path>", `Path to config file (default: ${DEFAULT_CONFIG_PATH})`).option(
   "--force-content-types",
   "Force overwrite content type schema even if modified in dashboard after last SDK sync"
 ).addHelpText("after", `
@@ -37980,6 +38026,7 @@ Description:
 
 Examples:
   $ npx riverbankcms push-config
+  $ npx riverbankcms push-config --env=remote
   $ npx riverbankcms push-config --api-key bld_mgmt_sk_... --dashboard https://www.riverbankcms.com
   $ npx riverbankcms push-config --config ./src/riverbank.config.ts
 `).action(async (options, command) => {
@@ -52226,6 +52273,403 @@ function reportMediaValidationWarningsAndCollectBlocking(output, validation) {
   return validation.diagnostics.filter((diagnostic) => diagnostic.severity === "error").map((diagnostic) => formatMediaGuardDiagnostic(diagnostic));
 }
 
+// src/cli/site-commands/oneOffCommands.ts
+init_src();
+function compileOneOffEntryCommand(input) {
+  const commandBinding2 = oneOffEntryCommandBinding(input.mutation);
+  return planCliCommandBatchForBindings({
+    source: input.source,
+    siteId: input.siteId,
+    targetEnv: input.targetEnv,
+    commandTypes: entrySiteCommandTypes,
+    commandBindings: [commandBinding2]
+  });
+}
+function compileOneOffPageCommand(input) {
+  const commandBinding2 = oneOffPageCommandBinding(input.mutation);
+  return planCliCommandBatchForBindings({
+    source: input.source,
+    siteId: input.siteId,
+    targetEnv: input.targetEnv,
+    commandTypes: pageSiteCommandTypes,
+    commandBindings: [commandBinding2]
+  });
+}
+function compileOneOffBlockCommand(input) {
+  const commandBinding2 = oneOffBlockCommandBinding(input.mutation);
+  return planCliCommandBatchForBindings({
+    source: input.source,
+    siteId: input.siteId,
+    targetEnv: input.targetEnv,
+    commandTypes: pageSiteCommandTypes,
+    commandBindings: [commandBinding2]
+  });
+}
+function compileOneOffNavigationCommand(input) {
+  const commandBinding2 = oneOffNavigationCommandBinding(input.mutation);
+  return planCliCommandBatchForBindings({
+    source: input.source,
+    siteId: input.siteId,
+    targetEnv: input.targetEnv,
+    commandTypes: navigationSiteCommandTypes,
+    commandBindings: [commandBinding2]
+  });
+}
+async function executeOneOffEntryCommand(input) {
+  const plannedCommand = singlePlannedCommand(input.compiledPlan.plan.commands);
+  return input.apply(plannedCommand.command, input.client);
+}
+async function executeOneOffPageCommand(input) {
+  const plannedCommand = singlePlannedCommand(input.compiledPlan.plan.commands);
+  return input.apply(plannedCommand.command, input.client);
+}
+async function executeOneOffNavigationCommand(input) {
+  const plannedCommand = singlePlannedCommand(input.compiledPlan.plan.commands);
+  return input.apply(plannedCommand.command, input.client);
+}
+async function applyOneOffEntryCommand(command, client) {
+  switch (command.type) {
+    case "upsertContentEntry":
+      return client.entries.upsert({
+        identifier: entryIdentifierForCommand(command),
+        contentType: command.input.contentTypeKey,
+        data: command.input.data ?? {},
+        slug: command.input.slug
+      });
+    case "publishContentEntry":
+      await client.entries.publish(
+        command.input.contentTypeKey,
+        entryIdentifierForCommand(command)
+      );
+      return;
+    case "unpublishContentEntry":
+      await client.entries.unpublish(
+        command.input.contentTypeKey,
+        entryIdentifierForCommand(command)
+      );
+      return;
+    case "deleteContentEntry":
+      await client.entries.delete(
+        command.input.contentTypeKey,
+        entryIdentifierForCommand(command)
+      );
+      return;
+    default:
+      assertNever(command);
+  }
+}
+async function applyOneOffEntryCommandReturningEntry(command, client) {
+  const result = await applyOneOffEntryCommand(command, client);
+  if (!result) {
+    throw new Error("Entry upsert completed without returning an entry.");
+  }
+  return result;
+}
+async function applyOneOffPageCommand(command, client) {
+  switch (command.type) {
+    case "upsertPage":
+      return client.pages.upsert({
+        identifier: pageIdentifierForCommand(command),
+        title: command.input.title,
+        path: pagePathForCommand(command),
+        seoTitle: command.input.seoTitle,
+        seoDescription: command.input.seoDescription
+      });
+    case "publishPage":
+      await client.pages.publish(pageIdentifierForCommand(command));
+      return;
+    case "unpublishPage":
+      await client.pages.unpublish(pageIdentifierForCommand(command));
+      return;
+    case "upsertPageBlock":
+      return client.blocks.upsert(pageIdentifierForBlockCommand(command), {
+        identifier: blockIdentifierForCommand(command),
+        kind: command.input.type,
+        data: command.input.props ?? {}
+      });
+    case "reorderPageBlocks":
+      await client.blocks.reorder(
+        pageIdentifierForBlockCommand(command),
+        [...blockOrderIdentifiersForCommand(command)]
+      );
+      return;
+    case "deletePageBlock":
+      await client.blocks.delete(
+        pageIdentifierForBlockCommand(command),
+        blockIdentifierForCommand(command)
+      );
+      return;
+    default:
+      assertNever(command);
+  }
+}
+async function applyOneOffPageCommandReturningPage(command, client) {
+  const result = await applyOneOffPageCommand(command, client);
+  if (!result || !isManagementPage(result)) {
+    throw new Error("Page upsert completed without returning a page.");
+  }
+  return result;
+}
+async function applyOneOffPageCommandReturningBlock(command, client) {
+  const result = await applyOneOffPageCommand(command, client);
+  if (!result || !isManagementBlock(result)) {
+    throw new Error("Block upsert completed without returning a block.");
+  }
+  return result;
+}
+async function applyOneOffNavigationCommand(command, client) {
+  const role = navigationCommandRole2(command);
+  return client.navigation.upsert({
+    name: navigationCommandMenuName2(command),
+    items: command.input.items.map(navigationItemInput2),
+    ...role === "primary" ? { isPrimary: true } : {},
+    ...role === "footer" ? { isFooter: true } : {}
+  });
+}
+function oneOffEntryCommandBinding(mutation) {
+  const contentType = asCliContentTypeKey(mutation.contentType);
+  const identifier = asCliEntryIdentifier(mutation.identifier);
+  switch (mutation.kind) {
+    case "upsert": {
+      const title = titleFromEntryData(mutation.data);
+      const command = {
+        type: "upsertContentEntry",
+        ref: createContentEntryRef([contentType, identifier]),
+        input: {
+          identifier,
+          contentTypeKey: contentType,
+          ...mutation.slug ? { slug: mutation.slug } : {},
+          ...title ? { title } : {},
+          data: mutation.data
+        }
+      };
+      return {
+        command,
+        reportSubject: { contentType, identifier, counter: "updated" }
+      };
+    }
+    case "publish": {
+      const command = {
+        type: "publishContentEntry",
+        ref: createCommandRef("publish", [contentType, identifier]),
+        input: { contentTypeKey: contentType, identifier }
+      };
+      return {
+        command,
+        reportSubject: { contentType, identifier, counter: "published" }
+      };
+    }
+    case "unpublish": {
+      const command = {
+        type: "unpublishContentEntry",
+        ref: createCommandRef("unpublish", [contentType, identifier]),
+        input: { contentTypeKey: contentType, identifier }
+      };
+      return {
+        command,
+        reportSubject: { contentType, identifier, counter: "unpublished" }
+      };
+    }
+    default:
+      assertNever(mutation);
+  }
+}
+function oneOffPageCommandBinding(mutation) {
+  const identifier = asCliPageIdentifier(mutation.identifier);
+  switch (mutation.kind) {
+    case "upsert": {
+      const command = {
+        type: "upsertPage",
+        ref: createPageRef([identifier]),
+        input: {
+          identifier,
+          slug: identifier,
+          title: mutation.title,
+          path: mutation.path,
+          ...mutation.seoTitle ? { seoTitle: mutation.seoTitle } : {},
+          ...mutation.seoDescription ? { seoDescription: mutation.seoDescription } : {}
+        }
+      };
+      return {
+        command,
+        reportSubject: { resource: "page", identifier, counter: "updated" }
+      };
+    }
+    case "publish": {
+      const command = {
+        type: "publishPage",
+        ref: createCommandRef("publish-page", [identifier]),
+        input: { identifier }
+      };
+      return {
+        command,
+        reportSubject: { resource: "page", identifier, counter: "published" }
+      };
+    }
+    case "unpublish": {
+      const command = {
+        type: "unpublishPage",
+        ref: createCommandRef("unpublish-page", [identifier]),
+        input: { identifier }
+      };
+      return {
+        command,
+        reportSubject: { resource: "page", identifier, counter: "unpublished" }
+      };
+    }
+    default:
+      assertNever(mutation);
+  }
+}
+function oneOffBlockCommandBinding(mutation) {
+  const pageIdentifier = asCliPageIdentifier(mutation.pageIdentifier);
+  switch (mutation.kind) {
+    case "upsert": {
+      const identifier = asCliBlockIdentifier(mutation.blockIdentifier);
+      const command = {
+        type: "upsertPageBlock",
+        ref: createBlockRef([pageIdentifier, identifier]),
+        input: {
+          pageIdentifier,
+          identifier,
+          type: mutation.blockKind,
+          props: mutation.data
+        }
+      };
+      return {
+        command,
+        reportSubject: {
+          resource: "block",
+          pageIdentifier,
+          identifier,
+          counter: "updated"
+        }
+      };
+    }
+    case "reorder": {
+      const identifiers = mutation.blockIdentifiers.map(asCliBlockIdentifier);
+      const command = {
+        type: "reorderPageBlocks",
+        ref: createBlocksRef([pageIdentifier]),
+        input: {
+          pageIdentifier,
+          blocks: identifiers.map((identifier) => ({
+            blockRef: createBlockRef([pageIdentifier, identifier]),
+            identifier
+          }))
+        }
+      };
+      return {
+        command,
+        reportSubject: {
+          resource: "block",
+          pageIdentifier,
+          identifier: pageIdentifier,
+          counter: "reordered"
+        }
+      };
+    }
+    default:
+      assertNever(mutation);
+  }
+}
+function oneOffNavigationCommandBinding(mutation) {
+  const name = asCliNavigationMenuName(mutation.menuName);
+  const command = {
+    type: "upsertNavigationMenu",
+    ref: createNavigationRef([name]),
+    input: {
+      name,
+      items: mutation.items.map(navigationItemForCommand2)
+    }
+  };
+  return {
+    command,
+    reportSubject: { name, counter: "updated" }
+  };
+}
+function navigationItemForCommand2(item) {
+  return {
+    label: item.label,
+    ...item.isCta ? { isCta: true } : {},
+    ...item.link ? { link: navigationLinkForCommand(item.link) } : {},
+    ...item.children ? { children: item.children.map(navigationItemForCommand2) } : {}
+  };
+}
+function navigationLinkForCommand(link2) {
+  switch (link2.kind) {
+    case "page":
+      return { kind: "page", identifier: link2.identifier };
+    case "entry":
+      return {
+        kind: "entry",
+        contentType: link2.contentType,
+        identifier: link2.identifier
+      };
+    case "external":
+      return { kind: "external", href: link2.href };
+    case "url":
+      return { kind: "url", href: link2.href };
+    case "portal":
+      return {
+        kind: "portal",
+        ...link2.path ? { path: link2.path } : {},
+        ...link2.labels ? { labels: link2.labels } : {}
+      };
+    case "cart":
+      return {
+        kind: "cart",
+        badge: link2.badge,
+        label: link2.label
+      };
+    default:
+      assertNever(link2);
+  }
+}
+function navigationItemInput2(item) {
+  return {
+    label: item.label,
+    ...item.isCta ? { isCta: true } : {},
+    ...item.link ? { link: item.link } : {},
+    ...item.children ? { children: item.children.map(navigationItemInput2) } : {}
+  };
+}
+function navigationCommandMenuName2(command) {
+  const name = command.input.name ?? command.input.location;
+  if (name) return name;
+  throw new Error(`Invalid navigation command ${command.ref}: missing input.name or input.location.`);
+}
+function navigationCommandRole2(command) {
+  if (command.input.role) return command.input.role;
+  switch (command.input.location) {
+    case "main":
+    case "header":
+      return "primary";
+    case "footer":
+      return "footer";
+    case void 0:
+      return void 0;
+    default:
+      return assertNever(command.input.location);
+  }
+}
+function isManagementPage(value) {
+  return "path" in value;
+}
+function isManagementBlock(value) {
+  return "kind" in value;
+}
+function singlePlannedCommand(commands) {
+  if (commands.length !== 1) {
+    throw new Error(`Expected exactly one one-off site command, got ${commands.length}.`);
+  }
+  const plannedCommand = commands[0];
+  if (!plannedCommand) {
+    throw new Error("Expected one one-off site command, got none.");
+  }
+  return plannedCommand;
+}
+
 // src/cli/commands/entry.ts
 var ENTRY_LIST_COLUMNS = [
   "id",
@@ -52389,8 +52833,8 @@ async function validateEntryUpsertMedia(options) {
   };
 }
 var upsertCommand = new Command("upsert").description("Create or update an entry").argument("<type>", "Content type").argument("<identifier>", "Entry identifier").option("--data <json>", "Entry data as JSON string").option("--file <path>", "Path to JSON file with entry data").option("--slug <slug>", "Entry slug (defaults to identifier)").action(
-  withErrorHandling(async (type, identifier, options, command) => {
-    const { output, client } = createCommandContext(command);
+  withCommandContext(async (ctx, type, identifier, options) => {
+    const { output, client, siteId, targetEnv } = ctx;
     const data = await parseJsonData(options);
     output.info(`Upserting entry: ${type}/${identifier}`);
     const mediaValidation = await validateEntryUpsertMedia({
@@ -52406,11 +52850,25 @@ var upsertCommand = new Command("upsert").description("Create or update an entry
         suggestion: "Resolve media identifiers on the CMS first, or remove invalid media references."
       });
     }
-    const entry = await client.entries.upsert({
-      contentType: type,
-      identifier,
-      data,
-      slug: options.slug
+    const compiled = compileOneOffEntryCommand({
+      source: "one_off_entry",
+      siteId,
+      targetEnv,
+      mutation: {
+        kind: "upsert",
+        contentType: type,
+        identifier,
+        data,
+        ...options.slug ? { slug: options.slug } : {}
+      }
+    });
+    if (!compiled.ok) {
+      return output.error(compiled.error.message);
+    }
+    const entry = await executeOneOffEntryCommand({
+      compiledPlan: compiled.value,
+      client,
+      apply: applyOneOffEntryCommandReturningEntry
     });
     output.success(`Entry upserted: ${entry.identifier}`, {
       id: entry.id,
@@ -52420,16 +52878,50 @@ var upsertCommand = new Command("upsert").description("Create or update an entry
     });
   })
 );
-var publishCommand = createPublishCommand({
-  resourceName: "entry",
-  args: ["type", "identifier"],
-  action: (client, type, identifier) => client.entries.publish(type, identifier)
-});
-var unpublishCommand = createUnpublishCommand({
-  resourceName: "entry",
-  args: ["type", "identifier"],
-  action: (client, type, identifier) => client.entries.unpublish(type, identifier)
-});
+var publishCommand = new Command("publish").description("Publish a entry").argument("<type>", "Type").argument("<identifier>", "Identifier").action(
+  withCommandContext(async (ctx, type, identifier) => {
+    const { output, client, siteId, targetEnv } = ctx;
+    const label = `${type}/${identifier}`;
+    output.info(`Publishing entry: ${label}`);
+    const compiled = compileOneOffEntryCommand({
+      source: "one_off_entry",
+      siteId,
+      targetEnv,
+      mutation: { kind: "publish", contentType: type, identifier }
+    });
+    if (!compiled.ok) {
+      return output.error(compiled.error.message);
+    }
+    await executeOneOffEntryCommand({
+      compiledPlan: compiled.value,
+      client,
+      apply: applyOneOffEntryCommand
+    });
+    output.success(`Entry published: ${label}`);
+  })
+);
+var unpublishCommand = new Command("unpublish").description("Unpublish a entry").argument("<type>", "Type").argument("<identifier>", "Identifier").action(
+  withCommandContext(async (ctx, type, identifier) => {
+    const { output, client, siteId, targetEnv } = ctx;
+    const label = `${type}/${identifier}`;
+    output.info(`Unpublishing entry: ${label}`);
+    const compiled = compileOneOffEntryCommand({
+      source: "one_off_entry",
+      siteId,
+      targetEnv,
+      mutation: { kind: "unpublish", contentType: type, identifier }
+    });
+    if (!compiled.ok) {
+      return output.error(compiled.error.message);
+    }
+    await executeOneOffEntryCommand({
+      compiledPlan: compiled.value,
+      client,
+      apply: applyOneOffEntryCommand
+    });
+    output.success(`Entry unpublished: ${label}`);
+  })
+);
 async function findEntryById(client, contentType, entryId, options = {}) {
   const limit = options.limit ?? 20;
   if (!Number.isFinite(limit) || limit <= 0) {
@@ -52564,15 +53056,29 @@ var formatPageRow = (page) => [
   formatDateShort(page.updatedAt)
 ];
 var upsertCommand2 = new Command("upsert").description("Create or update a page").argument("<identifier>", "Page identifier").requiredOption("--title <title>", "Page title").requiredOption("--path <path>", "Page path (e.g., /about)").option("--seo-title <title>", "SEO title").option("--seo-description <description>", "SEO description").action(
-  withErrorHandling(async (identifier, options, command) => {
-    const { output, client } = createCommandContext(command);
+  withCommandContext(async (ctx, identifier, options) => {
+    const { output, client, siteId, targetEnv } = ctx;
     output.info(`Upserting page: ${identifier}`);
-    const page = await client.pages.upsert({
-      identifier,
-      title: options.title,
-      path: options.path,
-      seoTitle: options.seoTitle,
-      seoDescription: options.seoDescription
+    const compiled = compileOneOffPageCommand({
+      source: "one_off_page",
+      siteId,
+      targetEnv,
+      mutation: {
+        kind: "upsert",
+        identifier,
+        title: options.title,
+        path: options.path,
+        ...options.seoTitle ? { seoTitle: options.seoTitle } : {},
+        ...options.seoDescription ? { seoDescription: options.seoDescription } : {}
+      }
+    });
+    if (!compiled.ok) {
+      return output.error(compiled.error.message);
+    }
+    const page = await executeOneOffPageCommand({
+      compiledPlan: compiled.value,
+      client,
+      apply: applyOneOffPageCommandReturningPage
     });
     output.success(`Page upserted: ${page.identifier}`, {
       id: page.id,
@@ -52582,16 +53088,48 @@ var upsertCommand2 = new Command("upsert").description("Create or update a page"
     });
   })
 );
-var publishCommand2 = createPublishCommand({
-  resourceName: "page",
-  args: ["identifier"],
-  action: (client, identifier) => client.pages.publish(identifier)
-});
-var unpublishCommand2 = createUnpublishCommand({
-  resourceName: "page",
-  args: ["identifier"],
-  action: (client, identifier) => client.pages.unpublish(identifier)
-});
+var publishCommand2 = new Command("publish").description("Publish a page").argument("<identifier>", "Identifier").action(
+  withCommandContext(async (ctx, identifier) => {
+    const { output, client, siteId, targetEnv } = ctx;
+    output.info(`Publishing page: ${identifier}`);
+    const compiled = compileOneOffPageCommand({
+      source: "one_off_page",
+      siteId,
+      targetEnv,
+      mutation: { kind: "publish", identifier }
+    });
+    if (!compiled.ok) {
+      return output.error(compiled.error.message);
+    }
+    await executeOneOffPageCommand({
+      compiledPlan: compiled.value,
+      client,
+      apply: applyOneOffPageCommand
+    });
+    output.success(`Page published: ${identifier}`);
+  })
+);
+var unpublishCommand2 = new Command("unpublish").description("Unpublish a page").argument("<identifier>", "Identifier").action(
+  withCommandContext(async (ctx, identifier) => {
+    const { output, client, siteId, targetEnv } = ctx;
+    output.info(`Unpublishing page: ${identifier}`);
+    const compiled = compileOneOffPageCommand({
+      source: "one_off_page",
+      siteId,
+      targetEnv,
+      mutation: { kind: "unpublish", identifier }
+    });
+    if (!compiled.ok) {
+      return output.error(compiled.error.message);
+    }
+    await executeOneOffPageCommand({
+      compiledPlan: compiled.value,
+      client,
+      apply: applyOneOffPageCommand
+    });
+    output.success(`Page unpublished: ${identifier}`);
+  })
+);
 var getCommand2 = createGetCommand({
   resourceName: "page",
   args: ["identifier"],
@@ -52653,9 +53191,9 @@ async function validateBlockUpsertMedia(options) {
   };
 }
 var upsertCommand3 = new Command("upsert").description("Create or update a block on a page").argument("<page-identifier>", "Page identifier").argument("<block-identifier>", "Block identifier").requiredOption("--kind <kind>", "Block kind (e.g., block.hero, block.body-text)").option("--data <json>", "Block data as JSON string").option("--file <path>", "Path to JSON file with block data").option("--position <n>", "Block position (0-indexed)").action(
-  withErrorHandling(
-    async (pageIdentifier, blockIdentifier, options, command) => {
-      const { output, client } = createCommandContext(command);
+  withCommandContext(
+    async (ctx, pageIdentifier, blockIdentifier, options) => {
+      const { output, client, siteId, targetEnv } = ctx;
       const data = await parseJsonData(options);
       output.info(`Upserting block: ${pageIdentifier}/${blockIdentifier}`);
       const mediaValidation = await validateBlockUpsertMedia({
@@ -52672,12 +53210,37 @@ var upsertCommand3 = new Command("upsert").description("Create or update a block
           suggestion: "Resolve media identifiers on the CMS first, or remove invalid media references."
         });
       }
-      const block = await client.blocks.upsert(pageIdentifier, {
-        identifier: blockIdentifier,
-        kind: options.kind,
-        data,
-        position: options.position ? parseInt(options.position, 10) : void 0
-      });
+      const position = options.position ? parseInt(options.position, 10) : void 0;
+      let block;
+      if (position !== void 0) {
+        block = await client.blocks.upsert(pageIdentifier, {
+          identifier: blockIdentifier,
+          kind: options.kind,
+          data,
+          position
+        });
+      } else {
+        const compiled = compileOneOffBlockCommand({
+          source: "one_off_block",
+          siteId,
+          targetEnv,
+          mutation: {
+            kind: "upsert",
+            pageIdentifier,
+            blockIdentifier,
+            blockKind: options.kind,
+            data
+          }
+        });
+        if (!compiled.ok) {
+          return output.error(compiled.error.message);
+        }
+        block = await executeOneOffPageCommand({
+          compiledPlan: compiled.value,
+          client,
+          apply: applyOneOffPageCommandReturningBlock
+        });
+      }
       output.success(`Block upserted: ${block.identifier}`, {
         id: block.id,
         identifier: block.identifier,
@@ -52688,14 +53251,27 @@ var upsertCommand3 = new Command("upsert").description("Create or update a block
   )
 );
 var reorderCommand = new Command("reorder").description("Reorder blocks on a page").argument("<page-identifier>", "Page identifier").argument("<identifiers...>", "Block identifiers in desired order").action(
-  withErrorHandling(
-    async (pageIdentifier, identifiers, _options, command) => {
-      const { output, client } = createCommandContext(command);
+  withCommandContext(
+    async (ctx, pageIdentifier, identifiers) => {
+      const { output, client, siteId, targetEnv } = ctx;
       if (identifiers.length < 2) {
         return output.error("At least 2 block identifiers are required for reordering");
       }
       output.info(`Reordering blocks on page: ${pageIdentifier}`);
-      await client.blocks.reorder(pageIdentifier, identifiers);
+      const compiled = compileOneOffBlockCommand({
+        source: "one_off_block",
+        siteId,
+        targetEnv,
+        mutation: { kind: "reorder", pageIdentifier, blockIdentifiers: identifiers }
+      });
+      if (!compiled.ok) {
+        return output.error(compiled.error.message);
+      }
+      await executeOneOffPageCommand({
+        compiledPlan: compiled.value,
+        client,
+        apply: applyOneOffPageCommand
+      });
       output.success(`Blocks reordered`, {
         page: pageIdentifier,
         order: identifiers
@@ -52763,13 +53339,23 @@ function countItems(items) {
   return count;
 }
 var upsertCommand4 = new Command("upsert").description("Create or update a navigation menu").argument("<menu-name>", "Navigation menu name").option("--file <path>", "Path to JSON file with menu items").option("--data <json>", "Menu items as JSON string").action(
-  withErrorHandling(async (menuName, options, command) => {
-    const { output, client } = createCommandContext(command);
+  withCommandContext(async (ctx, menuName, options) => {
+    const { output, client, siteId, targetEnv } = ctx;
     const items = await parseJsonArray(options);
     output.info(`Upserting navigation menu: ${menuName}`);
-    const menu = await client.navigation.upsert({
-      name: menuName,
-      items
+    const compiled = compileOneOffNavigationCommand({
+      source: "one_off_navigation",
+      siteId,
+      targetEnv,
+      mutation: { kind: "upsert", menuName, items }
+    });
+    if (!compiled.ok) {
+      return output.error(compiled.error.message);
+    }
+    const menu = await executeOneOffNavigationCommand({
+      compiledPlan: compiled.value,
+      client,
+      apply: applyOneOffNavigationCommand
     });
     output.success(`Navigation menu upserted: ${menu.name}`, {
       id: menu.id,
@@ -53919,7 +54505,8 @@ async function initDocs(options) {
     { filename: "content-types.md", template: "workflow-content-types" },
     { filename: "templates.md", template: "workflow-templates" },
     { filename: "cmsify-page.md", template: "workflow-cmsify-page" },
-    { filename: "editor-workflows.md", template: "workflow-editor-workflows" }
+    { filename: "editor-workflows.md", template: "workflow-editor-workflows" },
+    { filename: "preview-mode.md", template: "workflow-preview-mode" }
   ];
   await Promise.all(
     coreWorkflows.map(
@@ -54249,7 +54836,7 @@ var SimpleCache = class {
 };
 
 // src/version.ts
-var SDK_VERSION = "0.70.2";
+var SDK_VERSION = "0.70.4";
 
 // src/client/error.ts
 var RiverbankApiError = class _RiverbankApiError extends Error {
@@ -57302,7 +57889,14 @@ function collectLayoutClassNames(node, out = /* @__PURE__ */ new Set()) {
 }
 
 // src/manifest/validation/output-schema.ts
-var blockCategoryEnum2 = z.enum(["marketing", "content", "blog", "media", "layout", "interactive"]);
+var blockCategoryEnum2 = z.enum([
+  "marketing",
+  "content",
+  "blog",
+  "media",
+  "layout",
+  "interactive"
+]);
 var llmColorValue = z.object({
   name: z.string(),
   hex: z.string()
@@ -57320,8 +57914,16 @@ var llmThemePatchValue = z.union([
   z.array(llmThemePrimitive)
 ]);
 var llmThemePatchOpSchema = z.discriminatedUnion("op", [
-  z.object({ op: z.literal("add"), path: z.string().min(1), value: llmThemePatchValue }),
-  z.object({ op: z.literal("replace"), path: z.string().min(1), value: llmThemePatchValue }),
+  z.object({
+    op: z.literal("add"),
+    path: z.string().min(1),
+    value: llmThemePatchValue
+  }),
+  z.object({
+    op: z.literal("replace"),
+    path: z.string().min(1),
+    value: llmThemePatchValue
+  }),
   z.object({ op: z.literal("remove"), path: z.string().min(1) })
 ]);
 var llmCssDeclaration = z.object({
@@ -57398,7 +58000,11 @@ var llmRichTextFieldSchema = llmBaseFieldSchema.extend({
 });
 var llmMediaFieldSchema = llmBaseFieldSchema.extend({
   type: z.literal("media"),
-  mediaKinds: z.array(z.enum(["image", "video", "audio", "document", "spreadsheet", "archive"])).nullable()
+  mediaKinds: z.array(z.enum(["image", "video", "audio"])).nullable()
+});
+var llmFileFieldSchema = llmBaseFieldSchema.extend({
+  type: z.literal("file"),
+  fileKinds: z.array(z.enum(["document", "spreadsheet", "archive", "audio"])).nullable()
 });
 var llmBooleanFieldSchema = llmBaseFieldSchema.extend({
   type: z.literal("boolean")
@@ -57408,10 +58014,12 @@ var llmLinkFieldSchema = llmBaseFieldSchema.extend({
 });
 var llmSelectFieldSchema = llmBaseFieldSchema.extend({
   type: z.literal("select"),
-  options: z.array(z.object({
-    value: z.string(),
-    label: z.string()
-  })),
+  options: z.array(
+    z.object({
+      value: z.string(),
+      label: z.string()
+    })
+  ),
   multiple: z.boolean().nullable()
 });
 var llmNumberFieldSchema = llmBaseFieldSchema.extend({
@@ -57447,6 +58055,7 @@ var llmFieldSchema = z.union([
   llmTextFieldSchema,
   llmRichTextFieldSchema,
   llmMediaFieldSchema,
+  llmFileFieldSchema,
   llmBooleanFieldSchema,
   llmLinkFieldSchema,
   llmSelectFieldSchema,
@@ -57457,9 +58066,11 @@ var llmFieldSchema = z.union([
 var llmBindingSchema = z.object({
   from: z.string(),
   fallback: z.string().nullable(),
-  transforms: z.array(z.object({
-    id: z.string()
-  })).nullable()
+  transforms: z.array(
+    z.object({
+      id: z.string()
+    })
+  ).nullable()
 });
 var llmRepeatSchema = z.object({
   collection: z.object({ from: z.string() }),
@@ -57518,11 +58129,17 @@ function collectValidationErrors(output) {
   const blockIds = output.blocks.map((b) => b.id);
   const singleBlockId = blockIds.length === 1 ? blockIds[0] ?? null : null;
   for (const block of output.blocks) {
-    const layoutErrors = validateLayoutDeep(block.layout, block.id, block.fields);
+    const layoutErrors = validateLayoutDeep(
+      block.layout,
+      block.id,
+      block.fields
+    );
     errors.push(...layoutErrors);
     const fieldInfo = collectFieldInfo(block.fields);
     const used = collectUsedFieldRefs(block.layout);
-    const unusedTopLevelFields = Array.from(fieldInfo.topLevelFieldIds).filter((id) => !used.topLevel.has(id));
+    const unusedTopLevelFields = Array.from(fieldInfo.topLevelFieldIds).filter(
+      (id) => !used.topLevel.has(id)
+    );
     if (unusedTopLevelFields.length > 0) {
       errors.push({
         path: `blocks["${block.id}"].fields`,
@@ -57530,10 +58147,15 @@ function collectValidationErrors(output) {
         suggestion: `Every field should be bound to a layout node. Add $bind: { from: "content.${unusedTopLevelFields[0]}" } to an appropriate node, or remove unused fields.`
       });
     }
-    for (const [repeaterFieldId, nestedFieldIds] of fieldInfo.repeaterNestedFieldIds.entries()) {
+    for (const [
+      repeaterFieldId,
+      nestedFieldIds
+    ] of fieldInfo.repeaterNestedFieldIds.entries()) {
       if (!used.topLevel.has(repeaterFieldId)) continue;
       const usedNested = used.nestedByRepeater.get(repeaterFieldId) ?? /* @__PURE__ */ new Set();
-      const missingNested = Array.from(nestedFieldIds).filter((id) => !usedNested.has(id));
+      const missingNested = Array.from(nestedFieldIds).filter(
+        (id) => !usedNested.has(id)
+      );
       if (missingNested.length === 0) continue;
       const itemName = used.itemNameByRepeater.get(repeaterFieldId) ?? "item";
       errors.push({
@@ -57546,10 +58168,18 @@ function collectValidationErrors(output) {
     errors.push(...missingBindings);
     errors.push(...validateLinkFieldDefaultValues(block));
     errors.push(...findMissingLinkHrefs(block.layout, block.id, block.fields));
-    errors.push(...detectRedundantLinkLabels(block.layout, block.id, block.fields));
+    errors.push(
+      ...detectRedundantLinkLabels(block.layout, block.id, block.fields)
+    );
   }
   if (output.customCssRules && output.customCssRules.length > 0) {
-    errors.push(...validateCustomCssRules(output.customCssRules, singleBlockId, output.blocks));
+    errors.push(
+      ...validateCustomCssRules(
+        output.customCssRules,
+        singleBlockId,
+        output.blocks
+      )
+    );
   }
   return errors;
 }
@@ -57625,7 +58255,9 @@ function resolveFieldTypeForFrom(allFields, from, repeatStack) {
     const segments = from.slice(prefix.length).split(".").filter(Boolean);
     const [nestedId, ...rest] = segments;
     if (!nestedId) return null;
-    let current = ctx.fields.find((f) => f.id === nestedId);
+    let current = ctx.fields.find(
+      (f) => f.id === nestedId
+    );
     if (!current) return null;
     for (const seg of rest) {
       const nested = getNestedFields(current);
@@ -57641,7 +58273,9 @@ function bindingHasTransform(bind2, id) {
   if (!bind2) return false;
   const transforms = bind2.transforms;
   if (!Array.isArray(transforms)) return false;
-  return transforms.some((t) => t && typeof t === "object" && t.id === id);
+  return transforms.some(
+    (t) => t && typeof t === "object" && t.id === id
+  );
 }
 function extractNestedHrefBindFromProps(props2) {
   if (!props2 || typeof props2 !== "object") return null;
@@ -57702,7 +58336,15 @@ function findMissingLinkHrefs(node, blockId, fields3, path24 = "layout", repeatS
   }
   if ("children" in n && Array.isArray(n.children)) {
     for (let i = 0; i < n.children.length; i++) {
-      errors.push(...findMissingLinkHrefs(n.children[i], blockId, fields3, `${path24}.children[${i}]`, nextRepeatStack));
+      errors.push(
+        ...findMissingLinkHrefs(
+          n.children[i],
+          blockId,
+          fields3,
+          `${path24}.children[${i}]`,
+          nextRepeatStack
+        )
+      );
     }
   }
   return errors;
@@ -57726,22 +58368,30 @@ function detectRedundantLinkLabels(node, blockId, fields3, path24 = "layout", re
   }
   if (Array.isArray(n.children) && n.children.length > 1) {
     const children = n.children;
-    const redundancies = findRedundantLinkTextSiblings(children, nextRepeatStack, path24);
-    errors.push(...redundancies.map((r) => ({
-      path: r.path,
-      message: `Block "${blockId}": ${r.message}`,
-      suggestion: r.suggestion
-    })));
+    const redundancies = findRedundantLinkTextSiblings(
+      children,
+      nextRepeatStack,
+      path24
+    );
+    errors.push(
+      ...redundancies.map((r) => ({
+        path: r.path,
+        message: `Block "${blockId}": ${r.message}`,
+        suggestion: r.suggestion
+      }))
+    );
   }
   if (Array.isArray(n.children)) {
     for (let i = 0; i < n.children.length; i++) {
-      errors.push(...detectRedundantLinkLabels(
-        n.children[i],
-        blockId,
-        fields3,
-        `${path24}.children[${i}]`,
-        nextRepeatStack
-      ));
+      errors.push(
+        ...detectRedundantLinkLabels(
+          n.children[i],
+          blockId,
+          fields3,
+          `${path24}.children[${i}]`,
+          nextRepeatStack
+        )
+      );
     }
   }
   return errors;
@@ -57795,7 +58445,8 @@ function checkRedundantLabelBinding(linkBindFrom, textBindFrom, repeatStack) {
     const ctx = repeatStack[i];
     if (!ctx) continue;
     const prefix = `${ctx.itemName}.`;
-    if (!linkBindFrom.startsWith(prefix) || !textBindFrom.startsWith(prefix)) continue;
+    if (!linkBindFrom.startsWith(prefix) || !textBindFrom.startsWith(prefix))
+      continue;
     const linkFieldId = linkBindFrom.slice(prefix.length).split(".")[0] ?? "";
     const textFieldId = textBindFrom.slice(prefix.length).split(".")[0] ?? "";
     const linkField = ctx.fields.find((f) => f.id === linkFieldId);
@@ -57820,7 +58471,10 @@ function validateCustomCssRules(rules, singleBlockId, blocks) {
   const layoutClassNamesByBlockId = /* @__PURE__ */ new Map();
   const layoutNodeInfosByBlockId = /* @__PURE__ */ new Map();
   for (const block of blocks) {
-    layoutClassNamesByBlockId.set(block.id, collectLayoutClassNames(block.layout));
+    layoutClassNamesByBlockId.set(
+      block.id,
+      collectLayoutClassNames(block.layout)
+    );
     layoutNodeInfosByBlockId.set(block.id, collectLayoutNodeInfos(block.layout));
   }
   const missingLayoutHooksByBlockId = /* @__PURE__ */ new Map();
@@ -57889,11 +58543,18 @@ function validateCustomCssRules(rules, singleBlockId, blocks) {
       }
     }
   }
-  for (const [blockId, missingClassNames] of missingLayoutHooksByBlockId.entries()) {
+  for (const [
+    blockId,
+    missingClassNames
+  ] of missingLayoutHooksByBlockId.entries()) {
     const missing = Array.from(missingClassNames).sort();
     if (missing.length === 0) continue;
     const layoutNodeInfos = layoutNodeInfosByBlockId.get(blockId) ?? [];
-    const attachSuggestions = buildClassHookAttachSuggestions(blockId, missing, layoutNodeInfos);
+    const attachSuggestions = buildClassHookAttachSuggestions(
+      blockId,
+      missing,
+      layoutNodeInfos
+    );
     const attachSuggestionsLine = attachSuggestions ? `
 
 Suggested attachments:
@@ -57927,7 +58588,9 @@ function buildClassHookAttachSuggestions(blockId, missingClassNames, nodes) {
       continue;
     }
     if ((lower.includes("headline") || lower.includes("title")) && (headlineNode ?? firstStack)) {
-      lines.push(`- ${className} \u2192 add to ${headlineNode ?? firstStack}.props.className`);
+      lines.push(
+        `- ${className} \u2192 add to ${headlineNode ?? firstStack}.props.className`
+      );
       continue;
     }
     if (lower.includes("highlight") && highlightNode) {
@@ -57935,7 +58598,9 @@ function buildClassHookAttachSuggestions(blockId, missingClassNames, nodes) {
       continue;
     }
     if ((lower.includes("body") || lower.includes("copy") || lower.includes("paragraph")) && (paragraphNode ?? firstStack)) {
-      lines.push(`- ${className} \u2192 add to ${paragraphNode ?? firstStack}.props.className`);
+      lines.push(
+        `- ${className} \u2192 add to ${paragraphNode ?? firstStack}.props.className`
+      );
       continue;
     }
     lines.push(`- ${className} \u2192 add to ${rootPath}.props.className (fallback)`);
@@ -57943,7 +58608,10 @@ function buildClassHookAttachSuggestions(blockId, missingClassNames, nodes) {
   return lines.slice(0, 8).join("\n");
 }
 function extractSelectorClasses(selector) {
-  const withoutDataBlockAttrs = selector.replace(/\[data-block=(["']).*?\1\]/g, "");
+  const withoutDataBlockAttrs = selector.replace(
+    /\[data-block=(["']).*?\1\]/g,
+    ""
+  );
   const classes = /* @__PURE__ */ new Set();
   const re = /\.([_a-zA-Z][-_a-zA-Z0-9]*)/g;
   let match;
@@ -57960,7 +58628,9 @@ function extractBlockIdFromSelector(selector) {
   return match?.[2] ?? null;
 }
 function validateNodeType(nodeType, path24, ctx) {
-  if (!ALLOWED_NODE_TYPES.includes(nodeType)) {
+  if (!ALLOWED_NODE_TYPES.includes(
+    nodeType
+  )) {
     return {
       path: `${path24}.type`,
       message: `Block "${ctx.blockId}": Unknown node type "${nodeType}" at ${path24}`,
@@ -57974,7 +58644,9 @@ function validateTransforms(transforms, path24, ctx) {
   for (let i = 0; i < transforms.length; i++) {
     const transform = transforms[i];
     if (transform.id && typeof transform.id === "string") {
-      if (!ALLOWED_TRANSFORM_IDS.includes(transform.id)) {
+      if (!ALLOWED_TRANSFORM_IDS.includes(
+        transform.id
+      )) {
         errors.push({
           path: `${path24}.transforms[${i}].id`,
           message: `Block "${ctx.blockId}": Unknown transform "${transform.id}"`,
@@ -58023,16 +58695,28 @@ function validateLayoutNode(node, path24, ctx) {
     if (typeError) errors.push(typeError);
   }
   if ("$bind" in n && n.$bind && typeof n.$bind === "object") {
-    const bindErrors = validateBinding(n.$bind, `${path24}.$bind`, ctx);
+    const bindErrors = validateBinding(
+      n.$bind,
+      `${path24}.$bind`,
+      ctx
+    );
     errors.push(...bindErrors);
   }
   if ("props" in n && n.props && typeof n.props === "object") {
-    const propsErrors = validatePropsBindings(n.props, `${path24}.props`, ctx);
+    const propsErrors = validatePropsBindings(
+      n.props,
+      `${path24}.props`,
+      ctx
+    );
     errors.push(...propsErrors);
   }
   if ("children" in n && Array.isArray(n.children)) {
     for (let i = 0; i < n.children.length; i++) {
-      const childErrors = validateLayoutNode(n.children[i], `${path24}.children[${i}]`, ctx);
+      const childErrors = validateLayoutNode(
+        n.children[i],
+        `${path24}.children[${i}]`,
+        ctx
+      );
       errors.push(...childErrors);
     }
   }
@@ -58046,7 +58730,11 @@ function validatePropsBindings(props2, path24, ctx) {
       const bindErrors = validateBinding(bind2, `${path24}.${key}.$bind`, ctx);
       errors.push(...bindErrors);
     } else if (value && typeof value === "object" && !Array.isArray(value)) {
-      const nestedErrors = validatePropsBindings(value, `${path24}.${key}`, ctx);
+      const nestedErrors = validatePropsBindings(
+        value,
+        `${path24}.${key}`,
+        ctx
+      );
       errors.push(...nestedErrors);
     }
   }
@@ -58087,7 +58775,10 @@ function collectFieldInfo(fields3) {
     topLevelFieldIds.add(field.id);
     if (field.type === "repeater" && field.schema && typeof field.schema === "object" && "fields" in field.schema) {
       const nestedFields = field.schema.fields ?? [];
-      repeaterNestedFieldIds.set(field.id, new Set(nestedFields.map((f) => f.id)));
+      repeaterNestedFieldIds.set(
+        field.id,
+        new Set(nestedFields.map((f) => f.id))
+      );
     }
   }
   return { topLevelFieldIds, repeaterNestedFieldIds };
@@ -58207,7 +58898,11 @@ function findMissingBindings(node, blockId, path24 = "layout") {
   }
   if ("children" in n && Array.isArray(n.children)) {
     for (let i = 0; i < n.children.length; i++) {
-      const childErrors = findMissingBindings(n.children[i], blockId, `${path24}.children[${i}]`);
+      const childErrors = findMissingBindings(
+        n.children[i],
+        blockId,
+        `${path24}.children[${i}]`
+      );
       errors.push(...childErrors);
     }
   }
@@ -58218,7 +58913,9 @@ function getMaxDepth(node, currentDepth = 0) {
   const n = node;
   if (!n.children || !Array.isArray(n.children)) return currentDepth;
   if (n.children.length === 0) return currentDepth;
-  return Math.max(...n.children.map((child) => getMaxDepth(child, currentDepth + 1)));
+  return Math.max(
+    ...n.children.map((child) => getMaxDepth(child, currentDepth + 1))
+  );
 }
 var CONTAINER_NODE_TYPES = ["section", "stack", "grid", "div", "inline"];
 function detectPotentialTruncation(node, maxAllowedDepth, currentDepth = 0, path24 = "layout") {
@@ -58233,7 +58930,12 @@ function detectPotentialTruncation(node, maxAllowedDepth, currentDepth = 0, path
   if (n.children && Array.isArray(n.children)) {
     n.children.forEach((child, i) => {
       truncatedPaths.push(
-        ...detectPotentialTruncation(child, maxAllowedDepth, currentDepth + 1, `${path24}.children[${i}]`)
+        ...detectPotentialTruncation(
+          child,
+          maxAllowedDepth,
+          currentDepth + 1,
+          `${path24}.children[${i}]`
+        )
       );
     });
   }
@@ -58248,14 +58950,20 @@ function formatValidationFeedback(errors, output) {
     if (truncatedPaths.length > 0) {
       lines.push("### DEPTH LIMIT WARNING");
       lines.push("");
-      lines.push(`The layout reached the maximum depth of ${MAX_LAYOUT_DEPTH} levels.`);
+      lines.push(
+        `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 path24 of truncatedPaths) {
         lines.push(`  \u26A0\uFE0F ${path24}`);
       }
       lines.push("");
-      lines.push("**FIX**: Flatten your layout structure or use $repeat for lists.");
-      lines.push("- Combine wrapper nodes where possible (e.g., section > stack > div \u2192 section > stack)");
+      lines.push(
+        "**FIX**: Flatten your layout structure or use $repeat for lists."
+      );
+      lines.push(
+        "- Combine wrapper nodes where possible (e.g., section > stack > div \u2192 section > stack)"
+      );
       lines.push("- Use $repeat instead of manual nesting for repeated items");
       lines.push(`- Current max depth: ${maxDepth}, limit: ${MAX_LAYOUT_DEPTH}`);
       lines.push("");
@@ -58264,13 +58972,19 @@ function formatValidationFeedback(errors, output) {
   if (errors.length === 0) {
     return lines.length > 0 ? lines.join("\n") : "";
   }
-  lines.push("## CRITICAL: Your output failed validation. You MUST fix these errors.");
+  lines.push(
+    "## CRITICAL: Your output failed validation. You MUST fix these errors."
+  );
   lines.push("");
   lines.push("Your previous output had the following problems:");
   lines.push("");
   const missingBindErrors = errors.filter((e) => e.message.includes("no $bind"));
-  const unusedFieldErrors = errors.filter((e) => e.message.includes("never used"));
-  const otherErrors = errors.filter((e) => !e.message.includes("no $bind") && !e.message.includes("never used"));
+  const unusedFieldErrors = errors.filter(
+    (e) => e.message.includes("never used")
+  );
+  const otherErrors = errors.filter(
+    (e) => !e.message.includes("no $bind") && !e.message.includes("never used")
+  );
   if (missingBindErrors.length > 0) {
     lines.push("### MISSING $bind ERRORS (nodes that display nothing)");
     lines.push("");
@@ -58278,16 +58992,22 @@ function formatValidationFeedback(errors, output) {
       lines.push(`\u274C ${error.message}`);
     }
     lines.push("");
-    lines.push("**FIX**: Every text, richText, media, button, and link node MUST have $bind.");
+    lines.push(
+      "**FIX**: Every text, richText, media, button, and link node MUST have $bind."
+    );
     lines.push("");
     lines.push("WRONG (displays nothing):");
     lines.push("```json");
-    lines.push('{ "type": "text", "props": { "as": "h1" }, "children": null, "$bind": null }');
+    lines.push(
+      '{ "type": "text", "props": { "as": "h1" }, "children": null, "$bind": null }'
+    );
     lines.push("```");
     lines.push("");
     lines.push("CORRECT (bound to field):");
     lines.push("```json");
-    lines.push('{ "type": "text", "props": { "as": "h1" }, "children": null, "$bind": { "from": "content.headline", "fallback": null, "transforms": null } }');
+    lines.push(
+      '{ "type": "text", "props": { "as": "h1" }, "children": null, "$bind": { "from": "content.headline", "fallback": null, "transforms": null } }'
+    );
     lines.push("```");
     lines.push("");
   }
@@ -58306,11 +59026,15 @@ function formatValidationFeedback(errors, output) {
     if (fieldNames.length > 0) {
       lines.push("**CHECKLIST - Add a binding for EACH of these fields:**");
       for (const field of fieldNames) {
-        lines.push(`- [ ] ${field} \u2192 text node with $bind: { from: "content.${field}" }`);
+        lines.push(
+          `- [ ] ${field} \u2192 text node with $bind: { from: "content.${field}" }`
+        );
       }
       lines.push("");
     }
-    lines.push("**COMMON MISTAKE**: Creating container nodes with `children: null` instead of actual bindings.");
+    lines.push(
+      "**COMMON MISTAKE**: Creating container nodes with `children: null` instead of actual bindings."
+    );
     lines.push("");
     lines.push("This is WRONG (container with no content inside):");
     lines.push("```json");
@@ -58320,12 +59044,18 @@ function formatValidationFeedback(errors, output) {
     lines.push("This is CORRECT (container with bound text node):");
     lines.push("```json");
     lines.push('{ "type": "inline", "children": [');
-    lines.push('  { "type": "text", "$bind": { "from": "content.fieldName", "fallback": null, "transforms": null }, "props": null, "$repeat": null, "$when": null, "children": null }');
+    lines.push(
+      '  { "type": "text", "$bind": { "from": "content.fieldName", "fallback": null, "transforms": null }, "props": null, "$repeat": null, "$when": null, "children": null }'
+    );
     lines.push("] }");
     lines.push("```");
     lines.push("");
-    lines.push("**FIX**: Every field you define MUST be used in a $bind somewhere in the layout.");
-    lines.push('If you have a field "highlight", you MUST have a node with $bind: { from: "content.highlight" }');
+    lines.push(
+      "**FIX**: Every field you define MUST be used in a $bind somewhere in the layout."
+    );
+    lines.push(
+      'If you have a field "highlight", you MUST have a node with $bind: { from: "content.highlight" }'
+    );
     lines.push("");
   }
   if (otherErrors.length > 0) {
@@ -60883,6 +61613,10 @@ Examples:
     }
   })
 );
+
+// src/cli/commands/style.ts
+init_buttons();
+init_site_styles();
 function buildStyleSelectionApplyInputFromOptions(options) {
   const baseSelectionVersion = Number(options.baseSelectionVersion);
   if (!Number.isInteger(baseSelectionVersion) || baseSelectionVersion < 0) {
@@ -60915,6 +61649,55 @@ function isStringRecord(value) {
   }
   return Object.values(value).every((entry) => typeof entry === "string");
 }
+function buildStyleCatalogListRows(styles = curatedSiteStyles, options = {}) {
+  const filteredStyles = options.siteStyleId ? styles.filter((style) => String(style.id) === options.siteStyleId) : styles;
+  return filteredStyles.map((style) => ({
+    siteStyleId: style.id,
+    name: style.name,
+    palettes: style.paletteVariantChoices.map((choice) => ({
+      id: choice.id,
+      label: findPaletteVariant(choice.id)?.name ?? choice.id
+    })),
+    buttonPersonalities: style.buttonPersonalityChoices.map((choice) => ({
+      id: choice.id,
+      label: findButtonPersonality(choice.id)?.name ?? choice.id
+    })),
+    headerLooks: style.recommendedHeaderLookIds.map((lookId) => ({
+      id: lookId,
+      label: findHeaderLook(lookId)?.label ?? lookId
+    })),
+    footerLooks: style.recommendedFooterLookIds.map((lookId) => ({
+      id: lookId,
+      label: findFooterLook(lookId)?.label ?? lookId
+    }))
+  }));
+}
+function formatStyleCatalogListRow(row) {
+  return [
+    row.siteStyleId,
+    row.name,
+    formatChoiceList(row.palettes),
+    formatChoiceList(row.buttonPersonalities),
+    formatChoiceList(row.headerLooks),
+    formatChoiceList(row.footerLooks)
+  ];
+}
+function formatChoiceList(choices) {
+  return choices.map((choice) => `${choice.id} (${choice.label})`).join(", ");
+}
+var listCommand8 = new Command("list").description("List curated site styles and compatible selection IDs").option("--site-style-id <id>", "Show one curated site style").action(
+  withErrorHandling(async (options, command) => {
+    const { output } = getOutputContext(command);
+    const rows = buildStyleCatalogListRows(curatedSiteStyles, options);
+    if (options.siteStyleId && rows.length === 0) {
+      output.error(`Unknown site style: ${options.siteStyleId}`);
+    }
+    output.table(
+      ["Site Style ID", "Name", "Palettes", "Buttons", "Header Looks", "Footer Looks"],
+      rows.map(formatStyleCatalogListRow)
+    );
+  })
+);
 var applyCommand = new Command("apply").description("Apply a curated site-style selection").requiredOption("--site-style-id <id>", "Site style ID, e.g. site-style:calm-studio").requiredOption("--base-selection-version <version>", "Current style selection version").option("--selection-id <id>", "Current style selection row ID").option("--button-personality-id <id>", "Button personality ID").option("--palette-variant-id <id>", "Palette variant ID").option("--palette-overrides <json>", "JSON object of palette token overrides").option("--header-look-id <id>", "Header look ID").option("--footer-look-id <id>", "Footer look ID").action(
   withErrorHandling(async (options, command) => {
     const { output, client } = createCommandContext(command);
@@ -60935,7 +61718,7 @@ var styleCommand = new Command("style").description("Manage curated site styles"
 Examples:
   $ riverbankcms style apply --site-style-id site-style:calm-studio --base-selection-version 3
   $ riverbankcms style apply --site-style-id site-style:calm-studio --base-selection-version 3 --palette-variant-id soft-natural-sage
-`).addCommand(applyCommand);
+`).addCommand(listCommand8).addCommand(applyCommand);
 
 // src/cli/index.ts
 config({ path: ".env.local" });