@riverbankcms/sdk 0.70.0 → 0.70.3

package/dist/cli/index.mjs

@@ -3402,7 +3402,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 +3425,7 @@ var init_personalities = __esm({
       brushedWash,
       showtimePill
     ];
-    new Map(
+    personalitiesById = new Map(
       buttonPersonalities.map((p) => [p.id, p])
     );
   }
@@ -5115,7 +5118,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 +5148,7 @@ var init_variants = __esm({
       softNaturalStone,
       softNaturalWatercolor
     ];
-    new Map(
+    paletteVariantsById = new Map(
       paletteVariants.map((v) => [v.id, v])
     );
   }
@@ -5407,7 +5413,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 +5496,7 @@ var init_headerLooks = __esm({
         compile: floatingGlassHeader
       }
     ];
-    new Map(
+    headerLooksById = new Map(
       headerLookCatalog.map((look) => [look.id, look])
     );
   }
@@ -5556,7 +5565,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 +5587,7 @@ var init_footerLooks = __esm({
         compile: brandTwoBandFooter
       }
     ];
-    new Map(
+    footerLooksById = new Map(
       footerLookCatalog.map((look) => [look.id, look])
     );
   }
@@ -19328,6 +19340,24 @@ var ENDPOINT_DEFINITIONS = {
       "server:internal_error"
     ]
   },
+  setServiceSpecificAvailability: {
+    path: "/sites/{siteId}/bookings/resources/{resourceId}/service-availability",
+    method: "PUT",
+    auth: "user",
+    responseKind: "json",
+    errors: [
+      "validation:invalid_input",
+      "resource:not_found",
+      "server:internal_error"
+    ]
+  },
+  deleteServiceSpecificAvailability: {
+    path: "/sites/{siteId}/bookings/resources/{resourceId}/service-availability/{scheduleId}",
+    method: "DELETE",
+    auth: "user",
+    responseKind: "json",
+    errors: ["resource:not_found", "server:internal_error"]
+  },
   listBlackouts: {
     path: "/sites/{siteId}/bookings/resources/{resourceId}/blackouts",
     method: "GET",
@@ -20963,6 +20993,20 @@ var ENDPOINT_DEFINITIONS = {
     auth: "user",
     responseKind: "json"
   },
+  applySiteStyleSelection: {
+    path: "/sites/{siteId}/theme/style-selection/apply",
+    method: "POST",
+    tags: [TAG_TEMPLATES.siteCollection, TAG_TEMPLATES.siteTheme],
+    auth: "user",
+    errors: [
+      "validation:invalid_input",
+      "auth:forbidden",
+      "resource:not_found",
+      "resource:conflict",
+      "server:internal_error"
+    ],
+    responseKind: "json"
+  },
   saveSiteChromeLookSelection: {
     path: "/sites/{siteId}/theme/site-chrome-look",
     method: "POST",
@@ -23706,6 +23750,13 @@ var ENDPOINT_DEFINITIONS = {
     auth: "service",
     responseKind: "json"
   },
+  sdkApplySiteStyleSelection: {
+    path: "/sdk/{siteId}/theme/style-selection/apply",
+    method: "POST",
+    auth: "service",
+    responseKind: "json",
+    errors: ["validation:invalid_input", "resource:not_found", "resource:conflict", "server:internal_error"]
+  },
   sdkUpsertFooter: {
     path: "/sdk/{siteId}/footer",
     method: "POST",
@@ -34679,11 +34730,26 @@ var appointmentSetupWeeklyWindowDraftSchema = z.object({
   startTime: z.string(),
   endTime: z.string()
 });
+var appointmentSetupStartTimePolicyDraftSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("automatic_spacing") }),
+  z.object({
+    kind: z.literal("regular_interval"),
+    intervalMinutes: z.union([
+      z.literal(10),
+      z.literal(15),
+      z.literal(20),
+      z.literal(30),
+      z.literal(45),
+      z.literal(60)
+    ])
+  })
+]);
 var appointmentSetupAvailabilityDraftSchema = z.object({
   kind: z.literal("weekly_windows"),
   resourceRef: appointmentSetupRefSchema,
   serviceRef: appointmentSetupRefSchema.nullable(),
-  windows: z.array(appointmentSetupWeeklyWindowDraftSchema)
+  windows: z.array(appointmentSetupWeeklyWindowDraftSchema),
+  startTimePolicy: appointmentSetupStartTimePolicyDraftSchema.optional()
 });
 var APPOINTMENT_DEFAULT_MIN_LEAD_MINUTES_MAX = 28 * 24 * 60;
 var APPOINTMENT_DEFAULT_MAX_BOOKING_NOTICE_MINUTES_MAX = 10 * 365 * 24 * 60;
