fix: prevent infinite recursion in importNodeModule functions

- Add import caching to SDK importNodeModule to prevent circular calls
- Add import caching to node runtime plugin importNodeModule
- Add ESM module caching to prevent loadModule recursion
- Use direct dynamic import in vm.Script fallback to avoid cycles
- Add regression test for maximum call stack exceeded scenario

Fixes RangeError: Maximum call stack size exceeded when NextJS apps
use Module Federation with both SDK and node runtime plugin importing
each other's modules through importModuleDynamically callbacks.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: ScriptedAlchemy

packages/node/src/runtimePlugin.ts

@@ -39,17 +39,31 @@ type WebpackRequire = {
 declare const __webpack_require__: WebpackRequire;
 declare const __non_webpack_require__: (id: string) => any;
 
+const nodeRuntimeImportCache = new Map<string, Promise<any>>();
+
 export function importNodeModule<T>(name: string): Promise<T> {
   if (!name) {
     throw new Error('import specifier is required');
   }
+
+  // Check cache to prevent infinite recursion
+  if (nodeRuntimeImportCache.has(name)) {
+    return nodeRuntimeImportCache.get(name)!;
+  }
+
   const importModule = new Function('name', `return import(name)`);
-  return importModule(name)
+  const promise = importModule(name)
     .then((res: any) => res.default as T)
     .catch((error: any) => {
       console.error(`Error importing module ${name}:`, error);
+      // Remove from cache on error so it can be retried
+      nodeRuntimeImportCache.delete(name);
       throw error;
     });
+
+  // Cache the promise to prevent recursive calls
+  nodeRuntimeImportCache.set(name, promise);
+  return promise;
 }
 
 // Hoisted utility function to resolve file paths for chunks
@@ -106,7 +120,15 @@ export const loadFromFs = (
             filename,
             importModuleDynamically:
               //@ts-ignore
-              vm.constants?.USE_MAIN_CONTEXT_DEFAULT_LOADER ?? importNodeModule,
+              vm.constants?.USE_MAIN_CONTEXT_DEFAULT_LOADER ??
+              ((specifier: string) => {
+                // Use direct dynamic import to avoid recursion
+                const dynamicImport = new Function(
+                  'specifier',
+                  'return import(specifier)',
+                );
+                return dynamicImport(specifier);
+              }),
           },
         );
         script.runInThisContext()(

packages/sdk/src/__tests__/node-recursion.test.ts

@@ -0,0 +1,153 @@
+/**
+ * Test to reproduce the Maximum call stack size exceeded error
+ * when there are circular dependencies in module loading
+ */
+
+import { jest } from '@jest/globals';
+
+// Mock vm and fetch to simulate the error scenario
+const mockVm = {
+  Script: jest.fn(),
+  SourceTextModule: jest.fn(),
+  constants: {
+    USE_MAIN_CONTEXT_DEFAULT_LOADER: undefined,
+  },
+};
+
+const mockFetch = jest.fn();
+
+// Mock the modules that would be imported
+jest.mock('vm', () => mockVm, { virtual: true });
+jest.mock(
+  'path',
+  () => ({
+    basename: jest.fn(),
+    join: jest.fn(),
+  }),
+  { virtual: true },
+);
+
+describe('Node importNodeModule recursion test', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should reproduce maximum call stack size exceeded', async () => {
+    // Mock a scenario where importNodeModule gets called recursively
+    let callCount = 0;
+    const maxCalls = 10000; // Set high to trigger stack overflow
+
+    // Create a mock script that will trigger recursive importModuleDynamically calls
+    const mockScript = {
+      runInThisContext: jest.fn(() => {
+        return (
+          exports: any,
+          module: any,
+          require: any,
+          dirname: string,
+          filename: string,
+        ) => {
+          // Simulate module execution that triggers another import
+          module.exports = {};
+        };
+      }),
+    };
+
+    // Set up the vm.Script mock to simulate importModuleDynamically calls
+    mockVm.Script.mockImplementation((code: string, options: any) => {
+      // Simulate the importModuleDynamically option being called
+      if (options.importModuleDynamically && callCount < maxCalls) {
+        callCount++;
+        // This simulates a circular dependency where modules import each other
+        setTimeout(() => {
+          options.importModuleDynamically('circular-module').catch(() => {});
+        }, 0);
+      }
+      return mockScript;
+    });
+
+    // Mock fetch to return some JavaScript code
+    mockFetch.mockResolvedValue({
+      text: () => Promise.resolve('module.exports = {};'),
+    });
+
+    // Simulate the createScriptNode function call that leads to recursion
+    const { createScriptNode } = await import('../node');
+
+    // This should trigger the recursive calls and eventually cause a stack overflow
+    const promise = new Promise((resolve, reject) => {
+      createScriptNode(
+        'http://example.com/test.js',
+        (error, scriptContext) => {
+          if (error) {
+            reject(error);
+          } else {
+            resolve(scriptContext);
+          }
+        },
+        {},
+        {
+          fetch: mockFetch,
+        },
+      );
+    });
+
+    // The test should catch the stack overflow error
+    await expect(promise).rejects.toThrow();
+
+    // Verify that multiple calls were made (indicating recursion)
+    expect(callCount).toBeGreaterThan(1);
+  }, 30000); // Increased timeout for this test
+
+  it('should reproduce ESM module loading recursion', async () => {
+    // Mock SourceTextModule for ESM loading test
+    let linkCallCount = 0;
+    const mockModule = {
+      link: jest.fn(async (linker) => {
+        linkCallCount++;
+        if (linkCallCount < 5) {
+          // Simulate circular dependency by calling linker with same module
+          await linker('circular-esm-module');
+        }
+      }),
+      evaluate: jest.fn(),
+    };
+
+    mockVm.SourceTextModule.mockImplementation((code: string, options: any) => {
+      // Trigger importModuleDynamically recursion
+      if (options.importModuleDynamically && linkCallCount < 3) {
+        setTimeout(() => {
+          options.importModuleDynamically('circular-esm', {}).catch(() => {});
+        }, 0);
+      }
+      return mockModule;
+    });
+
+    mockFetch.mockResolvedValue({
+      text: () => Promise.resolve('export default {};'),
+    });
+
+    const { createScriptNode } = await import('../node');
+
+    const promise = new Promise((resolve, reject) => {
+      createScriptNode(
+        'http://example.com/test.mjs',
+        (error, scriptContext) => {
+          if (error) {
+            reject(error);
+          } else {
+            resolve(scriptContext);
+          }
+        },
+        { type: 'esm' },
+        {
+          fetch: mockFetch,
+        },
+      );
+    });
+
+    // This test demonstrates the ESM loading recursion scenario
+    await expect(promise).rejects.toThrow();
+    expect(linkCallCount).toBeGreaterThan(1);
+  }, 30000);
+});

