storyblok 4.17.2 → 4.18.0-alpha.0

package/dist/index.mjs

@@ -7,7 +7,7 @@ import { homedir } from 'node:os';
 import { loadConfig as loadConfig$1, SUPPORTED_EXTENSIONS } from 'c12';
 import chalk from 'chalk';
 import { readPackageUp } from 'read-package-up';
-import { Command } from 'commander';
+import { Command, Option } from 'commander';
 import { MultiBar, Presets } from 'cli-progress';
 import { Spinner } from '@topcli/spinner';
 import fs, { mkdir, writeFile, access, constants, readFile as readFile$1, appendFile, readdir, unlink } from 'node:fs/promises';
@@ -26,6 +26,7 @@ import { Octokit } from 'octokit';
 import { pipeline as pipeline$1 } from 'node:stream/promises';
 import { Buffer } from 'node:buffer';
 import Storyblok from 'storyblok-js-client';
+import { createTwoFilesPatch } from 'diff';
 
 const commands = {
   LOGIN: "login",
@@ -41,7 +42,8 @@ const commands = {
   LOGS: "logs",
   REPORTS: "reports",
   ASSETS: "assets",
-  STORIES: "stories"
+  STORIES: "stories",
+  SCHEMA: "schema"
 };
 const colorPalette = {
   PRIMARY: "#8d60ff",
@@ -61,7 +63,8 @@ const colorPalette = {
   LOGS: "#4ade80",
   REPORTS: "#4ade80",
   ASSETS: "#f97316",
-  STORIES: "#a185ff"
+  STORIES: "#a185ff",
+  SCHEMA: "#e91e63"
 };
 const regions = {
   EU: "eu",
@@ -1005,11 +1008,11 @@ function requireAuthentication(state, verbose = false) {
   return true;
 }
 
-const toCamelCase = (str) => {
+const toCamelCase$1 = (str) => {
   return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase()).replace(/_/g, "").replace(/-([a-z])/g, (_, letter) => letter.toUpperCase()).replace(/[^a-z0-9]([a-z])/gi, (_, letter) => letter.toUpperCase()).replace(/[^a-z0-9]/gi, "");
 };
 const toPascalCase = (str) => {
-  const camelCase = toCamelCase(str);
+  const camelCase = toCamelCase$1(str);
   return camelCase ? camelCase[0].toUpperCase() + camelCase.slice(1) : camelCase;
 };
 const capitalize = (str) => {
@@ -1107,6 +1110,25 @@ function getPackageJson() {
   return packageJson$1;
 }
 
+async function fetchAllPages(fetchFunction, extractDataFunction) {
+  const items = [];
+  let page = 1;
+  while (true) {
+    const { data, response } = await fetchFunction(page);
+    const totalHeader = response.headers.get("total");
+    const fetchedItems = extractDataFunction(data);
+    items.push(...fetchedItems);
+    if (!totalHeader) {
+      return items;
+    }
+    const total = Number(totalHeader);
+    if (Number.isNaN(total) || items.length >= total || fetchedItems.length === 0) {
+      return items;
+    }
+    page++;
+  }
+}
+
 const __filename$1 = fileURLToPath(import.meta.url);
 const __dirname$1 = dirname(__filename$1);
 function isRegion(value) {
@@ -1195,6 +1217,10 @@ class UI {
       this.br();
     }
   }
+  /** Plain console.log passthrough — use for preformatted or multi-line text. */
+  log(message) {
+    this.console?.log(message);
+  }
   list(items) {
     for (const item of items) {
       this.console?.log(`  ${item}`);
@@ -2101,14 +2127,14 @@ async function performInteractiveLogin(options) {
   }
 }
 
-const program$e = getProgram();
+const program$f = getProgram();
 const allRegionsText = Object.values(regions).join(",");
-program$e.command(commands.LOGIN).description("Login to the Storyblok CLI").option("-t, --token <token>", "Token to login directly without questions, like for CI environments").option(
+program$f.command(commands.LOGIN).description("Login to the Storyblok CLI").option("-t, --token <token>", "Token to login directly without questions, like for CI environments").option(
   "-r, --region <region>",
   `The region you would like to work in. Please keep in mind that the region must match the region of your space. This region flag will be used for the other cli's commands. You can use the values: ${allRegionsText}.`
 ).action(async (options) => {
   konsola.title(`${commands.LOGIN}`, colorPalette.LOGIN);
-  const verbose = program$e.opts().verbose;
+  const verbose = program$f.opts().verbose;
   const { token, region } = options;
   const { state, updateSession, persistCredentials } = session();
   if (state.isLoggedIn && !state.envLogin) {
@@ -2166,10 +2192,10 @@ program$e.command(commands.LOGIN).description("Login to the Storyblok CLI").opti
   konsola.br();
 });
 
-const program$d = getProgram();
-program$d.command(commands.LOGOUT).description("Logout from the Storyblok CLI").action(async () => {
+const program$e = getProgram();
+program$e.command(commands.LOGOUT).description("Logout from the Storyblok CLI").action(async () => {
   konsola.title(`${commands.LOGOUT}`, colorPalette.LOGOUT);
-  const verbose = program$d.opts().verbose;
+  const verbose = program$e.opts().verbose;
   try {
     const { state } = session();
     if (!state.isLoggedIn || !state.password || !state.region) {
@@ -2216,10 +2242,10 @@ async function openSignupInBrowser(url) {
   }
 }
 
-const program$c = getProgram();
-program$c.command(commands.SIGNUP).description("Sign up for Storyblok").action(async () => {
+const program$d = getProgram();
+program$d.command(commands.SIGNUP).description("Sign up for Storyblok").action(async () => {
   konsola.title(`${commands.SIGNUP}`, colorPalette.SIGNUP);
-  const verbose = program$c.opts().verbose;
+  const verbose = program$d.opts().verbose;
   const { state } = session();
   if (state.isLoggedIn && !state.envLogin) {
     konsola.ok(`You are already logged in. If you want to signup with a different account, please logout first.`);
@@ -2240,10 +2266,10 @@ program$c.command(commands.SIGNUP).description("Sign up for Storyblok").action(a
   konsola.br();
 });
 
-const program$b = getProgram();
-program$b.command(commands.USER).description("Get the current user").action(async () => {
+const program$c = getProgram();
+program$c.command(commands.USER).description("Get the current user").action(async () => {
   konsola.title(`${commands.USER}`, colorPalette.USER);
-  const verbose = program$b.opts().verbose;
+  const verbose = program$c.opts().verbose;
   const { state } = session();
   if (!requireAuthentication(state)) {
     return;
@@ -2271,48 +2297,24 @@ program$b.command(commands.USER).description("Get the current user").action(asyn
   konsola.br();
 });
 
-const program$a = getProgram();
-const componentsCommand = program$a.command(commands.COMPONENTS).alias("comp").description(`Manage your space's block schema`);
+const program$b = getProgram();
+const componentsCommand = program$b.command(commands.COMPONENTS).alias("comp").description(`Manage your space's block schema`);
 
 const DEFAULT_COMPONENTS_FILENAME = "components";
-const DEFAULT_GROUPS_FILENAME = "groups";
+const DEFAULT_GROUPS_FILENAME$1 = "groups";
 const DEFAULT_PRESETS_FILENAME = "presets";
 const DEFAULT_TAGS_FILENAME = "tags";
 
-async function fetchAllPages(fetchFunction, extractDataFunction) {
-  const items = [];
-  let page = 1;
-  while (true) {
-    const { data, response } = await fetchFunction(page);
-    const totalHeader = response.headers.get("total");
-    const fetchedItems = extractDataFunction(data);
-    items.push(...fetchedItems);
-    if (!totalHeader) {
-      return items;
-    }
-    const total = Number(totalHeader);
-    if (Number.isNaN(total) || items.length >= total || fetchedItems.length === 0) {
-      return items;
-    }
-    page++;
-  }
-}
-
 const fetchComponents = async (spaceId) => {
   try {
     const client = getMapiClient();
-    return await fetchAllPages(
-      (page) => client.components.list({
-        path: {
-          space_id: Number(spaceId)
-        },
-        query: {
-          page
-        },
-        throwOnError: true
-      }),
-      (data) => data?.components ?? []
-    );
+    const { data } = await client.components.list({
+      path: {
+        space_id: Number(spaceId)
+      },
+      throwOnError: true
+    });
+    return data?.components ?? [];
   } catch (error) {
     handleAPIError("pull_components", error);
   }
@@ -2320,19 +2322,16 @@ const fetchComponents = async (spaceId) => {
 const fetchComponent = async (spaceId, componentName) => {
   try {
     const client = getMapiClient();
-    const matches = await fetchAllPages(
-      (page) => client.components.list({
-        path: {
-          space_id: Number(spaceId)
-        },
-        query: {
-          page,
-          search: componentName
-        },
-        throwOnError: true
-      }),
-      (data) => data?.components ?? []
-    );
+    const { data } = await client.components.list({
+      path: {
+        space_id: Number(spaceId)
+      },
+      query: {
+        search: componentName
+      },
+      throwOnError: true
+    });
+    const matches = data?.components ?? [];
     return matches.find((c) => c.name === componentName);
   } catch (error) {
     handleAPIError("pull_components", error, `Failed to fetch component ${componentName}`);
@@ -2399,7 +2398,7 @@ const saveComponentsToFiles = async (space, spaceData, options) => {
           const presetsFilePath = join(resolvedPath, suffix ? `${sanitizedName}.${DEFAULT_PRESETS_FILENAME}.${suffix}.json` : `${sanitizedName}.${DEFAULT_PRESETS_FILENAME}.json`);
           await saveToFile(presetsFilePath, JSON.stringify(componentPresets, null, 2));
         }
-        const groupsFilePath = join(resolvedPath, suffix ? `${DEFAULT_GROUPS_FILENAME}.${suffix}.json` : `${DEFAULT_GROUPS_FILENAME}.json`);
+        const groupsFilePath = join(resolvedPath, suffix ? `${DEFAULT_GROUPS_FILENAME$1}.${suffix}.json` : `${DEFAULT_GROUPS_FILENAME$1}.json`);
         await saveToFile(groupsFilePath, JSON.stringify(groups, null, 2));
         const internalTagsFilePath = join(resolvedPath, suffix ? `${DEFAULT_TAGS_FILENAME}.${suffix}.json` : `${DEFAULT_TAGS_FILENAME}.json`);
         await saveToFile(internalTagsFilePath, JSON.stringify(internalTags, null, 2));
@@ -2409,7 +2408,7 @@ const saveComponentsToFiles = async (space, spaceData, options) => {
     const componentsFilePath = join(resolvedPath, suffix ? `${filename}.${suffix}.json` : `${filename}.json`);
     await saveToFile(componentsFilePath, JSON.stringify(components, null, 2));
     if (groups.length > 0) {
-      const groupsFilePath = join(resolvedPath, suffix ? `${DEFAULT_GROUPS_FILENAME}.${suffix}.json` : `${DEFAULT_GROUPS_FILENAME}.json`);
+      const groupsFilePath = join(resolvedPath, suffix ? `${DEFAULT_GROUPS_FILENAME$1}.${suffix}.json` : `${DEFAULT_GROUPS_FILENAME$1}.json`);
       await saveToFile(groupsFilePath, JSON.stringify(groups, null, 2));
     }
     if (presets.length > 0) {
@@ -2425,6 +2424,21 @@ const saveComponentsToFiles = async (space, spaceData, options) => {
   }
 };
 
+function isSchemaField$1(value) {
+  return typeof value === "object" && value !== null && "type" in value;
+}
+function toWritableSchema(schema) {
+  if (!schema) {
+    return void 0;
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (isSchemaField$1(value)) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
 const pushComponent = async (space, component) => {
   try {
     const client = getMapiClient();
@@ -2459,10 +2473,23 @@ const updateComponent = async (space, componentId, component) => {
   }
 };
 const upsertComponent = async (space, component, existingId) => {
+  const { name, display_name, schema, is_root, is_nestable, component_group_uuid, color, icon, preview_field, internal_tag_ids } = component;
+  const payload = {
+    name,
+    display_name,
+    schema: toWritableSchema(schema),
+    is_root,
+    is_nestable,
+    component_group_uuid: component_group_uuid ?? void 0,
+    color: color ?? void 0,
+    icon: icon ?? void 0,
+    preview_field: preview_field ?? void 0,
+    internal_tag_ids
+  };
   if (existingId) {
-    return await updateComponent(space, existingId, component);
+    return await updateComponent(space, existingId, payload);
   } else {
-    return await pushComponent(space, component);
+    return await pushComponent(space, payload);
   }
 };
 const pushComponentGroup = async (space, componentGroup) => {
@@ -2565,7 +2592,7 @@ const pushComponentInternalTag = async (space, componentInternalTag) => {
       path: {
         space_id: Number(space)
       },
-      body: componentInternalTag,
+      body: { internal_tag: componentInternalTag },
       throwOnError: true
     });
     return data.internal_tag;
@@ -2580,7 +2607,7 @@ const updateComponentInternalTag = async (space, tagId, componentInternalTag) =>
       path: {
         space_id: Number(space)
       },
-      body: componentInternalTag,
+      body: { internal_tag: componentInternalTag },
       throwOnError: true
     });
     return data.internal_tag;
@@ -2635,7 +2662,7 @@ async function readSeparateFiles$1(resolvedPath, suffix) {
   });
   for (const file of filteredFiles) {
     const filePath = join(resolvedPath, file);
-    if (file === `${DEFAULT_GROUPS_FILENAME}.json` || file === `${DEFAULT_GROUPS_FILENAME}.${suffix}.json`) {
+    if (file === `${DEFAULT_GROUPS_FILENAME$1}.json` || file === `${DEFAULT_GROUPS_FILENAME$1}.${suffix}.json`) {
       const result = await readJsonFile(filePath);
       if (result.error) {
         handleFileSystemError("read", result.error);
@@ -2687,7 +2714,7 @@ async function readConsolidatedFiles$1(resolvedPath, suffix) {
     );
   }
   const [groupsResult, presetsResult, tagsResult] = await Promise.all([
-    readJsonFile(join(resolvedPath, suffix ? `${DEFAULT_GROUPS_FILENAME}.${suffix}.json` : `${DEFAULT_GROUPS_FILENAME}.json`)),
+    readJsonFile(join(resolvedPath, suffix ? `${DEFAULT_GROUPS_FILENAME$1}.${suffix}.json` : `${DEFAULT_GROUPS_FILENAME$1}.json`)),
     readJsonFile(join(resolvedPath, suffix ? `${DEFAULT_PRESETS_FILENAME}.${suffix}.json` : `${DEFAULT_PRESETS_FILENAME}.json`)),
     readJsonFile(join(resolvedPath, suffix ? `${DEFAULT_TAGS_FILENAME}.${suffix}.json` : `${DEFAULT_TAGS_FILENAME}.json`))
   ]);
@@ -3945,8 +3972,8 @@ const saveLanguagesToFile = async (space, internationalizationOptions, options)
   }
 };
 
-const program$9 = getProgram();
-const languagesCommand = program$9.command(commands.LANGUAGES).alias("lang").description(`Manage your space's languages`);
+const program$a = getProgram();
+const languagesCommand = program$a.command(commands.LANGUAGES).alias("lang").description(`Manage your space's languages`);
 const pullCmd$3 = languagesCommand.command("pull").description(`Download your space's languages schema as json`).option("-f, --filename <filename>", "filename to save the file as <filename>.<suffix>.json").option("--su, --suffix <suffix>", "suffix to add to the file name (e.g. languages.<suffix>.json). By default, the space ID is used.").option("-s, --space <space>", "space ID");
 pullCmd$3.action(async (options, command) => {
   konsola.title(`${commands.LANGUAGES}`, colorPalette.LANGUAGES);
@@ -3992,8 +4019,8 @@ pullCmd$3.action(async (options, command) => {
   konsola.br();
 });
 
-const program$8 = getProgram();
-const migrationsCommand = program$8.command(commands.MIGRATIONS).alias("mig").description(`Manage your space's migrations`);
+const program$9 = getProgram();
+const migrationsCommand = program$9.command(commands.MIGRATIONS).alias("mig").description(`Manage your space's migrations`);
 
 const getMigrationTemplate = () => {
   return `export default function (block) {
@@ -5020,8 +5047,8 @@ rollbackCmd.action(async (migrationFile, _options, command) => {
   }
 });
 
-const program$7 = getProgram();
-const typesCommand = program$7.command(commands.TYPES).alias("ts").description(`Generate types d.ts for your component schemas`);
+const program$8 = getProgram();
+const typesCommand = program$8.command(commands.TYPES).alias("ts").description(`Generate types d.ts for your component schemas`);
 
 const getAssetJSONSchema = (title) => ({
   $id: "#/asset",
@@ -5632,7 +5659,7 @@ const getPropertyTypeAnnotation = (property, prefix, suffix) => {
   }
 };
 function getStoryType(property, prefix, suffix) {
-  return `${STORY_TYPE}<${prefix ?? ""}${capitalize(toCamelCase(property))}${suffix ?? ""}>`;
+  return `${STORY_TYPE}<${prefix ?? ""}${capitalize(toCamelCase$1(property))}${suffix ?? ""}>`;
 }
 const getComponentType = (componentName, options) => {
   const prefix = options.typePrefix ?? "";
@@ -6157,8 +6184,8 @@ generateCmd.action(async (options, command) => {
   }
 });
 
-const program$6 = getProgram();
-const datasourcesCommand = program$6.command(commands.DATASOURCES).alias("ds").description(`Manage your space's datasources`);
+const program$7 = getProgram();
+const datasourcesCommand = program$7.command(commands.DATASOURCES).alias("ds").description(`Manage your space's datasources`);
 
 const fetchDatasourceEntries = async (spaceId, datasourceId) => {
   try {
@@ -6709,13 +6736,13 @@ async function promptForLogin(verbose) {
     return null;
   }
 }
-const program$5 = getProgram();
-program$5.command(`${commands.CREATE} [project-path]`).alias("c").description(`Scaffold a new project using Storyblok`).option("-t, --template <template>", "technology starter template").option("-b, --blueprint <blueprint>", "[DEPRECATED] use --template instead").option("--skip-space", "skip space creation").option("--token <token>", "Storyblok access token (skip space creation and use this token)").option(
+const program$6 = getProgram();
+program$6.command(`${commands.CREATE} [project-path]`).alias("c").description(`Scaffold a new project using Storyblok`).option("-t, --template <template>", "technology starter template").option("-b, --blueprint <blueprint>", "[DEPRECATED] use --template instead").option("--skip-space", "skip space creation").option("--token <token>", "Storyblok access token (skip space creation and use this token)").option(
   "-r, --region <region>",
   `The region to apply to the generated project template (does not affect space creation).`
 ).action(async (projectPath, options) => {
   konsola.title(`${commands.CREATE}`, colorPalette.CREATE);
-  const verbose = program$5.opts().verbose;
+  const verbose = program$6.opts().verbose;
   const { template, blueprint, token } = options;
   if (options.region && !isRegion(options.region)) {
     handleError(new CommandError(`The provided region: ${options.region} is not valid. Please use one of the following values: ${Object.values(regions).join(" | ")}`));
@@ -6934,8 +6961,8 @@ program$5.command(`${commands.CREATE} [project-path]`).alias("c").description(`S
   konsola.br();
 });
 
-const program$4 = getProgram();
-const logsCommand = program$4.command(commands.LOGS).alias("lg").description(`Inspect and manage logs.`);
+const program$5 = getProgram();
+const logsCommand = program$5.command(commands.LOGS).alias("lg").description(`Inspect and manage logs.`);
 
 const listCmd$1 = logsCommand.command("list").description("List logs").option("-s, --space <space>", "space ID");
 listCmd$1.action(async (_options, command) => {
@@ -6960,8 +6987,8 @@ pruneCmd$1.action(async (options, command) => {
   ui.info(`Deleted ${deletedFilesCount} log file${deletedFilesCount === 1 ? "" : "s"}`);
 });
 
-const program$3 = getProgram();
-const reportsCommand = program$3.command(commands.REPORTS).alias("rp").description("Inspect and manage reports.");
+const program$4 = getProgram();
+const reportsCommand = program$4.command(commands.REPORTS).alias("rp").description("Inspect and manage reports.");
 
 const listCmd = reportsCommand.command("list").description("List reports").option("-s, --space <space>", "space ID");
 listCmd.action(async (_options, command) => {
@@ -6986,8 +7013,8 @@ pruneCmd.action(async (options, command) => {
   ui.info(`Deleted ${deletedFilesCount} report file${deletedFilesCount === 1 ? "" : "s"}`);
 });
 
-const program$2 = getProgram();
-const assetsCommand = program$2.command(commands.ASSETS).description(`Manage your space's assets`);
+const program$3 = getProgram();
+const assetsCommand = program$3.command(commands.ASSETS).description(`Manage your space's assets`);
 
 const fetchAssets = async ({ spaceId, params }) => {
   try {
@@ -7177,7 +7204,7 @@ const isRemoteSource = (assetBinaryPath) => {
     return false;
   }
 };
-const isValidManifestEntry = (entry) => Boolean(typeof entry.old_id === "number" && typeof entry.new_id === "number" && entry.old_filename && entry.new_filename);
+const isValidManifestEntry = (entry) => Boolean(typeof entry.old_id === "number" && typeof entry.new_id === "number" && entry.new_filename);
 const loadAssetMap = async (manifestFile) => {
   const manifest = await loadManifest(manifestFile);
   const entries = manifest.filter(isValidManifestEntry).map((e) => [
@@ -7878,8 +7905,8 @@ const traverseAndMapBySchema = (data, {
   const dataNew = { ...data };
   for (const [fieldName, fieldValue] of Object.entries(data)) {
     const fieldSchema = schema[fieldName.replace(/__i18n__.*/, "")];
-    const fieldType = fieldSchema && typeof fieldSchema === "object" && "type" in fieldSchema && fieldSchema.type;
-    const fieldRefMapper = typeof fieldType === "string" && fieldRefMappers2[fieldType];
+    const fieldType = fieldSchema && typeof fieldSchema === "object" && "type" in fieldSchema ? fieldSchema.type : void 0;
+    const fieldRefMapper = typeof fieldType === "string" ? fieldRefMappers2[fieldType] : void 0;
     if (fieldRefMapper) {
       dataNew[fieldName] = fieldRefMapper(fieldValue, {
         schema: fieldSchema,
@@ -7944,6 +7971,9 @@ const richtextFieldRefMapper = (data, { schemas, maps, fieldRefMappers: fieldRef
   fieldRefMappers: fieldRefMappers2
 });
 const multilinkFieldRefMapper = (data, { maps }) => {
+  if (!data || typeof data !== "object") {
+    return data;
+  }
   if (data.linktype !== "story") {
     return data;
   }
@@ -7963,6 +7993,9 @@ const bloksFieldRefMapper = (data, { schemas, maps, fieldRefMappers: fieldRefMap
   }));
 };
 const assetFieldRefMapper = (data, { maps }) => {
+  if (!data || typeof data !== "object") {
+    return data;
+  }
   const mappedAsset = typeof data.id === "number" ? maps.assets?.get(data.id) : void 0;
   if (!mappedAsset) {
     return data;
@@ -7980,7 +8013,7 @@ const multiassetFieldRefMapper = (data, options) => {
   return data.map((d) => assetFieldRefMapper(d, options));
 };
 const optionsFieldRefMapper = (data, { schema, maps }) => {
-  if (schema.source !== "internal_stories" || !Array.isArray(data)) {
+  if (!schema || !("source" in schema) || schema.source !== "internal_stories" || !Array.isArray(data)) {
     return data;
   }
   return data.map((d) => maps.stories?.get(d) || d);
@@ -8897,8 +8930,8 @@ pushCmd$1.action(async (assetInput, options, command) => {
   }
 });
 
-const program$1 = getProgram();
-const storiesCommand = program$1.command(commands.STORIES).description(`Manage your space's stories`);
+const program$2 = getProgram();
+const storiesCommand = program$2.command(commands.STORIES).description(`Manage your space's stories`);
 
 const pullCmd = storiesCommand.command("pull").option("-s, --space <space>", "space ID").option("-d, --dry-run", "Preview changes without applying them to Storyblok").option("-q, --query <query>", 'Filter stories by content attributes using Storyblok filter query syntax. Example: --query="[highlighted][in]=true"').option("--starts-with <path>", 'Filter stories by path. Example: --starts-with="/en/blog/"').description(`Download your space's stories as separate json files.`);
 pullCmd.action(async (options, command) => {
@@ -9391,6 +9424,1957 @@ pushCmd.action(async (options, command) => {
   }
 });
 
+const program$1 = getProgram();
+const schemaCommand = program$1.command(commands.SCHEMA).description(`Manage your space's schema from code`);
+
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isComponent(value) {
+  return isObject(value) && typeof value.name === "string" && "schema" in value && isObject(value.schema);
+}
+function isDatasource(value) {
+  return isObject(value) && typeof value.name === "string" && typeof value.slug === "string" && !("schema" in value);
+}
+function isComponentFolder(value) {
+  return isObject(value) && typeof value.name === "string" && !("schema" in value) && !("slug" in value) && ("uuid" in value || "parent_id" in value);
+}
+function isSchemaObject(value) {
+  return isObject(value) && ("blocks" in value || "blockFolders" in value || "datasources" in value);
+}
+function classifyExports(moduleExports) {
+  const components = [];
+  const componentFolders = [];
+  const datasources = [];
+  function collect(value) {
+    if (isComponent(value)) {
+      components.push(value);
+    } else if (isDatasource(value)) {
+      datasources.push(value);
+    } else if (isComponentFolder(value)) {
+      componentFolders.push(value);
+    }
+  }
+  for (const value of Object.values(moduleExports)) {
+    if (isSchemaObject(value)) {
+      for (const group of Object.values(value)) {
+        if (isObject(group)) {
+          for (const entity of Object.values(group)) {
+            collect(entity);
+          }
+        }
+      }
+    } else {
+      collect(value);
+    }
+  }
+  return { components, componentFolders, datasources };
+}
+async function loadSchema(entryPath) {
+  const { createJiti } = await import('jiti');
+  const jiti = createJiti(import.meta.url, {
+    interopDefault: true
+  });
+  const absolutePath = (await import('pathe')).resolve(entryPath);
+  const mod = await jiti.import(absolutePath);
+  return classifyExports(mod);
+}
+
+const COMPONENT_STRIP_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "created_at",
+  "updated_at",
+  "real_name",
+  // API-computed display/technical name, read-only
+  "preset_id",
+  // Instance-level preset selection, not part of schema definition
+  "all_presets",
+  // Computed list of presets, managed via /presets API
+  "internal_tags_list",
+  // Read-only expanded form of internal_tag_ids ({id, name} objects)
+  "content_type_asset_preview",
+  // Read-only, not in ComponentCreate/ComponentUpdate
+  "image",
+  // Read-only preview image URL
+  "preview_tmpl",
+  // Read-only preview template
+  "metadata"
+  // Not in current API types, stripped defensively
+]);
+const DATASOURCE_STRIP_KEYS = /* @__PURE__ */ new Set(["id", "created_at", "updated_at"]);
+const DATASOURCE_DIMENSION_STRIP_KEYS = /* @__PURE__ */ new Set(["id", "datasource_id", "created_at", "updated_at"]);
+const FOLDER_INIT_STRIP_KEYS = /* @__PURE__ */ new Set(["id"]);
+const FOLDER_STRIP_KEYS = /* @__PURE__ */ new Set(["id", "uuid"]);
+const DATASOURCE_DEFAULTS = {
+  dimensions: []
+};
+const COMPONENT_DEFAULTS = {
+  display_name: "",
+  color: "",
+  icon: "",
+  preview_field: "",
+  internal_tag_ids: []
+};
+function applyDefaults(entity, defaults) {
+  const result = { ...entity };
+  for (const [key, defaultValue] of Object.entries(defaults)) {
+    if (result[key] === void 0 || result[key] === null) {
+      Object.assign(result, { [key]: defaultValue });
+    }
+  }
+  return result;
+}
+const INDENT = "  ";
+function formatValue(value, depth) {
+  const indent = INDENT.repeat(depth);
+  const innerIndent = INDENT.repeat(depth + 1);
+  if (value === null || value === void 0) {
+    return String(value);
+  }
+  if (typeof value === "string") {
+    return `'${value.replace(/'/g, "\\'")}'`;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return "[]";
+    }
+    const items = value.map((item) => `${innerIndent}${formatValue(item, depth + 1)},`);
+    return `[
+${items.join("\n")}
+${indent}]`;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value).filter(([, v]) => v !== void 0 && v !== null).sort(([a], [b]) => a.localeCompare(b));
+    if (entries.length === 0) {
+      return "{}";
+    }
+    const props = entries.map(
+      ([key, val]) => `${innerIndent}${key}: ${formatValue(val, depth + 1)},`
+    );
+    return `{
+${props.join("\n")}
+${indent}}`;
+  }
+  return String(value);
+}
+function fileTimestamp(iso) {
+  return iso.replace(/[:.]/g, "-");
+}
+function stripKeys(obj, keysToStrip) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (!keysToStrip.has(key) && value !== void 0 && value !== null) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+function sortSchemaByPos$1(schema) {
+  const entries = Object.entries(schema).filter(([key]) => key !== "_uid" && key !== "component").sort(([, a], [, b]) => {
+    const posA = typeof a.pos === "number" ? a.pos : Infinity;
+    const posB = typeof b.pos === "number" ? b.pos : Infinity;
+    return posA - posB;
+  });
+  return Object.fromEntries(
+    entries.map(([key, field]) => {
+      const { id, ...rest } = field;
+      return [key, rest];
+    })
+  );
+}
+function serializeComponent(component) {
+  const clean = stripKeys(component, COMPONENT_STRIP_KEYS);
+  if (clean.schema && typeof clean.schema === "object") {
+    clean.schema = sortSchemaByPos$1(clean.schema);
+  }
+  const ordered = {};
+  if (clean.name !== void 0) {
+    ordered.name = clean.name;
+  }
+  if (clean.display_name !== void 0) {
+    ordered.display_name = clean.display_name;
+  }
+  if (clean.is_root !== void 0) {
+    ordered.is_root = clean.is_root;
+  }
+  if (clean.is_nestable !== void 0) {
+    ordered.is_nestable = clean.is_nestable;
+  }
+  const handled = /* @__PURE__ */ new Set(["name", "display_name", "is_root", "is_nestable", "schema"]);
+  for (const [key, value] of Object.entries(clean).sort(([a], [b]) => a.localeCompare(b))) {
+    if (!handled.has(key)) {
+      ordered[key] = value;
+    }
+  }
+  if (clean.schema !== void 0) {
+    ordered.schema = clean.schema;
+  }
+  return `defineBlock(${formatValue(ordered, 0)})`;
+}
+function serializeDatasource(datasource) {
+  const clean = stripKeys(datasource, DATASOURCE_STRIP_KEYS);
+  if (Array.isArray(clean.dimensions)) {
+    clean.dimensions = clean.dimensions.map(
+      (dim) => typeof dim === "object" && dim !== null ? stripKeys(dim, DATASOURCE_DIMENSION_STRIP_KEYS) : dim
+    );
+  }
+  const ordered = {};
+  if (clean.name !== void 0) {
+    ordered.name = clean.name;
+  }
+  if (clean.slug !== void 0) {
+    ordered.slug = clean.slug;
+  }
+  const handled = /* @__PURE__ */ new Set(["name", "slug"]);
+  for (const [key, value] of Object.entries(clean).sort(([a], [b]) => a.localeCompare(b))) {
+    if (!handled.has(key)) {
+      ordered[key] = value;
+    }
+  }
+  return `defineDatasource(${formatValue(ordered, 0)})`;
+}
+function serializeComponentFolder(folder) {
+  const clean = stripKeys(folder, FOLDER_STRIP_KEYS);
+  const ordered = {};
+  if (clean.name !== void 0) {
+    ordered.name = clean.name;
+  }
+  const handled = /* @__PURE__ */ new Set(["name"]);
+  for (const [key, value] of Object.entries(clean).sort(([a], [b]) => a.localeCompare(b))) {
+    if (!handled.has(key)) {
+      ordered[key] = value;
+    }
+  }
+  return `defineBlockFolder(${formatValue(ordered, 0)})`;
+}
+
+function diffEntity(type, name, localSerialized, remoteSerialized) {
+  if (!remoteSerialized && localSerialized) {
+    return { type, name, action: "create", diff: null, local: null, remote: null };
+  }
+  if (remoteSerialized && !localSerialized) {
+    return { type, name, action: "stale", diff: null, local: null, remote: null };
+  }
+  if (localSerialized === remoteSerialized) {
+    return { type, name, action: "unchanged", diff: null, local: null, remote: null };
+  }
+  const patch = createTwoFilesPatch(
+    `remote/${name}`,
+    `local/${name}`,
+    remoteSerialized,
+    localSerialized,
+    "remote",
+    "local"
+  );
+  return { type, name, action: "update", diff: patch, local: null, remote: null };
+}
+function diffSchema(local, remote) {
+  const diffs = [];
+  const processedComponentNames = /* @__PURE__ */ new Set();
+  for (const comp of local.components) {
+    processedComponentNames.add(comp.name);
+    const remoteComp = remote.components.get(comp.name);
+    const localSerialized = serializeComponent(applyDefaults(comp, COMPONENT_DEFAULTS));
+    const remoteSerialized = remoteComp ? serializeComponent(applyDefaults(remoteComp, COMPONENT_DEFAULTS)) : null;
+    diffs.push(diffEntity("component", comp.name, localSerialized, remoteSerialized));
+  }
+  for (const [name] of remote.components) {
+    if (!processedComponentNames.has(name)) {
+      diffs.push(diffEntity("component", name, null, "stale"));
+    }
+  }
+  const processedFolderNames = /* @__PURE__ */ new Set();
+  for (const folder of local.componentFolders) {
+    processedFolderNames.add(folder.name);
+    const remoteFolder = remote.componentFolders.get(folder.name);
+    const localSerialized = serializeComponentFolder(folder);
+    const remoteSerialized = remoteFolder ? serializeComponentFolder(remoteFolder) : null;
+    diffs.push(diffEntity("componentFolder", folder.name, localSerialized, remoteSerialized));
+  }
+  for (const [name] of remote.componentFolders) {
+    if (!processedFolderNames.has(name)) {
+      diffs.push(diffEntity("componentFolder", name, null, "stale"));
+    }
+  }
+  const processedDatasourceNames = /* @__PURE__ */ new Set();
+  for (const ds of local.datasources) {
+    processedDatasourceNames.add(ds.name);
+    const remoteDs = remote.datasources.get(ds.name);
+    const localSerialized = serializeDatasource(applyDefaults(ds, DATASOURCE_DEFAULTS));
+    const remoteSerialized = remoteDs ? serializeDatasource(applyDefaults(remoteDs, DATASOURCE_DEFAULTS)) : null;
+    diffs.push(diffEntity("datasource", ds.name, localSerialized, remoteSerialized));
+  }
+  for (const [name] of remote.datasources) {
+    if (!processedDatasourceNames.has(name)) {
+      diffs.push(diffEntity("datasource", name, null, "stale"));
+    }
+  }
+  return {
+    diffs,
+    creates: diffs.filter((d) => d.action === "create").length,
+    updates: diffs.filter((d) => d.action === "update").length,
+    unchanged: diffs.filter((d) => d.action === "unchanged").length,
+    stale: diffs.filter((d) => d.action === "stale").length
+  };
+}
+
+async function fetchRemoteSchema(spaceId) {
+  const client = getMapiClient();
+  const spaceIdNum = Number(spaceId);
+  const [componentsRes, foldersRes, rawDatasources] = await Promise.all([
+    client.components.list({ path: { space_id: spaceIdNum }, throwOnError: true }),
+    client.componentFolders.list({ path: { space_id: spaceIdNum }, throwOnError: true }),
+    fetchAllPages(
+      (page) => client.datasources.list({ path: { space_id: spaceIdNum }, query: { page }, throwOnError: true }),
+      (data) => data?.datasources ?? []
+    )
+  ]);
+  const rawComponents = componentsRes.data?.components ?? [];
+  const rawComponentFolders = foldersRes.data?.component_groups ?? [];
+  const remote = {
+    components: new Map(rawComponents.map((c) => [c.name, c])),
+    componentFolders: new Map(rawComponentFolders.map((f) => [f.name, f])),
+    datasources: new Map(rawDatasources.map((d) => [d.name, d]))
+  };
+  return { remote, rawComponents, rawComponentFolders, rawDatasources };
+}
+
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSchemaField(value) {
+  return isRecord(value) && "type" in value;
+}
+function toSchemaRecord(schema) {
+  const result = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (key === "_uid" || key === "component" || !isSchemaField(value)) {
+      continue;
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function buildComponentPayload(input) {
+  if (!isRecord(input)) {
+    return { name: "" };
+  }
+  return {
+    name: typeof input.name === "string" ? input.name : "",
+    // Fields in COMPONENT_DEFAULTS are always sent with their reset value so that
+    // removing a field from the local schema actually clears it on the API.
+    // (Root-level fields are additive on MAPI update — omitting preserves the old value.)
+    display_name: typeof input.display_name === "string" ? input.display_name : "",
+    color: typeof input.color === "string" ? input.color : "",
+    icon: typeof input.icon === "string" ? input.icon : "",
+    preview_field: typeof input.preview_field === "string" ? input.preview_field : "",
+    internal_tag_ids: Array.isArray(input.internal_tag_ids) ? input.internal_tag_ids : [],
+    // Conditionally sent: only included when explicitly set in local schema
+    ...isRecord(input.schema) && { schema: toSchemaRecord(input.schema) },
+    ...typeof input.is_root === "boolean" && { is_root: input.is_root },
+    ...typeof input.is_nestable === "boolean" && { is_nestable: input.is_nestable },
+    ...typeof input.component_group_uuid === "string" && { component_group_uuid: input.component_group_uuid }
+  };
+}
+function toComponentCreate(input) {
+  return buildComponentPayload(input);
+}
+function toComponentUpdate(input) {
+  return buildComponentPayload(input);
+}
+function toComponentFolderCreate(input) {
+  if (!isRecord(input)) {
+    return { name: "" };
+  }
+  return {
+    name: typeof input.name === "string" ? input.name : "",
+    ...typeof input.parent_id === "number" && { parent_id: input.parent_id }
+  };
+}
+function toDatasourceCreate(input) {
+  if (!isRecord(input)) {
+    return { name: "", slug: "" };
+  }
+  const result = {
+    name: typeof input.name === "string" ? input.name : "",
+    slug: typeof input.slug === "string" ? input.slug : ""
+  };
+  if (Array.isArray(input.dimensions)) {
+    result.dimensions_attributes = input.dimensions.filter((d) => isRecord(d) && typeof d.name === "string" && typeof d.entry_value === "string").map((d) => ({
+      name: d.name,
+      entry_value: d.entry_value
+    }));
+  }
+  return result;
+}
+function toDatasourceUpdate(input, remote) {
+  const base = toDatasourceCreate(input);
+  const localDims = base.dimensions_attributes ?? [];
+  const remoteDims = remote.dimensions ?? [];
+  if (remoteDims.length === 0) {
+    return base;
+  }
+  const localKeys = new Set(localDims.map((d) => `${d.name}::${d.entry_value}`));
+  const destroyEntries = remoteDims.filter((rd) => rd.id != null && !localKeys.has(`${rd.name}::${rd.entry_value}`)).map((rd) => ({ id: rd.id, _destroy: true }));
+  if (destroyEntries.length > 0) {
+    return {
+      ...base,
+      dimensions_attributes: [...localDims, ...destroyEntries]
+    };
+  }
+  return base;
+}
+
+function formatDiffOutput(result, options) {
+  const lines = [];
+  const byType = {
+    component: [],
+    componentFolder: [],
+    datasource: []
+  };
+  for (const diff of result.diffs) {
+    byType[diff.type].push(diff);
+  }
+  const willDelete = options?.delete ?? false;
+  const icons = {
+    create: chalk.green("+"),
+    update: chalk.yellow("~"),
+    unchanged: chalk.dim("="),
+    stale: chalk.red("-")
+  };
+  const sections = [
+    ["Components", byType.component],
+    ["Component Folders", byType.componentFolder],
+    ["Datasources", byType.datasource]
+  ];
+  for (const [label, diffs] of sections) {
+    if (diffs.length === 0) {
+      continue;
+    }
+    lines.push(chalk.bold(label));
+    for (const diff of diffs) {
+      const icon = icons[diff.action] ?? " ";
+      const name = diff.action === "stale" ? chalk.red(diff.name) : diff.name;
+      const actionLabel = diff.action === "stale" && willDelete ? "delete" : diff.action;
+      lines.push(`  ${icon} ${name} ${chalk.dim(`(${actionLabel})`)}`);
+      if (diff.diff) {
+        for (const line of diff.diff.split("\n")) {
+          if (line.startsWith("+") && !line.startsWith("+++")) {
+            lines.push(`    ${chalk.green(line)}`);
+          } else if (line.startsWith("-") && !line.startsWith("---")) {
+            lines.push(`    ${chalk.red(line)}`);
+          }
+        }
+      }
+    }
+    lines.push("");
+  }
+  const summary = [
+    result.creates > 0 ? chalk.green(`${result.creates} to create`) : null,
+    result.updates > 0 ? chalk.yellow(`${result.updates} to update`) : null,
+    result.unchanged > 0 ? chalk.dim(`${result.unchanged} unchanged`) : null,
+    result.stale > 0 ? chalk.red(`${result.stale} ${willDelete ? "to delete" : "stale"}`) : null
+  ].filter(Boolean).join(", ");
+  lines.push(`Summary: ${summary}`);
+  return lines.join("\n");
+}
+async function executePush(spaceId, local, remote, diffResult, options) {
+  const client = getMapiClient();
+  const spaceIdNum = Number(spaceId);
+  let created = 0;
+  let updated = 0;
+  let deleted = 0;
+  const createdFolderUuids = /* @__PURE__ */ new Map();
+  const folderDiffs = diffResult.diffs.filter((d) => d.type === "componentFolder");
+  const folderResults = await Promise.allSettled(
+    folderDiffs.map(async (diff) => {
+      const localFolder = local.componentFolders.find((f) => f.name === diff.name);
+      if (diff.action === "create" && localFolder) {
+        const response = await client.componentFolders.create({
+          path: { space_id: spaceIdNum },
+          body: { component_group: toComponentFolderCreate(localFolder) },
+          throwOnError: true
+        });
+        return { action: "created", uuid: response.data?.component_group?.uuid };
+      }
+      if (diff.action === "update" && localFolder) {
+        const existing = remote.componentFolders.get(diff.name);
+        if (existing?.id) {
+          await client.componentFolders.update(existing.id, {
+            path: { space_id: spaceIdNum },
+            body: { component_group: toComponentFolderCreate(localFolder) },
+            throwOnError: true
+          });
+          return { action: "updated" };
+        }
+      }
+    })
+  );
+  for (let i = 0; i < folderResults.length; i++) {
+    const result = folderResults[i];
+    const diff = folderDiffs[i];
+    if (result.status === "fulfilled") {
+      if (result.value?.action === "created") {
+        if (result.value.uuid) {
+          createdFolderUuids.set(diff.name, result.value.uuid);
+        }
+        created++;
+      } else if (result.value?.action === "updated") {
+        updated++;
+      }
+    } else {
+      const eventId = diff.action === "create" ? "push_component_group" : "update_component_group";
+      handleAPIError(eventId, result.reason, `Failed to ${diff.action} component folder ${diff.name}`);
+    }
+  }
+  const skippedComponents = /* @__PURE__ */ new Set();
+  if (options.pendingFolderAssignments) {
+    const logger = getLogger();
+    for (const [folderName, componentNames] of options.pendingFolderAssignments) {
+      const remoteUuid = createdFolderUuids.get(folderName);
+      if (!remoteUuid) {
+        logger.warn(`Could not resolve folder '${folderName}' \u2014 skipping components: ${componentNames.join(", ")}`);
+        for (const name of componentNames) {
+          skippedComponents.add(name);
+        }
+        continue;
+      }
+      for (const compName of componentNames) {
+        const comp = local.components.find((c) => c.name === compName);
+        if (comp) {
+          comp.component_group_uuid = remoteUuid;
+        }
+      }
+    }
+  }
+  const componentDiffs = diffResult.diffs.filter((d) => d.type === "component" && !skippedComponents.has(d.name));
+  const componentResults = await Promise.allSettled(
+    componentDiffs.map(async (diff) => {
+      const localComp = local.components.find((c) => c.name === diff.name);
+      if (diff.action === "create" && localComp) {
+        await client.components.create({
+          path: { space_id: spaceIdNum },
+          body: { component: toComponentCreate(localComp) },
+          throwOnError: true
+        });
+        return "created";
+      }
+      if (diff.action === "update" && localComp) {
+        const existing = remote.components.get(diff.name);
+        if (existing?.id) {
+          await client.components.update(existing.id, {
+            path: { space_id: spaceIdNum },
+            body: { component: toComponentUpdate(localComp) },
+            throwOnError: true
+          });
+          return "updated";
+        }
+      }
+    })
+  );
+  for (let i = 0; i < componentResults.length; i++) {
+    const result = componentResults[i];
+    const diff = componentDiffs[i];
+    if (result.status === "fulfilled") {
+      if (result.value === "created") {
+        created++;
+      } else if (result.value === "updated") {
+        updated++;
+      }
+    } else {
+      const eventId = diff.action === "create" ? "push_component" : "update_component";
+      handleAPIError(eventId, result.reason, `Failed to ${diff.action} component ${diff.name}`);
+    }
+  }
+  const datasourceDiffs = diffResult.diffs.filter((d) => d.type === "datasource");
+  const datasourceResults = await Promise.allSettled(
+    datasourceDiffs.map(async (diff) => {
+      const localDs = local.datasources.find((d) => d.name === diff.name);
+      if (diff.action === "create" && localDs) {
+        await client.datasources.create({
+          path: { space_id: spaceIdNum },
+          body: { datasource: toDatasourceCreate(localDs) },
+          throwOnError: true
+        });
+        return "created";
+      }
+      if (diff.action === "update" && localDs) {
+        const existing = remote.datasources.get(diff.name);
+        if (existing?.id) {
+          await client.datasources.update(existing.id, {
+            path: { space_id: spaceIdNum },
+            body: { datasource: toDatasourceUpdate(localDs, existing) },
+            throwOnError: true
+          });
+          return "updated";
+        }
+      }
+    })
+  );
+  for (let i = 0; i < datasourceResults.length; i++) {
+    const result = datasourceResults[i];
+    const diff = datasourceDiffs[i];
+    if (result.status === "fulfilled") {
+      if (result.value === "created") {
+        created++;
+      } else if (result.value === "updated") {
+        updated++;
+      }
+    } else {
+      const eventId = diff.action === "create" ? "push_datasource" : "update_datasource";
+      handleAPIError(eventId, result.reason, `Failed to ${diff.action} datasource ${diff.name}`);
+    }
+  }
+  if (options.delete) {
+    const staleComponents = diffResult.diffs.filter((d) => d.type === "component" && d.action === "stale");
+    const deleteComponentResults = await Promise.allSettled(
+      staleComponents.map(async (diff) => {
+        const existing = remote.components.get(diff.name);
+        if (existing?.id) {
+          await client.components.delete(existing.id, {
+            path: { space_id: spaceIdNum },
+            throwOnError: true
+          });
+          return true;
+        }
+      })
+    );
+    for (let i = 0; i < deleteComponentResults.length; i++) {
+      const result = deleteComponentResults[i];
+      if (result.status === "fulfilled") {
+        if (result.value) {
+          deleted++;
+        }
+      } else {
+        handleAPIError("push_component", result.reason, `Failed to delete component ${staleComponents[i].name}`);
+      }
+    }
+    const staleDatasources = diffResult.diffs.filter((d) => d.type === "datasource" && d.action === "stale");
+    const deleteDatasourceResults = await Promise.allSettled(
+      staleDatasources.map(async (diff) => {
+        const existing = remote.datasources.get(diff.name);
+        if (existing?.id) {
+          await client.datasources.delete(existing.id, {
+            path: { space_id: spaceIdNum },
+            throwOnError: true
+          });
+          return true;
+        }
+      })
+    );
+    for (let i = 0; i < deleteDatasourceResults.length; i++) {
+      const result = deleteDatasourceResults[i];
+      if (result.status === "fulfilled") {
+        if (result.value) {
+          deleted++;
+        }
+      } else {
+        handleAPIError("delete_datasource", result.reason, `Failed to delete datasource ${staleDatasources[i].name}`);
+      }
+    }
+    const staleFolders = diffResult.diffs.filter((d) => d.type === "componentFolder" && d.action === "stale");
+    const deleteFolderResults = await Promise.allSettled(
+      staleFolders.map(async (diff) => {
+        const existing = remote.componentFolders.get(diff.name);
+        if (existing?.id) {
+          await client.componentFolders.delete(existing.id, {
+            path: { space_id: spaceIdNum },
+            throwOnError: true
+          });
+          return true;
+        }
+      })
+    );
+    for (let i = 0; i < deleteFolderResults.length; i++) {
+      const result = deleteFolderResults[i];
+      if (result.status === "fulfilled") {
+        if (result.value) {
+          deleted++;
+        }
+      } else {
+        handleAPIError("push_component_group", result.reason, `Failed to delete folder ${staleFolders[i].name}`);
+      }
+    }
+  }
+  return { created, updated, deleted };
+}
+function buildChangesetEntries(diffResult, local, remote, options) {
+  const changes = [];
+  for (const diff of diffResult.diffs) {
+    if (diff.action === "unchanged") {
+      continue;
+    }
+    if (diff.action === "stale" && !options.delete) {
+      continue;
+    }
+    const action = diff.action === "stale" ? "delete" : diff.action;
+    let remoteSrc;
+    let localSrc;
+    if (diff.type === "component") {
+      remoteSrc = remote.components.get(diff.name);
+      localSrc = local.components.find((c) => c.name === diff.name);
+    } else if (diff.type === "componentFolder") {
+      remoteSrc = remote.componentFolders.get(diff.name);
+      localSrc = local.componentFolders.find((f) => f.name === diff.name);
+    } else if (diff.type === "datasource") {
+      remoteSrc = remote.datasources.get(diff.name);
+      localSrc = local.datasources.find((d) => d.name === diff.name);
+    }
+    changes.push({
+      type: diff.type,
+      name: diff.name,
+      action,
+      ...remoteSrc && { before: { ...remoteSrc } },
+      ...localSrc && { after: { ...localSrc } }
+    });
+  }
+  return changes;
+}
+
+function findRemoteFolderByUuid(remoteFolders, uuid) {
+  for (const folder of remoteFolders.values()) {
+    if (folder.uuid === uuid) {
+      return folder;
+    }
+  }
+  return void 0;
+}
+function resolveFolderReferences(local, remote) {
+  const localUuidToName = /* @__PURE__ */ new Map();
+  for (const folder of local.componentFolders) {
+    if (folder.uuid) {
+      localUuidToName.set(folder.uuid, folder.name);
+    }
+  }
+  const pendingFolderAssignments = /* @__PURE__ */ new Map();
+  const resolvedComponents = local.components.map((comp) => {
+    if (!comp.component_group_uuid) {
+      return comp;
+    }
+    const folderName = localUuidToName.get(comp.component_group_uuid);
+    if (!folderName) {
+      return comp;
+    }
+    const remoteByUuid = findRemoteFolderByUuid(remote.componentFolders, comp.component_group_uuid);
+    if (remoteByUuid) {
+      return comp;
+    }
+    const remoteByName = remote.componentFolders.get(folderName);
+    if (remoteByName) {
+      return { ...comp, component_group_uuid: remoteByName.uuid };
+    }
+    const pending = pendingFolderAssignments.get(folderName) ?? [];
+    pending.push(comp.name);
+    pendingFolderAssignments.set(folderName, pending);
+    return comp;
+  });
+  return {
+    resolved: { ...local, components: resolvedComponents },
+    pendingFolderAssignments
+  };
+}
+
+async function ensureDir(dir) {
+  await mkdir(dir, { recursive: true });
+}
+async function saveChangeset(basePath, data) {
+  const dir = join(basePath, "schema", "changesets");
+  await ensureDir(dir);
+  const fileName = `${fileTimestamp(data.timestamp)}.json`;
+  const filePath = join(dir, fileName);
+  await writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+  return filePath;
+}
+
+const SENTINEL_FIELDS = /* @__PURE__ */ new Set(["_uid", "component"]);
+function classifyFieldChanges(remoteSchema, localSchema) {
+  const removed = [];
+  const added = [];
+  const typeChanged = [];
+  const requiredAdded = [];
+  const requiredChanged = [];
+  for (const [field, remoteField] of Object.entries(remoteSchema)) {
+    if (SENTINEL_FIELDS.has(field)) {
+      continue;
+    }
+    if (typeof remoteField.type !== "string") {
+      continue;
+    }
+    if (!(field in localSchema)) {
+      removed.push({ field, type: remoteField.type });
+    }
+  }
+  for (const [field, localField] of Object.entries(localSchema)) {
+    if (SENTINEL_FIELDS.has(field)) {
+      continue;
+    }
+    if (typeof localField.type !== "string") {
+      continue;
+    }
+    if (!(field in remoteSchema)) {
+      if (localField.required) {
+        requiredAdded.push({ field, type: localField.type });
+      } else {
+        added.push({ field, type: localField.type, required: false });
+      }
+    } else {
+      const remoteField = remoteSchema[field];
+      if (typeof remoteField?.type !== "string") {
+        continue;
+      }
+      if (remoteField.type !== localField.type) {
+        typeChanged.push({ field, oldType: remoteField.type, newType: localField.type });
+      }
+      if (localField.required && !remoteField.required) {
+        requiredChanged.push({ field, type: localField.type });
+      }
+    }
+  }
+  return { removed, added, typeChanged, requiredAdded, requiredChanged };
+}
+function longestCommonSubstring(a, b) {
+  let maxLen = 0;
+  for (let i = 0; i < a.length; i++) {
+    for (let j = 0; j < b.length; j++) {
+      let len = 0;
+      while (i + len < a.length && j + len < b.length && a[i + len] === b[j + len]) {
+        len++;
+      }
+      if (len > maxLen) {
+        maxLen = len;
+      }
+    }
+  }
+  return maxLen;
+}
+function nameSimilarity(a, b) {
+  const longer = Math.max(a.length, b.length);
+  if (longer === 0) {
+    return 1;
+  }
+  return longestCommonSubstring(a, b) / longer;
+}
+function detectRenames(removed, added) {
+  const renames = [];
+  const usedRemoved = /* @__PURE__ */ new Set();
+  const usedAdded = /* @__PURE__ */ new Set();
+  const addedByType = /* @__PURE__ */ new Map();
+  for (const addedField of added) {
+    if (!addedByType.has(addedField.type)) {
+      addedByType.set(addedField.type, []);
+    }
+    addedByType.get(addedField.type).push(addedField);
+  }
+  const isSinglePair = removed.length === 1 && added.length === 1;
+  for (const removedField of removed) {
+    const candidates = addedByType.get(removedField.type) ?? [];
+    const availableCandidates = candidates.filter((c) => !usedAdded.has(c.field));
+    if (availableCandidates.length === 0) {
+      continue;
+    }
+    let bestCandidate = availableCandidates[0];
+    let bestScore = nameSimilarity(removedField.field, bestCandidate.field);
+    for (let i = 1; i < availableCandidates.length; i++) {
+      const score = nameSimilarity(removedField.field, availableCandidates[i].field);
+      if (score > bestScore) {
+        bestScore = score;
+        bestCandidate = availableCandidates[i];
+      }
+    }
+    if (!isSinglePair && bestScore < 0.3) {
+      continue;
+    }
+    renames.push({ oldField: removedField.field, newField: bestCandidate.field, fieldType: removedField.type });
+    usedRemoved.add(removedField.field);
+    usedAdded.add(bestCandidate.field);
+  }
+  const unmatchedRemoved = removed.filter((r) => !usedRemoved.has(r.field));
+  const unmatchedAdded = added.filter((a) => !usedAdded.has(a.field));
+  return { renames, unmatchedRemoved, unmatchedAdded };
+}
+function analyzeBreakingChanges(diffResult, local, remote) {
+  const results = [];
+  const updatedComponents = diffResult.diffs.filter(
+    (d) => d.type === "component" && d.action === "update"
+  );
+  for (const diff of updatedComponents) {
+    const localComp = local.components.find((c) => c.name === diff.name);
+    const remoteComp = remote.components.get(diff.name);
+    if (!localComp?.schema || !remoteComp?.schema) {
+      continue;
+    }
+    const classification = classifyFieldChanges(
+      remoteComp.schema,
+      localComp.schema
+    );
+    const changes = [];
+    const { renames, unmatchedRemoved } = detectRenames(classification.removed, classification.added);
+    for (const rename of renames) {
+      changes.push({ kind: "rename", field: rename.newField, oldField: rename.oldField });
+    }
+    for (const removed of unmatchedRemoved) {
+      changes.push({ kind: "removed", field: removed.field });
+    }
+    for (const tc of classification.typeChanged) {
+      changes.push({ kind: "type_changed", field: tc.field, oldType: tc.oldType, newType: tc.newType });
+    }
+    for (const ra of classification.requiredAdded) {
+      changes.push({ kind: "required_added", field: ra.field, fieldType: ra.type });
+    }
+    for (const rc of classification.requiredChanged) {
+      changes.push({ kind: "required_changed", field: rc.field, fieldType: rc.type });
+    }
+    if (changes.length > 0) {
+      results.push({ componentName: diff.name, changes });
+    }
+  }
+  return results;
+}
+
+const COMPATIBLE_TYPES = /* @__PURE__ */ new Set(["text:textarea", "textarea:text"]);
+function defaultForType(fieldType) {
+  switch (fieldType) {
+    case "text":
+    case "textarea":
+    case "markdown":
+      return `''`;
+    case "number":
+      return "0";
+    case "boolean":
+      return "false";
+    default:
+      return null;
+  }
+}
+function typeConversion(field, oldType, newType) {
+  const key = `${oldType}:${newType}`;
+  if (COMPATIBLE_TYPES.has(key)) {
+    return null;
+  }
+  const accessor = `block.${field}`;
+  switch (key) {
+    case "text:number":
+      return `${accessor} = Number(${accessor}) || 0;`;
+    case "number:text":
+      return `${accessor} = String(${accessor});`;
+    case "text:boolean":
+      return `${accessor} = !!${accessor};`;
+    case "boolean:text":
+      return `${accessor} = String(${accessor});`;
+    default:
+      return `${accessor}; // TODO: convert from ${oldType} to ${newType}`;
+  }
+}
+function renderMigrationCode(changes) {
+  const lines = [];
+  lines.push("  // Review this migration before running it against your space.");
+  lines.push("  // Generated migrations are scaffolds and may need manual adjustments.");
+  lines.push("  // Example rename migration:");
+  lines.push("  // block.new_field = block.old_field;");
+  lines.push("  // delete block.old_field;");
+  lines.push("");
+  for (const change of changes) {
+    switch (change.kind) {
+      case "rename":
+        lines.push(`  // Rename: ${change.oldField} \u2192 ${change.field}`);
+        lines.push(`  if ('${change.oldField}' in block) {`);
+        lines.push(`    block.${change.field} = block.${change.oldField};`);
+        lines.push(`    delete block.${change.oldField};`);
+        lines.push(`  }`);
+        break;
+      case "removed":
+        if (change.renameHint) {
+          lines.push(`  // If '${change.field}' was renamed to '${change.renameHint.newField}', uncomment:`);
+          lines.push(`  // block.${change.renameHint.newField} = block.${change.field};`);
+        } else {
+          lines.push(`  // Removed field: ${change.field}`);
+        }
+        lines.push(`  delete block.${change.field};`);
+        break;
+      case "type_changed": {
+        const conversion = typeConversion(change.field, change.oldType, change.newType);
+        if (conversion) {
+          lines.push(`  // Type change: ${change.field} (${change.oldType} \u2192 ${change.newType})`);
+          lines.push(`  ${conversion}`);
+        }
+        break;
+      }
+      case "required_added": {
+        const defaultValue = defaultForType(change.fieldType);
+        lines.push(`  // New required field: ${change.field} (${change.fieldType})`);
+        if (defaultValue !== null) {
+          lines.push(`  // TODO: provide a meaningful default value`);
+          lines.push(`  block.${change.field} = block.${change.field} ?? ${defaultValue};`);
+        } else {
+          lines.push(`  // TODO: provide a default value appropriate for the '${change.fieldType}' type`);
+          lines.push(`  // block.${change.field} = block.${change.field} ?? <default>;`);
+        }
+        break;
+      }
+      case "required_changed": {
+        const defaultValue = defaultForType(change.fieldType);
+        lines.push(`  // Field is now required: ${change.field} (${change.fieldType})`);
+        lines.push(`  // Existing stories may have null/undefined values \u2014 provide a default for those.`);
+        if (defaultValue !== null) {
+          lines.push(`  // TODO: provide a meaningful default value`);
+          lines.push(`  block.${change.field} = block.${change.field} ?? ${defaultValue};`);
+        } else {
+          lines.push(`  // TODO: provide a default value appropriate for the '${change.fieldType}' type`);
+          lines.push(`  // block.${change.field} = block.${change.field} ?? <default>;`);
+        }
+        break;
+      }
+    }
+    lines.push("");
+  }
+  const body = lines.length > 0 ? `
+${lines.join("\n")}` : "\n";
+  return `export default function (block) {${body}  return block;
+}
+`;
+}
+async function writeMigrationFile(options) {
+  const { spaceId, componentName, code, timestamp, basePath } = options;
+  const dir = resolvePath(basePath, `migrations/${spaceId}`);
+  await mkdir(dir, { recursive: true });
+  const fileName = `${componentName}.${fileTimestamp(timestamp)}.js`;
+  const filePath = join(dir, fileName);
+  await writeFile(filePath, code, "utf-8");
+  return filePath;
+}
+
+const DEFAULT_GROUPS_FILENAME = "groups.json";
+const CONSOLIDATED_COMPONENTS_FILENAME = "components.json";
+async function writeLocalComponents({
+  space,
+  basePath,
+  resolved,
+  diffResult,
+  deleteRemoved,
+  ui,
+  logger
+}) {
+  const componentsDir = resolveCommandPath(directories.components, space, basePath);
+  const consolidatedPath = join(componentsDir, CONSOLIDATED_COMPONENTS_FILENAME);
+  if (await fileExists(consolidatedPath)) {
+    ui.warn(
+      `A consolidated ${CONSOLIDATED_COMPONENTS_FILENAME} exists at ${componentsDir}. Per-component files will still be written, but the consolidated file may shadow them when stories push validates schemas. Delete it or run \`storyblok components pull --separate-files\` to regenerate.`
+    );
+  }
+  for (const component of resolved.components) {
+    const filePath = join(componentsDir, `${sanitizeFilename(component.name || "")}.json`);
+    await saveToFile(filePath, JSON.stringify(component, null, 2));
+  }
+  const groupsPath = join(componentsDir, DEFAULT_GROUPS_FILENAME);
+  if (resolved.componentFolders.length > 0) {
+    await saveToFile(groupsPath, JSON.stringify(resolved.componentFolders, null, 2));
+  } else if (await fileExists(groupsPath)) {
+    try {
+      await unlink(groupsPath);
+      logger.info("Removed stale local groups file", { path: groupsPath });
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  if (deleteRemoved) {
+    const staleComponents = diffResult.diffs.filter(
+      (d) => d.type === "component" && d.action === "stale"
+    );
+    for (const stale of staleComponents) {
+      const filePath = join(componentsDir, `${sanitizeFilename(stale.name)}.json`);
+      try {
+        await unlink(filePath);
+        logger.info("Removed stale local component file", { path: filePath });
+      } catch (error) {
+        if (error.code !== "ENOENT") {
+          throw error;
+        }
+      }
+    }
+  }
+  logger.info("Wrote local component files", {
+    space,
+    componentsWritten: resolved.components.length,
+    groupsWritten: resolved.componentFolders.length
+  });
+}
+
+schemaCommand.command("push <entry-file>").description("Push local TypeScript schema and datasource definitions to a Storyblok space").option("-s, --space <space>", "space ID").option("-p, --path <path>", "path for file storage").option("--dry-run", "Show diffs without applying changes", false).option("--delete", "Delete remote entities not present in local schema", false).option("--migrations", "Generate scaffold migration files for breaking changes", true).addOption(new Option("--no-migrations", "Skip migration generation for breaking changes")).option("--write-components", "Write component schemas as local JSON files after push (also removes local files for components deleted via --delete)", true).addOption(new Option("--no-write-components", "Skip writing local component files")).action(async (entryFile, options, command) => {
+  const ui = getUI();
+  const logger = getLogger();
+  const reporter = getReporter();
+  const { space, path: basePath, verbose } = command.optsWithGlobals();
+  const { state } = session();
+  ui.title(commands.SCHEMA, colorPalette.SCHEMA, "Pushing schema...");
+  logger.info("Schema push started", { entryFile, space });
+  if (!requireAuthentication(state, verbose)) {
+    return;
+  }
+  if (!space) {
+    handleError(new CommandError("Please provide the space as argument --space SPACE_ID."), verbose);
+    return;
+  }
+  const summary = { total: 0, succeeded: 0, failed: 0 };
+  try {
+    const loadSpinner = ui.createSpinner("Resolving schema...");
+    let local;
+    try {
+      local = await loadSchema(entryFile);
+    } catch (maybeError) {
+      loadSpinner.failed("Failed to resolve schema");
+      handleError(toError(maybeError), verbose);
+      return;
+    }
+    loadSpinner.succeed(`Found: ${local.components.length} components, ${local.componentFolders.length} component folders, ${local.datasources.length} datasources`);
+    const totalLocal = local.components.length + local.componentFolders.length + local.datasources.length;
+    if (totalLocal === 0) {
+      ui.warn("No components, folders, or datasources found in the entry file. Verify the file exports schema definitions.");
+      return;
+    }
+    const remoteSpinner = ui.createSpinner(`Fetching remote state from space ${space}...`);
+    let remoteResult;
+    try {
+      remoteResult = await fetchRemoteSchema(space);
+    } catch (maybeError) {
+      remoteSpinner.failed("Failed to fetch remote schema");
+      handleError(toError(maybeError), verbose);
+      return;
+    }
+    const { remote, rawComponents, rawComponentFolders, rawDatasources } = remoteResult;
+    remoteSpinner.succeed(`Remote: ${remote.components.size} components, ${remote.componentFolders.size} component folders, ${remote.datasources.size} datasources`);
+    const { resolved, pendingFolderAssignments } = resolveFolderReferences(local, remote);
+    const diffResult = diffSchema(resolved, remote);
+    ui.br();
+    ui.log(formatDiffOutput(diffResult, { delete: options.delete }));
+    if (options.migrations) {
+      const breakingChanges = analyzeBreakingChanges(diffResult, resolved, remote);
+      if (breakingChanges.length > 0) {
+        const totalChanges = breakingChanges.reduce((sum, c) => sum + c.changes.length, 0);
+        ui.br();
+        ui.warn(`${totalChanges} breaking change(s) detected in ${breakingChanges.length} component(s).`);
+        ui.info("Generated migrations are scaffolds. Review and adjust them before running `storyblok migrations run`.");
+        if (!options.dryRun) {
+          const explicitMigrations = command.getOptionValueSource("migrations") === "cli";
+          const shouldGenerate = explicitMigrations || await confirm({
+            message: "Generate migration files for breaking changes?",
+            default: true
+          });
+          if (shouldGenerate) {
+            const migrationTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+            const resolvedBase = resolvePath(basePath, "");
+            for (const comp of breakingChanges) {
+              const renames = comp.changes.filter((c) => c.kind === "rename");
+              if (renames.length > 0 && explicitMigrations) {
+                for (const r of renames) {
+                  if (r.kind === "rename") {
+                    ui.log(`  Assumed rename in '${comp.componentName}': ${r.oldField} \u2192 ${r.field}`);
+                  }
+                }
+              }
+              if (renames.length > 0 && !explicitMigrations) {
+                ui.br();
+                ui.log(`Detected renames in '${comp.componentName}':`);
+                for (const r of renames) {
+                  if (r.kind === "rename") {
+                    ui.log(`  ${r.oldField} \u2192 ${r.field}`);
+                  }
+                }
+                const renameConfirmed = await confirm({
+                  message: "Are these renames correct?",
+                  default: true
+                });
+                if (!renameConfirmed) {
+                  comp.changes = comp.changes.map((c) => {
+                    if (c.kind === "rename") {
+                      return { kind: "removed", field: c.oldField, renameHint: { newField: c.field } };
+                    }
+                    return c;
+                  });
+                }
+              }
+              const code = renderMigrationCode(comp.changes);
+              const path = await writeMigrationFile({
+                spaceId: space,
+                componentName: comp.componentName,
+                code,
+                timestamp: migrationTimestamp,
+                basePath: resolvedBase
+              });
+              ui.log(`  Generated: ${path}`);
+            }
+            ui.br();
+            ui.info(`Run migrations when ready: storyblok migrations run --space ${space}`);
+          }
+        }
+      }
+    }
+    if (options.delete) {
+      const deletedComponents = diffResult.diffs.filter((d) => d.type === "component" && d.action === "stale");
+      for (const comp of deletedComponents) {
+        ui.warn(`Component '${comp.name}' will be deleted. Stories using it will have out-of-schema content.`);
+      }
+    }
+    if (diffResult.stale > 0 && !options.delete) {
+      ui.warn(`${diffResult.stale} stale entity(s) exist remotely but not in schema. Use --delete to remove.`);
+    }
+    if (options.dryRun) {
+      ui.info("Dry run \u2014 no changes applied.");
+      logger.info("Dry run completed", { creates: diffResult.creates, updates: diffResult.updates });
+      return;
+    }
+    const resolvedPath = resolvePath(basePath, "");
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const changesetPath = await saveChangeset(resolvedPath, {
+      timestamp,
+      spaceId: Number(space),
+      remote: { components: rawComponents, componentFolders: rawComponentFolders, datasources: rawDatasources },
+      changes: buildChangesetEntries(diffResult, resolved, remote, { delete: options.delete })
+    });
+    logger.info("Changeset saved", { path: changesetPath });
+    const nothingToPush = diffResult.creates === 0 && diffResult.updates === 0 && (!options.delete || diffResult.stale === 0);
+    if (nothingToPush) {
+      ui.ok("Everything up to date \u2014 nothing to push.");
+    } else {
+      const pushSpinner = ui.createSpinner("Pushing schema...");
+      let result;
+      try {
+        result = await executePush(space, resolved, remote, diffResult, { delete: options.delete, pendingFolderAssignments });
+      } catch (error) {
+        pushSpinner.failed("Failed to push schema");
+        throw error;
+      }
+      summary.total = result.created + result.updated + result.deleted;
+      summary.succeeded = summary.total;
+      pushSpinner.succeed(`Pushed ${result.created} creations, ${result.updated} updates${result.deleted > 0 ? `, ${result.deleted} deletions` : ""}.`);
+    }
+    if (options.writeComponents) {
+      try {
+        await writeLocalComponents({
+          space,
+          basePath,
+          resolved,
+          diffResult,
+          deleteRemoved: options.delete,
+          ui,
+          logger
+        });
+      } catch (writeError) {
+        ui.warn(`Failed to write local component files: ${toError(writeError).message}`);
+        logger.warn("Failed to write local component files", { error: toError(writeError).message });
+      }
+    }
+  } catch (maybeError) {
+    summary.failed += 1;
+    handleError(toError(maybeError), verbose);
+  } finally {
+    logger.info("Schema push finished", { summary });
+    reporter.addSummary("schemaPushResults", summary);
+    reporter.finalize();
+  }
+});
+
+const FIELD_STRIP_KEYS = /* @__PURE__ */ new Set(["id", "pos"]);
+function toCamelCase(str) {
+  return str.toLowerCase().replace(/[\s_-]+(.)/g, (_, char) => char.toUpperCase());
+}
+function toKebabCase(str) {
+  return str.replace(/[\s_]+/g, "-").replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function componentVarName(name) {
+  return `${toCamelCase(name)}Block`;
+}
+function folderVarName(name) {
+  return `${toCamelCase(name)}Folder`;
+}
+function datasourceVarName(name) {
+  return `${toCamelCase(name)}Datasource`;
+}
+function componentFileName(name) {
+  return toKebabCase(name);
+}
+function folderFileName(name) {
+  return toKebabCase(name);
+}
+function datasourceFileName(datasource) {
+  return toKebabCase(datasource.slug || datasource.name);
+}
+function generateFieldCode(fieldName, fieldData, depth) {
+  const clean = stripKeys(fieldData, FIELD_STRIP_KEYS);
+  return `defineField('${fieldName.replace(/'/g, "\\'")}', ${formatValue(clean, depth + 1)})`;
+}
+function sortSchemaByPos(schema) {
+  return Object.entries(schema).filter(([key]) => key !== "_uid" && key !== "component").sort(([, a], [, b]) => {
+    const posA = typeof a.pos === "number" ? a.pos : Infinity;
+    const posB = typeof b.pos === "number" ? b.pos : Infinity;
+    return posA - posB;
+  });
+}
+function generateComponentFile(component, componentFolders) {
+  const lines = [];
+  let matchedFolder;
+  if (component.component_group_uuid && componentFolders) {
+    matchedFolder = componentFolders.find((f) => f.uuid === component.component_group_uuid);
+  }
+  lines.push("import {");
+  lines.push("  defineBlock,");
+  lines.push("  defineField,");
+  lines.push("} from '@storyblok/schema';");
+  if (matchedFolder) {
+    lines.push("");
+    const fVarName = folderVarName(matchedFolder.name);
+    const fFileName = folderFileName(matchedFolder.name);
+    lines.push(`import { ${fVarName} } from './folders/${fFileName}';`);
+  }
+  lines.push("");
+  const varName = componentVarName(component.name);
+  lines.push(`export const ${varName} = defineBlock({`);
+  const clean = stripKeys(component, COMPONENT_STRIP_KEYS);
+  if (matchedFolder) {
+    delete clean.component_group_uuid;
+  }
+  const orderedKeys = [];
+  if (clean.name !== void 0) {
+    orderedKeys.push("name");
+  }
+  if (clean.display_name !== void 0) {
+    orderedKeys.push("display_name");
+  }
+  if (clean.is_root !== void 0) {
+    orderedKeys.push("is_root");
+  }
+  if (clean.is_nestable !== void 0) {
+    orderedKeys.push("is_nestable");
+  }
+  const handled = /* @__PURE__ */ new Set(["name", "display_name", "is_root", "is_nestable", "schema"]);
+  for (const key of Object.keys(clean).sort()) {
+    if (!handled.has(key)) {
+      orderedKeys.push(key);
+    }
+  }
+  if (matchedFolder) {
+    const fVarName = folderVarName(matchedFolder.name);
+    lines.push(`${INDENT}component_group_uuid: ${fVarName}.uuid,`);
+  }
+  for (const key of orderedKeys) {
+    lines.push(`${INDENT}${key}: ${formatValue(clean[key], 1)},`);
+  }
+  if (clean.schema && typeof clean.schema === "object") {
+    const schema = clean.schema;
+    const sortedFields = sortSchemaByPos(schema);
+    if (sortedFields.length > 0) {
+      lines.push(`${INDENT}schema: [`);
+      for (const [fieldName, fieldData] of sortedFields) {
+        const fieldCode = generateFieldCode(fieldName, fieldData, 2);
+        lines.push(`${INDENT}${INDENT}${fieldCode},`);
+      }
+      lines.push(`${INDENT}],`);
+    } else {
+      lines.push(`${INDENT}schema: [],`);
+    }
+  }
+  lines.push("});");
+  lines.push("");
+  return lines.join("\n");
+}
+function generateFolderFile(folder) {
+  const lines = [];
+  lines.push("import { defineBlockFolder } from '@storyblok/schema';");
+  lines.push("");
+  const varName = folderVarName(folder.name);
+  lines.push(`export const ${varName} = defineBlockFolder({`);
+  const clean = stripKeys(folder, FOLDER_INIT_STRIP_KEYS);
+  if (clean.name !== void 0) {
+    lines.push(`${INDENT}name: ${formatValue(clean.name, 1)},`);
+  }
+  const handled = /* @__PURE__ */ new Set(["name"]);
+  for (const [key, value] of Object.entries(clean).sort(([a], [b]) => a.localeCompare(b))) {
+    if (!handled.has(key)) {
+      lines.push(`${INDENT}${key}: ${formatValue(value, 1)},`);
+    }
+  }
+  lines.push("});");
+  lines.push("");
+  return lines.join("\n");
+}
+function generateDatasourceFile(datasource) {
+  const lines = [];
+  lines.push("import { defineDatasource } from '@storyblok/schema';");
+  lines.push("");
+  const varName = datasourceVarName(datasource.name);
+  lines.push(`export const ${varName} = defineDatasource({`);
+  const clean = stripKeys(datasource, DATASOURCE_STRIP_KEYS);
+  if (clean.name !== void 0) {
+    lines.push(`${INDENT}name: ${formatValue(clean.name, 1)},`);
+  }
+  if (clean.slug !== void 0) {
+    lines.push(`${INDENT}slug: ${formatValue(clean.slug, 1)},`);
+  }
+  const handled = /* @__PURE__ */ new Set(["name", "slug"]);
+  for (const [key, value] of Object.entries(clean).sort(([a], [b]) => a.localeCompare(b))) {
+    if (!handled.has(key)) {
+      lines.push(`${INDENT}${key}: ${formatValue(value, 1)},`);
+    }
+  }
+  lines.push("});");
+  lines.push("");
+  return lines.join("\n");
+}
+function generateSchemaFile(components, componentFolders, datasources) {
+  const lines = [];
+  lines.push("import type { Schema as InferSchema, Story as InferStory } from '@storyblok/schema';");
+  lines.push("import type { MapiStory as InferStoryMapi } from '@storyblok/schema';");
+  lines.push("");
+  for (const component of components) {
+    const varName = componentVarName(component.name);
+    const fileName = componentFileName(component.name);
+    lines.push(`import { ${varName} } from './components/${fileName}';`);
+  }
+  for (const folder of componentFolders) {
+    const varName = folderVarName(folder.name);
+    const fileName = folderFileName(folder.name);
+    lines.push(`import { ${varName} } from './components/folders/${fileName}';`);
+  }
+  for (const datasource of datasources) {
+    const varName = datasourceVarName(datasource.name);
+    const fileName = datasourceFileName(datasource);
+    lines.push(`import { ${varName} } from './datasources/${fileName}';`);
+  }
+  lines.push("");
+  lines.push("export const schema = {");
+  if (components.length > 0) {
+    lines.push("  blocks: {");
+    for (const component of components) {
+      const varName = componentVarName(component.name);
+      lines.push(`    ${varName},`);
+    }
+    lines.push("  },");
+  }
+  if (componentFolders.length > 0) {
+    lines.push("  blockFolders: {");
+    for (const folder of componentFolders) {
+      const varName = folderVarName(folder.name);
+      lines.push(`    ${varName},`);
+    }
+    lines.push("  },");
+  }
+  if (datasources.length > 0) {
+    lines.push("  datasources: {");
+    for (const datasource of datasources) {
+      const varName = datasourceVarName(datasource.name);
+      lines.push(`    ${varName},`);
+    }
+    lines.push("  },");
+  }
+  lines.push("};");
+  lines.push("");
+  lines.push("export type Schema = InferSchema<typeof schema>;");
+  lines.push("export type Blocks = Schema['blocks'];");
+  lines.push("export type Story = InferStory<Blocks>;");
+  lines.push("export type StoryMapi = InferStoryMapi<Blocks>;");
+  lines.push("");
+  return lines.join("\n");
+}
+
+async function writeFileWithDirs(filePath, content) {
+  const dir = dirname(filePath);
+  await mkdir(dir, { recursive: true });
+  await writeFile(filePath, content, "utf-8");
+}
+async function writeSchemaFiles(targetPath, components, componentFolders, datasources) {
+  const writtenFiles = [];
+  for (const comp of components) {
+    const fileName = componentFileName(comp.name);
+    const filePath = join(targetPath, "components", `${fileName}.ts`);
+    await writeFileWithDirs(filePath, generateComponentFile(comp, componentFolders));
+    writtenFiles.push(filePath);
+  }
+  for (const folder of componentFolders) {
+    const fileName = folderFileName(folder.name);
+    const filePath = join(targetPath, "components", "folders", `${fileName}.ts`);
+    await writeFileWithDirs(filePath, generateFolderFile(folder));
+    writtenFiles.push(filePath);
+  }
+  for (const ds of datasources) {
+    const fileName = datasourceFileName(ds);
+    const filePath = join(targetPath, "datasources", `${fileName}.ts`);
+    await writeFileWithDirs(filePath, generateDatasourceFile(ds));
+    writtenFiles.push(filePath);
+  }
+  const schemaPath = join(targetPath, "schema.ts");
+  await writeFileWithDirs(schemaPath, generateSchemaFile(components, componentFolders, datasources));
+  writtenFiles.push(schemaPath);
+  return writtenFiles;
+}
+
+async function isTargetEmpty(targetPath) {
+  try {
+    const entries = await readdir(targetPath);
+    return entries.every((entry) => entry.startsWith("."));
+  } catch (maybeError) {
+    const error = maybeError;
+    if (error?.code === "ENOENT") {
+      return true;
+    }
+    throw error;
+  }
+}
+schemaCommand.command("init").description("Initialize a local code-driven schema workspace from an existing Storyblok space (one-time bootstrap)").option("-s, --space <space>", "space ID").option("--out-dir <dir>", "Output directory for generated bootstrap files", ".storyblok/schema").action(async (options, command) => {
+  const ui = getUI();
+  const logger = getLogger();
+  const reporter = getReporter();
+  const { space, verbose } = command.optsWithGlobals();
+  const { state } = session();
+  ui.title(commands.SCHEMA, colorPalette.SCHEMA, "Initializing schema...");
+  logger.info("Schema init started", { space });
+  if (!requireAuthentication(state, verbose)) {
+    return;
+  }
+  if (!space) {
+    handleError(new CommandError("Please provide the space as argument --space SPACE_ID."), verbose);
+    return;
+  }
+  const targetPath = resolve(options.outDir);
+  if (!await isTargetEmpty(targetPath)) {
+    handleError(
+      new CommandError(`Target directory ${targetPath} is not empty. \`schema init\` is a one-time bootstrap and refuses to overwrite existing files. Use \`schema push\` for ongoing changes, or remove the directory to re-bootstrap.`),
+      verbose
+    );
+    return;
+  }
+  const summary = { total: 0, succeeded: 0, failed: 0 };
+  try {
+    const fetchSpinner = ui.createSpinner(`Fetching schema from space ${space}...`);
+    let fetchResult;
+    try {
+      fetchResult = await fetchRemoteSchema(space);
+    } catch (maybeError) {
+      fetchSpinner.failed("Failed to fetch remote schema");
+      handleError(toError(maybeError), verbose);
+      return;
+    }
+    const { rawComponents, rawComponentFolders, rawDatasources } = fetchResult;
+    fetchSpinner.succeed(`Found: ${rawComponents.length} components, ${rawComponentFolders.length} component folders, ${rawDatasources.length} datasources`);
+    const writeSpinner = ui.createSpinner(`Generating TypeScript files to ${targetPath}...`);
+    const writtenFiles = await writeSchemaFiles(targetPath, rawComponents, rawComponentFolders, rawDatasources);
+    summary.total = writtenFiles.length;
+    summary.succeeded = writtenFiles.length;
+    writeSpinner.succeed(`Generated ${writtenFiles.length} files`);
+    ui.list(writtenFiles);
+    ui.warn("`schema init` is a one-time bootstrap step for adopting an existing space. Review generated files before continuing.");
+    ui.info("After bootstrapping, keep your local schema as the source of truth and use `schema push` for ongoing changes.");
+    ui.info("Make sure `@storyblok/schema` is installed in the project that imports these files (e.g. `pnpm add @storyblok/schema`).");
+  } catch (maybeError) {
+    summary.failed += 1;
+    handleError(toError(maybeError), verbose);
+  } finally {
+    logger.info("Schema init finished", { summary });
+    reporter.addSummary("schemaInitResults", summary);
+    reporter.finalize();
+  }
+});
+
+const API_ASSIGNED_FIELDS = [
+  "id",
+  "created_at",
+  "updated_at",
+  "real_name",
+  "all_presets",
+  "image",
+  "uuid"
+];
+function stripApiFields(payload) {
+  const result = { ...payload };
+  for (const field of API_ASSIGNED_FIELDS) {
+    delete result[field];
+  }
+  return result;
+}
+async function listChangesets(basePath) {
+  const dir = join(basePath, "schema", "changesets");
+  if (!await fileExists(dir)) {
+    return [];
+  }
+  const files = await readDirectory(dir);
+  return files.filter((f) => f.endsWith(".json")).sort().reverse().map((f) => join(dir, f));
+}
+async function loadChangeset(filePath) {
+  const content = await readFile$1(filePath, "utf-8");
+  return JSON.parse(content);
+}
+function buildRollbackOps(changeset) {
+  if (changeset.changes.length === 0) {
+    return [];
+  }
+  return changeset.changes.map((entry) => {
+    switch (entry.action) {
+      case "create":
+        return { type: entry.type, name: entry.name, action: "delete", payload: {} };
+      case "update":
+        return { type: entry.type, name: entry.name, action: "update", payload: entry.before ?? {} };
+      case "delete":
+        return { type: entry.type, name: entry.name, action: "create", payload: entry.before ?? {} };
+      default:
+        return { type: entry.type, name: entry.name, action: entry.action, payload: {} };
+    }
+  });
+}
+function rollbackAction(original) {
+  switch (original) {
+    case "create":
+      return "delete";
+    case "update":
+      return "update";
+    case "delete":
+      return "create";
+  }
+}
+function formatRollbackOutput(changes) {
+  const byType = {
+    component: [],
+    componentFolder: [],
+    datasource: []
+  };
+  for (const entry of changes) {
+    byType[entry.type]?.push(entry);
+  }
+  const icons = {
+    create: chalk.green("+"),
+    update: chalk.yellow("~"),
+    delete: chalk.red("-")
+  };
+  const lines = [];
+  const sections = [
+    ["Components", byType.component],
+    ["Component Folders", byType.componentFolder],
+    ["Datasources", byType.datasource]
+  ];
+  for (const [label, entries] of sections) {
+    if (entries.length === 0) {
+      continue;
+    }
+    lines.push(chalk.bold(label));
+    for (const entry of entries) {
+      const action = rollbackAction(entry.action);
+      const icon = icons[action] ?? " ";
+      const name = action === "delete" ? chalk.red(entry.name) : entry.name;
+      lines.push(`  ${icon} ${name} ${chalk.dim(`(${action})`)}`);
+      if (entry.action === "update" && entry.before && entry.after) {
+        let fromStr;
+        let toStr;
+        if (entry.type === "component") {
+          fromStr = serializeComponent(applyDefaults(entry.after, COMPONENT_DEFAULTS));
+          toStr = serializeComponent(applyDefaults(entry.before, COMPONENT_DEFAULTS));
+        } else if (entry.type === "componentFolder") {
+          fromStr = serializeComponentFolder(entry.after);
+          toStr = serializeComponentFolder(entry.before);
+        } else {
+          fromStr = serializeDatasource(entry.after);
+          toStr = serializeDatasource(entry.before);
+        }
+        if (fromStr !== toStr) {
+          const patch = createTwoFilesPatch(
+            `current/${entry.name}`,
+            `restore/${entry.name}`,
+            fromStr,
+            toStr,
+            "current",
+            "restore"
+          );
+          for (const line of patch.split("\n")) {
+            if (line.startsWith("+") && !line.startsWith("+++")) {
+              lines.push(`    ${chalk.green(line)}`);
+            } else if (line.startsWith("-") && !line.startsWith("---")) {
+              lines.push(`    ${chalk.red(line)}`);
+            }
+          }
+        }
+      }
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd();
+}
+async function executeRollback(spaceId, ops, remote) {
+  const client = getMapiClient();
+  const spaceIdNum = Number(spaceId);
+  let created = 0;
+  let updated = 0;
+  let deleted = 0;
+  const folderOps = ops.filter((op) => op.type === "componentFolder");
+  const componentOps = ops.filter((op) => op.type === "component");
+  const datasourceOps = ops.filter((op) => op.type === "datasource");
+  const folderUuidRemap = /* @__PURE__ */ new Map();
+  for (const op of folderOps.filter((o) => o.action !== "delete")) {
+    if (op.action === "create") {
+      const oldUuid = op.payload.uuid;
+      const payload = toComponentFolderCreate(stripApiFields(op.payload));
+      try {
+        const response = await client.componentFolders.create({
+          path: { space_id: spaceIdNum },
+          body: { component_group: payload },
+          throwOnError: true
+        });
+        const remoteUuid = response.data?.component_group?.uuid;
+        if (remoteUuid && typeof oldUuid === "string") {
+          folderUuidRemap.set(oldUuid, remoteUuid);
+        }
+        created++;
+      } catch (error) {
+        handleAPIError("push_component_group", error, `Failed to create folder ${op.name}`);
+      }
+    } else if (op.action === "update") {
+      const existing = remote.componentFolders.get(op.name);
+      if (existing?.id) {
+        const payload = toComponentFolderCreate(stripApiFields(op.payload));
+        try {
+          await client.componentFolders.update(existing.id, {
+            path: { space_id: spaceIdNum },
+            body: { component_group: payload },
+            throwOnError: true
+          });
+          updated++;
+        } catch (error) {
+          handleAPIError("update_component_group", error, `Failed to update folder ${op.name}`);
+        }
+      }
+    }
+  }
+  for (const op of componentOps) {
+    const oldUuid = op.payload.component_group_uuid;
+    if (typeof oldUuid !== "string") {
+      continue;
+    }
+    const newUuid = folderUuidRemap.get(oldUuid);
+    if (newUuid) {
+      op.payload.component_group_uuid = newUuid;
+    }
+  }
+  for (const op of componentOps.filter((o) => o.action !== "delete")) {
+    if (op.action === "create") {
+      const payload = toComponentCreate(stripApiFields(op.payload));
+      try {
+        await client.components.create({
+          path: { space_id: spaceIdNum },
+          body: { component: payload },
+          throwOnError: true
+        });
+        created++;
+      } catch (error) {
+        handleAPIError("push_component", error, `Failed to create component ${op.name}`);
+      }
+    } else if (op.action === "update") {
+      const existing = remote.components.get(op.name);
+      if (existing?.id) {
+        const payload = toComponentUpdate(stripApiFields(op.payload));
+        try {
+          await client.components.update(existing.id, {
+            path: { space_id: spaceIdNum },
+            body: { component: payload },
+            throwOnError: true
+          });
+          updated++;
+        } catch (error) {
+          handleAPIError("update_component", error, `Failed to update component ${op.name}`);
+        }
+      }
+    }
+  }
+  for (const op of datasourceOps.filter((o) => o.action !== "delete")) {
+    if (op.action === "create") {
+      const payload = toDatasourceCreate(stripApiFields(op.payload));
+      try {
+        await client.datasources.create({
+          path: { space_id: spaceIdNum },
+          body: { datasource: payload },
+          throwOnError: true
+        });
+        created++;
+      } catch (error) {
+        handleAPIError("push_datasource", error, `Failed to create datasource ${op.name}`);
+      }
+    } else if (op.action === "update") {
+      const existing = remote.datasources.get(op.name);
+      if (existing?.id) {
+        const payload = toDatasourceUpdate(stripApiFields(op.payload), existing);
+        try {
+          await client.datasources.update(existing.id, {
+            path: { space_id: spaceIdNum },
+            body: { datasource: payload },
+            throwOnError: true
+          });
+          updated++;
+        } catch (error) {
+          handleAPIError("update_datasource", error, `Failed to update datasource ${op.name}`);
+        }
+      }
+    }
+  }
+  for (const op of datasourceOps.filter((o) => o.action === "delete")) {
+    const existing = remote.datasources.get(op.name);
+    if (existing?.id) {
+      try {
+        await client.datasources.delete(existing.id, {
+          path: { space_id: spaceIdNum },
+          throwOnError: true
+        });
+        deleted++;
+      } catch (error) {
+        handleAPIError("delete_datasource", error, `Failed to delete datasource ${op.name}`);
+      }
+    }
+  }
+  for (const op of componentOps.filter((o) => o.action === "delete")) {
+    const existing = remote.components.get(op.name);
+    if (existing?.id) {
+      try {
+        await client.components.delete(existing.id, {
+          path: { space_id: spaceIdNum },
+          throwOnError: true
+        });
+        deleted++;
+      } catch (error) {
+        handleAPIError("push_component", error, `Failed to delete component ${op.name}`);
+      }
+    }
+  }
+  for (const op of folderOps.filter((o) => o.action === "delete")) {
+    const existing = remote.componentFolders.get(op.name);
+    if (existing?.id) {
+      try {
+        await client.componentFolders.delete(existing.id, {
+          path: { space_id: spaceIdNum },
+          throwOnError: true
+        });
+        deleted++;
+      } catch (error) {
+        handleAPIError("push_component_group", error, `Failed to delete folder ${op.name}`);
+      }
+    }
+  }
+  return { created, updated, deleted };
+}
+
+schemaCommand.command("rollback [changeset-file]").description("Roll back a Storyblok space to the state captured in a changeset").option("-s, --space <space>", "space ID").option("-p, --path <path>", "path for file storage").option("--dry-run", "Show what would be undone without applying changes", false).option("--yes", "Skip confirmation prompt", false).option("--latest", "Automatically select the most recent changeset", false).action(async (changesetFile, options, command) => {
+  const ui = getUI();
+  const logger = getLogger();
+  const reporter = getReporter();
+  const { space, path: basePath, verbose } = command.optsWithGlobals();
+  const { state } = session();
+  ui.title(commands.SCHEMA, colorPalette.SCHEMA, "Rolling back schema...");
+  logger.info("Schema rollback started", { changesetFile, space });
+  if (!requireAuthentication(state, verbose)) {
+    return;
+  }
+  if (!space) {
+    handleError(new CommandError("Please provide the space as argument --space SPACE_ID."), verbose);
+    return;
+  }
+  const summary = { total: 0, succeeded: 0, failed: 0 };
+  try {
+    const resolvedBase = resolvePath(basePath, "");
+    let resolvedFile;
+    if (changesetFile) {
+      resolvedFile = changesetFile;
+    } else if (options.latest) {
+      const available = await listChangesets(resolvedBase);
+      if (available.length === 0) {
+        ui.warn("No changesets found. Run `schema push` first to create one.");
+        return;
+      }
+      resolvedFile = available[0];
+      ui.info(`Using latest changeset: ${basename(resolvedFile)}`);
+    } else {
+      const available = await listChangesets(resolvedBase);
+      if (available.length === 0) {
+        ui.warn("No changesets found. Run `schema push` first to create one.");
+        return;
+      }
+      resolvedFile = await select({
+        message: "Select a changeset to roll back:",
+        choices: available.map((f) => ({ name: basename(f), value: f }))
+      });
+    }
+    let changeset;
+    try {
+      changeset = await loadChangeset(resolvedFile);
+    } catch (maybeError) {
+      handleError(toError(maybeError), verbose);
+      return;
+    }
+    logger.info("Changeset loaded", { file: resolvedFile, changes: changeset.changes.length });
+    const ops = buildRollbackOps(changeset);
+    if (ops.length === 0) {
+      ui.ok("Changeset has no changes \u2014 nothing to roll back.");
+      return;
+    }
+    ui.br();
+    ui.log(formatRollbackOutput(changeset.changes));
+    if (options.dryRun) {
+      ui.info("Dry run \u2014 no changes applied.");
+      logger.info("Dry run completed", { ops: ops.length });
+      return;
+    }
+    if (!options.yes) {
+      const confirmed = await confirm({
+        message: `Apply rollback of ${ops.length} change(s) from ${basename(resolvedFile)}?`,
+        default: false
+      });
+      if (!confirmed) {
+        ui.info("Rollback cancelled.");
+        return;
+      }
+    }
+    const remoteSpinner = ui.createSpinner(`Fetching current remote state from space ${space}...`);
+    let remoteResult;
+    try {
+      remoteResult = await fetchRemoteSchema(space);
+    } catch (maybeError) {
+      remoteSpinner.failed("Failed to fetch remote schema");
+      handleError(toError(maybeError), verbose);
+      return;
+    }
+    const { remote } = remoteResult;
+    remoteSpinner.succeed(`Remote: ${remote.components.size} components, ${remote.componentFolders.size} component folders, ${remote.datasources.size} datasources`);
+    const rollbackSpinner = ui.createSpinner("Applying rollback...");
+    let result;
+    try {
+      result = await executeRollback(space, ops, remote);
+    } catch (error) {
+      rollbackSpinner.failed("Failed to apply rollback");
+      throw error;
+    }
+    summary.total = result.created + result.updated + result.deleted;
+    summary.succeeded = summary.total;
+    rollbackSpinner.succeed(`Rolled back: ${result.created} created, ${result.updated} updated, ${result.deleted} deleted.`);
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const rollbackChangesetPath = await saveChangeset(resolvedBase, {
+      timestamp,
+      spaceId: Number(space),
+      remote: { components: remoteResult.rawComponents, componentFolders: remoteResult.rawComponentFolders, datasources: remoteResult.rawDatasources },
+      changes: ops.map((op) => ({
+        type: op.type,
+        name: op.name,
+        action: op.action,
+        ...Object.keys(op.payload).length > 0 && { after: op.payload }
+      }))
+    });
+    logger.info("Rollback changeset saved", { path: rollbackChangesetPath });
+  } catch (maybeError) {
+    summary.failed += 1;
+    handleError(toError(maybeError), verbose);
+  } finally {
+    logger.info("Schema rollback finished", { summary });
+    reporter.addSummary("schemaRollbackResults", summary);
+    reporter.finalize();
+  }
+});
+
 const program = getProgram();
 konsola.br();
 konsola.br();