@@ -36532,11 +36598,51 @@ function createFormOperations(http) {
 }
 
 // src/client/management/theme.ts
+function buildApplySiteStyleSelectionCommand(input) {
+  return {
+    type: "applySiteStyleSelection",
+    ref: input.siteStyleId,
+    input: {
+      siteStyleId: input.siteStyleId,
+      buttonPersonalityId: input.buttonPersonalityId,
+      paletteVariantId: input.paletteVariantId,
+      paletteOverrides: input.paletteOverrides,
+      headerLookId: input.headerLookId,
+      footerLookId: input.footerLookId,
+      baseSelectionVersion: input.baseSelectionVersion
+    }
+  };
+}
+function applySiteStyleSelectionBodyFromCommand(command, selectionId) {
+  const baseSelectionVersion = command.input.baseSelectionVersion;
+  if (baseSelectionVersion === void 0) {
+    throw new Error("applySiteStyleSelection command is missing baseSelectionVersion");
+  }
+  return {
+    siteStyleId: command.input.siteStyleId,
+    buttonPersonalityId: command.input.buttonPersonalityId,
+    paletteVariantId: command.input.paletteVariantId,
+    paletteOverrides: command.input.paletteOverrides,
+    headerLookId: command.input.headerLookId,
+    footerLookId: command.input.footerLookId,
+    baseSelectionVersion,
+    selectionId
+  };
+}
 function createThemeOperations(http) {
   return {
     async upsert(input) {
       const result = await http.post("/theme", input);
       return result;
+    },
+    async applySelection(input) {
+      const command = buildApplySiteStyleSelectionCommand(input);
+      const body = applySiteStyleSelectionBodyFromCommand(command, input.selectionId);
+      const result = await http.post(
+        "/theme/style-selection/apply",
+        body
+      );
+      return result;
     }
   };
 }
