contentful-import 10.3.0 → 10.5.0

package/dist/index.mjs

@@ -235,7 +235,7 @@ var require_logging = __commonJS({
         throw new Error("Unable to extract API error data");
       }
     }
-    function formatLogMessageOneLine(logMessage) {
+    function formatLogMessageOneLine2(logMessage) {
       const { level } = logMessage;
       if (!level) {
         return logMessage.toString().replace(/\s+/g, " ");
@@ -271,7 +271,7 @@ var require_logging = __commonJS({
         return logMessage.error.toString().replace(/\s+/g, " ");
       }
     }
-    exports2.formatLogMessageOneLine = formatLogMessageOneLine;
+    exports2.formatLogMessageOneLine = formatLogMessageOneLine2;
     function formatLogMessageLogfile(logMessage) {
       const { level } = logMessage;
       if (level === "info" || level === "warning") {
@@ -310,7 +310,7 @@ var require_logging = __commonJS({
 
 The following ${count.errors} errors and ${count.warnings} warnings occurred:
 `);
-        errorLog.map((logMessage) => `${(0, format_1.default)((0, parseISO_1.default)(logMessage.ts), "HH:mm:ss")} - ${formatLogMessageOneLine(logMessage)}`).map((logMessage) => console.log(logMessage));
+        errorLog.map((logMessage) => `${(0, format_1.default)((0, parseISO_1.default)(logMessage.ts), "HH:mm:ss")} - ${formatLogMessageOneLine2(logMessage)}`).map((logMessage) => console.log(logMessage));
         return;
       }
       console.log("No errors or warnings occurred");
@@ -357,7 +357,7 @@ The following ${count.errors} errors and ${count.warnings} warnings occurred:
     exports2.setupLogging = setupLogging2;
     function logToTaskOutput(task) {
       function logToTask(logMessage) {
-        const content = formatLogMessageOneLine(logMessage);
+        const content = formatLogMessageOneLine2(logMessage);
         const symbols = {
           info: figures_1.default.tick,
           warning: figures_1.default.warning,
@@ -570,12 +570,12 @@ var require_common = __commonJS({
             args.unshift("%O");
           }
           let index = 0;
-          args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format2) => {
+          args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format3) => {
             if (match === "%%") {
               return "%";
             }
             index++;
-            const formatter = createDebug.formatters[format2];
+            const formatter = createDebug.formatters[format3];
             if (typeof formatter === "function") {
               const val = args[index];
               match = formatter.call(self2, val);
@@ -4517,34 +4517,6 @@ var createBaseEach_default = createBaseEach;
 var baseEach = createBaseEach_default(baseForOwn_default);
 var baseEach_default = baseEach;
 
-// node_modules/lodash-es/defaults.js
-var objectProto18 = Object.prototype;
-var hasOwnProperty15 = objectProto18.hasOwnProperty;
-var defaults = baseRest_default(function(object, sources) {
-  object = Object(object);
-  var index = -1;
-  var length = sources.length;
-  var guard = length > 2 ? sources[2] : void 0;
-  if (guard && isIterateeCall_default(sources[0], sources[1], guard)) {
-    length = 1;
-  }
-  while (++index < length) {
-    var source = sources[index];
-    var props = keysIn_default(source);
-    var propsIndex = -1;
-    var propsLength = props.length;
-    while (++propsIndex < propsLength) {
-      var key = props[propsIndex];
-      var value = object[key];
-      if (value === void 0 || eq_default(value, objectProto18[key]) && !hasOwnProperty15.call(object, key)) {
-        object[key] = source[key];
-      }
-    }
-  }
-  return object;
-});
-var defaults_default = defaults;
-
 // node_modules/lodash-es/last.js
 function last(array) {
   var length = array == null ? 0 : array.length;
@@ -4625,10 +4597,10 @@ function map(collection, iteratee) {
 var map_default = map;
 
 // node_modules/lodash-es/_baseHas.js
-var objectProto19 = Object.prototype;
-var hasOwnProperty16 = objectProto19.hasOwnProperty;
+var objectProto18 = Object.prototype;
+var hasOwnProperty15 = objectProto18.hasOwnProperty;
 function baseHas(object, key) {
-  return object != null && hasOwnProperty16.call(object, key);
+  return object != null && hasOwnProperty15.call(object, key);
 }
 var baseHas_default = baseHas;
 
@@ -4682,8 +4654,8 @@ function negate(predicate) {
 var negate_default = negate;
 
 // node_modules/lodash-es/_baseUnset.js
-var objectProto20 = Object.prototype;
-var hasOwnProperty17 = objectProto20.hasOwnProperty;
+var objectProto19 = Object.prototype;
+var hasOwnProperty16 = objectProto19.hasOwnProperty;
 function baseUnset(object, path) {
   path = castPath_default(path, object);
   var index = -1, length = path.length;
@@ -4692,7 +4664,7 @@ function baseUnset(object, path) {
   }
   while (++index < length) {
     var key = toKey_default(path[index]);
-    if (key === "__proto__" && !hasOwnProperty17.call(object, "__proto__")) {
+    if (key === "__proto__" && !hasOwnProperty16.call(object, "__proto__")) {
       return false;
     }
     if ((key === "constructor" || key === "prototype") && index < length - 1) {
@@ -4855,7 +4827,7 @@ var startCase = createCompounder_default(function(result, word, index) {
 var startCase_default = startCase;
 
 // lib/index.ts
-var import_logging12 = __toESM(require_logging());
+var import_logging14 = __toESM(require_logging());
 var import_listr4 = __toESM(require_listr());
 import PQueue from "p-queue";
 
@@ -4889,17 +4861,17 @@ import Promise3 from "bluebird";
 
 // lib/utils/publish-exo-entities.ts
 var import_logging2 = __toESM(require_logging());
-function filterExoEntitiesToPublish(entities, sourceEntities) {
+function filterExoEntitiesToPublish(entities2, sourceEntities) {
   const entityIdsToPublish = new Set(
     sourceEntities.filter((entity) => entity.sys.publishedVersion).map((entity) => entity.sys.id)
   );
-  return entities.filter((entity) => entityIdsToPublish.has(entity.sys.id));
+  return entities2.filter((entity) => entityIdsToPublish.has(entity.sys.id));
 }
-function filterExoEntitiesToUnpublish(entities, sourceEntities) {
+function filterExoEntitiesToUnpublish(entities2, sourceEntities) {
   const entityIdsPublishedInSource = new Set(
     sourceEntities.filter((entity) => entity.sys.publishedVersion).map((entity) => entity.sys.id)
   );
-  return entities.filter((entity) => entity.sys.publishedVersion && !entityIdsPublishedInSource.has(entity.sys.id));
+  return entities2.filter((entity) => entity.sys.publishedVersion && !entityIdsPublishedInSource.has(entity.sys.id));
 }
 async function publishExoEntity(type, entity, publish) {
   try {
@@ -4922,6 +4894,34 @@ async function unpublishExoEntity(type, entity, unpublish) {
     return null;
   }
 }
+function filterVariantsToPublish(variants) {
+  return variants.filter((v) => v.sys.publishedVersion);
+}
+function filterVariantsToArchive(variants) {
+  return variants.filter((v) => v.sys.archivedVersion && !v.sys.publishedVersion);
+}
+async function publishVariant(type, entity, publish) {
+  try {
+    const result = await publish();
+    import_logging2.logEmitter.emit("info", `PUBLISH ${type} ${entity.sys.variant}`);
+    return result;
+  } catch (err) {
+    err.entity = entity;
+    import_logging2.logEmitter.emit("error", err);
+    return null;
+  }
+}
+async function archiveVariant(type, entity, archive) {
+  try {
+    const result = await archive();
+    import_logging2.logEmitter.emit("info", `ARCHIVE ${type} ${entity.sys.variant}`);
+    return result;
+  } catch (err) {
+    err.entity = entity;
+    import_logging2.logEmitter.emit("error", err);
+    return null;
+  }
+}
 function isExoEntitlementError(err) {
   if (!(err instanceof Error)) {
     return false;
@@ -4933,6 +4933,17 @@ function isExoEntitlementError(err) {
     return false;
   }
 }
+function isTimelineEntitlementError(err) {
+  if (!(err instanceof Error)) {
+    return false;
+  }
+  try {
+    const parsed = JSON.parse(err.message);
+    return parsed?.status === 403 && parsed?.details?.reasons === "Timeline is not enabled for this organization";
+  } catch {
+    return false;
+  }
+}
 var EXO_M1_FEATURE = "exoM1";
 async function spaceHasExoM1Entitlement(client, spaceId) {
   try {
@@ -4959,7 +4970,8 @@ var CURSOR_QUERY_METHODS = {
   experienceTemplates: { name: "experience templates", namespace: "experienceTemplate" },
   experienceFragments: { name: "experience fragments", namespace: "experienceFragment" },
   dataAssemblies: { name: "data assemblies", namespace: "dataAssembly" },
-  experiences: { name: "experiences", namespace: "experience" }
+  experiences: { name: "experiences", namespace: "experience" },
+  releases: { name: "releases", namespace: "release" }
 };
 var ENTITY_METHODS = {
   contentTypes: { name: "content types", ns: "contentType" },
@@ -5062,11 +5074,26 @@ async function cursorPaginatedQuery({ client, spaceId, environmentId, type, requ
   const allItems = [];
   do {
     const items = await requestQueue.add(async () => {
-      const response = await client[namespace].getMany({
-        spaceId,
-        environmentId,
-        query: { limit: BATCH_SIZE_LIMIT, ...pageNext && { pageNext } }
-      });
+      let response;
+      if (type === "releases") {
+        response = await client.release.query({
+          environmentId,
+          spaceId,
+          query: {
+            "metadata.annotations.Contentful:Timeline.type[nin]": "Staging,Hidden",
+            "sys.schemaVersion": "Release.v2",
+            "sys.status[in]": "active",
+            limit: BATCH_SIZE_LIMIT,
+            ...pageNext && { pageNext }
+          }
+        });
+      } else {
+        response = await client[namespace].getMany({
+          spaceId,
+          environmentId,
+          query: { limit: BATCH_SIZE_LIMIT, ...pageNext && { pageNext } }
+        });
+      }
       totalFetched += response.items.length;
       import_logging3.logEmitter.emit("info", `Fetched ${totalFetched} ${entityTypeName}`);
       pageNext = response.pages?.next;
@@ -5083,6 +5110,8 @@ async function cursorPaginatedQueryOrWarn(params) {
     const { name: entityTypeName } = CURSOR_QUERY_METHODS[params.type];
     if (isExoEntitlementError(err)) {
       import_logging3.logEmitter.emit("error", new Error(`Skipping ${entityTypeName} import: Experience Orchestration (ExO) is not enabled for this space`));
+    } else if (isTimelineEntitlementError(err)) {
+      import_logging3.logEmitter.emit("error", new Error(`Skipping ${entityTypeName} import: Timeline (Releases) is not enabled for this organization`));
     } else {
       import_logging3.logEmitter.emit("error", err instanceof Error ? err : new Error(String(err)));
     }
@@ -5112,7 +5141,8 @@ async function getDestinationData({
     experienceFragments: [],
     dataAssemblies: [],
     designTokens: [],
-    webhooks: []
+    webhooks: [],
+    releases: []
   };
   sourceData = {
     ...result,
@@ -5173,6 +5203,7 @@ async function getDestinationData({
       requestQueue
     });
   }
+  result.releases = cursorPaginatedQueryOrWarn({ client, spaceId, environmentId, type: "releases", requestQueue });
   if (includeExperienceOrchestration && client) {
     const sourceHasDesignTokens = Boolean(sourceData.designTokens?.length);
     const sourceHasComponents = Boolean(sourceData.components?.length);
@@ -5210,7 +5241,7 @@ async function getDestinationData({
 }
 
 // lib/tasks/push-to-space/push-to-space.ts
-var import_logging11 = __toESM(require_logging());
+var import_logging12 = __toESM(require_logging());
 var import_listr2 = __toESM(require_listr());
 import Listr from "listr";
 import verboseRenderer from "listr-verbose-renderer";
@@ -5312,14 +5343,14 @@ async function processAssets({
 // lib/tasks/push-to-space/creation.ts
 var import_get_entity_name2 = __toESM(require_get_entity_name());
 var import_logging5 = __toESM(require_logging());
-function createEntities({ context, entities, destinationEntitiesById, skipUpdates, requestQueue }) {
-  return createEntitiesWithConcurrency({ context, entities, destinationEntitiesById, skipUpdates, requestQueue });
+function createEntities({ context, entities: entities2, destinationEntitiesById, skipUpdates, requestQueue }) {
+  return createEntitiesWithConcurrency({ context, entities: entities2, destinationEntitiesById, skipUpdates, requestQueue });
 }
-function createLocales({ context, entities, destinationEntitiesById, requestQueue }) {
-  return createEntitiesInSequence({ context, entities, destinationEntitiesById, requestQueue });
+function createLocales({ context, entities: entities2, destinationEntitiesById, requestQueue }) {
+  return createEntitiesInSequence({ context, entities: entities2, destinationEntitiesById, requestQueue });
 }
-async function createEntitiesWithConcurrency({ context, entities, destinationEntitiesById, skipUpdates, requestQueue }) {
-  const pendingCreatedEntities = entities.map((entity) => {
+async function createEntitiesWithConcurrency({ context, entities: entities2, destinationEntitiesById, skipUpdates, requestQueue }) {
+  const pendingCreatedEntities = entities2.map((entity) => {
     const destinationEntity = getDestinationEntityForSourceEntity(destinationEntitiesById, entity.transformed);
     const updateOperation = skipUpdates ? "skip" : "update";
     const operation = destinationEntity ? updateOperation : "create";
@@ -5340,9 +5371,9 @@ async function createEntitiesWithConcurrency({ context, entities, destinationEnt
   const createdEntities = await Promise.all(pendingCreatedEntities);
   return createdEntities.filter((entity) => entity);
 }
-async function createEntitiesInSequence({ context, entities, destinationEntitiesById, requestQueue }) {
+async function createEntitiesInSequence({ context, entities: entities2, destinationEntitiesById, requestQueue }) {
   const createdEntities = [];
-  for (const entity of entities) {
+  for (const entity of entities2) {
     const destinationEntity = getDestinationEntityForSourceEntity(destinationEntitiesById, entity.transformed);
     const operation = destinationEntity ? "update" : "create";
     try {
@@ -5361,8 +5392,8 @@ async function createEntitiesInSequence({ context, entities, destinationEntities
   }
   return createdEntities;
 }
-async function createEntries({ context, entities, destinationEntitiesById, skipUpdates, requestQueue }) {
-  const createdEntries = await Promise.all(entities.map((entry) => {
+async function createEntries({ context, entities: entities2, destinationEntitiesById, skipUpdates, requestQueue }) {
+  const createdEntries = await Promise.all(entities2.map((entry) => {
     return createEntry({ entry, context, destinationEntitiesById, skipUpdates, requestQueue });
   }));
   return createdEntries.filter((entry) => entry);
@@ -5617,27 +5648,27 @@ function archiveEntity(client, spaceId, environmentId, entity) {
   }
   throw new Error(`archiveEntity: unsupported type "${type}"`);
 }
-async function publishEntities({ entities, client, spaceId, environmentId, requestQueue, localePublishing }) {
-  if (entities.length === 0) {
+async function publishEntities({ entities: entities2, client, spaceId, environmentId, requestQueue, localePublishing }) {
+  if (entities2.length === 0) {
     import_logging7.logEmitter.emit("info", "Skipping publishing since zero valid entities passed");
     return [];
   }
-  const entity = entities[0];
+  const entity = entities2[0];
   const type = entity.sys.type || "unknown type";
-  import_logging7.logEmitter.emit("info", `Publishing ${entities.length} ${type}s`);
-  const result = await runQueue(entities, [], client, spaceId, environmentId, requestQueue, localePublishing);
+  import_logging7.logEmitter.emit("info", `Publishing ${entities2.length} ${type}s`);
+  const result = await runQueue(entities2, [], client, spaceId, environmentId, requestQueue, localePublishing);
   import_logging7.logEmitter.emit("info", `Successfully published ${result.length} ${type}s`);
   return result;
 }
-async function archiveEntities({ entities, client, spaceId, environmentId, requestQueue }) {
-  if (entities.length === 0) {
+async function archiveEntities({ entities: entities2, client, spaceId, environmentId, requestQueue }) {
+  if (entities2.length === 0) {
     import_logging7.logEmitter.emit("info", "Skipping archiving since zero valid entities passed");
     return [];
   }
-  const entity = entities[0];
+  const entity = entities2[0];
   const type = entity.sys.type || "unknown type";
-  import_logging7.logEmitter.emit("info", `Archiving ${entities.length} ${type}s`);
-  const pendingArchivedEntities = entities.map((entity2) => {
+  import_logging7.logEmitter.emit("info", `Archiving ${entities2.length} ${type}s`);
+  const pendingArchivedEntities = entities2.map((entity2) => {
     return requestQueue.add(async () => {
       try {
         const archivedEntity = await archiveEntity(client, spaceId, environmentId, entity2);
@@ -5725,6 +5756,55 @@ async function runQueue(queue, result = [], client, spaceId, environmentId, requ
   return result;
 }
 
+// lib/tasks/push-to-space/releases.ts
+var import_logging8 = __toESM(require_logging());
+function partitionReleasesBySchemaVersion(releases2) {
+  return {
+    supported: releases2.filter((release) => release.transformed.sys.schemaVersion === "Release.v2"),
+    unsupported: releases2.filter((release) => release.transformed.sys.schemaVersion !== "Release.v2")
+  };
+}
+function logUnsupportedRelease(release) {
+  import_logging8.logEmitter.emit("error", new Error(
+    `Skipping Release "${release.transformed.sys.id}": only Release.v2 ("Releases") is supported, got schemaVersion "${release.transformed.sys.schemaVersion}"`
+  ));
+}
+function buildReleaseCreatePayload(release) {
+  const { id: _sourceId, ...sourceSysWithoutId } = release.transformed.sys;
+  return {
+    ...release.transformed,
+    entities: release.transformed.entities,
+    sys: { ...sourceSysWithoutId, type: "Release", schemaVersion: "Release.v2" }
+  };
+}
+function buildReleaseUpdatePayload(release) {
+  return {
+    ...release.transformed,
+    entities: release.transformed.entities,
+    sys: { type: "Release", schemaVersion: "Release.v2" }
+  };
+}
+async function importRelease(release, existing, context) {
+  const { client, spaceId, environmentId } = context;
+  try {
+    if (existing) {
+      const result2 = await client.release.update(
+        { spaceId, environmentId, releaseId: existing.sys.id, version: existing.sys.version },
+        buildReleaseUpdatePayload(release)
+      );
+      import_logging8.logEmitter.emit("info", `UPDATE Release ${existing.sys.id}`);
+      return result2;
+    }
+    const result = await client.release.create({ spaceId, environmentId }, buildReleaseCreatePayload(release));
+    import_logging8.logEmitter.emit("info", `CREATE Release ${result.sys.id}`);
+    return result;
+  } catch (err) {
+    err.entity = release.transformed;
+    import_logging8.logEmitter.emit("error", err);
+    return null;
+  }
+}
+
 // lib/utils/graphql-schema-backoff.ts
 var GRAPHQL_SCHEMA_STALE_DELAYS_MS = [500, 1500, 6e3];
 function isGraphQLSchemaStaleError(err) {
@@ -5851,18 +5931,18 @@ function sortExperienceFragments(experienceFragments) {
 }
 
 // lib/utils/sort-or-report.ts
-var import_logging8 = __toESM(require_logging());
+var import_logging9 = __toESM(require_logging());
 function sortOrReport(sortFn) {
   try {
     return sortFn();
   } catch (err) {
-    import_logging8.logEmitter.emit("error", err);
+    import_logging9.logEmitter.emit("error", err);
     throw err;
   }
 }
 
 // lib/utils/import-exo-folders.ts
-var import_logging9 = __toESM(require_logging());
+var import_logging10 = __toESM(require_logging());
 var FOLDER_CONCEPT_PREFIX = "contentful.folder-";
 var PARENT_FOLDER_GROUP_IDS = {
   designToken: "contentful.folder-group-designToken",
@@ -5879,8 +5959,8 @@ var ENTITY_TYPE_TO_PARENT_GROUP_ID = {
   experiences: PARENT_FOLDER_GROUP_IDS.experience
 };
 function getSourceSpaceId(sourceEntities) {
-  for (const entities of Object.values(sourceEntities)) {
-    for (const entity of entities ?? []) {
+  for (const entities2 of Object.values(sourceEntities)) {
+    for (const entity of entities2 ?? []) {
       const spaceId = entity.sys?.space?.sys?.id;
       if (spaceId) return spaceId;
     }
@@ -5932,7 +6012,7 @@ async function createOrPatchChildConcepts(client, organizationId, destinationSpa
       existing = await client.concept.get({ organizationId, conceptId: destConceptId });
     } catch (err) {
       if (err?.name !== "NotFound") {
-        import_logging9.logEmitter.emit("warning", `Could not fetch destination child concept ${destConceptId}: ${err?.message ?? err}`);
+        import_logging10.logEmitter.emit("warning", `Could not fetch destination child concept ${destConceptId}: ${err?.message ?? err}`);
       }
     }
     if (!existing) {
@@ -5942,9 +6022,9 @@ async function createOrPatchChildConcepts(client, organizationId, destinationSpa
           // @ts-expect-error - CMA.js type needs to be updated to be aware of purpose: 'internal'
           { purpose: "internal", prefLabel, metadata: { spaces: [spaceLink] } }
         );
-        import_logging9.logEmitter.emit("info", `Created child folder concept ${destConceptId}`);
+        import_logging10.logEmitter.emit("info", `Created child folder concept ${destConceptId}`);
       } catch (err) {
-        import_logging9.logEmitter.emit("error", `Failed to create child folder concept ${destConceptId}: ${err?.message ?? err}`);
+        import_logging10.logEmitter.emit("error", `Failed to create child folder concept ${destConceptId}: ${err?.message ?? err}`);
       }
     } else {
       const patches = [];
@@ -5958,9 +6038,9 @@ async function createOrPatchChildConcepts(client, organizationId, destinationSpa
             { organizationId, conceptId: destConceptId, version: existing.sys.version },
             patches
           );
-          import_logging9.logEmitter.emit("info", `Patched child folder concept ${destConceptId} (${patches.map((p) => p.path).join(", ")})`);
+          import_logging10.logEmitter.emit("info", `Patched child folder concept ${destConceptId} (${patches.map((p) => p.path).join(", ")})`);
         } catch (err) {
-          import_logging9.logEmitter.emit("error", `Failed to patch child folder concept ${destConceptId}: ${err?.message ?? err}`);
+          import_logging10.logEmitter.emit("error", `Failed to patch child folder concept ${destConceptId}: ${err?.message ?? err}`);
         }
       }
     }
@@ -5978,14 +6058,14 @@ async function linkChildConceptsToParentGroups(client, organizationId, childConc
         [{ op: "add", path: "/concepts/-", value: { sys: { type: "Link", linkType: "TaxonomyConcept", id: destConceptId } } }]
       );
       parentGroups.set(parentGroupId, updated);
-      import_logging9.logEmitter.emit("info", `Linked child concept ${destConceptId} to parent group ${parentGroupId}`);
+      import_logging10.logEmitter.emit("info", `Linked child concept ${destConceptId} to parent group ${parentGroupId}`);
     } catch (err) {
-      import_logging9.logEmitter.emit("error", `Failed to link child concept ${destConceptId} to parent group ${parentGroupId}: ${err?.message ?? err}`);
+      import_logging10.logEmitter.emit("error", `Failed to link child concept ${destConceptId} to parent group ${parentGroupId}: ${err?.message ?? err}`);
     }
   }
 }
-function rewriteEntityFolderConcepts(entities, childConceptMap) {
-  for (const entity of entities) {
+function rewriteEntityFolderConcepts(entities2, childConceptMap) {
+  for (const entity of entities2) {
     if (!entity.metadata?.concepts) continue;
     entity.metadata.concepts = entity.metadata.concepts.map((link) => {
       const entry = childConceptMap.get(link.sys.id);
@@ -6002,17 +6082,17 @@ async function importExoFolders({
 }) {
   const sourceSpaceId = getSourceSpaceId(sourceEntities);
   if (sourceSpaceId === destinationSpaceId) {
-    import_logging9.logEmitter.emit("info", "Source and destination space are the same \u2014 skipping ExO folder import");
+    import_logging10.logEmitter.emit("info", "Source and destination space are the same \u2014 skipping ExO folder import");
     return;
   }
   const parentGroups = await ensureParentFolderGroupsExist(client, organizationId);
   if (parentGroups.size === 0) {
-    import_logging9.logEmitter.emit("warn", "One or more Experience Orchestration folder group concept schemes are missing in the destination organization. Please create them before importing.");
+    import_logging10.logEmitter.emit("warn", "One or more Experience Orchestration folder group concept schemes are missing in the destination organization. Please create them before importing.");
     return;
   }
   const childConceptMap = deriveChildConceptMap(sourceEntities, destinationSpaceId);
   if (childConceptMap.size === 0) return;
-  import_logging9.logEmitter.emit("info", `Importing ${childConceptMap.size} ExO folder concept(s) into destination space ${destinationSpaceId}`);
+  import_logging10.logEmitter.emit("info", `Importing ${childConceptMap.size} ExO folder concept(s) into destination space ${destinationSpaceId}`);
   await createOrPatchChildConcepts(client, organizationId, destinationSpaceId, childConceptMap);
   await linkChildConceptsToParentGroups(client, organizationId, childConceptMap, parentGroups);
   const allEntities = [
@@ -6078,7 +6158,7 @@ function buildLocalePublishPlan(sourceEntities, destinationLocaleCodes, { destin
 }
 
 // lib/utils/destination-locales.ts
-var import_logging10 = __toESM(require_logging());
+var import_logging11 = __toESM(require_logging());
 var cache = /* @__PURE__ */ new WeakMap();
 function getDestinationLocaleCodes({ client, spaceId, environmentId, requestQueue }) {
   let byEnvironment = cache.get(client);
@@ -6090,7 +6170,7 @@ function getDestinationLocaleCodes({ client, spaceId, environmentId, requestQueu
   let localeCodes = byEnvironment.get(key);
   if (!localeCodes) {
     localeCodes = batchedPageQuery({ client, spaceId, environmentId, type: "locales", requestQueue }).then((items) => items.map((locale) => locale.code)).catch((err) => {
-      import_logging10.logEmitter.emit("warning", `Could not read the locales of the destination environment, falling back to publishing all locales: ${err.message}`);
+      import_logging11.logEmitter.emit("warning", `Could not read the locales of the destination environment, falling back to publishing all locales: ${err.message}`);
       return null;
     });
     byEnvironment.set(key, localeCodes);
@@ -6109,7 +6189,7 @@ async function withGraphQLSchemaBackoff(fn) {
         throw err;
       }
       const delay = GRAPHQL_SCHEMA_STALE_DELAYS_MS[attempt];
-      import_logging11.logEmitter.emit("warning", `DataAssembly GraphQL schema not yet current, retrying in ${delay}ms (attempt ${attempt + 1}/${GRAPHQL_SCHEMA_STALE_DELAYS_MS.length})`);
+      import_logging12.logEmitter.emit("warning", `DataAssembly GraphQL schema not yet current, retrying in ${delay}ms (attempt ${attempt + 1}/${GRAPHQL_SCHEMA_STALE_DELAYS_MS.length})`);
       await new Promise((resolve2) => setTimeout(resolve2, delay));
       lastErr = err;
     }
@@ -6132,6 +6212,7 @@ function pushToSpace({
   spaceId,
   environmentId,
   includeExperienceOrchestration,
+  skipExoVariants,
   contentModelOnly,
   skipContentModel,
   skipContentUpdates,
@@ -6154,13 +6235,20 @@ function pushToSpace({
     ...DEFAULT_CONTENT_STRUCTURE,
     ...destinationData
   };
+  const hasOptimizationVariants = [
+    ...sourceData.experiences || [],
+    ...sourceData.experienceFragments || []
+  ].some((parent2) => (parent2.optimizationVariants || []).some(isRealOptimizationVariant));
+  if (includeExperienceOrchestration && !skipExoVariants && hasOptimizationVariants) {
+    import_logging12.logEmitter.emit("warning", "Optimization Variants are imported with new destination IDs and can be duplicated by re-imports. Set skipExoVariants to true to skip them.");
+  }
   listrOptions = listrOptions || {
     renderer: verboseRenderer
   };
   const destinationDataById = {};
-  for (const [entityType, entities] of Object.entries(destinationData)) {
+  for (const [entityType, entities2] of Object.entries(destinationData)) {
     const entitiesById = /* @__PURE__ */ new Map();
-    for (const entity of entities) {
+    for (const entity of entities2) {
       entitiesById.set(entity.sys.id, entity);
     }
     destinationDataById[entityType] = entitiesById;
@@ -6249,7 +6337,7 @@ function pushToSpace({
             const ctEditorInterface = await requestQueue.add(
               () => client.editorInterface.get({ spaceId, environmentId, contentTypeId: contentType.sys.id })
             );
-            import_logging11.logEmitter.emit("info", `Fetched editor interface for ${contentType.name}`);
+            import_logging12.logEmitter.emit("info", `Fetched editor interface for ${contentType.name}`);
             const updatedData = {
               ...ctEditorInterface,
               controls: editorInterface.controls,
@@ -6267,7 +6355,7 @@ function pushToSpace({
             return updatedEditorInterface;
           } catch (err) {
             err.entity = editorInterface;
-            import_logging11.logEmitter.emit("error", err);
+            import_logging12.logEmitter.emit("error", err);
             return null;
           }
         });
@@ -6285,7 +6373,7 @@ function pushToSpace({
           for (const file of Object.values(asset.transformed.fields.file)) {
             allPendingUploads.push(requestQueue.add(async () => {
               try {
-                import_logging11.logEmitter.emit("info", `Uploading Asset file ${file.upload}`);
+                import_logging12.logEmitter.emit("info", `Uploading Asset file ${file.upload}`);
                 const assetStream = await getAssetStreamForURL(file.upload, assetsDirectory);
                 const upload = await client.upload.create(
                   { spaceId, environmentId },
@@ -6301,7 +6389,7 @@ function pushToSpace({
                 };
                 return upload;
               } catch (err) {
-                import_logging11.logEmitter.emit("error", err);
+                import_logging12.logEmitter.emit("error", err);
               }
             }));
           }
@@ -6447,7 +6535,7 @@ function pushToSpace({
             }
           });
         } catch (error) {
-          import_logging11.logEmitter.emit("warning", `Unable to create Experience Orchestration (ExO) folders, error: ${error}`);
+          import_logging12.logEmitter.emit("warning", `Unable to create Experience Orchestration (ExO) folders, error: ${error}`);
         }
       }),
       skip: () => !includeExperienceOrchestration
@@ -6465,19 +6553,19 @@ function pushToSpace({
                 { spaceId, environmentId, dataAssemblyId: entity.sys.id },
                 payload
               ));
-              import_logging11.logEmitter.emit("info", `UPDATE DataAssembly ${entity.sys.id}`);
+              import_logging12.logEmitter.emit("info", `UPDATE DataAssembly ${entity.sys.id}`);
             } else {
               const payload = { ...omitSys(entity), sys: buildDataAssemblySys(entity, 0) };
               result = await withGraphQLSchemaBackoff(() => client.dataAssembly.update(
                 { spaceId, environmentId, dataAssemblyId: entity.sys.id },
                 payload
               ));
-              import_logging11.logEmitter.emit("info", `CREATE DataAssembly ${entity.sys.id}`);
+              import_logging12.logEmitter.emit("info", `CREATE DataAssembly ${entity.sys.id}`);
             }
             return result;
           } catch (err) {
             err.entity = entity;
-            import_logging11.logEmitter.emit("error", err);
+            import_logging12.logEmitter.emit("error", err);
             return null;
           }
         }));
@@ -6507,17 +6595,17 @@ function pushToSpace({
             if (existing) {
               const payload = { ...entity, sys: { id: entity.sys.id, type: "DesignToken", version: existing.sys.version } };
               const result = await client.designToken.upsert({ spaceId, environmentId, designTokenId: entity.sys.id }, payload);
-              import_logging11.logEmitter.emit("info", `UPDATE DesignToken ${entity.sys.id}`);
+              import_logging12.logEmitter.emit("info", `UPDATE DesignToken ${entity.sys.id}`);
               return result;
             } else {
               const payload = { ...omitSys(entity), sys: { id: entity.sys.id, type: "DesignToken" } };
               const result = await client.designToken.upsert({ spaceId, environmentId, designTokenId: entity.sys.id }, payload);
-              import_logging11.logEmitter.emit("info", `CREATE DesignToken ${entity.sys.id}`);
+              import_logging12.logEmitter.emit("info", `CREATE DesignToken ${entity.sys.id}`);
               return result;
             }
           } catch (err) {
             err.entity = entity;
-            import_logging11.logEmitter.emit("error", err);
+            import_logging12.logEmitter.emit("error", err);
             return null;
           }
         }));
@@ -6536,17 +6624,17 @@ function pushToSpace({
             if (existing) {
               const payload = { ...entity, sys: { id: entity.sys.id, type: "Component", version: existing.sys.version } };
               const result = await client.component.upsert({ spaceId, environmentId, componentId: entity.sys.id }, payload);
-              import_logging11.logEmitter.emit("info", `UPDATE Component ${entity.sys.id}`);
+              import_logging12.logEmitter.emit("info", `UPDATE Component ${entity.sys.id}`);
               results.push(result);
             } else {
               const payload = { ...omitSys(entity), sys: { id: entity.sys.id, type: "Component" } };
               const result = await client.component.upsert({ spaceId, environmentId, componentId: entity.sys.id }, payload);
-              import_logging11.logEmitter.emit("info", `CREATE Component ${entity.sys.id}`);
+              import_logging12.logEmitter.emit("info", `CREATE Component ${entity.sys.id}`);
               results.push(result);
             }
           } catch (err) {
             err.entity = entity;
-            import_logging11.logEmitter.emit("error", err);
+            import_logging12.logEmitter.emit("error", err);
           }
         }
         ctx.data.components = results;
@@ -6578,17 +6666,17 @@ function pushToSpace({
             if (existing) {
               const payload = { ...entity, sys: { id: entity.sys.id, type: "ExperienceTemplate", version: existing.sys.version } };
               const result = await client.experienceTemplate.upsert({ spaceId, environmentId, experienceTemplateId: entity.sys.id }, payload);
-              import_logging11.logEmitter.emit("info", `UPDATE ExperienceTemplate ${entity.sys.id}`);
+              import_logging12.logEmitter.emit("info", `UPDATE ExperienceTemplate ${entity.sys.id}`);
               return result;
             } else {
               const payload = { ...omitSys(entity), sys: { id: entity.sys.id, type: "ExperienceTemplate" } };
               const result = await client.experienceTemplate.upsert({ spaceId, environmentId, experienceTemplateId: entity.sys.id }, payload);
-              import_logging11.logEmitter.emit("info", `CREATE ExperienceTemplate ${entity.sys.id}`);
+              import_logging12.logEmitter.emit("info", `CREATE ExperienceTemplate ${entity.sys.id}`);
               return result;
             }
           } catch (err) {
             err.entity = entity;
-            import_logging11.logEmitter.emit("error", err);
+            import_logging12.logEmitter.emit("error", err);
             return null;
           }
         }));
@@ -6618,19 +6706,19 @@ function pushToSpace({
           try {
             const existing = destinationDataById.experienceFragments?.get(entity.sys.id);
             if (existing) {
-              const payload = { ...entity, sys: { id: entity.sys.id, type: "ExperienceFragment", version: existing.sys.version } };
+              const payload = { ...omitSysAndOptimizationVariants(entity), sys: { id: entity.sys.id, type: "ExperienceFragment", version: existing.sys.version } };
               const result = await client.experienceFragment.upsert({ spaceId, environmentId, experienceFragmentId: entity.sys.id }, payload);
-              import_logging11.logEmitter.emit("info", `UPDATE ExperienceFragment ${entity.sys.id}`);
+              import_logging12.logEmitter.emit("info", `UPDATE ExperienceFragment ${entity.sys.id}`);
               results.push(result);
             } else {
-              const payload = { ...omitSys(entity), component: entity.sys.component, sys: { id: entity.sys.id, type: "ExperienceFragment" } };
+              const payload = { ...omitSysAndOptimizationVariants(entity), component: entity.sys.component, sys: { id: entity.sys.id, type: "ExperienceFragment" } };
               const result = await client.experienceFragment.upsert({ spaceId, environmentId, experienceFragmentId: entity.sys.id }, payload);
-              import_logging11.logEmitter.emit("info", `CREATE ExperienceFragment ${entity.sys.id}`);
+              import_logging12.logEmitter.emit("info", `CREATE ExperienceFragment ${entity.sys.id}`);
               results.push(result);
             }
           } catch (err) {
             err.entity = entity;
-            import_logging11.logEmitter.emit("error", err);
+            import_logging12.logEmitter.emit("error", err);
           }
         }
         ctx.data.experienceFragments = results;
@@ -6660,19 +6748,19 @@ function pushToSpace({
           try {
             const existing = destinationDataById.experiences?.get(entity.sys.id);
             if (existing) {
-              const payload = { ...entity, sys: { id: entity.sys.id, type: "Experience", version: existing.sys.version } };
+              const payload = { ...omitSysAndOptimizationVariants(entity), sys: { id: entity.sys.id, type: "Experience", version: existing.sys.version } };
               const result = await client.experience.upsert({ spaceId, environmentId, experienceId: entity.sys.id }, payload);
-              import_logging11.logEmitter.emit("info", `UPDATE Experience ${entity.sys.id}`);
+              import_logging12.logEmitter.emit("info", `UPDATE Experience ${entity.sys.id}`);
               return result;
             } else {
-              const payload = { ...omitSys(entity), experienceTemplate: entity.sys.experienceTemplate, sys: { id: entity.sys.id, type: "Experience" } };
+              const payload = { ...omitSysAndOptimizationVariants(entity), experienceTemplate: entity.sys.experienceTemplate, sys: { id: entity.sys.id, type: "Experience" } };
               const result = await client.experience.upsert({ spaceId, environmentId, experienceId: entity.sys.id }, payload);
-              import_logging11.logEmitter.emit("info", `CREATE Experience ${entity.sys.id}`);
+              import_logging12.logEmitter.emit("info", `CREATE Experience ${entity.sys.id}`);
               return result;
             }
           } catch (err) {
             err.entity = entity;
-            import_logging11.logEmitter.emit("error", err);
+            import_logging12.logEmitter.emit("error", err);
             return null;
           }
         }));
@@ -6693,6 +6781,85 @@ function pushToSpace({
       }),
       skip: () => !includeExperienceOrchestration || skipContentPublishing || !(sourceData.experiences || []).length
     },
+    // Optimization Variants are sub-resources nested on their parent Experience/ExperienceFragment
+    // (sourceData.experiences[].optimizationVariants), not a flat top-level array. A variant's
+    // sys.id is borrowed from its parent, not unique, so variant creation/publish/archive is
+    // handled by new, self-contained functions (importVariantsForParents, filterVariantsToPublish,
+    // filterVariantsToArchive, publishVariant, archiveVariant) rather than by generalizing
+    // destinationDataById / filterExoEntitiesToPublish / filterExoEntitiesToUnpublish, which all
+    // assume sys.id uniqueness.
+    //
+    // Unlike the base Experience/Fragment create/update, there is no upsert-by-known-ID for
+    // variants: the upstream API's create endpoint always server-generates a fresh variantId
+    // (crypto.randomUUID()) and its update endpoint 404s on an unknown variantId rather than
+    // creating one. So every import run creates fresh destination variants via POST rather than
+    // matching against any existing destination variant.
+    {
+      title: "Importing Experience Optimization Variants",
+      task: (0, import_listr2.wrapTask)(async (ctx) => {
+        const results = await importVariantsForParents({
+          parents: ctx.data.experiences || [],
+          sourceParents: sourceData.experiences || [],
+          client,
+          spaceId,
+          environmentId,
+          kind: "experience"
+        });
+        ctx.data.experienceVariants = results.flatMap((r) => r.created);
+      }),
+      skip: () => !includeExperienceOrchestration || skipExoVariants || !(sourceData.experiences || []).some((e) => (e.optimizationVariants || []).some(isRealOptimizationVariant))
+    },
+    {
+      title: "Publishing Experience Optimization Variants",
+      task: (0, import_listr2.wrapTask)(async (ctx) => {
+        const toPublish = filterVariantsToPublish(ctx.data.experienceVariants || []);
+        await Promise.all(toPublish.map(
+          (v) => publishVariant("ExperienceVariant", v, () => client.experienceVariant.publish(
+            { spaceId, environmentId, experienceId: v.sys.id, variantId: v.sys.variant, version: v.sys.version }
+          ))
+        ));
+        const toArchive = filterVariantsToArchive(ctx.data.experienceVariants || []);
+        await Promise.all(toArchive.map(
+          (v) => archiveVariant("ExperienceVariant", v, () => client.experienceVariant.archive(
+            { spaceId, environmentId, experienceId: v.sys.id, variantId: v.sys.variant, version: v.sys.version }
+          ))
+        ));
+      }),
+      skip: () => !includeExperienceOrchestration || skipExoVariants || skipContentPublishing || !(sourceData.experiences || []).some((e) => (e.optimizationVariants || []).some(isRealOptimizationVariant))
+    },
+    {
+      title: "Importing Experience Fragment Optimization Variants",
+      task: (0, import_listr2.wrapTask)(async (ctx) => {
+        const results = await importVariantsForParents({
+          parents: ctx.data.experienceFragments || [],
+          sourceParents: sourceData.experienceFragments || [],
+          client,
+          spaceId,
+          environmentId,
+          kind: "experienceFragment"
+        });
+        ctx.data.experienceFragmentVariants = results.flatMap((r) => r.created);
+      }),
+      skip: () => !includeExperienceOrchestration || skipExoVariants || !(sourceData.experienceFragments || []).some((f) => (f.optimizationVariants || []).some(isRealOptimizationVariant))
+    },
+    {
+      title: "Publishing Experience Fragment Optimization Variants",
+      task: (0, import_listr2.wrapTask)(async (ctx) => {
+        const toPublish = filterVariantsToPublish(ctx.data.experienceFragmentVariants || []);
+        await Promise.all(toPublish.map(
+          (v) => publishVariant("ExperienceFragmentVariant", v, () => client.experienceFragmentVariant.publish(
+            { spaceId, environmentId, experienceFragmentId: v.sys.id, variantId: v.sys.variant, version: v.sys.version }
+          ))
+        ));
+        const toArchive = filterVariantsToArchive(ctx.data.experienceFragmentVariants || []);
+        await Promise.all(toArchive.map(
+          (v) => archiveVariant("ExperienceFragmentVariant", v, () => client.experienceFragmentVariant.archive(
+            { spaceId, environmentId, experienceFragmentId: v.sys.id, variantId: v.sys.variant, version: v.sys.version }
+          ))
+        ));
+      }),
+      skip: () => !includeExperienceOrchestration || skipExoVariants || skipContentPublishing || !(sourceData.experienceFragments || []).some((f) => (f.optimizationVariants || []).some(isRealOptimizationVariant))
+    },
     // Unpublishing runs after all Importing/Publishing tasks, in reverse dependency order
     // (Experience first, DataAssembly last) - the API rejects unpublishing an entity that a
     // still-published parent references, so parents must unpublish before the children they embed.
@@ -6757,6 +6924,18 @@ function pushToSpace({
         ));
       }),
       skip: () => !includeExperienceOrchestration || skipContentPublishing || !(sourceData.dataAssemblies || []).length
+    },
+    {
+      title: "Importing Releases",
+      task: (0, import_listr2.wrapTask)(async (ctx) => {
+        const { supported: v2Releases, unsupported: v1Releases } = partitionReleasesBySchemaVersion(sourceData.releases || []);
+        v1Releases.forEach(logUnsupportedRelease);
+        const results = await Promise.all(v2Releases.map(
+          (release) => importRelease(release, destinationDataById.releases?.get(release.transformed.sys.id), { client, spaceId, environmentId })
+        ));
+        ctx.data.releases = results.filter(Boolean);
+      }),
+      skip: () => !(sourceData.releases || []).length
     }
   ], listrOptions);
 }
@@ -6764,14 +6943,56 @@ function omitSys(entity) {
   const { sys: _sys, ...rest } = entity;
   return rest;
 }
-function archiveEntities2({ entities, sourceEntities, client, spaceId, environmentId, requestQueue }) {
+function omitSysAndOptimizationVariants(entity) {
+  const { sys: _sys, optimizationVariants: _variants, ...rest } = entity;
+  return rest;
+}
+function omitVariantSys(variant) {
+  const { sys: _sys, ...rest } = variant;
+  return rest;
+}
+function isRealOptimizationVariant(variant) {
+  return Boolean(variant?.sys) && variant.sys.variantType !== "default";
+}
+async function importVariantsForParents({
+  parents,
+  sourceParents,
+  client,
+  spaceId,
+  environmentId,
+  kind
+}) {
+  const ns = kind === "experience" ? client.experienceVariant : client.experienceFragmentVariant;
+  const idParam = kind === "experience" ? "experienceId" : "experienceFragmentId";
+  const label = kind === "experience" ? "ExperienceVariant" : "ExperienceFragmentVariant";
+  const parentRefField = kind === "experience" ? "experienceTemplate" : "component";
+  const sourceParentsById = new Map(sourceParents.map((sourceParent) => [sourceParent.sys.id, sourceParent]));
+  return Promise.all(parents.map(async (parent2) => {
+    const sourceParent = sourceParentsById.get(parent2.sys.id);
+    const sourceVariants = (sourceParent?.optimizationVariants ?? []).filter(isRealOptimizationVariant);
+    const created = [];
+    for (const variant of sourceVariants) {
+      try {
+        const payload = { ...omitVariantSys(variant), [parentRefField]: variant.sys[parentRefField] };
+        const result = await ns.create({ spaceId, environmentId, [idParam]: parent2.sys.id }, payload);
+        import_logging12.logEmitter.emit("info", `CREATE ${label} ${result.sys.variant} (parent ${parent2.sys.id})`);
+        created.push({ ...result, sys: { ...result.sys, publishedVersion: variant.sys.publishedVersion, archivedVersion: variant.sys.archivedVersion } });
+      } catch (err) {
+        err.entity = variant;
+        import_logging12.logEmitter.emit("error", err);
+      }
+    }
+    return { parentId: parent2.sys.id, created };
+  }));
+}
+function archiveEntities2({ entities: entities2, sourceEntities, client, spaceId, environmentId, requestQueue }) {
   const entityIdsToArchive = sourceEntities.filter(({ original }) => original.sys.archivedVersion).map(({ original }) => original.sys.id);
-  const entitiesToArchive = entities.filter((entity) => entityIdsToArchive.indexOf(entity.sys.id) !== -1);
+  const entitiesToArchive = entities2.filter((entity) => entityIdsToArchive.indexOf(entity.sys.id) !== -1);
   return archiveEntities({ entities: entitiesToArchive, client, spaceId, environmentId, requestQueue });
 }
-async function publishEntities2({ entities, sourceEntities, client, spaceId, environmentId, requestQueue, destinationEntitiesById }) {
+async function publishEntities2({ entities: entities2, sourceEntities, client, spaceId, environmentId, requestQueue, destinationEntitiesById }) {
   const entityIdsToPublish = sourceEntities.filter(({ original }) => original.sys.publishedVersion).map(({ original }) => original.sys.id);
-  let entitiesToPublish = entities.filter((entity) => entityIdsToPublish.indexOf(entity.sys.id) !== -1);
+  let entitiesToPublish = entities2.filter((entity) => entityIdsToPublish.indexOf(entity.sys.id) !== -1);
   const publishAllLocales = () => publishEntities({ entities: entitiesToPublish, client, spaceId, environmentId, requestQueue });
   const hasFieldStatus = sourceEntities.some(({ original }) => original.sys.fieldStatus);
   if (!hasFieldStatus) {
@@ -6792,7 +7013,7 @@ async function publishEntities2({ entities, sourceEntities, client, spaceId, env
       if (!localePublishing.skippedEntityIds.has(entity.sys.id)) {
         return true;
       }
-      import_logging11.logEmitter.emit("warning", `Not publishing ${entity.sys.type} ${entity.sys.id} because none of the locales it was published for exist in the destination environment`);
+      import_logging12.logEmitter.emit("warning", `Not publishing ${entity.sys.type} ${entity.sys.id} because none of the locales it was published for exist in the destination environment`);
       return false;
     });
   }
@@ -6813,6 +7034,7 @@ __export(transformers_exports, {
   contentTypes: () => contentTypes,
   entries: () => entries,
   locales: () => locales,
+  releases: () => releases,
   tags: () => tags,
   webhooks: () => webhooks
 });
@@ -6868,6 +7090,9 @@ function removeMetadataTags(entity, tagsEnabled = false) {
   }
   return entity;
 }
+function releases(release) {
+  return release;
+}
 
 // lib/utils/sort-entries.ts
 function sortEntries(entries2) {
@@ -7117,24 +7342,24 @@ function upgradeExoResources(resources) {
 }
 
 // lib/transform/transform-space.ts
-var spaceEntities = [
+var entities = [
   "contentTypes",
   "entries",
   "assets",
   "locales",
   "webhooks",
-  "tags"
+  "tags",
+  "releases"
 ];
-function transform_space_default(sourceData, destinationData, customTransformers, entities = spaceEntities) {
-  const transformers = defaults_default(customTransformers, transformers_exports);
+function transform_space_default(sourceData, destinationData) {
   const baseSpaceData = upgradeExoResources(omit_default(sourceData, ...entities));
   sourceData.locales = sortLocales(sourceData.locales);
   const tagsEnabled = !!destinationData.tags;
   return entities.reduce((transformedSpaceData, type) => {
-    const sortedEntities = type === "tags" ? sourceData[type] ?? [] : sortEntries(sourceData[type] ?? []);
+    const sortedEntities = type === "tags" || type === "releases" ? sourceData[type] ?? [] : sortEntries(sourceData[type] ?? []);
     const transformedEntities = sortedEntities.map((entity) => ({
       original: entity,
-      transformed: transformers[type](entity, destinationData[type], tagsEnabled)
+      transformed: transformers_exports[type](entity, destinationData[type], tagsEnabled)
     }));
     transformedSpaceData[type] = transformedEntities;
     return transformedSpaceData;
@@ -7224,13 +7449,13 @@ var attachEntityName = (details, payload) => {
   });
 };
 var countInvalidEntities = (validationData) => {
-  const entityCount = validationData.reduce((entities, currentDetail) => {
-    if (!entities[currentDetail.path[0]]) {
-      entities[currentDetail.path[0]] = 1;
+  const entityCount = validationData.reduce((entities2, currentDetail) => {
+    if (!entities2[currentDetail.path[0]]) {
+      entities2[currentDetail.path[0]] = 1;
     } else {
-      entities[currentDetail.path[0]]++;
+      entities2[currentDetail.path[0]]++;
     }
-    return entities;
+    return entities2;
   }, {});
   return Object.keys(entityCount).map((key) => `${key}:${entityCount[key]}`);
 };
@@ -7333,7 +7558,8 @@ var SUPPORTED_ENTITY_TYPES = [
   "experienceTemplates",
   "dataAssemblies",
   "experienceFragments",
-  "experiences"
+  "experiences",
+  "releases"
 ];
 async function parseOptions(params) {
   const defaultOptions = {
@@ -7349,6 +7575,7 @@ async function parseOptions(params) {
     uploadAssets: false,
     rateLimit: 7,
     includeExperienceOrchestration: true,
+    skipExoVariants: false,
     host: "api.contentful.com"
   };
   const configFile = params.config ? __require(resolve(process.cwd(), params.config)) : {};
@@ -7423,6 +7650,29 @@ async function parseOptions(params) {
   return options;
 }
 
+// lib/utils/display-error-log.ts
+var import_logging13 = __toESM(require_logging());
+import { format as format2, parseISO } from "date-fns";
+function displayErrorLog(errorLog) {
+  if (errorLog.length) {
+    const count = errorLog.reduce((count2, curr) => {
+      if (Object.prototype.hasOwnProperty.call(curr, "warning")) {
+        count2.warnings++;
+      } else if (Object.prototype.hasOwnProperty.call(curr, "error")) {
+        count2.errors++;
+      }
+      return count2;
+    }, { warnings: 0, errors: 0 });
+    console.log(`
+
+The following ${count.errors} errors and ${count.warnings} warnings occurred:
+`);
+    errorLog.map((logMessage) => `${format2(parseISO(logMessage.ts), "HH:mm:ss")} - ${(0, import_logging13.formatLogMessageOneLine)(logMessage)}`).map((logMessage) => console.log(logMessage));
+    return;
+  }
+  console.log("No errors or warnings occurred");
+}
+
 // lib/index.ts
 var ONE_SECOND = 1e3;
 var tableOptions = {
@@ -7449,7 +7699,7 @@ async function runContentfulImport(params) {
     intervalCap: options.rateLimit,
     carryoverConcurrencyCount: true
   });
-  (0, import_logging12.setupLogging)(log);
+  (0, import_logging14.setupLogging)(log);
   const infoTable = new Table(tableOptions);
   infoTable.push([{ colSpan: 2, content: "The following entities are going to be imported:" }]);
   Object.keys(options.content).forEach((type) => {
@@ -7464,6 +7714,20 @@ async function runContentfulImport(params) {
     }
     infoTable.push([startCase_default(type), options.content[type].length]);
   });
+  const experienceVariantCount = (options.content.experiences || []).reduce(
+    (sum, e) => sum + (e.optimizationVariants?.length ?? 0),
+    0
+  );
+  if (!options.skipExoVariants && experienceVariantCount > 0) {
+    infoTable.push(["Experience Optimization Variants", experienceVariantCount]);
+  }
+  const experienceFragmentVariantCount = (options.content.experienceFragments || []).reduce(
+    (sum, f) => sum + (f.optimizationVariants?.length ?? 0),
+    0
+  );
+  if (!options.skipExoVariants && experienceFragmentVariantCount > 0) {
+    infoTable.push(["Experience Fragment Optimization Variants", experienceFragmentVariantCount]);
+  }
   console.log(infoTable.toString());
   const tasks = new Listr2([
     {
@@ -7512,6 +7776,7 @@ async function runContentfulImport(params) {
           client: ctx.client,
           spaceId: options.spaceId,
           includeExperienceOrchestration: options.includeExperienceOrchestration,
+          skipExoVariants: options.skipExoVariants,
           environmentId: options.environmentId,
           contentModelOnly: options.contentModelOnly,
           skipLocales: options.skipLocales,
@@ -7559,9 +7824,9 @@ async function runContentfulImport(params) {
   }).then((data) => {
     const errorLog = log.filter((logMessage) => logMessage.level !== "info" && logMessage.level !== "warning");
     const displayLog = log.filter((logMessage) => logMessage.level !== "info");
-    (0, import_logging12.displayErrorLog)(displayLog);
+    displayErrorLog(displayLog);
     if (errorLog.length) {
-      return (0, import_logging12.writeErrorLogFile)(options.errorLogFile, errorLog).then(() => {
+      return (0, import_logging14.writeErrorLogFile)(options.errorLogFile, errorLog).then(() => {
         const multiError = new ContentfulMultiError("Errors occurred");
         multiError.name = "ContentfulMultiError";
         multiError.errors = errorLog;