fix: resolve circular deadlock with Vite preload helper and loadShare TLA

The build was hanging due to a circular dependency where:
1. hostInit imports preload helper from a shared chunk
2. That chunk contains loadShare TLA waiting for initPromise
3. initPromise only resolves after remoteEntry.init() is called
4. hostInit can't call init() until the shared chunk loads → DEADLOCK

Changes:
- Isolate vite/preload-helper, vite/modulepreload-polyfill, and
  commonjsHelpers into a separate 'preload-helper' chunk via manualChunks
- Fix shared module alias regex: patterns ending with '/' (e.g., 'react/')
  now correctly match only subpaths ('react/jsx-runtime') and not the
  base package ('react')
- Use globalThis singleton for initPromise to prevent duplicate instances

This ensures the preload helper is available before any TLA-blocked chunks
need to load, breaking the circular dependency.

Author: DallasCarraher

src/index.ts

@@ -15,6 +15,7 @@ import {
 } from './utils/normalizeModuleFederationOptions';
 import normalizeOptimizeDepsPlugin from './utils/normalizeOptimizeDeps';
 import VirtualModule from './utils/VirtualModule';
+// wrapManualChunks not used - direct function assignment is simpler and works better
 import {
   getHostAutoInitImportId,
   getHostAutoInitPath,
@@ -94,6 +95,42 @@ function federation(mfUserOptions: ModuleFederationOptions): Plugin[] {
         config.optimizeDeps?.include?.push(virtualDir);
         config.optimizeDeps?.needsInterop?.push(virtualDir);
         config.optimizeDeps?.needsInterop?.push(getLocalSharedImportMapPath());
+
+        // FIX: Isolate preload helper to prevent deadlock with loadShare TLA
+        // This prevents a circular deadlock where:
+        // 1. hostInit imports preload helper from a shared chunk
+        // 2. That chunk has loadShare TLA waiting for initPromise
+        // 3. initPromise only resolves after remoteEntry.init() is called
+        // 4. But hostInit can't call init() until the shared chunk loads → DEADLOCK
+        if (_command === 'build') {
+          config.build = config.build || {};
+          config.build.rollupOptions = config.build.rollupOptions || {};
+          config.build.rollupOptions.output = config.build.rollupOptions.output || {};
+
+          const output = Array.isArray(config.build.rollupOptions.output)
+            ? config.build.rollupOptions.output[0]
+            : config.build.rollupOptions.output;
+
+          const existingManualChunks = output.manualChunks;
+          output.manualChunks = (id: string, meta: any) => {
+            // Isolate preload helper to prevent deadlock
+            if (
+              id.includes('vite/preload-helper') ||
+              id.includes('vite/modulepreload-polyfill') ||
+              id.includes('commonjsHelpers')
+            ) {
+              return 'preload-helper';
+            }
+            // Call existing manualChunks if it exists
+            if (typeof existingManualChunks === 'function') {
+              return existingManualChunks(id, meta);
+            }
+            if (existingManualChunks && (existingManualChunks as any)[id]) {
+              return (existingManualChunks as any)[id];
+            }
+            return undefined;
+          };
+        }
       },
     },
     ...pluginManifest(),

src/plugins/pluginProxySharedModule_preBuild.ts

