contentful-import 10.2.3 → 10.4.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);
@@ -2280,8 +2280,8 @@ function getNative(object, key) {
 var getNative_default = getNative;
 
 // node_modules/lodash-es/_WeakMap.js
-var WeakMap = getNative_default(root_default, "WeakMap");
-var WeakMap_default = WeakMap;
+var WeakMap2 = getNative_default(root_default, "WeakMap");
+var WeakMap_default = WeakMap2;
 
 // node_modules/lodash-es/_baseCreate.js
 var objectCreate = Object.create;
@@ -3007,12 +3007,12 @@ function memoize(func, resolver) {
     throw new TypeError(FUNC_ERROR_TEXT);
   }
   var memoized = function() {
-    var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
-    if (cache.has(key)) {
-      return cache.get(key);
+    var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache2 = memoized.cache;
+    if (cache2.has(key)) {
+      return cache2.get(key);
     }
     var result = func.apply(this, args);
-    memoized.cache = cache.set(key, result) || cache;
+    memoized.cache = cache2.set(key, result) || cache2;
     return result;
   };
   memoized.cache = new (memoize.Cache || MapCache_default)();
@@ -3025,12 +3025,12 @@ var memoize_default = memoize;
 var MAX_MEMOIZE_SIZE = 500;
 function memoizeCapped(func) {
   var result = memoize_default(func, function(key) {
-    if (cache.size === MAX_MEMOIZE_SIZE) {
-      cache.clear();
+    if (cache2.size === MAX_MEMOIZE_SIZE) {
+      cache2.clear();
     }
     return key;
   });
-  var cache = result.cache;
+  var cache2 = result.cache;
   return result;
 }
 var memoizeCapped_default = memoizeCapped;
@@ -4073,8 +4073,8 @@ function arraySome(array, predicate) {
 var arraySome_default = arraySome;
 
 // node_modules/lodash-es/_cacheHas.js
-function cacheHas(cache, key) {
-  return cache.has(key);
+function cacheHas(cache2, key) {
+  return cache2.has(key);
 }
 var cacheHas_default = cacheHas;
 
@@ -4855,7 +4855,7 @@ var startCase = createCompounder_default(function(result, word, index) {
 var startCase_default = startCase;
 
 // lib/index.ts
-var import_logging10 = __toESM(require_logging());
+var import_logging13 = __toESM(require_logging());
 var import_listr4 = __toESM(require_listr());
 import PQueue from "p-queue";
 
@@ -4922,6 +4922,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;
@@ -5210,7 +5238,7 @@ async function getDestinationData({
 }
 
 // lib/tasks/push-to-space/push-to-space.ts
-var import_logging9 = __toESM(require_logging());
+var import_logging11 = __toESM(require_logging());
 var import_listr2 = __toESM(require_listr());
 import Listr from "listr";
 import verboseRenderer from "listr-verbose-renderer";
@@ -5509,21 +5537,103 @@ function getPlainData(entity) {
 
 // lib/tasks/push-to-space/publishing.ts
 var import_get_entity_name3 = __toESM(require_get_entity_name());
+var import_logging7 = __toESM(require_logging());
+
+// lib/utils/locale-publishing.ts
 var import_logging6 = __toESM(require_logging());
-function publishEntity(client, spaceId, environmentId, entity) {
+var LOCALE_PUBLISHING_FEATURES = ["localeBasedPublishing", "localePublishing"];
+var ENABLE_ON_ENVIRONMENT = 'To preserve it, select "Locale-based (un)publishing" for the destination environment under Settings > Locales > Publishing options.';
+var NOT_ENTITLED = "Locale-based publishing is only available on some plans \u2014 contact Contentful to have it added.";
+async function spaceHasLocalePublishingEntitlement(client, spaceId) {
+  try {
+    const space = await client.space.get({ spaceId });
+    const organizationId = space.sys.organization?.sys?.id;
+    if (!organizationId) {
+      return null;
+    }
+    const entitlements = await client.raw.get(
+      `/organizations/${organizationId}/organization_entitlement_set`
+    );
+    const features = entitlements.features;
+    const known = LOCALE_PUBLISHING_FEATURES.filter((feature) => features?.[feature]?.value !== void 0);
+    if (!known.length) {
+      return null;
+    }
+    return known.some((feature) => features?.[feature]?.value === true);
+  } catch {
+    return null;
+  }
+}
+var localeScopingUnavailable = /* @__PURE__ */ new WeakSet();
+var entitlementChecks = /* @__PURE__ */ new WeakMap();
+async function ensureLocalePublishingEntitlement(client, spaceId) {
+  if (localeScopingUnavailable.has(client)) {
+    return;
+  }
+  let check = entitlementChecks.get(client);
+  if (!check) {
+    check = spaceHasLocalePublishingEntitlement(client, spaceId);
+    entitlementChecks.set(client, check);
+  }
+  if (await check === false) {
+    markLocaleScopingUnavailable(client, "The destination organization is not entitled to locale-based publishing.", NOT_ENTITLED);
+  }
+}
+function isLocaleScopingUnavailable(client) {
+  return localeScopingUnavailable.has(client);
+}
+function markLocaleScopingUnavailable(client, reason, remedy = ENABLE_ON_ENVIRONMENT) {
+  if (localeScopingUnavailable.has(client)) {
+    return;
+  }
+  localeScopingUnavailable.add(client);
+  import_logging6.logEmitter.emit("warning", `${reason} Publishing every locale instead \u2014 the per-locale publish state in the content file cannot be preserved. ${remedy}`);
+}
+function isLocalePublishingRejectedError(err) {
+  if (!(err instanceof Error)) {
+    return false;
+  }
+  const status = err.status ?? err.response?.status;
+  if (status === 403 || status === 400) {
+    return true;
+  }
+  try {
+    const parsed = JSON.parse(err.message)?.status;
+    return parsed === 403 || parsed === 400;
+  } catch {
+    return false;
+  }
+}
+function destinationScopedThePublish(publishedEntity) {
+  return Boolean(publishedEntity?.sys?.fieldStatus?.["*"]);
+}
+
+// lib/tasks/push-to-space/publishing.ts
+function publishEntity(client, spaceId, environmentId, entity, locales2) {
   const id = entity.sys.id;
   const type = entity.sys.type;
   if (type === "Entry") {
-    return client.entry.publish({ spaceId, environmentId, entryId: id }, entity);
+    return client.entry.publish({ spaceId, environmentId, entryId: id, locales: locales2 }, entity);
   }
   if (type === "Asset") {
-    return client.asset.publish({ spaceId, environmentId, assetId: id }, entity);
+    return client.asset.publish({ spaceId, environmentId, assetId: id, locales: locales2 }, entity);
   }
   if (type === "ContentType") {
     return client.contentType.publish({ spaceId, environmentId, contentTypeId: id }, entity);
   }
   throw new Error(`publishEntity: unsupported type "${type}"`);
 }
+function unpublishEntityLocales(client, spaceId, environmentId, entity, locales2) {
+  const id = entity.sys.id;
+  const type = entity.sys.type;
+  if (type === "Entry") {
+    return client.entry.unpublish({ spaceId, environmentId, entryId: id, locales: locales2 }, entity);
+  }
+  if (type === "Asset") {
+    return client.asset.unpublish({ spaceId, environmentId, assetId: id, locales: locales2 }, entity);
+  }
+  throw new Error(`unpublishEntityLocales: unsupported type "${type}"`);
+}
 function archiveEntity(client, spaceId, environmentId, entity) {
   const id = entity.sys.id;
   const type = entity.sys.type;
@@ -5535,26 +5645,26 @@ function archiveEntity(client, spaceId, environmentId, entity) {
   }
   throw new Error(`archiveEntity: unsupported type "${type}"`);
 }
-async function publishEntities({ entities, client, spaceId, environmentId, requestQueue }) {
+async function publishEntities({ entities, client, spaceId, environmentId, requestQueue, localePublishing }) {
   if (entities.length === 0) {
-    import_logging6.logEmitter.emit("info", "Skipping publishing since zero valid entities passed");
+    import_logging7.logEmitter.emit("info", "Skipping publishing since zero valid entities passed");
     return [];
   }
   const entity = entities[0];
   const type = entity.sys.type || "unknown type";
-  import_logging6.logEmitter.emit("info", `Publishing ${entities.length} ${type}s`);
-  const result = await runQueue(entities, [], client, spaceId, environmentId, requestQueue);
-  import_logging6.logEmitter.emit("info", `Successfully published ${result.length} ${type}s`);
+  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", `Successfully published ${result.length} ${type}s`);
   return result;
 }
 async function archiveEntities({ entities, client, spaceId, environmentId, requestQueue }) {
   if (entities.length === 0) {
-    import_logging6.logEmitter.emit("info", "Skipping archiving since zero valid entities passed");
+    import_logging7.logEmitter.emit("info", "Skipping archiving since zero valid entities passed");
     return [];
   }
   const entity = entities[0];
   const type = entity.sys.type || "unknown type";
-  import_logging6.logEmitter.emit("info", `Archiving ${entities.length} ${type}s`);
+  import_logging7.logEmitter.emit("info", `Archiving ${entities.length} ${type}s`);
   const pendingArchivedEntities = entities.map((entity2) => {
     return requestQueue.add(async () => {
       try {
@@ -5564,28 +5674,66 @@ async function archiveEntities({ entities, client, spaceId, environmentId, reque
         if (err instanceof ContentfulEntityError) {
           err.entity = entity2;
         }
-        import_logging6.logEmitter.emit("error", err);
+        import_logging7.logEmitter.emit("error", err);
         return null;
       }
     });
   });
   const allPossiblyArchivedEntities = await Promise.all(pendingArchivedEntities);
   const allArchivedEntities = allPossiblyArchivedEntities.filter((entity2) => entity2);
-  import_logging6.logEmitter.emit("info", `Successfully archived ${allArchivedEntities.length} ${type}s`);
+  import_logging7.logEmitter.emit("info", `Successfully archived ${allArchivedEntities.length} ${type}s`);
   return allArchivedEntities;
 }
-async function runQueue(queue, result = [], client, spaceId, environmentId, requestQueue) {
+async function publishEntityLocales(client, spaceId, environmentId, entity, locales2, localesToDemote) {
+  let published;
+  try {
+    published = await publishEntity(client, spaceId, environmentId, entity, locales2);
+  } catch (err) {
+    if (!isLocalePublishingRejectedError(err)) {
+      throw err;
+    }
+    markLocaleScopingUnavailable(client, `The destination rejected locale-scoped publishing, starting with ${entity.sys.type} ${(0, import_get_entity_name3.default)(entity)}.`);
+    return publishEntity(client, spaceId, environmentId, entity);
+  }
+  if (!destinationScopedThePublish(published)) {
+    markLocaleScopingUnavailable(client, `The destination published ${entity.sys.type} ${(0, import_get_entity_name3.default)(entity)} without honouring the requested locales (${locales2.join(", ")}) and reported no per-locale state back.`);
+    return published;
+  }
+  if (!localesToDemote?.length) {
+    return published;
+  }
+  import_logging7.logEmitter.emit("info", `Unpublishing locales ${localesToDemote.join(", ")} of ${entity.sys.type} ${(0, import_get_entity_name3.default)(entity)}`);
+  try {
+    return await unpublishEntityLocales(client, spaceId, environmentId, published, localesToDemote);
+  } catch (err) {
+    if (isLocalePublishingRejectedError(err)) {
+      markLocaleScopingUnavailable(client, `The destination rejected locale-scoped unpublishing, starting with ${entity.sys.type} ${(0, import_get_entity_name3.default)(entity)}.`);
+      return published;
+    }
+    if (err instanceof ContentfulEntityError) {
+      err.entity = entity;
+    }
+    import_logging7.logEmitter.emit("error", err);
+    return published;
+  }
+}
+async function runQueue(queue, result = [], client, spaceId, environmentId, requestQueue, localePublishing) {
   const publishedEntities = [];
   for (const entity of queue) {
-    import_logging6.logEmitter.emit("info", `Publishing ${entity.sys.type} ${(0, import_get_entity_name3.default)(entity)}`);
+    const locales2 = localePublishing && !isLocaleScopingUnavailable(client) ? localePublishing.localesByEntityId.get(entity.sys.id) : void 0;
+    if (locales2) {
+      import_logging7.logEmitter.emit("info", `Publishing ${entity.sys.type} ${(0, import_get_entity_name3.default)(entity)} for locales ${locales2.join(", ")}`);
+    } else {
+      import_logging7.logEmitter.emit("info", `Publishing ${entity.sys.type} ${(0, import_get_entity_name3.default)(entity)}`);
+    }
     try {
-      const publishedEntity = await requestQueue.add(() => publishEntity(client, spaceId, environmentId, entity));
+      const publishedEntity = await requestQueue.add(() => locales2 ? publishEntityLocales(client, spaceId, environmentId, entity, locales2, localePublishing?.demoteLocalesByEntityId.get(entity.sys.id)) : publishEntity(client, spaceId, environmentId, entity));
       publishedEntities.push(publishedEntity);
     } catch (err) {
       if (err instanceof ContentfulEntityError) {
         err.entity = entity;
       }
-      import_logging6.logEmitter.emit("error", err);
+      import_logging7.logEmitter.emit("error", err);
     }
   }
   result = [
@@ -5597,9 +5745,9 @@ async function runQueue(queue, result = [], client, spaceId, environmentId, requ
   if (unpublishedEntities.length > 0) {
     if (queue.length === unpublishedEntities.length) {
       const unpublishedEntityNames = unpublishedEntities.map(import_get_entity_name3.default).join(", ");
-      import_logging6.logEmitter.emit("error", `Could not publish the following entities: ${unpublishedEntityNames}`);
+      import_logging7.logEmitter.emit("error", `Could not publish the following entities: ${unpublishedEntityNames}`);
     } else {
-      return runQueue(unpublishedEntities, result, client, spaceId, environmentId, requestQueue);
+      return runQueue(unpublishedEntities, result, client, spaceId, environmentId, requestQueue, localePublishing);
     }
   }
   return result;
@@ -5731,18 +5879,18 @@ function sortExperienceFragments(experienceFragments) {
 }
 
 // lib/utils/sort-or-report.ts
-var import_logging7 = __toESM(require_logging());
+var import_logging8 = __toESM(require_logging());
 function sortOrReport(sortFn) {
   try {
     return sortFn();
   } catch (err) {
-    import_logging7.logEmitter.emit("error", err);
+    import_logging8.logEmitter.emit("error", err);
     throw err;
   }
 }
 
 // lib/utils/import-exo-folders.ts
-var import_logging8 = __toESM(require_logging());
+var import_logging9 = __toESM(require_logging());
 var FOLDER_CONCEPT_PREFIX = "contentful.folder-";
 var PARENT_FOLDER_GROUP_IDS = {
   designToken: "contentful.folder-group-designToken",
@@ -5812,7 +5960,7 @@ async function createOrPatchChildConcepts(client, organizationId, destinationSpa
       existing = await client.concept.get({ organizationId, conceptId: destConceptId });
     } catch (err) {
       if (err?.name !== "NotFound") {
-        import_logging8.logEmitter.emit("warning", `Could not fetch destination child concept ${destConceptId}: ${err?.message ?? err}`);
+        import_logging9.logEmitter.emit("warning", `Could not fetch destination child concept ${destConceptId}: ${err?.message ?? err}`);
       }
     }
     if (!existing) {
@@ -5822,9 +5970,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_logging8.logEmitter.emit("info", `Created child folder concept ${destConceptId}`);
+        import_logging9.logEmitter.emit("info", `Created child folder concept ${destConceptId}`);
       } catch (err) {
-        import_logging8.logEmitter.emit("error", `Failed to create child folder concept ${destConceptId}: ${err?.message ?? err}`);
+        import_logging9.logEmitter.emit("error", `Failed to create child folder concept ${destConceptId}: ${err?.message ?? err}`);
       }
     } else {
       const patches = [];
@@ -5838,9 +5986,9 @@ async function createOrPatchChildConcepts(client, organizationId, destinationSpa
             { organizationId, conceptId: destConceptId, version: existing.sys.version },
             patches
           );
-          import_logging8.logEmitter.emit("info", `Patched child folder concept ${destConceptId} (${patches.map((p) => p.path).join(", ")})`);
+          import_logging9.logEmitter.emit("info", `Patched child folder concept ${destConceptId} (${patches.map((p) => p.path).join(", ")})`);
         } catch (err) {
-          import_logging8.logEmitter.emit("error", `Failed to patch child folder concept ${destConceptId}: ${err?.message ?? err}`);
+          import_logging9.logEmitter.emit("error", `Failed to patch child folder concept ${destConceptId}: ${err?.message ?? err}`);
         }
       }
     }
@@ -5858,9 +6006,9 @@ async function linkChildConceptsToParentGroups(client, organizationId, childConc
         [{ op: "add", path: "/concepts/-", value: { sys: { type: "Link", linkType: "TaxonomyConcept", id: destConceptId } } }]
       );
       parentGroups.set(parentGroupId, updated);
-      import_logging8.logEmitter.emit("info", `Linked child concept ${destConceptId} to parent group ${parentGroupId}`);
+      import_logging9.logEmitter.emit("info", `Linked child concept ${destConceptId} to parent group ${parentGroupId}`);
     } catch (err) {
-      import_logging8.logEmitter.emit("error", `Failed to link child concept ${destConceptId} to parent group ${parentGroupId}: ${err?.message ?? err}`);
+      import_logging9.logEmitter.emit("error", `Failed to link child concept ${destConceptId} to parent group ${parentGroupId}: ${err?.message ?? err}`);
     }
   }
 }
@@ -5882,17 +6030,17 @@ async function importExoFolders({
 }) {
   const sourceSpaceId = getSourceSpaceId(sourceEntities);
   if (sourceSpaceId === destinationSpaceId) {
-    import_logging8.logEmitter.emit("info", "Source and destination space are the same \u2014 skipping ExO folder import");
+    import_logging9.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_logging8.logEmitter.emit("warn", "One or more Experience Orchestration folder group concept schemes are missing in the destination organization. Please create them before importing.");
+    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.");
     return;
   }
   const childConceptMap = deriveChildConceptMap(sourceEntities, destinationSpaceId);
   if (childConceptMap.size === 0) return;
-  import_logging8.logEmitter.emit("info", `Importing ${childConceptMap.size} ExO folder concept(s) into destination space ${destinationSpaceId}`);
+  import_logging9.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 = [
@@ -5905,6 +6053,79 @@ async function importExoFolders({
   rewriteEntityFolderConcepts(allEntities, childConceptMap);
 }
 
+// lib/utils/resolve-publish-locales.ts
+var LIVE_FIELD_STATUSES = ["published", "changed"];
+function resolvePublishLocales(sys, destinationLocaleCodes) {
+  const fieldStatus = sys.fieldStatus?.["*"];
+  if (!fieldStatus || !destinationLocaleCodes) {
+    return null;
+  }
+  const liveLocales = Object.keys(fieldStatus).filter((locale) => LIVE_FIELD_STATUSES.indexOf(fieldStatus[locale]) !== -1);
+  const availableLocales = liveLocales.filter((locale) => destinationLocaleCodes.indexOf(locale) !== -1);
+  if (availableLocales.length === 0) {
+    return [];
+  }
+  const everyLocaleIsLive = destinationLocaleCodes.every((locale) => availableLocales.indexOf(locale) !== -1);
+  return everyLocaleIsLive ? null : availableLocales;
+}
+function resolveLocalesToDemote(sys, destinationSys, destinationLocaleCodes) {
+  const fieldStatus = sys.fieldStatus?.["*"];
+  const destinationFieldStatus = destinationSys?.fieldStatus?.["*"];
+  if (!fieldStatus || !destinationFieldStatus) {
+    return [];
+  }
+  return Object.keys(fieldStatus).filter((locale) => fieldStatus[locale] === "draft").filter((locale) => destinationLocaleCodes.indexOf(locale) !== -1).filter((locale) => LIVE_FIELD_STATUSES.indexOf(destinationFieldStatus[locale]) !== -1);
+}
+function buildLocalePublishPlan(sourceEntities, destinationLocaleCodes, { destinationEntitiesById } = {}) {
+  const localesByEntityId = /* @__PURE__ */ new Map();
+  const skippedEntityIds = /* @__PURE__ */ new Set();
+  const demoteLocalesByEntityId = /* @__PURE__ */ new Map();
+  for (const { original } of sourceEntities) {
+    const locales2 = resolvePublishLocales(original.sys, destinationLocaleCodes);
+    if (locales2 === null) {
+      continue;
+    }
+    if (locales2.length === 0) {
+      skippedEntityIds.add(original.sys.id);
+      continue;
+    }
+    localesByEntityId.set(original.sys.id, locales2);
+    if (!destinationEntitiesById) {
+      continue;
+    }
+    const localesToDemote = resolveLocalesToDemote(
+      original.sys,
+      destinationEntitiesById.get(original.sys.id)?.sys,
+      destinationLocaleCodes
+    );
+    if (localesToDemote.length) {
+      demoteLocalesByEntityId.set(original.sys.id, localesToDemote);
+    }
+  }
+  return { localesByEntityId, skippedEntityIds, demoteLocalesByEntityId };
+}
+
+// lib/utils/destination-locales.ts
+var import_logging10 = __toESM(require_logging());
+var cache = /* @__PURE__ */ new WeakMap();
+function getDestinationLocaleCodes({ client, spaceId, environmentId, requestQueue }) {
+  let byEnvironment = cache.get(client);
+  if (!byEnvironment) {
+    byEnvironment = /* @__PURE__ */ new Map();
+    cache.set(client, byEnvironment);
+  }
+  const key = `${spaceId}/${environmentId}`;
+  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}`);
+      return null;
+    });
+    byEnvironment.set(key, localeCodes);
+  }
+  return localeCodes;
+}
+
 // lib/tasks/push-to-space/push-to-space.ts
 async function withGraphQLSchemaBackoff(fn) {
   let lastErr;
@@ -5916,7 +6137,7 @@ async function withGraphQLSchemaBackoff(fn) {
         throw err;
       }
       const delay = GRAPHQL_SCHEMA_STALE_DELAYS_MS[attempt];
-      import_logging9.logEmitter.emit("warning", `DataAssembly GraphQL schema not yet current, retrying in ${delay}ms (attempt ${attempt + 1}/${GRAPHQL_SCHEMA_STALE_DELAYS_MS.length})`);
+      import_logging11.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;
     }
@@ -5939,11 +6160,13 @@ function pushToSpace({
   spaceId,
   environmentId,
   includeExperienceOrchestration,
+  skipExoVariants,
   contentModelOnly,
   skipContentModel,
   skipContentUpdates,
   skipLocales,
   skipContentPublishing,
+  unpublishDraftLocales,
   timeout,
   retryLimit,
   listrOptions,
@@ -5960,6 +6183,13 @@ function pushToSpace({
     ...DEFAULT_CONTENT_STRUCTURE,
     ...destinationData
   };
+  const hasOptimizationVariants = [
+    ...sourceData.experiences || [],
+    ...sourceData.experienceFragments || []
+  ].some((parent2) => (parent2.optimizationVariants || []).some(isRealOptimizationVariant));
+  if (includeExperienceOrchestration && !skipExoVariants && hasOptimizationVariants) {
+    import_logging11.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
   };
@@ -6055,7 +6285,7 @@ function pushToSpace({
             const ctEditorInterface = await requestQueue.add(
               () => client.editorInterface.get({ spaceId, environmentId, contentTypeId: contentType.sys.id })
             );
-            import_logging9.logEmitter.emit("info", `Fetched editor interface for ${contentType.name}`);
+            import_logging11.logEmitter.emit("info", `Fetched editor interface for ${contentType.name}`);
             const updatedData = {
               ...ctEditorInterface,
               controls: editorInterface.controls,
@@ -6073,7 +6303,7 @@ function pushToSpace({
             return updatedEditorInterface;
           } catch (err) {
             err.entity = editorInterface;
-            import_logging9.logEmitter.emit("error", err);
+            import_logging11.logEmitter.emit("error", err);
             return null;
           }
         });
@@ -6091,7 +6321,7 @@ function pushToSpace({
           for (const file of Object.values(asset.transformed.fields.file)) {
             allPendingUploads.push(requestQueue.add(async () => {
               try {
-                import_logging9.logEmitter.emit("info", `Uploading Asset file ${file.upload}`);
+                import_logging11.logEmitter.emit("info", `Uploading Asset file ${file.upload}`);
                 const assetStream = await getAssetStreamForURL(file.upload, assetsDirectory);
                 const upload = await client.upload.create(
                   { spaceId, environmentId },
@@ -6107,7 +6337,7 @@ function pushToSpace({
                 };
                 return upload;
               } catch (err) {
-                import_logging9.logEmitter.emit("error", err);
+                import_logging11.logEmitter.emit("error", err);
               }
             }));
           }
@@ -6152,7 +6382,8 @@ function pushToSpace({
           client,
           spaceId,
           environmentId,
-          requestQueue
+          requestQueue,
+          destinationEntitiesById: unpublishDraftLocales ? destinationDataById.assets : void 0
         });
         ctx.data.publishedAssets = publishedAssets;
       }),
@@ -6196,7 +6427,8 @@ function pushToSpace({
           client,
           spaceId,
           environmentId,
-          requestQueue
+          requestQueue,
+          destinationEntitiesById: unpublishDraftLocales ? destinationDataById.entries : void 0
         });
         ctx.data.publishedEntries = publishedEntries;
       }),
@@ -6251,7 +6483,7 @@ function pushToSpace({
             }
           });
         } catch (error) {
-          import_logging9.logEmitter.emit("warning", `Unable to create Experience Orchestration (ExO) folders, error: ${error}`);
+          import_logging11.logEmitter.emit("warning", `Unable to create Experience Orchestration (ExO) folders, error: ${error}`);
         }
       }),
       skip: () => !includeExperienceOrchestration
@@ -6269,19 +6501,19 @@ function pushToSpace({
                 { spaceId, environmentId, dataAssemblyId: entity.sys.id },
                 payload
               ));
-              import_logging9.logEmitter.emit("info", `UPDATE DataAssembly ${entity.sys.id}`);
+              import_logging11.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_logging9.logEmitter.emit("info", `CREATE DataAssembly ${entity.sys.id}`);
+              import_logging11.logEmitter.emit("info", `CREATE DataAssembly ${entity.sys.id}`);
             }
             return result;
           } catch (err) {
             err.entity = entity;
-            import_logging9.logEmitter.emit("error", err);
+            import_logging11.logEmitter.emit("error", err);
             return null;
           }
         }));
@@ -6311,17 +6543,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_logging9.logEmitter.emit("info", `UPDATE DesignToken ${entity.sys.id}`);
+              import_logging11.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_logging9.logEmitter.emit("info", `CREATE DesignToken ${entity.sys.id}`);
+              import_logging11.logEmitter.emit("info", `CREATE DesignToken ${entity.sys.id}`);
               return result;
             }
           } catch (err) {
             err.entity = entity;
-            import_logging9.logEmitter.emit("error", err);
+            import_logging11.logEmitter.emit("error", err);
             return null;
           }
         }));
@@ -6340,17 +6572,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_logging9.logEmitter.emit("info", `UPDATE Component ${entity.sys.id}`);
+              import_logging11.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_logging9.logEmitter.emit("info", `CREATE Component ${entity.sys.id}`);
+              import_logging11.logEmitter.emit("info", `CREATE Component ${entity.sys.id}`);
               results.push(result);
             }
           } catch (err) {
             err.entity = entity;
-            import_logging9.logEmitter.emit("error", err);
+            import_logging11.logEmitter.emit("error", err);
           }
         }
         ctx.data.components = results;
@@ -6382,17 +6614,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_logging9.logEmitter.emit("info", `UPDATE ExperienceTemplate ${entity.sys.id}`);
+              import_logging11.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_logging9.logEmitter.emit("info", `CREATE ExperienceTemplate ${entity.sys.id}`);
+              import_logging11.logEmitter.emit("info", `CREATE ExperienceTemplate ${entity.sys.id}`);
               return result;
             }
           } catch (err) {
             err.entity = entity;
-            import_logging9.logEmitter.emit("error", err);
+            import_logging11.logEmitter.emit("error", err);
             return null;
           }
         }));
@@ -6422,19 +6654,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_logging9.logEmitter.emit("info", `UPDATE ExperienceFragment ${entity.sys.id}`);
+              import_logging11.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_logging9.logEmitter.emit("info", `CREATE ExperienceFragment ${entity.sys.id}`);
+              import_logging11.logEmitter.emit("info", `CREATE ExperienceFragment ${entity.sys.id}`);
               results.push(result);
             }
           } catch (err) {
             err.entity = entity;
-            import_logging9.logEmitter.emit("error", err);
+            import_logging11.logEmitter.emit("error", err);
           }
         }
         ctx.data.experienceFragments = results;
@@ -6464,19 +6696,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_logging9.logEmitter.emit("info", `UPDATE Experience ${entity.sys.id}`);
+              import_logging11.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_logging9.logEmitter.emit("info", `CREATE Experience ${entity.sys.id}`);
+              import_logging11.logEmitter.emit("info", `CREATE Experience ${entity.sys.id}`);
               return result;
             }
           } catch (err) {
             err.entity = entity;
-            import_logging9.logEmitter.emit("error", err);
+            import_logging11.logEmitter.emit("error", err);
             return null;
           }
         }));
@@ -6497,6 +6729,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.
@@ -6568,15 +6879,88 @@ function omitSys(entity) {
   const { sys: _sys, ...rest } = entity;
   return rest;
 }
+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_logging11.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_logging11.logEmitter.emit("error", err);
+      }
+    }
+    return { parentId: parent2.sys.id, created };
+  }));
+}
 function archiveEntities2({ entities, 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);
   return archiveEntities({ entities: entitiesToArchive, client, spaceId, environmentId, requestQueue });
 }
-function publishEntities2({ entities, sourceEntities, client, spaceId, environmentId, requestQueue }) {
+async function publishEntities2({ entities, sourceEntities, client, spaceId, environmentId, requestQueue, destinationEntitiesById }) {
   const entityIdsToPublish = sourceEntities.filter(({ original }) => original.sys.publishedVersion).map(({ original }) => original.sys.id);
-  const entitiesToPublish = entities.filter((entity) => entityIdsToPublish.indexOf(entity.sys.id) !== -1);
-  return publishEntities({ entities: entitiesToPublish, client, spaceId, environmentId, requestQueue });
+  let entitiesToPublish = entities.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) {
+    return publishAllLocales();
+  }
+  await ensureLocalePublishingEntitlement(client, spaceId);
+  if (isLocaleScopingUnavailable(client)) {
+    return publishAllLocales();
+  }
+  const destinationLocaleCodes = await getDestinationLocaleCodes({ client, spaceId, environmentId, requestQueue });
+  const localePublishing = buildLocalePublishPlan(
+    sourceEntities,
+    destinationLocaleCodes,
+    { destinationEntitiesById }
+  );
+  if (localePublishing.skippedEntityIds.size) {
+    entitiesToPublish = entitiesToPublish.filter((entity) => {
+      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`);
+      return false;
+    });
+  }
+  return publishEntities({
+    entities: entitiesToPublish,
+    client,
+    spaceId,
+    environmentId,
+    requestQueue,
+    localePublishing
+  });
 }
 
 // lib/transform/transformers.ts
@@ -7113,6 +7497,7 @@ async function parseOptions(params) {
     skipContentModel: false,
     skipLocales: false,
     skipContentPublishing: false,
+    unpublishDraftLocales: false,
     skipAssetUpdates: false,
     skipContentUpdates: false,
     useVerboseRenderer: false,
@@ -7121,6 +7506,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)) : {};
@@ -7195,6 +7581,29 @@ async function parseOptions(params) {
   return options;
 }
 
+// lib/utils/display-error-log.ts
+var import_logging12 = __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_logging12.formatLogMessageOneLine)(logMessage)}`).map((logMessage) => console.log(logMessage));
+    return;
+  }
+  console.log("No errors or warnings occurred");
+}
+
 // lib/index.ts
 var ONE_SECOND = 1e3;
 var tableOptions = {
@@ -7221,7 +7630,7 @@ async function runContentfulImport(params) {
     intervalCap: options.rateLimit,
     carryoverConcurrencyCount: true
   });
-  (0, import_logging10.setupLogging)(log);
+  (0, import_logging13.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) => {
@@ -7236,6 +7645,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([
     {
@@ -7284,11 +7707,13 @@ 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,
           skipContentModel: options.skipContentModel,
           skipContentPublishing: options.skipContentPublishing,
+          unpublishDraftLocales: options.unpublishDraftLocales,
           skipAssetUpdates: options.skipAssetUpdates,
           skipContentUpdates: options.skipContentUpdates,
           timeout: options.timeout,
@@ -7330,9 +7755,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_logging10.displayErrorLog)(displayLog);
+    displayErrorLog(displayLog);
     if (errorLog.length) {
-      return (0, import_logging10.writeErrorLogFile)(options.errorLogFile, errorLog).then(() => {
+      return (0, import_logging13.writeErrorLogFile)(options.errorLogFile, errorLog).then(() => {
         const multiError = new ContentfulMultiError("Errors occurred");
         multiError.name = "ContentfulMultiError";
         multiError.errors = errorLog;