contentful-import 10.4.0 → 10.5.1

package/dist/index.mjs

@@ -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_logging13 = __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 {
@@ -4961,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 {
@@ -4987,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" },
@@ -5090,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;
@@ -5111,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)));
     }
@@ -5140,7 +5141,8 @@ async function getDestinationData({
     experienceFragments: [],
     dataAssemblies: [],
     designTokens: [],
-    webhooks: []
+    webhooks: [],
+    releases: []
   };
   sourceData = {
     ...result,
@@ -5201,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);
@@ -5238,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";
@@ -5340,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";
@@ -5368,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 {
@@ -5389,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);
@@ -5645,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);
@@ -5753,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) {
@@ -5879,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",
@@ -5899,6 +5951,29 @@ var PARENT_FOLDER_GROUP_IDS = {
   fragment: "contentful.folder-group-fragment",
   experience: "contentful.folder-group-experience"
 };
+var VERSION_CONFLICT_MAX_ATTEMPTS = 5;
+var VERSION_CONFLICT_RETRY_DELAY_MS = 250;
+var MissingExoFolderGroupSchemesError = class extends Error {
+  constructor(missingSchemeIds) {
+    super(`Missing ExO folder-group concept scheme(s) in the destination organization: ${missingSchemeIds.join(", ")}`);
+    this.name = "MissingExoFolderGroupSchemesError";
+    this.missingSchemeIds = missingSchemeIds;
+  }
+};
+var SourceExoFolderConceptReadError = class extends Error {
+  constructor(sourceConceptId, error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    super(`Unable to read source ExO folder concept ${sourceConceptId}: ${reason}`);
+    this.name = "SourceExoFolderConceptReadError";
+    this.sourceConceptId = sourceConceptId;
+  }
+};
+var SourceOrganizationResolutionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SourceOrganizationResolutionError";
+  }
+};
 var ENTITY_TYPE_TO_PARENT_GROUP_ID = {
   designTokens: PARENT_FOLDER_GROUP_IDS.designToken,
   components: PARENT_FOLDER_GROUP_IDS.componentType,
@@ -5907,27 +5982,52 @@ 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;
     }
   }
   return void 0;
 }
