Merge remote-tracking branch 'origin/dev' into cloud/issues-048-merge

Author: isaiahb

cloud/packages/cloud/src/services/session/AppAudioStreamManager.ts

@@ -151,6 +151,9 @@ export class AppAudioStreamManager {
   /** This user's active streams (typically 0 or 1) */
   private streams = new Map<string, ActiveStream>();
 
+  /** Timers for deferred stream cleanup — tracked so dispose() can cancel them */
+  private pendingCleanupTimers = new Set<NodeJS.Timeout>();
+
   private disposed = false;
 
   constructor(userId: string, logger: Logger, sendPlayRequest: SendPlayRequestFn) {
@@ -286,7 +289,11 @@ export class AppAudioStreamManager {
       writer.close().catch(() => {});
       // Clean up the stream entry after a short delay to let the HTTP
       // response drain
-      setTimeout(() => this.streams.delete(streamId), 1000);
+      const timer = setTimeout(() => {
+        this.pendingCleanupTimers.delete(timer);
+        this.streams.delete(streamId);
+      }, 1000);
+      this.pendingCleanupTimers.add(timer);
     } else {
       // Start the abandon timeout (resets on each write from the SDK)
       this.resetAbandonTimer(streamId, stream);
@@ -351,7 +358,11 @@ export class AppAudioStreamManager {
         // Already closed
       }
       // Clean up after a short delay to let HTTP response drain
-      setTimeout(() => this.streams.delete(streamId), 1000);
+      const timer = setTimeout(() => {
+        this.pendingCleanupTimers.delete(timer);
+        this.streams.delete(streamId);
+      }, 1000);
+      this.pendingCleanupTimers.add(timer);
     } else if (stream.pendingChunks.length > 0) {
       // There's buffered audio but no phone reader. The next claimStream()
       // call will flush it and then close. If the phone never reconnects,
@@ -414,6 +425,12 @@ export class AppAudioStreamManager {
       this.destroyStream(streamId);
     }
 
+    // Clear any pending cleanup timers so their closures don't prevent GC
+    for (const timer of this.pendingCleanupTimers) {
+      clearTimeout(timer);
+    }
+    this.pendingCleanupTimers.clear();
+
     this.logger.debug("AppAudioStreamManager disposed");
   }
 

cloud/packages/cloud/src/services/session/AppManager.ts

@@ -666,6 +666,13 @@ export class AppManager {
         return new Promise<AppStartResult>((resolve) => {
           // Set up a listener for when the existing attempt completes
           const checkCompletion = () => {
+            // Guard: if the session was disposed while we were polling,
+            // resolve immediately to avoid holding a reference to the dead session.
+            if (this.disposed) {
+              resolve({ success: false, error: { stage: "CONNECTION", message: "Session disposed while waiting" } });
+              return;
+            }
+
             if (!this.pendingConnections.has(packageName)) {
               // Existing attempt completed, check final state
               if (this.userSession.runningApps.has(packageName)) {

cloud/packages/cloud/src/services/session/UserSession.ts

@@ -33,6 +33,7 @@ import CalendarManager from "./CalendarManager";
 import { DashboardManager } from "./dashboard";
 import DeviceManager from "./DeviceManager";
 import { handleAppMessage as appMessageHandler, handleGlassesMessage as glassesMessageHandler } from "./handlers";
+import { clearSubscriptionChangeTimer } from "./handlers/app-message-handler";
 import LocationManager from "./LocationManager";
 import MicrophoneManager from "./MicrophoneManager";
 import PhotoManager from "./PhotoManager";
@@ -443,6 +444,7 @@ export class UserSession {
     if (this.microphoneManager) {
       this.logger.info(`[UserSession:updateWebSocket] Scheduling mic state resync after WebSocket reconnect`);
       setTimeout(() => {
+        if (this.disposed) return;
         if (this.microphoneManager && this.websocket?.readyState === WebSocketReadyState.OPEN) {
           this.logger.info(`[UserSession:updateWebSocket] Forcing mic state resync after WebSocket reconnect`);
           this.microphoneManager.forceResync();
@@ -777,6 +779,17 @@ export class UserSession {
 
     this.logger.warn(`[UserSession:dispose]: Disposing UserSession: ${this.userId}`);
 
+    // Clear the subscription-change debounce timer for this user. Its closure
+    // captures `userSession`, so leaving it alive would prevent GC of the
+    // disposed UserSession until the timer fires.
+    // Only clear if this is still the active session for this userId — during
+    // reconnect races, a stale session's dispose must not cancel the newer
+    // session's pending subscription-change timer. The timer map is keyed by
+    // userId, so a blind clear would affect whichever session currently owns it.
+    if (UserSession.sessions.get(this.userId) === this || !UserSession.sessions.has(this.userId)) {
+      clearSubscriptionChangeTimer(this.userId);
+    }
+
     // Clean up all tracked resources (removes event listeners, clears timers)
     // This must happen BEFORE disposing managers to prevent stale callbacks
     this.resources.dispose();

cloud/packages/cloud/src/services/session/handlers/app-message-handler.ts

@@ -63,6 +63,21 @@ export enum AppErrorCode {
 const subscriptionChangeTimers = new Map<string, NodeJS.Timeout>();
 const SUBSCRIPTION_DEBOUNCE_MS = 500;
 
+/**
+ * Clears any pending subscription-change debounce timer for the given user.
+ *
+ * Must be called from UserSession.dispose() to prevent the timer's closure
+ * from holding a strong reference to the disposed UserSession, which would
+ * keep the entire session object graph alive until the debounce fires.
+ */
+export function clearSubscriptionChangeTimer(userId: string): void {
+  const timer = subscriptionChangeTimers.get(userId);
+  if (timer) {
+    clearTimeout(timer);
+    subscriptionChangeTimers.delete(userId);
+  }
+}
+
 /**
  * Handle incoming app message by routing to appropriate managers
  *

cloud/packages/cloud/src/services/session/translation/providers/SonioxTranslationProvider.ts

@@ -156,6 +156,13 @@ class SonioxTranslationStream implements TranslationStreamInstance {
   }
 
   private async connect(): Promise<void> {
+    // Silently return instead of rejecting — closeHandler schedules
+    // setTimeout(() => this.connect(), ...) without .catch(), so rejecting
+    // here would create an unhandled rejection during normal shutdown.
+    if (this.disposed || this.isClosing) {
+      return;
+    }
+
     return new Promise((resolve, reject) => {
       try {
         // Create WebSocket connection