@ricsam/isolate-runtime 0.1.15 → 0.1.17

package/dist/mjs/index.mjs

@@ -632,49 +632,102 @@ function createLocalCustomFunctionsMarshalOptions() {
 }
 function createModuleResolver(state) {
   return async (specifier, referrer) => {
-    const staticCached = state.staticModuleCache.get(specifier);
+    const importerPath = state.moduleToFilename.get(referrer) ?? "<unknown>";
+    const importerResolveDir = path.posix.dirname(importerPath);
+    const importerStack = state.moduleImportChain.get(importerPath) ?? [];
+    const resolvedSpecifier = specifier.startsWith(".") ? path.posix.normalize(path.posix.join(importerResolveDir, specifier)) : specifier;
+    state.specifierToImporter.set(resolvedSpecifier, importerPath);
+    const staticCached = state.staticModuleCache.get(resolvedSpecifier);
     if (staticCached)
       return staticCached;
-    const cached = state.moduleCache.get(specifier);
+    const cached = state.moduleCache.get(resolvedSpecifier);
     if (cached)
       return cached;
     if (!state.moduleLoader) {
       throw new Error(`No module loader registered. Cannot import: ${specifier}`);
     }
-    const importerPath = state.moduleToFilename.get(referrer) ?? "<unknown>";
-    const importerResolveDir = path.posix.dirname(importerPath);
     const result = await state.moduleLoader(specifier, {
       path: importerPath,
       resolveDir: importerResolveDir
     });
     const { code, resolveDir } = result;
+    if (result.filename.includes("/")) {
+      throw new Error(`moduleLoader returned a filename with slashes: "${result.filename}". ` + `filename must be a basename (e.g. "utils.js"), not a path.`);
+    }
+    const resolvedFilename = path.posix.join(resolveDir, result.filename);
     const hash = contentHash(code);
-    const cacheKey = `${specifier}:${hash}`;
+    const cacheKey = `${resolvedSpecifier}:${hash}`;
+    const inFlightKey = `${result.static ? "static" : "dynamic"}:${cacheKey}`;
+    const staticCachedAfterLoad = state.staticModuleCache.get(resolvedSpecifier);
+    if (staticCachedAfterLoad)
+      return staticCachedAfterLoad;
+    const cachedAfterLoad = state.moduleCache.get(resolvedSpecifier);
+    if (cachedAfterLoad)
+      return cachedAfterLoad;
     const hashCached = state.moduleCache.get(cacheKey);
     if (hashCached)
       return hashCached;
-    let transformed = state.transformCache.get(hash);
-    if (!transformed) {
-      transformed = await transformModuleCode(code, specifier);
-      state.transformCache.set(hash, transformed);
-    }
-    if (transformed.sourceMap) {
-      state.sourceMaps.set(specifier, transformed.sourceMap);
+    const inFlight = state.moduleLoadsInFlight.get(inFlightKey);
+    if (inFlight)
+      return inFlight;
+    const loadPromise = (async () => {
+      let mod;
+      try {
+        let transformed = state.transformCache.get(hash);
+        if (!transformed) {
+          transformed = await transformModuleCode(code, resolvedSpecifier);
+          state.transformCache.set(hash, transformed);
+        }
+        if (transformed.sourceMap) {
+          state.sourceMaps.set(resolvedSpecifier, transformed.sourceMap);
+        }
+        mod = await state.isolate.compileModule(transformed.code, {
+          filename: resolvedSpecifier
+        });
+        state.moduleToFilename.set(mod, resolvedFilename);
+        state.moduleImportChain.set(resolvedFilename, [...importerStack, importerPath]);
+        if (result.static) {
+          state.staticModuleCache.set(resolvedSpecifier, mod);
+        } else {
+          state.moduleCache.set(resolvedSpecifier, mod);
+          state.moduleCache.set(cacheKey, mod);
+        }
+        return mod;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        error.message = `Failed to compile module "${resolvedSpecifier}" (imported by "${importerPath}"):
+${error.message}`;
+        if (importerStack.length > 0) {
+          error.message += `
+
+Import chain:
+  ${[...importerStack, importerPath].join(`
+    -> `)}`;
+        }
+        if (mod) {
+          state.moduleToFilename.delete(mod);
+          if (result.static) {
+            if (state.staticModuleCache.get(resolvedSpecifier) === mod) {
+              state.staticModuleCache.delete(resolvedSpecifier);
+            }
+          } else {
+            if (state.moduleCache.get(resolvedSpecifier) === mod) {
+              state.moduleCache.delete(resolvedSpecifier);
+            }
+            if (state.moduleCache.get(cacheKey) === mod) {
+              state.moduleCache.delete(cacheKey);
+            }
+          }
+        }
+        throw error;
+      }
+    })();
+    state.moduleLoadsInFlight.set(inFlightKey, loadPromise);
+    try {
+      return await loadPromise;
+    } finally {
+      state.moduleLoadsInFlight.delete(inFlightKey);
     }
-    const mod = await state.isolate.compileModule(transformed.code, {
-      filename: specifier
-    });
-    const resolvedPath = path.posix.join(resolveDir, path.posix.basename(specifier));
-    state.moduleToFilename.set(mod, resolvedPath);
-    if (result.static) {
-      state.staticModuleCache.set(specifier, mod);
-    } else {
-      state.moduleCache.set(specifier, mod);
-      state.moduleCache.set(cacheKey, mod);
-    }
-    const resolver = createModuleResolver(state);
-    await mod.instantiate(state.context, resolver);
-    return mod;
   };
 }
 function convertFetchCallback(callback) {
@@ -700,10 +753,14 @@ async function createRuntime(options) {
     handles: {},
     moduleCache: new Map,
     staticModuleCache: new Map,
+    moduleLoadsInFlight: new Map,
     transformCache: new Map,
     moduleToFilename: new Map,
     sourceMaps: new Map,
+    moduleImportChain: new Map,
+    specifierToImporter: new Map,
     pendingCallbacks: [],
+    evalChain: Promise.resolve(),
     moduleLoader: opts.moduleLoader,
     customFunctions: opts.customFunctions
   };
@@ -839,6 +896,18 @@ async function createRuntime(options) {
         throw new Error("Fetch handle not available");
       }
       return state.handles.fetch.onClientWebSocketCommand(callback);
+    },
+    onEvent(callback) {
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      return state.handles.fetch.onEvent(callback);
+    },
+    dispatchEvent(event, payload) {
+      if (!state.handles.fetch) {
+        throw new Error("Fetch handle not available");
+      }
+      state.handles.fetch.dispatchEvent(event, payload);
     }
   };
   const timersHandle = {
@@ -923,45 +992,101 @@ async function createRuntime(options) {
     testEnvironment: testEnvironmentHandle,
     playwright: playwrightHandle,
     async eval(code, filenameOrOptions) {
-      const options2 = typeof filenameOrOptions === "string" ? { filename: filenameOrOptions } : filenameOrOptions;
-      const filename = normalizeEntryFilename(options2?.filename);
-      try {
-        const transformed = await transformEntryCode(code, filename);
-        if (transformed.sourceMap) {
-          state.sourceMaps.set(filename, transformed.sourceMap);
-        }
-        const mod = await state.isolate.compileModule(transformed.code, {
-          filename
-        });
-        state.moduleToFilename.set(mod, filename);
-        const resolver = createModuleResolver(state);
-        await mod.instantiate(state.context, resolver);
-        await mod.evaluate();
-        const ns = mod.namespace;
-        const runRef = await ns.get("default", { reference: true });
+      const runEval = async () => {
+        const options2 = typeof filenameOrOptions === "string" ? { filename: filenameOrOptions } : filenameOrOptions;
+        const filename = normalizeEntryFilename(options2?.filename);
         try {
-          await runRef.apply(undefined, [], {
-            result: { promise: true },
-            ...options2?.maxExecutionMs ? { timeout: options2.maxExecutionMs } : {}
+          const transformed = await transformEntryCode(code, filename);
+          if (transformed.sourceMap) {
+            state.sourceMaps.set(filename, transformed.sourceMap);
+          }
+          const mod = await state.isolate.compileModule(transformed.code, {
+            filename
           });
-        } finally {
-          runRef.release();
-        }
-        if (state.pendingCallbacks.length > 0) {
-          await Promise.all(state.pendingCallbacks);
-          state.pendingCallbacks.length = 0;
-        }
-      } catch (err) {
-        const error = err;
-        if (error.stack && state.sourceMaps.size > 0) {
-          error.stack = mapErrorStack(error.stack, state.sourceMaps);
+          state.moduleToFilename.set(mod, filename);
+          state.moduleImportChain.set(filename, []);
+          const resolver = createModuleResolver(state);
+          try {
+            await mod.instantiate(state.context, resolver);
+          } catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            const specifierMatch = error.message.match(/The requested module '([^']+)'/);
+            const exportMatch = error.message.match(/export named '([^']+)'/);
+            const failingSpecifier = specifierMatch?.[1];
+            const failingExport = exportMatch?.[1];
+            const importerFile = failingSpecifier ? state.specifierToImporter.get(failingSpecifier) : undefined;
+            const details = [];
+            if (importerFile) {
+              const chain = state.moduleImportChain.get(importerFile) ?? [];
+              const fullChain = [...chain, importerFile];
+              if (failingSpecifier)
+                fullChain.push(failingSpecifier);
+              const trimmed = fullChain.length > 12 ? fullChain.slice(-12) : fullChain;
+              const prefix = fullChain.length > 12 ? `  ...
+` : "";
+              details.push(`Import chain:
+` + prefix + trimmed.map((p) => `  ${p}`).join(`
+    -> `));
+            } else if (failingSpecifier) {
+              for (const [modPath, chain] of state.moduleImportChain) {
+                if (modPath.includes(failingSpecifier) || modPath.endsWith(failingSpecifier)) {
+                  const fullChain = [...chain, modPath];
+                  const trimmed = fullChain.length > 12 ? fullChain.slice(-12) : fullChain;
+                  details.push(`Import chain:
+` + trimmed.map((p) => `  ${p}`).join(`
+    -> `));
+                  break;
+                }
+              }
+            }
+            if (failingExport && failingSpecifier) {
+              details.push(`Hint: If '${failingExport}' is a TypeScript type/interface, use \`import type\` to prevent it from being resolved at runtime:
+` + `  import type { ${failingExport} } from '${failingSpecifier}';`);
+            }
+            const suffix = details.length > 0 ? `
+
+` + details.join(`
+
+`) : "";
+            error.message = `Module instantiation failed: ${error.message}${suffix}`;
+            throw error;
+          }
+          await mod.evaluate();
+          const ns = mod.namespace;
+          const runRef = await ns.get("default", { reference: true });
+          try {
+            await runRef.apply(undefined, [], {
+              result: { promise: true }
+            });
+          } finally {
+            runRef.release();
+          }
+          if (state.pendingCallbacks.length > 0) {
+            await Promise.all(state.pendingCallbacks);
+            state.pendingCallbacks.length = 0;
+          }
+        } catch (err) {
+          const error = err;
+          if (error.stack && state.sourceMaps.size > 0) {
+            error.stack = mapErrorStack(error.stack, state.sourceMaps);
+          }
+          throw error;
         }
-        throw error;
-      }
+      };
+      const queuedEval = state.evalChain.then(runEval, runEval);
+      state.evalChain = queuedEval.then(() => {
+        return;
+      }, () => {
+        return;
+      });
+      return queuedEval;
     },
     clearModuleCache() {
       state.moduleCache.clear();
+      state.moduleLoadsInFlight.clear();
       state.moduleToFilename.clear();
+      state.moduleImportChain.clear();
+      state.specifierToImporter.clear();
       state.sourceMaps.clear();
     },
     async dispose() {
@@ -979,6 +1104,7 @@ async function createRuntime(options) {
       state.handles.console?.dispose();
       state.handles.core?.dispose();
       state.moduleCache.clear();
+      state.moduleLoadsInFlight.clear();
       state.context.release();
       state.isolate.dispose();
     }
@@ -1007,4 +1133,4 @@ export {
   createNodeFileSystemHandler
 };
 
-//# debugId=D363252DB857D59164756E2164756E21
+//# debugId=30C3A0A75715847864756E2164756E21