@softarc/native-federation 3.5.5 → 4.0.0-RC10

package/src/lib/core/normalize-options.d.ts

@@ -0,0 +1,12 @@
+import type { NormalizedFederationConfig } from '../domain/config/federation-config.contract.js';
+import type { FederationOptions, NormalizedFederationOptions } from '../domain/core/federation-options.contract.js';
+import { type FederationCache } from '../../domain.js';
+export declare function normalizeFederationOptions(options: FederationOptions): Promise<{
+    config: NormalizedFederationConfig;
+    options: NormalizedFederationOptions<undefined>;
+}>;
+export declare function normalizeFederationOptions<TBundlerCache>(options: FederationOptions, cache: FederationCache<TBundlerCache>): Promise<{
+    config: NormalizedFederationConfig;
+    options: NormalizedFederationOptions<TBundlerCache>;
+}>;
+export declare function resolveProjectName(name?: string): string;

package/src/lib/core/normalize-options.js

@@ -0,0 +1,57 @@
+import * as path from 'path';
+import * as fs from 'fs';
+import { pathToFileURL } from 'url';
+import { removeUnusedDeps } from '../config/remove-unused-deps.js';
+import { createFederationCache } from './federation-cache.js';
+import { getDefaultCachePath } from '../utils/cache-persistence.js';
+import { getUsedDependenciesFactory } from '../utils/get-used-dependencies.js';
+import { logger } from '../utils/logger.js';
+import { normalizePackageName } from '../utils/normalize.js';
+export async function normalizeFederationOptions(options, cache) {
+    /**
+     * Step 1: normalizing config
+     */
+    const fullConfigPath = path.join(options.workspaceRoot, options.federationConfig);
+    const getUsedDeps = getUsedDependenciesFactory(options.workspaceRoot, options.entryPoints);
+    if (!fs.existsSync(fullConfigPath)) {
+        throw new Error('Expected ' + fullConfigPath);
+    }
+    let config = (await import(pathToFileURL(fullConfigPath).href))
+        ?.default;
+    /**
+     * Step 2: normalizing options
+     */
+    const federationCache = cache ??
+        createFederationCache(getDefaultCachePath(options.workspaceRoot));
+    const normalizedOptions = {
+        ...options,
+        entryPoints: options.entryPoints ?? Object.values(config.exposes ?? {}),
+        projectName: resolveProjectName(options.projectName ?? config.name),
+        federationCache,
+    };
+    /**
+     * Step 3: Remove unused deps
+     */
+    if (config.features.ignoreUnusedDeps) {
+        config = removeUnusedDeps(getUsedDeps(config), config);
+        logger.info('Removed unused dependencies.');
+        logger.debug('This can be disabled per dependency/external using the "includeSecondaries: {keepAll: true}" property. Or in general by disabling the "ignoreUnusedDeps" feature. ');
+    }
+    else {
+        const withWildcard = Object.keys(config.sharedMappings).some(m => m.includes('*'));
+        if (withWildcard) {
+            logger.warn('Sharing mapped paths with wildcards (*) is only supported with ignoreUnusedDeps feature.');
+            config.sharedMappings = Object.entries(config.sharedMappings)
+                .filter(([_path]) => !_path.includes('*'))
+                .reduce((acc, [_path, _import]) => ({ ...acc, [_path]: _import }), {});
+        }
+    }
+    return { config, options: normalizedOptions };
+}
+export function resolveProjectName(name) {
+    if (!name || name.length < 1) {
+        logger.warn("Project name in 'federation.config.js' is empty, defaulting to 'shell' cache folder (could collide with other projects in the workspace).");
+        return 'shell';
+    }
+    return normalizePackageName(name);
+}

package/src/lib/core/rebuild-for-federation.d.ts

@@ -0,0 +1,4 @@
+import type { FederationInfo } from '../domain/core/federation-info.contract.js';
+import type { NormalizedFederationOptions } from '../domain/core/federation-options.contract.js';
+import type { NormalizedFederationConfig } from '../domain/config/federation-config.contract.js';
+export declare function rebuildForFederation(config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions, externals: string[], modifiedFiles: string[], signal?: AbortSignal): Promise<FederationInfo>;