@@ -37435,14 +37541,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();
@@ -37488,6 +37594,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];
@@ -37522,40 +37636,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) {
@@ -44215,6 +44295,7 @@ var recipeIdentifierSchema = z.string().regex(
   "Use lowercase letters, numbers, and hyphens."
 );
 var currencySchema = z.string().regex(/^[A-Z]{3}$/u);
+var hexColorSchema2 = z.string().regex(/^#[0-9a-f]{6}$/u, "Hex must be #RRGGBB (lowercase)");
 var isoDateTimeSchema = z.string().datetime({ offset: true });
 var ianaTimezoneSchema = z.string().trim().min(1).max(64).refine(isValidIanaTimezone, {
   message: "Invalid IANA timezone"
@@ -44364,11 +44445,20 @@ var configureSiteIdentityCommandSchema = z.object({
     seoIndexing: z.enum(["index", "noindex", "noindex_demo"]).optional()
   }).strict()
 }).strict();
-var applySiteStyleCommandSchema = z.object({
-  type: z.literal("applySiteStyle"),
+var styleSelectionVersionSchema = nonNegativeIntegerSchema;
+var styleCatalogIdSchema = z.string().trim().min(1);
+var paletteOverridesSchema2 = z.record(z.string().trim().min(1), hexColorSchema2).readonly();
+var applySiteStyleSelectionCommandSchema = z.object({
+  type: z.literal("applySiteStyleSelection"),
   ref: siteStyleRefSchema,
   input: z.object({
-    styleKey: z.string().min(1)
+    siteStyleId: siteStyleRefSchema,
+    buttonPersonalityId: styleCatalogIdSchema.nullable(),
+    paletteVariantId: styleCatalogIdSchema.nullable(),
+    paletteOverrides: paletteOverridesSchema2.nullable(),
+    headerLookId: styleCatalogIdSchema.nullable(),
+    footerLookId: styleCatalogIdSchema.nullable(),
+    baseSelectionVersion: styleSelectionVersionSchema.optional()
   }).strict()
 }).strict();
 var upsertMediaAssetCommandSchema = z.object({
@@ -45097,7 +45187,7 @@ var configureAppointmentAvailabilityCommandSchema = z.object({
 var siteCommandSchema = z.discriminatedUnion("type", [
   configureSiteIdentityCommandSchema,
   configureBookingSettingsCommandSchema,
-  applySiteStyleCommandSchema,
+  applySiteStyleSelectionCommandSchema,
   upsertMediaAssetCommandSchema,
   upsertPageCommandSchema,
   upsertBlockTreeCommandSchema,
@@ -45238,7 +45328,7 @@ var siteCommandMetadata = {
     capability: "bookings.settings.write",
     support: "supported"
   },
-  applySiteStyle: {
+  applySiteStyleSelection: {
     scope: "style",
     risk: "low",
     writeSemantics: "upsert",
@@ -45247,7 +45337,7 @@ var siteCommandMetadata = {
     conflictPolicy: "update_existing",
     previewability: "static_preview",
     allowedRuntimes: ["development", "staging", "demo", "production"],
-    intendedExposure: ["recipe", "sdk_cli", "onboarding_planner", "internal_apply"],
+    intendedExposure: ["recipe", "sdk_cli", "onboarding_planner", "ai_proposal", "internal_apply"],
     capability: "theme.write",
     support: "supported"
   },
@@ -45812,7 +45902,7 @@ function commandRefContributions(command) {
     case "configureSiteIdentity":
     case "configureBookingSettings":
       return { provides: [], requires: [] };
-    case "applySiteStyle":
+    case "applySiteStyleSelection":
       return { provides: [{ ref: command.ref, field: "ref" }], requires: [] };
     case "upsertMediaAsset":
     case "upsertPage":
@@ -46236,7 +46326,7 @@ function matchSiteCommand(command, match) {
       return match(command);
     case "configureBookingSettings":
       return match(command);
-    case "applySiteStyle":
+    case "applySiteStyleSelection":
       return match(command);
     case "upsertMediaAsset":
       return match(command);
@@ -52122,6 +52212,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",
@@ -52285,8 +52772,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({
@@ -52302,11 +52789,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,
@@ -52316,16 +52817,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) {
@@ -52460,15 +52995,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,
@@ -52478,16 +53027,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"],
@@ -52549,9 +53130,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({
@@ -52568,12 +53149,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,
@@ -52584,14 +53190,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
@@ -52659,13 +53278,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,
@@ -54145,7 +54774,7 @@ var SimpleCache = class {
 };
 
 // src/version.ts
-var SDK_VERSION = "0.70.0";
+var SDK_VERSION = "0.70.3";
 
 // src/client/error.ts
 var RiverbankApiError = class _RiverbankApiError extends Error {
@@ -60780,6 +61409,112 @@ 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) {
+    throw new Error("--base-selection-version must be a non-negative integer");
+  }
+  return {
+    siteStyleId: options.siteStyleId,
+    buttonPersonalityId: options.buttonPersonalityId ?? null,
+    paletteVariantId: options.paletteVariantId ?? null,
+    paletteOverrides: parsePaletteOverrides(options.paletteOverrides),
+    headerLookId: options.headerLookId ?? null,
+    footerLookId: options.footerLookId ?? null,
+    baseSelectionVersion,
+    selectionId: options.selectionId ?? null
+  };
+}
+function parsePaletteOverrides(value) {
+  if (value === void 0 || value.trim() === "") {
+    return null;
+  }
+  const parsed = JSON.parse(value);
+  if (!isStringRecord(parsed)) {
+    throw new Error("--palette-overrides must be a JSON object with string values");
+  }
+  return parsed;
+}
+function isStringRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  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);
+    const input = buildStyleSelectionApplyInputFromOptions(options);
+    const commandIr = buildApplySiteStyleSelectionCommand(input);
+    output.info(`Applying site style: ${input.siteStyleId}`);
+    const result = await client.theme.applySelection(input);
+    output.success("Site style applied", {
+      command: commandIr,
+      themeId: result.themeId,
+      selectionId: result.selectionId,
+      selectionVersion: result.selectionVersion,
+      savedAt: result.savedAt
+    });
+  })
+);
+var styleCommand = new Command("style").description("Manage curated site styles").addHelpText("after", `
+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(listCommand8).addCommand(applyCommand);
+
 // src/cli/index.ts
 config({ path: ".env.local" });
 config({ path: ".env" });
@@ -60829,6 +61564,7 @@ program.addCommand(auditCommand);
 program.addCommand(compareCommand);
 program.addCommand(eventCommand);
 program.addCommand(courseCommand2);
+program.addCommand(styleCommand);
 program.addCommand(manifestCommand);
 program.addCommand(envCommand);
 program.addCommand(migrateCommand);