sb-mig 6.2.0 → 6.3.0-beta.2

package/dist/api/data-migration/component-data-migration.d.ts

@@ -1,7 +1,9 @@
 import type { PublishLanguagesOption } from "../stories/stories.types.js";
 import type { RequestBaseConfig } from "../utils/request.js";
+import { type LanguagePublishStateMap } from "../stories/language-publish-state.js";
 import { type MigrationComponentAliasesByMigration, type MigrationComponentOverridesByMigration } from "./migration-component-scope.js";
 import { type PreparedMigrationValidator } from "./migration-validation.js";
+import { type PublishedLayerContext } from "./published-layer.js";
 export type MigrateFrom = "file" | "space";
 export type PublicationMode = "preserve-layers" | "collapse-draft" | "save-only";
 export interface PreparedMigrationConfig {
@@ -73,6 +75,60 @@ export declare const runMigrationPipelineInMemory: ({ itemType, itemsToMigrate,
     preparedMigrationConfigs: PreparedMigrationConfig[];
 }) => MigrationPipelineResult;
 export declare const migrateAllComponentsDataInStories: ({ itemType, migrationConfig, migrateFrom, from, to, filters, dryRun, publicationMode, publicationLanguages, fromFilePath, fileName, languagePublishStatePath, migrationComponentAliases, migrationComponentOverrides, }: Omit<MigrateItems, "componentsToMigrate" | "preparedMigrationConfigs">, config: RequestBaseConfig) => Promise<void>;
+export interface ContinueManifest {
+    manifestVersion: 1;
+    createdAt?: string;
+    kind: "migrate-content-continue-manifest";
+    itemType: "story" | "preset";
+    from: string;
+    to: string;
+    migrateFrom: MigrateFrom;
+    fromFilePath?: string | null;
+    publicationMode: PublicationMode;
+    migrationConfigNames: string[];
+    publishLanguages?: {
+        requested?: PublishLanguagesOption;
+    } | null;
+    resolvedPublishLanguages?: string[] | null;
+    artifactBaseName: string;
+    useDatestamp: boolean;
+    artifacts: {
+        changedItems: string;
+        pipelineSummary: string;
+        inputFull?: string | null;
+        languageStateMap?: string | null;
+        draftAfterFull?: string | null;
+        publishedAfterFull?: string | null;
+        dirtyPublishedRecords?: string | null;
+    };
+}
+interface FinalizeMigrationArgs {
+    itemType: "story" | "preset";
+    from: string;
+    to: string;
+    migrateFrom: MigrateFrom;
+    fromFilePath?: string;
+    languagePublishStatePath?: string;
+    publicationMode: PublicationMode;
+    effectivePublicationLanguages?: PublishLanguagesOption;
+    resolvedPublishLanguages?: string[];
+    languagePublishStateMap?: LanguagePublishStateMap;
+    appliedMigrationNames: string[];
+    pipelineResult: MigrationPipelineResult;
+    publishedLayerContext?: PublishedLayerContext;
+    publishedLayerPipelineResult: MigrationPipelineResult | null;
+    artifactBaseName: string;
+    useDatestamp: boolean;
+    continuedFromManifest?: string;
+}
+/**
+ * Everything `doTheMigration` does AFTER the dry-run preview returns:
+ * mark migrations as applied, write the changes to Storyblok, and write the
+ * run log. Extracted so `migrate continue` can run the exact same path against
+ * inputs reconstructed from dry-run artifacts (instead of re-pulling + re-transforming).
+ */
+export declare const finalizeMigration: ({ itemType, from, to, migrateFrom, fromFilePath, languagePublishStatePath, publicationMode, effectivePublicationLanguages, resolvedPublishLanguages, languagePublishStateMap, appliedMigrationNames, pipelineResult, publishedLayerContext, publishedLayerPipelineResult, artifactBaseName, useDatestamp, continuedFromManifest, }: FinalizeMigrationArgs, config: RequestBaseConfig) => Promise<void>;
+export declare const findArtifactFilename: (files: string[], stem: string) => string | null;
 export declare const doTheMigration: ({ itemType, from, itemsToMigrate, migrationConfig, migrationConfigs, to, dryRun, publicationMode, publicationLanguages, migrateFrom, fromFilePath, fileName, languagePublishStatePath, }: {
     itemType?: "story" | "preset";
     from: string;
@@ -89,4 +145,29 @@ export declare const doTheMigration: ({ itemType, from, itemsToMigrate, migratio
     languagePublishStatePath?: string;
 }, config: RequestBaseConfig) => Promise<void>;
 export declare const migrateProvidedComponentsDataInStories: ({ itemType, migrationConfig, migrateFrom, from, to, componentsToMigrate, filters, dryRun, publicationMode, publicationLanguages, fromFilePath, fileName, languagePublishStatePath, preparedMigrationConfigs, migrationComponentAliases, migrationComponentOverrides, }: MigrateItems, config: RequestBaseConfig) => Promise<void>;
+export interface ContinuePlanSummary {
+    manifestFileName: string;
+    from: string;
+    to: string;
+    itemType: "story" | "preset";
+    publicationMode: PublicationMode;
+    migrationConfigNames: string[];
+    resolvedPublishLanguages: string[];
+    changedCount: number;
+    dirtyPublishedCount: number;
+    artifactFiles: string[];
+}
+export interface ContinuePlan {
+    summary: ContinuePlanSummary;
+    run: () => Promise<void>;
+}
+/**
+ * Discover the dry-run `continue` manifest in the migrations folder, load the
+ * artifacts it points at, and reconstruct the exact inputs `finalizeMigration`
+ * needs. Returns a summary (for the confirmation prompt) and a `run()` thunk that
+ * performs the write. Does NOT pull stories, transform, or fetch published layers.
+ */
+export declare const prepareContinueMigration: ({ manifestFileName }: {
+    manifestFileName?: string;
+}, config: RequestBaseConfig) => Promise<ContinuePlan>;
 export {};

package/dist/api/data-migration/component-data-migration.js

@@ -2,7 +2,7 @@ import path from "path";
 import chalk from "chalk";
 import { discoverMigrationConfig, discoverStories, LOOKUP_TYPE, SCOPE, } from "../../cli/utils/discover.js";
 import storyblokConfig from "../../config/config.js";
-import { createAndSaveToFile, getFileContentWithRequire, getFilesContentWithRequire, } from "../../utils/files.js";
+import { createAndSaveToFile, getFileContentWithRequire, getFilesContentWithRequire, listFilesInDir, readFile, } from "../../utils/files.js";
 import Logger from "../../utils/logger.js";
 import { modifyOrCreateAppliedMigrationsFile } from "../../utils/migrations.js";
 import { isObjectEmpty } from "../../utils/object-utils.js";
@@ -810,6 +810,222 @@ export const migrateAllComponentsDataInStories = async ({ itemType, migrationCon
         preparedMigrationConfigs,
     }, config);
 };
+/**
+ * Everything `doTheMigration` does AFTER the dry-run preview returns:
+ * mark migrations as applied, write the changes to Storyblok, and write the
+ * run log. Extracted so `migrate continue` can run the exact same path against
+ * inputs reconstructed from dry-run artifacts (instead of re-pulling + re-transforming).
+ */
+export const finalizeMigration = async ({ itemType, from, to, migrateFrom, fromFilePath, languagePublishStatePath, publicationMode, effectivePublicationLanguages, resolvedPublishLanguages, languagePublishStateMap, appliedMigrationNames, pipelineResult, publishedLayerContext, publishedLayerPipelineResult, artifactBaseName, useDatestamp, continuedFromManifest, }, config) => {
+    for (const migrationConfigName of appliedMigrationNames) {
+        await modifyOrCreateAppliedMigrationsFile(migrationConfigName, itemType);
+    }
+    const publishedLayerChangedCount = publishedLayerPipelineResult?.changedItems.length ?? 0;
+    if (pipelineResult.changedItems.length === 0 &&
+        publishedLayerChangedCount === 0) {
+        return;
+    }
+    let writeResults = [];
+    if (itemType === "story") {
+        if (shouldUsePublishedLayerMode(publicationMode) &&
+            publishedLayerContext) {
+            const dirtyStoryIds = new Set(publishedLayerContext.dirtyPublishedRecords.map((record) => String(record.storyId)));
+            const nonDirtyChangedItems = pipelineResult.changedItems.filter((item) => !dirtyStoryIds.has(storyIdOf(item)));
+            const nonDirtyWriteResults = nonDirtyChangedItems.length > 0
+                ? await managementApi.stories.updateStories({
+                    stories: nonDirtyChangedItems,
+                    spaceId: to,
+                    options: {
+                        publish: shouldPublishForPublicationMode(publicationMode),
+                        publishLanguages: resolvedPublishLanguages,
+                        preservePublishState: shouldPublishForPublicationMode(publicationMode),
+                        languagePublishStateMap,
+                    },
+                }, config)
+                : [];
+            const dirtyWriteResults = publishedLayerPipelineResult
+                ? await writeDirtyPublishedLayerStories({
+                    context: publishedLayerContext,
+                    draftPipelineResult: pipelineResult,
+                    publishedPipelineResult: publishedLayerPipelineResult,
+                    to,
+                    resolvedPublishLanguages,
+                    languagePublishStateMap,
+                }, config)
+                : [];
+            writeResults = [...nonDirtyWriteResults, ...dirtyWriteResults];
+        }
+        else {
+            writeResults = await managementApi.stories.updateStories({
+                stories: pipelineResult.changedItems,
+                spaceId: to,
+                options: {
+                    publish: shouldPublishForPublicationMode(publicationMode),
+                    publishLanguages: resolvedPublishLanguages,
+                    preservePublishState: shouldPublishForPublicationMode(publicationMode),
+                    publishDirtyPublishedStories: shouldPublishDirtyDrafts(publicationMode),
+                    languagePublishStateMap,
+                },
+            }, config);
+        }
+    }
+    else if (itemType === "preset") {
+        writeResults = await managementApi.presets.updatePresets({
+            presets: pipelineResult.changedItems,
+            spaceId: to,
+            options: {},
+        }, config);
+    }
+    const writeSummary = summarizeMutationWriteResults(writeResults);
+    try {
+        await saveMigrationRunLog({
+            artifactBaseName,
+            useDatestamp,
+            from,
+            to,
+            itemType,
+            dryRun: false,
+            publish: shouldPublishForPublicationMode(publicationMode),
+            publishLanguages: effectivePublicationLanguages,
+            resolvedPublishLanguages,
+            migrateFrom,
+            fromFilePath,
+            languagePublishStatePath,
+            pipelineResult,
+            writeResults,
+            writeSummary,
+            continuedFromManifest,
+        }, config);
+    }
+    catch (error) {
+        Logger.warning(`[MIGRATION] Could not write migration run log: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (writeSummary.failed === 0) {
+        Logger.success(`[MIGRATION] Update complete. ${writeSummary.successful}/${writeSummary.total} ${itemType}(s) updated successfully.`);
+        return;
+    }
+    Logger.warning(`[MIGRATION] Update complete with partial failures. ${writeSummary.successful}/${writeSummary.total} ${itemType}(s) updated successfully, ${writeSummary.failed} failed.`);
+    writeSummary.failedItems.slice(0, 10).forEach((item) => {
+        const label = item.slug || item.name || item.id || "unknown";
+        Logger.error(`[MIGRATION] Failed ${itemType}: ${String(label)}`);
+    });
+    if (writeSummary.failedItems.length > 10) {
+        Logger.warning(`[MIGRATION] Showing first 10 failed ${itemType}(s) only.`);
+    }
+};
+/**
+ * Sortable key for an artifact's datestamp suffix.
+ *
+ * Datestamps use the non-zero-padded `YYYY-M-D_H-M` format from
+ * generateDatestamp, so a plain string sort is NOT chronological
+ * (e.g. "2026-1-15_9-30" sorts before "2026-1-9_9-30"). Parse the parts and
+ * compare numerically instead. Returns -1 for the non-datestamped variant
+ * (`${stem}.json`), which only exists when --fileName is used (single match,
+ * never mixed with datestamped files for the same stem).
+ */
+const artifactDatestampKey = (filename, stem) => {
+    const prefix = `${stem}__`;
+    if (!filename.startsWith(prefix) || !filename.endsWith(".json")) {
+        return -1;
+    }
+    const stamp = filename.slice(prefix.length, -".json".length);
+    const match = /^(\d+)-(\d+)-(\d+)_(\d+)-(\d+)$/.exec(stamp);
+    if (!match) {
+        return -1;
+    }
+    const [, year, month, day, hour, minute] = match;
+    // month/day/hour/minute each fit in two decimal digits, so this packs the
+    // parts into one monotonically increasing key.
+    return (Number(year) * 100_000_000 +
+        Number(month) * 1_000_000 +
+        Number(day) * 10_000 +
+        Number(hour) * 100 +
+        Number(minute));
+};
+export const findArtifactFilename = (files, stem) => {
+    const matches = files.filter((file) => file === `${stem}.json` || file.startsWith(`${stem}__`));
+    if (matches.length === 0) {
+        return null;
+    }
+    // Pick the chronologically newest match. Do not lexicographically sort:
+    // the datestamp format is not zero-padded, so string order is not time order.
+    return matches.reduce((newest, candidate) => artifactDatestampKey(candidate, stem) >=
+        artifactDatestampKey(newest, stem)
+        ? candidate
+        : newest);
+};
+/**
+ * Written at the end of a dry-run only. A small machine file that lets
+ * `migrate continue` finish the migration without re-pulling/re-transforming:
+ * carries the scalars that aren't otherwise saved (target space, exact migration
+ * names, run-log metadata) and references the heavy dry-run artifacts by filename.
+ */
+const saveContinueManifest = async ({ artifactBaseName, useDatestamp, dryRun, itemType, from, to, migrateFrom, fromFilePath, publicationMode, effectivePublicationLanguages, resolvedPublishLanguages, appliedMigrationNames, publishedLayerContext, publishedLayerPipelineResult, }, config) => {
+    if (!dryRun) {
+        return;
+    }
+    const isPreserveLayers = shouldUsePublishedLayerMode(publicationMode) &&
+        Boolean(publishedLayerContext);
+    if (isPreserveLayers && publishedLayerContext) {
+        const publishedChangedIds = (publishedLayerPipelineResult?.changedItems ?? []).map((item) => storyIdOf(item));
+        await createAndSaveToFile({
+            datestamp: useDatestamp,
+            ext: "json",
+            filename: `dry-run--${artifactBaseName}---dirty-published-records`,
+            folder: "migrations",
+            res: {
+                dirtyPublishedRecords: publishedLayerContext.dirtyPublishedRecords,
+                publishedChangedIds,
+            },
+        }, config);
+    }
+    // Resolve the real sibling filenames from disk. The datestamp suffix has
+    // minute granularity, so sibling artifacts can in rare cases differ; reading
+    // the folder avoids guessing the exact name.
+    const files = await listFilesInDir(`${config.sbmigWorkingDirectory}/migrations`);
+    const resolve = (stem) => findArtifactFilename(files, `dry-run--${artifactBaseName}---${stem}`);
+    const artifacts = {
+        changedItems: resolve(`${itemType}-to-migrate`) ?? "",
+        pipelineSummary: resolve(`${itemType}-migration-pipeline-summary`) ?? "",
+        inputFull: resolve(`${itemType}-input-full`),
+        languageStateMap: resolve("language-publish-state-map"),
+        draftAfterFull: isPreserveLayers
+            ? resolve("draft-current-after-full")
+            : null,
+        publishedAfterFull: isPreserveLayers
+            ? resolve("published-layer-after-full")
+            : null,
+        dirtyPublishedRecords: isPreserveLayers
+            ? resolve("dirty-published-records")
+            : null,
+    };
+    const manifest = {
+        manifestVersion: 1,
+        createdAt: new Date().toISOString(),
+        kind: "migrate-content-continue-manifest",
+        itemType,
+        from,
+        to,
+        migrateFrom,
+        fromFilePath: fromFilePath ?? null,
+        publicationMode,
+        migrationConfigNames: appliedMigrationNames,
+        publishLanguages: publicationMode === "save-only"
+            ? null
+            : { requested: effectivePublicationLanguages },
+        resolvedPublishLanguages: resolvedPublishLanguages ?? null,
+        artifactBaseName,
+        useDatestamp,
+        artifacts,
+    };
+    await createAndSaveToFile({
+        datestamp: useDatestamp,
+        ext: "json",
+        filename: `dry-run--${artifactBaseName}---${itemType}-continue-manifest`,
+        folder: "migrations",
+        res: manifest,
+    }, config);
+};
 export const doTheMigration = async ({ itemType = "story", from, itemsToMigrate, migrationConfig, migrationConfigs, to, dryRun, publicationMode = DEFAULT_PUBLICATION_MODE, publicationLanguages, migrateFrom, fromFilePath, fileName, languagePublishStatePath, }, config) => {
     const preparedMigrationConfigs = migrationConfigs ||
         prepareMigrationConfigs({
@@ -952,6 +1168,23 @@ export const doTheMigration = async ({ itemType = "story", from, itemsToMigrate,
         languagePublishStatePath,
         pipelineResult,
     }, config);
+    await saveContinueManifest({
+        artifactBaseName,
+        useDatestamp,
+        dryRun,
+        itemType,
+        from,
+        to,
+        migrateFrom,
+        fromFilePath,
+        publicationMode,
+        effectivePublicationLanguages,
+        resolvedPublishLanguages,
+        appliedMigrationNames: preparedMigrationConfigs.map((preparedMigrationConfig) => preparedMigrationConfig.migrationConfigName),
+        pipelineResult,
+        publishedLayerContext,
+        publishedLayerPipelineResult,
+    }, config);
     if (dryRun) {
         console.log(" ");
         if (publishedLayerPipelineResult) {
@@ -961,100 +1194,24 @@ export const doTheMigration = async ({ itemType = "story", from, itemsToMigrate,
         Logger.success(`[DRY RUN] No API changes were made. Review the saved migration file for details.`);
         return;
     }
-    for (const preparedMigrationConfig of preparedMigrationConfigs) {
-        await modifyOrCreateAppliedMigrationsFile(preparedMigrationConfig.migrationConfigName, itemType);
-    }
-    const publishedLayerChangedCount = publishedLayerPipelineResult?.changedItems.length ?? 0;
-    if (pipelineResult.changedItems.length === 0 &&
-        publishedLayerChangedCount === 0) {
-        return;
-    }
-    let writeResults = [];
-    if (itemType === "story") {
-        if (shouldUsePublishedLayerMode(publicationMode) &&
-            publishedLayerContext) {
-            const dirtyStoryIds = new Set(publishedLayerContext.dirtyPublishedRecords.map((record) => String(record.storyId)));
-            const nonDirtyChangedItems = pipelineResult.changedItems.filter((item) => !dirtyStoryIds.has(storyIdOf(item)));
-            const nonDirtyWriteResults = nonDirtyChangedItems.length > 0
-                ? await managementApi.stories.updateStories({
-                    stories: nonDirtyChangedItems,
-                    spaceId: to,
-                    options: {
-                        publish: shouldPublishForPublicationMode(publicationMode),
-                        publishLanguages: resolvedPublishLanguages,
-                        preservePublishState: shouldPublishForPublicationMode(publicationMode),
-                        languagePublishStateMap,
-                    },
-                }, config)
-                : [];
-            const dirtyWriteResults = publishedLayerPipelineResult
-                ? await writeDirtyPublishedLayerStories({
-                    context: publishedLayerContext,
-                    draftPipelineResult: pipelineResult,
-                    publishedPipelineResult: publishedLayerPipelineResult,
-                    to,
-                    resolvedPublishLanguages,
-                    languagePublishStateMap,
-                }, config)
-                : [];
-            writeResults = [...nonDirtyWriteResults, ...dirtyWriteResults];
-        }
-        else {
-            writeResults = await managementApi.stories.updateStories({
-                stories: pipelineResult.changedItems,
-                spaceId: to,
-                options: {
-                    publish: shouldPublishForPublicationMode(publicationMode),
-                    publishLanguages: resolvedPublishLanguages,
-                    preservePublishState: shouldPublishForPublicationMode(publicationMode),
-                    publishDirtyPublishedStories: shouldPublishDirtyDrafts(publicationMode),
-                    languagePublishStateMap,
-                },
-            }, config);
-        }
-    }
-    else if (itemType === "preset") {
-        writeResults = await managementApi.presets.updatePresets({
-            presets: pipelineResult.changedItems,
-            spaceId: to,
-            options: {},
-        }, config);
-    }
-    const writeSummary = summarizeMutationWriteResults(writeResults);
-    try {
-        await saveMigrationRunLog({
-            artifactBaseName,
-            useDatestamp,
-            from,
-            to,
-            itemType,
-            dryRun,
-            publish: shouldPublishForPublicationMode(publicationMode),
-            publishLanguages: effectivePublicationLanguages,
-            resolvedPublishLanguages,
-            migrateFrom,
-            fromFilePath,
-            languagePublishStatePath,
-            pipelineResult,
-            writeResults,
-            writeSummary,
-        }, config);
-    }
-    catch (error) {
-        Logger.warning(`[MIGRATION] Could not write migration run log: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    if (writeSummary.failed === 0) {
-        Logger.success(`[MIGRATION] Update complete. ${writeSummary.successful}/${writeSummary.total} ${itemType}(s) updated successfully.`);
-        return;
-    }
-    Logger.warning(`[MIGRATION] Update complete with partial failures. ${writeSummary.successful}/${writeSummary.total} ${itemType}(s) updated successfully, ${writeSummary.failed} failed.`);
-    writeSummary.failedItems.slice(0, 10).forEach((item) => {
-        const label = item.slug || item.name || item.id || "unknown";
-        Logger.error(`[MIGRATION] Failed ${itemType}: ${String(label)}`);
-    });
-    if (writeSummary.failedItems.length > 10) {
-        Logger.warning(`[MIGRATION] Showing first 10 failed ${itemType}(s) only.`);
-    }
+    await finalizeMigration({
+        itemType,
+        from,
+        to,
+        migrateFrom,
+        fromFilePath,
+        languagePublishStatePath,
+        publicationMode,
+        effectivePublicationLanguages,
+        resolvedPublishLanguages,
+        languagePublishStateMap,
+        appliedMigrationNames: preparedMigrationConfigs.map((preparedMigrationConfig) => preparedMigrationConfig.migrationConfigName),
+        pipelineResult,
+        publishedLayerContext,
+        publishedLayerPipelineResult,
+        artifactBaseName,
+        useDatestamp,
+    }, config);
 };
 const saveBackupToFile = async ({ itemType, res, folder, filename }, config) => {
     await createAndSaveToFile({
@@ -1109,3 +1266,142 @@ export const migrateProvidedComponentsDataInStories = async ({ itemType, migrati
         languagePublishStatePath,
     }, config);
 };
+const CONTINUE_MANIFEST_RE = /---(?:story|preset)-continue-manifest(?:__.*)?\.json$/;
+const readMigrationJson = async (config, filename) => {
+    const content = await readFile(`${config.sbmigWorkingDirectory}/migrations/${filename}`);
+    if (content === undefined) {
+        throw new Error(`Could not read migration artifact: migrations/${filename}`);
+    }
+    try {
+        return JSON.parse(content);
+    }
+    catch {
+        throw new Error(`Migration artifact is not valid JSON: migrations/${filename}`);
+    }
+};
+/**
+ * Discover the dry-run `continue` manifest in the migrations folder, load the
+ * artifacts it points at, and reconstruct the exact inputs `finalizeMigration`
+ * needs. Returns a summary (for the confirmation prompt) and a `run()` thunk that
+ * performs the write. Does NOT pull stories, transform, or fetch published layers.
+ */
+export const prepareContinueMigration = async ({ manifestFileName }, config) => {
+    const files = await listFilesInDir(`${config.sbmigWorkingDirectory}/migrations`);
+    const manifestFiles = files.filter((file) => CONTINUE_MANIFEST_RE.test(file));
+    let chosen;
+    if (manifestFileName) {
+        if (!files.includes(manifestFileName)) {
+            throw new Error(`Manifest not found in migrations folder: ${manifestFileName}`);
+        }
+        chosen = manifestFileName;
+    }
+    else if (manifestFiles.length === 1) {
+        chosen = manifestFiles[0];
+    }
+    else if (manifestFiles.length === 0) {
+        throw new Error("No dry-run found to continue. Run `sb-mig migrate content … --dryRun` first.");
+    }
+    else {
+        throw new Error(`Multiple dry-run manifests found. Re-run with --manifest <filename>:\n${manifestFiles
+            .map((file) => `  - ${file}`)
+            .join("\n")}`);
+    }
+    const manifest = (await readMigrationJson(config, chosen));
+    if (manifest.kind !== "migrate-content-continue-manifest") {
+        throw new Error(`Not a continue manifest: ${chosen}`);
+    }
+    if (manifest.manifestVersion !== 1) {
+        throw new Error(`Unsupported continue manifest version (${manifest.manifestVersion}) in ${chosen}.`);
+    }
+    const { artifacts } = manifest;
+    if (!artifacts?.changedItems) {
+        throw new Error(`Manifest ${chosen} is missing the changed-items artifact reference.`);
+    }
+    const changedItems = (await readMigrationJson(config, artifacts.changedItems));
+    const pipelineSummary = artifacts.pipelineSummary
+        ? await readMigrationJson(config, artifacts.pipelineSummary)
+        : null;
+    const languagePublishStateMap = artifacts.languageStateMap
+        ? (await readMigrationJson(config, artifacts.languageStateMap))
+        : undefined;
+    const isPreserveLayers = shouldUsePublishedLayerMode(manifest.publicationMode) &&
+        Boolean(artifacts.dirtyPublishedRecords);
+    let publishedLayerContext;
+    let publishedLayerPipelineResult = null;
+    if (isPreserveLayers && artifacts.dirtyPublishedRecords) {
+        const dirty = (await readMigrationJson(config, artifacts.dirtyPublishedRecords));
+        publishedLayerContext = {
+            records: [],
+            publishedLayerInputItems: [],
+            dirtyPublishedRecords: dirty.dirtyPublishedRecords ?? [],
+            missingPublishedLayerRecords: [],
+        };
+        const publishedFinalItems = artifacts.publishedAfterFull
+            ? (await readMigrationJson(config, artifacts.publishedAfterFull))
+            : [];
+        const publishedChangedIdSet = new Set((dirty.publishedChangedIds ?? []).map(String));
+        publishedLayerPipelineResult = {
+            changedItems: publishedFinalItems.filter((item) => publishedChangedIdSet.has(storyIdOf(item))),
+            finalItems: publishedFinalItems,
+            stepReports: [],
+            totalItems: publishedFinalItems.length,
+        };
+    }
+    const draftFinalItems = artifacts.draftAfterFull
+        ? (await readMigrationJson(config, artifacts.draftAfterFull))
+        : changedItems;
+    const pipelineResult = {
+        changedItems,
+        finalItems: draftFinalItems,
+        stepReports: Array.isArray(pipelineSummary?.steps)
+            ? pipelineSummary.steps
+            : [],
+        totalItems: typeof pipelineSummary?.totalItems === "number"
+            ? pipelineSummary.totalItems
+            : changedItems.length,
+    };
+    const resolvedPublishLanguages = manifest.resolvedPublishLanguages ?? undefined;
+    const effectivePublicationLanguages = manifest.publishLanguages?.requested;
+    const artifactFiles = [
+        artifacts.changedItems,
+        artifacts.pipelineSummary,
+        artifacts.draftAfterFull,
+        artifacts.publishedAfterFull,
+        artifacts.dirtyPublishedRecords,
+        artifacts.languageStateMap,
+        artifacts.inputFull,
+    ].filter((file) => Boolean(file));
+    const summary = {
+        manifestFileName: chosen,
+        from: manifest.from,
+        to: manifest.to,
+        itemType: manifest.itemType,
+        publicationMode: manifest.publicationMode,
+        migrationConfigNames: manifest.migrationConfigNames ?? [],
+        resolvedPublishLanguages: resolvedPublishLanguages ?? [],
+        changedCount: changedItems.length,
+        dirtyPublishedCount: publishedLayerContext?.dirtyPublishedRecords.length ?? 0,
+        artifactFiles,
+    };
+    const run = async () => {
+        await finalizeMigration({
+            itemType: manifest.itemType,
+            from: manifest.from,
+            to: manifest.to,
+            migrateFrom: manifest.migrateFrom,
+            fromFilePath: manifest.fromFilePath ?? undefined,
+            publicationMode: manifest.publicationMode,
+            effectivePublicationLanguages,
+            resolvedPublishLanguages,
+            languagePublishStateMap,
+            appliedMigrationNames: manifest.migrationConfigNames ?? [],
+            pipelineResult,
+            publishedLayerContext,
+            publishedLayerPipelineResult,
+            artifactBaseName: manifest.artifactBaseName,
+            useDatestamp: manifest.useDatestamp,
+            continuedFromManifest: chosen,
+        }, config);
+    };
+    return { summary, run };
+};

package/dist/api/data-migration/migration-run-log.d.ts

@@ -23,6 +23,7 @@ export interface MigrationRunLogRecord {
         resolved?: string[];
     };
     dryRun: boolean;
+    continuedFromManifest?: string;
     migrationConfigs: string[];
     totalItems: number;
     totalChangedItems: number;
@@ -76,8 +77,9 @@ interface SaveMigrationRunLogArgs {
     pipelineResult: MigrationPipelineResult;
     writeResults: PromiseSettledResult<MutationWriteResult>[];
     writeSummary: MutationWriteSummary;
+    continuedFromManifest?: string;
 }
-export declare const buildMigrationRunLogRecords: ({ from, to, itemType, dryRun, publish, publishLanguages, resolvedPublishLanguages, migrateFrom, fromFilePath, languagePublishStatePath, pipelineResult, writeResults, writeSummary, }: Omit<SaveMigrationRunLogArgs, "artifactBaseName" | "useDatestamp">) => MigrationRunLogRecord[];
+export declare const buildMigrationRunLogRecords: ({ from, to, itemType, dryRun, publish, publishLanguages, resolvedPublishLanguages, migrateFrom, fromFilePath, languagePublishStatePath, pipelineResult, writeResults, writeSummary, continuedFromManifest, }: Omit<SaveMigrationRunLogArgs, "artifactBaseName" | "useDatestamp">) => MigrationRunLogRecord[];
 export declare const recordsToJsonl: (records: MigrationRunLogRecord[]) => string;
 export declare const saveMigrationRunLog: (args: SaveMigrationRunLogArgs, config: RequestBaseConfig) => Promise<void>;
 export {};

package/dist/api/data-migration/migration-run-log.js

@@ -31,7 +31,7 @@ const resolveWriteResultValue = (result) => {
         error: result.reason,
     };
 };
-export const buildMigrationRunLogRecords = ({ from, to, itemType, dryRun, publish, publishLanguages, resolvedPublishLanguages, migrateFrom, fromFilePath, languagePublishStatePath, pipelineResult, writeResults, writeSummary, }) => {
+export const buildMigrationRunLogRecords = ({ from, to, itemType, dryRun, publish, publishLanguages, resolvedPublishLanguages, migrateFrom, fromFilePath, languagePublishStatePath, pipelineResult, writeResults, writeSummary, continuedFromManifest, }) => {
     const timestamp = new Date().toISOString();
     const runId = `${itemType}-${timestamp}`;
     const baseRecord = {
@@ -57,6 +57,7 @@ export const buildMigrationRunLogRecords = ({ from, to, itemType, dryRun, publis
             }
             : {}),
         dryRun: Boolean(dryRun),
+        ...(continuedFromManifest ? { continuedFromManifest } : {}),
         migrationConfigs: pipelineResult.stepReports.map((step) => step.migrationConfig),
         totalItems: pipelineResult.totalItems,
         totalChangedItems: pipelineResult.changedItems.length,

package/dist/api/managementApi.d.ts

@@ -1,3 +1,4 @@
+import * as assets from "./assets/index.js";
 import * as inspect from "./inspect/index.js";
 import * as stories from "./stories/index.js";
 export declare const managementApi: {
@@ -8,7 +9,12 @@ export declare const managementApi: {
         getAsset: (assetName: string | undefined) => Promise<void>;
         getAssetById: import("./assets/assets.types.js").GetAssetById;
         getAssetByName: import("./assets/assets.types.js").GetAssetByName;
+        createAssetAndFinalize: assets.CreateAssetAndFinalize;
+        downloadAsset: import("./assets/assets.types.js").DownloadAsset;
+        finishAssetUpload: assets.FinishAssetUpload;
         updateAsset: import("./assets/assets.types.js").UpdateAsset;
+        createAssetFolder: assets.CreateAssetFolder;
+        getAllAssetFolders: import("./assets/asset-folders.types.js").GetAllAssetFolders;
     };
     auth: {
         getCurrentUser: import("./auth/auth.types.js").GetCurrentUser;