sb-mig 6.2.0 → 6.3.0

package/dist/cli/commands/copy.js

@@ -1,195 +1,2141 @@
+import fs from "fs/promises";
+import path from "path";
+import { appendManifestEntry, buildCopyAssetsGraph, buildCopyMaps, createCopyGraph, dedupeManifestFile, getDefaultCopyManifestPaths, loadManifest, normalizeAssetFolderParentId, rewriteCopyReferences, scanStoriesReferences, summarizeCopyGraph, } from "../../api/copy/index.js";
+import { buildPublishedLayerContext, resolveStoryLayerState, } from "../../api/data-migration/published-layer.js";
 import { managementApi } from "../../api/managementApi.js";
-import { createTree, traverseAndCreate } from "../../api/stories/tree.js";
+import { parsePublishLanguagesOption, resolvePublishLanguageCodes, } from "../../api/stories/stories.js";
+import { createTree } from "../../api/stories/tree.js";
+import { mapWithConcurrency } from "../../utils/async-utils.js";
 import Logger from "../../utils/logger.js";
+import { getFileName } from "../../utils/string-utils.js";
 import { apiConfig } from "../api-config.js";
-import { getSourceSpace, getTargetSpace, getWhat, getWhere, } from "../utils/cli-utils.js";
 const COPY_COMMANDS = {
     stories: "stories",
+    assets: "assets",
 };
