@riddix/hamh 2.0.50 → 2.0.52

package/dist/backend/cli.js

@@ -1767,8 +1767,8 @@ var init_Cancelable = __esm({
         };
         return result;
       }
-      static set logger(logger247) {
-        this.#logger = logger247;
+      static set logger(logger251) {
+        this.#logger = logger251;
       }
       static get logger() {
         return this.#logger;
@@ -3475,13 +3475,13 @@ var init_Logger = __esm({
        *
        * @deprecated use {@link destinations}
        */
-      static addLogger(identifier, logger247, options) {
+      static addLogger(identifier, logger251, options) {
         if (identifier in this.destinations) {
           throw new ImplementationError(`Logger "${identifier}" already exists`);
         }
         const dest = LogDestination({ name: identifier });
         const legacy = adaptDestinationToLegacy(dest);
-        legacy.log = logger247;
+        legacy.log = logger251;
         if (options?.defaultLogLevel !== void 0) {
           legacy.defaultLogLevel = options.defaultLogLevel;
         }
@@ -5687,8 +5687,8 @@ var init_Construction = __esm({
           }
         }
         #unhandledError(...args) {
-          const logger247 = Logger.get(this.#subject.constructor.name);
-          logger247.error(...args);
+          const logger251 = Logger.get(this.#subject.constructor.name);
+          logger251.error(...args);
         }
         #createErrorHandler(name) {
           return (e) => {
@@ -11712,18 +11712,18 @@ var init_FileHandleTracker = __esm({
     logger12 = Logger.get("FileHandleTracker");
     ((FileHandleTracker2) => {
       const openHandles = /* @__PURE__ */ new Set();
-      const registry2 = new FinalizationRegistry((info) => {
+      const registry3 = new FinalizationRegistry((info) => {
         logger12.warn(`File handle GC'd without close: "${info.purpose}" for ${info.path}`);
       });
       function register(handle) {
         const info = { purpose: handle.purpose, path: handle.path };
-        registry2.register(handle, info, handle);
+        registry3.register(handle, info, handle);
         const ref = new WeakRef(handle);
         openHandles.add(ref);
       }
       FileHandleTracker2.register = register;
       function unregister(handle) {
-        registry2.unregister(handle);
+        registry3.unregister(handle);
         for (const ref of openHandles) {
           if (ref.deref() === handle) {
             openHandles.delete(ref);
@@ -64070,8 +64070,8 @@ var init_NodeSession = __esm({
         return session?.type === SessionType.Unicast;
       }
       NodeSession2.is = is;
-      function logNew(logger247, operation, session, messenger, fabric, peerNodeId) {
-        logger247.info(
+      function logNew(logger251, operation, session, messenger, fabric, peerNodeId) {
+        logger251.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 logger247 = loggers.get(facility);
-        if (!logger247) {
-          loggers.set(facility, logger247 = Logger.get(facility));
+        let logger251 = loggers.get(facility);
+        if (!logger251) {
+          loggers.set(facility, logger251 = Logger.get(facility));
         }
-        logger247[level](Diagnostic.via(id || "(anon)"), message);
+        logger251[level](Diagnostic.via(id || "(anon)"), message);
       }
       Api2.log = log;
       function logRequest(facility, id, method, target) {
@@ -131221,6 +131221,13 @@ var init_controller_compat = __esm({
         aqara: "yes",
         note: "Aqara lists battery storage; others show battery inside a device."
       },
+      1292: {
+        apple: "no",
+        google: "no",
+        alexa: "no",
+        aqara: "yes",
+        note: "HA and Aqara render EnergyEvse; SmartThings announced support, unconfirmed. Bridged EVSE can break Alexa device recognition, keep it off Alexa bridges."
+      },
       39: {
         apple: "no",
         google: "no",
@@ -132058,6 +132065,12 @@ var init_bridge_config_schema = __esm({
           description: "Anchor each device to its Home Assistant entity registry id instead of the entity id, so renaming an entity no longer re-adds it in your controller (Alexa, Google Home, Apple Home) and keeps groups and automations. Records are seeded from the start, so enabling this later is safe and never re-adds existing devices. Default off.",
           type: "boolean",
           default: false
+        },
+        wedgeWatchdog: {
+          title: "Wedge Watchdog (Apple 'Updating' workaround)",
+          description: "Rotate the one session that looks wedged, subscriptions still alive but no inbound request from the controller for about 45 minutes, earlier than the blind session rotation. Targets Apple Home tiles stuck on 'Updating' where the controller keeps acking but stops consuming data. A false positive only triggers a transparent reconnect, the same as normal rotation. Default off.",
+          type: "boolean",
+          default: false
         }
       }
     };
@@ -132618,10 +132631,10 @@ var init_home_assistant_actions = __esm({
       circuitBreakerResetMs: 3e4
     };
     HomeAssistantActions = class extends Service {
-      constructor(logger247, client, config11) {
+      constructor(logger251, client, config11) {
         super("HomeAssistantActions");
         this.client = client;
-        this.log = logger247.get(this);
+        this.log = logger251.get(this);
         this.config = { ...defaultConfig, ...config11 };
         this.circuitBreaker = new CircuitBreaker(
           this.config.circuitBreakerThreshold,
@@ -132967,10 +132980,10 @@ var DiagnosticService = class {
 };
 
 // src/api/access-log.ts
-function accessLogger(logger247) {
+function accessLogger(logger251) {
   return (req, res, next) => {
     res.on("finish", () => {
-      logger247.debug(
+      logger251.debug(
         `${req.method} ${decodeURI(req.originalUrl)} ${res.statusCode} ${res.statusMessage} from ${req.socket.remoteAddress}`
       );
     });
@@ -133155,6 +133168,8 @@ WARNING: ${includeIdentity ? "This backup contains sensitive Matter identity dat
                     currentEntity: config11.currentEntity,
                     batteryPowerEntity: config11.batteryPowerEntity,
                     batteryEnergyEntity: config11.batteryEnergyEntity,
+                    chargingSwitchEntity: config11.chargingSwitchEntity,
+                    currentLimitEntity: config11.currentLimitEntity,
                     suctionLevelEntity: config11.suctionLevelEntity,
                     mopIntensityEntity: config11.mopIntensityEntity,
                     valetudoIdentifier: config11.valetudoIdentifier,
@@ -133316,6 +133331,8 @@ WARNING: ${includeIdentity ? "This backup contains sensitive Matter identity dat
                   currentEntity: config11.currentEntity,
                   batteryPowerEntity: config11.batteryPowerEntity,
                   batteryEnergyEntity: config11.batteryEnergyEntity,
+                  chargingSwitchEntity: config11.chargingSwitchEntity,
+                  currentLimitEntity: config11.currentLimitEntity,
                   suctionLevelEntity: config11.suctionLevelEntity,
                   mopIntensityEntity: config11.mopIntensityEntity,
                   temperatureEntity: config11.temperatureEntity,
@@ -134168,6 +134185,8 @@ function entityMappingApi(mappingStorage, identityStorage) {
       currentEntity: body.currentEntity,
       batteryPowerEntity: body.batteryPowerEntity,
       batteryEnergyEntity: body.batteryEnergyEntity,
+      chargingSwitchEntity: body.chargingSwitchEntity,
+      currentLimitEntity: body.currentLimitEntity,
       suctionLevelEntity: body.suctionLevelEntity,
       mopIntensityEntity: body.mopIntensityEntity,
       customServiceAreas: body.customServiceAreas,
@@ -134669,6 +134688,8 @@ function configToProfileEntry(config11) {
     currentEntity: config11.currentEntity,
     batteryPowerEntity: config11.batteryPowerEntity,
     batteryEnergyEntity: config11.batteryEnergyEntity,
+    chargingSwitchEntity: config11.chargingSwitchEntity,
+    currentLimitEntity: config11.currentLimitEntity,
     suctionLevelEntity: config11.suctionLevelEntity,
     mopIntensityEntity: config11.mopIntensityEntity,
     customServiceAreas: config11.customServiceAreas,
@@ -134808,6 +134829,8 @@ function mappingProfileApi(mappingStorage) {
           currentEntity: entry.currentEntity,
           batteryPowerEntity: entry.batteryPowerEntity,
           batteryEnergyEntity: entry.batteryEnergyEntity,
+          chargingSwitchEntity: entry.chargingSwitchEntity,
+          currentLimitEntity: entry.currentLimitEntity,
           suctionLevelEntity: entry.suctionLevelEntity,
           mopIntensityEntity: entry.mopIntensityEntity,
           customServiceAreas: entry.customServiceAreas,
@@ -135034,6 +135057,300 @@ function resolveLabelValue(value, labels) {
   return value.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
 }
 
+// src/matter/endpoints/entity-endpoint.ts
+init_esm7();
+var EntityEndpoint = class extends Endpoint {
+  constructor(type, entityId, customName, mappedEntityIds, endpointId) {
+    super(type, { id: endpointId ?? createEndpointId(entityId, customName) });
+    this.entityId = entityId;
+    this.mappedEntityIds = mappedEntityIds ?? [];
+  }
+  entityId;
+  mappedEntityIds;
+  lastMappedStates = {};
+  hasMappedEntityChanged(states) {
+    let changed = false;
+    for (const mappedId of this.mappedEntityIds) {
+      const mappedState = states[mappedId];
+      if (!mappedState) continue;
+      const fp = mappedState.state;
+      if (fp !== this.lastMappedStates[mappedId]) {
+        this.lastMappedStates[mappedId] = fp;
+        changed = true;
+      }
+    }
+    return changed;
+  }
+};
+function createEndpointId(entityId, customName) {
+  const baseName = customName || entityId;
+  return baseName.replace(/\./g, "_").replace(/\s+/g, "_");
+}
+function getMappedEntityIds(mapping) {
+  if (!mapping) return [];
+  const ids = [];
+  if (mapping.batteryEntity && !mapping.disableBatteryMapping) {
+    ids.push(mapping.batteryEntity);
+  }
+  if (mapping.faultEntity) ids.push(mapping.faultEntity);
+  if (mapping.chargingStateEntity) ids.push(mapping.chargingStateEntity);
+  if (mapping.temperatureEntity) ids.push(mapping.temperatureEntity);
+  if (mapping.humidityEntity) ids.push(mapping.humidityEntity);
+  if (mapping.pressureEntity) ids.push(mapping.pressureEntity);
+  if (mapping.cleaningModeEntity) ids.push(mapping.cleaningModeEntity);
+  if (mapping.suctionLevelEntity) ids.push(mapping.suctionLevelEntity);
+  if (mapping.mopIntensityEntity) ids.push(mapping.mopIntensityEntity);
+  if (mapping.filterLifeEntity) ids.push(mapping.filterLifeEntity);
+  if (mapping.powerEntity) ids.push(mapping.powerEntity);
+  if (mapping.energyEntity) ids.push(mapping.energyEntity);
+  if (mapping.voltageEntity) ids.push(mapping.voltageEntity);
+  if (mapping.currentEntity) ids.push(mapping.currentEntity);
+  if (mapping.batteryPowerEntity) ids.push(mapping.batteryPowerEntity);
+  if (mapping.batteryEnergyEntity) ids.push(mapping.batteryEnergyEntity);
+  if (mapping.chargingSwitchEntity) ids.push(mapping.chargingSwitchEntity);
+  if (mapping.currentLimitEntity) ids.push(mapping.currentLimitEntity);
+  if (mapping.currentRoomEntity) ids.push(mapping.currentRoomEntity);
+  if (mapping.cleanedAreaEntity) ids.push(mapping.cleanedAreaEntity);
+  if (mapping.composedEntities) {
+    for (const sub of mapping.composedEntities) {
+      if (sub.entityId) ids.push(sub.entityId);
+    }
+  }
+  return ids;
+}
+
+// src/services/bridges/identity-resolver.ts
+var SEP = "\0";
+function identityKey(entity) {
+  const uniqueId = entity.registry?.unique_id;
+  const platform = entity.registry?.platform;
+  if (!uniqueId || !platform) {
+    return null;
+  }
+  const domain = entity.entity_id.split(".")[0];
+  return platform + SEP + domain + SEP + uniqueId;
+}
+var IdentityResolver = class {
+  constructor(identityStorage, mappingStorage) {
+    this.identityStorage = identityStorage;
+    this.mappingStorage = mappingStorage;
+  }
+  identityStorage;
+  mappingStorage;
+  async resolveIdentity(bridgeId, entity, mapping, opts) {
+    const entityId = entity.entity_id;
+    const key = identityKey(entity);
+    if (key == null) {
+      return {
+        endpointId: createEndpointId(entityId, mapping?.customName),
+        anchorEntityId: entityId,
+        protected: false
+      };
+    }
+    const existing = this.identityStorage.getIdentity(bridgeId, key);
+    if (existing) {
+      const renamedFrom = existing.lastEntityId !== entityId ? existing.lastEntityId ?? existing.anchorEntityId : void 0;
+      if (opts.stableIdentity) {
+        if (renamedFrom) {
+          this.identityStorage.setIdentity(bridgeId, key, {
+            ...existing,
+            lastEntityId: entityId
+          });
+          await this.rekeyMapping(bridgeId, renamedFrom, entityId);
+        }
+        return {
+          endpointId: existing.endpointId,
+          anchorEntityId: existing.anchorEntityId,
+          protected: true,
+          renamedFrom
+        };
+      }
+      const liveEndpointId = createEndpointId(entityId, mapping?.customName);
+      if (existing.endpointId !== liveEndpointId || existing.anchorEntityId !== entityId || existing.lastEntityId !== entityId) {
+        this.identityStorage.setIdentity(bridgeId, key, {
+          ...existing,
+          endpointId: liveEndpointId,
+          anchorEntityId: entityId,
+          lastEntityId: entityId
+        });
+      }
+      return {
+        endpointId: liveEndpointId,
+        anchorEntityId: entityId,
+        protected: false,
+        renamedFrom
+      };
+    }
+    const desired = createEndpointId(entityId, mapping?.customName);
+    let endpointId = desired;
+    if (opts.stableIdentity) {
+      let n = 2;
+      while (opts.isEndpointIdTaken(endpointId, key)) {
+        endpointId = `${desired}_${n++}`;
+      }
+    }
+    const record = {
+      endpointId,
+      anchorEntityId: entityId,
+      lastEntityId: entityId,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.identityStorage.setIdentity(bridgeId, key, record);
+    if (opts.stableIdentity) {
+      return {
+        endpointId: record.endpointId,
+        anchorEntityId: record.anchorEntityId,
+        protected: true
+      };
+    }
+    return {
+      endpointId: desired,
+      anchorEntityId: entityId,
+      protected: false
+    };
+  }
+  // Carry a mapping from the old entity_id to the new one on rename. anchorEntityId
+  // never changes, only the mapping key. Skips when no old mapping exists or a new
+  // one already does, so a manual mapping under the new id is never clobbered.
+  async rekeyMapping(bridgeId, oldEntityId, newEntityId) {
+    if (oldEntityId === newEntityId) {
+      return;
+    }
+    const old = this.mappingStorage.getMapping(bridgeId, oldEntityId);
+    if (!old) {
+      return;
+    }
+    if (this.mappingStorage.getMapping(bridgeId, newEntityId)) {
+      return;
+    }
+    await this.mappingStorage.setMapping({
+      ...old,
+      bridgeId,
+      entityId: newEntityId
+    });
+    await this.mappingStorage.deleteMapping(bridgeId, oldEntityId);
+  }
+};
+
+// src/services/storage/orphan-cleanup.ts
+var ORPHAN_TOMBSTONE_MS = 7 * 24 * 60 * 60 * 1e3;
+function buildPresentIdentityKeys(entities) {
+  const keys3 = /* @__PURE__ */ new Set();
+  for (const entity of Object.values(entities ?? {})) {
+    if (!entity?.entity_id) continue;
+    const key = identityKey({ entity_id: entity.entity_id, registry: entity });
+    if (key != null) keys3.add(key);
+  }
+  return keys3;
+}
+function buildPresentEntityIds(entities) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const entity of Object.values(entities ?? {})) {
+    if (entity?.entity_id) ids.add(entity.entity_id);
+  }
+  return ids;
+}
+function stampIdentityPresence(store, bridgeId, presentKeys, now = Date.now()) {
+  const nowIso = new Date(now).toISOString();
+  for (const key of [...store.getBridgeIdentities(bridgeId).keys()]) {
+    if (presentKeys.has(key)) {
+      store.clearIdentityMissing(bridgeId, key);
+    } else {
+      store.markIdentityMissing(bridgeId, key, nowIso);
+    }
+  }
+}
+function stampMappingPresence(store, bridgeId, presentEntityIds, now = Date.now()) {
+  const nowIso = new Date(now).toISOString();
+  const entityIds = store.getMappingsForBridge(bridgeId).map((m) => m.entityId);
+  for (const entityId of entityIds) {
+    if (presentEntityIds.has(entityId)) {
+      store.clearMappingMissing(bridgeId, entityId);
+    } else {
+      store.markMappingMissing(bridgeId, entityId, nowIso);
+    }
+  }
+}
+function computeOrphanCandidates(input) {
+  const now = input.now ?? Date.now();
+  const candidates = [];
+  for (const [key, record] of input.identities) {
+    if (!record.missingSince) continue;
+    const missingFor = now - Date.parse(record.missingSince);
+    if (!(missingFor >= ORPHAN_TOMBSTONE_MS)) continue;
+    if (input.presentKeys.has(key)) continue;
+    const lastEntityId = record.lastEntityId ?? record.anchorEntityId;
+    candidates.push({
+      identityKey: key,
+      lastEntityId,
+      missingSince: record.missingSince,
+      // Only a true orphan mapping, not one a live entity holds under a reused
+      // entity_id (a different identity key). Guards the sweep from clobbering
+      // that live entity's custom mapping.
+      hasMapping: input.hasMapping(lastEntityId) && !input.presentEntityIds.has(lastEntityId),
+      kind: "identity"
+    });
+  }
+  if (input.mappings) {
+    const linkedByIdentity = /* @__PURE__ */ new Set();
+    for (const candidate of candidates) {
+      if (candidate.hasMapping) linkedByIdentity.add(candidate.lastEntityId);
+    }
+    for (const mapping of input.mappings) {
+      if (!mapping.missingSince) continue;
+      const missingFor = now - Date.parse(mapping.missingSince);
+      if (!(missingFor >= ORPHAN_TOMBSTONE_MS)) continue;
+      if (input.presentEntityIds.has(mapping.entityId)) continue;
+      if (linkedByIdentity.has(mapping.entityId)) continue;
+      candidates.push({
+        identityKey: mapping.entityId,
+        lastEntityId: mapping.entityId,
+        missingSince: mapping.missingSince,
+        hasMapping: true,
+        kind: "mapping"
+      });
+    }
+  }
+  return candidates;
+}
+async function executeOrphanCleanup(input) {
+  const candidates = computeOrphanCandidates({
+    bridgeId: input.bridgeId,
+    identities: input.identities,
+    presentKeys: input.presentKeys,
+    presentEntityIds: input.presentEntityIds,
+    hasMapping: (entityId) => input.getMapping(input.bridgeId, entityId) != null,
+    mappings: input.mappings,
+    now: input.now
+  });
+  const byKey = new Map(candidates.map((c) => [c.identityKey, c]));
+  const results = [];
+  for (const key of input.requestedKeys) {
+    const candidate = byKey.get(key);
+    if (!candidate) {
+      results.push({
+        identityKey: key,
+        deleted: false,
+        reason: "not a current orphan candidate"
+      });
+      continue;
+    }
+    if (candidate.kind === "mapping") {
+      if (!input.presentEntityIds.has(candidate.lastEntityId)) {
+        await input.deleteMapping(input.bridgeId, candidate.lastEntityId);
+      }
+      results.push({ identityKey: key, deleted: true });
+      continue;
+    }
+    if (candidate.hasMapping && !input.presentEntityIds.has(candidate.lastEntityId)) {
+      await input.deleteMapping(input.bridgeId, candidate.lastEntityId);
+    }
+    await input.deleteIdentity(input.bridgeId, key);
+    results.push({ identityKey: key, deleted: true });
+  }
+  return results;
+}
+
 // src/utils/json/endpoint-to-json.ts
 function safeClone(value, depth = 0) {
   if (depth > 20 || value === null || value === void 0) return value;
@@ -135079,7 +135396,7 @@ function endpointToJson(endpoint, parentId) {
 
 // src/api/matter-api.ts
 var ajv = new Ajv();
-function matterApi(bridgeService, haRegistry, identityStorage) {
+function matterApi(bridgeService, haRegistry, identityStorage, mappingStorage) {
   const router = express11.Router();
   router.get("/", (_, res) => {
     res.status(200).json({});
@@ -135182,6 +135499,64 @@ function matterApi(bridgeService, haRegistry, identityStorage) {
       });
     }
   });
+  router.get("/bridges/:bridgeId/orphans", async (req, res) => {
+    const bridgeId = req.params.bridgeId;
+    const bridge = bridgeService.bridges.find((b) => b.id === bridgeId);
+    if (!bridge) {
+      res.status(404).send("Not Found");
+      return;
+    }
+    if (!haRegistry || !identityStorage) {
+      res.status(503).json({ error: "Orphan cleanup is not available" });
+      return;
+    }
+    const presentKeys = buildPresentIdentityKeys(haRegistry.entities);
+    const presentEntityIds = buildPresentEntityIds(haRegistry.entities);
+    const candidates = computeOrphanCandidates({
+      bridgeId,
+      identities: identityStorage.getBridgeIdentities(bridgeId),
+      presentKeys,
+      presentEntityIds,
+      hasMapping: (entityId) => mappingStorage?.getMapping(bridgeId, entityId) != null,
+      mappings: mappingStorage?.getMappingsForBridge(bridgeId)
+    });
+    res.status(200).json({ candidates });
+  });
+  router.post(
+    "/bridges/:bridgeId/actions/cleanup-orphans",
+    async (req, res) => {
+      const bridgeId = req.params.bridgeId;
+      const bridge = bridgeService.bridges.find((b) => b.id === bridgeId);
+      if (!bridge) {
+        res.status(404).send("Not Found");
+        return;
+      }
+      if (!haRegistry || !identityStorage || !mappingStorage) {
+        res.status(503).json({ error: "Orphan cleanup is not available" });
+        return;
+      }
+      const body = req.body;
+      const requestedKeys = Array.isArray(body?.identityKeys) ? body.identityKeys.filter((k) => typeof k === "string") : [];
+      try {
+        const results = await executeOrphanCleanup({
+          bridgeId,
+          requestedKeys,
+          identities: identityStorage.getBridgeIdentities(bridgeId),
+          presentKeys: buildPresentIdentityKeys(haRegistry.entities),
+          presentEntityIds: buildPresentEntityIds(haRegistry.entities),
+          getMapping: (b, e) => mappingStorage.getMapping(b, e),
+          deleteMapping: (b, e) => mappingStorage.deleteMapping(b, e),
+          deleteIdentity: (b, k) => identityStorage.deleteIdentity(b, k),
+          mappings: mappingStorage.getMappingsForBridge(bridgeId)
+        });
+        res.status(200).json({ results });
+      } catch (e) {
+        res.status(500).json({
+          error: e instanceof Error ? e.message : "Unknown error"
+        });
+      }
+    }
+  );
   router.get("/bridges/:bridgeId/devices", async (req, res) => {
     const bridgeId = req.params.bridgeId;
     const bridge = bridgeService.bridges.find((b) => b.id === bridgeId);
@@ -136242,11 +136617,12 @@ var BLOCKED_PREFIXES = [
 function pluginApi(bridgeService, storageLocation) {
   const router = express14.Router();
   const installer = new PluginInstaller(storageLocation);
-  const registry2 = new PluginRegistry(storageLocation);
+  const registry3 = new PluginRegistry(storageLocation);
   router.get("/", (_req, res) => {
     const result = [];
     for (const bridge of bridgeService.bridges) {
       const info = bridge.pluginInfo;
+      if (!info) continue;
       const plugins = info.metadata.map((meta) => ({
         name: meta.name,
         version: meta.version,
@@ -136269,41 +136645,41 @@ function pluginApi(bridgeService, storageLocation) {
     }
     res.json(result);
   });
-  router.post("/:bridgeId/:pluginName/enable", (req, res) => {
-    const bridge = bridgeService.get(req.params.bridgeId);
+  function pluginBridge(bridgeId, res) {
+    const bridge = bridgeService.get(bridgeId);
     if (!bridge) {
       res.status(404).json({ error: "Bridge not found" });
-      return;
+      return void 0;
+    }
+    if (typeof bridge.enablePlugin !== "function") {
+      res.status(400).json({ error: "Bridge does not support plugins" });
+      return void 0;
     }
+    return bridge;
+  }
+  router.post("/:bridgeId/:pluginName/enable", (req, res) => {
+    const bridge = pluginBridge(req.params.bridgeId, res);
+    if (!bridge) return;
     const { pluginName } = req.params;
     bridge.enablePlugin(pluginName);
     res.json({ success: true, pluginName, enabled: true });
   });
   router.post("/:bridgeId/:pluginName/disable", (req, res) => {
-    const bridge = bridgeService.get(req.params.bridgeId);
-    if (!bridge) {
-      res.status(404).json({ error: "Bridge not found" });
-      return;
-    }
+    const bridge = pluginBridge(req.params.bridgeId, res);
+    if (!bridge) return;
     const { pluginName } = req.params;
     bridge.disablePlugin(pluginName);
     res.json({ success: true, pluginName, enabled: false });
   });
   router.get("/:bridgeId/:pluginName/config-schema", (req, res) => {
-    const bridge = bridgeService.get(req.params.bridgeId);
-    if (!bridge) {
-      res.status(404).json({ error: "Bridge not found" });
-      return;
-    }
+    const bridge = pluginBridge(req.params.bridgeId, res);
+    if (!bridge) return;
     const schema6 = bridge.getPluginConfigSchema(req.params.pluginName);
     res.json({ pluginName: req.params.pluginName, schema: schema6 ?? null });
   });
   router.post("/:bridgeId/:pluginName/config", async (req, res) => {
-    const bridge = bridgeService.get(req.params.bridgeId);
-    if (!bridge) {
-      res.status(404).json({ error: "Bridge not found" });
-      return;
-    }
+    const bridge = pluginBridge(req.params.bridgeId, res);
+    if (!bridge) return;
     const { config: config11 } = req.body;
     if (!config11 || typeof config11 !== "object") {
       res.status(400).json({ error: "config object is required" });
@@ -136317,17 +136693,14 @@ function pluginApi(bridgeService, storageLocation) {
     res.json({ success: true, pluginName: req.params.pluginName });
   });
   router.post("/:bridgeId/:pluginName/reset", (req, res) => {
-    const bridge = bridgeService.get(req.params.bridgeId);
-    if (!bridge) {
-      res.status(404).json({ error: "Bridge not found" });
-      return;
-    }
+    const bridge = pluginBridge(req.params.bridgeId, res);
+    if (!bridge) return;
     const { pluginName } = req.params;
     bridge.resetPlugin(pluginName);
     res.json({ success: true, pluginName, reset: true });
   });
   router.get("/installed", (_req, res) => {
-    const registered = registry2.getAll();
+    const registered = registry3.getAll();
     const npmInstalled = installer.listInstalled();
     const result = registered.map((entry) => {
       const npm = npmInstalled.find((p) => p.name === entry.packageName);
@@ -136357,7 +136730,7 @@ function pluginApi(bridgeService, storageLocation) {
         });
         return;
       }
-      registry2.add(packageName, config11 ?? {});
+      registry3.add(packageName, config11 ?? {});
       res.json({
         success: true,
         packageName,
@@ -136385,7 +136758,7 @@ function pluginApi(bridgeService, storageLocation) {
         });
         return;
       }
-      registry2.remove(packageName);
+      registry3.remove(packageName);
       res.json({
         success: true,
         packageName,
@@ -136425,7 +136798,7 @@ function pluginApi(bridgeService, storageLocation) {
         });
         return;
       }
-      registry2.add(result.packageName, {});
+      registry3.add(result.packageName, {});
       res.json({
         success: true,
         packageName: result.packageName,
@@ -136458,7 +136831,7 @@ function pluginApi(bridgeService, storageLocation) {
         });
         return;
       }
-      registry2.add(result.packageName, {});
+      registry3.add(result.packageName, {});
       res.json({
         success: true,
         packageName: result.packageName,
@@ -137155,7 +137528,7 @@ var WebSocketApi = class {
 
 // src/api/web-api.ts
 var WebApi = class extends Service {
-  constructor(logger247, bridgeService, haClient, haRegistry, bridgeStorage, mappingStorage, identityStorage, lockCredentialStorage, settingsStorage, backupService, props) {
+  constructor(logger251, bridgeService, haClient, haRegistry, bridgeStorage, mappingStorage, identityStorage, lockCredentialStorage, settingsStorage, backupService, props) {
     super("WebApi");
     this.bridgeService = bridgeService;
     this.haClient = haClient;
@@ -137167,8 +137540,8 @@ var WebApi = class extends Service {
     this.settingsStorage = settingsStorage;
     this.backupService = backupService;
     this.props = props;
-    this.logger = logger247;
-    this.log = logger247.get(this);
+    this.logger = logger251;
+    this.log = logger251.get(this);
     this.accessLogger = accessLogger(this.log.createChild("Access Log"));
     this.startTime = Date.now();
     this.wsApi = new WebSocketApi(
@@ -137201,7 +137574,12 @@ var WebApi = class extends Service {
     const api = express17.Router();
     api.use(express17.json()).use(nocache()).use(
       "/matter",
-      matterApi(this.bridgeService, this.haRegistry, this.identityStorage)
+      matterApi(
+        this.bridgeService,
+        this.haRegistry,
+        this.identityStorage,
+        this.mappingStorage
+      )
     ).use(
       "/health",
       healthApi(
@@ -138354,10 +138732,10 @@ function isTransientConnectError(reason) {
   return msg.includes("socket hang up") || msg.includes("tls") || msg.includes("TLS");
 }
 var HomeAssistantClient = class extends Service {
-  constructor(logger247, options) {
+  constructor(logger251, options) {
     super("HomeAssistantClient");
     this.options = options;
-    this.log = logger247.get(this);
+    this.log = logger251.get(this);
   }
   options;
   static Options = /* @__PURE__ */ Symbol.for("HomeAssistantClientProps");
@@ -139022,11 +139400,37 @@ var EntityIdentityStorage = class extends Service {
     this.identities.delete(bridgeId);
     await this.flush();
   }
+  // Drop a single identity record. Used by the manual orphan cleanup after the
+  // 7-day tombstone; flush immediately since it is a user-initiated deletion.
+  async deleteIdentity(bridgeId, key) {
+    const bridgeMap = this.identities.get(bridgeId);
+    if (bridgeMap?.delete(key)) {
+      await this.flush();
+    }
+  }
+  // Stamp the tombstone the first time a record's entity is absent from HA. Keeps
+  // the first-seen time on later passes and no-ops once stamped, so a steady
+  // absence does not churn the debounced persist.
+  markIdentityMissing(bridgeId, key, nowIso) {
+    const record = this.identities.get(bridgeId)?.get(key);
+    if (!record || record.missingSince != null) return;
+    record.missingSince = nowIso;
+    this.schedulePersist();
+  }
+  // Clear the tombstone when the entity is present again. No-ops when there is
+  // nothing to clear, so an all-present bridge writes nothing on refresh.
+  clearIdentityMissing(bridgeId, key) {
+    const record = this.identities.get(bridgeId)?.get(key);
+    if (!record || record.missingSince == null) return;
+    delete record.missingSince;
+    this.schedulePersist();
+  }
 };
 
 // src/services/storage/entity-mapping-storage.ts
 init_service();
 var CURRENT_VERSION2 = 1;
+var PERSIST_DEBOUNCE_MS2 = 500;
 var EntityMappingStorage = class extends Service {
   constructor(appStorage) {
     super("EntityMappingStorage");
@@ -139035,10 +139439,14 @@ var EntityMappingStorage = class extends Service {
   appStorage;
   storage;
   mappings = /* @__PURE__ */ new Map();
+  persistTimer = null;
   async initialize() {
     this.storage = this.appStorage.createContext("entity-mappings");
     await this.load();
   }
+  async dispose() {
+    await this.flush();
+  }
   async load() {
     const stored = await this.storage.get("data", {
       version: CURRENT_VERSION2,
@@ -139073,6 +139481,10 @@ var EntityMappingStorage = class extends Service {
     }
   }
   async persist() {
+    if (this.persistTimer) {
+      clearTimeout(this.persistTimer);
+      this.persistTimer = null;
+    }
     const data = {
       version: CURRENT_VERSION2,
       mappings: {}
@@ -139082,6 +139494,17 @@ var EntityMappingStorage = class extends Service {
     }
     await this.storage.set("data", data);
   }
+  schedulePersist() {
+    if (this.persistTimer) return;
+    this.persistTimer = setTimeout(() => {
+      this.persistTimer = null;
+      void this.persist();
+    }, PERSIST_DEBOUNCE_MS2);
+  }
+  // Flush any pending debounced write, used on dispose and by tests.
+  async flush() {
+    await this.persist();
+  }
   getMappingsForBridge(bridgeId) {
     const bridgeMap = this.mappings.get(bridgeId);
     return bridgeMap ? Array.from(bridgeMap.values()) : [];
@@ -139128,6 +139551,8 @@ var EntityMappingStorage = class extends Service {
       currentEntity: request.currentEntity?.trim() || void 0,
       batteryPowerEntity: request.batteryPowerEntity?.trim() || void 0,
       batteryEnergyEntity: request.batteryEnergyEntity?.trim() || void 0,
+      chargingSwitchEntity: request.chargingSwitchEntity?.trim() || void 0,
+      currentLimitEntity: request.currentLimitEntity?.trim() || void 0,
       pressureEntity: request.pressureEntity?.trim() || void 0,
       suctionLevelEntity: request.suctionLevelEntity?.trim() || void 0,
       mopIntensityEntity: request.mopIntensityEntity?.trim() || void 0,
@@ -139156,7 +139581,7 @@ var EntityMappingStorage = class extends Service {
       composedEntities: request.composedEntities?.filter((e) => e.entityId?.trim()) ?? void 0,
       disableMomentaryFlip: request.disableMomentaryFlip || void 0
     };
-    if (!config11.matterDeviceType && !config11.customName && !config11.customProductName && !config11.customVendorName && !config11.customSerialNumber && config11.customVendorId === void 0 && config11.disabled !== true && !config11.filterLifeEntity && !config11.cleaningModeEntity && !config11.temperatureEntity && !config11.humidityEntity && !config11.batteryEntity && !config11.disableBatteryMapping && !config11.chargingStateEntity && !config11.roomEntities && !config11.disableLockPin && !config11.lockUsercodeService && config11.lockUsercodeSlot === void 0 && config11.lockPinMinLength === void 0 && config11.lockPinMaxLength === void 0 && !config11.powerEntity && !config11.energyEntity && !config11.voltageEntity && !config11.currentEntity && !config11.batteryPowerEntity && !config11.batteryEnergyEntity && !config11.pressureEntity && !config11.suctionLevelEntity && !config11.mopIntensityEntity && (!config11.customServiceAreas || config11.customServiceAreas.length === 0) && (!config11.customFanSpeedTags || Object.keys(config11.customFanSpeedTags).length === 0) && (!config11.fanWindPresets || (config11.fanWindPresets.natural?.length ?? 0) === 0 && (config11.fanWindPresets.sleep?.length ?? 0) === 0) && !config11.fanRestoreSpeedOnPowerOn && !config11.currentRoomEntity && !config11.cleanedAreaEntity && !config11.disableCustomAreaRoomModes && !config11.valetudoIdentifier && !config11.coverSwapOpenClose && !config11.coverExposeAsDimmableLight && !config11.selectExposeAsSwitch && !config11.selectSwitchOnOption && !config11.selectSwitchOffOption && !config11.coverSliderDebounceMs && !config11.updateThrottleMs && !config11.disableClimateOnOff && !config11.disableClimateFanControl && !config11.climateKeepModeOnIdle && !config11.climateExposeFan && !config11.climateAutoMode && (!config11.composedEntities || config11.composedEntities.length === 0) && !config11.disableMomentaryFlip) {
+    if (!config11.matterDeviceType && !config11.customName && !config11.customProductName && !config11.customVendorName && !config11.customSerialNumber && config11.customVendorId === void 0 && config11.disabled !== true && !config11.filterLifeEntity && !config11.cleaningModeEntity && !config11.temperatureEntity && !config11.humidityEntity && !config11.batteryEntity && !config11.disableBatteryMapping && !config11.chargingStateEntity && !config11.roomEntities && !config11.disableLockPin && !config11.lockUsercodeService && config11.lockUsercodeSlot === void 0 && config11.lockPinMinLength === void 0 && config11.lockPinMaxLength === void 0 && !config11.powerEntity && !config11.energyEntity && !config11.voltageEntity && !config11.currentEntity && !config11.batteryPowerEntity && !config11.batteryEnergyEntity && !config11.chargingSwitchEntity && !config11.currentLimitEntity && !config11.pressureEntity && !config11.suctionLevelEntity && !config11.mopIntensityEntity && (!config11.customServiceAreas || config11.customServiceAreas.length === 0) && (!config11.customFanSpeedTags || Object.keys(config11.customFanSpeedTags).length === 0) && (!config11.fanWindPresets || (config11.fanWindPresets.natural?.length ?? 0) === 0 && (config11.fanWindPresets.sleep?.length ?? 0) === 0) && !config11.fanRestoreSpeedOnPowerOn && !config11.currentRoomEntity && !config11.cleanedAreaEntity && !config11.disableCustomAreaRoomModes && !config11.valetudoIdentifier && !config11.coverSwapOpenClose && !config11.coverExposeAsDimmableLight && !config11.selectExposeAsSwitch && !config11.selectSwitchOnOption && !config11.selectSwitchOffOption && !config11.coverSliderDebounceMs && !config11.updateThrottleMs && !config11.disableClimateOnOff && !config11.disableClimateFanControl && !config11.climateKeepModeOnIdle && !config11.climateExposeFan && !config11.climateAutoMode && (!config11.composedEntities || config11.composedEntities.length === 0) && !config11.disableMomentaryFlip) {
       bridgeMap.delete(request.entityId);
     } else {
       bridgeMap.set(request.entityId, config11);
@@ -139175,6 +139600,23 @@ var EntityMappingStorage = class extends Service {
     this.mappings.delete(bridgeId);
     await this.persist();
   }
+  // Stamp the tombstone the first time a mapping's entity is absent from HA.
+  // Keeps the first-seen time on later passes and no-ops once stamped, so a
+  // steady absence does not churn the debounced persist.
+  markMappingMissing(bridgeId, entityId, nowIso) {
+    const record = this.mappings.get(bridgeId)?.get(entityId);
+    if (!record || record.missingSince != null) return;
+    record.missingSince = nowIso;
+    this.schedulePersist();
+  }
+  // Clear the tombstone when the entity is present again. No-ops when there is
+  // nothing to clear, so an all-present bridge writes nothing on refresh.
+  clearMappingMissing(bridgeId, entityId) {
+    const record = this.mappings.get(bridgeId)?.get(entityId);
+    if (!record || record.missingSince == null) return;
+    delete record.missingSince;
+    this.schedulePersist();
+  }
 };
 function sanitizeVendorId(value) {
   if (value === void 0 || value === null || value === "") {
@@ -149100,6 +149542,7 @@ var EnergyEvseDeviceDefinition = MutableEndpoint({
   )
 });
 Object.freeze(EnergyEvseDeviceDefinition);
+var EnergyEvseDevice = EnergyEvseDeviceDefinition;
 
 // ../../node_modules/.pnpm/@matter+node@0.17.7_patch_hash=34f8224b2964673272e9f22613c0cb1f8ec12758dd46b4fe303d42373451ad4c/node_modules/@matter/node/dist/esm/devices/extended-color-light.js
 init_IdentifyServer();
@@ -156079,8 +156522,8 @@ var PluginManager = class {
     this.storageDir = storageDir;
     this.homeAssistant = homeAssistant;
   }
-  setRegistry(registry2) {
-    this.registry = registry2;
+  setRegistry(registry3) {
+    this.registry = registry3;
   }
   /**
    * Load and register a built-in plugin instance.
@@ -156805,16 +157248,96 @@ function seedExistingSessionStarts(startedAt, sessions, now = Date.now()) {
   }
 }
 
+// src/services/bridges/subscription-summary.ts
+function readPaths(value) {
+  return Array.isArray(value) ? value : null;
+}
+function unknownSummary(id) {
+  return {
+    id,
+    attributePaths: 0,
+    eventPaths: 0,
+    scope: "unknown",
+    endpointIds: []
+  };
+}
+function summarizeSubscription(sub) {
+  let id = null;
+  let request;
+  try {
+    const s = sub;
+    if (typeof s.subscriptionId === "number") {
+      id = s.subscriptionId;
+    }
+    request = s.request;
+  } catch {
+    return unknownSummary(id);
+  }
+  if (request == null || typeof request !== "object") {
+    return unknownSummary(id);
+  }
+  const req = request;
+  const attrPaths = readPaths(req.attributeRequests);
+  const eventPaths = readPaths(req.eventRequests);
+  if (attrPaths === null && eventPaths === null) {
+    return unknownSummary(id);
+  }
+  const all = [...attrPaths ?? [], ...eventPaths ?? []];
+  let wildcard = false;
+  const endpointIds = /* @__PURE__ */ new Set();
+  for (const path14 of all) {
+    const ep = path14?.endpointId;
+    if (ep == null) {
+      wildcard = true;
+    } else if (typeof ep === "number" || typeof ep === "bigint") {
+      endpointIds.add(Number(ep));
+    }
+  }
+  return {
+    id,
+    attributePaths: attrPaths?.length ?? 0,
+    eventPaths: eventPaths?.length ?? 0,
+    scope: wildcard ? "wildcard" : "endpoint-specific",
+    endpointIds: [...endpointIds].sort((a, b) => a - b)
+  };
+}
+function summarizeSubscriptions(subscriptions) {
+  const out = [];
+  try {
+    for (const sub of subscriptions) {
+      out.push(summarizeSubscription(sub));
+    }
+  } catch {
+  }
+  return out;
+}
+
+// src/services/bridges/wedge-watchdog.ts
+var WEDGE_WARMUP_MS = 15 * 60 * 1e3;
+var WEDGE_IM_SILENCE_MS = 45 * 60 * 1e3;
+var WEDGE_MIN_ROTATE_INTERVAL_MS = 60 * 60 * 1e3;
+function decideWedgeRotation(input) {
+  const {
+    subscriptionCount,
+    sessionAgeMs,
+    lastImRequestMsAgo,
+    lastRotatedMsAgo
+  } = input;
+  const imSilenceMs = lastImRequestMsAgo == null ? sessionAgeMs : lastImRequestMsAgo;
+  return subscriptionCount > 0 && sessionAgeMs > WEDGE_WARMUP_MS && imSilenceMs > WEDGE_IM_SILENCE_MS && (lastRotatedMsAgo == null || lastRotatedMsAgo > WEDGE_MIN_ROTATE_INTERVAL_MS);
+}
+
 // src/services/bridges/bridge.ts
+var imWrapMarker = /* @__PURE__ */ Symbol("hamh.wedgeImWrap");
 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, logger247, dataProvider, endpointManager, serverOptions) {
+  constructor(env, logger251, dataProvider, endpointManager, serverOptions) {
     this.dataProvider = dataProvider;
     this.endpointManager = endpointManager;
     this.serverOptions = serverOptions;
-    this.log = logger247.get(`Bridge / ${dataProvider.id}`);
+    this.log = logger251.get(`Bridge / ${dataProvider.id}`);
     this.server = new BridgeServerNode(
       env,
       this.dataProvider,
@@ -156853,6 +157376,12 @@ var Bridge = class {
   sessionStartedAt = /* @__PURE__ */ new Map();
   rotationTimer = null;
   maxSessionAgeMs = 0;
+  // Wedge watchdog: last inbound Interaction Model request time per session and
+  // last time the watchdog rotated it, both keyed by the long-lived session
+  // object so they clear when the session goes away.
+  lastImRequestAt = /* @__PURE__ */ new WeakMap();
+  wedgeLastRotatedAt = /* @__PURE__ */ new WeakMap();
+  wedgeWatchdogTimer = null;
   // Watches the advertised interface addresses so a dynamic ISP IPv6 prefix
   // change forces a fresh operational announcement (#415).
   mdnsAddressTimer = null;
@@ -156899,6 +157428,7 @@ var Bridge = class {
       const sessionList = sessions.map((s) => {
         const subCount = s.subscriptions.size;
         totalSubscriptions += subCount;
+        const subscriptions = summarizeSubscriptions(s.subscriptions);
         const fi = typeof s.fabric?.fabricIndex === "number" ? s.fabric.fabricIndex : null;
         if (fi !== null) {
           const existing = fabricMap.get(fi) ?? {
@@ -156912,14 +157442,18 @@ var Bridge = class {
         const nowMs = Date.now();
         const lastActiveMsAgo = typeof s.activeTimestamp === "number" && s.activeTimestamp > 0 ? nowMs - s.activeTimestamp : null;
         const lastAnyActivityMsAgo = typeof s.timestamp === "number" ? nowMs - s.timestamp : null;
+        const lastImAt = this.lastImRequestAt.get(s);
+        const lastImRequestMsAgo = lastImAt != null ? nowMs - lastImAt : null;
         const startedAt = this.sessionStartedAt.get(s.id);
         return {
           id: s.id,
           peerNodeId: String(s.peerNodeId),
           fabricIndex: fi,
           subscriptionCount: subCount,
+          subscriptions,
           lastActiveMsAgo,
           lastAnyActivityMsAgo,
+          lastImRequestMsAgo,
           isPeerActive: Boolean(s.isPeerActive),
           ageMsFromOpen: startedAt != null ? nowMs - startedAt : null
         };
@@ -157086,6 +157620,7 @@ var Bridge = class {
       this.wireSessionDiagnostics();
       this.wireFabricWarnings();
       this.startSessionRotation();
+      this.startWedgeWatchdog();
       this.startMdnsAddressWatch();
       logMemoryUsage(this.log, "bridge running");
       diagnosticEventBus.emit("bridge_started", `Bridge started`, {
@@ -157285,6 +157820,29 @@ ${e?.toString()}`);
       };
       sessionManager.sessions.added.on(this.sessionAddedHandler);
       sessionManager.sessions.deleted.on(this.sessionDeletedHandler);
+      this.wireImRequestTracking();
+    } catch {
+    }
+  }
+  // Stamp the time of every inbound Interaction Model request per session by
+  // wrapping InteractionServer.onNewExchange. The wedge watchdog reads these to
+  // tell a live-but-consuming controller from one that only keeps acking.
+  wireImRequestTracking() {
+    try {
+      const is = this.server.env.get(InteractionServer);
+      const marked = is;
+      if (marked[imWrapMarker]) {
+        return;
+      }
+      const original = is.onNewExchange.bind(is);
+      is.onNewExchange = (exchange, message) => {
+        const session = exchange.session;
+        if (session) {
+          this.lastImRequestAt.set(session, Date.now());
+        }
+        return original(exchange, message);
+      };
+      marked[imWrapMarker] = true;
     } catch {
     }
   }
@@ -157447,6 +158005,7 @@ ${e?.toString()}`);
     }
     this.staleSessionTimers.clear();
     this.stopSessionRotation();
+    this.stopWedgeWatchdog();
     this.stopMdnsAddressWatch();
     this.sessionStartedAt.clear();
   }
@@ -157512,6 +158071,72 @@ ${e?.toString()}`);
       this.rotationTimer = null;
     }
   }
+  // Opt-in wedge watchdog: reuse the rotation check cadence (5min) to look for
+  // the one session wedged on "Updating" and rotate just that one.
+  startWedgeWatchdog() {
+    this.stopWedgeWatchdog();
+    if (!this.dataProvider.featureFlags?.wedgeWatchdog) {
+      return;
+    }
+    this.wedgeWatchdogTimer = setInterval(
+      () => this.runWedgeWatchdogCheck(),
+      ROTATION_CHECK_INTERVAL_MS
+    );
+    this.log.info(
+      `Wedge watchdog: checking every ${ROTATION_CHECK_INTERVAL_MS / 6e4}min`
+    );
+  }
+  stopWedgeWatchdog() {
+    if (this.wedgeWatchdogTimer) {
+      clearInterval(this.wedgeWatchdogTimer);
+      this.wedgeWatchdogTimer = null;
+    }
+  }
+  // Rotate exactly the sessions the pure rule flags as wedged. Closing is the
+  // same graceful-then-force path age rotation uses, so a false positive just
+  // re-CASEs the controller.
+  runWedgeWatchdogCheck() {
+    try {
+      const sessionManager = this.server.env.get(SessionManager);
+      const now = Date.now();
+      const closes = [];
+      for (const s of [...sessionManager.sessions]) {
+        if (s.isClosing) continue;
+        const startedAt = this.sessionStartedAt.get(s.id);
+        const sessionAgeMs = startedAt != null ? now - startedAt : 0;
+        const lastImAt = this.lastImRequestAt.get(s);
+        const lastImRequestMsAgo = lastImAt != null ? now - lastImAt : null;
+        const lastRotatedAt = this.wedgeLastRotatedAt.get(s);
+        const lastRotatedMsAgo = lastRotatedAt != null ? now - lastRotatedAt : null;
+        if (!decideWedgeRotation({
+          subscriptionCount: s.subscriptions.size,
+          sessionAgeMs,
+          lastImRequestMsAgo,
+          lastRotatedMsAgo
+        })) {
+          continue;
+        }
+        const silenceMin = Math.round(
+          (lastImRequestMsAgo ?? sessionAgeMs) / 6e4
+        );
+        this.log.info(
+          `Wedge watchdog: rotating session ${s.id}, no inbound interaction for ${silenceMin}min`
+        );
+        this.wedgeLastRotatedAt.set(s, now);
+        closes.push(
+          s.initiateClose().catch(() => {
+            return s.initiateForceClose({
+              cause: new Error("wedge watchdog, forcing")
+            });
+          })
+        );
+      }
+      if (closes.length > 0) {
+        Promise.allSettled(closes).then(() => this.triggerMdnsReAnnounce());
+      }
+    } catch {
+    }
+  }
   // Poll the interface addresses mDNS advertises and re-announce when they
   // change. matter.js caches the operational records at first announcement, so
   // a dynamic ISP IPv6 prefix change keeps advertising the dead global address
@@ -157643,6 +158268,7 @@ ${e?.toString()}`);
       if (this.status.code === BridgeStatus.Running) {
         this.startAutoForceSyncIfEnabled();
         this.startSessionRotation();
+        this.startWedgeWatchdog();
       }
     } catch (e) {
       const reason = "Failed to update bridge due to error:";
@@ -157765,66 +158391,6 @@ var AggregatorEndpoint2 = class extends Endpoint {
   }
 };
 
-// src/matter/endpoints/entity-endpoint.ts
-init_esm7();
-var EntityEndpoint = class extends Endpoint {
-  constructor(type, entityId, customName, mappedEntityIds, endpointId) {
-    super(type, { id: endpointId ?? createEndpointId(entityId, customName) });
-    this.entityId = entityId;
-    this.mappedEntityIds = mappedEntityIds ?? [];
-  }
-  entityId;
-  mappedEntityIds;
-  lastMappedStates = {};
-  hasMappedEntityChanged(states) {
-    let changed = false;
-    for (const mappedId of this.mappedEntityIds) {
-      const mappedState = states[mappedId];
-      if (!mappedState) continue;
-      const fp = mappedState.state;
-      if (fp !== this.lastMappedStates[mappedId]) {
-        this.lastMappedStates[mappedId] = fp;
-        changed = true;
-      }
-    }
-    return changed;
-  }
-};
-function createEndpointId(entityId, customName) {
-  const baseName = customName || entityId;
-  return baseName.replace(/\./g, "_").replace(/\s+/g, "_");
-}
-function getMappedEntityIds(mapping) {
-  if (!mapping) return [];
-  const ids = [];
-  if (mapping.batteryEntity && !mapping.disableBatteryMapping) {
-    ids.push(mapping.batteryEntity);
-  }
-  if (mapping.faultEntity) ids.push(mapping.faultEntity);
-  if (mapping.chargingStateEntity) ids.push(mapping.chargingStateEntity);
-  if (mapping.temperatureEntity) ids.push(mapping.temperatureEntity);
-  if (mapping.humidityEntity) ids.push(mapping.humidityEntity);
-  if (mapping.pressureEntity) ids.push(mapping.pressureEntity);
-  if (mapping.cleaningModeEntity) ids.push(mapping.cleaningModeEntity);
-  if (mapping.suctionLevelEntity) ids.push(mapping.suctionLevelEntity);
-  if (mapping.mopIntensityEntity) ids.push(mapping.mopIntensityEntity);
-  if (mapping.filterLifeEntity) ids.push(mapping.filterLifeEntity);
-  if (mapping.powerEntity) ids.push(mapping.powerEntity);
-  if (mapping.energyEntity) ids.push(mapping.energyEntity);
-  if (mapping.voltageEntity) ids.push(mapping.voltageEntity);
-  if (mapping.currentEntity) ids.push(mapping.currentEntity);
-  if (mapping.batteryPowerEntity) ids.push(mapping.batteryPowerEntity);
-  if (mapping.batteryEnergyEntity) ids.push(mapping.batteryEnergyEntity);
-  if (mapping.currentRoomEntity) ids.push(mapping.currentRoomEntity);
-  if (mapping.cleanedAreaEntity) ids.push(mapping.cleanedAreaEntity);
-  if (mapping.composedEntities) {
-    for (const sub of mapping.composedEntities) {
-      if (sub.entityId) ids.push(sub.entityId);
-    }
-  }
-  return ids;
-}
-
 // src/matter/endpoints/legacy/legacy-endpoint.ts
 init_dist();
 init_esm();
@@ -157903,9 +158469,9 @@ function resolveBatteryPercent(state) {
   return BATTERY_ENUM_PERCENT[state.toLowerCase()] ?? null;
 }
 var EntityStateProvider = class extends Service {
-  constructor(registry2) {
+  constructor(registry3) {
     super("EntityStateProvider");
-    this.registry = registry2;
+    this.registry = registry3;
   }
   registry;
   /**
@@ -159823,11 +160389,11 @@ function createEndpointId2(entityId, customName) {
   const baseName = customName || entityId;
   return baseName.replace(/\./g, "_").replace(/\s+/g, "_");
 }
-function buildEntityPayload(registry2, entityId) {
-  const state = registry2.initialState(entityId);
+function buildEntityPayload(registry3, entityId) {
+  const state = registry3.initialState(entityId);
   if (!state) return void 0;
-  const entity = registry2.entity(entityId);
-  const deviceRegistry = registry2.deviceOf(entityId);
+  const entity = registry3.entity(entityId);
+  const deviceRegistry = registry3.deviceOf(entityId);
   return {
     entity_id: entityId,
     state,
@@ -159842,8 +160408,8 @@ var ComposedAirPurifierEndpoint = class _ComposedAirPurifierEndpoint extends End
   lastStates = /* @__PURE__ */ new Map();
   debouncedUpdates = /* @__PURE__ */ new Map();
   static async create(config11) {
-    const { registry: registry2, primaryEntityId } = config11;
-    const primaryPayload = buildEntityPayload(registry2, primaryEntityId);
+    const { registry: registry3, primaryEntityId } = config11;
+    const primaryPayload = buildEntityPayload(registry3, primaryEntityId);
     if (!primaryPayload) return void 0;
     const airPurifierAttributes = primaryPayload.state.attributes;
     const supportedFeatures = airPurifierAttributes.supported_features ?? 0;
@@ -159931,7 +160497,7 @@ var ComposedAirPurifierEndpoint = class _ComposedAirPurifierEndpoint extends End
     let tempSub;
     if (config11.temperatureEntityId) {
       const tempPayload = buildEntityPayload(
-        registry2,
+        registry3,
         config11.temperatureEntityId
       );
       if (tempPayload) {
@@ -159946,7 +160512,7 @@ var ComposedAirPurifierEndpoint = class _ComposedAirPurifierEndpoint extends End
     }
     let humSub;
     if (config11.humidityEntityId) {
-      const humPayload = buildEntityPayload(registry2, config11.humidityEntityId);
+      const humPayload = buildEntityPayload(registry3, config11.humidityEntityId);
       if (humPayload) {
         humSub = new Endpoint(
           HumiditySubType.set({
@@ -161400,14 +161966,14 @@ function createEndpointId3(entityId, customName) {
   const baseName = customName || entityId;
   return baseName.replace(/\./g, "_").replace(/\s+/g, "_");
 }
-function buildEntityPayload2(registry2, entityId) {
-  const state = registry2.initialState(entityId);
+function buildEntityPayload2(registry3, entityId) {
+  const state = registry3.initialState(entityId);
   if (!state) return void 0;
   return {
     entity_id: entityId,
     state,
-    registry: registry2.entity(entityId),
-    deviceRegistry: registry2.deviceOf(entityId)
+    registry: registry3.entity(entityId),
+    deviceRegistry: registry3.deviceOf(entityId)
   };
 }
 var ComposedClimateFanEndpoint = class _ComposedClimateFanEndpoint extends Endpoint {
@@ -161417,8 +161983,8 @@ var ComposedClimateFanEndpoint = class _ComposedClimateFanEndpoint extends Endpo
   lastStates = /* @__PURE__ */ new Map();
   debouncedUpdates = /* @__PURE__ */ new Map();
   static async create(config11) {
-    const { registry: registry2, primaryEntityId } = config11;
-    const payload = buildEntityPayload2(registry2, primaryEntityId);
+    const { registry: registry3, primaryEntityId } = config11;
+    const payload = buildEntityPayload2(registry3, primaryEntityId);
     if (!payload) return void 0;
     const endpointId = config11.endpointId ?? createEndpointId3(primaryEntityId, config11.customName);
     const mapping = config11.mapping ?? {
@@ -161676,11 +162242,11 @@ function createEndpointId4(entityId, customName) {
   const baseName = customName || entityId;
   return baseName.replace(/\./g, "_").replace(/\s+/g, "_");
 }
-function buildEntityPayload3(registry2, entityId) {
-  const state = registry2.initialStateIncludingUnfiltered(entityId);
+function buildEntityPayload3(registry3, entityId) {
+  const state = registry3.initialStateIncludingUnfiltered(entityId);
   if (!state) return void 0;
-  const entity = registry2.entityIncludingUnfiltered(entityId);
-  const deviceRegistry = registry2.deviceOfIncludingUnfiltered(entityId);
+  const entity = registry3.entityIncludingUnfiltered(entityId);
+  const deviceRegistry = registry3.deviceOfIncludingUnfiltered(entityId);
   return {
     entity_id: entityId,
     state,
@@ -161695,8 +162261,8 @@ var ComposedSensorEndpoint = class _ComposedSensorEndpoint extends Endpoint {
   lastStates = /* @__PURE__ */ new Map();
   debouncedUpdates = /* @__PURE__ */ new Map();
   static async create(config11) {
-    const { registry: registry2, primaryEntityId } = config11;
-    const primaryPayload = buildEntityPayload3(registry2, primaryEntityId);
+    const { registry: registry3, primaryEntityId } = config11;
+    const primaryPayload = buildEntityPayload3(registry3, primaryEntityId);
     if (!primaryPayload) return void 0;
     let parentType = BridgedNodeEndpoint.with(
       BasicInformationServer2,
@@ -161740,7 +162306,7 @@ var ComposedSensorEndpoint = class _ComposedSensorEndpoint extends Endpoint {
     parts.push(tempSub);
     let humSub;
     if (config11.humidityEntityId) {
-      const humPayload = buildEntityPayload3(registry2, config11.humidityEntityId);
+      const humPayload = buildEntityPayload3(registry3, config11.humidityEntityId);
       if (humPayload) {
         humSub = new Endpoint(
           HumiditySubType2.set({
@@ -161754,7 +162320,7 @@ var ComposedSensorEndpoint = class _ComposedSensorEndpoint extends Endpoint {
     let pressSub;
     if (config11.pressureEntityId) {
       const pressPayload = buildEntityPayload3(
-        registry2,
+        registry3,
         config11.pressureEntityId
       );
       if (pressPayload) {
@@ -162708,6 +163274,15 @@ function clearPendingTilt(st) {
   st.pendingTilt = null;
 }
 var coverOptimistic = /* @__PURE__ */ new WeakMap();
+function haRestEnd(action) {
+  if (action.action.includes("open_cover")) {
+    return "open";
+  }
+  if (action.action.includes("close_cover")) {
+    return "close";
+  }
+  return null;
+}
 function getCoverOptimistic(endpoint) {
   let st = coverOptimistic.get(endpoint);
   if (!st) {
@@ -162822,7 +163397,10 @@ var WindowCoveringServerBase = class _WindowCoveringServerBase extends FeaturedB
       if (!entry) {
         return MovementStatus.Stopped;
       }
-      const reachedTarget = positionAware && current100ths != null && existingTarget != null && Math.abs(current100ths - existingTarget) < 100;
+      const getExpected = config11.getExpectedRestPosition;
+      const expectedPercent = entry.expectedRestEnd != null && getExpected != null ? getExpected(entry.expectedRestEnd, this.agent) : null;
+      const goal = expectedPercent != null ? expectedPercent * 100 : existingTarget;
+      const reachedTarget = positionAware && current100ths != null && goal != null && Math.abs(current100ths - goal) < 100;
       const expired = Date.now() - entry.startedAt >= optimisticMovementTimeoutMs;
       if (reachedTarget || expired) {
         clearOptimisticAxis(optimistic, axis);
@@ -162927,7 +163505,7 @@ var WindowCoveringServerBase = class _WindowCoveringServerBase extends FeaturedB
   }
   // Record the optimistic direction and emit it now so a controller gets the
   // moving->stopped edge even when HA never reports a transitional state (#429).
-  startOptimisticMovement(axis, status3) {
+  startOptimisticMovement(axis, status3, expectedRestEnd) {
     const optimistic = getCoverOptimistic(this.endpoint);
     clearOptimisticAxis(optimistic, axis);
     const endpoint = this.endpoint;
@@ -162972,7 +163550,7 @@ var WindowCoveringServerBase = class _WindowCoveringServerBase extends FeaturedB
       })();
     }, optimisticMovementTimeoutMs);
     timer.unref?.();
-    optimistic[axis] = { status: status3, startedAt, timer };
+    optimistic[axis] = { status: status3, startedAt, timer, expectedRestEnd };
     this.writeOperationalStatus({ [axis]: status3 });
   }
   async handleMovement(type, _, direction, targetPercent100ths) {
@@ -163031,17 +163609,25 @@ var WindowCoveringServerBase = class _WindowCoveringServerBase extends FeaturedB
   }
   handleLiftOpen() {
     clearPendingLift(getCoverDebounce(this.endpoint));
-    this.startOptimisticMovement("lift", MovementStatus.Opening);
     const homeAssistant = this.agent.get(HomeAssistantEntityBehavior);
     const action = this.state.config.openCoverLift(void 0, this.agent);
+    this.startOptimisticMovement(
+      "lift",
+      MovementStatus.Opening,
+      haRestEnd(action)
+    );
     logger218.info(`handleLiftOpen: calling action=${action.action}`);
     homeAssistant.callAction(action);
   }
   handleLiftClose() {
     clearPendingLift(getCoverDebounce(this.endpoint));
-    this.startOptimisticMovement("lift", MovementStatus.Closing);
     const homeAssistant = this.agent.get(HomeAssistantEntityBehavior);
     const action = this.state.config.closeCoverLift(void 0, this.agent);
+    this.startOptimisticMovement(
+      "lift",
+      MovementStatus.Closing,
+      haRestEnd(action)
+    );
     logger218.info(`handleLiftClose: calling action=${action.action}`);
     homeAssistant.callAction(action);
   }
@@ -163052,14 +163638,15 @@ var WindowCoveringServerBase = class _WindowCoveringServerBase extends FeaturedB
       return;
     }
     this.state.targetPositionLiftPercent100ths = targetPercent100ths;
-    this.startOptimisticMovement(
-      "lift",
-      currentPositionMatter != null && targetPercent100ths < currentPositionMatter ? MovementStatus.Opening : MovementStatus.Closing
-    );
     const targetPosition = targetPercent100ths / 100;
     const homeAssistant = this.agent.get(HomeAssistantEntityBehavior);
     const action = config11.setLiftPosition(targetPosition, this.agent);
     const entityId = homeAssistant.entityId;
+    this.startOptimisticMovement(
+      "lift",
+      currentPositionMatter != null && targetPercent100ths < currentPositionMatter ? MovementStatus.Opening : MovementStatus.Closing,
+      haRestEnd(action)
+    );
     const actions = this.env.get(HomeAssistantActions);
     const st = getCoverDebounce(this.endpoint);
     st.pendingLift = { action, entityId, actions };
@@ -163092,21 +163679,27 @@ var WindowCoveringServerBase = class _WindowCoveringServerBase extends FeaturedB
     const st = getCoverDebounce(this.endpoint);
     clearPendingTilt(st);
     if (st.pendingLift?.action.action.includes("tilt")) clearPendingLift(st);
-    this.startOptimisticMovement("tilt", MovementStatus.Opening);
-    const homeAssistant = this.agent.get(HomeAssistantEntityBehavior);
-    homeAssistant.callAction(
-      this.state.config.openCoverTilt(void 0, this.agent)
+    const action = this.state.config.openCoverTilt(void 0, this.agent);
+    this.startOptimisticMovement(
+      "tilt",
+      MovementStatus.Opening,
+      haRestEnd(action)
     );
+    const homeAssistant = this.agent.get(HomeAssistantEntityBehavior);
+    homeAssistant.callAction(action);
   }
   handleTiltClose() {
     const st = getCoverDebounce(this.endpoint);
     clearPendingTilt(st);
     if (st.pendingLift?.action.action.includes("tilt")) clearPendingLift(st);
-    this.startOptimisticMovement("tilt", MovementStatus.Closing);
-    const homeAssistant = this.agent.get(HomeAssistantEntityBehavior);
-    homeAssistant.callAction(
-      this.state.config.closeCoverTilt(void 0, this.agent)
+    const action = this.state.config.closeCoverTilt(void 0, this.agent);
+    this.startOptimisticMovement(
+      "tilt",
+      MovementStatus.Closing,
+      haRestEnd(action)
     );
+    const homeAssistant = this.agent.get(HomeAssistantEntityBehavior);
+    homeAssistant.callAction(action);
   }
   handleGoToTiltPosition(targetPercent100ths) {
     const config11 = this.state.config;
@@ -163115,14 +163708,15 @@ var WindowCoveringServerBase = class _WindowCoveringServerBase extends FeaturedB
       return;
     }
     this.state.targetPositionTiltPercent100ths = targetPercent100ths;
-    this.startOptimisticMovement(
-      "tilt",
-      currentPositionMatter != null && targetPercent100ths < currentPositionMatter ? MovementStatus.Opening : MovementStatus.Closing
-    );
     const targetPosition = targetPercent100ths / 100;
     const homeAssistant = this.agent.get(HomeAssistantEntityBehavior);
     const action = config11.setTiltPosition(targetPosition, this.agent);
     const entityId = homeAssistant.entityId;
+    this.startOptimisticMovement(
+      "tilt",
+      currentPositionMatter != null && targetPercent100ths < currentPositionMatter ? MovementStatus.Opening : MovementStatus.Closing,
+      haRestEnd(action)
+    );
     const actions = this.env.get(HomeAssistantActions);
     const st = getCoverDebounce(this.endpoint);
     st.pendingTilt = { action, entityId, actions };
@@ -163264,6 +163858,7 @@ var adjustPositionForWriting2 = (position, agent) => {
   const matterSem = usesMatterSemantics(agent);
   return adjustPositionForWriting(position, featureFlags, matterSem);
 };
+var expectedRestPosition = (end, agent) => adjustPositionForReading2(end === "open" ? 100 : 0, agent);
 var shouldSwapOpenClose = (agent) => {
   const homeAssistant = agent.get(HomeAssistantEntityBehavior);
   const entitySwap = homeAssistant.state.mapping?.coverSwapOpenClose;
@@ -163351,11 +163946,11 @@ var config6 = {
     }
     return position == null ? null : adjustPositionForReading2(position, agent);
   },
+  getExpectedRestPosition: expectedRestPosition,
   getCoverType: (entity) => deviceClassMapping(entity)?.type,
   getEndProductType: (entity) => deviceClassMapping(entity)?.endProductType,
   getMovementStatus: (entity, agent) => {
-    const { featureFlags } = agent.env.get(BridgeDataProvider);
-    const swapped = featureFlags?.coverSwapOpenClose === true;
+    const swapped = shouldSwapOpenClose(agent);
     const coverState = entity.state;
     if (coverState === CoverDeviceState.opening) {
       return swapped ? WindowCovering3.MovementStatus.Closing : WindowCovering3.MovementStatus.Opening;
@@ -167397,6 +167992,284 @@ var ElectricalMeterType = ElectricalMeterDevice.with(
   EnergyServer
 );
 
+// src/matter/endpoints/legacy/sensor/devices/energy-evse.ts
+init_esm();
+init_home_assistant_actions();
+init_home_assistant_entity_behavior();
+
+// src/matter/endpoints/legacy/sensor/devices/evse-status.ts
+function mapEvseStatus(rawState, chargingSwitchOn) {
+  const raw = rawState.toLowerCase().trim();
+  const switchSupply = chargingSwitchOn ? EnergyEvse3.SupplyState.ChargingEnabled : EnergyEvse3.SupplyState.Disabled;
+  if (raw === "" || raw === "unknown" || raw === "unavailable") {
+    return {
+      state: null,
+      supplyState: EnergyEvse3.SupplyState.Disabled,
+      faultState: EnergyEvse3.FaultState.NoError
+    };
+  }
+  if (raw.includes("error") || raw.includes("fault")) {
+    return {
+      state: EnergyEvse3.State.Fault,
+      supplyState: EnergyEvse3.SupplyState.DisabledError,
+      faultState: EnergyEvse3.FaultState.Other
+    };
+  }
+  if (raw.includes("not connected") || raw.includes("not_connected") || raw.includes("disconnected") || raw.includes("no vehicle")) {
+    return {
+      state: EnergyEvse3.State.NotPluggedIn,
+      supplyState: switchSupply,
+      faultState: EnergyEvse3.FaultState.NoError
+    };
+  }
+  if (raw.includes("not charging") || raw.includes("not_charging") || raw.includes("not-charging")) {
+    return {
+      state: EnergyEvse3.State.PluggedInNoDemand,
+      supplyState: switchSupply,
+      faultState: EnergyEvse3.FaultState.NoError
+    };
+  }
+  if (raw.includes("charg") && !raw.includes("discharg")) {
+    return {
+      state: EnergyEvse3.State.PluggedInCharging,
+      supplyState: EnergyEvse3.SupplyState.ChargingEnabled,
+      faultState: EnergyEvse3.FaultState.NoError
+    };
+  }
+  if (raw.includes("connected") || raw.includes("ready") || raw.includes("awaiting") || raw.includes("completed") || raw.includes("sleep") || raw.includes("paused")) {
+    return {
+      state: EnergyEvse3.State.PluggedInNoDemand,
+      supplyState: switchSupply,
+      faultState: EnergyEvse3.FaultState.NoError
+    };
+  }
+  return {
+    state: null,
+    supplyState: EnergyEvse3.SupplyState.Disabled,
+    faultState: EnergyEvse3.FaultState.NoError
+  };
+}
+
+// src/matter/endpoints/legacy/sensor/devices/energy-evse.ts
+var logger229 = Logger.get("EnergyEvse");
+var MIN_CHARGE_CURRENT_MA = 6e3;
+var MAX_CHARGE_CURRENT_MA = 32e3;
+var CIRCUIT_CAPACITY_MA = 32e3;
+var MAX_TIMER_MS = 2147483647;
+function clampMa(ma) {
+  return Math.min(CIRCUIT_CAPACITY_MA, Math.max(MIN_CHARGE_CURRENT_MA, ma));
+}
+var evseChargingTimers = /* @__PURE__ */ new WeakMap();
+function clearEvseChargingTimer(endpoint) {
+  const timer = evseChargingTimers.get(endpoint);
+  if (timer) {
+    clearTimeout(timer);
+    evseChargingTimers.delete(endpoint);
+  }
+}
+var EvseStatusServer = class _EvseStatusServer extends EnergyEvseServer {
+  async initialize() {
+    await super.initialize();
+    const homeAssistant = await this.agent.load(HomeAssistantEntityBehavior);
+    this.update();
+    this.reactTo(homeAssistant.onChange, this.update, { offline: true });
+  }
+  async [Symbol.asyncDispose]() {
+    clearEvseChargingTimer(this.endpoint);
+    await super[Symbol.asyncDispose]();
+  }
+  chargingSwitchIsOn() {
+    const mapping = this.agent.get(HomeAssistantEntityBehavior).state.mapping;
+    const switchEntity = mapping?.chargingSwitchEntity;
+    if (!switchEntity) return false;
+    const stateProvider = this.agent.env.get(EntityStateProvider);
+    return stateProvider.getState(switchEntity)?.state === "on";
+  }
+  update() {
+    const homeAssistant = this.agent.get(HomeAssistantEntityBehavior);
+    const raw = homeAssistant.entity.state?.state ?? "";
+    const status3 = mapEvseStatus(raw, this.chargingSwitchIsOn());
+    const patch = {
+      state: status3.state,
+      supplyState: status3.supplyState,
+      faultState: status3.faultState
+    };
+    const mapping = homeAssistant.state.mapping;
+    if (mapping?.currentLimitEntity) {
+      const stateProvider = this.agent.env.get(EntityStateProvider);
+      const amps = stateProvider.getNumericState(mapping.currentLimitEntity);
+      if (amps != null) {
+        patch.maximumChargeCurrent = clampMa(Math.round(amps * 1e3));
+      }
+    }
+    applyPatchState(this.state, patch);
+  }
+  enableCharging(request) {
+    const homeAssistant = this.agent.get(HomeAssistantEntityBehavior);
+    const mapping = homeAssistant.state.mapping;
+    const until = request.chargingEnabledUntil;
+    if (until != null && until * 1e3 <= Date.now()) {
+      this.disable();
+      return;
+    }
+    clearEvseChargingTimer(this.endpoint);
+    let dispatched = false;
+    if (mapping?.chargingSwitchEntity) {
+      homeAssistant.callAction({
+        action: "switch.turn_on",
+        target: mapping.chargingSwitchEntity
+      });
+      dispatched = true;
+    }
+    const maxCurrent = request.maximumChargeCurrent;
+    if (mapping?.currentLimitEntity && maxCurrent != null) {
+      const amps = Math.max(
+        MIN_CHARGE_CURRENT_MA / 1e3,
+        Math.floor(clampMa(Number(maxCurrent)) / 1e3)
+      );
+      homeAssistant.callAction({
+        action: "number.set_value",
+        target: mapping.currentLimitEntity,
+        data: { value: amps }
+      });
+      dispatched = true;
+    }
+    if (!dispatched) {
+      logger229.debug(
+        `enableCharging ignored for ${homeAssistant.entityId}: no charging switch or current limit mapped`
+      );
+      return;
+    }
+    const patch = {
+      supplyState: EnergyEvse3.SupplyState.ChargingEnabled,
+      chargingEnabledUntil: until ?? null
+    };
+    if (request.minimumChargeCurrent != null) {
+      patch.minimumChargeCurrent = clampMa(
+        Number(request.minimumChargeCurrent)
+      );
+    }
+    if (maxCurrent != null) {
+      patch.maximumChargeCurrent = clampMa(Number(maxCurrent));
+    }
+    applyPatchState(this.state, patch);
+    if (until != null) {
+      const delay = until * 1e3 - Date.now();
+      if (delay > 0 && delay <= MAX_TIMER_MS) {
+        const endpoint = this.endpoint;
+        const actions = this.env.get(HomeAssistantActions);
+        const entityId = homeAssistant.entityId;
+        const switchEntity = mapping?.chargingSwitchEntity;
+        const timer = setTimeout(() => {
+          void (async () => {
+            try {
+              if (evseChargingTimers.get(endpoint) !== timer) return;
+              if (switchEntity) {
+                actions.call(
+                  { action: "switch.turn_off", target: switchEntity },
+                  entityId
+                );
+              }
+              await endpoint.setStateOf(_EvseStatusServer, {
+                supplyState: EnergyEvse3.SupplyState.Disabled,
+                chargingEnabledUntil: null
+              });
+            } catch (error) {
+              logger229.debug(
+                `EVSE charge-window expiry write failed (endpoint may be closing): ${error}`
+              );
+            } finally {
+              if (evseChargingTimers.get(endpoint) === timer) {
+                evseChargingTimers.delete(endpoint);
+              }
+            }
+          })();
+        }, delay);
+        timer.unref?.();
+        evseChargingTimers.set(endpoint, timer);
+      }
+    }
+  }
+  disable() {
+    clearEvseChargingTimer(this.endpoint);
+    const homeAssistant = this.agent.get(HomeAssistantEntityBehavior);
+    const mapping = homeAssistant.state.mapping;
+    if (mapping?.chargingSwitchEntity) {
+      homeAssistant.callAction({
+        action: "switch.turn_off",
+        target: mapping.chargingSwitchEntity
+      });
+    }
+    if (mapping?.chargingSwitchEntity || mapping?.currentLimitEntity) {
+      applyPatchState(this.state, {
+        supplyState: EnergyEvse3.SupplyState.Disabled,
+        chargingEnabledUntil: null
+      });
+    } else {
+      logger229.debug(
+        `disable ignored for ${homeAssistant.entityId}: no charging switch mapped`
+      );
+    }
+  }
+};
+var EvseStatusSeeded = EvseStatusServer.set({
+  supplyState: EnergyEvse3.SupplyState.Disabled,
+  faultState: EnergyEvse3.FaultState.NoError,
+  circuitCapacity: CIRCUIT_CAPACITY_MA,
+  minimumChargeCurrent: MIN_CHARGE_CURRENT_MA,
+  maximumChargeCurrent: MAX_CHARGE_CURRENT_MA
+});
+var EvseModeSeeded = EnergyEvseModeServer.set({
+  supportedModes: [
+    {
+      label: "Manual",
+      mode: 1,
+      modeTags: [{ value: EnergyEvseMode3.ModeTag.Manual }]
+    }
+  ],
+  currentMode: 1
+});
+var WiredPowerSourceBase = PowerSourceServer.with("Wired");
+var EvsePowerSourceServer = class extends WiredPowerSourceBase {
+  async initialize() {
+    await super.initialize();
+    const endpointNumber = this.endpoint.number;
+    if (endpointNumber != null) {
+      applyPatchState(this.state, { endpointList: [endpointNumber] });
+    }
+  }
+};
+var EvsePowerSource = EvsePowerSourceServer.set({
+  status: PowerSource3.PowerSourceStatus.Active,
+  order: 0,
+  description: "Mains",
+  wiredCurrentType: PowerSource3.WiredCurrentType.Ac
+});
+var EnergyEvseBase = EnergyEvseDevice.with(
+  BasicInformationServer2,
+  IdentifyServer2,
+  HomeAssistantEntityBehavior,
+  EvseStatusSeeded,
+  EvseModeSeeded,
+  EvsePowerSource,
+  // Always mount the measurement clusters; both seed safe defaults when no
+  // power/energy entity is mapped, so the endpoint honestly carries the
+  // ElectricalSensor device type.
+  PowerServer,
+  EnergyServer,
+  DescriptorServer
+).set({
+  descriptor: {
+    deviceTypeList: [
+      { deviceType: DeviceTypeId(1292), revision: 2 },
+      { deviceType: DeviceTypeId(1296), revision: 1 }
+    ]
+  }
+});
+function energyEvseType() {
+  return EnergyEvseBase;
+}
+
 // src/matter/behaviors/flow-measurement-server.ts
 init_home_assistant_entity_behavior();
 var FlowMeasurementServerBase = class extends FlowMeasurementServer {
@@ -168136,7 +169009,7 @@ var TvocConcentrationMeasurementServer = class extends TvocConcentrationMeasurem
 };
 
 // src/matter/endpoints/legacy/sensor/devices/tvoc-sensor.ts
-var logger229 = Logger.get("TvocSensor");
+var logger230 = Logger.get("TvocSensor");
 function airQualityFromUgm3(value) {
   if (value <= 300) return AirQuality3.AirQualityEnum.Good;
   if (value <= 1e3) return AirQuality3.AirQualityEnum.Fair;
@@ -168177,17 +169050,17 @@ var TvocAirQualityServer = class extends TvocAirQualityServerBase {
     const attributes9 = entity.state.attributes;
     const deviceClass = attributes9.device_class;
     let airQuality = AirQuality3.AirQualityEnum.Unknown;
-    logger229.debug(
+    logger230.debug(
       `[${entity.entity_id}] TVOC update: state="${state}", device_class="${deviceClass}"`
     );
     if (state != null && !Number.isNaN(+state)) {
       const value = +state;
       airQuality = deviceClass === SensorDeviceClass.volatile_organic_compounds ? airQualityFromUgm3(value) : airQualityFromPpb(value);
-      logger229.debug(
+      logger230.debug(
         `[${entity.entity_id}] TVOC value=${value} (${deviceClass}) -> airQuality=${AirQuality3.AirQualityEnum[airQuality]}`
       );
     } else {
-      logger229.warn(
+      logger230.warn(
         `[${entity.entity_id}] TVOC state not a valid number: "${state}"`
       );
     }
@@ -168401,7 +169274,7 @@ init_home_assistant_entity_behavior();
 // src/matter/behaviors/pm25-concentration-measurement-server.ts
 init_esm();
 init_home_assistant_entity_behavior();
-var logger230 = Logger.get("Pm25ConcentrationMeasurementServer");
+var logger231 = Logger.get("Pm25ConcentrationMeasurementServer");
 var Pm25ConcentrationMeasurementServerBase = Pm25ConcentrationMeasurementServer.with(
   ConcentrationMeasurement3.Feature.NumericMeasurement
 );
@@ -168425,11 +169298,11 @@ var Pm25ConcentrationMeasurementServer2 = class extends Pm25ConcentrationMeasure
     if (this.state.measurementMedium === void 0) {
       this.state.measurementMedium = ConcentrationMeasurement3.MeasurementMedium.Air;
     }
-    logger230.debug(
+    logger231.debug(
       "Pm25ConcentrationMeasurementServer: before super.initialize()"
     );
     await super.initialize();
-    logger230.debug(
+    logger231.debug(
       "Pm25ConcentrationMeasurementServer: after super.initialize()"
     );
     const homeAssistant = await this.agent.load(HomeAssistantEntityBehavior);
@@ -168452,7 +169325,7 @@ var Pm25ConcentrationMeasurementServer2 = class extends Pm25ConcentrationMeasure
 };
 
 // src/matter/endpoints/legacy/sensor/devices/pm25-sensor.ts
-var logger231 = Logger.get("Pm25AirQualityServer");
+var logger232 = Logger.get("Pm25AirQualityServer");
 var Pm25AirQualityServerBase = AirQualityServer.with(
   AirQuality3.Feature.Fair,
   AirQuality3.Feature.Moderate,
@@ -168464,9 +169337,9 @@ var Pm25AirQualityServer = class extends Pm25AirQualityServerBase {
     if (this.state.airQuality === void 0) {
       this.state.airQuality = AirQuality3.AirQualityEnum.Unknown;
     }
-    logger231.debug("Pm25AirQualityServer: before super.initialize()");
+    logger232.debug("Pm25AirQualityServer: before super.initialize()");
     await super.initialize();
-    logger231.debug("Pm25AirQualityServer: after super.initialize()");
+    logger232.debug("Pm25AirQualityServer: after super.initialize()");
     const homeAssistant = await this.agent.load(HomeAssistantEntityBehavior);
     this.update(homeAssistant.entity);
     this.reactTo(homeAssistant.onChange, this.update, { offline: true });
@@ -168891,7 +169764,7 @@ init_home_assistant_entity_behavior();
 init_dist();
 init_esm();
 init_home_assistant_entity_behavior();
-var logger232 = Logger.get("VacuumIdentifyServer");
+var logger233 = Logger.get("VacuumIdentifyServer");
 var IDENTIFY_BUTTON_SUFFIXES = ["_identify", "_locate", "_find_me"];
 var VacuumIdentifyServer = class extends IdentifyServer2 {
   triggerEffect(effect) {
@@ -168908,19 +169781,19 @@ var VacuumIdentifyServer = class extends IdentifyServer2 {
     const homeAssistant = this.agent.get(HomeAssistantEntityBehavior);
     const features3 = homeAssistant.entity.state.attributes.supported_features ?? 0;
     if (testBit(features3, VacuumDeviceFeature.LOCATE)) {
-      logger232.info(`${source} \u2192 vacuum.locate for ${homeAssistant.entityId}`);
+      logger233.info(`${source} \u2192 vacuum.locate for ${homeAssistant.entityId}`);
       homeAssistant.callAction({ action: "vacuum.locate" });
       return;
     }
     const sibling = this.#findIdentifyButton(homeAssistant);
     if (sibling) {
-      logger232.info(
+      logger233.info(
         `${source} \u2192 button.press ${sibling} for ${homeAssistant.entityId}`
       );
       homeAssistant.callAction({ action: "button.press", target: sibling });
       return;
     }
-    logger232.warn(
+    logger233.warn(
       `${source} for ${homeAssistant.entityId}, LOCATE not in supported_features (${features3}), trying vacuum.locate anyway`
     );
     homeAssistant.callAction({ action: "vacuum.locate" });
@@ -168928,8 +169801,8 @@ var VacuumIdentifyServer = class extends IdentifyServer2 {
   #findIdentifyButton(homeAssistant) {
     const deviceId = homeAssistant.entity.registry?.device_id;
     if (!deviceId) return void 0;
-    const registry2 = this.env.get(HomeAssistantRegistry);
-    for (const entity of Object.values(registry2.entities)) {
+    const registry3 = this.env.get(HomeAssistantRegistry);
+    for (const entity of Object.values(registry3.entities)) {
       if (entity.device_id !== deviceId) continue;
       if (!entity.entity_id.startsWith("button.")) continue;
       const uniqueId = entity.unique_id ?? "";
@@ -169119,14 +169992,14 @@ init_esm();
 
 // src/matter/behaviors/service-area-server.ts
 init_esm();
-var logger233 = Logger.get("ServiceAreaServer");
+var logger234 = Logger.get("ServiceAreaServer");
 var ServiceAreaWithProgress = ServiceAreaBehavior.with(
   ServiceArea3.Feature.ProgressReporting
 );
 var ServiceAreaServerBase = class extends ServiceAreaWithProgress {
   selectAreas(request) {
     const { newAreas } = request;
-    logger233.info(
+    logger234.info(
       `ServiceArea selectAreas called with: ${JSON.stringify(newAreas)}`
     );
     const uniqueAreas = [...new Set(newAreas)];
@@ -169135,7 +170008,7 @@ var ServiceAreaServerBase = class extends ServiceAreaWithProgress {
       (id) => !supportedAreaIds.includes(id)
     );
     if (invalidAreas.length > 0) {
-      logger233.warn(`Invalid area IDs requested: ${invalidAreas.join(", ")}`);
+      logger234.warn(`Invalid area IDs requested: ${invalidAreas.join(", ")}`);
       return {
         status: ServiceArea3.SelectAreasStatus.UnsupportedArea,
         statusText: `Invalid area IDs: ${invalidAreas.join(", ")}`
@@ -169147,7 +170020,7 @@ var ServiceAreaServerBase = class extends ServiceAreaWithProgress {
       status: ServiceArea3.OperationalStatus.Pending
     }));
     this.state.currentArea = null;
-    logger233.info(
+    logger234.info(
       `ServiceArea: Stored ${uniqueAreas.length} areas for cleaning: ${uniqueAreas.join(", ")}`
     );
     return {
@@ -169168,7 +170041,7 @@ var ServiceAreaServerBase = class extends ServiceAreaWithProgress {
   ServiceAreaServerBase2.State = State;
 })(ServiceAreaServerBase || (ServiceAreaServerBase = {}));
 function ServiceAreaServer2(initialState) {
-  logger233.info(
+  logger234.info(
     `Creating ServiceAreaServer with ${initialState.supportedAreas.length} areas`
   );
   return ServiceAreaServerBase.set({
@@ -169185,7 +170058,7 @@ var ServiceAreaWithMapsAndProgress = ServiceAreaBehavior.with(
 var ServiceAreaServerWithMapsBase = class extends ServiceAreaWithMapsAndProgress {
   selectAreas(request) {
     const { newAreas } = request;
-    logger233.info(
+    logger234.info(
       `ServiceArea selectAreas called with: ${JSON.stringify(newAreas)}`
     );
     const uniqueAreas = [...new Set(newAreas)];
@@ -169194,7 +170067,7 @@ var ServiceAreaServerWithMapsBase = class extends ServiceAreaWithMapsAndProgress
       (id) => !supportedAreaIds.includes(id)
     );
     if (invalidAreas.length > 0) {
-      logger233.warn(`Invalid area IDs requested: ${invalidAreas.join(", ")}`);
+      logger234.warn(`Invalid area IDs requested: ${invalidAreas.join(", ")}`);
       return {
         status: ServiceArea3.SelectAreasStatus.UnsupportedArea,
         statusText: `Invalid area IDs: ${invalidAreas.join(", ")}`
@@ -169206,7 +170079,7 @@ var ServiceAreaServerWithMapsBase = class extends ServiceAreaWithMapsAndProgress
       status: ServiceArea3.OperationalStatus.Pending
     }));
     this.state.currentArea = null;
-    logger233.info(
+    logger234.info(
       `ServiceArea: Stored ${uniqueAreas.length} areas for cleaning: ${uniqueAreas.join(", ")}`
     );
     return {
@@ -169227,14 +170100,14 @@ var ServiceAreaServerWithMapsBase = class extends ServiceAreaWithMapsAndProgress
   ServiceAreaServerWithMapsBase2.State = State;
 })(ServiceAreaServerWithMapsBase || (ServiceAreaServerWithMapsBase = {}));
 function ServiceAreaServerWithMaps(initialState) {
-  logger233.info(
+  logger234.info(
     `Creating ServiceAreaServer with Maps: ${initialState.supportedAreas.length} areas, ${initialState.supportedMaps.length} maps`
   );
   for (const map of initialState.supportedMaps) {
     const areaCount = initialState.supportedAreas.filter(
       (a) => a.mapId === map.mapId
     ).length;
-    logger233.info(`  Map ${map.mapId}: "${map.name}" (${areaCount} areas)`);
+    logger234.info(`  Map ${map.mapId}: "${map.name}" (${areaCount} areas)`);
   }
   return ServiceAreaServerWithMapsBase.set({
     supportedAreas: initialState.supportedAreas,
@@ -169246,7 +170119,7 @@ function ServiceAreaServerWithMaps(initialState) {
 }
 
 // src/matter/endpoints/legacy/vacuum/behaviors/vacuum-service-area-server.ts
-var logger234 = Logger.get("VacuumServiceAreaServer");
+var logger235 = Logger.get("VacuumServiceAreaServer");
 function toAreaId(roomId) {
   if (typeof roomId === "number") {
     return roomId;
@@ -169325,13 +170198,13 @@ function createVacuumServiceAreaServer(attributes9, roomEntities, includeUnnamed
   let rooms;
   if (roomEntities && roomEntities.length > 0) {
     rooms = buttonEntitiesToRooms(roomEntities, attributes9);
-    logger234.info(
+    logger235.info(
       `Using ${rooms.length} button entities as rooms: ${rooms.map((r) => r.name).join(", ")}`
     );
   } else {
     rooms = parseVacuumRooms(attributes9, includeUnnamedRooms);
     if (rooms.length > 0) {
-      logger234.info(
+      logger235.info(
         `Using ${rooms.length} rooms from attributes: ${rooms.map((r) => r.name).join(", ")}`
       );
     }
@@ -169385,7 +170258,7 @@ function createCustomServiceAreaServer(customAreas) {
       landmarkInfo: null
     }
   }));
-  logger234.info(
+  logger235.info(
     `Using ${customAreas.length} custom service areas: ${customAreas.map((a) => a.name).join(", ")}`
   );
   return ServiceAreaServer2({
@@ -169407,7 +170280,7 @@ function createCleanAreaServiceAreaServer(cleanAreaRooms) {
       landmarkInfo: null
     }
   }));
-  logger234.info(
+  logger235.info(
     `Using ${cleanAreaRooms.length} HA areas via CLEAN_AREA: ${cleanAreaRooms.map((r) => r.name).join(", ")}`
   );
   return ServiceAreaServer2({
@@ -169418,11 +170291,11 @@ function createCleanAreaServiceAreaServer(cleanAreaRooms) {
 }
 
 // src/matter/endpoints/legacy/vacuum/behaviors/vacuum-rvc-run-mode-server.ts
-var logger235 = Logger.get("VacuumRvcRunModeServer");
+var logger236 = Logger.get("VacuumRvcRunModeServer");
 function buildValetudoSegmentAction(vacuumEntityId, segmentIds, valetudoIdentifier) {
   const identifier = valetudoIdentifier || vacuumEntityId.replace(/^vacuum\.valetudo_/, "");
   const topic = `valetudo/${identifier}/MapSegmentationCapability/clean/set`;
-  logger235.info(
+  logger236.info(
     `Valetudo: mqtt.publish to ${topic}, segments: ${segmentIds.join(", ")}`
   );
   return {
@@ -169527,14 +170400,14 @@ function mergeBatchData(areas) {
 function handleCustomServiceAreas(selectedAreas, customAreas, session) {
   const matched = selectedAreas.map((areaId) => ({ areaId, area: customAreas[areaId - 1] })).filter((m) => !!m.area);
   if (matched.length === 0) {
-    logger235.warn(
+    logger236.warn(
       `Custom service areas: no match for selected IDs ${selectedAreas.join(", ")}`
     );
     return { action: "vacuum.start" };
   }
   const batchArea = matched.find(({ area }) => area.batchDispatch === true);
   if (batchArea) {
-    logger235.info(
+    logger236.info(
       `Custom service areas (batch): single call for ${matched.length} room(s): ${matched.map(({ area }) => area.name).join(", ")}`
     );
     session.pendingDispatches = [];
@@ -169555,7 +170428,7 @@ function handleCustomServiceAreas(selectedAreas, customAreas, session) {
       }
     };
   }
-  logger235.info(
+  logger236.info(
     `Custom service areas: ${matched.length} room(s) queued: ${matched.map(({ area }) => `${area.service} (${area.name})`).join(", ")}`
   );
   session.pendingDispatches = matched.slice(1).map(({ areaId, area }) => ({
@@ -169579,20 +170452,22 @@ function resolveCleanAreaIds(selectedAreas, cleanAreaRooms) {
   }
   return haAreaIds;
 }
+var cleaningStates = [
+  VacuumState.cleaning,
+  VacuumState.segment_cleaning,
+  VacuumState.zone_cleaning,
+  VacuumState.spot_cleaning,
+  VacuumState.mop_cleaning,
+  VacuumState.paused
+];
+function vacuumIsCleaning(state) {
+  return state != null && cleaningStates.includes(state);
+}
 var vacuumRvcRunModeConfig = {
   getCurrentMode: (entity) => {
-    const state = entity.state;
-    const cleaningStates = [
-      VacuumState.cleaning,
-      VacuumState.segment_cleaning,
-      VacuumState.zone_cleaning,
-      VacuumState.spot_cleaning,
-      VacuumState.mop_cleaning,
-      VacuumState.paused
-    ];
-    const isCleaning = cleaningStates.includes(state);
-    logger235.debug(
-      `Vacuum state: "${state}", isCleaning: ${isCleaning}, currentMode: ${isCleaning ? "Cleaning" : "Idle"}`
+    const isCleaning = vacuumIsCleaning(entity.state);
+    logger236.debug(
+      `Vacuum state: "${entity.state}", isCleaning: ${isCleaning}, currentMode: ${isCleaning ? "Cleaning" : "Idle"}`
     );
     return isCleaning ? 1 /* Cleaning */ : 0 /* Idle */;
   },
@@ -169625,7 +170500,7 @@ var vacuumRvcRunModeConfig = {
         if (cleanAreaRooms && cleanAreaRooms.length > 0) {
           const haAreaIds = resolveCleanAreaIds(selectedAreas, cleanAreaRooms);
           if (haAreaIds.length > 0) {
-            logger235.info(
+            logger236.info(
               `CLEAN_AREA: cleaning HA areas: ${haAreaIds.join(", ")}`
             );
             return {
@@ -169644,7 +170519,7 @@ var vacuumRvcRunModeConfig = {
             }
           }
           if (matched.length > 0) {
-            logger235.info(
+            logger236.info(
               `Roborock: ${matched.length} room button(s) queued: ${matched.map((m) => m.entityId).join(", ")}`
             );
             session.pendingDispatches = matched.slice(1).map(({ areaId, entityId }) => ({
@@ -169678,14 +170553,14 @@ var vacuumRvcRunModeConfig = {
           }
         }
         if (roomIds.length > 0) {
-          logger235.info(
+          logger236.info(
             `Starting cleaning with selected areas: ${roomIds.join(", ")}`
           );
           if (isDreameVacuum(attributes9)) {
             if (targetMapName) {
               const vacName = vacuumEntityId.replace("vacuum.", "");
               const selectedMapEntity = `select.${vacName}_selected_map`;
-              logger235.info(
+              logger236.info(
                 `Dreame multi-floor: switching to map "${targetMapName}" via ${selectedMapEntity}`
               );
               homeAssistant.callAction({
@@ -169712,7 +170587,7 @@ var vacuumRvcRunModeConfig = {
           }
           if (isEcovacsVacuum(attributes9)) {
             const roomIdStr = roomIds.join(",");
-            logger235.info(
+            logger236.info(
               `Ecovacs vacuum: Using spot_area for rooms: ${roomIdStr}`
             );
             return {
@@ -169727,14 +170602,14 @@ var vacuumRvcRunModeConfig = {
               }
             };
           }
-          logger235.warn(
+          logger236.warn(
             `Room cleaning via send_command not supported for this vacuum type. Rooms: ${roomIds.join(", ")}. Falling back to vacuum.start`
           );
         }
       }
     } catch {
     }
-    logger235.info("Starting regular cleaning (no areas selected)");
+    logger236.info("Starting regular cleaning (no areas selected)");
     return { action: "vacuum.start" };
   },
   returnToBase: () => ({ action: "vacuum.return_to_base" }),
@@ -169749,7 +170624,7 @@ var vacuumRvcRunModeConfig = {
     const homeAssistant = agent.get(HomeAssistantEntityBehavior);
     const entity = homeAssistant.entity;
     const attributes9 = entity.state.attributes;
-    logger235.info(`cleanRoom called: roomMode=${roomMode}`);
+    logger236.info(`cleanRoom called: roomMode=${roomMode}`);
     const cleanAreaRooms = homeAssistant.state.mapping?.cleanAreaRooms;
     if (cleanAreaRooms && cleanAreaRooms.length > 0) {
       const sorted = [...cleanAreaRooms].sort(
@@ -169758,7 +170633,7 @@ var vacuumRvcRunModeConfig = {
       const areaIndex = roomMode - ROOM_MODE_BASE2 - 1;
       if (areaIndex >= 0 && areaIndex < sorted.length) {
         const area = sorted[areaIndex];
-        logger235.info(
+        logger236.info(
           `cleanRoom: CLEAN_AREA "${area.name}" \u2192 vacuum.clean_area(${area.haAreaId})`
         );
         return {
@@ -169775,7 +170650,7 @@ var vacuumRvcRunModeConfig = {
       const areaIndex = roomMode - ROOM_MODE_BASE2 - 1;
       if (areaIndex >= 0 && areaIndex < sorted.length) {
         const area = sorted[areaIndex];
-        logger235.info(
+        logger236.info(
           `cleanRoom: custom service area "${area.name}" \u2192 ${area.service}`
         );
         return {
@@ -169796,7 +170671,7 @@ var vacuumRvcRunModeConfig = {
     }
     const rooms = parseVacuumRooms(attributes9);
     const numericIdFromMode = getRoomIdFromMode(roomMode);
-    logger235.info(
+    logger236.info(
       `cleanRoom: numericIdFromMode=${numericIdFromMode}, available rooms: ${JSON.stringify(rooms.map((r) => ({ id: r.id, name: r.name, modeValue: getRoomModeValue(r) })))}`
     );
     const room = rooms.find((r) => getRoomModeValue(r) === roomMode);
@@ -169806,7 +170681,7 @@ var vacuumRvcRunModeConfig = {
         if (room.mapName) {
           const vacuumName = vacuumEntityId.replace("vacuum.", "");
           const selectedMapEntity = `select.${vacuumName}_selected_map`;
-          logger235.info(
+          logger236.info(
             `Dreame multi-floor: switching to map "${room.mapName}" via ${selectedMapEntity}`
           );
           homeAssistant.callAction({
@@ -169815,7 +170690,7 @@ var vacuumRvcRunModeConfig = {
             data: { option: room.mapName }
           });
         }
-        logger235.debug(
+        logger236.debug(
           `Dreame vacuum detected, using dreame_vacuum.vacuum_clean_segment for room ${room.name} (commandId: ${commandId3}, id: ${room.id})`
         );
         return {
@@ -169826,7 +170701,7 @@ var vacuumRvcRunModeConfig = {
         };
       }
       if (isRoborockVacuum(attributes9) || isXiaomiMiotVacuum(attributes9)) {
-        logger235.debug(
+        logger236.debug(
           `Using vacuum.send_command with app_segment_clean for room ${room.name} (commandId: ${commandId3}, id: ${room.id})`
         );
         return {
@@ -169839,7 +170714,7 @@ var vacuumRvcRunModeConfig = {
       }
       if (isEcovacsVacuum(attributes9)) {
         const roomIdStr = String(commandId3);
-        logger235.info(
+        logger236.info(
           `Ecovacs vacuum: Using spot_area for room ${room.name} (id: ${roomIdStr})`
         );
         return {
@@ -169854,7 +170729,7 @@ var vacuumRvcRunModeConfig = {
           }
         };
       }
-      logger235.warn(
+      logger236.warn(
         `Room cleaning via send_command not supported for this vacuum type. Room: ${room.name} (id=${commandId3}). Falling back to vacuum.start`
       );
     }
@@ -169871,20 +170746,20 @@ function createVacuumRvcRunModeServer(attributes9, includeUnnamedRooms = false,
     customAreas,
     disableRoomModes
   );
-  logger235.info(
+  logger236.info(
     `Creating VacuumRvcRunModeServer with ${rooms.length} rooms, ${supportedModes2.length} total modes`
   );
   if (rooms.length > 0) {
-    logger235.info(`Rooms found: ${rooms.map((r) => r.name).join(", ")}`);
+    logger236.info(`Rooms found: ${rooms.map((r) => r.name).join(", ")}`);
   }
   if (filteredCount > 0) {
     const filtered = allRooms.filter((r) => !rooms.some((x) => x.id === r.id));
-    logger235.info(
+    logger236.info(
       `Filtered out ${filteredCount} unnamed room(s): ${filtered.map((r) => r.name).join(", ")}`
     );
   }
   if (allRooms.length === 0) {
-    logger235.debug(
+    logger236.debug(
       `No rooms found. Attributes: rooms=${JSON.stringify(attributes9.rooms)}, segments=${JSON.stringify(attributes9.segments)}, room_list=${attributes9.room_list}`
     );
   }
@@ -169918,7 +170793,7 @@ function createCleanAreaRvcRunModeServer(cleanAreaRooms) {
       modeTags: [{ value: RvcRunMode3.ModeTag.Cleaning }]
     });
   }
-  logger235.info(
+  logger236.info(
     `Creating CLEAN_AREA RvcRunModeServer with ${cleanAreaRooms.length} HA areas, ${modes.length} total modes`
   );
   return RvcRunModeServer2(vacuumRvcRunModeConfig, {
@@ -169926,11 +170801,12 @@ function createCleanAreaRvcRunModeServer(cleanAreaRooms) {
     currentMode: 0 /* Idle */
   });
 }
-var VacuumRvcRunModeServer = RvcRunModeServer2(vacuumRvcRunModeConfig);
 
 // src/matter/endpoints/legacy/vacuum/behaviors/vacuum-on-off-server.ts
 var VacuumOnOffServer = OnOffServer2({
-  isOn: (_, agent) => agent.get(VacuumRvcRunModeServer).state.currentMode === 1 /* Cleaning */,
+  // Derive from the entity directly. Reading the sibling rvcRunMode behavior
+  // crashed with a class mismatch and would lag one tick behind anyway (#428).
+  isOn: (entity) => vacuumIsCleaning(entity.state),
   turnOn: () => ({ action: "vacuum.start" }),
   turnOff: () => ({ action: "vacuum.return_to_base" })
 }).with();
@@ -170007,7 +170883,7 @@ init_nodejs();
 
 // src/matter/behaviors/rvc-clean-mode-server.ts
 init_home_assistant_entity_behavior();
-var logger236 = Logger.get("RvcCleanModeServerBase");
+var logger237 = Logger.get("RvcCleanModeServerBase");
 var RvcCleanModeServerBase = class _RvcCleanModeServerBase extends RvcCleanModeServer {
   // Pending mode from a recent changeToMode command.
   // Prevents stale HA state (from a different entity like select.xxx)
@@ -170054,14 +170930,14 @@ var RvcCleanModeServerBase = class _RvcCleanModeServerBase extends RvcCleanModeS
     const homeAssistant = this.agent.get(HomeAssistantEntityBehavior);
     const { newMode } = request;
     if (newMode !== this.state.currentMode && !this.state.supportedModes.some((m) => m.mode === newMode)) {
-      logger236.warn(`changeToMode(${newMode}) rejected: unsupported mode`);
+      logger237.warn(`changeToMode(${newMode}) rejected: unsupported mode`);
       return {
         status: ModeBase3.ModeChangeStatus.UnsupportedMode,
         statusText: `Unsupported mode: ${newMode}`
       };
     }
     const modeLabel = this.state.supportedModes.find((m) => m.mode === newMode);
-    logger236.info(
+    logger237.info(
       `changeToMode(${newMode}) "${modeLabel?.label ?? "unknown"}" for ${homeAssistant.entityId}`
     );
     this.pendingMode = newMode;
@@ -170069,7 +170945,7 @@ var RvcCleanModeServerBase = class _RvcCleanModeServerBase extends RvcCleanModeS
     this.state.currentMode = newMode;
     const action = this.state.config.setCleanMode(newMode, this.agent);
     if (action) {
-      logger236.info(
+      logger237.info(
         `changeToMode: dispatching action ${action.action} \u2192 ${action.target ?? homeAssistant.entityId}`
       );
       homeAssistant.callAction(action);
@@ -170102,7 +170978,7 @@ function RvcCleanModeServer2(config11, initialState) {
 }
 
 // src/matter/endpoints/legacy/vacuum/behaviors/vacuum-rvc-clean-mode-server.ts
-var logger237 = Logger.get("VacuumRvcCleanModeServer");
+var logger238 = Logger.get("VacuumRvcCleanModeServer");
 var MODE_VACUUM = 0;
 var MODE_VACUUM_AND_MOP = 1;
 var MODE_MOP = 2;
@@ -170372,7 +171248,7 @@ function findMatchingCleanOption(ct, availableOptions) {
     const match = availableOptions.find((o) => classifyCleanOption(o) === type);
     if (match) return match;
   }
-  logger237.warn(
+  logger238.warn(
     `No match for ${CLEAN_TYPE_LABELS[ct]} in [${availableOptions.join(", ")}]`
   );
   return availableOptions[0];
@@ -170381,7 +171257,7 @@ function buildCleaningModeAction(targetCleanType, agent) {
   const selectEntityId = getCleaningModeSelectEntity(agent);
   const { options } = readSelectEntity(selectEntityId, agent);
   const optionToUse = findMatchingCleanOption(targetCleanType, options);
-  logger237.info(
+  logger238.info(
     `Switching cleaning mode to: ${optionToUse} via ${selectEntityId}`
   );
   return {
@@ -170470,7 +171346,7 @@ function createCleanModeConfig(fanSpeedList, mopIntensityList, cleaningModeOptio
           }
         }
         if (speedMode !== void 0) {
-          logger237.debug(
+          logger238.debug(
             `Current mode: Vacuum + fan_speed="${speedState}" -> mode ${speedMode}`
           );
           return speedMode;
@@ -170491,7 +171367,7 @@ function createCleanModeConfig(fanSpeedList, mopIntensityList, cleaningModeOptio
           }
         }
         if (mopMode !== void 0) {
-          logger237.debug(
+          logger238.debug(
             `Current mode: Mop + intensity="${state}" -> mode ${mopMode}`
           );
           return mopMode;
@@ -170509,14 +171385,14 @@ function createCleanModeConfig(fanSpeedList, mopIntensityList, cleaningModeOptio
       const homeAssistant = agent.get(HomeAssistantEntityBehavior);
       const vacuumEntityId = homeAssistant.entityId;
       const mapping = homeAssistant.state.mapping;
-      logger237.info(
+      logger238.info(
         `setCleanMode(${mode}) for ${vacuumEntityId}, suctionEntity=${mapping?.suctionLevelEntity ?? "none"}, mopEntity=${mapping?.mopIntensityEntity ?? "none"}, fanSpeedList=${JSON.stringify(fanSpeedList ?? [])}, mopIntensityList=${JSON.stringify(mopIntensityList ?? [])}, customTags=${JSON.stringify(customFanSpeedTags ?? {})}`
       );
       if (mopIntensityList && mopIntensityList.length > 0 && isMopIntensityMode(mode)) {
         const mopIndex = mode - MOP_INTENSITY_MODE_BASE;
         const mopName = mopIntensityList[mopIndex];
         if (!mopName) {
-          logger237.warn(`Invalid mop intensity mode index: ${mopIndex}`);
+          logger238.warn(`Invalid mop intensity mode index: ${mopIndex}`);
           return void 0;
         }
         if (hasCleanTypes) {
@@ -170529,18 +171405,18 @@ function createCleanModeConfig(fanSpeedList, mopIntensityList, cleaningModeOptio
             mapping.mopIntensityEntity,
             agent
           );
-          logger237.info(
+          logger238.info(
             `Mop intensity entity ${mapping.mopIntensityEntity}: current="${state}", options=${JSON.stringify(options ?? [])}`
           );
           let option = matchMopIntensityOption(mopName, options);
           if (!option && options && mopIndex < options.length) {
             option = options[mopIndex];
-            logger237.info(
+            logger238.info(
               `Positional match for mop "${mopName}" -> "${option}" (index ${mopIndex})`
             );
           }
           if (option) {
-            logger237.info(
+            logger238.info(
               `Setting mop intensity to: ${option} via ${mapping.mopIntensityEntity}`
             );
             return {
@@ -170549,11 +171425,11 @@ function createCleanModeConfig(fanSpeedList, mopIntensityList, cleaningModeOptio
               target: mapping.mopIntensityEntity
             };
           }
-          logger237.warn(
+          logger238.warn(
             `No match for mop intensity "${mopName}" in options: [${(options ?? []).join(", ")}]`
           );
         } else {
-          logger237.warn(
+          logger238.warn(
             `Mop intensity mode ${mode} requested but no mopIntensityEntity configured`
           );
         }
@@ -170563,7 +171439,7 @@ function createCleanModeConfig(fanSpeedList, mopIntensityList, cleaningModeOptio
         const fanSpeedIndex = mode - FAN_SPEED_MODE_BASE;
         const fanSpeedName = fanSpeedList[fanSpeedIndex];
         if (!fanSpeedName) {
-          logger237.warn(`Invalid fan speed mode index: ${fanSpeedIndex}`);
+          logger238.warn(`Invalid fan speed mode index: ${fanSpeedIndex}`);
           return void 0;
         }
         if (mapping?.suctionLevelEntity) {
@@ -170576,7 +171452,7 @@ function createCleanModeConfig(fanSpeedList, mopIntensityList, cleaningModeOptio
             mapping.suctionLevelEntity,
             agent
           );
-          logger237.info(
+          logger238.info(
             `Suction entity ${mapping.suctionLevelEntity}: current="${state}", options=${JSON.stringify(options ?? [])}`
           );
           let option = matchFanSpeedOption(
@@ -170586,12 +171462,12 @@ function createCleanModeConfig(fanSpeedList, mopIntensityList, cleaningModeOptio
           );
           if (!option && options && fanSpeedIndex < options.length) {
             option = options[fanSpeedIndex];
-            logger237.info(
+            logger238.info(
               `Positional match for fan "${fanSpeedName}" -> "${option}" (index ${fanSpeedIndex})`
             );
           }
           if (option) {
-            logger237.info(
+            logger238.info(
               `Setting suction to: ${option} via ${mapping.suctionLevelEntity}`
             );
             return {
@@ -170600,7 +171476,7 @@ function createCleanModeConfig(fanSpeedList, mopIntensityList, cleaningModeOptio
               target: mapping.suctionLevelEntity
             };
           }
-          logger237.warn(
+          logger238.warn(
             `No match for fan speed "${fanSpeedName}" in suction options: [${(options ?? []).join(", ")}]`
           );
           return void 0;
@@ -170610,7 +171486,7 @@ function createCleanModeConfig(fanSpeedList, mopIntensityList, cleaningModeOptio
             buildCleaningModeAction(0 /* Sweeping */, agent)
           );
         }
-        logger237.info(
+        logger238.info(
           `Setting fan speed to: ${fanSpeedName} via vacuum.set_fan_speed`
         );
         return {
@@ -170620,7 +171496,7 @@ function createCleanModeConfig(fanSpeedList, mopIntensityList, cleaningModeOptio
         };
       }
       if (!hasCleanTypes) {
-        logger237.debug(
+        logger238.debug(
           `Ignoring cleaning type change (mode=${mode}): no cleaning mode entity`
         );
         return void 0;
@@ -170632,7 +171508,7 @@ function createCleanModeConfig(fanSpeedList, mopIntensityList, cleaningModeOptio
         agent
       );
       const optionToUse = findMatchingCleanOption(cleanType, availableOptions);
-      logger237.info(
+      logger238.info(
         `Setting cleaning mode to: ${optionToUse} (mode=${mode}) via ${selectEntityId}`
       );
       return {
@@ -170650,10 +171526,10 @@ function createVacuumRvcCleanModeServer(_attributes, fanSpeedList, mopIntensityL
     cleaningModeOptions,
     customFanSpeedTags
   );
-  logger237.info(
+  logger238.info(
     `Creating VacuumRvcCleanModeServer with ${supportedModes2.length} modes (fanSpeedList=${JSON.stringify(fanSpeedList ?? [])}, mopIntensityList=${JSON.stringify(mopIntensityList ?? [])}, cleaningModeOptions=${JSON.stringify(cleaningModeOptions ?? [])}, customTags=${JSON.stringify(customFanSpeedTags ?? {})})`
   );
-  logger237.info(
+  logger238.info(
     `Modes: ${supportedModes2.map((m) => `${m.mode}:${m.label}[${m.modeTags.map((t) => t.value).join(",")}]`).join(", ")}`
   );
   const initialState = {
@@ -170716,7 +171592,7 @@ function resolveMopIntensityList(mopIntensityEntity) {
 init_dist();
 init_esm();
 init_home_assistant_entity_behavior();
-var logger238 = Logger.get("VacuumRvcOperationalStateServer");
+var logger239 = Logger.get("VacuumRvcOperationalStateServer");
 function batteryFromAttributes(attrs) {
   const raw = attrs.battery_level ?? attrs.battery;
   if (raw == null) return null;
@@ -170743,7 +171619,7 @@ function isDockedCharging(entity, batteryPercent) {
 }
 function mapVacuumOperationalState(entity, batteryPercent = batteryFromAttributes(entity.attributes), chargingState = null) {
   const state = entity.state;
-  const cleaningStates = [
+  const cleaningStates2 = [
     VacuumState.cleaning,
     VacuumState.segment_cleaning,
     VacuumState.zone_cleaning,
@@ -170756,7 +171632,7 @@ function mapVacuumOperationalState(entity, batteryPercent = batteryFromAttribute
     operationalState = charging ? RvcOperationalState4.OperationalState.Charging : RvcOperationalState4.OperationalState.Docked;
   } else if (state === VacuumState.returning) {
     operationalState = RvcOperationalState4.OperationalState.SeekingCharger;
-  } else if (cleaningStates.includes(state)) {
+  } else if (cleaningStates2.includes(state)) {
     operationalState = RvcOperationalState4.OperationalState.Running;
   } else if (state === VacuumState.paused) {
     operationalState = RvcOperationalState4.OperationalState.Paused;
@@ -170767,16 +171643,16 @@ function mapVacuumOperationalState(entity, batteryPercent = batteryFromAttribute
     operationalState = RvcOperationalState4.OperationalState.Error;
   } else {
     if (state.toLowerCase().includes("clean")) {
-      logger238.info(
+      logger239.info(
         `Unknown vacuum state "${state}" contains 'clean', treating as Running`
       );
       operationalState = RvcOperationalState4.OperationalState.Running;
     } else {
-      logger238.info(`Unknown vacuum state "${state}", treating as Stopped`);
+      logger239.info(`Unknown vacuum state "${state}", treating as Stopped`);
       operationalState = RvcOperationalState4.OperationalState.Stopped;
     }
   }
-  logger238.debug(
+  logger239.debug(
     `Vacuum operationalState: "${state}" -> ${RvcOperationalState4.OperationalState[operationalState]}`
   );
   return operationalState;
@@ -170805,7 +171681,7 @@ var VacuumRvcOperationalStateServer = RvcOperationalStateServer2({
 });
 
 // src/matter/endpoints/legacy/vacuum/index.ts
-var logger239 = Logger.get("VacuumDevice");
+var logger240 = Logger.get("VacuumDevice");
 var VacuumEndpointType = RoboticVacuumCleanerDevice.with(
   BasicInformationServer2,
   VacuumIdentifyServer,
@@ -170819,7 +171695,7 @@ function VacuumDevice(homeAssistantEntity, includeOnOff = false, cleaningModeOpt
   const entityId = homeAssistantEntity.entity.entity_id;
   const attributes9 = homeAssistantEntity.entity.state.attributes;
   const customAreas = homeAssistantEntity.mapping?.customServiceAreas;
-  logger239.info(
+  logger240.info(
     `Creating vacuum endpoint for ${entityId}, mapping: ${JSON.stringify(homeAssistantEntity.mapping ?? "none")}`
   );
   const cleanAreaRooms = homeAssistantEntity.mapping?.cleanAreaRooms;
@@ -170832,32 +171708,32 @@ function VacuumDevice(homeAssistantEntity, includeOnOff = false, cleaningModeOpt
     )
   ).set({ homeAssistantEntity });
   if (includeOnOff) {
-    logger239.info(`${entityId}: Adding OnOff cluster (vacuumOnOff flag enabled)`);
+    logger240.info(`${entityId}: Adding OnOff cluster (vacuumOnOff flag enabled)`);
     device = device.with(VacuumOnOffServer);
   }
   device = device.with(VacuumPowerSourceServer);
   const roomEntities = homeAssistantEntity.mapping?.roomEntities;
   const rooms = parseVacuumRooms(attributes9);
-  logger239.info(
+  logger240.info(
     `${entityId}: customAreas=${customAreas?.length ?? 0}, roomEntities=${JSON.stringify(roomEntities ?? [])}, parsedRooms=${rooms.length}, cleanAreaRooms=${cleanAreaRooms?.length ?? 0}`
   );
   if (cleanAreaRooms && cleanAreaRooms.length > 0) {
-    logger239.info(
+    logger240.info(
       `${entityId}: Adding ServiceArea (${cleanAreaRooms.length} HA areas via CLEAN_AREA)`
     );
     device = device.with(createCleanAreaServiceAreaServer(cleanAreaRooms));
   } else if (customAreas && customAreas.length > 0) {
-    logger239.info(
+    logger240.info(
       `${entityId}: Adding ServiceArea (${customAreas.length} custom areas)`
     );
     device = device.with(createCustomServiceAreaServer(customAreas));
   } else if (rooms.length > 0 || roomEntities && roomEntities.length > 0) {
-    logger239.info(`${entityId}: Adding ServiceArea (${rooms.length} rooms)`);
+    logger240.info(`${entityId}: Adding ServiceArea (${rooms.length} rooms)`);
     device = device.with(
       createVacuumServiceAreaServer(attributes9, roomEntities)
     );
   } else {
-    logger239.info(`${entityId}: Adding ServiceArea (default single-area)`);
+    logger240.info(`${entityId}: Adding ServiceArea (default single-area)`);
     device = device.with(createDefaultServiceAreaServer());
   }
   const fanSpeedList = resolveFanSpeedList(
@@ -170868,7 +171744,7 @@ function VacuumDevice(homeAssistantEntity, includeOnOff = false, cleaningModeOpt
     homeAssistantEntity.mapping?.mopIntensityEntity
   );
   if (cleaningModeOptions || fanSpeedList || mopIntensityList) {
-    logger239.info(
+    logger240.info(
       `${entityId}: Adding RvcCleanMode (multi-mode, cleaningModeOptions=${JSON.stringify(cleaningModeOptions ?? [])}, fanSpeedList=${JSON.stringify(fanSpeedList ?? [])}, mopIntensityList=${JSON.stringify(mopIntensityList ?? [])})`
     );
     device = device.with(
@@ -170881,7 +171757,7 @@ function VacuumDevice(homeAssistantEntity, includeOnOff = false, cleaningModeOpt
       )
     );
   } else {
-    logger239.info(`${entityId}: Adding RvcCleanMode (default single-mode)`);
+    logger240.info(`${entityId}: Adding RvcCleanMode (default single-mode)`);
     device = device.with(createDefaultRvcCleanModeServer());
   }
   return device;
@@ -171047,7 +171923,7 @@ var WaterHeaterThermostatServer = ThermostatServer2(
 );
 
 // src/matter/endpoints/legacy/water-heater/index.ts
-var logger240 = Logger.get("WaterHeaterDevice");
+var logger241 = Logger.get("WaterHeaterDevice");
 var WaterHeaterDeviceType = ThermostatDevice.with(
   BasicInformationServer2,
   IdentifyServer2,
@@ -171063,7 +171939,7 @@ function toMatterTemp2(value) {
 }
 function WaterHeaterDevice(homeAssistantEntity) {
   const attributes9 = homeAssistantEntity.entity.state.attributes;
-  logger240.debug(
+  logger241.debug(
     `Creating device for ${homeAssistantEntity.entity.entity_id}, min_temp=${attributes9.min_temp}, max_temp=${attributes9.max_temp}`
   );
   const minLimit = toMatterTemp2(attributes9.min_temp) ?? 0;
@@ -171303,6 +172179,7 @@ var matterDeviceTypeFactories = {
   // Legacy SolarPower alias, kept for existing mappings.
   electrical_sensor: (ha) => ElectricalSensorType.set({ homeAssistantEntity: ha }),
   solar_power: (ha) => ElectricalSensorType.set({ homeAssistantEntity: ha }),
+  evse: (ha) => energyEvseType().set({ homeAssistantEntity: ha }),
   contact_sensor: (ha) => ContactSensorType.set({ homeAssistantEntity: ha }),
   motion_sensor: (ha) => MotionSensorType.set({ homeAssistantEntity: ha }),
   occupancy_sensor: (ha) => OccupancySensorType.set({ homeAssistantEntity: ha }),
@@ -171318,7 +172195,7 @@ var matterDeviceTypeFactories = {
 };
 
 // src/matter/endpoints/composed/user-composed-endpoint.ts
-var logger241 = Logger.get("UserComposedEndpoint");
+var logger242 = Logger.get("UserComposedEndpoint");
 function stripBasicInformation(type) {
   const behaviors = { ...type.behaviors };
   delete behaviors.bridgedDeviceBasicInformation;
@@ -171328,11 +172205,11 @@ function createEndpointId5(entityId, customName) {
   const baseName = customName || entityId;
   return baseName.replace(/\./g, "_").replace(/\s+/g, "_");
 }
-function buildEntityPayload4(registry2, entityId) {
-  const state = registry2.initialStateIncludingUnfiltered(entityId);
+function buildEntityPayload4(registry3, entityId) {
+  const state = registry3.initialStateIncludingUnfiltered(entityId);
   if (!state) return void 0;
-  const entity = registry2.entityIncludingUnfiltered(entityId);
-  const deviceRegistry = registry2.deviceOfIncludingUnfiltered(entityId);
+  const entity = registry3.entityIncludingUnfiltered(entityId);
+  const deviceRegistry = registry3.deviceOfIncludingUnfiltered(entityId);
   return {
     entity_id: entityId,
     state,
@@ -171348,8 +172225,8 @@ var UserComposedEndpoint = class _UserComposedEndpoint extends Endpoint {
   lastMappedStates = /* @__PURE__ */ new Map();
   debouncedUpdates = /* @__PURE__ */ new Map();
   static async create(config11) {
-    const { registry: registry2, primaryEntityId, composedEntities } = config11;
-    const primaryPayload = buildEntityPayload4(registry2, primaryEntityId);
+    const { registry: registry3, primaryEntityId, composedEntities } = config11;
+    const primaryPayload = buildEntityPayload4(registry3, primaryEntityId);
     if (!primaryPayload) return void 0;
     let parentType = BridgedNodeEndpoint.with(
       BasicInformationServer2,
@@ -171391,10 +172268,10 @@ var UserComposedEndpoint = class _UserComposedEndpoint extends Endpoint {
       primarySubPayload,
       primaryMapping,
       config11.areaName,
-      { vacuumOnOff: registry2.isVacuumOnOffEnabled() }
+      { vacuumOnOff: registry3.isVacuumOnOffEnabled() }
     );
     if (!primaryType) {
-      logger241.warn(
+      logger242.warn(
         `Cannot create endpoint type for primary entity ${primaryEntityId}`
       );
       return void 0;
@@ -171407,9 +172284,9 @@ var UserComposedEndpoint = class _UserComposedEndpoint extends Endpoint {
     for (let i = 0; i < composedEntities.length; i++) {
       const sub = composedEntities[i];
       if (!sub.entityId) continue;
-      const subPayload = buildEntityPayload4(registry2, sub.entityId);
+      const subPayload = buildEntityPayload4(registry3, sub.entityId);
       if (!subPayload) {
-        logger241.warn(
+        logger242.warn(
           `Cannot find state for composed sub-entity ${sub.entityId}, it does not exist in Home Assistant (removed or renamed?)`
         );
         continue;
@@ -171424,7 +172301,7 @@ var UserComposedEndpoint = class _UserComposedEndpoint extends Endpoint {
         config11.areaName
       );
       if (!subType) {
-        logger241.warn(
+        logger242.warn(
           `Cannot create endpoint type for composed sub-entity ${sub.entityId}`
         );
         continue;
@@ -171437,7 +172314,7 @@ var UserComposedEndpoint = class _UserComposedEndpoint extends Endpoint {
       mappedIds.push(sub.entityId);
     }
     if (parts.length < 2) {
-      logger241.warn(
+      logger242.warn(
         `User composed device ${primaryEntityId}: only ${parts.length} sub-endpoint(s), need at least 2 (primary + one sub-entity). Falling back to standalone.`
       );
       return void 0;
@@ -171461,7 +172338,7 @@ var UserComposedEndpoint = class _UserComposedEndpoint extends Endpoint {
     const labels = parts.map(
       (_, i) => i === 0 ? primaryEntityId.split(".")[0] : composedEntities[i - 1]?.entityId?.split(".")[0] ?? "?"
     ).join("+");
-    logger241.info(
+    logger242.info(
       `Created user composed device ${primaryEntityId}: ${parts.length} sub-endpoint(s) [${labels}]`
     );
     return endpoint;
@@ -171567,45 +172444,45 @@ function asStandaloneEndpointType(type) {
 }
 
 // src/matter/endpoints/legacy/legacy-endpoint.ts
-var logger242 = Logger.get("LegacyEndpoint");
+var logger243 = Logger.get("LegacyEndpoint");
 var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
-  static async create(registry2, entityId, mapping, pluginDomainMappings, standalone = false, endpointId, identityAnchor) {
-    const deviceRegistry = registry2.deviceOf(entityId);
-    let state = registry2.initialState(entityId);
-    const entity = registry2.entity(entityId);
+  static async create(registry3, entityId, mapping, pluginDomainMappings, standalone = false, endpointId, identityAnchor) {
+    const deviceRegistry = registry3.deviceOf(entityId);
+    let state = registry3.initialState(entityId);
+    const entity = registry3.entity(entityId);
     if (!state) {
       return;
     }
-    if (registry2.isAutoBatteryMappingEnabled() && registry2.isBatteryEntityUsed(entityId)) {
-      logger242.debug(
+    if (registry3.isAutoBatteryMappingEnabled() && registry3.isBatteryEntityUsed(entityId)) {
+      logger243.debug(
         `Skipping ${entityId} - already auto-assigned as battery to another device`
       );
       return;
     }
-    if (registry2.isAutoHumidityMappingEnabled() && registry2.isHumidityEntityUsed(entityId)) {
-      logger242.debug(
+    if (registry3.isAutoHumidityMappingEnabled() && registry3.isHumidityEntityUsed(entityId)) {
+      logger243.debug(
         `Skipping ${entityId} - already auto-assigned as humidity to a temperature sensor`
       );
       return;
     }
-    if (registry2.isAutoPressureMappingEnabled() && registry2.isPressureEntityUsed(entityId)) {
-      logger242.debug(
+    if (registry3.isAutoPressureMappingEnabled() && registry3.isPressureEntityUsed(entityId)) {
+      logger243.debug(
         `Skipping ${entityId} - already auto-assigned as pressure to a temperature sensor`
       );
       return;
     }
-    if (registry2.isAutoComposedDevicesEnabled() && registry2.isComposedSubEntityUsed(entityId)) {
-      logger242.debug(
+    if (registry3.isAutoComposedDevicesEnabled() && registry3.isComposedSubEntityUsed(entityId)) {
+      logger243.debug(
         `Skipping ${entityId} - already consumed by a composed device`
       );
       return;
     }
     let effectiveMapping = mapping;
     if (entity.device_id) {
-      if (registry2.isAutoHumidityMappingEnabled()) {
+      if (registry3.isAutoHumidityMappingEnabled()) {
         const attrs = state.attributes;
         if (!mapping?.humidityEntity && entityId.startsWith("sensor.") && attrs.device_class === SensorDeviceClass.temperature) {
-          const humidityEntityId = registry2.findHumidityEntityForDevice(
+          const humidityEntityId = registry3.findHumidityEntityForDevice(
             entity.device_id
           );
           if (humidityEntityId && humidityEntityId !== entityId) {
@@ -171614,17 +172491,17 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
               entityId: effectiveMapping?.entityId ?? entityId,
               humidityEntity: humidityEntityId
             };
-            registry2.markHumidityEntityUsed(humidityEntityId);
-            logger242.debug(
+            registry3.markHumidityEntityUsed(humidityEntityId);
+            logger243.debug(
               `Auto-assigned humidity ${humidityEntityId} to ${entityId}`
             );
           }
         }
       }
-      if (registry2.isAutoPressureMappingEnabled()) {
+      if (registry3.isAutoPressureMappingEnabled()) {
         const attrs = state.attributes;
         if (!mapping?.pressureEntity && entityId.startsWith("sensor.") && attrs.device_class === SensorDeviceClass.temperature) {
-          const pressureEntityId = registry2.findPressureEntityForDevice(
+          const pressureEntityId = registry3.findPressureEntityForDevice(
             entity.device_id
           );
           if (pressureEntityId && pressureEntityId !== entityId) {
@@ -171633,16 +172510,16 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
               entityId: effectiveMapping?.entityId ?? entityId,
               pressureEntity: pressureEntityId
             };
-            registry2.markPressureEntityUsed(pressureEntityId);
-            logger242.debug(
+            registry3.markPressureEntityUsed(pressureEntityId);
+            logger243.debug(
               `Auto-assigned pressure ${pressureEntityId} to ${entityId}`
             );
           }
         }
       }
       const isVacuum = entityId.startsWith("vacuum.");
-      if ((registry2.isAutoBatteryMappingEnabled() || isVacuum) && !mapping?.batteryEntity && !mapping?.disableBatteryMapping) {
-        const batteryEntityId = registry2.findBatteryEntityForDevice(
+      if ((registry3.isAutoBatteryMappingEnabled() || isVacuum) && !mapping?.batteryEntity && !mapping?.disableBatteryMapping) {
+        const batteryEntityId = registry3.findBatteryEntityForDevice(
           entity.device_id
         );
         if (batteryEntityId && batteryEntityId !== entityId) {
@@ -171651,16 +172528,16 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
             entityId: effectiveMapping?.entityId ?? entityId,
             batteryEntity: batteryEntityId
           };
-          registry2.markBatteryEntityUsed(batteryEntityId);
-          logger242.debug(
+          registry3.markBatteryEntityUsed(batteryEntityId);
+          logger243.debug(
             `Auto-assigned battery ${batteryEntityId} to ${entityId}`
           );
         }
       }
       const alarmDeviceClass = state.attributes.device_class;
       const isSmokeCoAlarm = mapping?.matterDeviceType === "smoke_co_alarm" || entityId.startsWith("binary_sensor.") && (alarmDeviceClass === "smoke" || alarmDeviceClass === "carbon_monoxide" || alarmDeviceClass === "gas");
-      if (registry2.isAutoBatteryMappingEnabled() && !mapping?.faultEntity && isSmokeCoAlarm) {
-        const faultEntityId = registry2.findProblemEntityForDevice(
+      if (registry3.isAutoBatteryMappingEnabled() && !mapping?.faultEntity && isSmokeCoAlarm) {
+        const faultEntityId = registry3.findProblemEntityForDevice(
           entity.device_id
         );
         if (faultEntityId && faultEntityId !== entityId) {
@@ -171669,13 +172546,13 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
             entityId: effectiveMapping?.entityId ?? entityId,
             faultEntity: faultEntityId
           };
-          logger242.debug(`Auto-assigned fault ${faultEntityId} to ${entityId}`);
+          logger243.debug(`Auto-assigned fault ${faultEntityId} to ${entityId}`);
         }
       }
       if (!mapping?.powerEntity) {
         const domain = entityId.split(".")[0];
         if (domain === "switch") {
-          const powerEntityId = registry2.findPowerEntityForDevice(
+          const powerEntityId = registry3.findPowerEntityForDevice(
             entity.device_id
           );
           if (powerEntityId && powerEntityId !== entityId) {
@@ -171684,15 +172561,15 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
               entityId: effectiveMapping?.entityId ?? entityId,
               powerEntity: powerEntityId
             };
-            registry2.markPowerEntityUsed(powerEntityId);
-            logger242.debug(`Auto-assigned power ${powerEntityId} to ${entityId}`);
+            registry3.markPowerEntityUsed(powerEntityId);
+            logger243.debug(`Auto-assigned power ${powerEntityId} to ${entityId}`);
           }
         }
       }
       if (!mapping?.energyEntity) {
         const domain = entityId.split(".")[0];
         if (domain === "switch") {
-          const energyEntityId = registry2.findEnergyEntityForDevice(
+          const energyEntityId = registry3.findEnergyEntityForDevice(
             entity.device_id
           );
           if (energyEntityId && energyEntityId !== entityId) {
@@ -171701,15 +172578,15 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
               entityId: effectiveMapping?.entityId ?? entityId,
               energyEntity: energyEntityId
             };
-            registry2.markEnergyEntityUsed(energyEntityId);
-            logger242.debug(
+            registry3.markEnergyEntityUsed(energyEntityId);
+            logger243.debug(
               `Auto-assigned energy ${energyEntityId} to ${entityId}`
             );
           }
         }
       }
       if (entityId.startsWith("vacuum.")) {
-        const vacuumEntities = registry2.findVacuumSelectEntities(
+        const vacuumEntities = registry3.findVacuumSelectEntities(
           entity.device_id
         );
         if (!effectiveMapping?.cleaningModeEntity && vacuumEntities.cleaningModeEntity) {
@@ -171718,7 +172595,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
             entityId: effectiveMapping?.entityId ?? entityId,
             cleaningModeEntity: vacuumEntities.cleaningModeEntity
           };
-          logger242.info(
+          logger243.info(
             `Auto-assigned cleaningMode ${vacuumEntities.cleaningModeEntity} to ${entityId}`
           );
         }
@@ -171728,7 +172605,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
             entityId: effectiveMapping?.entityId ?? entityId,
             suctionLevelEntity: vacuumEntities.suctionLevelEntity
           };
-          logger242.info(
+          logger243.info(
             `Auto-assigned suctionLevel ${vacuumEntities.suctionLevelEntity} to ${entityId}`
           );
         }
@@ -171738,7 +172615,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
             entityId: effectiveMapping?.entityId ?? entityId,
             mopIntensityEntity: vacuumEntities.mopIntensityEntity
           };
-          logger242.info(
+          logger243.info(
             `Auto-assigned mopIntensity ${vacuumEntities.mopIntensityEntity} to ${entityId}`
           );
         }
@@ -171748,12 +172625,12 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
             entityId: effectiveMapping?.entityId ?? entityId,
             currentRoomEntity: vacuumEntities.currentRoomEntity
           };
-          logger242.info(
+          logger243.info(
             `Auto-assigned currentRoom ${vacuumEntities.currentRoomEntity} to ${entityId}`
           );
         }
         const supportedFeatures = state.attributes.supported_features ?? 0;
-        const cleanAreaRooms = await registry2.resolveCleanAreaRooms(
+        const cleanAreaRooms = await registry3.resolveCleanAreaRooms(
           entityId,
           supportedFeatures
         );
@@ -171763,13 +172640,13 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
             entityId: effectiveMapping?.entityId ?? entityId,
             cleanAreaRooms
           };
-          logger242.info(
+          logger243.info(
             `Using ${cleanAreaRooms.length} HA areas via CLEAN_AREA for ${entityId}`
           );
         }
         const vacAttrs = state.attributes;
         if (cleanAreaRooms.length === 0 && !vacAttrs.rooms && !vacAttrs.segments && !vacAttrs.room_mapping) {
-          const valetudoRooms = registry2.findValetudoMapSegments(
+          const valetudoRooms = registry3.findValetudoMapSegments(
             entity.device_id
           );
           if (valetudoRooms.length > 0) {
@@ -171784,11 +172661,11 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
                 rooms: roomsObj
               }
             };
-            logger242.debug(
+            logger243.debug(
               `Auto-detected ${valetudoRooms.length} Valetudo segments for ${entityId}`
             );
           } else {
-            const roborockRooms = await registry2.resolveRoborockRooms(entityId);
+            const roborockRooms = await registry3.resolveRoborockRooms(entityId);
             if (roborockRooms.length > 0) {
               const roomsObj = {};
               for (const r of roborockRooms) {
@@ -171801,7 +172678,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
                   rooms: roomsObj
                 }
               };
-              logger242.debug(
+              logger243.debug(
                 `Auto-detected ${roborockRooms.length} Roborock rooms for ${entityId}`
               );
             }
@@ -171810,14 +172687,14 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
       }
     }
     if (standalone && ((effectiveMapping?.composedEntities?.length ?? 0) > 0 || effectiveMapping?.climateExposeFan === true)) {
-      logger242.warn(
+      logger243.warn(
         `Composed mappings are not supported in server mode, exposing ${entityId} as a flat standalone endpoint`
       );
     }
-    if (!standalone && registry2.isAutoComposedDevicesEnabled() && effectiveMapping?.composedEntities && effectiveMapping.composedEntities.length > 0) {
-      const composedAreaName = registry2.getAreaName(entityId);
+    if (!standalone && registry3.isAutoComposedDevicesEnabled() && effectiveMapping?.composedEntities && effectiveMapping.composedEntities.length > 0) {
+      const composedAreaName = registry3.getAreaName(entityId);
       const composed = await UserComposedEndpoint.create({
-        registry: registry2,
+        registry: registry3,
         primaryEntityId: entityId,
         mapping: effectiveMapping,
         composedEntities: effectiveMapping.composedEntities,
@@ -171829,16 +172706,16 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
       if (composed) {
         return composed;
       }
-      logger242.warn(
+      logger243.warn(
         `User composed device creation failed for ${entityId}, falling back to standalone`
       );
     }
-    if (!standalone && registry2.isAutoComposedDevicesEnabled()) {
+    if (!standalone && registry3.isAutoComposedDevicesEnabled()) {
       const attrs = state.attributes;
       if (entityId.startsWith("sensor.") && attrs.device_class === SensorDeviceClass.temperature && (effectiveMapping?.humidityEntity || effectiveMapping?.pressureEntity)) {
-        const composedAreaName = registry2.getAreaName(entityId);
+        const composedAreaName = registry3.getAreaName(entityId);
         const composed = await ComposedSensorEndpoint.create({
-          registry: registry2,
+          registry: registry3,
           primaryEntityId: entityId,
           humidityEntityId: effectiveMapping?.humidityEntity,
           pressureEntityId: effectiveMapping?.pressureEntity,
@@ -171854,12 +172731,12 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
       }
       const resolvedMatterType = mapping?.matterDeviceType ?? (entityId.startsWith("fan.") ? "fan" : void 0);
       if (resolvedMatterType === "air_purifier") {
-        const temperatureEntityId = effectiveMapping?.temperatureEntity || (entity.device_id ? registry2.findTemperatureEntityForDevice(entity.device_id) : void 0);
-        const humidityEntityId = effectiveMapping?.humidityEntity || (entity.device_id ? registry2.findHumidityEntityForDevice(entity.device_id) : void 0);
+        const temperatureEntityId = effectiveMapping?.temperatureEntity || (entity.device_id ? registry3.findTemperatureEntityForDevice(entity.device_id) : void 0);
+        const humidityEntityId = effectiveMapping?.humidityEntity || (entity.device_id ? registry3.findHumidityEntityForDevice(entity.device_id) : void 0);
         if (temperatureEntityId || humidityEntityId) {
-          const composedAreaName = registry2.getAreaName(entityId);
+          const composedAreaName = registry3.getAreaName(entityId);
           const composed = await ComposedAirPurifierEndpoint.create({
-            registry: registry2,
+            registry: registry3,
             primaryEntityId: entityId,
             temperatureEntityId,
             humidityEntityId,
@@ -171881,9 +172758,9 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
     if (!standalone && entityId.startsWith("climate.") && effectiveMapping?.climateExposeFan === true) {
       const climateFeatures = state.attributes.supported_features ?? 0;
       if ((climateFeatures & ClimateDeviceFeature.FAN_MODE) !== 0) {
-        const composedAreaName = registry2.getAreaName(entityId);
+        const composedAreaName = registry3.getAreaName(entityId);
         const composed = await ComposedClimateFanEndpoint.create({
-          registry: registry2,
+          registry: registry3,
           primaryEntityId: entityId,
           mapping: effectiveMapping,
           customName: effectiveMapping?.customName,
@@ -171894,7 +172771,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
         if (composed) {
           return composed;
         }
-        logger242.warn(
+        logger243.warn(
           `Companion fan creation failed for ${entityId}, falling back to standalone`
         );
       }
@@ -171908,7 +172785,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
     let cleaningModeOptions;
     if (entityId.startsWith("vacuum.")) {
       if (effectiveMapping?.cleaningModeEntity) {
-        const cmState = registry2.initialState(
+        const cmState = registry3.initialState(
           effectiveMapping.cleaningModeEntity
         );
         cleaningModeOptions = cmState?.attributes?.options;
@@ -171922,13 +172799,13 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
         ];
       }
     }
-    const areaName = registry2.getAreaName(entityId);
+    const areaName = registry3.getAreaName(entityId);
     let type = createLegacyEndpointType(
       payload,
       effectiveMapping,
       areaName,
       {
-        vacuumOnOff: registry2.isVacuumOnOffEnabled(),
+        vacuumOnOff: registry3.isVacuumOnOffEnabled(),
         cleaningModeOptions,
         pluginDomainMappings
       },
@@ -171974,11 +172851,11 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
     }
     if (mappedChanged) {
       this.pendingMappedChange = true;
-      logger242.debug(
+      logger243.debug(
         `Mapped entity change detected for ${this.entityId}, forcing update`
       );
     }
-    logger242.debug(
+    logger243.debug(
       `State update received for ${this.entityId}: state=${state.state}`
     );
     this.lastState = state;
@@ -172107,18 +172984,186 @@ var CameraAvStreamServer = class extends Base4 {
 })(CameraAvStreamServer || (CameraAvStreamServer = {}));
 
 // src/plugins/builtin/camera/webrtc-provider-server.ts
+init_esm();
 init_esm7();
 init_esm3();
+
+// src/plugins/builtin/camera/requestor-client.ts
+init_esm();
+init_esm4();
+var logger244 = Logger.get("CameraWebRtcRequestor");
+var registry2 = /* @__PURE__ */ new Map();
+var pendingDeliveries = /* @__PURE__ */ new Map();
+var invokeTransport = defaultInvoke;
+function registerRequestor(sessionId, registration) {
+  registry2.set(sessionId, registration);
+}
+function unregisterRequestor(sessionId) {
+  registry2.delete(sessionId);
+  const timer = pendingDeliveries.get(sessionId);
+  if (timer) {
+    clearTimeout(timer);
+    pendingDeliveries.delete(sessionId);
+  }
+}
+function unregisterAllRequestors() {
+  for (const id of [...registry2.keys()]) unregisterRequestor(id);
+  for (const timer of pendingDeliveries.values()) clearTimeout(timer);
+  pendingDeliveries.clear();
+}
+function deliverAnswerDeferred(sessionId, sdp, onGiveUp) {
+  const prior = pendingDeliveries.get(sessionId);
+  if (prior) clearTimeout(prior);
+  const owner = registry2.get(sessionId);
+  const timer = setTimeout(() => {
+    void (async () => {
+      try {
+        for (const delayMs of [0, 250, 500]) {
+          if (delayMs > 0) await new Promise((r) => setTimeout(r, delayMs));
+          if (registry2.get(sessionId) !== owner || pendingDeliveries.get(sessionId) !== timer) {
+            return;
+          }
+          if (await sendAnswer(sessionId, sdp)) {
+            logger244.info(`answer delivered for session ${sessionId}`);
+            return;
+          }
+        }
+        if (registry2.get(sessionId) !== owner || pendingDeliveries.get(sessionId) !== timer) {
+          return;
+        }
+        logger244.info(
+          `answer delivery failed for session ${sessionId}, giving up`
+        );
+        await onGiveUp();
+      } catch (err) {
+        logger244.info(
+          `answer delivery for session ${sessionId} threw: ${errText(err)}`
+        );
+      } finally {
+        if (pendingDeliveries.get(sessionId) === timer) {
+          pendingDeliveries.delete(sessionId);
+        }
+      }
+    })();
+  }, 0);
+  timer.unref?.();
+  pendingDeliveries.set(sessionId, timer);
+}
+function hasRequestor(sessionId) {
+  return registry2.has(sessionId);
+}
+function sendAnswer(sessionId, sdp) {
+  return invokeRequestor(sessionId, "answer", {
+    webRtcSessionId: sessionId,
+    sdp
+  });
+}
+async function invokeRequestor(sessionId, command, fields) {
+  const registration = registry2.get(sessionId);
+  if (!registration) {
+    logger244.info(`requestor ${command}: no session ${sessionId} registered`);
+    return false;
+  }
+  if (registration.session.isClosed) {
+    logger244.info(`requestor ${command}: session ${sessionId} already closed`);
+    return false;
+  }
+  const request = {
+    endpoint: registration.requestorEndpoint,
+    cluster: WebRtcTransportRequestor3.Cluster,
+    command,
+    fields
+  };
+  try {
+    return await invokeTransport({ registration, request });
+  } catch (err) {
+    logger244.info(
+      `requestor ${command} failed for session ${sessionId}: ${errText(err)}`
+    );
+    return false;
+  }
+}
+async function defaultInvoke({
+  registration,
+  request
+}) {
+  const { session, env } = registration;
+  const exchangeManager = env.get(ExchangeManager);
+  const exchangeProvider = new DedicatedChannelExchangeProvider(
+    exchangeManager,
+    session
+  );
+  const client = new ClientInteraction({ environment: env, exchangeProvider });
+  try {
+    const result = client.invoke(
+      Invoke({
+        commands: [
+          {
+            endpoint: request.endpoint,
+            cluster: request.cluster,
+            command: request.command,
+            // biome-ignore lint/suspicious/noExplicitAny: fields typed per command by caller
+            fields: request.fields
+          }
+        ]
+      })
+    );
+    for await (const chunk of result) {
+      for (const entry of chunk) {
+        if (entry.kind === "cmd-status") {
+          if (entry.status !== Status2.Success) {
+            logger244.info(
+              `requestor ${request.command} status ${entry.status} for session ${String(request.fields.webRtcSessionId)}`
+            );
+            return false;
+          }
+          return true;
+        }
+      }
+    }
+    return true;
+  } finally {
+    await client.close().catch(() => {
+    });
+  }
+}
+function errText(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/plugins/builtin/camera/webrtc-provider-server.ts
+var logger245 = Logger.get("CameraWebRtc");
+var nextGlobalSessionId = 0;
+function mintSessionId() {
+  for (let i = 0; i <= 65534; i++) {
+    const id = nextGlobalSessionId;
+    nextGlobalSessionId = nextGlobalSessionId >= 65534 ? 0 : nextGlobalSessionId + 1;
+    if (!hasRequestor(id)) return id;
+  }
+  return nextGlobalSessionId;
+}
 var CameraWebRtcProviderServer = class extends WebRtcTransportProviderServer {
   solicitOffer(request) {
-    const id = this.state.nextSessionId++;
+    const id = mintSessionId();
     this.trackSession(id, request.streamUsage, request.originatingEndpointId);
-    void this.state.bridge.startSession(id, this.state.entityId).catch(() => {
-    });
+    logger245.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) => logger245.info(
+        `solicitOffer startSession failed for ${this.state.entityId}: ${errText2(err)}`
+      )
+    );
     return { webRtcSessionId: id, deferredOffer: true };
   }
   async provideOffer(request) {
-    const id = request.webRtcSessionId ?? this.state.nextSessionId++;
+    const id = request.webRtcSessionId ?? mintSessionId();
+    logger245.info(
+      `provideOffer entry: entityId=${this.state.entityId} session=${id} (sdp ${request.sdp.length} chars)`
+    );
     if (request.webRtcSessionId == null) {
       this.trackSession(
         id,
@@ -172126,37 +173171,96 @@ var CameraWebRtcProviderServer = class extends WebRtcTransportProviderServer {
         request.originatingEndpointId ?? EndpointNumber(0)
       );
     }
-    const answerSdp = await this.state.bridge.acceptControllerOffer(
-      id,
-      this.state.entityId,
-      request.sdp
+    const requestorEndpoint = request.originatingEndpointId ?? EndpointNumber(0);
+    const session = this.context.session;
+    if (session) {
+      registerRequestor(id, {
+        session,
+        requestorEndpoint,
+        env: this.env
+      });
+    }
+    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 = errText2(err);
+      logger245.info(
+        `provideOffer failed for ${this.state.entityId} session=${id}: ${message}`
+      );
+      unregisterRequestor(id);
+      this.state.currentSessions = this.state.currentSessions.filter(
+        (s) => s.id !== id
+      );
+      throw new StatusResponseError(
+        `WebRTC offer failed: ${message}`,
+        StatusCode.Failure
+      );
+    }
+    logger245.info(
+      `provideOffer answer computed for ${this.state.entityId} session=${id} (${answerSdp.length} chars); delivering via requestor`
     );
-    void answerSdp;
+    const bridge = this.state.bridge;
+    const state = this.state;
+    deliverAnswerDeferred(id, answerSdp, async () => {
+      await bridge.endSession(id).catch(() => {
+      });
+      unregisterRequestor(id);
+      try {
+        state.currentSessions = state.currentSessions.filter(
+          (s) => s.id !== id
+        );
+      } catch {
+      }
+    });
     return { webRtcSessionId: id };
   }
   provideAnswer(request) {
+    logger245.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) {
+    logger245.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) {
+    logger245.info(
+      `endSession session=${request.webRtcSessionId} (${this.state.entityId})`
+    );
     await this.state.bridge.endSession(request.webRtcSessionId);
+    unregisterRequestor(request.webRtcSessionId);
     this.state.currentSessions = this.state.currentSessions.filter(
       (s) => s.id !== request.webRtcSessionId
     );
   }
   trackSession(id, streamUsage, peerEndpointId) {
     const session = this.context.session;
+    const fabricIndex = session?.associatedFabric?.fabricIndex;
+    if (fabricIndex == null) {
+      return;
+    }
     this.state.currentSessions = [
       ...this.state.currentSessions,
       {
@@ -172165,16 +173269,18 @@ var CameraWebRtcProviderServer = class extends WebRtcTransportProviderServer {
         peerEndpointId,
         streamUsage,
         metadataEnabled: false,
-        fabricIndex: session?.associatedFabric?.fabricIndex ?? FabricIndex3(0)
+        fabricIndex
       }
     ];
   }
 };
+function errText2(err) {
+  return err instanceof Error ? err.message : String(err);
+}
 ((CameraWebRtcProviderServer2) => {
   class State extends WebRtcTransportProviderServer.State {
     bridge;
     entityId;
-    nextSessionId = 1;
   }
   CameraWebRtcProviderServer2.State = State;
 })(CameraWebRtcProviderServer || (CameraWebRtcProviderServer = {}));
@@ -172193,8 +173299,7 @@ function createCameraEndpointType(bridge, entityId, sensor = defaultSensorParams
     webRtcTransportProvider: {
       bridge,
       entityId,
-      currentSessions: [],
-      nextSessionId: 1
+      currentSessions: []
     },
     cameraAvStreamManagement: {
       bridge,
@@ -172256,128 +173361,232 @@ 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 logger246 = 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);
+    await this.closeExistingPeers(matterSessionId);
+    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);
+      logger246.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);
+      logger246.info(
+        `controller offer created for ${entityId} (${sdp.length} chars)`
+      );
+      return { sdp, iceCandidates };
+    } catch (err) {
+      logger246.info(`startSession failed for ${entityId}: ${errText3(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);
+    await this.closeExistingPeers(matterSessionId);
     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);
+      logger246.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);
+      logger246.info(
+        `controller answer created for ${entityId} (${answerSdp.length} chars)`
+      );
+      return answerSdp;
+    } catch (err) {
+      logger246.info(
+        `acceptControllerOffer failed for ${entityId}: ${errText3(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;
+    logger246.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;
+    logger246.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
+    });
+  }
+  // Close the peers of a session we are about to overwrite. Leaves no map
+  // entry; the caller replaces it with fresh peers under the same id.
+  async closeExistingPeers(matterSessionId) {
+    const prior = this.sessions.get(matterSessionId);
+    if (!prior) return;
+    logger246.info(
+      `replacing session ${matterSessionId} (${prior.entityId}), closing prior peers`
+    );
+    if (prior.haUnsubscribe) {
+      await Promise.resolve(prior.haUnsubscribe()).catch(
+        (err) => logger246.debug(`HA unsubscribe failed: ${errText3(err)}`)
+      );
+    }
+    await prior.haPeer.close().catch(() => {
+    });
+    await prior.controllerPeer.close().catch(() => {
+    });
+    await this.stopHaStream(prior).catch(() => {
     });
   }
   async endSession(matterSessionId) {
     const session = this.sessions.get(matterSessionId);
     if (!session) return;
+    logger246.info(`ending session ${matterSessionId} (${session.entityId})`);
     this.sessions.delete(matterSessionId);
-    await session.haPeer.close();
-    await session.controllerPeer.close();
-    if (session.haSessionId) {
-      try {
-        const conn = await this.ha();
-        await conn.sendMessagePromise({
-          type: "camera/webrtc/candidate",
-          entity_id: session.entityId,
-          session_id: session.haSessionId,
-          candidate: { candidate: "" }
-        });
-      } catch {
-      }
+    if (session.haUnsubscribe) {
+      await Promise.resolve(session.haUnsubscribe()).catch(
+        (err) => logger246.debug(`HA unsubscribe failed: ${errText3(err)}`)
+      );
     }
+    await session.haPeer.close().catch(() => {
+    });
+    await session.controllerPeer.close().catch(() => {
+    });
+    await this.stopHaStream(session).catch(() => {
+    });
+  }
+  // Tell HA to stop the stream if we tracked an HA session id. Best effort.
+  async stopHaStream(session) {
+    if (!session.haSessionId) return;
+    const conn = await this.ha();
+    await conn.sendMessagePromise({
+      type: "camera/webrtc/candidate",
+      entity_id: session.entityId,
+      session_id: session.haSessionId,
+      candidate: { candidate: "" }
+    });
   }
   // 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) {
+      logger246.info(`snapshot fetch failed for ${entityId}: ${errText3(err)}`);
+      throw err;
+    }
     if (!res.ok) {
+      logger246.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());
@@ -172389,29 +173598,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) => {
+      logger246.info(`onTrack ${track.kind} from HA (${entityId})`);
+      const transceiver = senders.get(track.kind);
+      if (!transceiver) {
+        logger246.info(
+          `no controller transceiver for ${track.kind} (${entityId})`
+        );
+        return;
+      }
+      let firstLogged = false;
+      track.onReceiveRtp.subscribe((rtp) => {
+        if (!firstLogged) {
+          firstLogged = true;
+          logger246.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) => logger246.info(`${label} connectionState=${s} (${entityId})`)
+    );
+    peer.iceConnectionStateChange.subscribe(
+      (s) => logger246.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) {
+      logger246.info(`controller peer using default ICE servers (${entityId})`);
+      return void 0;
+    }
+    const policy = ice?.iceTransportPolicy === "relay" || ice?.iceTransportPolicy === "all" ? ice.iceTransportPolicy : void 0;
+    logger246.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;
+    logger246.debug(`HA ICE candidate for ${entityId}: ${value}`);
+    void haPeer.addIceCandidate({
+      candidate: value,
+      sdpMid: candidate?.sdpMid ?? void 0,
+      sdpMLineIndex: candidate?.sdpMLineIndex ?? void 0
+    }).catch(
+      (e) => logger246.debug(
+        `HA addIceCandidate failed for ${entityId}: ${errText3(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(() => {
+        logger246.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(() => {
+                  logger246.info(
+                    `HA answer received for ${entityId} (${ans.length} chars)`
+                  );
+                  resolve11(ans);
+                });
+              }
+              break;
+            case "error": {
+              const detail = msg.message ?? msg.code ?? "unknown error";
+              logger246.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 errText3(err) {
+  return err instanceof Error ? err.message : String(err);
+}
 
 // src/plugins/builtin/camera/camera-plugin.ts
 var CONFIG_KEY = "config";
@@ -172544,6 +173881,7 @@ var CameraPlugin = class {
     await this.bridge?.close().catch(() => {
     });
     this.bridge = void 0;
+    unregisterAllRequestors();
   }
 };
 
@@ -172557,7 +173895,7 @@ import {
   getCollection
 } from "home-assistant-js-websocket";
 import { atLeastHaVersion } from "home-assistant-js-websocket/dist/util.js";
-var logger243 = Logger.get("SubscribeEntities");
+var logger247 = Logger.get("SubscribeEntities");
 function processEvent(store, updates) {
   const state = { ...store.state };
   if (updates.a) {
@@ -172583,7 +173921,7 @@ function processEvent(store, updates) {
     for (const entityId in updates.c) {
       let entityState = state[entityId];
       if (!entityState) {
-        logger243.warn("Received state update for unknown entity", entityId);
+        logger247.warn("Received state update for unknown entity", entityId);
         continue;
       }
       entityState = { ...entityState };
@@ -172672,7 +174010,7 @@ var subscribeEntities = (conn, onChange, entityIds) => {
 // src/services/bridges/entity-isolation-service.ts
 init_esm();
 init_diagnostic_event_bus();
-var logger244 = Logger.get("EntityIsolation");
+var logger248 = Logger.get("EntityIsolation");
 var EntityIsolationServiceImpl = class {
   isolatedEntities = /* @__PURE__ */ new Map();
   isolationCallbacks = /* @__PURE__ */ new Map();
@@ -172737,13 +174075,13 @@ var EntityIsolationServiceImpl = class {
     }
     const parsed = this.parseEndpointPath(msg);
     if (!parsed) {
-      logger244.warn("Could not parse entity from error:", msg);
+      logger248.warn("Could not parse entity from error:", msg);
       return false;
     }
     const { bridgeId, entityName } = parsed;
     const callback = this.isolationCallbacks.get(bridgeId);
     if (!callback) {
-      logger244.warn(
+      logger248.warn(
         `No isolation callback registered for bridge ${bridgeId}, entity: ${entityName}`
       );
       return false;
@@ -172758,7 +174096,7 @@ var EntityIsolationServiceImpl = class {
       reason,
       failedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
-    logger244.warn(
+    logger248.warn(
       `Isolating entity "${entityName}" from bridge ${bridgeId} due to: ${reason}`
     );
     diagnosticEventBus.emit("entity_error", `Entity isolated: ${entityName}`, {
@@ -172770,7 +174108,7 @@ var EntityIsolationServiceImpl = class {
       await callback(entityName);
       return true;
     } catch (e) {
-      logger244.error(`Failed to isolate entity ${entityName}:`, e);
+      logger248.error(`Failed to isolate entity ${entityName}:`, e);
       return false;
     }
   }
@@ -172799,128 +174137,16 @@ var EntityIsolationServiceImpl = class {
 };
 var EntityIsolationService = new EntityIsolationServiceImpl();
 
-// src/services/bridges/identity-resolver.ts
-var SEP = "\0";
-function identityKey(entity) {
-  const uniqueId = entity.registry?.unique_id;
-  const platform = entity.registry?.platform;
-  if (!uniqueId || !platform) {
-    return null;
-  }
-  const domain = entity.entity_id.split(".")[0];
-  return platform + SEP + domain + SEP + uniqueId;
-}
-var IdentityResolver = class {
-  constructor(identityStorage, mappingStorage) {
-    this.identityStorage = identityStorage;
-    this.mappingStorage = mappingStorage;
-  }
-  identityStorage;
-  mappingStorage;
-  async resolveIdentity(bridgeId, entity, mapping, opts) {
-    const entityId = entity.entity_id;
-    const key = identityKey(entity);
-    if (key == null) {
-      return {
-        endpointId: createEndpointId(entityId, mapping?.customName),
-        anchorEntityId: entityId,
-        protected: false
-      };
-    }
-    const existing = this.identityStorage.getIdentity(bridgeId, key);
-    if (existing) {
-      const renamedFrom = existing.lastEntityId !== entityId ? existing.lastEntityId ?? existing.anchorEntityId : void 0;
-      if (opts.stableIdentity) {
-        if (renamedFrom) {
-          this.identityStorage.setIdentity(bridgeId, key, {
-            ...existing,
-            lastEntityId: entityId
-          });
-          await this.rekeyMapping(bridgeId, renamedFrom, entityId);
-        }
-        return {
-          endpointId: existing.endpointId,
-          anchorEntityId: existing.anchorEntityId,
-          protected: true,
-          renamedFrom
-        };
-      }
-      const liveEndpointId = createEndpointId(entityId, mapping?.customName);
-      if (existing.endpointId !== liveEndpointId || existing.anchorEntityId !== entityId || existing.lastEntityId !== entityId) {
-        this.identityStorage.setIdentity(bridgeId, key, {
-          ...existing,
-          endpointId: liveEndpointId,
-          anchorEntityId: entityId,
-          lastEntityId: entityId
-        });
-      }
-      return {
-        endpointId: liveEndpointId,
-        anchorEntityId: entityId,
-        protected: false,
-        renamedFrom
-      };
-    }
-    const desired = createEndpointId(entityId, mapping?.customName);
-    let endpointId = desired;
-    if (opts.stableIdentity) {
-      let n = 2;
-      while (opts.isEndpointIdTaken(endpointId, key)) {
-        endpointId = `${desired}_${n++}`;
-      }
-    }
-    const record = {
-      endpointId,
-      anchorEntityId: entityId,
-      lastEntityId: entityId,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this.identityStorage.setIdentity(bridgeId, key, record);
-    if (opts.stableIdentity) {
-      return {
-        endpointId: record.endpointId,
-        anchorEntityId: record.anchorEntityId,
-        protected: true
-      };
-    }
-    return {
-      endpointId: desired,
-      anchorEntityId: entityId,
-      protected: false
-    };
-  }
-  // Carry a mapping from the old entity_id to the new one on rename. anchorEntityId
-  // never changes, only the mapping key. Skips when no old mapping exists or a new
-  // one already does, so a manual mapping under the new id is never clobbered.
-  async rekeyMapping(bridgeId, oldEntityId, newEntityId) {
-    if (oldEntityId === newEntityId) {
-      return;
-    }
-    const old = this.mappingStorage.getMapping(bridgeId, oldEntityId);
-    if (!old) {
-      return;
-    }
-    if (this.mappingStorage.getMapping(bridgeId, newEntityId)) {
-      return;
-    }
-    await this.mappingStorage.setMapping({
-      ...old,
-      bridgeId,
-      entityId: newEntityId
-    });
-    await this.mappingStorage.deleteMapping(bridgeId, oldEntityId);
-  }
-};
-
 // src/services/bridges/bridge-endpoint-manager.ts
 var MAX_ENTITY_ID_LENGTH = 150;
 var ENDPOINT_REMOVAL_GRACE_MS = 6e4;
 var BridgeEndpointManager = class extends Service {
-  constructor(client, registry2, mappingStorage, identityStorage, bridgeId, log, pluginManager, pluginRegistry, pluginInstaller) {
+  constructor(client, registry3, mappingStorage, identityStorage, bridgeId, log, pluginManager, pluginRegistry, pluginInstaller) {
     super("BridgeEndpointManager");
     this.client = client;
-    this.registry = registry2;
+    this.registry = registry3;
     this.mappingStorage = mappingStorage;
+    this.identityStorage = identityStorage;
     this.bridgeId = bridgeId;
     this.log = log;
     this.pluginManager = pluginManager;
@@ -172942,6 +174168,7 @@ var BridgeEndpointManager = class extends Service {
   client;
   registry;
   mappingStorage;
+  identityStorage;
   bridgeId;
   log;
   pluginManager;
@@ -173339,6 +174566,17 @@ var BridgeEndpointManager = class extends Service {
         this.mappingFingerprints.set(entityId, fp);
       }
     }
+    const fullEntities = this.registry.fullEntities;
+    stampIdentityPresence(
+      this.identityStorage,
+      this.bridgeId,
+      buildPresentIdentityKeys(fullEntities)
+    );
+    stampMappingPresence(
+      this.mappingStorage,
+      this.bridgeId,
+      buildPresentEntityIds(fullEntities)
+    );
     const existingEndpoints = [];
     const now = Date.now();
     for (const endpoint of endpoints) {
@@ -173617,8 +174855,8 @@ init_send_ha_message();
 import { callService as callService2 } from "home-assistant-js-websocket";
 import { keys as keys2, pickBy, values as values3 } from "lodash-es";
 var BridgeRegistry = class _BridgeRegistry {
-  constructor(registry2, dataProvider, client) {
-    this.registry = registry2;
+  constructor(registry3, dataProvider, client) {
+    this.registry = registry3;
     this.dataProvider = dataProvider;
     this.client = client;
     this.refresh();
@@ -173658,6 +174896,11 @@ var BridgeRegistry = class _BridgeRegistry {
   initialState(entityId) {
     return this._states[entityId];
   }
+  // The complete HA entity set (unfiltered). Used by orphan tombstone stamping
+  // so a filter change or a scope narrowing never looks like a removal.
+  get fullEntities() {
+    return this.registry.entities;
+  }
   // composed sub-entities may sit outside the bridge filter (#408), so these
   // fall back to the full HA registry. keep them separate from the strict
   // accessors above, every other caller must stay filtered.
@@ -174375,6 +175618,7 @@ init_dist();
 init_esm7();
 import * as os10 from "node:os";
 init_diagnostic_event_bus();
+var imWrapMarker2 = /* @__PURE__ */ Symbol("hamh.wedgeImWrap");
 var AUTO_FORCE_SYNC_INTERVAL_MS2 = 9e4;
 var SHUTDOWN_SESSION_CLOSE_TIMEOUT_MS2 = 2500;
 var MDNS_ADDRESS_CHECK_INTERVAL_MS2 = 6e4;
@@ -174382,11 +175626,11 @@ function makeWarmStartState(state, now = (/* @__PURE__ */ new Date()).toISOStrin
   return { ...state, last_updated: now };
 }
 var ServerModeBridge = class {
-  constructor(logger247, dataProvider, endpointManager, server) {
+  constructor(logger251, dataProvider, endpointManager, server) {
     this.dataProvider = dataProvider;
     this.endpointManager = endpointManager;
     this.server = server;
-    this.log = logger247.get(`ServerModeBridge / ${dataProvider.id}`);
+    this.log = logger251.get(`ServerModeBridge / ${dataProvider.id}`);
   }
   dataProvider;
   endpointManager;
@@ -174407,6 +175651,12 @@ var ServerModeBridge = class {
   sessionStartedAt = /* @__PURE__ */ new Map();
   rotationTimer = null;
   maxSessionAgeMs = 0;
+  // Wedge watchdog: last inbound Interaction Model request time per session and
+  // last time the watchdog rotated it, both keyed by the long-lived session
+  // object so they clear when the session goes away.
+  lastImRequestAt = /* @__PURE__ */ new WeakMap();
+  wedgeLastRotatedAt = /* @__PURE__ */ new WeakMap();
+  wedgeWatchdogTimer = null;
   // Watches the advertised interface addresses so a dynamic ISP IPv6 prefix
   // change forces a fresh operational announcement (#415).
   mdnsAddressTimer = null;
@@ -174470,6 +175720,7 @@ var ServerModeBridge = class {
       const sessionList = sessions.map((s) => {
         const subCount = s.subscriptions.size;
         totalSubscriptions += subCount;
+        const subscriptions = summarizeSubscriptions(s.subscriptions);
         const fi = typeof s.fabric?.fabricIndex === "number" ? s.fabric.fabricIndex : null;
         if (fi !== null) {
           const existing = fabricMap.get(fi) ?? {
@@ -174483,14 +175734,18 @@ var ServerModeBridge = class {
         const nowMs = Date.now();
         const lastActiveMsAgo = typeof s.activeTimestamp === "number" && s.activeTimestamp > 0 ? nowMs - s.activeTimestamp : null;
         const lastAnyActivityMsAgo = typeof s.timestamp === "number" ? nowMs - s.timestamp : null;
+        const lastImAt = this.lastImRequestAt.get(s);
+        const lastImRequestMsAgo = lastImAt != null ? nowMs - lastImAt : null;
         const startedAt = this.sessionStartedAt.get(s.id);
         return {
           id: s.id,
           peerNodeId: String(s.peerNodeId),
           fabricIndex: fi,
           subscriptionCount: subCount,
+          subscriptions,
           lastActiveMsAgo,
           lastAnyActivityMsAgo,
+          lastImRequestMsAgo,
           isPeerActive: Boolean(s.isPeerActive),
           ageMsFromOpen: startedAt != null ? nowMs - startedAt : null
         };
@@ -174554,6 +175809,7 @@ var ServerModeBridge = class {
       this.wireSessionDiagnostics();
       this.wireFabricWarnings();
       this.startSessionRotation();
+      this.startWedgeWatchdog();
       this.startMdnsAddressWatch();
       this.scheduleWarmStart();
       logMemoryUsage(this.log, "server mode bridge running");
@@ -174571,6 +175827,7 @@ ${e?.toString()}`);
   }
   async stop(code = BridgeStatus.Stopped, reason = "Manually stopped") {
     this.stopSessionRotation();
+    this.stopWedgeWatchdog();
     this.stopMdnsAddressWatch();
     this.unwireSessionDiagnostics();
     this.unwireFabricWarnings();
@@ -174603,6 +175860,7 @@ ${e?.toString()}`);
       if (this.status.code === BridgeStatus.Running) {
         this.startAutoForceSyncIfEnabled();
         this.startSessionRotation();
+        this.startWedgeWatchdog();
       }
     } catch (e) {
       const reason = "Failed to update server mode bridge due to error:";
@@ -174787,6 +176045,29 @@ ${e?.toString()}`);
       sessionManager.sessions.added.on(this.sessionAddedHandler);
       sessionManager.sessions.deleted.on(this.sessionDeletedHandler);
       seedExistingSessionStarts(this.sessionStartedAt, sessionManager.sessions);
+      this.wireImRequestTracking();
+    } catch {
+    }
+  }
+  // Stamp the time of every inbound Interaction Model request per session by
+  // wrapping InteractionServer.onNewExchange. The wedge watchdog reads these to
+  // tell a live-but-consuming controller from one that only keeps acking.
+  wireImRequestTracking() {
+    try {
+      const is = this.server.env.get(InteractionServer);
+      const marked = is;
+      if (marked[imWrapMarker2]) {
+        return;
+      }
+      const original = is.onNewExchange.bind(is);
+      is.onNewExchange = (exchange, message) => {
+        const session = exchange.session;
+        if (session) {
+          this.lastImRequestAt.set(session, Date.now());
+        }
+        return original(exchange, message);
+      };
+      marked[imWrapMarker2] = true;
     } catch {
     }
   }
@@ -175004,6 +176285,72 @@ ${e?.toString()}`);
       this.rotationTimer = null;
     }
   }
+  // Opt-in wedge watchdog: reuse the rotation check cadence (5min) to look for
+  // the one session wedged on "Updating" and rotate just that one.
+  startWedgeWatchdog() {
+    this.stopWedgeWatchdog();
+    if (!this.dataProvider.featureFlags?.wedgeWatchdog) {
+      return;
+    }
+    this.wedgeWatchdogTimer = setInterval(
+      () => this.runWedgeWatchdogCheck(),
+      ROTATION_CHECK_INTERVAL_MS
+    );
+    this.log.info(
+      `Wedge watchdog: checking every ${ROTATION_CHECK_INTERVAL_MS / 6e4}min`
+    );
+  }
+  stopWedgeWatchdog() {
+    if (this.wedgeWatchdogTimer) {
+      clearInterval(this.wedgeWatchdogTimer);
+      this.wedgeWatchdogTimer = null;
+    }
+  }
+  // Rotate exactly the sessions the pure rule flags as wedged. Closing is the
+  // same graceful-then-force path age rotation uses, so a false positive just
+  // re-CASEs the controller.
+  runWedgeWatchdogCheck() {
+    try {
+      const sessionManager = this.server.env.get(SessionManager);
+      const now = Date.now();
+      const closes = [];
+      for (const s of [...sessionManager.sessions]) {
+        if (s.isClosing) continue;
+        const startedAt = this.sessionStartedAt.get(s.id);
+        const sessionAgeMs = startedAt != null ? now - startedAt : 0;
+        const lastImAt = this.lastImRequestAt.get(s);
+        const lastImRequestMsAgo = lastImAt != null ? now - lastImAt : null;
+        const lastRotatedAt = this.wedgeLastRotatedAt.get(s);
+        const lastRotatedMsAgo = lastRotatedAt != null ? now - lastRotatedAt : null;
+        if (!decideWedgeRotation({
+          subscriptionCount: s.subscriptions.size,
+          sessionAgeMs,
+          lastImRequestMsAgo,
+          lastRotatedMsAgo
+        })) {
+          continue;
+        }
+        const silenceMin = Math.round(
+          (lastImRequestMsAgo ?? sessionAgeMs) / 6e4
+        );
+        this.log.info(
+          `Wedge watchdog: rotating session ${s.id}, no inbound interaction for ${silenceMin}min`
+        );
+        this.wedgeLastRotatedAt.set(s, now);
+        closes.push(
+          s.initiateClose().catch(() => {
+            return s.initiateForceClose({
+              cause: new Error("wedge watchdog, forcing")
+            });
+          })
+        );
+      }
+      if (closes.length > 0) {
+        Promise.allSettled(closes).then(() => this.triggerMdnsReAnnounce());
+      }
+    } catch {
+    }
+  }
   // Poll the interface addresses mDNS advertises and re-announce when they
   // change. matter.js caches the operational records at first announcement, so
   // a dynamic ISP IPv6 prefix change keeps advertising the dead global address
@@ -175313,12 +176660,12 @@ function ServerModeVacuumDevice(homeAssistantEntity, includeOnOff = false, clean
 }
 
 // src/matter/endpoints/server-mode-vacuum-endpoint.ts
-var logger245 = Logger.get("ServerModeVacuumEndpoint");
+var logger249 = Logger.get("ServerModeVacuumEndpoint");
 var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEndpoint {
-  static async create(registry2, entityId, mapping, endpointId) {
-    const deviceRegistry = registry2.deviceOf(entityId);
-    let state = registry2.initialState(entityId);
-    const entity = registry2.entity(entityId);
+  static async create(registry3, entityId, mapping, endpointId) {
+    const deviceRegistry = registry3.deviceOf(entityId);
+    let state = registry3.initialState(entityId);
+    const entity = registry3.entity(entityId);
     if (!state) {
       return void 0;
     }
@@ -175326,12 +176673,12 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
     if (mapping?.disableBatteryMapping && mapping.batteryEntity) {
       effectiveMapping = { ...mapping, batteryEntity: void 0 };
     }
-    logger245.info(
+    logger249.info(
       `${entityId}: device_id=${entity.device_id}, manualBattery=${mapping?.batteryEntity ?? "none"}`
     );
     if (entity.device_id) {
       if (!mapping?.batteryEntity && !mapping?.disableBatteryMapping) {
-        const batteryEntityId = registry2.findBatteryEntityForDevice(
+        const batteryEntityId = registry3.findBatteryEntityForDevice(
           entity.device_id
         );
         if (batteryEntityId && batteryEntityId !== entityId) {
@@ -175340,22 +176687,22 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
             entityId: effectiveMapping?.entityId ?? entityId,
             batteryEntity: batteryEntityId
           };
-          registry2.markBatteryEntityUsed(batteryEntityId);
-          logger245.info(`${entityId}: Auto-assigned battery ${batteryEntityId}`);
+          registry3.markBatteryEntityUsed(batteryEntityId);
+          logger249.info(`${entityId}: Auto-assigned battery ${batteryEntityId}`);
         } else {
           const attrs = state.attributes;
           if (attrs.battery_level != null || attrs.battery != null) {
-            logger245.info(
+            logger249.info(
               `${entityId}: No battery entity found, using battery attribute from vacuum state`
             );
           } else {
-            logger245.warn(
+            logger249.warn(
               `${entityId}: No battery entity found for device ${entity.device_id}`
             );
           }
         }
       }
-      const vacuumEntities = registry2.findVacuumSelectEntities(
+      const vacuumEntities = registry3.findVacuumSelectEntities(
         entity.device_id
       );
       if (!effectiveMapping?.cleaningModeEntity && vacuumEntities.cleaningModeEntity) {
@@ -175364,7 +176711,7 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
           entityId: effectiveMapping?.entityId ?? entityId,
           cleaningModeEntity: vacuumEntities.cleaningModeEntity
         };
-        logger245.info(
+        logger249.info(
           `${entityId}: Auto-assigned cleaningMode ${vacuumEntities.cleaningModeEntity}`
         );
       }
@@ -175374,7 +176721,7 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
           entityId: effectiveMapping?.entityId ?? entityId,
           suctionLevelEntity: vacuumEntities.suctionLevelEntity
         };
-        logger245.info(
+        logger249.info(
           `${entityId}: Auto-assigned suctionLevel ${vacuumEntities.suctionLevelEntity}`
         );
       }
@@ -175384,7 +176731,7 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
           entityId: effectiveMapping?.entityId ?? entityId,
           mopIntensityEntity: vacuumEntities.mopIntensityEntity
         };
-        logger245.info(
+        logger249.info(
           `${entityId}: Auto-assigned mopIntensity ${vacuumEntities.mopIntensityEntity}`
         );
       }
@@ -175394,12 +176741,12 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
           entityId: effectiveMapping?.entityId ?? entityId,
           currentRoomEntity: vacuumEntities.currentRoomEntity
         };
-        logger245.info(
+        logger249.info(
           `${entityId}: Auto-assigned currentRoom ${vacuumEntities.currentRoomEntity}`
         );
       }
       const supportedFeatures = state.attributes.supported_features ?? 0;
-      const cleanAreaRooms = await registry2.resolveCleanAreaRooms(
+      const cleanAreaRooms = await registry3.resolveCleanAreaRooms(
         entityId,
         supportedFeatures
       );
@@ -175409,13 +176756,13 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
           entityId: effectiveMapping?.entityId ?? entityId,
           cleanAreaRooms
         };
-        logger245.info(
+        logger249.info(
           `${entityId}: Using ${cleanAreaRooms.length} HA areas via CLEAN_AREA`
         );
       }
       const vacAttrs = state.attributes;
       if (cleanAreaRooms.length === 0 && !vacAttrs.rooms && !vacAttrs.segments && !vacAttrs.room_mapping) {
-        const valetudoRooms = registry2.findValetudoMapSegments(
+        const valetudoRooms = registry3.findValetudoMapSegments(
           entity.device_id
         );
         if (valetudoRooms.length > 0) {
@@ -175430,11 +176777,11 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
               rooms: roomsObj
             }
           };
-          logger245.info(
+          logger249.info(
             `${entityId}: Auto-detected ${valetudoRooms.length} Valetudo segments`
           );
         } else {
-          const roborockRooms = await registry2.resolveRoborockRooms(entityId);
+          const roborockRooms = await registry3.resolveRoborockRooms(entityId);
           if (roborockRooms.length > 0) {
             const roomsObj = {};
             for (const r of roborockRooms) {
@@ -175447,14 +176794,14 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
                 rooms: roomsObj
               }
             };
-            logger245.info(
+            logger249.info(
               `${entityId}: Auto-detected ${roborockRooms.length} Roborock rooms`
             );
           }
         }
       }
     } else {
-      logger245.warn(`${entityId}: No device_id, cannot auto-assign battery`);
+      logger249.warn(`${entityId}: No device_id, cannot auto-assign battery`);
     }
     const payload = {
       entity_id: entityId,
@@ -175465,7 +176812,7 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
     const vacAttrsForClean = state.attributes;
     let cleaningModeOptions;
     if (effectiveMapping?.cleaningModeEntity) {
-      const cmState = registry2.initialState(
+      const cmState = registry3.initialState(
         effectiveMapping.cleaningModeEntity
       );
       cleaningModeOptions = cmState?.attributes?.options;
@@ -175485,7 +176832,7 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
         customName,
         mapping: effectiveMapping
       },
-      registry2.isServerModeVacuumOnOffEnabled(),
+      registry3.isServerModeVacuumOnOffEnabled(),
       cleaningModeOptions
     );
     if (!endpointType) {
@@ -175527,11 +176874,11 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
     }
     if (mappedChanged) {
       this.pendingMappedChange = true;
-      logger245.debug(
+      logger249.debug(
         `Mapped entity change detected for ${this.entityId}, forcing update`
       );
     }
-    logger245.debug(
+    logger249.debug(
       `State update received for ${this.entityId}: state=${state.state}`
     );
     this.lastState = state;
@@ -175571,12 +176918,13 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
 // src/services/bridges/server-mode-endpoint-manager.ts
 var MAX_SERVER_MODE_DEVICES = 10;
 var ServerModeEndpointManager = class extends Service {
-  constructor(serverNode, client, registry2, mappingStorage, identityStorage, dataProvider, log) {
+  constructor(serverNode, client, registry3, mappingStorage, identityStorage, dataProvider, log) {
     super("ServerModeEndpointManager");
     this.serverNode = serverNode;
     this.client = client;
-    this.registry = registry2;
+    this.registry = registry3;
     this.mappingStorage = mappingStorage;
+    this.identityStorage = identityStorage;
     this.dataProvider = dataProvider;
     this.log = log;
     this.identityResolver = new IdentityResolver(
@@ -175588,6 +176936,7 @@ var ServerModeEndpointManager = class extends Service {
   client;
   registry;
   mappingStorage;
+  identityStorage;
   dataProvider;
   log;
   entityIds = [];
@@ -175687,6 +177036,17 @@ var ServerModeEndpointManager = class extends Service {
     this.registry.refresh();
     this._failedEntities = [];
     this.entityIds = this.registry.entityIds;
+    const fullEntities = this.registry.fullEntities;
+    stampIdentityPresence(
+      this.identityStorage,
+      this.dataProvider.id,
+      buildPresentIdentityKeys(fullEntities)
+    );
+    stampMappingPresence(
+      this.mappingStorage,
+      this.dataProvider.id,
+      buildPresentEntityIds(fullEntities)
+    );
     try {
       if (this.entityIds.length === 0) {
         this.log.warn("Server mode bridge has no entities configured");
@@ -176096,10 +177456,10 @@ var BridgeEnvironmentFactory = class extends BridgeFactory {
 // src/core/ioc/app-environment.ts
 var AppEnvironment = class _AppEnvironment extends EnvironmentBase {
   constructor(rootEnv, options) {
-    const logger247 = rootEnv.get(LoggerService);
+    const logger251 = rootEnv.get(LoggerService);
     super({
       id: "App",
-      log: logger247.get("AppContainer"),
+      log: logger251.get("AppContainer"),
       parent: rootEnv
     });
     this.options = options;
@@ -176113,8 +177473,8 @@ var AppEnvironment = class _AppEnvironment extends EnvironmentBase {
   }
   construction;
   async init() {
-    const logger247 = this.get(LoggerService);
-    this.set(LoggerService, logger247);
+    const logger251 = this.get(LoggerService);
+    this.set(LoggerService, logger251);
     this.set(AppStorage, new AppStorage(await this.load(StorageService)));
     this.set(BridgeStorage, new BridgeStorage(await this.load(AppStorage)));
     this.set(
@@ -176135,7 +177495,7 @@ var AppEnvironment = class _AppEnvironment extends EnvironmentBase {
     );
     this.set(
       HomeAssistantClient,
-      new HomeAssistantClient(logger247, this.options.homeAssistant)
+      new HomeAssistantClient(logger251, this.options.homeAssistant)
     );
     this.set(
       HomeAssistantConfig,
@@ -176143,7 +177503,7 @@ var AppEnvironment = class _AppEnvironment extends EnvironmentBase {
     );
     this.set(
       HomeAssistantActions,
-      new HomeAssistantActions(logger247, await this.load(HomeAssistantClient))
+      new HomeAssistantActions(logger251, await this.load(HomeAssistantClient))
     );
     this.set(
       HomeAssistantRegistry,
@@ -176179,7 +177539,7 @@ var AppEnvironment = class _AppEnvironment extends EnvironmentBase {
     this.set(
       WebApi,
       new WebApi(
-        logger247,
+        logger251,
         await this.load(BridgeService),
         await this.load(HomeAssistantClient),
         await this.load(HomeAssistantRegistry),
@@ -176200,7 +177560,7 @@ var AppEnvironment = class _AppEnvironment extends EnvironmentBase {
 
 // src/matter/patches/patch-level-control-tlv.ts
 init_esm();
-var logger246 = Logger.get("PatchLevelControlTlv");
+var logger250 = Logger.get("PatchLevelControlTlv");
 var optionalFieldModels = /* @__PURE__ */ new WeakSet();
 var fieldModelMandatoryGetterPatched = false;
 function patchLevelControlTlv() {
@@ -176256,11 +177616,11 @@ function patchLevelControlTlv() {
     patched++;
   }
   if (patched > 0) {
-    logger246.info(
+    logger250.info(
       `Patched ${patched} LevelControl TLV schema(s): transitionTime is now optional (Google Home compatibility)`
     );
   } else {
-    logger246.warn(
+    logger250.warn(
       "Failed to patch LevelControl TLV schemas, field definitions not found. Google Home brightness adjustment may not work.",
       {
         moveToLevel: describeFields(