@@ -48,9 +48,9 @@ export function proxySharedModule(options: {
       config(config: UserConfig, { command }) {
         (config.resolve as any).alias.push(
           ...Object.keys(shared).map((key) => {
-            const pattern = key.endsWith('/')
-              ? `(^${key.replace(/\/$/, '')}(\/.+)?$)`
-              : `(^${key}$)`;
+            // FIX: When key ends with '/', only match subpaths (e.g., 'react/' matches 'react/jsx-runtime' but NOT 'react')
+            // The previous regex (/.+)? was optional, incorrectly matching the base package too
+            const pattern = key.endsWith('/') ? `(^${key.replace(/\/$/, '')}/.+$)` : `(^${key}$)`;
             return {
               // Intercept all shared requests and proxy them to loadShare
               find: new RegExp(pattern),

src/virtualModules/virtualRuntimeInitStatus.ts

@@ -3,8 +3,6 @@ export const virtualRuntimeInitStatus = new VirtualModule('runtimeInit');
 export function writeRuntimeInitStatus() {
   // Use globalThis singleton to ensure only one initPromise exists
   const globalKey = `__mf_init__${virtualRuntimeInitStatus.getImportId()}__`;
-  // This module is imported by both dev and build modes
-  // We use a dual-export pattern that works with both CJS require() and ESM import
   virtualRuntimeInitStatus.writeSync(`
     const globalKey = ${JSON.stringify(globalKey)}
     if (!globalThis[globalKey]) {
@@ -19,10 +17,6 @@ export function writeRuntimeInitStatus() {
         initReject
       }
     }
-    // Dual exports: CJS for dev mode (require), ESM for build mode (import)
     module.exports = globalThis[globalKey]
-    export const initPromise = globalThis[globalKey].initPromise
-    export const initResolve = globalThis[globalKey].initResolve
-    export const initReject = globalThis[globalKey].initReject
     `);
 }

src/virtualModules/virtualShared_preBuild.ts

@@ -37,37 +37,19 @@ export function getLoadShareModulePath(pkg: string): string {
   return filepath;
 }
 export function writeLoadShareModule(pkg: string, shareItem: ShareItem, command: string) {
-  if (command === 'build') {
-    // Build mode: Use ESM syntax to fix Vite 7/Rolldown compatibility
-    // Rolldown wraps CJS (require + module.exports) in a function, breaking top-level await
-    loadShareCacheMap[pkg].writeSync(`
-      import { initPromise } from "${virtualRuntimeInitStatus.getImportId()}"
-      ;() => import(${JSON.stringify(getPreBuildLibImportId(pkg))}).catch(() => {});
-      const res = initPromise.then(runtime => runtime.loadShare(${JSON.stringify(pkg)}, {
-        customShareInfo: {shareConfig:{
-          singleton: ${shareItem.shareConfig.singleton},
-          strictVersion: ${shareItem.shareConfig.strictVersion},
-          requiredVersion: ${JSON.stringify(shareItem.shareConfig.requiredVersion)}
-        }}
-      }))
-      const exportModule = await res.then(factory => factory())
-      export default exportModule
-    `);
-  } else {
-    // Dev mode: Use original CJS syntax for compatibility with existing plugins
-    loadShareCacheMap[pkg].writeSync(`
-      ;() => import(${JSON.stringify(getPreBuildLibImportId(pkg))}).catch(() => {});
-      ;() => import(${JSON.stringify(pkg)}).catch(() => {});
-      const {initPromise} = require("${virtualRuntimeInitStatus.getImportId()}")
-      const res = initPromise.then(runtime => runtime.loadShare(${JSON.stringify(pkg)}, {
-        customShareInfo: {shareConfig:{
-          singleton: ${shareItem.shareConfig.singleton},
-          strictVersion: ${shareItem.shareConfig.strictVersion},
-          requiredVersion: ${JSON.stringify(shareItem.shareConfig.requiredVersion)}
-        }}
-      }))
-      const exportModule = /*mf top-level-await placeholder replacement mf*/res.then(factory => factory())
-      module.exports = exportModule
-    `);
-  }
+  loadShareCacheMap[pkg].writeSync(`
+    ;() => import(${JSON.stringify(getPreBuildLibImportId(pkg))}).catch(() => {});
+    // dev uses dynamic import to separate chunks
+    ${command !== 'build' ? `;() => import(${JSON.stringify(pkg)}).catch(() => {});` : ''}
+    const {initPromise} = require("${virtualRuntimeInitStatus.getImportId()}")
+    const res = initPromise.then(runtime => runtime.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
+  `);
 }