@riddix/hamh 2.1.0-alpha.836 → 2.1.0-alpha.838

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(logger248) {
+        this.#logger = logger248;
       }
       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, logger248, 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 = logger248;
         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 logger248 = Logger.get(this.#subject.constructor.name);
+          logger248.error(...args);
         }
         #createErrorHandler(name) {
           return (e) => {
@@ -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(logger248, operation, session, messenger, fabric, peerNodeId) {
+        logger248.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 logger248 = loggers.get(facility);
+        if (!logger248) {
+          loggers.set(facility, logger248 = Logger.get(facility));
         }
-        logger247[level](Diagnostic.via(id || "(anon)"), message);
+        logger248[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",
@@ -132624,10 +132631,10 @@ var init_home_assistant_actions = __esm({
       circuitBreakerResetMs: 3e4
     };
     HomeAssistantActions = class extends Service {
-      constructor(logger247, client, config11) {
+      constructor(logger248, client, config11) {
         super("HomeAssistantActions");
         this.client = client;
-        this.log = logger247.get(this);
+        this.log = logger248.get(this);
         this.config = { ...defaultConfig, ...config11 };
         this.circuitBreaker = new CircuitBreaker(
           this.config.circuitBreakerThreshold,
@@ -132973,10 +132980,10 @@ var DiagnosticService = class {
 };
 
 // src/api/access-log.ts
-function accessLogger(logger247) {
+function accessLogger(logger248) {
   return (req, res, next) => {
     res.on("finish", () => {
-      logger247.debug(
+      logger248.debug(
         `${req.method} ${decodeURI(req.originalUrl)} ${res.statusCode} ${res.statusMessage} from ${req.socket.remoteAddress}`
       );
     });
@@ -133161,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,
@@ -133322,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,
@@ -134174,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,
@@ -134675,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,
@@ -134814,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,
@@ -135040,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;
@@ -135085,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({});
@@ -135188,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);
@@ -137161,7 +137530,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(logger248, bridgeService, haClient, haRegistry, bridgeStorage, mappingStorage, identityStorage, lockCredentialStorage, settingsStorage, backupService, props) {
     super("WebApi");
     this.bridgeService = bridgeService;
     this.haClient = haClient;
@@ -137173,8 +137542,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 = logger248;
+    this.log = logger248.get(this);
     this.accessLogger = accessLogger(this.log.createChild("Access Log"));
     this.startTime = Date.now();
     this.wsApi = new WebSocketApi(
@@ -137207,7 +137576,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(
@@ -138360,10 +138734,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(logger248, options) {
     super("HomeAssistantClient");
     this.options = options;
-    this.log = logger247.get(this);
+    this.log = logger248.get(this);
   }
   options;
   static Options = /* @__PURE__ */ Symbol.for("HomeAssistantClientProps");
@@ -139028,11 +139402,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");
@@ -139041,10 +139441,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,
@@ -139079,6 +139483,10 @@ var EntityMappingStorage = class extends Service {
     }
   }
   async persist() {
+    if (this.persistTimer) {
+      clearTimeout(this.persistTimer);
+      this.persistTimer = null;
+    }
     const data = {
       version: CURRENT_VERSION2,
       mappings: {}
@@ -139088,6 +139496,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()) : [];
@@ -139134,6 +139553,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,
@@ -139162,7 +139583,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);
@@ -139181,6 +139602,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 === "") {
@@ -149106,6 +149544,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();
@@ -156832,11 +157271,11 @@ var AUTO_FORCE_SYNC_INTERVAL_MS = 9e4;
 var SHUTDOWN_SESSION_CLOSE_TIMEOUT_MS = 2500;
 var MDNS_ADDRESS_CHECK_INTERVAL_MS = 6e4;
 var Bridge = class {
-  constructor(env, logger247, dataProvider, endpointManager, serverOptions) {
+  constructor(env, logger248, dataProvider, endpointManager, serverOptions) {
     this.dataProvider = dataProvider;
     this.endpointManager = endpointManager;
     this.serverOptions = serverOptions;
-    this.log = logger247.get(`Bridge / ${dataProvider.id}`);
+    this.log = logger248.get(`Bridge / ${dataProvider.id}`);
     this.server = new BridgeServerNode(
       env,
       this.dataProvider,
@@ -157888,66 +158327,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();
@@ -167520,6 +167899,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 {
@@ -168259,7 +168916,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;
@@ -168300,17 +168957,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}"`
       );
     }
@@ -168524,7 +169181,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
 );
@@ -168548,11 +169205,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);
@@ -168575,7 +169232,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,
@@ -168587,9 +169244,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 });
@@ -169014,7 +169671,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) {
@@ -169031,19 +169688,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" });
@@ -169242,14 +169899,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)];
@@ -169258,7 +169915,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(", ")}`
@@ -169270,7 +169927,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 {
@@ -169291,7 +169948,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({
@@ -169308,7 +169965,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)];
@@ -169317,7 +169974,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(", ")}`
@@ -169329,7 +169986,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 {
@@ -169350,14 +170007,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,
@@ -169369,7 +170026,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;
@@ -169448,13 +170105,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(", ")}`
       );
     }
@@ -169508,7 +170165,7 @@ function createCustomServiceAreaServer(customAreas) {
       landmarkInfo: null
     }
   }));
-  logger234.info(
+  logger235.info(
     `Using ${customAreas.length} custom service areas: ${customAreas.map((a) => a.name).join(", ")}`
   );
   return ServiceAreaServer2({
@@ -169530,7 +170187,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({
@@ -169541,11 +170198,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 {
@@ -169650,14 +170307,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 = [];
@@ -169678,7 +170335,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 }) => ({
@@ -169716,7 +170373,7 @@ function vacuumIsCleaning(state) {
 var vacuumRvcRunModeConfig = {
   getCurrentMode: (entity) => {
     const isCleaning = vacuumIsCleaning(entity.state);
-    logger235.debug(
+    logger236.debug(
       `Vacuum state: "${entity.state}", isCleaning: ${isCleaning}, currentMode: ${isCleaning ? "Cleaning" : "Idle"}`
     );
     return isCleaning ? 1 /* Cleaning */ : 0 /* Idle */;
@@ -169750,7 +170407,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 {
@@ -169769,7 +170426,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 }) => ({
@@ -169803,14 +170460,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({
@@ -169837,7 +170494,7 @@ var vacuumRvcRunModeConfig = {
           }
           if (isEcovacsVacuum(attributes9)) {
             const roomIdStr = roomIds.join(",");
-            logger235.info(
+            logger236.info(
               `Ecovacs vacuum: Using spot_area for rooms: ${roomIdStr}`
             );
             return {
@@ -169852,14 +170509,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" }),
@@ -169874,7 +170531,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(
@@ -169883,7 +170540,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 {
@@ -169900,7 +170557,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 {
@@ -169921,7 +170578,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);
@@ -169931,7 +170588,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({
@@ -169940,7 +170597,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 {
@@ -169951,7 +170608,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 {
@@ -169964,7 +170621,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 {
@@ -169979,7 +170636,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`
       );
     }
@@ -169996,20 +170653,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}`
     );
   }
@@ -170043,7 +170700,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, {
@@ -170133,7 +170790,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)
@@ -170180,14 +170837,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;
@@ -170195,7 +170852,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);
@@ -170228,7 +170885,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;
@@ -170498,7 +171155,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];
@@ -170507,7 +171164,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 {
@@ -170596,7 +171253,7 @@ function createCleanModeConfig(fanSpeedList, mopIntensityList, cleaningModeOptio
           }
         }
         if (speedMode !== void 0) {
-          logger237.debug(
+          logger238.debug(
             `Current mode: Vacuum + fan_speed="${speedState}" -> mode ${speedMode}`
           );
           return speedMode;
@@ -170617,7 +171274,7 @@ function createCleanModeConfig(fanSpeedList, mopIntensityList, cleaningModeOptio
           }
         }
         if (mopMode !== void 0) {
-          logger237.debug(
+          logger238.debug(
             `Current mode: Mop + intensity="${state}" -> mode ${mopMode}`
           );
           return mopMode;
@@ -170635,14 +171292,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) {
@@ -170655,18 +171312,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 {
@@ -170675,11 +171332,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`
           );
         }
@@ -170689,7 +171346,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) {
@@ -170702,7 +171359,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(
@@ -170712,12 +171369,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 {
@@ -170726,7 +171383,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;
@@ -170736,7 +171393,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 {
@@ -170746,7 +171403,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;
@@ -170758,7 +171415,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 {
@@ -170776,10 +171433,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 = {
@@ -170842,7 +171499,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;
@@ -170893,16 +171550,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;
@@ -170931,7 +171588,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,
@@ -170945,7 +171602,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;
@@ -170958,32 +171615,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(
@@ -170994,7 +171651,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(
@@ -171007,7 +171664,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;
@@ -171173,7 +171830,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,
@@ -171189,7 +171846,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;
@@ -171429,6 +172086,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 }),
@@ -171444,7 +172102,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;
@@ -171520,7 +172178,7 @@ var UserComposedEndpoint = class _UserComposedEndpoint extends Endpoint {
       { vacuumOnOff: registry2.isVacuumOnOffEnabled() }
     );
     if (!primaryType) {
-      logger241.warn(
+      logger242.warn(
         `Cannot create endpoint type for primary entity ${primaryEntityId}`
       );
       return void 0;
@@ -171535,7 +172193,7 @@ var UserComposedEndpoint = class _UserComposedEndpoint extends Endpoint {
       if (!sub.entityId) continue;
       const subPayload = buildEntityPayload4(registry2, 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;
@@ -171550,7 +172208,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;
@@ -171563,7 +172221,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;
@@ -171587,7 +172245,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;
@@ -171693,7 +172351,7 @@ 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);
@@ -171703,25 +172361,25 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
       return;
     }
     if (registry2.isAutoBatteryMappingEnabled() && registry2.isBatteryEntityUsed(entityId)) {
-      logger242.debug(
+      logger243.debug(
         `Skipping ${entityId} - already auto-assigned as battery to another device`
       );
       return;
     }
     if (registry2.isAutoHumidityMappingEnabled() && registry2.isHumidityEntityUsed(entityId)) {
-      logger242.debug(
+      logger243.debug(
         `Skipping ${entityId} - already auto-assigned as humidity to a temperature sensor`
       );
       return;
     }
     if (registry2.isAutoPressureMappingEnabled() && registry2.isPressureEntityUsed(entityId)) {
-      logger242.debug(
+      logger243.debug(
         `Skipping ${entityId} - already auto-assigned as pressure to a temperature sensor`
       );
       return;
     }
     if (registry2.isAutoComposedDevicesEnabled() && registry2.isComposedSubEntityUsed(entityId)) {
-      logger242.debug(
+      logger243.debug(
         `Skipping ${entityId} - already consumed by a composed device`
       );
       return;
@@ -171741,7 +172399,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
               humidityEntity: humidityEntityId
             };
             registry2.markHumidityEntityUsed(humidityEntityId);
-            logger242.debug(
+            logger243.debug(
               `Auto-assigned humidity ${humidityEntityId} to ${entityId}`
             );
           }
@@ -171760,7 +172418,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
               pressureEntity: pressureEntityId
             };
             registry2.markPressureEntityUsed(pressureEntityId);
-            logger242.debug(
+            logger243.debug(
               `Auto-assigned pressure ${pressureEntityId} to ${entityId}`
             );
           }
@@ -171778,7 +172436,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
             batteryEntity: batteryEntityId
           };
           registry2.markBatteryEntityUsed(batteryEntityId);
-          logger242.debug(
+          logger243.debug(
             `Auto-assigned battery ${batteryEntityId} to ${entityId}`
           );
         }
@@ -171795,7 +172453,7 @@ 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) {
@@ -171811,7 +172469,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
               powerEntity: powerEntityId
             };
             registry2.markPowerEntityUsed(powerEntityId);
-            logger242.debug(`Auto-assigned power ${powerEntityId} to ${entityId}`);
+            logger243.debug(`Auto-assigned power ${powerEntityId} to ${entityId}`);
           }
         }
       }
@@ -171828,7 +172486,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
               energyEntity: energyEntityId
             };
             registry2.markEnergyEntityUsed(energyEntityId);
-            logger242.debug(
+            logger243.debug(
               `Auto-assigned energy ${energyEntityId} to ${entityId}`
             );
           }
@@ -171844,7 +172502,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}`
           );
         }
@@ -171854,7 +172512,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}`
           );
         }
@@ -171864,7 +172522,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}`
           );
         }
@@ -171874,7 +172532,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
             entityId: effectiveMapping?.entityId ?? entityId,
             currentRoomEntity: vacuumEntities.currentRoomEntity
           };
-          logger242.info(
+          logger243.info(
             `Auto-assigned currentRoom ${vacuumEntities.currentRoomEntity} to ${entityId}`
           );
         }
@@ -171889,7 +172547,7 @@ 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}`
           );
         }
@@ -171910,7 +172568,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
                 rooms: roomsObj
               }
             };
