@riverbankcms/sdk 0.70.2 → 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])
     );
   }
@@ -37529,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();
@@ -37582,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];
@@ -37616,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) {
@@ -52226,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",
@@ -52389,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({
@@ -52406,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,
@@ -52420,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) {
@@ -52564,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,
@@ -52582,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"],
@@ -52653,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({
@@ -52672,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,
@@ -52688,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
@@ -52763,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,
@@ -54249,7 +54774,7 @@ var SimpleCache = class {
 };
 
 // src/version.ts
-var SDK_VERSION = "0.70.2";
+var SDK_VERSION = "0.70.3";
 
 // src/client/error.ts
 var RiverbankApiError = class _RiverbankApiError extends Error {
@@ -60883,6 +61408,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 +61444,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 +61513,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" });