@ricsam/isolate 0.1.7 → 0.1.10

package/dist/cjs/internal/daemon/connection.cjs

@@ -311,6 +311,45 @@ function logRuntimeLifecycle(state, event, instance, reason, level = "log") {
   const reasonSuffix = reason ? `: ${reason}` : "";
   logger(`[isolate-daemon] ${event} runtime ${import_runtime_pool.formatRuntimeLabel(instance)}${poisonedSuffix}${reasonSuffix}; ${import_runtime_pool.formatRuntimePoolSnapshot(import_runtime_pool.collectRuntimePoolSnapshot(state))}`);
 }
+function formatDebugValue(value) {
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number" || typeof value === "boolean" || value === null) {
+    return String(value);
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return JSON.stringify(String(value));
+  }
+}
+function formatDebugFields(fields) {
+  return Object.entries(fields).filter(([, value]) => value !== undefined).map(([key, value]) => `${key}=${formatDebugValue(value)}`).join(" ");
+}
+function isDisposedOperationError(error) {
+  const text = getErrorText(error).toLowerCase();
+  return text.includes("disposed");
+}
+function buildRuntimeDebugFields(instance, connection, extras = {}) {
+  return {
+    isolateId: instance.isolateId,
+    namespaceId: instance.namespaceId ?? null,
+    pooled: instance.isDisposed,
+    ownerMatches: instance.ownerConnection === connection.socket,
+    connectionOwnsIsolate: connection.isolates.has(instance.isolateId),
+    runtimeAbortAborted: instance.runtimeAbortController?.signal.aborted ?? null,
+    disposedForMs: instance.disposedAt !== undefined ? Date.now() - instance.disposedAt : null,
+    callbackConnectionPresent: !!instance.callbackContext?.connection,
+    reconnectPending: !!instance.callbackContext?.reconnectionPromise,
+    callbackRegistrations: instance.callbacks.size,
+    ...extras
+  };
+}
+function logSuspiciousRuntimeOperation(state, operation, instance, connection, extras = {}, level = "warn") {
+  const logger = level === "warn" ? console.warn : console.log;
+  logger(`[isolate-daemon] ${operation} runtime ${import_runtime_pool.formatRuntimeLabel(instance)}; ${import_runtime_pool.formatRuntimePoolSnapshot(import_runtime_pool.collectRuntimePoolSnapshot(state))} ${formatDebugFields(buildRuntimeDebugFields(instance, connection, extras))}`);
+}
 async function hardDeleteRuntime(instance, state, reason) {
   const wasPooled = instance.isDisposed;
   try {
@@ -343,6 +382,8 @@ async function hardDeleteRuntime(instance, state, reason) {
 }
 var RECONNECTION_TIMEOUT_MS = 30000;
 function softDeleteRuntime(instance, state, reason) {
+  const runtimeAbortWasAborted = instance.runtimeAbortController?.signal.aborted ?? false;
+  const hadCallbackConnection = !!instance.callbackContext?.connection;
   if (instance.runtimeAbortController && !instance.runtimeAbortController.signal.aborted) {
     instance.runtimeAbortController.abort(new Error(reason ?? "Runtime was soft-disposed"));
   }
@@ -380,8 +421,19 @@ function softDeleteRuntime(instance, state, reason) {
   instance.returnedIterators?.clear();
   instance.runtime.clearModuleCache();
   logRuntimeLifecycle(state, "soft-disposed", instance, reason);
+  console.warn(`[isolate-daemon] soft-dispose state runtime ${import_runtime_pool.formatRuntimeLabel(instance)}; ${import_runtime_pool.formatRuntimePoolSnapshot(import_runtime_pool.collectRuntimePoolSnapshot(state))} ${formatDebugFields({
+    runtimeAbortWasAborted,
+    runtimeAbortAborted: instance.runtimeAbortController?.signal.aborted ?? null,
+    hadCallbackConnection,
+    callbackConnectionPresent: !!instance.callbackContext?.connection,
+    reconnectPending: !!instance.callbackContext?.reconnectionPromise,
+    callbackRegistrations: instance.callbacks.size
+  })}`);
 }
 function reuseNamespacedRuntime(instance, connection, message, state) {
+  const disposedForMs = instance.disposedAt !== undefined ? Date.now() - instance.disposedAt : null;
+  const runtimeAbortWasAborted = instance.runtimeAbortController?.signal.aborted ?? false;
+  const reconnectWasPending = !!instance.callbackContext?.reconnectionPromise;
   instance.ownerConnection = connection.socket;
   instance.isDisposed = false;
   instance.isPoisoned = false;
@@ -492,6 +544,11 @@ function reuseNamespacedRuntime(instance, connection, message, state) {
   instance.returnedIterators = new Map;
   instance.nextLocalCallbackId = 1e6;
   logRuntimeLifecycle(state, "reused pooled", instance);
+  logSuspiciousRuntimeOperation(state, "reuse state", instance, connection, {
+    disposedForMs,
+    runtimeAbortWasAborted,
+    reconnectWasPending
+  }, "log");
 }
 async function waitForConnection(callbackContext) {
   if (callbackContext.connection) {
@@ -1162,6 +1219,12 @@ async function handleDispatchRequest(message, connection, state) {
     sendError(connection.socket, message.requestId, import_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
     return;
   }
+  if (instance.isDisposed) {
+    logSuspiciousRuntimeOperation(state, "dispatchRequest received for pooled", instance, connection, {
+      method: message.request.method,
+      url: message.request.url
+    });
+  }
   instance.lastActivity = Date.now();
   const dispatchAbortController = new AbortController;
   connection.dispatchAbortControllers.set(message.requestId, dispatchAbortController);
@@ -1207,6 +1270,13 @@ async function handleDispatchRequest(message, connection, state) {
       }
     } catch (err) {
       const error = err;
+      if (instance.isDisposed || isDisposedOperationError(error)) {
+        logSuspiciousRuntimeOperation(state, "dispatchRequest failed", instance, connection, {
+          method: message.request.method,
+          url: message.request.url,
+          error: error.message
+        });
+      }
       sendError(connection.socket, message.requestId, import_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
     } finally {
       connection.dispatchAbortControllers.delete(message.requestId);
@@ -1325,12 +1395,20 @@ async function handleFetchGetUpgradeRequest(message, connection, state) {
     sendError(connection.socket, message.requestId, import_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
     return;
   }
+  if (instance.isDisposed) {
+    logSuspiciousRuntimeOperation(state, "getUpgradeRequest received for pooled", instance, connection);
+  }
   instance.lastActivity = Date.now();
   try {
     const upgradeRequest = instance.runtime.fetch.getUpgradeRequest();
     sendOk(connection.socket, message.requestId, upgradeRequest);
   } catch (err) {
     const error = err;
+    if (instance.isDisposed || isDisposedOperationError(error)) {
+      logSuspiciousRuntimeOperation(state, "getUpgradeRequest failed", instance, connection, {
+        error: error.message
+      });
+    }
     sendError(connection.socket, message.requestId, import_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
   }
 }
@@ -1340,12 +1418,20 @@ async function handleFetchHasServeHandler(message, connection, state) {
     sendError(connection.socket, message.requestId, import_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
     return;
   }
+  if (instance.isDisposed) {
+    logSuspiciousRuntimeOperation(state, "hasServeHandler received for pooled", instance, connection);
+  }
   instance.lastActivity = Date.now();
   try {
     const hasHandler = instance.runtime.fetch.hasServeHandler();
     sendOk(connection.socket, message.requestId, hasHandler);
   } catch (err) {
     const error = err;
+    if (instance.isDisposed || isDisposedOperationError(error)) {
+      logSuspiciousRuntimeOperation(state, "hasServeHandler failed", instance, connection, {
+        error: error.message
+      });
+    }
     sendError(connection.socket, message.requestId, import_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
   }
 }
@@ -1355,12 +1441,20 @@ async function handleFetchHasActiveConnections(message, connection, state) {
     sendError(connection.socket, message.requestId, import_protocol.ErrorCode.ISOLATE_NOT_FOUND, `Isolate not found: ${message.isolateId}`);
     return;
   }
+  if (instance.isDisposed) {
+    logSuspiciousRuntimeOperation(state, "hasActiveConnections received for pooled", instance, connection);
+  }
   instance.lastActivity = Date.now();
   try {
     const hasConnections = instance.runtime.fetch.hasActiveConnections();
     sendOk(connection.socket, message.requestId, hasConnections);
   } catch (err) {
     const error = err;
+    if (instance.isDisposed || isDisposedOperationError(error)) {
+      logSuspiciousRuntimeOperation(state, "hasActiveConnections failed", instance, connection, {
+        error: error.message
+      });
+    }
     sendError(connection.socket, message.requestId, import_protocol.ErrorCode.SCRIPT_ERROR, error.message, { name: error.name, stack: error.stack });
   }
 }
@@ -2014,4 +2108,4 @@ async function handleClearCollectedData(message, connection, state) {
   }
 }
 
-//# debugId=0C2C837A78ED90B564756E2164756E21
+//# debugId=E087502A37B0261064756E2164756E21