-async function ensureParentFolderGroupsExist(client, organizationId) {
+function isVersionMismatchError(err) {
+  return err?.error?.sys?.id === "VersionMismatch";
+}
+async function waitForVersionConflictRetry(attempt) {
+  await new Promise((resolve2) => setTimeout(resolve2, VERSION_CONFLICT_RETRY_DELAY_MS * attempt));
+}
+async function resolveSourceOrganizationId(client, sourceSpaceId) {
+  if (!sourceSpaceId) {
+    throw new SourceOrganizationResolutionError(
+      "Unable to resolve the source organization because the exported ExO entity does not include a source space ID"
+    );
+  }
+  try {
+    const sourceSpace = await client.space.get({ spaceId: sourceSpaceId });
+    const sourceOrganizationId = sourceSpace?.sys?.organization?.sys?.id;
+    if (!sourceOrganizationId) {
+      throw new Error(`source space ${sourceSpaceId} has no organization link`);
+    }
+    return sourceOrganizationId;
+  } catch (err) {
+    if (err instanceof SourceOrganizationResolutionError) throw err;
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new SourceOrganizationResolutionError(
+      `Unable to resolve the source organization for space ${sourceSpaceId}: ${reason}`
+    );
+  }
+}
+async function ensureParentFolderGroupsExist(client, destinationOrganizationId, requiredParentGroupIds) {
+  if (requiredParentGroupIds.size === 0) return /* @__PURE__ */ new Map();
   const { items } = await client.conceptScheme.getMany({
-    organizationId,
+    organizationId: destinationOrganizationId,
     query: { purpose: "internal" }
   });
   const existingIds = new Set(items.map((s) => s.sys.id));
-  const allParentFolderGroupsExist = Object.values(PARENT_FOLDER_GROUP_IDS).every((id) => existingIds.has(id));
-  if (!allParentFolderGroupsExist) {
-    return /* @__PURE__ */ new Map();
-  }
-  const parentGroupIdSet = new Set(Object.values(PARENT_FOLDER_GROUP_IDS));
+  const missingSchemeIds = [...requiredParentGroupIds].filter((id) => !existingIds.has(id));
+  if (missingSchemeIds.length > 0) throw new MissingExoFolderGroupSchemesError(missingSchemeIds);
   return new Map(
-    items.filter((s) => parentGroupIdSet.has(s.sys.id)).map((s) => [s.sys.id, s])
+    items.filter((s) => requiredParentGroupIds.has(s.sys.id)).map((s) => [s.sys.id, s])
   );
 }
 function deriveChildConceptMap(sourceEntities, destinationSpaceId) {
@@ -5946,33 +6046,54 @@ function deriveChildConceptMap(sourceEntities, destinationSpaceId) {
   }
   return childConceptMap;
 }
-async function createOrPatchChildConcepts(client, organizationId, destinationSpaceId, childConceptMap) {
+async function createOrPatchChildConcepts(client, sourceOrganizationId, destinationOrganizationId, destinationSpaceId, childConceptMap) {
   const spaceLink = { sys: { type: "Link", linkType: "Space", id: destinationSpaceId } };
+  const existingDestinationConcepts = /* @__PURE__ */ new Map();
   for (const [sourceConceptId, { destConceptId }] of childConceptMap) {
-    let prefLabel = { "en-US": destConceptId };
-    try {
-      const sourceConcept = await client.concept.get({ organizationId, conceptId: sourceConceptId });
-      if (sourceConcept?.prefLabel) prefLabel = sourceConcept.prefLabel;
-    } catch {
-    }
     let existing = null;
     try {
-      existing = await client.concept.get({ organizationId, conceptId: destConceptId });
+      existing = await client.concept.get({
+        organizationId: destinationOrganizationId,
+        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}`);
       }
     }
+    existingDestinationConcepts.set(sourceConceptId, existing);
+  }
+  const sourceConceptLabels = /* @__PURE__ */ new Map();
+  for (const [sourceConceptId] of childConceptMap) {
+    if (existingDestinationConcepts.get(sourceConceptId)) {
+      continue;
+    }
+    try {
+      const sourceConcept = await client.concept.get({
+        organizationId: sourceOrganizationId,
+        conceptId: sourceConceptId
+      });
+      if (!sourceConcept?.prefLabel) {
+        throw new Error("source concept has no prefLabel");
+      }
+      sourceConceptLabels.set(sourceConceptId, sourceConcept.prefLabel);
+    } catch (err) {
+      throw new SourceExoFolderConceptReadError(sourceConceptId, err);
+    }
+  }
+  for (const [sourceConceptId, { destConceptId }] of childConceptMap) {
+    const existing = existingDestinationConcepts.get(sourceConceptId);
     if (!existing) {
+      const prefLabel = sourceConceptLabels.get(sourceConceptId);
       try {
         await client.concept.createWithId(
-          { organizationId, conceptId: destConceptId },
+          { organizationId: destinationOrganizationId, conceptId: destConceptId },
           // @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 = [];
@@ -5983,37 +6104,49 @@ async function createOrPatchChildConcepts(client, organizationId, destinationSpa
       if (patches.length > 0) {
         try {
           await client.concept.patch(
-            { organizationId, conceptId: destConceptId, version: existing.sys.version },
+            { organizationId: destinationOrganizationId, 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}`);
         }
       }
     }
   }
 }
