@mentra/sdk 2.1.31-beta.5 → 3.0.0-alpha.1

package/dist/session.js

@@ -0,0 +1,4110 @@
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/logging/clean-transport.ts
+import { Writable } from "stream";
+import chalk from "chalk";
+function createCleanStream() {
+  return new Writable({
+    write(chunk, _encoding, callback) {
+      try {
+        const line = chunk.toString().trim();
+        if (!line) {
+          callback();
+          return;
+        }
+        const obj = JSON.parse(line);
+        const level = obj.level ?? 30;
+        const msg = obj.msg ?? "";
+        if (!msg) {
+          callback();
+          return;
+        }
+        if (obj._sdk === true && level < WARN_LEVEL && !VERBOSE) {
+          callback();
+          return;
+        }
+        const config = LEVEL_CONFIG[level] ?? DEFAULT_LEVEL_CONFIG;
+        const symbol = config.color(config.symbol);
+        const formatted = `${PREFIX}  ${symbol} ${msg}
+`;
+        process.stderr.write(formatted);
+      } catch {
+        process.stderr.write(chunk);
+      }
+      callback();
+    }
+  });
+}
+var LEVEL_CONFIG, VERBOSE, WARN_LEVEL = 40, DEFAULT_LEVEL_CONFIG, PREFIX;
+var init_clean_transport = __esm(() => {
+  LEVEL_CONFIG = {
+    10: { symbol: "·", color: chalk.dim },
+    20: { symbol: "·", color: chalk.dim },
+    30: { symbol: "✓", color: chalk.green },
+    40: { symbol: "⚠", color: chalk.yellow },
+    50: { symbol: "✗", color: chalk.red },
+    60: { symbol: "✗", color: chalk.red }
+  };
+  VERBOSE = process.env.MENTRA_VERBOSE === "true" || process.env.MENTRA_VERBOSE === "1";
+  DEFAULT_LEVEL_CONFIG = { symbol: "·", color: chalk.dim };
+  PREFIX = chalk.dim("MentraOS");
+});
+
+// src/logging/logger.ts
+var exports_logger = {};
+__export(exports_logger, {
+  logger: () => logger,
+  default: () => logger_default,
+  createLogger: () => createLogger
+});
+import pino from "pino";
+import { Writable as Writable2 } from "stream";
+function toPinoLevel(level) {
+  return level === "none" ? "silent" : level;
+}
+function resolveConfig(config) {
+  const envVerbose = process.env.MENTRA_VERBOSE === "true" || process.env.MENTRA_VERBOSE === "1";
+  const envLevel = process.env.MENTRA_LOG_LEVEL;
+  if (envVerbose) {
+    return { pinoLevel: "debug", verbose: true };
+  }
+  if (envLevel && VALID_LEVELS.includes(envLevel)) {
+    const pinoLevel = toPinoLevel(envLevel);
+    return { pinoLevel, verbose: envLevel === "debug" };
+  }
+  if (config?.verbose) {
+    return { pinoLevel: "debug", verbose: true };
+  }
+  if (config?.logLevel && VALID_LEVELS.includes(config.logLevel)) {
+    const pinoLevel = toPinoLevel(config.logLevel);
+    return { pinoLevel, verbose: config.logLevel === "debug" };
+  }
+  return { pinoLevel: "info", verbose: false };
+}
+function createNoopStream() {
+  return new Writable2({
+    write(_chunk, _encoding, callback) {
+      callback();
+    }
+  });
+}
+function tryCreatePrettyTransport() {
+  try {
+    const prettyTransport = pino.transport({
+      target: "pino-pretty",
+      options: {
+        colorize: true,
+        translateTime: "SYS:standard",
+        ignore: "pid,hostname,env,module,server",
+        messageFormat: "{msg}",
+        errorProps: "*"
+      }
+    });
+    return { stream: prettyTransport, level: "debug" };
+  } catch {
+    return null;
+  }
+}
+function tryCreateBetterStackTransport() {
+  const token = process.env.BETTERSTACK_SOURCE_TOKEN;
+  if (!token)
+    return null;
+  const endpoint = process.env.BETTERSTACK_ENDPOINT || "https://s1311181.eu-nbg-2.betterstackdata.com";
+  try {
+    const transport = pino.transport({
+      target: "@logtail/pino",
+      options: {
+        sourceToken: token,
+        options: { endpoint }
+      }
+    });
+    return { stream: transport, level: "debug" };
+  } catch {
+    return null;
+  }
+}
+function createLogger(config) {
+  const { pinoLevel, verbose } = resolveConfig(config);
+  const NODE_ENV = "development";
+  const PORTER_APP_NAME = process.env.PORTER_APP_NAME || "cloud-local";
+  const streams = [];
+  if (pinoLevel !== "silent") {
+    if (verbose) {
+      const pretty = tryCreatePrettyTransport();
+      if (pretty) {
+        pretty.level = pinoLevel;
+        streams.push(pretty);
+      } else {
+        process.stderr.write("[MentraOS] pino-pretty not installed — verbose output will be JSON. " + `Install it with: bun add -d pino-pretty
+`);
+        streams.push({ stream: process.stdout, level: pinoLevel });
+      }
+    } else {
+      streams.push({ stream: createCleanStream(), level: pinoLevel });
+    }
+  }
+  const betterStack = tryCreateBetterStackTransport();
+  if (betterStack) {
+    streams.push(betterStack);
+  }
+  if (streams.length === 0) {
+    streams.push({ stream: createNoopStream(), level: "silent" });
+  }
+  const multistream = pino.multistream(streams);
+  return pino({
+    level: "debug",
+    base: {
+      env: NODE_ENV,
+      server: PORTER_APP_NAME
+    },
+    timestamp: pino.stdTimeFunctions.isoTime
+  }, multistream);
+}
+var VALID_LEVELS, logger, logger_default;
+var init_logger = __esm(() => {
+  init_clean_transport();
+  VALID_LEVELS = ["none", "error", "warn", "info", "debug"];
+  logger = createLogger({
+    logLevel: "debug",
+    verbose: true
+  });
+  logger_default = logger;
+});
+
+// src/types/streams.ts
+function createLanguageStream(type) {
+  return type;
+}
+function isValidLanguageCode(code) {
+  return /^[a-z]{2,3}-[A-Z]{2}$/.test(code);
+}
+function parseLanguageStream(subscription) {
+  if (typeof subscription !== "string") {
+    return null;
+  }
+  if (subscription.startsWith(`${"transcription" /* TRANSCRIPTION */}:`)) {
+    const [baseType, rest] = subscription.split(":");
+    const [languageCode, queryString] = rest?.split("?") ?? [];
+    if (languageCode && (languageCode === "auto" || isValidLanguageCode(languageCode))) {
+      const options = {};
+      if (queryString) {
+        const params = new URLSearchParams(queryString);
+        for (const [key, value] of params.entries()) {
+          if (value === "true") {
+            options[key] = true;
+          } else if (value === "false") {
+            options[key] = false;
+          } else {
+            options[key] = value;
+          }
+        }
+      }
+      return {
+        type: "transcription" /* TRANSCRIPTION */,
+        baseType,
+        transcribeLanguage: languageCode,
+        options: Object.keys(options).length > 0 ? options : undefined,
+        original: subscription
+      };
+    }
+  }
+  if (subscription.startsWith(`${"translation" /* TRANSLATION */}:`)) {
+    const [baseType, rest] = subscription.split(":");
+    const [languagePair, queryString] = rest?.split("?") ?? [];
+    const [sourceLanguage, targetLanguage] = languagePair?.split("-to-") ?? [];
+    const isAllToFormat = sourceLanguage === "all" && targetLanguage && isValidLanguageCode(targetLanguage);
+    const isSpecificPairFormat = sourceLanguage && targetLanguage && isValidLanguageCode(sourceLanguage) && isValidLanguageCode(targetLanguage);
+    if (isAllToFormat || isSpecificPairFormat) {
+      const options = {};
+      if (queryString) {
+        const params = new URLSearchParams(queryString);
+        for (const [key, value] of params.entries()) {
+          if (value === "true") {
+            options[key] = true;
+          } else if (value === "false") {
+            options[key] = false;
+          } else {
+            options[key] = value;
+          }
+        }
+      }
+      return {
+        type: "translation" /* TRANSLATION */,
+        baseType,
+        transcribeLanguage: sourceLanguage,
+        translateLanguage: targetLanguage,
+        options: Object.keys(options).length > 0 ? options : undefined,
+        original: subscription
+      };
+    }
+  }
+  return null;
+}
+function createTranscriptionStream(language, options) {
+  console.log(`\uD83C\uDFA4 Creating transcription stream for language: ${language}`);
+  console.log(`\uD83C\uDFA4 Options: ${JSON.stringify(options)}`);
+  const languageCode = language.split("?")[0];
+  if (languageCode !== "auto" && !isValidLanguageCode(languageCode)) {
+    throw new Error(`Invalid language code: ${languageCode}`);
+  }
+  const base = `${"transcription" /* TRANSCRIPTION */}:${languageCode}`;
+  const params = new URLSearchParams;
+  if (options?.disableLanguageIdentification) {
+    params.set("no-language-identification", "true");
+  }
+  if (options?.hints && options.hints.length > 0) {
+    params.set("hints", options.hints.join(","));
+  }
+  const queryString = params.toString();
+  return queryString ? `${base}?${queryString}` : base;
+}
+function createTranslationStream(sourceLanguage, targetLanguage, options) {
+  const cleanSourceLanguage = sourceLanguage.split("?")[0];
+  const cleanTargetLanguage = targetLanguage.split("?")[0];
+  const isAllToFormat = cleanSourceLanguage === "all";
+  if (!isAllToFormat && !isValidLanguageCode(cleanSourceLanguage) || !isValidLanguageCode(cleanTargetLanguage)) {
+    throw new Error(`Invalid language code(s): ${cleanSourceLanguage}, ${cleanTargetLanguage}`);
+  }
+  const base = `${"translation" /* TRANSLATION */}:${cleanSourceLanguage}-to-${cleanTargetLanguage}`;
+  if (options?.disableLanguageIdentification) {
+    return `${base}?no-language-identification=true`;
+  }
+  return createLanguageStream(base);
+}
+function parseTouchEventStream(subscription) {
+  if (typeof subscription !== "string") {
+    return null;
+  }
+  if (subscription.startsWith(`${"touch_event" /* TOUCH_EVENT */}:`)) {
+    const [, gestureName] = subscription.split(":");
+    const validGestures = [
+      "single_tap",
+      "double_tap",
+      "triple_tap",
+      "long_press",
+      "forward_swipe",
+      "backward_swipe",
+      "up_swipe",
+      "down_swipe"
+    ];
+    if (gestureName && validGestures.includes(gestureName)) {
+      return gestureName;
+    }
+  }
+  return null;
+}
+function createTouchEventStream(gesture) {
+  const validGestures = [
+    "single_tap",
+    "double_tap",
+    "triple_tap",
+    "long_press",
+    "forward_swipe",
+    "backward_swipe",
+    "up_swipe",
+    "down_swipe"
+  ];
+  if (!validGestures.includes(gesture)) {
+    throw new Error(`Invalid gesture: ${gesture}`);
+  }
+  return `${"touch_event" /* TOUCH_EVENT */}:${gesture}`;
+}
+function createUniversalTranslationStream(targetLanguage, options) {
+  const cleanTargetLanguage = targetLanguage.split("?")[0];
+  if (!isValidLanguageCode(cleanTargetLanguage)) {
+    throw new Error(`Invalid target language code: ${cleanTargetLanguage}`);
+  }
+  const base = `${"translation" /* TRANSLATION */}:all-to-${cleanTargetLanguage}`;
+  if (options?.disableLanguageIdentification) {
+    return `${base}?no-language-identification=true`;
+  }
+  return createLanguageStream(base);
+}
+function isValidStreamType(subscription) {
+  if (Object.values(StreamType).includes(subscription)) {
+    return true;
+  }
+  const languageStream = parseLanguageStream(subscription);
+  if (languageStream !== null) {
+    return true;
+  }
+  const gestureStream = parseTouchEventStream(subscription);
+  if (gestureStream !== null) {
+    return true;
+  }
+  return false;
+}
+function isStreamCategory(streamType, category) {
+  const baseType = getBaseStreamType(streamType);
+  return baseType ? STREAM_CATEGORIES[baseType] === category : false;
+}
+function getStreamTypesByCategory(category) {
+  return Object.entries(STREAM_CATEGORIES).filter(([_, cat]) => cat === category).map(([type]) => type);
+}
+function getBaseStreamType(subscription) {
+  if (Object.values(StreamType).includes(subscription)) {
+    return subscription;
+  }
+  const languageStream = parseLanguageStream(subscription);
+  if (languageStream) {
+    return languageStream.type;
+  }
+  const gestureStream = parseTouchEventStream(subscription);
+  if (gestureStream) {
+    return "touch_event" /* TOUCH_EVENT */;
+  }
+  return null;
+}
+function isLanguageStream(subscription) {
+  return parseLanguageStream(subscription) !== null;
+}
+function getLanguageInfo(subscription) {
+  return parseLanguageStream(subscription);
+}
+var StreamType, StreamCategory, STREAM_CATEGORIES;
+var init_streams = __esm(() => {
+  ((StreamType2) => {
+    StreamType2["BUTTON_PRESS"] = "button_press";
+    StreamType2["HEAD_POSITION"] = "head_position";
+    StreamType2["TOUCH_EVENT"] = "touch_event";
+    StreamType2["GLASSES_BATTERY_UPDATE"] = "glasses_battery_update";
+    StreamType2["PHONE_BATTERY_UPDATE"] = "phone_battery_update";
+    StreamType2["GLASSES_CONNECTION_STATE"] = "glasses_connection_state";
+    StreamType2["LOCATION_UPDATE"] = "location_update";
+    StreamType2["LOCATION_STREAM"] = "location_stream";
+    StreamType2["VPS_COORDINATES"] = "vps_coordinates";
+    StreamType2["TRANSCRIPTION"] = "transcription";
+    StreamType2["TRANSLATION"] = "translation";
+    StreamType2["VAD"] = "VAD";
+    StreamType2["AUDIO_CHUNK"] = "audio_chunk";
+    StreamType2["PHONE_NOTIFICATION"] = "phone_notification";
+    StreamType2["PHONE_NOTIFICATION_DISMISSED"] = "phone_notification_dismissed";
+    StreamType2["CALENDAR_EVENT"] = "calendar_event";
+    StreamType2["START_APP"] = "start_app";
+    StreamType2["STOP_APP"] = "stop_app";
+    StreamType2["OPEN_DASHBOARD"] = "open_dashboard";
+    StreamType2["CORE_STATUS_UPDATE"] = "core_status_update";
+    StreamType2["VIDEO"] = "video";
+    StreamType2["PHOTO_REQUEST"] = "photo_request";
+    StreamType2["PHOTO_RESPONSE"] = "photo_response";
+    StreamType2["STREAM_STATUS"] = "stream_status";
+    StreamType2["MANAGED_STREAM_STATUS"] = "managed_stream_status";
+    StreamType2["ALL"] = "all";
+    StreamType2["WILDCARD"] = "*";
+    StreamType2["MENTRAOS_SETTINGS_UPDATE_REQUEST"] = "settings_update_request";
+    StreamType2["CUSTOM_MESSAGE"] = "custom_message";
+    StreamType2["PHOTO_TAKEN"] = "photo_taken";
+  })(StreamType ||= {});
+  ((StreamCategory2) => {
+    StreamCategory2["HARDWARE"] = "hardware";
+    StreamCategory2["AUDIO"] = "audio";
+    StreamCategory2["PHONE"] = "phone";
+    StreamCategory2["SYSTEM"] = "system";
+  })(StreamCategory ||= {});
+  STREAM_CATEGORIES = {
+    ["button_press" /* BUTTON_PRESS */]: "hardware" /* HARDWARE */,
+    ["head_position" /* HEAD_POSITION */]: "hardware" /* HARDWARE */,
+    ["touch_event" /* TOUCH_EVENT */]: "hardware" /* HARDWARE */,
+    ["glasses_battery_update" /* GLASSES_BATTERY_UPDATE */]: "hardware" /* HARDWARE */,
+    ["phone_battery_update" /* PHONE_BATTERY_UPDATE */]: "hardware" /* HARDWARE */,
+    ["glasses_connection_state" /* GLASSES_CONNECTION_STATE */]: "hardware" /* HARDWARE */,
+    ["location_update" /* LOCATION_UPDATE */]: "hardware" /* HARDWARE */,
+    ["location_stream" /* LOCATION_STREAM */]: "hardware" /* HARDWARE */,
+    ["vps_coordinates" /* VPS_COORDINATES */]: "hardware" /* HARDWARE */,
+    ["transcription" /* TRANSCRIPTION */]: "audio" /* AUDIO */,
+    ["translation" /* TRANSLATION */]: "audio" /* AUDIO */,
+    ["VAD" /* VAD */]: "audio" /* AUDIO */,
+    ["audio_chunk" /* AUDIO_CHUNK */]: "audio" /* AUDIO */,
+    ["phone_notification" /* PHONE_NOTIFICATION */]: "phone" /* PHONE */,
+    ["phone_notification_dismissed" /* PHONE_NOTIFICATION_DISMISSED */]: "phone" /* PHONE */,
+    ["calendar_event" /* CALENDAR_EVENT */]: "phone" /* PHONE */,
+    ["start_app" /* START_APP */]: "system" /* SYSTEM */,
+    ["stop_app" /* STOP_APP */]: "system" /* SYSTEM */,
+    ["open_dashboard" /* OPEN_DASHBOARD */]: "system" /* SYSTEM */,
+    ["core_status_update" /* CORE_STATUS_UPDATE */]: "system" /* SYSTEM */,
+    ["video" /* VIDEO */]: "hardware" /* HARDWARE */,
+    ["photo_request" /* PHOTO_REQUEST */]: "hardware" /* HARDWARE */,
+    ["photo_response" /* PHOTO_RESPONSE */]: "hardware" /* HARDWARE */,
+    ["stream_status" /* STREAM_STATUS */]: "hardware" /* HARDWARE */,
+    ["managed_stream_status" /* MANAGED_STREAM_STATUS */]: "hardware" /* HARDWARE */,
+    ["all" /* ALL */]: "system" /* SYSTEM */,
+    ["*" /* WILDCARD */]: "system" /* SYSTEM */,
+    ["settings_update_request" /* MENTRAOS_SETTINGS_UPDATE_REQUEST */]: "system" /* SYSTEM */,
+    ["custom_message" /* CUSTOM_MESSAGE */]: "system" /* SYSTEM */,
+    ["photo_taken" /* PHOTO_TAKEN */]: "hardware" /* HARDWARE */
+  };
+});
+
+// src/types/message-types.ts
+var GlassesToCloudMessageType, CloudToGlassesMessageType, AppToCloudMessageType, CloudToAppMessageType, ControlActionTypes, EventTypes, ResponseTypes, UpdateTypes, DashboardMessageTypes;
+var init_message_types = __esm(() => {
+  init_streams();
+  ((GlassesToCloudMessageType2) => {
+    GlassesToCloudMessageType2["CONNECTION_INIT"] = "connection_init";
+    GlassesToCloudMessageType2["REQUEST_SETTINGS"] = "request_settings";
+    GlassesToCloudMessageType2[GlassesToCloudMessageType2["START_APP"] = "start_app" /* START_APP */] = "START_APP";
+    GlassesToCloudMessageType2[GlassesToCloudMessageType2["STOP_APP"] = "stop_app" /* STOP_APP */] = "STOP_APP";
+    GlassesToCloudMessageType2["DASHBOARD_STATE"] = "dashboard_state";
+    GlassesToCloudMessageType2[GlassesToCloudMessageType2["OPEN_DASHBOARD"] = "open_dashboard" /* OPEN_DASHBOARD */] = "OPEN_DASHBOARD";
+    GlassesToCloudMessageType2[GlassesToCloudMessageType2["PHOTO_RESPONSE"] = "photo_response" /* PHOTO_RESPONSE */] = "PHOTO_RESPONSE";
+    GlassesToCloudMessageType2["LOCAL_TRANSCRIPTION"] = "local_transcription";
+    GlassesToCloudMessageType2[GlassesToCloudMessageType2["STREAM_STATUS"] = "stream_status" /* STREAM_STATUS */] = "STREAM_STATUS";
+    GlassesToCloudMessageType2["KEEP_ALIVE_ACK"] = "keep_alive_ack";
+    GlassesToCloudMessageType2[GlassesToCloudMessageType2["BUTTON_PRESS"] = "button_press" /* BUTTON_PRESS */] = "BUTTON_PRESS";
+    GlassesToCloudMessageType2[GlassesToCloudMessageType2["HEAD_POSITION"] = "head_position" /* HEAD_POSITION */] = "HEAD_POSITION";
+    GlassesToCloudMessageType2[GlassesToCloudMessageType2["TOUCH_EVENT"] = "touch_event" /* TOUCH_EVENT */] = "TOUCH_EVENT";
+    GlassesToCloudMessageType2[GlassesToCloudMessageType2["GLASSES_BATTERY_UPDATE"] = "glasses_battery_update" /* GLASSES_BATTERY_UPDATE */] = "GLASSES_BATTERY_UPDATE";
+    GlassesToCloudMessageType2[GlassesToCloudMessageType2["PHONE_BATTERY_UPDATE"] = "phone_battery_update" /* PHONE_BATTERY_UPDATE */] = "PHONE_BATTERY_UPDATE";
+    GlassesToCloudMessageType2[GlassesToCloudMessageType2["GLASSES_CONNECTION_STATE"] = "glasses_connection_state" /* GLASSES_CONNECTION_STATE */] = "GLASSES_CONNECTION_STATE";
+    GlassesToCloudMessageType2[GlassesToCloudMessageType2["LOCATION_UPDATE"] = "location_update" /* LOCATION_UPDATE */] = "LOCATION_UPDATE";
+    GlassesToCloudMessageType2[GlassesToCloudMessageType2["VPS_COORDINATES"] = "vps_coordinates" /* VPS_COORDINATES */] = "VPS_COORDINATES";
+    GlassesToCloudMessageType2[GlassesToCloudMessageType2["VAD"] = "VAD" /* VAD */] = "VAD";
+    GlassesToCloudMessageType2[GlassesToCloudMessageType2["PHONE_NOTIFICATION"] = "phone_notification" /* PHONE_NOTIFICATION */] = "PHONE_NOTIFICATION";
+    GlassesToCloudMessageType2[GlassesToCloudMessageType2["PHONE_NOTIFICATION_DISMISSED"] = "phone_notification_dismissed" /* PHONE_NOTIFICATION_DISMISSED */] = "PHONE_NOTIFICATION_DISMISSED";
+    GlassesToCloudMessageType2[GlassesToCloudMessageType2["CALENDAR_EVENT"] = "calendar_event" /* CALENDAR_EVENT */] = "CALENDAR_EVENT";
+    GlassesToCloudMessageType2[GlassesToCloudMessageType2["MENTRAOS_SETTINGS_UPDATE_REQUEST"] = "settings_update_request" /* MENTRAOS_SETTINGS_UPDATE_REQUEST */] = "MENTRAOS_SETTINGS_UPDATE_REQUEST";
+    GlassesToCloudMessageType2[GlassesToCloudMessageType2["CORE_STATUS_UPDATE"] = "core_status_update" /* CORE_STATUS_UPDATE */] = "CORE_STATUS_UPDATE";
+    GlassesToCloudMessageType2[GlassesToCloudMessageType2["PHOTO_TAKEN"] = "photo_taken" /* PHOTO_TAKEN */] = "PHOTO_TAKEN";
+    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";
+    CloudToGlassesMessageType2["CONNECTION_ERROR"] = "connection_error";
+    CloudToGlassesMessageType2["AUTH_ERROR"] = "auth_error";
+    CloudToGlassesMessageType2["DISPLAY_EVENT"] = "display_event";
+    CloudToGlassesMessageType2["APP_STATE_CHANGE"] = "app_state_change";
+    CloudToGlassesMessageType2["MICROPHONE_STATE_CHANGE"] = "microphone_state_change";
+    CloudToGlassesMessageType2["SETTINGS_UPDATE"] = "settings_update";
+    CloudToGlassesMessageType2["PHOTO_REQUEST"] = "photo_request";
+    CloudToGlassesMessageType2["AUDIO_PLAY_REQUEST"] = "audio_play_request";
+    CloudToGlassesMessageType2["AUDIO_STOP_REQUEST"] = "audio_stop_request";
+    CloudToGlassesMessageType2["RGB_LED_CONTROL"] = "rgb_led_control";
+    CloudToGlassesMessageType2["CAMERA_FOV_SET"] = "camera_fov_set";
+    CloudToGlassesMessageType2["SHOW_WIFI_SETUP"] = "show_wifi_setup";
+    CloudToGlassesMessageType2["START_STREAM"] = "start_stream";
+    CloudToGlassesMessageType2["STOP_STREAM"] = "stop_stream";
+    CloudToGlassesMessageType2["KEEP_STREAM_ALIVE"] = "keep_stream_alive";
+    CloudToGlassesMessageType2["DASHBOARD_MODE_CHANGE"] = "dashboard_mode_change";
+    CloudToGlassesMessageType2["DASHBOARD_ALWAYS_ON_CHANGE"] = "dashboard_always_on_change";
+    CloudToGlassesMessageType2["SET_LOCATION_TIER"] = "set_location_tier";
+    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";
+    AppToCloudMessageType2["RECONNECT"] = "reconnect";
+    AppToCloudMessageType2["SUBSCRIPTION_UPDATE"] = "subscription_update";
+    AppToCloudMessageType2["LOCATION_POLL_REQUEST"] = "location_poll_request";
+    AppToCloudMessageType2["DISPLAY_REQUEST"] = "display_event";
+    AppToCloudMessageType2["PHOTO_REQUEST"] = "photo_request";
+    AppToCloudMessageType2["AUDIO_PLAY_REQUEST"] = "audio_play_request";
+    AppToCloudMessageType2["AUDIO_STOP_REQUEST"] = "audio_stop_request";
+    AppToCloudMessageType2["AUDIO_STREAM_START"] = "audio_stream_start";
+    AppToCloudMessageType2["AUDIO_STREAM_END"] = "audio_stream_end";
+    AppToCloudMessageType2["RGB_LED_CONTROL"] = "rgb_led_control";
+    AppToCloudMessageType2["CAMERA_FOV_SET"] = "camera_fov_set";
+    AppToCloudMessageType2["REQUEST_WIFI_SETUP"] = "request_wifi_setup";
+    AppToCloudMessageType2["STREAM_REQUEST"] = "stream_request";
+    AppToCloudMessageType2["STREAM_STOP"] = "stream_stop";
+    AppToCloudMessageType2["MANAGED_STREAM_REQUEST"] = "managed_stream_request";
+    AppToCloudMessageType2["MANAGED_STREAM_STOP"] = "managed_stream_stop";
+    AppToCloudMessageType2["STREAM_STATUS_CHECK"] = "stream_status_check";
+    AppToCloudMessageType2["DASHBOARD_CONTENT_UPDATE"] = "dashboard_content_update";
+    AppToCloudMessageType2["DASHBOARD_MODE_CHANGE"] = "dashboard_mode_change";
+    AppToCloudMessageType2["DASHBOARD_SYSTEM_UPDATE"] = "dashboard_system_update";
+    AppToCloudMessageType2["APP_BROADCAST_MESSAGE"] = "app_broadcast_message";
+    AppToCloudMessageType2["APP_DIRECT_MESSAGE"] = "app_direct_message";
+    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";
+    AppToCloudMessageType2["TELEMETRY_RESPONSE"] = "telemetry_response";
+  })(AppToCloudMessageType ||= {});
+  ((CloudToAppMessageType2) => {
+    CloudToAppMessageType2["CONNECTION_ACK"] = "tpa_connection_ack";
+    CloudToAppMessageType2["CONNECTION_ERROR"] = "tpa_connection_error";
+    CloudToAppMessageType2["RECONNECT_ACK"] = "reconnect_ack";
+    CloudToAppMessageType2["RECONNECT_REJECTED"] = "reconnect_rejected";
+    CloudToAppMessageType2["RECONNECT_DEFERRED"] = "reconnect_deferred";
+    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";
+    CloudToAppMessageType2["PHOTO_RESPONSE"] = "photo_response";
+    CloudToAppMessageType2["AUDIO_PLAY_RESPONSE"] = "audio_play_response";
+    CloudToAppMessageType2["AUDIO_STREAM_READY"] = "audio_stream_ready";
+    CloudToAppMessageType2["RGB_LED_CONTROL_RESPONSE"] = "rgb_led_control_response";
+    CloudToAppMessageType2["STREAM_STATUS"] = "stream_status";
+    CloudToAppMessageType2["MANAGED_STREAM_STATUS"] = "managed_stream_status";
+    CloudToAppMessageType2["STREAM_STATUS_CHECK_RESPONSE"] = "stream_status_check_response";
+    CloudToAppMessageType2["WEBSOCKET_ERROR"] = "websocket_error";
+    CloudToAppMessageType2["PERMISSION_ERROR"] = "permission_error";
+    CloudToAppMessageType2["REQUEST_TELEMETRY"] = "request_telemetry";
+    CloudToAppMessageType2["CUSTOM_MESSAGE"] = "custom_message";
+    CloudToAppMessageType2["APP_MESSAGE_RECEIVED"] = "app_message_received";
+    CloudToAppMessageType2["APP_USER_JOINED"] = "app_user_joined";
+    CloudToAppMessageType2["APP_USER_LEFT"] = "app_user_left";
+    CloudToAppMessageType2["APP_ROOM_UPDATED"] = "app_room_updated";
+    CloudToAppMessageType2["APP_DIRECT_MESSAGE_RESPONSE"] = "app_direct_message_response";
+  })(CloudToAppMessageType ||= {});
+  ControlActionTypes = [
+    "connection_init" /* CONNECTION_INIT */,
+    GlassesToCloudMessageType.START_APP,
+    GlassesToCloudMessageType.STOP_APP,
+    "dashboard_state" /* DASHBOARD_STATE */,
+    GlassesToCloudMessageType.OPEN_DASHBOARD
+  ];
+  EventTypes = [
+    GlassesToCloudMessageType.BUTTON_PRESS,
+    GlassesToCloudMessageType.HEAD_POSITION,
+    GlassesToCloudMessageType.GLASSES_BATTERY_UPDATE,
+    GlassesToCloudMessageType.PHONE_BATTERY_UPDATE,
+    GlassesToCloudMessageType.GLASSES_CONNECTION_STATE,
+    GlassesToCloudMessageType.LOCATION_UPDATE,
+    GlassesToCloudMessageType.VPS_COORDINATES,
+    GlassesToCloudMessageType.VAD,
+    GlassesToCloudMessageType.PHONE_NOTIFICATION,
+    GlassesToCloudMessageType.PHONE_NOTIFICATION_DISMISSED,
+    GlassesToCloudMessageType.CALENDAR_EVENT,
+    GlassesToCloudMessageType.MENTRAOS_SETTINGS_UPDATE_REQUEST,
+    GlassesToCloudMessageType.CORE_STATUS_UPDATE,
+    "local_transcription" /* LOCAL_TRANSCRIPTION */
+  ];
+  ResponseTypes = [
+    "connection_ack" /* CONNECTION_ACK */,
+    "connection_error" /* CONNECTION_ERROR */,
+    "auth_error" /* AUTH_ERROR */
+  ];
+  UpdateTypes = [
+    "display_event" /* DISPLAY_EVENT */,
+    "app_state_change" /* APP_STATE_CHANGE */,
+    "microphone_state_change" /* MICROPHONE_STATE_CHANGE */,
+    "photo_request" /* PHOTO_REQUEST */,
+    "audio_play_request" /* AUDIO_PLAY_REQUEST */,
+    "audio_stop_request" /* AUDIO_STOP_REQUEST */,
+    "rgb_led_control" /* RGB_LED_CONTROL */,
+    "settings_update" /* SETTINGS_UPDATE */,
+    "dashboard_mode_change" /* DASHBOARD_MODE_CHANGE */,
+    "dashboard_always_on_change" /* DASHBOARD_ALWAYS_ON_CHANGE */,
+    "start_stream" /* START_STREAM */,
+    "stop_stream" /* STOP_STREAM */,
+    "keep_stream_alive" /* KEEP_STREAM_ALIVE */,
+    "livekit_info" /* LIVEKIT_INFO */
+  ];
+  DashboardMessageTypes = [
+    "dashboard_content_update" /* DASHBOARD_CONTENT_UPDATE */,
+    "dashboard_mode_change" /* DASHBOARD_MODE_CHANGE */,
+    "dashboard_system_update" /* DASHBOARD_SYSTEM_UPDATE */,
+    "dashboard_mode_changed" /* DASHBOARD_MODE_CHANGED */,
+    "dashboard_always_on_changed" /* DASHBOARD_ALWAYS_ON_CHANGED */
+  ];
+});
+// src/types/messages/glasses-to-cloud.ts
+function isControlAction(message) {
+  return ControlActionTypes.includes(message.type);
+}
+function isEvent(message) {
+  return EventTypes.includes(message.type);
+}
+function isConnectionInit(message) {
+  return message.type === "connection_init" /* CONNECTION_INIT */;
+}
+function isRequestSettings(message) {
+  return message.type === "request_settings" /* REQUEST_SETTINGS */;
+}
+function isStartApp(message) {
+  return message.type === GlassesToCloudMessageType.START_APP;
+}
+function isStopApp(message) {
+  return message.type === GlassesToCloudMessageType.STOP_APP;
+}
+function isButtonPress(message) {
+  return message.type === GlassesToCloudMessageType.BUTTON_PRESS;
+}
+function isHeadPosition(message) {
+  return message.type === GlassesToCloudMessageType.HEAD_POSITION;
+}
+function isGlassesBatteryUpdate(message) {
+  return message.type === GlassesToCloudMessageType.GLASSES_BATTERY_UPDATE;
+}
+function isPhoneBatteryUpdate(message) {
+  return message.type === GlassesToCloudMessageType.PHONE_BATTERY_UPDATE;
+}
+function isGlassesConnectionState(message) {
+  return message.type === GlassesToCloudMessageType.GLASSES_CONNECTION_STATE;
+}
+function isLocationUpdate(message) {
+  return message.type === GlassesToCloudMessageType.LOCATION_UPDATE;
+}
+function isCalendarEvent(message) {
+  return message.type === GlassesToCloudMessageType.CALENDAR_EVENT;
+}
+function isVad(message) {
+  return message.type === GlassesToCloudMessageType.VAD;
+}
+function isPhoneNotification(message) {
+  return message.type === GlassesToCloudMessageType.PHONE_NOTIFICATION;
+}
+function isPhoneNotificationDismissed(message) {
+  return message.type === GlassesToCloudMessageType.PHONE_NOTIFICATION_DISMISSED;
+}
+function isStreamStatus(message) {
+  return message.type === GlassesToCloudMessageType.STREAM_STATUS;
+}
+function isPhotoResponse(message) {
+  return message.type === GlassesToCloudMessageType.PHOTO_RESPONSE;
+}
+function isRgbLedControlResponse(message) {
+  return message.type === "rgb_led_control_response" /* RGB_LED_CONTROL_RESPONSE */;
+}
+function isKeepAliveAck(message) {
+  return message.type === "keep_alive_ack" /* KEEP_ALIVE_ACK */;
+}
+function isPhotoTaken(message) {
+  return message.type === GlassesToCloudMessageType.PHOTO_TAKEN;
+}
+function isAudioPlayResponse(message) {
+  return message.type === "audio_play_response" /* AUDIO_PLAY_RESPONSE */;
+}
+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 */;
+}
+var PhotoErrorCode, PhotoStage;
+var init_glasses_to_cloud = __esm(() => {
+  init_message_types();
+  ((PhotoErrorCode2) => {
+    PhotoErrorCode2["CAMERA_INIT_FAILED"] = "CAMERA_INIT_FAILED";
+    PhotoErrorCode2["CAMERA_CAPTURE_FAILED"] = "CAMERA_CAPTURE_FAILED";
+    PhotoErrorCode2["CAMERA_TIMEOUT"] = "CAMERA_TIMEOUT";
+    PhotoErrorCode2["CAMERA_BUSY"] = "CAMERA_BUSY";
+    PhotoErrorCode2["UPLOAD_FAILED"] = "UPLOAD_FAILED";
+    PhotoErrorCode2["UPLOAD_TIMEOUT"] = "UPLOAD_TIMEOUT";
+    PhotoErrorCode2["BLE_TRANSFER_FAILED"] = "BLE_TRANSFER_FAILED";
+    PhotoErrorCode2["BLE_TRANSFER_BUSY"] = "BLE_TRANSFER_BUSY";
+    PhotoErrorCode2["BLE_TRANSFER_FAILED_TO_START"] = "BLE_TRANSFER_FAILED_TO_START";
+    PhotoErrorCode2["BLE_TRANSFER_TIMEOUT"] = "BLE_TRANSFER_TIMEOUT";
+    PhotoErrorCode2["COMPRESSION_FAILED"] = "COMPRESSION_FAILED";
+    PhotoErrorCode2["PERMISSION_DENIED"] = "PERMISSION_DENIED";
+    PhotoErrorCode2["STORAGE_FULL"] = "STORAGE_FULL";
+    PhotoErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
+    PhotoErrorCode2["PHONE_GLASSES_NOT_CONNECTED"] = "PHONE_GLASSES_NOT_CONNECTED";
+    PhotoErrorCode2["PHONE_BLE_TRANSFER_FAILED"] = "PHONE_BLE_TRANSFER_FAILED";
+    PhotoErrorCode2["PHONE_UPLOAD_FAILED"] = "PHONE_UPLOAD_FAILED";
+    PhotoErrorCode2["PHONE_TIMEOUT"] = "PHONE_TIMEOUT";
+    PhotoErrorCode2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+  })(PhotoErrorCode ||= {});
+  ((PhotoStage2) => {
+    PhotoStage2["REQUEST_RECEIVED"] = "REQUEST_RECEIVED";
+    PhotoStage2["CAMERA_INIT"] = "CAMERA_INIT";
+    PhotoStage2["PHOTO_CAPTURE"] = "PHOTO_CAPTURE";
+    PhotoStage2["COMPRESSION"] = "COMPRESSION";
+    PhotoStage2["UPLOAD_START"] = "UPLOAD_START";
+    PhotoStage2["UPLOAD_PROGRESS"] = "UPLOAD_PROGRESS";
+    PhotoStage2["BLE_TRANSFER"] = "BLE_TRANSFER";
+    PhotoStage2["RESPONSE_SENT"] = "RESPONSE_SENT";
+  })(PhotoStage ||= {});
+});
+
+// src/types/messages/cloud-to-glasses.ts
+function isResponse(message) {
+  return ResponseTypes.includes(message.type);
+}
+function isUpdate(message) {
+  return UpdateTypes.includes(message.type);
+}
+function isConnectionAck(message) {
+  return message.type === "connection_ack" /* CONNECTION_ACK */;
+}
+function isConnectionError(message) {
+  return message.type === "connection_error" /* CONNECTION_ERROR */;
+}
+function isAuthError(message) {
+  return message.type === "auth_error" /* AUTH_ERROR */;
+}
+function isDisplayEvent(message) {
+  return message.type === "display_event" /* DISPLAY_EVENT */;
+}
+function isAppStateChange(message) {
+  return message.type === "app_state_change" /* APP_STATE_CHANGE */;
+}
+function isMicrophoneStateChange(message) {
+  return message.type === "microphone_state_change" /* MICROPHONE_STATE_CHANGE */;
+}
+function isPhotoRequest(message) {
+  return message.type === "photo_request" /* PHOTO_REQUEST */;
+}
+function isRgbLedControl(message) {
+  return message.type === "rgb_led_control" /* RGB_LED_CONTROL */;
+}
+function isSettingsUpdate(message) {
+  return message.type === "settings_update" /* SETTINGS_UPDATE */;
+}
+function isStartStream(message) {
+  return message.type === "start_stream" /* START_STREAM */;
+}
+function isStopStream(message) {
+  return message.type === "stop_stream" /* STOP_STREAM */;
+}
+function isKeepStreamAlive(message) {
+  return message.type === "keep_stream_alive" /* KEEP_STREAM_ALIVE */;
+}
+function isAudioPlayRequestToGlasses(message) {
+  return message.type === "audio_play_request" /* AUDIO_PLAY_REQUEST */;
+}
+function isAudioStopRequestToGlasses(message) {
+  return message.type === "audio_stop_request" /* AUDIO_STOP_REQUEST */;
+}
+var init_cloud_to_glasses = __esm(() => {
+  init_message_types();
+});
+
+// src/types/messages/app-to-cloud.ts
+function isAppConnectionInit(message) {
+  return message.type === "tpa_connection_init" /* CONNECTION_INIT */;
+}
+function isAppReconnect(message) {
+  return message.type === "reconnect" /* RECONNECT */;
+}
+function isAppSubscriptionUpdate(message) {
+  return message.type === "subscription_update" /* SUBSCRIPTION_UPDATE */;
+}
+function isDisplayRequest(message) {
+  return message.type === "display_event" /* DISPLAY_REQUEST */;
+}
+function isPhotoRequest2(message) {
+  return message.type === "photo_request" /* PHOTO_REQUEST */;
+}
+function isRgbLedControlRequest(message) {
+  return message.type === "rgb_led_control" /* RGB_LED_CONTROL */;
+}
+function isCameraFovSetRequest(message) {
+  return message.type === "camera_fov_set" /* CAMERA_FOV_SET */;
+}
+function isAudioPlayRequest(message) {
+  return message.type === "audio_play_request" /* AUDIO_PLAY_REQUEST */;
+}
+function isAudioStopRequest(message) {
+  return message.type === "audio_stop_request" /* AUDIO_STOP_REQUEST */;
+}
+function isDashboardContentUpdate(message) {
+  return message.type === "dashboard_content_update" /* DASHBOARD_CONTENT_UPDATE */;
+}
+function isDashboardModeChange(message) {
+  return message.type === "dashboard_mode_change" /* DASHBOARD_MODE_CHANGE */;
+}
+function isDashboardSystemUpdate(message) {
+  return message.type === "dashboard_system_update" /* DASHBOARD_SYSTEM_UPDATE */;
+}
+function isManagedStreamRequest(message) {
+  return message.type === "managed_stream_request" /* MANAGED_STREAM_REQUEST */;
+}
+function isManagedStreamStopRequest(message) {
+  return message.type === "managed_stream_stop" /* MANAGED_STREAM_STOP */;
+}
+function isStreamRequest(message) {
+  return message.type === "stream_request" /* STREAM_REQUEST */;
+}
+function isStreamStopRequest(message) {
+  return message.type === "stream_stop" /* STREAM_STOP */;
+}
+function isOwnershipRelease(message) {
+  return message.type === "ownership_release" /* OWNERSHIP_RELEASE */;
+}
+function isTelemetryResponse(message) {
+  return message.type === "telemetry_response" /* TELEMETRY_RESPONSE */;
+}
+var init_app_to_cloud = __esm(() => {
+  init_message_types();
+});
+
+// src/types/messages/cloud-to-app.ts
+function isAppConnectionAck(message) {
+  return message.type === "tpa_connection_ack" /* CONNECTION_ACK */;
+}
+function isAppConnectionError(message) {
+  return message.type === "tpa_connection_error" /* CONNECTION_ERROR */ || message.type === "connection_error";
+}
+function isAppStopped(message) {
+  return message.type === "app_stopped" /* APP_STOPPED */;
+}
+function isSettingsUpdate2(message) {
+  return message.type === "settings_update" /* SETTINGS_UPDATE */;
+}
+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 */;
+}
+function isAudioChunk(message) {
+  return message.type === "audio_chunk" /* AUDIO_CHUNK */;
+}
+function isDashboardModeChanged(message) {
+  return message.type === "dashboard_mode_changed" /* DASHBOARD_MODE_CHANGED */;
+}
+function isDashboardAlwaysOnChanged(message) {
+  return message.type === "dashboard_always_on_changed" /* DASHBOARD_ALWAYS_ON_CHANGED */;
+}
+function isManagedStreamStatus(message) {
+  return message.type === "managed_stream_status" /* MANAGED_STREAM_STATUS */;
+}
+function isStreamStatus2(message) {
+  return message.type === GlassesToCloudMessageType.STREAM_STATUS;
+}
+function isPhotoResponse2(message) {
+  return message.type === GlassesToCloudMessageType.PHOTO_RESPONSE;
+}
+function isRgbLedControlResponse2(message) {
+  return message.type === "rgb_led_control_response" /* RGB_LED_CONTROL_RESPONSE */;
+}
+function isStreamStatusCheckResponse(message) {
+  return message.type === "stream_status_check_response" /* STREAM_STATUS_CHECK_RESPONSE */;
+}
+function isAudioPlayResponse2(message) {
+  return message.type === "audio_play_response" /* AUDIO_PLAY_RESPONSE */;
+}
+function isRequestTelemetry(message) {
+  return message.type === "request_telemetry" /* REQUEST_TELEMETRY */;
+}
+var init_cloud_to_app = __esm(() => {
+  init_message_types();
+  init_streams();
+});
+// src/types/dashboard/index.ts
+var DashboardMode;
+var init_dashboard = __esm(() => {
+  ((DashboardMode2) => {
+    DashboardMode2["MAIN"] = "main";
+    DashboardMode2["EXPANDED"] = "expanded";
+  })(DashboardMode ||= {});
+});
+// src/types/enums.ts
+var AppType, LayoutType, ViewType, AppSettingType, HardwareType, HardwareRequirementLevel;
+var init_enums = __esm(() => {
+  ((AppType2) => {
+    AppType2["SYSTEM_DASHBOARD"] = "system_dashboard";
+    AppType2["BACKGROUND"] = "background";
+    AppType2["STANDARD"] = "standard";
+  })(AppType ||= {});
+  ((LayoutType2) => {
+    LayoutType2["TEXT_WALL"] = "text_wall";
+    LayoutType2["DOUBLE_TEXT_WALL"] = "double_text_wall";
+    LayoutType2["DASHBOARD_CARD"] = "dashboard_card";
+    LayoutType2["REFERENCE_CARD"] = "reference_card";
+    LayoutType2["BITMAP_VIEW"] = "bitmap_view";
+    LayoutType2["BITMAP_ANIMATION"] = "bitmap_animation";
+    LayoutType2["CLEAR_VIEW"] = "clear_view";
+  })(LayoutType ||= {});
+  ((ViewType2) => {
+    ViewType2["DASHBOARD"] = "dashboard";
+    ViewType2["MAIN"] = "main";
+  })(ViewType ||= {});
+  ((AppSettingType2) => {
+    AppSettingType2["TOGGLE"] = "toggle";
+    AppSettingType2["TEXT"] = "text";
+    AppSettingType2["SELECT"] = "select";
+    AppSettingType2["SLIDER"] = "slider";
+    AppSettingType2["GROUP"] = "group";
+    AppSettingType2["TEXT_NO_SAVE_BUTTON"] = "text_no_save_button";
+    AppSettingType2["SELECT_WITH_SEARCH"] = "select_with_search";
+    AppSettingType2["MULTISELECT"] = "multiselect";
+    AppSettingType2["TITLE_VALUE"] = "titleValue";
+    AppSettingType2["NUMERIC_INPUT"] = "numeric_input";
+    AppSettingType2["TIME_PICKER"] = "time_picker";
+  })(AppSettingType ||= {});
+  ((HardwareType2) => {
+    HardwareType2["CAMERA"] = "CAMERA";
+    HardwareType2["DISPLAY"] = "DISPLAY";
+    HardwareType2["MICROPHONE"] = "MICROPHONE";
+    HardwareType2["SPEAKER"] = "SPEAKER";
+    HardwareType2["IMU"] = "IMU";
+    HardwareType2["BUTTON"] = "BUTTON";
+    HardwareType2["LIGHT"] = "LIGHT";
+    HardwareType2["WIFI"] = "WIFI";
+  })(HardwareType ||= {});
+  ((HardwareRequirementLevel2) => {
+    HardwareRequirementLevel2["REQUIRED"] = "REQUIRED";
+    HardwareRequirementLevel2["OPTIONAL"] = "OPTIONAL";
+  })(HardwareRequirementLevel ||= {});
+});
+
+// src/types/models.ts
+function validateAppConfig(config) {
+  if (!config || typeof config !== "object")
+    return false;
+  if (typeof config.name !== "string" || typeof config.description !== "string" || typeof config.version !== "string") {
+    return false;
+  }
+  if (!Array.isArray(config.settings))
+    return false;
+  return config.settings.every((setting) => {
+    if (setting.type === "group") {
+      return typeof setting.title === "string";
+    }
+    if (setting.type === "titleValue") {
+      return typeof setting.label === "string" && "value" in setting;
+    }
+    if (typeof setting.key !== "string" || typeof setting.label !== "string") {
+      return false;
+    }
+    switch (setting.type) {
+      case "toggle" /* TOGGLE */:
+        return typeof setting.defaultValue === "boolean";
+      case "text" /* TEXT */:
+      case "text_no_save_button" /* TEXT_NO_SAVE_BUTTON */:
+        return setting.defaultValue === undefined || typeof setting.defaultValue === "string";
+      case "select" /* SELECT */:
+      case "select_with_search" /* SELECT_WITH_SEARCH */:
+        return Array.isArray(setting.options) && setting.options.every((opt) => typeof opt.label === "string" && ("value" in opt));
+      case "multiselect" /* MULTISELECT */:
+        return Array.isArray(setting.options) && setting.options.every((opt) => typeof opt.label === "string" && ("value" in opt)) && (setting.defaultValue === undefined || Array.isArray(setting.defaultValue));
+      case "slider" /* SLIDER */:
+        return typeof setting.defaultValue === "number" && typeof setting.min === "number" && typeof setting.max === "number" && setting.min <= setting.max;
+      case "numeric_input" /* NUMERIC_INPUT */:
+        return (setting.defaultValue === undefined || typeof setting.defaultValue === "number") && (setting.min === undefined || typeof setting.min === "number") && (setting.max === undefined || typeof setting.max === "number") && (setting.step === undefined || typeof setting.step === "number") && (setting.placeholder === undefined || typeof setting.placeholder === "string");
+      case "time_picker" /* TIME_PICKER */:
+        return (setting.defaultValue === undefined || typeof setting.defaultValue === "number") && (setting.showSeconds === undefined || typeof setting.showSeconds === "boolean");
+      case "group" /* GROUP */:
+        return typeof setting.title === "string";
+      case "titleValue" /* TITLE_VALUE */:
+        return typeof setting.label === "string" && "value" in setting;
+      default:
+        return false;
+    }
+  });
+}
+var PermissionType, LEGACY_PERMISSION_MAP;
+var init_models = __esm(() => {
+  init_enums();
+  ((PermissionType2) => {
+    PermissionType2["MICROPHONE"] = "MICROPHONE";
+    PermissionType2["LOCATION"] = "LOCATION";
+    PermissionType2["BACKGROUND_LOCATION"] = "BACKGROUND_LOCATION";
+    PermissionType2["CALENDAR"] = "CALENDAR";
+    PermissionType2["CAMERA"] = "CAMERA";
+    PermissionType2["NOTIFICATIONS"] = "NOTIFICATIONS";
+    PermissionType2["READ_NOTIFICATIONS"] = "READ_NOTIFICATIONS";
+    PermissionType2["POST_NOTIFICATIONS"] = "POST_NOTIFICATIONS";
+    PermissionType2["ALL"] = "ALL";
+  })(PermissionType ||= {});
+  LEGACY_PERMISSION_MAP = new Map([
+    ["NOTIFICATIONS" /* NOTIFICATIONS */, ["READ_NOTIFICATIONS" /* READ_NOTIFICATIONS */]]
+  ]);
+});
+
+// src/types/webhooks.ts
+function isSessionWebhookRequest(request) {
+  return request.type === "session_request" /* SESSION_REQUEST */;
+}
+function isStopWebhookRequest(request) {
+  return request.type === "stop_request" /* STOP_REQUEST */;
+}
+var WebhookRequestType;
+var init_webhooks = __esm(() => {
+  ((WebhookRequestType2) => {
+    WebhookRequestType2["SESSION_REQUEST"] = "session_request";
+    WebhookRequestType2["STOP_REQUEST"] = "stop_request";
+  })(WebhookRequestType ||= {});
+});
+// src/types/index.ts
+var init_types = __esm(() => {
+  init_app_to_cloud();
+  init_cloud_to_app();
+  init_message_types();
+  init_glasses_to_cloud();
+  init_cloud_to_glasses();
+  init_streams();
+  init_dashboard();
+  init_enums();
+  init_models();
+  init_webhooks();
+});
+
+// src/session/MentraSession.ts
+init_logger();
+init_message_types();
+import EventEmitter2 from "events";
+
+// src/session/managers/CameraManager.ts
+init_types();
+import { EventEmitter } from "events";
+var DEFAULT_TIMEOUT_MS = 30000;
+var STREAM_CHECK_TIMEOUT_MS = 5000;
+var MANAGED_STREAM_TIMEOUT_MS = 30000;
+function generateRequestId(prefix) {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return `${prefix}_${crypto.randomUUID()}`;
+  }
+  return `${prefix}_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+}
+
+class CameraManager {
+  deps;
+  events = new EventEmitter;
+  handlerCleanups = [];
+  pendingRequests = new Map;
+  pendingStreamChecks = new Map;
+  pendingManagedStreamRequest;
+  _hasPermission = true;
+  isStreaming = false;
+  currentStreamUrl;
+  currentStreamState;
+  isManagedStreaming = false;
+  currentManagedStreamId;
+  currentManagedStreamUrls;
+  managedStreamStatus;
+  constructor(deps) {
+    this.deps = deps;
+    this.handlerCleanups.push(this.deps.messageHandlers.register("photo_response" /* PHOTO_RESPONSE */, (msg) => this.handlePhotoResponse(msg)), this.deps.messageHandlers.register("stream_status" /* STREAM_STATUS */, (msg) => this.handleStreamStatus(msg)), this.deps.messageHandlers.register("rtmp_stream_status", (msg) => this.handleStreamStatus(msg)), this.deps.messageHandlers.register("managed_stream_status" /* MANAGED_STREAM_STATUS */, (msg) => this.handleManagedStreamStatus(msg)), this.deps.messageHandlers.register("stream_status_check_response" /* STREAM_STATUS_CHECK_RESPONSE */, (msg) => this.handleStreamCheckResponse(msg)));
+  }
+  takePhoto(opts) {
+    return new Promise((resolve, reject) => {
+      const requestId = generateRequestId("photo_req");
+      const timeoutMs = opts?.timeout ?? DEFAULT_TIMEOUT_MS;
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(requestId);
+        reject(new Error(`Photo request timed out after ${timeoutMs}ms (requestId: ${requestId})`));
+      }, timeoutMs);
+      this.pendingRequests.set(requestId, { requestId, resolve, reject, timer });
+      const message = {
+        type: "photo_request" /* PHOTO_REQUEST */,
+        packageName: this.deps.getPackageName(),
+        sessionId: this.deps.getSessionId(),
+        requestId,
+        timestamp: new Date,
+        saveToGallery: opts?.saveToGallery ?? false,
+        size: opts?.size ?? "medium",
+        compress: opts?.compression ?? "none",
+        sound: opts?.sound
+      };
+      try {
+        this.deps.sendMessage(message);
+        this.deps.logger.info({ requestId, size: message.size, compress: message.compress, saveToGallery: message.saveToGallery }, "\uD83D\uDCF8 Photo request sent");
+      } catch (err) {
+        clearTimeout(timer);
+        this.pendingRequests.delete(requestId);
+        reject(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+  }
+  onPhotoTaken(handler) {
+    const streamKey = "photo_taken" /* PHOTO_TAKEN */;
+    this.deps.addSubscription(streamKey);
+    const routerCleanup = this.deps.router.on(streamKey, (_streamType, data) => {
+      try {
+        handler(normalisePhotoData(data));
+      } catch (err) {
+        this.deps.logger.error("[CameraManager] Error in onPhotoTaken handler:", err);
+      }
+    });
+    return () => {
+      routerCleanup();
+      this.deps.removeSubscription(streamKey);
+    };
+  }
+  async startStream(options) {
+    const opts = options ?? {};
+    if (opts.direct) {
+      return this._startDirectStream(opts);
+    }
+    return this._startManagedStream(opts);
+  }
+  async stopStream() {
+    if (this.isStreaming) {
+      this.deps.sendMessage({
+        type: "stream_stop" /* STREAM_STOP */,
+        packageName: this.deps.getPackageName(),
+        sessionId: this.deps.getSessionId(),
+        streamId: this.currentStreamState?.streamId,
+        timestamp: new Date
+      });
+    }
+    if (this.isManagedStreaming) {
+      this.deps.sendMessage({
+        type: "managed_stream_stop" /* MANAGED_STREAM_STOP */,
+        packageName: this.deps.getPackageName(),
+        sessionId: this.deps.getSessionId(),
+        timestamp: new Date
+      });
+      this.isManagedStreaming = false;
+      this.currentManagedStreamId = undefined;
+      this.currentManagedStreamUrls = undefined;
+    }
+  }
+  onStreamStatus(handler) {
+    this.deps.addSubscription("stream_status" /* STREAM_STATUS */);
+    this.deps.addSubscription("managed_stream_status" /* MANAGED_STREAM_STATUS */);
+    this.events.on("stream_status", handler);
+    this.events.on("managed_stream_status", handler);
+    return () => {
+      this.events.off("stream_status", handler);
+      this.events.off("managed_stream_status", handler);
+      this.deps.removeSubscription("stream_status" /* STREAM_STATUS */);
+      this.deps.removeSubscription("managed_stream_status" /* MANAGED_STREAM_STATUS */);
+    };
+  }
+  isCurrentlyStreaming() {
+    return this.isStreaming || this.isManagedStreaming;
+  }
+  getCurrentStreamUrl() {
+    return this.currentStreamUrl;
+  }
+  getStreamStatus() {
+    return this.currentStreamState;
+  }
+  getStreamUrls() {
+    return this.currentManagedStreamUrls;
+  }
+  async _startDirectStream(opts) {
+    const url = opts.direct;
+    if (!url.startsWith("rtmp://") && !url.startsWith("rtmps://") && !url.startsWith("srt://") && !url.startsWith("https://") && !url.startsWith("http://")) {
+      throw new Error("Invalid stream URL: must start with rtmp://, rtmps://, srt://, https://, or http://");
+    }
+    if (this.isStreaming || this.isManagedStreaming) {
+      throw new Error("Already streaming. Stop the current stream before starting a new one.");
+    }
+    this.currentStreamUrl = url;
+    this.deps.sendMessage({
+      type: "stream_request" /* STREAM_REQUEST */,
+      packageName: this.deps.getPackageName(),
+      sessionId: this.deps.getSessionId(),
+      streamUrl: url,
+      video: opts.video,
+      audio: opts.audio,
+      stream: opts.stream,
+      sound: opts.sound,
+      timestamp: new Date
+    });
+    this.isStreaming = true;
+  }
+  async _startManagedStream(opts) {
+    if (this.isStreaming || this.isManagedStreaming) {
+      throw new Error("Already streaming. Stop the current stream before starting a new one.");
+    }
+    const restreamDestinations = opts.destinations?.map((url) => ({ url }));
+    this.deps.sendMessage({
+      type: "managed_stream_request" /* MANAGED_STREAM_REQUEST */,
+      packageName: this.deps.getPackageName(),
+      sessionId: this.deps.getSessionId(),
+      quality: opts.quality,
+      enableWebRTC: opts.enableWebRTC ?? true,
+      video: opts.video,
+      audio: opts.audio,
+      stream: opts.stream,
+      restreamDestinations,
+      sound: opts.sound,
+      timestamp: new Date
+    });
+    this.isManagedStreaming = true;
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        if (this.pendingManagedStreamRequest?.timeoutId === timeoutId) {
+          this.pendingManagedStreamRequest = undefined;
+          this.isManagedStreaming = false;
+          reject(new Error("Managed stream request timeout"));
+        }
+      }, MANAGED_STREAM_TIMEOUT_MS);
+      this.pendingManagedStreamRequest = { resolve, reject, timeoutId };
+    });
+  }
+  async startDirectStream(options) {
+    return this._startDirectStream({ direct: options.rtmpUrl, video: options.video, audio: options.audio, stream: options.stream, sound: options.sound });
+  }
+  async startManagedStream(options = {}) {
+    return this._startManagedStream({
+      quality: options.quality,
+      enableWebRTC: options.enableWebRTC,
+      video: options.video,
+      audio: options.audio,
+      stream: options.stream,
+      destinations: options.restreamDestinations?.map((d) => d.url),
+      sound: options.sound
+    });
+  }
+  async stopManagedStream() {
+    return this.stopStream();
+  }
+  onManagedStreamStatus(handler) {
+    this.deps.addSubscription("managed_stream_status" /* MANAGED_STREAM_STATUS */);
+    this.events.on("managed_stream_status", handler);
+    return () => {
+      this.events.off("managed_stream_status", handler);
+      this.deps.removeSubscription("managed_stream_status" /* MANAGED_STREAM_STATUS */);
+    };
+  }
+  isManagedStreamActive() {
+    return this.isManagedStreaming;
+  }
+  getManagedStreamUrls() {
+    return this.currentManagedStreamUrls;
+  }
+  getManagedStreamStatus() {
+    return this.managedStreamStatus;
+  }
+  async checkExistingStream() {
+    return new Promise((resolve) => {
+      const requestId = generateRequestId("stream_check");
+      const timeoutId = setTimeout(() => {
+        this.pendingStreamChecks.delete(requestId);
+        resolve({ hasActiveStream: false });
+      }, STREAM_CHECK_TIMEOUT_MS);
+      this.pendingStreamChecks.set(requestId, { resolve, timeoutId });
+      this.deps.sendMessage({
+        type: "stream_status_check" /* STREAM_STATUS_CHECK */,
+        packageName: this.deps.getPackageName(),
+        sessionId: this.deps.getSessionId(),
+        requestId,
+        timestamp: new Date
+      });
+    });
+  }
+  get hasPermission() {
+    return this._hasPermission;
+  }
+  handlePhotoResponse(message) {
+    const requestId = message?.requestId;
+    if (!requestId) {
+      this.deps.logger.warn("[CameraManager] Received PHOTO_RESPONSE without requestId:", message);
+      return;
+    }
+    const pending = this.pendingRequests.get(requestId);
+    if (!pending) {
+      this.deps.logger.debug(`[CameraManager] No pending request for requestId="${requestId}" — ignoring.`);
+      return;
+    }
+    clearTimeout(pending.timer);
+    this.pendingRequests.delete(requestId);
+    if (message.error?.code === "permission_denied") {
+      this._hasPermission = false;
+    }
+    if (message.success === false) {
+      const errorMsg = message.error?.message ?? message.error?.code ?? "Photo capture failed";
+      pending.reject(new Error(errorMsg));
+      return;
+    }
+    pending.resolve({
+      url: message.photoUrl ?? "",
+      width: message.width ?? 0,
+      height: message.height ?? 0,
+      timestamp: message.timestamp ? new Date(message.timestamp).getTime() : Date.now(),
+      savedToGallery: message.savedToGallery ?? false
+    });
+  }
+  handleStreamStatus(message) {
+    this.currentStreamState = {
+      ...message,
+      timestamp: message.timestamp ? new Date(message.timestamp) : new Date
+    };
+    if (this.isStreaming) {
+      if (message.status === "stopped" || message.status === "error" || message.status === "timeout") {
+        this.isStreaming = false;
+        this.currentStreamUrl = undefined;
+      }
+    }
+    this.events.emit("stream_status", this.currentStreamState);
+  }
+  handleManagedStreamStatus(status) {
+    this.managedStreamStatus = status;
+    if (status.status === "initializing" && status.streamId) {
+      this.isManagedStreaming = true;
+      this.currentManagedStreamId = status.streamId;
+    }
+    if (status.status === "active") {
+      this.isManagedStreaming = true;
+      this.currentManagedStreamId = status.streamId;
+      if (status.hlsUrl && status.dashUrl) {
+        const result = {
+          hlsUrl: status.hlsUrl,
+          dashUrl: status.dashUrl,
+          webrtcUrl: status.webrtcUrl,
+          previewUrl: status.previewUrl,
+          thumbnailUrl: status.thumbnailUrl,
+          streamId: status.streamId ?? ""
+        };
+        this.currentManagedStreamUrls = result;
+        if (this.pendingManagedStreamRequest) {
+          clearTimeout(this.pendingManagedStreamRequest.timeoutId);
+          this.pendingManagedStreamRequest.resolve(result);
+          this.pendingManagedStreamRequest = undefined;
+        }
+      }
+    }
+    if (status.status === "error" || status.status === "stopped") {
+      if (this.pendingManagedStreamRequest) {
+        clearTimeout(this.pendingManagedStreamRequest.timeoutId);
+        this.pendingManagedStreamRequest.reject(new Error(status.message || "Managed stream failed"));
+        this.pendingManagedStreamRequest = undefined;
+      }
+      this.isManagedStreaming = false;
+      this.currentManagedStreamId = undefined;
+      this.currentManagedStreamUrls = undefined;
+    }
+    this.events.emit("managed_stream_status", status);
+  }
+  handleStreamCheckResponse(response) {
+    const requestId = response.requestId;
+    const pending = requestId ? this.pendingStreamChecks.get(requestId) : undefined;
+    if (!pending) {
+      const firstEntry = this.pendingStreamChecks.entries().next();
+      if (firstEntry.done || !firstEntry.value) {
+        return;
+      }
+      const [fallbackId, fallbackPending] = firstEntry.value;
+      clearTimeout(fallbackPending.timeoutId);
+      this.pendingStreamChecks.delete(fallbackId);
+      fallbackPending.resolve({
+        hasActiveStream: response.hasActiveStream,
+        streamInfo: response.streamInfo ? {
+          ...response.streamInfo,
+          createdAt: new Date(response.streamInfo.createdAt)
+        } : undefined
+      });
+      return;
+    }
+    clearTimeout(pending.timeoutId);
+    this.pendingStreamChecks.delete(requestId);
+    pending.resolve({
+      hasActiveStream: response.hasActiveStream,
+      streamInfo: response.streamInfo ? {
+        ...response.streamInfo,
+        createdAt: new Date(response.streamInfo.createdAt)
+      } : undefined
+    });
+  }
+  destroy() {
+    for (const [requestId, pending] of this.pendingRequests) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error(`CameraManager destroyed — session disconnected (${requestId})`));
+    }
+    this.pendingRequests.clear();
+    for (const [requestId, pending] of this.pendingStreamChecks) {
+      clearTimeout(pending.timeoutId);
+      pending.resolve({ hasActiveStream: false });
+      this.pendingStreamChecks.delete(requestId);
+    }
+    if (this.pendingManagedStreamRequest) {
+      clearTimeout(this.pendingManagedStreamRequest.timeoutId);
+      this.pendingManagedStreamRequest.reject(new Error("CameraManager destroyed — session disconnected"));
+      this.pendingManagedStreamRequest = undefined;
+    }
+    for (const cleanup of this.handlerCleanups) {
+      cleanup();
+    }
+    this.handlerCleanups.length = 0;
+    this.events.removeAllListeners();
+    this.currentStreamState = undefined;
+    this.currentStreamUrl = undefined;
+    this.isStreaming = false;
+    this.managedStreamStatus = undefined;
+    this.currentManagedStreamId = undefined;
+    this.currentManagedStreamUrls = undefined;
+    this.isManagedStreaming = false;
+  }
+}
+function normalisePhotoData(raw) {
+  return {
+    url: raw.photoUrl ?? raw.url ?? "",
+    width: raw.width ?? 0,
+    height: raw.height ?? 0,
+    timestamp: raw.timestamp ? new Date(raw.timestamp).getTime() : Date.now(),
+    savedToGallery: raw.savedToGallery ?? false
+  };
+}
+
+// src/session/managers/DashboardManager.ts
+init_message_types();
+init_dashboard();
+
+class DashboardManager {
+  deps;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  showText(text) {
+    const content = Array.isArray(text) ? text.join(`
+`) : text;
+    const message = {
+      type: "dashboard_content_update" /* DASHBOARD_CONTENT_UPDATE */,
+      packageName: this.deps.getPackageName(),
+      sessionId: `${this.deps.getSessionId()}-${this.deps.getPackageName()}`,
+      content,
+      modes: ["main" /* MAIN */],
+      timestamp: new Date
+    };
+    this.deps.sendMessage(message);
+    this.deps.logger.debug({ contentLength: content.length }, "\uD83D\uDCCA Dashboard content update sent");
+  }
+  clear() {
+    const message = {
+      type: "dashboard_content_update" /* DASHBOARD_CONTENT_UPDATE */,
+      packageName: this.deps.getPackageName(),
+      sessionId: `${this.deps.getSessionId()}-${this.deps.getPackageName()}`,
+      content: "",
+      modes: ["main" /* MAIN */],
+      timestamp: new Date
+    };
+    this.deps.sendMessage(message);
+    this.deps.logger.debug("\uD83D\uDCCA Dashboard content cleared");
+  }
+  destroy() {
+    this.deps.logger.debug("[DashboardManager] Destroyed.");
+  }
+}
+
+// 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/session/managers/DeviceManager.ts
+init_streams();
+function normaliseTouchEvent(raw) {
+  return {
+    ...raw,
+    gesture: raw.gesture_name ?? raw.gesture ?? "unknown",
+    model: raw.device_model ?? raw.model ?? "unknown",
+    timestamp: raw.timestamp ?? new Date().toISOString()
+  };
+}
+
+class DeviceManager {
+  state;
+  capabilities = null;
+  deps;
+  permissions;
+  _connected;
+  _modelName;
+  _batteryLevel;
+  _charging;
+  _caseBatteryLevel;
+  _caseCharging;
+  _caseOpen;
+  _caseRemoved;
+  _wifiConnected;
+  _wifiSsid;
+  _wifiLocalIp;
+  _hotspotEnabled;
+  _hotspotSsid;
+  capabilitiesListeners = new Set;
+  handlerCounts = new Map;
+  cleanups = [];
+  constructor(deps) {
+    this.deps = deps;
+    this.permissions = deps.permissions;
+    this._connected = new Observable(false);
+    this._modelName = 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._wifiConnected = new Observable(false);
+    this._wifiSsid = new Observable(null);
+    this._wifiLocalIp = new Observable(null);
+    this._hotspotEnabled = new Observable(null);
+    this._hotspotSsid = new Observable(null);
+    this.state = {
+      connected: this._connected,
+      modelName: this._modelName,
+      batteryLevel: this._batteryLevel,
+      charging: this._charging,
+      caseBatteryLevel: this._caseBatteryLevel,
+      caseCharging: this._caseCharging,
+      caseOpen: this._caseOpen,
+      caseRemoved: this._caseRemoved,
+      wifiConnected: this._wifiConnected,
+      wifiSsid: this._wifiSsid,
+      wifiLocalIp: this._wifiLocalIp,
+      hotspotEnabled: this._hotspotEnabled,
+      hotspotSsid: this._hotspotSsid
+    };
+    this.cleanups.push(deps.messageHandlers.register("device_state_update", (msg) => {
+      this.handleDeviceStateUpdate(msg);
+    }));
+    this.cleanups.push(deps.messageHandlers.register("capabilities_update", (msg) => {
+      this.handleCapabilitiesUpdate(msg);
+    }));
+  }
+  onButtonPress(handler) {
+    return this.addStreamHandler("button_press" /* BUTTON_PRESS */, (_st, data) => {
+      handler({
+        buttonId: data.buttonId ?? data.button_id ?? "unknown",
+        pressType: data.pressType ?? data.press_type ?? "short"
+      });
+    });
+  }
+  onHeadPosition(handler) {
+    return this.addStreamHandler("head_position" /* HEAD_POSITION */, (_st, data) => {
+      handler({
+        position: data.position ?? "down"
+      });
+    });
+  }
+  onTouchEvent(gestureOrHandler, handler) {
+    if (typeof gestureOrHandler === "function") {
+      return this.addStreamHandler("touch_event" /* TOUCH_EVENT */, (_st, data) => {
+        gestureOrHandler(normaliseTouchEvent(data));
+      });
+    }
+    const gesture = gestureOrHandler;
+    const gestureStream = `${"touch_event" /* TOUCH_EVENT */}:${gesture}`;
+    return this.addStreamHandler(gestureStream, (_st, data) => {
+      handler(normaliseTouchEvent(data));
+    });
+  }
+  subscribeToGestures(gestures) {
+    const cleanupFns = [];
+    for (const gesture of gestures) {
+      const gestureStream = `${"touch_event" /* TOUCH_EVENT */}:${gesture}`;
+      const cleanup = this.addStreamHandler(gestureStream, () => {});
+      cleanupFns.push(cleanup);
+    }
+    return () => {
+      for (const fn of cleanupFns) {
+        fn();
+      }
+    };
+  }
+  onBatteryUpdate(handler) {
+    return this.addStreamHandler("glasses_battery_update" /* GLASSES_BATTERY_UPDATE */, (_st, data) => {
+      if (data.level !== undefined) {
+        this._batteryLevel.setValue(data.level);
+      }
+      if (data.charging !== undefined) {
+        this._charging.setValue(data.charging);
+      }
+      handler({
+        level: data.level ?? 0,
+        charging: data.charging ?? false,
+        timeRemaining: data.timeRemaining ?? data.time_remaining
+      });
+    });
+  }
+  onVpsCoordinates(handler) {
+    return this.addStreamHandler("vps_coordinates" /* VPS_COORDINATES */, (_st, data) => {
+      handler(data);
+    });
+  }
+  requestWifiSetup(reason) {
+    this.deps.logger.info(`DeviceManager: Requesting WiFi setup${reason ? ` — ${reason}` : ""}`);
+    this.deps.sendMessage({
+      type: "request_wifi_setup",
+      packageName: this.deps.getPackageName(),
+      sessionId: this.deps.getSessionId(),
+      timestamp: new Date().toISOString(),
+      ...reason ? { reason } : {}
+    });
+  }
+  onCapabilitiesChange(handler) {
+    this.capabilitiesListeners.add(handler);
+    return () => {
+      this.capabilitiesListeners.delete(handler);
+    };
+  }
+  handleDeviceStateUpdate(message) {
+    const state = message?.state ?? message?.data ?? message;
+    if (!state) {
+      this.deps.logger.debug("DeviceManager: Received empty device_state_update");
+      return;
+    }
+    this.deps.logger.debug("DeviceManager: Processing device state update");
+    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);
+  }
+  handleCapabilitiesUpdate(message) {
+    const caps = message?.capabilities ?? message?.data?.capabilities ?? null;
+    const modelName = message?.modelName ?? message?.data?.modelName ?? null;
+    if (modelName) {
+      this._modelName.setValue(modelName);
+    }
+    this.setCapabilities(caps);
+  }
+  setCapabilities(caps) {
+    this.capabilities = caps;
+    this.deps.logger.info(`DeviceManager: Capabilities ${caps ? "updated" : "cleared"}`);
+    for (const listener of this.capabilitiesListeners) {
+      try {
+        listener(caps);
+      } catch (err) {
+        this.deps.logger.error(`DeviceManager: Error in capabilities listener: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }
+  destroy() {
+    for (const cleanup of this.cleanups) {
+      cleanup();
+    }
+    this.cleanups.length = 0;
+    this.handlerCounts.clear();
+    this.capabilitiesListeners.clear();
+  }
+  addStreamHandler(streamKey, handler) {
+    const currentCount = this.handlerCounts.get(streamKey) ?? 0;
+    if (currentCount === 0) {
+      this.deps.addSubscription(streamKey);
+    }
+    this.handlerCounts.set(streamKey, currentCount + 1);
+    const routerCleanup = this.deps.router.on(streamKey, handler);
+    let cleaned = false;
+    const cleanup = () => {
+      if (cleaned)
+        return;
+      cleaned = true;
+      routerCleanup();
+      const count = this.handlerCounts.get(streamKey) ?? 0;
+      const newCount = count - 1;
+      if (newCount <= 0) {
+        this.handlerCounts.delete(streamKey);
+        this.deps.removeSubscription(streamKey);
+      } else {
+        this.handlerCounts.set(streamKey, newCount);
+      }
+    };
+    this.cleanups.push(cleanup);
+    return cleanup;
+  }
+}
+
+// src/session/managers/DisplayManager.ts
+init_enums();
+init_message_types();
+
+class DisplayManager {
+  deps;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  showText(text) {
+    const resolved = Array.isArray(text) ? text.join(`
+`) : text;
+    this.showTextWall(resolved);
+  }
+  showTextWall(text) {
+    if (text === undefined || text === null) {
+      text = "";
+      this.deps.logger.warn("showTextWall called with null/undefined text");
+    }
+    if (typeof text !== "string") {
+      text = String(text);
+      this.deps.logger.warn("showTextWall: non-string input converted to string");
+    }
+    const layout = {
+      layoutType: "text_wall" /* TEXT_WALL */,
+      text
+    };
+    try {
+      this.sendDisplayEvent(layout);
+    } catch (err) {
+      this.deps.logger.error("Failed to display text wall:", err);
+    }
+  }
+  showDoubleTextWall(leftText, rightText) {
+    const layout = {
+      layoutType: "double_text_wall" /* DOUBLE_TEXT_WALL */,
+      topText: leftText,
+      bottomText: rightText
+    };
+    this.sendDisplayEvent(layout);
+  }
+  showReferenceCard(title, body) {
+    const layout = {
+      layoutType: "reference_card" /* REFERENCE_CARD */,
+      title,
+      text: body
+    };
+    this.sendDisplayEvent(layout);
+  }
+  showDashboardCard(leftText, rightText) {
+    const layout = {
+      layoutType: "dashboard_card" /* DASHBOARD_CARD */,
+      leftText,
+      rightText
+    };
+    this.sendDisplayEvent(layout, "dashboard" /* DASHBOARD */);
+  }
+  showBitmap(data) {
+    if (typeof data !== "string") {
+      this.deps.logger.error("showBitmap: data must be a string");
+      return;
+    }
+    if (data.length > 1e6) {
+      this.deps.logger.error("showBitmap: data exceeds 1 MB limit");
+      return;
+    }
+    const layout = {
+      layoutType: "bitmap_view" /* BITMAP_VIEW */,
+      data
+    };
+    this.sendDisplayEvent(layout);
+  }
+  clear() {
+    const layout = {
+      layoutType: "clear_view" /* CLEAR_VIEW */
+    };
+    this.sendDisplayEvent(layout);
+  }
+  sendDisplayEvent(layout, view = "main" /* MAIN */, durationMs) {
+    if (!layout || !layout.layoutType) {
+      this.deps.logger.error("sendDisplayEvent: layout must have a layoutType property");
+      return;
+    }
+    if (view !== "main" /* MAIN */ && view !== "dashboard" /* DASHBOARD */) {
+      this.deps.logger.warn(`Invalid view type: ${view}, defaulting to MAIN`);
+      view = "main" /* MAIN */;
+    }
+    if (durationMs !== undefined) {
+      if (typeof durationMs !== "number" || durationMs < 0) {
+        this.deps.logger.warn(`Invalid duration: ${durationMs}, ignoring`);
+        durationMs = undefined;
+      }
+    }
+    const message = {
+      timestamp: new Date,
+      sessionId: this.deps.getSessionId(),
+      type: "display_event" /* DISPLAY_REQUEST */,
+      packageName: this.deps.getPackageName(),
+      view,
+      layout,
+      durationMs
+    };
+    this.deps.sendMessage(message);
+  }
+}
+
+// src/session/managers/LedManager.ts
+init_types();
+function generateRequestId2() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return `led_req_${crypto.randomUUID()}`;
+  }
+  return `led_req_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+}
+
+class LedManager {
+  deps;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  setColor(color, onTimeMs) {
+    const requestId = generateRequestId2();
+    const message = {
+      type: "rgb_led_control" /* RGB_LED_CONTROL */,
+      packageName: this.deps.getPackageName(),
+      sessionId: this.deps.getSessionId(),
+      requestId,
+      timestamp: new Date,
+      action: "on",
+      color,
+      ontime: onTimeMs ?? 1000,
+      offtime: 0,
+      count: 1
+    };
+    this.deps.sendMessage(message);
+    this.deps.logger.debug({ requestId, color, ontime: message.ontime }, "\uD83D\uDCA1 LED setColor request sent");
+  }
+  off() {
+    const requestId = generateRequestId2();
+    const message = {
+      type: "rgb_led_control" /* RGB_LED_CONTROL */,
+      packageName: this.deps.getPackageName(),
+      sessionId: this.deps.getSessionId(),
+      requestId,
+      timestamp: new Date,
+      action: "off"
+    };
+    this.deps.sendMessage(message);
+    this.deps.logger.debug({ requestId }, "\uD83D\uDCA1 LED off request sent");
+  }
+  destroy() {
+    this.deps.logger.debug("[LedManager] Destroyed.");
+  }
+}
+
+// src/session/managers/LocationManager.ts
+init_types();
+var LOCATION_STREAM = "location_stream" /* LOCATION_STREAM */;
+var LOCATION_UPDATE = "location_update" /* LOCATION_UPDATE */;
+function generateCorrelationId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return `poll_${crypto.randomUUID()}`;
+  }
+  return `poll_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+}
+function normalise(raw) {
+  return {
+    lat: typeof raw.lat === "number" ? raw.lat : 0,
+    lng: typeof raw.lng === "number" ? raw.lng : 0,
+    accuracy: typeof raw.accuracy === "number" ? raw.accuracy : undefined,
+    timestamp: raw.timestamp ? new Date(raw.timestamp).getTime() : Date.now(),
+    correlationId: raw.correlationId
+  };
+}
+
+class LocationManager {
+  deps;
+  registrations = new Set;
+  streamRefCount = 0;
+  _lat = null;
+  _lng = null;
+  _accuracy = null;
+  _timestamp = null;
+  _hasPermission = true;
+  locationUpdateCleanup = null;
+  constructor(deps) {
+    this.deps = deps;
+    this.locationUpdateCleanup = this.deps.router.on(LOCATION_UPDATE, (_streamType, data, _message) => {
+      this.cacheLocation(data);
+    });
+  }
+  onUpdate(handler, accuracy) {
+    const streamKey = LOCATION_STREAM;
+    const routerCleanup = this.deps.router.on(streamKey, (_streamType, data, _message) => {
+      try {
+        const location = normalise(data);
+        this.cacheLocation(data);
+        handler(location);
+      } catch (err) {
+        this.deps.logger.error("[LocationManager] Error in onUpdate handler:", err);
+      }
+    });
+    const updateCleanup = this.deps.router.on(LOCATION_UPDATE, (_streamType, data, _message) => {
+      try {
+        const location = normalise(data);
+        this.cacheLocation(data);
+        handler(location);
+      } catch (err) {
+        this.deps.logger.error("[LocationManager] Error in onUpdate handler (location_update):", err);
+      }
+    });
+    const reg = { routerCleanup, updateCleanup, streamKey };
+    this.registrations.add(reg);
+    this.streamRefCount++;
+    if (this.streamRefCount === 1) {
+      this.deps.addSubscription(streamKey);
+      this.deps.logger.debug({ accuracy: accuracy ?? "standard" }, `[LocationManager] Subscribed to "${streamKey}".`);
+    }
+    return () => {
+      if (!this.registrations.has(reg))
+        return;
+      routerCleanup();
+      updateCleanup();
+      this.registrations.delete(reg);
+      this.streamRefCount--;
+      if (this.streamRefCount <= 0) {
+        this.streamRefCount = 0;
+        this.deps.removeSubscription(streamKey);
+        this.deps.logger.debug(`[LocationManager] Unsubscribed from "${streamKey}".`);
+      }
+    };
+  }
+  requestUpdate(accuracy) {
+    const correlationId = generateCorrelationId();
+    const message = {
+      type: "location_poll_request" /* LOCATION_POLL_REQUEST */,
+      correlationId,
+      packageName: this.deps.getPackageName(),
+      sessionId: this.deps.getSessionId(),
+      accuracy: accuracy ?? "standard"
+    };
+    this.deps.sendMessage(message);
+    this.deps.logger.debug({ correlationId, accuracy: message.accuracy }, "\uD83D\uDCCD Location poll request sent");
+  }
+  stop() {
+    const snapshot = Array.from(this.registrations);
+    for (const reg of snapshot) {
+      reg.routerCleanup();
+      reg.updateCleanup();
+      this.registrations.delete(reg);
+    }
+    if (this.streamRefCount > 0) {
+      this.deps.removeSubscription(LOCATION_STREAM);
+    }
+    this.streamRefCount = 0;
+    this.deps.logger.debug("[LocationManager] All subscriptions stopped.");
+  }
+  get lat() {
+    return this._lat;
+  }
+  get lng() {
+    return this._lng;
+  }
+  get accuracy() {
+    return this._accuracy;
+  }
+  get timestamp() {
+    return this._timestamp;
+  }
+  get hasPermission() {
+    return this._hasPermission;
+  }
+  cacheLocation(raw) {
+    if (typeof raw.lat === "number") {
+      this._lat = raw.lat;
+    }
+    if (typeof raw.lng === "number") {
+      this._lng = raw.lng;
+    }
+    if (typeof raw.accuracy === "number") {
+      this._accuracy = raw.accuracy;
+    }
+    this._timestamp = raw.timestamp ? new Date(raw.timestamp).getTime() : Date.now();
+  }
+  setPermission(granted) {
+    this._hasPermission = granted;
+  }
+  destroy() {
+    this.stop();
+    if (this.locationUpdateCleanup) {
+      this.locationUpdateCleanup();
+      this.locationUpdateCleanup = null;
+    }
+    this._lat = null;
+    this._lng = null;
+    this._accuracy = null;
+    this._timestamp = null;
+    this.deps.logger.debug("[LocationManager] Destroyed.");
+  }
+}
+
+// src/session/managers/MicManager.ts
+var AUDIO_CHUNK_STREAM = "audio_chunk";
+var VAD_STREAM = "VAD";
+
+class MicManager {
+  deps;
+  chunkHandlers = new Set;
+  vadHandlers = new Set;
+  vadRouterCleanup = null;
+  _isSpeaking = false;
+  _hasPermission = true;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  get isSpeaking() {
+    return this._isSpeaking;
+  }
+  get isActive() {
+    return this.chunkHandlers.size > 0;
+  }
+  get hasPermission() {
+    return this._hasPermission;
+  }
+  onChunk(handler) {
+    const isFirst = this.chunkHandlers.size === 0;
+    this.chunkHandlers.add(handler);
+    if (isFirst) {
+      this.deps.addSubscription(AUDIO_CHUNK_STREAM);
+      this.deps.logger.debug("Subscribed to audio_chunk stream");
+    }
+    return () => {
+      this.chunkHandlers.delete(handler);
+      if (this.chunkHandlers.size === 0) {
+        this.deps.removeSubscription(AUDIO_CHUNK_STREAM);
+        this.deps.logger.debug("Unsubscribed from audio_chunk stream");
+      }
+    };
+  }
+  onVoiceActivity(handler) {
+    const isFirst = this.vadHandlers.size === 0;
+    this.vadHandlers.add(handler);
+    if (isFirst) {
+      this.deps.addSubscription(VAD_STREAM);
+      this.vadRouterCleanup = this.deps.router.on(VAD_STREAM, (_streamType, data, _message) => {
+        this.handleVadMessage(data);
+      });
+      this.deps.logger.debug("Subscribed to VAD stream");
+    }
+    return () => {
+      this.vadHandlers.delete(handler);
+      if (this.vadHandlers.size === 0) {
+        this.deps.removeSubscription(VAD_STREAM);
+        if (this.vadRouterCleanup) {
+          this.vadRouterCleanup();
+          this.vadRouterCleanup = null;
+        }
+        this.deps.logger.debug("Unsubscribed from VAD stream");
+      }
+    };
+  }
+  stop() {
+    if (this.chunkHandlers.size > 0) {
+      this.chunkHandlers.clear();
+      this.deps.removeSubscription(AUDIO_CHUNK_STREAM);
+      this.deps.logger.debug("Stopped audio_chunk subscriptions");
+    }
+    if (this.vadHandlers.size > 0) {
+      this.vadHandlers.clear();
+      this.deps.removeSubscription(VAD_STREAM);
+      if (this.vadRouterCleanup) {
+        this.vadRouterCleanup();
+        this.vadRouterCleanup = null;
+      }
+      this.deps.logger.debug("Stopped VAD subscriptions");
+    }
+    this._isSpeaking = false;
+  }
+  handleBinaryAudio(data) {
+    if (this.chunkHandlers.size === 0) {
+      return;
+    }
+    const chunk = {
+      data,
+      sampleRate: 16000,
+      channels: 1,
+      timestamp: Date.now()
+    };
+    for (const handler of this.chunkHandlers) {
+      try {
+        handler(chunk);
+      } catch (err) {
+        this.deps.logger.error("Audio chunk handler error:", err);
+      }
+    }
+  }
+  handleVadMessage(data) {
+    if (!data)
+      return;
+    const rawStatus = data.status;
+    let isSpeaking;
+    if (typeof rawStatus === "boolean") {
+      isSpeaking = rawStatus;
+    } else if (typeof rawStatus === "string") {
+      isSpeaking = rawStatus.toLowerCase() === "true";
+    } else {
+      this.deps.logger.warn("Unexpected VAD status type:", typeof rawStatus, rawStatus);
+      return;
+    }
+    this._isSpeaking = isSpeaking;
+    const event = {
+      isSpeaking,
+      timestamp: Date.now()
+    };
+    for (const handler of this.vadHandlers) {
+      try {
+        handler(event);
+      } catch (err) {
+        this.deps.logger.error("VAD handler error:", err);
+      }
+    }
+  }
+}
+
+// src/session/managers/PermissionsManager.ts
+var ALL_PERMISSIONS = [
+  "location",
+  "microphone",
+  "camera",
+  "notifications",
+  "calendar"
+];
+function createDefaultPermissions() {
+  return {
+    location: false,
+    microphone: false,
+    camera: false,
+    notifications: false,
+    calendar: false
+  };
+}
+
+class PermissionsManager {
+  permissions;
+  listeners = new Set;
+  logger;
+  constructor(deps) {
+    this.logger = deps.logger;
+    this.permissions = createDefaultPermissions();
+  }
+  has(permission) {
+    return this.permissions[permission] ?? false;
+  }
+  getAll() {
+    return { ...this.permissions };
+  }
+  onUpdate(handler) {
+    this.listeners.add(handler);
+    return () => {
+      this.listeners.delete(handler);
+    };
+  }
+  updateFromSettings(settings) {
+    if (!settings) {
+      this.logger.debug("PermissionsManager: No settings provided, skipping update");
+      return;
+    }
+    const previous = { ...this.permissions };
+    let updated = false;
+    const permissionsSource = settings.permissions ?? settings.appPermissions ?? settings;
+    for (const perm of ALL_PERMISSIONS) {
+      if (perm in permissionsSource) {
+        const value = Boolean(permissionsSource[perm]);
+        if (this.permissions[perm] !== value) {
+          this.permissions[perm] = value;
+          updated = true;
+        }
+      }
+    }
+    if (updated) {
+      this.logger.info("PermissionsManager: Permissions updated — " + ALL_PERMISSIONS.map((p) => `${p}=${this.permissions[p]}`).join(", "));
+      for (const perm of ALL_PERMISSIONS) {
+        if (previous[perm] !== this.permissions[perm]) {
+          this.logger.debug(`PermissionsManager: ${perm}: ${previous[perm]} → ${this.permissions[perm]}`);
+        }
+      }
+      const snapshot = this.getAll();
+      for (const listener of this.listeners) {
+        try {
+          listener(snapshot);
+        } catch (err) {
+          this.logger.error(`PermissionsManager: Error in onUpdate listener: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+    } else {
+      this.logger.debug("PermissionsManager: No permission changes detected");
+    }
+  }
+}
+
+// src/session/managers/PhoneManager.ts
+init_streams();
+function normaliseCalendarEvent(raw) {
+  return {
+    ...raw,
+    eventId: raw.eventId ?? raw.event_id ?? "unknown",
+    title: raw.title ?? "",
+    start: raw.dtStart ?? raw.start ?? "",
+    end: raw.dtEnd ?? raw.end ?? "",
+    timezone: raw.timezone ?? "",
+    timestamp: raw.timeStamp ?? raw.timestamp ?? new Date().toISOString()
+  };
+}
+
+class StreamHandlerTracker {
+  router;
+  addSubscription;
+  removeSubscription;
+  handlerCounts = new Map;
+  cleanups = [];
+  constructor(router, addSubscription, removeSubscription) {
+    this.router = router;
+    this.addSubscription = addSubscription;
+    this.removeSubscription = removeSubscription;
+  }
+  add(streamKey, handler) {
+    const currentCount = this.handlerCounts.get(streamKey) ?? 0;
+    if (currentCount === 0) {
+      this.addSubscription(streamKey);
+    }
+    this.handlerCounts.set(streamKey, currentCount + 1);
+    const routerCleanup = this.router.on(streamKey, handler);
+    let cleaned = false;
+    const cleanup = () => {
+      if (cleaned)
+        return;
+      cleaned = true;
+      routerCleanup();
+      const count = this.handlerCounts.get(streamKey) ?? 0;
+      const newCount = count - 1;
+      if (newCount <= 0) {
+        this.handlerCounts.delete(streamKey);
+        this.removeSubscription(streamKey);
+      } else {
+        this.handlerCounts.set(streamKey, newCount);
+      }
+    };
+    this.cleanups.push(cleanup);
+    return cleanup;
+  }
+  destroyAll() {
+    for (const fn of this.cleanups) {
+      fn();
+    }
+    this.cleanups.length = 0;
+    this.handlerCounts.clear();
+  }
+}
+
+class NotificationSubManager {
+  permissions;
+  tracker;
+  logger;
+  constructor(permissions, tracker, logger2) {
+    this.permissions = permissions;
+    this.tracker = tracker;
+    this.logger = logger2;
+  }
+  get hasPermission() {
+    return this.permissions.has("notifications");
+  }
+  on(handler) {
+    return this.tracker.add("phone_notification" /* PHONE_NOTIFICATION */, (_streamType, data) => {
+      try {
+        handler({
+          notificationId: data.notificationId ?? data.notification_id ?? "unknown",
+          app: data.app ?? "unknown",
+          title: data.title ?? "",
+          content: data.content ?? "",
+          priority: data.priority ?? "normal"
+        });
+      } catch (err) {
+        this.logger.error(`NotificationSubManager: Error in notification handler: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    });
+  }
+  onDismissed(handler) {
+    return this.tracker.add("phone_notification_dismissed" /* PHONE_NOTIFICATION_DISMISSED */, (_streamType, data) => {
+      try {
+        handler({
+          notificationId: data.notificationId ?? data.notification_id ?? "unknown",
+          app: data.app ?? "unknown",
+          title: data.title ?? "",
+          content: data.content ?? "",
+          notificationKey: data.notificationKey ?? data.notification_key ?? ""
+        });
+      } catch (err) {
+        this.logger.error(`NotificationSubManager: Error in dismissal handler: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    });
+  }
+}
+
+class CalendarSubManager {
+  permissions;
+  tracker;
+  logger;
+  constructor(permissions, tracker, logger2) {
+    this.permissions = permissions;
+    this.tracker = tracker;
+    this.logger = logger2;
+  }
+  get hasPermission() {
+    return this.permissions.has("calendar");
+  }
+  on(handler) {
+    return this.tracker.add("calendar_event" /* CALENDAR_EVENT */, (_streamType, data) => {
+      try {
+        handler(normaliseCalendarEvent(data));
+      } catch (err) {
+        this.logger.error(`CalendarSubManager: Error in calendar handler: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    });
+  }
+}
+
+class PhoneManager {
+  notifications;
+  calendar;
+  deps;
+  permissions;
+  tracker;
+  _battery = null;
+  constructor(deps) {
+    this.deps = deps;
+    this.permissions = deps.permissions;
+    this.tracker = new StreamHandlerTracker(deps.router, deps.addSubscription, deps.removeSubscription);
+    this.notifications = new NotificationSubManager(this.permissions, this.tracker, deps.logger);
+    this.calendar = new CalendarSubManager(this.permissions, this.tracker, deps.logger);
+  }
+  get battery() {
+    return this._battery;
+  }
+  onBatteryUpdate(handler) {
+    return this.tracker.add("phone_battery_update" /* PHONE_BATTERY_UPDATE */, (_streamType, data) => {
+      const level = data.level ?? data.batteryLevel ?? data.battery_level;
+      if (level !== undefined) {
+        this._battery = level;
+      }
+      try {
+        handler({
+          level: level ?? 0,
+          charging: data.charging ?? false,
+          timeRemaining: data.timeRemaining ?? data.time_remaining
+        });
+      } catch (err) {
+        this.deps.logger.error(`PhoneManager: Error in battery handler: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    });
+  }
+  destroy() {
+    this.tracker.destroyAll();
+    this._battery = null;
+    this.deps.logger.debug("PhoneManager: Destroyed.");
+  }
+}
+
+// src/session/managers/SpeakerManager.ts
+init_message_types();
+var STREAM_ID_LENGTH = 36;
+var STREAM_READY_TIMEOUT_MS = 1e4;
+var PLAY_RESPONSE_TIMEOUT_MS = 60000;
+
+class AudioOutputStreamImpl {
+  id;
+  _state = "created";
+  deps;
+  streamIdBytes;
+  options;
+  stateChangeHandlers = [];
+  streamUrl = null;
+  constructor(streamId, deps, opts = {}) {
+    this.id = streamId;
+    this.deps = deps;
+    this.options = {
+      format: opts.format ?? "mp3",
+      sampleRate: opts.sampleRate ?? 24000,
+      channels: opts.channels ?? 1,
+      bitrate: opts.bitrate ?? 128,
+      volume: opts.volume ?? 1,
+      trackId: opts.trackId ?? 1,
+      stopOtherAudio: opts.stopOtherAudio ?? true
+    };
+    this.streamIdBytes = new TextEncoder().encode(this.id);
+  }
+  get state() {
+    return this._state;
+  }
+  async open() {
+    if (this._state !== "created") {
+      throw new Error(`Cannot open stream in state "${this._state}"`);
+    }
+    const startMessage = {
+      type: "audio_stream_start" /* AUDIO_STREAM_START */,
+      packageName: this.deps.getPackageName(),
+      sessionId: this.deps.getSessionId(),
+      streamId: this.id,
+      contentType: "audio/mpeg",
+      timestamp: new Date
+    };
+    this.deps.sendMessage(startMessage);
+    this.streamUrl = await this.waitForReady();
+    this.setState("streaming");
+    const playMessage = {
+      type: "audio_play_request" /* AUDIO_PLAY_REQUEST */,
+      packageName: this.deps.getPackageName(),
+      sessionId: this.deps.getSessionId(),
+      requestId: `stream_${this.id}`,
+      audioUrl: this.streamUrl,
+      volume: this.options.volume,
+      stopOtherAudio: this.options.stopOtherAudio,
+      trackId: this.options.trackId,
+      timestamp: new Date
+    };
+    this.deps.sendMessage(playMessage);
+    this.deps.logger.debug("Audio output stream opened", this.id);
+  }
+  write(chunk) {
+    if (this._state !== "streaming") {
+      this.deps.logger.debug(`Write called on non-streaming output (state=${this._state}), ignoring`);
+      return;
+    }
+    if (chunk.length === 0)
+      return;
+    this.sendBinaryFrame(chunk);
+  }
+  async end() {
+    if (this._state !== "streaming")
+      return;
+    this.setState("ending");
+    const endMessage = {
+      type: "audio_stream_end" /* AUDIO_STREAM_END */,
+      packageName: this.deps.getPackageName(),
+      sessionId: this.deps.getSessionId(),
+      streamId: this.id,
+      timestamp: new Date
+    };
+    this.deps.sendMessage(endMessage);
+    this.setState("ended");
+    this.deps.logger.debug("Audio output stream ended");
+  }
+  flush() {
+    if (this._state !== "streaming")
+      return;
+    this.setState("ending");
+    const endMessage = {
+      type: "audio_stream_end" /* AUDIO_STREAM_END */,
+      packageName: this.deps.getPackageName(),
+      sessionId: this.deps.getSessionId(),
+      streamId: this.id,
+      timestamp: new Date
+    };
+    this.deps.sendMessage(endMessage);
+    const stopMessage = {
+      type: "audio_stop_request" /* AUDIO_STOP_REQUEST */,
+      packageName: this.deps.getPackageName(),
+      sessionId: this.deps.getSessionId(),
+      trackId: this.options.trackId,
+      timestamp: new Date
+    };
+    this.deps.sendMessage(stopMessage);
+    this.setState("ended");
+    this.deps.logger.debug("Audio output stream flushed (interrupted)");
+  }
+  onStateChange(handler) {
+    this.stateChangeHandlers.push(handler);
+  }
+  setState(state) {
+    this._state = state;
+    for (const handler of this.stateChangeHandlers) {
+      try {
+        handler(state);
+      } catch (err) {
+        this.deps.logger.error("AudioOutputStream state change handler error:", err);
+      }
+    }
+  }
+  sendBinaryFrame(audioData) {
+    const frame = new Uint8Array(STREAM_ID_LENGTH + audioData.length);
+    frame.set(this.streamIdBytes, 0);
+    frame.set(audioData, STREAM_ID_LENGTH);
+    try {
+      this.deps.sendBinary(frame);
+    } catch (err) {
+      this.deps.logger.error("Failed to send binary audio frame:", err);
+      this.setState("error");
+    }
+  }
+  waitForReady() {
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const timeout = setTimeout(() => {
+        if (settled)
+          return;
+        settled = true;
+        unregister();
+        reject(new Error(`Audio stream relay not ready after ${STREAM_READY_TIMEOUT_MS}ms`));
+      }, STREAM_READY_TIMEOUT_MS);
+      const unregister = this.deps.messageHandlers.register("audio_stream_ready" /* AUDIO_STREAM_READY */, (message) => {
+        if (message?.streamId === this.id) {
+          if (settled)
+            return;
+          settled = true;
+          clearTimeout(timeout);
+          unregister();
+          resolve(message.streamUrl);
+        }
+      });
+    });
+  }
+}
+
+class SpeakerManager {
+  deps;
+  pendingRequests = new Map;
+  activeStream = null;
+  _hasPermission = true;
+  responseHandlerCleanup = null;
+  constructor(deps) {
+    this.deps = deps;
+    this.responseHandlerCleanup = this.deps.messageHandlers.register("audio_play_response" /* AUDIO_PLAY_RESPONSE */, (message) => {
+      this.handleAudioPlayResponse(message);
+    });
+  }
+  get hasPermission() {
+    return this._hasPermission;
+  }
+  async play(opts) {
+    if (!opts.url) {
+      throw new Error("PlayOptions.url must be provided");
+    }
+    const requestId = `audio_req_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    const volume = opts.volume ?? 1;
+    const trackId = opts.trackId ?? 0;
+    const stopOtherAudio = opts.stopOtherAudio ?? false;
+    const message = {
+      type: "audio_play_request" /* AUDIO_PLAY_REQUEST */,
+      packageName: this.deps.getPackageName(),
+      sessionId: this.deps.getSessionId(),
+      requestId,
+      timestamp: new Date,
+      audioUrl: opts.url,
+      volume,
+      stopOtherAudio,
+      trackId
+    };
+    if (!stopOtherAudio) {
+      this.deps.sendMessage(message);
+      this.deps.logger.debug("Audio playback started in non-blocking mode", requestId);
+      return { duration: 0 };
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(requestId);
+        reject(new Error("Audio play request timed out"));
+        this.deps.logger.warn("Audio play request timed out", requestId);
+      }, PLAY_RESPONSE_TIMEOUT_MS);
+      this.pendingRequests.set(requestId, { resolve, reject, timer });
+      this.deps.sendMessage(message);
+    });
+  }
+  async stop(trackId) {
+    const message = {
+      type: "audio_stop_request" /* AUDIO_STOP_REQUEST */,
+      packageName: this.deps.getPackageName(),
+      sessionId: this.deps.getSessionId(),
+      trackId,
+      timestamp: new Date
+    };
+    this.deps.sendMessage(message);
+    const trackInfo = trackId !== undefined ? ` (track ${trackId})` : " (all tracks)";
+    this.deps.logger.info(`Audio stop request sent${trackInfo}`);
+  }
+  async speak(text, opts = {}) {
+    if (!text) {
+      throw new Error("text must be provided");
+    }
+    const queryParams = new URLSearchParams;
+    queryParams.append("text", text);
+    if (opts.voiceId) {
+      queryParams.append("voice_id", opts.voiceId);
+    }
+    if (opts.modelId) {
+      queryParams.append("model_id", opts.modelId);
+    }
+    if (opts.voiceSettings) {
+      const settings = {};
+      if (opts.voiceSettings.stability !== undefined)
+        settings.stability = opts.voiceSettings.stability;
+      if (opts.voiceSettings.similarityBoost !== undefined)
+        settings.similarity_boost = opts.voiceSettings.similarityBoost;
+      if (opts.voiceSettings.style !== undefined)
+        settings.style = opts.voiceSettings.style;
+      if (opts.voiceSettings.speed !== undefined)
+        settings.speed = opts.voiceSettings.speed;
+      queryParams.append("voice_settings", JSON.stringify(settings));
+    }
+    const ttsUrl = `/api/tts?${queryParams.toString()}`;
+    this.deps.logger.debug("Generating speech from text", text);
+    return this.play({
+      url: ttsUrl,
+      volume: opts.volume,
+      stopOtherAudio: opts.stopOtherAudio ?? false,
+      trackId: opts.trackId ?? 2
+    });
+  }
+  async createStream(opts = {}) {
+    if (this.activeStream && this.activeStream.state === "streaming") {
+      const err = new Error(`AUDIO_STREAM_ALREADY_ACTIVE: Stream ${this.activeStream.id} is still active. ` + `Call end() or flush() before creating a new output stream.`);
+      err.code = "AUDIO_STREAM_ALREADY_ACTIVE";
+      this.deps.logger.warn("Refusing to create a second output stream while one is active");
+      throw err;
+    }
+    const streamId = crypto.randomUUID();
+    const stream = new AudioOutputStreamImpl(streamId, this.deps, opts);
+    await stream.open();
+    this.activeStream = stream;
+    stream.onStateChange((state) => {
+      if ((state === "ended" || state === "error") && this.activeStream === stream) {
+        this.activeStream = null;
+      }
+    });
+    return stream;
+  }
+  destroy() {
+    if (this.responseHandlerCleanup) {
+      this.responseHandlerCleanup();
+      this.responseHandlerCleanup = null;
+    }
+    for (const [requestId, pending] of this.pendingRequests) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error("SpeakerManager destroyed"));
+      this.deps.logger.debug("Audio request cancelled during cleanup", requestId);
+    }
+    this.pendingRequests.clear();
+    if (this.activeStream && this.activeStream.state === "streaming") {
+      this.activeStream.end().catch(() => {});
+      this.activeStream = null;
+    }
+  }
+  handleAudioPlayResponse(response) {
+    const requestId = response?.requestId;
+    if (!requestId)
+      return;
+    const pending = this.pendingRequests.get(requestId);
+    if (!pending) {
+      this.deps.logger.debug("Received audio play response for unknown request", requestId);
+      return;
+    }
+    clearTimeout(pending.timer);
+    this.pendingRequests.delete(requestId);
+    if (response.success) {
+      pending.resolve({
+        duration: response.duration ?? 0
+      });
+      this.deps.logger.info("Audio play response received", requestId, "duration:", response.duration);
+    } else {
+      pending.reject(new Error(response.error || "Audio playback failed"));
+      this.deps.logger.warn("Audio play failed", requestId, response.error);
+    }
+  }
+}
+
+// src/session/managers/StorageManager.ts
+var MAX_VALUE_SIZE = 1e5;
+var DEBOUNCE_MS = 3000;
+var MAX_WAIT_MS = 1e4;
+
+class StorageManager {
+  deps;
+  userId;
+  apiKey;
+  cache = null;
+  baseUrl;
+  pendingWrites = new Map;
+  debounceTimer;
+  maxWaitTimer;
+  firstWriteTime;
+  constructor(deps, config) {
+    this.deps = deps;
+    this.userId = config.userId;
+    this.apiKey = config.apiKey ?? "unknown-api-key";
+    this.baseUrl = this.resolveBaseUrl();
+  }
+  async get(key) {
+    try {
+      await this.ensureCacheLoaded();
+      return this.cache?.[key];
+    } catch (error) {
+      this.deps.logger.error("[StorageManager] Error getting item:", error);
+      return;
+    }
+  }
+  async set(key, value) {
+    const serialised = typeof value === "string" ? value : JSON.stringify(value);
+    if (serialised.length > MAX_VALUE_SIZE) {
+      throw new Error(`StorageManager value exceeds 100KB limit (${serialised.length} chars). ` + `For large files, use your own S3 bucket storage.`);
+    }
+    await this.ensureCacheLoaded();
+    if (this.cache) {
+      this.cache[key] = serialised;
+    }
+    this.pendingWrites.set(key, serialised);
+    this.scheduleFlush();
+  }
+  async delete(key) {
+    try {
+      await this.ensureCacheLoaded();
+      if (this.cache) {
+        delete this.cache[key];
+      }
+      this.pendingWrites.delete(key);
+      const response = await fetch(`${this.baseUrl}/api/sdk/simple-storage/${encodeURIComponent(this.userId)}/${encodeURIComponent(key)}`, {
+        method: "DELETE",
+        headers: this.getAuthHeaders()
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        this.deps.logger.error("[StorageManager] Failed to delete key from server:", errorText);
+      }
+    } catch (error) {
+      this.deps.logger.error("[StorageManager] Error deleting item:", error);
+    }
+  }
+  async clear() {
+    try {
+      this.cache = {};
+      this.pendingWrites.clear();
+      this.clearTimers();
+      const response = await fetch(`${this.baseUrl}/api/sdk/simple-storage/${encodeURIComponent(this.userId)}`, {
+        method: "DELETE",
+        headers: this.getAuthHeaders()
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        this.deps.logger.error("[StorageManager] Failed to clear storage on server:", errorText);
+      }
+    } catch (error) {
+      this.deps.logger.error("[StorageManager] Error clearing storage:", error);
+    }
+  }
+  async keys() {
+    try {
+      await this.ensureCacheLoaded();
+      return Object.keys(this.cache || {});
+    } catch (error) {
+      this.deps.logger.error("[StorageManager] Error getting keys:", error);
+      return [];
+    }
+  }
+  async has(key) {
+    try {
+      await this.ensureCacheLoaded();
+      return key in (this.cache || {});
+    } catch (error) {
+      this.deps.logger.error("[StorageManager] Error checking key:", error);
+      return false;
+    }
+  }
+  async getAll() {
+    try {
+      await this.ensureCacheLoaded();
+      return { ...this.cache || {} };
+    } catch (error) {
+      this.deps.logger.error("[StorageManager] Error getting all data:", error);
+      return {};
+    }
+  }
+  async setMultiple(data) {
+    for (const [key, value] of Object.entries(data)) {
+      const serialised = typeof value === "string" ? value : JSON.stringify(value);
+      if (serialised.length > MAX_VALUE_SIZE) {
+        throw new Error(`StorageManager value for key "${key}" exceeds 100KB limit (${serialised.length} chars).`);
+      }
+    }
+    await this.ensureCacheLoaded();
+    for (const [key, value] of Object.entries(data)) {
+      const serialised = typeof value === "string" ? value : JSON.stringify(value);
+      if (this.cache) {
+        this.cache[key] = serialised;
+      }
+      this.pendingWrites.set(key, serialised);
+    }
+    this.scheduleFlush();
+  }
+  async flush() {
+    if (this.pendingWrites.size === 0)
+      return;
+    this.clearTimers();
+    const batch = Object.fromEntries(this.pendingWrites);
+    this.pendingWrites.clear();
+    try {
+      const response = await fetch(`${this.baseUrl}/api/sdk/simple-storage/${encodeURIComponent(this.userId)}`, {
+        method: "PUT",
+        headers: this.getAuthHeaders(),
+        body: JSON.stringify({ data: batch })
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        this.deps.logger.error("[StorageManager] Failed to persist writes:", errorText);
+        if (response.status === 413) {
+          throw new Error("StorageManager total size exceeds 1MB limit. Delete unused keys.");
+        }
+        if (response.status === 429) {
+          throw new Error("StorageManager rate limit exceeded.");
+        }
+        throw new Error(`StorageManager flush failed: ${errorText}`);
+      }
+    } catch (error) {
+      this.deps.logger.error("[StorageManager] Error flushing writes:", error);
+      throw error;
+    }
+  }
+  async destroy() {
+    try {
+      await this.flush();
+    } catch (error) {
+      this.deps.logger.error("[StorageManager] Error flushing on destroy:", error);
+    }
+    this.clearTimers();
+    this.pendingWrites.clear();
+    this.cache = null;
+    this.deps.logger.debug("[StorageManager] Destroyed.");
+  }
+  async ensureCacheLoaded() {
+    if (this.cache !== null)
+      return;
+    await this.fetchFromServer();
+  }
+  async fetchFromServer() {
+    try {
+      const response = await fetch(`${this.baseUrl}/api/sdk/simple-storage/${encodeURIComponent(this.userId)}`, {
+        headers: this.getAuthHeaders()
+      });
+      if (response.ok) {
+        const result = await response.json();
+        if (result.success && result.data) {
+          this.cache = result.data;
+        } else {
+          this.cache = {};
+        }
+      } else {
+        this.deps.logger.error("[StorageManager] Failed to fetch storage from server:", await response.text());
+        this.cache = {};
+      }
+    } catch (error) {
+      this.deps.logger.error("[StorageManager] Error fetching storage from server:", error);
+      this.cache = {};
+    }
+  }
+  scheduleFlush() {
+    if (!this.firstWriteTime) {
+      this.firstWriteTime = Date.now();
+    }
+    if (this.debounceTimer !== undefined) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = undefined;
+    }
+    const elapsedMs = Date.now() - this.firstWriteTime;
+    const remainingMaxWaitMs = MAX_WAIT_MS - elapsedMs;
+    if (remainingMaxWaitMs <= 0) {
+      this.flush().catch((err) => {
+        this.deps.logger.error("[StorageManager] Error in scheduled flush:", err);
+      });
+      return;
+    }
+    this.debounceTimer = setTimeout(() => {
+      this.flush().catch((err) => {
+        this.deps.logger.error("[StorageManager] Error in debounced flush:", err);
+      });
+    }, Math.min(DEBOUNCE_MS, remainingMaxWaitMs));
+    if (this.maxWaitTimer === undefined && remainingMaxWaitMs > 0) {
+      this.maxWaitTimer = setTimeout(() => {
+        this.flush().catch((err) => {
+          this.deps.logger.error("[StorageManager] Error in max-wait flush:", err);
+        });
+      }, remainingMaxWaitMs);
+    }
+  }
+  clearTimers() {
+    if (this.debounceTimer !== undefined) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = undefined;
+    }
+    if (this.maxWaitTimer !== undefined) {
+      clearTimeout(this.maxWaitTimer);
+      this.maxWaitTimer = undefined;
+    }
+    this.firstWriteTime = undefined;
+  }
+  resolveBaseUrl() {
+    const serverUrl = this.deps.getServerUrl?.() ?? null;
+    if (!serverUrl)
+      return "http://localhost:8002";
+    return serverUrl.replace(/\/app-ws$/, "").replace(/^ws/, "http");
+  }
+  getAuthHeaders() {
+    return {
+      Authorization: `Bearer ${this.deps.getPackageName()}:${this.apiKey}`,
+      "Content-Type": "application/json"
+    };
+  }
+}
+
+// src/session/managers/TimeUtils.ts
+class TimeUtils {
+  _zone;
+  constructor(timezone) {
+    TimeUtils.validateTimezone(timezone);
+    this._zone = timezone;
+  }
+  get zone() {
+    return this._zone;
+  }
+  now() {
+    return new Date;
+  }
+  toLocal(date = new Date) {
+    const parts = new Intl.DateTimeFormat("en-US", {
+      timeZone: this._zone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      hour12: false
+    }).formatToParts(date);
+    const get = (type) => {
+      const part = parts.find((p) => p.type === type);
+      return part?.value ?? "0";
+    };
+    const year = parseInt(get("year"), 10);
+    const month = parseInt(get("month"), 10) - 1;
+    const day = parseInt(get("day"), 10);
+    let hour = parseInt(get("hour"), 10);
+    const minute = parseInt(get("minute"), 10);
+    const second = parseInt(get("second"), 10);
+    if (hour === 24)
+      hour = 0;
+    return new Date(Date.UTC(year, month, day, hour, minute, second));
+  }
+  format(date, opts) {
+    const mergedOpts = {
+      ...opts,
+      timeZone: this._zone
+    };
+    return new Intl.DateTimeFormat(undefined, mergedOpts).format(date);
+  }
+  setTimezone(tz) {
+    TimeUtils.validateTimezone(tz);
+    this._zone = tz;
+  }
+  static validateTimezone(tz) {
+    try {
+      Intl.DateTimeFormat(undefined, { timeZone: tz });
+    } catch {
+      throw new RangeError(`Invalid timezone: "${tz}". ` + `Must be a valid IANA timezone identifier (e.g., "America/New_York", "UTC", "Asia/Tokyo").`);
+    }
+  }
+}
+
+// src/session/managers/TranscriptionManager.ts
+init_types();
+var STREAM_PREFIX = "transcription" /* TRANSCRIPTION */;
+function subscriptionKey(lang) {
+  return `${STREAM_PREFIX}:${lang}`;
+}
+function normalise2(streamType, raw) {
+  const language = raw.detectedLanguage ?? raw.transcribeLanguage ?? streamType.replace(`${STREAM_PREFIX}:`, "") ?? "";
+  return {
+    text: raw.text ?? "",
+    isFinal: !!raw.isFinal,
+    language,
+    speakerId: raw.speakerId,
+    utteranceId: raw.utteranceId,
+    confidence: raw.confidence,
+    startTime: raw.startTime ?? 0,
+    endTime: raw.endTime ?? 0,
+    duration: raw.duration,
+    metadata: raw.metadata
+  };
+}
+
+class TranscriptionManager {
+  deps;
+  registrations = new Set;
+  refCounts = new Map;
+  currentConfig = null;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  on(handler) {
+    const stream = subscriptionKey("auto");
+    const routerCleanup = this.deps.router.on(STREAM_PREFIX, (_streamType, data, _message) => {
+      try {
+        handler(normalise2(_streamType, data));
+      } catch (err) {
+        this.deps.logger.error(`[TranscriptionManager] Error in on() handler:`, err);
+      }
+    });
+    const reg = {
+      streams: [stream],
+      routerCleanups: [routerCleanup]
+    };
+    this.addRegistration(reg);
+    return () => this.removeRegistration(reg);
+  }
+  forLanguage(lang, handler) {
+    const langs = Array.isArray(lang) ? lang : [lang];
+    if (langs.length === 0) {
+      this.deps.logger.warn("[TranscriptionManager] forLanguage() called with empty language array — no-op.");
+      return () => {};
+    }
+    const streams2 = [];
+    const routerCleanups = [];
+    for (const l of langs) {
+      const stream = subscriptionKey(l);
+      const cleanup = this.deps.router.on(stream, (_streamType, data, _message) => {
+        try {
+          handler(normalise2(_streamType, data));
+        } catch (err) {
+          this.deps.logger.error(`[TranscriptionManager] Error in forLanguage("${l}") handler:`, err);
+        }
+      });
+      streams2.push(stream);
+      routerCleanups.push(cleanup);
+    }
+    const reg = { streams: streams2, routerCleanups };
+    this.addRegistration(reg);
+    return () => this.removeRegistration(reg);
+  }
+  configure(config) {
+    this.currentConfig = { ...config };
+    this.deps.sendMessage({
+      type: "transcription_config",
+      languageHints: config.languageHints,
+      vocabulary: config.vocabulary,
+      diarization: config.diarization ?? true
+    });
+    this.deps.logger.debug("[TranscriptionManager] Configuration sent:", config);
+  }
+  stop() {
+    const snapshot = Array.from(this.registrations);
+    for (const reg of snapshot) {
+      this.removeRegistration(reg);
+    }
+    this.currentConfig = null;
+    this.deps.logger.debug("[TranscriptionManager] All subscriptions stopped.");
+  }
+  get active() {
+    return this.registrations.size > 0;
+  }
+  get config() {
+    return this.currentConfig ? { ...this.currentConfig } : null;
+  }
+  addRegistration(reg) {
+    this.registrations.add(reg);
+    for (const stream of reg.streams) {
+      const prev = this.refCounts.get(stream) ?? 0;
+      this.refCounts.set(stream, prev + 1);
+      if (prev === 0) {
+        this.deps.addSubscription(stream);
+        this.deps.logger.debug(`[TranscriptionManager] Subscribed to "${stream}".`);
+      }
+    }
+  }
+  removeRegistration(reg) {
+    if (!this.registrations.has(reg))
+      return;
+    for (const cleanup of reg.routerCleanups) {
+      try {
+        cleanup();
+      } catch {}
+    }
+    for (const stream of reg.streams) {
+      const count = this.refCounts.get(stream) ?? 0;
+      const next = count - 1;
+      if (next <= 0) {
+        this.refCounts.delete(stream);
+        this.deps.removeSubscription(stream);
+        this.deps.logger.debug(`[TranscriptionManager] Unsubscribed from "${stream}".`);
+      } else {
+        this.refCounts.set(stream, next);
+      }
+    }
+    this.registrations.delete(reg);
+  }
+}
+
+// src/session/managers/TranslationManager.ts
+init_types();
+var STREAM_PREFIX2 = "translation" /* TRANSLATION */;
+function subscriptionKey2(source, target) {
+  return `${STREAM_PREFIX2}:${source}-${target}`;
+}
+function parseStreamType(streamType) {
+  const prefixLen = STREAM_PREFIX2.length + 1;
+  if (!streamType.startsWith(`${STREAM_PREFIX2}:`))
+    return null;
+  const pair = streamType.slice(prefixLen);
+  const dashIdx = pair.indexOf("-");
+  if (dashIdx === -1)
+    return null;
+  return {
+    source: pair.slice(0, dashIdx),
+    target: pair.slice(dashIdx + 1)
+  };
+}
+function normalise3(streamType, raw) {
+  const parsed = parseStreamType(streamType);
+  const sourceLanguage = raw.transcribeLanguage ?? parsed?.source ?? "";
+  const targetLanguage = raw.translateLanguage ?? parsed?.target ?? "";
+  return {
+    text: raw.text ?? "",
+    isFinal: !!raw.isFinal,
+    sourceLanguage,
+    targetLanguage,
+    originalText: raw.originalText,
+    utteranceId: raw.utteranceId,
+    confidence: raw.confidence,
+    startTime: raw.startTime ?? 0,
+    endTime: raw.endTime ?? 0
+  };
+}
+
+class TranslationManager {
+  deps;
+  registrations = new Set;
+  refCounts = new Map;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  on(handler) {
+    const routerCleanup = this.deps.router.on(STREAM_PREFIX2, (_streamType, data, _message) => {
+      try {
+        handler(normalise3(_streamType, data));
+      } catch (err) {
+        this.deps.logger.error("[TranslationManager] Error in on() handler:", err);
+      }
+    });
+    const reg = {
+      streams: [],
+      routerCleanups: [routerCleanup]
+    };
+    this.registrations.add(reg);
+    return () => this.removeRegistration(reg);
+  }
+  to(target, handler) {
+    const targets = Array.isArray(target) ? target : [target];
+    if (targets.length === 0) {
+      this.deps.logger.warn("[TranslationManager] to() called with empty target array — no-op.");
+      return () => {};
+    }
+    const streams2 = [];
+    const routerCleanups = [];
+    for (const t of targets) {
+      const stream = subscriptionKey2("auto", t);
+      const cleanup = this.deps.router.on(stream, (_streamType, data, _message) => {
+        try {
+          handler(normalise3(_streamType, data));
+        } catch (err) {
+          this.deps.logger.error(`[TranslationManager] Error in to("${t}") handler:`, err);
+        }
+      });
+      streams2.push(stream);
+      routerCleanups.push(cleanup);
+    }
+    const reg = { streams: streams2, routerCleanups };
+    this.addRegistration(reg);
+    return () => this.removeRegistration(reg);
+  }
+  fromTo(source, target, handler) {
+    const targets = Array.isArray(target) ? target : [target];
+    if (targets.length === 0) {
+      this.deps.logger.warn("[TranslationManager] fromTo() called with empty target array — no-op.");
+      return () => {};
+    }
+    const streams2 = [];
+    const routerCleanups = [];
+    for (const t of targets) {
+      const stream = subscriptionKey2(source, t);
+      const cleanup = this.deps.router.on(stream, (_streamType, data, _message) => {
+        try {
+          handler(normalise3(_streamType, data));
+        } catch (err) {
+          this.deps.logger.error(`[TranslationManager] Error in fromTo("${source}", "${t}") handler:`, err);
+        }
+      });
+      streams2.push(stream);
+      routerCleanups.push(cleanup);
+    }
+    const reg = { streams: streams2, routerCleanups };
+    this.addRegistration(reg);
+    return () => this.removeRegistration(reg);
+  }
+  stop() {
+    const snapshot = Array.from(this.registrations);
+    for (const reg of snapshot) {
+      this.removeRegistration(reg);
+    }
+    this.deps.logger.debug("[TranslationManager] All subscriptions stopped.");
+  }
+  get active() {
+    return this.registrations.size > 0;
+  }
+  addRegistration(reg) {
+    this.registrations.add(reg);
+    for (const stream of reg.streams) {
+      const prev = this.refCounts.get(stream) ?? 0;
+      this.refCounts.set(stream, prev + 1);
+      if (prev === 0) {
+        this.deps.addSubscription(stream);
+        this.deps.logger.debug(`[TranslationManager] Subscribed to "${stream}".`);
+      }
+    }
+  }
+  removeRegistration(reg) {
+    if (!this.registrations.has(reg))
+      return;
+    for (const cleanup of reg.routerCleanups) {
+      try {
+        cleanup();
+      } catch {}
+    }
+    for (const stream of reg.streams) {
+      const count = this.refCounts.get(stream) ?? 0;
+      const next = count - 1;
+      if (next <= 0) {
+        this.refCounts.delete(stream);
+        this.deps.removeSubscription(stream);
+        this.deps.logger.debug(`[TranslationManager] Unsubscribed from "${stream}".`);
+      } else {
+        this.refCounts.set(stream, next);
+      }
+    }
+    this.registrations.delete(reg);
+  }
+}
+
+// src/session/DataStreamRouter.ts
+class MessageHandlerRegistry {
+  handlers = new Map;
+  register(type, handler) {
+    let list = this.handlers.get(type);
+    if (!list) {
+      list = [];
+      this.handlers.set(type, list);
+    }
+    list.push(handler);
+    return () => {
+      const arr = this.handlers.get(type);
+      if (arr) {
+        const idx = arr.indexOf(handler);
+        if (idx !== -1) {
+          arr.splice(idx, 1);
+        }
+        if (arr.length === 0) {
+          this.handlers.delete(type);
+        }
+      }
+    };
+  }
+  dispatch(message) {
+    const list = this.handlers.get(message.type);
+    if (!list || list.length === 0) {
+      return false;
+    }
+    for (const handler of list) {
+      try {
+        handler(message);
+      } catch (err) {
+        console.error(`[MessageHandlerRegistry] Handler error for type="${message.type}":`, err);
+      }
+    }
+    return true;
+  }
+  has(type) {
+    const list = this.handlers.get(type);
+    return !!list && list.length > 0;
+  }
+  clear() {
+    this.handlers.clear();
+  }
+}
+
+class DataStreamRouter {
+  handlers = new Map;
+  prefixKeysCache = null;
+  on(key, handler) {
+    let list = this.handlers.get(key);
+    if (!list) {
+      list = [];
+      this.handlers.set(key, list);
+    }
+    list.push(handler);
+    this.prefixKeysCache = null;
+    return () => {
+      const arr = this.handlers.get(key);
+      if (arr) {
+        const idx = arr.indexOf(handler);
+        if (idx !== -1) {
+          arr.splice(idx, 1);
+        }
+        if (arr.length === 0) {
+          this.handlers.delete(key);
+          this.prefixKeysCache = null;
+        }
+      }
+    };
+  }
+  handle(message) {
+    const streamType = message?.streamType;
+    if (!streamType)
+      return false;
+    const data = message?.data ?? message;
+    let matched = false;
+    const exactHandlers = this.handlers.get(streamType);
+    if (exactHandlers && exactHandlers.length > 0) {
+      for (const handler of exactHandlers) {
+        try {
+          handler(streamType, data, message);
+          matched = true;
+        } catch (err) {
+          console.error(`[DataStreamRouter] Handler error for streamType="${streamType}":`, err);
+        }
+      }
+    }
+    const prefixKeys = this.getPrefixKeys();
+    for (const key of prefixKeys) {
+      if (key === streamType)
+        continue;
+      if (streamType.startsWith(key)) {
+        const nextChar = streamType[key.length];
+        if (nextChar === undefined || nextChar === ":") {
+          const handlers = this.handlers.get(key);
+          if (handlers) {
+            for (const handler of handlers) {
+              try {
+                handler(streamType, data, message);
+                matched = true;
+              } catch (err) {
+                console.error(`[DataStreamRouter] Prefix handler error for key="${key}" streamType="${streamType}":`, err);
+              }
+            }
+          }
+        }
+      }
+    }
+    return matched;
+  }
+  has(key) {
+    const list = this.handlers.get(key);
+    return !!list && list.length > 0;
+  }
+  getRegisteredKeys() {
+    return Array.from(this.handlers.keys()).filter((key) => {
+      const list = this.handlers.get(key);
+      return list && list.length > 0;
+    });
+  }
+  clear() {
+    this.handlers.clear();
+    this.prefixKeysCache = null;
+  }
+  getPrefixKeys() {
+    if (this.prefixKeysCache === null) {
+      this.prefixKeysCache = Array.from(this.handlers.keys()).sort((a, b) => b.length - a.length);
+    }
+    return this.prefixKeysCache;
+  }
+}
+
+// src/session/internal/_MessageRouter.ts
+class _MessageRouter {
+  messageHandlers = new MessageHandlerRegistry;
+  dataStreamRouter = new DataStreamRouter;
+  logger;
+  constructor(logger2) {
+    this.logger = logger2;
+  }
+  handleRawText(raw) {
+    let message;
+    try {
+      message = JSON.parse(raw);
+    } catch (error) {
+      this.logger.warn({ raw }, "MentraSession received invalid JSON");
+      throw error instanceof Error ? error : new Error(String(error));
+    }
+    if (!message?.type) {
+      this.logger.debug({ message }, "MentraSession ignored message without type");
+      return false;
+    }
+    const handled = this.messageHandlers.dispatch(message);
+    if (!handled && message.type !== "pong") {
+      this.logger.debug({ type: message.type }, "MentraSession received unhandled message type");
+    }
+    return handled;
+  }
+  destroy() {
+    this.messageHandlers.clear();
+  }
+}
+
+// src/transport/Transport.ts
+var TransportState = {
+  CONNECTING: 0,
+  OPEN: 1,
+  CLOSING: 2,
+  CLOSED: 3
+};
+function isTransportOpen(transport) {
+  return transport.readyState === TransportState.OPEN;
+}
+function isTransportClosed(transport) {
+  return transport.readyState === TransportState.CLOSING || transport.readyState === TransportState.CLOSED;
+}
+
+// src/session/internal/_ConnectionManager.ts
+var PING_INTERVAL_MS = 15000;
+
+class _ConnectionManager {
+  deps;
+  connected = false;
+  parked = false;
+  explicitDisconnect = false;
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  pingInterval = null;
+  parkedTimer = null;
+  constructor(deps) {
+    this.deps = deps;
+    this.attachTransportHandlers();
+  }
+  get isConnected() {
+    return this.connected && this.deps.transport.readyState === TransportState.OPEN;
+  }
+  get isParked() {
+    return this.parked;
+  }
+  async connect() {
+    this.explicitDisconnect = false;
+    this.parked = false;
+    this.stopParkedTimer();
+    const transport = this.deps.transport;
+    if (typeof transport.connect === "function") {
+      await transport.connect();
+    } else if (this.deps.transport.readyState !== TransportState.OPEN) {
+      throw new Error("Transport is not open and does not expose connect()");
+    }
+    this.deps.onTransportReady();
+  }
+  disconnect() {
+    this.explicitDisconnect = true;
+    this.parked = false;
+    this.connected = false;
+    this.stopReconnectTimer();
+    this.stopPingInterval();
+    this.stopParkedTimer();
+    this.deps.transport.close(1000, "Client disconnect");
+  }
+  markConnected() {
+    this.connected = true;
+    this.parked = false;
+    this.reconnectAttempts = 0;
+    this.stopParkedTimer();
+    this.startPingInterval();
+  }
+  park(timeoutMs, onTimeout) {
+    this.connected = false;
+    this.parked = true;
+    this.stopReconnectTimer();
+    this.stopPingInterval();
+    this.stopParkedTimer();
+    this.parkedTimer = setTimeout(() => {
+      this.parkedTimer = null;
+      this.parked = false;
+      onTimeout();
+    }, timeoutMs);
+  }
+  destroy() {
+    this.connected = false;
+    this.parked = false;
+    this.stopReconnectTimer();
+    this.stopPingInterval();
+    this.stopParkedTimer();
+  }
+  attachTransportHandlers() {
+    this.deps.transport.onMessage((raw) => {
+      this.deps.onTextMessage(raw);
+    });
+    this.deps.transport.onBinary((data) => {
+      this.deps.onBinaryMessage(data);
+    });
+    this.deps.transport.onClose((code, reason) => {
+      const permanent = this.explicitDisconnect || !this.deps.autoReconnect;
+      this.connected = false;
+      this.stopPingInterval();
+      this.deps.onClose({ code, reason, permanent });
+      if (!permanent && !this.parked) {
+        this.scheduleReconnect();
+      }
+    });
+    this.deps.transport.onError((error) => {
+      this.deps.onError(error);
+    });
+  }
+  scheduleReconnect() {
+    if (this.reconnectAttempts >= this.deps.maxReconnectAttempts) {
+      this.deps.onClose({
+        code: 4000,
+        reason: "Maximum reconnection attempts exceeded",
+        permanent: true
+      });
+      return;
+    }
+    const delay = this.deps.reconnectDelay * Math.pow(2, this.reconnectAttempts);
+    this.reconnectAttempts += 1;
+    this.stopReconnectTimer();
+    this.deps.logger.warn({ attempt: this.reconnectAttempts, delay }, "MentraSession transport closed; scheduling reconnect");
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect().catch((error) => {
+        this.deps.onError(error instanceof Error ? error : new Error(String(error)));
+        this.scheduleReconnect();
+      });
+    }, delay);
+  }
+  startPingInterval() {
+    this.stopPingInterval();
+    this.pingInterval = setInterval(() => {
+      if (this.deps.transport.readyState !== TransportState.OPEN) {
+        return;
+      }
+      this.deps.transport.send(JSON.stringify({ type: "ping" }));
+    }, PING_INTERVAL_MS);
+  }
+  stopPingInterval() {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
+    }
+  }
+  stopReconnectTimer() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  stopParkedTimer() {
+    if (this.parkedTimer) {
+      clearTimeout(this.parkedTimer);
+      this.parkedTimer = null;
+    }
+  }
+}
+
+// src/session/internal/_SubscriptionManager.ts
+init_message_types();
+
+class _SubscriptionManager {
+  deps;
+  subscriptions = new Set;
+  syncScheduled = false;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  add(stream) {
+    if (this.subscriptions.has(stream))
+      return;
+    this.subscriptions.add(stream);
+    this.scheduleSync();
+  }
+  remove(stream) {
+    if (!this.subscriptions.has(stream))
+      return;
+    this.subscriptions.delete(stream);
+    this.scheduleSync();
+  }
+  sync() {
+    this.syncScheduled = false;
+    this.deps.sendMessage({
+      type: "subscription_update" /* SUBSCRIPTION_UPDATE */,
+      packageName: this.deps.getPackageName(),
+      sessionId: this.deps.getSessionId(),
+      subscriptions: this.snapshot(),
+      timestamp: new Date
+    });
+  }
+  snapshot() {
+    return Array.from(this.subscriptions);
+  }
+  clear() {
+    this.subscriptions.clear();
+    this.syncScheduled = false;
+  }
+  scheduleSync() {
+    if (!this.deps.isConnected() || this.syncScheduled)
+      return;
+    this.syncScheduled = true;
+    queueMicrotask(() => {
+      if (!this.syncScheduled)
+        return;
+      this.syncScheduled = false;
+      if (this.deps.isConnected()) {
+        this.sync();
+      }
+    });
+  }
+}
+
+// src/session/MentraSession.ts
+var DEFAULT_RECONNECT_ATTEMPTS = 3;
+var DEFAULT_RECONNECT_DELAY_MS = 1000;
+var DEFAULT_PARKED_TIMEOUT_MS = 30000;
+var SDK_VERSION = "3.0.0-hono.8";
+
+class MentraSession {
+  transport;
+  logger;
+  permissions;
+  transcription;
+  translation;
+  display;
+  speaker;
+  mic;
+  device;
+  phone;
+  camera;
+  led;
+  location;
+  dashboard;
+  storage;
+  time;
+  settingsData = [];
+  mentraosSettings = {};
+  appConfig = null;
+  capabilities = null;
+  runtimeSessionId;
+  hasCompletedInitialConnect = false;
+  config;
+  lifecycle = new EventEmitter2;
+  cleanupTasks = [];
+  _router;
+  _subscriptions;
+  _lifecycleManager;
+  constructor(config) {
+    this.transport = config.transport;
+    this.runtimeSessionId = config.sessionId;
+    this.config = {
+      packageName: config.packageName,
+      apiKey: config.apiKey,
+      sessionId: config.sessionId,
+      userId: config.userId,
+      serverUrl: config.serverUrl,
+      autoReconnect: config.autoReconnect ?? true,
+      maxReconnectAttempts: config.maxReconnectAttempts ?? DEFAULT_RECONNECT_ATTEMPTS,
+      reconnectDelay: config.reconnectDelay ?? DEFAULT_RECONNECT_DELAY_MS
+    };
+    this.logger = config.logger ?? createLogger({
+      logLevel: config.logLevel,
+      verbose: config.verbose
+    }).child({
+      packageName: this.config.packageName,
+      sessionId: this.config.sessionId,
+      service: "mentra-session"
+    });
+    const sdkLogger = this.logger.child({ _sdk: true });
+    this._router = new _MessageRouter(sdkLogger);
+    this._subscriptions = new _SubscriptionManager({
+      logger: sdkLogger,
+      isConnected: () => this.isConnected,
+      sendMessage: this.sendMessage.bind(this),
+      getPackageName: () => this.config.packageName,
+      getSessionId: () => this.runtimeSessionId
+    });
+    this._lifecycleManager = new _ConnectionManager({
+      transport: this.transport,
+      logger: sdkLogger,
+      autoReconnect: this.config.autoReconnect,
+      maxReconnectAttempts: this.config.maxReconnectAttempts,
+      reconnectDelay: this.config.reconnectDelay,
+      onTransportReady: () => this.sendHandshake(),
+      onTextMessage: (raw) => this.handleTextMessage(raw),
+      onBinaryMessage: (data) => this.mic.handleBinaryAudio(data),
+      onClose: (info) => this.emit("disconnected", info),
+      onError: (error) => {
+        this.emit("error", error);
+        this.logger.error(error, "MentraSession transport error");
+      }
+    });
+    this.permissions = new PermissionsManager({ logger: sdkLogger });
+    const deps = {
+      router: this._router.dataStreamRouter,
+      messageHandlers: this._router.messageHandlers,
+      addSubscription: (stream) => this._subscriptions.add(stream),
+      removeSubscription: (stream) => this._subscriptions.remove(stream),
+      sendMessage: this.sendMessage.bind(this),
+      sendBinary: this.sendBinary.bind(this),
+      logger: sdkLogger,
+      getPackageName: () => this.config.packageName,
+      getSessionId: () => this.runtimeSessionId,
+      getServerUrl: () => this.getServerUrl(),
+      permissions: this.permissions
+    };
+    this.transcription = new TranscriptionManager(deps);
+    this.translation = new TranslationManager(deps);
+    this.display = new DisplayManager(deps);
+    this.speaker = new SpeakerManager(deps);
+    this.mic = new MicManager(deps);
+    this.device = new DeviceManager(deps);
+    this.phone = new PhoneManager(deps);
+    this.camera = new CameraManager(deps);
+    this.led = new LedManager(deps);
+    this.location = new LocationManager(deps);
+    this.dashboard = new DashboardManager(deps);
+    this.storage = new StorageManager(deps, {
+      userId: this.config.userId ?? "unknown-user",
+      apiKey: this.config.apiKey
+    });
+    this.time = new TimeUtils("UTC");
+    this.registerCoreHandlers();
+  }
+  get packageName() {
+    return this.config.packageName;
+  }
+  get sessionId() {
+    return this.runtimeSessionId;
+  }
+  get userId() {
+    return this.config.userId;
+  }
+  get isConnected() {
+    return this._lifecycleManager.isConnected;
+  }
+  get isParked() {
+    return this._lifecycleManager.isParked;
+  }
+  async connect() {
+    await this._lifecycleManager.connect();
+  }
+  async disconnect() {
+    this._lifecycleManager.disconnect();
+    await this.destroyManagers();
+    this._router.destroy();
+    this._subscriptions.clear();
+  }
+  async releaseOwnership(reason) {
+    this.sendMessage({
+      type: "ownership_release" /* OWNERSHIP_RELEASE */,
+      packageName: this.config.packageName,
+      sessionId: this.runtimeSessionId,
+      reason,
+      timestamp: new Date
+    });
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  updateSettingsForTesting(newSettings) {
+    this.settingsData = newSettings;
+    this.permissions.updateFromSettings(newSettings);
+    this.emit("settings", this.settingsData);
+  }
+  onConnected(handler) {
+    this.lifecycle.on("connected", handler);
+    return () => this.lifecycle.off("connected", handler);
+  }
+  onDisconnected(handler) {
+    this.lifecycle.on("disconnected", handler);
+    return () => this.lifecycle.off("disconnected", handler);
+  }
+  onError(handler) {
+    this.lifecycle.on("error", handler);
+    return () => this.lifecycle.off("error", handler);
+  }
+  onStopped(handler) {
+    this.lifecycle.on("stopped", handler);
+    return () => this.lifecycle.off("stopped", handler);
+  }
+  onSettings(handler) {
+    this.lifecycle.on("settings", handler);
+    return () => this.lifecycle.off("settings", handler);
+  }
+  onReconnected(handler) {
+    this.lifecycle.on("reconnected", handler);
+    return () => this.lifecycle.off("reconnected", handler);
+  }
+  sendMessage(message) {
+    this.transport.send(JSON.stringify(message));
+  }
+  sendBinary(data) {
+    this.transport.sendBinary(data);
+  }
+  getServerUrl() {
+    return this.config.serverUrl ?? null;
+  }
+  registerCoreHandlers() {
+    this.cleanupTasks.push(this._router.messageHandlers.register("data_stream" /* DATA_STREAM */, (message) => {
+      this._router.dataStreamRouter.handle(message);
+    }));
+    this.cleanupTasks.push(this._router.messageHandlers.register("tpa_connection_ack" /* CONNECTION_ACK */, (message) => {
+      this.handleConnectionAck(message, false);
+    }));
+    this.cleanupTasks.push(this._router.messageHandlers.register("reconnect_ack" /* RECONNECT_ACK */, (message) => {
+      this.handleConnectionAck(message, true);
+    }));
+    this.cleanupTasks.push(this._router.messageHandlers.register("settings_update" /* SETTINGS_UPDATE */, (message) => {
+      this.handleSettingsUpdate(message);
+    }));
+    this.cleanupTasks.push(this._router.messageHandlers.register("capabilities_update" /* CAPABILITIES_UPDATE */, (message) => {
+      this.capabilities = message.capabilities ?? null;
+      this.device.handleCapabilitiesUpdate(message);
+    }));
+    this.cleanupTasks.push(this._router.messageHandlers.register("device_state_update" /* DEVICE_STATE_UPDATE */, (message) => {
+      this.device.handleDeviceStateUpdate(message);
+    }));
+    this.cleanupTasks.push(this._router.messageHandlers.register("app_stopped" /* APP_STOPPED */, (message) => {
+      const reason = message.reason ?? "unknown";
+      this.logger.info({ reason }, "MentraSession received app_stopped");
+      this._lifecycleManager.disconnect();
+      this.emit("stopped", reason);
+    }));
+    this.cleanupTasks.push(this._router.messageHandlers.register("tpa_connection_error" /* CONNECTION_ERROR */, (message) => {
+      this.emit("error", new Error(message.message ?? "MentraSession connection error"));
+    }));
+    this.cleanupTasks.push(this._router.messageHandlers.register("reconnect_rejected" /* RECONNECT_REJECTED */, (message) => {
+      if (message.code === "NOT_RUNNING" || message.code === "BOOT_TIMEOUT") {
+        this.transport.close(1000, message.message ?? "Reconnect rejected");
+        this.emit("disconnected", {
+          code: 4002,
+          reason: message.message ?? "Reconnect rejected",
+          permanent: true
+        });
+        return;
+      }
+      this.sendConnectionInit();
+    }));
+    this.cleanupTasks.push(this._router.messageHandlers.register("reconnect_deferred" /* RECONNECT_DEFERRED */, (message) => {
+      const timeoutMs = typeof message.timeoutMs === "number" ? message.timeoutMs : DEFAULT_PARKED_TIMEOUT_MS;
+      this._lifecycleManager.park(timeoutMs, () => {
+        this.transport.close(1000, "Parked timeout");
+        this.emit("disconnected", {
+          code: 4001,
+          reason: "Parked reconnect timeout exceeded",
+          permanent: true
+        });
+      });
+    }));
+    this.cleanupTasks.push(this._router.messageHandlers.register("augmentos_settings_update", (message) => {
+      this.applyMentraosSettings(message.settings ?? {});
+    }));
+  }
+  handleTextMessage(raw) {
+    try {
+      this._router.handleRawText(raw);
+    } catch (error) {
+      this.emit("error", error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  handleConnectionAck(message, isReconnect) {
+    this.settingsData = message.settings ?? [];
+    this.appConfig = message.config ?? null;
+    this.capabilities = message.capabilities ?? null;
+    this.runtimeSessionId = message.sessionId ?? this.runtimeSessionId;
+    this.permissions.updateFromSettings(message.mentraosSettings ?? message.settings ?? {});
+    this.applyMentraosSettings(message.mentraosSettings ?? {});
+    if (message.capabilities) {
+      this.device.handleCapabilitiesUpdate({
+        type: "capabilities_update" /* CAPABILITIES_UPDATE */,
+        capabilities: message.capabilities,
+        modelName: message.capabilities.modelName ?? null
+      });
+    }
+    this._lifecycleManager.markConnected();
+    this._subscriptions.sync();
+    const wasReconnect = isReconnect || this.hasCompletedInitialConnect;
+    this.hasCompletedInitialConnect = true;
+    const transcriptionConfig = this.transcription.config;
+    if (transcriptionConfig) {
+      this.transcription.configure(transcriptionConfig);
+    }
+    this.emit("connected", this.settingsData);
+    this.emit("settings", this.settingsData);
+    if (wasReconnect) {
+      this.emit("reconnected");
+    }
+  }
+  handleSettingsUpdate(message) {
+    this.settingsData = message.settings ?? [];
+    this.permissions.updateFromSettings(message.settings ?? {});
+    this.emit("settings", this.settingsData);
+  }
+  applyMentraosSettings(settings) {
+    this.mentraosSettings = settings;
+    const timezone = settings?.timezone;
+    if (typeof timezone === "string" && timezone.length > 0) {
+      try {
+        this.time.setTimezone(timezone);
+      } catch (error) {
+        this.logger.warn({ timezone, error }, "MentraSession received invalid timezone");
+      }
+    }
+  }
+  sendHandshake() {
+    if (this.hasCompletedInitialConnect) {
+      this.sendMessage({
+        type: "reconnect" /* RECONNECT */,
+        sessionId: this.runtimeSessionId,
+        sdkVersion: SDK_VERSION,
+        timestamp: new Date
+      });
+      return;
+    }
+    this.sendConnectionInit();
+  }
+  sendConnectionInit() {
+    this.sendMessage({
+      type: "tpa_connection_init" /* CONNECTION_INIT */,
+      packageName: this.config.packageName,
+      apiKey: this.config.apiKey,
+      sdkVersion: SDK_VERSION,
+      timestamp: new Date
+    });
+  }
+  emit(event, ...args) {
+    this.lifecycle.emit(event, ...args);
+  }
+  async destroyManagers() {
+    this._lifecycleManager.destroy();
+    await this.storage.destroy();
+    this.camera.destroy();
+    this.dashboard.destroy();
+    this.device.destroy();
+    this.led.destroy();
+    this.location.destroy();
+    this.mic.stop();
+    this.phone.destroy();
+    this.speaker.destroy();
+    this.transcription.stop();
+    this.translation.stop();
+    for (const cleanup of this.cleanupTasks.splice(0)) {
+      await cleanup();
+    }
+  }
+}
+// src/utils/error-utils.ts
+function toErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error === null) {
+    return "null";
+  }
+  if (error === undefined) {
+    return "undefined";
+  }
+  if (typeof error === "object") {
+    const obj = error;
+    if (typeof obj.message === "string") {
+      return obj.message;
+    }
+    try {
+      return JSON.stringify(error);
+    } catch {
+      return String(error);
+    }
+  }
+  return String(error);
+}
+function toError(error, fallbackMessage) {
+  if (error instanceof Error) {
+    return error;
+  }
+  const message = toErrorMessage(error);
+  return new Error(message || fallbackMessage || "Unknown error");
+}
+var _deprecationWarnings = new Set;
+function warnOnce(key, message, logger2) {
+  if (_deprecationWarnings.has(key))
+    return;
+  _deprecationWarnings.add(key);
+  const formatted = `⚠️  DEPRECATION: ${message}`;
+  if (logger2) {
+    logger2.warn(formatted);
+  } else {
+    console.warn(formatted);
+  }
+}
+export {
+  warnOnce,
+  toErrorMessage,
+  toError,
+  isTransportOpen,
+  isTransportClosed,
+  TransportState,
+  TimeUtils,
+  Observable,
+  MessageHandlerRegistry,
+  MentraSession,
+  DataStreamRouter
+};
+
+//# debugId=8AE847F1727E65C164756E2164756E21