@riddix/hamh 2.1.0-alpha.839 → 2.1.0-alpha.840

package/dist/backend/cli.js

@@ -1767,8 +1767,8 @@ var init_Cancelable = __esm({
         };
         return result;
       }
-      static set logger(logger248) {
-        this.#logger = logger248;
+      static set logger(logger250) {
+        this.#logger = logger250;
       }
       static get logger() {
         return this.#logger;
@@ -3475,13 +3475,13 @@ var init_Logger = __esm({
        *
        * @deprecated use {@link destinations}
        */
-      static addLogger(identifier, logger248, options) {
+      static addLogger(identifier, logger250, options) {
         if (identifier in this.destinations) {
           throw new ImplementationError(`Logger "${identifier}" already exists`);
         }
         const dest = LogDestination({ name: identifier });
         const legacy = adaptDestinationToLegacy(dest);
-        legacy.log = logger248;
+        legacy.log = logger250;
         if (options?.defaultLogLevel !== void 0) {
           legacy.defaultLogLevel = options.defaultLogLevel;
         }
@@ -5687,8 +5687,8 @@ var init_Construction = __esm({
           }
         }
         #unhandledError(...args) {
-          const logger248 = Logger.get(this.#subject.constructor.name);
-          logger248.error(...args);
+          const logger250 = Logger.get(this.#subject.constructor.name);
+          logger250.error(...args);
         }
         #createErrorHandler(name) {
           return (e) => {
@@ -64070,8 +64070,8 @@ var init_NodeSession = __esm({
         return session?.type === SessionType.Unicast;
       }
       NodeSession2.is = is;
-      function logNew(logger248, operation, session, messenger, fabric, peerNodeId) {
-        logger248.info(
+      function logNew(logger250, operation, session, messenger, fabric, peerNodeId) {
+        logger250.info(
           session.via,
           `${operation} session with`,
           Diagnostic.strong(PeerAddress({ fabricIndex: fabric.fabricIndex, nodeId: peerNodeId }).toString()),
@@ -117714,11 +117714,11 @@ var init_Api = __esm({
       }
       Api2.resourceFor = resourceFor;
       function log(level, facility, id, ...message) {
-        let logger248 = loggers.get(facility);
-        if (!logger248) {
-          loggers.set(facility, logger248 = Logger.get(facility));
+        let logger250 = loggers.get(facility);
+        if (!logger250) {
+          loggers.set(facility, logger250 = Logger.get(facility));
         }
-        logger248[level](Diagnostic.via(id || "(anon)"), message);
+        logger250[level](Diagnostic.via(id || "(anon)"), message);
       }
       Api2.log = log;
       function logRequest(facility, id, method, target) {
@@ -132631,10 +132631,10 @@ var init_home_assistant_actions = __esm({
       circuitBreakerResetMs: 3e4
     };
     HomeAssistantActions = class extends Service {
-      constructor(logger248, client, config11) {
+      constructor(logger250, client, config11) {
         super("HomeAssistantActions");
         this.client = client;
-        this.log = logger248.get(this);
+        this.log = logger250.get(this);
         this.config = { ...defaultConfig, ...config11 };
         this.circuitBreaker = new CircuitBreaker(
           this.config.circuitBreakerThreshold,
@@ -132980,10 +132980,10 @@ var DiagnosticService = class {
 };
 
 // src/api/access-log.ts
-function accessLogger(logger248) {
+function accessLogger(logger250) {
   return (req, res, next) => {
     res.on("finish", () => {
-      logger248.debug(
+      logger250.debug(
         `${req.method} ${decodeURI(req.originalUrl)} ${res.statusCode} ${res.statusMessage} from ${req.socket.remoteAddress}`
       );
     });
@@ -137530,7 +137530,7 @@ var WebSocketApi = class {
 
 // src/api/web-api.ts
 var WebApi = class extends Service {
-  constructor(logger248, bridgeService, haClient, haRegistry, bridgeStorage, mappingStorage, identityStorage, lockCredentialStorage, settingsStorage, backupService, props) {
+  constructor(logger250, bridgeService, haClient, haRegistry, bridgeStorage, mappingStorage, identityStorage, lockCredentialStorage, settingsStorage, backupService, props) {
     super("WebApi");
     this.bridgeService = bridgeService;
     this.haClient = haClient;
@@ -137542,8 +137542,8 @@ var WebApi = class extends Service {
     this.settingsStorage = settingsStorage;
     this.backupService = backupService;
     this.props = props;
-    this.logger = logger248;
-    this.log = logger248.get(this);
+    this.logger = logger250;
+    this.log = logger250.get(this);
     this.accessLogger = accessLogger(this.log.createChild("Access Log"));
     this.startTime = Date.now();
     this.wsApi = new WebSocketApi(
@@ -138734,10 +138734,10 @@ function isTransientConnectError(reason) {
   return msg.includes("socket hang up") || msg.includes("tls") || msg.includes("TLS");
 }
 var HomeAssistantClient = class extends Service {
-  constructor(logger248, options) {
+  constructor(logger250, options) {
     super("HomeAssistantClient");
     this.options = options;
-    this.log = logger248.get(this);
+    this.log = logger250.get(this);
   }
   options;
   static Options = /* @__PURE__ */ Symbol.for("HomeAssistantClientProps");
@@ -157335,11 +157335,11 @@ var AUTO_FORCE_SYNC_INTERVAL_MS = 9e4;
 var SHUTDOWN_SESSION_CLOSE_TIMEOUT_MS = 2500;
 var MDNS_ADDRESS_CHECK_INTERVAL_MS = 6e4;
 var Bridge = class {
-  constructor(env, logger248, dataProvider, endpointManager, serverOptions) {
+  constructor(env, logger250, dataProvider, endpointManager, serverOptions) {
     this.dataProvider = dataProvider;
     this.endpointManager = endpointManager;
     this.serverOptions = serverOptions;
-    this.log = logger248.get(`Bridge / ${dataProvider.id}`);
+    this.log = logger250.get(`Bridge / ${dataProvider.id}`);
     this.server = new BridgeServerNode(
       env,
       this.dataProvider,
@@ -172957,18 +172957,32 @@ var CameraAvStreamServer = class extends Base4 {
 })(CameraAvStreamServer || (CameraAvStreamServer = {}));
 
 // src/plugins/builtin/camera/webrtc-provider-server.ts
+init_esm();
 init_esm7();
 init_esm3();
+var logger244 = Logger.get("CameraWebRtc");
 var CameraWebRtcProviderServer = class extends WebRtcTransportProviderServer {
   solicitOffer(request) {
     const id = this.state.nextSessionId++;
     this.trackSession(id, request.streamUsage, request.originatingEndpointId);
-    void this.state.bridge.startSession(id, this.state.entityId).catch(() => {
-    });
+    logger244.info(
+      `solicitOffer session=${id} (${this.state.entityId}), deferred offer`
+    );
+    void this.state.bridge.startSession(id, this.state.entityId, {
+      iceServers: request.iceServers,
+      iceTransportPolicy: request.iceTransportPolicy
+    }).catch(
+      (err) => logger244.info(
+        `solicitOffer startSession failed for ${this.state.entityId}: ${errText(err)}`
+      )
+    );
     return { webRtcSessionId: id, deferredOffer: true };
   }
   async provideOffer(request) {
     const id = request.webRtcSessionId ?? this.state.nextSessionId++;
+    logger244.info(
+      `provideOffer entry: entityId=${this.state.entityId} session=${id} (sdp ${request.sdp.length} chars)`
+    );
     if (request.webRtcSessionId == null) {
       this.trackSession(
         id,
@@ -172976,30 +172990,62 @@ var CameraWebRtcProviderServer = class extends WebRtcTransportProviderServer {
         request.originatingEndpointId ?? EndpointNumber(0)
       );
     }
-    const answerSdp = await this.state.bridge.acceptControllerOffer(
-      id,
-      this.state.entityId,
-      request.sdp
+    let answerSdp;
+    try {
+      answerSdp = await this.state.bridge.acceptControllerOffer(
+        id,
+        this.state.entityId,
+        request.sdp,
+        {
+          iceServers: request.iceServers,
+          iceTransportPolicy: request.iceTransportPolicy
+        }
+      );
+    } catch (err) {
+      const message = errText(err);
+      logger244.info(
+        `provideOffer failed for ${this.state.entityId} session=${id}: ${message}`
+      );
+      this.state.currentSessions = this.state.currentSessions.filter(
+        (s) => s.id !== id
+      );
+      throw new StatusResponseError(
+        `WebRTC offer failed: ${message}`,
+        StatusCode.Failure
+      );
+    }
+    logger244.info(
+      `provideOffer answer computed for ${this.state.entityId} session=${id} (${answerSdp.length} chars); awaiting requestor delivery path`
     );
     void answerSdp;
     return { webRtcSessionId: id };
   }
   provideAnswer(request) {
+    logger244.info(
+      `provideAnswer session=${request.webRtcSessionId} (sdp ${request.sdp.length} chars, ${this.state.entityId})`
+    );
     return this.state.bridge.acceptControllerAnswer(
       request.webRtcSessionId,
       request.sdp
     );
   }
   async provideIceCandidates(request) {
+    logger244.info(
+      `provideIceCandidates session=${request.webRtcSessionId}: ${request.iceCandidates.length} candidate(s) (${this.state.entityId})`
+    );
     for (const c of request.iceCandidates) {
       await this.state.bridge.addControllerIceCandidate(
         request.webRtcSessionId,
         c.candidate,
-        c.sdpMid
+        c.sdpMid,
+        c.sdpmLineIndex
       );
     }
   }
   async endSession(request) {
+    logger244.info(
+      `endSession session=${request.webRtcSessionId} (${this.state.entityId})`
+    );
     await this.state.bridge.endSession(request.webRtcSessionId);
     this.state.currentSessions = this.state.currentSessions.filter(
       (s) => s.id !== request.webRtcSessionId
@@ -173020,6 +173066,9 @@ var CameraWebRtcProviderServer = class extends WebRtcTransportProviderServer {
     ];
   }
 };
+function errText(err) {
+  return err instanceof Error ? err.message : String(err);
+}
 ((CameraWebRtcProviderServer2) => {
   class State extends WebRtcTransportProviderServer.State {
     bridge;
@@ -173106,108 +173155,180 @@ function createCameraEndpointType(bridge, entityId, sensor = defaultSensorParams
 }
 
 // src/plugins/builtin/camera/webrtc-bridge.ts
+init_esm();
 import {
   createConnection as createConnection3,
   createLongLivedTokenAuth as createLongLivedTokenAuth2
 } from "home-assistant-js-websocket";
 import { RTCPeerConnection } from "werift";
+var logger245 = Logger.get("CameraWebRtc");
+var DEFAULT_HA_WEBRTC_TIMEOUT_MS = 15e3;
+var haWebRtcTimeoutMs = DEFAULT_HA_WEBRTC_TIMEOUT_MS;
 var WebRtcBridge = class {
-  constructor(config11) {
+  constructor(config11, deps = {}) {
     this.config = config11;
+    this.deps = deps;
   }
   config;
+  deps;
   connection;
   sessions = /* @__PURE__ */ new Map();
   async ha() {
     if (this.connection) return this.connection;
-    const auth = createLongLivedTokenAuth2(
-      this.config.haUrl,
-      this.config.haToken
-    );
-    this.connection = await createConnection3({ auth });
+    if (this.deps.connect) {
+      this.connection = await this.deps.connect(this.config);
+    } else {
+      const auth = createLongLivedTokenAuth2(
+        this.config.haUrl,
+        this.config.haToken
+      );
+      this.connection = await createConnection3({ auth });
+    }
     return this.connection;
   }
   // We offer to the controller; it answers. Pulls HA media first, then forwards.
-  async startSession(matterSessionId, entityId) {
+  async startSession(matterSessionId, entityId, ice) {
     const haPeer = new RTCPeerConnection();
-    const controllerPeer = new RTCPeerConnection();
-    haPeer.onTrack.subscribe((track) => {
-      const transceiver = controllerPeer.addTransceiver(
-        track.kind,
-        { direction: "sendonly" }
+    const controllerPeer = new RTCPeerConnection(
+      this.controllerConfig(entityId, ice)
+    );
+    this.wireStateLogging(haPeer, "haPeer", entityId);
+    this.wireStateLogging(controllerPeer, "controllerPeer", entityId);
+    const senders = /* @__PURE__ */ new Map();
+    senders.set(
+      "video",
+      controllerPeer.addTransceiver("video", { direction: "sendonly" })
+    );
+    this.forwardHaTracks(haPeer, senders, entityId);
+    this.sessions.set(matterSessionId, { entityId, haPeer, controllerPeer });
+    try {
+      haPeer.addTransceiver("video", { direction: "recvonly" });
+      haPeer.addTransceiver("audio", { direction: "recvonly" });
+      const haOffer = await haPeer.createOffer();
+      await haPeer.setLocalDescription(haOffer);
+      const haOfferSdp = this.localSdp(haPeer);
+      logger245.info(`HA offer sent for ${entityId} (${haOfferSdp.length} chars)`);
+      const { answer, sessionId, unsubscribe } = await this.requestHaWebRtc(
+        entityId,
+        haOfferSdp,
+        haPeer
       );
-      track.onReceiveRtp.subscribe((rtp) => transceiver.sender.sendRtp(rtp));
-    });
-    haPeer.addTransceiver("video", { direction: "recvonly" });
-    haPeer.addTransceiver("audio", { direction: "recvonly" });
-    const haOffer = await haPeer.createOffer();
-    await haPeer.setLocalDescription(haOffer);
-    const haAnswer = await this.requestHaWebRtc(entityId, haOffer.sdp);
-    await haPeer.setRemoteDescription({ type: "answer", sdp: haAnswer });
-    const controllerOffer = await controllerPeer.createOffer();
-    await controllerPeer.setLocalDescription(controllerOffer);
-    const iceCandidates = [];
-    controllerPeer.onIceCandidate.subscribe((c) => {
-      if (c?.candidate)
-        iceCandidates.push({
-          candidate: c.candidate,
-          sdpMid: c.sdpMid ?? null
-        });
-    });
-    this.sessions.set(matterSessionId, {
-      entityId,
-      haPeer,
-      controllerPeer
-    });
-    return { sdp: controllerOffer.sdp, iceCandidates };
+      const session = this.sessions.get(matterSessionId);
+      if (session) {
+        session.haSessionId = sessionId;
+        session.haUnsubscribe = unsubscribe;
+      }
+      await haPeer.setRemoteDescription({ type: "answer", sdp: answer });
+      const iceCandidates = [];
+      controllerPeer.onIceCandidate.subscribe((c) => {
+        if (c?.candidate)
+          iceCandidates.push({
+            candidate: c.candidate,
+            sdpMid: c.sdpMid ?? null
+          });
+      });
+      const controllerOffer = await controllerPeer.createOffer();
+      await controllerPeer.setLocalDescription(controllerOffer);
+      const sdp = this.localSdp(controllerPeer);
+      logger245.info(
+        `controller offer created for ${entityId} (${sdp.length} chars)`
+      );
+      return { sdp, iceCandidates };
+    } catch (err) {
+      logger245.info(`startSession failed for ${entityId}: ${errText2(err)}`);
+      await this.endSession(matterSessionId);
+      throw err;
+    }
   }
   // ProvideOffer flow: controller sent its offer. Pull HA media, answer it.
   // Returning the answer to the controller is the unverified Requestor path.
-  async acceptControllerOffer(matterSessionId, entityId, controllerOfferSdp) {
+  async acceptControllerOffer(matterSessionId, entityId, controllerOfferSdp, ice) {
     const haPeer = new RTCPeerConnection();
-    const controllerPeer = new RTCPeerConnection();
-    haPeer.onTrack.subscribe((track) => {
-      const transceiver = controllerPeer.addTransceiver(track.kind, {
-        direction: "sendonly"
-      });
-      track.onReceiveRtp.subscribe((rtp) => transceiver.sender.sendRtp(rtp));
-    });
+    const controllerPeer = new RTCPeerConnection(
+      this.controllerConfig(entityId, ice)
+    );
+    this.wireStateLogging(haPeer, "haPeer", entityId);
+    this.wireStateLogging(controllerPeer, "controllerPeer", entityId);
+    const senders = /* @__PURE__ */ new Map();
+    for (const kind of offerKinds(controllerOfferSdp)) {
+      senders.set(
+        kind,
+        controllerPeer.addTransceiver(kind, { direction: "sendonly" })
+      );
+    }
+    this.forwardHaTracks(haPeer, senders, entityId);
     this.sessions.set(matterSessionId, { entityId, haPeer, controllerPeer });
-    haPeer.addTransceiver("video", { direction: "recvonly" });
-    haPeer.addTransceiver("audio", { direction: "recvonly" });
-    const haOffer = await haPeer.createOffer();
-    await haPeer.setLocalDescription(haOffer);
-    const haAnswer = await this.requestHaWebRtc(entityId, haOffer.sdp);
-    await haPeer.setRemoteDescription({ type: "answer", sdp: haAnswer });
-    await controllerPeer.setRemoteDescription({
-      type: "offer",
-      sdp: controllerOfferSdp
-    });
-    const answer = await controllerPeer.createAnswer();
-    await controllerPeer.setLocalDescription(answer);
-    return answer.sdp;
+    try {
+      haPeer.addTransceiver("video", { direction: "recvonly" });
+      haPeer.addTransceiver("audio", { direction: "recvonly" });
+      const haOffer = await haPeer.createOffer();
+      await haPeer.setLocalDescription(haOffer);
+      const haOfferSdp = this.localSdp(haPeer);
+      logger245.info(`HA offer sent for ${entityId} (${haOfferSdp.length} chars)`);
+      const { answer, sessionId, unsubscribe } = await this.requestHaWebRtc(
+        entityId,
+        haOfferSdp,
+        haPeer
+      );
+      const session = this.sessions.get(matterSessionId);
+      if (session) {
+        session.haSessionId = sessionId;
+        session.haUnsubscribe = unsubscribe;
+      }
+      await haPeer.setRemoteDescription({ type: "answer", sdp: answer });
+      await controllerPeer.setRemoteDescription({
+        type: "offer",
+        sdp: controllerOfferSdp
+      });
+      const controllerAnswer = await controllerPeer.createAnswer();
+      await controllerPeer.setLocalDescription(controllerAnswer);
+      const answerSdp = this.localSdp(controllerPeer);
+      logger245.info(
+        `controller answer created for ${entityId} (${answerSdp.length} chars)`
+      );
+      return answerSdp;
+    } catch (err) {
+      logger245.info(
+        `acceptControllerOffer failed for ${entityId}: ${errText2(err)}`
+      );
+      await this.endSession(matterSessionId);
+      throw err;
+    }
   }
   /** Apply the Matter controller's SDP answer to the controller peer. */
   async acceptControllerAnswer(matterSessionId, sdp) {
     const session = this.sessions.get(matterSessionId);
     if (!session) return;
+    logger245.debug(`controller answer applied for ${session.entityId}`);
     await session.controllerPeer.setRemoteDescription({ type: "answer", sdp });
   }
   /** Add a remote ICE candidate from the Matter controller. */
-  async addControllerIceCandidate(matterSessionId, candidate, sdpMid) {
+  async addControllerIceCandidate(matterSessionId, candidate, sdpMid, sdpMLineIndex) {
     const session = this.sessions.get(matterSessionId);
     if (!session) return;
+    logger245.debug(
+      `controller ICE candidate for ${session.entityId}: ${candidate}`
+    );
     await session.controllerPeer.addIceCandidate({
       candidate,
-      sdpMid: sdpMid ?? void 0
+      sdpMid: sdpMid ?? void 0,
+      sdpMLineIndex: sdpMLineIndex ?? void 0
     });
   }
   async endSession(matterSessionId) {
     const session = this.sessions.get(matterSessionId);
     if (!session) return;
+    logger245.info(`ending session ${matterSessionId} (${session.entityId})`);
     this.sessions.delete(matterSessionId);
-    await session.haPeer.close();
-    await session.controllerPeer.close();
+    if (session.haUnsubscribe) {
+      await Promise.resolve(session.haUnsubscribe()).catch(
+        (err) => logger245.debug(`HA unsubscribe failed: ${errText2(err)}`)
+      );
+    }
+    await session.haPeer.close().catch(() => {
+    });
+    await session.controllerPeer.close().catch(() => {
+    });
     if (session.haSessionId) {
       try {
         const conn = await this.ha();
@@ -173224,10 +173345,19 @@ var WebRtcBridge = class {
   // Grab a still JPEG via HA's camera proxy (for CaptureSnapshot).
   async snapshot(entityId) {
     const url2 = `${this.config.haUrl}/api/camera_proxy/${entityId}`;
-    const res = await fetch(url2, {
-      headers: { Authorization: `Bearer ${this.config.haToken}` }
-    });
+    let res;
+    try {
+      res = await fetch(url2, {
+        headers: { Authorization: `Bearer ${this.config.haToken}` }
+      });
+    } catch (err) {
+      logger245.info(`snapshot fetch failed for ${entityId}: ${errText2(err)}`);
+      throw err;
+    }
     if (!res.ok) {
+      logger245.info(
+        `snapshot fetch failed for ${entityId}: camera_proxy ${res.status}`
+      );
       throw new Error(`HA camera_proxy ${entityId}: ${res.status}`);
     }
     return new Uint8Array(await res.arrayBuffer());
@@ -173239,29 +173369,157 @@ var WebRtcBridge = class {
     this.connection?.close();
     this.connection = void 0;
   }
-  // Offer to HA's WebRTC, resolve on the first answer event off the same sub.
-  async requestHaWebRtc(entityId, offerSdp) {
+  // Forward every track HA sends into the matching pre-added controller sender.
+  forwardHaTracks(haPeer, senders, entityId) {
+    haPeer.onTrack.subscribe((track) => {
+      logger245.info(`onTrack ${track.kind} from HA (${entityId})`);
+      const transceiver = senders.get(track.kind);
+      if (!transceiver) {
+        logger245.info(
+          `no controller transceiver for ${track.kind} (${entityId})`
+        );
+        return;
+      }
+      let firstLogged = false;
+      track.onReceiveRtp.subscribe((rtp) => {
+        if (!firstLogged) {
+          firstLogged = true;
+          logger245.info(`first RTP forwarded for ${track.kind} (${entityId})`);
+        }
+        transceiver.sender.sendRtp(rtp);
+      });
+    });
+  }
+  // Log connection/ice state transitions (these events fire on change only).
+  wireStateLogging(peer, label, entityId) {
+    peer.connectionStateChange.subscribe(
+      (s) => logger245.info(`${label} connectionState=${s} (${entityId})`)
+    );
+    peer.iceConnectionStateChange.subscribe(
+      (s) => logger245.info(`${label} iceConnectionState=${s} (${entityId})`)
+    );
+  }
+  // Map the Matter ICE struct onto werift's config. Only the controller peer
+  // uses controller-supplied servers; the HA peer keeps werift defaults.
+  controllerConfig(entityId, ice) {
+    const iceServers = (ice?.iceServers ?? []).flatMap(
+      (s) => (s.urLs ?? []).map((url2) => ({
+        urls: url2,
+        username: s.username,
+        credential: s.credential
+      }))
+    );
+    if (iceServers.length === 0) {
+      logger245.info(`controller peer using default ICE servers (${entityId})`);
+      return void 0;
+    }
+    const policy = ice?.iceTransportPolicy === "relay" || ice?.iceTransportPolicy === "all" ? ice.iceTransportPolicy : void 0;
+    logger245.info(
+      `controller peer using ${iceServers.length} controller ICE server(s)${policy ? ` policy=${policy}` : ""} (${entityId})`
+    );
+    return policy ? { iceServers, iceTransportPolicy: policy } : { iceServers };
+  }
+  localSdp(peer) {
+    const local = peer.localDescription;
+    if (!local) throw new Error("no local description");
+    return local.sdp;
+  }
+  // Feed an HA trickle-ICE candidate into the HA peer.
+  feedHaCandidate(entityId, haPeer, candidate) {
+    const value = candidate?.candidate;
+    if (!value) return;
+    logger245.debug(`HA ICE candidate for ${entityId}: ${value}`);
+    void haPeer.addIceCandidate({
+      candidate: value,
+      sdpMid: candidate?.sdpMid ?? void 0,
+      sdpMLineIndex: candidate?.sdpMLineIndex ?? void 0
+    }).catch(
+      (e) => logger245.debug(
+        `HA addIceCandidate failed for ${entityId}: ${errText2(e)}`
+      )
+    );
+  }
+  // Offer to HA's WebRTC and resolve on the first answer. Rejects on an error
+  // reply or after a timeout; keeps the subscription open past the answer so HA
+  // trickle candidates keep flowing into the HA peer until the session ends.
+  async requestHaWebRtc(entityId, offerSdp, haPeer) {
     const conn = await this.ha();
-    return new Promise((resolve11, reject) => {
+    let unsubscribe = () => {
+    };
+    let sessionId;
+    const answer = await new Promise((resolve11, reject) => {
       let settled = false;
+      let rejected = false;
+      let timer;
+      const settle = (fn) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        fn();
+      };
+      const fail = (err) => settle(() => {
+        rejected = true;
+        unsubscribe();
+        reject(err);
+      });
+      timer = setTimeout(() => {
+        logger245.info(
+          `HA WebRTC timed out after ${haWebRtcTimeoutMs}ms for ${entityId}`
+        );
+        fail(
+          new Error(`HA WebRTC request timed out after ${haWebRtcTimeoutMs}ms`)
+        );
+      }, haWebRtcTimeoutMs);
       conn.subscribeMessage(
         (msg) => {
-          if (msg.type === "answer" && msg.answer && !settled) {
-            settled = true;
-            const session = [...this.sessions.values()].find(
-              (s) => s.entityId === entityId
-            );
-            if (session && msg.session_id) {
-              session.haSessionId = msg.session_id;
+          switch (msg.type) {
+            case "session":
+              if (msg.session_id) sessionId = msg.session_id;
+              break;
+            case "answer":
+              if (msg.answer) {
+                if (msg.session_id) sessionId = msg.session_id;
+                const ans = msg.answer;
+                settle(() => {
+                  logger245.info(
+                    `HA answer received for ${entityId} (${ans.length} chars)`
+                  );
+                  resolve11(ans);
+                });
+              }
+              break;
+            case "error": {
+              const detail = msg.message ?? msg.code ?? "unknown error";
+              logger245.info(`HA WebRTC error for ${entityId}: ${detail}`);
+              fail(new Error(`HA WebRTC error: ${detail}`));
+              break;
             }
-            resolve11(msg.answer);
+            case "candidate":
+              this.feedHaCandidate(entityId, haPeer, msg.candidate);
+              break;
           }
         },
         { type: "camera/webrtc/offer", entity_id: entityId, offer: offerSdp }
-      ).catch(reject);
+      ).then((unsub) => {
+        unsubscribe = unsub;
+        if (rejected) unsub();
+      }).catch((err) => {
+        fail(err instanceof Error ? err : new Error(String(err)));
+      });
     });
+    return { answer, sessionId, unsubscribe };
   }
 };
+function offerKinds(sdp) {
+  const kinds = [];
+  for (const m of sdp.matchAll(/^m=(video|audio)/gm)) {
+    kinds.push(m[1]);
+  }
+  return kinds;
+}
+function errText2(err) {
+  return err instanceof Error ? err.message : String(err);
+}
 
 // src/plugins/builtin/camera/camera-plugin.ts
 var CONFIG_KEY = "config";
@@ -173407,7 +173665,7 @@ import {
   getCollection
 } from "home-assistant-js-websocket";
 import { atLeastHaVersion } from "home-assistant-js-websocket/dist/util.js";
-var logger244 = Logger.get("SubscribeEntities");
+var logger246 = Logger.get("SubscribeEntities");
 function processEvent(store, updates) {
   const state = { ...store.state };
   if (updates.a) {
@@ -173433,7 +173691,7 @@ function processEvent(store, updates) {
     for (const entityId in updates.c) {
       let entityState = state[entityId];
       if (!entityState) {
-        logger244.warn("Received state update for unknown entity", entityId);
+        logger246.warn("Received state update for unknown entity", entityId);
         continue;
       }
       entityState = { ...entityState };
@@ -173522,7 +173780,7 @@ var subscribeEntities = (conn, onChange, entityIds) => {
 // src/services/bridges/entity-isolation-service.ts
 init_esm();
 init_diagnostic_event_bus();
-var logger245 = Logger.get("EntityIsolation");
+var logger247 = Logger.get("EntityIsolation");
 var EntityIsolationServiceImpl = class {
   isolatedEntities = /* @__PURE__ */ new Map();
   isolationCallbacks = /* @__PURE__ */ new Map();
@@ -173587,13 +173845,13 @@ var EntityIsolationServiceImpl = class {
     }
     const parsed = this.parseEndpointPath(msg);
     if (!parsed) {
-      logger245.warn("Could not parse entity from error:", msg);
+      logger247.warn("Could not parse entity from error:", msg);
       return false;
     }
     const { bridgeId, entityName } = parsed;
     const callback = this.isolationCallbacks.get(bridgeId);
     if (!callback) {
-      logger245.warn(
+      logger247.warn(
         `No isolation callback registered for bridge ${bridgeId}, entity: ${entityName}`
       );
       return false;
@@ -173608,7 +173866,7 @@ var EntityIsolationServiceImpl = class {
       reason,
       failedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
-    logger245.warn(
+    logger247.warn(
       `Isolating entity "${entityName}" from bridge ${bridgeId} due to: ${reason}`
     );
     diagnosticEventBus.emit("entity_error", `Entity isolated: ${entityName}`, {
@@ -173620,7 +173878,7 @@ var EntityIsolationServiceImpl = class {
       await callback(entityName);
       return true;
     } catch (e) {
-      logger245.error(`Failed to isolate entity ${entityName}:`, e);
+      logger247.error(`Failed to isolate entity ${entityName}:`, e);
       return false;
     }
   }
@@ -175138,11 +175396,11 @@ function makeWarmStartState(state, now = (/* @__PURE__ */ new Date()).toISOStrin
   return { ...state, last_updated: now };
 }
 var ServerModeBridge = class {
-  constructor(logger248, dataProvider, endpointManager, server) {
+  constructor(logger250, dataProvider, endpointManager, server) {
     this.dataProvider = dataProvider;
     this.endpointManager = endpointManager;
     this.server = server;
-    this.log = logger248.get(`ServerModeBridge / ${dataProvider.id}`);
+    this.log = logger250.get(`ServerModeBridge / ${dataProvider.id}`);
   }
   dataProvider;
   endpointManager;
@@ -176172,7 +176430,7 @@ function ServerModeVacuumDevice(homeAssistantEntity, includeOnOff = false, clean
 }
 
 // src/matter/endpoints/server-mode-vacuum-endpoint.ts
-var logger246 = Logger.get("ServerModeVacuumEndpoint");
+var logger248 = Logger.get("ServerModeVacuumEndpoint");
 var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEndpoint {
   static async create(registry2, entityId, mapping, endpointId) {
     const deviceRegistry = registry2.deviceOf(entityId);
@@ -176185,7 +176443,7 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
     if (mapping?.disableBatteryMapping && mapping.batteryEntity) {
       effectiveMapping = { ...mapping, batteryEntity: void 0 };
     }
-    logger246.info(
+    logger248.info(
       `${entityId}: device_id=${entity.device_id}, manualBattery=${mapping?.batteryEntity ?? "none"}`
     );
     if (entity.device_id) {
@@ -176200,15 +176458,15 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
             batteryEntity: batteryEntityId
           };
           registry2.markBatteryEntityUsed(batteryEntityId);
-          logger246.info(`${entityId}: Auto-assigned battery ${batteryEntityId}`);
+          logger248.info(`${entityId}: Auto-assigned battery ${batteryEntityId}`);
         } else {
           const attrs = state.attributes;
           if (attrs.battery_level != null || attrs.battery != null) {
-            logger246.info(
+            logger248.info(
               `${entityId}: No battery entity found, using battery attribute from vacuum state`
             );
           } else {
-            logger246.warn(
+            logger248.warn(
               `${entityId}: No battery entity found for device ${entity.device_id}`
             );
           }
@@ -176223,7 +176481,7 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
           entityId: effectiveMapping?.entityId ?? entityId,
           cleaningModeEntity: vacuumEntities.cleaningModeEntity
         };
-        logger246.info(
+        logger248.info(
           `${entityId}: Auto-assigned cleaningMode ${vacuumEntities.cleaningModeEntity}`
         );
       }
@@ -176233,7 +176491,7 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
           entityId: effectiveMapping?.entityId ?? entityId,
           suctionLevelEntity: vacuumEntities.suctionLevelEntity
         };
-        logger246.info(
+        logger248.info(
           `${entityId}: Auto-assigned suctionLevel ${vacuumEntities.suctionLevelEntity}`
         );
       }
@@ -176243,7 +176501,7 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
           entityId: effectiveMapping?.entityId ?? entityId,
           mopIntensityEntity: vacuumEntities.mopIntensityEntity
         };
-        logger246.info(
+        logger248.info(
           `${entityId}: Auto-assigned mopIntensity ${vacuumEntities.mopIntensityEntity}`
         );
       }
@@ -176253,7 +176511,7 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
           entityId: effectiveMapping?.entityId ?? entityId,
           currentRoomEntity: vacuumEntities.currentRoomEntity
         };
-        logger246.info(
+        logger248.info(
           `${entityId}: Auto-assigned currentRoom ${vacuumEntities.currentRoomEntity}`
         );
       }
@@ -176268,7 +176526,7 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
           entityId: effectiveMapping?.entityId ?? entityId,
           cleanAreaRooms
         };
-        logger246.info(
+        logger248.info(
           `${entityId}: Using ${cleanAreaRooms.length} HA areas via CLEAN_AREA`
         );
       }
@@ -176289,7 +176547,7 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
               rooms: roomsObj
             }
           };
-          logger246.info(
+          logger248.info(
             `${entityId}: Auto-detected ${valetudoRooms.length} Valetudo segments`
           );
         } else {
@@ -176306,14 +176564,14 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
                 rooms: roomsObj
               }
             };
-            logger246.info(
+            logger248.info(
               `${entityId}: Auto-detected ${roborockRooms.length} Roborock rooms`
             );
           }
         }
       }
     } else {
-      logger246.warn(`${entityId}: No device_id, cannot auto-assign battery`);
+      logger248.warn(`${entityId}: No device_id, cannot auto-assign battery`);
     }
     const payload = {
       entity_id: entityId,
@@ -176386,11 +176644,11 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
     }
     if (mappedChanged) {
       this.pendingMappedChange = true;
-      logger246.debug(
+      logger248.debug(
         `Mapped entity change detected for ${this.entityId}, forcing update`
       );
     }
-    logger246.debug(
+    logger248.debug(
       `State update received for ${this.entityId}: state=${state.state}`
     );
     this.lastState = state;
@@ -176968,10 +177226,10 @@ var BridgeEnvironmentFactory = class extends BridgeFactory {
 // src/core/ioc/app-environment.ts
 var AppEnvironment = class _AppEnvironment extends EnvironmentBase {
   constructor(rootEnv, options) {
-    const logger248 = rootEnv.get(LoggerService);
+    const logger250 = rootEnv.get(LoggerService);
     super({
       id: "App",
-      log: logger248.get("AppContainer"),
+      log: logger250.get("AppContainer"),
       parent: rootEnv
     });
     this.options = options;
@@ -176985,8 +177243,8 @@ var AppEnvironment = class _AppEnvironment extends EnvironmentBase {
   }
   construction;
   async init() {
-    const logger248 = this.get(LoggerService);
-    this.set(LoggerService, logger248);
+    const logger250 = this.get(LoggerService);
+    this.set(LoggerService, logger250);
     this.set(AppStorage, new AppStorage(await this.load(StorageService)));
     this.set(BridgeStorage, new BridgeStorage(await this.load(AppStorage)));
     this.set(
@@ -177007,7 +177265,7 @@ var AppEnvironment = class _AppEnvironment extends EnvironmentBase {
     );
     this.set(
       HomeAssistantClient,
-      new HomeAssistantClient(logger248, this.options.homeAssistant)
+      new HomeAssistantClient(logger250, this.options.homeAssistant)
     );
     this.set(
       HomeAssistantConfig,
@@ -177015,7 +177273,7 @@ var AppEnvironment = class _AppEnvironment extends EnvironmentBase {
     );
     this.set(
       HomeAssistantActions,
-      new HomeAssistantActions(logger248, await this.load(HomeAssistantClient))
+      new HomeAssistantActions(logger250, await this.load(HomeAssistantClient))
     );
     this.set(
       HomeAssistantRegistry,
@@ -177051,7 +177309,7 @@ var AppEnvironment = class _AppEnvironment extends EnvironmentBase {
     this.set(
       WebApi,
       new WebApi(
-        logger248,
+        logger250,
         await this.load(BridgeService),
         await this.load(HomeAssistantClient),
         await this.load(HomeAssistantRegistry),
@@ -177072,7 +177330,7 @@ var AppEnvironment = class _AppEnvironment extends EnvironmentBase {
 
 // src/matter/patches/patch-level-control-tlv.ts
 init_esm();
-var logger247 = Logger.get("PatchLevelControlTlv");
+var logger249 = Logger.get("PatchLevelControlTlv");
 var optionalFieldModels = /* @__PURE__ */ new WeakSet();
 var fieldModelMandatoryGetterPatched = false;
 function patchLevelControlTlv() {
@@ -177128,11 +177386,11 @@ function patchLevelControlTlv() {
     patched++;
   }
   if (patched > 0) {
-    logger247.info(
+    logger249.info(
       `Patched ${patched} LevelControl TLV schema(s): transitionTime is now optional (Google Home compatibility)`
     );
   } else {
-    logger247.warn(
+    logger249.warn(
       "Failed to patch LevelControl TLV schemas, field definitions not found. Google Home brightness adjustment may not work.",
       {
         moveToLevel: describeFields(