-async function linkChildConceptsToParentGroups(client, organizationId, childConceptMap, parentGroups) {
+async function linkChildConceptsToParentGroups(client, destinationOrganizationId, childConceptMap, parentGroups) {
   for (const [, { destConceptId, parentGroupId }] of childConceptMap) {
-    const parentGroup = parentGroups.get(parentGroupId);
-    if (!parentGroup) continue;
-    const alreadyLinked = (parentGroup.concepts ?? []).some((c) => c.sys.id === destConceptId);
-    if (alreadyLinked) continue;
-    try {
-      const updated = await client.conceptScheme.patch(
-        { organizationId, conceptSchemeId: parentGroupId, version: parentGroup.sys.version },
-        [{ 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}`);
-    } catch (err) {
-      import_logging9.logEmitter.emit("error", `Failed to link child concept ${destConceptId} to parent group ${parentGroupId}: ${err?.message ?? err}`);
+    let parentGroup = parentGroups.get(parentGroupId);
+    for (let attempt = 1; parentGroup && attempt <= VERSION_CONFLICT_MAX_ATTEMPTS; attempt++) {
+      const alreadyLinked = (parentGroup.concepts ?? []).some((c) => c.sys.id === destConceptId);
+      if (alreadyLinked) break;
+      try {
+        const updated = await client.conceptScheme.patch(
+          { organizationId: destinationOrganizationId, conceptSchemeId: parentGroupId, version: parentGroup.sys.version },
+          [{ op: "add", path: "/concepts/-", value: { sys: { type: "Link", linkType: "TaxonomyConcept", id: destConceptId } } }]
+        );
+        parentGroups.set(parentGroupId, updated);
+        import_logging10.logEmitter.emit("info", `Linked child concept ${destConceptId} to parent group ${parentGroupId}`);
+        break;
+      } catch (err) {
+        if (!isVersionMismatchError(err) || attempt === VERSION_CONFLICT_MAX_ATTEMPTS) {
+          import_logging10.logEmitter.emit("error", `Failed to link child concept ${destConceptId} to parent group ${parentGroupId}: ${err?.message ?? err}`);
+          break;
+        }
+        import_logging10.logEmitter.emit("warning", `Version mismatch linking child concept ${destConceptId} to parent group ${parentGroupId}; retrying`);
+        await waitForVersionConflictRetry(attempt);
+        parentGroup = await client.conceptScheme.get({
+          organizationId: destinationOrganizationId,
+          conceptSchemeId: parentGroupId
+        });
+        parentGroups.set(parentGroupId, parentGroup);
+      }
     }
   }
 }
-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);
@@ -6024,25 +6157,31 @@ function rewriteEntityFolderConcepts(entities, childConceptMap) {
 }
 async function importExoFolders({
   client,
-  organizationId,
+  destinationOrganizationId,
   destinationSpaceId,
   sourceEntities
 }) {
   const sourceSpaceId = getSourceSpaceId(sourceEntities);
   if (sourceSpaceId === destinationSpaceId) {
-    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_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("info", "Source and destination space are the same \u2014 skipping ExO folder import");
     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}`);
-  await createOrPatchChildConcepts(client, organizationId, destinationSpaceId, childConceptMap);
-  await linkChildConceptsToParentGroups(client, organizationId, childConceptMap, parentGroups);
+  const requiredParentGroupIds = new Set(
+    [...childConceptMap.values()].map(({ parentGroupId }) => parentGroupId)
+  );
+  const sourceOrganizationId = await resolveSourceOrganizationId(client, sourceSpaceId);
+  const parentGroups = await ensureParentFolderGroupsExist(client, destinationOrganizationId, requiredParentGroupIds);
+  import_logging10.logEmitter.emit("info", `Importing ${childConceptMap.size} ExO folder concept(s) into destination space ${destinationSpaceId}`);
+  await createOrPatchChildConcepts(
+    client,
+    sourceOrganizationId,
+    destinationOrganizationId,
+    destinationSpaceId,
+    childConceptMap
+  );
+  await linkChildConceptsToParentGroups(client, destinationOrganizationId, childConceptMap, parentGroups);
   const allEntities = [
     ...sourceEntities.designTokens ?? [],
     ...sourceEntities.components ?? [],
@@ -6106,7 +6245,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);
@@ -6118,7 +6257,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);
@@ -6137,7 +6276,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;
     }
@@ -6188,15 +6327,15 @@ function pushToSpace({
     ...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.");
+    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;
@@ -6285,7 +6424,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,
@@ -6303,7 +6442,7 @@ function pushToSpace({
             return updatedEditorInterface;
           } catch (err) {
             err.entity = editorInterface;
-            import_logging11.logEmitter.emit("error", err);
+            import_logging12.logEmitter.emit("error", err);
             return null;
           }
         });
@@ -6321,7 +6460,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 },
@@ -6337,7 +6476,7 @@ function pushToSpace({
                 };
                 return upload;
               } catch (err) {
-                import_logging11.logEmitter.emit("error", err);
+                import_logging12.logEmitter.emit("error", err);
               }
             }));
           }
