@ricsam/isolate-runtime 0.1.16 → 0.1.18

package/dist/cjs/index.cjs

@@ -4,38 +4,59 @@ var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
-var __moduleCache = /* @__PURE__ */ new WeakMap;
 var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
   if (entry)
     return entry;
   entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
   __moduleCache.set(from, entry);
   return entry;
 };
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 
@@ -670,29 +691,36 @@ function createLocalCustomFunctionsMarshalOptions() {
 }
 function createModuleResolver(state) {
   return async (specifier, referrer) => {
-    const staticCached = state.staticModuleCache.get(specifier);
+    const importerPath = state.moduleToFilename.get(referrer) ?? "<unknown>";
+    const importerResolveDir = import_node_path.default.posix.dirname(importerPath);
+    const importerStack = state.moduleImportChain.get(importerPath) ?? [];
+    const resolvedSpecifier = specifier.startsWith(".") ? import_node_path.default.posix.normalize(import_node_path.default.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 = import_node_path.default.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 = import_node_path.default.posix.join(resolveDir, result.filename);
     const hash = import_isolate_transform.contentHash(code);
-    const cacheKey = `${specifier}:${hash}`;
+    const cacheKey = `${resolvedSpecifier}:${hash}`;
     const inFlightKey = `${result.static ? "static" : "dynamic"}:${cacheKey}`;
-    const staticCachedAfterLoad = state.staticModuleCache.get(specifier);
+    const staticCachedAfterLoad = state.staticModuleCache.get(resolvedSpecifier);
     if (staticCachedAfterLoad)
       return staticCachedAfterLoad;
-    const cachedAfterLoad = state.moduleCache.get(specifier);
+    const cachedAfterLoad = state.moduleCache.get(resolvedSpecifier);
     if (cachedAfterLoad)
       return cachedAfterLoad;
     const hashCached = state.moduleCache.get(cacheKey);
@@ -706,41 +734,51 @@ function createModuleResolver(state) {
       try {
         let transformed = state.transformCache.get(hash);
         if (!transformed) {
-          transformed = await import_isolate_transform.transformModuleCode(code, specifier);
+          transformed = await import_isolate_transform.transformModuleCode(code, resolvedSpecifier);
           state.transformCache.set(hash, transformed);
         }
         if (transformed.sourceMap) {
-          state.sourceMaps.set(specifier, transformed.sourceMap);
+          state.sourceMaps.set(resolvedSpecifier, transformed.sourceMap);
         }
         mod = await state.isolate.compileModule(transformed.code, {
-          filename: specifier
+          filename: resolvedSpecifier
         });
-        const resolvedPath = import_node_path.default.posix.join(resolveDir, import_node_path.default.posix.basename(specifier));
-        state.moduleToFilename.set(mod, resolvedPath);
+        state.moduleToFilename.set(mod, resolvedFilename);
+        state.moduleImportChain.set(resolvedFilename, [...importerStack, importerPath]);
         if (result.static) {
-          state.staticModuleCache.set(specifier, mod);
+          state.staticModuleCache.set(resolvedSpecifier, mod);
         } else {
-          state.moduleCache.set(specifier, mod);
+          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(specifier) === mod) {
-              state.staticModuleCache.delete(specifier);
+            if (state.staticModuleCache.get(resolvedSpecifier) === mod) {
+              state.staticModuleCache.delete(resolvedSpecifier);
             }
           } else {
-            if (state.moduleCache.get(specifier) === mod) {
-              state.moduleCache.delete(specifier);
+            if (state.moduleCache.get(resolvedSpecifier) === mod) {
+              state.moduleCache.delete(resolvedSpecifier);
             }
             if (state.moduleCache.get(cacheKey) === mod) {
               state.moduleCache.delete(cacheKey);
             }
           }
         }
-        throw err;
+        throw error;
       }
     })();
     state.moduleLoadsInFlight.set(inFlightKey, loadPromise);
@@ -778,6 +816,8 @@ async function createRuntime(options) {
     transformCache: new Map,
     moduleToFilename: new Map,
     sourceMaps: new Map,
+    moduleImportChain: new Map,
+    specifierToImporter: new Map,
     pendingCallbacks: [],
     evalChain: Promise.resolve(),
     moduleLoader: opts.moduleLoader,
@@ -1023,8 +1063,53 @@ async function createRuntime(options) {
             filename
           });
           state.moduleToFilename.set(mod, filename);
+          state.moduleImportChain.set(filename, []);
           const resolver = createModuleResolver(state);
-          await mod.instantiate(state.context, resolver);
+          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 });
@@ -1059,6 +1144,8 @@ async function createRuntime(options) {
       state.moduleCache.clear();
       state.moduleLoadsInFlight.clear();
       state.moduleToFilename.clear();
+      state.moduleImportChain.clear();
+      state.specifierToImporter.clear();
       state.sourceMaps.clear();
     },
     async dispose() {
@@ -1083,4 +1170,4 @@ async function createRuntime(options) {
   };
 }
 
-//# debugId=9159E7F9BC462BBB64756E2164756E21
+//# debugId=2027548ECE80ECC164756E2164756E21