@mentra/sdk 2.1.29-beta.2 → 2.1.29

package/dist/index.js

@@ -326,6 +326,8 @@ var init_message_types = __esm(() => {
     GlassesToCloudMessageType2["AUDIO_PLAY_RESPONSE"] = "audio_play_response";
     GlassesToCloudMessageType2["RGB_LED_CONTROL_RESPONSE"] = "rgb_led_control_response";
     GlassesToCloudMessageType2["LIVEKIT_INIT"] = "livekit_init";
+    GlassesToCloudMessageType2["UDP_REGISTER"] = "udp_register";
+    GlassesToCloudMessageType2["UDP_UNREGISTER"] = "udp_unregister";
   })(GlassesToCloudMessageType ||= {});
   ((CloudToGlassesMessageType2) => {
     CloudToGlassesMessageType2["CONNECTION_ACK"] = "connection_ack";
@@ -349,6 +351,7 @@ var init_message_types = __esm(() => {
     CloudToGlassesMessageType2["REQUEST_SINGLE_LOCATION"] = "request_single_location";
     CloudToGlassesMessageType2["WEBSOCKET_ERROR"] = "websocket_error";
     CloudToGlassesMessageType2["LIVEKIT_INFO"] = "livekit_info";
+    CloudToGlassesMessageType2["UDP_PING_ACK"] = "udp_ping_ack";
   })(CloudToGlassesMessageType ||= {});
   ((AppToCloudMessageType2) => {
     AppToCloudMessageType2["CONNECTION_INIT"] = "tpa_connection_init";
@@ -373,6 +376,7 @@ var init_message_types = __esm(() => {
     AppToCloudMessageType2["APP_USER_DISCOVERY"] = "app_user_discovery";
     AppToCloudMessageType2["APP_ROOM_JOIN"] = "app_room_join";
     AppToCloudMessageType2["APP_ROOM_LEAVE"] = "app_room_leave";
+    AppToCloudMessageType2["OWNERSHIP_RELEASE"] = "ownership_release";
   })(AppToCloudMessageType ||= {});
   ((CloudToAppMessageType2) => {
     CloudToAppMessageType2["CONNECTION_ACK"] = "tpa_connection_ack";
@@ -380,6 +384,7 @@ var init_message_types = __esm(() => {
     CloudToAppMessageType2["APP_STOPPED"] = "app_stopped";
     CloudToAppMessageType2["SETTINGS_UPDATE"] = "settings_update";
     CloudToAppMessageType2["CAPABILITIES_UPDATE"] = "capabilities_update";
+    CloudToAppMessageType2["DEVICE_STATE_UPDATE"] = "device_state_update";
     CloudToAppMessageType2["DASHBOARD_MODE_CHANGED"] = "dashboard_mode_changed";
     CloudToAppMessageType2["DASHBOARD_ALWAYS_ON_CHANGED"] = "dashboard_always_on_changed";
     CloudToAppMessageType2["DATA_STREAM"] = "data_stream";
@@ -735,6 +740,12 @@ function isAudioPlayResponse(message) {
 function isLocalTranscription(message) {
   return message.type === "local_transcription" /* LOCAL_TRANSCRIPTION */;
 }
+function isUdpRegister(message) {
+  return message.type === "udp_register" /* UDP_REGISTER */;
+}
+function isUdpUnregister(message) {
+  return message.type === "udp_unregister" /* UDP_UNREGISTER */;
+}
 // src/types/messages/cloud-to-glasses.ts
 init_message_types();
 function isResponse(message) {
@@ -829,6 +840,9 @@ function isRtmpStreamRequest(message) {
 function isRtmpStreamStopRequest(message) {
   return message.type === "rtmp_stream_stop" /* RTMP_STREAM_STOP */;
 }
+function isOwnershipRelease(message) {
+  return message.type === "ownership_release" /* OWNERSHIP_RELEASE */;
+}
 // src/utils/bitmap-utils.ts
 import * as fs from "fs/promises";
 import * as path from "path";
@@ -1339,6 +1353,9 @@ function isSettingsUpdate2(message) {
 function isCapabilitiesUpdate(message) {
   return message.type === "capabilities_update" /* CAPABILITIES_UPDATE */;
 }
+function isDeviceStateUpdate(message) {
+  return message.type === "device_state_update" /* DEVICE_STATE_UPDATE */;
+}
 function isDataStream(message) {
   return message.type === "data_stream" /* DATA_STREAM */;
 }
@@ -1906,6 +1923,9 @@ class EventManager {
       this.unsubscribe(type);
     }
   }
+  getRegisteredStreams() {
+    return Array.from(this.handlers.keys());
+  }
   emit(event, data) {
     try {
       this.emitter.emit(event, data);
@@ -2195,7 +2215,7 @@ class ApiClient {
 import pino from "pino";
 var BETTERSTACK_SOURCE_TOKEN = process.env.BETTERSTACK_SOURCE_TOKEN;
 var BETTERSTACK_ENDPOINT = process.env.BETTERSTACK_ENDPOINT || "https://s1311181.eu-nbg-2.betterstackdata.com";
-var NODE_ENV = "isaiah";
+var NODE_ENV = "aryan";
 var PORTER_APP_NAME = process.env.PORTER_APP_NAME || "cloud-local";
 var LOG_LEVEL = NODE_ENV === "production" ? "info" : "debug";
 var streams2 = [];
@@ -2635,7 +2655,6 @@ class CameraModule {
   packageName;
   sessionId;
   logger;
-  pendingPhotoRequests = new Map;
   isStreaming = false;
   currentStreamUrl;
   currentStreamState;
@@ -2652,9 +2671,15 @@ class CameraModule {
       const baseUrl = this.session?.getHttpsServerUrl?.() || "";
       cameraWarnLog(baseUrl, this.packageName, "requestPhoto");
       try {
-        console.log("DEBUG: requestPhoto options:", options);
         const requestId = `photo_req_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-        this.pendingPhotoRequests.set(requestId, { resolve, reject });
+        this.session.appServer.registerPhotoRequest(requestId, {
+          userId: this.session.userId,
+          sessionId: this.sessionId,
+          session: this.session,
+          resolve,
+          reject: (error) => reject(error.message),
+          timestamp: Date.now()
+        });
         const message = {
           type: "photo_request" /* PHOTO_REQUEST */,
           packageName: this.packageName,
@@ -2676,91 +2701,41 @@ class CameraModule {
         }, `\uD83D\uDCF8 Photo request sent`);
         if (options?.customWebhookUrl) {
           this.logger.info({ requestId, customWebhookUrl: options.customWebhookUrl }, `\uD83D\uDCF8 Using custom webhook URL - resolving promise immediately since photo will be uploaded directly to custom endpoint`);
-          const mockPhotoData = {
-            buffer: Buffer.from([]),
-            mimeType: "image/jpeg",
-            filename: "photo.jpg",
-            requestId,
-            size: 0,
-            timestamp: new Date
-          };
-          this.pendingPhotoRequests.delete(requestId);
-          resolve(mockPhotoData);
+          const pending = this.session.appServer.completePhotoRequest(requestId);
+          if (pending) {
+            const mockPhotoData = {
+              buffer: Buffer.from([]),
+              mimeType: "image/jpeg",
+              filename: "photo.jpg",
+              requestId,
+              size: 0,
+              timestamp: new Date
+            };
+            pending.resolve(mockPhotoData);
+          }
           return;
         }
-        const timeoutMs = 30000;
-        if (this.session && this.session.resources) {
-          this.session.resources.setTimeout(() => {
-            if (this.pendingPhotoRequests.has(requestId)) {
-              this.pendingPhotoRequests.get(requestId).reject("Photo request timed out");
-              this.pendingPhotoRequests.delete(requestId);
-              this.logger.warn({ requestId }, `\uD83D\uDCF8 Photo request timed out`);
-            }
-          }, timeoutMs);
-        } else {
-          setTimeout(() => {
-            if (this.pendingPhotoRequests.has(requestId)) {
-              this.pendingPhotoRequests.get(requestId).reject("Photo request timed out");
-              this.pendingPhotoRequests.delete(requestId);
-              this.logger.warn({ requestId }, `\uD83D\uDCF8 Photo request timed out`);
-            }
-          }, timeoutMs);
-        }
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         reject(`Failed to request photo: ${errorMessage}`);
       }
     });
   }
-  handlePhotoReceived(photoData) {
-    const { requestId } = photoData;
-    const pendingRequest = this.pendingPhotoRequests.get(requestId);
-    if (pendingRequest) {
-      this.logger.info({ requestId }, `\uD83D\uDCF8 Photo received for request ${requestId}`);
-      pendingRequest.resolve(photoData);
-      this.pendingPhotoRequests.delete(requestId);
-    } else {
-      this.logger.warn({ requestId }, `\uD83D\uDCF8 Received photo for unknown request ID: ${requestId}`);
-    }
-  }
-  handlePhotoError(errorResponse) {
-    const { requestId, error } = errorResponse;
-    const pendingRequest = this.pendingPhotoRequests.get(requestId);
-    if (pendingRequest) {
-      this.logger.error({ requestId, errorCode: error.code, errorMessage: error.message }, `\uD83D\uDCF8 Photo capture failed: ${error.code} - ${error.message}`);
-      pendingRequest.reject(`${error.code}: ${error.message}`);
-      this.pendingPhotoRequests.delete(requestId);
-    } else {
-      this.logger.warn({ requestId, errorCode: error.code, errorMessage: error.message }, `\uD83D\uDCF8 Received photo error for unknown request ID: ${requestId}`);
-    }
-  }
   hasPhotoPendingRequest(requestId) {
-    return this.pendingPhotoRequests.has(requestId);
-  }
-  getPhotoPendingRequestCount() {
-    return this.pendingPhotoRequests.size;
-  }
-  getPhotoPendingRequestIds() {
-    return Array.from(this.pendingPhotoRequests.keys());
+    return this.session.appServer.getPhotoRequest(requestId) !== undefined;
   }
   cancelPhotoRequest(requestId) {
-    const pendingRequest = this.pendingPhotoRequests.get(requestId);
-    if (pendingRequest) {
-      pendingRequest.reject("Photo request cancelled");
-      this.pendingPhotoRequests.delete(requestId);
+    const pending = this.session.appServer.completePhotoRequest(requestId);
+    if (pending) {
+      pending.reject(new Error("Photo request cancelled"));
       this.logger.info({ requestId }, `\uD83D\uDCF8 Photo request cancelled`);
       return true;
     }
     return false;
   }
   cancelAllPhotoRequests() {
-    const count = this.pendingPhotoRequests.size;
-    for (const [requestId, { reject }] of this.pendingPhotoRequests) {
-      reject("Photo request cancelled - session cleanup");
-      this.logger.info({ requestId }, `\uD83D\uDCF8 Photo request cancelled during cleanup`);
-    }
-    this.pendingPhotoRequests.clear();
-    return count;
+    this.logger.debug(`\uD83D\uDCF8 cancelAllPhotoRequests called - cleanup now happens at AppServer level`);
+    return 0;
   }
   async startStream(options) {
     this.logger.info({ rtmpUrl: options.rtmpUrl }, `\uD83D\uDCF9 RTMP stream request starting`);
@@ -3527,7 +3502,151 @@ class SimpleStorage {
   }
 }
 
+// src/utils/Observable.ts
+class Observable {
+  _value;
+  _listeners = new Set;
+  _initialized = false;
+  constructor(initialValue) {
+    this._value = initialValue;
+  }
+  get value() {
+    return this._value;
+  }
+  valueOf() {
+    return this._value;
+  }
+  toString() {
+    return String(this._value);
+  }
+  [Symbol.toPrimitive](hint) {
+    if (hint === "string") {
+      return String(this._value);
+    }
+    return this._value;
+  }
+  onChange(callback) {
+    this._listeners.add(callback);
+    if (this._initialized) {
+      callback(this._value);
+    }
+    return () => this._listeners.delete(callback);
+  }
+  setValue(value) {
+    const isFirstInit = !this._initialized;
+    if (isFirstInit) {
+      this._initialized = true;
+    }
+    if (isFirstInit || this._value !== value) {
+      this._value = value;
+      this._listeners.forEach((cb) => {
+        try {
+          cb(value);
+        } catch (error) {
+          console.error("Error in Observable onChange callback:", error);
+        }
+      });
+    }
+  }
+  get listenerCount() {
+    return this._listeners.size;
+  }
+}
+
+// src/app/session/device-state.ts
+class DeviceState {
+  wifiConnected;
+  wifiSsid;
+  wifiLocalIp;
+  batteryLevel;
+  charging;
+  caseBatteryLevel;
+  caseCharging;
+  caseOpen;
+  caseRemoved;
+  hotspotEnabled;
+  hotspotSsid;
+  connected;
+  modelName;
+  appSession;
+  constructor(appSession) {
+    this.appSession = appSession;
+    this.wifiConnected = new Observable(false);
+    this.wifiSsid = new Observable(null);
+    this.wifiLocalIp = new Observable(null);
+    this.batteryLevel = new Observable(null);
+    this.charging = new Observable(null);
+    this.caseBatteryLevel = new Observable(null);
+    this.caseCharging = new Observable(null);
+    this.caseOpen = new Observable(null);
+    this.caseRemoved = new Observable(null);
+    this.hotspotEnabled = new Observable(null);
+    this.hotspotSsid = new Observable(null);
+    this.connected = new Observable(false);
+    this.modelName = new Observable(null);
+  }
+  updateFromMessage(state) {
+    if (state.connected !== undefined) {
+      this.connected.setValue(state.connected);
+    }
+    if (state.modelName !== undefined) {
+      this.modelName.setValue(state.modelName);
+    }
+    if (state.wifiConnected !== undefined) {
+      this.wifiConnected.setValue(state.wifiConnected);
+    }
+    if (state.wifiSsid !== undefined) {
+      this.wifiSsid.setValue(state.wifiSsid ?? null);
+    }
+    if (state.wifiLocalIp !== undefined) {
+      this.wifiLocalIp.setValue(state.wifiLocalIp ?? null);
+    }
+    if (state.batteryLevel !== undefined) {
+      this.batteryLevel.setValue(state.batteryLevel ?? null);
+    }
+    if (state.charging !== undefined) {
+      this.charging.setValue(state.charging ?? null);
+    }
+    if (state.caseBatteryLevel !== undefined) {
+      this.caseBatteryLevel.setValue(state.caseBatteryLevel ?? null);
+    }
+    if (state.caseCharging !== undefined) {
+      this.caseCharging.setValue(state.caseCharging ?? null);
+    }
+    if (state.caseOpen !== undefined) {
+      this.caseOpen.setValue(state.caseOpen ?? null);
+    }
+    if (state.caseRemoved !== undefined) {
+      this.caseRemoved.setValue(state.caseRemoved ?? null);
+    }
+    if (state.hotspotEnabled !== undefined) {
+      this.hotspotEnabled.setValue(state.hotspotEnabled ?? null);
+    }
+    if (state.hotspotSsid !== undefined) {
+      this.hotspotSsid.setValue(state.hotspotSsid ?? null);
+    }
+  }
+  getSnapshot() {
+    return {
+      connected: this.connected.value,
+      modelName: this.modelName.value ?? undefined,
+      wifiConnected: this.wifiConnected.value,
+      wifiSsid: this.wifiSsid.value ?? undefined,
+      wifiLocalIp: this.wifiLocalIp.value ?? undefined,
+      batteryLevel: this.batteryLevel.value ?? undefined,
+      charging: this.charging.value ?? undefined,
+      caseBatteryLevel: this.caseBatteryLevel.value ?? undefined,
+      caseCharging: this.caseCharging.value ?? undefined,
+      caseOpen: this.caseOpen.value ?? undefined,
+      caseRemoved: this.caseRemoved.value ?? undefined,
+      hotspotEnabled: this.hotspotEnabled.value ?? undefined,
+      hotspotSsid: this.hotspotSsid.value ?? undefined
+    };
+  }
+}
+
 // src/app/session/index.ts
+var SDK_SUBSCRIPTION_PATCH = "bug007-fix-v2";
 var APP_TO_APP_EVENT_TYPES = [
   "app_message_received",
   "app_user_joined",
@@ -3541,7 +3660,7 @@ class AppSession {
   ws = null;
   sessionId = null;
   reconnectAttempts = 0;
-  subscriptions = new Set;
+  terminated = false;
   streamRates = new Map;
   resources = new ResourceTracker;
   settingsData = [];
@@ -3560,6 +3679,7 @@ class AppSession {
   led;
   audio;
   simpleStorage;
+  device;
   appServer;
   logger;
   userId;
@@ -3609,18 +3729,14 @@ class AppSession {
     this.layouts = new LayoutManager(config.packageName, this.send.bind(this));
     this.settings = new SettingsManager(this.settingsData, this.config.packageName, this.config.mentraOSWebsocketUrl, this.sessionId ?? undefined, async (streams3) => {
       this.logger.debug({ streams: JSON.stringify(streams3) }, `[AppSession] subscribeFn called for streams`);
-      streams3.forEach((stream) => {
-        if (!this.subscriptions.has(stream)) {
-          this.subscriptions.add(stream);
-          this.logger.debug(`[AppSession] Auto-subscribed to stream '${stream}' for MentraOS setting.`);
-        } else {
-          this.logger.debug(`[AppSession] Already subscribed to stream '${stream}'.`);
-        }
-      });
-      this.logger.debug({ subscriptions: JSON.stringify(Array.from(this.subscriptions)) }, `[AppSession] Current subscriptions after subscribeFn`);
+      const currentHandlerStreams = this.events.getRegisteredStreams();
+      this.logger.debug({
+        requestedStreams: JSON.stringify(streams3),
+        currentHandlerStreams: JSON.stringify(currentHandlerStreams)
+      }, `[AppSession] subscribeFn: requested streams vs current handler streams`);
       if (this.ws?.readyState === 1) {
         this.updateSubscriptions();
-        this.logger.debug(`[AppSession] Sent updated subscriptions to cloud after auto-subscribing to MentraOS setting.`);
+        this.logger.debug(`[AppSession] Sent updated subscriptions to cloud (derived from handlers).`);
       } else {
         this.logger.debug(`[AppSession] WebSocket not open, will send subscriptions when connected.`);
       }
@@ -3631,6 +3747,7 @@ class AppSession {
     this.led = new LedModule(this, this.config.packageName, this.sessionId || "unknown-session-id", this.logger.child({ module: "led" }));
     this.audio = new AudioManager(this, this.config.packageName, this.sessionId || "unknown-session-id", this.logger.child({ module: "audio" }));
     this.simpleStorage = new SimpleStorage(this);
+    this.device = { state: new DeviceState(this) };
     this.location = new LocationManager(this);
   }
   getSessionId() {
@@ -3697,7 +3814,6 @@ class AppSession {
       this.logger.warn(`[AppSession] Attempted to subscribe to App-to-App event type '${type}', which is not a valid stream. Use the event handler (e.g., onAppMessage) instead.`);
       return;
     }
-    this.subscriptions.add(type);
     if (rate) {
       this.streamRates.set(type, rate);
     }
@@ -3716,7 +3832,6 @@ class AppSession {
       this.logger.warn(`[AppSession] Attempted to unsubscribe from App-to-App event type '${type}', which is not a valid stream.`);
       return;
     }
-    this.subscriptions.delete(type);
     this.streamRates.delete(type);
     if (this.ws?.readyState === 1) {
       this.updateSubscriptions();
@@ -3840,11 +3955,15 @@ class AppSession {
           const isUserSessionEnded = reason && reason.includes("User session ended");
           this.logger.debug(`\uD83D\uDD0C [${this.config.packageName}] WebSocket closed with code ${code}${reasonStr}`);
           this.logger.debug(`\uD83D\uDD0C [${this.config.packageName}] isNormalClosure: ${isNormalClosure}, isManualStop: ${isManualStop}, isUserSessionEnded: ${isUserSessionEnded}`);
-          if (!isNormalClosure && !isManualStop) {
+          if (isUserSessionEnded) {
+            this.terminated = true;
+            this.logger.info(`\uD83D\uDED1 [${this.config.packageName}] User session ended - marking as terminated, no reconnection allowed`);
+          }
+          if (!isNormalClosure && !isManualStop && !this.terminated) {
             this.logger.warn(`\uD83D\uDD0C [${this.config.packageName}] Abnormal closure detected, attempting reconnection`);
             this.handleReconnection();
           } else {
-            this.logger.debug(`\uD83D\uDD0C [${this.config.packageName}] Normal closure detected, not attempting reconnection`);
+            this.logger.debug(`\uD83D\uDD0C [${this.config.packageName}] Normal/terminated closure detected, not attempting reconnection (terminated: ${this.terminated})`);
           }
           if (isUserSessionEnded) {
             this.logger.info(`\uD83D\uDED1 [${this.config.packageName}] User session ended - emitting disconnected event with sessionEnded flag`);
@@ -3908,7 +4027,26 @@ class AppSession {
       }
     });
   }
-  async disconnect() {
+  async releaseOwnership(reason) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      this.logger.debug(`[${this.config.packageName}] Cannot release ownership - WebSocket not open`);
+      return;
+    }
+    const message = {
+      type: "ownership_release" /* OWNERSHIP_RELEASE */,
+      packageName: this.config.packageName,
+      sessionId: this.sessionId || "",
+      reason,
+      timestamp: new Date
+    };
+    this.logger.info({ reason, sessionId: this.sessionId }, `\uD83D\uDD04 [${this.config.packageName}] Releasing ownership: ${reason}`);
+    this.send(message);
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  async disconnect(options) {
+    if (options?.releaseOwnership && options?.reason) {
+      await this.releaseOwnership(options.reason);
+    }
     try {
       await this.simpleStorage.flush();
       console.log("SimpleStorage flushed on disconnect");
@@ -3924,7 +4062,6 @@ class AppSession {
     this.resources.dispose();
     this.ws = null;
     this.sessionId = null;
-    this.subscriptions.clear();
     this.reconnectAttempts = 0;
   }
   getSettings() {
@@ -3945,11 +4082,14 @@ class AppSession {
     if (!this.subscriptionSettingsHandler)
       return;
     try {
-      const newSubscriptions = this.subscriptionSettingsHandler(this.settingsData);
-      this.subscriptions.clear();
-      newSubscriptions.forEach((subscription) => {
-        this.subscriptions.add(subscription);
-      });
+      const settingsSubscriptions = this.subscriptionSettingsHandler(this.settingsData);
+      const handlerStreams = this.events.getRegisteredStreams();
+      if (settingsSubscriptions.length !== handlerStreams.length) {
+        this.logger.warn({
+          settingsSubscriptions: JSON.stringify(settingsSubscriptions),
+          handlerStreams: JSON.stringify(handlerStreams)
+        }, `[AppSession] Settings-based subscriptions (${settingsSubscriptions.length}) differ from handler-based subscriptions (${handlerStreams.length}). ` + `Subscriptions are now derived from handlers. Ensure handlers are registered for desired streams.`);
+      }
       if (this.ws && this.ws.readyState === 1) {
         this.updateSubscriptions();
       }
@@ -4079,6 +4219,8 @@ class AppSession {
             this.logger.debug(`[AppSession] No capabilities provided in CONNECTION_ACK`);
           }
           this.events.emit("connected", this.settingsData);
+          const handlerCount = this.events.getRegisteredStreams().length;
+          this.logger.info({ patch: SDK_SUBSCRIPTION_PATCH, handlerCount }, `[AppSession] \uD83D\uDD27 SDK Patch Active: ${SDK_SUBSCRIPTION_PATCH} - Subscriptions derived from ${handlerCount} handler(s)`);
           this.updateSubscriptions();
           if (this.shouldUpdateSubscriptionsOnSettingsChange && this.settingsData.length > 0) {
             this.updateSubscriptionsFromSettings();
@@ -4087,28 +4229,33 @@ class AppSession {
           const errorMessage = message.message || "Unknown connection error";
           this.events.emit("error", new Error(errorMessage));
         } else if (message.type === "audio_chunk" /* AUDIO_CHUNK */) {
-          if (this.subscriptions.has("audio_chunk" /* AUDIO_CHUNK */)) {
+          const hasAudioHandler = this.events.getRegisteredStreams().includes("audio_chunk" /* AUDIO_CHUNK */);
+          if (hasAudioHandler) {
             this.events.emit("audio_chunk" /* AUDIO_CHUNK */, message);
           }
         } else if (isDataStream(message) && message.streamType === "glasses_connection_state" /* GLASSES_CONNECTION_STATE */) {
           this.glassesConnectionState = message.data;
-          if (this.subscriptions.has("glasses_connection_state" /* GLASSES_CONNECTION_STATE */)) {
+          const hasGlassesStateHandler = this.events.getRegisteredStreams().includes("glasses_connection_state" /* GLASSES_CONNECTION_STATE */);
+          if (hasGlassesStateHandler) {
             const sanitizedData = this.sanitizeEventData("glasses_connection_state" /* GLASSES_CONNECTION_STATE */, message.data);
             this.events.emit("glasses_connection_state" /* GLASSES_CONNECTION_STATE */, sanitizedData);
           }
         } else if (isDataStream(message)) {
           const messageStreamType = message.streamType;
-          if (messageStreamType && this.subscriptions.has(messageStreamType)) {
+          const hasHandler = this.events.getRegisteredStreams().includes(messageStreamType);
+          if (messageStreamType && hasHandler) {
             const sanitizedData = this.sanitizeEventData(messageStreamType, message.data);
             this.events.emit(messageStreamType, sanitizedData);
           }
         } else if (isRtmpStreamStatus2(message)) {
-          if (this.subscriptions.has("rtmp_stream_status" /* RTMP_STREAM_STATUS */)) {
+          const hasRtmpHandler = this.events.getRegisteredStreams().includes("rtmp_stream_status" /* RTMP_STREAM_STATUS */);
+          if (hasRtmpHandler) {
             this.events.emit("rtmp_stream_status" /* RTMP_STREAM_STATUS */, message);
           }
           this.camera.updateStreamState(message);
         } else if (isManagedStreamStatus(message)) {
-          if (this.subscriptions.has("managed_stream_status" /* MANAGED_STREAM_STATUS */)) {
+          const hasManagedStreamHandler = this.events.getRegisteredStreams().includes("managed_stream_status" /* MANAGED_STREAM_STATUS */);
+          if (hasManagedStreamHandler) {
             this.events.emit("managed_stream_status" /* MANAGED_STREAM_STATUS */, message);
           }
           this.camera.handleManagedStreamStatus(message);
@@ -4139,6 +4286,12 @@ class AppSession {
             modelName: capabilitiesMessage.modelName,
             timestamp: capabilitiesMessage.timestamp
           });
+        } else if (isDeviceStateUpdate(message)) {
+          this.device.state.updateFromMessage(message.state);
+          this.logger.debug({
+            changedFields: Object.keys(message.state),
+            fullSnapshot: message.fullSnapshot
+          }, `[AppSession] Device state updated via WebSocket`);
         } else if (isAppStopped(message)) {
           const reason = message.reason || "unknown";
           const displayReason = `App stopped: ${reason}`;
@@ -4245,7 +4398,8 @@ class AppSession {
   }
   handleBinaryMessage(buffer) {
     try {
-      if (!this.subscriptions.has("audio_chunk" /* AUDIO_CHUNK */)) {
+      const hasAudioHandler = this.events.getRegisteredStreams().includes("audio_chunk" /* AUDIO_CHUNK */);
+      if (!hasAudioHandler) {
         return;
       }
       if (!buffer || buffer.byteLength === 0) {
@@ -4318,8 +4472,9 @@ class AppSession {
     this.send(message);
   }
   updateSubscriptions() {
-    this.logger.info({ subscriptions: JSON.stringify(Array.from(this.subscriptions)) }, `[AppSession] updateSubscriptions: sending subscriptions to cloud`);
-    const subscriptionPayload = Array.from(this.subscriptions).map((stream) => {
+    const derivedSubscriptions = this.events.getRegisteredStreams();
+    this.logger.info({ subscriptions: JSON.stringify(derivedSubscriptions) }, `[AppSession] updateSubscriptions: sending ${derivedSubscriptions.length} subscriptions to cloud (derived from handlers)`);
+    const subscriptionPayload = derivedSubscriptions.map((stream) => {
       const rate = this.streamRates.get(stream);
       if (rate && stream === "location_stream" /* LOCATION_STREAM */) {
         return { stream: "location_stream", rate };
@@ -4336,6 +4491,10 @@ class AppSession {
     this.send(message);
   }
   async handleReconnection() {
+    if (this.terminated) {
+      this.logger.info(`\uD83D\uDD04 Reconnection skipped: session was terminated (User session ended). ` + `If cloud restarts app, onSession will be called with fresh handlers.`);
+      return;
+    }
     if (!this.config.autoReconnect || !this.sessionId) {
       this.logger.debug(`\uD83D\uDD04 Reconnection skipped: autoReconnect=${this.config.autoReconnect}, sessionId=${this.sessionId ? "valid" : "invalid"}`);
       return;
@@ -4415,7 +4574,12 @@ class AppSession {
         throw new Error(`Failed to send message: ${errorMessage}`);
       }
     } catch (error) {
-      this.logger.error(error, "Message send error");
+      const isDisconnectError = error instanceof Error && (error.message.includes("WebSocket not connected") || error.message.includes("CLOSED") || error.message.includes("CLOSING"));
+      if (isDisconnectError) {
+        this.logger.debug(error, "Message send skipped - session disconnected");
+      } else {
+        this.logger.error(error, "Message send error");
+      }
       if (error instanceof Error) {
         this.events.emit("error", error);
       } else {
@@ -4872,6 +5036,7 @@ class AppServer {
   activeSessionsByUserId = new Map;
   cleanupHandlers = [];
   appInstructions = null;
+  pendingPhotoRequests = new Map;
   logger;
   constructor(config) {
     this.config = config;
@@ -4968,10 +5133,10 @@ class AppServer {
       });
     });
   }
-  stop() {
+  async stop() {
     this.logger.info(`
 \uD83D\uDED1 Shutting down...`);
-    this.cleanup();
+    await this.cleanup();
     process.exit(0);
   }
   generateToken(userId, sessionId, secretKey) {
@@ -5046,6 +5211,23 @@ class AppServer {
     this.logger.info({ userId }, `\uD83D\uDDE3️ Received session request for user ${userId}, session ${sessionId}
 
 `);
+    const existingSession = this.activeSessions.get(sessionId);
+    if (existingSession) {
+      this.logger.info({ sessionId, userId }, `\uD83D\uDD04 Existing session found for ${sessionId} - sending OWNERSHIP_RELEASE and disconnecting before new connection`);
+      try {
+        await existingSession.releaseOwnership("switching_clouds");
+      } catch (error) {
+        this.logger.warn({ error, sessionId }, `⚠️ Failed to send OWNERSHIP_RELEASE to old session - continuing anyway`);
+      }
+      try {
+        existingSession.disconnect();
+      } catch (error) {
+        this.logger.warn({ error, sessionId }, `⚠️ Failed to disconnect old session - continuing anyway`);
+      }
+      this.activeSessions.delete(sessionId);
+      this.activeSessionsByUserId.delete(userId);
+      this.logger.info({ sessionId, userId }, `✅ Old session cleaned up, proceeding with new connection`);
+    }
     const session = new AppSession({
       packageName: this.config.packageName,
       apiKey: this.config.apiKey,
@@ -5054,25 +5236,48 @@ class AppServer {
       userId
     });
     const cleanupDisconnect = session.events.onDisconnected((info) => {
+      let isPermanent = false;
+      let reason = "unknown";
       if (typeof info === "string") {
         this.logger.info(`\uD83D\uDC4B Session ${sessionId} disconnected: ${info}`);
+        reason = info;
+        isPermanent = false;
       } else {
         this.logger.info(`\uD83D\uDC4B Session ${sessionId} disconnected: ${info.message} (code: ${info.code}, reason: ${info.reason})`);
+        reason = info.reason || info.message;
         if (info.sessionEnded === true) {
           this.logger.info(`\uD83D\uDED1 User session ended for session ${sessionId}, calling onStop`);
+          isPermanent = true;
           this.onStop(sessionId, userId, "User session ended").catch((error) => {
             this.logger.error(error, `❌ Error in onStop handler for session end:`);
           });
         } else if (info.permanent === true) {
           this.logger.info(`\uD83D\uDED1 Permanent disconnection detected for session ${sessionId}, calling onStop`);
-          const _session = this.activeSessions.get(sessionId);
+          isPermanent = true;
           this.onStop(sessionId, userId, `Connection permanently lost: ${info.reason}`).catch((error) => {
             this.logger.error(error, `❌ Error in onStop handler for permanent disconnection:`);
           });
+        } else if (info.wasClean === true || info.code === 1000 || info.code === 1001) {
+          this.logger.info(`\uD83D\uDED1 Clean WebSocket closure for session ${sessionId} (code: ${info.code}), treating as permanent`);
+          isPermanent = true;
+          this.onStop(sessionId, userId, `Clean disconnect: ${reason}`).catch((error) => {
+            this.logger.error(error, `❌ Error in onStop handler for clean disconnect:`);
+          });
         }
       }
-      this.activeSessions.delete(sessionId);
-      this.activeSessionsByUserId.delete(userId);
+      if (isPermanent) {
+        if (this.activeSessions.get(sessionId) === session) {
+          this.activeSessions.delete(sessionId);
+        } else {
+          this.logger.debug({ sessionId }, `\uD83D\uDD04 Session ${sessionId} cleanup skipped - a newer session has taken over`);
+        }
+        if (this.activeSessionsByUserId.get(userId) === session) {
+          this.activeSessionsByUserId.delete(userId);
+        }
+        this.cleanupPhotoRequestsForSession(sessionId);
+      } else {
+        this.logger.debug({ sessionId, reason }, `\uD83D\uDD04 Temporary disconnect for session ${sessionId}, keeping in maps for reconnection`);
+      }
     });
     const cleanupError = session.events.onError((error) => {
       this.logger.error(error, `❌ [Session ${sessionId}] Error:`);
@@ -5175,10 +5380,20 @@ class AppServer {
     process.on("SIGTERM", () => this.stop());
     process.on("SIGINT", () => this.stop());
   }
-  cleanup() {
+  async cleanup() {
+    this.logger.info(`\uD83D\uDD27 [LOCAL SDK] cleanup() called - NOT sending OWNERSHIP_RELEASE`);
     for (const [sessionId, session] of this.activeSessions) {
-      this.logger.info(`\uD83D\uDC4B Closing session ${sessionId}`);
-      session.disconnect();
+      this.logger.info(`\uD83D\uDC4B Closing session ${sessionId} (no ownership release - cloud will resurrect)`);
+      try {
+        await session.disconnect({
+          releaseOwnership: false
+        });
+      } catch (error) {
+        this.logger.error(error, `Error during cleanup of session ${sessionId}`);
+        try {
+          await session.disconnect();
+        } catch {}
+      }
     }
     this.activeSessions.clear();
     this.activeSessionsByUserId.clear();
@@ -5203,7 +5418,6 @@ class AppServer {
       try {
         const { requestId, type, success, errorCode, errorMessage } = req.body;
         const photoFile = req.file;
-        console.log("Received photo response: ", req.body);
         this.logger.info({ requestId, type, success, errorCode }, `\uD83D\uDCF8 Received photo response: ${requestId} (type: ${type})`);
         if (!requestId) {
           this.logger.error("No requestId in photo response");
@@ -5212,24 +5426,18 @@ class AppServer {
             error: "No requestId provided"
           });
         }
-        const session = this.findSessionByPhotoRequestId(requestId);
-        if (!session) {
-          this.logger.warn({ requestId }, "No active session found for photo request");
+        const pending = this.completePhotoRequest(requestId);
+        if (!pending) {
+          this.logger.warn({ requestId, pendingCount: this.pendingPhotoRequests.size }, "\uD83D\uDCF8 No pending request found for photo (may have timed out or session ended)");
           return res.status(404).json({
             success: false,
-            error: "No active session found for this photo request"
+            error: "No pending request found for this photo (may have timed out or session ended)"
           });
         }
         if (type === "photo_error" || success === false) {
-          const errorResponse = {
-            requestId,
-            success: false,
-            error: {
-              code: errorCode || "UNKNOWN_ERROR",
-              message: errorMessage || "Unknown error occurred"
-            }
-          };
-          session.camera.handlePhotoError(errorResponse);
+          const errorMsg = errorMessage || "Unknown error occurred";
+          this.logger.info({ requestId, errorCode, errorMessage: errorMsg }, "\uD83D\uDCF8 Photo error received");
+          pending.reject(new Error(`Photo capture failed: ${errorMsg} (code: ${errorCode || "UNKNOWN_ERROR"})`));
           return res.json({
             success: true,
             requestId,
@@ -5238,6 +5446,7 @@ class AppServer {
         }
         if (!photoFile) {
           this.logger.error({ requestId }, "No photo file in successful upload");
+          pending.reject(new Error("No photo file provided for successful upload"));
           return res.status(400).json({
             success: false,
             error: "No photo file provided for successful upload"
@@ -5251,7 +5460,8 @@ class AppServer {
           size: photoFile.size,
           timestamp: new Date
         };
-        session.camera.handlePhotoReceived(photoData);
+        this.logger.info({ requestId, size: photoFile.size, mimeType: photoFile.mimetype }, "\uD83D\uDCF8 Photo received successfully, resolving promise");
+        pending.resolve(photoData);
         res.json({
           success: true,
           requestId,
@@ -5266,6 +5476,53 @@ class AppServer {
       }
     });
   }
+  registerPhotoRequest(requestId, request) {
+    const timeoutMs = 30000;
+    const timeoutId = setTimeout(() => {
+      const pending = this.pendingPhotoRequests.get(requestId);
+      if (pending) {
+        pending.reject(new Error("Photo request timed out"));
+        this.pendingPhotoRequests.delete(requestId);
+        this.logger.warn({ requestId }, "\uD83D\uDCF8 Photo request timed out");
+      }
+    }, timeoutMs);
+    this.pendingPhotoRequests.set(requestId, {
+      ...request,
+      timeoutId
+    });
+    this.logger.debug({ requestId, userId: request.userId, sessionId: request.sessionId }, "\uD83D\uDCF8 Photo request registered at AppServer level");
+  }
+  getPhotoRequest(requestId) {
+    return this.pendingPhotoRequests.get(requestId);
+  }
+  completePhotoRequest(requestId) {
+    const pending = this.pendingPhotoRequests.get(requestId);
+    if (pending) {
+      if (pending.timeoutId) {
+        clearTimeout(pending.timeoutId);
+      }
+      this.pendingPhotoRequests.delete(requestId);
+      this.logger.debug({ requestId }, "\uD83D\uDCF8 Photo request completed");
+    }
+    return pending;
+  }
+  cleanupPhotoRequestsForSession(sessionId) {
+    let cleanedCount = 0;
+    for (const [requestId, pending] of this.pendingPhotoRequests) {
+      if (pending.sessionId === sessionId) {
+        if (pending.timeoutId) {
+          clearTimeout(pending.timeoutId);
+        }
+        pending.reject(new Error("Session ended"));
+        this.pendingPhotoRequests.delete(requestId);
+        cleanedCount++;
+        this.logger.debug({ requestId, sessionId }, "\uD83D\uDCF8 Photo request cleaned up (session ended)");
+      }
+    }
+    if (cleanedCount > 0) {
+      this.logger.info({ sessionId, cleanedCount }, "\uD83D\uDCF8 Cleaned up photo requests for ended session");
+    }
+  }
   setupMentraAuthRedirect() {
     this.app.get("/mentra-auth", (req, res) => {
       const authUrl = `https://account.mentra.glass/auth?packagename=${encodeURIComponent(this.config.packageName)}`;
@@ -5273,14 +5530,6 @@ class AppServer {
       res.redirect(302, authUrl);
     });
   }
-  findSessionByPhotoRequestId(requestId) {
-    for (const [_sessionId, session] of this.activeSessions) {
-      if (session.camera.hasPhotoPendingRequest(requestId)) {
-        return session;
-      }
-    }
-    return;
-  }
 }
 
 class TpaServer extends AppServer {
@@ -5301,6 +5550,8 @@ export {
   isValidLanguageCode,
   isVad,
   isUpdate,
+  isUdpUnregister,
+  isUdpRegister,
   isStreamStatusCheckResponse,
   isStreamCategory,
   isStopWebhookRequest,
@@ -5332,6 +5583,7 @@ export {
   isPhoneNotificationDismissed,
   isPhoneNotification,
   isPhoneBatteryUpdate,
+  isOwnershipRelease,
   isMicrophoneStateChange,
   isManagedStreamStopRequest,
   isManagedStreamStatus,
@@ -5400,6 +5652,7 @@ export {
   PhotoStage,
   PhotoErrorCode,
   PermissionType,
+  Observable,
   LedModule,
   LayoutType,
   LEGACY_PERMISSION_MAP,
@@ -5408,6 +5661,7 @@ export {
   GlassesToCloudMessageType,
   GIVE_APP_CONTROL_OF_TOOL_RESPONSE,
   EventTypes,
+  DeviceState,
   DashboardMode,
   DashboardMessageTypes,
   ControlActionTypes,
@@ -5425,4 +5679,4 @@ export {
   AnimationUtils
 };
 
-//# debugId=AD30D8A3207C691A64756E2164756E21
+//# debugId=82AABDD8D6AA68F464756E2164756E21