@@ -6472,7 +6611,7 @@ function pushToSpace({
           const space = await client.space.get({ spaceId });
           await importExoFolders({
             client,
-            organizationId: space.sys.organization.sys.id,
+            destinationOrganizationId: space.sys.organization.sys.id,
             destinationSpaceId: spaceId,
             sourceEntities: {
               designTokens: sourceData.designTokens,
@@ -6483,7 +6622,10 @@ function pushToSpace({
             }
           });
         } catch (error) {
-          import_logging11.logEmitter.emit("warning", `Unable to create Experience Orchestration (ExO) folders, error: ${error}`);
+          if (error instanceof MissingExoFolderGroupSchemesError || error instanceof SourceOrganizationResolutionError || error instanceof SourceExoFolderConceptReadError) {
+            throw error;
+          }
+          import_logging12.logEmitter.emit("warning", `Unable to create Experience Orchestration (ExO) folders, error: ${error}`);
         }
       }),
       skip: () => !includeExperienceOrchestration
@@ -6501,19 +6643,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;
           }
         }));
@@ -6543,17 +6685,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;
           }
         }));
@@ -6572,17 +6714,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;
@@ -6614,17 +6756,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;
           }
         }));
@@ -6656,17 +6798,17 @@ function pushToSpace({
             if (existing) {
               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 = { ...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;
@@ -6698,17 +6840,17 @@ function pushToSpace({
             if (existing) {
               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 = { ...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;
           }
         }));
@@ -6872,6 +7014,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);
 }
@@ -6911,24 +7065,24 @@ async function importVariantsForParents({
       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})`);
+        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_logging11.logEmitter.emit("error", err);
+        import_logging12.logEmitter.emit("error", err);
       }
     }
     return { parentId: parent2.sys.id, created };
   }));
 }
-function archiveEntities2({ entities, sourceEntities, client, spaceId, environmentId, requestQueue }) {
+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) {
@@ -6949,7 +7103,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;
     });
   }
@@ -6970,6 +7124,7 @@ __export(transformers_exports, {
   contentTypes: () => contentTypes,
   entries: () => entries,
   locales: () => locales,
+  releases: () => releases,
   tags: () => tags,
   webhooks: () => webhooks
 });
@@ -7025,6 +7180,9 @@ function removeMetadataTags(entity, tagsEnabled = false) {
   }
   return entity;
 }
+function releases(release) {
+  return release;
+}
 
 // lib/utils/sort-entries.ts
 function sortEntries(entries2) {
@@ -7274,24 +7432,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;
@@ -7381,13 +7539,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]}`);
 };
@@ -7490,7 +7648,8 @@ var SUPPORTED_ENTITY_TYPES = [
   "experienceTemplates",
   "dataAssemblies",
   "experienceFragments",
-  "experiences"
+  "experiences",
+  "releases"
 ];
 async function parseOptions(params) {
   const defaultOptions = {
@@ -7582,7 +7741,7 @@ async function parseOptions(params) {
 }
 
 // lib/utils/display-error-log.ts
-var import_logging12 = __toESM(require_logging());
+var import_logging13 = __toESM(require_logging());
 import { format as format2, parseISO } from "date-fns";
 function displayErrorLog(errorLog) {
   if (errorLog.length) {
@@ -7598,7 +7757,7 @@ function displayErrorLog(errorLog) {
 
 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));
+    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");
@@ -7630,7 +7789,7 @@ async function runContentfulImport(params) {
     intervalCap: options.rateLimit,
     carryoverConcurrencyCount: true
   });
-  (0, import_logging13.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) => {
@@ -7757,7 +7916,7 @@ async function runContentfulImport(params) {
     const displayLog = log.filter((logMessage) => logMessage.level !== "info");
     displayErrorLog(displayLog);
     if (errorLog.length) {
-      return (0, import_logging13.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;