packages/sdk/src/node.ts

@@ -3,17 +3,31 @@ import { CreateScriptHookNode, FetchHook } from './types';
 // Declare the ENV_TARGET constant that will be defined by DefinePlugin
 declare const ENV_TARGET: 'web' | 'node';
 
+const sdkImportCache = new Map<string, Promise<any>>();
+
 function importNodeModule<T>(name: string): Promise<T> {
   if (!name) {
     throw new Error('import specifier is required');
   }
+
+  // Check cache to prevent infinite recursion
+  if (sdkImportCache.has(name)) {
+    return sdkImportCache.get(name)!;
+  }
+
   const importModule = new Function('name', `return import(name)`);
-  return importModule(name)
+  const promise = importModule(name)
     .then((res: any) => res as T)
     .catch((error: any) => {
       console.error(`Error importing module ${name}:`, error);
+      // Remove from cache on error so it can be retried
+      sdkImportCache.delete(name);
       throw error;
     });
+
+  // Cache the promise to prevent recursive calls
+  sdkImportCache.set(name, promise);
+  return promise;
 }
 
 const loadNodeFetch = async (): Promise<typeof fetch> => {
@@ -225,13 +239,20 @@ export const loadScriptNode =
         );
       };
 
+const esmModuleCache = new Map<string, any>();
+
 async function loadModule(
   url: string,
   options: {
     vm: any;
     fetch: any;
   },
 ) {
+  // Check cache to prevent infinite recursion in ESM loading
+  if (esmModuleCache.has(url)) {
+    return esmModuleCache.get(url)!;
+  }
+
   const { fetch, vm } = options;
   const response = await fetch(url);
   const code = await response.text();
@@ -244,6 +265,9 @@ async function loadModule(
     },
   });
 
+  // Cache the module before linking to prevent cycles
+  esmModuleCache.set(url, module);
+
   await module.link(async (specifier: string) => {
     const resolvedUrl = new URL(specifier, url).href;
     const module = await loadModule(resolvedUrl, options);