@softarc/native-federation 4.0.0-RC1 → 4.0.0-RC10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softarc/native-federation",
-  "version": "4.0.0-RC1",
+  "version": "4.0.0-RC10",
   "type": "module",
   "license": "MIT",
   "dependencies": {
@@ -8,7 +8,7 @@
     "chalk": "^5.6.2",
     "fast-glob": "^3.3.3",
     "json5": "^2.2.3",
-    "esbuild": "^0.19.2"
+    "esbuild": "^0.28.0"
   },
   "exports": {
     "./package.json": "./package.json",

package/src/config.d.ts

@@ -2,4 +2,3 @@ export * from './lib/domain/config/index.js';
 export { withNativeFederation } from './lib/config/with-native-federation.js';
 export { findRootTsConfigJson, share, shareAll } from './lib/config/share-utils.js';
 export { DEFAULT_SKIP_LIST } from './lib/config/default-skip-list.js';
-//# sourceMappingURL=config.d.ts.map

package/src/domain.d.ts

@@ -1,3 +1,2 @@
 export * from './lib/domain/config/index.js';
 export * from './lib/domain/core/index.js';
-//# sourceMappingURL=domain.d.ts.map

package/src/index.d.ts

@@ -1,9 +1,10 @@
 export { setBuildAdapter } from './lib/core/build-adapter.js';
 export { buildForFederation } from './lib/core/build-for-federation.js';
+export { rebuildForFederation } from './lib/core/rebuild-for-federation.js';
+export { createFederationCache } from './lib/core/federation-cache.js';
 export { bundleExposedAndMappings } from './lib/core/bundle-exposed-and-mappings.js';
 export { getExternals } from './lib/core/get-externals.js';
-export { loadFederationConfig } from './lib/core/load-federation-config.js';
+export { normalizeFederationOptions } from './lib/core/normalize-options.js';
 export { writeFederationInfo } from './lib/core/write-federation-info.js';
 export { type BuildHelperParams, federationBuilder } from './lib/core/federation-builder.js';
 export * from './domain.js';
-//# sourceMappingURL=index.d.ts.map

package/src/index.js

@@ -1,8 +1,10 @@
 export { setBuildAdapter } from './lib/core/build-adapter.js';
 export { buildForFederation } from './lib/core/build-for-federation.js';
+export { rebuildForFederation } from './lib/core/rebuild-for-federation.js';
+export { createFederationCache } from './lib/core/federation-cache.js';
 export { bundleExposedAndMappings } from './lib/core/bundle-exposed-and-mappings.js';
 export { getExternals } from './lib/core/get-externals.js';
-export { loadFederationConfig } from './lib/core/load-federation-config.js';
+export { normalizeFederationOptions } from './lib/core/normalize-options.js';
 export { writeFederationInfo } from './lib/core/write-federation-info.js';
 export { federationBuilder } from './lib/core/federation-builder.js';
 export * from './domain.js';

package/src/internal.d.ts

@@ -2,11 +2,12 @@ export * from './lib/utils/build-result-map.js';
 export { hashFile } from './lib/utils/hash-file.js';
 export * from './lib/utils/errors.js';
 export { logger, setLogLevel } from './lib/utils/logger.js';
-export type { MappedPath } from './lib/domain/utils/mapped-path.contract.js';
-export { RebuildQueue } from './lib/utils/rebuild-queue.js';
+export type { PathToImport } from './lib/domain/utils/mapped-path.contract.js';
+export { RebuildQueue, type TrackResult } from './lib/utils/rebuild-queue.js';
 export { AbortedError } from './lib/utils/errors.js';
-export { createBuildResultMap, lookupInResultMap } from './lib/utils/build-result-map.js';
+export { createBuildResultMap, lookupInResultMap, popFromResultMap, } from './lib/utils/build-result-map.js';
 export { writeImportMap } from './lib/core/write-import-map.js';
 export type { NormalizedExternalConfig, NormalizedSharedExternalsConfig, } from './lib/domain/config/external-config.contract.js';
 export type { NormalizedFederationConfig } from './lib/domain/config/federation-config.contract.js';
-//# sourceMappingURL=internal.d.ts.map
+export { getDefaultCachePath, getChecksum } from './lib/utils/cache-persistence.js';
+export { isInSkipList, prepareSkipList } from './lib/config/default-skip-list.js';

package/src/internal.js

@@ -4,5 +4,7 @@ export * from './lib/utils/errors.js';
 export { logger, setLogLevel } from './lib/utils/logger.js';
 export { RebuildQueue } from './lib/utils/rebuild-queue.js';
 export { AbortedError } from './lib/utils/errors.js';
-export { createBuildResultMap, lookupInResultMap } from './lib/utils/build-result-map.js';
+export { createBuildResultMap, lookupInResultMap, popFromResultMap, } from './lib/utils/build-result-map.js';
 export { writeImportMap } from './lib/core/write-import-map.js';
+export { getDefaultCachePath, getChecksum } from './lib/utils/cache-persistence.js';
+export { isInSkipList, prepareSkipList } from './lib/config/default-skip-list.js';

package/src/lib/config/configuration-context.d.ts

@@ -5,4 +5,3 @@ export interface ConfigurationContext {
 export declare function useWorkspace(workspaceRoot: string): void;
 export declare function usePackageJson(packageJson?: string): void;
 export declare function getConfigContext(): ConfigurationContext;
-//# sourceMappingURL=configuration-context.d.ts.map

package/src/lib/config/default-skip-list.d.ts

@@ -2,4 +2,3 @@ import type { PreparedSkipList, SkipList } from '../domain/config/skip-list.cont
 export declare const DEFAULT_SKIP_LIST: SkipList;
 export declare function prepareSkipList(skipList: SkipList): PreparedSkipList;
 export declare function isInSkipList(entry: string, skipList: PreparedSkipList): boolean;
-//# sourceMappingURL=default-skip-list.d.ts.map

package/src/lib/config/default-skip-list.js

@@ -1,26 +1,14 @@
 export const DEFAULT_SKIP_LIST = [
-    '@softarc/native-federation-runtime',
     '@softarc/native-federation',
     '@softarc/native-federation-core',
     '@softarc/native-federation-node',
     '@softarc/native-federation-esbuild',
-    '@angular-architects/native-federation',
-    '@angular-architects/native-federation-runtime',
+    '@softarc/native-federation-runtime',
+    '@softarc/native-federation-orchestrator',
+    'vanilla-native-federation',
     'es-module-shims',
-    'zone.js',
     'tslib/',
-    '@angular/localize',
-    '@angular/localize/init',
-    '@angular/localize/tools',
-    // '@angular/platform-server',
-    // '@angular/platform-server/init',
-    // '@angular/ssr',
-    /\/schematics(\/|$)/,
-    /^@nx\/angular/,
-    pkg => pkg.startsWith('@angular/') && !!pkg.match(/\/testing(\/|$)/),
     pkg => pkg.startsWith('@types/'),
-    'express',
-    // (pkg) => pkg.startsWith('@angular/common/locales'),
 ];
 export function prepareSkipList(skipList) {
     return {

package/src/lib/config/remove-unused-deps.d.ts

@@ -0,0 +1,3 @@
+import type { NormalizedFederationConfig } from '../domain/config/federation-config.contract.js';
+import type { UsedDependencies } from '../domain/utils/used-dependencies.contract.js';
+export declare function removeUnusedDeps(usedDependencies: UsedDependencies, config: NormalizedFederationConfig): NormalizedFederationConfig;

package/src/lib/config/remove-unused-deps.js

@@ -0,0 +1,10 @@
+export function removeUnusedDeps(usedDependencies, config) {
+    const filteredDependencies = Object.entries(config.shared)
+        .filter(([shared, meta]) => !!meta.includeSecondaries || usedDependencies.external.has(shared))
+        .reduce((acc, [shared, meta]) => ({ ...acc, [shared]: meta }), {});
+    return {
+        ...config,
+        shared: filteredDependencies,
+        sharedMappings: usedDependencies.internal,
+    };
+}

package/src/lib/config/share-utils.d.ts

@@ -1,6 +1,5 @@
 import { type SkipList } from '../domain/config/skip-list.contract.js';
 import type { ShareAllExternalsOptions, ShareExternalsOptions } from '../domain/config/external-config.contract.js';
-export declare const DEFAULT_SECONDARIES_SKIP_LIST: string[];
 export declare function findRootTsConfigJson(): string;
 export declare function shareAll(config: ShareAllExternalsOptions, opts?: {
     skipList?: SkipList;
@@ -9,4 +8,3 @@ export declare function shareAll(config: ShareAllExternalsOptions, opts?: {
 }): ShareExternalsOptions | null;
 export declare function setInferVersion(infer: boolean): void;
 export declare function share(configuredShareObjects: ShareExternalsOptions, projectPath?: string, skipList?: SkipList): ShareExternalsOptions;
-//# sourceMappingURL=share-utils.d.ts.map

package/src/lib/config/share-utils.js

@@ -5,9 +5,8 @@ import { DEFAULT_SKIP_LIST, isInSkipList, prepareSkipList } from './default-skip
 import { findDepPackageJson, getVersionMaps } from '../utils/package-info.js';
 import { getConfigContext } from './configuration-context.js';
 import { logger } from '../utils/logger.js';
-import { resolveWildcardKeys } from '../utils/resolve-wildcard-keys.js';
+import { resolvePackageJsonExportsWildcard } from '../utils/resolve-wildcard-keys.js';
 let inferVersion = false;
-export const DEFAULT_SECONDARIES_SKIP_LIST = ['@angular/router/upgrade', '@angular/common/upgrade'];
 export function findRootTsConfigJson() {
     const packageJson = findPackageJson(cwd());
     const projectRoot = path.dirname(packageJson);
@@ -49,9 +48,6 @@ function lookupVersionInMap(key, versions) {
     else {
         key = parts[0];
     }
-    if (key.toLowerCase() === '@angular-architects/module-federation-runtime') {
-        key = '@angular-architects/module-federation';
-    }
     if (!versions[key]) {
         return null;
     }
@@ -82,7 +78,7 @@ function findSecondaries(libPath, excludes, shareObject, preparedSkipList) {
     return acc;
 }
 function getSecondaries(includeSecondaries, libPath, key, shareObject, preparedSkipList) {
-    let exclude = [...DEFAULT_SECONDARIES_SKIP_LIST];
+    let exclude = [];
     let resolveGlob = false;
     if (typeof includeSecondaries === 'object') {
         if (Array.isArray(includeSecondaries.skip)) {
@@ -166,7 +162,7 @@ function resolveGlobSecondaries(key, libPath, parent, secondaryName, entry, excl
     if (key.includes('*')) {
         if (!resolveGlob)
             return items;
-        const expanded = resolveWildcardKeys(key, entry, libPath);
+        const expanded = resolvePackageJsonExportsWildcard(key, entry, libPath);
         items = expanded
             .map(e => ({
             key: path.join(parent, e.key),
@@ -221,10 +217,10 @@ export function shareAll(config, opts = {}) {
     // }
     const versionMaps = getVersionMaps(projectPath, projectPath);
     const sharedExternals = {};
-    const preparedSkipList = prepareSkipList(opts.skipList ?? DEFAULT_SKIP_LIST);
+    const skipList = opts.skipList ?? DEFAULT_SKIP_LIST;
     for (const versions of versionMaps) {
         for (const key in versions) {
-            if (isInSkipList(key, preparedSkipList)) {
+            if (isInSkipList(key, prepareSkipList(skipList))) {
                 continue;
             }
             if (!!opts.overrides && Object.keys(opts.overrides).some(o => key.startsWith(o))) {
@@ -238,10 +234,8 @@ export function shareAll(config, opts = {}) {
         }
     }
     return {
-        ...share(sharedExternals, opts.projectPath, opts.skipList ?? DEFAULT_SKIP_LIST),
-        ...(!opts.overrides
-            ? {}
-            : share(opts.overrides, opts.projectPath, opts.skipList ?? DEFAULT_SKIP_LIST)),
+        ...share(sharedExternals, opts.projectPath, skipList),
+        ...(!opts.overrides ? {} : share(opts.overrides, opts.projectPath, skipList)),
     };
 }
 function inferProjectPath(projectPath) {

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

@@ -1,3 +1,2 @@
 import type { FederationConfig, NormalizedFederationConfig } from '../domain/config/federation-config.contract.js';
 export declare function withNativeFederation(config: FederationConfig): NormalizedFederationConfig;
-//# sourceMappingURL=with-native-federation.d.ts.map

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

@@ -1,88 +1,70 @@
-import { getMappedPaths } from '../utils/mapped-paths.js';
+import { getRawMappedPaths } from '../utils/mapped-paths.js';
 import { shareAll, findRootTsConfigJson } from './share-utils.js';
 import { isInSkipList, prepareSkipList } from './default-skip-list.js';
 import { logger } from '../utils/logger.js';
-import { DEFAULT_SERVER_DEPS_LIST } from '../core/default-server-deps-list.js';
 export function withNativeFederation(config) {
     const skip = prepareSkipList(config.skip ?? []);
+    const chunks = config.chunks ?? true;
     const normalized = {
+        $type: 'classic',
         name: config.name ?? '',
         exposes: config.exposes ?? {},
-        shared: normalizeShared(config, skip),
-        sharedMappings: normalizeSharedMappings(config, skip),
+        shared: normalizeShared(config, skip, chunks),
+        sharedMappings: removeSkippedMappings(config, skip),
+        chunks,
         skip,
         externals: config.externals ?? [],
         features: {
             mappingVersion: config.features?.mappingVersion ?? false,
-            ignoreUnusedDeps: config.features?.ignoreUnusedDeps ?? false,
+            ignoreUnusedDeps: config.features?.ignoreUnusedDeps ?? true,
+            denseChunking: config.features?.denseChunking ?? false,
         },
+        ...(config.shareScope && { shareScope: config.shareScope }),
     };
-    // This is for being backwards compatible
-    if (!normalized.features.ignoreUnusedDeps) {
-        normalized.shared = filterShared(normalized.shared);
-    }
     return normalized;
 }
-function filterShared(shared) {
-    const keys = Object.keys(shared).filter(k => !k.startsWith('@angular/common/locales'));
-    const filtered = keys.reduce((acc, curr) => ({
-        ...acc,
-        [curr]: shared[curr],
-    }), {});
-    return filtered;
-}
-function normalizeShared(config, skip) {
+function normalizeShared(config, skip, chunks) {
     let result = {};
-    const shared = config.shared;
-    if (!shared) {
-        result = shareAll({
+    const shared = config.shared ??
+        shareAll({
             singleton: true,
             strictVersion: true,
             requiredVersion: 'auto',
             platform: 'browser',
         });
-    }
-    else {
-        result = Object.keys(shared).reduce((acc, cur) => ({
+    result = Object.keys(shared).reduce((acc, cur) => {
+        const key = cur.replace(/\\/g, '/');
+        const sharedConfig = shared[cur];
+        if (!!sharedConfig.chunks && !sharedConfig.build && sharedConfig.chunks !== chunks) {
+            logger.warn(`External '${cur}' has explicit chunk settings, consider switching build type to { build: 'package' }.`);
+            sharedConfig.chunks = chunks;
+        }
+        const normalizedConfig = {
+            requiredVersion: sharedConfig.requiredVersion ?? 'auto',
+            singleton: sharedConfig.singleton ?? false,
+            strictVersion: sharedConfig.strictVersion ?? false,
+            version: sharedConfig.version,
+            chunks: sharedConfig.chunks ?? chunks,
+            includeSecondaries: sharedConfig.includeSecondaries,
+            packageInfo: sharedConfig.packageInfo,
+            platform: sharedConfig.platform ?? config.platform ?? 'browser',
+            build: sharedConfig.build ?? 'default',
+            ...(sharedConfig.shareScope && { shareScope: sharedConfig.shareScope }),
+        };
+        return {
             ...acc,
-            [cur.replace(/\\/g, '/')]: {
-                requiredVersion: shared[cur].requiredVersion ?? 'auto',
-                singleton: shared[cur].singleton ?? false,
-                strictVersion: shared[cur].strictVersion ?? false,
-                version: shared[cur].version,
-                includeSecondaries: shared[cur].includeSecondaries,
-                packageInfo: shared[cur].packageInfo,
-                platform: shared[cur].platform ?? getDefaultPlatform(cur),
-                build: shared[cur].build ?? 'default',
-            },
-        }), {});
-        //result = share(result) as Record<string, NormalizedSharedConfig>;
-    }
+            [key]: normalizedConfig,
+        };
+    }, {});
     result = Object.keys(result)
         .filter(key => !isInSkipList(key, skip))
-        .reduce((acc, cur) => ({
-        ...acc,
-        [cur]: result[cur],
-    }), {});
+        .reduce((acc, cur) => ({ ...acc, [cur]: result[cur] }), {});
     return result;
 }
-function normalizeSharedMappings(config, skip) {
+function removeSkippedMappings(config, skipList) {
     const rootTsConfigPath = findRootTsConfigJson();
-    const paths = getMappedPaths({
-        rootTsConfigPath,
-        sharedMappings: config.sharedMappings,
-    });
-    const result = paths.filter(p => !isInSkipList(p.key, skip) && !p.key.includes('*'));
-    if (paths.find(p => p.key.includes('*'))) {
-        logger.warn('Sharing mapped paths with wildcards (*) not supported');
-    }
-    return result;
-}
-function getDefaultPlatform(cur) {
-    if (DEFAULT_SERVER_DEPS_LIST.find(e => cur.startsWith(e))) {
-        return 'node';
-    }
-    else {
-        return 'browser';
-    }
+    const paths = getRawMappedPaths(rootTsConfigPath, config.sharedMappings);
+    return Object.entries(paths)
+        .filter(([, _import]) => !isInSkipList(_import, skipList))
+        .reduce((acc, [_path, _import]) => ({ ...acc, [_path]: _import }), {});
 }

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

@@ -1,4 +1,3 @@
 import type { NFBuildAdapter } from '../domain/core/build-adapter.contract.js';
 export declare function setBuildAdapter(buildAdapter: NFBuildAdapter): void;
 export declare function getBuildAdapter(): NFBuildAdapter;
-//# sourceMappingURL=build-adapter.d.ts.map

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

@@ -1,12 +1,12 @@
 import { logger } from '../utils/logger.js';
-let _buildAdapter = async () => {
-    // TODO: add logger
-    logger.error('NF is missing a build adapter!');
-    return [];
-};
+let _buildAdapter = null;
 export function setBuildAdapter(buildAdapter) {
     _buildAdapter = buildAdapter;
 }
 export function getBuildAdapter() {
+    if (!_buildAdapter) {
+        logger.error('Please set a BuildAdapter!');
+        throw new Error('BuildAdapter not set');
+    }
     return _buildAdapter;
 }

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

@@ -1,7 +1,4 @@
 import type { FederationInfo } from '../domain/core/federation-info.contract.js';
-import type { FederationOptions } from '../domain/core/federation-options.contract.js';
+import type { NormalizedFederationOptions } from '../domain/core/federation-options.contract.js';
 import type { NormalizedFederationConfig } from '../domain/config/federation-config.contract.js';
-import type { BuildParams } from '../domain/core/build-params.contract.js';
-export declare const defaultBuildParams: BuildParams;
-export declare function buildForFederation(config: NormalizedFederationConfig, fedOptions: FederationOptions, externals: string[], buildParams?: BuildParams): Promise<FederationInfo>;
-//# sourceMappingURL=build-for-federation.d.ts.map
+export declare function buildForFederation(config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions, externals: string[], signal?: AbortSignal): Promise<FederationInfo>;

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

@@ -3,88 +3,92 @@ import { bundleShared } from './bundle-shared.js';
 import { writeFederationInfo } from './write-federation-info.js';
 import { writeImportMap } from './write-import-map.js';
 import { logger } from '../utils/logger.js';
-import { getCachePath } from './../utils/bundle-caching.js';
 import { normalizePackageName } from '../utils/normalize.js';
 import { AbortedError } from '../utils/errors.js';
-export const defaultBuildParams = {
-    skipMappingsAndExposed: false,
-    skipShared: false,
-};
-const sharedPackageInfoCache = [];
-export async function buildForFederation(config, fedOptions, externals, buildParams = defaultBuildParams) {
-    const signal = buildParams.signal;
-    let artefactInfo;
-    if (!buildParams.skipMappingsAndExposed) {
-        const start = process.hrtime();
-        artefactInfo = await bundleExposedAndMappings(config, fedOptions, externals, signal);
-        logger.measure(start, '[build artifacts] - To bundle all mappings and exposed.');
-        if (signal?.aborted)
-            throw new AbortedError('[buildForFederation] After exposed-and-mappings bundle');
-    }
-    const exposedInfo = !artefactInfo ? describeExposed(config, fedOptions) : artefactInfo.exposes;
-    const normalizedCacheFolder = normalizePackageName(config.name);
-    if (normalizedCacheFolder.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).");
-    }
-    const cacheProjectFolder = normalizedCacheFolder.length < 1 ? 'shell' : normalizedCacheFolder;
-    const pathToCache = getCachePath(fedOptions.workspaceRoot, cacheProjectFolder);
-    if (!buildParams.skipShared && sharedPackageInfoCache.length > 0) {
+import { addExternalsToCache } from './federation-cache.js';
+import path from 'path';
+export async function buildForFederation(config, fedOptions, externals, signal) {
+    // 1. Setup
+    fedOptions.federationCache.cachePath = path.join(fedOptions.federationCache.cachePath, fedOptions.projectName);
+    logger.info('Building federation artifacts');
+    logger.notice("Skip packages you don't want to share in your federation config");
+    // 2. Externals
+    if (fedOptions.federationCache.externals.length > 0) {
         logger.info('Checksum matched, re-using cached externals.');
     }
-    if (!buildParams.skipShared && sharedPackageInfoCache.length === 0) {
+    if (fedOptions.federationCache.externals.length === 0) {
         const { sharedBrowser, sharedServer, separateBrowser, separateServer } = splitShared(config.shared);
         if (Object.keys(sharedBrowser).length > 0) {
-            notifyBundling('browser-shared');
+            logger.info(`Bundling external npm packages with bundle type 'browser-shared'`);
             const start = process.hrtime();
-            const sharedPackageInfoBrowser = await bundleShared(sharedBrowser, config, fedOptions, externals, 'browser', { pathToCache, bundleName: 'browser-shared' });
-            logger.measure(start, '[build artifacts] - To bundle all shared browser externals');
-            sharedPackageInfoCache.push(...sharedPackageInfoBrowser);
+            const sharedPackageInfoBrowser = await bundleShared(sharedBrowser, config, fedOptions, externals, { platform: 'browser', bundleName: 'browser-shared', chunks: config.chunks });
+            logger.measure(start, 'Step 2.1) Bundling all shared browser externals');
+            addExternalsToCache(fedOptions.federationCache, sharedPackageInfoBrowser);
             if (signal?.aborted)
                 throw new AbortedError('[buildForFederation] After shared-browser bundle');
         }
         if (Object.keys(sharedServer).length > 0) {
-            notifyBundling('browser-shared');
+            logger.info(`Bundling external npm packages with bundle type 'server-shared'`);
             const start = process.hrtime();
-            const sharedPackageInfoServer = await bundleShared(sharedServer, config, fedOptions, externals, 'node', { pathToCache, bundleName: 'node-shared' });
-            logger.measure(start, '[build artifacts] - To bundle all shared node externals');
-            sharedPackageInfoCache.push(...sharedPackageInfoServer);
+            const sharedPackageInfoServer = await bundleShared(sharedServer, config, fedOptions, externals, { platform: 'node', bundleName: 'node-shared', chunks: config.chunks });
+            logger.measure(start, 'Step 2.1) Bundling all shared node externals');
+            addExternalsToCache(fedOptions.federationCache, sharedPackageInfoServer);
             if (signal?.aborted)
                 throw new AbortedError('[buildForFederation] After shared-node bundle');
         }
         if (Object.keys(separateBrowser).length > 0) {
-            notifyBundling('browser-shared');
+            logger.info(`Bundling external npm packages with bundle type 'browser-separate'`);
             const start = process.hrtime();
-            const separatePackageInfoBrowser = await bundleSeparatePackages(separateBrowser, externals, config, fedOptions, 'browser', pathToCache);
-            logger.measure(start, '[build artifacts] - To bundle all separate browser externals');
-            sharedPackageInfoCache.push(...separatePackageInfoBrowser);
+            const separatePackageInfoBrowser = await bundleSeparatePackages(separateBrowser, externals, config, fedOptions, { platform: 'browser' });
+            logger.measure(start, 'Step 2.2) Bundling all separate browser external packages');
+            addExternalsToCache(fedOptions.federationCache, separatePackageInfoBrowser);
             if (signal?.aborted)
                 throw new AbortedError('[buildForFederation] After separate-browser bundle');
         }
         if (Object.keys(separateServer).length > 0) {
-            notifyBundling('browser-shared');
+            logger.info(`Bundling external npm packages with bundle type 'node-separate'`);
             const start = process.hrtime();
-            const separatePackageInfoServer = await bundleSeparatePackages(separateServer, externals, config, fedOptions, 'node', pathToCache);
-            logger.measure(start, '[build artifacts] - To bundle all separate node externals');
-            sharedPackageInfoCache.push(...separatePackageInfoServer);
+            const separatePackageInfoServer = await bundleSeparatePackages(separateServer, externals, config, fedOptions, { platform: 'node' });
+            logger.measure(start, 'Step 2.2) Bundling all separate node external packages');
+            addExternalsToCache(fedOptions.federationCache, separatePackageInfoServer);
         }
         if (signal?.aborted)
             throw new AbortedError('[buildForFederation] After separate-node bundle');
     }
-    const sharedMappingInfo = !artefactInfo
+    // 2. Shared mappings and exposed modules
+    const start = process.hrtime();
+    const artifactInfo = await bundleExposedAndMappings(config, fedOptions, externals, undefined, signal);
+    logger.measure(start, 'Step 3) Bundling 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)
-        : artefactInfo.mappings;
-    const sharedInfo = [...sharedPackageInfoCache, ...sharedMappingInfo];
+        : artifactInfo.mappings;
+    const sharedExternals = [...fedOptions.federationCache.externals, ...sharedMappingInfo];
+    if (config?.shareScope) {
+        Object.values(sharedExternals).forEach(external => {
+            if (!external.shareScope)
+                external.shareScope = config.shareScope;
+        });
+    }
     const buildNotificationsEndpoint = fedOptions.buildNotifications?.enable && fedOptions.dev
         ? fedOptions.buildNotifications?.endpoint
         : undefined;
     const federationInfo = {
         name: config.name,
-        shared: sharedInfo,
+        shared: sharedExternals,
         exposes: exposedInfo,
         buildNotificationsEndpoint,
     };
+    if (fedOptions.federationCache.chunks) {
+        federationInfo.chunks = fedOptions.federationCache.chunks;
+    }
+    if (artifactInfo?.chunks) {
+        federationInfo.chunks = { ...(federationInfo.chunks ?? {}), ...artifactInfo?.chunks };
+    }
     writeFederationInfo(federationInfo, fedOptions);
-    writeImportMap(sharedInfo, fedOptions);
+    writeImportMap(fedOptions.federationCache, fedOptions);
     return federationInfo;
 }
 function inferPackageFromSecondary(secondary) {
@@ -94,28 +98,33 @@ function inferPackageFromSecondary(secondary) {
     }
     return parts[0];
 }
-async function bundleSeparatePackages(separateBrowser, externals, config, fedOptions, platform, pathToCache) {
+async function bundleSeparatePackages(separateBrowser, externals, config, fedOptions, buildOptions) {
     const groupedByPackage = {};
     for (const [key, shared] of Object.entries(separateBrowser)) {
         const packageName = shared.build === 'separate' ? key : inferPackageFromSecondary(key);
         if (!groupedByPackage[packageName]) {
-            groupedByPackage[packageName] = {};
+            groupedByPackage[packageName] = {
+                chunks: shared.chunks,
+                entries: {},
+            };
         }
-        groupedByPackage[packageName][key] = shared;
+        groupedByPackage[packageName].entries[key] = shared;
     }
-    const bundlePromises = Object.entries(groupedByPackage).map(async ([packageName, sharedGroup]) => {
-        return bundleShared(sharedGroup, config, fedOptions, externals.filter(e => !e.startsWith(packageName)), platform, {
-            pathToCache,
-            bundleName: `${platform}-${normalizePackageName(packageName)}`,
+    const bundlePromises = Object.entries(groupedByPackage).map(async ([packageName, packageConfig]) => {
+        return bundleShared(packageConfig.entries, config, fedOptions, externals.filter(e => !e.startsWith(packageName)), {
+            platform: buildOptions.platform,
+            chunks: packageConfig.chunks,
+            bundleName: `${buildOptions.platform}-${normalizePackageName(packageName)}`,
         });
     });
     const buildResults = await Promise.all(bundlePromises);
-    return buildResults.flat();
-}
-function notifyBundling(platform) {
-    logger.info('Preparing shared npm packages for the platform ' + platform);
-    logger.notice('This only needs to be done once, as results are cached');
-    logger.notice("Skip packages you don't want to share in your federation config");
+    return buildResults.reduce((acc, r) => {
+        let chunks = acc.chunks;
+        if (r.chunks) {
+            chunks = { ...(acc.chunks ?? {}), ...r.chunks };
+        }
+        return { externals: [...acc.externals, ...r.externals], chunks };
+    }, { externals: [] });
 }
 function splitShared(shared) {
     const sharedServer = {};

package/src/lib/core/bundle-exposed-and-mappings.d.ts

@@ -1,7 +1,6 @@
-import type { ArtefactInfo, ExposesInfo, SharedInfo } from '../domain/core/federation-info.contract.js';
+import type { ArtifactInfo, ExposesInfo, SharedInfo } from '../domain/core/federation-info.contract.js';
 import type { NormalizedFederationConfig } from '../domain/config/federation-config.contract.js';
-import { type FederationOptions } from '../domain/core/federation-options.contract.js';
-export declare function bundleExposedAndMappings(config: NormalizedFederationConfig, fedOptions: FederationOptions, externals: string[], signal?: AbortSignal): Promise<ArtefactInfo>;
-export declare function describeExposed(config: NormalizedFederationConfig, options: FederationOptions): Array<ExposesInfo>;
-export declare function describeSharedMappings(config: NormalizedFederationConfig, fedOptions: FederationOptions): Array<SharedInfo>;
-//# sourceMappingURL=bundle-exposed-and-mappings.d.ts.map
+import { type NormalizedFederationOptions } from '../domain/core/federation-options.contract.js';
+export declare function bundleExposedAndMappings(config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions, externals: string[], modifiedFiles?: string[], signal?: AbortSignal): Promise<ArtifactInfo>;
+export declare function describeExposed(config: NormalizedFederationConfig, options: NormalizedFederationOptions): Array<ExposesInfo>;
+export declare function describeSharedMappings(config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions): Array<SharedInfo>;