@module-federation/vite 1.0.0-alpha-2f53b4e → 1.0.0-alpha-b1bba84

package/lib/index.modern.js

@@ -1,29 +1,36 @@
 import * as fs from 'fs';
-import { existsSync, mkdirSync, writeFileSync, writeFile } from 'fs';
+import { mkdirSync, writeFileSync, existsSync, writeFile } from 'fs';
 import * as path from 'pathe';
-import path__default, { parse, join, dirname, resolve } from 'pathe';
+import path__default, { parse, join, dirname, resolve, relative } from 'pathe';
 import { createFilter } from '@rollup/pluginutils';
-import { defu } from 'defu';
 import { walk } from 'estree-walker';
 import MagicString from 'magic-string';
+import { defu } from 'defu';
 
 const addEntry = ({
   entryName,
   entryPath,
   fileName
 }) => {
+  const devEntryPath = entryPath.startsWith("virtual:mf") ? "/@id/" + entryPath : entryPath;
   let entryFiles = [];
   let htmlFilePath;
+  let _command;
   return [{
     name: 'add-entry',
     apply: "serve",
+    config(config, {
+      command
+    }) {
+      _command = command;
+    },
     configureServer(server) {
       var _server$httpServer;
       (_server$httpServer = server.httpServer) == null || _server$httpServer.once == null || _server$httpServer.once('listening', () => {
         const {
           port
         } = server.config.server;
-        fetch(path.join(`http://localhost:${port}`, `${entryPath}`)).catch(e => {});
+        fetch(path.join(`http://localhost:${port}`, `${devEntryPath}`)).catch(e => {});
       });
       server.middlewares.use((req, res, next) => {
         if (!fileName) {
@@ -31,18 +38,17 @@ const addEntry = ({
           return;
         }
         if (req.url && req.url.startsWith(fileName.replace(/^\/?/, '/'))) {
-          req.url = entryPath;
+          req.url = devEntryPath;
         }
         next();
       });
     },
     transformIndexHtml(c) {
-      return c.replace('<head>', `<head><script type="module" src=${JSON.stringify(entryPath.replace(/.+?\:([/\\])[/\\]?/, '$1').replace(/\\\\?/g, '/'))}></script>`);
+      return c.replace('<head>', `<head><script type="module" src=${JSON.stringify(devEntryPath.replace(/.+?\:([/\\])[/\\]?/, '$1').replace(/\\\\?/g, '/'))}></script>`);
     }
   }, {
     name: "add-entry",
     enforce: "post",
-    apply: "build",
     configResolved(config) {
       const inputOptions = config.build.rollupOptions.input;
       if (!inputOptions) {
@@ -59,6 +65,7 @@ const addEntry = ({
       }
     },
     buildStart() {
+      if (_command === "serve") return;
       const hasHash = fileName == null || fileName.includes == null ? void 0 : fileName.includes("[hash");
       this.emitFile({
         name: entryName,
@@ -87,46 +94,81 @@ const addEntry = ({
   }];
 };
 
-let _resolve,
-  promise = new Promise((resolve, reject) => {
-    _resolve = resolve;
-  });
-let parsePromise = promise;
-const parseStartSet = new Set();
-const parseEndSet = new Set();
-function pluginModuleParseEnd (excludeFn) {
-  return [{
-    name: "_",
+/**
+ * Solve the problem that dev mode dependency prebunding does not support top-level await syntax
+ */
+function PluginDevProxyModuleTopLevelAwait() {
+  const filterFunction = createFilter();
+  return {
+    name: "dev-proxy-module-top-level-await",
     apply: "serve",
-    config() {
-      // No waiting in development mode
-      _resolve(1);
-    }
-  }, {
-    enforce: "pre",
-    name: "parseStart",
-    apply: "build",
-    load(id) {
-      if (excludeFn(id)) {
-        return;
-      }
-      parseStartSet.add(id);
-    }
-  }, {
-    enforce: "post",
-    name: "parseEnd",
-    apply: "build",
-    moduleParsed(module) {
-      const id = module.id;
-      if (excludeFn(id)) {
-        return;
+    transform(code, id) {
+      if (!code.includes("/*mf top-level-await placeholder replacement mf*/")) {
+        return null;
       }
-      parseEndSet.add(id);
-      if (parseStartSet.size === parseEndSet.size) {
-        _resolve(1);
+      if (!filterFunction(id)) return null;
+      let ast;
+      try {
+        ast = this.parse(code, {
+          allowReturnOutsideFunction: true
+        });
+      } catch (e) {
+        throw new Error(`${id}: ${e}`);
       }
+      const magicString = new MagicString(code);
+      walk(ast, {
+        enter(node) {
+          if (node.type === 'ExportNamedDeclaration' && node.specifiers) {
+            const exportSpecifiers = node.specifiers.map(specifier => specifier.exported.name);
+            const proxyStatements = exportSpecifiers.map(name => `
+              const __mfproxy__await${name} = await ${name}();
+              const __mfproxy__${name} = () => __mfproxy__await${name};
+            `).join('\n');
+            const exportStatements = exportSpecifiers.map(name => `__mfproxy__${name} as ${name}`).join(', ');
+            const start = node.start;
+            const end = node.end;
+            const replacement = `${proxyStatements}\nexport { ${exportStatements} };`;
+            magicString.overwrite(start, end, replacement);
+          }
+          if (node.type === 'ExportDefaultDeclaration') {
+            const declaration = node.declaration;
+            const start = node.start;
+            const end = node.end;
+            let proxyStatement;
+            let exportStatement = 'default';
+            if (declaration.type === 'Identifier') {
+              // example: export default foo;
+              proxyStatement = `
+                const __mfproxy__awaitdefault = await ${declaration.name}();
+                const __mfproxy__default = __mfproxy__awaitdefault;
+              `;
+            } else if (declaration.type === 'CallExpression' || declaration.type === 'FunctionDeclaration') {
+              // example: export default someFunction();
+              const declarationCode = code.slice(declaration.start, declaration.end);
+              proxyStatement = `
+                const __mfproxy__awaitdefault = await (${declarationCode});
+                const __mfproxy__default = __mfproxy__awaitdefault;
+              `;
+            } else {
+              // other
+              proxyStatement = `
+                const __mfproxy__awaitdefault = await (${code.slice(declaration.start, declaration.end)});
+                const __mfproxy__default = __mfproxy__awaitdefault;
+              `;
+            }
+            const replacement = `${proxyStatement}\nexport { __mfproxy__default as ${exportStatement} };`;
+            magicString.overwrite(start, end, replacement);
+          }
+        }
+      });
+      return {
+        code: magicString.toString(),
+        map: magicString.generateMap({
+          hires: true
+        })
+      };
     }
-  }];
+  };
 }
 
 function normalizeExposesItem(key, item) {
@@ -178,7 +220,7 @@ function normalizeRemoteItem(key, remote) {
     entryGlobalName: key
   }, remote);
 }
-function removePathFromNpmPackage$1(packageString) {
+function removePathFromNpmPackage(packageString) {
   // 匹配npm包名的正则表达式，忽略路径部分
   const regex = /^(?:@[^/]+\/)?[^/]+/;
   // 使用正则表达式匹配并提取包名
@@ -189,7 +231,7 @@ function removePathFromNpmPackage$1(packageString) {
 function normalizeShareItem(key, shareItem) {
   let version;
   try {
-    version = require(path.join(removePathFromNpmPackage$1(key), 'package.json')).version;
+    version = require(path.join(removePathFromNpmPackage(key), 'package.json')).version;
   } catch (e) {
     console.log(e);
   }
@@ -237,10 +279,25 @@ function normalizeLibrary(library) {
   if (!library) return undefined;
   return library;
 }
+function normalizeManifest(manifest = false) {
+  if (typeof manifest === "boolean") {
+    return manifest;
+  }
+  return Object.assign({
+    filePath: "",
+    disableAssetsAnalyze: false,
+    fileName: "mf-manifest.json"
+  }, manifest);
+}
 let config;
 function getNormalizeModuleFederationOptions() {
   return config;
 }
+function getNormalizeShareItem(key) {
+  const options = getNormalizeModuleFederationOptions();
+  const shareItem = options.shared[removePathFromNpmPackage(key)] || options.shared[removePathFromNpmPackage(key) + "/"];
+  return shareItem;
+}
 function normalizeModuleFederationOptions(options) {
   return config = {
     exposes: normalizeExposes(options.exposes),
@@ -255,7 +312,7 @@ function normalizeModuleFederationOptions(options) {
     runtimePlugins: options.runtimePlugins || [],
     getPublicPath: options.getPublicPath,
     implementation: options.implementation,
-    manifest: options.manifest,
+    manifest: normalizeManifest(options.manifest),
     dev: options.dev,
     dts: options.dts
   };
@@ -270,33 +327,43 @@ function normalizeModuleFederationOptions(options) {
  *  . => 4
  */
 /**
- * @param {*} name "@scope/xx-xx.xx" => "__$1__scope__$2__xx__$3__xx$__4__xx"
+ * Encodes a package name into a valid file name.
+ * @param {string} name - The package name, e.g., "@scope/xx-xx.xx".
+ * @returns {string} - The encoded file name.
  */
 function packageNameEncode(name) {
   if (typeof name !== "string") throw new Error("A string package name is required");
-  return name.replace(/\@/g, "__$1__").replace(/\//g, "__$2__").replace(/\-/g, "__$3__").replace(/\./g, "__$4__");
+  return name.replace(/@/g, "_mf_0_").replace(/\//g, "_mf_1_").replace(/-/g, "_mf_2_").replace(/\./g, "_mf_3_");
 }
 /**
- * @param {*} global "__$1__scope__$2__xx__$3__xx$__4__xx" => "@scope/xx-xx.xx"
+ * Decodes an encoded file name back to the original package name.
+ * @param {string} encoded - The encoded file name, e.g., "_mf_0_scope_mf_1_xx_mf_2_xx_mf_3_xx".
+ * @returns {string} - The decoded package name.
  */
-function packageNameDecode(global) {
-  if (typeof global !== "string") throw new Error("A string global variable name is required");
-  return global.replace(/\_\_\$1\_\_/g, "@").replace(/\_\_\$2\_\_/g, "/").replace(/\_\_\$3\_\_/g, "-").replace(/\_\_\$4\_\_/g, ".");
+function packageNameDecode(encoded) {
+  if (typeof encoded !== "string") throw new Error("A string encoded file name is required");
+  return encoded.replace(/_mf_0_/g, "@").replace(/_mf_1_/g, "/").replace(/_mf_2_/g, "-").replace(/_mf_3_/g, ".");
 }
-function removePathFromNpmPackage(packageString) {
-  // Regular expression to match npm package name, ignoring path parts
-  const regex = /^(?:@[^/]+\/)?[^/]+/;
-  // Use regular expression to match and extract the package name
-  const match = packageString.match(regex);
-  // Return the matched package name or the original string if no match is found
-  return match ? match[0] : packageString;
+
+/**
+ * https://github.com/module-federation/vite/issues/68
+ */
+function getLocalSharedImportMapPath_windows() {
+  const {
+    name
+  } = getNormalizeModuleFederationOptions();
+  return path__default.resolve(".__mf__win", packageNameEncode(name), "localSharedImportMap");
 }
-function getExtFromNpmPackage(packageString) {
-  const pkgName = removePathFromNpmPackage(packageString);
-  const subpath = packageString.replace(pkgName, "");
-  const parts = subpath.split('.');
-  const ext = parts.length > 1 ? "." + parts.pop() : undefined;
-  return ext;
+function writeLocalSharedImportMap_windows(content) {
+  const localSharedImportMapId = getLocalSharedImportMapPath_windows();
+  createFile(localSharedImportMapId + ".js", "\n// Windows temporarily needs this file, https://github.com/module-federation/vite/issues/68\n" + content);
+}
+function createFile(filePath, content) {
+  const dir = path__default.dirname(filePath);
+  mkdirSync(dir, {
+    recursive: true
+  });
+  writeFileSync(filePath, content);
 }
 
 const nodeModulesDir = function findNodeModulesDir(startDir = process.cwd()) {
@@ -319,25 +386,38 @@ writeFileSync(resolve(nodeModulesDir, virtualPackageName, "package.json"), JSON.
   name: virtualPackageName,
   main: "empty.js"
 }));
+const patternMap = {};
+const cacheMap = {};
 /**
  * Physically generate files as virtual modules under node_modules/__mf__virtual/*
  */
 class VirtualModule {
-  constructor(name, ext = ".js") {
-    this.originName = void 0;
+  static findModule(tag, str = "") {
+    if (!patternMap[tag]) patternMap[tag] = new RegExp(`(.*${packageNameEncode(tag)}(.+?)${packageNameEncode(tag)}.*)`);
+    const moduleName = (str.match(patternMap[tag]) || [])[2];
+    if (moduleName) return cacheMap[tag][packageNameDecode(moduleName)];
+    return undefined;
+  }
+  constructor(name, tag = '__mf_v__', suffix = "") {
+    var _name$split$slice$pop;
+    this.name = void 0;
+    this.tag = void 0;
+    this.suffix = void 0;
     this.inited = false;
-    this.ext = void 0;
-    this.originName = name;
-    this.ext = ext;
+    this.name = name;
+    this.tag = tag;
+    this.suffix = suffix || ((_name$split$slice$pop = name.split(".").slice(1).pop()) == null ? void 0 : _name$split$slice$pop.replace(/(.)/, ".$1")) || ".js";
+    if (!cacheMap[this.tag]) cacheMap[this.tag] = {};
+    cacheMap[this.tag][this.name] = this;
   }
   getPath() {
     return resolve(nodeModulesDir, this.getImportId());
   }
   getImportId() {
     const {
-      name
+      name: mfName
     } = getNormalizeModuleFederationOptions();
-    return `${virtualPackageName}/${packageNameEncode(name)}-${packageNameEncode(this.originName)}${this.ext}`;
+    return `${virtualPackageName}/${packageNameEncode(`${mfName}${this.tag}${this.name}${this.tag}`)}${this.suffix}`;
   }
   writeSync(code, force) {
     if (!force && this.inited) return;
@@ -351,25 +431,50 @@ class VirtualModule {
   }
 }
 
-/**
- * https://github.com/module-federation/vite/issues/68
- */
-function getLocalSharedImportMapPath_windows() {
-  const {
-    name
-  } = getNormalizeModuleFederationOptions();
-  return path__default.resolve(".__mf__win", packageNameEncode(name), "localSharedImportMap");
+const virtualRuntimeInitStatus = new VirtualModule("runtimeInit");
+function writeRuntimeInitStatus() {
+  virtualRuntimeInitStatus.writeSync(`
+    let initResolve, initReject
+    const initPromise = new Promise((re, rj) => {
+      initResolve = re
+      initReject = rj
+    })
+    export {
+      initPromise,
+      initResolve,
+      initReject
+    }
+    `);
 }
-function writeLocalSharedImportMap_windows(content) {
-  const localSharedImportMapId = getLocalSharedImportMapPath_windows();
-  createFile(localSharedImportMapId + ".js", "\n// Windows temporarily needs this file, https://github.com/module-federation/vite/issues/68\n" + content);
+
+const cacheRemoteMap = {};
+const LOAD_REMOTE_TAG = '__loadRemote__';
+function getRemoteVirtualModule(remote, command) {
+  if (!cacheRemoteMap[remote]) {
+    cacheRemoteMap[remote] = new VirtualModule(remote, LOAD_REMOTE_TAG, ".js");
+    cacheRemoteMap[remote].writeSync(generateRemotes(remote, command));
+  }
+  const virtual = cacheRemoteMap[remote];
+  return virtual;
 }
-function createFile(filePath, content) {
-  const dir = path__default.dirname(filePath);
-  mkdirSync(dir, {
-    recursive: true
-  });
-  writeFileSync(filePath, content);
+const usedRemotesMap = {
+  // remote1: {remote1/App, remote1, remote1/Button}
+};
+function addUsedRemote(remoteKey, remoteModule) {
+  if (!usedRemotesMap[remoteKey]) usedRemotesMap[remoteKey] = new Set();
+  usedRemotesMap[remoteKey].add(remoteModule);
+}
+function getUsedRemotesMap() {
+  return usedRemotesMap;
+}
+function generateRemotes(id, command) {
+  return `
+    const {loadRemote} = require("@module-federation/runtime")
+    const {initPromise} = require("${virtualRuntimeInitStatus.getImportId()}")
+    const res = initPromise.then(_ => loadRemote(${JSON.stringify(id)}))
+    const exportModule = ${command !== "build" ? "/*mf top-level-await placeholder replacement mf*/" : "await "}initPromise.then(_ => res)
+    module.exports = exportModule
+  `;
 }
 
 /**
@@ -381,17 +486,47 @@ function createFile(filePath, content) {
 const preBuildCacheMap = {};
 const PREBUILD_TAG = "__prebuild__";
 function writePreBuildLibPath(pkg) {
-  if (!preBuildCacheMap[pkg]) preBuildCacheMap[pkg] = new VirtualModule(PREBUILD_TAG + pkg, getExtFromNpmPackage(pkg));
+  if (!preBuildCacheMap[pkg]) preBuildCacheMap[pkg] = new VirtualModule(pkg, PREBUILD_TAG);
   preBuildCacheMap[pkg].writeSync("");
 }
 function getPreBuildLibImportId(pkg) {
-  if (!preBuildCacheMap[pkg]) preBuildCacheMap[pkg] = new VirtualModule(PREBUILD_TAG + pkg, getExtFromNpmPackage(pkg));
+  if (!preBuildCacheMap[pkg]) preBuildCacheMap[pkg] = new VirtualModule(pkg, PREBUILD_TAG);
   const importId = preBuildCacheMap[pkg].getImportId();
   return importId;
 }
-let shareds = new Set();
-function addShare(pkg) {
-  shareds.add(pkg);
+// *** __loadShare__
+const LOAD_SHARE_TAG = "__loadShare__";
+const loadShareCacheMap = {};
+function getLoadShareModulePath(pkg) {
+  if (!loadShareCacheMap[pkg]) loadShareCacheMap[pkg] = new VirtualModule(pkg, LOAD_SHARE_TAG, ".js");
+  const filepath = loadShareCacheMap[pkg].getPath();
+  return filepath;
+}
+function writeLoadShareModule(pkg, shareItem, command) {
+  loadShareCacheMap[pkg].writeSync(`
+    
+    ;() => import(${JSON.stringify(getPreBuildLibImportId(pkg))}).catch(() => {});
+    // dev uses dynamic import to separate chunks
+    ${command !== "build" ? `;() => import(${JSON.stringify(pkg)}).catch(() => {});` : ''}
+    const {loadShare} = require("@module-federation/runtime")
+    const {initPromise} = require("${virtualRuntimeInitStatus.getImportId()}")
+    const res = initPromise.then(_ => loadShare(${JSON.stringify(pkg)}, {
+    customShareInfo: {shareConfig:{
+      singleton: ${shareItem.shareConfig.singleton},
+      strictVersion: ${shareItem.shareConfig.strictVersion},
+      requiredVersion: ${JSON.stringify(shareItem.shareConfig.requiredVersion)}
+    }}}))
+    const exportModule = ${command !== "build" ? "/*mf top-level-await placeholder replacement mf*/" : "await "}res.then(factory => factory())
+    module.exports = exportModule
+  `);
+}
+
+let usedShares = new Set();
+function getUsedShares() {
+  return usedShares;
+}
+function addUsedShares(pkg) {
+  usedShares.add(pkg);
 }
 // *** Expose locally provided shared modules here
 const localSharedImportMapModule = new VirtualModule("localSharedImportMap");
@@ -401,32 +536,32 @@ function getLocalSharedImportMapPath() {
   }
   return localSharedImportMapModule.getPath();
 }
-let prevSharedCount = 0;
-async function writeLocalSharedImportMap() {
-  const sharedCount = shareds.size;
+let prevSharedCount;
+function writeLocalSharedImportMap() {
+  const sharedCount = getUsedShares().size;
   if (prevSharedCount !== sharedCount) {
     prevSharedCount = sharedCount;
     if (process.platform === "win32") {
-      return writeLocalSharedImportMap_windows(await generateLocalSharedImportMap());
+      writeLocalSharedImportMap_windows(generateLocalSharedImportMap());
+    } else {
+      localSharedImportMapModule.writeSync(generateLocalSharedImportMap(), true);
     }
-    return localSharedImportMapModule.writeSync(await generateLocalSharedImportMap(), true);
   }
 }
-async function generateLocalSharedImportMap() {
-  await parsePromise;
+function generateLocalSharedImportMap() {
   const options = getNormalizeModuleFederationOptions();
   return `
-    const localSharedImportMap = {
-      ${Array.from(shareds).map(pkg => `
+    const importMap = {
+      ${Array.from(getUsedShares()).map(pkg => `
         ${JSON.stringify(pkg)}: async () => {
           let pkg = await import("${getPreBuildLibImportId(pkg)}")
           return pkg
         }
       `).join(",")}
     }
-      const localShared = {
-      ${Array.from(shareds).map(key => {
-    const shareItem = options.shared[removePathFromNpmPackage(key)] || options.shared[removePathFromNpmPackage(key) + "/"];
+      const usedShared = {
+      ${Array.from(getUsedShares()).map(key => {
+    const shareItem = getNormalizeShareItem(key);
     return `
           ${JSON.stringify(key)}: {
             name: ${JSON.stringify(key)},
@@ -435,8 +570,8 @@ async function generateLocalSharedImportMap() {
             loaded: false,
             from: ${JSON.stringify(options.name)},
             async get () {
-              localShared[${JSON.stringify(key)}].loaded = true
-              const {${JSON.stringify(key)}: pkgDynamicImport} = localSharedImportMap 
+              usedShared[${JSON.stringify(key)}].loaded = true
+              const {${JSON.stringify(key)}: pkgDynamicImport} = importMap 
               const res = await pkgDynamicImport()
               const exportModule = {...res}
               // All npm packages pre-built by vite will be converted to esm
@@ -456,40 +591,29 @@ async function generateLocalSharedImportMap() {
         `;
   }).join(',')}
     }
-      export default localShared
+      const usedRemotes = [${Object.keys(getUsedRemotesMap()).map(key => {
+    const remote = options.remotes[key];
+    return `
+                {
+                  entryGlobalName: ${JSON.stringify(remote.entryGlobalName)},
+                  name: ${JSON.stringify(remote.name)},
+                  type: ${JSON.stringify(remote.type)},
+                  entry: ${JSON.stringify(remote.entry)},
+                }
+          `;
+  }).join(',')}
+      ]
+      export {
+        usedShared,
+        usedRemotes
+      }
       `;
 }
-// *** __loadShare__
-const LOAD_SHARE_TAG = "__loadShare__";
-const loadShareCacheMap = {};
-function getLoadShareModulePath(pkg) {
-  if (!loadShareCacheMap[pkg]) loadShareCacheMap[pkg] = new VirtualModule(LOAD_SHARE_TAG + pkg);
-  const filepath = loadShareCacheMap[pkg].getPath();
-  return filepath;
-}
-function writeLoadShareModule(pkg, shareItem, command) {
-  loadShareCacheMap[pkg].writeSync(`
-    () => import(${JSON.stringify(getPreBuildLibImportId(pkg))}).catch(() => {});
-    // dev uses dynamic import to separate chunks
-    ${command !== "build" ? `;() => import(${JSON.stringify(pkg)}).catch(() => {});` : ''}
-    const {loadShare} = require("@module-federation/runtime")
-    const res = loadShare(${JSON.stringify(pkg)}, {
-    customShareInfo: {shareConfig:{
-      singleton: ${shareItem.shareConfig.singleton},
-      strictVersion: ${shareItem.shareConfig.strictVersion},
-      requiredVersion: ${JSON.stringify(shareItem.shareConfig.requiredVersion)}
-    }}})
-    const exportModule = ${command !== "build" ? "/*mf top-level-await placeholder replacement mf*/" : "await "}res.then(factory => factory())
-    module.exports = exportModule
-  `);
-}
-
-const REMOTE_ENTRY_ID = 'REMOTE_ENTRY_ID';
+const REMOTE_ENTRY_ID = 'virtual:mf-REMOTE_ENTRY_ID';
 function generateRemoteEntry(options) {
   const pluginImportNames = options.runtimePlugins.map((p, i) => [`$runtimePlugin_${i}`, `import $runtimePlugin_${i} from "${p}";`]);
   return `
   import {init as runtimeInit, loadRemote} from "@module-federation/runtime";
-  
   ${pluginImportNames.map(item => item[1]).join('\n')}
 
   const exposesMap = {
@@ -508,26 +632,19 @@ function generateRemoteEntry(options) {
       `;
   }).join(',')}
   }
-  import localSharedImportMap from "${getLocalSharedImportMapPath()}"
+  import {usedShared, usedRemotes} from "${getLocalSharedImportMapPath()}"
+  import {
+    initResolve
+  } from "${virtualRuntimeInitStatus.getImportId()}"
   async function init(shared = {}) {
     const initRes = runtimeInit({
       name: ${JSON.stringify(options.name)},
-      remotes: [${Object.keys(options.remotes).map(key => {
-    const remote = options.remotes[key];
-    return `
-                {
-                  entryGlobalName: ${JSON.stringify(remote.entryGlobalName)},
-                  name: ${JSON.stringify(remote.name)},
-                  type: ${JSON.stringify(remote.type)},
-                  entry: ${JSON.stringify(remote.entry)},
-                }
-          `;
-  }).join(',')}
-      ],
-      shared: localSharedImportMap,
+      remotes: usedRemotes,
+      shared: usedShared,
       plugins: [${pluginImportNames.map(item => `${item[0]}()`).join(', ')}]
     });
     initRes.initShareScopeMap('${options.shareScope}', shared);
+    initResolve(initRes)
     return initRes
   }
 
@@ -541,19 +658,6 @@ function generateRemoteEntry(options) {
   }
   `;
 }
-const wrapRemoteEntryModule = new VirtualModule("wrapRemoteEntry");
-function writeWrapRemoteEntry() {
-  wrapRemoteEntryModule.writeSync(`
-    import {init, get} from "${REMOTE_ENTRY_ID}"
-    export {init, get}
-    `);
-}
-function getWrapRemoteEntryImportId() {
-  return wrapRemoteEntryModule.getImportId();
-}
-function getWrapRemoteEntryPath() {
-  return wrapRemoteEntryModule.getPath();
-}
 /**
  * Inject entry file, automatically init when used as host,
  * and will not inject remoteEntry
@@ -572,37 +676,374 @@ function getHostAutoInitPath() {
   return hostAutoInitModule.getPath();
 }
 
-const remoteVirtualModule = new VirtualModule("remoteModule");
-function writeRemote() {
-  remoteVirtualModule.writeSync("");
-}
-function generateRemotes(id, command) {
-  return {
-    code: `
-    import {loadRemote} from "@module-federation/runtime"
-    const exportModule = await loadRemote(${JSON.stringify(id)})
-    ${command === "build" && `
-        export default 'default' in (exportModule || {}) ? exportModule.default : undefined
-        export const __mf__dynamicExports = exportModule
-        ` || ""}
-      ${command !== "build" && `
-        export default exportModule
-        ` || ""}
-  `,
-    map: null,
-    // TODO: vite dev mode invalid, use optimizeDeps.needsInterop
-    syntheticNamedExports: '__mf__dynamicExports'
-  };
-}
-
 function initVirtualModules() {
   writeLocalSharedImportMap();
-  writeWrapRemoteEntry();
   writeHostAutoInit();
-  writeRemote();
+  writeRuntimeInitStatus();
 }
 
-const filter$1 = createFilter();
+const Manifest = () => {
+  const mfOptions = getNormalizeModuleFederationOptions();
+  const {
+    name,
+    filename,
+    manifest: manifestOptions
+  } = mfOptions;
+  let mfManifestName = "";
+  if (manifestOptions === true) {
+    mfManifestName = "mf-manifest.json";
+  }
+  if (typeof manifestOptions !== "boolean") {
+    mfManifestName = join((manifestOptions == null ? void 0 : manifestOptions.filePath) || "", (manifestOptions == null ? void 0 : manifestOptions.fileName) || "");
+  }
+  let extensions;
+  let root;
+  let remoteEntryFile;
+  return [{
+    name: 'moddule-federation-manifest',
+    apply: 'serve',
+    configureServer(server) {
+      server.middlewares.use((req, res, next) => {
+        if (!mfManifestName) {
+          next();
+          return;
+        }
+        if (req.url === mfManifestName.replace(/^\/?/, "/")) {
+          res.setHeader('Content-Type', 'application/json');
+          res.setHeader('Access-Control-Allow-Origin', '*');
+          res.end(JSON.stringify({
+            id: name,
+            name: name,
+            metaData: {
+              name: name,
+              type: 'app',
+              buildInfo: {
+                buildVersion: '1.0.0',
+                buildName: name
+              },
+              remoteEntry: {
+                name: filename,
+                path: '',
+                type: 'module'
+              },
+              ssrRemoteEntry: {
+                name: filename,
+                path: '',
+                type: 'module'
+              },
+              types: {
+                path: '',
+                name: ''
+              },
+              globalName: name,
+              pluginVersion: '0.2.5',
+              publicPath: 'auto'
+            },
+            shared: Array.from(getUsedShares()).map(shareKey => {
+              const shareItem = getNormalizeShareItem(shareKey);
+              return {
+                id: `${name}:${shareKey}`,
+                name: shareKey,
+                version: shareItem.version,
+                requiredVersion: shareItem.shareConfig.requiredVersion,
+                assets: {
+                  js: {
+                    async: [],
+                    sync: []
+                  },
+                  css: {
+                    async: [],
+                    sync: []
+                  }
+                }
+              };
+            }),
+            remotes: function () {
+              const remotes = [];
+              const usedRemotesMap = getUsedRemotesMap();
+              Object.keys(usedRemotesMap).forEach(remoteKey => {
+                const usedModules = Array.from(usedRemotesMap[remoteKey]);
+                usedModules.forEach(moduleKey => {
+                  remotes.push({
+                    federationContainerName: mfOptions.remotes[remoteKey].entry,
+                    moduleName: moduleKey.replace(remoteKey, '').replace('/', ''),
+                    alias: remoteKey,
+                    entry: '*'
+                  });
+                });
+              });
+              return remotes;
+            }(),
+            exposes: Object.keys(mfOptions.exposes).map(key => {
+              const formatKey = key.replace('./', '');
+              return {
+                id: name + ':' + formatKey,
+                name: formatKey,
+                assets: {
+                  js: {
+                    async: [],
+                    sync: []
+                  },
+                  css: {
+                    sync: [],
+                    async: []
+                  }
+                },
+                path: key
+              };
+            })
+          }));
+        } else {
+          next();
+        }
+      });
+    }
+  }, {
+    name: 'moddule-federation-manifest',
+    enforce: 'post',
+    config(config) {
+      if (!config.build) config.build = {};
+      if (!config.build.manifest) config.build.manifest = config.build.manifest || !!manifestOptions;
+    },
+    configResolved(config) {
+      root = config.root;
+      extensions = config.resolve.extensions || ['.mjs', '.js', '.mts', '.ts', '.jsx', '.tsx', '.json'];
+    },
+    async generateBundle(options, bundle) {
+      if (!mfManifestName) return;
+      const exposesModules = Object.keys(mfOptions.exposes).map(item => mfOptions.exposes[item].import); // 获取你提供的 moduleIds
+      const filesContainingModules = {};
+      // 帮助函数：检查模块路径是否匹配
+      const isModuleMatched = (relativeModulePath, preloadModule) => {
+        // 先尝试直接匹配
+        if (relativeModulePath === preloadModule) return true;
+        // 如果 preloadModule 没有后缀，尝试添加可能的后缀进行匹配
+        for (const ext of extensions) {
+          if (relativeModulePath === `${preloadModule}${ext}`) {
+            return true;
+          }
+        }
+        return false;
+      };
+      // 遍历打包生成的每个文件
+      for (const [fileName, fileData] of Object.entries(bundle)) {
+        if (mfOptions.filename.replace(/[\[\]]/g, "_") === fileData.name) {
+          remoteEntryFile = fileData.fileName;
+        }
+        if (fileData.type === 'chunk') {
+          // 遍历该文件的所有模块
+          for (const modulePath of Object.keys(fileData.modules)) {
+            // 将绝对路径转换为相对于 Vite root 的相对路径
+            const relativeModulePath = relative(root, modulePath);
+            // 检查模块是否在 preloadModules 列表中
+            for (const preloadModule of exposesModules) {
+              const formatPreloadModule = preloadModule.replace("./", "");
+              if (isModuleMatched(relativeModulePath, formatPreloadModule)) {
+                if (!filesContainingModules[preloadModule]) {
+                  filesContainingModules[preloadModule] = {
+                    sync: [],
+                    async: []
+                  };
+                }
+                console.log(Object.keys(fileData.modules));
+                filesContainingModules[preloadModule].sync.push(fileName);
+                filesContainingModules[preloadModule].async.push(...(fileData.dynamicImports || []));
+                findSynchronousImports(fileName, filesContainingModules[preloadModule].sync);
+                break; // 如果找到匹配，跳出循环
+              }
+            }
+          }
+        }
+      }
+      // 递归查找模块的同步导入文件
+      function findSynchronousImports(fileName, array) {
+        const fileData = bundle[fileName];
+        if (fileData && fileData.type === 'chunk') {
+          array.push(fileName); // 将当前文件加入预加载列表
+          // 遍历该文件的同步导入文件
+          fileData.imports.forEach(importedFile => {
+            if (array.indexOf(importedFile) === -1) {
+              findSynchronousImports(importedFile, array); // 递归查找同步导入的文件
+            }
+          });
+        }
+      }
+      const fileToShareKey = {};
+      await Promise.all(Array.from(getUsedShares()).map(async shareKey => {
+        const file = (await this.resolve(getPreBuildLibImportId(shareKey))).id.split("?")[0];
+        fileToShareKey[file] = shareKey;
+      }));
+      // 遍历打包生成的每个文件
+      for (const [fileName, fileData] of Object.entries(bundle)) {
+        if (fileData.type === 'chunk') {
+          // 遍历该文件的所有模块
+          for (const modulePath of Object.keys(fileData.modules)) {
+            const sharedKey = fileToShareKey[modulePath];
+            if (sharedKey) {
+              if (!filesContainingModules[sharedKey]) {
+                filesContainingModules[sharedKey] = {
+                  sync: [],
+                  async: []
+                };
+              }
+              filesContainingModules[sharedKey].sync.push(fileName);
+              filesContainingModules[sharedKey].async.push(...(fileData.dynamicImports || []));
+              findSynchronousImports(fileName, filesContainingModules[sharedKey].sync);
+              break; // 如果找到匹配，跳出循环
+            }
+          }
+        }
+      }
+      Object.keys(filesContainingModules).forEach(key => {
+        filesContainingModules[key].sync = Array.from(new Set(filesContainingModules[key].sync));
+        filesContainingModules[key].async = Array.from(new Set(filesContainingModules[key].async));
+      });
+      this.emitFile({
+        type: 'asset',
+        fileName: mfManifestName,
+        source: generateMFManifest(filesContainingModules)
+      });
+    }
+  }];
+  function generateMFManifest(preloadMap) {
+    const options = getNormalizeModuleFederationOptions();
+    const {
+      name
+    } = options;
+    const remoteEntry = {
+      name: remoteEntryFile,
+      path: '',
+      type: 'module'
+    };
+    const remotes = [];
+    const usedRemotesMap = getUsedRemotesMap();
+    Object.keys(usedRemotesMap).forEach(remoteKey => {
+      const usedModules = Array.from(usedRemotesMap[remoteKey]);
+      usedModules.forEach(moduleKey => {
+        remotes.push({
+          federationContainerName: options.remotes[remoteKey].entry,
+          moduleName: moduleKey.replace(remoteKey, '').replace('/', ''),
+          alias: remoteKey,
+          entry: '*'
+        });
+      });
+    });
+    // @ts-ignore
+    const shared = Array.from(getUsedShares()).map(shareKey => {
+      // assets(.css, .jpg, .svg等)其他资源, 不重要, 暂未处理
+      if (!preloadMap[shareKey]) return;
+      const shareItem = getNormalizeShareItem(shareKey);
+      return {
+        id: `${name}:${shareKey}`,
+        name: shareKey,
+        version: shareItem.version,
+        requiredVersion: shareItem.shareConfig.requiredVersion,
+        assets: {
+          js: {
+            async: preloadMap[shareKey].async,
+            sync: preloadMap[shareKey].sync
+          },
+          css: {
+            async: [],
+            sync: []
+          }
+        }
+      };
+    }).filter(item => item);
+    const exposes = Object.keys(options.exposes).map(key => {
+      // assets(.css, .jpg, .svg等)其他资源, 不重要, 暂未处理
+      const formatKey = key.replace('./', '');
+      const sourceFile = options.exposes[key].import;
+      if (!preloadMap[sourceFile]) return;
+      return {
+        id: name + ':' + formatKey,
+        name: formatKey,
+        assets: {
+          js: {
+            async: preloadMap[sourceFile].async,
+            sync: preloadMap[sourceFile].sync
+          },
+          css: {
+            sync: [],
+            async: []
+          }
+        },
+        path: key
+      };
+    }).filter(item => item); // Filter out any null values
+    const result = {
+      id: name,
+      name: name,
+      metaData: {
+        name: name,
+        type: 'app',
+        buildInfo: {
+          buildVersion: '1.0.0',
+          buildName: name
+        },
+        remoteEntry,
+        ssrRemoteEntry: remoteEntry,
+        types: {
+          path: '',
+          name: ''
+          // "zip": "@mf-types.zip",
+          // "api": "@mf-types.d.ts"
+        },
+        globalName: name,
+        pluginVersion: '0.2.5',
+        publicPath: 'auto'
+      },
+      shared,
+      remotes,
+      exposes
+    };
+    return JSON.stringify(result);
+  }
+};
+
+let _resolve,
+  promise = new Promise((resolve, reject) => {
+    _resolve = resolve;
+  });
+let parsePromise = promise;
+const parseStartSet = new Set();
+const parseEndSet = new Set();
+function pluginModuleParseEnd (excludeFn) {
+  return [{
+    name: "_",
+    apply: "serve",
+    config() {
+      // No waiting in development mode
+      _resolve(1);
+    }
+  }, {
+    enforce: "pre",
+    name: "parseStart",
+    apply: "build",
+    load(id) {
+      if (excludeFn(id)) {
+        return;
+      }
+      parseStartSet.add(id);
+    }
+  }, {
+    enforce: "post",
+    name: "parseEnd",
+    apply: "build",
+    moduleParsed(module) {
+      const id = module.id;
+      if (excludeFn(id)) {
+        return;
+      }
+      parseEndSet.add(id);
+      if (parseStartSet.size === parseEndSet.size) {
+        _resolve(1);
+      }
+    }
+  }];
+}
+
+const filter = createFilter();
 function pluginProxyRemoteEntry () {
   return {
     name: 'proxyRemoteEntry',
@@ -614,56 +1055,40 @@ function pluginProxyRemoteEntry () {
     },
     load(id) {
       if (id === REMOTE_ENTRY_ID) {
-        return generateRemoteEntry(getNormalizeModuleFederationOptions());
+        return parsePromise.then(_ => generateRemoteEntry(getNormalizeModuleFederationOptions()));
       }
     },
     async transform(code, id) {
-      if (!filter$1(id)) return;
+      if (!filter(id)) return;
       if (id.includes(REMOTE_ENTRY_ID)) {
-        return generateRemoteEntry(getNormalizeModuleFederationOptions());
+        return parsePromise.then(_ => generateRemoteEntry(getNormalizeModuleFederationOptions()));
       }
     }
   };
 }
 
-const filter = createFilter();
+createFilter();
 function pluginProxyRemotes (options) {
-  let command;
   const {
     remotes
   } = options;
-  const matchRemotesList = Object.keys(remotes).map(item => item.replace(/\//g, "_"));
   return {
     name: "proxyRemotes",
     config(config, {
       command: _command
     }) {
-      command = _command;
       Object.keys(remotes).forEach(key => {
         const remote = remotes[key];
         config.resolve.alias.push({
-          find: new RegExp(`(${remote.name}(\/.*|$)?)`),
-          replacement: '$1',
+          find: new RegExp(`^(${remote.name}(\/.*|$))`),
+          replacement: "$1",
           customResolver(source) {
-            const requestPath = remoteVirtualModule.getImportId() + '?__moduleRemote__=' + encodeURIComponent(source);
-            if (!config.optimizeDeps) config.optimizeDeps = {};
-            if (!config.optimizeDeps.needsInterop) config.optimizeDeps.needsInterop = [];
-            if (config.optimizeDeps.needsInterop.indexOf(requestPath) === -1) config.optimizeDeps.needsInterop.push(requestPath);
-            return this.resolve(requestPath);
+            const remoteModule = getRemoteVirtualModule(source, _command);
+            addUsedRemote(remote.name, source);
+            return remoteModule.getPath();
           }
         });
       });
-    },
-    async transform(code, id) {
-      if (!filter(id)) return;
-      let [devRemoteModuleName] = matchRemotesList.length && id.match(new RegExp(`\/(${matchRemotesList.join('|')})(\_.*\.js|\.js)`)) || [];
-      if (devRemoteModuleName) {
-        return generateRemotes(devRemoteModuleName.replace('/', '').replace(/_/g, '/').replace('.js', ''), command);
-      }
-      let [prodRemoteName] = id.match(/\_\_moduleRemote\_\_=[^&]+/) || [];
-      if (prodRemoteName) {
-        return generateRemotes(decodeURIComponent(prodRemoteName.replace('__moduleRemote__=', '')), command);
-      }
     }
   };
 }
@@ -702,42 +1127,23 @@ class PromiseStore {
   }
 }
 
-function wrapManualChunks(output, manualChunksCb) {
-  if (!output.manualChunks) output.manualChunks = {};
-  const wrapManualChunks = original => (id, ...args) => {
-    const customRes = manualChunksCb == null ? void 0 : manualChunksCb(id, ...args);
-    if (customRes) return customRes;
-    if (typeof original === 'function') {
-      return original(id, ...args);
-    }
-    if (typeof original === 'object' && original) {
-      return original[id];
-    }
-  };
-  output.manualChunks = wrapManualChunks(output.manualChunks);
-}
-
 function proxySharedModule(options) {
   let {
     shared = {},
     include,
     exclude
   } = options;
-  const filterFunction = createFilter(include, exclude);
   return [{
     name: "generateLocalSharedImportMap",
     enforce: "post",
-    resolveId(id) {
-      if (id.includes(getLocalSharedImportMapPath())) return id;
-    },
     load(id) {
       if (id.includes(getLocalSharedImportMapPath())) {
-        return generateLocalSharedImportMap();
+        return parsePromise.then(_ => generateLocalSharedImportMap());
       }
     },
     transform(code, id) {
       if (id.includes(getLocalSharedImportMapPath())) {
-        return generateLocalSharedImportMap();
+        return parsePromise.then(_ => generateLocalSharedImportMap());
       }
     }
   }, {
@@ -746,21 +1152,6 @@ function proxySharedModule(options) {
     config(config, {
       command
     }) {
-      if (!config.build) config.build = {};
-      if (!config.build.rollupOptions) config.build.rollupOptions = {};
-      let {
-        rollupOptions
-      } = config.build;
-      if (!rollupOptions.output) rollupOptions.output = {};
-      wrapManualChunks(config.build.rollupOptions.output, id => {
-        // https://github.com/module-federation/vite/issues/40#issuecomment-2311434503
-        if (id.includes('/preload-helper.js')) {
-          return "preload-helper";
-        }
-        if (id.includes("node_modules/@module-federation/runtime")) {
-          return "@module-federation/runtime";
-        }
-      });
       config.resolve.alias.push(...Object.keys(shared).map(key => {
         const pattern = key.endsWith("/") ? `(^${key.replace(/\/$/, "")}(\/.+)?$)` : `(^${key}$)`;
         return {
@@ -768,12 +1159,10 @@ function proxySharedModule(options) {
           find: new RegExp(pattern),
           replacement: "$1",
           customResolver(source, importer) {
-            var _config$optimizeDeps;
             const loadSharePath = getLoadShareModulePath(source);
-            config == null || (_config$optimizeDeps = config.optimizeDeps) == null || (_config$optimizeDeps = _config$optimizeDeps.needsInterop) == null || _config$optimizeDeps.push(loadSharePath);
             writeLoadShareModule(source, shared[key], command);
             writePreBuildLibPath(source);
-            addShare(source);
+            addUsedShares(source);
             writeLocalSharedImportMap();
             return this.resolve(loadSharePath);
           }
@@ -782,18 +1171,16 @@ function proxySharedModule(options) {
       const savePrebuild = new PromiseStore();
       config.resolve.alias.push(...Object.keys(shared).map(key => {
         return command === "build" ? {
-          find: new RegExp(`(.*${PREBUILD_TAG}(.+))`),
+          find: new RegExp(`(.*${PREBUILD_TAG}.*)`),
           replacement: function ($1) {
-            $1 = $1.replace(/\.[^.]+$/, "");
-            const pkgName = packageNameDecode($1.split(PREBUILD_TAG)[1]);
-            return packageNameDecode(pkgName);
+            const pkgName = VirtualModule.findModule(PREBUILD_TAG, $1).name;
+            return pkgName;
           }
         } : {
-          find: new RegExp(`(.*${PREBUILD_TAG}(.+))`),
+          find: new RegExp(`(.*${PREBUILD_TAG}.*)`),
           replacement: "$1",
           async customResolver(source, importer) {
-            source = source.replace(/\.[^.]+$/, "");
-            const pkgName = packageNameDecode(source.split(PREBUILD_TAG)[1]);
+            const pkgName = VirtualModule.findModule(PREBUILD_TAG, source).name;
             if (importer.includes(LOAD_SHARE_TAG)) {
               // save pre-bunding module id
               savePrebuild.set(pkgName, this.resolve(pkgName).then(item => item.id));
@@ -820,75 +1207,6 @@ function proxySharedModule(options) {
       watch.ignored = [].concat(watch.ignored);
       watch.ignored.push(`!**${getLocalSharedImportMapPath()}**`);
     }
-  }, {
-    name: "prebuild-top-level-await",
-    apply: "serve",
-    transform(code, id) {
-      if (!code.includes("/*mf top-level-await placeholder replacement mf*/")) {
-        return null;
-      }
-      if (!filterFunction(id)) return null;
-      let ast;
-      try {
-        ast = this.parse(code, {
-          allowReturnOutsideFunction: true
-        });
-      } catch (e) {
-        throw new Error(`${id}: ${e}`);
-      }
-      const magicString = new MagicString(code);
-      walk(ast, {
-        enter(node) {
-          if (node.type === 'ExportNamedDeclaration' && node.specifiers) {
-            const exportSpecifiers = node.specifiers.map(specifier => specifier.exported.name);
-            const proxyStatements = exportSpecifiers.map(name => `
-                const __mfproxy__await${name} = await ${name}();
-                const __mfproxy__${name} = () => __mfproxy__await${name};
-              `).join('\n');
-            const exportStatements = exportSpecifiers.map(name => `__mfproxy__${name} as ${name}`).join(', ');
-            const start = node.start;
-            const end = node.end;
-            const replacement = `${proxyStatements}\nexport { ${exportStatements} };`;
-            magicString.overwrite(start, end, replacement);
-          }
-          if (node.type === 'ExportDefaultDeclaration') {
-            const declaration = node.declaration;
-            const start = node.start;
-            const end = node.end;
-            let proxyStatement;
-            let exportStatement = 'default';
-            if (declaration.type === 'Identifier') {
-              // example: export default foo;
-              proxyStatement = `
-                  const __mfproxy__awaitdefault = await ${declaration.name}();
-                  const __mfproxy__default = __mfproxy__awaitdefault;
-                `;
-            } else if (declaration.type === 'CallExpression' || declaration.type === 'FunctionDeclaration') {
-              // example: export default someFunction();
-              const declarationCode = code.slice(declaration.start, declaration.end);
-              proxyStatement = `
-                  const __mfproxy__awaitdefault = await (${declarationCode});
-                  const __mfproxy__default = __mfproxy__awaitdefault;
-                `;
-            } else {
-              // other
-              proxyStatement = `
-                  const __mfproxy__awaitdefault = await (${code.slice(declaration.start, declaration.end)});
-                  const __mfproxy__default = __mfproxy__awaitdefault;
-                `;
-            }
-            const replacement = `${proxyStatement}\nexport { __mfproxy__default as ${exportStatement} };`;
-            magicString.overwrite(start, end, replacement);
-          }
-        }
-      });
-      return {
-        code: magicString.toString(),
-        map: magicString.generateMap({
-          hires: true
-        })
-      };
-    }
   }];
 }
 
@@ -942,16 +1260,16 @@ function federation(mfUserOptions) {
   if (!name) throw new Error("name is required");
   return [aliasToArrayPlugin, normalizeOptimizeDepsPlugin, ...addEntry({
     entryName: 'remoteEntry',
-    entryPath: getWrapRemoteEntryPath(),
+    entryPath: REMOTE_ENTRY_ID,
     fileName: filename
   }), ...addEntry({
     entryName: 'hostInit',
     entryPath: getHostAutoInitPath()
   }), pluginProxyRemoteEntry(), pluginProxyRemotes(options), ...pluginModuleParseEnd(id => {
-    return id.includes(getHostAutoInitImportId()) || id.includes(getWrapRemoteEntryImportId()) || id.includes(REMOTE_ENTRY_ID) || id.includes(getLocalSharedImportMapPath());
+    return id.includes(getHostAutoInitImportId()) || id.includes(REMOTE_ENTRY_ID) || id.includes(getLocalSharedImportMapPath());
   }), ...proxySharedModule({
     shared
-  }), {
+  }), PluginDevProxyModuleTopLevelAwait(), {
     name: 'module-federation-vite',
     enforce: 'post',
     config(config, {
@@ -963,11 +1281,8 @@ function federation(mfUserOptions) {
         replacement: require.resolve('@module-federation/runtime')
       });
       (_config$optimizeDeps = config.optimizeDeps) == null || (_config$optimizeDeps = _config$optimizeDeps.include) == null || _config$optimizeDeps.push('@module-federation/runtime');
-      // Object.keys(shared).forEach((key) => {
-      //   config.optimizeDeps?.include?.push(key);
-      // });
     }
-  }];
+  }, ...Manifest()];
 }
 
 export { federation };