@ricsam/isolate-daemon 0.1.10 → 0.1.12

package/dist/cjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/isolate-daemon",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "type": "commonjs"
 }

package/dist/mjs/connection.mjs

@@ -1,5 +1,6 @@
 // packages/isolate-daemon/src/connection.ts
 import { randomUUID } from "node:crypto";
+import path from "node:path";
 import ivm from "isolated-vm";
 import {
   createFrameParser,
@@ -8,6 +9,7 @@ import {
   ErrorCode,
   STREAM_CHUNK_SIZE,
   STREAM_DEFAULT_CREDIT,
+  normalizeEntryFilename,
   marshalValue,
   unmarshalValue
 } from "@ricsam/isolate-protocol";
@@ -24,6 +26,12 @@ import {
 import {
   createInternalRuntime
 } from "@ricsam/isolate-runtime";
+import {
+  transformEntryCode,
+  transformModuleCode,
+  contentHash,
+  mapErrorStack
+} from "@ricsam/isolate-transform";
 function handleConnection(socket, state) {
   const connection = {
     socket,
@@ -406,7 +414,7 @@ async function handleCreateRuntime(message, connection, state) {
         }
       },
       fs: {
-        getDirectory: async (path) => {
+        getDirectory: async (path2) => {
           const conn = callbackContext.connection;
           if (!conn) {
             throw new Error("FS callbacks not available");
@@ -415,7 +423,7 @@ async function handleCreateRuntime(message, connection, state) {
             connection: conn,
             callbackContext,
             invokeClientCallback,
-            basePath: path
+            basePath: path2
           });
         }
       }
@@ -439,6 +447,7 @@ async function handleCreateRuntime(message, connection, state) {
     if (moduleLoaderCallback) {
       instance.moduleLoaderCallbackId = moduleLoaderCallback.callbackId;
       instance.moduleCache = new Map;
+      instance.moduleToFilename = new Map;
     }
     if (customCallbacks) {
       await setupCustomFunctions(runtime.context, customCallbacks, connection, instance);
@@ -583,10 +592,19 @@ async function handleEval(message, connection, state) {
   }
   instance.lastActivity = Date.now();
   try {
-    const mod = await instance.runtime.isolate.compileModule(message.code, {
-      filename: message.filename ?? "<eval>"
+    const filename = normalizeEntryFilename(message.filename);
+    const transformed = await transformEntryCode(message.code, filename);
+    if (transformed.sourceMap) {
+      if (!instance.sourceMaps) {
+        instance.sourceMaps = new Map;
+      }
+      instance.sourceMaps.set(filename, transformed.sourceMap);
+    }
+    const mod = await instance.runtime.isolate.compileModule(transformed.code, {
+      filename
     });
     if (instance.moduleLoaderCallbackId) {
+      instance.moduleToFilename?.set(mod, filename);
       const resolver = createModuleResolver(instance, connection);
       await mod.instantiate(instance.runtime.context, resolver);
     } else {
@@ -594,13 +612,25 @@ async function handleEval(message, connection, state) {
         throw new Error(`No module loader registered. Cannot import: ${specifier}`);
       });
     }
-    const timeout = message.maxExecutionMs;
-    await mod.evaluate(timeout ? { timeout } : undefined);
+    await mod.evaluate();
+    const ns = mod.namespace;
+    const runRef = await ns.get("default", { reference: true });
+    try {
+      await runRef.apply(undefined, [], {
+        result: { promise: true },
+        ...message.maxExecutionMs ? { timeout: message.maxExecutionMs } : {}
+      });
+    } finally {
+      runRef.release();
+    }
     await Promise.all(instance.pendingCallbacks);
     instance.pendingCallbacks.length = 0;
     sendOk(connection.socket, message.requestId, { value: undefined });
   } catch (err) {
     const error = err;
+    if (error.stack && instance.sourceMaps?.size) {
+      error.stack = mapErrorStack(error.stack, instance.sourceMaps);
+    }
     const isTimeoutError = error.message?.includes("Script execution timed out");
     sendError(connection.socket, message.requestId, isTimeoutError ? ErrorCode.ISOLATE_TIMEOUT : ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
   }
@@ -1354,20 +1384,38 @@ async function setupCustomFunctions(context, customCallbacks, connection, instan
   }
 }
 function createModuleResolver(instance, connection) {
-  return async (specifier, _referrer) => {
+  return async (specifier, referrer) => {
     const cached = instance.moduleCache?.get(specifier);
     if (cached)
       return cached;
     if (!instance.moduleLoaderCallbackId) {
       throw new Error(`Module not found: ${specifier}`);
     }
-    const code = await invokeClientCallback(connection, instance.moduleLoaderCallbackId, [specifier]);
-    const mod = await instance.runtime.isolate.compileModule(code, {
+    const importerPath = instance.moduleToFilename?.get(referrer) ?? "<unknown>";
+    const importerResolveDir = path.posix.dirname(importerPath);
+    const result = await invokeClientCallback(connection, instance.moduleLoaderCallbackId, [specifier, { path: importerPath, resolveDir: importerResolveDir }]);
+    const { code, resolveDir } = result;
+    const hash = contentHash(code);
+    const cacheKey = `${specifier}:${hash}`;
+    const hashCached = instance.moduleCache?.get(cacheKey);
+    if (hashCached)
+      return hashCached;
+    const transformed = await transformModuleCode(code, specifier);
+    if (transformed.sourceMap) {
+      if (!instance.sourceMaps) {
+        instance.sourceMaps = new Map;
+      }
+      instance.sourceMaps.set(specifier, transformed.sourceMap);
+    }
+    const mod = await instance.runtime.isolate.compileModule(transformed.code, {
       filename: specifier
     });
+    const resolvedPath = path.posix.join(resolveDir, path.posix.basename(specifier));
+    instance.moduleToFilename?.set(mod, resolvedPath);
     const resolver = createModuleResolver(instance, connection);
     await mod.instantiate(instance.runtime.context, resolver);
     instance.moduleCache?.set(specifier, mod);
+    instance.moduleCache?.set(cacheKey, mod);
     return mod;
   };
 }
@@ -1510,6 +1558,10 @@ function handleCallbackStreamStart(message, connection) {
         resolver();
       }
       connection.callbackStreamReceivers.delete(message.streamId);
+      sendMessage(connection.socket, {
+        type: MessageType.CALLBACK_STREAM_CANCEL,
+        streamId: message.streamId
+      });
       return Promise.resolve();
     }
   });
@@ -1785,4 +1837,4 @@ export {
   handleConnection
 };
 
-//# debugId=2A1E0650E9CDD7A964756E2164756E21
+//# debugId=514032B8427B94A564756E2164756E21