@riddix/hamh 2.1.0-alpha.868 → 2.1.0-alpha.869

package/dist/backend/cli.js

@@ -160300,7 +160300,7 @@ var PowerSourceServerBase = class extends FeaturedBase3 {
     }
     let batChargeState = PowerSource3.BatChargeState.Unknown;
     if (isCharging2 === true) {
-      batChargeState = batteryPercent != null && batteryPercent >= 100 ? PowerSource3.BatChargeState.IsAtFullCharge : PowerSource3.BatChargeState.IsCharging;
+      batChargeState = batteryPercent == null ? PowerSource3.BatChargeState.Unknown : batteryPercent >= 100 ? PowerSource3.BatChargeState.IsAtFullCharge : PowerSource3.BatChargeState.IsCharging;
     } else if (isCharging2 === false) {
       batChargeState = PowerSource3.BatChargeState.IsNotCharging;
     }
@@ -173213,10 +173213,12 @@ function isCharging(entity) {
   if (attrs.is_charging === false || attrs.charging === false) return false;
   const level = batteryFromAttributes(entity.attributes);
   if (level != null && level >= 100) return false;
+  const status3 = typeof attrs.status === "string" ? attrs.status.toLowerCase().replace(/[-_]/g, " ") : "";
+  if (status3.includes("discharg") || status3.includes("not charg") || status3.includes("full") || status3.includes("complete")) {
+    return false;
+  }
   if (attrs.battery_icon?.includes("charging")) return true;
-  if (typeof attrs.status === "string" && attrs.status.toLowerCase().includes("charg"))
-    return true;
-  return false;
+  return status3.includes("charg");
 }
 function isDockedCharging(entity, batteryPercent) {
   const attrs = entity.attributes;
@@ -175132,6 +175134,9 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
       )) {
         return;
       }
+      if (errorMessage.includes("is not present on this endpoint")) {
+        return;
+      }
       throw error;
     }
   }
@@ -177322,1827 +177327,1964 @@ var subscribeEntities = (conn, onChange, entityIds) => {
   });
 };
 
-// src/services/bridges/entity-isolation-service.ts
+// src/services/bridges/bridge-registry.ts
+init_dist();
 init_esm();
