export-runtime 0.0.22 → 0.0.24

package/handler.js

@@ -323,7 +323,6 @@ export const createHandler = (moduleMap, generatedTypes, minifiedCore, coreId, m
     // Track session state and connection state for this WebSocket connection
     const wsSession = { token: null };
     let isClosed = false;
-    const pendingOps = new Set();
 
     // Safe send that ignores errors when connection is closed
     const safeSend = (data) => {
@@ -335,63 +334,66 @@ export const createHandler = (moduleMap, generatedTypes, minifiedCore, coreId, m
       }
     };
 
-    // Wrap async operations to track them
-    const trackOp = async (op) => {
-      const promise = op();
-      pendingOps.add(promise);
-      try {
-        return await promise;
-      } finally {
-        pendingOps.delete(promise);
+    const handleClose = () => {
+      if (isClosed) return;
+      isClosed = true;
+      if (onClose) {
+        try { onClose(); } catch {}
       }
     };
 
     server.addEventListener("message", (event) => {
-      if (isClosed) return;
+      // Wrap entire handler in try-catch to prevent any unhandled errors
+      try {
+        if (isClosed) return;
 
-      // Handle message asynchronously but don't await it
-      trackOp(async () => {
+        // Parse message synchronously to get the id
+        let msg;
         let id;
         try {
-          if (isClosed) return;
-          const msg = parse(event.data);
+          msg = parse(event.data);
           id = msg.id;
+        } catch {
+          return;
+        }
 
-          // Handle auth token updates (on reconnect or explicit setToken)
-          if (msg.type === "auth" && msg.token && !msg.method) {
-            wsSession.token = msg.token;
-            safeSend(stringify({ type: "auth-result", id, success: true }));
-            return;
-          }
-
-          if (isClosed) return;
-          const result = await dispatchMessage(dispatcher, msg, env, wsSession);
-
-          if (isClosed) return;
-
-          // Extract token from auth responses
-          if (result?.value?.token && msg.type === "auth") {
-            wsSession.token = result.value.token;
-          }
+        // Handle ping synchronously - no async needed
+        if (msg.type === "ping") {
+          safeSend(stringify({ type: "pong", id }));
+          return;
+        }
 
-          if (result) safeSend(stringify({ ...result, id }));
-        } catch (err) {
-          if (isClosed || String(err).includes("Connection closed")) return;
-          if (id !== undefined) safeSend(stringify({ type: "error", id, error: String(err) }));
+        // Handle auth token updates synchronously
+        if (msg.type === "auth" && msg.token && !msg.method) {
+          wsSession.token = msg.token;
+          safeSend(stringify({ type: "auth-result", id, success: true }));
+          return;
         }
-      });
-    });
 
-    server.addEventListener("close", () => {
-      isClosed = true;
-      if (onClose) onClose();
+        // Handle other messages asynchronously with full error protection
+        (async () => {
+          try {
+            if (isClosed) return;
+            const result = await dispatchMessage(dispatcher, msg, env, wsSession);
+            if (isClosed) return;
+
+            // Extract token from auth responses
+            if (result?.value?.token && msg.type === "auth") {
+              wsSession.token = result.value.token;
+            }
+
+            if (result) safeSend(stringify({ ...result, id }));
+          } catch {
+            // Silently ignore all errors - connection may be closing
+          }
+        })().catch(() => {});  // Double-catch to ensure no unhandled promise rejection
+      } catch {
+        // Silently ignore outer errors too
+      }
     });
 
-    server.addEventListener("error", (err) => {
-      isClosed = true;
-      if (onClose) onClose();
-      try { server.close(); } catch {}
-    });
+    server.addEventListener("close", handleClose);
+    server.addEventListener("error", handleClose);
   };
 
   return {
@@ -419,12 +421,6 @@ export const createHandler = (moduleMap, generatedTypes, minifiedCore, coreId, m
         const pair = new WebSocketPair();
         const [client, server] = Object.values(pair);
 
-        // Create a promise that resolves when the WebSocket closes
-        const wsLifetime = new Promise((resolve) => {
-          server.addEventListener("close", resolve, { once: true });
-          server.addEventListener("error", resolve, { once: true });
-        });
-
         server.accept();
 
         if (isShared && env?.SHARED_EXPORT) {
@@ -437,11 +433,6 @@ export const createHandler = (moduleMap, generatedTypes, minifiedCore, coreId, m
           wireWebSocket(server, dispatcher, env, () => dispatcher.clearAll());
         }
 
-        // Keep worker alive for the WebSocket lifetime
-        if (ctx?.waitUntil) {
-          ctx.waitUntil(wsLifetime);
-        }
-
         return new Response(null, { status: 101, webSocket: client });
       }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "export-runtime",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "description": "Cloudflare Workers ESM Export Framework Runtime",
   "keywords": [
     "cloudflare",