@ricsam/isolate-daemon 0.1.11 → 0.1.12

package/dist/cjs/connection.cjs

@@ -53,6 +53,7 @@ var import_callback_fs_handler = require("./callback-fs-handler.cjs");
 var import_isolate_test_environment = require("@ricsam/isolate-test-environment");
 var import_isolate_playwright = require("@ricsam/isolate-playwright");
 var import_isolate_runtime = require("@ricsam/isolate-runtime");
+var import_isolate_transform = require("@ricsam/isolate-transform");
 function handleConnection(socket, state) {
   const connection = {
     socket,
@@ -614,7 +615,14 @@ async function handleEval(message, connection, state) {
   instance.lastActivity = Date.now();
   try {
     const filename = import_isolate_protocol.normalizeEntryFilename(message.filename);
-    const mod = await instance.runtime.isolate.compileModule(message.code, {
+    const transformed = await import_isolate_transform.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) {
@@ -626,13 +634,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 = import_isolate_transform.mapErrorStack(error.stack, instance.sourceMaps);
+    }
     const isTimeoutError = error.message?.includes("Script execution timed out");
     sendError(connection.socket, message.requestId, isTimeoutError ? import_isolate_protocol.ErrorCode.ISOLATE_TIMEOUT : import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
   }
@@ -1397,7 +1417,19 @@ function createModuleResolver(instance, connection) {
     const importerResolveDir = import_node_path.default.posix.dirname(importerPath);
     const result = await invokeClientCallback(connection, instance.moduleLoaderCallbackId, [specifier, { path: importerPath, resolveDir: importerResolveDir }]);
     const { code, resolveDir } = result;
-    const mod = await instance.runtime.isolate.compileModule(code, {
+    const hash = import_isolate_transform.contentHash(code);
+    const cacheKey = `${specifier}:${hash}`;
+    const hashCached = instance.moduleCache?.get(cacheKey);
+    if (hashCached)
+      return hashCached;
+    const transformed = await import_isolate_transform.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 = import_node_path.default.posix.join(resolveDir, import_node_path.default.posix.basename(specifier));
@@ -1405,6 +1437,7 @@ function createModuleResolver(instance, connection) {
     const resolver = createModuleResolver(instance, connection);
     await mod.instantiate(instance.runtime.context, resolver);
     instance.moduleCache?.set(specifier, mod);
+    instance.moduleCache?.set(cacheKey, mod);
     return mod;
   };
 }
@@ -1547,6 +1580,10 @@ function handleCallbackStreamStart(message, connection) {
         resolver();
       }
       connection.callbackStreamReceivers.delete(message.streamId);
+      sendMessage(connection.socket, {
+        type: import_isolate_protocol.MessageType.CALLBACK_STREAM_CANCEL,
+        streamId: message.streamId
+      });
       return Promise.resolve();
     }
   });
@@ -1819,4 +1856,4 @@ async function handleClearCollectedData(message, connection, state) {
   }
 }
 
-//# debugId=6F23033E4A4DC7E564756E2164756E21
+//# debugId=32017BAA615D918C64756E2164756E21