package/src/lib/core/rebuild-for-federation.js

@@ -0,0 +1,37 @@
+import { bundleExposedAndMappings, describeExposed, describeSharedMappings, } from './bundle-exposed-and-mappings.js';
+import { writeFederationInfo } from './write-federation-info.js';
+import { writeImportMap } from './write-import-map.js';
+import { logger } from '../utils/logger.js';
+import { AbortedError } from '../utils/errors.js';
+export async function rebuildForFederation(config, fedOptions, externals, modifiedFiles, signal) {
+    const federationCache = fedOptions.federationCache;
+    logger.info(`Re-bundling all internal libraries and exposed modules..'`);
+    const start = process.hrtime();
+    const artifactInfo = await bundleExposedAndMappings(config, fedOptions, externals, modifiedFiles, signal);
+    logger.measure(start, 'To re-bundle all internal libraries and exposed modules.');
+    if (signal?.aborted)
+        throw new AbortedError('[buildForFederation] After exposed-and-mappings bundle');
+    const exposedInfo = !artifactInfo ? describeExposed(config, fedOptions) : artifactInfo.exposes;
+    const sharedMappingInfo = !artifactInfo
+        ? describeSharedMappings(config, fedOptions)
+        : artifactInfo.mappings;
+    const sharedExternals = [...federationCache.externals, ...sharedMappingInfo];
+    const buildNotificationsEndpoint = fedOptions.buildNotifications?.enable && fedOptions.dev
+        ? fedOptions.buildNotifications?.endpoint
+        : undefined;
+    const federationInfo = {
+        name: config.name,
+        shared: sharedExternals,
+        exposes: exposedInfo,
+        buildNotificationsEndpoint,
+    };
+    if (federationCache.chunks) {
+        federationInfo.chunks = federationCache.chunks;
+    }
+    if (artifactInfo?.chunks) {
+        federationInfo.chunks = { ...(federationInfo.chunks ?? {}), ...artifactInfo?.chunks };
+    }
+    writeFederationInfo(federationInfo, fedOptions);
+    writeImportMap(federationCache, fedOptions);
+    return federationInfo;
+}

package/src/lib/core/write-federation-info.d.ts

@@ -1,3 +1,3 @@
-import { FederationInfo } from '@softarc/native-federation-runtime';
-import { FederationOptions } from './federation-options';
+import type { FederationInfo } from '../domain/core/federation-info.contract.js';
+import type { FederationOptions } from '../domain/core/federation-options.contract.js';
 export declare function writeFederationInfo(federationInfo: FederationInfo, fedOptions: FederationOptions): void;

package/src/lib/core/write-federation-info.js

