@module-federation/metro 2.4.0 → 2.5.0

package/dist/modules/asyncRequire.ts

@@ -70,19 +70,44 @@ function buildLoadBundleAsyncWrapper() {
   const loadBundleAsync =
     __loadBundleAsync as typeof globalThis.__loadBundleAsync;
 
-  return async (originalBundlePath: string) => {
+  return async (originalBundlePath: string): Promise<void> => {
     const scope = globalThis.__FEDERATION__.__NATIVE__[__METRO_GLOBAL_PREFIX__];
 
     // entry is always in the root directory of assets associated with remote
     // based on that, we extract the public path from the origin URL
     // e.g. http://example.com/a/b/c/mf-manfiest.json -> http://example.com/a/b/c
     const publicPath = getPublicPath(scope.origin);
-    const bundlePath = getBundlePath(originalBundlePath, publicPath);
+    let bundlePath = getBundlePath(originalBundlePath, publicPath);
+
+    const isSplitBundle = !isUrl(originalBundlePath);
+
+    // Cache handler registered externally (e.g. by zephyr-native-cache register()).
+    // Stored under __FEDERATION__.__NATIVE__.__CACHE__ as a singleton (no prefix scope).
+    const cacheHandler = (globalThis as any).__FEDERATION__?.__NATIVE__
+      ?.__CACHE__ as
+      | ((
+          fallback: (path: string) => Promise<void>,
+          bundlePath: string,
+        ) => Promise<void>)
+      | undefined;
+
+    // For remote split bundles with cache enabled, convert relative paths to
+    // full URLs so they enter the same cache path as container bundles.
+    // In dev mode, getBundlePath returns relative paths unchanged, but we need
+    // full URLs for the cache layer (download + eval).
+    if (isSplitBundle && cacheHandler && publicPath && !isUrl(bundlePath)) {
+      bundlePath = joinComponents(publicPath, bundlePath);
+    }
 
     // ../../node_modules/ -> ..%2F..%2Fnode_modules/ so that it's not automatically sanitized
     const encodedBundlePath = bundlePath.replaceAll('../', '..%2F');
 
-    const result = await loadBundleAsync(encodedBundlePath);
+    let result;
+    if (cacheHandler) {
+      await cacheHandler(loadBundleAsync, encodedBundlePath);
+    } else {
+      result = await loadBundleAsync(encodedBundlePath);
+    }
 
     // when the origin is not the same, it means we are loading a remote container
     // we can return early since dependencies are processed differently for entry bundles

package/dist/modules/asyncStartup.tsx

@@ -2,7 +2,6 @@ import type { Federation } from '@module-federation/runtime';
 import React from 'react';
 
 declare global {
-  // @ts-expect-error -- Intentional redeclaration for Metro/React Native runtime global.
   // eslint-disable-next-line no-var
   var __DEV__: boolean;
   // eslint-disable-next-line no-var

package/dist/modules/metroCorePlugin.ts

@@ -4,7 +4,6 @@ import type {
 } from '@module-federation/runtime';
 
 declare global {
-  // @ts-expect-error -- Intentional redeclaration for Metro/React Native runtime global.
   // eslint-disable-next-line no-var
   var __DEV__: boolean;
   // eslint-disable-next-line no-var

package/dist/plugin/generators.js

@@ -97,12 +97,12 @@ function generateRemotes(remotes = {}) {
         const remoteEntryParts = remoteEntry.split('@');
         const remoteName = remoteEntryParts[0];
         const remoteEntryUrl = remoteEntryParts.slice(1).join('@');
-        remotesEntries.push(`{ 
-          alias: "${remoteAlias}", 
-          name: "${remoteName}", 
-          entry: "${remoteEntryUrl}", 
-          entryGlobalName: "${remoteName}", 
-          type: "var" 
+        remotesEntries.push(`{
+          alias: ${JSON.stringify(remoteAlias)},
+          name: ${JSON.stringify(remoteName)},
+          entry: ${JSON.stringify(remoteEntryUrl)},
+          entryGlobalName: ${JSON.stringify(remoteName)},
+          type: "var"
        }`);
     }
     return `[${remotesEntries.join(',\n')}]`;

package/dist/plugin/generators.mjs

@@ -55,12 +55,12 @@ function generateRemotes(remotes = {}) {
         const remoteEntryParts = remoteEntry.split('@');
         const remoteName = remoteEntryParts[0];
         const remoteEntryUrl = remoteEntryParts.slice(1).join('@');
-        remotesEntries.push(`{ 
-          alias: "${remoteAlias}", 
-          name: "${remoteName}", 
-          entry: "${remoteEntryUrl}", 
-          entryGlobalName: "${remoteName}", 
-          type: "var" 
+        remotesEntries.push(`{
+          alias: ${JSON.stringify(remoteAlias)},
+          name: ${JSON.stringify(remoteName)},
+          entry: ${JSON.stringify(remoteEntryUrl)},
+          entryGlobalName: ${JSON.stringify(remoteName)},
+          type: "var"
        }`);
     }
     return `[${remotesEntries.join(',\n')}]`;

package/dist/plugin/index.js

@@ -45,6 +45,7 @@ const federated_remote_types_js_namespaceObject = require("../utils/federated-re
 const external_babel_transformer_js_namespaceObject = require("./babel-transformer.js");
 const external_helpers_js_namespaceObject = require("./helpers.js");
 const external_manifest_js_namespaceObject = require("./manifest.js");
+const external_manifest_middleware_js_namespaceObject = require("./manifest-middleware.js");
 const external_normalize_extra_options_js_namespaceObject = require("./normalize-extra-options.js");
 const external_normalize_options_js_namespaceObject = require("./normalize-options.js");
 const external_resolver_js_namespaceObject = require("./resolver.js");
@@ -87,7 +88,12 @@ function augmentConfig(config, federationOptions, extraOptions) {
         enableInitializeCorePatching: flags.unstable_patchInitializeCore,
         enableRuntimeRequirePatching: flags.unstable_patchRuntimeRequire
     });
-    const manifestPath = (0, external_manifest_js_namespaceObject.createManifest)(options, tmpDirPath);
+    const manifestOptions = {
+        projectRoot: config.projectRoot,
+        target: (0, external_helpers_js_namespaceObject.isUsingMFBundleCommand)() ? 'build' : 'development',
+        tmpDirPath
+    };
+    const manifestPath = (0, external_manifest_js_namespaceObject.createManifest)(options, tmpDirPath, manifestOptions);
     (0, external_helpers_js_namespaceObject.stubHostEntry)(hostEntryPath);
     (0, external_helpers_js_namespaceObject.stubRemoteEntry)(remoteEntryPath);
     global.__METRO_FEDERATION_CONFIG = options;
@@ -106,7 +112,7 @@ function augmentConfig(config, federationOptions, extraOptions) {
         ...config,
         serializer: {
             ...config.serializer,
-            customSerializer: (0, external_serializer_js_namespaceObject.getModuleFederationSerializer)(options, (0, external_helpers_js_namespaceObject.isUsingMFBundleCommand)()),
+            customSerializer: (0, external_serializer_js_namespaceObject.getModuleFederationSerializer)(options, (0, external_helpers_js_namespaceObject.isUsingMFBundleCommand)(), manifestPath, manifestOptions),
             getModulesRunBeforeMainModule: (entryFilePath)=>{
                 if (flags.unstable_patchInitializeCore) return config.serializer.getModulesRunBeforeMainModule(entryFilePath);
                 if (isRemote) return [];
@@ -150,7 +156,16 @@ function augmentConfig(config, federationOptions, extraOptions) {
         },
         server: {
             ...config.server,
-            enhanceMiddleware: vmManager.getMiddleware(),
+            enhanceMiddleware: (middleware, metroServer)=>{
+                const manifestMiddleware = (0, external_manifest_middleware_js_namespaceObject.createManifestMiddleware)({
+                    federationConfig: options,
+                    projectRoot: config.projectRoot,
+                    remoteEntryPath,
+                    tmpDirPath,
+                    vmManager
+                })(middleware, metroServer);
+                return vmManager.getMiddleware()(manifestMiddleware, metroServer);
+            },
             rewriteRequestUrl: (0, external_rewrite_request_js_namespaceObject.createRewriteRequest)({
                 config,
                 originalEntryFilename,

package/dist/plugin/index.mjs

@@ -8,6 +8,7 @@ import { applyTypesMetaToManifest, maybeGenerateFederatedRemoteTypes } from "../
 import { createBabelTransformer } from "./babel-transformer.mjs";
 import { isUsingMFBundleCommand, isUsingMFCommand, prepareTmpDir, replaceExtension, stubHostEntry, stubRemoteEntry } from "./helpers.mjs";
 import { createManifest } from "./manifest.mjs";
+import { createManifestMiddleware } from "./manifest-middleware.mjs";
 import { normalizeExtraOptions } from "./normalize-extra-options.mjs";
 import { normalizeOptions } from "./normalize-options.mjs";
 import { createResolveRequest } from "./resolver.mjs";
@@ -50,7 +51,12 @@ function augmentConfig(config, federationOptions, extraOptions) {
         enableInitializeCorePatching: flags.unstable_patchInitializeCore,
         enableRuntimeRequirePatching: flags.unstable_patchRuntimeRequire
     });
-    const manifestPath = createManifest(options, tmpDirPath);
+    const manifestOptions = {
+        projectRoot: config.projectRoot,
+        target: isUsingMFBundleCommand() ? 'build' : 'development',
+        tmpDirPath
+    };
+    const manifestPath = createManifest(options, tmpDirPath, manifestOptions);
     stubHostEntry(hostEntryPath);
     stubRemoteEntry(remoteEntryPath);
     global.__METRO_FEDERATION_CONFIG = options;
@@ -69,7 +75,7 @@ function augmentConfig(config, federationOptions, extraOptions) {
         ...config,
         serializer: {
             ...config.serializer,
-            customSerializer: getModuleFederationSerializer(options, isUsingMFBundleCommand()),
+            customSerializer: getModuleFederationSerializer(options, isUsingMFBundleCommand(), manifestPath, manifestOptions),
             getModulesRunBeforeMainModule: (entryFilePath)=>{
                 if (flags.unstable_patchInitializeCore) return config.serializer.getModulesRunBeforeMainModule(entryFilePath);
                 if (isRemote) return [];
@@ -113,7 +119,16 @@ function augmentConfig(config, federationOptions, extraOptions) {
         },
         server: {
             ...config.server,
-            enhanceMiddleware: vmManager.getMiddleware(),
+            enhanceMiddleware: (middleware, metroServer)=>{
+                const manifestMiddleware = createManifestMiddleware({
+                    federationConfig: options,
+                    projectRoot: config.projectRoot,
+                    remoteEntryPath,
+                    tmpDirPath,
+                    vmManager
+                })(middleware, metroServer);
+                return vmManager.getMiddleware()(manifestMiddleware, metroServer);
+            },
             rewriteRequestUrl: createRewriteRequest({
                 config,
                 originalEntryFilename,

package/dist/plugin/manifest-middleware.d.ts

@@ -0,0 +1,12 @@
+import type { ServerConfigT } from 'metro-config';
+import type { ModuleFederationConfigNormalized } from '../types';
+import type { VirtualModuleManager } from '../utils';
+type ManifestMiddlewareOptions = {
+    federationConfig: ModuleFederationConfigNormalized;
+    projectRoot: string;
+    remoteEntryPath: string;
+    tmpDirPath: string;
+    vmManager: Pick<VirtualModuleManager, 'registerVirtualModule'>;
+};
+export declare function createManifestMiddleware({ federationConfig, projectRoot, remoteEntryPath, tmpDirPath, vmManager, }: ManifestMiddlewareOptions): NonNullable<ServerConfigT['enhanceMiddleware']>;
+export {};

package/dist/plugin/manifest-middleware.js

@@ -0,0 +1,213 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createManifestMiddleware: ()=>createManifestMiddleware
+});
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const metro_compat_js_namespaceObject = require("../utils/metro-compat.js");
+const external_constants_js_namespaceObject = require("./constants.js");
+const external_generators_js_namespaceObject = require("./generators.js");
+const external_helpers_js_namespaceObject = require("./helpers.js");
+const external_manifest_js_namespaceObject = require("./manifest.js");
+function createManifestMiddleware({ federationConfig, projectRoot, remoteEntryPath, tmpDirPath, vmManager }) {
+    const warmups = new Map();
+    return (middleware, metroServer)=>{
+        const nextMiddleware = middleware;
+        return async (req, res, next)=>{
+            try {
+                const warmupOptions = getManifestWarmupOptions(req.url);
+                if (warmupOptions) {
+                    const warmupKey = JSON.stringify(warmupOptions);
+                    let warmup = warmups.get(warmupKey);
+                    if (!warmup) {
+                        warmup = warmManifestBundles(metroServer, {
+                            federationConfig,
+                            host: req.headers.host,
+                            projectRoot,
+                            remoteEntryPath,
+                            tmpDirPath,
+                            vmManager,
+                            warmupOptions
+                        }).finally(()=>{
+                            warmups.delete(warmupKey);
+                        });
+                        warmups.set(warmupKey, warmup);
+                    }
+                    await warmup;
+                }
+                return nextMiddleware(req, res, next);
+            } catch (error) {
+                next(error instanceof Error ? error : new Error(String(error)));
+            }
+        };
+    };
+}
+function getManifestWarmupOptions(rawUrl) {
+    const parsedUrl = new URL(rawUrl ?? '/', 'http://localhost');
+    if (parsedUrl.pathname !== `/${external_constants_js_namespaceObject.MANIFEST_FILENAME}`) return null;
+    const platform = parsedUrl.searchParams.get('platform');
+    if (!platform) return null;
+    return {
+        dev: getBoolean(parsedUrl.searchParams, 'dev', true),
+        excludeSource: getBoolean(parsedUrl.searchParams, 'excludeSource', false),
+        minify: getBoolean(parsedUrl.searchParams, 'minify', false),
+        platform,
+        sourcePaths: parsedUrl.searchParams.get('sourcePaths') ?? void 0
+    };
+}
+async function warmManifestBundles(metroServer, { federationConfig, host, projectRoot, remoteEntryPath, tmpDirPath, vmManager, warmupOptions }) {
+    for (const request of getBundleWarmupRequests({
+        federationConfig,
+        projectRoot,
+        remoteEntryPath,
+        tmpDirPath,
+        vmManager
+    })){
+        if (request.virtualModule) await ensureVirtualModuleReady(request.virtualModule, vmManager);
+        await metroServer.build(getBundleOptions(request, host, warmupOptions));
+    }
+}
+function getBundleWarmupRequests({ federationConfig, projectRoot, remoteEntryPath, tmpDirPath }) {
+    const relativeTmpDirPath = (0, external_helpers_js_namespaceObject.toPosixPath)(external_node_path_default().relative(projectRoot, tmpDirPath));
+    const remoteEntryName = (0, external_helpers_js_namespaceObject.removeExtension)(external_node_path_default().basename(remoteEntryPath));
+    const relativeRemoteEntryPath = (0, external_helpers_js_namespaceObject.toPosixPath)(external_node_path_default().relative(projectRoot, remoteEntryPath));
+    const requests = [
+        {
+            bundlePath: `${relativeTmpDirPath}/${remoteEntryName}.bundle`,
+            entryFile: `./${relativeRemoteEntryPath}`,
+            isContainer: true,
+            virtualModule: {
+                filePath: remoteEntryPath,
+                getCode: ()=>(0, external_generators_js_namespaceObject.getRemoteEntryModule)(federationConfig, {
+                        projectDir: projectRoot,
+                        tmpDir: tmpDirPath
+                    })
+            }
+        }
+    ];
+    for (const exposePath of Object.values(federationConfig.exposes)){
+        const bundlePath = getBundlePathForSource(exposePath);
+        requests.push({
+            bundlePath,
+            entryFile: normalizeEntryFile(exposePath),
+            isContainer: false
+        });
+    }
+    for (const [sharedName, sharedConfig] of Object.entries(federationConfig.shared)){
+        if (sharedConfig.eager || false === sharedConfig.import) continue;
+        const sharedVirtualModulePath = (0, external_manifest_js_namespaceObject.getSharedVirtualModulePath)(tmpDirPath, sharedName);
+        const relativeSharedVirtualModulePath = (0, external_helpers_js_namespaceObject.toPosixPath)(external_node_path_default().relative(projectRoot, sharedVirtualModulePath));
+        const sharedImportName = getSharedImportName(sharedName, sharedConfig);
+        requests.push({
+            bundlePath: (0, external_helpers_js_namespaceObject.replaceExtension)(relativeSharedVirtualModulePath, '.bundle'),
+            entryFile: normalizeEntryFile(relativeSharedVirtualModulePath),
+            isContainer: false,
+            virtualModule: {
+                filePath: sharedVirtualModulePath,
+                getCode: ()=>(0, external_generators_js_namespaceObject.getRemoteModule)(sharedImportName)
+            }
+        });
+    }
+    return requests;
+}
+async function ensureVirtualModuleReady(virtualModule, vmManager) {
+    const code = virtualModule.getCode();
+    await external_node_fs_namespaceObject.promises.mkdir(external_node_path_default().dirname(virtualModule.filePath), {
+        recursive: true
+    });
+    await external_node_fs_namespaceObject.promises.writeFile(virtualModule.filePath, code, 'utf-8');
+    vmManager.registerVirtualModule(virtualModule.filePath, ()=>code);
+}
+function getBundleOptions(request, host, warmupOptions) {
+    const query = getBundleQuery(warmupOptions, request.isContainer);
+    const sourceUrl = getSourceUrl(host, request.bundlePath, query);
+    const bundleOptions = {
+        ...metro_compat_js_namespaceObject.Server.DEFAULT_BUNDLE_OPTIONS,
+        dev: warmupOptions.dev,
+        entryFile: request.entryFile,
+        excludeSource: warmupOptions.excludeSource,
+        lazy: true,
+        minify: warmupOptions.minify,
+        modulesOnly: !request.isContainer,
+        platform: warmupOptions.platform,
+        runModule: request.isContainer,
+        sourceMapUrl: sourceUrl.replace(/\.bundle(\?)/, '.map$1'),
+        sourceUrl
+    };
+    if (warmupOptions.sourcePaths) bundleOptions.sourcePaths = warmupOptions.sourcePaths;
+    return bundleOptions;
+}
+function getBundleQuery(warmupOptions, isContainer) {
+    const query = new URLSearchParams();
+    query.set('platform', warmupOptions.platform);
+    query.set('dev', String(warmupOptions.dev));
+    query.set('lazy', 'true');
+    query.set('minify', String(warmupOptions.minify));
+    query.set('runModule', String(isContainer));
+    query.set('modulesOnly', String(!isContainer));
+    if (warmupOptions.excludeSource) query.set('excludeSource', 'true');
+    if (warmupOptions.sourcePaths) query.set('sourcePaths', warmupOptions.sourcePaths);
+    return query;
+}
+function getSourceUrl(host, bundlePath, query) {
+    const normalizedBundlePath = bundlePath.startsWith('/') ? bundlePath : `/${bundlePath}`;
+    return `http://${host ?? 'localhost'}${normalizedBundlePath}?${query.toString()}`;
+}
+function getBundlePathForSource(sourcePath) {
+    const normalized = (0, external_helpers_js_namespaceObject.toPosixPath)(external_node_path_default().normalize(sourcePath));
+    const withoutPrefix = normalized.startsWith('./') ? normalized.slice(2) : normalized;
+    return (0, external_helpers_js_namespaceObject.replaceExtension)(withoutPrefix, '.bundle');
+}
+function normalizeEntryFile(sourcePath) {
+    const normalized = (0, external_helpers_js_namespaceObject.toPosixPath)(external_node_path_default().normalize(sourcePath));
+    return normalized.startsWith('./') ? normalized : `./${normalized}`;
+}
+function getSharedImportName(sharedName, sharedConfig) {
+    return 'string' == typeof sharedConfig.import ? sharedConfig.import : sharedName;
+}
+function getBoolean(params, key, defaultValue) {
+    const value = params.get(key);
+    if (null == value) return defaultValue;
+    return 'true' === value || '1' === value;
+}
+exports.createManifestMiddleware = __webpack_exports__.createManifestMiddleware;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "createManifestMiddleware"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/plugin/manifest-middleware.mjs

@@ -0,0 +1,171 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { promises } from "node:fs";
+import node_path from "node:path";
+import { Server } from "../utils/metro-compat.mjs";
+import { MANIFEST_FILENAME } from "./constants.mjs";
+import { getRemoteEntryModule, getRemoteModule } from "./generators.mjs";
+import { removeExtension, replaceExtension, toPosixPath } from "./helpers.mjs";
+import { getSharedVirtualModulePath } from "./manifest.mjs";
+function createManifestMiddleware({ federationConfig, projectRoot, remoteEntryPath, tmpDirPath, vmManager }) {
+    const warmups = new Map();
+    return (middleware, metroServer)=>{
+        const nextMiddleware = middleware;
+        return async (req, res, next)=>{
+            try {
+                const warmupOptions = getManifestWarmupOptions(req.url);
+                if (warmupOptions) {
+                    const warmupKey = JSON.stringify(warmupOptions);
+                    let warmup = warmups.get(warmupKey);
+                    if (!warmup) {
+                        warmup = warmManifestBundles(metroServer, {
+                            federationConfig,
+                            host: req.headers.host,
+                            projectRoot,
+                            remoteEntryPath,
+                            tmpDirPath,
+                            vmManager,
+                            warmupOptions
+                        }).finally(()=>{
+                            warmups.delete(warmupKey);
+                        });
+                        warmups.set(warmupKey, warmup);
+                    }
+                    await warmup;
+                }
+                return nextMiddleware(req, res, next);
+            } catch (error) {
+                next(error instanceof Error ? error : new Error(String(error)));
+            }
+        };
+    };
+}
+function getManifestWarmupOptions(rawUrl) {
+    const parsedUrl = new URL(rawUrl ?? '/', 'http://localhost');
+    if (parsedUrl.pathname !== `/${MANIFEST_FILENAME}`) return null;
+    const platform = parsedUrl.searchParams.get('platform');
+    if (!platform) return null;
+    return {
+        dev: getBoolean(parsedUrl.searchParams, 'dev', true),
+        excludeSource: getBoolean(parsedUrl.searchParams, 'excludeSource', false),
+        minify: getBoolean(parsedUrl.searchParams, 'minify', false),
+        platform,
+        sourcePaths: parsedUrl.searchParams.get('sourcePaths') ?? void 0
+    };
+}
+async function warmManifestBundles(metroServer, { federationConfig, host, projectRoot, remoteEntryPath, tmpDirPath, vmManager, warmupOptions }) {
+    for (const request of getBundleWarmupRequests({
+        federationConfig,
+        projectRoot,
+        remoteEntryPath,
+        tmpDirPath,
+        vmManager
+    })){
+        if (request.virtualModule) await ensureVirtualModuleReady(request.virtualModule, vmManager);
+        await metroServer.build(getBundleOptions(request, host, warmupOptions));
+    }
+}
+function getBundleWarmupRequests({ federationConfig, projectRoot, remoteEntryPath, tmpDirPath }) {
+    const relativeTmpDirPath = toPosixPath(node_path.relative(projectRoot, tmpDirPath));
+    const remoteEntryName = removeExtension(node_path.basename(remoteEntryPath));
+    const relativeRemoteEntryPath = toPosixPath(node_path.relative(projectRoot, remoteEntryPath));
+    const requests = [
+        {
+            bundlePath: `${relativeTmpDirPath}/${remoteEntryName}.bundle`,
+            entryFile: `./${relativeRemoteEntryPath}`,
+            isContainer: true,
+            virtualModule: {
+                filePath: remoteEntryPath,
+                getCode: ()=>getRemoteEntryModule(federationConfig, {
+                        projectDir: projectRoot,
+                        tmpDir: tmpDirPath
+                    })
+            }
+        }
+    ];
+    for (const exposePath of Object.values(federationConfig.exposes)){
+        const bundlePath = getBundlePathForSource(exposePath);
+        requests.push({
+            bundlePath,
+            entryFile: normalizeEntryFile(exposePath),
+            isContainer: false
+        });
+    }
+    for (const [sharedName, sharedConfig] of Object.entries(federationConfig.shared)){
+        if (sharedConfig.eager || false === sharedConfig.import) continue;
+        const sharedVirtualModulePath = getSharedVirtualModulePath(tmpDirPath, sharedName);
+        const relativeSharedVirtualModulePath = toPosixPath(node_path.relative(projectRoot, sharedVirtualModulePath));
+        const sharedImportName = getSharedImportName(sharedName, sharedConfig);
+        requests.push({
+            bundlePath: replaceExtension(relativeSharedVirtualModulePath, '.bundle'),
+            entryFile: normalizeEntryFile(relativeSharedVirtualModulePath),
+            isContainer: false,
+            virtualModule: {
+                filePath: sharedVirtualModulePath,
+                getCode: ()=>getRemoteModule(sharedImportName)
+            }
+        });
+    }
+    return requests;
+}
+async function ensureVirtualModuleReady(virtualModule, vmManager) {
+    const code = virtualModule.getCode();
+    await promises.mkdir(node_path.dirname(virtualModule.filePath), {
+        recursive: true
+    });
+    await promises.writeFile(virtualModule.filePath, code, 'utf-8');
+    vmManager.registerVirtualModule(virtualModule.filePath, ()=>code);
+}
+function getBundleOptions(request, host, warmupOptions) {
+    const query = getBundleQuery(warmupOptions, request.isContainer);
+    const sourceUrl = getSourceUrl(host, request.bundlePath, query);
+    const bundleOptions = {
+        ...Server.DEFAULT_BUNDLE_OPTIONS,
+        dev: warmupOptions.dev,
+        entryFile: request.entryFile,
+        excludeSource: warmupOptions.excludeSource,
+        lazy: true,
+        minify: warmupOptions.minify,
+        modulesOnly: !request.isContainer,
+        platform: warmupOptions.platform,
+        runModule: request.isContainer,
+        sourceMapUrl: sourceUrl.replace(/\.bundle(\?)/, '.map$1'),
+        sourceUrl
+    };
+    if (warmupOptions.sourcePaths) bundleOptions.sourcePaths = warmupOptions.sourcePaths;
+    return bundleOptions;
+}
+function getBundleQuery(warmupOptions, isContainer) {
+    const query = new URLSearchParams();
+    query.set('platform', warmupOptions.platform);
+    query.set('dev', String(warmupOptions.dev));
+    query.set('lazy', 'true');
+    query.set('minify', String(warmupOptions.minify));
+    query.set('runModule', String(isContainer));
+    query.set('modulesOnly', String(!isContainer));
+    if (warmupOptions.excludeSource) query.set('excludeSource', 'true');
+    if (warmupOptions.sourcePaths) query.set('sourcePaths', warmupOptions.sourcePaths);
+    return query;
+}
+function getSourceUrl(host, bundlePath, query) {
+    const normalizedBundlePath = bundlePath.startsWith('/') ? bundlePath : `/${bundlePath}`;
+    return `http://${host ?? 'localhost'}${normalizedBundlePath}?${query.toString()}`;
+}
+function getBundlePathForSource(sourcePath) {
+    const normalized = toPosixPath(node_path.normalize(sourcePath));
+    const withoutPrefix = normalized.startsWith('./') ? normalized.slice(2) : normalized;
+    return replaceExtension(withoutPrefix, '.bundle');
+}
+function normalizeEntryFile(sourcePath) {
+    const normalized = toPosixPath(node_path.normalize(sourcePath));
+    return normalized.startsWith('./') ? normalized : `./${normalized}`;
+}
+function getSharedImportName(sharedName, sharedConfig) {
+    return 'string' == typeof sharedConfig.import ? sharedConfig.import : sharedName;
+}
+function getBoolean(params, key, defaultValue) {
+    const value = params.get(key);
+    if (null == value) return defaultValue;
+    return 'true' === value || '1' === value;
+}
+export { createManifestMiddleware };

package/dist/plugin/manifest.d.ts

@@ -1,3 +1,16 @@
 import type { ModuleFederationConfigNormalized } from '../types';
-export declare function createManifest(options: ModuleFederationConfigNormalized, mfMetroPath: string): string;
-export declare const updateManifest: (manifestPath: string, options: ModuleFederationConfigNormalized) => string;
+export type BundleHashMap = Map<string, string>;
+export type ManifestGenerationOptions = {
+    projectRoot?: string;
+    target?: 'development' | 'build';
+    tmpDirPath?: string;
+};
+export declare function createManifest(options: ModuleFederationConfigNormalized, mfMetroPath: string, hashesOrOptions?: BundleHashMap | ManifestGenerationOptions, manifestOptions?: ManifestGenerationOptions): string;
+export declare function updateManifest(manifestPath: string, options: ModuleFederationConfigNormalized, hashesOrOptions?: BundleHashMap | ManifestGenerationOptions, manifestOptions?: ManifestGenerationOptions): string;
+/**
+ * Compute SHA-256 of bundle code and store the hash for the matching
+ * manifest entry (container, exposed, or shared).
+ */
+export declare function recordBundleHash(hashes: BundleHashMap, code: string, entryPoint: string, projectRoot: string, config: ModuleFederationConfigNormalized): void;
+export declare function getSharedVirtualModuleName(sharedName: string): string;
+export declare function getSharedVirtualModulePath(tmpDirPath: string, sharedName: string): string;

package/dist/plugin/manifest.js

@@ -33,42 +33,62 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    getSharedVirtualModulePath: ()=>getSharedVirtualModulePath,
     createManifest: ()=>createManifest,
-    updateManifest: ()=>updateManifest
+    recordBundleHash: ()=>recordBundleHash,
+    updateManifest: ()=>updateManifest,
+    getSharedVirtualModuleName: ()=>getSharedVirtualModuleName
 });
+const external_node_crypto_namespaceObject = require("node:crypto");
+var external_node_crypto_default = /*#__PURE__*/ __webpack_require__.n(external_node_crypto_namespaceObject);
 const external_node_fs_namespaceObject = require("node:fs");
 var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const external_constants_js_namespaceObject = require("./constants.js");
-function createManifest(options, mfMetroPath) {
+const external_helpers_js_namespaceObject = require("./helpers.js");
+function createManifest(options, mfMetroPath, hashesOrOptions, manifestOptions) {
+    const { hashes, options: generationOptions } = normalizeManifestArgs(hashesOrOptions, manifestOptions);
     const manifestPath = external_node_path_default().join(mfMetroPath, external_constants_js_namespaceObject.MANIFEST_FILENAME);
-    const manifest = generateManifest(options);
+    const manifest = generateManifest(options, hashes, generationOptions);
     external_node_fs_default().writeFileSync(manifestPath, JSON.stringify(manifest, void 0, 2));
     return manifestPath;
 }
-const updateManifest = (manifestPath, options)=>{
-    const manifest = generateManifest(options);
+function updateManifest(manifestPath, options, hashesOrOptions, manifestOptions) {
+    var _existingManifest_metaData;
+    const { hashes, options: generationOptions } = normalizeManifestArgs(hashesOrOptions, manifestOptions);
+    const manifest = generateManifest(options, hashes, generationOptions);
+    const existingManifest = readManifest(manifestPath);
+    if (null == existingManifest ? void 0 : null == (_existingManifest_metaData = existingManifest.metaData) ? void 0 : _existingManifest_metaData.types) manifest.metaData.types = {
+        ...manifest.metaData.types,
+        ...existingManifest.metaData.types
+    };
     external_node_fs_default().writeFileSync(manifestPath, JSON.stringify(manifest, void 0, 2));
     return manifestPath;
-};
-function generateManifest(config) {
+}
+function recordBundleHash(hashes, code, entryPoint, projectRoot, config) {
+    const hash = external_node_crypto_default().createHash('sha256').update(code).digest('hex');
+    const key = resolveBundleKey(entryPoint, projectRoot, config);
+    if (key) hashes.set(key, hash);
+}
+function generateManifest(config, hashes, manifestOptions = {}) {
     return {
         id: config.name,
         name: config.name,
-        metaData: generateMetaData(config),
-        exposes: generateExposes(config),
+        metaData: generateMetaData(config, hashes),
+        exposes: generateExposes(config, hashes),
         remotes: generateRemotes(config),
-        shared: generateShared(config)
+        shared: generateShared(config, hashes, manifestOptions)
     };
 }
-function generateMetaData(config) {
+function generateMetaData(config, hashes) {
     return {
         name: config.name,
         type: 'app',
         buildInfo: {
             buildVersion: '1.0.0',
-            buildName: config.name
+            buildName: config.name,
+            hash: (null == hashes ? void 0 : hashes.get(`container:${config.name}`)) ?? ''
         },
         remoteEntry: {
             name: config.filename,
@@ -86,7 +106,7 @@ function generateMetaData(config) {
         publicPath: 'auto'
     };
 }
-function generateExposes(config) {
+function generateExposes(config, hashes) {
     return Object.keys(config.exposes).map((expose)=>{
         const formatKey = expose.replace('./', '');
         const assets = getEmptyAssets();
@@ -95,7 +115,8 @@ function generateExposes(config) {
             id: `${config.name}:${formatKey}`,
             name: formatKey,
             path: expose,
-            assets
+            assets,
+            hash: (null == hashes ? void 0 : hashes.get(`expose:${formatKey}`)) ?? ''
         };
     });
 }
@@ -107,22 +128,86 @@ function generateRemotes(config) {
             entry: '*'
         }));
 }
-function generateShared(config) {
+function generateShared(config, hashes, manifestOptions = {}) {
     return Object.keys(config.shared).map((sharedName)=>{
         const assets = getEmptyAssets();
         if (config.shared[sharedName].eager) assets.js.sync.push(config.filename);
-        else if (false !== config.shared[sharedName].import) assets.js.sync.push(`shared/${sharedName}.bundle`);
+        else if (false !== config.shared[sharedName].import) assets.js.sync.push(getSharedAssetPath(sharedName, manifestOptions));
         return {
             id: sharedName,
             name: sharedName,
             version: getManifestVersion(config.shared[sharedName].version),
             requiredVersion: getManifestRequiredVersion(config.shared[sharedName].requiredVersion),
             singleton: config.shared[sharedName].singleton,
-            hash: '',
+            hash: (null == hashes ? void 0 : hashes.get(`shared:${sharedName}`)) ?? '',
             assets
         };
     });
 }
+function resolveBundleKey(entryPoint, projectRoot, config) {
+    const relPath = (0, external_helpers_js_namespaceObject.toPosixPath)(external_node_path_default().relative(projectRoot, entryPoint));
+    const normalizedRel = relPath.startsWith('./') ? relPath.slice(2) : relPath;
+    const normalizedRelNoExt = (0, external_helpers_js_namespaceObject.removeExtension)(normalizedRel);
+    for (const [exposeKey, exposePath] of Object.entries(config.exposes)){
+        const normalizedExpose = (0, external_helpers_js_namespaceObject.toPosixPath)(exposePath.startsWith('./') ? exposePath.slice(2) : exposePath);
+        if (normalizedRel === normalizedExpose || normalizedRelNoExt === (0, external_helpers_js_namespaceObject.removeExtension)(normalizedExpose)) return `expose:${exposeKey.replace('./', '')}`;
+    }
+    if ((0, external_helpers_js_namespaceObject.removeExtension)(external_node_path_default().basename(entryPoint)) === (0, external_helpers_js_namespaceObject.removeExtension)(external_node_path_default().basename(config.filename))) return `container:${config.name}`;
+    const virtualSharedKey = resolveDevVirtualSharedKey(entryPoint, projectRoot, config);
+    if (virtualSharedKey) return virtualSharedKey;
+    const absPath = (0, external_helpers_js_namespaceObject.toPosixPath)(external_node_path_default().resolve(entryPoint));
+    const nmMatch = absPath.match(/.*node_modules\/(.+)/);
+    if (nmMatch) {
+        const modulePath = (0, external_helpers_js_namespaceObject.removeExtension)(nmMatch[1]);
+        const sharedKey = findSharedKeyForModulePath(modulePath, config);
+        if (sharedKey) return `shared:${sharedKey}`;
+    }
+    return null;
+}
+function normalizeManifestArgs(hashesOrOptions, manifestOptions) {
+    if (hashesOrOptions instanceof Map) return {
+        hashes: hashesOrOptions,
+        options: manifestOptions ?? {}
+    };
+    return {
+        hashes: void 0,
+        options: hashesOrOptions ?? {}
+    };
+}
+function readManifest(manifestPath) {
+    if (!external_node_fs_default().existsSync(manifestPath)) return;
+    return JSON.parse(external_node_fs_default().readFileSync(manifestPath, 'utf-8'));
+}
+function getSharedVirtualModuleName(sharedName) {
+    return sharedName.replaceAll('/', '_');
+}
+function getSharedVirtualModulePath(tmpDirPath, sharedName) {
+    return external_node_path_default().join(tmpDirPath, 'shared', `${getSharedVirtualModuleName(sharedName)}.js`);
+}
+function getSharedAssetPath(sharedName, manifestOptions) {
+    if ('development' === manifestOptions.target && manifestOptions.projectRoot && manifestOptions.tmpDirPath) return (0, external_helpers_js_namespaceObject.toPosixPath)(external_node_path_default().relative(manifestOptions.projectRoot, getSharedVirtualModulePath(manifestOptions.tmpDirPath, sharedName)));
+    return `shared/${sharedName}.bundle`;
+}
+function resolveDevVirtualSharedKey(entryPoint, projectRoot, config) {
+    const relativePath = (0, external_helpers_js_namespaceObject.toPosixPath)(external_node_path_default().relative(projectRoot, entryPoint));
+    const virtualSharedPrefix = `node_modules/${external_constants_js_namespaceObject.TMP_DIR_NAME}/shared/`;
+    if (!relativePath.startsWith(virtualSharedPrefix)) return null;
+    const virtualModuleName = (0, external_helpers_js_namespaceObject.removeExtension)(relativePath.slice(virtualSharedPrefix.length));
+    const sharedKey = Object.keys(config.shared).find((sharedName)=>getSharedVirtualModuleName(sharedName) === virtualModuleName);
+    return sharedKey ? `shared:${sharedKey}` : null;
+}
+function findSharedKeyForModulePath(modulePath, config) {
+    const sharedEntries = Object.entries(config.shared).map(([sharedName, sharedConfig])=>{
+        const importName = 'string' == typeof sharedConfig.import ? sharedConfig.import : sharedName;
+        return {
+            importName,
+            sharedName
+        };
+    }).sort((a, b)=>b.importName.length - a.importName.length);
+    const normalizedModulePath = (0, external_helpers_js_namespaceObject.toPosixPath)(modulePath);
+    for (const { importName, sharedName } of sharedEntries)if (normalizedModulePath === importName || normalizedModulePath.startsWith(`${importName}/`)) return sharedName;
+    return null;
+}
 function getManifestVersion(version) {
     return 'string' == typeof version ? version : '';
 }
@@ -142,9 +227,15 @@ function getEmptyAssets() {
     };
 }
 exports.createManifest = __webpack_exports__.createManifest;
+exports.getSharedVirtualModuleName = __webpack_exports__.getSharedVirtualModuleName;
+exports.getSharedVirtualModulePath = __webpack_exports__.getSharedVirtualModulePath;
+exports.recordBundleHash = __webpack_exports__.recordBundleHash;
 exports.updateManifest = __webpack_exports__.updateManifest;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
     "createManifest",
+    "getSharedVirtualModuleName",
+    "getSharedVirtualModulePath",
+    "recordBundleHash",
     "updateManifest"
 ].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
 Object.defineProperty(exports, '__esModule', {

package/dist/plugin/manifest.mjs

@@ -1,36 +1,52 @@
 import 'module';
 /*#__PURE__*/ import.meta.url;
+import node_crypto from "node:crypto";
 import node_fs from "node:fs";
 import node_path from "node:path";
-import { MANIFEST_FILENAME } from "./constants.mjs";
-function createManifest(options, mfMetroPath) {
+import { MANIFEST_FILENAME, TMP_DIR_NAME } from "./constants.mjs";
+import { removeExtension, toPosixPath } from "./helpers.mjs";
+function createManifest(options, mfMetroPath, hashesOrOptions, manifestOptions) {
+    const { hashes, options: generationOptions } = normalizeManifestArgs(hashesOrOptions, manifestOptions);
     const manifestPath = node_path.join(mfMetroPath, MANIFEST_FILENAME);
-    const manifest = generateManifest(options);
+    const manifest = generateManifest(options, hashes, generationOptions);
     node_fs.writeFileSync(manifestPath, JSON.stringify(manifest, void 0, 2));
     return manifestPath;
 }
-const updateManifest = (manifestPath, options)=>{
-    const manifest = generateManifest(options);
+function updateManifest(manifestPath, options, hashesOrOptions, manifestOptions) {
+    var _existingManifest_metaData;
+    const { hashes, options: generationOptions } = normalizeManifestArgs(hashesOrOptions, manifestOptions);
+    const manifest = generateManifest(options, hashes, generationOptions);
+    const existingManifest = readManifest(manifestPath);
+    if (null == existingManifest ? void 0 : null == (_existingManifest_metaData = existingManifest.metaData) ? void 0 : _existingManifest_metaData.types) manifest.metaData.types = {
+        ...manifest.metaData.types,
+        ...existingManifest.metaData.types
+    };
     node_fs.writeFileSync(manifestPath, JSON.stringify(manifest, void 0, 2));
     return manifestPath;
-};
-function generateManifest(config) {
+}
+function recordBundleHash(hashes, code, entryPoint, projectRoot, config) {
+    const hash = node_crypto.createHash('sha256').update(code).digest('hex');
+    const key = resolveBundleKey(entryPoint, projectRoot, config);
+    if (key) hashes.set(key, hash);
+}
+function generateManifest(config, hashes, manifestOptions = {}) {
     return {
         id: config.name,
         name: config.name,
-        metaData: generateMetaData(config),
-        exposes: generateExposes(config),
+        metaData: generateMetaData(config, hashes),
+        exposes: generateExposes(config, hashes),
         remotes: generateRemotes(config),
-        shared: generateShared(config)
+        shared: generateShared(config, hashes, manifestOptions)
     };
 }
-function generateMetaData(config) {
+function generateMetaData(config, hashes) {
     return {
         name: config.name,
         type: 'app',
         buildInfo: {
             buildVersion: '1.0.0',
-            buildName: config.name
+            buildName: config.name,
+            hash: (null == hashes ? void 0 : hashes.get(`container:${config.name}`)) ?? ''
         },
         remoteEntry: {
             name: config.filename,
@@ -48,7 +64,7 @@ function generateMetaData(config) {
         publicPath: 'auto'
     };
 }
-function generateExposes(config) {
+function generateExposes(config, hashes) {
     return Object.keys(config.exposes).map((expose)=>{
         const formatKey = expose.replace('./', '');
         const assets = getEmptyAssets();
@@ -57,7 +73,8 @@ function generateExposes(config) {
             id: `${config.name}:${formatKey}`,
             name: formatKey,
             path: expose,
-            assets
+            assets,
+            hash: (null == hashes ? void 0 : hashes.get(`expose:${formatKey}`)) ?? ''
         };
     });
 }
@@ -69,22 +86,86 @@ function generateRemotes(config) {
             entry: '*'
         }));
 }
-function generateShared(config) {
+function generateShared(config, hashes, manifestOptions = {}) {
     return Object.keys(config.shared).map((sharedName)=>{
         const assets = getEmptyAssets();
         if (config.shared[sharedName].eager) assets.js.sync.push(config.filename);
-        else if (false !== config.shared[sharedName].import) assets.js.sync.push(`shared/${sharedName}.bundle`);
+        else if (false !== config.shared[sharedName].import) assets.js.sync.push(getSharedAssetPath(sharedName, manifestOptions));
         return {
             id: sharedName,
             name: sharedName,
             version: getManifestVersion(config.shared[sharedName].version),
             requiredVersion: getManifestRequiredVersion(config.shared[sharedName].requiredVersion),
             singleton: config.shared[sharedName].singleton,
-            hash: '',
+            hash: (null == hashes ? void 0 : hashes.get(`shared:${sharedName}`)) ?? '',
             assets
         };
     });
 }
+function resolveBundleKey(entryPoint, projectRoot, config) {
+    const relPath = toPosixPath(node_path.relative(projectRoot, entryPoint));
+    const normalizedRel = relPath.startsWith('./') ? relPath.slice(2) : relPath;
+    const normalizedRelNoExt = removeExtension(normalizedRel);
+    for (const [exposeKey, exposePath] of Object.entries(config.exposes)){
+        const normalizedExpose = toPosixPath(exposePath.startsWith('./') ? exposePath.slice(2) : exposePath);
+        if (normalizedRel === normalizedExpose || normalizedRelNoExt === removeExtension(normalizedExpose)) return `expose:${exposeKey.replace('./', '')}`;
+    }
+    if (removeExtension(node_path.basename(entryPoint)) === removeExtension(node_path.basename(config.filename))) return `container:${config.name}`;
+    const virtualSharedKey = resolveDevVirtualSharedKey(entryPoint, projectRoot, config);
+    if (virtualSharedKey) return virtualSharedKey;
+    const absPath = toPosixPath(node_path.resolve(entryPoint));
+    const nmMatch = absPath.match(/.*node_modules\/(.+)/);
+    if (nmMatch) {
+        const modulePath = removeExtension(nmMatch[1]);
+        const sharedKey = findSharedKeyForModulePath(modulePath, config);
+        if (sharedKey) return `shared:${sharedKey}`;
+    }
+    return null;
+}
+function normalizeManifestArgs(hashesOrOptions, manifestOptions) {
+    if (hashesOrOptions instanceof Map) return {
+        hashes: hashesOrOptions,
+        options: manifestOptions ?? {}
+    };
+    return {
+        hashes: void 0,
+        options: hashesOrOptions ?? {}
+    };
+}
+function readManifest(manifestPath) {
+    if (!node_fs.existsSync(manifestPath)) return;
+    return JSON.parse(node_fs.readFileSync(manifestPath, 'utf-8'));
+}
+function getSharedVirtualModuleName(sharedName) {
+    return sharedName.replaceAll('/', '_');
+}
+function getSharedVirtualModulePath(tmpDirPath, sharedName) {
+    return node_path.join(tmpDirPath, 'shared', `${getSharedVirtualModuleName(sharedName)}.js`);
+}
+function getSharedAssetPath(sharedName, manifestOptions) {
+    if ('development' === manifestOptions.target && manifestOptions.projectRoot && manifestOptions.tmpDirPath) return toPosixPath(node_path.relative(manifestOptions.projectRoot, getSharedVirtualModulePath(manifestOptions.tmpDirPath, sharedName)));
+    return `shared/${sharedName}.bundle`;
+}
+function resolveDevVirtualSharedKey(entryPoint, projectRoot, config) {
+    const relativePath = toPosixPath(node_path.relative(projectRoot, entryPoint));
+    const virtualSharedPrefix = `node_modules/${TMP_DIR_NAME}/shared/`;
+    if (!relativePath.startsWith(virtualSharedPrefix)) return null;
+    const virtualModuleName = removeExtension(relativePath.slice(virtualSharedPrefix.length));
+    const sharedKey = Object.keys(config.shared).find((sharedName)=>getSharedVirtualModuleName(sharedName) === virtualModuleName);
+    return sharedKey ? `shared:${sharedKey}` : null;
+}
+function findSharedKeyForModulePath(modulePath, config) {
+    const sharedEntries = Object.entries(config.shared).map(([sharedName, sharedConfig])=>{
+        const importName = 'string' == typeof sharedConfig.import ? sharedConfig.import : sharedName;
+        return {
+            importName,
+            sharedName
+        };
+    }).sort((a, b)=>b.importName.length - a.importName.length);
+    const normalizedModulePath = toPosixPath(modulePath);
+    for (const { importName, sharedName } of sharedEntries)if (normalizedModulePath === importName || normalizedModulePath.startsWith(`${importName}/`)) return sharedName;
+    return null;
+}
 function getManifestVersion(version) {
     return 'string' == typeof version ? version : '';
 }
@@ -103,4 +184,4 @@ function getEmptyAssets() {
         }
     };
 }
-export { createManifest, updateManifest };
+export { createManifest, getSharedVirtualModuleName, getSharedVirtualModulePath, recordBundleHash, updateManifest };

package/dist/plugin/resolver.d.ts

@@ -19,7 +19,7 @@ interface CreateResolveRequestOptions {
         tmpDir: string;
     };
     options: ModuleFederationConfigNormalized;
-    vmManager: VirtualModuleManager;
+    vmManager: Pick<VirtualModuleManager, 'registerVirtualModule'>;
     customResolver?: CustomResolver;
 }
 export declare function createResolveRequest({ vmManager, options, hacks, paths, isRemote, customResolver, }: CreateResolveRequestOptions): CustomResolver;

package/dist/plugin/resolver.js

@@ -128,8 +128,8 @@ function createResolveRequest({ vmManager, options, hacks, paths, isRemote, cust
         for (const sharedName of Object.keys(options.shared)){
             const importName = options.shared[sharedName].import || sharedName;
             if (moduleName === importName) {
-                const sharedPath = getSharedPath(moduleName, paths.tmpDir);
-                const sharedGenerator = ()=>(0, external_generators_js_namespaceObject.getRemoteModule)(moduleName);
+                const sharedPath = getSharedPath(sharedName, paths.tmpDir);
+                const sharedGenerator = ()=>(0, external_generators_js_namespaceObject.getRemoteModule)(importName);
                 vmManager.registerVirtualModule(sharedPath, sharedGenerator);
                 return {
                     type: 'sourceFile',

package/dist/plugin/resolver.mjs

@@ -95,8 +95,8 @@ function createResolveRequest({ vmManager, options, hacks, paths, isRemote, cust
         for (const sharedName of Object.keys(options.shared)){
             const importName = options.shared[sharedName].import || sharedName;
             if (moduleName === importName) {
-                const sharedPath = getSharedPath(moduleName, paths.tmpDir);
-                const sharedGenerator = ()=>getRemoteModule(moduleName);
+                const sharedPath = getSharedPath(sharedName, paths.tmpDir);
+                const sharedGenerator = ()=>getRemoteModule(importName);
                 vmManager.registerVirtualModule(sharedPath, sharedGenerator);
                 return {
                     type: 'sourceFile',

package/dist/plugin/serializer.d.ts

@@ -1,5 +1,6 @@
 import type { SerializerConfigT } from 'metro-config';
 import type { ModuleFederationConfigNormalized } from '../types';
+import { type ManifestGenerationOptions } from './manifest';
 type CustomSerializer = SerializerConfigT['customSerializer'];
-export declare function getModuleFederationSerializer(mfConfig: ModuleFederationConfigNormalized, isUsingMFBundleCommand: boolean): CustomSerializer;
+export declare function getModuleFederationSerializer(mfConfig: ModuleFederationConfigNormalized, isUsingMFBundleCommand: boolean, manifestPath?: string, manifestOptions?: ManifestGenerationOptions): CustomSerializer;
 export {};

package/dist/plugin/serializer.js

@@ -39,31 +39,39 @@ const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const errors_js_namespaceObject = require("../utils/errors.js");
 const external_helpers_js_namespaceObject = require("./helpers.js");
+const external_manifest_js_namespaceObject = require("./manifest.js");
 const metro_compat_js_namespaceObject = require("../utils/metro-compat.js");
-function getModuleFederationSerializer(mfConfig, isUsingMFBundleCommand) {
+function getModuleFederationSerializer(mfConfig, isUsingMFBundleCommand, manifestPath, manifestOptions) {
+    const bundleHashes = new Map();
     return async (entryPoint, preModules, graph, options)=>{
         const syncRemoteModules = collectSyncRemoteModules(graph, mfConfig.remotes);
         const syncSharedModules = collectSyncSharedModules(graph, mfConfig.shared);
+        let code;
         if (true === options.runModule) {
             const finalPreModules = [
                 getEarlyShared(syncSharedModules),
                 getEarlyRemotes(syncRemoteModules),
                 ...preModules
             ];
-            return getBundleCode(entryPoint, finalPreModules, graph, options);
+            code = getBundleCode(entryPoint, finalPreModules, graph, options);
+        } else if (isProjectSource(entryPoint, options.projectRoot)) {
+            const bundlePath = getBundlePath(entryPoint, options.projectRoot, mfConfig.exposes, isUsingMFBundleCommand);
+            const finalPreModules = [
+                getSyncShared(syncSharedModules, bundlePath, mfConfig.name),
+                getSyncRemotes(syncRemoteModules, bundlePath, mfConfig.name)
+            ];
+            if (false === options.modulesOnly) finalPreModules.push(...preModules);
+            const finalOptions = {
+                ...options,
+                modulesOnly: false
+            };
+            code = getBundleCode(entryPoint, finalPreModules, graph, finalOptions);
+        } else code = getBundleCode(entryPoint, preModules, graph, options);
+        if (manifestPath) {
+            (0, external_manifest_js_namespaceObject.recordBundleHash)(bundleHashes, code, entryPoint, options.projectRoot, mfConfig);
+            (0, external_manifest_js_namespaceObject.updateManifest)(manifestPath, mfConfig, bundleHashes, manifestOptions);
         }
-        if (!isProjectSource(entryPoint, options.projectRoot)) return getBundleCode(entryPoint, preModules, graph, options);
-        const bundlePath = getBundlePath(entryPoint, options.projectRoot, mfConfig.exposes, isUsingMFBundleCommand);
-        const finalPreModules = [
-            getSyncShared(syncSharedModules, bundlePath, mfConfig.name),
-            getSyncRemotes(syncRemoteModules, bundlePath, mfConfig.name)
-        ];
-        if (false === options.modulesOnly) finalPreModules.push(...preModules);
-        const finalOptions = {
-            ...options,
-            modulesOnly: false
-        };
-        return getBundleCode(entryPoint, finalPreModules, graph, finalOptions);
+        return code;
     };
 }
 function collectSyncRemoteModules(graph, _remotes) {

package/dist/plugin/serializer.mjs

@@ -3,31 +3,39 @@ import 'module';
 import node_path from "node:path";
 import { ConfigError } from "../utils/errors.mjs";
 import { toPosixPath } from "./helpers.mjs";
+import { recordBundleHash, updateManifest } from "./manifest.mjs";
 import { CountingSet, baseJSBundle, bundleToString } from "../utils/metro-compat.mjs";
-function getModuleFederationSerializer(mfConfig, isUsingMFBundleCommand) {
+function getModuleFederationSerializer(mfConfig, isUsingMFBundleCommand, manifestPath, manifestOptions) {
+    const bundleHashes = new Map();
     return async (entryPoint, preModules, graph, options)=>{
         const syncRemoteModules = collectSyncRemoteModules(graph, mfConfig.remotes);
         const syncSharedModules = collectSyncSharedModules(graph, mfConfig.shared);
+        let code;
         if (true === options.runModule) {
             const finalPreModules = [
                 getEarlyShared(syncSharedModules),
                 getEarlyRemotes(syncRemoteModules),
                 ...preModules
             ];
-            return getBundleCode(entryPoint, finalPreModules, graph, options);
+            code = getBundleCode(entryPoint, finalPreModules, graph, options);
+        } else if (isProjectSource(entryPoint, options.projectRoot)) {
+            const bundlePath = getBundlePath(entryPoint, options.projectRoot, mfConfig.exposes, isUsingMFBundleCommand);
+            const finalPreModules = [
+                getSyncShared(syncSharedModules, bundlePath, mfConfig.name),
+                getSyncRemotes(syncRemoteModules, bundlePath, mfConfig.name)
+            ];
+            if (false === options.modulesOnly) finalPreModules.push(...preModules);
+            const finalOptions = {
+                ...options,
+                modulesOnly: false
+            };
+            code = getBundleCode(entryPoint, finalPreModules, graph, finalOptions);
+        } else code = getBundleCode(entryPoint, preModules, graph, options);
+        if (manifestPath) {
+            recordBundleHash(bundleHashes, code, entryPoint, options.projectRoot, mfConfig);
+            updateManifest(manifestPath, mfConfig, bundleHashes, manifestOptions);
         }
-        if (!isProjectSource(entryPoint, options.projectRoot)) return getBundleCode(entryPoint, preModules, graph, options);
-        const bundlePath = getBundlePath(entryPoint, options.projectRoot, mfConfig.exposes, isUsingMFBundleCommand);
-        const finalPreModules = [
-            getSyncShared(syncSharedModules, bundlePath, mfConfig.name),
-            getSyncRemotes(syncRemoteModules, bundlePath, mfConfig.name)
-        ];
-        if (false === options.modulesOnly) finalPreModules.push(...preModules);
-        const finalOptions = {
-            ...options,
-            modulesOnly: false
-        };
-        return getBundleCode(entryPoint, finalPreModules, graph, finalOptions);
+        return code;
     };
 }
 function collectSyncRemoteModules(graph, _remotes) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@module-federation/metro",
-  "version": "2.4.0",
+  "version": "2.5.0",
   "description": "Module Federation for Metro bundler",
   "keywords": [
     "module-federation",
@@ -57,9 +57,9 @@
   },
   "dependencies": {
     "@expo/metro-runtime": "^5.0.4",
-    "@module-federation/dts-plugin": "2.4.0",
-    "@module-federation/runtime": "2.4.0",
-    "@module-federation/sdk": "2.4.0"
+    "@module-federation/dts-plugin": "2.5.0",
+    "@module-federation/runtime": "2.5.0",
+    "@module-federation/sdk": "2.5.0"
   },
   "peerDependencies": {
     "@babel/types": "^7.25.0",