-init_diagnostic_event_bus();
-var logger252 = Logger.get("EntityIsolation");
-var EntityIsolationServiceImpl = class {
-  isolatedEntities = /* @__PURE__ */ new Map();
-  isolationCallbacks = /* @__PURE__ */ new Map();
-  /**
-   * Register a callback to be called when an entity needs to be isolated.
-   * The callback should remove the entity from the bridge's aggregator.
-   */
-  registerIsolationCallback(bridgeId, callback) {
-    this.isolationCallbacks.set(bridgeId, callback);
+init_send_ha_message();
+import { callService as callService2 } from "home-assistant-js-websocket";
+import { keys as keys2, pickBy, values as values3 } from "lodash-es";
+function fingerprintBattery(fingerprint) {
+  try {
+    const parsed = JSON.parse(fingerprint);
+    return Array.isArray(parsed) && typeof parsed[1] === "string" ? parsed[1] : null;
+  } catch {
+    return null;
   }
-  unregisterIsolationCallback(bridgeId) {
-    this.isolationCallbacks.delete(bridgeId);
+}
+var BridgeRegistry = class _BridgeRegistry {
+  constructor(registry3, dataProvider, client) {
+    this.registry = registry3;
+    this.dataProvider = dataProvider;
+    this.client = client;
+    this.refresh();
+  }
+  registry;
+  dataProvider;
+  client;
+  get entityIds() {
+    return keys2(this._entities);
+  }
+  _devices = {};
+  _entities = {};
+  _states = {};
+  // Track battery entities that have been auto-assigned to other devices
+  _usedBatteryEntities = /* @__PURE__ */ new Set();
+  // Cache for battery entity lookups (deviceId -> entityId or null)
+  _batteryEntityCache = /* @__PURE__ */ new Map();
+  // Cache for problem entity lookups (deviceId -> entityId or null) (#408)
+  _problemEntityCache = /* @__PURE__ */ new Map();
+  // Track humidity entities that have been auto-assigned to temperature sensors
+  _usedHumidityEntities = /* @__PURE__ */ new Set();
+  // Track pressure entities that have been auto-assigned to temperature sensors
+  _usedPressureEntities = /* @__PURE__ */ new Set();
+  // Track power entities that have been auto-assigned to switch/plug entities
+  _usedPowerEntities = /* @__PURE__ */ new Set();
+  // Track energy entities that have been auto-assigned to switch/plug entities
+  _usedEnergyEntities = /* @__PURE__ */ new Set();
+  // Track entities consumed by composed devices (e.g., sensors/climate grouped under air purifier)
+  _usedComposedSubEntities = /* @__PURE__ */ new Set();
+  deviceOf(entityId) {
+    const entity = this._entities[entityId];
+    return this._devices[entity.device_id];
+  }
+  entity(entityId) {
+    return this._entities[entityId];
+  }
+  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;
+  }
+  // Successful-reload counter, see HomeAssistantRegistry (#438).
+  get snapshotGeneration() {
+    return this.registry.snapshotGeneration;
+  }
+  // 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.
+  initialStateIncludingUnfiltered(entityId) {
+    return this._states[entityId] ?? this.registry.states[entityId];
+  }
+  entityIncludingUnfiltered(entityId) {
+    return this._entities[entityId] ?? this.registry.entities[entityId];
+  }
+  deviceOfIncludingUnfiltered(entityId) {
+    const entity = this.entityIncludingUnfiltered(entityId);
+    if (!entity) return void 0;
+    return this._devices[entity.device_id] ?? this.registry.devices[entity.device_id];
   }
   /**
-   * Parse the endpoint path from a Matter.js error message and extract the entity name.
-   * Example path: "ed5b4f8d042e4599b833f21da4ededba.aggregator.Küchenlicht.onOff.on"
-   * Returns: { bridgeId: "ed5b4f8d...", entityName: "Küchenlicht" }
+   * The battery sensor the auto-mapping would resolve for this entity right
+   * now, or "" when auto-mapping does not apply. Part of the endpoint mapping
+   * fingerprint: a sensor that was unavailable at endpoint creation used to be
+   * negative-cached forever, the endpoint never rebuilt and the vacuum lost
+   * its battery until a full restart (#450).
    */
-  parseEndpointPath(errorMessage) {
-    const match = errorMessage.match(/([a-f0-9]{32})\.aggregator\.([^.\s>]+)/i);
-    if (match) {
-      return {
-        bridgeId: match[1],
-        entityName: match[2]
-      };
-    }
-    return null;
-  }
-  classifyError(msg) {
-    if (msg.includes("Invalid intervalMs")) {
-      return "Subscription timing error (Invalid intervalMs)";
-    }
-    if (msg.includes("Behaviors have errors")) {
-      return "Behavior initialization failure";
-    }
-    if (msg.includes("TransactionDestroyedError")) {
-      return "Transaction destroyed during operation";
-    }
-    if (msg.includes("DestroyedDependencyError")) {
-      return "Dependency destroyed during operation";
-    }
-    if (msg.includes("UninitializedDependencyError")) {
-      return "Uninitialized dependency access";
-    }
-    if (msg.includes("Endpoint storage inaccessible")) {
-      return "Endpoint storage inaccessible";
-    }
-    if (msg.includes("Error initializing part")) {
-      return "Endpoint construction failure";
+  batteryFingerprintFor(entityId, mapping) {
+    if (mapping?.batteryEntity || mapping?.disableBatteryMapping) return "";
+    if (entityId.startsWith("sensor.") || entityId.startsWith("binary_sensor.")) {
+      return "";
     }
-    if (msg.includes("aggregator.")) {
-      return "Runtime error in endpoint";
+    if (!this.isAutoBatteryMappingEnabled() && !entityId.startsWith("vacuum.")) {
+      return "";
     }
-    return null;
+    const entity = this.entity(entityId);
+    if (!entity?.device_id) return "";
+    const resolved = this.findBatteryEntityForDevice(entity.device_id);
+    return resolved && resolved !== entityId ? resolved : "";
+  }
+  /** Drop one cached battery answer so the next lookup resolves fresh (#450). */
+  forgetBatteryCacheForDevice(deviceId) {
+    this._batteryEntityCache.delete(deviceId);
   }
   /**
-   * Attempt to isolate an entity based on an error.
-   * Returns true if the entity was successfully identified and isolation was triggered.
+   * Find a battery sensor entity that belongs to the same HA device.
+   * Returns the entity_id of the battery sensor, or undefined if none found.
    */
-  async isolateFromError(error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    const classification = this.classifyError(msg);
-    if (!classification) {
-      return false;
-    }
-    const parsed = this.parseEndpointPath(msg);
-    if (!parsed) {
-      logger252.warn("Could not parse entity from error:", msg);
-      return false;
+  findBatteryEntityForDevice(deviceId) {
+    if (this._batteryEntityCache.has(deviceId)) {
+      const cached = this._batteryEntityCache.get(deviceId);
+      return cached === null ? void 0 : cached;
     }
-    const { bridgeId, entityName } = parsed;
-    const callback = this.isolationCallbacks.get(bridgeId);
-    if (!callback) {
-      logger252.warn(
-        `No isolation callback registered for bridge ${bridgeId}, entity: ${entityName}`
-      );
-      return false;
+    const entities = values3(this.registry.entities);
+    const sameDevice = entities.filter((e) => e.device_id === deviceId);
+    for (const entity of sameDevice) {
+      if (!entity.entity_id.startsWith("sensor.")) continue;
+      const state = this.registry.states[entity.entity_id];
+      if (!state) {
+        continue;
+      }
+      const attrs = state.attributes;
+      if (attrs.device_class === SensorDeviceClass.battery && resolveBatteryPercent(state.state) != null) {
+        this._batteryEntityCache.set(deviceId, entity.entity_id);
+        return entity.entity_id;
+      }
     }
-    const key = `${bridgeId}:${entityName}`;
-    if (this.isolatedEntities.has(key)) {
-      return true;
+    for (const entity of sameDevice) {
+      if (!entity.entity_id.startsWith("binary_sensor.")) continue;
+      const state = this.registry.states[entity.entity_id];
+      if (!state) continue;
+      const attrs = state.attributes;
+      if (attrs.device_class === "battery" && resolveBatteryPercent(state.state) != null) {
+        this._batteryEntityCache.set(deviceId, entity.entity_id);
+        return entity.entity_id;
+      }
     }
-    const reason = `${classification}. Entity isolated to protect bridge stability.`;
-    this.isolatedEntities.set(key, {
-      entityId: entityName,
-      reason,
-      failedAt: (/* @__PURE__ */ new Date()).toISOString()
-    });
-    logger252.warn(
-      `Isolating entity "${entityName}" from bridge ${bridgeId} due to: ${reason}`
-    );
-    diagnosticEventBus.emit("entity_error", `Entity isolated: ${entityName}`, {
-      bridgeId,
-      entityId: entityName,
-      details: { reason: classification }
-    });
-    try {
-      await callback(entityName);
-      return true;
-    } catch (e) {
-      logger252.error(`Failed to isolate entity ${entityName}:`, e);
-      return false;
+    for (const entity of sameDevice) {
+      if (!entity.entity_id.startsWith("sensor.")) continue;
+      const state = this.registry.states[entity.entity_id];
+      if (!state) continue;
+      const attrs = state.attributes;
+      const looksLikeBattery = attrs.unit_of_measurement === "%" || entity.entity_id.toLowerCase().includes("batt");
+      if ((attrs.device_class === "enum" || attrs.device_class == null && looksLikeBattery) && resolveBatteryPercent(state.state) != null) {
+        this._batteryEntityCache.set(deviceId, entity.entity_id);
+        return entity.entity_id;
+      }
     }
+    this._batteryEntityCache.set(deviceId, null);
+    return void 0;
   }
   /**
-   * Get all isolated entities for a specific bridge.
+   * Mark a battery entity as used (auto-assigned to another device).
    */
-  getIsolatedEntities(bridgeId) {
-    const result = [];
-    for (const [key, entity] of this.isolatedEntities) {
-      if (key.startsWith(`${bridgeId}:`)) {
-        result.push(entity);
-      }
-    }
-    return result;
+  markBatteryEntityUsed(entityId) {
+    this._usedBatteryEntities.add(entityId);
   }
   /**
-   * Clear isolated entities for a bridge (e.g., on restart).
+   * Check if a battery entity has been auto-assigned to another device.
    */
-  clearIsolatedEntities(bridgeId) {
-    for (const key of this.isolatedEntities.keys()) {
-      if (key.startsWith(`${bridgeId}:`)) {
-        this.isolatedEntities.delete(key);
-      }
-    }
+  isBatteryEntityUsed(entityId) {
+    return this._usedBatteryEntities.has(entityId);
   }
-};
-var EntityIsolationService = new EntityIsolationServiceImpl();
-
-// src/services/bridges/bridge-endpoint-manager.ts
-var MAX_ENTITY_ID_LENGTH = 150;
-var ENDPOINT_REMOVAL_GRACE_MS = 3e5;
-function isEntityPart(p) {
-  return typeof p.updateStates === "function";
-}
-function hasEntityIdentity(p) {
-  return typeof p.entityId === "string";
-}
-var BridgeEndpointManager = class extends Service {
-  constructor(client, registry3, mappingStorage, identityStorage, bridgeId, log, pluginManager, pluginRegistry, pluginInstaller) {
-    super("BridgeEndpointManager");
-    this.client = client;
-    this.registry = registry3;
-    this.mappingStorage = mappingStorage;
-    this.identityStorage = identityStorage;
-    this.bridgeId = bridgeId;
-    this.log = log;
-    this.pluginManager = pluginManager;
-    this.pluginRegistry = pluginRegistry;
-    this.pluginInstaller = pluginInstaller;
-    this.root = new AggregatorEndpoint2("aggregator");
-    this.identityResolver = new IdentityResolver(
-      identityStorage,
-      mappingStorage
+  /**
+   * Find a problem/safety binary sensor on the same HA device, so a smoke/CO
+   * alarm can drive hardwareFaultAlert from it. Prefers device_class=problem
+   * over safety. Returns the entity_id, or undefined if none found (#408).
+   */
+  findProblemEntityForDevice(deviceId) {
+    if (this._problemEntityCache.has(deviceId)) {
+      const cached = this._problemEntityCache.get(deviceId);
+      return cached === null ? void 0 : cached;
+    }
+    const entities = values3(this.registry.entities);
+    const sameDevice = entities.filter((e) => e.device_id === deviceId);
+    let safety;
+    for (const entity of sameDevice) {
+      if (!entity.entity_id.startsWith("binary_sensor.")) continue;
+      const state = this.registry.states[entity.entity_id];
+      if (!state) continue;
+      const attrs = state.attributes;
+      if (attrs.device_class === "problem") {
+        this._problemEntityCache.set(deviceId, entity.entity_id);
+        return entity.entity_id;
+      }
+      if (attrs.device_class === "safety" && !safety) {
+        safety = entity.entity_id;
+      }
+    }
+    this._problemEntityCache.set(deviceId, safety ?? null);
+    return safety;
+  }
+  /**
+   * Check if auto battery mapping is enabled for this bridge.
+   */
+  isAutoBatteryMappingEnabled() {
+    return this.dataProvider.featureFlags?.autoBatteryMapping === true || this.dataProvider.featureFlags?.autoComposedDevices === true;
+  }
+  /**
+   * Check if auto composed devices mode is enabled.
+   * When enabled, temperature sensors with auto-mapped humidity/pressure/battery
+   * build real Matter Composed Devices (BridgedNodeEndpoint with sub-endpoints)
+   * rather than stacking extra clusters onto a flat TemperatureSensor.
+   * Apple Home, Google Home, and Alexa render each sub-endpoint using its
+   * own device type.
+   */
+  isAutoComposedDevicesEnabled() {
+    return this.dataProvider.featureFlags?.autoComposedDevices === true;
+  }
+  /**
+   * Check if auto humidity mapping is enabled for this bridge.
+   * Default: true (enabled by default).
+   * When enabled, humidity sensors on the same device as a temperature sensor
+   * are combined into a single TemperatureHumiditySensor endpoint.
+   * Note: Apple Home does not display humidity on TemperatureSensorDevice
+   * endpoints, so users on Apple Home should explicitly disable this.
+   * See: https://github.com/RiDDiX/home-assistant-matter-hub/issues/133
+   */
+  isAutoHumidityMappingEnabled() {
+    return this.dataProvider.featureFlags?.autoHumidityMapping !== false || this.dataProvider.featureFlags?.autoComposedDevices === true;
+  }
+  /**
+   * Find a humidity sensor entity that belongs to the same HA device.
+   * Returns the entity_id of the humidity sensor, or undefined if none found.
+   */
+  findHumidityEntityForDevice(deviceId) {
+    const entities = values3(this.registry.entities);
+    for (const entity of entities) {
+      if (entity.device_id !== deviceId) continue;
+      if (!entity.entity_id.startsWith("sensor.")) continue;
+      const state = this.registry.states[entity.entity_id];
+      if (!state) continue;
+      const attrs = state.attributes;
+      if (attrs.device_class === SensorDeviceClass.humidity) {
+        return entity.entity_id;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Find a temperature sensor entity that belongs to the same HA device.
+   * Returns the entity_id of the temperature sensor, or undefined if none found.
+   */
+  findTemperatureEntityForDevice(deviceId) {
+    const entities = values3(this.registry.entities);
+    for (const entity of entities) {
+      if (entity.device_id !== deviceId) continue;
+      if (!entity.entity_id.startsWith("sensor.")) continue;
+      const state = this.registry.states[entity.entity_id];
+      if (!state) continue;
+      const attrs = state.attributes;
+      if (attrs.device_class === SensorDeviceClass.temperature) {
+        return entity.entity_id;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Find a climate entity that belongs to the same HA device.
+   * Returns the entity_id of the climate entity, or undefined if none found.
+   */
+  findClimateEntityForDevice(deviceId) {
+    const entities = values3(this.registry.entities);
+    for (const entity of entities) {
+      if (entity.device_id !== deviceId) continue;
+      if (!entity.entity_id.startsWith("climate.")) continue;
+      const state = this.registry.states[entity.entity_id];
+      if (state) return entity.entity_id;
+    }
+    return void 0;
+  }
+  /**
+   * Mark an entity as consumed by a composed device.
+   */
+  markComposedSubEntityUsed(entityId) {
+    this._usedComposedSubEntities.add(entityId);
+  }
+  /**
+   * Check if an entity has been consumed by a composed device.
+   */
+  isComposedSubEntityUsed(entityId) {
+    return this._usedComposedSubEntities.has(entityId);
+  }
+  /**
+   * Mark a humidity entity as used (auto-assigned to a temperature sensor).
+   */
+  markHumidityEntityUsed(entityId) {
+    this._usedHumidityEntities.add(entityId);
+  }
+  /**
+   * Check if a humidity entity has been auto-assigned to a temperature sensor.
+   */
+  isHumidityEntityUsed(entityId) {
+    return this._usedHumidityEntities.has(entityId);
+  }
+  /**
+   * Check if auto pressure mapping is enabled for this bridge.
+   * Default: true (enabled by default).
+   * When enabled, pressure sensors on the same device as a temperature sensor
+   * are combined into a single endpoint with PressureMeasurement cluster.
+   */
+  isAutoPressureMappingEnabled() {
+    return this.dataProvider.featureFlags?.autoPressureMapping !== false || this.dataProvider.featureFlags?.autoComposedDevices === true;
+  }
+  /**
+   * Check if the vacuum OnOff cluster feature flag is enabled.
+   * Defaults to OFF. OnOff is NOT part of the RoboticVacuumCleaner (0x74) device
+   * type spec. Adding it makes the device non-conformant and causes Amazon Alexa
+   * to reject it entirely (#185, #183). Only enable if a specific controller needs it.
+   */
+  isVacuumOnOffEnabled() {
+    return this.dataProvider.featureFlags?.vacuumOnOff === true;
+  }
+  // Consume frozen device identities (#404). Seeding always runs; only
+  // consumption of the stored endpoint id/anchor is gated on this flag.
+  isStableIdentityEnabled() {
+    return this.dataProvider.featureFlags?.stableIdentity === true;
+  }
+  /**
+   * Check if the vacuum OnOff cluster should be included for server-mode vacuums.
+   * Defaults to OFF. OnOff is NOT part of the RoboticVacuumCleaner (0x74) device
+   * type spec. Adding it makes the device non-conformant and causes Amazon Alexa
+   * to reject it entirely (#185, #183). Apple Home may also render the vacuum
+   * incorrectly (shows "Updating" or switch UI). Only enable via feature flag
+   * if a specific controller requires it.
+   */
+  isServerModeVacuumOnOffEnabled() {
+    return this.dataProvider.featureFlags?.vacuumOnOff === true;
+  }
+  /**
+   * Auto-detect vacuum-related select entities on the same HA device.
+   * HA integrations (Dreame, Roborock, Ecovacs, Valetudo, etc.) expose vacuum
+   * features as select entities with well-known suffixes. This finds them
+   * automatically so users don't need to configure each entity manually.
+   */
+  findVacuumSelectEntities(deviceId) {
+    const entities = values3(this.registry.entities);
+    const sameDevice = entities.filter(
+      (e) => e.device_id === deviceId && e.entity_id.startsWith("select.")
     );
-    EntityIsolationService.registerIsolationCallback(
-      bridgeId,
-      this.isolateEntity.bind(this)
+    let cleaningModeEntity;
+    let suctionLevelEntity;
+    let mopIntensityEntity;
+    for (const entity of sameDevice) {
+      const state = this.registry.states[entity.entity_id];
+      if (!state) continue;
+      const id = entity.entity_id.toLowerCase();
+      if (!cleaningModeEntity) {
+        if (id.includes("cleaning_mode")) {
+          cleaningModeEntity = entity.entity_id;
+        } else if (id.endsWith("_mode")) {
+          const options = state.attributes?.options;
+          if (options?.some(
+            (o) => /^(vacuum|mop|sweep|sweep_mop|sweep_before_mopping|sweep_then_mop|vacuum_and_mop|vacuum_then_mop|mopping|sweeping|sweeping_and_mopping|mopping_after_sweeping)$/i.test(
+              o.replace(/\s+/g, "_")
+            )
+          )) {
+            cleaningModeEntity = entity.entity_id;
+          }
+        }
+      }
+      if (!suctionLevelEntity && (id.includes("suction_level") || id.endsWith("_fan"))) {
+        suctionLevelEntity = entity.entity_id;
+      }
+      if (!mopIntensityEntity && (id.includes("mop_intensity") || id.includes("mop_pad_humidity") || id.includes("water_volume") || id.includes("water_amount") || id.endsWith("_water"))) {
+        mopIntensityEntity = entity.entity_id;
+      }
+    }
+    let currentRoomEntity;
+    const sameDeviceSensors = entities.filter(
+      (e) => e.device_id === deviceId && e.entity_id.startsWith("sensor.")
     );
-    if (this.pluginManager) {
-      this.wirePluginCallbacks();
+    for (const entity of sameDeviceSensors) {
+      if (entity.entity_id.toLowerCase().endsWith("_current_room")) {
+        currentRoomEntity = entity.entity_id;
+        break;
+      }
     }
+    return {
+      cleaningModeEntity,
+      suctionLevelEntity,
+      mopIntensityEntity,
+      currentRoomEntity
+    };
   }
-  client;
-  registry;
-  mappingStorage;
-  identityStorage;
-  bridgeId;
-  log;
-  pluginManager;
-  pluginRegistry;
-  pluginInstaller;
-  root;
-  entityIds = [];
-  unsubscribe;
-  observingRequested = false;
-  _failedEntities = [];
-  mappingFingerprints = /* @__PURE__ */ new Map();
-  // entityId -> first absence stamp (grace window)
-  pendingRemovals = /* @__PURE__ */ new Map();
-  removalRecheckTimer = null;
-  // Bumped on every stop, so a refresh that was already running cannot arm a
-  // timer on a bridge that has since stopped (#438).
-  lifecycle = 0;
-  pluginEndpoints = /* @__PURE__ */ new Map();
-  pluginStateUpdating = /* @__PURE__ */ new Set();
-  pluginListeners = /* @__PURE__ */ new Map();
-  get failedEntities() {
-    const isolated = EntityIsolationService.getIsolatedEntities(this.bridgeId);
-    return [...this._failedEntities, ...isolated];
+  static valetudoLogger = Logger.get("ValetudoRooms");
+  /**
+   * Find Valetudo map segments from the sensor.*_map_segments entity on the
+   * same HA device. Valetudo exposes room/segment data via MQTT as a sensor
+   * with numeric segment IDs in its attributes.
+   *
+   * Attribute format:
+   * - Unnamed segments: { "1": 1, "2": 2, "4": 4 }
+   * - Named segments:   { "1": "Kitchen", "2": "Living Room" }
+   */
+  findValetudoMapSegments(deviceId) {
+    const entities = values3(this.registry.entities);
+    const mapSensor = entities.find(
+      (e) => e.device_id === deviceId && e.entity_id.startsWith("sensor.") && e.entity_id.endsWith("_map_segments")
+    );
+    if (!mapSensor) return [];
+    const state = this.registry.states[mapSensor.entity_id];
+    if (!state) return [];
+    const attrs = state.attributes;
+    const rooms = [];
+    for (const [key, value] of Object.entries(attrs)) {
+      if (!/^\d+$/.test(key)) continue;
+      const segmentId = Number.parseInt(key, 10);
+      const name = typeof value === "string" ? value : `Segment ${key}`;
+      rooms.push({ id: segmentId, name });
+    }
+    if (rooms.length > 0) {
+      _BridgeRegistry.valetudoLogger.info(
+        `Found ${rooms.length} Valetudo segments via ${mapSensor.entity_id}`
+      );
+    }
+    return rooms;
+  }
+  static roborockLogger = Logger.get("RoborockRooms");
+  /**
+   * Resolve rooms for a Roborock vacuum by calling roborock.get_maps.
+   * Returns parsed VacuumRoom[] with segment IDs, or empty array if
+   * the service is unavailable or the vacuum is not Roborock.
+   */
+  async resolveRoborockRooms(entityId) {
+    if (!this.client) return [];
+    try {
+      const raw = await callService2(
+        this.client.connection,
+        "roborock",
+        "get_maps",
+        void 0,
+        { entity_id: entityId },
+        true
+      );
+      const wrapper = raw;
+      const responseData = wrapper?.response ?? wrapper;
+      const entityData = responseData?.[entityId];
+      if (!entityData?.maps) {
+        _BridgeRegistry.roborockLogger.debug(
+          `${entityId}: roborock.get_maps returned no maps (keys: ${Object.keys(responseData ?? {}).join(", ")})`
+        );
+        return [];
+      }
+      const rooms = [];
+      for (const map of entityData.maps) {
+        if (!map.rooms) continue;
+        for (const [segmentId, roomName] of Object.entries(map.rooms)) {
+          const id = /^\d+$/.test(segmentId) ? Number.parseInt(segmentId, 10) : segmentId;
+          rooms.push({ id, name: roomName });
+        }
+      }
+      if (rooms.length > 0) {
+        _BridgeRegistry.roborockLogger.info(
+          `${entityId}: Resolved ${rooms.length} rooms via roborock.get_maps`
+        );
+      }
+      return rooms;
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : typeof error === "object" && error !== null ? JSON.stringify(error) : String(error);
+      _BridgeRegistry.roborockLogger.warn(
+        `${entityId}: roborock.get_maps failed: ${msg}`
+      );
+      return [];
+    }
+  }
+  static cleanAreaLogger = Logger.get("CleanAreaRooms");
+  /**
+   * Resolve HA areas mapped to vacuum segments via HA 2026.3 CLEAN_AREA.
+   * Fetches the full entity registry entry (including options.vacuum.area_mapping)
+   * and resolves HA area names from the area registry.
+   * Returns CleanAreaRoom[] sorted alphabetically, or empty array if
+   * CLEAN_AREA is not supported or no area_mapping is configured.
+   */
+  async resolveCleanAreaRooms(entityId, supportedFeatures) {
+    if (!this.client) return [];
+    if (!(supportedFeatures & VacuumDeviceFeature.CLEAN_AREA)) return [];
+    try {
+      const entry = await sendHaMessage(this.client.connection, {
+        type: "config/entity_registry/get",
+        entity_id: entityId
+      });
+      const vacuumOptions = entry?.options?.vacuum;
+      const areaMapping = vacuumOptions?.area_mapping;
+      if (!areaMapping || Object.keys(areaMapping).length === 0) {
+        _BridgeRegistry.cleanAreaLogger.debug(
+          `${entityId}: CLEAN_AREA supported but no area_mapping configured`
+        );
+        return [];
+      }
+      let validSegmentIds;
+      try {
+        const segmentsResponse = await sendHaMessage(this.client.connection, {
+          type: "vacuum/get_segments",
+          entity_id: entityId
+        });
+        if (Array.isArray(segmentsResponse)) {
+          validSegmentIds = new Set(segmentsResponse.map((s) => s.id));
+          _BridgeRegistry.cleanAreaLogger.debug(
+            `${entityId}: Current vacuum segments: ${[...validSegmentIds].join(", ")}`
+          );
+        }
+      } catch {
+        _BridgeRegistry.cleanAreaLogger.debug(
+          `${entityId}: vacuum/get_segments not available, skipping stale entry detection`
+        );
+      }
+      const rooms = [];
+      for (const haAreaId of Object.keys(areaMapping)) {
+        const segments = areaMapping[haAreaId];
+        if (!segments || segments.length === 0) {
+          _BridgeRegistry.cleanAreaLogger.debug(
+            `${entityId}: Skipping HA area ${haAreaId}, no segments mapped`
+          );
+          continue;
+        }
+        if (validSegmentIds && !segments.some((sid) => validSegmentIds.has(sid))) {
+          const areaName2 = this.registry.areas.get(haAreaId) ?? haAreaId;
+          _BridgeRegistry.cleanAreaLogger.info(
+            `${entityId}: Skipping stale HA area "${areaName2}" (${haAreaId}), segments [${segments.join(", ")}] no longer exist on vacuum`
+          );
+          continue;
+        }
+        const areaName = this.registry.areas.get(haAreaId) ?? haAreaId;
+        rooms.push({
+          areaId: hashAreaId(haAreaId),
+          haAreaId,
+          name: areaName
+        });
+      }
+      rooms.sort((a, b) => a.name.localeCompare(b.name));
+      if (rooms.length > 0) {
+        _BridgeRegistry.cleanAreaLogger.info(
+          `${entityId}: Resolved ${rooms.length} HA areas via CLEAN_AREA mapping`
+        );
+      }
+      return rooms;
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : typeof error === "object" && error !== null ? JSON.stringify(error) : String(error);
+      _BridgeRegistry.cleanAreaLogger.warn(
+        `${entityId}: Failed to resolve CLEAN_AREA mapping: ${msg}`
+      );
+      return [];
+    }
+  }
+  /**
+   * Find a pressure sensor entity that belongs to the same HA device.
+   * Returns the entity_id of the pressure sensor, or undefined if none found.
+   */
+  findPressureEntityForDevice(deviceId) {
+    const entities = values3(this.registry.entities);
+    for (const entity of entities) {
+      if (entity.device_id !== deviceId) continue;
+      if (!entity.entity_id.startsWith("sensor.")) continue;
+      const state = this.registry.states[entity.entity_id];
+      if (!state) continue;
+      const attrs = state.attributes;
+      if (attrs.device_class === SensorDeviceClass.pressure || attrs.device_class === SensorDeviceClass.atmospheric_pressure) {
+        return entity.entity_id;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Mark a pressure entity as used (auto-assigned to a temperature sensor).
+   */
+  markPressureEntityUsed(entityId) {
+    this._usedPressureEntities.add(entityId);
+  }
+  /**
+   * Check if a pressure entity has been auto-assigned to a temperature sensor.
+   */
+  isPressureEntityUsed(entityId) {
+    return this._usedPressureEntities.has(entityId);
+  }
+  /**
+   * Find a power sensor entity (device_class: power) on the same HA device.
+   */
+  findPowerEntityForDevice(deviceId) {
+    const entities = values3(this.registry.entities);
+    for (const entity of entities) {
+      if (entity.device_id !== deviceId) continue;
+      if (!entity.entity_id.startsWith("sensor.")) continue;
+      const state = this.registry.states[entity.entity_id];
+      if (!state) continue;
+      const attrs = state.attributes;
+      if (attrs.device_class === SensorDeviceClass.power) {
+        return entity.entity_id;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Find an energy sensor entity (device_class: energy) on the same HA device.
+   */
+  findEnergyEntityForDevice(deviceId) {
+    const entities = values3(this.registry.entities);
+    for (const entity of entities) {
+      if (entity.device_id !== deviceId) continue;
+      if (!entity.entity_id.startsWith("sensor.")) continue;
+      const state = this.registry.states[entity.entity_id];
+      if (!state) continue;
+      const attrs = state.attributes;
+      if (attrs.device_class === SensorDeviceClass.energy) {
+        return entity.entity_id;
+      }
+    }
+    return void 0;
+  }
+  markPowerEntityUsed(entityId) {
+    this._usedPowerEntities.add(entityId);
+  }
+  isPowerEntityUsed(entityId) {
+    return this._usedPowerEntities.has(entityId);
+  }
+  markEnergyEntityUsed(entityId) {
+    this._usedEnergyEntities.add(entityId);
+  }
+  isEnergyEntityUsed(entityId) {
+    return this._usedEnergyEntities.has(entityId);
+  }
+  mergeExternalStates(states) {
+    const registryStates = this.registry.states;
+    for (const entityId of Object.keys(states)) {
+      registryStates[entityId] = states[entityId];
+    }
+  }
+  /**
+   * Get the area name for an entity, resolving from HA area registry.
+   * Priority: entity area_id > device area_id > undefined
+   */
+  getAreaName(entityId) {
+    const entity = this._entities[entityId];
+    if (!entity) return void 0;
+    const entityAreaId = entity.area_id;
+    if (entityAreaId) {
+      const name = this.registry.areas.get(entityAreaId);
+      if (name) return name;
+    }
+    const device = this._devices[entity.device_id];
+    const deviceAreaId = device?.area_id;
+    if (deviceAreaId) {
+      const name = this.registry.areas.get(deviceAreaId);
+      if (name) return name;
+    }
+    return void 0;
   }
-  addFailedEntity(entityId, reason) {
-    this._failedEntities.push({
-      entityId,
-      reason,
-      failedAt: (/* @__PURE__ */ new Date()).toISOString()
+  refresh() {
+    this._usedBatteryEntities.clear();
+    this._usedHumidityEntities.clear();
+    this._usedPressureEntities.clear();
+    this._usedPowerEntities.clear();
+    this._usedEnergyEntities.clear();
+    this._usedComposedSubEntities.clear();
+    this._batteryEntityCache.clear();
+    this._problemEntityCache.clear();
+    this._entities = pickBy(this.registry.entities, (entity) => {
+      const device = this.registry.devices[entity.device_id];
+      const filter = this.dataProvider.filter;
+      const featureFlags = this.dataProvider.featureFlags ?? {};
+      if (entity.disabled_by != null) {
+        return false;
+      }
+      const isHidden = entity.hidden_by != null;
+      if (isHidden && !featureFlags.includeHiddenEntities) {
+        return false;
+      }
+      const state = this.registry.states[entity.entity_id];
+      return this.matchesFilter(filter, entity, device, state);
     });
+    this._states = pickBy(
+      this.registry.states,
+      (e) => !!this._entities[e.entity_id]
+    );
+    this._devices = pickBy(
+      this.registry.devices,
+      (d) => values3(this._entities).map((e) => e.device_id).some((id) => d.id === id)
+    );
+    this.preCalculateAutoAssignments();
   }
-  identityResolver;
-  wirePluginCallbacks() {
-    if (!this.pluginManager) return;
-    this.pluginManager.onDeviceRegistered = async (pluginName, device) => {
-      let endpoint;
-      if (device.endpointType) {
-        try {
-          validateEndpointType(
-            device.endpointType,
-            `plugin:${pluginName}:${device.id}`
-          );
-        } catch (e) {
-          this.log.warn(
-            `Plugin "${pluginName}": invalid endpointType for device "${device.id}":`,
-            e
+  /**
+   * Pre-calculate which entities will be auto-assigned to other devices.
+   * This must run BEFORE endpoint creation to ensure correct "used" marking
+   * regardless of the order entities are processed.
+   */
+  preCalculateAutoAssignments() {
+    const entities = values3(this._entities);
+    for (const entity of entities) {
+      if (!entity.device_id) continue;
+      if (!entity.entity_id.startsWith("sensor.")) continue;
+      const state = this._states[entity.entity_id];
+      if (!state) continue;
+      const attrs = state.attributes;
+      if (attrs.device_class === SensorDeviceClass.temperature) {
+        if (this.isAutoHumidityMappingEnabled()) {
+          const humidityEntityId = this.findHumidityEntityForDevice(
+            entity.device_id
           );
-          return;
-        }
-        const supplied = device.endpointType;
-        const initialState = {};
-        for (const cluster2 of device.clusters) {
-          if (cluster2.clusterId === "pluginDevice" && supplied.behaviors?.pluginDevice == null && supplied.behaviors?.bridgedDeviceBasicInformation == null) {
-            this.log.warn(
-              `Plugin "${pluginName}": device "${device.id}" declares a "pluginDevice" cluster without owning that behavior, ignoring it`
-            );
-            continue;
+          if (humidityEntityId && humidityEntityId !== entity.entity_id) {
+            this._usedHumidityEntities.add(humidityEntityId);
           }
-          initialState[cluster2.clusterId] = cluster2.attributes;
-        }
-        const hasOwnIdentity = supplied.behaviors?.bridgedDeviceBasicInformation != null;
-        const ownsPluginDevice = supplied.behaviors?.pluginDevice != null;
-        const mutable = typeof supplied.with === "function" && typeof supplied.set === "function";
-        if (!mutable && Object.keys(initialState).length > 0) {
-          this.log.warn(
-            `Plugin "${pluginName}": endpointType for device "${device.id}" cannot take its cluster config, skipping it`
-          );
-          return;
-        }
-        if (!hasOwnIdentity && (!mutable || ownsPluginDevice)) {
-          this.log.warn(
-            `Plugin "${pluginName}": device "${device.id}" mounts without BridgedDeviceBasicInformation, controllers may not show it`
-          );
-        }
-        let base = device.endpointType;
-        if (mutable && !hasOwnIdentity && !ownsPluginDevice) {
-          base = base.with(PluginBasicInformationServer, PluginDeviceBehavior);
-          initialState.pluginDevice = { device, pluginName };
         }
-        endpoint = new Endpoint(
-          Object.keys(initialState).length > 0 ? base.set(initialState) : base,
-          { id: `plugin_${device.id}` }
-        );
-      } else {
-        const type = createPluginEndpointType(device.deviceType ?? "");
-        if (!type) {
-          this.log.warn(
-            `Plugin "${pluginName}": unsupported device type "${device.deviceType}" for device "${device.id}"`
+        if (this.isAutoPressureMappingEnabled()) {
+          const pressureEntityId = this.findPressureEntityForDevice(
+            entity.device_id
           );
-          return;
-        }
-        const initialState = {
-          pluginDevice: { device, pluginName }
-        };
-        for (const cluster2 of device.clusters) {
-          initialState[cluster2.clusterId] = cluster2.attributes;
-        }
-        endpoint = new Endpoint(type.set(initialState), {
-          id: `plugin_${device.id}`
-        });
-      }
-      try {
-        await this.root.add(endpoint);
-        this.pluginEndpoints.set(device.id, endpoint);
-        this.wirePluginEndpointEvents(device, endpoint);
-        this.log.info(
-          `Plugin "${pluginName}": added device "${device.name}" (${device.deviceType})`
-        );
-      } catch (e) {
-        this.log.warn(
-          `Plugin "${pluginName}": failed to add device "${device.id}":`,
-          e
-        );
-      }
-    };
-    this.pluginManager.onDeviceUnregistered = async (pluginName, deviceId, options) => {
-      const listeners = this.pluginListeners.get(deviceId);
-      if (listeners) {
-        for (const { observable, listener } of listeners) {
-          try {
-            observable.off(listener);
-          } catch {
-          }
-        }
-        this.pluginListeners.delete(deviceId);
-      }
-      const endpoint = this.pluginEndpoints.get(deviceId);
-      if (endpoint) {
-        try {
-          if (options?.keepIdentity) {
-            await endpoint.close();
-          } else {
-            await endpoint.delete();
+          if (pressureEntityId && pressureEntityId !== entity.entity_id) {
+            this._usedPressureEntities.add(pressureEntityId);
           }
-        } catch (e) {
-          this.log.warn(
-            `Plugin "${pluginName}": failed to remove device "${deviceId}":`,
-            e
-          );
-        }
-        this.pluginEndpoints.delete(deviceId);
-      }
-    };
-    this.pluginManager.onDeviceStateUpdated = (pluginName, deviceId, clusterId3, attributes9) => {
-      const endpoint = this.pluginEndpoints.get(deviceId);
-      if (!endpoint) return;
-      const behaviorType = endpoint.type.behaviors[clusterId3];
-      if (!behaviorType) {
-        this.log.debug(
-          `Plugin "${pluginName}": cluster "${clusterId3}" not found on device "${deviceId}"`
-        );
-        return;
-      }
-      this.pluginStateUpdating.add(deviceId);
-      endpoint.setStateOf(behaviorType, attributes9).catch((e) => {
-        this.log.warn(
-          `Plugin "${pluginName}": failed to update "${clusterId3}" on "${deviceId}":`,
-          e
-        );
-      }).finally(() => {
-        this.pluginStateUpdating.delete(deviceId);
-      });
-    };
-  }
-  wirePluginEndpointEvents(device, endpoint) {
-    if (!device.onAttributeWrite) return;
-    const allEvents = endpoint.events;
-    const listeners = [];
-    for (const behaviorId of Object.keys(endpoint.type.behaviors)) {
-      if (behaviorId === "pluginDevice") continue;
-      const behaviorEvents = allEvents[behaviorId];
-      if (!behaviorEvents || typeof behaviorEvents !== "object") continue;
-      const eventNames = /* @__PURE__ */ new Set();
-      for (let proto = behaviorEvents; proto && proto !== Object.prototype; proto = Object.getPrototypeOf(proto)) {
-        for (const name of Object.getOwnPropertyNames(proto)) {
-          if (name.endsWith("$Changed")) eventNames.add(name);
         }
       }
-      for (const eventName of eventNames) {
-        const observable = behaviorEvents[eventName];
-        if (!observable || typeof observable.on !== "function") continue;
-        const attrName = eventName.slice(0, -"$Changed".length);
-        const listener = (newValue) => {
-          if (this.pluginStateUpdating.has(device.id)) return;
-          device.onAttributeWrite?.(behaviorId, attrName, newValue).catch((e) => {
-            this.log.debug(
-              `Plugin device "${device.id}": onAttributeWrite error for ${behaviorId}.${attrName}:`,
-              e
-            );
-          });
-        };
-        observable.on(listener);
-        listeners.push({ observable, listener });
-      }
-    }
-    if (listeners.length > 0) {
-      this.pluginListeners.set(device.id, listeners);
     }
-  }
-  async startPlugins() {
-    if (!this.pluginManager) return;
-    await this.registerBuiltInPlugins();
-    await this.loadRegisteredPlugins();
-    await this.pluginManager.startAll();
-    await this.pluginManager.configureAll();
-  }
-  // Built-in plugins ship inside the backend bundle, so they share the same
-  // matter.js instance and can hand over live EndpointTypes.
-  async registerBuiltInPlugins() {
-    if (!this.pluginManager) return;
-    for (const Plugin of BUILTIN_PLUGINS) {
-      const plugin = new Plugin();
-      try {
-        await this.pluginManager.registerBuiltIn(plugin);
-      } catch (e) {
-        this.log.warn(
-          `Failed to register built-in plugin "${plugin.name}":`,
-          e
-        );
+    for (const entity of entities) {
+      if (!entity.device_id) continue;
+      const domain = entity.entity_id.split(".")[0];
+      if (domain !== "switch" && domain !== "light") continue;
+      const powerEntityId = this.findPowerEntityForDevice(entity.device_id);
+      if (powerEntityId && powerEntityId !== entity.entity_id) {
+        if (!this._usedPowerEntities.has(powerEntityId)) {
+          this._usedPowerEntities.add(powerEntityId);
+        }
+      }
+      const energyEntityId = this.findEnergyEntityForDevice(entity.device_id);
+      if (energyEntityId && energyEntityId !== entity.entity_id) {
+        if (!this._usedEnergyEntities.has(energyEntityId)) {
+          this._usedEnergyEntities.add(energyEntityId);
+        }
       }
     }
-  }
-  async loadRegisteredPlugins() {
-    if (!this.pluginManager || !this.pluginRegistry || !this.pluginInstaller)
-      return;
-    const registered = this.pluginRegistry.getAll();
-    for (const entry of registered) {
-      if (!entry.autoLoad) continue;
-      const packagePath = this.pluginInstaller.getPluginPath(entry.packageName);
-      try {
-        await this.pluginManager.loadExternal(packagePath, entry.config);
-        this.log.info(
-          `Loaded external plugin: ${entry.packageName} from ${packagePath}`
-        );
-      } catch (e) {
-        this.log.warn(
-          `Failed to load external plugin "${entry.packageName}":`,
-          e
+    if (this.isAutoBatteryMappingEnabled()) {
+      for (const entity of entities) {
+        if (!entity.device_id) continue;
+        if (this._usedHumidityEntities.has(entity.entity_id)) continue;
+        if (entity.entity_id.startsWith("sensor.")) {
+          const state = this._states[entity.entity_id];
+          if (state) {
+            const attrs = state.attributes;
+            if (attrs.device_class === SensorDeviceClass.battery) continue;
+          }
+        }
+        if (entity.entity_id.startsWith("binary_sensor.")) {
+          const state = this._states[entity.entity_id];
+          if (state) {
+            const attrs = state.attributes;
+            if (attrs.device_class === "battery") continue;
+          }
+        }
+        const batteryEntityId = this.findBatteryEntityForDevice(
+          entity.device_id
         );
+        if (batteryEntityId && batteryEntityId !== entity.entity_id) {
+          if (!this._usedBatteryEntities.has(batteryEntityId)) {
+            this._usedBatteryEntities.add(batteryEntityId);
+          }
+        }
       }
     }
   }
-  async stopPlugins() {
-    if (!this.pluginManager) return;
-    await this.pluginManager.shutdownAll("Bridge stopping");
-    for (const [id, endpoint] of this.pluginEndpoints) {
-      try {
-        await endpoint.close();
-      } catch (e) {
-        this.log.warn(`Failed to close plugin endpoint ${id}:`, e);
+  /**
+   * The first already-matched entity the given matcher tests true for.
+   * Server mode pins the primary entity to the first include matcher with
+   * this, independent of HA registry order (#301).
+   */
+  firstEntityMatching(matcher) {
+    const labels = this.registry.labels;
+    for (const entity of values3(this._entities)) {
+      const device = this.registry.devices[entity.device_id];
+      const state = this.registry.states[entity.entity_id];
+      if (testMatchers([matcher], device, entity, "any", state, labels)) {
+        return entity.entity_id;
       }
     }
-    this.pluginEndpoints.clear();
+    return void 0;
   }
-  getPluginInfo() {
-    if (!this.pluginManager) {
-      return { metadata: [], devices: [], circuitBreakers: {} };
+  matchesFilter(filter, entity, device, entityState) {
+    const labels = this.registry.labels;
+    if (filter.include.length > 0 && !testMatchers(
+      filter.include,
+      device,
+      entity,
+      filter.includeMode,
+      entityState,
+      labels
+    )) {
+      return false;
     }
-    const cbStates = this.pluginManager.getCircuitBreakerStates();
-    const circuitBreakers = {};
-    for (const [name, state] of cbStates) {
-      circuitBreakers[name] = state;
+    if (filter.exclude.length > 0 && testMatchers(filter.exclude, device, entity, "any", entityState, labels)) {
+      return false;
     }
-    return {
-      metadata: this.pluginManager.getMetadata(),
-      devices: this.pluginManager.getAllDevices(),
-      circuitBreakers
-    };
-  }
-  async enablePlugin(pluginName) {
-    return await this.pluginManager?.enablePlugin(pluginName);
-  }
-  async disablePlugin(pluginName) {
-    return await this.pluginManager?.disablePlugin(pluginName);
+    return true;
   }
-  resetPlugin(pluginName) {
-    this.pluginManager?.resetPlugin(pluginName);
+};
+function hashAreaId(areaId) {
+  let hash2 = 0;
+  for (let i = 0; i < areaId.length; i++) {
+    const char = areaId.charCodeAt(i);
+    hash2 = (hash2 << 5) - hash2 + char;
+    hash2 |= 0;
   }
-  getPluginConfigSchema(pluginName) {
-    return this.pluginManager?.getConfigSchema(pluginName);
+  return Math.abs(hash2);
+}
+
+// src/services/bridges/entity-isolation-service.ts
+init_esm();
+init_diagnostic_event_bus();
+var logger252 = Logger.get("EntityIsolation");
+var EntityIsolationServiceImpl = class {
+  isolatedEntities = /* @__PURE__ */ new Map();
+  isolationCallbacks = /* @__PURE__ */ new Map();
+  /**
+   * Register a callback to be called when an entity needs to be isolated.
+   * The callback should remove the entity from the bridge's aggregator.
+   */
+  registerIsolationCallback(bridgeId, callback) {
+    this.isolationCallbacks.set(bridgeId, callback);
   }
-  async updatePluginConfig(pluginName, config8) {
-    return await this.pluginManager?.updateConfig(pluginName, config8) ?? false;
+  unregisterIsolationCallback(bridgeId) {
+    this.isolationCallbacks.delete(bridgeId);
   }
   /**
-   * Isolate an entity by removing it from the aggregator.
-   * Called by EntityIsolationService when a runtime error is detected.
+   * Parse the endpoint path from a Matter.js error message and extract the entity name.
+   * Example path: "ed5b4f8d042e4599b833f21da4ededba.aggregator.Küchenlicht.onOff.on"
+   * Returns: { bridgeId: "ed5b4f8d...", entityName: "Küchenlicht" }
    */
-  async isolateEntity(entityName) {
-    const endpoints = [...this.root.parts].filter(hasEntityIdentity);
-    const endpoint = endpoints.find(
-      (e) => !(e instanceof VacuumAreaSwitchEndpoint) && (e.id === entityName || e.entityId === entityName)
-    ) ?? endpoints.find((e) => e.id === entityName);
-    if (endpoint) {
-      this.log.warn(
-        `Isolating entity ${endpoint.entityId} due to runtime error`
-      );
-      try {
-        await endpoint.close();
-      } catch (e) {
-        this.log.error(`Failed to close isolated endpoint:`, e);
-      }
-      this.pendingRemovals.delete(endpoint.entityId);
-      this.mappingFingerprints.delete(endpoint.entityId);
-      if (!(endpoint instanceof VacuumAreaSwitchEndpoint)) {
-        for (const sw of endpoints) {
-          if (!(sw instanceof VacuumAreaSwitchEndpoint)) continue;
-          if (sw.vacuumEndpointId !== endpoint.id) continue;
-          try {
-            await sw.close();
-          } catch (e) {
-            this.log.warn(`Failed to remove area switch ${sw.id}:`, e);
-          }
-        }
-      }
+  parseEndpointPath(errorMessage) {
+    const match = errorMessage.match(/([a-f0-9]{32})\.aggregator\.([^.\s>]+)/i);
+    if (match) {
+      return {
+        bridgeId: match[1],
+        entityName: match[2]
+      };
     }
+    return null;
   }
-  // refreshDevices only runs on registry-fingerprint changes, which may not
-  // recur, so drive any held removals to completion ourselves once the grace
-  // window has passed.
-  scheduleRemovalRecheck() {
-    if (this.removalRecheckTimer) {
-      clearTimeout(this.removalRecheckTimer);
-      this.removalRecheckTimer = null;
+  classifyError(msg) {
+    if (msg.includes("Invalid intervalMs")) {
+      return "Subscription timing error (Invalid intervalMs)";
     }
-    if (this.pendingRemovals.size === 0) return;
-    const lifecycle = this.lifecycle;
-    this.removalRecheckTimer = setTimeout(() => {
-      this.removalRecheckTimer = null;
-      this.refreshDevices().catch((e) => {
-        this.log.warn("Endpoint removal recheck failed:", e);
-        if (lifecycle === this.lifecycle) this.scheduleRemovalRecheck();
-      });
-    }, ENDPOINT_REMOVAL_GRACE_MS + 5e3);
-  }
-  getPluginDomainMappings() {
-    if (!this.pluginManager) return void 0;
-    const mappings = this.pluginManager.getDomainMappings();
-    if (mappings.size === 0) return void 0;
-    const result = /* @__PURE__ */ new Map();
-    for (const [domain, mapping] of mappings) {
-      result.set(domain, mapping.matterDeviceType);
+    if (msg.includes("Behaviors have errors")) {
+      return "Behavior initialization failure";
     }
-    return result;
-  }
-  getEntityMapping(entityId) {
-    return this.mappingStorage.getMapping(this.bridgeId, entityId);
-  }
-  computeMappingFingerprint(mapping) {
-    if (!mapping) return "";
-    return JSON.stringify(mapping);
-  }
-  async dispose() {
-    this.stopObserving();
-    if (this.removalRecheckTimer) {
-      clearTimeout(this.removalRecheckTimer);
-      this.removalRecheckTimer = null;
+    if (msg.includes("TransactionDestroyedError")) {
+      return "Transaction destroyed during operation";
     }
-    this.pendingRemovals.clear();
-    EntityIsolationService.unregisterIsolationCallback(this.bridgeId);
-    EntityIsolationService.clearIsolatedEntities(this.bridgeId);
-    const endpoints = this.root.parts.map((p) => p);
-    for (const endpoint of endpoints) {
-      try {
-        await endpoint.close();
-      } catch (e) {
-        this.log.warn(`Failed to close endpoint during dispose:`, e);
-      }
+    if (msg.includes("DestroyedDependencyError")) {
+      return "Dependency destroyed during operation";
     }
-  }
-  async startObserving() {
-    this.clearSubscription();
-    this.observingRequested = true;
-    if (!this.entityIds.length) {
-      return;
+    if (msg.includes("UninitializedDependencyError")) {
+      return "Uninitialized dependency access";
     }
-    const subscriptionIds = this.collectSubscriptionEntityIds();
-    this.unsubscribe = subscribeEntities(
-      this.client.connection,
-      (e, changed) => this.updateStates(e, changed),
-      subscriptionIds
-    );
-  }
-  collectSubscriptionEntityIds() {
-    const ids = new Set(this.entityIds);
-    const endpoints = this.root.parts.map((p) => p);
-    for (const endpoint of endpoints) {
-      const mappedIds = endpoint.mappedEntityIds;
-      if (mappedIds) {
-        for (const mappedId of mappedIds) {
-          ids.add(mappedId);
-        }
-      }
+    if (msg.includes("Endpoint storage inaccessible")) {
+      return "Endpoint storage inaccessible";
+    }
+    if (msg.includes("Error initializing part")) {
+      return "Endpoint construction failure";
     }
-    return [...ids];
-  }
-  clearSubscription() {
-    this.unsubscribe?.();
-    this.unsubscribe = void 0;
-  }
-  stopObserving() {
-    this.observingRequested = false;
-    this.lifecycle++;
-    this.clearSubscription();
-    if (this.removalRecheckTimer) {
-      clearTimeout(this.removalRecheckTimer);
-      this.removalRecheckTimer = null;
+    if (msg.includes("aggregator.")) {
+      return "Runtime error in endpoint";
     }
+    return null;
   }
-  async refreshDevices() {
-    this.registry.refresh();
-    const lifecycle = this.lifecycle;
-    const endpoints = [...this.root.parts].filter(hasEntityIdentity).filter((p) => !(p instanceof VacuumAreaSwitchEndpoint));
-    const fullEntities = this.registry.fullEntities;
-    if (!this.client.haRunning || Object.keys(fullEntities).length === 0) {
-      this.pendingRemovals.clear();
-      this.log.warn(
-        `HA not running or registry empty, deferring reconcile of ${endpoints.length} endpoints`
+  /**
+   * Attempt to isolate an entity based on an error.
+   * Returns true if the entity was successfully identified and isolation was triggered.
+   */
+  async isolateFromError(error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    const classification = this.classifyError(msg);
+    if (!classification) {
+      return false;
+    }
+    const parsed = this.parseEndpointPath(msg);
+    if (!parsed) {
+      logger252.warn("Could not parse entity from error:", msg);
+      return false;
+    }
+    const { bridgeId, entityName } = parsed;
+    const callback = this.isolationCallbacks.get(bridgeId);
+    if (!callback) {
+      logger252.warn(
+        `No isolation callback registered for bridge ${bridgeId}, entity: ${entityName}`
       );
-      return;
+      return false;
     }
-    this._failedEntities = [];
-    this.entityIds = this.registry.entityIds;
-    if (this.registry.isAutoComposedDevicesEnabled()) {
-      for (const eid of this.entityIds) {
-        const m = this.getEntityMapping(eid);
-        if (m?.composedEntities) {
-          for (const sub of m.composedEntities) {
-            if (sub.entityId) {
-              this.registry.markComposedSubEntityUsed(sub.entityId);
-            }
-          }
-        }
-        if (!eid.startsWith("fan.")) continue;
-        const matterType = m?.matterDeviceType ?? "fan";
-        if (matterType !== "air_purifier") continue;
-        const ent = this.registry.entity(eid);
-        const tempId = m?.temperatureEntity || (ent?.device_id ? this.registry.findTemperatureEntityForDevice(ent.device_id) : void 0);
-        const humId = m?.humidityEntity || (ent?.device_id ? this.registry.findHumidityEntityForDevice(ent.device_id) : void 0);
-        if (tempId) this.registry.markComposedSubEntityUsed(tempId);
-        if (humId) this.registry.markComposedSubEntityUsed(humId);
+    const key = `${bridgeId}:${entityName}`;
+    if (this.isolatedEntities.has(key)) {
+      return true;
+    }
+    const reason = `${classification}. Entity isolated to protect bridge stability.`;
+    this.isolatedEntities.set(key, {
+      entityId: entityName,
+      reason,
+      failedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    logger252.warn(
+      `Isolating entity "${entityName}" from bridge ${bridgeId} due to: ${reason}`
+    );
+    diagnosticEventBus.emit("entity_error", `Entity isolated: ${entityName}`, {
+      bridgeId,
+      entityId: entityName,
+      details: { reason: classification }
+    });
+    try {
+      await callback(entityName);
+      return true;
+    } catch (e) {
+      logger252.error(`Failed to isolate entity ${entityName}:`, e);
+      return false;
+    }
+  }
+  /**
+   * Get all isolated entities for a specific bridge.
+   */
+  getIsolatedEntities(bridgeId) {
+    const result = [];
+    for (const [key, entity] of this.isolatedEntities) {
+      if (key.startsWith(`${bridgeId}:`)) {
+        result.push(entity);
       }
     }
-    const stableIdentity = this.registry.isStableIdentityEnabled();
-    const resolvedByEntity = /* @__PURE__ */ new Map();
-    const endpointIdToEntity = /* @__PURE__ */ new Map();
-    const claimedEndpointIds = /* @__PURE__ */ new Map();
-    for (const entityId of this.entityIds) {
-      const entityInfo = {
-        entity_id: entityId,
-        registry: this.registry.entity(entityId)
-      };
-      const resolved = await this.identityResolver.resolveIdentity(
-        this.bridgeId,
-        entityInfo,
-        this.getEntityMapping(entityId),
-        {
-          stableIdentity,
-          isEndpointIdTaken: (id, key) => claimedEndpointIds.has(id) && claimedEndpointIds.get(id) !== key
-        }
-      );
-      resolvedByEntity.set(entityId, resolved);
-      claimedEndpointIds.set(
-        resolved.endpointId,
-        identityKey(entityInfo) ?? `\0e:${entityId}`
-      );
-      endpointIdToEntity.set(resolved.endpointId, entityId);
-      if (resolved.renamedFrom && this.mappingFingerprints.has(resolved.renamedFrom)) {
-        const fp = this.mappingFingerprints.get(resolved.renamedFrom);
-        this.mappingFingerprints.delete(resolved.renamedFrom);
-        this.mappingFingerprints.set(entityId, fp);
+    return result;
+  }
+  /**
+   * Clear isolated entities for a bridge (e.g., on restart).
+   */
+  clearIsolatedEntities(bridgeId) {
+    for (const key of this.isolatedEntities.keys()) {
+      if (key.startsWith(`${bridgeId}:`)) {
+        this.isolatedEntities.delete(key);
       }
     }
-    stampIdentityPresence(
-      this.identityStorage,
-      this.bridgeId,
-      buildPresentIdentityKeys(fullEntities)
+  }
+};
+var EntityIsolationService = new EntityIsolationServiceImpl();
+
+// src/services/bridges/bridge-endpoint-manager.ts
+var MAX_ENTITY_ID_LENGTH = 150;
+var ENDPOINT_REMOVAL_GRACE_MS = 3e5;
+function isEntityPart(p) {
+  return typeof p.updateStates === "function";
+}
+function hasEntityIdentity(p) {
+  return typeof p.entityId === "string";
+}
+var BridgeEndpointManager = class extends Service {
+  constructor(client, registry3, mappingStorage, identityStorage, bridgeId, log, pluginManager, pluginRegistry, pluginInstaller) {
+    super("BridgeEndpointManager");
+    this.client = client;
+    this.registry = registry3;
+    this.mappingStorage = mappingStorage;
+    this.identityStorage = identityStorage;
+    this.bridgeId = bridgeId;
+    this.log = log;
+    this.pluginManager = pluginManager;
+    this.pluginRegistry = pluginRegistry;
+    this.pluginInstaller = pluginInstaller;
+    this.root = new AggregatorEndpoint2("aggregator");
+    this.identityResolver = new IdentityResolver(
+      identityStorage,
+      mappingStorage
     );
-    stampMappingPresence(
-      this.mappingStorage,
-      this.bridgeId,
-      buildPresentEntityIds(fullEntities)
+    EntityIsolationService.registerIsolationCallback(
+      bridgeId,
+      this.isolateEntity.bind(this)
     );
-    for (const part of [...this.root.parts]) {
-      if (!(part instanceof VacuumAreaSwitchEndpoint)) continue;
-      const claimant = endpointIdToEntity.get(part.id);
-      if (claimant == null) continue;
-      this.log.info(
-        `Area switch ${part.id} collides with entity ${claimant}, removing the switch`
-      );
-      try {
-        await part.delete();
-      } catch (e) {
-        this.log.warn(`Failed to remove colliding area switch ${part.id}:`, e);
-      }
+    if (this.pluginManager) {
+      this.wirePluginCallbacks();
     }
-    const existingEndpoints = [];
-    const now = Date.now();
-    for (const endpoint of endpoints) {
-      const present = this.entityIds.includes(endpoint.entityId);
-      const claimant = endpointIdToEntity.get(endpoint.id);
-      if (!present && claimant != null && claimant !== endpoint.entityId) {
-        this.log.info(
-          `Entity renamed ${endpoint.entityId} -> ${claimant}, keeping endpoint ${endpoint.id}`
-        );
-        try {
-          await endpoint.close();
-        } catch (e) {
-          this.log.warn(
-            `Failed to close renamed endpoint ${endpoint.entityId}:`,
-            e
-          );
-        }
-        this.pendingRemovals.delete(endpoint.entityId);
-        this.mappingFingerprints.delete(endpoint.entityId);
-        continue;
-      }
-      if (present) {
-        this.pendingRemovals.delete(endpoint.entityId);
-      }
-      if (!present) {
-        const entry = this.pendingRemovals.get(endpoint.entityId);
-        if (entry == null) {
-          this.pendingRemovals.set(endpoint.entityId, {
-            since: now,
-            generation: this.registry.snapshotGeneration
-          });
-          existingEndpoints.push(endpoint);
-          continue;
-        }
-        if (now - entry.since < ENDPOINT_REMOVAL_GRACE_MS || now - this.client.runningSince < ENDPOINT_REMOVAL_GRACE_MS || this.registry.snapshotGeneration <= entry.generation) {
-          existingEndpoints.push(endpoint);
-          continue;
-        }
+  }
+  client;
+  registry;
+  mappingStorage;
+  identityStorage;
+  bridgeId;
+  log;
+  pluginManager;
+  pluginRegistry;
+  pluginInstaller;
+  root;
+  entityIds = [];
+  unsubscribe;
+  observingRequested = false;
+  _failedEntities = [];
+  mappingFingerprints = /* @__PURE__ */ new Map();
+  // entityId -> first absence stamp (grace window)
+  pendingRemovals = /* @__PURE__ */ new Map();
+  removalRecheckTimer = null;
+  // Bumped on every stop, so a refresh that was already running cannot arm a
+  // timer on a bridge that has since stopped (#438).
+  lifecycle = 0;
+  pluginEndpoints = /* @__PURE__ */ new Map();
+  pluginStateUpdating = /* @__PURE__ */ new Set();
+  pluginListeners = /* @__PURE__ */ new Map();
+  get failedEntities() {
+    const isolated = EntityIsolationService.getIsolatedEntities(this.bridgeId);
+    return [...this._failedEntities, ...isolated];
+  }
+  addFailedEntity(entityId, reason) {
+    this._failedEntities.push({
+      entityId,
+      reason,
+      failedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  identityResolver;
+  wirePluginCallbacks() {
+    if (!this.pluginManager) return;
+    this.pluginManager.onDeviceRegistered = async (pluginName, device) => {
+      let endpoint;
+      if (device.endpointType) {
         try {
-          this.log.info(
-            `Removing endpoint ${endpoint.entityId} (ep ${endpoint.number}) after the grace window, controllers will see a new number if it returns`
+          validateEndpointType(
+            device.endpointType,
+            `plugin:${pluginName}:${device.id}`
           );
-          await endpoint.delete();
-        } catch (e) {
-          this.log.warn(`Failed to delete endpoint ${endpoint.entityId}:`, e);
-        }
-        this.mappingFingerprints.delete(endpoint.entityId);
-        this.pendingRemovals.delete(endpoint.entityId);
-      } else if (this.registry.isAutoComposedDevicesEnabled() && this.registry.isComposedSubEntityUsed(endpoint.entityId)) {
-        this.log.info(
-          `Removing standalone endpoint ${endpoint.entityId}, consumed by composed device`
-        );
-        try {
-          await endpoint.close();
         } catch (e) {
           this.log.warn(
-            `Failed to remove composed sub-entity endpoint ${endpoint.entityId}:`,
+            `Plugin "${pluginName}": invalid endpointType for device "${device.id}":`,
             e
           );
+          return;
         }
-        this.mappingFingerprints.delete(endpoint.entityId);
-      } else {
-        const currentMapping = this.getEntityMapping(endpoint.entityId);
-        const currentFp = this.computeMappingFingerprint(currentMapping);
-        const storedFp = this.mappingFingerprints.get(endpoint.entityId) ?? "";
-        if (currentFp !== storedFp) {
-          this.log.info(
-            `Mapping changed for ${endpoint.entityId}, recreating endpoint`
-          );
-          const resolvedId = resolvedByEntity.get(endpoint.entityId)?.endpointId ?? createEndpointId(endpoint.entityId, currentMapping?.customName);
-          const sameId = resolvedId === endpoint.id;
-          try {
-            if (sameId) {
-              await endpoint.close();
-            } else {
-              await endpoint.delete();
-            }
-          } catch (e) {
+        const supplied = device.endpointType;
+        const initialState = {};
+        for (const cluster2 of device.clusters) {
+          if (cluster2.clusterId === "pluginDevice" && supplied.behaviors?.pluginDevice == null && supplied.behaviors?.bridgedDeviceBasicInformation == null) {
             this.log.warn(
-              `Failed to recreate endpoint ${endpoint.entityId} for mapping change:`,
-              e
+              `Plugin "${pluginName}": device "${device.id}" declares a "pluginDevice" cluster without owning that behavior, ignoring it`
             );
+            continue;
           }
-          this.mappingFingerprints.delete(endpoint.entityId);
-        } else {
-          existingEndpoints.push(endpoint);
+          initialState[cluster2.clusterId] = cluster2.attributes;
         }
-      }
-    }
-    if (lifecycle === this.lifecycle) {
-      this.scheduleRemovalRecheck();
-    }
-    let memoryLimitReached = false;
-    for (const entityId of this.entityIds) {
-      if (!memoryLimitReached && isHeapUnderPressure()) {
-        memoryLimitReached = true;
-        this.log.error(
-          "Memory pressure detected, skipping remaining entities to prevent OOM crash. Reduce the number of entities in this bridge or increase the Node.js heap size (NODE_OPTIONS=--max-old-space-size=1024)."
-        );
-      }
-      if (memoryLimitReached) {
-        if (!existingEndpoints.some((e) => e.entityId === entityId)) {
-          this.addFailedEntity(
-            entityId,
-            "Skipped due to memory pressure, reduce entities or increase heap size"
+        const hasOwnIdentity = supplied.behaviors?.bridgedDeviceBasicInformation != null;
+        const ownsPluginDevice = supplied.behaviors?.pluginDevice != null;
+        const mutable = typeof supplied.with === "function" && typeof supplied.set === "function";
+        if (!mutable && Object.keys(initialState).length > 0) {
+          this.log.warn(
+            `Plugin "${pluginName}": endpointType for device "${device.id}" cannot take its cluster config, skipping it`
           );
+          return;
         }
-        continue;
-      }
-      const mapping = this.getEntityMapping(entityId);
-      if (mapping?.disabled) {
-        this.log.debug(`Skipping disabled entity: ${entityId}`);
-        continue;
-      }
-      if (this.registry.isAutoComposedDevicesEnabled() && this.registry.isComposedSubEntityUsed(entityId)) {
-        this.log.debug(
-          `Skipping ${entityId}, already part of a composed device`
-        );
-        continue;
-      }
-      if (entityId.length > MAX_ENTITY_ID_LENGTH) {
-        const reason = `Entity ID too long (${entityId.length} chars, max ${MAX_ENTITY_ID_LENGTH}). This would cause filesystem errors.`;
-        this.log.warn(`Skipping entity: ${entityId}. Reason: ${reason}`);
-        this.addFailedEntity(entityId, reason);
-        continue;
-      }
-      let endpoint = existingEndpoints.find((e) => e.entityId === entityId);
-      if (!endpoint) {
-        try {
-          const domainMappings = this.getPluginDomainMappings();
-          const resolved = resolvedByEntity.get(entityId);
-          endpoint = await LegacyEndpoint.create(
-            this.registry,
-            entityId,
-            mapping,
-            domainMappings,
-            false,
-            resolved?.endpointId,
-            resolved?.anchorEntityId
+        if (!hasOwnIdentity && (!mutable || ownsPluginDevice)) {
+          this.log.warn(
+            `Plugin "${pluginName}": device "${device.id}" mounts without BridgedDeviceBasicInformation, controllers may not show it`
           );
-        } catch (e) {
-          const reason = this.extractErrorReason(e);
-          this.log.warn(`Failed to create device ${entityId}: ${reason}`);
-          this.addFailedEntity(entityId, reason);
-          continue;
         }
-        if (endpoint) {
-          try {
-            await this.root.add(endpoint);
-            this.mappingFingerprints.set(
-              entityId,
-              this.computeMappingFingerprint(mapping)
-            );
-          } catch (e) {
-            const errorMessage = e instanceof Error ? e.message : String(e);
-            this.log.warn(
-              `Failed to add endpoint for ${entityId}: ${errorMessage}`
-            );
-            this.logDetailedError(entityId, e);
-            this.addFailedEntity(entityId, this.extractErrorReason(e));
-          }
+        let base = device.endpointType;
+        if (mutable && !hasOwnIdentity && !ownsPluginDevice) {
+          base = base.with(PluginBasicInformationServer, PluginDeviceBehavior);
+          initialState.pluginDevice = { device, pluginName };
         }
-      }
-    }
-    await this.reconcileAreaSwitches();
-    if (this.observingRequested) {
-      this.startObserving();
-    }
-  }
-  // Opt-in per-area room switches (#355). One momentary OnOffPlugInUnit sibling
-  // per configured service area, mounted alongside its vacuum with a stable
-  // derived id. Areas and mapping come from the parent's vacuumEffective, the
-  // exact config its ServiceArea cluster was built from, never from raw storage
-  // (raw can be a different id space: injected Valetudo/Roborock rooms,
-  // auto-resolved CLEAN_AREA). The vacuum's own endpoint is never touched here.
-  // Switches are kept while their parent endpoint survives with the flag on
-  // (the parent's removal grace is mirrored for free), rebuilt via close() when
-  // the parent was recreated for a mapping change so numbers survive, and
-  // deleted when the flag goes off, the area is gone, or the parent is gone.
-  async reconcileAreaSwitches() {
-    const parts = this.root.parts.map((p) => p);
-    const switches = parts.filter(
-      (p) => p instanceof VacuumAreaSwitchEndpoint
-    );
-    const vacuumById = /* @__PURE__ */ new Map();
-    for (const part of parts) {
-      if (part instanceof VacuumAreaSwitchEndpoint) continue;
-      vacuumById.set(part.id, part);
-    }
-    const isolated = new Set(
-      EntityIsolationService.getIsolatedEntities(this.bridgeId).map(
-        (f) => f.entityId
-      )
-    );
-    const parentIsolated = (parent) => isolated.has(parent.id) || parent.entityId != null && isolated.has(parent.entityId);
-    const kept = /* @__PURE__ */ new Set();
-    for (const sw of switches) {
-      const parent = vacuumById.get(sw.vacuumEndpointId);
-      const mapping = parent ? this.getEntityMapping(parent.entityId) : void 0;
-      const effective = parent instanceof LegacyEndpoint ? parent.vacuumEffective : void 0;
-      let keep = false;
-      let rebuild = false;
-      if (parent && !parentIsolated(parent) && mapping?.vacuumRoomSwitches && effective) {
-        const areas = getVacuumServiceAreas(
-          effective.state.attributes,
-          effective.mapping
+        endpoint = new Endpoint(
+          Object.keys(initialState).length > 0 ? base.set(initialState) : base,
+          { id: `plugin_${device.id}` }
         );
-        if (areas.some((a) => a.areaId === sw.areaId)) {
-          if (sw.parentEffective === effective) {
-            keep = true;
-          } else {
-            rebuild = true;
-          }
-        }
-      }
-      if (keep) {
-        kept.add(sw.id);
-        continue;
-      }
-      try {
-        if (rebuild) {
-          await sw.close();
-        } else {
-          await sw.delete();
-        }
-      } catch (e) {
-        this.log.warn(`Failed to remove area switch ${sw.id}:`, e);
-      }
-    }
-    for (const part of vacuumById.values()) {
-      const entityId = part.entityId;
-      if (!entityId?.startsWith("vacuum.")) continue;
-      if (parentIsolated(part)) continue;
-      const mapping = this.getEntityMapping(entityId);
-      if (!mapping?.vacuumRoomSwitches) continue;
-      const effective = part instanceof LegacyEndpoint ? part.vacuumEffective : void 0;
-      if (!effective) continue;
-      const areas = getVacuumServiceAreas(
-        effective.state.attributes,
-        effective.mapping
-      );
-      const entity = {
-        entity_id: entityId,
-        state: effective.state,
-        registry: this.registry.entity(entityId),
-        deviceRegistry: this.registry.deviceOf(entityId)
-      };
-      for (const area of areas) {
-        const switchId = `${part.id}_roomsw_${area.areaId}`;
-        if (kept.has(switchId)) continue;
-        const holder = vacuumById.get(switchId);
-        if (holder) {
+      } else {
+        const type = createPluginEndpointType(device.deviceType ?? "");
+        if (!type) {
           this.log.warn(
-            `Skipping area switch ${switchId} for ${entityId}: id taken by entity ${holder.entityId}`
+            `Plugin "${pluginName}": unsupported device type "${device.deviceType}" for device "${device.id}"`
           );
-          continue;
+          return;
+        }
+        const initialState = {
+          pluginDevice: { device, pluginName }
+        };
+        for (const cluster2 of device.clusters) {
+          initialState[cluster2.clusterId] = cluster2.attributes;
+        }
+        endpoint = new Endpoint(type.set(initialState), {
+          id: `plugin_${device.id}`
+        });
+      }
+      try {
+        await this.root.add(endpoint);
+        this.pluginEndpoints.set(device.id, endpoint);
+        this.wirePluginEndpointEvents(device, endpoint);
+        this.log.info(
+          `Plugin "${pluginName}": added device "${device.name}" (${device.deviceType})`
+        );
+      } catch (e) {
+        this.log.warn(
+          `Plugin "${pluginName}": failed to add device "${device.id}":`,
+          e
+        );
+      }
+    };
+    this.pluginManager.onDeviceUnregistered = async (pluginName, deviceId, options) => {
+      const listeners = this.pluginListeners.get(deviceId);
+      if (listeners) {
+        for (const { observable, listener } of listeners) {
+          try {
+            observable.off(listener);
+          } catch {
+          }
         }
+        this.pluginListeners.delete(deviceId);
+      }
+      const endpoint = this.pluginEndpoints.get(deviceId);
+      if (endpoint) {
         try {
-          const endpoint = VacuumAreaSwitchEndpoint.create({
-            vacuumEndpointId: part.id,
-            entity,
-            mapping: effective.mapping,
-            area,
-            parentEffective: effective
-          });
-          await this.root.add(endpoint);
+          if (options?.keepIdentity) {
+            await endpoint.close();
+          } else {
+            await endpoint.delete();
+          }
         } catch (e) {
           this.log.warn(
-            `Failed to add area switch ${switchId} for ${entityId}:`,
+            `Plugin "${pluginName}": failed to remove device "${deviceId}":`,
             e
           );
         }
+        this.pluginEndpoints.delete(deviceId);
       }
-    }
-  }
-  updateInFlight;
-  pendingStates;
-  pendingChanged;
-  mergeChanged(a, b) {
-    if (a === null || b === null) return null;
-    const merged = new Set(a);
-    for (const id of b) merged.add(id);
-    return merged;
-  }
-  async updateStates(states, changed = null) {
-    if (this.updateInFlight) {
-      this.pendingStates = states;
-      this.pendingChanged = this.pendingChanged === void 0 ? changed : this.mergeChanged(this.pendingChanged, changed);
-      return this.updateInFlight;
-    }
-    this.updateInFlight = this.runUpdateStates(states, changed).finally(() => {
-      this.updateInFlight = void 0;
-      const queued = this.pendingStates;
-      const queuedChanged = this.pendingChanged;
-      this.pendingStates = void 0;
-      this.pendingChanged = void 0;
-      if (queued) {
-        this.updateStates(
-          queued,
-          queuedChanged === void 0 ? null : queuedChanged
-        ).catch((e) => this.log.warn("Queued state update failed:", e));
-      }
-    });
-    return this.updateInFlight;
-  }
-  async runUpdateStates(states, changed) {
-    const startMs = performance.now();
-    this.registry.mergeExternalStates(states);
-    const allEndpoints = [...this.root.parts].filter(isEntityPart);
-    const endpoints = changed === null ? allEndpoints : allEndpoints.filter(
-      (e) => changed.has(e.entityId) || (e.mappedEntityIds ?? []).some((id) => changed.has(id))
-    );
-    if (endpoints.length === 0) return;
-    const results = await Promise.allSettled(
-      endpoints.map((endpoint) => endpoint.updateStates(states))
-    );
-    let failedCount = 0;
-    for (const result of results) {
-      if (result.status === "rejected") {
-        failedCount++;
-        this.log.warn("State update failed for endpoint:", result.reason);
-      }
-    }
-    const latencyMs = Math.round((performance.now() - startMs) * 100) / 100;
-    if (latencyMs > 200 || failedCount > 0) {
-      const msg = `State update: ${endpoints.length} endpoints in ${latencyMs}ms` + (failedCount > 0 ? ` (${failedCount} failed)` : "");
-      if (latencyMs > 200) {
-        this.log.warn(`Slow ${msg}`);
-      }
-      diagnosticEventBus.emit("state_update", msg, {
-        bridgeId: this.bridgeId,
-        details: {
-          endpointCount: endpoints.length,
-          failedCount,
-          latencyMs
-        }
-      });
-    }
-  }
-  /**
-   * Log detailed behavior error information for debugging "Behaviors have errors".
-   * Matter.js EndpointBehaviorsError extends AggregateError, the `errors` array
-   * contains individual behavior crash errors (one per failed behavior).
-   */
-  logDetailedError(entityId, error) {
-    if (!(error instanceof Error)) return;
-    const errorsArray = error.errors;
-    if (Array.isArray(errorsArray) && errorsArray.length > 0) {
-      for (let i = 0; i < errorsArray.length; i++) {
-        const subError = errorsArray[i];
-        const subMsg = subError instanceof Error ? subError.message : String(subError);
-        this.log.warn(
-          `[${entityId}] Behavior error [${i + 1}/${errorsArray.length}]: ${subMsg}`
+    };
+    this.pluginManager.onDeviceStateUpdated = (pluginName, deviceId, clusterId3, attributes9) => {
+      const endpoint = this.pluginEndpoints.get(deviceId);
+      if (!endpoint) return;
+      const behaviorType = endpoint.type.behaviors[clusterId3];
+      if (!behaviorType) {
+        this.log.debug(
+          `Plugin "${pluginName}": cluster "${clusterId3}" not found on device "${deviceId}"`
         );
-        let cause = subError instanceof Error ? subError.cause : void 0;
-        while (cause instanceof Error) {
-          this.log.warn(`[${entityId}]   Caused by: ${cause.message}`);
-          cause = cause.cause;
-        }
-        if (subError instanceof Error && subError.stack) {
-          this.log.debug(`[${entityId}] Sub-error stack: ${subError.stack}`);
-        }
-      }
-    } else {
-      let current = error.cause;
-      while (current instanceof Error) {
-        this.log.warn(`[${entityId}] Caused by: ${current.message}`);
-        current = current.cause;
-      }
-    }
-    if (error.stack) {
-      this.log.debug(`[${entityId}] Full stack: ${error.stack}`);
-    }
-  }
-  extractErrorReason(error) {
-    if (error instanceof Error) {
-      const cause = error.cause;
-      if (cause?.message) {
-        return `${error.message}: ${cause.message}`;
+        return;
       }
-      return error.message;
-    }
-    return String(error);
-  }
-};
-
-// src/services/bridges/bridge-registry.ts
-init_dist();
-init_esm();
-init_send_ha_message();
-import { callService as callService2 } from "home-assistant-js-websocket";
-import { keys as keys2, pickBy, values as values3 } from "lodash-es";
-var BridgeRegistry = class _BridgeRegistry {
-  constructor(registry3, dataProvider, client) {
-    this.registry = registry3;
-    this.dataProvider = dataProvider;
-    this.client = client;
-    this.refresh();
-  }
-  registry;
-  dataProvider;
-  client;
-  get entityIds() {
-    return keys2(this._entities);
-  }
-  _devices = {};
-  _entities = {};
-  _states = {};
-  // Track battery entities that have been auto-assigned to other devices
-  _usedBatteryEntities = /* @__PURE__ */ new Set();
-  // Cache for battery entity lookups (deviceId -> entityId or null)
-  _batteryEntityCache = /* @__PURE__ */ new Map();
-  // Cache for problem entity lookups (deviceId -> entityId or null) (#408)
-  _problemEntityCache = /* @__PURE__ */ new Map();
-  // Track humidity entities that have been auto-assigned to temperature sensors
-  _usedHumidityEntities = /* @__PURE__ */ new Set();
-  // Track pressure entities that have been auto-assigned to temperature sensors
-  _usedPressureEntities = /* @__PURE__ */ new Set();
-  // Track power entities that have been auto-assigned to switch/plug entities
-  _usedPowerEntities = /* @__PURE__ */ new Set();
-  // Track energy entities that have been auto-assigned to switch/plug entities
-  _usedEnergyEntities = /* @__PURE__ */ new Set();
-  // Track entities consumed by composed devices (e.g., sensors/climate grouped under air purifier)
-  _usedComposedSubEntities = /* @__PURE__ */ new Set();
-  deviceOf(entityId) {
-    const entity = this._entities[entityId];
-    return this._devices[entity.device_id];
-  }
-  entity(entityId) {
-    return this._entities[entityId];
-  }
-  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;
-  }
-  // Successful-reload counter, see HomeAssistantRegistry (#438).
-  get snapshotGeneration() {
-    return this.registry.snapshotGeneration;
-  }
-  // 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.
-  initialStateIncludingUnfiltered(entityId) {
-    return this._states[entityId] ?? this.registry.states[entityId];
-  }
-  entityIncludingUnfiltered(entityId) {
-    return this._entities[entityId] ?? this.registry.entities[entityId];
-  }
-  deviceOfIncludingUnfiltered(entityId) {
-    const entity = this.entityIncludingUnfiltered(entityId);
-    if (!entity) return void 0;
-    return this._devices[entity.device_id] ?? this.registry.devices[entity.device_id];
-  }
-  /**
-   * Find a battery sensor entity that belongs to the same HA device.
-   * Returns the entity_id of the battery sensor, or undefined if none found.
-   */
-  findBatteryEntityForDevice(deviceId) {
-    if (this._batteryEntityCache.has(deviceId)) {
-      const cached = this._batteryEntityCache.get(deviceId);
-      return cached === null ? void 0 : cached;
-    }
-    const entities = values3(this.registry.entities);
-    const sameDevice = entities.filter((e) => e.device_id === deviceId);
-    for (const entity of sameDevice) {
-      if (!entity.entity_id.startsWith("sensor.")) continue;
-      const state = this.registry.states[entity.entity_id];
-      if (!state) {
-        continue;
+      this.pluginStateUpdating.add(deviceId);
+      endpoint.setStateOf(behaviorType, attributes9).catch((e) => {
+        this.log.warn(
+          `Plugin "${pluginName}": failed to update "${clusterId3}" on "${deviceId}":`,
+          e
+        );
+      }).finally(() => {
+        this.pluginStateUpdating.delete(deviceId);
+      });
+    };
+  }
+  wirePluginEndpointEvents(device, endpoint) {
+    if (!device.onAttributeWrite) return;
+    const allEvents = endpoint.events;
+    const listeners = [];
+    for (const behaviorId of Object.keys(endpoint.type.behaviors)) {
+      if (behaviorId === "pluginDevice") continue;
+      const behaviorEvents = allEvents[behaviorId];
+      if (!behaviorEvents || typeof behaviorEvents !== "object") continue;
+      const eventNames = /* @__PURE__ */ new Set();
+      for (let proto = behaviorEvents; proto && proto !== Object.prototype; proto = Object.getPrototypeOf(proto)) {
+        for (const name of Object.getOwnPropertyNames(proto)) {
+          if (name.endsWith("$Changed")) eventNames.add(name);
+        }
       }
-      const attrs = state.attributes;
-      if (attrs.device_class === SensorDeviceClass.battery && resolveBatteryPercent(state.state) != null) {
-        this._batteryEntityCache.set(deviceId, entity.entity_id);
-        return entity.entity_id;
+      for (const eventName of eventNames) {
+        const observable = behaviorEvents[eventName];
+        if (!observable || typeof observable.on !== "function") continue;
+        const attrName = eventName.slice(0, -"$Changed".length);
+        const listener = (newValue) => {
+          if (this.pluginStateUpdating.has(device.id)) return;
+          device.onAttributeWrite?.(behaviorId, attrName, newValue).catch((e) => {
+            this.log.debug(
+              `Plugin device "${device.id}": onAttributeWrite error for ${behaviorId}.${attrName}:`,
+              e
+            );
+          });
+        };
+        observable.on(listener);
+        listeners.push({ observable, listener });
       }
     }
-    for (const entity of sameDevice) {
-      if (!entity.entity_id.startsWith("binary_sensor.")) continue;
-      const state = this.registry.states[entity.entity_id];
-      if (!state) continue;
-      const attrs = state.attributes;
-      if (attrs.device_class === "battery" && resolveBatteryPercent(state.state) != null) {
-        this._batteryEntityCache.set(deviceId, entity.entity_id);
-        return entity.entity_id;
-      }
+    if (listeners.length > 0) {
+      this.pluginListeners.set(device.id, listeners);
     }
-    for (const entity of sameDevice) {
-      if (!entity.entity_id.startsWith("sensor.")) continue;
-      const state = this.registry.states[entity.entity_id];
-      if (!state) continue;
-      const attrs = state.attributes;
-      const looksLikeBattery = attrs.unit_of_measurement === "%" || entity.entity_id.toLowerCase().includes("batt");
-      if ((attrs.device_class === "enum" || attrs.device_class == null && looksLikeBattery) && resolveBatteryPercent(state.state) != null) {
-        this._batteryEntityCache.set(deviceId, entity.entity_id);
-        return entity.entity_id;
+  }
+  async startPlugins() {
+    if (!this.pluginManager) return;
+    await this.registerBuiltInPlugins();
+    await this.loadRegisteredPlugins();
+    await this.pluginManager.startAll();
+    await this.pluginManager.configureAll();
+  }
+  // Built-in plugins ship inside the backend bundle, so they share the same
+  // matter.js instance and can hand over live EndpointTypes.
+  async registerBuiltInPlugins() {
+    if (!this.pluginManager) return;
+    for (const Plugin of BUILTIN_PLUGINS) {
+      const plugin = new Plugin();
+      try {
+        await this.pluginManager.registerBuiltIn(plugin);
+      } catch (e) {
+        this.log.warn(
+          `Failed to register built-in plugin "${plugin.name}":`,
+          e
+        );
       }
     }
-    this._batteryEntityCache.set(deviceId, null);
-    return void 0;
   }
-  /**
-   * Mark a battery entity as used (auto-assigned to another device).
-   */
-  markBatteryEntityUsed(entityId) {
-    this._usedBatteryEntities.add(entityId);
+  async loadRegisteredPlugins() {
+    if (!this.pluginManager || !this.pluginRegistry || !this.pluginInstaller)
+      return;
+    const registered = this.pluginRegistry.getAll();
+    for (const entry of registered) {
+      if (!entry.autoLoad) continue;
+      const packagePath = this.pluginInstaller.getPluginPath(entry.packageName);
+      try {
+        await this.pluginManager.loadExternal(packagePath, entry.config);
+        this.log.info(
+          `Loaded external plugin: ${entry.packageName} from ${packagePath}`
+        );
+      } catch (e) {
+        this.log.warn(
+          `Failed to load external plugin "${entry.packageName}":`,
+          e
+        );
+      }
+    }
   }
-  /**
-   * Check if a battery entity has been auto-assigned to another device.
-   */
-  isBatteryEntityUsed(entityId) {
-    return this._usedBatteryEntities.has(entityId);
+  async stopPlugins() {
+    if (!this.pluginManager) return;
+    await this.pluginManager.shutdownAll("Bridge stopping");
+    for (const [id, endpoint] of this.pluginEndpoints) {
+      try {
+        await endpoint.close();
+      } catch (e) {
+        this.log.warn(`Failed to close plugin endpoint ${id}:`, e);
+      }
+    }
+    this.pluginEndpoints.clear();
   }
-  /**
-   * Find a problem/safety binary sensor on the same HA device, so a smoke/CO
-   * alarm can drive hardwareFaultAlert from it. Prefers device_class=problem
-   * over safety. Returns the entity_id, or undefined if none found (#408).
-   */
-  findProblemEntityForDevice(deviceId) {
-    if (this._problemEntityCache.has(deviceId)) {
-      const cached = this._problemEntityCache.get(deviceId);
-      return cached === null ? void 0 : cached;
+  getPluginInfo() {
+    if (!this.pluginManager) {
+      return { metadata: [], devices: [], circuitBreakers: {} };
     }
-    const entities = values3(this.registry.entities);
-    const sameDevice = entities.filter((e) => e.device_id === deviceId);
-    let safety;
-    for (const entity of sameDevice) {
-      if (!entity.entity_id.startsWith("binary_sensor.")) continue;
-      const state = this.registry.states[entity.entity_id];
-      if (!state) continue;
-      const attrs = state.attributes;
-      if (attrs.device_class === "problem") {
-        this._problemEntityCache.set(deviceId, entity.entity_id);
-        return entity.entity_id;
-      }
-      if (attrs.device_class === "safety" && !safety) {
-        safety = entity.entity_id;
-      }
+    const cbStates = this.pluginManager.getCircuitBreakerStates();
+    const circuitBreakers = {};
+    for (const [name, state] of cbStates) {
+      circuitBreakers[name] = state;
     }
-    this._problemEntityCache.set(deviceId, safety ?? null);
-    return safety;
+    return {
+      metadata: this.pluginManager.getMetadata(),
+      devices: this.pluginManager.getAllDevices(),
+      circuitBreakers
+    };
   }
-  /**
-   * Check if auto battery mapping is enabled for this bridge.
-   */
-  isAutoBatteryMappingEnabled() {
-    return this.dataProvider.featureFlags?.autoBatteryMapping === true || this.dataProvider.featureFlags?.autoComposedDevices === true;
+  async enablePlugin(pluginName) {
+    return await this.pluginManager?.enablePlugin(pluginName);
   }
-  /**
-   * Check if auto composed devices mode is enabled.
-   * When enabled, temperature sensors with auto-mapped humidity/pressure/battery
-   * build real Matter Composed Devices (BridgedNodeEndpoint with sub-endpoints)
-   * rather than stacking extra clusters onto a flat TemperatureSensor.
-   * Apple Home, Google Home, and Alexa render each sub-endpoint using its
-   * own device type.
-   */
-  isAutoComposedDevicesEnabled() {
-    return this.dataProvider.featureFlags?.autoComposedDevices === true;
+  async disablePlugin(pluginName) {
+    return await this.pluginManager?.disablePlugin(pluginName);
   }
-  /**
-   * Check if auto humidity mapping is enabled for this bridge.
-   * Default: true (enabled by default).
-   * When enabled, humidity sensors on the same device as a temperature sensor
-   * are combined into a single TemperatureHumiditySensor endpoint.
-   * Note: Apple Home does not display humidity on TemperatureSensorDevice
-   * endpoints, so users on Apple Home should explicitly disable this.
-   * See: https://github.com/RiDDiX/home-assistant-matter-hub/issues/133
-   */
-  isAutoHumidityMappingEnabled() {
-    return this.dataProvider.featureFlags?.autoHumidityMapping !== false || this.dataProvider.featureFlags?.autoComposedDevices === true;
+  resetPlugin(pluginName) {
+    this.pluginManager?.resetPlugin(pluginName);
+  }
+  getPluginConfigSchema(pluginName) {
+    return this.pluginManager?.getConfigSchema(pluginName);
+  }
+  async updatePluginConfig(pluginName, config8) {
+    return await this.pluginManager?.updateConfig(pluginName, config8) ?? false;
   }
   /**
-   * Find a humidity sensor entity that belongs to the same HA device.
-   * Returns the entity_id of the humidity sensor, or undefined if none found.
+   * Isolate an entity by removing it from the aggregator.
+   * Called by EntityIsolationService when a runtime error is detected.
    */
-  findHumidityEntityForDevice(deviceId) {
-    const entities = values3(this.registry.entities);
-    for (const entity of entities) {
-      if (entity.device_id !== deviceId) continue;
-      if (!entity.entity_id.startsWith("sensor.")) continue;
-      const state = this.registry.states[entity.entity_id];
-      if (!state) continue;
-      const attrs = state.attributes;
-      if (attrs.device_class === SensorDeviceClass.humidity) {
-        return entity.entity_id;
+  async isolateEntity(entityName) {
+    const endpoints = [...this.root.parts].filter(hasEntityIdentity);
+    const endpoint = endpoints.find(
+      (e) => !(e instanceof VacuumAreaSwitchEndpoint) && (e.id === entityName || e.entityId === entityName)
+    ) ?? endpoints.find((e) => e.id === entityName);
+    if (endpoint) {
+      this.log.warn(
+        `Isolating entity ${endpoint.entityId} due to runtime error`
+      );
+      try {
+        await endpoint.close();
+      } catch (e) {
+        this.log.error(`Failed to close isolated endpoint:`, e);
+      }
+      this.pendingRemovals.delete(endpoint.entityId);
+      this.mappingFingerprints.delete(endpoint.entityId);
+      if (!(endpoint instanceof VacuumAreaSwitchEndpoint)) {
+        for (const sw of endpoints) {
+          if (!(sw instanceof VacuumAreaSwitchEndpoint)) continue;
+          if (sw.vacuumEndpointId !== endpoint.id) continue;
+          try {
+            await sw.close();
+          } catch (e) {
+            this.log.warn(`Failed to remove area switch ${sw.id}:`, e);
+          }
+        }
       }
     }
-    return void 0;
   }
-  /**
-   * Find a temperature sensor entity that belongs to the same HA device.
-   * Returns the entity_id of the temperature sensor, or undefined if none found.
-   */
-  findTemperatureEntityForDevice(deviceId) {
-    const entities = values3(this.registry.entities);
-    for (const entity of entities) {
-      if (entity.device_id !== deviceId) continue;
-      if (!entity.entity_id.startsWith("sensor.")) continue;
-      const state = this.registry.states[entity.entity_id];
-      if (!state) continue;
-      const attrs = state.attributes;
-      if (attrs.device_class === SensorDeviceClass.temperature) {
-        return entity.entity_id;
-      }
+  // refreshDevices only runs on registry-fingerprint changes, which may not
+  // recur, so drive any held removals to completion ourselves once the grace
+  // window has passed.
+  scheduleRemovalRecheck() {
+    if (this.removalRecheckTimer) {
+      clearTimeout(this.removalRecheckTimer);
+      this.removalRecheckTimer = null;
+    }
+    if (this.pendingRemovals.size === 0) return;
+    const lifecycle = this.lifecycle;
+    this.removalRecheckTimer = setTimeout(() => {
+      this.removalRecheckTimer = null;
+      this.refreshDevices().catch((e) => {
+        this.log.warn("Endpoint removal recheck failed:", e);
+        if (lifecycle === this.lifecycle) this.scheduleRemovalRecheck();
+      });
+    }, ENDPOINT_REMOVAL_GRACE_MS + 5e3);
+  }
+  getPluginDomainMappings() {
+    if (!this.pluginManager) return void 0;
+    const mappings = this.pluginManager.getDomainMappings();
+    if (mappings.size === 0) return void 0;
+    const result = /* @__PURE__ */ new Map();
+    for (const [domain, mapping] of mappings) {
+      result.set(domain, mapping.matterDeviceType);
     }
-    return void 0;
+    return result;
   }
-  /**
-   * Find a climate entity that belongs to the same HA device.
-   * Returns the entity_id of the climate entity, or undefined if none found.
-   */
-  findClimateEntityForDevice(deviceId) {
-    const entities = values3(this.registry.entities);
-    for (const entity of entities) {
-      if (entity.device_id !== deviceId) continue;
-      if (!entity.entity_id.startsWith("climate.")) continue;
-      const state = this.registry.states[entity.entity_id];
-      if (state) return entity.entity_id;
+  getEntityMapping(entityId) {
+    return this.mappingStorage.getMapping(this.bridgeId, entityId);
+  }
+  // #450: an endpoint built while its battery sensor was unavailable stays
+  // battery-less, because registry ticks only refresh on structural changes.
+  // When a same-device sensor state arrives, re-resolve and rebuild.
+  batteryRetryScheduled = false;
+  batteryRetryTimer = null;
+  // deviceId -> primary entityId of endpoints that auto-map but carry no
+  // battery, bounds the per-state-batch check to a map hit
+  batteryRetryCandidates = /* @__PURE__ */ new Map();
+  // Only endpoints the auto-mapping applies to belong here: a manual or
+  // disabled mapping, or a sensor endpoint sharing the device, must not
+  // claim the slot (last writer would win) and stall the recovery.
+  batteryRetryEligible(entityId) {
+    const mapping = this.getEntityMapping(entityId);
+    if (mapping?.batteryEntity || mapping?.disableBatteryMapping) return false;
+    if (entityId.startsWith("sensor.") || entityId.startsWith("binary_sensor.")) {
+      return false;
     }
-    return void 0;
+    return entityId.startsWith("vacuum.") || !!this.registry.isAutoBatteryMappingEnabled?.();
   }
-  /**
-   * Mark an entity as consumed by a composed device.
-   */
-  markComposedSubEntityUsed(entityId) {
-    this._usedComposedSubEntities.add(entityId);
+  rebuildBatteryRetryCandidates() {
+    this.batteryRetryCandidates.clear();
+    for (const part of this.root.parts) {
+      if (!hasEntityIdentity(part)) continue;
+      const fingerprint = this.mappingFingerprints.get(part.entityId);
+      if (fingerprint === void 0) continue;
+      if (fingerprintBattery(fingerprint) != null) continue;
+      if (!this.batteryRetryEligible(part.entityId)) continue;
+      const deviceId = this.registry.entity(part.entityId)?.device_id;
+      if (deviceId) this.batteryRetryCandidates.set(deviceId, part.entityId);
+    }
   }
-  /**
-   * Check if an entity has been consumed by a composed device.
-   */
-  isComposedSubEntityUsed(entityId) {
-    return this._usedComposedSubEntities.has(entityId);
+  maybeRetryBatteryMapping(states, changed) {
+    if (!this.observingRequested || this.batteryRetryScheduled || this.batteryRetryCandidates.size === 0) {
+      return;
+    }
+    for (const id of changed ?? Object.keys(states)) {
+      if (!id.startsWith("sensor.") && !id.startsWith("binary_sensor."))
+        continue;
+      const deviceId = this.registry.fullEntities[id]?.device_id;
+      if (!deviceId) continue;
+      const entityId = this.batteryRetryCandidates.get(deviceId);
+      if (!entityId) continue;
+      this.registry.forgetBatteryCacheForDevice(deviceId);
+      const resolved = this.registry.batteryFingerprintFor(
+        entityId,
+        this.getEntityMapping(entityId)
+      );
+      if (!resolved) continue;
+      this.batteryRetryScheduled = true;
+      this.log.info(
+        `Battery sensor ${resolved} appeared for ${entityId}, rebuilding`
+      );
+      this.batteryRetryTimer = setTimeout(() => {
+        this.batteryRetryTimer = null;
+        this.refreshDevices().catch((e) => this.log.warn("Battery retry refresh failed:", e)).finally(() => {
+          this.batteryRetryScheduled = false;
+        });
+      }, 0);
+      return;
+    }
   }
-  /**
-   * Mark a humidity entity as used (auto-assigned to a temperature sensor).
-   */
-  markHumidityEntityUsed(entityId) {
-    this._usedHumidityEntities.add(entityId);
+  computeMappingFingerprint(mapping, entityId) {
+    const battery = entityId ? this.registry.batteryFingerprintFor(entityId, mapping) : "";
+    return JSON.stringify([mapping ?? null, battery || null]);
+  }
+  // Live fingerprint for reconcile compares: when the resolver finds nothing
+  // right now but the stored fingerprint maps a sensor that still exists on
+  // the SAME device, keep it. An unavailable snapshot (HA restart) must not
+  // strip the mapping and rebuild the endpoint battery-less (#450).
+  compareFingerprint(mapping, entityId, storedFingerprint) {
+    const fingerprint = this.computeMappingFingerprint(mapping, entityId);
+    if (fingerprintBattery(fingerprint) != null || !storedFingerprint)
+      return fingerprint;
+    if (!this.batteryRetryEligible(entityId)) return fingerprint;
+    const battery = fingerprintBattery(storedFingerprint);
+    if (!battery) return fingerprint;
+    const deviceId = this.registry.entity(entityId)?.device_id;
+    const stillSameDevice = !!deviceId && this.registry.fullEntities[battery]?.device_id === deviceId;
+    return stillSameDevice ? JSON.stringify([mapping ?? null, battery]) : fingerprint;
+  }
+  // The stored fingerprint must reflect what this endpoint actually maps: a
+  // battery resolved while the endpoint was built without one (sensor outage
+  // during a forced rebuild) would otherwise never trigger the catch-up (#450).
+  fingerprintAsBuilt(mapping, entityId, endpoint) {
+    const fingerprint = this.computeMappingFingerprint(mapping, entityId);
+    const battery = fingerprintBattery(fingerprint);
+    if (battery == null) return fingerprint;
+    return (endpoint.mappedEntityIds ?? []).includes(battery) ? fingerprint : JSON.stringify([mapping ?? null, null]);
   }
-  /**
-   * Check if a humidity entity has been auto-assigned to a temperature sensor.
-   */
-  isHumidityEntityUsed(entityId) {
-    return this._usedHumidityEntities.has(entityId);
+  async dispose() {
+    this.stopObserving();
+    if (this.removalRecheckTimer) {
+      clearTimeout(this.removalRecheckTimer);
+      this.removalRecheckTimer = null;
+    }
+    this.pendingRemovals.clear();
+    EntityIsolationService.unregisterIsolationCallback(this.bridgeId);
+    EntityIsolationService.clearIsolatedEntities(this.bridgeId);
+    const endpoints = this.root.parts.map((p) => p);
+    for (const endpoint of endpoints) {
+      try {
+        await endpoint.close();
+      } catch (e) {
+        this.log.warn(`Failed to close endpoint during dispose:`, e);
+      }
+    }
   }
-  /**
-   * Check if auto pressure mapping is enabled for this bridge.
-   * Default: true (enabled by default).
-   * When enabled, pressure sensors on the same device as a temperature sensor
-   * are combined into a single endpoint with PressureMeasurement cluster.
-   */
-  isAutoPressureMappingEnabled() {
-    return this.dataProvider.featureFlags?.autoPressureMapping !== false || this.dataProvider.featureFlags?.autoComposedDevices === true;
+  async startObserving() {
+    this.clearSubscription();
+    this.observingRequested = true;
+    if (!this.entityIds.length) {
+      return;
+    }
+    const subscriptionIds = this.collectSubscriptionEntityIds();
+    this.unsubscribe = subscribeEntities(
+      this.client.connection,
+      (e, changed) => this.updateStates(e, changed),
+      subscriptionIds
+    );
   }
-  /**
-   * Check if the vacuum OnOff cluster feature flag is enabled.
-   * Defaults to OFF. OnOff is NOT part of the RoboticVacuumCleaner (0x74) device
-   * type spec. Adding it makes the device non-conformant and causes Amazon Alexa
-   * to reject it entirely (#185, #183). Only enable if a specific controller needs it.
-   */
-  isVacuumOnOffEnabled() {
-    return this.dataProvider.featureFlags?.vacuumOnOff === true;
+  collectSubscriptionEntityIds() {
+    const ids = new Set(this.entityIds);
+    const endpoints = this.root.parts.map((p) => p);
+    for (const endpoint of endpoints) {
+      const mappedIds = endpoint.mappedEntityIds;
+      if (mappedIds) {
+        for (const mappedId of mappedIds) {
+          ids.add(mappedId);
+        }
+      }
+    }
+    if (this.batteryRetryCandidates.size > 0) {
+      for (const entity of Object.values(this.registry.fullEntities)) {
+        if (!entity.device_id) continue;
+        if (!this.batteryRetryCandidates.has(entity.device_id)) continue;
+        if (entity.entity_id.startsWith("sensor.") || entity.entity_id.startsWith("binary_sensor.")) {
+          ids.add(entity.entity_id);
+        }
+      }
+    }
+    return [...ids];
   }
-  // Consume frozen device identities (#404). Seeding always runs; only
-  // consumption of the stored endpoint id/anchor is gated on this flag.
-  isStableIdentityEnabled() {
-    return this.dataProvider.featureFlags?.stableIdentity === true;
+  clearSubscription() {
+    this.unsubscribe?.();
+    this.unsubscribe = void 0;
   }
-  /**
-   * Check if the vacuum OnOff cluster should be included for server-mode vacuums.
-   * Defaults to OFF. OnOff is NOT part of the RoboticVacuumCleaner (0x74) device
-   * type spec. Adding it makes the device non-conformant and causes Amazon Alexa
-   * to reject it entirely (#185, #183). Apple Home may also render the vacuum
-   * incorrectly (shows "Updating" or switch UI). Only enable via feature flag
-   * if a specific controller requires it.
-   */
-  isServerModeVacuumOnOffEnabled() {
-    return this.dataProvider.featureFlags?.vacuumOnOff === true;
+  stopObserving() {
+    this.observingRequested = false;
+    this.lifecycle++;
+    this.clearSubscription();
+    if (this.removalRecheckTimer) {
+      clearTimeout(this.removalRecheckTimer);
+      this.removalRecheckTimer = null;
+    }
+    if (this.batteryRetryTimer) {
+      clearTimeout(this.batteryRetryTimer);
+      this.batteryRetryTimer = null;
+    }
+    this.batteryRetryScheduled = false;
   }
-  /**
-   * Auto-detect vacuum-related select entities on the same HA device.
-   * HA integrations (Dreame, Roborock, Ecovacs, Valetudo, etc.) expose vacuum
-   * features as select entities with well-known suffixes. This finds them
-   * automatically so users don't need to configure each entity manually.
-   */
-  findVacuumSelectEntities(deviceId) {
-    const entities = values3(this.registry.entities);
-    const sameDevice = entities.filter(
-      (e) => e.device_id === deviceId && e.entity_id.startsWith("select.")
-    );
-    let cleaningModeEntity;
-    let suctionLevelEntity;
-    let mopIntensityEntity;
-    for (const entity of sameDevice) {
-      const state = this.registry.states[entity.entity_id];
-      if (!state) continue;
-      const id = entity.entity_id.toLowerCase();
-      if (!cleaningModeEntity) {
-        if (id.includes("cleaning_mode")) {
-          cleaningModeEntity = entity.entity_id;
-        } else if (id.endsWith("_mode")) {
-          const options = state.attributes?.options;
-          if (options?.some(
-            (o) => /^(vacuum|mop|sweep|sweep_mop|sweep_before_mopping|sweep_then_mop|vacuum_and_mop|vacuum_then_mop|mopping|sweeping|sweeping_and_mopping|mopping_after_sweeping)$/i.test(
-              o.replace(/\s+/g, "_")
-            )
-          )) {
-            cleaningModeEntity = entity.entity_id;
+  async refreshDevices() {
+    this.registry.refresh();
+    const lifecycle = this.lifecycle;
+    const endpoints = [...this.root.parts].filter(hasEntityIdentity).filter((p) => !(p instanceof VacuumAreaSwitchEndpoint));
+    const fullEntities = this.registry.fullEntities;
+    if (!this.client.haRunning || Object.keys(fullEntities).length === 0) {
+      this.pendingRemovals.clear();
+      this.log.warn(
+        `HA not running or registry empty, deferring reconcile of ${endpoints.length} endpoints`
+      );
+      return;
+    }
+    this._failedEntities = [];
+    this.entityIds = this.registry.entityIds;
+    if (this.registry.isAutoComposedDevicesEnabled()) {
+      for (const eid of this.entityIds) {
+        const m = this.getEntityMapping(eid);
+        if (m?.composedEntities) {
+          for (const sub of m.composedEntities) {
+            if (sub.entityId) {
+              this.registry.markComposedSubEntityUsed(sub.entityId);
+            }
           }
         }
-      }
-      if (!suctionLevelEntity && (id.includes("suction_level") || id.endsWith("_fan"))) {
-        suctionLevelEntity = entity.entity_id;
-      }
-      if (!mopIntensityEntity && (id.includes("mop_intensity") || id.includes("mop_pad_humidity") || id.includes("water_volume") || id.includes("water_amount") || id.endsWith("_water"))) {
-        mopIntensityEntity = entity.entity_id;
+        if (!eid.startsWith("fan.")) continue;
+        const matterType = m?.matterDeviceType ?? "fan";
+        if (matterType !== "air_purifier") continue;
+        const ent = this.registry.entity(eid);
+        const tempId = m?.temperatureEntity || (ent?.device_id ? this.registry.findTemperatureEntityForDevice(ent.device_id) : void 0);
+        const humId = m?.humidityEntity || (ent?.device_id ? this.registry.findHumidityEntityForDevice(ent.device_id) : void 0);
+        if (tempId) this.registry.markComposedSubEntityUsed(tempId);
+        if (humId) this.registry.markComposedSubEntityUsed(humId);
       }
     }
-    let currentRoomEntity;
-    const sameDeviceSensors = entities.filter(
-      (e) => e.device_id === deviceId && e.entity_id.startsWith("sensor.")
-    );
-    for (const entity of sameDeviceSensors) {
-      if (entity.entity_id.toLowerCase().endsWith("_current_room")) {
-        currentRoomEntity = entity.entity_id;
-        break;
+    const stableIdentity = this.registry.isStableIdentityEnabled();
+    const resolvedByEntity = /* @__PURE__ */ new Map();
+    const endpointIdToEntity = /* @__PURE__ */ new Map();
+    const claimedEndpointIds = /* @__PURE__ */ new Map();
+    for (const entityId of this.entityIds) {
+      const entityInfo = {
+        entity_id: entityId,
+        registry: this.registry.entity(entityId)
+      };
+      const resolved = await this.identityResolver.resolveIdentity(
+        this.bridgeId,
+        entityInfo,
+        this.getEntityMapping(entityId),
+        {
+          stableIdentity,
+          isEndpointIdTaken: (id, key) => claimedEndpointIds.has(id) && claimedEndpointIds.get(id) !== key
+        }
+      );
+      resolvedByEntity.set(entityId, resolved);
+      claimedEndpointIds.set(
+        resolved.endpointId,
+        identityKey(entityInfo) ?? `\0e:${entityId}`
+      );
+      endpointIdToEntity.set(resolved.endpointId, entityId);
+      if (resolved.renamedFrom && this.mappingFingerprints.has(resolved.renamedFrom)) {
+        const fp = this.mappingFingerprints.get(resolved.renamedFrom);
+        this.mappingFingerprints.delete(resolved.renamedFrom);
+        this.mappingFingerprints.set(entityId, fp);
       }
     }
-    return {
-      cleaningModeEntity,
-      suctionLevelEntity,
-      mopIntensityEntity,
-      currentRoomEntity
-    };
-  }
-  static valetudoLogger = Logger.get("ValetudoRooms");
-  /**
-   * Find Valetudo map segments from the sensor.*_map_segments entity on the
-   * same HA device. Valetudo exposes room/segment data via MQTT as a sensor
-   * with numeric segment IDs in its attributes.
-   *
-   * Attribute format:
-   * - Unnamed segments: { "1": 1, "2": 2, "4": 4 }
-   * - Named segments:   { "1": "Kitchen", "2": "Living Room" }
-   */
-  findValetudoMapSegments(deviceId) {
-    const entities = values3(this.registry.entities);
-    const mapSensor = entities.find(
-      (e) => e.device_id === deviceId && e.entity_id.startsWith("sensor.") && e.entity_id.endsWith("_map_segments")
+    stampIdentityPresence(
+      this.identityStorage,
+      this.bridgeId,
+      buildPresentIdentityKeys(fullEntities)
     );
-    if (!mapSensor) return [];
-    const state = this.registry.states[mapSensor.entity_id];
-    if (!state) return [];
-    const attrs = state.attributes;
-    const rooms = [];
-    for (const [key, value] of Object.entries(attrs)) {
-      if (!/^\d+$/.test(key)) continue;
-      const segmentId = Number.parseInt(key, 10);
-      const name = typeof value === "string" ? value : `Segment ${key}`;
-      rooms.push({ id: segmentId, name });
-    }
-    if (rooms.length > 0) {
-      _BridgeRegistry.valetudoLogger.info(
-        `Found ${rooms.length} Valetudo segments via ${mapSensor.entity_id}`
+    stampMappingPresence(
+      this.mappingStorage,
+      this.bridgeId,
+      buildPresentEntityIds(fullEntities)
+    );
+    for (const part of [...this.root.parts]) {
+      if (!(part instanceof VacuumAreaSwitchEndpoint)) continue;
+      const claimant = endpointIdToEntity.get(part.id);
+      if (claimant == null) continue;
+      this.log.info(
+        `Area switch ${part.id} collides with entity ${claimant}, removing the switch`
       );
+      try {
+        await part.delete();
+      } catch (e) {
+        this.log.warn(`Failed to remove colliding area switch ${part.id}:`, e);
+      }
     }
-    return rooms;
-  }
-  static roborockLogger = Logger.get("RoborockRooms");
-  /**
-   * Resolve rooms for a Roborock vacuum by calling roborock.get_maps.
-   * Returns parsed VacuumRoom[] with segment IDs, or empty array if
-   * the service is unavailable or the vacuum is not Roborock.
-   */
-  async resolveRoborockRooms(entityId) {
-    if (!this.client) return [];
-    try {
-      const raw = await callService2(
-        this.client.connection,
-        "roborock",
-        "get_maps",
-        void 0,
-        { entity_id: entityId },
-        true
-      );
-      const wrapper = raw;
-      const responseData = wrapper?.response ?? wrapper;
-      const entityData = responseData?.[entityId];
-      if (!entityData?.maps) {
-        _BridgeRegistry.roborockLogger.debug(
-          `${entityId}: roborock.get_maps returned no maps (keys: ${Object.keys(responseData ?? {}).join(", ")})`
+    const existingEndpoints = [];
+    const now = Date.now();
+    for (const endpoint of endpoints) {
+      const present = this.entityIds.includes(endpoint.entityId);
+      const claimant = endpointIdToEntity.get(endpoint.id);
+      if (!present && claimant != null && claimant !== endpoint.entityId) {
+        this.log.info(
+          `Entity renamed ${endpoint.entityId} -> ${claimant}, keeping endpoint ${endpoint.id}`
         );
-        return [];
-      }
-      const rooms = [];
-      for (const map of entityData.maps) {
-        if (!map.rooms) continue;
-        for (const [segmentId, roomName] of Object.entries(map.rooms)) {
-          const id = /^\d+$/.test(segmentId) ? Number.parseInt(segmentId, 10) : segmentId;
-          rooms.push({ id, name: roomName });
+        try {
+          await endpoint.close();
+        } catch (e) {
+          this.log.warn(
+            `Failed to close renamed endpoint ${endpoint.entityId}:`,
+            e
+          );
         }
+        this.pendingRemovals.delete(endpoint.entityId);
+        this.mappingFingerprints.delete(endpoint.entityId);
+        continue;
       }
-      if (rooms.length > 0) {
-        _BridgeRegistry.roborockLogger.info(
-          `${entityId}: Resolved ${rooms.length} rooms via roborock.get_maps`
-        );
-      }
-      return rooms;
-    } catch (error) {
-      const msg = error instanceof Error ? error.message : typeof error === "object" && error !== null ? JSON.stringify(error) : String(error);
-      _BridgeRegistry.roborockLogger.warn(
-        `${entityId}: roborock.get_maps failed: ${msg}`
-      );
-      return [];
-    }
-  }
-  static cleanAreaLogger = Logger.get("CleanAreaRooms");
-  /**
-   * Resolve HA areas mapped to vacuum segments via HA 2026.3 CLEAN_AREA.
-   * Fetches the full entity registry entry (including options.vacuum.area_mapping)
-   * and resolves HA area names from the area registry.
-   * Returns CleanAreaRoom[] sorted alphabetically, or empty array if
-   * CLEAN_AREA is not supported or no area_mapping is configured.
-   */
-  async resolveCleanAreaRooms(entityId, supportedFeatures) {
-    if (!this.client) return [];
-    if (!(supportedFeatures & VacuumDeviceFeature.CLEAN_AREA)) return [];
-    try {
-      const entry = await sendHaMessage(this.client.connection, {
-        type: "config/entity_registry/get",
-        entity_id: entityId
-      });
-      const vacuumOptions = entry?.options?.vacuum;
-      const areaMapping = vacuumOptions?.area_mapping;
-      if (!areaMapping || Object.keys(areaMapping).length === 0) {
-        _BridgeRegistry.cleanAreaLogger.debug(
-          `${entityId}: CLEAN_AREA supported but no area_mapping configured`
-        );
-        return [];
+      if (present) {
+        this.pendingRemovals.delete(endpoint.entityId);
       }
-      let validSegmentIds;
-      try {
-        const segmentsResponse = await sendHaMessage(this.client.connection, {
-          type: "vacuum/get_segments",
-          entity_id: entityId
-        });
-        if (Array.isArray(segmentsResponse)) {
-          validSegmentIds = new Set(segmentsResponse.map((s) => s.id));
-          _BridgeRegistry.cleanAreaLogger.debug(
-            `${entityId}: Current vacuum segments: ${[...validSegmentIds].join(", ")}`
+      if (!present) {
+        const entry = this.pendingRemovals.get(endpoint.entityId);
+        if (entry == null) {
+          this.pendingRemovals.set(endpoint.entityId, {
+            since: now,
+            generation: this.registry.snapshotGeneration
+          });
+          existingEndpoints.push(endpoint);
+          continue;
+        }
+        if (now - entry.since < ENDPOINT_REMOVAL_GRACE_MS || now - this.client.runningSince < ENDPOINT_REMOVAL_GRACE_MS || this.registry.snapshotGeneration <= entry.generation) {
+          existingEndpoints.push(endpoint);
+          continue;
+        }
+        try {
+          this.log.info(
+            `Removing endpoint ${endpoint.entityId} (ep ${endpoint.number}) after the grace window, controllers will see a new number if it returns`
           );
+          await endpoint.delete();
+        } catch (e) {
+          this.log.warn(`Failed to delete endpoint ${endpoint.entityId}:`, e);
         }
-      } catch {
-        _BridgeRegistry.cleanAreaLogger.debug(
-          `${entityId}: vacuum/get_segments not available, skipping stale entry detection`
+        this.mappingFingerprints.delete(endpoint.entityId);
+        this.pendingRemovals.delete(endpoint.entityId);
+      } else if (this.registry.isAutoComposedDevicesEnabled() && this.registry.isComposedSubEntityUsed(endpoint.entityId)) {
+        this.log.info(
+          `Removing standalone endpoint ${endpoint.entityId}, consumed by composed device`
         );
-      }
-      const rooms = [];
-      for (const haAreaId of Object.keys(areaMapping)) {
-        const segments = areaMapping[haAreaId];
-        if (!segments || segments.length === 0) {
-          _BridgeRegistry.cleanAreaLogger.debug(
-            `${entityId}: Skipping HA area ${haAreaId}, no segments mapped`
+        try {
+          await endpoint.close();
+        } catch (e) {
+          this.log.warn(
+            `Failed to remove composed sub-entity endpoint ${endpoint.entityId}:`,
+            e
           );
-          continue;
         }
-        if (validSegmentIds && !segments.some((sid) => validSegmentIds.has(sid))) {
-          const areaName2 = this.registry.areas.get(haAreaId) ?? haAreaId;
-          _BridgeRegistry.cleanAreaLogger.info(
-            `${entityId}: Skipping stale HA area "${areaName2}" (${haAreaId}), segments [${segments.join(", ")}] no longer exist on vacuum`
+        this.mappingFingerprints.delete(endpoint.entityId);
+      } else {
+        const currentMapping = this.getEntityMapping(endpoint.entityId);
+        const storedFp = this.mappingFingerprints.get(endpoint.entityId) ?? "";
+        const currentFp = this.compareFingerprint(
+          currentMapping,
+          endpoint.entityId,
+          storedFp
+        );
+        if (currentFp !== storedFp) {
+          this.log.info(
+            `Mapping changed for ${endpoint.entityId}, recreating endpoint`
           );
-          continue;
+          const resolvedId = resolvedByEntity.get(endpoint.entityId)?.endpointId ?? createEndpointId(endpoint.entityId, currentMapping?.customName);
+          const sameId = resolvedId === endpoint.id;
+          try {
+            if (sameId) {
+              await endpoint.close();
+            } else {
+              await endpoint.delete();
+            }
+          } catch (e) {
+            this.log.warn(
+              `Failed to recreate endpoint ${endpoint.entityId} for mapping change:`,
+              e
+            );
+          }
+          this.mappingFingerprints.delete(endpoint.entityId);
+        } else {
+          existingEndpoints.push(endpoint);
         }
-        const areaName = this.registry.areas.get(haAreaId) ?? haAreaId;
-        rooms.push({
-          areaId: hashAreaId(haAreaId),
-          haAreaId,
-          name: areaName
-        });
       }
-      rooms.sort((a, b) => a.name.localeCompare(b.name));
-      if (rooms.length > 0) {
-        _BridgeRegistry.cleanAreaLogger.info(
-          `${entityId}: Resolved ${rooms.length} HA areas via CLEAN_AREA mapping`
-        );
+    }
+    if (lifecycle === this.lifecycle) {
+      this.scheduleRemovalRecheck();
+    }
+    let memoryLimitReached = false;
+    for (const entityId of this.entityIds) {
+      if (!memoryLimitReached && isHeapUnderPressure()) {
+        memoryLimitReached = true;
+        this.log.error(
+          "Memory pressure detected, skipping remaining entities to prevent OOM crash. Reduce the number of entities in this bridge or increase the Node.js heap size (NODE_OPTIONS=--max-old-space-size=1024)."
+        );
+      }
+      if (memoryLimitReached) {
+        if (!existingEndpoints.some((e) => e.entityId === entityId)) {
+          this.addFailedEntity(
+            entityId,
+            "Skipped due to memory pressure, reduce entities or increase heap size"
+          );
+        }
+        continue;
+      }
+      const mapping = this.getEntityMapping(entityId);
+      if (mapping?.disabled) {
+        this.log.debug(`Skipping disabled entity: ${entityId}`);
+        continue;
       }
-      return rooms;
-    } catch (error) {
-      const msg = error instanceof Error ? error.message : typeof error === "object" && error !== null ? JSON.stringify(error) : String(error);
-      _BridgeRegistry.cleanAreaLogger.warn(
-        `${entityId}: Failed to resolve CLEAN_AREA mapping: ${msg}`
-      );
-      return [];
-    }
-  }
-  /**
-   * Find a pressure sensor entity that belongs to the same HA device.
-   * Returns the entity_id of the pressure sensor, or undefined if none found.
-   */
-  findPressureEntityForDevice(deviceId) {
-    const entities = values3(this.registry.entities);
-    for (const entity of entities) {
-      if (entity.device_id !== deviceId) continue;
-      if (!entity.entity_id.startsWith("sensor.")) continue;
-      const state = this.registry.states[entity.entity_id];
-      if (!state) continue;
-      const attrs = state.attributes;
-      if (attrs.device_class === SensorDeviceClass.pressure || attrs.device_class === SensorDeviceClass.atmospheric_pressure) {
-        return entity.entity_id;
+      if (this.registry.isAutoComposedDevicesEnabled() && this.registry.isComposedSubEntityUsed(entityId)) {
+        this.log.debug(
+          `Skipping ${entityId}, already part of a composed device`
+        );
+        continue;
       }
-    }
-    return void 0;
-  }
-  /**
-   * Mark a pressure entity as used (auto-assigned to a temperature sensor).
-   */
-  markPressureEntityUsed(entityId) {
-    this._usedPressureEntities.add(entityId);
-  }
-  /**
-   * Check if a pressure entity has been auto-assigned to a temperature sensor.
-   */
-  isPressureEntityUsed(entityId) {
-    return this._usedPressureEntities.has(entityId);
-  }
-  /**
-   * Find a power sensor entity (device_class: power) on the same HA device.
-   */
-  findPowerEntityForDevice(deviceId) {
-    const entities = values3(this.registry.entities);
-    for (const entity of entities) {
-      if (entity.device_id !== deviceId) continue;
-      if (!entity.entity_id.startsWith("sensor.")) continue;
-      const state = this.registry.states[entity.entity_id];
-      if (!state) continue;
-      const attrs = state.attributes;
-      if (attrs.device_class === SensorDeviceClass.power) {
-        return entity.entity_id;
+      if (entityId.length > MAX_ENTITY_ID_LENGTH) {
+        const reason = `Entity ID too long (${entityId.length} chars, max ${MAX_ENTITY_ID_LENGTH}). This would cause filesystem errors.`;
+        this.log.warn(`Skipping entity: ${entityId}. Reason: ${reason}`);
+        this.addFailedEntity(entityId, reason);
+        continue;
       }
-    }
-    return void 0;
-  }
-  /**
-   * Find an energy sensor entity (device_class: energy) on the same HA device.
-   */
-  findEnergyEntityForDevice(deviceId) {
-    const entities = values3(this.registry.entities);
-    for (const entity of entities) {
-      if (entity.device_id !== deviceId) continue;
-      if (!entity.entity_id.startsWith("sensor.")) continue;
-      const state = this.registry.states[entity.entity_id];
-      if (!state) continue;
-      const attrs = state.attributes;
-      if (attrs.device_class === SensorDeviceClass.energy) {
-        return entity.entity_id;
+      let endpoint = existingEndpoints.find((e) => e.entityId === entityId);
+      if (!endpoint) {
+        try {
+          const domainMappings = this.getPluginDomainMappings();
+          const resolved = resolvedByEntity.get(entityId);
+          endpoint = await LegacyEndpoint.create(
+            this.registry,
+            entityId,
+            mapping,
+            domainMappings,
+            false,
+            resolved?.endpointId,
+            resolved?.anchorEntityId
+          );
+        } catch (e) {
+          const reason = this.extractErrorReason(e);
+          this.log.warn(`Failed to create device ${entityId}: ${reason}`);
+          this.addFailedEntity(entityId, reason);
+          continue;
+        }
+        if (endpoint) {
+          try {
+            await this.root.add(endpoint);
+            this.mappingFingerprints.set(
+              entityId,
+              this.fingerprintAsBuilt(mapping, entityId, endpoint)
+            );
+          } catch (e) {
+            const errorMessage = e instanceof Error ? e.message : String(e);
+            this.log.warn(
+              `Failed to add endpoint for ${entityId}: ${errorMessage}`
+            );
+            this.logDetailedError(entityId, e);
+            this.addFailedEntity(entityId, this.extractErrorReason(e));
+          }
+        }
       }
     }
-    return void 0;
-  }
-  markPowerEntityUsed(entityId) {
-    this._usedPowerEntities.add(entityId);
-  }
-  isPowerEntityUsed(entityId) {
-    return this._usedPowerEntities.has(entityId);
-  }
-  markEnergyEntityUsed(entityId) {
-    this._usedEnergyEntities.add(entityId);
-  }
-  isEnergyEntityUsed(entityId) {
-    return this._usedEnergyEntities.has(entityId);
-  }
-  mergeExternalStates(states) {
-    const registryStates = this.registry.states;
-    for (const entityId of Object.keys(states)) {
-      registryStates[entityId] = states[entityId];
-    }
-  }
-  /**
-   * Get the area name for an entity, resolving from HA area registry.
-   * Priority: entity area_id > device area_id > undefined
-   */
-  getAreaName(entityId) {
-    const entity = this._entities[entityId];
-    if (!entity) return void 0;
-    const entityAreaId = entity.area_id;
-    if (entityAreaId) {
-      const name = this.registry.areas.get(entityAreaId);
-      if (name) return name;
-    }
-    const device = this._devices[entity.device_id];
-    const deviceAreaId = device?.area_id;
-    if (deviceAreaId) {
-      const name = this.registry.areas.get(deviceAreaId);
-      if (name) return name;
+    await this.reconcileAreaSwitches();
+    this.rebuildBatteryRetryCandidates();
+    if (this.observingRequested) {
+      this.startObserving();
     }
-    return void 0;
   }
-  refresh() {
-    this._usedBatteryEntities.clear();
-    this._usedHumidityEntities.clear();
-    this._usedPressureEntities.clear();
-    this._usedPowerEntities.clear();
-    this._usedEnergyEntities.clear();
-    this._usedComposedSubEntities.clear();
-    this._batteryEntityCache.clear();
-    this._problemEntityCache.clear();
-    this._entities = pickBy(this.registry.entities, (entity) => {
-      const device = this.registry.devices[entity.device_id];
-      const filter = this.dataProvider.filter;
-      const featureFlags = this.dataProvider.featureFlags ?? {};
-      if (entity.disabled_by != null) {
-        return false;
-      }
-      const isHidden = entity.hidden_by != null;
-      if (isHidden && !featureFlags.includeHiddenEntities) {
-        return false;
-      }
-      const state = this.registry.states[entity.entity_id];
-      return this.matchesFilter(filter, entity, device, state);
-    });
-    this._states = pickBy(
-      this.registry.states,
-      (e) => !!this._entities[e.entity_id]
+  // Opt-in per-area room switches (#355). One momentary OnOffPlugInUnit sibling
+  // per configured service area, mounted alongside its vacuum with a stable
+  // derived id. Areas and mapping come from the parent's vacuumEffective, the
+  // exact config its ServiceArea cluster was built from, never from raw storage
+  // (raw can be a different id space: injected Valetudo/Roborock rooms,
+  // auto-resolved CLEAN_AREA). The vacuum's own endpoint is never touched here.
+  // Switches are kept while their parent endpoint survives with the flag on
+  // (the parent's removal grace is mirrored for free), rebuilt via close() when
+  // the parent was recreated for a mapping change so numbers survive, and
+  // deleted when the flag goes off, the area is gone, or the parent is gone.
+  async reconcileAreaSwitches() {
+    const parts = this.root.parts.map((p) => p);
+    const switches = parts.filter(
+      (p) => p instanceof VacuumAreaSwitchEndpoint
     );
-    this._devices = pickBy(
-      this.registry.devices,
-      (d) => values3(this._entities).map((e) => e.device_id).some((id) => d.id === id)
+    const vacuumById = /* @__PURE__ */ new Map();
+    for (const part of parts) {
+      if (part instanceof VacuumAreaSwitchEndpoint) continue;
+      vacuumById.set(part.id, part);
+    }
+    const isolated = new Set(
+      EntityIsolationService.getIsolatedEntities(this.bridgeId).map(
+        (f) => f.entityId
+      )
     );
-    this.preCalculateAutoAssignments();
-  }
-  /**
-   * Pre-calculate which entities will be auto-assigned to other devices.
-   * This must run BEFORE endpoint creation to ensure correct "used" marking
-   * regardless of the order entities are processed.
-   */
-  preCalculateAutoAssignments() {
-    const entities = values3(this._entities);
-    for (const entity of entities) {
-      if (!entity.device_id) continue;
-      if (!entity.entity_id.startsWith("sensor.")) continue;
-      const state = this._states[entity.entity_id];
-      if (!state) continue;
-      const attrs = state.attributes;
-      if (attrs.device_class === SensorDeviceClass.temperature) {
-        if (this.isAutoHumidityMappingEnabled()) {
-          const humidityEntityId = this.findHumidityEntityForDevice(
-            entity.device_id
-          );
-          if (humidityEntityId && humidityEntityId !== entity.entity_id) {
-            this._usedHumidityEntities.add(humidityEntityId);
-          }
-        }
-        if (this.isAutoPressureMappingEnabled()) {
-          const pressureEntityId = this.findPressureEntityForDevice(
-            entity.device_id
-          );
-          if (pressureEntityId && pressureEntityId !== entity.entity_id) {
-            this._usedPressureEntities.add(pressureEntityId);
+    const parentIsolated = (parent) => isolated.has(parent.id) || parent.entityId != null && isolated.has(parent.entityId);
+    const kept = /* @__PURE__ */ new Set();
+    for (const sw of switches) {
+      const parent = vacuumById.get(sw.vacuumEndpointId);
+      const mapping = parent ? this.getEntityMapping(parent.entityId) : void 0;
+      const effective = parent instanceof LegacyEndpoint ? parent.vacuumEffective : void 0;
+      let keep = false;
+      let rebuild = false;
+      if (parent && !parentIsolated(parent) && mapping?.vacuumRoomSwitches && effective) {
+        const areas = getVacuumServiceAreas(
+          effective.state.attributes,
+          effective.mapping
+        );
+        if (areas.some((a) => a.areaId === sw.areaId)) {
+          if (sw.parentEffective === effective) {
+            keep = true;
+          } else {
+            rebuild = true;
           }
         }
       }
-    }
-    for (const entity of entities) {
-      if (!entity.device_id) continue;
-      const domain = entity.entity_id.split(".")[0];
-      if (domain !== "switch" && domain !== "light") continue;
-      const powerEntityId = this.findPowerEntityForDevice(entity.device_id);
-      if (powerEntityId && powerEntityId !== entity.entity_id) {
-        if (!this._usedPowerEntities.has(powerEntityId)) {
-          this._usedPowerEntities.add(powerEntityId);
-        }
+      if (keep) {
+        kept.add(sw.id);
+        continue;
       }
-      const energyEntityId = this.findEnergyEntityForDevice(entity.device_id);
-      if (energyEntityId && energyEntityId !== entity.entity_id) {
-        if (!this._usedEnergyEntities.has(energyEntityId)) {
-          this._usedEnergyEntities.add(energyEntityId);
+      try {
+        if (rebuild) {
+          await sw.close();
+        } else {
+          await sw.delete();
         }
+      } catch (e) {
+        this.log.warn(`Failed to remove area switch ${sw.id}:`, e);
       }
     }
-    if (this.isAutoBatteryMappingEnabled()) {
-      for (const entity of entities) {
-        if (!entity.device_id) continue;
-        if (this._usedHumidityEntities.has(entity.entity_id)) continue;
-        if (entity.entity_id.startsWith("sensor.")) {
-          const state = this._states[entity.entity_id];
-          if (state) {
-            const attrs = state.attributes;
-            if (attrs.device_class === SensorDeviceClass.battery) continue;
-          }
-        }
-        if (entity.entity_id.startsWith("binary_sensor.")) {
-          const state = this._states[entity.entity_id];
-          if (state) {
-            const attrs = state.attributes;
-            if (attrs.device_class === "battery") continue;
-          }
+    for (const part of vacuumById.values()) {
+      const entityId = part.entityId;
+      if (!entityId?.startsWith("vacuum.")) continue;
+      if (parentIsolated(part)) continue;
+      const mapping = this.getEntityMapping(entityId);
+      if (!mapping?.vacuumRoomSwitches) continue;
+      const effective = part instanceof LegacyEndpoint ? part.vacuumEffective : void 0;
+      if (!effective) continue;
+      const areas = getVacuumServiceAreas(
+        effective.state.attributes,
+        effective.mapping
+      );
+      const entity = {
+        entity_id: entityId,
+        state: effective.state,
+        registry: this.registry.entity(entityId),
+        deviceRegistry: this.registry.deviceOf(entityId)
+      };
+      for (const area of areas) {
+        const switchId = `${part.id}_roomsw_${area.areaId}`;
+        if (kept.has(switchId)) continue;
+        const holder = vacuumById.get(switchId);
+        if (holder) {
+          this.log.warn(
+            `Skipping area switch ${switchId} for ${entityId}: id taken by entity ${holder.entityId}`
+          );
+          continue;
         }
-        const batteryEntityId = this.findBatteryEntityForDevice(
-          entity.device_id
-        );
-        if (batteryEntityId && batteryEntityId !== entity.entity_id) {
-          if (!this._usedBatteryEntities.has(batteryEntityId)) {
-            this._usedBatteryEntities.add(batteryEntityId);
-          }
+        try {
+          const endpoint = VacuumAreaSwitchEndpoint.create({
+            vacuumEndpointId: part.id,
+            entity,
+            mapping: effective.mapping,
+            area,
+            parentEffective: effective
+          });
+          await this.root.add(endpoint);
+        } catch (e) {
+          this.log.warn(
+            `Failed to add area switch ${switchId} for ${entityId}:`,
+            e
+          );
         }
       }
     }
   }
+  updateInFlight;
+  pendingStates;
+  pendingChanged;
+  mergeChanged(a, b) {
+    if (a === null || b === null) return null;
+    const merged = new Set(a);
+    for (const id of b) merged.add(id);
+    return merged;
+  }
+  async updateStates(states, changed = null) {
+    if (this.updateInFlight) {
+      this.pendingStates = states;
+      this.pendingChanged = this.pendingChanged === void 0 ? changed : this.mergeChanged(this.pendingChanged, changed);
+      return this.updateInFlight;
+    }
+    this.updateInFlight = this.runUpdateStates(states, changed).finally(() => {
+      this.updateInFlight = void 0;
+      const queued = this.pendingStates;
+      const queuedChanged = this.pendingChanged;
+      this.pendingStates = void 0;
+      this.pendingChanged = void 0;
+      if (queued) {
+        this.updateStates(
+          queued,
+          queuedChanged === void 0 ? null : queuedChanged
+        ).catch((e) => this.log.warn("Queued state update failed:", e));
+      }
+    });
+    return this.updateInFlight;
+  }
+  async runUpdateStates(states, changed) {
+    const startMs = performance.now();
+    this.registry.mergeExternalStates(states);
+    this.maybeRetryBatteryMapping(states, changed);
+    const allEndpoints = [...this.root.parts].filter(isEntityPart);
+    const endpoints = changed === null ? allEndpoints : allEndpoints.filter(
+      (e) => changed.has(e.entityId) || (e.mappedEntityIds ?? []).some((id) => changed.has(id))
+    );
+    if (endpoints.length === 0) return;
+    const results = await Promise.allSettled(
+      endpoints.map((endpoint) => endpoint.updateStates(states))
+    );
+    let failedCount = 0;
+    for (const result of results) {
+      if (result.status === "rejected") {
+        failedCount++;
+        this.log.warn("State update failed for endpoint:", result.reason);
+      }
+    }
+    const latencyMs = Math.round((performance.now() - startMs) * 100) / 100;
+    if (latencyMs > 200 || failedCount > 0) {
+      const msg = `State update: ${endpoints.length} endpoints in ${latencyMs}ms` + (failedCount > 0 ? ` (${failedCount} failed)` : "");
+      if (latencyMs > 200) {
+        this.log.warn(`Slow ${msg}`);
+      }
+      diagnosticEventBus.emit("state_update", msg, {
+        bridgeId: this.bridgeId,
+        details: {
+          endpointCount: endpoints.length,
+          failedCount,
+          latencyMs
+        }
+      });
+    }
+  }
   /**
-   * The first already-matched entity the given matcher tests true for.
-   * Server mode pins the primary entity to the first include matcher with
-   * this, independent of HA registry order (#301).
+   * Log detailed behavior error information for debugging "Behaviors have errors".
+   * Matter.js EndpointBehaviorsError extends AggregateError, the `errors` array
+   * contains individual behavior crash errors (one per failed behavior).
    */
-  firstEntityMatching(matcher) {
-    const labels = this.registry.labels;
-    for (const entity of values3(this._entities)) {
-      const device = this.registry.devices[entity.device_id];
-      const state = this.registry.states[entity.entity_id];
-      if (testMatchers([matcher], device, entity, "any", state, labels)) {
-        return entity.entity_id;
+  logDetailedError(entityId, error) {
+    if (!(error instanceof Error)) return;
+    const errorsArray = error.errors;
+    if (Array.isArray(errorsArray) && errorsArray.length > 0) {
+      for (let i = 0; i < errorsArray.length; i++) {
+        const subError = errorsArray[i];
+        const subMsg = subError instanceof Error ? subError.message : String(subError);
+        this.log.warn(
+          `[${entityId}] Behavior error [${i + 1}/${errorsArray.length}]: ${subMsg}`
+        );
+        let cause = subError instanceof Error ? subError.cause : void 0;
+        while (cause instanceof Error) {
+          this.log.warn(`[${entityId}]   Caused by: ${cause.message}`);
+          cause = cause.cause;
+        }
+        if (subError instanceof Error && subError.stack) {
+          this.log.debug(`[${entityId}] Sub-error stack: ${subError.stack}`);
+        }
+      }
+    } else {
+      let current = error.cause;
+      while (current instanceof Error) {
+        this.log.warn(`[${entityId}] Caused by: ${current.message}`);
+        current = current.cause;
       }
     }
-    return void 0;
-  }
-  matchesFilter(filter, entity, device, entityState) {
-    const labels = this.registry.labels;
-    if (filter.include.length > 0 && !testMatchers(
-      filter.include,
-      device,
-      entity,
-      filter.includeMode,
-      entityState,
-      labels
-    )) {
-      return false;
+    if (error.stack) {
+      this.log.debug(`[${entityId}] Full stack: ${error.stack}`);
     }
-    if (filter.exclude.length > 0 && testMatchers(filter.exclude, device, entity, "any", entityState, labels)) {
-      return false;
+  }
+  extractErrorReason(error) {
+    if (error instanceof Error) {
+      const cause = error.cause;
+      if (cause?.message) {
+        return `${error.message}: ${cause.message}`;
+      }
+      return error.message;
     }
-    return true;
+    return String(error);
   }
 };
-function hashAreaId(areaId) {
-  let hash2 = 0;
-  for (let i = 0; i < areaId.length; i++) {
-    const char = areaId.charCodeAt(i);
-    hash2 = (hash2 << 5) - hash2 + char;
-    hash2 |= 0;
-  }
-  return Math.abs(hash2);
-}
 
 // src/services/bridges/server-mode-bridge.ts
 init_dist();
@@ -180645,9 +180787,82 @@ var ServerModeEndpointManager = class extends Service {
   getEntityMapping(entityId) {
     return this.mappingStorage.getMapping(this.dataProvider.id, entityId);
   }
-  computeMappingFingerprint(mapping) {
-    if (!mapping) return "";
-    return JSON.stringify(mapping);
+  // #450: an endpoint built while its battery sensor was unavailable stays
+  // battery-less, because registry ticks only refresh on structural changes.
+  // When a same-device sensor state arrives, re-resolve and rebuild.
+  batteryRetryScheduled = false;
+  batteryRetryTimer = null;
+  // deviceId -> primary entityId of endpoints that auto-map but carry no
+  // battery, bounds the per-state-batch check to a map hit
+  batteryRetryCandidates = /* @__PURE__ */ new Map();
+  // Only endpoints the auto-mapping applies to belong here: a manual or
+  // disabled mapping, or a sensor endpoint sharing the device, must not
+  // claim the slot (last writer would win) and stall the recovery.
+  batteryRetryEligible(entityId) {
+    const mapping = this.getEntityMapping(entityId);
+    if (mapping?.batteryEntity || mapping?.disableBatteryMapping) return false;
+    if (entityId.startsWith("sensor.") || entityId.startsWith("binary_sensor.")) {
+      return false;
+    }
+    return entityId.startsWith("vacuum.") || !!this.registry.isAutoBatteryMappingEnabled?.();
+  }
+  rebuildBatteryRetryCandidates() {
+    this.batteryRetryCandidates.clear();
+    for (const [entityId, entry] of this.endpoints) {
+      if (fingerprintBattery(entry.fingerprint) != null) continue;
+      if (!this.batteryRetryEligible(entityId)) continue;
+      const deviceId = this.registry.entity(entityId)?.device_id;
+      if (deviceId) this.batteryRetryCandidates.set(deviceId, entityId);
+    }
+  }
+  maybeRetryBatteryMapping(states) {
+    if (!this.observingRequested || this.batteryRetryScheduled || this.batteryRetryCandidates.size === 0) {
+      return;
+    }
+    for (const id of Object.keys(states)) {
+      if (!id.startsWith("sensor.") && !id.startsWith("binary_sensor."))
+        continue;
+      const deviceId = this.registry.fullEntities[id]?.device_id;
+      if (!deviceId) continue;
+      const entityId = this.batteryRetryCandidates.get(deviceId);
+      if (!entityId) continue;
+      this.registry.forgetBatteryCacheForDevice(deviceId);
+      const resolved = this.registry.batteryFingerprintFor(
+        entityId,
+        this.getEntityMapping(entityId)
+      );
+      if (!resolved) continue;
+      this.batteryRetryScheduled = true;
+      this.log.info(
+        `Battery sensor ${resolved} appeared for ${entityId}, rebuilding`
+      );
+      this.batteryRetryTimer = setTimeout(() => {
+        this.batteryRetryTimer = null;
+        this.refreshDevices().catch((e) => this.log.warn("Battery retry refresh failed:", e)).finally(() => {
+          this.batteryRetryScheduled = false;
+        });
+      }, 0);
+      return;
+    }
+  }
+  computeMappingFingerprint(mapping, entityId) {
+    const battery = entityId ? this.registry.batteryFingerprintFor(entityId, mapping) : "";
+    return JSON.stringify([mapping ?? null, battery || null]);
+  }
+  // Live fingerprint for reconcile compares: when the resolver finds nothing
+  // right now but the stored fingerprint maps a sensor that still exists on
+  // the SAME device, keep it. An unavailable snapshot (HA restart) must not
+  // strip the mapping and rebuild the endpoint battery-less (#450).
+  compareFingerprint(mapping, entityId, storedFingerprint) {
+    const fingerprint = this.computeMappingFingerprint(mapping, entityId);
+    if (fingerprintBattery(fingerprint) != null || !storedFingerprint)
+      return fingerprint;
+    if (!this.batteryRetryEligible(entityId)) return fingerprint;
+    const battery = fingerprintBattery(storedFingerprint);
+    if (!battery) return fingerprint;
+    const deviceId = this.registry.entity(entityId)?.device_id;
+    const stillSameDevice = !!deviceId && this.registry.fullEntities[battery]?.device_id === deviceId;
+    return stillSameDevice ? JSON.stringify([mapping ?? null, battery]) : fingerprint;
   }
   async dispose() {
     this.stopObserving();
@@ -180688,6 +180903,15 @@ var ServerModeEndpointManager = class extends Service {
         ids.add(mappedId);
       }
     }
+    if (this.batteryRetryCandidates.size > 0) {
+      for (const entity of Object.values(this.registry.fullEntities)) {
+        if (!entity.device_id) continue;
+        if (!this.batteryRetryCandidates.has(entity.device_id)) continue;
+        if (entity.entity_id.startsWith("sensor.") || entity.entity_id.startsWith("binary_sensor.")) {
+          ids.add(entity.entity_id);
+        }
+      }
+    }
     return [...ids];
   }
   clearSubscription() {
@@ -180702,6 +180926,11 @@ var ServerModeEndpointManager = class extends Service {
       clearTimeout(this.removalRecheckTimer);
       this.removalRecheckTimer = null;
     }
+    if (this.batteryRetryTimer) {
+      clearTimeout(this.batteryRetryTimer);
+      this.batteryRetryTimer = null;
+    }
+    this.batteryRetryScheduled = false;
   }
   /** Primary first (the entity the first include matcher tests true for). */
   orderEntityIds(ids) {
@@ -180896,9 +181125,9 @@ var ServerModeEndpointManager = class extends Service {
           });
           continue;
         }
-        const fingerprint = this.computeMappingFingerprint(mapping);
+        const fingerprint = this.computeMappingFingerprint(mapping, entityId);
         const existing = this.endpoints.get(entityId);
-        if (existing && existing.fingerprint === fingerprint) {
+        if (existing && existing.fingerprint === this.compareFingerprint(mapping, entityId, existing.fingerprint)) {
           this.log.debug(`Device endpoint already exists for ${entityId}`);
           continue;
         }
@@ -180967,7 +181196,9 @@ var ServerModeEndpointManager = class extends Service {
             continue;
           }
           await this.serverNode.addDevice(endpoint);
-          this.endpoints.set(entityId, { endpoint, fingerprint });
+          const builtBattery = fingerprintBattery(fingerprint);
+          const asBuilt = builtBattery != null && !endpoint.mappedEntityIds.includes(builtBattery) ? JSON.stringify([mapping ?? null, null]) : fingerprint;
+          this.endpoints.set(entityId, { endpoint, fingerprint: asBuilt });
           for (const [id, owner] of this.parkedEndpointIds) {
             if (id === endpointId || owner === entityId) {
               this.parkedEndpointIds.delete(id);
@@ -180995,6 +181226,7 @@ var ServerModeEndpointManager = class extends Service {
       if (lifecycle === this.lifecycle) {
         this.scheduleRemovalRecheck();
       }
+      this.rebuildBatteryRetryCandidates();
       if (this.observingRequested) {
         this.startObserving();
       }
@@ -181002,6 +181234,7 @@ var ServerModeEndpointManager = class extends Service {
   }
   async updateStates(states) {
     this.registry.mergeExternalStates(states);
+    this.maybeRetryBatteryMapping(states);
     for (const [entityId, entry] of this.endpoints) {
       try {
         await entry.endpoint.updateStates(states);