@ricsam/isolate-daemon 0.1.14 → 0.1.15

package/dist/cjs/connection.cjs

@@ -36,6 +36,28 @@ var import_node_crypto = require("node:crypto");
 var import_isolate_protocol = require("@ricsam/isolate-protocol");
 var import_callback_fs_handler = require("./callback-fs-handler.cjs");
 var import_isolate_runtime = require("@ricsam/isolate-runtime");
+var LINKER_CONFLICT_ERROR = "Module is currently being linked by another linker";
+function getErrorText(error) {
+  if (error instanceof Error) {
+    const cause = error.cause;
+    const causeText = cause instanceof Error ? `${cause.name}: ${cause.message}
+${cause.stack ?? ""}` : cause != null ? String(cause) : "";
+    return [error.name, error.message, error.stack, causeText].filter((part) => part != null && part !== "").join(`
+`);
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error ?? "");
+  }
+}
+function isLinkerConflictError(error) {
+  const text = getErrorText(error).toLowerCase();
+  return text.includes(LINKER_CONFLICT_ERROR.toLowerCase());
+}
 function handleConnection(socket, state) {
   const connection = {
     socket,
@@ -68,17 +90,17 @@ function handleConnection(socket, state) {
       const instance = state.isolates.get(isolateId);
       if (instance) {
         if (instance.namespaceId != null && !instance.isDisposed) {
-          softDeleteRuntime(instance, state);
+          if (instance.isPoisoned) {
+            hardDeleteRuntime(instance, state).catch(() => {});
+          } else {
+            softDeleteRuntime(instance, state);
+          }
         } else if (!instance.isDisposed) {
-          instance.runtime.dispose().catch(() => {});
-          state.isolates.delete(isolateId);
+          hardDeleteRuntime(instance, state).catch(() => {});
         }
       }
     }
     for (const [, pending] of connection.pendingCallbacks) {
-      if (pending.timeoutId) {
-        clearTimeout(pending.timeoutId);
-      }
       pending.reject(new Error("Connection closed"));
     }
     connection.pendingCallbacks.clear();
@@ -206,22 +228,32 @@ async function handleMessage(message, connection, state) {
     case import_isolate_protocol.MessageType.CALLBACK_STREAM_END:
       handleCallbackStreamEnd(message, connection);
       break;
-    case import_isolate_protocol.MessageType.CLIENT_WS_OPENED:
-      handleClientWsOpened(message, connection, state);
-      break;
-    case import_isolate_protocol.MessageType.CLIENT_WS_MESSAGE:
-      handleClientWsMessage(message, connection, state);
-      break;
-    case import_isolate_protocol.MessageType.CLIENT_WS_CLOSED:
-      handleClientWsClosed(message, connection, state);
-      break;
-    case import_isolate_protocol.MessageType.CLIENT_WS_ERROR:
-      handleClientWsError(message, connection, state);
+    case import_isolate_protocol.MessageType.CLIENT_EVENT:
+      handleClientEvent(message, connection, state);
       break;
     default:
       sendError(connection.socket, message.requestId ?? 0, import_isolate_protocol.ErrorCode.UNKNOWN_MESSAGE_TYPE, `Unknown message type: ${message.type}`);
   }
 }
+async function hardDeleteRuntime(instance, state) {
+  try {
+    await instance.runtime.dispose();
+  } finally {
+    state.isolates.delete(instance.isolateId);
+    if (instance.namespaceId != null) {
+      const indexed = state.namespacedRuntimes.get(instance.namespaceId);
+      if (indexed?.isolateId === instance.isolateId) {
+        state.namespacedRuntimes.delete(instance.namespaceId);
+      }
+    }
+    instance.isDisposed = true;
+    instance.disposedAt = undefined;
+    instance.ownerConnection = null;
+    if (instance.callbackContext) {
+      instance.callbackContext.connection = null;
+    }
+  }
+}
 function softDeleteRuntime(instance, state) {
   instance.isDisposed = true;
   instance.disposedAt = Date.now();
@@ -241,6 +273,7 @@ function softDeleteRuntime(instance, state) {
 function reuseNamespacedRuntime(instance, connection, message, state) {
   instance.ownerConnection = connection.socket;
   instance.isDisposed = false;
+  instance.isPoisoned = false;
   instance.disposedAt = undefined;
   instance.lastActivity = Date.now();
   connection.isolates.add(instance.isolateId);
@@ -355,18 +388,15 @@ async function evictOldestDisposedRuntime(state) {
   }
   if (oldest) {
     try {
-      await oldest.runtime.dispose();
+      await hardDeleteRuntime(oldest, state);
     } catch {}
-    state.isolates.delete(oldest.isolateId);
-    if (oldest.namespaceId != null) {
-      state.namespacedRuntimes.delete(oldest.namespaceId);
-    }
     return true;
   }
   return false;
 }
 async function handleCreateRuntime(message, connection, state) {
   const namespaceId = message.options.namespaceId;
+  let namespaceCreationLocked = false;
   if (namespaceId != null) {
     const existing = state.namespacedRuntimes.get(namespaceId);
     if (existing) {
@@ -388,14 +418,20 @@ async function handleCreateRuntime(message, connection, state) {
       });
       return;
     }
-  }
-  if (state.isolates.size >= state.options.maxIsolates) {
-    if (!await evictOldestDisposedRuntime(state)) {
-      sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.ISOLATE_MEMORY_LIMIT, `Maximum isolates (${state.options.maxIsolates}) reached`);
+    if (state.namespacedCreatesInFlight.has(namespaceId)) {
+      sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, `Namespace "${namespaceId}" creation already in progress`);
       return;
     }
+    state.namespacedCreatesInFlight.add(namespaceId);
+    namespaceCreationLocked = true;
   }
   try {
+    if (state.isolates.size >= state.options.maxIsolates) {
+      if (!await evictOldestDisposedRuntime(state)) {
+        sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.ISOLATE_MEMORY_LIMIT, `Maximum isolates (${state.options.maxIsolates}) reached`);
+        return;
+      }
+    }
     const isolateId = import_node_crypto.randomUUID();
     const consoleCallbacks = message.options.callbacks?.console;
     const fetchCallback = message.options.callbacks?.fetch;
@@ -438,6 +474,7 @@ async function handleCreateRuntime(message, connection, state) {
       nextLocalCallbackId: 1e6,
       namespaceId,
       isDisposed: false,
+      isPoisoned: false,
       callbackContext
     };
     let bridgedCustomFunctions;
@@ -460,12 +497,10 @@ async function handleCreateRuntime(message, connection, state) {
           return iteratorId;
         }
       });