@@ -1,11 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeFederationInfo = writeFederationInfo;
-const tslib_1 = require("tslib");
-const fs = tslib_1.__importStar(require("fs"));
-const path = tslib_1.__importStar(require("path"));
-function writeFederationInfo(federationInfo, fedOptions) {
+import * as fs from 'fs';
+import * as path from 'path';
+export function writeFederationInfo(federationInfo, fedOptions) {
     const metaDataPath = path.join(fedOptions.workspaceRoot, fedOptions.outputPath, 'remoteEntry.json');
     fs.writeFileSync(metaDataPath, JSON.stringify(federationInfo, null, 2));
 }
-//# sourceMappingURL=write-federation-info.js.map

package/src/lib/core/write-import-map.d.ts

@@ -1,3 +1,6 @@
-import { SharedInfo } from '@softarc/native-federation-runtime';
-import { FederationOptions } from './federation-options';
-export declare function writeImportMap(sharedInfo: SharedInfo[], fedOption: FederationOptions): void;
+import type { ChunkInfo, SharedInfo } from '../domain/core/federation-info.contract.js';
+import type { FederationOptions } from '../domain/core/federation-options.contract.js';
+export declare function writeImportMap(sharedInfo: {
+    externals: SharedInfo[];
+    chunks?: ChunkInfo;
+}, fedOption: FederationOptions): void;

package/src/lib/core/write-import-map.js

@@ -1,18 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeImportMap = writeImportMap;
-const tslib_1 = require("tslib");
-const path = tslib_1.__importStar(require("path"));
-const fs = tslib_1.__importStar(require("fs"));
-function writeImportMap(sharedInfo, fedOption) {
-    const imports = sharedInfo.reduce((acc, cur) => {
+import * as path from 'path';
+import * as fs from 'fs';
+import { toChunkImport } from '../domain/core/chunk.js';
+export function writeImportMap(sharedInfo, fedOption) {
+    const imports = sharedInfo.externals.reduce((acc, cur) => {
         return {
             ...acc,
             [cur.packageName]: cur.outFileName,
         };
     }, {});
+    if (sharedInfo.chunks) {
+        Object.values(sharedInfo.chunks).forEach(c => {
+            c.forEach(e => {
+                const key = toChunkImport(e);
+                imports[key] = e;
+            });
+        });
+    }
     const importMap = { imports };
     const importMapPath = path.join(fedOption.workspaceRoot, fedOption.outputPath, 'importmap.json');
     fs.writeFileSync(importMapPath, JSON.stringify(importMap, null, 2));
 }
-//# sourceMappingURL=write-import-map.js.map

package/src/lib/domain/config/external-config.contract.d.ts

@@ -0,0 +1,43 @@
+export interface ExternalConfig {
+    singleton?: boolean;
+    strictVersion?: boolean;
+    requiredVersion?: string;
+    version?: string;
+    includeSecondaries?: boolean;
+    platform?: 'browser' | 'node';
+    build?: 'separate' | 'package';
+    chunks?: boolean;
+    shareScope?: string;
+    packageInfo?: {
+        entryPoint: string;
+        version?: string;
+        esm?: boolean;
+    };
+}
+export interface NormalizedExternalConfig {
+    singleton: boolean;
+    strictVersion: boolean;
+    requiredVersion: string;
+    version?: string;
+    includeSecondaries?: boolean;
+    shareScope?: string;
+    chunks: boolean;
+    platform: 'browser' | 'node';
+    build: 'default' | 'separate' | 'package';
+    packageInfo?: {
+        entryPoint: string;
+        version: string;
+        esm: boolean;
+    };
+}
+export type IncludeSecondariesOptions = {
+    skip: string | string[];
+    resolveGlob?: boolean;
+    keepAll?: boolean;
+} | boolean;
+export type SharedExternalsConfig = Record<string, ExternalConfig>;
+export type NormalizedSharedExternalsConfig = Record<string, NormalizedExternalConfig>;
+export type ShareAllExternalsOptions = ExternalConfig & {
+    includeSecondaries?: IncludeSecondariesOptions;
+};
+export type ShareExternalsOptions = Record<string, ShareAllExternalsOptions>;

package/src/lib/domain/config/external-config.contract.js

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

package/src/lib/domain/config/federation-config.contract.d.ts

@@ -0,0 +1,35 @@
+import type { PreparedSkipList, SkipList } from './skip-list.contract.js';
+import type { PathToImport } from '../utils/mapped-path.contract.js';
+import type { NormalizedSharedExternalsConfig, SharedExternalsConfig } from './external-config.contract.js';
+export interface FederationConfig {
+    name?: string;
+    exposes?: Record<string, string>;
+    shared?: SharedExternalsConfig;
+    platform?: 'browser' | 'node';
+    sharedMappings?: Array<string>;
+    chunks?: boolean;
+    skip?: SkipList;
+    externals?: string[];
+    shareScope?: string;
+    features?: {
+        mappingVersion?: boolean;
+        ignoreUnusedDeps?: boolean;
+        denseChunking?: boolean;
+    };
+}
+export interface NormalizedFederationConfig {
+    $type: 'classic';
+    name: string;
+    exposes: Record<string, string>;
+    shared: NormalizedSharedExternalsConfig;
+    sharedMappings: PathToImport;
+    skip: PreparedSkipList;
+    chunks: boolean;
+    externals: string[];
+    shareScope?: string;
+    features: {
+        mappingVersion: boolean;
+        ignoreUnusedDeps: boolean;
+        denseChunking: boolean;
+    };
+}

package/src/lib/domain/config/federation-config.contract.js

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

package/src/lib/domain/config/index.d.ts

@@ -0,0 +1,3 @@
+export type { ExternalConfig, IncludeSecondariesOptions, SharedExternalsConfig, ShareAllExternalsOptions, ShareExternalsOptions, } from './external-config.contract.js';
+export type { FederationConfig } from './federation-config.contract.js';
+export type { PreparedSkipList, SkipFn, SkipList, SkipListEntry } from './skip-list.contract.js';

package/src/lib/domain/config/index.js

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

package/src/lib/{core/default-skip-list.d.ts → domain/config/skip-list.contract.d.ts}

@@ -1,11 +1,8 @@
 export type SkipFn = (name: string) => boolean;
 export type SkipListEntry = string | RegExp | SkipFn;
 export type SkipList = SkipListEntry[];
-export declare const DEFAULT_SKIP_LIST: SkipList;
 export type PreparedSkipList = {
     strings: Set<string>;
     functions: SkipFn[];
     regexps: RegExp[];
 };
-export declare function prepareSkipList(skipList: SkipList): PreparedSkipList;
-export declare function isInSkipList(entry: string, skipList: PreparedSkipList): boolean;

package/src/lib/domain/config/skip-list.contract.js

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

package/src/lib/domain/config/with-native-federation.contract.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizedFederationConfig } from './federation-config.contract.js';
+export type WithNativeFederation = NormalizedFederationConfig;

package/src/lib/domain/config/with-native-federation.contract.js

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

package/src/lib/domain/core/build-adapter.contract.d.ts

@@ -0,0 +1,40 @@
+import type { PathToImport } from '../utils/mapped-path.contract.js';
+import type { FederationCache } from './federation-cache.contract.js';
+export interface NFBuildAdapterContext<TBundlerContext = unknown> {
+    ctx: TBundlerContext;
+    outdir: string;
+    dev: boolean;
+    name: string;
+    isMappingOrExposed: boolean;
+}
+export interface NFBuildAdapter {
+    setup(name: string, options: NFBuildAdapterOptions): Promise<void>;
+    build(name: string, opts?: {
+        modifiedFiles?: string[];
+        signal?: AbortSignal;
+    }): Promise<NFBuildAdapterResult[]>;
+    dispose(name?: string): Promise<void>;
+}
+export interface EntryPoint {
+    fileName: string;
+    outName: string;
+    key?: string;
+}
+export interface NFBuildAdapterOptions<TBundlerCache = unknown> {
+    entryPoints: EntryPoint[];
+    tsConfigPath?: string;
+    external: string[];
+    outdir: string;
+    mappedPaths: PathToImport;
+    isMappingOrExposed: boolean;
+    dev?: boolean;
+    watch?: boolean;
+    chunks?: boolean;
+    hash: boolean;
+    platform?: 'browser' | 'node';
+    optimizedMappings?: boolean;
+    cache: FederationCache<TBundlerCache>;
+}
+export interface NFBuildAdapterResult {
+    fileName: string;
+}

package/src/lib/domain/core/build-adapter.contract.js

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

package/src/lib/domain/core/build-notification-options.contract.d.ts

@@ -0,0 +1,9 @@
+export interface BuildNotificationOptions {
+    enable: boolean;
+    endpoint: string;
+}
+export declare enum BuildNotificationType {
+    COMPLETED = "federation-rebuild-complete",
+    ERROR = "federation-rebuild-error",
+    CANCELLED = "federation-rebuild-cancelled"
+}

package/src/lib/domain/core/build-notification-options.contract.js

@@ -0,0 +1,6 @@
+export var BuildNotificationType;
+(function (BuildNotificationType) {
+    BuildNotificationType["COMPLETED"] = "federation-rebuild-complete";
+    BuildNotificationType["ERROR"] = "federation-rebuild-error";
+    BuildNotificationType["CANCELLED"] = "federation-rebuild-cancelled";
+})(BuildNotificationType || (BuildNotificationType = {}));

package/src/lib/domain/core/chunk.d.ts

@@ -0,0 +1,2 @@
+export declare const CHUNK_PREFIX = "@nf-internal";
+export declare function toChunkImport(fileName: string): string;

package/src/lib/domain/core/chunk.js

@@ -0,0 +1,8 @@
+export const CHUNK_PREFIX = '@nf-internal';
+export function toChunkImport(fileName) {
+    if (fileName.startsWith('./')) {
+        fileName = fileName.slice(2);
+    }
+    const packageName = fileName.replace(/.(m|c)?js$/, '');
+    return CHUNK_PREFIX + '/' + packageName;
+}

package/src/lib/domain/core/federation-cache.contract.d.ts

@@ -0,0 +1,7 @@
+import type { ChunkInfo, SharedInfo } from './federation-info.contract.js';
+export type FederationCache<TBundlerCache = unknown> = {
+    externals: SharedInfo[];
+    chunks?: ChunkInfo;
+    bundlerCache: TBundlerCache;
+    cachePath: string;
+};

package/src/lib/domain/core/federation-cache.contract.js

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

package/src/lib/domain/core/federation-info.contract.d.ts

@@ -0,0 +1,33 @@
+export interface FederationInfo {
+    name: string;
+    exposes: ExposesInfo[];
+    shared: SharedInfo[];
+    chunks?: Record<string, string[]>;
+    buildNotificationsEndpoint?: string;
+}
+export type SharedInfo = {
+    singleton: boolean;
+    strictVersion: boolean;
+    requiredVersion: string;
+    version?: string;
+    packageName: string;
+    shareScope?: string;
+    bundle?: string;
+    outFileName: string;
+    dev?: {
+        entryPoint: string;
+    };
+};
+export type ChunkInfo = Record<string, string[]>;
+export interface ExposesInfo {
+    key: string;
+    outFileName: string;
+    dev?: {
+        entryPoint: string;
+    };
+}
+export interface ArtifactInfo {
+    mappings: SharedInfo[];
+    exposes: ExposesInfo[];
+    chunks?: ChunkInfo;
+}

package/src/lib/domain/core/federation-info.contract.js

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

package/src/lib/domain/core/federation-options.contract.d.ts

@@ -0,0 +1,21 @@
+import type { BuildNotificationOptions } from './build-notification-options.contract.js';
+import type { FederationCache } from './federation-cache.contract.js';
+export interface FederationOptions {
+    workspaceRoot: string;
+    outputPath: string;
+    federationConfig: string;
+    projectName?: string;
+    cacheExternalArtifacts?: boolean;
+    tsConfig?: string;
+    verbose?: boolean;
+    dev?: boolean;
+    watch?: boolean;
+    packageJson?: string;
+    entryPoints?: string[];
+    buildNotifications?: BuildNotificationOptions;
+}
+export interface NormalizedFederationOptions<TBundlerCache = unknown> extends FederationOptions {
+    federationCache: FederationCache<TBundlerCache>;
+    entryPoints: string[];
+    projectName: string;
+}

package/src/lib/domain/core/federation-options.contract.js

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

package/src/lib/domain/core/index.d.ts

@@ -0,0 +1,6 @@
+export type { SharedInfo, FederationInfo, ExposesInfo, ArtifactInfo, ChunkInfo, } from './federation-info.contract.js';
+export { type BuildNotificationOptions, BuildNotificationType, } from './build-notification-options.contract.js';
+export type { FederationOptions, NormalizedFederationOptions, } from './federation-options.contract.js';
+export type { EntryPoint, NFBuildAdapterOptions, NFBuildAdapter, NFBuildAdapterResult, NFBuildAdapterContext, } from './build-adapter.contract.js';
+export { CHUNK_PREFIX, toChunkImport } from './chunk.js';
+export type { FederationCache } from './federation-cache.contract.js';

package/src/lib/domain/core/index.js

@@ -0,0 +1,2 @@
+export { BuildNotificationType, } from './build-notification-options.contract.js';
+export { CHUNK_PREFIX, toChunkImport } from './chunk.js';

package/src/lib/domain/utils/index.d.ts

@@ -0,0 +1,2 @@
+export type { KeyValuePair } from './keyvaluepair.contract.js';
+export type { PathToImport } from './mapped-path.contract.js';

package/src/lib/domain/utils/index.js

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

package/src/lib/domain/utils/keyvaluepair.contract.d.ts

@@ -0,0 +1,4 @@
+export type KeyValuePair = {
+    key: string;
+    value: string;
+};

package/src/lib/domain/utils/keyvaluepair.contract.js

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

package/src/lib/domain/utils/mapped-path.contract.d.ts

@@ -0,0 +1 @@
+export type PathToImport = Record<string, string>;

package/src/lib/domain/utils/mapped-path.contract.js

@@ -0,0 +1,5 @@
+// export interface MappedPath {
+//   key: string;
+//   path: string;
+// }
+export {};

package/src/lib/domain/utils/used-dependencies.contract.d.ts

@@ -0,0 +1,5 @@
+import type { PathToImport } from './mapped-path.contract.js';
+export type UsedDependencies = {
+    external: Set<string>;
+    internal: PathToImport;
+};

package/src/lib/domain/utils/used-dependencies.contract.js

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

package/src/lib/utils/build-result-map.d.ts

@@ -1,3 +1,4 @@
-import { BuildResult } from '../core/build-adapter';
-export declare function createBuildResultMap(buildResult: BuildResult[], isHashed: boolean): Record<string, string>;
+import type { NFBuildAdapterResult } from '../domain/core/build-adapter.contract.js';
+export declare function createBuildResultMap(buildResult: NFBuildAdapterResult[], isHashed: boolean): Record<string, string>;
 export declare function lookupInResultMap(map: Record<string, string>, requestName: string): string;
+export declare function popFromResultMap(map: Record<string, string>, requestName: string): string;

package/src/lib/utils/build-result-map.js

@@ -1,13 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createBuildResultMap = createBuildResultMap;
-exports.lookupInResultMap = lookupInResultMap;
-const tslib_1 = require("tslib");
-const path_1 = tslib_1.__importDefault(require("path"));
-function createBuildResultMap(buildResult, isHashed) {
+import path from 'path';
+export function createBuildResultMap(buildResult, isHashed) {
     const map = {};
     for (const item of buildResult) {
-        const resultName = path_1.default.basename(item.fileName);
+        const resultName = path.basename(item.fileName);
         let requestName = resultName;
         if (isHashed) {
             const start = resultName.lastIndexOf('-');
@@ -16,12 +11,18 @@ function createBuildResultMap(buildResult, isHashed) {
             const part2 = resultName.substring(end);
             requestName = part1 + part2;
         }
-        map[requestName] = resultName;
+        map[requestName] = item.fileName;
     }
     return map;
 }
-function lookupInResultMap(map, requestName) {
-    const key = path_1.default.basename(requestName);
-    return map[key];
+export function lookupInResultMap(map, requestName) {
+    const key = path.basename(requestName);
+    // path.basename is to maintain backwards compatible
+    return path.basename(map[key]);
+}
+export function popFromResultMap(map, requestName) {
+    const key = path.basename(requestName);
+    const out = map[key];
+    delete map[key];
+    return out;
 }
-//# sourceMappingURL=build-result-map.js.map

package/src/lib/utils/{bundle-caching.d.ts → cache-persistence.d.ts}

@@ -1,17 +1,19 @@
-import { NormalizedSharedConfig } from '../config/federation-config';
-import { SharedInfo } from '@softarc/native-federation-runtime';
-export declare const getCachePath: (workspaceRoot: string, project: string) => string;
+import type { NormalizedExternalConfig } from '../domain/config/external-config.contract.js';
+import type { ChunkInfo, SharedInfo } from '../domain/core/federation-info.contract.js';
+export declare const getDefaultCachePath: (workspaceRoot: string) => string;
 export declare const getFilename: (title: string, dev?: boolean) => string;
-export declare const getChecksum: (shared: Record<string, NormalizedSharedConfig>, dev: "1" | "0") => string;
+export declare const getChecksum: (shared: Record<string, NormalizedExternalConfig>, dev: "1" | "0") => string;
 export declare const cacheEntry: (pathToCache: string, fileName: string) => {
     getMetadata: (checksum: string) => {
         checksum: string;
         externals: SharedInfo[];
+        chunks?: ChunkInfo;
         files: string[];
     } | undefined;
     persist: (payload: {
         checksum: string;
         externals: SharedInfo[];
+        chunks?: ChunkInfo;
         files: string[];
     }) => void;
     copyFiles: (fullOutputPath: string) => void;