-const attachToFolder = async (where, targetSpace) => {
-    console.log("attachToFolder", where, targetSpace);
-    const entryStory = await managementApi.stories.getStoryBySlug(where, {
+const COPY_MODES = ["subtree", "children", "self"];
+const TARGET_CONFLICT_CHECK_CONCURRENCY = 10;
+const COPY_DRY_RUN_BASE_LIMITATIONS = [
+    "create_or_match",
+    "target_state_may_change",
+];
+const COPY_DRY_RUN_STORY_ONLY_LIMITATIONS = [
+    "assets_not_copied_by_story_command",
+    "asset_rewrite_requires_existing_asset_manifest",
+];
+const COPY_DRY_RUN_WITH_ASSETS_LIMITATIONS = [
+    "target_asset_identity_not_resolved_until_apply",
+];
+const isCopyMode = (value) => COPY_MODES.includes(value);
+const readStringFlag = (flags, names) => {
+    for (const name of names) {
+        const value = flags[name];
+        if (value !== undefined && value !== null && value !== "") {
+            return String(value);
+        }
+    }
+    return undefined;
+};
+const readStringListFlag = (flags, names) => {
+    const values = [];
+    for (const name of names) {
+        const value = flags[name];
+        if (Array.isArray(value)) {
+            values.push(...value.map(String));
+            continue;
+        }
+        if (value !== undefined && value !== null && value !== "") {
+            values.push(String(value));
+        }
+    }
+    return values
+        .map((value) => value.trim())
+        .filter((value) => value.length > 0);
+};
+const getCopySpace = (flags, names, fallback) => readStringFlag(flags, names) ?? fallback;
+const parseCopyPublicationMode = (publicationModeFlag) => {
+    if (!publicationModeFlag) {
+        return "preserve-layers";
+    }
+    if (publicationModeFlag === "preserve-layers" ||
+        publicationModeFlag === "collapse-draft" ||
+        publicationModeFlag === "save-only") {
+        return publicationModeFlag;
+    }
+    throw new Error("--publicationMode must be one of: preserve-layers, collapse-draft, save-only.");
+};
+const resolveCopyPublicationOptions = async ({ flags, targetSpace, dryRun, }) => {
+    const mode = parseCopyPublicationMode(readStringFlag(flags, ["publicationMode", "publication-mode"]));
+    const publicationLanguagesFlag = readStringFlag(flags, [
+        "publicationLanguages",
+        "publication-languages",
+    ]);
+    if (mode === "save-only" && publicationLanguagesFlag) {
+        throw new Error("--publicationLanguages cannot be used with --publicationMode save-only.");
+    }
+    if (mode === "save-only") {
+        return { mode };
+    }
+    const publishLanguages = publicationLanguagesFlag
+        ? parsePublishLanguagesOption(publicationLanguagesFlag)
+        : "all";
+    return {
+        mode,
+        publishLanguages,
+        resolvedPublishLanguages: dryRun
+            ? undefined
+            : await resolvePublishLanguageCodes(publishLanguages, {
+                ...apiConfig,
+                spaceId: targetSpace,
+            }),
+    };
+};
+const normalizeDestination = (destination) => !destination || destination === "/" || destination === "root"
+    ? ""
+    : destination.replace(/^\/+|\/+$/g, "");
+const joinSlugs = (...parts) => parts
+    .filter((part) => Boolean(part))
+    .map((part) => part.replace(/^\/+|\/+$/g, ""))
+    .filter((part) => part.length > 0)
+    .join("/");
+const normalizeAssetFolderPath = (folderPath) => folderPath.replace(/^\/+|\/+$/g, "");
+const toSelectionReport = (selection) => selection.type === "all"
+    ? "all"
+    : selection.type === "referenced_by_stories"
+        ? {
+            type: "referenced_by_stories",
+            source: selection.storySelection.source,
+            mode: selection.storySelection.mode,
+        }
+        : {
+            type: selection.type,
+            values: selection.values,
+        };
+const resolveCopyAssetsSelection = (flags) => {
+    const assetValues = readStringListFlag(flags, ["asset", "assetId"]);
+    const assetFolderValues = readStringListFlag(flags, [
+        "assetFolder",
+        "asset-folder",
+        "assetFolderId",
+        "asset-folder-id",
+    ]);
+    const hasAll = Boolean(flags["all"]);
+    const hasReferencedByStories = Boolean(flags["referencedByStories"] ?? flags["referenced-by-stories"]);
+    const selectorCount = (hasAll ? 1 : 0) +
+        (assetValues.length > 0 ? 1 : 0) +
+        (assetFolderValues.length > 0 ? 1 : 0) +
+        (hasReferencedByStories ? 1 : 0);
+    if (selectorCount === 0) {
+        throw new Error("copy assets requires one selector: --all, --asset <id|url|unique-name>, --assetFolder <id|path>, or --referenced-by-stories --source <full_slug>.");
+    }
+    if (selectorCount > 1) {
+        throw new Error("copy assets accepts only one selector family at a time. Use --all, --asset, --assetFolder, or --referenced-by-stories.");
+    }
+    if (hasReferencedByStories) {
+        return {
+            type: "referenced_by_stories",
+            storySelection: resolveCopySelection(flags),
+        };
+    }
+    if (assetValues.length > 0) {
+        return {
+            type: "asset",
+            values: assetValues,
+        };
+    }
+    if (assetFolderValues.length > 0) {
+        return {
+            type: "asset_folder",
+            values: assetFolderValues.map(normalizeAssetFolderPath),
+        };
+    }
+    return {
+        type: "all",
+    };
+};
+const resolveCopySelection = (flags) => {
+    const rawSource = readStringFlag(flags, ["source", "what"]);
+    if (!rawSource) {
+        throw new Error("Missing source. Pass --source <full_slug> (or legacy --what <full_slug>).");
+    }
+    const rawMode = readStringFlag(flags, ["mode"]);
+    if (rawMode && !isCopyMode(rawMode)) {
+        throw new Error(`Unsupported copy mode '${rawMode}'. Use one of: ${COPY_MODES.join(", ")}.`);
+    }
+    const explicitMode = rawMode;
+    if (rawSource.endsWith("/*")) {
+        return {
+            source: rawSource.slice(0, -2),
+            mode: explicitMode ?? "children",
+        };
+    }
+    return {
+        source: rawSource,
+        mode: explicitMode ?? "subtree",
+    };
+};
+const resolveDestinationParentId = async (destination, targetSpace) => {
+    if (!destination || destination === "/" || destination === "root") {
+        return null;
+    }
+    const targetEntryStory = await managementApi.stories.getStoryBySlug(destination, {
         ...apiConfig,
         spaceId: targetSpace,
     });
-    console.log("entryStory", entryStory);
+    if (!targetEntryStory) {
+        throw new Error(`Destination story or folder not found in target space: ${destination}`);
+    }
+    if (!targetEntryStory.story.is_folder) {
+        throw new Error(`Destination must be a folder or root. '${destination}' is not a folder.`);
+    }
+    return targetEntryStory.story.id;
+};
+const getStoryBySlugOrThrow = async (slug, sourceSpace) => {
+    const entryStory = await managementApi.stories.getStoryBySlug(slug, {
+        ...apiConfig,
+        spaceId: sourceSpace,
+    });
+    if (!entryStory) {
+        throw new Error(`Source story or folder not found: ${slug}`);
+    }
     return entryStory;
 };
-const decideStrategy = async (args) => {
-    const { what, sourceSpace } = args;
-    // Check if path ends with /* for recursive folder strategy
-    if (what.endsWith("/*")) {
-        const folderPath = what.slice(0, -2); // Remove /* from the endcurso
-        const entryStory = await managementApi.stories.getStoryBySlug(folderPath, {
+const getStoriesForSelection = async (selection, sourceSpace) => {
+    const rootStory = await getStoryBySlugOrThrow(selection.source, sourceSpace);
+    const root = rootStory.story;
+    if (selection.mode === "self") {
+        return [rootStory];
+    }
+    if (!root.is_folder) {
+        if (selection.mode === "children") {
+            throw new Error(`Copy mode 'children' requires a folder source. '${selection.source}' is not a folder.`);
+        }
+        return [rootStory];
+    }
+    const children = await managementApi.stories.getAllStories({
+        options: {
+            starts_with: `${selection.source}/`,
+        },
+    }, {
+        ...apiConfig,
+        spaceId: sourceSpace,
+    });
+    return [rootStory, ...children];
+};
+const stripGeneratedStoryFields = (story) => {
+    const { id, uuid, created_at, updated_at, published_at, first_published_at, last_author, alternates, parent, ...copyableStory } = story;
+    return copyableStory;
+};
+const normalizeStoriesForTree = (stories, selection) => stories.map((item) => {
+    const story = item.story;
+    const copyableStory = stripGeneratedStoryFields(story);
+    if (story.full_slug === selection.source) {
+        return {
+            ...copyableStory,
+            id: story.id,
+            parent_id: null,
+        };
+    }
+    return {
+        ...copyableStory,
+        id: story.id,
+        parent_id: story.parent_id === 0 ? null : story.parent_id,
+    };
+});
+const selectTreeRoots = (tree, selection) => {
+    if (selection.mode === "children") {
+        return tree[0]?.children ?? [];
+    }
+    return tree;
+};
+const prepareTreeForCreate = (tree) => tree.map((node) => ({
+    ...node,
+    story: stripGeneratedStoryFields(node.story),
+    children: node.children ? prepareTreeForCreate(node.children) : [],
+}));
+const resolveStorySlug = (story) => {
+    if (typeof story.slug === "string" && story.slug.length > 0) {
+        return story.slug;
+    }
+    const fullSlug = String(story.full_slug ?? "");
+    return fullSlug.split("/").filter(Boolean).at(-1) ?? "";
+};
+const buildStoryShellPayload = (story, parentId) => {
+    const component = story.content?.component;
+    return {
+        name: story.name,
+        slug: resolveStorySlug(story),
+        is_folder: story.is_folder === true,
+        ...(parentId !== null ? { parent_id: parentId } : {}),
+        ...(story.is_startpage === true && parentId !== null
+            ? { is_startpage: true }
+            : {}),
+        ...(component
+            ? {
+                content: {
+                    _uid: "",
+                    component,
+                },
+            }
+            : {}),
+    };
+};
+const buildFinalStoryPayload = ({ sourceStory, targetParentId, rewrittenContent, }) => {
+    const payload = stripGeneratedStoryFields(sourceStory);
+    delete payload.full_slug;
+    delete payload.parent_id;
+    payload.slug = resolveStorySlug(sourceStory);
+    payload.content = rewrittenContent;
+    if (targetParentId !== null) {
+        payload.parent_id = targetParentId;
+    }
+    if (sourceStory.is_startpage === true && targetParentId !== null) {
+        payload.is_startpage = true;
+    }
+    return payload;
+};
+const getValidMappedTargetStory = async ({ sourceStory, targetStoryId, targetFullSlug, targetSpace, }) => {
+    const targetStory = await managementApi.stories.getStoryById(String(targetStoryId), {
+        ...apiConfig,
+        spaceId: targetSpace,
+    });
+    if (targetStory?.story?.id) {
+        if (!targetFullSlug) {
+            return targetStory.story;
+        }
+        const targetStoryBySlug = await managementApi.stories.getStoryBySlug(targetFullSlug, {
+            ...apiConfig,
+            spaceId: targetSpace,
+        });
+        if (Number(targetStoryBySlug?.story?.id) === targetStoryId) {
+            return targetStory.story;
+        }
+    }
+    Logger.warning(`Ignoring stale story manifest mapping for '${sourceStory.full_slug ?? sourceStory.slug}' because target story '${targetStoryId}' was not found at the expected target path in space '${targetSpace}'.`);
+    return undefined;
+};
+const assertStoryUpdateSucceeded = ({ result, sourceStory, targetStoryId, targetSpace, }) => {
+    if (result?.ok !== false) {
+        return;
+    }
+    const statusLabel = result.status
+        ? `status ${result.status}`
+        : "unknown status";
+    const responseLabel = result.response
+        ? ` Response: ${result.response}`
+        : "";
+    throw new Error(`Failed to update copied story '${sourceStory.full_slug ?? sourceStory.slug}' in target space '${targetSpace}' (target story id ${targetStoryId}, ${statusLabel}).${responseLabel}`);
+};
+const isStoryUpdateNotFound = (result) => result?.ok === false && Number(result.status) === 404;
+const buildCopyPlan = (tree, destination) => {
+    const destinationRoot = normalizeDestination(destination);
+    const plan = [];
+    const walk = (nodes, parentTargetSlug) => {
+        for (const node of nodes) {
+            const story = node.story;
+            const targetFullSlug = joinSlugs(parentTargetSlug, resolveStorySlug(story));
+            plan.push({
+                type: story.is_folder ? "folder" : "story",
+                sourceFullSlug: String(story.full_slug ?? story.slug ?? ""),
+                targetFullSlug,
+                name: String(story.name ?? story.slug ?? "unknown"),
+                action: "create",
+            });
+            if (node.children?.length) {
+                walk(node.children, targetFullSlug);
+            }
+        }
+    };
+    walk(tree, destinationRoot);
+    return plan;
+};
+const findTargetConflicts = async (plan, targetSpace) => {
+    let checked = 0;
+    if (plan.length === 0) {
+        return [];
+    }
+    Logger.warning(`Checking ${plan.length} planned target path(s) for existing stories/folders.`);
+    const results = await mapWithConcurrency(plan, TARGET_CONFLICT_CHECK_CONCURRENCY, async (item) => {
+        const existingStory = await managementApi.stories.getStoryBySlug(item.targetFullSlug, {
             ...apiConfig,
-            spaceId: sourceSpace,
+            spaceId: targetSpace,
         });
-        if (!entryStory) {
-            throw new Error(`Story not found: ${folderPath}`);
+        checked += 1;
+        if (checked === plan.length ||
+            checked % 25 === 0 ||
+            plan.length <= 25) {
+            Logger.success(`Checked ${checked} of ${plan.length} target path(s) for conflicts.`);
         }
-        if (!entryStory.story.is_folder) {
-            throw new Error(`${folderPath} is not a folder`);
+        return existingStory ? item : null;
+    });
+    const conflicts = results.filter((item) => item !== null);
+    Logger.success(`Target conflict check complete. Found ${conflicts.length} existing target path(s).`);
+    return conflicts;
+};
+const withConflictFlags = (plan, conflicts) => {
+    const conflictSlugs = new Set(conflicts.map((conflict) => conflict.targetFullSlug));
+    return plan.map((item) => ({
+        ...item,
+        ...(conflictSlugs.has(item.targetFullSlug) ? { conflict: true } : {}),
+    }));
+};
+const buildDryRunWarnings = ({ conflicts, withAssets, }) => [
+    ...conflicts.map((conflict) => ({
+        code: "target_exists",
+        message: `Target ${conflict.type} already exists at '${conflict.targetFullSlug}'. Current copy is create-only, so the real copy may fail.`,
+        targetFullSlug: conflict.targetFullSlug,
+    })),
+    ...(withAssets
+        ? []
+        : [
+            {
+                code: "assets_not_copied_by_story_command",
+                message: "Assets are not copied by this command unless --with-assets is passed.",
+            },
+            {
+                code: "asset_rewrite_requires_existing_asset_manifest",
+                message: "Asset fields are rewritten only when matching asset manifest entries already exist.",
+            },
+        ]),
+];
+const quoteCommandArg = (value) => /^[a-zA-Z0-9_./:-]+$/.test(value) ? value : JSON.stringify(value);
+const buildCopyCommand = ({ sourceSpace, targetSpace, selection, destination, withAssets, dryRun, outputPath, }) => {
+    const args = [
+        "sb-mig",
+        "copy",
+        "stories",
+        "--from",
+        sourceSpace,
+        "--to",
+        targetSpace,
+        "--source",
+        selection.source,
+        "--mode",
+        selection.mode,
+    ];
+    if (destination) {
+        args.push("--destination", destination);
+    }
+    if (withAssets) {
+        args.push("--with-assets");
+    }
+    if (dryRun) {
+        args.push("--dry-run");
+    }
+    if (outputPath) {
+        args.push("--outputPath", outputPath);
+    }
+    return args.map(quoteCommandArg).join(" ");
+};
+const buildCopyAssetsCommand = ({ sourceSpace, targetSpace, selection, dryRun, outputPath, }) => {
+    const args = [
+        "sb-mig",
+        "copy",
+        "assets",
+        "--from",
+        sourceSpace,
+        "--to",
+        targetSpace,
+    ];
+    if (selection.type === "all") {
+        args.push("--all");
+    }
+    else if (selection.type === "asset") {
+        for (const value of selection.values) {
+            args.push("--asset", value);
+        }
+    }
+    else if (selection.type === "asset_folder") {
+        for (const value of selection.values) {
+            args.push("--assetFolder", value);
         }
-        return { strategy: "folder_recursive" };
     }
-    // For regular paths, check if it's a folder or story
-    const entryStory = await managementApi.stories.getStoryBySlug(what, {
+    else {
+        args.push("--referenced-by-stories", "--source", selection.storySelection.source, "--mode", selection.storySelection.mode);
+    }
+    if (dryRun) {
+        args.push("--dry-run");
+    }
+    if (outputPath) {
+        args.push("--outputPath", outputPath);
+    }
+    return args.map(quoteCommandArg).join(" ");
+};
+const parseStoryblokAssetUrl = (filename) => {
+    if (!filename) {
+        return {};
+    }
+    let url;
+    try {
+        url = new URL(filename);
+    }
+    catch {
+        return {
+            uniqueKey: filename,
+        };
+    }
+    if (url.hostname !== "a.storyblok.com") {
+        return {
+            uniqueKey: filename,
+        };
+    }
+    const parts = url.pathname.split("/").filter(Boolean);
+    const fIndex = parts.indexOf("f");
+    const spaceId = fIndex >= 0 ? parts[fIndex + 1] : undefined;
+    const assetHash = fIndex >= 0 ? parts[fIndex + 3] : undefined;
+    const assetName = fIndex >= 0 ? parts.slice(fIndex + 4).join("/") : "";
+    if (!spaceId || !assetHash || !assetName) {
+        return {
+            spaceId,
+            uniqueKey: filename,
+        };
+    }
+    return {
+        spaceId,
+        uniqueKey: `storyblok:${spaceId}:${assetHash}:${assetName}`,
+    };
+};
+const getAssetReferenceUniqueKey = (reference) => {
+    const parsed = parseStoryblokAssetUrl(reference.filename);
+    return (parsed.uniqueKey ??
+        (reference.assetId === undefined
+            ? `unknown:${reference.path}`
+            : `asset-id:${reference.assetId}`));
+};
+const buildAssetReferenceSummary = ({ graph, sourceSpace, }) => {
+    if (!graph) {
+        return undefined;
+    }
+    const statuses = [
+        "mapped",
+        "planned",
+        "unresolved",
+        "unsupported",
+    ];
+    const uniqueByStatus = new Map(statuses.map((status) => [status, new Set()]));
+    const occurrencesByStatus = new Map(statuses.map((status) => [status, 0]));
+    const foreignSpaces = new Map();
+    for (const reference of graph.assetReferences) {
+        const status = reference.status;
+        const uniqueKey = getAssetReferenceUniqueKey(reference);
+        occurrencesByStatus.set(status, (occurrencesByStatus.get(status) ?? 0) + 1);
+        uniqueByStatus.get(status)?.add(uniqueKey);
+        const parsed = parseStoryblokAssetUrl(reference.filename);
+        if (parsed.spaceId && parsed.spaceId !== sourceSpace) {
+            const existing = foreignSpaces.get(parsed.spaceId) ?? {
+                occurrences: 0,
+                uniqueAssets: new Set(),
+            };
+            existing.occurrences += 1;
+            existing.uniqueAssets.add(uniqueKey);
+            foreignSpaces.set(parsed.spaceId, existing);
+        }
+    }
+    const bucket = (status) => ({
+        occurrences: occurrencesByStatus.get(status) ?? 0,
+        uniqueAssets: uniqueByStatus.get(status)?.size ?? 0,
+    });
+    return {
+        mapped: bucket("mapped"),
+        planned: bucket("planned"),
+        unresolved: bucket("unresolved"),
+        unsupported: bucket("unsupported"),
+        foreignAssetSpaces: Array.from(foreignSpaces.entries())
+            .map(([spaceId, summary]) => ({
+            spaceId,
+            occurrences: summary.occurrences,
+            uniqueAssets: summary.uniqueAssets.size,
+        }))
+            .sort((left, right) => left.spaceId.localeCompare(right.spaceId)),
+    };
+};
+const buildCopyDryRunReport = ({ sourceSpace, targetSpace, selection, destination, withAssets, input, plan, conflicts, graph, outputPath, }) => {
+    const items = withConflictFlags(plan, conflicts);
+    const warnings = buildDryRunWarnings({ conflicts, withAssets });
+    const graphSummary = graph ? summarizeCopyGraph(graph) : undefined;
+    const assetReferencesMapped = graph?.assetReferences.filter((reference) => reference.status === "mapped").length ?? 0;
+    const assetReferencesPlanned = graph?.assetReferences.filter((reference) => reference.status === "planned").length ?? 0;
+    const assetReferencesUnresolved = graph?.assetReferences.filter((reference) => reference.status === "unresolved").length ?? 0;
+    const storyReferencesMapped = graph?.storyReferences.filter((reference) => reference.status === "mapped").length ?? 0;
+    const storyReferencesPreserved = graph?.storyReferences.filter((reference) => reference.status === "preserved_external").length ?? 0;
+    const storyReferencesUnresolved = graph?.storyReferences.filter((reference) => reference.status === "unresolved").length ?? 0;
+    const assetsMapped = graph?.assets.filter((asset) => asset.action === "match").length ?? 0;
+    const assetsToCopy = graph?.assets.filter((asset) => asset.action === "create").length ?? 0;
+    const assetReferenceSummary = buildAssetReferenceSummary({
+        graph,
+        sourceSpace,
+    });
+    const limitations = [
+        ...COPY_DRY_RUN_BASE_LIMITATIONS,
+        ...(withAssets
+            ? COPY_DRY_RUN_WITH_ASSETS_LIMITATIONS
+            : COPY_DRY_RUN_STORY_ONLY_LIMITATIONS),
+    ];
+    return {
+        schemaVersion: 1,
+        command: "copy stories",
+        dryRun: true,
+        generatedAt: new Date().toISOString(),
+        input,
+        normalized: {
+            sourceSpaceId: sourceSpace,
+            targetSpaceId: targetSpace,
+            source: selection.source,
+            destination: normalizeDestination(destination) || "root",
+            mode: selection.mode,
+            withAssets,
+        },
+        summary: {
+            plannedCreates: items.length,
+            folders: items.filter((item) => item.type === "folder").length,
+            stories: items.filter((item) => item.type === "story").length,
+            assetFolders: graphSummary?.assetFolders ?? 0,
+            assets: graphSummary?.assets ?? 0,
+            assetReferences: graphSummary?.assetReferences ?? 0,
+            assetReferencesMapped,
+            assetReferencesPlanned,
+            assetReferencesUnresolved,
+            assetsMapped,
+            assetsToCopy,
+            storyReferences: graphSummary?.storyReferences ?? 0,
+            storyReferencesMapped,
+            storyReferencesPreserved,
+            storyReferencesUnresolved,
+            conflicts: conflicts.length,
+            warnings: warnings.length + (graphSummary?.warnings ?? 0),
+            errors: graphSummary?.errors ?? 0,
+        },
+        items,
+        ...(graph ? { graph } : {}),
+        ...(assetReferenceSummary ? { assetReferenceSummary } : {}),
+        warnings,
+        errors: graph?.errors ?? [],
+        limitations,
+        commands: {
+            dryRun: buildCopyCommand({
+                sourceSpace,
+                targetSpace,
+                selection,
+                destination,
+                withAssets,
+                dryRun: true,
+                outputPath,
+            }),
+            apply: buildCopyCommand({
+                sourceSpace,
+                targetSpace,
+                selection,
+                destination,
+                withAssets,
+                dryRun: false,
+            }),
+        },
+    };
+};
+const buildCopyAssetsDryRunReport = ({ sourceSpace, targetSpace, selection, input, outputPath, graph, }) => {
+    const graphSummary = summarizeCopyGraph(graph);
+    return {
+        schemaVersion: 1,
+        command: "copy assets",
+        dryRun: true,
+        generatedAt: graph.generatedAt,
+        input,
+        normalized: {
+            sourceSpaceId: sourceSpace,
+            targetSpaceId: targetSpace,
+            selection: toSelectionReport(selection),
+        },
+        summary: {
+            plannedCreates: graphSummary.assetFolders + graphSummary.assets,
+            assetFolders: graphSummary.assetFolders,
+            assets: graphSummary.assets,
+            warnings: graphSummary.warnings,
+            errors: graphSummary.errors,
+        },
+        graph,
+        limitations: graph.limitations,
+        commands: {
+            dryRun: buildCopyAssetsCommand({
+                sourceSpace,
+                targetSpace,
+                selection,
+                dryRun: true,
+                outputPath,
+            }),
+            apply: buildCopyAssetsCommand({
+                sourceSpace,
+                targetSpace,
+                selection,
+                dryRun: false,
+            }),
+        },
+    };
+};
+const buildCopyStoriesApplyReport = ({ sourceSpace, targetSpace, selection, destination, withAssets, input, plan, storySummary, graph, assetCopyReport, manifestRoot, }) => {
+    const manifestPaths = getDefaultCopyManifestPaths({
+        sourceSpaceId: sourceSpace,
+        targetSpaceId: targetSpace,
+        rootDir: manifestRoot,
+    });
+    const graphSummary = graph ? summarizeCopyGraph(graph) : undefined;
+    return {
+        schemaVersion: 1,
+        command: "copy stories",
+        dryRun: false,
+        generatedAt: new Date().toISOString(),
+        input,
+        normalized: {
+            sourceSpaceId: sourceSpace,
+            targetSpaceId: targetSpace,
+            source: selection.source,
+            destination: normalizeDestination(destination) || "root",
+            mode: selection.mode,
+            withAssets,
+        },
+        summary: {
+            ...storySummary,
+            ...(assetCopyReport
+                ? {
+                    assetFoldersCreated: assetCopyReport.summary.assetFoldersCreated,
+                    assetFoldersMatched: assetCopyReport.summary.assetFoldersMatched,
+                    assetsCreated: assetCopyReport.summary.assetsCreated,
+                    assetsMatched: assetCopyReport.summary.assetsMatched,
+                }
+                : {}),
+            warnings: (graphSummary?.warnings ?? 0) +
+                (assetCopyReport?.summary.warnings ?? 0),
+            errors: (graphSummary?.errors ?? 0) +
+                (assetCopyReport?.summary.errors ?? 0),
+        },
+        items: plan,
+        ...(graph ? { graph } : {}),
+        ...(assetCopyReport ? { assetCopy: assetCopyReport } : {}),
+        manifestPaths: {
+            stories: manifestPaths.stories,
+            assets: manifestPaths.assets,
+            assetFolders: manifestPaths.assetFolders,
+            combined: manifestPaths.combined,
+        },
+        warnings: [
+            ...(graph?.warnings ?? []),
+            ...(assetCopyReport?.warnings ?? []),
+        ],
+        errors: [...(graph?.errors ?? []), ...(assetCopyReport?.errors ?? [])],
+    };
+};
+const writeDryRunReport = async (outputPath, report) => {
+    const outputDirectory = path.dirname(outputPath);
+    await fs.mkdir(outputDirectory, { recursive: true });
+    await fs.writeFile(outputPath, JSON.stringify(report, null, 2), "utf8");
+    Logger.success(`[dry-run] Copy plan written to ${outputPath}`);
+};
+const writeJsonReport = async (outputPath, report) => {
+    const outputDirectory = path.dirname(outputPath);
+    await fs.mkdir(outputDirectory, { recursive: true });
+    await fs.writeFile(outputPath, JSON.stringify(report, null, 2), "utf8");
+    Logger.success(`Copy report written to ${outputPath}`);
+};
+const appendCopyManifestEntry = async ({ combinedPath, resourcePath, entry, }) => {
+    await appendManifestEntry(resourcePath, entry);
+    await appendManifestEntry(combinedPath, entry);
+};
+const getAssetFolderPath = (folder, folderById) => {
+    const names = [String(folder.name ?? folder.id)];
+    const visited = new Set([Number(folder.id)]);
+    let parentId = folder.parent_id;
+    while (parentId !== null && parentId !== undefined) {
+        const parent = folderById.get(Number(parentId));
+        if (!parent || visited.has(Number(parent.id))) {
+            break;
+        }
+        names.unshift(String(parent.name ?? parent.id));
+        visited.add(Number(parent.id));
+        parentId = parent.parent_id;
+    }
+    return names.join("/");
+};
+const buildAssetFolderPathMap = (folders) => {
+    const folderById = new Map(folders.map((folder) => [Number(folder.id), folder]));
+    const folderByPath = new Map();
+    for (const folder of folders) {
+        folderByPath.set(getAssetFolderPath(folder, folderById), folder);
+    }
+    return folderByPath;
+};
+const isNumericSelector = (value) => /^\d+$/.test(value);
+const findSourceAssetBySelector = (assets, selector) => {
+    if (isNumericSelector(selector)) {
+        const byId = assets.find((asset) => Number(asset.id) === Number(selector));
+        if (byId) {
+            return byId;
+        }
+    }
+    const exactFilenameMatches = assets.filter((asset) => asset.filename === selector);
+    if (exactFilenameMatches.length === 1) {
+        return exactFilenameMatches[0];
+    }
+    if (exactFilenameMatches.length > 1) {
+        throw new Error(`Asset selector '${selector}' matched multiple source assets by filename. Use --asset <asset-id>.`);
+    }
+    const fileNameMatches = assets.filter((asset) => getFileName(asset.filename) === selector);
+    if (fileNameMatches.length === 1) {
+        return fileNameMatches[0];
+    }
+    if (fileNameMatches.length > 1) {
+        throw new Error(`Asset selector '${selector}' matched multiple source assets by file name. Use --asset <asset-id>.`);
+    }
+    throw new Error(`Asset selector '${selector}' did not match a source asset by id, filename, or unique file name.`);
+};
+const findSourceAssetFolderBySelector = (folderById, folderByPath, selector) => {
+    if (isNumericSelector(selector)) {
+        const byId = folderById.get(Number(selector));
+        if (byId) {
+            return byId;
+        }
+    }
+    const normalizedPath = normalizeAssetFolderPath(selector);
+    const byPath = folderByPath.get(normalizedPath);
+    if (byPath) {
+        return byPath;
+    }
+    throw new Error(`Asset folder selector '${selector}' did not match a source asset folder by id or path.`);
+};
+const addAssetFolderAncestors = ({ folderId, folderById, selectedFolderIds, }) => {
+    const visited = new Set();
+    let currentFolderId = folderId;
+    while (currentFolderId !== null && currentFolderId !== undefined) {
+        const currentFolder = folderById.get(Number(currentFolderId));
+        if (!currentFolder || visited.has(Number(currentFolder.id))) {
+            break;
+        }
+        selectedFolderIds.add(Number(currentFolder.id));
+        visited.add(Number(currentFolder.id));
+        currentFolderId = currentFolder.parent_id;
+    }
+};
+const collectAssetFolderSubtreeIds = (rootFolderId, folders) => {
+    const selected = new Set([rootFolderId]);
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const folder of folders) {
+            const folderId = Number(folder.id);
+            const parentId = folder.parent_id;
+            if (parentId !== null &&
+                parentId !== undefined &&
+                selected.has(Number(parentId)) &&
+                !selected.has(folderId)) {
+                selected.add(folderId);
+                changed = true;
+            }
+        }
+    }
+    return selected;
+};
+const selectSourceAssetsForCopy = ({ selection, sourceAssets, sourceAssetFolders, }) => {
+    if (selection.type === "all") {
+        return {
+            assets: sourceAssets,
+            assetFolders: sourceAssetFolders,
+        };
+    }
+    const folderById = new Map(sourceAssetFolders.map((folder) => [Number(folder.id), folder]));
+    const folderByPath = buildAssetFolderPathMap(sourceAssetFolders);
+    const selectedAssetIds = new Set();
+    const selectedFolderIds = new Set();
+    if (selection.type === "asset") {
+        for (const selector of selection.values) {
+            const asset = findSourceAssetBySelector(sourceAssets, selector);
+            selectedAssetIds.add(Number(asset.id));
+            addAssetFolderAncestors({
+                folderId: asset.asset_folder_id,
+                folderById,
+                selectedFolderIds,
+            });
+        }
+    }
+    if (selection.type === "asset_folder") {
+        for (const selector of selection.values) {
+            const folder = findSourceAssetFolderBySelector(folderById, folderByPath, selector);
+            const subtreeFolderIds = collectAssetFolderSubtreeIds(Number(folder.id), sourceAssetFolders);
+            for (const folderId of subtreeFolderIds) {
+                selectedFolderIds.add(folderId);
+            }
+            addAssetFolderAncestors({
+                folderId: folder.parent_id,
+                folderById,
+                selectedFolderIds,
+            });
+        }
+        for (const asset of sourceAssets) {
+            if (asset.asset_folder_id !== null &&
+                asset.asset_folder_id !== undefined &&
+                selectedFolderIds.has(Number(asset.asset_folder_id))) {
+                selectedAssetIds.add(Number(asset.id));
+            }
+        }
+    }
+    return {
+        assets: sourceAssets.filter((asset) => selectedAssetIds.has(Number(asset.id))),
+        assetFolders: sourceAssetFolders.filter((folder) => selectedFolderIds.has(Number(folder.id))),
+    };
+};
+const selectSourceAssetsFromGraph = ({ graph, sourceAssets, sourceAssetFolders, }) => {
+    const graphAssetIds = new Set(graph.assets.map((asset) => Number(asset.sourceId)));
+    const graphAssetFolderIds = new Set(graph.assetFolders.map((folder) => Number(folder.sourceId)));
+    return {
+        assets: sourceAssets.filter((asset) => graphAssetIds.has(Number(asset.id))),
+        assetFolders: sourceAssetFolders.filter((folder) => graphAssetFolderIds.has(Number(folder.id))),
+    };
+};
+const getAssetMetadataPayload = (asset) => ({
+    ...(asset.alt ? { alt: asset.alt } : {}),
+    ...(asset.title ? { title: asset.title } : {}),
+    ...(asset.copyright ? { copyright: asset.copyright } : {}),
+    ...(asset.source ? { source: asset.source } : {}),
+    ...(asset.focus ? { focus: asset.focus } : {}),
+    ...(asset.meta_data ? { meta_data: asset.meta_data } : {}),
+    ...(asset.is_private === undefined ? {} : { is_private: asset.is_private }),
+    ...(asset.locked === undefined ? {} : { locked: asset.locked }),
+    ...(asset.publish_at === undefined ? {} : { publish_at: asset.publish_at }),
+    ...(asset.internal_tag_ids?.length
+        ? { internal_tag_ids: asset.internal_tag_ids }
+        : {}),
+});
+const findUniqueTargetAssetByFileName = (targetAssets, fileName) => {
+    const matches = targetAssets.filter((asset) => getFileName(asset.filename) === fileName);
+    return matches.length === 1 ? matches[0] : undefined;
+};
+const buildCopyAssetsApplyReport = ({ sourceSpace, targetSpace, selection, input, graph, manifestPaths, assetFoldersCreated, assetFoldersMatched, assetsCreated, assetsMatched, }) => ({
+    schemaVersion: 1,
+    command: "copy assets",
+    dryRun: false,
+    generatedAt: graph.generatedAt,
+    input,
+    normalized: {
+        sourceSpaceId: sourceSpace,
+        targetSpaceId: targetSpace,
+        selection: toSelectionReport(selection),
+    },
+    summary: {
+        assetFoldersCreated,
+        assetFoldersMatched,
+        assetsCreated,
+        assetsMatched,
+        warnings: graph.warnings.length,
+        errors: graph.errors.length,
+    },
+    graph,
+    manifestPaths: {
+        assets: manifestPaths.assets,
+        assetFolders: manifestPaths.assetFolders,
+        combined: manifestPaths.combined,
+    },
+    warnings: graph.warnings,
+    errors: graph.errors,
+});
+const buildSourceStoryById = (sourceStories) => new Map(sourceStories
+    .map((item) => item?.story)
+    .filter(Boolean)
+    .map((story) => [Number(story.id), story]));
+const buildTargetSlugBySourceSlug = (plan) => new Map(plan.map((item) => [item.sourceFullSlug, item.targetFullSlug]));
+const countTreeStories = (nodes) => nodes.reduce((counts, node) => {
+    const childCounts = countTreeStories(node.children ?? []);
+    return {
+        folders: counts.folders +
+            childCounts.folders +
+            (node.story?.is_folder ? 1 : 0),
+        stories: counts.stories +
+            childCounts.stories +
+            (node.story?.is_folder ? 0 : 1),
+    };
+}, { folders: 0, stories: 0 });
+const buildComponentSchemaRegistry = async (sourceSpace) => {
+    const components = await managementApi.components.getAllComponents({
         ...apiConfig,
         spaceId: sourceSpace,
     });
-    if (!entryStory) {
-        throw new Error(`Story not found: ${what}`);
+    if (!Array.isArray(components)) {
+        return {};
     }
-    const entryStoryIsFolder = entryStory.story.is_folder;
-    if (entryStoryIsFolder) {
-        return { strategy: "folder_with_root" };
+    return Object.fromEntries(components
+        .filter((component) => component?.name && component?.schema)
+        .map((component) => [component.name, component.schema]));
+};
+const collectAssetFolderAncestors = ({ assets, assetFolders, }) => {
+    const folderById = new Map(assetFolders.map((folder) => [Number(folder.id), folder]));
+    const selectedFolderIds = new Set();
+    for (const asset of assets) {
+        let folderId = asset.asset_folder_id;
+        const visited = new Set();
+        while (folderId !== null && folderId !== undefined) {
+            const numericFolderId = Number(folderId);
+            if (visited.has(numericFolderId)) {
+                break;
+            }
+            visited.add(numericFolderId);
+            selectedFolderIds.add(numericFolderId);
+            const folder = folderById.get(numericFolderId);
+            if (!folder) {
+                break;
+            }
+            folderId = folder.parent_id;
+        }
     }
-    return { strategy: "story" };
+    return assetFolders.filter((folder) => selectedFolderIds.has(Number(folder.id)));
 };
-export const copyCommand = async (props) => {
-    const { input, flags } = props;
-    const command = input[1];
-    switch (command) {
-        case COPY_COMMANDS.stories:
-            Logger.warning(`test sb-mig... with command: ${command}`);
-            console.log({ flags });
-            const sourceSpace = getSourceSpace(flags, apiConfig);
-            const targetSpace = getTargetSpace(flags, apiConfig);
-            const what = getWhat(flags);
-            const where = getWhere(flags);
-            console.log({ sourceSpace, targetSpace, what, where });
-            const { strategy } = await decideStrategy({ what, sourceSpace });
-            if (strategy === "folder_recursive") {
-                console.log({ strategy });
-                const rootStorySlug = what.slice(0, -2);
-                // 0. get the root story
-                const rootStory = await managementApi.stories.getStoryBySlug(rootStorySlug, {
-                    ...apiConfig,
-                    spaceId: sourceSpace,
+const hasMappedAssetReference = ({ assetId, filename, copyMaps, }) => (assetId !== undefined && copyMaps.assetIds.has(assetId)) ||
+    (filename !== undefined && copyMaps.assetFilenames.has(filename));
+const annotateReferencesWithManifestMaps = ({ graph, copyMaps, withAssets, }) => {
+    for (const reference of graph.assetReferences) {
+        if (hasMappedAssetReference({ ...reference, copyMaps })) {
+            reference.status = "mapped";
+            continue;
+        }
+        if (!withAssets && reference.status === "planned") {
+            reference.status = "unresolved";
+        }
+    }
+    for (const reference of graph.storyReferences) {
+        if ((reference.referencedStoryId !== undefined &&
+            copyMaps.storyIds.has(reference.referencedStoryId)) ||
+            (reference.referencedStoryUuid !== undefined &&
+                copyMaps.storyUuids.has(reference.referencedStoryUuid))) {
+            reference.status = "mapped";
+        }
+    }
+};
+const annotateAssetsWithManifestMaps = ({ graph, copyMaps, }) => {
+    for (const folder of graph.assetFolders) {
+        const targetFolderId = copyMaps.assetFolderIds.get(folder.sourceId);
+        if (targetFolderId === undefined) {
+            continue;
+        }
+        const sourceParentId = normalizeAssetFolderParentId(folder.sourceParentId);
+        folder.targetParentId =
+            sourceParentId === null
+                ? null
+                : (copyMaps.assetFolderIds.get(sourceParentId) ?? null);
+        folder.action = "match";
+    }
+    for (const asset of graph.assets) {
+        const mappedAsset = copyMaps.assetIds.get(asset.sourceId);
+        const targetFilename = mappedAsset?.filename ??
+            copyMaps.assetFilenames.get(asset.sourceFilename);
+        if (!mappedAsset && !targetFilename) {
+            continue;
+        }
+        asset.action = "match";
+        asset.targetFilename = targetFilename ?? asset.targetFilename;
+        asset.targetAssetFolderId =
+            asset.sourceAssetFolderId === null ||
+                asset.sourceAssetFolderId === undefined
+                ? null
+                : (copyMaps.assetFolderIds.get(asset.sourceAssetFolderId) ??
+                    null);
+    }
+};
+const buildStoryReferenceDryRunGraph = ({ sourceSpace, targetSpace, selection, destination, plan, sourceStories, schemas, copyMaps, onScanProgress, }) => {
+    const sourceStoryByFullSlug = new Map(sourceStories
+        .map((item) => item?.story)
+        .filter(Boolean)
+        .map((story) => [String(story.full_slug ?? ""), story]));
+    const scanResult = scanStoriesReferences({
+        stories: sourceStories.map((item) => item?.story).filter(Boolean),
+        schemas,
+        options: {
+            referencePolicy: "preserve",
+            onProgress: onScanProgress,
+        },
+    });
+    const graph = createCopyGraph({
+        sourceSpaceId: sourceSpace,
+        targetSpaceId: targetSpace,
+        scope: {
+            command: "copy stories",
+            source: selection.source,
+            destination: normalizeDestination(destination) || "root",
+            mode: selection.mode,
+            withAssets: false,
+            referencePolicy: "preserve",
+        },
+    });
+    graph.stories = plan.map((item) => ({
+        type: "story",
+        sourceId: Number(sourceStoryByFullSlug.get(item.sourceFullSlug)?.id ?? 0),
+        sourceUuid: sourceStoryByFullSlug.get(item.sourceFullSlug)?.uuid,
+        sourceFullSlug: item.sourceFullSlug,
+        targetFullSlug: item.targetFullSlug,
+        isFolder: item.type === "folder",
+        action: item.action,
+    }));
+    graph.assetReferences.push(...scanResult.assetReferences);
+    graph.storyReferences.push(...scanResult.storyReferences);
+    graph.opaqueFields.push(...scanResult.opaqueFields);
+    graph.warnings.push(...scanResult.warnings);
+    graph.errors.push(...scanResult.errors);
+    annotateReferencesWithManifestMaps({
+        graph,
+        copyMaps,
+        withAssets: false,
+    });
+    return graph;
+};
+const buildReferencedAssetsGraph = ({ sourceSpace, targetSpace, selection, destination, plan, sourceStories, sourceAssets, sourceAssetFolders, schemas, copyMaps, onScanProgress, }) => {
+    const scanResult = scanStoriesReferences({
+        stories: sourceStories.map((item) => item?.story).filter(Boolean),
+        schemas,
+        options: {
+            referencePolicy: "preserve",
+            onProgress: onScanProgress,
+        },
+    });
+    const referencedAssetIds = new Set(scanResult.assetReferences
+        .map((reference) => reference.assetId)
+        .filter((assetId) => assetId !== undefined));
+    const referencedFilenames = new Set(scanResult.assetReferences
+        .map((reference) => reference.filename)
+        .filter((filename) => filename !== undefined));
+    const selectedAssets = sourceAssets.filter((asset) => referencedAssetIds.has(Number(asset.id)) ||
+        referencedFilenames.has(String(asset.filename)));
+    const selectedAssetIds = new Set(selectedAssets.map((asset) => Number(asset.id)));
+    const selectedFilenames = new Set(selectedAssets.map((asset) => String(asset.filename)));
+    const selectedAssetFolders = collectAssetFolderAncestors({
+        assets: selectedAssets,
+        assetFolders: sourceAssetFolders,
+    });
+    const sourceStoryByFullSlug = new Map(sourceStories
+        .map((item) => item?.story)
+        .filter(Boolean)
+        .map((story) => [String(story.full_slug ?? ""), story]));
+    const graph = buildCopyAssetsGraph({
+        sourceSpaceId: sourceSpace,
+        targetSpaceId: targetSpace,
+        assets: selectedAssets,
+        assetFolders: selectedAssetFolders,
+    });
+    graph.scope = {
+        command: "copy stories",
+        source: selection.source,
+        destination: normalizeDestination(destination) || "root",
+        mode: selection.mode,
+        withAssets: true,
+        referencePolicy: "preserve",
+    };
+    graph.stories = plan.map((item) => ({
+        type: "story",
+        sourceId: Number(sourceStoryByFullSlug.get(item.sourceFullSlug)?.id ?? 0),
+        sourceUuid: sourceStoryByFullSlug.get(item.sourceFullSlug)?.uuid,
+        sourceFullSlug: item.sourceFullSlug,
+        targetFullSlug: item.targetFullSlug,
+        isFolder: item.type === "folder",
+        action: item.action,
+    }));
+    graph.assetReferences.push(...scanResult.assetReferences.map((reference) => {
+        const isPlanned = (reference.assetId !== undefined &&
+            selectedAssetIds.has(reference.assetId)) ||
+            (reference.filename !== undefined &&
+                selectedFilenames.has(reference.filename));
+        return {
+            ...reference,
+            status: isPlanned ? "planned" : "unresolved",
+        };
+    }));
+    graph.storyReferences.push(...scanResult.storyReferences);
+    graph.opaqueFields.push(...scanResult.opaqueFields);
+    graph.warnings.push(...scanResult.warnings);
+    graph.errors.push(...scanResult.errors);
+    annotateReferencesWithManifestMaps({
+        graph,
+        copyMaps,
+        withAssets: true,
+    });
+    annotateAssetsWithManifestMaps({
+        graph,
+        copyMaps,
+    });
+    for (const reference of graph.assetReferences) {
+        if (reference.status !== "unresolved") {
+            continue;
+        }
+        graph.warnings.push({
+            code: "referenced_asset_not_found",
+            message: "A story references an asset that was not returned by the source space asset list.",
+            path: reference.path,
+            sourceValue: reference.assetId ?? reference.filename,
+        });
+    }
+    return graph;
+};
+const countStoryItems = (sourceStories) => sourceStories.map((item) => item?.story).filter(Boolean).length;
+const logReferenceScanProgress = ({ scanned, total, }) => {
+    Logger.success(`Scanned ${scanned} of ${total} stories for references.`);
+};
+const shouldUsePublishedLayerCopy = (publication, sourceStory, publishedLayerRecord) => publication.mode === "preserve-layers" &&
+    resolveStoryLayerState(sourceStory) === "dirty-published" &&
+    Boolean(publishedLayerRecord?.publishedLayerItem?.story);
+const shouldPublishCopiedCurrentStory = (publication, sourceStory) => {
+    if (publication.mode === "save-only") {
+        return false;
+    }
+    const layerState = resolveStoryLayerState(sourceStory);
+    if (layerState === "clean-published") {
+        return true;
+    }
+    if (layerState === "dirty-published") {
+        return publication.mode === "collapse-draft";
+    }
+    return false;
+};
+const buildRewrittenStoryPayload = ({ sourceStory, content, targetParentId, maps, schemas, }) => {
+    const rewritten = rewriteCopyReferences({
+        value: content ?? {},
+        maps,
+        schemas,
+    });
+    return {
+        payload: buildFinalStoryPayload({
+            sourceStory,
+            targetParentId,
+            rewrittenContent: rewritten.value,
+        }),
+        rewrittenReferences: rewritten.records.length,
+    };
+};
+const publishCopiedStory = async ({ storyId, story, publication, targetSpace, }) => {
+    const languages = publication.resolvedPublishLanguages;
+    if (!languages || languages.length === 0) {
+        return { ok: true, stage: "publish_skipped" };
+    }
+    return managementApi.stories.publishStoryLanguages({
+        storyId,
+        story,
+        languages,
+    }, {
+        ...apiConfig,
+        spaceId: targetSpace,
+    });
+};
+const rewriteCopiedStoryContents = async ({ tree, realParentId, sourceStoryById, targetSlugBySourceSlug, publication, publishedLayerRecordBySourceId, sourceSpace, targetSpace, manifestRoot, }) => {
+    const manifestPaths = getDefaultCopyManifestPaths({
+        sourceSpaceId: sourceSpace,
+        targetSpaceId: targetSpace,
+        rootDir: manifestRoot,
+    });
+    const manifestEntries = await loadManifest(manifestPaths.combined);
+    const maps = buildCopyMaps(manifestEntries);
+    const schemas = await buildComponentSchemaRegistry(sourceSpace);
+    let updatedStories = 0;
+    let rewrittenReferences = 0;
+    const writeStoryMapping = async ({ sourceStory, targetStory, targetFullSlug, action, }) => {
+        const entry = {
+            type: "story",
+            source_space_id: sourceSpace,
+            target_space_id: targetSpace,
+            source_id: Number(sourceStory.id),
+            target_id: Number(targetStory.id),
+            source_uuid: String(sourceStory.uuid),
+            target_uuid: String(targetStory.uuid),
+            source_full_slug: String(sourceStory.full_slug ?? ""),
+            target_full_slug: targetStory.full_slug ?? targetFullSlug,
+            action,
+            created_at: new Date().toISOString(),
+        };
+        await appendCopyManifestEntry({
+            combinedPath: manifestPaths.combined,
+            resourcePath: manifestPaths.stories,
+            entry,
+        });
+        maps.storyIds.set(entry.source_id, entry.target_id);
+        maps.storyUuids.set(entry.source_uuid, entry.target_uuid);
+        return entry.target_id;
+    };
+    const createOrMatchReplacementShell = async ({ node, sourceStory, parentId, staleTargetId, }) => {
+        const sourceFullSlug = String(sourceStory.full_slug ?? "");
+        const targetFullSlug = targetSlugBySourceSlug.get(sourceFullSlug);
+        const existingTargetStory = targetFullSlug
+            ? await managementApi.stories.getStoryBySlug(targetFullSlug, {
+                ...apiConfig,
+                spaceId: targetSpace,
+            })
+            : undefined;
+        if (existingTargetStory?.story?.id &&
+            Number(existingTargetStory.story.id) !== staleTargetId) {
+            return writeStoryMapping({
+                sourceStory,
+                targetStory: existingTargetStory.story,
+                targetFullSlug,
+                action: "matched_by_target_key",
+            });
+        }
+        const createdStoryResult = await managementApi.stories.createStory(buildStoryShellPayload(node.story ?? sourceStory, parentId), {
+            ...apiConfig,
+            spaceId: targetSpace,
+        }, {
+            publish: false,
+        });
+        const targetStory = createdStoryResult?.story;
+        if (!targetStory?.id || !targetStory?.uuid) {
+            throw new Error(`Failed to create replacement target story for '${sourceFullSlug}'.`);
+        }
+        return writeStoryMapping({
+            sourceStory,
+            targetStory,
+            targetFullSlug,
+            action: "created",
+        });
+    };
+    const walk = async (nodes, parentId) => {
+        for (const node of nodes) {
+            const sourceId = Number(node.id ?? node.story?.id);
+            const sourceStory = sourceStoryById.get(sourceId);
+            if (!sourceStory?.id) {
+                continue;
+            }
+            let targetStoryId = maps.storyIds.get(Number(sourceStory.id));
+            if (!targetStoryId) {
+                targetStoryId = await createOrMatchReplacementShell({
+                    node,
+                    sourceStory,
+                    parentId,
                 });
-                // 1. get all stories inside this folder, and recursively
-                const allSourceStories = [rootStory].concat(await managementApi.stories.getAllStories({
-                    options: {
-                        starts_with: `${rootStorySlug}/`,
-                    },
-                }, {
-                    ...apiConfig,
-                    spaceId: sourceSpace,
-                }));
-                const normalizedStories = allSourceStories
-                    .map((item) => item.story)
-                    .map((item) => {
-                    if (item.full_slug === rootStorySlug) {
+            }
+            const writeStory = async (id) => {
+                const current = buildRewrittenStoryPayload({
+                    sourceStory,
+                    content: sourceStory.content,
+                    targetParentId: parentId,
+                    maps,
+                    schemas,
+                });
+                const publishedLayerRecord = publishedLayerRecordBySourceId.get(String(sourceStory.id));
+                if (shouldUsePublishedLayerCopy(publication, sourceStory, publishedLayerRecord)) {
+                    const publishedLayerStory = publishedLayerRecord?.publishedLayerItem?.story;
+                    const publishedLayer = buildRewrittenStoryPayload({
+                        sourceStory: publishedLayerStory,
+                        content: publishedLayerStory?.content,
+                        targetParentId: parentId,
+                        maps,
+                        schemas,
+                    });
+                    const publishedUpdateResult = await managementApi.stories.updateStory(publishedLayer.payload, String(id), {
+                        force_update: true,
+                        publish: false,
+                    }, {
+                        ...apiConfig,
+                        spaceId: targetSpace,
+                    });
+                    if (!publishedUpdateResult?.ok) {
                         return {
-                            ...item,
-                            parent_id: null,
+                            result: publishedUpdateResult,
+                            rewrittenReferences: current.rewrittenReferences +
+                                publishedLayer.rewrittenReferences,
                         };
                     }
+                    const publishResult = await publishCopiedStory({
+                        storyId: id,
+                        story: publishedLayer.payload,
+                        publication,
+                        targetSpace,
+                    });
+                    if (!publishResult?.ok) {
+                        return {
+                            result: publishResult,
+                            rewrittenReferences: current.rewrittenReferences +
+                                publishedLayer.rewrittenReferences,
+                        };
+                    }
+                    const restoreDraftResult = await managementApi.stories.updateStory(current.payload, String(id), {
+                        force_update: true,
+                        publish: false,
+                    }, {
+                        ...apiConfig,
+                        spaceId: targetSpace,
+                    });
                     return {
-                        ...item,
-                    };
-                });
-                const treeOfStories = createTree(normalizedStories);
-                const entryStory = await attachToFolder(where, targetSpace);
-                const reAttachedTreeOfStories = treeOfStories[0]?.children?.map((child) => {
-                    return {
-                        ...child,
-                        parent_id: entryStory.story.id,
-                        story: {
-                            ...child.story,
-                            parent_id: entryStory.story.id,
-                        },
+                        result: restoreDraftResult,
+                        rewrittenReferences: current.rewrittenReferences +
+                            publishedLayer.rewrittenReferences,
                     };
-                });
-                await traverseAndCreate({
-                    tree: reAttachedTreeOfStories,
-                    realParentId: entryStory.story.id,
-                    spaceId: targetSpace,
+                }
+                if (publication.mode === "preserve-layers" &&
+                    resolveStoryLayerState(sourceStory) === "dirty-published") {
+                    Logger.warning(`Skipping publish for copied story '${sourceStory.full_slug ?? sourceStory.slug}' because source story has unpublished changes and no published layer could be resolved.`);
+                }
+                const result = await managementApi.stories.updateStory(current.payload, String(id), {
+                    force_update: true,
+                    publish: false,
                 }, {
                     ...apiConfig,
                     spaceId: targetSpace,
                 });
-            }
-            if (strategy === "folder_with_root") {
-                console.log({ strategy });
-                // 0. get the root story
-                const rootStory = await managementApi.stories.getStoryBySlug(what, {
-                    ...apiConfig,
-                    spaceId: sourceSpace,
-                });
-                // 1. get all stories
-                const allSourceStories = [rootStory].concat(await managementApi.stories.getAllStories({
-                    options: {
-                        starts_with: `${what}/`,
-                    },
-                }, {
-                    ...apiConfig,
-                    spaceId: sourceSpace,
-                }));
-                const normalizedStories = allSourceStories
-                    .map((item) => item.story)
-                    .map((item) => {
-                    if (item.full_slug === what) {
+                if (result?.ok &&
+                    shouldPublishCopiedCurrentStory(publication, sourceStory)) {
+                    const publishResult = await publishCopiedStory({
+                        storyId: id,
+                        story: current.payload,
+                        publication,
+                        targetSpace,
+                    });
+                    if (!publishResult?.ok) {
                         return {
-                            ...item,
-                            parent_id: null,
+                            result: publishResult,
+                            rewrittenReferences: current.rewrittenReferences,
                         };
                     }
-                    return {
-                        ...item,
-                    };
-                });
-                const treeOfStories = createTree(normalizedStories);
-                const entryStory = await attachToFolder(where, targetSpace);
-                const enhancedTreeOfStories = {
-                    ...treeOfStories[0],
-                    parent_id: entryStory.story.id,
+                }
+                return {
+                    result,
+                    rewrittenReferences: current.rewrittenReferences,
                 };
-                await traverseAndCreate({
-                    tree: [enhancedTreeOfStories],
-                    realParentId: entryStory.story.id,
-                    spaceId: targetSpace,
-                }, {
+            };
+            let update = await writeStory(Number(targetStoryId));
+            if (isStoryUpdateNotFound(update.result)) {
+                Logger.warning(`Ignoring stale story manifest mapping for '${sourceStory.full_slug ?? sourceStory.slug}' because target story '${targetStoryId}' could not be updated in space '${targetSpace}'.`);
+                maps.storyIds.delete(Number(sourceStory.id));
+                maps.storyUuids.delete(String(sourceStory.uuid));
+                targetStoryId = await createOrMatchReplacementShell({
+                    node,
+                    sourceStory,
+                    parentId,
+                    staleTargetId: Number(targetStoryId),
+                });
+                update = await writeStory(Number(targetStoryId));
+            }
+            assertStoryUpdateSucceeded({
+                result: update.result,
+                sourceStory,
+                targetStoryId: Number(targetStoryId),
+                targetSpace,
+            });
+            updatedStories += 1;
+            rewrittenReferences += update.rewrittenReferences;
+            await walk(node.children ?? [], Number(targetStoryId));
+        }
+    };
+    await walk(tree, realParentId);
+    await dedupeManifestFile(manifestPaths.stories);
+    await dedupeManifestFile(manifestPaths.combined);
+    if (updatedStories > 0) {
+        Logger.success(`Updated ${updatedStories} copied story/story shell(s); rewrote ${rewrittenReferences} reference(s).`);
+    }
+};
+const createStoriesAndWriteManifests = async ({ tree, realParentId, sourceStoryById, targetSlugBySourceSlug, sourceSpace, targetSpace, manifestRoot, }) => {
+    const manifestPaths = getDefaultCopyManifestPaths({
+        sourceSpaceId: sourceSpace,
+        targetSpaceId: targetSpace,
+        rootDir: manifestRoot,
+    });
+    const existingManifestEntries = await loadManifest(manifestPaths.combined);
+    const copyMaps = buildCopyMaps(existingManifestEntries);
+    let storiesCreated = 0;
+    let storiesMatched = 0;
+    const walk = async (nodes, parentId) => {
+        for (const node of nodes) {
+            const sourceStory = sourceStoryById.get(Number(node.id ?? node.story.id));
+            const sourceFullSlug = String(sourceStory?.full_slug ?? node.story.full_slug ?? "");
+            const targetFullSlug = targetSlugBySourceSlug.get(sourceFullSlug);
+            if (!sourceStory?.uuid) {
+                throw new Error(`Cannot write story manifest for '${sourceFullSlug}' because source uuid is missing.`);
+            }
+            const mappedTargetId = copyMaps.storyIds.get(Number(sourceStory.id));
+            if (mappedTargetId) {
+                const mappedTargetStory = await getValidMappedTargetStory({
+                    sourceStory,
+                    targetStoryId: mappedTargetId,
+                    targetFullSlug,
+                    targetSpace,
+                });
+                if (mappedTargetStory) {
+                    storiesMatched += 1;
+                    await walk(node.children ?? [], mappedTargetId);
+                    continue;
+                }
+                copyMaps.storyIds.delete(Number(sourceStory.id));
+                copyMaps.storyUuids.delete(String(sourceStory.uuid));
+            }
+            const existingTargetStory = targetFullSlug
+                ? await managementApi.stories.getStoryBySlug(targetFullSlug, {
                     ...apiConfig,
                     spaceId: targetSpace,
+                })
+                : undefined;
+            const createdAt = new Date().toISOString();
+            if (existingTargetStory?.story) {
+                const targetStory = existingTargetStory.story;
+                const entry = {
+                    type: "story",
+                    source_space_id: sourceSpace,
+                    target_space_id: targetSpace,
+                    source_id: Number(sourceStory.id),
+                    target_id: Number(targetStory.id),
+                    source_uuid: String(sourceStory.uuid),
+                    target_uuid: String(targetStory.uuid),
+                    source_full_slug: sourceFullSlug,
+                    target_full_slug: targetStory.full_slug ?? targetFullSlug,
+                    action: "matched_by_target_key",
+                    created_at: createdAt,
+                };
+                await appendCopyManifestEntry({
+                    combinedPath: manifestPaths.combined,
+                    resourcePath: manifestPaths.stories,
+                    entry,
                 });
+                copyMaps.storyIds.set(entry.source_id, entry.target_id);
+                copyMaps.storyUuids.set(entry.source_uuid, entry.target_uuid);
+                storiesMatched += 1;
+                await walk(node.children ?? [], entry.target_id);
+                continue;
             }
-            if (strategy === "story") {
-                console.log({ strategy });
-                const entryStory = await managementApi.stories.getStoryBySlug(what, {
-                    ...apiConfig,
-                    spaceId: sourceSpace,
+            const createdStoryResult = await managementApi.stories.createStory(buildStoryShellPayload(node.story, parentId), {
+                ...apiConfig,
+                spaceId: targetSpace,
+            }, {
+                publish: false,
+            });
+            const targetStory = createdStoryResult?.story;
+            if (!targetStory?.id || !targetStory?.uuid) {
+                throw new Error(`Failed to create target story for '${sourceFullSlug}'.`);
+            }
+            const entry = {
+                type: "story",
+                source_space_id: sourceSpace,
+                target_space_id: targetSpace,
+                source_id: Number(sourceStory.id),
+                target_id: Number(targetStory.id),
+                source_uuid: String(sourceStory.uuid),
+                target_uuid: String(targetStory.uuid),
+                source_full_slug: sourceFullSlug,
+                target_full_slug: targetStory.full_slug ?? targetFullSlug,
+                action: "created",
+                created_at: createdAt,
+            };
+            await appendCopyManifestEntry({
+                combinedPath: manifestPaths.combined,
+                resourcePath: manifestPaths.stories,
+                entry,
+            });
+            copyMaps.storyIds.set(entry.source_id, entry.target_id);
+            copyMaps.storyUuids.set(entry.source_uuid, entry.target_uuid);
+            storiesCreated += 1;
+            await walk(node.children ?? [], entry.target_id);
+        }
+    };
+    await walk(tree, realParentId);
+    await dedupeManifestFile(manifestPaths.stories);
+    await dedupeManifestFile(manifestPaths.combined);
+    Logger.success(`Story manifest written to ${manifestPaths.stories}`);
+    const plannedCounts = countTreeStories(tree);
+    return {
+        storyFoldersPlanned: plannedCounts.folders,
+        storiesPlanned: plannedCounts.stories,
+        storiesCreated,
+        storiesMatched,
+    };
+};
+const copyAssetsAndWriteManifests = async ({ sourceSpace, targetSpace, selection, input, graph, sourceAssets, sourceAssetFolders, outputPath, manifestRoot, }) => {
+    const manifestPaths = getDefaultCopyManifestPaths({
+        sourceSpaceId: sourceSpace,
+        targetSpaceId: targetSpace,
+        rootDir: manifestRoot,
+    });
+    const existingManifestEntries = await loadManifest(manifestPaths.combined);
+    const copyMaps = buildCopyMaps(existingManifestEntries);
+    const targetAssetFoldersResult = await managementApi.assets.getAllAssetFolders({ spaceId: targetSpace }, {
+        ...apiConfig,
+        spaceId: targetSpace,
+    });
+    const targetAssetsResult = await managementApi.assets.getAllAssets({ spaceId: targetSpace }, {
+        ...apiConfig,
+        spaceId: targetSpace,
+    });
+    const targetAssetFolders = Array.isArray(targetAssetFoldersResult?.asset_folders)
+        ? targetAssetFoldersResult.asset_folders
+        : [];
+    const targetAssets = Array.isArray(targetAssetsResult?.assets)
+        ? targetAssetsResult.assets
+        : [];
+    const targetFolderByPath = buildAssetFolderPathMap(targetAssetFolders);
+    const sourceFolderById = new Map(sourceAssetFolders.map((folder) => [Number(folder.id), folder]));
+    const graphFolderBySourceId = new Map(graph.assetFolders.map((folder) => [folder.sourceId, folder]));
+    const graphAssetBySourceId = new Map(graph.assets.map((asset) => [asset.sourceId, asset]));
+    let assetFoldersCreated = 0;
+    let assetFoldersMatched = 0;
+    let assetsCreated = 0;
+    let assetsMatched = 0;
+    Logger.warning(`Copying assets from space '${sourceSpace}' to space '${targetSpace}'.`);
+    for (const folderNode of graph.assetFolders) {
+        const sourceFolder = sourceFolderById.get(folderNode.sourceId);
+        if (!sourceFolder) {
+            continue;
+        }
+        const sourceParentId = normalizeAssetFolderParentId(sourceFolder.parent_id);
+        const mappedTargetFolderId = copyMaps.assetFolderIds.get(folderNode.sourceId);
+        if (mappedTargetFolderId) {
+            folderNode.targetParentId =
+                sourceParentId === null
+                    ? null
+                    : (copyMaps.assetFolderIds.get(sourceParentId) ?? null);
+            folderNode.action = "match";
+            assetFoldersMatched += 1;
+            continue;
+        }
+        const existingTargetFolder = folderNode.sourcePath
+            ? targetFolderByPath.get(folderNode.sourcePath)
+            : undefined;
+        const createdAt = new Date().toISOString();
+        if (existingTargetFolder) {
+            const entry = {
+                type: "asset_folder",
+                source_space_id: sourceSpace,
+                target_space_id: targetSpace,
+                source_id: folderNode.sourceId,
+                target_id: Number(existingTargetFolder.id),
+                source_name: String(sourceFolder.name ?? ""),
+                target_name: String(existingTargetFolder.name ?? ""),
+                source_parent_id: sourceParentId,
+                target_parent_id: normalizeAssetFolderParentId(existingTargetFolder.parent_id),
+                source_path: folderNode.sourcePath,
+                target_path: folderNode.sourcePath,
+                action: "matched_by_target_key",
+                created_at: createdAt,
+            };
+            await appendCopyManifestEntry({
+                combinedPath: manifestPaths.combined,
+                resourcePath: manifestPaths.assetFolders,
+                entry,
+            });
+            copyMaps.assetFolderIds.set(entry.source_id, entry.target_id);
+            folderNode.targetParentId = entry.target_parent_id;
+            folderNode.action = "match";
+            assetFoldersMatched += 1;
+            continue;
+        }
+        const targetParentId = sourceParentId === null
+            ? null
+            : (copyMaps.assetFolderIds.get(sourceParentId) ?? null);
+        const createdFolder = await managementApi.assets.createAssetFolder({
+            spaceId: targetSpace,
+            payload: {
+                name: String(sourceFolder.name),
+                parent_id: targetParentId,
+            },
+        }, {
+            ...apiConfig,
+            spaceId: targetSpace,
+        });
+        const targetFolder = createdFolder.asset_folder;
+        const entry = {
+            type: "asset_folder",
+            source_space_id: sourceSpace,
+            target_space_id: targetSpace,
+            source_id: folderNode.sourceId,
+            target_id: Number(targetFolder.id),
+            source_name: String(sourceFolder.name ?? ""),
+            target_name: String(targetFolder.name ?? ""),
+            source_parent_id: sourceParentId,
+            target_parent_id: normalizeAssetFolderParentId(targetFolder.parent_id),
+            source_path: folderNode.sourcePath,
+            target_path: folderNode.sourcePath,
+            action: "created",
+            created_at: createdAt,
+        };
+        await appendCopyManifestEntry({
+            combinedPath: manifestPaths.combined,
+            resourcePath: manifestPaths.assetFolders,
+            entry,
+        });
+        copyMaps.assetFolderIds.set(entry.source_id, entry.target_id);
+        folderNode.targetParentId = entry.target_parent_id;
+        folderNode.action = "create";
+        assetFoldersCreated += 1;
+    }
+    for (const asset of sourceAssets) {
+        const graphAsset = graphAssetBySourceId.get(Number(asset.id));
+        if (!graphAsset) {
+            continue;
+        }
+        const mappedTargetAsset = copyMaps.assetIds.get(Number(asset.id));
+        if (mappedTargetAsset) {
+            graphAsset.targetFilename = mappedTargetAsset.filename;
+            graphAsset.targetAssetFolderId =
+                asset.asset_folder_id === null ||
+                    asset.asset_folder_id === undefined
+                    ? null
+                    : (copyMaps.assetFolderIds.get(Number(asset.asset_folder_id)) ?? null);
+            graphAsset.action = "match";
+            assetsMatched += 1;
+            continue;
+        }
+        const fileName = getFileName(asset.filename);
+        const existingTargetAsset = findUniqueTargetAssetByFileName(targetAssets, fileName);
+        const targetAssetFolderId = asset.asset_folder_id === null ||
+            asset.asset_folder_id === undefined
+            ? null
+            : (copyMaps.assetFolderIds.get(Number(asset.asset_folder_id)) ??
+                null);
+        const createdAt = new Date().toISOString();
+        if (existingTargetAsset) {
+            const entry = {
+                type: "asset",
+                source_space_id: sourceSpace,
+                target_space_id: targetSpace,
+                source_id: Number(asset.id),
+                target_id: Number(existingTargetAsset.id),
+                source_filename: asset.filename,
+                target_filename: existingTargetAsset.filename,
+                source_asset_folder_id: asset.asset_folder_id ?? null,
+                target_asset_folder_id: existingTargetAsset.asset_folder_id ?? null,
+                action: "matched_by_target_key",
+                created_at: createdAt,
+            };
+            await appendCopyManifestEntry({
+                combinedPath: manifestPaths.combined,
+                resourcePath: manifestPaths.assets,
+                entry,
+            });
+            copyMaps.assetIds.set(entry.source_id, {
+                id: entry.target_id,
+                filename: entry.target_filename,
+            });
+            copyMaps.assetFilenames.set(entry.source_filename, entry.target_filename);
+            graphAsset.targetFilename = entry.target_filename;
+            graphAsset.targetAssetFolderId = entry.target_asset_folder_id;
+            graphAsset.action = "match";
+            assetsMatched += 1;
+            continue;
+        }
+        const pathToFile = await managementApi.assets.downloadAsset({ payload: asset }, apiConfig);
+        const targetAsset = await managementApi.assets.createAssetAndFinalize({
+            spaceId: targetSpace,
+            pathToFile,
+            payload: {
+                filename: asset.filename,
+                asset_folder_id: targetAssetFolderId,
+            },
+        }, {
+            ...apiConfig,
+            spaceId: targetSpace,
+        });
+        if (Object.keys(getAssetMetadataPayload(asset)).length > 0) {
+            await managementApi.assets.updateAsset({
+                spaceId: targetSpace,
+                assetId: Number(targetAsset.id),
+                payload: getAssetMetadataPayload(asset),
+            }, {
+                ...apiConfig,
+                spaceId: targetSpace,
+            });
+        }
+        const entry = {
+            type: "asset",
+            source_space_id: sourceSpace,
+            target_space_id: targetSpace,
+            source_id: Number(asset.id),
+            target_id: Number(targetAsset.id),
+            source_filename: asset.filename,
+            target_filename: targetAsset.filename,
+            source_asset_folder_id: asset.asset_folder_id ?? null,
+            target_asset_folder_id: targetAssetFolderId,
+            action: "created",
+            created_at: createdAt,
+        };
+        await appendCopyManifestEntry({
+            combinedPath: manifestPaths.combined,
+            resourcePath: manifestPaths.assets,
+            entry,
+        });
+        copyMaps.assetIds.set(entry.source_id, {
+            id: entry.target_id,
+            filename: entry.target_filename,
+        });
+        copyMaps.assetFilenames.set(entry.source_filename, entry.target_filename);
+        graphAsset.targetFilename = entry.target_filename;
+        graphAsset.targetAssetFolderId = entry.target_asset_folder_id;
+        graphAsset.action = "create";
+        assetsCreated += 1;
+    }
+    await dedupeManifestFile(manifestPaths.assetFolders);
+    await dedupeManifestFile(manifestPaths.assets);
+    await dedupeManifestFile(manifestPaths.combined);
+    graph.limitations = [];
+    const report = buildCopyAssetsApplyReport({
+        sourceSpace,
+        targetSpace,
+        selection,
+        input,
+        graph,
+        manifestPaths,
+        assetFoldersCreated,
+        assetFoldersMatched,
+        assetsCreated,
+        assetsMatched,
+    });
+    if (outputPath) {
+        await writeJsonReport(outputPath, report);
+    }
+    Logger.success(`Asset copy complete. Created ${assetsCreated} asset(s), matched ${assetsMatched} asset(s).`);
+    Logger.success(`Asset manifest written to ${manifestPaths.assets}`);
+    Logger.success(`Asset folder manifest written to ${manifestPaths.assetFolders}`);
+    return report;
+};
+const logDryRunCopyPlan = async ({ report }) => {
+    Logger.warning("[dry-run] Copy stories preview only. No Storyblok writes will be made.");
+    Logger.warning(`[dry-run] Source space: ${report.normalized.sourceSpaceId}`);
+    Logger.warning(`[dry-run] Target space: ${report.normalized.targetSpaceId}`);
+    Logger.warning(`[dry-run] Source: ${report.normalized.source}`);
+    Logger.warning(`[dry-run] Destination: ${report.normalized.destination}`);
+    Logger.warning(`[dry-run] Mode: ${report.normalized.mode}`);
+    Logger.warning(`[dry-run] With assets: ${report.normalized.withAssets ? "yes" : "no"}`);
+    if (report.normalized.mode === "children") {
+        Logger.warning("[dry-run] Source folder root will not be created; only descendants are planned.");
+    }
+    if (report.normalized.mode === "self") {
+        Logger.warning("[dry-run] Descendants will not be copied; only the selected story or folder shell is planned.");
+    }
+    Logger.warning(`[dry-run] Would create ${report.items.length} story/folder item(s):`);
+    for (const item of report.items) {
+        Logger.warning(`[dry-run]   ${item.type.padEnd(6)} ${item.targetFullSlug || "<root>"}`);
+    }
+    if (report.graph) {
+        Logger.warning(`[dry-run] Would plan ${report.summary.assetFolders} referenced asset folder(s) and ${report.summary.assets} referenced asset(s).`);
+        Logger.warning(`[dry-run] Asset refs: ${report.summary.assetReferencesMapped} mapped, ${report.summary.assetReferencesPlanned} planned, ${report.summary.assetReferencesUnresolved} unresolved.`);
+        if (report.assetReferenceSummary) {
+            Logger.warning(`[dry-run] Unique asset refs: ${report.assetReferenceSummary.mapped.uniqueAssets} mapped, ${report.assetReferenceSummary.planned.uniqueAssets} planned, ${report.assetReferenceSummary.unresolved.uniqueAssets} unresolved.`);
+            for (const foreignSpace of report.assetReferenceSummary
+                .foreignAssetSpaces) {
+                Logger.warning(`[dry-run] Foreign asset space ${foreignSpace.spaceId}: ${foreignSpace.occurrences} occurrence(s), ${foreignSpace.uniqueAssets} unique asset(s).`);
+            }
+        }
+        Logger.warning(`[dry-run] Story refs: ${report.summary.storyReferencesMapped} mapped, ${report.summary.storyReferencesPreserved} preserved, ${report.summary.storyReferencesUnresolved} unresolved.`);
+        for (const folder of report.graph.assetFolders) {
+            Logger.warning(`[dry-run]   asset_folder ${folder.action.padEnd(6)} ${folder.targetPath ?? `#${folder.sourceId}`}`);
+        }
+        for (const asset of report.graph.assets) {
+            Logger.warning(`[dry-run]   asset ${asset.action.padEnd(6)} ${asset.targetFilename}`);
+        }
+        for (const reference of report.graph.assetReferences) {
+            Logger.warning(`[dry-run]   asset_ref ${reference.status.padEnd(10)} ${reference.filename ?? reference.assetId ?? "<unknown>"} at ${reference.sourceStoryFullSlug ?? reference.path}`);
+        }
+    }
+    report.warnings.forEach((warning) => Logger.warning(`[dry-run] ${warning.message}`));
+};
+const logDryRunCopyAssetsPlan = async ({ report, }) => {
+    const selectionLabel = report.normalized.selection === "all"
+        ? "all assets and asset folders"
+        : report.normalized.selection.type === "referenced_by_stories"
+            ? `referenced_by_stories ${report.normalized.selection.source} (${report.normalized.selection.mode})`
+            : `${report.normalized.selection.type} ${report.normalized.selection.values.join(", ")}`;
+    Logger.warning("[dry-run] Copy assets preview only. No Storyblok writes will be made.");
+    Logger.warning(`[dry-run] Source space: ${report.normalized.sourceSpaceId}`);
+    Logger.warning(`[dry-run] Target space: ${report.normalized.targetSpaceId}`);
+    Logger.warning(`[dry-run] Selection: ${selectionLabel}`);
+    Logger.warning(`[dry-run] Would plan ${report.summary.assetFolders} asset folder(s) and ${report.summary.assets} asset(s).`);
+    for (const folder of report.graph.assetFolders) {
+        Logger.warning(`[dry-run]   asset_folder ${folder.targetPath ?? `#${folder.sourceId}`}`);
+    }
+    for (const asset of report.graph.assets) {
+        Logger.warning(`[dry-run]   asset ${asset.targetFilename}`);
+    }
+    report.graph.warnings.forEach((warning) => Logger.warning(`[dry-run] ${warning.message}`));
+    report.limitations.forEach((limitation) => Logger.warning(`[dry-run] limitation: ${limitation}`));
+};
+export const copyCommand = async (props) => {
+    const { input, flags } = props;
+    const command = input[1];
+    switch (command) {
+        case COPY_COMMANDS.stories: {
+            const sourceSpace = getCopySpace(flags, ["from", "sourceSpace"], apiConfig.spaceId);
+            const targetSpace = getCopySpace(flags, ["to", "targetSpace"], apiConfig.spaceId);
+            const selection = resolveCopySelection(flags);
+            const dryRun = Boolean(flags["dryRun"]);
+            const outputPath = readStringFlag(flags, ["outputPath"]);
+            const manifestRoot = readStringFlag(flags, ["manifestRoot"]);
+            const withAssets = Boolean(flags["withAssets"] ?? flags["with-assets"]);
+            const publication = await resolveCopyPublicationOptions({
+                flags,
+                targetSpace,
+                dryRun,
+            });
+            const destination = readStringFlag(flags, ["destination", "where"]);
+            const destinationParentId = await resolveDestinationParentId(destination, targetSpace);
+            Logger.warning(`Copying stories from space '${sourceSpace}' to space '${targetSpace}'.`);
+            Logger.log(`Source '${selection.source}', mode '${selection.mode}', destination '${destination ?? "root"}'.`);
+            const sourceStories = await getStoriesForSelection(selection, sourceSpace);
+            const normalizedStories = normalizeStoriesForTree(sourceStories, selection);
+            const tree = createTree(normalizedStories);
+            const rootsToCreate = prepareTreeForCreate(selectTreeRoots(tree, selection));
+            if (rootsToCreate.length === 0) {
+                Logger.warning("No stories matched the copy selection.");
+                break;
+            }
+            const plan = buildCopyPlan(rootsToCreate, destination);
+            const manifestPaths = getDefaultCopyManifestPaths({
+                sourceSpaceId: sourceSpace,
+                targetSpaceId: targetSpace,
+                rootDir: manifestRoot,
+            });
+            const manifestEntries = await loadManifest(manifestPaths.combined);
+            const copyMaps = buildCopyMaps(manifestEntries);
+            let dryRunGraph;
+            let withAssetsGraph;
+            let sourceAssets = [];
+            let sourceAssetFolders = [];
+            if (dryRun || withAssets) {
+                const schemasPromise = buildComponentSchemaRegistry(sourceSpace);
+                if (withAssets) {
+                    const [schemas, assetsResult, assetFoldersResult] = await Promise.all([
+                        schemasPromise,
+                        managementApi.assets.getAllAssets({ spaceId: sourceSpace }, {
+                            ...apiConfig,
+                            spaceId: sourceSpace,
+                        }),
+                        managementApi.assets.getAllAssetFolders({ spaceId: sourceSpace }, {
+                            ...apiConfig,
+                            spaceId: sourceSpace,
+                        }),
+                    ]);
+                    sourceAssets = Array.isArray(assetsResult?.assets)
+                        ? assetsResult.assets
+                        : [];
+                    sourceAssetFolders = Array.isArray(assetFoldersResult?.asset_folders)
+                        ? assetFoldersResult.asset_folders
+                        : [];
+                    Logger.warning(`Planning referenced assets from ${countStoryItems(sourceStories)} stories against ${sourceAssets.length} source asset(s).`);
+                    withAssetsGraph = buildReferencedAssetsGraph({
+                        sourceSpace,
+                        targetSpace,
+                        selection,
+                        destination,
+                        plan,
+                        sourceStories,
+                        sourceAssets,
+                        sourceAssetFolders,
+                        schemas,
+                        copyMaps,
+                        onScanProgress: logReferenceScanProgress,
+                    });
+                    Logger.success(`Reference planning complete. Found ${withAssetsGraph.assets.length} referenced asset(s), ${withAssetsGraph.assetFolders.length} asset folder(s), ${withAssetsGraph.assetReferences.length} asset reference occurrence(s), and ${withAssetsGraph.storyReferences.length} story reference occurrence(s).`);
+                    dryRunGraph = withAssetsGraph;
+                }
+                else if (dryRun) {
+                    const schemas = await schemasPromise;
+                    Logger.warning(`Scanning ${countStoryItems(sourceStories)} stories for copy references.`);
+                    dryRunGraph = buildStoryReferenceDryRunGraph({
+                        sourceSpace,
+                        targetSpace,
+                        selection,
+                        destination,
+                        plan,
+                        sourceStories,
+                        schemas,
+                        copyMaps,
+                        onScanProgress: logReferenceScanProgress,
+                    });
+                    Logger.success(`Reference planning complete. Found ${dryRunGraph.assetReferences.length} asset reference occurrence(s) and ${dryRunGraph.storyReferences.length} story reference occurrence(s).`);
+                }
+            }
+            if (dryRun) {
+                const conflicts = await findTargetConflicts(plan, targetSpace);
+                Logger.warning("Building dry-run copy report.");
+                const report = buildCopyDryRunReport({
+                    sourceSpace,
+                    targetSpace,
+                    selection,
+                    destination,
+                    withAssets,
+                    input: { ...flags },
+                    plan,
+                    conflicts,
+                    graph: dryRunGraph,
+                    outputPath,
                 });
-                const targetEntryStory = await attachToFolder(where, targetSpace);
-                const finalStories = [
-                    {
-                        ...entryStory.story,
-                        parent_id: targetEntryStory.story.id,
+                await logDryRunCopyPlan({ report });
+                if (outputPath) {
+                    Logger.warning(`Writing dry-run copy report to ${outputPath}.`);
+                    await writeDryRunReport(outputPath, report);
+                }
+                break;
+            }
+            let assetCopyReport;
+            if (withAssetsGraph) {
+                Logger.warning("Copying referenced assets before stories because --with-assets was passed.");
+                assetCopyReport = await copyAssetsAndWriteManifests({
+                    sourceSpace,
+                    targetSpace,
+                    selection: {
+                        type: "asset",
+                        values: withAssetsGraph.assets.map((asset) => String(asset.sourceId)),
                     },
-                ];
-                const normalizedStories = finalStories.map((item) => {
-                    if (item.full_slug === what) {
-                        return {
-                            ...item,
-                            parent_id: null,
-                        };
-                    }
-                    return {
-                        ...item,
-                    };
+                    input: { ...flags },
+                    graph: withAssetsGraph,
+                    sourceAssets,
+                    sourceAssetFolders,
+                    manifestRoot,
                 });
-                const treeOfStories = createTree(normalizedStories);
-                await traverseAndCreate({
-                    tree: treeOfStories,
-                    realParentId: targetEntryStory.story.id,
-                    spaceId: targetSpace,
-                }, {
+            }
+            const publishedLayerRecordBySourceId = new Map();
+            if (publication.mode === "preserve-layers") {
+                const publishedLayerContext = await buildPublishedLayerContext({
+                    items: sourceStories,
+                    from: sourceSpace,
+                }, apiConfig);
+                for (const record of publishedLayerContext.records) {
+                    publishedLayerRecordBySourceId.set(String(record.storyId), record);
+                }
+            }
+            const storySummary = await createStoriesAndWriteManifests({
+                tree: rootsToCreate,
+                realParentId: destinationParentId,
+                sourceStoryById: buildSourceStoryById(sourceStories),
+                targetSlugBySourceSlug: buildTargetSlugBySourceSlug(plan),
+                sourceSpace,
+                targetSpace,
+                manifestRoot,
+            });
+            await rewriteCopiedStoryContents({
+                tree: rootsToCreate,
+                realParentId: destinationParentId,
+                sourceStoryById: buildSourceStoryById(sourceStories),
+                targetSlugBySourceSlug: buildTargetSlugBySourceSlug(plan),
+                publication,
+                publishedLayerRecordBySourceId,
+                sourceSpace,
+                targetSpace,
+                manifestRoot,
+            });
+            if (outputPath) {
+                const report = buildCopyStoriesApplyReport({
+                    sourceSpace,
+                    targetSpace,
+                    selection,
+                    destination,
+                    withAssets,
+                    input: { ...flags },
+                    plan,
+                    storySummary,
+                    graph: withAssetsGraph,
+                    assetCopyReport,
+                    manifestRoot,
+                });
+                await writeJsonReport(outputPath, report);
+            }
+            break;
+        }
+        case COPY_COMMANDS.assets: {
+            const sourceSpace = getCopySpace(flags, ["from", "sourceSpace"], apiConfig.spaceId);
+            const targetSpace = getCopySpace(flags, ["to", "targetSpace"], apiConfig.spaceId);
+            const dryRun = Boolean(flags["dryRun"]);
+            const outputPath = readStringFlag(flags, ["outputPath"]);
+            const manifestRoot = readStringFlag(flags, ["manifestRoot"]);
+            const selection = resolveCopyAssetsSelection(flags);
+            Logger.warning(dryRun
+                ? `Planning asset copy from space '${sourceSpace}' to space '${targetSpace}'.`
+                : `Preparing asset copy from space '${sourceSpace}' to space '${targetSpace}'.`);
+            const [assetsResult, assetFoldersResult] = await Promise.all([
+                managementApi.assets.getAllAssets({ spaceId: sourceSpace }, {
                     ...apiConfig,
-                    spaceId: targetSpace,
+                    spaceId: sourceSpace,
+                }),
+                managementApi.assets.getAllAssetFolders({ spaceId: sourceSpace }, {
+                    ...apiConfig,
+                    spaceId: sourceSpace,
+                }),
+            ]);
+            const sourceAssets = Array.isArray(assetsResult?.assets)
+                ? assetsResult.assets
+                : [];
+            const sourceAssetFolders = Array.isArray(assetFoldersResult?.asset_folders)
+                ? assetFoldersResult.asset_folders
+                : [];
+            let graph;
+            let scopedSource;
+            if (selection.type === "referenced_by_stories") {
+                const storySelection = selection.storySelection;
+                const [schemas, sourceStories] = await Promise.all([
+                    buildComponentSchemaRegistry(sourceSpace),
+                    getStoriesForSelection(storySelection, sourceSpace),
+                ]);
+                const normalizedStories = normalizeStoriesForTree(sourceStories, storySelection);
+                const tree = createTree(normalizedStories);
+                const rootsToCreate = prepareTreeForCreate(selectTreeRoots(tree, storySelection));
+                const plan = buildCopyPlan(rootsToCreate, undefined);
+                const manifestPaths = getDefaultCopyManifestPaths({
+                    sourceSpaceId: sourceSpace,
+                    targetSpaceId: targetSpace,
+                    rootDir: manifestRoot,
+                });
+                const manifestEntries = await loadManifest(manifestPaths.combined);
+                const copyMaps = buildCopyMaps(manifestEntries);
+                Logger.warning(`Planning referenced assets from ${countStoryItems(sourceStories)} stories against ${sourceAssets.length} source asset(s).`);
+                graph = buildReferencedAssetsGraph({
+                    sourceSpace,
+                    targetSpace,
+                    selection: storySelection,
+                    destination: undefined,
+                    plan,
+                    sourceStories,
+                    sourceAssets,
+                    sourceAssetFolders,
+                    schemas,
+                    copyMaps,
+                    onScanProgress: logReferenceScanProgress,
+                });
+                Logger.success(`Reference planning complete. Found ${graph.assets.length} referenced asset(s), ${graph.assetFolders.length} asset folder(s), ${graph.assetReferences.length} asset reference occurrence(s), and ${graph.storyReferences.length} story reference occurrence(s).`);
+                graph.scope = {
+                    command: "copy assets",
+                    source: storySelection.source,
+                    mode: storySelection.mode,
+                    referencePolicy: "preserve",
+                };
+                scopedSource = selectSourceAssetsFromGraph({
+                    graph,
+                    sourceAssets,
+                    sourceAssetFolders,
                 });
             }
+            else {
+                scopedSource = selectSourceAssetsForCopy({
+                    selection,
+                    sourceAssets,
+                    sourceAssetFolders,
+                });
+                graph = buildCopyAssetsGraph({
+                    sourceSpaceId: sourceSpace,
+                    targetSpaceId: targetSpace,
+                    assets: scopedSource.assets,
+                    assetFolders: scopedSource.assetFolders,
+                });
+            }
+            if (dryRun) {
+                const report = buildCopyAssetsDryRunReport({
+                    sourceSpace,
+                    targetSpace,
+                    selection,
+                    input: { ...flags },
+                    outputPath,
+                    graph,
+                });
+                await logDryRunCopyAssetsPlan({ report });
+                if (outputPath) {
+                    await writeDryRunReport(outputPath, report);
+                }
+                break;
+            }
+            await copyAssetsAndWriteManifests({
+                sourceSpace,
+                targetSpace,
+                selection,
+                input: { ...flags },
+                graph,
+                sourceAssets: scopedSource.assets,
+                sourceAssetFolders: scopedSource.assetFolders,
+                outputPath,
+                manifestRoot,
+            });
             break;
+        }
         default:
-            console.log(`no command like that: ${command}`);
+            Logger.warning("Unsupported copy command. Use: sb-mig copy stories --from <sourceSpaceId> --to <targetSpaceId> --source <full_slug> --destination <target_folder>, or sb-mig copy assets --from <sourceSpaceId> --to <targetSpaceId> --all --dry-run");
     }
 };