-      const isPromiseRef = (value) => typeof value === "object" && value !== null && value.__type === "PromiseRef";
-      const isAsyncIteratorRef = (value) => typeof value === "object" && value !== null && value.__type === "AsyncIteratorRef";
       const addCallbackIdsToRefs = (value) => {
         if (value === null || typeof value !== "object")
           return value;
-        if (isPromiseRef(value)) {
+        if (import_isolate_protocol.isPromiseRef(value)) {
           if ("__resolveCallbackId" in value)
             return value;
           const resolveCallbackId = instance.nextLocalCallbackId++;
@@ -481,7 +516,7 @@ async function handleCreateRuntime(message, connection, state) {
           });
           return { ...value, __resolveCallbackId: resolveCallbackId };
         }
-        if (isAsyncIteratorRef(value)) {
+        if (import_isolate_protocol.isAsyncIteratorRef(value)) {
           if ("__nextCallbackId" in value)
             return value;
           const nextCallbackId = instance.nextLocalCallbackId++;
@@ -640,7 +675,7 @@ async function handleCreateRuntime(message, connection, state) {
             };
           }
           try {
-            const resultJson = await invokeClientCallback(conn, callbackId, [JSON.stringify(op)], 60000);
+            const resultJson = await invokeClientCallback(conn, callbackId, [JSON.stringify(op)]);
             return JSON.parse(resultJson);
           } catch (err) {
             const error = err;
@@ -691,13 +726,13 @@ async function handleCreateRuntime(message, connection, state) {
           headers: init.headers,
           body: init.rawBody
         };
-        const result = await invokeClientCallback(conn, callbackId, [serialized], 60000);
+        const result = await invokeClientCallback(conn, callbackId, [serialized]);
         if (result && typeof result === "object" && result.__streamingResponse) {
           const response = result.response;
           response.__isCallbackStream = true;
           return response;
         }
-        return deserializeResponse(result);
+        return import_isolate_protocol.deserializeResponse(result);
       },
       fs: {
         getDirectory: async (dirPath) => {
@@ -791,18 +826,19 @@ async function handleCreateRuntime(message, connection, state) {
       } else {
         data = cmd.data;
       }
-      const wsCommandMsg = {
-        type: import_isolate_protocol.MessageType.WS_COMMAND,
-        isolateId,
-        command: {
-          type: cmd.type,
-          connectionId: cmd.connectionId,
-          data,
-          code: cmd.code,
-          reason: cmd.reason
-        }
+      const payload = {
+        type: cmd.type,
+        connectionId: cmd.connectionId,
+        data,
+        code: cmd.code,
+        reason: cmd.reason
       };
-      sendMessage(targetConnection.socket, wsCommandMsg);
+      sendMessage(targetConnection.socket, {
+        type: import_isolate_protocol.MessageType.ISOLATE_EVENT,
+        isolateId,
+        event: import_isolate_protocol.IsolateEvents.WS_COMMAND,
+        payload
+      });
     });
     runtime.fetch.onClientWebSocketCommand((cmd) => {
       const targetConnection = callbackContext.connection;
@@ -816,40 +852,62 @@ async function handleCreateRuntime(message, connection, state) {
         data = cmd.data;
       }
       if (cmd.type === "connect") {
-        const msg = {
-          type: import_isolate_protocol.MessageType.CLIENT_WS_CONNECT,
-          requestId: 0,
-          isolateId,
+        const payload = {
           socketId: cmd.socketId,
           url: cmd.url,
           protocols: cmd.protocols
         };
-        sendMessage(targetConnection.socket, msg);
-      } else if (cmd.type === "send") {
-        const msg = {
-          type: import_isolate_protocol.MessageType.CLIENT_WS_SEND,
-          requestId: 0,
+        sendMessage(targetConnection.socket, {
+          type: import_isolate_protocol.MessageType.ISOLATE_EVENT,
           isolateId,
+          event: import_isolate_protocol.IsolateEvents.WS_CLIENT_CONNECT,
+          payload
+        });
+      } else if (cmd.type === "send") {
+        const payload = {
           socketId: cmd.socketId,
           data
         };
-        sendMessage(targetConnection.socket, msg);
-      } else if (cmd.type === "close") {
-        const msg = {
-          type: import_isolate_protocol.MessageType.CLIENT_WS_CLOSE,
-          requestId: 0,
+        sendMessage(targetConnection.socket, {
+          type: import_isolate_protocol.MessageType.ISOLATE_EVENT,
           isolateId,
+          event: import_isolate_protocol.IsolateEvents.WS_CLIENT_SEND,
+          payload
+        });
+      } else if (cmd.type === "close") {
+        const payload = {
           socketId: cmd.socketId,
           code: cmd.code,
           reason: cmd.reason
         };
-        sendMessage(targetConnection.socket, msg);
+        sendMessage(targetConnection.socket, {
+          type: import_isolate_protocol.MessageType.ISOLATE_EVENT,
+          isolateId,
+          event: import_isolate_protocol.IsolateEvents.WS_CLIENT_CLOSE,
+          payload
+        });
       }
     });
+    runtime.fetch.onEvent((eventName, payload) => {
+      const targetConnection = callbackContext.connection;
+      if (!targetConnection) {
+        return;
+      }
+      sendMessage(targetConnection.socket, {
+        type: import_isolate_protocol.MessageType.ISOLATE_EVENT,
+        isolateId,
+        event: eventName,
+        payload
+      });
+    });
     sendOk(connection.socket, message.requestId, { isolateId, reused: false });
   } catch (err) {
     const error = err;
     sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
+  } finally {
+    if (namespaceCreationLocked && namespaceId != null) {
+      state.namespacedCreatesInFlight.delete(namespaceId);
+    }
   }
 }
 async function handleDisposeRuntime(message, connection, state) {
@@ -865,14 +923,20 @@ async function handleDisposeRuntime(message, connection, state) {
   try {
     connection.isolates.delete(message.isolateId);
     if (instance.namespaceId != null) {
-      softDeleteRuntime(instance, state);
+      if (instance.isPoisoned) {
+        await hardDeleteRuntime(instance, state);
+      } else {
+        softDeleteRuntime(instance, state);
+      }
     } else {
-      await instance.runtime.dispose();
-      state.isolates.delete(message.isolateId);
+      await hardDeleteRuntime(instance, state);
     }
     sendOk(connection.socket, message.requestId);
   } catch (err) {
     const error = err;
+    if (instance.namespaceId != null && isLinkerConflictError(error)) {
+      instance.isPoisoned = true;
+    }
     sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
   }
 }
@@ -885,14 +949,15 @@ async function handleEval(message, connection, state) {
   instance.lastActivity = Date.now();
   try {
     await instance.runtime.eval(message.code, {
-      filename: message.filename,
-      maxExecutionMs: message.maxExecutionMs
+      filename: message.filename
     });
     sendOk(connection.socket, message.requestId, { value: undefined });
   } catch (err) {
     const error = err;
-    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 });
+    if (instance.namespaceId != null && isLinkerConflictError(error)) {
+      instance.isPoisoned = true;
+    }
+    sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
   }
 }
 async function handleDispatchRequest(message, connection, state) {
@@ -1000,34 +1065,38 @@ async function handleWsClose(message, connection, state) {
     sendError(connection.socket, message.requestId, import_isolate_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
   }
 }
-function handleClientWsOpened(message, connection, state) {
+function handleClientEvent(message, connection, state) {
   const instance = state.isolates.get(message.isolateId);
   if (!instance)
     return;
   instance.lastActivity = Date.now();
-  instance.runtime.fetch.dispatchClientWebSocketOpen(message.socketId, message.protocol, message.extensions);
-}
-function handleClientWsMessage(message, connection, state) {
-  const instance = state.isolates.get(message.isolateId);
-  if (!instance)
-    return;
-  instance.lastActivity = Date.now();
-  const data = message.data instanceof Uint8Array ? message.data.buffer.slice(message.data.byteOffset, message.data.byteOffset + message.data.byteLength) : message.data;
-  instance.runtime.fetch.dispatchClientWebSocketMessage(message.socketId, data);
-}
-function handleClientWsClosed(message, connection, state) {
-  const instance = state.isolates.get(message.isolateId);
-  if (!instance)
-    return;
-  instance.lastActivity = Date.now();
-  instance.runtime.fetch.dispatchClientWebSocketClose(message.socketId, message.code, message.reason, message.wasClean);
-}
-function handleClientWsError(message, connection, state) {
-  const instance = state.isolates.get(message.isolateId);
-  if (!instance)
-    return;
-  instance.lastActivity = Date.now();
-  instance.runtime.fetch.dispatchClientWebSocketError(message.socketId);
+  switch (message.event) {
+    case import_isolate_protocol.ClientEvents.WS_CLIENT_OPENED: {
+      const payload = message.payload;
+      instance.runtime.fetch.dispatchClientWebSocketOpen(payload.socketId, payload.protocol, payload.extensions);
+      break;
+    }
+    case import_isolate_protocol.ClientEvents.WS_CLIENT_MESSAGE: {
+      const payload = message.payload;
+      const data = payload.data instanceof Uint8Array ? payload.data.buffer.slice(payload.data.byteOffset, payload.data.byteOffset + payload.data.byteLength) : payload.data;
+      instance.runtime.fetch.dispatchClientWebSocketMessage(payload.socketId, data);
+      break;
+    }
+    case import_isolate_protocol.ClientEvents.WS_CLIENT_CLOSED: {
+      const payload = message.payload;
+      instance.runtime.fetch.dispatchClientWebSocketClose(payload.socketId, payload.code, payload.reason, payload.wasClean);
+      break;
+    }
+    case import_isolate_protocol.ClientEvents.WS_CLIENT_ERROR: {
+      const payload = message.payload;
+      instance.runtime.fetch.dispatchClientWebSocketError(payload.socketId);
+      break;
+    }
+    default: {
+      instance.runtime.fetch.dispatchEvent(message.event, message.payload);
+      break;
+    }
+  }
 }
 async function handleFetchGetUpgradeRequest(message, connection, state) {
   const instance = state.isolates.get(message.isolateId);
@@ -1171,9 +1240,6 @@ function handleCallbackResponse(message, connection) {
     return;
   }
   connection.pendingCallbacks.delete(message.requestId);
-  if (pending.timeoutId) {
-    clearTimeout(pending.timeoutId);
-  }
   if (message.error) {
     const error = new Error(message.error.message);
     error.name = message.error.name;
@@ -1185,17 +1251,12 @@ function handleCallbackResponse(message, connection) {
     pending.resolve(message.result);
   }
 }
-async function invokeClientCallback(connection, callbackId, args, timeout = 1e4) {
+async function invokeClientCallback(connection, callbackId, args) {
   const requestId = connection.nextCallbackId++;
   return new Promise((resolve, reject) => {
-    const timeoutId = setTimeout(() => {
-      connection.pendingCallbacks.delete(requestId);
-      reject(new Error("Callback timeout"));
-    }, timeout);
     const pending = {
       resolve,
-      reject,
-      timeoutId
+      reject
     };
     connection.pendingCallbacks.set(requestId, pending);
     const invoke = {
@@ -1207,13 +1268,6 @@ async function invokeClientCallback(connection, callbackId, args, timeout = 1e4)
     sendMessage(connection.socket, invoke);
   });
 }
-function deserializeResponse(data) {
-  return new Response(data.body, {
-    status: data.status,
-    statusText: data.statusText,
-    headers: data.headers
-  });
-}
 function handleStreamPush(message, connection) {
   const receiver = connection.streamReceivers.get(message.streamId);
   if (!receiver) {
@@ -1341,9 +1395,6 @@ function handleCallbackStreamStart(message, connection) {
   const pending = connection.pendingCallbacks.get(message.requestId);
   if (pending) {
     connection.pendingCallbacks.delete(message.requestId);
-    if (pending.timeoutId) {
-      clearTimeout(pending.timeoutId);
-    }
     const response = new Response(readableStream, {
       status: message.metadata.status,
       statusText: message.metadata.statusText,
@@ -1559,4 +1610,4 @@ async function handleClearCollectedData(message, connection, state) {
   }
 }
 
-//# debugId=53A5FD566727ACE764756E2164756E21
+//# debugId=20B12DB74E4F312D64756E2164756E21