fix: cache compiled modules to prevent per-request SourceTextModule leak

The buildLink() function had a cache for Node builtins but none for
regular imports. Every dynamic import() during SSR rendering compiled
a new vm.SourceTextModule, read the file from disk, and evaluated it.
These modules were never freed because they're linked to the vm.Context.

After ~30 SSR renders, accumulated SourceTextModule instances filled
the 384MB heap limit and the worker OOMed. The stack traces confirmed
this: OOM consistently occurred inside ModuleWrap::CompileSourceTextModule
and SourceTextModule::Evaluate.

The fix: cache compiled modules by resolved file path. A module compiled
once is reused for all subsequent imports of the same file. This is safe
because the file contents don't change at runtime, and all modules share
the same vm.Context.

Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>

Author: steve

src/ember-app.js

@@ -243,10 +243,10 @@ export default class EmberApp {
     const importModuleDynamically = async specifier => {
       return (await link(specifier)).namespace;
     };
-    const builtinCache = new Map();
+    const moduleCache = new Map();
     const link = async (specifier, referencingModule) => {
       if (nodeBuiltins.has(specifier)) {
-        if (builtinCache.has(specifier)) return builtinCache.get(specifier);
+        if (moduleCache.has(specifier)) return moduleCache.get(specifier);
         const canonical = specifier.startsWith('node:') ? specifier : `node:${specifier}`;
         const native = await import(canonical);
         const exportNames = Object.keys(native);
@@ -262,15 +262,20 @@ export default class EmberApp {
         );
         await synth.link(() => {});
         await synth.evaluate();
-        builtinCache.set(specifier, synth);
+        moduleCache.set(specifier, synth);
         return synth;
       }
       const base = referencingModule?.identifier || defaultBase;
       const identifier = await this.resolveImport(specifier, base);
+      // Cache compiled modules by resolved path. Without this, every
+      // dynamic import during SSR compiles a new SourceTextModule,
+      // which are never freed and accumulate until OOM.
+      if (moduleCache.has(identifier)) return moduleCache.get(identifier);
       const module = await this.buildScript(
         identifier, context, link, importModuleDynamically,
       );
       await module.evaluate();
+      moduleCache.set(identifier, module);
       return module;
     };
     return { link, importModuleDynamically };