@absolutejs/voice 0.0.22-beta.657 → 0.0.22-beta.659

package/dist/index.js

@@ -39835,6 +39835,11 @@ var createVoiceMonitorRunnerRoutes = (options) => {
 };
 
 // src/core/plugin.ts
+var socketIdentity = (ws) => ws.raw && typeof ws.raw === "object" ? ws.raw : ws;
+var socketIsOpen = (ws) => {
+  const identity = socketIdentity(ws);
+  return identity.readyState === undefined || identity.readyState === 1;
+};
 var resolveQueryScenario = (query) => {
   if (typeof query?.scenarioId === "string" && query.scenarioId.trim()) {
     return query.scenarioId.trim();
@@ -39946,14 +39951,15 @@ var parseClientMessage = (raw) => {
 };
 var resolveSessionId3 = (runtime, ws) => {
   const query = ws.data && typeof ws.data === "object" && "query" in ws.data ? ws.data.query : undefined;
-  const existing = runtime.socketSessions.get(ws);
+  const identity = socketIdentity(ws);
+  const existing = runtime.socketSessions.get(identity);
   const providedSessionId = typeof query?.sessionId === "string" && query.sessionId.trim() ? query.sessionId.trim() : existing?.sessionId ?? createId();
   const scenarioId = resolveQueryScenario(query) ?? existing?.scenarioId ?? null;
   const resolved = {
     scenarioId,
     sessionId: providedSessionId
   };
-  runtime.socketSessions.set(ws, resolved);
+  runtime.socketSessions.set(identity, resolved);
   return resolved;
 };
 var resolveSocketQuery = (ws) => ws.data && typeof ws.data === "object" && ("query" in ws.data) ? ws.data.query ?? {} : {};
@@ -40158,30 +40164,55 @@ var voice = (config) => {
     socketSessions: new WeakMap
   };
   const authorizedSockets = new WeakSet;
-  const authorizeSocket = async (ws, sessionId, scenarioId) => {
-    if (!config.authorizeConnection) {
-      authorizedSockets.add(ws);
+  const closedSockets = new WeakSet;
+  const pendingSocketAuthorizations = new WeakMap;
+  const authorizeSocket = (ws, sessionId, scenarioId) => {
+    const identity = socketIdentity(ws);
+    const existing = pendingSocketAuthorizations.get(identity);
+    if (existing)
+      return existing;
+    const authorization = (async () => {
+      if (closedSockets.has(identity) || !socketIsOpen(ws))
+        return false;
+      if (!config.authorizeConnection) {
+        authorizedSockets.add(identity);
+        return true;
+      }
+      let authorized = false;
+      try {
+        authorized = await config.authorizeConnection({
+          context: ws.data,
+          headers: resolveSocketHeaders(ws),
+          path: config.path,
+          query: resolveSocketQuery(ws),
+          scenarioId,
+          sessionId
+        });
+      } catch (error) {
+        runtime.logger.warn?.(`[voice] connection authorization failed for session "${sessionId}": ${error instanceof Error ? error.message : String(error)}`);
+      }
+      if (closedSockets.has(identity) || !socketIsOpen(ws))
+        return false;
+      if (!authorized) {
+        ws.close(4401, "unauthorized");
+        return false;
+      }
+      authorizedSockets.add(identity);
       return true;
-    }
-    let authorized = false;
-    try {
-      authorized = await config.authorizeConnection({
-        context: ws.data,
-        headers: resolveSocketHeaders(ws),
-        path: config.path,
-        query: resolveSocketQuery(ws),
-        scenarioId,
-        sessionId
-      });
-    } catch (error) {
-      runtime.logger.warn?.(`[voice] connection authorization failed for session "${sessionId}": ${error instanceof Error ? error.message : String(error)}`);
-    }
-    if (!authorized) {
-      ws.close(4401, "unauthorized");
+    })();
+    pendingSocketAuthorizations.set(identity, authorization);
+    return authorization;
+  };
+  const waitForSocketAuthorization = async (ws) => {
+    const identity = socketIdentity(ws);
+    if (closedSockets.has(identity) || !socketIsOpen(ws))
       return false;
-    }
-    authorizedSockets.add(ws);
-    return true;
+    if (authorizedSockets.has(identity))
+      return true;
+    const pending = pendingSocketAuthorizations.get(identity);
+    if (!pending)
+      return false;
+    return await pending && !closedSockets.has(identity) && socketIsOpen(ws);
   };
   const { monitor } = config;
   const registerMonitorSession = (sessionId, handle) => {
@@ -40350,28 +40381,59 @@ var voice = (config) => {
     });
   };
   const createAndConnectSession = async (ws, sessionId, scenarioId) => {
+    const identity = socketIdentity(ws);
     const session = await createManagedSession(ws, sessionId, scenarioId);
     const typedSession = session;
+    if (closedSockets.has(identity) || !socketIsOpen(ws) || runtime.activeSockets.get(sessionId) !== identity) {
+      ws.close(1000, "superseded");
+      throw new Error("Voice socket was superseded during session creation");
+    }
+    try {
+      await session.connect(buildSocketAdapter(ws, sessionId));
+    } catch (error) {
+      runtime.logger.warn?.(`[voice] session initialization failed for "${sessionId}": ${error instanceof Error ? error.message : String(error)}`);
+      closedSockets.add(identity);
+      ws.close(1011, "voice session initialization failed");
+      throw error;
+    }
+    if (closedSockets.has(identity) || !socketIsOpen(ws) || runtime.activeSockets.get(sessionId) !== identity) {
+      await session.disconnect({
+        code: 1000,
+        reason: "superseded",
+        recoverable: true,
+        type: "close"
+      });
+      ws.close(1000, "superseded");
+      throw new Error("Voice socket was superseded during session connection");
+    }
     runtime.activeSessions.set(sessionId, typedSession);
     registerMonitorSession(sessionId, typedSession);
-    await session.connect(buildSocketAdapter(ws, sessionId));
     return typedSession;
   };
   const ensureManagedSession = async (ws, sessionId, scenarioId) => {
+    const identity = socketIdentity(ws);
+    if (closedSockets.has(identity) || !socketIsOpen(ws) || runtime.activeSockets.get(sessionId) !== identity) {
+      throw new Error("Voice socket is no longer active");
+    }
     const active = runtime.activeSessions.get(sessionId);
     if (active) {
       return active;
     }
     const inFlight = runtime.pendingSessions.get(sessionId);
-    if (inFlight) {
-      return inFlight;
+    if (inFlight?.identity === identity) {
+      return inFlight.promise;
     }
     const creation = createAndConnectSession(ws, sessionId, scenarioId);
-    runtime.pendingSessions.set(sessionId, creation);
+    runtime.pendingSessions.set(sessionId, {
+      identity,
+      promise: creation
+    });
     try {
       return await creation;
     } finally {
-      runtime.pendingSessions.delete(sessionId);
+      if (runtime.pendingSessions.get(sessionId)?.promise === creation) {
+        runtime.pendingSessions.delete(sessionId);
+      }
     }
   };
   const mountSurface = (app, value, factory) => {
@@ -40491,8 +40553,10 @@ var voice = (config) => {
   };
   return new Elysia70({ name: "absolutejs-voice" }).ws(config.path, {
     close: async (ws, code, reason) => {
-      const socketState = runtime.socketSessions.get(ws);
-      if (!socketState || runtime.activeSockets.get(socketState.sessionId) !== ws) {
+      const identity = socketIdentity(ws);
+      closedSockets.add(identity);
+      const socketState = runtime.socketSessions.get(identity);
+      if (!socketState || runtime.activeSockets.get(socketState.sessionId) !== identity) {
         return;
       }
       runtime.activeSockets.delete(socketState.sessionId);
@@ -40509,7 +40573,7 @@ var voice = (config) => {
       }
     },
     message: async (ws, raw) => {
-      if (!authorizedSockets.has(ws)) {
+      if (!await waitForSocketAuthorization(ws)) {
         ws.close(4401, "unauthorized");
         return;
       }
@@ -40595,8 +40659,8 @@ var voice = (config) => {
             deregisterMonitorSession(sessionState.sessionId, "session-switch");
           }
           sessionState.sessionId = message.sessionId;
-          runtime.activeSockets.set(message.sessionId, ws);
-          runtime.socketSessions.set(ws, {
+          runtime.activeSockets.set(message.sessionId, socketIdentity(ws));
+          runtime.socketSessions.set(socketIdentity(ws), {
             ...sessionState,
             sessionId: message.sessionId,
             scenarioId: sessionState.scenarioId
@@ -40604,7 +40668,7 @@ var voice = (config) => {
         }
         if (message.type === "start" && message.scenarioId) {
           sessionState.scenarioId = message.scenarioId;
-          runtime.socketSessions.set(ws, {
+          runtime.socketSessions.set(socketIdentity(ws), {
             ...sessionState,
             scenarioId: message.scenarioId
           });
@@ -40618,24 +40682,33 @@ var voice = (config) => {
       const session = current ?? await ensureManagedSession(ws, sessionState.sessionId, sessionState.scenarioId ?? undefined);
       await session.receiveAudio(audio);
     },
-    open: async (ws) => {
+    open: (ws) => {
       const sessionState = resolveSessionId3(runtime, ws);
-      if (!await authorizeSocket(ws, sessionState.sessionId, sessionState.scenarioId ?? undefined)) {
-        return;
-      }
-      const existing = runtime.activeSessions.get(sessionState.sessionId);
-      runtime.activeSockets.set(sessionState.sessionId, ws);
-      if (existing) {
-        await existing.disconnect({
-          code: 1006,
-          reason: "superseded",
-          recoverable: true,
-          type: "close"
-        });
-        runtime.activeSessions.delete(sessionState.sessionId);
-        deregisterMonitorSession(sessionState.sessionId, "superseded");
-      }
-      await ensureManagedSession(ws, sessionState.sessionId, sessionState.scenarioId ?? undefined);
+      (async () => {
+        if (!await authorizeSocket(ws, sessionState.sessionId, sessionState.scenarioId ?? undefined)) {
+          return;
+        }
+        const identity = socketIdentity(ws);
+        if (closedSockets.has(identity) || !socketIsOpen(ws))
+          return;
+        const existing = runtime.activeSessions.get(sessionState.sessionId);
+        runtime.activeSockets.set(sessionState.sessionId, identity);
+        if (existing) {
+          await existing.disconnect({
+            code: 1006,
+            reason: "superseded",
+            recoverable: true,
+            type: "close"
+          });
+          runtime.activeSessions.delete(sessionState.sessionId);
+          deregisterMonitorSession(sessionState.sessionId, "superseded");
+        }
+        await ensureManagedSession(ws, sessionState.sessionId, sessionState.scenarioId ?? undefined);
+      })().catch((error) => {
+        if (closedSockets.has(socketIdentity(ws)))
+          return;
+        runtime.logger.warn?.(`[voice] session initialization failed for "${sessionState.sessionId}": ${error instanceof Error ? error.message : String(error)}`);
+      });
     }
   }).use(htmxRoutes()).use(surfaceRoutes());
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@absolutejs/voice",
-  "version": "0.0.22-beta.657",
+  "version": "0.0.22-beta.659",
   "description": "Voice primitives and Elysia plugin for AbsoluteJS",
   "repository": {
     "type": "git",