sb-mig 6.2.0 → 6.3.0-beta.2

package/README.md

@@ -9,13 +9,20 @@ If you've found an issue or you have feature request - <a href="https://github.c
 [![GitHub issues](https://img.shields.io/github/issues/sb-mig/sb-mig.svg?style=flat-square&v=1)](https://github.com/sb-mig/sb-mig/issues?q=is%3Aopen+is%3Aissue)
 ![npm](https://img.shields.io/npms-io/maintenance-score/sb-mig)
 
+# Documentation
+
+- [Docs site](https://sb-mig.vercel.app) is the canonical documentation for current sb-mig workflows.
+- [Quickstart](https://sb-mig.vercel.app/docs/quickstart) covers installation, credentials, and first safe commands.
+- [CLI reference](https://sb-mig.vercel.app/docs/reference/cli) covers command families and safety conventions.
+- [LLM docs index](https://sb-mig.vercel.app/llms.txt) and [full Markdown corpus](https://sb-mig.vercel.app/llms-full.txt) are available for coding agents and other LLM tools.
+
 # Requirements:
 
 |      |              |
 | ---- | ------------ |
 | Node | 22.x.x or >=24.x.x |
 
-# 6.x.x version released!
+# Current release notes: 6.x.x
 
 ## Important Updates
 
@@ -38,7 +45,11 @@ If you've found an issue or you have feature request - <a href="https://github.c
     - `--publishLanguages` is now `--publicationLanguages`
     - `--preservePublishedLayer` is now `--publicationMode preserve-layers`
 
-# 5.x.x version released!
+# Historical release notes
+
+The sections below are retained for historical context. For current usage, prefer the [docs site](https://sb-mig.vercel.app) and `sb-mig --help`.
+
+## 5.x.x version released!
 
 ## Important Updates
 
@@ -60,13 +71,13 @@ If you've found an issue or you have feature request - <a href="https://github.c
 
 Do not hesitate to get in touch if you encounter any issues or require further clarification on any points.
 
-# 4.x.x version released!
+## 4.x.x version released!
 
 - Whole deployment now, is handled by [semantic-release](https://github.com/semantic-release/semantic-release). And is just normal repository, instead of Lerna monorepo which is not needed anymore, and it was recently unmaintained (now it was passed to `nrwl` to maintain (https://github.com/lerna/lerna/issues/3121) will see what will happen in future with it :)
 - Fromt the code perspective, there are no **breaking changes** between **3.x.x** and **4.x.x** but i'm going to fix some stuff now and add some more functionalities to it. So stay tuned!
 - This Readme, which is also kinda documentation, will also be updated. Cause in some places there is misleading information. The best documentation though is just `sb-mig --help` command.
 
-# 3.x.x version released!
+## 3.x.x version released!
 
 - completely rewritten to simple [Meow](https://github.com/sindresorhus/meow) lib with help of Typescript. Check [migration guide](https://github.com/sb-mig/sb-mig/blob/oclif-research/MIGRATION-GUIDE-v3.md)
 - support native es modules

package/dist/api/assets/asset-folders.d.ts

@@ -0,0 +1,3 @@
+import type { CreateAssetFolder, GetAllAssetFolders } from "./asset-folders.types.js";
+export declare const getAllAssetFolders: GetAllAssetFolders;
+export declare const createAssetFolder: CreateAssetFolder;

package/dist/api/assets/asset-folders.js

@@ -0,0 +1,56 @@
+import Logger from "../../utils/logger.js";
+import { getAllItemsWithPagination } from "../utils/request.js";
+const joinQueryValues = (values) => values && values.length > 0 ? values.join(",") : undefined;
+export const getAllAssetFolders = async (args, config) => {
+    const { spaceId, search, withParent, byIds, byUuids } = args;
+    const { sbApi } = config;
+    const assetFolders = await getAllItemsWithPagination({
+        apiFn: ({ per_page, page }) => sbApi
+            .get(`spaces/${spaceId}/asset_folders/`, {
+            ...(search ? { search } : {}),
+            ...(withParent !== undefined && withParent !== null
+                ? { with_parent: String(withParent) }
+                : {}),
+            ...(joinQueryValues(byIds)
+                ? { by_ids: joinQueryValues(byIds) }
+                : {}),
+            ...(joinQueryValues(byUuids)
+                ? { by_uuids: joinQueryValues(byUuids) }
+                : {}),
+            per_page,
+            page,
+        })
+            .catch((err) => {
+            if (err.response?.status === 404) {
+                Logger.error(`There are no asset folders in your Storyblok ${spaceId} space.`);
+                return {
+                    data: { asset_folders: [] },
+                    total: 0,
+                    perPage: 100,
+                };
+            }
+            Logger.error(err);
+            throw err;
+        }),
+        params: {},
+        itemsKey: "asset_folders",
+    });
+    return { asset_folders: assetFolders };
+};
+export const createAssetFolder = async ({ spaceId, payload }, config) => {
+    const { sbApi } = config;
+    return sbApi
+        .post(`spaces/${spaceId}/asset_folders/`, {
+        asset_folder: {
+            name: payload.name,
+            ...(payload.parent_id === undefined
+                ? {}
+                : { parent_id: payload.parent_id }),
+        },
+    })
+        .then(({ data }) => data)
+        .catch((err) => {
+        Logger.error(err);
+        throw err;
+    });
+};

package/dist/api/assets/asset-folders.types.d.ts

@@ -0,0 +1,29 @@
+import type { RequestBaseConfig } from "../utils/request.js";
+export interface SBAssetFolder {
+    id: number;
+    name: string;
+    parent_id: number | null;
+    uuid?: string;
+    parent_uuid?: string | null;
+    [key: string]: unknown;
+}
+export interface SBAllAssetFoldersRequestResult {
+    asset_folders: SBAssetFolder[];
+}
+export type CreateAssetFolderPayload = {
+    name: string;
+    parent_id?: number | null;
+};
+export type GetAllAssetFolders = ({ spaceId, search, withParent, byIds, byUuids, }: {
+    spaceId: string;
+    search?: string;
+    withParent?: number | string;
+    byIds?: Array<number | string>;
+    byUuids?: string[];
+}, config: RequestBaseConfig) => Promise<SBAllAssetFoldersRequestResult>;
+export type CreateAssetFolder = ({ spaceId, payload, }: {
+    spaceId: string;
+    payload: CreateAssetFolderPayload;
+}, config: RequestBaseConfig) => Promise<{
+    asset_folder: SBAssetFolder;
+}>;

package/dist/api/assets/asset-folders.types.js

@@ -0,0 +1 @@
+export {};

package/dist/api/assets/assets.d.ts

@@ -1,8 +1,11 @@
-import type { CreateAsset, GetAllAssets, GetAssetById, GetAssetByName, MigrateAsset, UpdateAsset } from "./assets.types.js";
+import type { CreateAsset, CreateAssetAndFinalize, GetAllAssets, GetAssetById, GetAssetByName, MigrateAsset, UpdateAsset, DownloadAsset, FinishAssetUpload } from "./assets.types.js";
 export declare const getAllAssets: GetAllAssets;
 export declare const getAssetByName: GetAssetByName;
+export declare const finishAssetUpload: FinishAssetUpload;
+export declare const downloadAsset: DownloadAsset;
 export declare const migrateAsset: MigrateAsset;
 export declare const createAsset: CreateAsset;
+export declare const createAssetAndFinalize: CreateAssetAndFinalize;
 export declare const updateAsset: UpdateAsset;
 export declare const getAssetById: GetAssetById;
 export declare const getAsset: (assetName: string | undefined) => Promise<void>;

package/dist/api/assets/assets.js

@@ -5,6 +5,7 @@ import FormData from "form-data";
 import { createDir, isDirectoryExists } from "../../utils/files.js";
 import Logger from "../../utils/logger.js";
 import { getFileName, getSizeFromURL } from "../../utils/string-utils.js";
+import { getAllItemsWithPagination } from "../utils/request.js";
 const isStoryblokSize = (size) => Boolean(size && /^\d+x\d+$/i.test(size));
 const prepareSignedUploadPayload = (payload) => {
     const { filename, asset_folder_id, id, size, validate_upload } = payload;
@@ -27,23 +28,26 @@ const prepareSignedUploadPayload = (payload) => {
 export const getAllAssets = async (args, config) => {
     const { spaceId, search } = args;
     const { sbApi } = config;
-    return sbApi
-        .get(`spaces/${spaceId}/assets/`, {
-        // @ts-ignore TODO: have to submit ISSUE to storyblok-js-client (in documentation it is search, in typescript its search_term STORYBLOK_ISSUE
-        search: search ? search : "",
-        per_page: 100, // need to do pagination here probably
-    })
-        .then(({ data }) => data)
-        .catch((err) => {
-        if (err.response.status === 404) {
-            Logger.error(`There is no assets in your Storyblok ${spaceId} space.`);
-            return true;
-        }
-        else {
+    const assets = await getAllItemsWithPagination({
+        apiFn: ({ per_page, page }) => sbApi
+            .get(`spaces/${spaceId}/assets/`, {
+            // @ts-ignore TODO: have to submit ISSUE to storyblok-js-client (in documentation it is search, in typescript its search_term STORYBLOK_ISSUE
+            search: search ? search : "",
+            per_page,
+            page,
+        })
+            .catch((err) => {
+            if (err.response?.status === 404) {
+                Logger.error(`There is no assets in your Storyblok ${spaceId} space.`);
+                return { data: { assets: [] }, total: 0, perPage: 100 };
+            }
             Logger.error(err);
-            return false;
-        }
+            throw err;
+        }),
+        params: {},
+        itemsKey: "assets",
     });
+    return { assets };
 };
 export const getAssetByName = async ({ spaceId, fileName }, config) => {
     const result = await getAllAssets({ spaceId, search: fileName }, config);
@@ -95,7 +99,31 @@ const uploadFile = ({ signedResponseObject, pathToFile }) => {
         });
     });
 };
-const downloadAsset = async (args, config) => {
+const getSignedUploadAssetId = (signedResponseObject) => {
+    const assetId = Number(signedResponseObject?.id ?? signedResponseObject?.asset?.id);
+    if (!Number.isFinite(assetId)) {
+        throw new Error("Signed upload response did not include an asset id, so upload cannot be finalized.");
+    }
+    return assetId;
+};
+const normalizeFinishedUploadAsset = (finishedUpload) => {
+    const asset = finishedUpload?.asset ?? finishedUpload?.data?.asset ?? finishedUpload;
+    if (!asset?.id || !asset?.filename) {
+        throw new Error("Finish upload response did not include a target asset id and filename.");
+    }
+    return asset;
+};
+export const finishAssetUpload = async ({ spaceId, assetId }, config) => {
+    const { sbApi } = config;
+    return sbApi
+        .get(`spaces/${spaceId}/assets/${assetId}/finish_upload`, {})
+        .then(({ data }) => data)
+        .catch((err) => {
+        Logger.error(err);
+        throw err;
+    });
+};
+export const downloadAsset = async (args, config) => {
     const { debug, sbmigWorkingDirectory } = config;
     const { payload } = args;
     if (!sbmigWorkingDirectory) {
@@ -149,6 +177,23 @@ export const createAsset = async ({ spaceId, pathToFile, payload = {} }, config)
     await uploadFile({ signedResponseObject, pathToFile });
     return signedResponseObject;
 };
+export const createAssetAndFinalize = async ({ spaceId, pathToFile, payload = {} }, config) => {
+    const signedResponseObject = await createAsset({
+        spaceId,
+        pathToFile,
+        payload: {
+            ...payload,
+            filename: payload.filename ?? pathToFile,
+            validate_upload: payload.validate_upload ?? 1,
+        },
+    }, config);
+    const assetId = getSignedUploadAssetId(signedResponseObject);
+    const finishedUpload = await finishAssetUpload({
+        spaceId,
+        assetId,
+    }, config);
+    return normalizeFinishedUploadAsset(finishedUpload);
+};
 export const updateAsset = async ({ spaceId, assetId, payload }, config) => {
     const { sbApi } = config;
     Logger.log(`Trying to update asset with id ${assetId}.`);

package/dist/api/assets/assets.types.d.ts

@@ -7,7 +7,7 @@ export interface SBAsset {
     space_id: number;
     created_at: string;
     updated_at: string;
-    asset_folder_id?: null;
+    asset_folder_id?: number | null;
     deleted_at: null;
     content_length: number;
     content_type: AssetTypes;
@@ -80,6 +80,11 @@ export type CreateAsset = ({ spaceId, pathToFile, payload, }: {
     pathToFile: string;
     payload?: CreateAssetPayload;
 }, config: RequestBaseConfig) => Promise<SignedResponseObject>;
+export type CreateAssetAndFinalize = ({ spaceId, pathToFile, payload, }: {
+    spaceId: string;
+    pathToFile: string;
+    payload?: CreateAssetPayload;
+}, config: RequestBaseConfig) => Promise<SBAsset>;
 export type UpdateAsset = ({ spaceId, assetId, payload, }: {
     spaceId: string;
     assetId: number;
@@ -92,6 +97,12 @@ export type UploadFile = ({ signedResponseObject, pathToFile, }: {
 export type FinalizeUpload = ({ signedResponseObject, }: {
     signedResponseObject: SignedResponseObject;
 }) => void;
+export type FinishAssetUpload = ({ spaceId, assetId, }: {
+    spaceId: string;
+    assetId: number;
+}, config: RequestBaseConfig) => Promise<{
+    asset: Partial<SBAsset> & Pick<SBAsset, "id" | "filename">;
+}>;
 export type RequestSignedUploadUrl = ({ spaceId, payload, }: {
     spaceId: string;
     payload: AssetPayload | SignedUploadPayload;

package/dist/api/assets/index.d.ts

@@ -1,2 +1,4 @@
-export { getAllAssets, createAsset, migrateAsset, getAsset, getAssetById, getAssetByName, updateAsset, } from "./assets.js";
-export type { CreateAssetPayload, SignedUploadPayload, UpdateAssetPayload, } from "./assets.types.js";
+export { getAllAssets, createAsset, migrateAsset, getAsset, getAssetById, getAssetByName, createAssetAndFinalize, downloadAsset, finishAssetUpload, updateAsset, } from "./assets.js";
+export { createAssetFolder, getAllAssetFolders } from "./asset-folders.js";
+export type { CreateAssetAndFinalize, CreateAssetPayload, FinishAssetUpload, SignedUploadPayload, UpdateAssetPayload, } from "./assets.types.js";
+export type { CreateAssetFolder, CreateAssetFolderPayload, SBAllAssetFoldersRequestResult, SBAssetFolder, } from "./asset-folders.types.js";

package/dist/api/assets/index.js

@@ -1 +1,2 @@
-export { getAllAssets, createAsset, migrateAsset, getAsset, getAssetById, getAssetByName, updateAsset, } from "./assets.js";
+export { getAllAssets, createAsset, migrateAsset, getAsset, getAssetById, getAssetByName, createAssetAndFinalize, downloadAsset, finishAssetUpload, updateAsset, } from "./assets.js";
+export { createAssetFolder, getAllAssetFolders } from "./asset-folders.js";

package/dist/api/copy/assets.d.ts

@@ -0,0 +1,12 @@
+import type { CopyGraph } from "./types.js";
+import type { SBAssetFolder } from "../assets/asset-folders.types.js";
+import type { SBAsset } from "../assets/assets.types.js";
+export declare const COPY_ASSETS_DRY_RUN_LIMITATIONS: string[];
+export declare const normalizeAssetFolderParentId: (parentId: number | null | undefined) => number | null;
+export declare const buildCopyAssetsGraph: ({ sourceSpaceId, targetSpaceId, assets, assetFolders, generatedAt, }: {
+    sourceSpaceId: string;
+    targetSpaceId: string;
+    assets: SBAsset[];
+    assetFolders: SBAssetFolder[];
+    generatedAt?: string;
+}) => CopyGraph;

package/dist/api/copy/assets.js

@@ -0,0 +1,84 @@
+import { createCopyGraph } from "./graph.js";
+export const COPY_ASSETS_DRY_RUN_LIMITATIONS = [
+    "target_conflicts_not_checked",
+    "target_asset_identity_not_resolved",
+    "manifests_not_written_in_dry_run",
+];
+export const normalizeAssetFolderParentId = (parentId) => (parentId === 0 || parentId == null ? null : parentId);
+const getAssetFolderPath = (folder, folderById) => {
+    const names = [folder.name];
+    const visited = new Set([folder.id]);
+    let parentId = normalizeAssetFolderParentId(folder.parent_id);
+    while (parentId !== null) {
+        const parent = folderById.get(parentId);
+        if (!parent || visited.has(parent.id)) {
+            break;
+        }
+        names.unshift(parent.name);
+        visited.add(parent.id);
+        parentId = normalizeAssetFolderParentId(parent.parent_id);
+    }
+    return names.join("/");
+};
+const getAssetFolderDepth = (folder, folderById) => {
+    let depth = 0;
+    const visited = new Set([folder.id]);
+    let parentId = normalizeAssetFolderParentId(folder.parent_id);
+    while (parentId !== null) {
+        const parent = folderById.get(parentId);
+        if (!parent || visited.has(parent.id)) {
+            break;
+        }
+        depth += 1;
+        visited.add(parent.id);
+        parentId = normalizeAssetFolderParentId(parent.parent_id);
+    }
+    return depth;
+};
+export const buildCopyAssetsGraph = ({ sourceSpaceId, targetSpaceId, assets, assetFolders, generatedAt, }) => {
+    const graph = createCopyGraph({
+        sourceSpaceId,
+        targetSpaceId,
+        generatedAt,
+        scope: {
+            command: "copy assets",
+        },
+    });
+    graph.limitations.push(...COPY_ASSETS_DRY_RUN_LIMITATIONS);
+    const folderById = new Map(assetFolders.map((folder) => [folder.id, folder]));
+    const folderNodes = assetFolders
+        .map((folder) => ({
+        type: "asset_folder",
+        sourceId: folder.id,
+        sourcePath: getAssetFolderPath(folder, folderById),
+        targetPath: getAssetFolderPath(folder, folderById),
+        sourceParentId: normalizeAssetFolderParentId(folder.parent_id),
+        action: "create",
+        depth: getAssetFolderDepth(folder, folderById),
+    }))
+        .sort((left, right) => left.depth - right.depth || left.sourceId - right.sourceId)
+        .map(({ depth: _depth, ...node }) => node);
+    graph.assetFolders.push(...folderNodes);
+    for (const folder of assetFolders) {
+        const parentId = normalizeAssetFolderParentId(folder.parent_id);
+        if (parentId !== null && !folderById.has(parentId)) {
+            graph.warnings.push({
+                code: "asset_folder_parent_missing",
+                message: `Asset folder '${folder.name}' references parent id ${parentId}, but that parent was not returned by Storyblok.`,
+                path: getAssetFolderPath(folder, folderById),
+                sourceValue: parentId,
+            });
+        }
+    }
+    graph.assets.push(...assets
+        .map((asset) => ({
+        type: "asset",
+        sourceId: asset.id,
+        sourceFilename: asset.filename,
+        targetFilename: asset.filename,
+        sourceAssetFolderId: asset.asset_folder_id ?? null,
+        action: "create",
+    }))
+        .sort((left, right) => left.sourceId - right.sourceId));
+    return graph;
+};

package/dist/api/copy/graph.d.ts

@@ -0,0 +1,8 @@
+import type { CopyGraph, CopyGraphSummary, CopyScope } from "./types.js";
+export declare const createCopyGraph: ({ sourceSpaceId, targetSpaceId, scope, generatedAt, }: {
+    sourceSpaceId: string;
+    targetSpaceId: string;
+    scope: CopyScope;
+    generatedAt?: string;
+}) => CopyGraph;
+export declare const summarizeCopyGraph: (graph: CopyGraph) => CopyGraphSummary;

package/dist/api/copy/graph.js

@@ -0,0 +1,27 @@
+export const createCopyGraph = ({ sourceSpaceId, targetSpaceId, scope, generatedAt = new Date().toISOString(), }) => ({
+    schemaVersion: 1,
+    sourceSpaceId,
+    targetSpaceId,
+    generatedAt,
+    scope,
+    stories: [],
+    assets: [],
+    assetFolders: [],
+    storyReferences: [],
+    assetReferences: [],
+    opaqueFields: [],
+    warnings: [],
+    errors: [],
+    limitations: [],
+});
+export const summarizeCopyGraph = (graph) => ({
+    stories: graph.stories.length,
+    assets: graph.assets.length,
+    assetFolders: graph.assetFolders.length,
+    storyReferences: graph.storyReferences.length,
+    assetReferences: graph.assetReferences.length,
+    opaqueFields: graph.opaqueFields.length,
+    warnings: graph.warnings.length,
+    errors: graph.errors.length,
+    limitations: graph.limitations.length,
+});

package/dist/api/copy/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./graph.js";
+export * from "./manifest.js";
+export * from "./reference-scanner.js";
+export * from "./reference-rewriter.js";
+export * from "./assets.js";
+export * from "./types.js";

package/dist/api/copy/index.js

@@ -0,0 +1,6 @@
+export * from "./graph.js";
+export * from "./manifest.js";
+export * from "./reference-scanner.js";
+export * from "./reference-rewriter.js";
+export * from "./assets.js";
+export * from "./types.js";

package/dist/api/copy/manifest.d.ts

@@ -0,0 +1,23 @@
+import type { CopyManifestEntry, CopyMaps } from "./types.js";
+export type CopyManifestPaths = {
+    rootDir: string;
+    combined: string;
+    stories: string;
+    assets: string;
+    assetFolders: string;
+    report: string;
+};
+export declare const getDefaultCopyManifestPaths: ({ sourceSpaceId, targetSpaceId, rootDir, }: {
+    sourceSpaceId: string;
+    targetSpaceId: string;
+    rootDir?: string;
+}) => CopyManifestPaths;
+export declare const createEmptyCopyMaps: () => CopyMaps;
+export declare const loadManifest: <T extends CopyManifestEntry>(filePath: string) => Promise<T[]>;
+export declare const parseManifestJsonl: <T extends CopyManifestEntry>(content: string, filePath?: string) => T[];
+export declare const appendManifestEntry: (filePath: string, entry: CopyManifestEntry) => Promise<void>;
+export declare const appendManifestEntries: (filePath: string, entries: CopyManifestEntry[]) => Promise<void>;
+export declare const writeManifest: (filePath: string, entries: CopyManifestEntry[]) => Promise<void>;
+export declare const dedupeManifestEntries: <T extends CopyManifestEntry>(entries: T[]) => T[];
+export declare const dedupeManifestFile: (filePath: string) => Promise<CopyManifestEntry[]>;
+export declare const buildCopyMaps: (entries: CopyManifestEntry[]) => CopyMaps;

package/dist/api/copy/manifest.js

@@ -0,0 +1,115 @@
+import fs from "fs/promises";
+import path from "path";
+export const getDefaultCopyManifestPaths = ({ sourceSpaceId, targetSpaceId, rootDir = ".sb-mig", }) => {
+    const copyRoot = path.join(rootDir, "copy", sourceSpaceId, targetSpaceId);
+    return {
+        rootDir: copyRoot,
+        combined: path.join(copyRoot, "manifest.jsonl"),
+        stories: path.join(copyRoot, "stories.manifest.jsonl"),
+        assets: path.join(copyRoot, "assets.manifest.jsonl"),
+        assetFolders: path.join(copyRoot, "asset-folders.manifest.jsonl"),
+        report: path.join(copyRoot, "report.json"),
+    };
+};
+export const createEmptyCopyMaps = () => ({
+    storyIds: new Map(),
+    storyUuids: new Map(),
+    assetIds: new Map(),
+    assetFilenames: new Map(),
+    assetFolderIds: new Map(),
+});
+export const loadManifest = async (filePath) => {
+    try {
+        const content = await fs.readFile(filePath, "utf8");
+        return parseManifestJsonl(content, filePath);
+    }
+    catch (error) {
+        if (error?.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    }
+};
+export const parseManifestJsonl = (content, filePath = "manifest.jsonl") => content
+    .split("\n")
+    .map((line, index) => ({ line: line.trim(), lineNumber: index + 1 }))
+    .filter(({ line }) => line.length > 0)
+    .map(({ line, lineNumber }) => {
+    try {
+        return JSON.parse(line);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse manifest '${filePath}' at line ${lineNumber}: ${error.message}`);
+    }
+});
+export const appendManifestEntry = async (filePath, entry) => {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.appendFile(filePath, `${JSON.stringify(entry)}\n`, "utf8");
+};
+export const appendManifestEntries = async (filePath, entries) => {
+    if (entries.length === 0) {
+        return;
+    }
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.appendFile(filePath, entries.map((entry) => JSON.stringify(entry)).join("\n") + "\n", "utf8");
+};
+export const writeManifest = async (filePath, entries) => {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    const content = entries.length > 0
+        ? entries.map((entry) => JSON.stringify(entry)).join("\n") + "\n"
+        : "";
+    await fs.writeFile(filePath, content, "utf8");
+};
+export const dedupeManifestEntries = (entries) => {
+    const byKey = new Map();
+    for (const entry of entries) {
+        byKey.set(getManifestEntrySourceKey(entry), entry);
+    }
+    return Array.from(byKey.values());
+};
+export const dedupeManifestFile = async (filePath) => {
+    const entries = await loadManifest(filePath);
+    const deduped = dedupeManifestEntries(entries);
+    await writeManifest(filePath, deduped);
+    return deduped;
+};
+export const buildCopyMaps = (entries) => {
+    const maps = createEmptyCopyMaps();
+    for (const entry of entries) {
+        if (isStoryManifestEntry(entry)) {
+            maps.storyIds.set(entry.source_id, entry.target_id);
+            maps.storyUuids.set(entry.source_uuid, entry.target_uuid);
+        }
+        if (isAssetManifestEntry(entry)) {
+            maps.assetIds.set(entry.source_id, {
+                id: entry.target_id,
+                filename: entry.target_filename,
+            });
+            maps.assetFilenames.set(entry.source_filename, entry.target_filename);
+        }
+        if (isAssetFolderManifestEntry(entry)) {
+            maps.assetFolderIds.set(entry.source_id, entry.target_id);
+        }
+    }
+    return maps;
+};
+const getManifestEntrySourceKey = (entry) => {
+    if (isStoryManifestEntry(entry)) {
+        return [
+            entry.type,
+            entry.source_space_id,
+            entry.target_space_id,
+            entry.source_id,
+            entry.source_uuid,
+        ].join(":");
+    }
+    return [
+        entry.type,
+        entry.source_space_id,
+        entry.target_space_id,
+        entry.source_id,
+    ].join(":");
+};
+const isStoryManifestEntry = (entry) => entry.type === "story";
+const isAssetManifestEntry = (entry) => entry.type === "asset";
+const isAssetFolderManifestEntry = (entry) => entry.type === "asset_folder";

package/dist/api/copy/reference-rewriter.d.ts

@@ -0,0 +1,6 @@
+import type { CopyComponentSchemaRegistry, CopyMaps, CopyRewriteResult } from "./types.js";
+export declare const rewriteCopyReferences: <T>({ value, maps, schemas, }: {
+    value: T;
+    maps: CopyMaps;
+    schemas?: CopyComponentSchemaRegistry;
+}) => CopyRewriteResult<T>;