storyblok 4.16.1 → 4.16.3

package/dist/index.mjs

@@ -681,6 +681,7 @@ const API_ACTIONS = {
   push_datasource: "Failed to push datasource",
   update_datasource: "Failed to update datasource",
   delete_datasource: "Failed to delete datasource",
+  delete_datasource_entry: "Failed to delete datasource entry",
   create_space: "Failed to create space",
   pull_spaces: "Failed to pull spaces",
   fetch_blueprints: "Failed to fetch blueprints from GitHub"
@@ -3995,6 +3996,8 @@ generateCmd$1.action(async (componentName, options, command) => {
   }
 });
 
+const normalizeFullSlug = (slug) => slug.replace(/\/$/, "");
+
 const fetchStories = async (spaceId, params) => {
   try {
     const client = getMapiClient();
@@ -4096,9 +4099,15 @@ const prefetchTargetStories = async (spaceId, options) => {
       options?.onTotal?.(total);
     }
     for (const story of response.stories) {
-      const ref = { id: story.id, uuid: story.uuid };
+      const ref = { id: story.id, uuid: story.uuid, is_folder: story.is_folder };
       if (story.full_slug) {
-        result.bySlug.set(story.full_slug, ref);
+        const key = normalizeFullSlug(story.full_slug);
+        const existing = result.bySlug.get(key);
+        if (existing) {
+          existing.push(ref);
+        } else {
+          result.bySlug.set(key, [ref]);
+        }
       }
       result.byId.set(story.id, ref);
     }
@@ -5874,7 +5883,7 @@ const upsertDatasource = async (space, datasource, existingId) => {
     return await pushDatasource(space, datasource);
   }
 };
-const pushDatasourceEntry = async (spaceId, datasourceId, entry) => {
+const pushDatasourceEntry = async (spaceId, datasourceId, entry, position) => {
   try {
     const client = getMapiClient();
     const { data } = await client.datasourceEntries.create({
@@ -5884,7 +5893,8 @@ const pushDatasourceEntry = async (spaceId, datasourceId, entry) => {
       body: {
         datasource_entry: {
           ...entry,
-          datasource_id: datasourceId
+          datasource_id: datasourceId,
+          ...position != null && { position }
         }
       },
       throwOnError: true
@@ -5894,7 +5904,7 @@ const pushDatasourceEntry = async (spaceId, datasourceId, entry) => {
     handleAPIError("push_datasource", error, `Failed to push datasource entry ${entry.name}`);
   }
 };
-const updateDatasourceEntry = async (spaceId, entryId, entry) => {
+const updateDatasourceEntry = async (spaceId, entryId, entry, position) => {
   try {
     const client = getMapiClient();
     await client.datasourceEntries.updateDatasourceEntry({
@@ -5903,7 +5913,10 @@ const updateDatasourceEntry = async (spaceId, entryId, entry) => {
         datasource_entry_id: entryId
       },
       body: {
-        datasource_entry: entry
+        datasource_entry: {
+          ...entry,
+          ...position != null && { position }
+        }
       },
       throwOnError: true
     });
@@ -5911,12 +5924,26 @@ const updateDatasourceEntry = async (spaceId, entryId, entry) => {
     handleAPIError("update_datasource", error, `Failed to update datasource entry ${entry.name}`);
   }
 };
-const upsertDatasourceEntry = async (space, datasourceId, entry, existingId) => {
+const upsertDatasourceEntry = async (space, datasourceId, entry, existingId, position) => {
   if (existingId) {
-    await updateDatasourceEntry(space, existingId, entry);
+    await updateDatasourceEntry(space, existingId, entry, position);
     return void 0;
   } else {
-    return await pushDatasourceEntry(space, datasourceId, entry);
+    return await pushDatasourceEntry(space, datasourceId, entry, position);
+  }
+};
+const deleteDatasourceEntry = async (spaceId, entryId) => {
+  try {
+    const client = getMapiClient();
+    await client.datasourceEntries.delete({
+      path: {
+        space_id: spaceId,
+        datasource_entry_id: entryId
+      },
+      throwOnError: true
+    });
+  } catch (error) {
+    handleAPIError("delete_datasource_entry", error, `Failed to delete datasource entry ${entryId}`);
   }
 };
 const readDatasourcesFiles = async (options) => {
@@ -5994,16 +6021,17 @@ const generateCmd = typesCommand.command("generate").description("Generate types
 ).option("--sf, --separate-files", "Generate one .d.ts file per component instead of a single combined file").option("--strict", "strict mode, no loose typing").option("--type-prefix <prefix>", "prefix to be prepended to all generated component type names").option("--type-suffix <suffix>", "suffix to be appended to all generated component type names").option("--suffix <suffix>", "Components suffix").option("--custom-fields-parser <path>", "Path to the parser file for Custom Field Types").option("--compiler-options <options>", "path to the compiler options from json-schema-to-typescript").option("-s, --space <space>", "space ID").option("-p, --path <path>", "path for file storage");
 generateCmd.action(async (options, command) => {
   konsola.title(`${commands.TYPES}`, colorPalette.TYPES, "Generating types...");
-  const { space, path, verbose } = command.optsWithGlobals();
+  const { space, path, verbose, suffix, filename, separateFiles } = command.optsWithGlobals();
   const spinner = new Spinner({
-    verbose: !isVitest
+    verbose
   });
   try {
     spinner.start(`Generating types...`);
     const componentsData = await readComponentsFiles({
       from: space,
       path,
-      suffix: options.suffix,
+      separateFiles,
+      suffix,
       verbose
     });
     let dataSourceData;
@@ -6011,7 +6039,8 @@ generateCmd.action(async (options, command) => {
       dataSourceData = await readDatasourcesFiles({
         from: space,
         path,
-        suffix: options.suffix,
+        separateFiles,
+        suffix,
         verbose
       });
     } catch (error) {
@@ -6029,18 +6058,17 @@ generateCmd.action(async (options, command) => {
       ...dataSourceData
     };
     const typedefData = await generateTypes(spaceDataWithComponentsAndDatasources, {
-      ...options,
-      path
+      ...options
     });
     if (typedefData) {
       await saveTypesToComponentsFile(space, typedefData, {
-        filename: options.filename,
+        filename,
         path,
-        separateFiles: options.separateFiles
+        separateFiles
       });
     }
     spinner.succeed();
-    if (options.separateFiles && options.filename) {
+    if (separateFiles && filename) {
       konsola.warn(`The --filename option is ignored when using --separate-files`);
     }
     konsola.ok(`Successfully generated types for space ${space}`, true);
@@ -6178,23 +6206,23 @@ pullCmd$2.action(async (datasourceName, options, command) => {
     handleError(new CommandError(`Please provide the space as argument --space YOUR_SPACE_ID.`), verbose);
     return;
   }
-  const spinnerDatasources = new Spinner({
-    verbose: !isVitest
-  });
+  const ui = getUI();
+  const logger = getLogger();
+  logger.info("Pulling datasources started", { space, datasourceName });
+  const spinnerDatasources = ui.createSpinner(`Fetching ${chalk.hex(colorPalette.DATASOURCES)("datasources")}`);
   try {
-    spinnerDatasources.start(`Fetching ${chalk.hex(colorPalette.DATASOURCES)("datasources")}`);
     let datasources;
     if (datasourceName) {
       const datasource = await fetchDatasource(space, datasourceName);
       if (!datasource) {
-        konsola.warn(`No datasource found with name "${datasourceName}"`);
+        spinnerDatasources.failed(`No datasource found with name "${datasourceName}"`);
         return;
       }
       datasources = [datasource];
     } else {
       datasources = await fetchDatasources(space);
       if (!datasources || datasources.length === 0) {
-        konsola.warn(`No datasources found in the space ${space}`);
+        spinnerDatasources.failed(`No datasources found in the space ${space}`);
         return;
       }
     }
@@ -6228,6 +6256,8 @@ pullCmd$2.action(async (datasourceName, options, command) => {
     spinnerDatasources.failed(`Fetching ${chalk.hex(colorPalette.DATASOURCES)("Datasources")} - Failed`);
     konsola.br();
     handleError(error, verbose);
+  } finally {
+    logger.info("Pulling datasources finished", { space, datasourceName });
   }
 });
 
@@ -6245,6 +6275,8 @@ pushCmd$2.action(async (datasourceName, options, command) => {
     handleError(new CommandError(`Please provide the target space as argument --space TARGET_SPACE_ID.`), verbose);
     return;
   }
+  const logger = getLogger();
+  logger.info("Pushing datasources started", { space, fromSpace, datasourceName, filter });
   konsola.info(`Attempting to push datasources ${chalk.bold("from")} space ${chalk.hex(colorPalette.DATASOURCES)(fromSpace)} ${chalk.bold("to")} ${chalk.hex(colorPalette.DATASOURCES)(space)}`);
   konsola.br();
   try {
@@ -6288,26 +6320,44 @@ pushCmd$2.action(async (datasourceName, options, command) => {
       successful: [],
       failed: []
     };
+    const ui = getUI();
     for (const datasource of spaceState.local.datasources) {
-      const spinner = new Spinner({
-        verbose: !isVitest
-      });
-      spinner.start(`Pushing ${chalk.hex(colorPalette.DATASOURCES)(datasource.name)}`);
+      const spinner = ui.createSpinner(`Pushing ${chalk.hex(colorPalette.DATASOURCES)(datasource.name)}`);
       const existingDatasource = spaceState.target.datasources.get(datasource.name);
       const existingId = existingDatasource?.id;
       const { entries, ...datasourceDefinition } = datasource;
       const result = await upsertDatasource(space, datasourceDefinition, existingId);
       if (result) {
         results.successful.push(datasource.name);
-        if (entries && entries.length > 0) {
-          for (const entry of entries) {
-            const existingEntryId = existingDatasource?.entries?.find((e) => e.name === entry.name)?.id;
-            try {
-              await upsertDatasourceEntry(space, result.id, entry, existingEntryId);
-            } catch (entryError) {
-              results.failed.push({ name: datasource.name, error: entryError });
-              spinner.failed(`${chalk.hex(colorPalette.DATASOURCES)(datasource.name)} - Failed in ${spinner.elapsedTime.toFixed(2)}ms`);
-            }
+        const localEntries = entries ?? [];
+        const existingEntries = existingDatasource?.entries ?? [];
+        const existingEntryMap = new Map(existingEntries.map((e, idx) => [e.name, { entry: e, position: idx + 1 }]));
+        for (let i = 0; i < localEntries.length; i++) {
+          const entry = localEntries[i];
+          const existing = existingEntryMap.get(entry.name);
+          const existingEntryId = existing?.entry.id;
+          const targetPosition = i + 1;
+          if (existing && existing.entry.value === entry.value && existing.entry.dimension_value === entry.dimension_value && existing.position === targetPosition) {
+            logger.info("Skipped datasource entry (unchanged)", { datasource: datasource.name, entry: entry.name, position: targetPosition });
+            continue;
+          }
+          try {
+            await upsertDatasourceEntry(space, result.id, entry, existingEntryId, i + 1);
+            logger.info(existingEntryId ? "Updated datasource entry" : "Created datasource entry", { datasource: datasource.name, entry: entry.name, position: i + 1 });
+          } catch (entryError) {
+            results.failed.push({ name: datasource.name, error: entryError });
+            spinner.failed(`${chalk.hex(colorPalette.DATASOURCES)(datasource.name)} - Failed in ${spinner.elapsedTime.toFixed(2)}ms`);
+          }
+        }
+        const localEntryNames = new Set(localEntries.map((e) => e.name));
+        const staleEntries = existingEntries.filter((e) => !localEntryNames.has(e.name));
+        for (const stale of staleEntries) {
+          try {
+            await deleteDatasourceEntry(space, stale.id);
+            logger.info("Deleted datasource entry", { datasource: datasource.name, entry: stale.name, entryId: stale.id });
+          } catch (entryError) {
+            results.failed.push({ name: datasource.name, error: entryError });
+            spinner.failed(`${chalk.hex(colorPalette.DATASOURCES)(datasource.name)} - Failed in ${spinner.elapsedTime.toFixed(2)}ms`);
           }
         }
         spinner.succeed(`${chalk.hex(colorPalette.DATASOURCES)(datasource.name)} - Completed in ${spinner.elapsedTime.toFixed(2)}ms`);
@@ -6328,6 +6378,8 @@ pushCmd$2.action(async (datasourceName, options, command) => {
     }
   } catch (error) {
     handleError(error, verbose);
+  } finally {
+    logger.info("Pushing datasources finished", { space, fromSpace });
   }
 });
 
@@ -6367,14 +6419,14 @@ deleteCmd.action(async (name, options, command) => {
     handleError(new CommandError("Please provide the space as argument --space YOUR_SPACE_ID."), verbose);
     return;
   }
-  const spinner = new Spinner({
-    verbose: !isVitest
-  });
+  const ui = getUI();
+  const logger = getLogger();
+  logger.info("Deleting datasource started", { space, name, id: options.id });
   try {
     if (options.id) {
-      spinner.start(`Deleting datasource...`);
+      const spinner = ui.createSpinner(`Deleting datasource...`);
       await deleteDatasource(space, options.id);
-      spinner.succeed();
+      spinner.succeed(`Datasource deleted`);
       konsola.ok(`Datasource ${chalk.hex(colorPalette.DATASOURCES)(options.id)} deleted successfully from space ${space}.`);
     } else {
       const datasource = await fetchDatasource(space, name);
@@ -6395,21 +6447,19 @@ deleteCmd.action(async (name, options, command) => {
           default: false
         });
         if (!confirmed) {
-          spinner.failed("Deletion aborted by user.");
           konsola.warn("Deletion aborted by user.");
           return;
         }
       }
-      spinner.start(`Deleting datasource...`);
+      const spinner = ui.createSpinner(`Deleting datasource...`);
       await deleteDatasource(space, datasource.id.toString());
-      spinner.succeed();
+      spinner.succeed(`Datasource deleted`);
       konsola.ok(`Datasource ${chalk.hex(colorPalette.DATASOURCES)(name)} deleted successfully from space ${space}.`);
     }
   } catch (error) {
-    spinner.failed(
-      `Failed to delete datasource ${chalk.hex(colorPalette.DATASOURCES)(options.id ? options.id : name)}`
-    );
     handleError(error, verbose);
+  } finally {
+    logger.info("Deleting datasource finished", { space, name, id: options.id });
   }
 });
 
@@ -8216,87 +8266,172 @@ const mapReferencesStream = ({
     }
   });
 };
-const makeCreateStoryAPITransport = ({ spaceId }) => async (localStory) => {
-  const { id: _id, uuid: _uuid, parent_id: _parentId, is_startpage: _isStartpage, content, ...newStoryData } = localStory;
-  if (!localStory.is_folder && !content?.component) {
-    throw new Error(`Story "${localStory.slug}" is missing a content type (content.component). Every story must define a content field with a valid component.`);
-  }
-  const remoteStory = await createStory(spaceId, {
-    story: {
-      ...newStoryData,
-      ...content?.component ? { content: { _uid: "", component: "__migration_artifact__" } } : {}
-    },
-    publish: 0
-  });
-  if (!remoteStory) {
-    throw new Error("No response!");
-  }
-  return remoteStory;
-};
-const makeAppendToManifestFSTransport = ({ manifestFile }) => async (localStory, remoteStory) => {
+const makeAppendToManifestFSTransport = ({ manifestFile }) => async (entry, remoteStory) => {
   const createdAt = (/* @__PURE__ */ new Date()).toISOString();
   await appendToFile(manifestFile, JSON.stringify({
-    old_id: localStory.uuid,
+    old_id: entry.uuid,
     new_id: remoteStory.uuid,
     created_at: createdAt
   }));
   await appendToFile(manifestFile, JSON.stringify({
-    old_id: localStory.id,
+    old_id: entry.id,
     new_id: remoteStory.id,
     created_at: createdAt
   }));
 };
-const createStoryPlaceholderStream = ({
+const scanLocalStoryIndex = async ({
+  directoryPath,
+  setTotalStories,
+  onIncrement,
+  onError
+}) => {
+  const files = (await readDirectory(directoryPath)).filter((f) => extname(f) === ".json");
+  setTotalStories?.(files.length);
+  const entries = [];
+  for (const file of files) {
+    try {
+      const filePath = join(directoryPath, file);
+      const fileContent = await readFile$1(filePath, "utf-8");
+      const story = JSON.parse(fileContent);
+      entries.push({
+        filename: file,
+        id: story.id,
+        uuid: story.uuid ?? "",
+        slug: story.slug ?? "",
+        name: story.name ?? "",
+        full_slug: story.full_slug ?? "",
+        is_folder: story.is_folder ?? false,
+        is_startpage: story.is_startpage === true,
+        parent_id: story.parent_id ?? null,
+        component: story.content?.component
+      });
+    } catch (maybeError) {
+      onError?.(toError(maybeError), file);
+    } finally {
+      onIncrement?.();
+    }
+  }
+  return entries;
+};
+const groupStoriesByDepth = (entries) => {
+  const depthMap = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const slug = normalizeFullSlug(entry.full_slug || "");
+    const depth = slug === "" ? 0 : slug.split("/").length - 1;
+    if (!depthMap.has(depth)) {
+      depthMap.set(depth, []);
+    }
+    depthMap.get(depth).push(entry);
+  }
+  const maxDepth = depthMap.size > 0 ? Math.max(...depthMap.keys()) : 0;
+  const levels = [];
+  for (let d = 0; d <= maxDepth; d++) {
+    const level = depthMap.get(d);
+    if (!level || level.length === 0) {
+      continue;
+    }
+    level.sort((a, b) => {
+      if (a.is_folder && !b.is_folder) {
+        return -1;
+      }
+      if (!a.is_folder && b.is_folder) {
+        return 1;
+      }
+      return 0;
+    });
+    levels.push(level);
+  }
+  return levels;
+};
+const findSlugMatch = ({
+  entry,
+  existingTargetStories,
+  claimedRemoteIds
+}) => {
+  const normalizedSlug = entry.full_slug ? normalizeFullSlug(entry.full_slug) : void 0;
+  const slugCandidates = normalizedSlug ? existingTargetStories.bySlug.get(normalizedSlug) : void 0;
+  if (!slugCandidates) {
+    return void 0;
+  }
+  const unclaimed = slugCandidates.filter((ref) => !claimedRemoteIds.has(ref.id));
+  return unclaimed.find((ref) => ref.is_folder === entry.is_folder) ?? unclaimed[0];
+};
+const createStoriesForLevel = async ({
+  level,
+  spaceId,
   maps,
   existingTargetStories,
+  claimedRemoteIds,
   isCrossSpace,
-  transports,
-  onIncrement,
+  dryRun,
+  appendToManifest,
   onStorySuccess,
   onStorySkipped,
   onStoryError
 }) => {
-  const processing = /* @__PURE__ */ new Set();
-  return new Writable({
-    objectMode: true,
-    async write(localStory, _encoding, callback) {
-      await apiConcurrencyLock.acquire();
-      const task = (async () => {
-        try {
-          const mappedStoryId = maps.stories?.get(localStory.id);
-          const mappedRemoteStory = mappedStoryId ? existingTargetStories.byId.get(Number(mappedStoryId)) : void 0;
-          if (mappedRemoteStory) {
-            onStorySkipped?.(localStory, mappedRemoteStory);
-            return;
-          }
-          const existingBySlug = localStory.full_slug ? existingTargetStories.bySlug.get(localStory.full_slug) : void 0;
-          if (existingBySlug) {
-            const isMatchConfirmed = isCrossSpace || existingBySlug.uuid === localStory.uuid;
-            if (isMatchConfirmed) {
-              await transports.appendStoryManifest(localStory, existingBySlug);
-              onStorySkipped?.(localStory, existingBySlug);
-              return;
-            }
-          }
-          const newRemoteStory = await transports.createStory(localStory);
-          await transports.appendStoryManifest(localStory, newRemoteStory);
-          onStorySuccess?.(localStory, newRemoteStory);
-        } catch (maybeError) {
-          onStoryError?.(toError(maybeError), localStory);
+  const processEntry = async (entry) => {
+    await apiConcurrencyLock.acquire();
+    try {
+      const mappedStoryId = maps.stories?.get(entry.id);
+      const mappedRemoteStory = mappedStoryId ? existingTargetStories.byId.get(Number(mappedStoryId)) : void 0;
+      if (mappedRemoteStory) {
+        claimedRemoteIds.add(mappedRemoteStory.id);
+        onStorySkipped?.(entry, mappedRemoteStory, "matched by manifest mapping from a previous push");
+        return;
+      }
+      const match = findSlugMatch({ entry, existingTargetStories, claimedRemoteIds });
+      if (match) {
+        const isMatchConfirmed = isCrossSpace || match.uuid === entry.uuid;
+        if (isMatchConfirmed) {
+          claimedRemoteIds.add(match.id);
+          await appendToManifest(entry, match);
+          onStorySkipped?.(entry, match, "matched by slug in target space");
+          return;
         }
-      })();
-      processing.add(task);
-      task.finally(() => {
-        onIncrement?.();
-        apiConcurrencyLock.release();
-        processing.delete(task);
+      }
+      if (!entry.is_folder && !entry.component) {
+        throw new Error(`Story "${entry.slug}" (${entry.filename}) is missing a content type (content.component). Every story must define a content field with a valid component.`);
+      }
+      const resolvedParentId = entry.parent_id != null ? maps.stories?.get(entry.parent_id) : void 0;
+      if (dryRun) {
+        const fakeRemote = { id: entry.id, uuid: entry.uuid };
+        onStorySuccess?.(entry, fakeRemote);
+        return;
+      }
+      const remoteStory = await createStory(spaceId, {
+        story: {
+          slug: entry.slug,
+          name: entry.name,
+          is_folder: entry.is_folder,
+          ...resolvedParentId != null ? { parent_id: Number(resolvedParentId) } : {},
+          ...entry.is_startpage && resolvedParentId != null ? { is_startpage: true } : {},
+          ...entry.component ? { content: { _uid: "", component: entry.component } } : {}
+        },
+        publish: 0
       });
-      callback();
-    },
-    final(callback) {
-      Promise.all(processing).finally(() => callback());
+      if (!remoteStory) {
+        throw new Error("No response!");
+      }
+      await appendToManifest(entry, remoteStory);
+      onStorySuccess?.(entry, remoteStory);
+    } catch (maybeError) {
+      onStoryError?.(toError(maybeError), entry);
+    } finally {
+      apiConcurrencyLock.release();
     }
-  });
+  };
+  const folders = level.filter((e) => e.is_folder);
+  const nonFolders = level.filter((e) => !e.is_folder);
+  const folderTasks = [];
+  for (const entry of folders) {
+    folderTasks.push(processEntry(entry));
+  }
+  await Promise.all(folderTasks);
+  const storyTasks = [];
+  for (const entry of nonFolders) {
+    storyTasks.push(processEntry(entry));
+  }
+  await Promise.all(storyTasks);
 };
 const makeWriteStoryFSTransport = ({ directoryPath }) => async (story) => {
   await saveToFile(resolve(directoryPath, getStoryFilename(story)), JSON.stringify(story, null, 2));
@@ -8306,15 +8441,25 @@ const makeWriteStoryAPITransport = ({ spaceId, publish }) => (mappedLocalStory)
   story: mappedLocalStory,
   publish: publish ?? (isStoryPublishedWithoutChanges(mappedLocalStory) ? 1 : 0)
 });
-const makeCleanupStoryFSTransport = ({ directoryPath, maps }) => async (mappedStory) => {
-  const mapEntry = maps.stories?.entries().find(([_, v]) => v === mappedStory.uuid);
-  const originalUuid = mapEntry?.[0] && typeof mapEntry?.[0] === "string" ? mapEntry?.[0] : mappedStory.uuid;
-  const storyFilename = getStoryFilename({
-    slug: mappedStory.slug,
-    uuid: originalUuid
-  });
-  const storyFilePath = resolve(directoryPath, storyFilename);
-  await unlink(storyFilePath);
+const makeCleanupStoryFSTransport = ({ directoryPath, maps }) => {
+  const reverseUuidMap = /* @__PURE__ */ new Map();
+  if (maps.stories) {
+    for (const [key, value] of maps.stories.entries()) {
+      if (typeof key === "string") {
+        reverseUuidMap.set(value, key);
+      }
+    }
+  }
+  return async (mappedStory) => {
+    const uuid = mappedStory.uuid ?? "";
+    const originalUuid = reverseUuidMap.get(uuid) ?? uuid;
+    const storyFilename = getStoryFilename({
+      slug: mappedStory.slug,
+      uuid: originalUuid
+    });
+    const storyFilePath = resolve(directoryPath, storyFilename);
+    await unlink(storyFilePath);
+  };
 };
 const writeStoryStream = ({
   transports,
@@ -8921,75 +9066,80 @@ pushCmd.action(async (options, command) => {
     });
     fetchProgress.stop();
     const storiesDirectoryPath = resolveCommandPath(directories.stories, fromSpace, basePath);
+    const scanProgress = ui.createProgressBar({ title: "Scanning Stories...".padEnd(21) });
+    const storyIndex = await scanLocalStoryIndex({
+      directoryPath: storiesDirectoryPath,
+      setTotalStories(total) {
+        scanProgress.setTotal(total);
+      },
+      onIncrement() {
+        scanProgress.increment();
+      },
+      onError(error, filename) {
+        summary.creationResults.failed += 1;
+        handleError(error, verbose, { storyFile: filename });
+      }
+    });
+    const levels = groupStoriesByDepth(storyIndex);
+    scanProgress.stop();
     const creationProgress = ui.createProgressBar({ title: "Creating Stories...".padEnd(21) });
     const processProgress = ui.createProgressBar({ title: "Processing Stories...".padEnd(21) });
     const updateProgress = ui.createProgressBar({ title: "Updating Stories...".padEnd(21) });
-    await pipeline$1(
-      // Read local stories from `.json` files.
-      readLocalStoriesStream({
-        directoryPath: storiesDirectoryPath,
-        setTotalStories(total) {
-          summary.creationResults.total = total;
-          summary.processResults.total = total;
-          summary.updateResults.total = total;
-          creationProgress.setTotal(total);
-          processProgress.setTotal(total);
-          updateProgress.setTotal(total);
-        },
-        onStoryError(error, filename) {
-          summary.creationResults.failed += 1;
-          summary.processResults.total -= 1;
-          summary.updateResults.total -= 1;
-          processProgress.setTotal(summary.processResults.total);
-          updateProgress.setTotal(summary.updateResults.total);
-          creationProgress.increment();
-          handleError(error, verbose, { storyFile: filename });
-        }
-      }),
-      // Create remote stories.
-      createStoryPlaceholderStream({
+    const totalStories = storyIndex.length + summary.creationResults.failed;
+    summary.creationResults.total = totalStories;
+    summary.processResults.total = totalStories;
+    summary.updateResults.total = totalStories;
+    creationProgress.setTotal(totalStories);
+    processProgress.setTotal(totalStories);
+    updateProgress.setTotal(totalStories);
+    const appendToManifest = options.dryRun ? (() => Promise.resolve()) : makeAppendToManifestFSTransport({ manifestFile });
+    const claimedRemoteIds = /* @__PURE__ */ new Set();
+    for (const level of levels) {
+      await createStoriesForLevel({
+        level,
+        spaceId: space,
         maps,
         existingTargetStories,
+        claimedRemoteIds,
         isCrossSpace: fromSpace !== space,
-        transports: {
-          createStory: options.dryRun ? async (story) => story : makeCreateStoryAPITransport({
-            spaceId: space
-          }),
-          appendStoryManifest: options.dryRun ? () => Promise.resolve() : makeAppendToManifestFSTransport({
-            manifestFile
-          })
-        },
-        onStorySuccess(localStory, remoteStory) {
-          if (!localStory.uuid || !remoteStory.uuid) {
+        dryRun: options.dryRun ?? false,
+        appendToManifest,
+        onStorySuccess(entry, remoteStory) {
+          if (!entry.uuid || !remoteStory.uuid) {
             throw new Error("Invalid story provided!");
           }
-          maps.stories.set(localStory.id, remoteStory.id);
-          maps.stories.set(localStory.uuid, remoteStory.uuid);
+          maps.stories.set(entry.id, remoteStory.id);
+          maps.stories.set(entry.uuid, remoteStory.uuid);
           logger.info("Created story", { storyId: remoteStory.uuid });
           summary.creationResults.succeeded += 1;
+          creationProgress.increment();
         },
-        onStorySkipped(localStory, remoteStory) {
-          if (!localStory.uuid || !remoteStory.uuid) {
+        onStorySkipped(entry, remoteStory, reason) {
+          if (!entry.uuid || !remoteStory.uuid) {
             throw new Error("Invalid story provided!");
           }
-          maps.stories.set(localStory.id, remoteStory.id);
-          maps.stories.set(localStory.uuid, remoteStory.uuid);
-          logger.info("Skipped creating story", { storyId: localStory.uuid });
+          maps.stories.set(entry.id, remoteStory.id);
+          maps.stories.set(entry.uuid, remoteStory.uuid);
+          logger.info(`Skipped creating story: ${reason}`, { storyId: entry.uuid });
           summary.creationResults.skipped += 1;
+          creationProgress.increment();
         },
-        onStoryError(error, localStory) {
+        onStoryError(error, entry) {
           summary.creationResults.failed += 1;
           summary.processResults.total -= 1;
           summary.updateResults.total -= 1;
           processProgress.setTotal(summary.processResults.total);
           updateProgress.setTotal(summary.updateResults.total);
-          handleError(error, verbose, { storyId: localStory?.uuid });
-        },
-        onIncrement() {
           creationProgress.increment();
+          handleError(error, verbose, { storyId: entry?.uuid });
         }
-      })
-    );
+      });
+    }
+    if (summary.creationResults.failed > 0) {
+      const message = `${summary.creationResults.failed} ${summary.creationResults.failed === 1 ? "story" : "stories"} failed to create. References to these stories will be left unmapped.`;
+      ui.warn(message);
+      logger.warn(message);
+    }
     await pipeline$1(
       // Read local stories from `.json` files.
       readLocalStoriesStream({
@@ -9055,7 +9205,7 @@ pushCmd.action(async (options, command) => {
       })
     );
   } catch (maybeError) {
-    handleError(toError(maybeError));
+    handleError(toError(maybeError), verbose);
   } finally {
     logger.info("Pushing stories finished", summary);
     ui.stopAllProgressBars();