-            logger242.debug(
+            logger243.debug(
               `Auto-detected ${valetudoRooms.length} Valetudo segments for ${entityId}`
             );
           } else {
@@ -171927,7 +172585,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
                   rooms: roomsObj
                 }
               };
-              logger242.debug(
+              logger243.debug(
                 `Auto-detected ${roborockRooms.length} Roborock rooms for ${entityId}`
               );
             }
@@ -171936,7 +172594,7 @@ 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`
       );
     }
@@ -171955,7 +172613,7 @@ 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`
       );
     }
@@ -172020,7 +172678,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`
         );
       }
@@ -172100,11 +172758,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;
@@ -172683,7 +173341,7 @@ import {
   getCollection
 } from "home-assistant-js-websocket";
 import { atLeastHaVersion } from "home-assistant-js-websocket/dist/util.js";
-var logger243 = Logger.get("SubscribeEntities");
+var logger244 = Logger.get("SubscribeEntities");
 function processEvent(store, updates) {
   const state = { ...store.state };
   if (updates.a) {
@@ -172709,7 +173367,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);
+        logger244.warn("Received state update for unknown entity", entityId);
         continue;
       }
       entityState = { ...entityState };
@@ -172798,7 +173456,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 logger245 = Logger.get("EntityIsolation");
 var EntityIsolationServiceImpl = class {
   isolatedEntities = /* @__PURE__ */ new Map();
   isolationCallbacks = /* @__PURE__ */ new Map();
@@ -172863,13 +173521,13 @@ var EntityIsolationServiceImpl = class {
     }
     const parsed = this.parseEndpointPath(msg);
     if (!parsed) {
-      logger244.warn("Could not parse entity from error:", msg);
+      logger245.warn("Could not parse entity from error:", msg);
       return false;
     }
     const { bridgeId, entityName } = parsed;
     const callback = this.isolationCallbacks.get(bridgeId);
     if (!callback) {
-      logger244.warn(
+      logger245.warn(
         `No isolation callback registered for bridge ${bridgeId}, entity: ${entityName}`
       );
       return false;
@@ -172884,7 +173542,7 @@ var EntityIsolationServiceImpl = class {
       reason,
       failedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
-    logger244.warn(
+    logger245.warn(
       `Isolating entity "${entityName}" from bridge ${bridgeId} due to: ${reason}`
     );
     diagnosticEventBus.emit("entity_error", `Entity isolated: ${entityName}`, {
@@ -172896,7 +173554,7 @@ var EntityIsolationServiceImpl = class {
       await callback(entityName);
       return true;
     } catch (e) {
-      logger244.error(`Failed to isolate entity ${entityName}:`, e);
+      logger245.error(`Failed to isolate entity ${entityName}:`, e);
       return false;
     }
   }
@@ -172925,119 +173583,6 @@ 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;
@@ -173047,6 +173592,7 @@ var BridgeEndpointManager = class extends Service {
     this.client = client;
     this.registry = registry2;
     this.mappingStorage = mappingStorage;
+    this.identityStorage = identityStorage;
     this.bridgeId = bridgeId;
     this.log = log;
     this.pluginManager = pluginManager;
@@ -173068,6 +173614,7 @@ var BridgeEndpointManager = class extends Service {
   client;
   registry;
   mappingStorage;
+  identityStorage;
   bridgeId;
   log;
   pluginManager;
@@ -173465,6 +174012,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) {
@@ -173784,6 +174342,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.
@@ -174509,11 +175072,11 @@ function makeWarmStartState(state, now = (/* @__PURE__ */ new Date()).toISOStrin
   return { ...state, last_updated: now };
 }
 var ServerModeBridge = class {
-  constructor(logger247, dataProvider, endpointManager, server) {
+  constructor(logger248, dataProvider, endpointManager, server) {
     this.dataProvider = dataProvider;
     this.endpointManager = endpointManager;
     this.server = server;
-    this.log = logger247.get(`ServerModeBridge / ${dataProvider.id}`);
+    this.log = logger248.get(`ServerModeBridge / ${dataProvider.id}`);
   }
   dataProvider;
   endpointManager;
@@ -175541,7 +176104,7 @@ function ServerModeVacuumDevice(homeAssistantEntity, includeOnOff = false, clean
 }
 
 // src/matter/endpoints/server-mode-vacuum-endpoint.ts
-var logger245 = Logger.get("ServerModeVacuumEndpoint");
+var logger246 = Logger.get("ServerModeVacuumEndpoint");
 var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEndpoint {
   static async create(registry2, entityId, mapping, endpointId) {
     const deviceRegistry = registry2.deviceOf(entityId);
@@ -175554,7 +176117,7 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
     if (mapping?.disableBatteryMapping && mapping.batteryEntity) {
       effectiveMapping = { ...mapping, batteryEntity: void 0 };
     }
-    logger245.info(
+    logger246.info(
       `${entityId}: device_id=${entity.device_id}, manualBattery=${mapping?.batteryEntity ?? "none"}`
     );
     if (entity.device_id) {
@@ -175569,15 +176132,15 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
             batteryEntity: batteryEntityId
           };
           registry2.markBatteryEntityUsed(batteryEntityId);
-          logger245.info(`${entityId}: Auto-assigned battery ${batteryEntityId}`);
+          logger246.info(`${entityId}: Auto-assigned battery ${batteryEntityId}`);
         } else {
           const attrs = state.attributes;
           if (attrs.battery_level != null || attrs.battery != null) {
-            logger245.info(
+            logger246.info(
               `${entityId}: No battery entity found, using battery attribute from vacuum state`
             );
           } else {
-            logger245.warn(
+            logger246.warn(
               `${entityId}: No battery entity found for device ${entity.device_id}`
             );
           }
@@ -175592,7 +176155,7 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
           entityId: effectiveMapping?.entityId ?? entityId,
           cleaningModeEntity: vacuumEntities.cleaningModeEntity
         };
-        logger245.info(
+        logger246.info(
           `${entityId}: Auto-assigned cleaningMode ${vacuumEntities.cleaningModeEntity}`
         );
       }
@@ -175602,7 +176165,7 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
           entityId: effectiveMapping?.entityId ?? entityId,
           suctionLevelEntity: vacuumEntities.suctionLevelEntity
         };
-        logger245.info(
+        logger246.info(
           `${entityId}: Auto-assigned suctionLevel ${vacuumEntities.suctionLevelEntity}`
         );
       }
@@ -175612,7 +176175,7 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
           entityId: effectiveMapping?.entityId ?? entityId,
           mopIntensityEntity: vacuumEntities.mopIntensityEntity
         };
-        logger245.info(
+        logger246.info(
           `${entityId}: Auto-assigned mopIntensity ${vacuumEntities.mopIntensityEntity}`
         );
       }
@@ -175622,7 +176185,7 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
           entityId: effectiveMapping?.entityId ?? entityId,
           currentRoomEntity: vacuumEntities.currentRoomEntity
         };
-        logger245.info(
+        logger246.info(
           `${entityId}: Auto-assigned currentRoom ${vacuumEntities.currentRoomEntity}`
         );
       }
@@ -175637,7 +176200,7 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
           entityId: effectiveMapping?.entityId ?? entityId,
           cleanAreaRooms
         };
-        logger245.info(
+        logger246.info(
           `${entityId}: Using ${cleanAreaRooms.length} HA areas via CLEAN_AREA`
         );
       }
@@ -175658,7 +176221,7 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
               rooms: roomsObj
             }
           };
-          logger245.info(
+          logger246.info(
             `${entityId}: Auto-detected ${valetudoRooms.length} Valetudo segments`
           );
         } else {
@@ -175675,14 +176238,14 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
                 rooms: roomsObj
               }
             };
-            logger245.info(
+            logger246.info(
               `${entityId}: Auto-detected ${roborockRooms.length} Roborock rooms`
             );
           }
         }
       }
     } else {
-      logger245.warn(`${entityId}: No device_id, cannot auto-assign battery`);
+      logger246.warn(`${entityId}: No device_id, cannot auto-assign battery`);
     }
     const payload = {
       entity_id: entityId,
@@ -175755,11 +176318,11 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
     }
     if (mappedChanged) {
       this.pendingMappedChange = true;
-      logger245.debug(
+      logger246.debug(
         `Mapped entity change detected for ${this.entityId}, forcing update`
       );
     }
-    logger245.debug(
+    logger246.debug(
       `State update received for ${this.entityId}: state=${state.state}`
     );
     this.lastState = state;
@@ -175805,6 +176368,7 @@ var ServerModeEndpointManager = class extends Service {
     this.client = client;
     this.registry = registry2;
     this.mappingStorage = mappingStorage;
+    this.identityStorage = identityStorage;
     this.dataProvider = dataProvider;
     this.log = log;
     this.identityResolver = new IdentityResolver(
@@ -175816,6 +176380,7 @@ var ServerModeEndpointManager = class extends Service {
   client;
   registry;
   mappingStorage;
+  identityStorage;
   dataProvider;
   log;
   entityIds = [];
@@ -175915,6 +176480,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");
@@ -176324,10 +176900,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 logger248 = rootEnv.get(LoggerService);
     super({
       id: "App",
-      log: logger247.get("AppContainer"),
+      log: logger248.get("AppContainer"),
       parent: rootEnv
     });
     this.options = options;
@@ -176341,8 +176917,8 @@ var AppEnvironment = class _AppEnvironment extends EnvironmentBase {
   }
   construction;
   async init() {
-    const logger247 = this.get(LoggerService);
-    this.set(LoggerService, logger247);
+    const logger248 = this.get(LoggerService);
+    this.set(LoggerService, logger248);
     this.set(AppStorage, new AppStorage(await this.load(StorageService)));
     this.set(BridgeStorage, new BridgeStorage(await this.load(AppStorage)));
     this.set(
@@ -176363,7 +176939,7 @@ var AppEnvironment = class _AppEnvironment extends EnvironmentBase {
     );
     this.set(
       HomeAssistantClient,
-      new HomeAssistantClient(logger247, this.options.homeAssistant)
+      new HomeAssistantClient(logger248, this.options.homeAssistant)
     );
     this.set(
       HomeAssistantConfig,
@@ -176371,7 +176947,7 @@ var AppEnvironment = class _AppEnvironment extends EnvironmentBase {
     );
     this.set(
       HomeAssistantActions,
-      new HomeAssistantActions(logger247, await this.load(HomeAssistantClient))
+      new HomeAssistantActions(logger248, await this.load(HomeAssistantClient))
     );
     this.set(
       HomeAssistantRegistry,
@@ -176407,7 +176983,7 @@ var AppEnvironment = class _AppEnvironment extends EnvironmentBase {
     this.set(
       WebApi,
       new WebApi(
-        logger247,
+        logger248,
         await this.load(BridgeService),
         await this.load(HomeAssistantClient),
         await this.load(HomeAssistantRegistry),
@@ -176428,7 +177004,7 @@ var AppEnvironment = class _AppEnvironment extends EnvironmentBase {
 
 // src/matter/patches/patch-level-control-tlv.ts
 init_esm();
-var logger246 = Logger.get("PatchLevelControlTlv");
+var logger247 = Logger.get("PatchLevelControlTlv");
 var optionalFieldModels = /* @__PURE__ */ new WeakSet();
 var fieldModelMandatoryGetterPatched = false;
 function patchLevelControlTlv() {
@@ -176484,11 +177060,11 @@ function patchLevelControlTlv() {
     patched++;
   }
   if (patched > 0) {
-    logger246.info(
+    logger247.info(
       `Patched ${patched} LevelControl TLV schema(s): transitionTime is now optional (Google Home compatibility)`
     );
   } else {
-    logger246.warn(
+    logger247.warn(
       "Failed to patch LevelControl TLV schemas, field definitions not found. Google Home brightness adjustment may not work.",
       {
         moveToLevel: describeFields(