@riddix/hamh 2.1.0-alpha.855 → 2.1.0-alpha.857

package/dist/backend/cli.js

@@ -133515,7 +133515,8 @@ WARNING: ${includeIdentity ? "This backup contains sensitive Matter identity dat
                     fanRestoreSpeedOnPowerOn: config8.fanRestoreSpeedOnPowerOn,
                     composedEntities: config8.composedEntities,
                     disableMomentaryFlip: config8.disableMomentaryFlip,
-                    vacuumAscendingRoomOrder: config8.vacuumAscendingRoomOrder
+                    vacuumAscendingRoomOrder: config8.vacuumAscendingRoomOrder,
+                    vacuumRoomSwitches: config8.vacuumRoomSwitches
                   });
                   mappingsRestored++;
                 }
@@ -133681,7 +133682,8 @@ WARNING: ${includeIdentity ? "This backup contains sensitive Matter identity dat
                   fanWindPresets: config8.fanWindPresets,
                   composedEntities: config8.composedEntities,
                   disableMomentaryFlip: config8.disableMomentaryFlip,
-                  vacuumAscendingRoomOrder: config8.vacuumAscendingRoomOrder
+                  vacuumAscendingRoomOrder: config8.vacuumAscendingRoomOrder,
+                  vacuumRoomSwitches: config8.vacuumRoomSwitches
                 });
                 mappingsRestored++;
               }
@@ -134533,6 +134535,7 @@ function entityMappingApi(mappingStorage, identityStorage) {
       currentRoomEntity: body.currentRoomEntity,
       cleanedAreaEntity: body.cleanedAreaEntity,
       vacuumAscendingRoomOrder: body.vacuumAscendingRoomOrder,
+      vacuumRoomSwitches: body.vacuumRoomSwitches,
       disableCustomAreaRoomModes: body.disableCustomAreaRoomModes,
       valetudoIdentifier: body.valetudoIdentifier,
       coverSwapOpenClose: body.coverSwapOpenClose,
@@ -135045,7 +135048,8 @@ function configToProfileEntry(config8) {
     climateExposeFan: config8.climateExposeFan,
     climateAutoMode: config8.climateAutoMode,
     disableMomentaryFlip: config8.disableMomentaryFlip,
-    vacuumAscendingRoomOrder: config8.vacuumAscendingRoomOrder
+    vacuumAscendingRoomOrder: config8.vacuumAscendingRoomOrder,
+    vacuumRoomSwitches: config8.vacuumRoomSwitches
   };
 }
 function mappingProfileApi(mappingStorage) {
@@ -135189,7 +135193,8 @@ function mappingProfileApi(mappingStorage) {
           climateExposeFan: entry.climateExposeFan,
           climateAutoMode: entry.climateAutoMode,
           disableMomentaryFlip: entry.disableMomentaryFlip,
-          vacuumAscendingRoomOrder: entry.vacuumAscendingRoomOrder
+          vacuumAscendingRoomOrder: entry.vacuumAscendingRoomOrder,
+          vacuumRoomSwitches: entry.vacuumRoomSwitches
         });
         applied++;
       } catch (e) {
@@ -136588,7 +136593,7 @@ import * as nodePath from "node:path";
 import express14 from "express";
 
 // src/plugins/builtin/names.ts
-var BUILTIN_PLUGIN_NAMES = ["camera"];
+var BUILTIN_PLUGIN_NAMES = ["camera", "security"];
 
 // src/plugins/plugin-installer.ts
 init_esm();
@@ -139966,6 +139971,7 @@ var EntityMappingStorage = class extends Service {
       currentRoomEntity: request.currentRoomEntity?.trim() || void 0,
       cleanedAreaEntity: request.cleanedAreaEntity?.trim() || void 0,
       vacuumAscendingRoomOrder: request.vacuumAscendingRoomOrder || void 0,
+      vacuumRoomSwitches: request.vacuumRoomSwitches || void 0,
       disableCustomAreaRoomModes: request.disableCustomAreaRoomModes || void 0,
       valetudoIdentifier: request.valetudoIdentifier?.trim() || void 0,
       coverSwapOpenClose: request.coverSwapOpenClose || void 0,
@@ -139983,7 +139989,7 @@ var EntityMappingStorage = class extends Service {
       composedEntities: request.composedEntities?.filter((e) => e.entityId?.trim()) ?? void 0,
       disableMomentaryFlip: request.disableMomentaryFlip || void 0
     };
-    if (!config8.matterDeviceType && !config8.customName && !config8.customProductName && !config8.customVendorName && !config8.customSerialNumber && config8.customVendorId === void 0 && config8.disabled !== true && !config8.filterLifeEntity && !config8.cleaningModeEntity && !config8.temperatureEntity && !config8.humidityEntity && !config8.batteryEntity && !config8.disableBatteryMapping && !config8.chargingStateEntity && !config8.roomEntities && !config8.disableLockPin && !config8.lockUsercodeService && config8.lockUsercodeSlot === void 0 && config8.lockPinMinLength === void 0 && config8.lockPinMaxLength === void 0 && !config8.powerEntity && !config8.energyEntity && !config8.meterSerialNumber && !config8.pointOfDelivery && !config8.voltageEntity && !config8.currentEntity && !config8.batteryPowerEntity && !config8.batteryEnergyEntity && !config8.chargingSwitchEntity && !config8.currentLimitEntity && !config8.pressureEntity && !config8.suctionLevelEntity && !config8.mopIntensityEntity && (!config8.customServiceAreas || config8.customServiceAreas.length === 0) && (!config8.customFanSpeedTags || Object.keys(config8.customFanSpeedTags).length === 0) && (!config8.fanWindPresets || (config8.fanWindPresets.natural?.length ?? 0) === 0 && (config8.fanWindPresets.sleep?.length ?? 0) === 0) && !config8.fanRestoreSpeedOnPowerOn && !config8.currentRoomEntity && !config8.cleanedAreaEntity && !config8.vacuumAscendingRoomOrder && !config8.disableCustomAreaRoomModes && !config8.valetudoIdentifier && !config8.coverSwapOpenClose && !config8.coverExposeAsDimmableLight && !config8.selectExposeAsSwitch && !config8.selectSwitchOnOption && !config8.selectSwitchOffOption && !config8.coverSliderDebounceMs && !config8.updateThrottleMs && !config8.disableClimateOnOff && !config8.disableClimateFanControl && !config8.climateKeepModeOnIdle && !config8.climateExposeFan && !config8.climateAutoMode && (!config8.composedEntities || config8.composedEntities.length === 0) && !config8.disableMomentaryFlip) {
+    if (!config8.matterDeviceType && !config8.customName && !config8.customProductName && !config8.customVendorName && !config8.customSerialNumber && config8.customVendorId === void 0 && config8.disabled !== true && !config8.filterLifeEntity && !config8.cleaningModeEntity && !config8.temperatureEntity && !config8.humidityEntity && !config8.batteryEntity && !config8.disableBatteryMapping && !config8.chargingStateEntity && !config8.roomEntities && !config8.disableLockPin && !config8.lockUsercodeService && config8.lockUsercodeSlot === void 0 && config8.lockPinMinLength === void 0 && config8.lockPinMaxLength === void 0 && !config8.powerEntity && !config8.energyEntity && !config8.meterSerialNumber && !config8.pointOfDelivery && !config8.voltageEntity && !config8.currentEntity && !config8.batteryPowerEntity && !config8.batteryEnergyEntity && !config8.chargingSwitchEntity && !config8.currentLimitEntity && !config8.pressureEntity && !config8.suctionLevelEntity && !config8.mopIntensityEntity && (!config8.customServiceAreas || config8.customServiceAreas.length === 0) && (!config8.customFanSpeedTags || Object.keys(config8.customFanSpeedTags).length === 0) && (!config8.fanWindPresets || (config8.fanWindPresets.natural?.length ?? 0) === 0 && (config8.fanWindPresets.sleep?.length ?? 0) === 0) && !config8.fanRestoreSpeedOnPowerOn && !config8.currentRoomEntity && !config8.cleanedAreaEntity && !config8.vacuumAscendingRoomOrder && !config8.vacuumRoomSwitches && !config8.disableCustomAreaRoomModes && !config8.valetudoIdentifier && !config8.coverSwapOpenClose && !config8.coverExposeAsDimmableLight && !config8.selectExposeAsSwitch && !config8.selectSwitchOnOption && !config8.selectSwitchOffOption && !config8.coverSliderDebounceMs && !config8.updateThrottleMs && !config8.disableClimateOnOff && !config8.disableClimateFanControl && !config8.climateKeepModeOnIdle && !config8.climateExposeFan && !config8.climateAutoMode && (!config8.composedEntities || config8.composedEntities.length === 0) && !config8.disableMomentaryFlip) {
       bridgeMap.delete(request.entityId);
     } else {
       bridgeMap.set(request.entityId, config8);
@@ -171139,6 +171145,31 @@ function createCleanAreaServiceAreaServer(cleanAreaRooms) {
     currentArea: null
   });
 }
+function getVacuumServiceAreas(attributes9, mapping) {
+  const cleanAreaRooms = mapping?.cleanAreaRooms;
+  if (cleanAreaRooms && cleanAreaRooms.length > 0) {
+    return cleanAreaRooms.map((room) => ({
+      areaId: room.areaId,
+      name: room.name
+    }));
+  }
+  const customAreas = mapping?.customServiceAreas;
+  if (customAreas && customAreas.length > 0) {
+    return customAreas.map((area, index) => ({
+      areaId: index + 1,
+      name: area.name
+    }));
+  }
+  const roomEntities = mapping?.roomEntities;
+  const rooms = roomEntities && roomEntities.length > 0 ? buttonEntitiesToRooms(roomEntities, attributes9) : parseVacuumRooms(attributes9);
+  if (rooms.length > 0) {
+    return roomsToAreas(rooms).map((area) => ({
+      areaId: area.areaId,
+      name: area.areaInfo.locationInfo?.locationName ?? ""
+    }));
+  }
+  return [];
+}
 
 // src/matter/endpoints/legacy/vacuum/behaviors/vacuum-rvc-run-mode-server.ts
 var logger236 = Logger.get("VacuumRvcRunModeServer");
@@ -171313,6 +171344,135 @@ var cleaningStates = [
 function vacuumIsCleaning(state) {
   return state != null && cleaningStates.includes(state);
 }
+function dispatchRoomClean(attributes9, mapping, entityId, selectedAreas, seam) {
+  const customAreas = mapping?.customServiceAreas;
+  if (customAreas && customAreas.length > 0) {
+    const ephemeral = {
+      completedAreas: /* @__PURE__ */ new Set(),
+      lastCurrentArea: null,
+      activeAreas: [],
+      loggedShortCircuits: /* @__PURE__ */ new Set(),
+      observedCleaning: false,
+      pendingDispatches: [],
+      cleanedAreaBaseline: null
+    };
+    const action = handleCustomServiceAreas(
+      selectedAreas,
+      customAreas,
+      ephemeral
+    );
+    return { action, pending: ephemeral.pendingDispatches };
+  }
+  const cleanAreaRooms = mapping?.cleanAreaRooms;
+  if (cleanAreaRooms && cleanAreaRooms.length > 0) {
+    const haAreaIds = resolveCleanAreaIds(selectedAreas, cleanAreaRooms);
+    if (haAreaIds.length > 0) {
+      logger236.info(`CLEAN_AREA: cleaning HA areas: ${haAreaIds.join(", ")}`);
+      return {
+        action: {
+          action: "vacuum.clean_area",
+          data: { cleaning_area_id: haAreaIds }
+        },
+        pending: []
+      };
+    }
+  }
+  const roomEntities = mapping?.roomEntities;
+  if (roomEntities && roomEntities.length > 0) {
+    const matched = [];
+    for (const areaId of selectedAreas) {
+      const buttonId = roomEntities.find((id) => toAreaId(id) === areaId);
+      if (buttonId) {
+        matched.push({ areaId, entityId: buttonId });
+      }
+    }
+    if (matched.length > 0) {
+      logger236.info(
+        `Roborock: ${matched.length} room button(s) queued: ${matched.map((m) => m.entityId).join(", ")}`
+      );
+      return {
+        action: { action: "button.press", target: matched[0].entityId },
+        pending: matched.slice(1).map(({ areaId, entityId: buttonId }) => ({
+          areaId,
+          action: { action: "button.press", target: buttonId }
+        }))
+      };
+    }
+  }
+  if (entityId.startsWith("vacuum.valetudo_")) {
+    return {
+      action: buildValetudoSegmentAction(
+        entityId,
+        selectedAreas,
+        mapping?.valetudoIdentifier
+      ),
+      pending: []
+    };
+  }
+  const rooms = parseVacuumRooms(attributes9);
+  const roomIds = [];
+  let targetMapName;
+  for (const areaId of selectedAreas) {
+    const room = rooms.find((r) => toAreaId(r.id) === areaId);
+    if (room) {
+      roomIds.push(room.originalId ?? room.id);
+      if (room.mapName && !targetMapName) {
+        targetMapName = room.mapName;
+      }
+    }
+  }
+  if (roomIds.length > 0) {
+    logger236.info(`Starting cleaning with selected areas: ${roomIds.join(", ")}`);
+    if (isDreameVacuum(attributes9)) {
+      if (targetMapName) {
+        const vacName = entityId.replace("vacuum.", "");
+        const selectedMapEntity = `select.${vacName}_selected_map`;
+        logger236.info(
+          `Dreame multi-floor: switching to map "${targetMapName}" via ${selectedMapEntity}`
+        );
+        seam.callAction({
+          action: "select.select_option",
+          target: selectedMapEntity,
+          data: { option: targetMapName }
+        });
+      }
+      return {
+        action: {
+          action: "dreame_vacuum.vacuum_clean_segment",
+          data: { segments: roomIds.length === 1 ? roomIds[0] : roomIds }
+        },
+        pending: []
+      };
+    }
+    if (isRoborockVacuum(attributes9) || isXiaomiMiotVacuum(attributes9)) {
+      return {
+        action: {
+          action: "vacuum.send_command",
+          data: { command: "app_segment_clean", params: roomIds }
+        },
+        pending: []
+      };
+    }
+    if (isEcovacsVacuum(attributes9)) {
+      const roomIdStr = roomIds.join(",");
+      logger236.info(`Ecovacs vacuum: Using spot_area for rooms: ${roomIdStr}`);
+      return {
+        action: {
+          action: "vacuum.send_command",
+          data: {
+            command: "spot_area",
+            params: { mapID: 0, cleanings: 1, rooms: roomIdStr }
+          }
+        },
+        pending: []
+      };
+    }
+    logger236.warn(
+      `Room cleaning via send_command not supported for this vacuum type. Rooms: ${roomIds.join(", ")}. Falling back to vacuum.start`
+    );
+  }
+  return { action: { action: "vacuum.start" }, pending: [] };
+}
 var vacuumRvcRunModeConfig = {
   getCurrentMode: (entity) => {
     const isCleaning = vacuumIsCleaning(entity.state);
@@ -171339,123 +171499,19 @@ var vacuumRvcRunModeConfig = {
       const selectedAreas = [...serviceArea.state.selectedAreas];
       if (selectedAreas.length > 0) {
         const homeAssistant = agent.get(HomeAssistantEntityBehavior);
-        const entity = homeAssistant.entity;
-        const attributes9 = entity.state.attributes;
+        const effective = homeAssistant.endpoint.vacuumEffective;
+        const attributes9 = (effective?.state ?? homeAssistant.entity.state).attributes;
+        const mapping = effective ? effective.mapping : homeAssistant.state.mapping;
         const session = getSession(homeAssistant.endpoint);
-        const customAreas = homeAssistant.state.mapping?.customServiceAreas;
-        if (customAreas && customAreas.length > 0) {
-          return handleCustomServiceAreas(selectedAreas, customAreas, session);
-        }
-        const cleanAreaRooms = homeAssistant.state.mapping?.cleanAreaRooms;
-        if (cleanAreaRooms && cleanAreaRooms.length > 0) {
-          const haAreaIds = resolveCleanAreaIds(selectedAreas, cleanAreaRooms);
-          if (haAreaIds.length > 0) {
-            logger236.info(
-              `CLEAN_AREA: cleaning HA areas: ${haAreaIds.join(", ")}`
-            );
-            return {
-              action: "vacuum.clean_area",
-              data: { cleaning_area_id: haAreaIds }
-            };
-          }
-        }
-        const roomEntities = homeAssistant.state.mapping?.roomEntities;
-        if (roomEntities && roomEntities.length > 0) {
-          const matched = [];
-          for (const areaId of selectedAreas) {
-            const entityId = roomEntities.find((id) => toAreaId(id) === areaId);
-            if (entityId) {
-              matched.push({ areaId, entityId });
-            }
-          }
-          if (matched.length > 0) {
-            logger236.info(
-              `Roborock: ${matched.length} room button(s) queued: ${matched.map((m) => m.entityId).join(", ")}`
-            );
-            session.pendingDispatches = matched.slice(1).map(({ areaId, entityId }) => ({
-              areaId,
-              action: { action: "button.press", target: entityId }
-            }));
-            return {
-              action: "button.press",
-              target: matched[0].entityId
-            };
-          }
-        }
-        const vacuumEntityId = homeAssistant.entityId;
-        if (vacuumEntityId.startsWith("vacuum.valetudo_")) {
-          return buildValetudoSegmentAction(
-            vacuumEntityId,
-            selectedAreas,
-            homeAssistant.state.mapping?.valetudoIdentifier
-          );
-        }
-        const rooms = parseVacuumRooms(attributes9);
-        const roomIds = [];
-        let targetMapName;
-        for (const areaId of selectedAreas) {
-          const room = rooms.find((r) => toAreaId(r.id) === areaId);
-          if (room) {
-            roomIds.push(room.originalId ?? room.id);
-            if (room.mapName && !targetMapName) {
-              targetMapName = room.mapName;
-            }
-          }
-        }
-        if (roomIds.length > 0) {
-          logger236.info(
-            `Starting cleaning with selected areas: ${roomIds.join(", ")}`
-          );
-          if (isDreameVacuum(attributes9)) {
-            if (targetMapName) {
-              const vacName = vacuumEntityId.replace("vacuum.", "");
-              const selectedMapEntity = `select.${vacName}_selected_map`;
-              logger236.info(
-                `Dreame multi-floor: switching to map "${targetMapName}" via ${selectedMapEntity}`
-              );
-              homeAssistant.callAction({
-                action: "select.select_option",
-                target: selectedMapEntity,
-                data: { option: targetMapName }
-              });
-            }
-            return {
-              action: "dreame_vacuum.vacuum_clean_segment",
-              data: {
-                segments: roomIds.length === 1 ? roomIds[0] : roomIds
-              }
-            };
-          }
-          if (isRoborockVacuum(attributes9) || isXiaomiMiotVacuum(attributes9)) {
-            return {
-              action: "vacuum.send_command",
-              data: {
-                command: "app_segment_clean",
-                params: roomIds
-              }
-            };
-          }
-          if (isEcovacsVacuum(attributes9)) {
-            const roomIdStr = roomIds.join(",");
-            logger236.info(
-              `Ecovacs vacuum: Using spot_area for rooms: ${roomIdStr}`
-            );
-            return {
-              action: "vacuum.send_command",
-              data: {
-                command: "spot_area",
-                params: {
-                  mapID: 0,
-                  cleanings: 1,
-                  rooms: roomIdStr
-                }
-              }
-            };
-          }
-          logger236.warn(
-            `Room cleaning via send_command not supported for this vacuum type. Rooms: ${roomIds.join(", ")}. Falling back to vacuum.start`
-          );
-        }
+        const result = dispatchRoomClean(
+          attributes9,
+          mapping,
+          homeAssistant.entityId,
+          selectedAreas,
+          { callAction: (a) => homeAssistant.callAction(a) }
+        );
+        session.pendingDispatches = result.pending;
+        return result.action;
       }
     } catch {
     }
@@ -173922,6 +173978,12 @@ function asStandaloneEndpointType(type) {
 // src/matter/endpoints/legacy/legacy-endpoint.ts
 var logger245 = Logger.get("LegacyEndpoint");
 var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
+  constructor(type, entityId, customName, mappedEntityIds, throttleMs, endpointId, vacuumEffective) {
+    super(type, entityId, customName, mappedEntityIds, endpointId);
+    this.vacuumEffective = vacuumEffective;
+    this.flushUpdate = throttleMs && throttleMs > 50 ? throttleLatest(this.flushPendingUpdate.bind(this), throttleMs) : debounce6(this.flushPendingUpdate.bind(this), 50);
+  }
+  vacuumEffective;
   static async create(registry3, entityId, mapping, pluginDomainMappings, standalone = false, endpointId, identityAnchor) {
     const deviceRegistry = registry3.deviceOf(entityId);
     let state = registry3.initialState(entityId);
@@ -174295,19 +174357,17 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
     }
     const customName = effectiveMapping?.customName;
     const mappedIds = getMappedEntityIds(effectiveMapping);
+    const vacuumEffective = entityId.startsWith("vacuum.") ? { mapping: effectiveMapping, state } : void 0;
     return new _LegacyEndpoint(
       type,
       entityId,
       customName,
       mappedIds,
       effectiveMapping?.updateThrottleMs,
-      endpointId
+      endpointId,
+      vacuumEffective
     );
   }
-  constructor(type, entityId, customName, mappedEntityIds, throttleMs, endpointId) {
-    super(type, entityId, customName, mappedEntityIds, endpointId);
-    this.flushUpdate = throttleMs && throttleMs > 50 ? throttleLatest(this.flushPendingUpdate.bind(this), throttleMs) : debounce6(this.flushPendingUpdate.bind(this), 50);
-  }
   lastState;
   pendingMappedChange = false;
   flushUpdate;
@@ -174374,6 +174434,96 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
   }
 };
 
+// src/matter/endpoints/legacy/vacuum/vacuum-area-switch.ts
+init_esm();
+init_home_assistant_entity_behavior();
+var VacuumAreaSwitchEndpoint = class _VacuumAreaSwitchEndpoint extends EntityEndpoint {
+  constructor(type, entityId, endpointId, areaId, vacuumEndpointId, parentEffective) {
+    super(type, entityId, void 0, [], endpointId);
+    this.areaId = areaId;
+    this.vacuumEndpointId = vacuumEndpointId;
+    this.parentEffective = parentEffective;
+  }
+  areaId;
+  vacuumEndpointId;
+  parentEffective;
+  static create(params) {
+    const { vacuumEndpointId, entity, mapping, area, parentEffective } = params;
+    const endpointId = `${vacuumEndpointId}_roomsw_${area.areaId}`;
+    const areaId = area.areaId;
+    const switchMapping = mapping?.customSerialNumber ? { ...mapping, customSerialNumber: void 0 } : mapping;
+    const switchEntity = entity.deviceRegistry?.serial_number ? {
+      ...entity,
+      deviceRegistry: {
+        ...entity.deviceRegistry,
+        serial_number: void 0
+      }
+    } : entity;
+    const type = OnOffPlugInUnitDevice.with(
+      BasicInformationServer2,
+      IdentifyServer2,
+      HomeAssistantEntityBehavior,
+      OnOffServer2({
+        isOn: () => false,
+        // off is a no-op (momentary auto-reset only, script pattern).
+        turnOff: null,
+        turnOn: (_value, agent) => {
+          const ha = agent.get(HomeAssistantEntityBehavior);
+          const { action } = dispatchRoomClean(
+            parentEffective.state.attributes,
+            parentEffective.mapping,
+            ha.entityId,
+            [areaId],
+            { callAction: (a) => ha.callAction(a) }
+          );
+          return action;
+        }
+      })
+    ).set({
+      homeAssistantEntity: {
+        entity: switchEntity,
+        mapping: switchMapping,
+        customName: area.name,
+        // Distinct anchor so uniqueId/serial don't collide with the vacuum's,
+        // and stay frozen across HA renames.
+        identityAnchor: endpointId
+      }
+    });
+    return new _VacuumAreaSwitchEndpoint(
+      type,
+      entity.entity_id,
+      endpointId,
+      areaId,
+      vacuumEndpointId,
+      parentEffective
+    );
+  }
+  async updateStates(states) {
+    const state = states[this.entityId];
+    if (!state) return;
+    try {
+      await this.construction.ready;
+    } catch {
+      return;
+    }
+    try {
+      const current = this.stateOf(HomeAssistantEntityBehavior).entity;
+      await this.setStateOf(HomeAssistantEntityBehavior, {
+        entity: { ...current, state }
+      });
+    } catch (error) {
+      if (error instanceof TransactionDestroyedError || error instanceof DestroyedDependencyError) {
+        return;
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("Endpoint storage inaccessible")) {
+        return;
+      }
+      throw error;
+    }
+  }
+};
+
 // src/plugins/builtin/camera/camera-plugin.ts
 init_esm();
 
@@ -175365,9 +175515,943 @@ var CameraPlugin = class {
   }
 };
 
+// src/plugins/builtin/security/security-plugin.ts
+init_esm();
+import {
+  callService as callService2,
+  createConnection as createConnection4,
+  createLongLivedTokenAuth as createLongLivedTokenAuth3
+} from "home-assistant-js-websocket";
+
+// src/plugins/builtin/security/security-state-machine.ts
+var ARM_MODES = [
+  "home",
+  "away",
+  "night",
+  "vacation"
+];
+var defaultSecurityScheduler = {
+  schedule(ms, fn) {
+    const timer = setTimeout(fn, ms);
+    timer.unref?.();
+    return () => clearTimeout(timer);
+  }
+};
+function parseEntityList(value) {
+  if (typeof value !== "string") return [];
+  return [
+    ...new Set(
+      value.split(",").map((s) => s.trim()).filter(Boolean)
+    )
+  ];
+}
+var SILENCEABLE_ALERT_DOMAINS = /* @__PURE__ */ new Set([
+  "siren",
+  "switch",
+  "light"
+]);
+var FIRE_ONLY_ALERT_DOMAINS = /* @__PURE__ */ new Set([
+  "script",
+  "scene"
+]);
+function resolveSecurityLists(config8, warn) {
+  const warned = /* @__PURE__ */ new Set();
+  const alerts = (value) => parseEntityList(value).filter((id) => {
+    const domain = id.split(".")[0];
+    if (SILENCEABLE_ALERT_DOMAINS.has(domain) || FIRE_ONLY_ALERT_DOMAINS.has(domain)) {
+      return true;
+    }
+    if (!warned.has(id)) {
+      warned.add(id);
+      warn?.(
+        `alert entity ${id} dropped, only siren/switch/light and script/scene are supported`
+      );
+    }
+    return false;
+  });
+  const awaySetters = parseEntityList(config8.awaySetters);
+  const awayTriggers = parseEntityList(config8.awayTriggers);
+  const awayAlerts = alerts(config8.awayAlerts);
+  const vacationSetters = parseEntityList(config8.vacationSetters);
+  const vacationTriggers = parseEntityList(config8.vacationTriggers);
+  const vacationAlerts = alerts(config8.vacationAlerts);
+  return {
+    setters: {
+      home: parseEntityList(config8.homeSetters),
+      away: awaySetters,
+      night: parseEntityList(config8.nightSetters),
+      vacation: vacationSetters.length > 0 ? vacationSetters : awaySetters
+    },
+    offSetters: parseEntityList(config8.offSetters),
+    triggers: {
+      home: parseEntityList(config8.homeTriggers),
+      away: awayTriggers,
+      night: parseEntityList(config8.nightTriggers),
+      vacation: vacationTriggers.length > 0 ? vacationTriggers : awayTriggers
+    },
+    triggers24h: parseEntityList(config8.triggers24h),
+    alerts: {
+      home: alerts(config8.homeAlerts),
+      away: awayAlerts,
+      night: alerts(config8.nightAlerts),
+      vacation: vacationAlerts.length > 0 ? vacationAlerts : awayAlerts
+    },
+    alerts24h: alerts(config8.alerts24h),
+    alwaysAlerts: alerts(config8.alwaysAlerts)
+  };
+}
+function alertsForTier(lists, tier) {
+  const base = tier === "24h" ? lists.alerts24h : lists.alerts[tier];
+  return [.../* @__PURE__ */ new Set([...base, ...lists.alwaysAlerts])];
+}
+function watchedTriggerEntities(lists) {
+  const all = new Set(lists.triggers24h);
+  for (const mode of ARM_MODES) {
+    for (const id of lists.triggers[mode]) all.add(id);
+  }
+  return all;
+}
+var PERIMETER_DEVICE_CLASSES = /* @__PURE__ */ new Set([
+  "door",
+  "window",
+  "garage_door",
+  "opening"
+]);
+function isPerimeterTrigger(entityId, deviceClass) {
+  return entityId.startsWith("binary_sensor.") && deviceClass != null && PERIMETER_DEVICE_CLASSES.has(deviceClass);
+}
+var SecurityStateMachine = class {
+  constructor(config8, effects, scheduler = defaultSecurityScheduler) {
+    this.config = config8;
+    this.effects = effects;
+    this.scheduler = scheduler;
+  }
+  config;
+  effects;
+  scheduler;
+  mode = null;
+  phase = "disarmed";
+  // Where a triggered alarm returns to when the trigger time runs out.
+  returnMode = null;
+  // Tier of the current trip, only meaningful while triggered.
+  trippedTier = null;
+  // False while an exit delay is still running, so an auto-return after a
+  // trip that cut the delay short can run the setters late.
+  modeReachedRan = true;
+  cancelTimer;
+  get snapshot() {
+    return { mode: this.mode, phase: this.phase };
+  }
+  // Live config swap: state survives, already running timers keep the delay
+  // they started with.
+  setConfig(config8) {
+    this.config = config8;
+  }
+  // Applied once on start from the persisted snapshot. Interrupted delays
+  // resolve to armed; triggered stays only when the trigger time is infinite.
+  // A resolution that changed the phase is persisted right away so a second
+  // restart replays no effects. An interrupted exit delay is the one case
+  // where the setters never ran, so that restore dispatches modeReached.
+  restore(snapshot) {
+    if (!snapshot) return;
+    const mode = ARM_MODES.includes(snapshot.mode) ? snapshot.mode : null;
+    const reached = snapshot.modeReached ?? true;
+    switch (snapshot.phase) {
+      case "arming":
+      case "pending":
+      case "armed":
+        if (mode) {
+          this.mode = mode;
+          this.phase = "armed";
+          this.modeReachedRan = true;
+          if (snapshot.phase !== "armed") this.persist();
+          if (snapshot.phase === "arming") this.effects.modeReached(mode);
+        }
+        break;
+      case "triggered":
+        if (this.config.triggerTimeSeconds === 0) {
+          this.mode = mode;
+          this.returnMode = mode;
+          this.phase = "triggered";
+          this.modeReachedRan = reached;
+        } else {
+          if (mode) {
+            this.mode = mode;
+            this.phase = "armed";
+            this.modeReachedRan = true;
+          }
+          this.persist();
+          if (mode && !reached) this.effects.modeReached(mode);
+        }
+        break;
+      default:
+        break;
+    }
+  }
+  // A mode switch changed on the Matter side. Exclusivity lives here: arming
+  // one mode reports the other three off, turning the active one off disarms.
+  handleModeSwitch(mode, on) {
+    if (on) {
+      if (this.mode === mode && this.phase !== "disarmed") {
+        this.reportSwitches();
+        return;
+      }
+      this.arm(mode);
+    } else if (this.mode === mode && this.phase !== "disarmed" || this.mode === null && this.phase === "triggered") {
+      this.disarm();
+    } else {
+      this.reportSwitches();
+    }
+  }
+  arm(mode) {
+    const wasTriggered = this.phase === "triggered";
+    this.clearTimer();
+    this.mode = mode;
+    this.returnMode = null;
+    const delayMs = this.config.exitDelaySeconds * 1e3;
+    if (delayMs > 0) {
+      this.phase = "arming";
+      this.modeReachedRan = false;
+      this.reportSwitches();
+      if (wasTriggered) this.effects.alarmCleared();
+      this.persist();
+      this.cancelTimer = this.scheduler.schedule(
+        delayMs,
+        () => this.becomeArmed()
+      );
+    } else {
+      this.phase = "armed";
+      this.modeReachedRan = true;
+      this.reportSwitches();
+      if (wasTriggered) this.effects.alarmCleared();
+      this.persist();
+      this.effects.modeReached(mode);
+    }
+  }
+  disarm() {
+    if (this.phase === "disarmed") {
+      this.reportSwitches();
+      return;
+    }
+    const wasTriggered = this.phase === "triggered";
+    this.clearTimer();
+    this.mode = null;
+    this.returnMode = null;
+    this.phase = "disarmed";
+    this.reportSwitches();
+    if (wasTriggered) this.effects.alarmCleared();
+    this.persist();
+    this.effects.disarmed();
+  }
+  // A watched entity entered on/open. The 24h list trips in every state and
+  // skips the entry delay; mode triggers only count while armed (the exit
+  // delay exists so leaving does not trip the alarm).
+  handleEntityOn(entityId, isPerimeter) {
+    if (this.config.triggers24h.includes(entityId)) {
+      if (this.phase !== "triggered" || this.trippedTier !== "24h") {
+        this.trip("24h", entityId);
+      }
+      return;
+    }
+    const mode = this.mode;
+    if (!mode) return;
+    if (!this.config.triggers[mode].includes(entityId)) return;
+    if (this.phase === "armed") {
+      const entryMs = this.config.entryDelaySeconds * 1e3;
+      if (isPerimeter && entryMs > 0) {
+        this.phase = "pending";
+        this.persist();
+        this.cancelTimer = this.scheduler.schedule(
+          entryMs,
+          () => this.trip(mode, entityId)
+        );
+      } else {
+        this.trip(mode, entityId);
+      }
+    } else if (this.phase === "pending" && !isPerimeter) {
+      this.trip(mode, entityId);
+    }
+  }
+  shutdown() {
+    this.clearTimer();
+  }
+  becomeArmed() {
+    this.cancelTimer = void 0;
+    const mode = this.mode;
+    if (!mode || this.phase !== "arming") return;
+    this.phase = "armed";
+    this.modeReachedRan = true;
+    this.persist();
+    this.effects.modeReached(mode);
+  }
+  trip(tier, entityId) {
+    this.clearTimer();
+    this.returnMode = this.mode;
+    this.trippedTier = tier;
+    this.phase = "triggered";
+    this.effects.tripped(tier, entityId);
+    this.persist();
+    const holdMs = this.config.triggerTimeSeconds * 1e3;
+    if (holdMs > 0) {
+      this.cancelTimer = this.scheduler.schedule(
+        holdMs,
+        () => this.autoReturn()
+      );
+    }
+  }
+  autoReturn() {
+    this.cancelTimer = void 0;
+    this.mode = this.returnMode;
+    this.returnMode = null;
+    this.phase = this.mode ? "armed" : "disarmed";
+    const lateSetters = this.mode != null && !this.modeReachedRan;
+    this.modeReachedRan = true;
+    this.effects.alarmCleared();
+    this.persist();
+    if (lateSetters && this.mode) this.effects.modeReached(this.mode);
+  }
+  reportSwitches() {
+    const active = this.phase === "disarmed" ? null : this.mode;
+    const states = {};
+    for (const mode of ARM_MODES) states[mode] = mode === active;
+    this.effects.switchStates(states);
+  }
+  persist() {
+    this.effects.persist({
+      ...this.snapshot,
+      modeReached: this.modeReachedRan
+    });
+  }
+  clearTimer() {
+    this.cancelTimer?.();
+    this.cancelTimer = void 0;
+  }
+};
+
+// src/plugins/builtin/security/security-plugin.ts
+var CONFIG_KEY2 = "config";
+var STATE_KEY = "state";
+var PENDING_SILENCE_KEY = "pendingSilence";
+var PENDING_SETTERS_KEY = "pendingSetters";
+var ALARM_DEVICE_ID = "alarm";
+var MODE_DEVICE_IDS = {
+  home: "mode_home",
+  away: "mode_away",
+  night: "mode_night",
+  vacation: "mode_vacation"
+};
+var MODE_NAMES = {
+  home: "Home",
+  away: "Away",
+  night: "Night",
+  vacation: "Vacation"
+};
+var RETRY_BASE_MS = 1e3;
+var RETRY_MAX_MS = 6e4;
+var CALL_DEADLINE_MS = 1e4;
+var SecurityPlugin = class {
+  constructor(config8 = {}, deps = {}) {
+    this.deps = deps;
+    this.config = config8;
+  }
+  deps;
+  name = "security";
+  version = "0.1.0";
+  log = Logger.get("SecurityPlugin");
+  context;
+  config;
+  lists = resolveSecurityLists({});
+  watched = /* @__PURE__ */ new Set();
+  machine;
+  activeAlerts = [];
+  // Effect tasks run strictly FIFO: a disarm's silence can never overtake the
+  // trip's turn_on loop it is chasing. Queued (not yet started) intent is
+  // coalesced per entity so a hung call cannot pile up work behind it.
+  tasks = [];
+  draining = false;
+  connection;
+  unsubscribeEvents;
+  retryTimer;
+  backoffMs = RETRY_BASE_MS;
+  // Bumped on every teardown; a dial resolving under a stale generation is
+  // discarded instead of installing an old target.
+  dialGeneration = 0;
+  async onStart(context) {
+    this.context = context;
+    const stored = await context.storage.get(CONFIG_KEY2);
+    this.config = { ...this.config, ...stored ?? {} };
+    this.applyLists();
+    this.machine = new SecurityStateMachine(
+      this.machineConfig(),
+      this.effects()
+    );
+    await this.registerDevices();
+    const state = await context.storage.get(STATE_KEY);
+    this.machine.restore(state);
+    await context.storage.flush?.();
+    if (state?.phase === "triggered") {
+      const known = state.activeAlerts;
+      if (this.machine.snapshot.phase === "triggered") {
+        this.activeAlerts = known ?? this.allSilenceableAlerts();
+      } else {
+        const candidates = (known ?? this.allSilenceableAlerts()).filter(
+          (id) => SILENCEABLE_ALERT_DOMAINS.has(id.split(".")[0])
+        );
+        this.enqueueSilence(candidates);
+      }
+    }
+    this.pushDeviceStates();
+    this.startConnection();
+  }
+  async onConfigChanged(config8) {
+    this.config = config8;
+    await this.context?.storage.set(CONFIG_KEY2, this.config);
+    this.applyLists();
+    this.machine?.setConfig(this.machineConfig());
+    await this.stopConnection();
+    this.startConnection();
+  }
+  async onShutdown() {
+    this.machine?.shutdown();
+    await this.stopConnection();
+    for (const id of [...Object.values(MODE_DEVICE_IDS), ALARM_DEVICE_ID]) {
+      await this.context?.unregisterDevice(id).catch(() => {
+      });
+    }
+  }
+  getCurrentConfig() {
+    return { ...this.config };
+  }
+  getConfigSchema() {
+    const entityList = (title, description) => ({
+      type: "string",
+      title,
+      description,
+      required: false
+    });
+    return {
+      title: "Security",
+      description: "A small alarm system: four exclusive mode switches plus an Alarm contact sensor. All entity fields are comma-separated lists.",
+      properties: {
+        exitDelaySeconds: {
+          type: "number",
+          title: "Exit delay (seconds)",
+          description: "Delay before an armed mode takes effect. 0 disables.",
+          default: 60,
+          required: false
+        },
+        entryDelaySeconds: {
+          type: "number",
+          title: "Entry delay (seconds)",
+          description: "Delay for door/window/garage door/opening sensors while armed. Other trigger classes trip instantly. 0 disables.",
+          default: 60,
+          required: false
+        },
+        triggerTimeSeconds: {
+          type: "number",
+          title: "Trigger time (seconds)",
+          description: "How long the alarm stays triggered before returning to the state it was tripped from. 0 keeps it triggered until disarm.",
+          default: 120,
+          required: false
+        },
+        homeSetters: entityList(
+          "Home setters",
+          "Invoked when Home is armed, e.g. scene.arm_home,script.notify"
+        ),
+        homeTriggers: entityList(
+          "Home triggers",
+          "Sensors that trip the alarm while armed Home."
+        ),
+        homeAlerts: entityList(
+          "Home alerts",
+          "Turned on when the alarm trips while armed Home."
+        ),
+        awaySetters: entityList("Away setters", "Invoked when Away is armed."),
+        awayTriggers: entityList(
+          "Away triggers",
+          "Sensors that trip the alarm while armed Away."
+        ),
+        awayAlerts: entityList(
+          "Away alerts",
+          "Turned on when the alarm trips while armed Away."
+        ),
+        nightSetters: entityList(
+          "Night setters",
+          "Invoked when Night is armed."
+        ),
+        nightTriggers: entityList(
+          "Night triggers",
+          "Sensors that trip the alarm while armed Night."
+        ),
+        nightAlerts: entityList(
+          "Night alerts",
+          "Turned on when the alarm trips while armed Night."
+        ),
+        vacationSetters: entityList(
+          "Vacation setters",
+          "Leave empty to use the Away setters."
+        ),
+        vacationTriggers: entityList(
+          "Vacation triggers",
+          "Leave empty to use the Away triggers."
+        ),
+        vacationAlerts: entityList(
+          "Vacation alerts",
+          "Leave empty to use the Away alerts."
+        ),
+        offSetters: entityList(
+          "Off setters",
+          "Invoked on disarm, e.g. scene.alarm_off"
+        ),
+        triggers24h: entityList(
+          "24h triggers",
+          "Trip the alarm in every state including disarmed, without entry delay. For smoke, gas, water leak and similar."
+        ),
+        alerts24h: entityList(
+          "24h alerts",
+          "Turned on when a 24h trigger trips the alarm."
+        ),
+        alwaysAlerts: entityList(
+          "Always",
+          "The master alert list: fired on every trip in addition to the tier's alerts."
+        ),
+        haUrl: {
+          type: "string",
+          title: "Home Assistant URL",
+          description: "e.g. http://homeassistant.local:8123. Set together with the token to use a different Home Assistant; leave both empty to use the bridge's credentials. One without the other is ignored.",
+          required: false
+        },
+        haToken: {
+          type: "string",
+          title: "Long-lived access token",
+          description: "Token for the custom URL, only used together with it. Leave both empty to use the bridge's credentials.",
+          required: false,
+          secret: true
+        }
+      }
+    };
+  }
+  // A watched entity changed state, from the websocket or from tests.
+  handleTriggerEvent(entityId, state, deviceClass) {
+    if (state !== "on" && state !== "open") return;
+    if (!this.watched.has(entityId)) return;
+    this.machine?.handleEntityOn(
+      entityId,
+      isPerimeterTrigger(entityId, deviceClass)
+    );
+  }
+  applyLists() {
+    this.lists = resolveSecurityLists(
+      this.config,
+      (message) => this.log.warn(message)
+    );
+    this.watched = watchedTriggerEntities(this.lists);
+  }
+  machineConfig() {
+    const seconds = (value, fallback) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : fallback;
+    return {
+      exitDelaySeconds: seconds(this.config.exitDelaySeconds, 60),
+      entryDelaySeconds: seconds(this.config.entryDelaySeconds, 60),
+      triggerTimeSeconds: seconds(this.config.triggerTimeSeconds, 120),
+      triggers: this.lists.triggers,
+      triggers24h: this.lists.triggers24h
+    };
+  }
+  effects() {
+    return {
+      switchStates: (states) => {
+        for (const mode of ARM_MODES) {
+          this.context?.updateDeviceState(MODE_DEVICE_IDS[mode], "onOff", {
+            onOff: states[mode]
+          });
+        }
+      },
+      modeReached: (mode) => {
+        this.enqueueSetters(mode);
+      },
+      disarmed: () => {
+        this.enqueueSetters("off");
+      },
+      tripped: (tier, entityId) => {
+        this.log.info(`alarm tripped by ${entityId} (${tier})`);
+        this.context?.updateDeviceState(ALARM_DEVICE_ID, "booleanState", {
+          stateValue: false
+        });
+        const alerts = alertsForTier(this.lists, tier);
+        this.activeAlerts = [.../* @__PURE__ */ new Set([...this.activeAlerts, ...alerts])];
+        this.enqueueAlerts(alerts);
+      },
+      alarmCleared: () => {
+        this.context?.updateDeviceState(ALARM_DEVICE_ID, "booleanState", {
+          stateValue: true
+        });
+        const toSilence = this.activeAlerts.filter(
+          (id) => SILENCEABLE_ALERT_DOMAINS.has(id.split(".")[0])
+        );
+        this.activeAlerts = [];
+        this.enqueueSilence(toSilence);
+      },
+      persist: (snapshot) => {
+        const state = {
+          ...snapshot,
+          activeAlerts: [...this.activeAlerts]
+        };
+        void this.context?.storage.set(STATE_KEY, state).catch((e) => this.log.warn("failed to persist alarm state:", e));
+      }
+    };
+  }
+  setters(key) {
+    return key === "off" ? this.lists.offSetters : this.lists.setters[key];
+  }
+  // Every alert a clear can turn off, across all tiers.
+  allSilenceableAlerts() {
+    const all = /* @__PURE__ */ new Set([
+      ...ARM_MODES.flatMap((mode) => this.lists.alerts[mode]),
+      ...this.lists.alerts24h,
+      ...this.lists.alwaysAlerts
+    ]);
+    return [...all].filter(
+      (id) => SILENCEABLE_ALERT_DOMAINS.has(id.split(".")[0])
+    );
+  }
+  async registerDevices() {
+    const context = this.context;
+    if (!context) return;
+    for (const mode of ARM_MODES) {
+      await context.registerDevice({
+        id: MODE_DEVICE_IDS[mode],
+        name: MODE_NAMES[mode],
+        deviceType: "on_off_plugin_unit",
+        clusters: [{ clusterId: "onOff", attributes: { onOff: false } }],
+        onAttributeWrite: async (clusterId3, attribute, value) => {
+          if (clusterId3 !== "onOff" || attribute !== "onOff") return;
+          this.machine?.handleModeSwitch(mode, value === true);
+        }
+      });
+    }
+    await context.registerDevice({
+      id: ALARM_DEVICE_ID,
+      name: "Alarm",
+      deviceType: "contact_sensor",
+      // stateValue true = closed = all quiet; false = open = tripped.
+      clusters: [
+        { clusterId: "booleanState", attributes: { stateValue: true } }
+      ]
+    });
+  }
+  // Reflect the restored snapshot onto the endpoints.
+  pushDeviceStates() {
+    const context = this.context;
+    const machine = this.machine;
+    if (!context || !machine) return;
+    const snap = machine.snapshot;
+    for (const mode of ARM_MODES) {
+      context.updateDeviceState(MODE_DEVICE_IDS[mode], "onOff", {
+        onOff: snap.mode === mode && snap.phase !== "disarmed"
+      });
+    }
+    context.updateDeviceState(ALARM_DEVICE_ID, "booleanState", {
+      stateValue: snap.phase !== "triggered"
+    });
+  }
+  pushTask(task) {
+    this.tasks.push(task);
+    queueMicrotask(() => void this.drain());
+  }
+  enqueueSetters(mode) {
+    this.tasks = this.tasks.filter((t) => t.kind !== "setters");
+    this.pushTask({ kind: "setters", mode });
+  }
+  enqueueAlerts(entityIds) {
+    this.dropQueuedIntent("silence", entityIds);
+    const queued = this.tasks.find((t) => t.kind === "alerts");
+    if (queued && queued.kind === "alerts") {
+      queued.entities = [.../* @__PURE__ */ new Set([...queued.entities, ...entityIds])];
+      return;
+    }
+    this.pushTask({ kind: "alerts", entities: [...entityIds] });
+  }
+  enqueueSilence(entityIds) {
+    this.dropQueuedIntent("alerts", entityIds);
+    const queued = this.tasks.find((t) => t.kind === "silence");
+    if (queued && queued.kind === "silence") {
+      queued.entities = [.../* @__PURE__ */ new Set([...queued.entities, ...entityIds])];
+      return;
+    }
+    this.pushTask({ kind: "silence", entities: [...entityIds] });
+  }
+  enqueueReconnect() {
+    if (this.tasks.some((t) => t.kind === "reconnect")) return;
+    this.pushTask({ kind: "reconnect" });
+  }
+  // A newer turn_on/turn_off intent for an entity replaces the queued
+  // opposite one. Only queued tasks are touched, an in-flight batch keeps
+  // its order guarantee.
+  dropQueuedIntent(kind, entityIds) {
+    const drop = new Set(entityIds);
+    this.tasks = this.tasks.flatMap((t) => {
+      if (t.kind !== kind) return [t];
+      const rest = t.entities.filter((id) => !drop.has(id));
+      return rest.length > 0 ? [{ ...t, entities: rest }] : [];
+    });
+  }
+  async drain() {
+    if (this.draining) return;
+    this.draining = true;
+    try {
+      for (; ; ) {
+        const task = this.tasks.shift();
+        if (!task) return;
+        try {
+          await this.runTask(task);
+        } catch (e) {
+          this.log.warn("effect batch failed:", e);
+        }
+      }
+    } finally {
+      this.draining = false;
+    }
+  }
+  async runTask(task) {
+    switch (task.kind) {
+      case "setters":
+        return this.runSetters(task.mode);
+      case "alerts":
+        return this.runAlerts(task.entities);
+      case "silence":
+        return this.runSilence(task.entities);
+      case "reconnect":
+        return this.flushAfterConnect();
+    }
+  }
+  // Setter turn_on per domain: script.turn_on for script.*, scene.turn_on for
+  // scene.*, else <domain>.turn_on. The intent goes to disk first and leaves
+  // it only once every call resolved, so a crash, gap or failed call is
+  // replayed on reconnect if the mode is still current.
+  async runSetters(key) {
+    const entities = this.setters(key);
+    if (entities.length === 0) return;
+    const storage2 = this.context?.storage;
+    await storage2?.set(PENDING_SETTERS_KEY, { mode: key });
+    await storage2?.flush?.();
+    if (this.connection?.connected !== true) {
+      this.log.debug(
+        `no Home Assistant connection, ${key} setters wait for the reconnect`
+      );
+      return;
+    }
+    const ok2 = await this.callSequential(entities, "turn_on");
+    if (ok2) await storage2?.delete(PENDING_SETTERS_KEY);
+  }
+  async runAlerts(entityIds) {
+    if (entityIds.length === 0) return;
+    await this.context?.storage.flush?.();
+    const connection = this.connection;
+    if (!connection || !connection.connected) {
+      this.log.warn(
+        `no Home Assistant connection, alerts skipped: ${entityIds.join(",")}`
+      );
+      return;
+    }
+    await this.callSequential(entityIds, "turn_on");
+  }
+  // Every due turn_off goes to storage first and leaves it only once HA
+  // confirmed the call, so a crash or gap can never lose a silence.
+  async runSilence(entityIds) {
+    const storage2 = this.context?.storage;
+    if (storage2 && entityIds.length > 0) {
+      const pending = await storage2.get(PENDING_SILENCE_KEY) ?? [];
+      await storage2.set(PENDING_SILENCE_KEY, [
+        .../* @__PURE__ */ new Set([...pending, ...entityIds])
+      ]);
+      await storage2.flush?.();
+    }
+    await this.flushPendingSilence();
+  }
+  async flushPendingSilence() {
+    const storage2 = this.context?.storage;
+    if (!storage2) return;
+    let pending = await storage2.get(PENDING_SILENCE_KEY) ?? [];
+    if (pending.length === 0) return;
+    const connection = this.connection;
+    if (!connection || !connection.connected) {
+      this.log.warn(
+        `no Home Assistant connection, silence stays pending for ${pending.join(",")}`
+      );
+      return;
+    }
+    for (const entityId of [...pending]) {
+      const domain = entityId.split(".")[0];
+      try {
+        await this.callWithDeadline(connection, domain, "turn_off", entityId);
+        pending = pending.filter((id) => id !== entityId);
+        await storage2.set(PENDING_SILENCE_KEY, pending);
+      } catch (e) {
+        this.log.warn(
+          `${domain}.turn_off failed for ${entityId}, retried on reconnect:`,
+          e
+        );
+      }
+    }
+    if (pending.length === 0) await storage2.delete(PENDING_SILENCE_KEY);
+  }
+  // Ran after every (re)connect: sirens first, then any setter batch a gap
+  // swallowed, but only if the machine still stands where it did.
+  async flushAfterConnect() {
+    await this.flushPendingSilence();
+    const storage2 = this.context?.storage;
+    if (!storage2) return;
+    const held = await storage2.get(
+      PENDING_SETTERS_KEY
+    );
+    if (!held) return;
+    const snap = this.machine?.snapshot;
+    const stillCurrent = held.mode === "off" ? snap?.phase === "disarmed" : snap?.mode === held.mode && snap?.phase !== "disarmed";
+    if (!stillCurrent) {
+      await storage2.delete(PENDING_SETTERS_KEY);
+      return;
+    }
+    const ok2 = await this.callSequential(this.setters(held.mode), "turn_on");
+    if (ok2) await storage2.delete(PENDING_SETTERS_KEY);
+  }
+  async callSequential(entityIds, service) {
+    const connection = this.connection;
+    if (!connection || !connection.connected) return false;
+    let allOk = true;
+    for (const entityId of entityIds) {
+      const domain = entityId.split(".")[0];
+      try {
+        await this.callWithDeadline(connection, domain, service, entityId);
+      } catch (e) {
+        allOk = false;
+        this.log.warn(`${domain}.${service} failed for ${entityId}:`, e);
+      }
+    }
+    return allOk;
+  }
+  async callWithDeadline(connection, domain, service, entityId) {
+    let timer;
+    try {
+      await Promise.race([
+        callService2(connection, domain, service, void 0, {
+          entity_id: entityId
+        }),
+        new Promise((_, reject) => {
+          timer = setTimeout(
+            () => reject(
+              new Error(
+                `${domain}.${service} for ${entityId} timed out after ${CALL_DEADLINE_MS}ms`
+              )
+            ),
+            CALL_DEADLINE_MS
+          );
+          timer.unref?.();
+        })
+      ]);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+  startConnection() {
+    const hasCustomUrl = !!this.config.haUrl;
+    const hasCustomToken = !!this.config.haToken;
+    if (hasCustomUrl !== hasCustomToken) {
+      this.log.warn(
+        "haUrl and haToken must both be set for a custom Home Assistant, using the bridge credentials instead"
+      );
+    }
+    const custom = hasCustomUrl && hasCustomToken;
+    const haUrl = custom ? this.config.haUrl : this.context?.homeAssistant?.url;
+    const haToken = custom ? this.config.haToken : this.context?.homeAssistant?.accessToken;
+    if (!haUrl || !haToken) {
+      this.log.info(
+        "no Home Assistant connection, setters, alerts and triggers stay inactive"
+      );
+      return;
+    }
+    void this.connect(haUrl, haToken);
+  }
+  async connect(haUrl, haToken) {
+    const generation = this.dialGeneration;
+    let connection;
+    try {
+      connection = this.deps.connect ? await this.deps.connect(haUrl, haToken) : await createConnection4({
+        auth: createLongLivedTokenAuth3(haUrl, haToken)
+      });
+      if (generation !== this.dialGeneration) {
+        connection.close();
+        return;
+      }
+      this.connection = connection;
+      this.backoffMs = RETRY_BASE_MS;
+      connection.addEventListener(
+        "disconnected",
+        () => this.log.info("Home Assistant connection lost, waiting for reconnect")
+      );
+      connection.addEventListener("ready", () => this.enqueueReconnect());
+      const unsubscribe = await connection.subscribeEvents(
+        (event3) => this.handleStateChanged(event3),
+        "state_changed"
+      );
+      if (generation !== this.dialGeneration) {
+        return;
+      }
+      this.unsubscribeEvents = unsubscribe;
+      this.log.info(`watching ${this.watched.size} trigger entities`);
+      this.enqueueReconnect();
+    } catch (e) {
+      connection?.close();
+      if (this.connection === connection) this.connection = void 0;
+      if (generation !== this.dialGeneration) return;
+      this.log.warn(
+        `Home Assistant connection failed, retrying in ${this.backoffMs}ms:`,
+        e
+      );
+      const delay = this.backoffMs;
+      this.backoffMs = Math.min(this.backoffMs * 2, RETRY_MAX_MS);
+      this.retryTimer = setTimeout(() => {
+        this.retryTimer = void 0;
+        if (generation !== this.dialGeneration) return;
+        void this.connect(haUrl, haToken);
+      }, delay);
+      this.retryTimer.unref?.();
+    }
+  }
+  async stopConnection() {
+    this.dialGeneration++;
+    if (this.retryTimer) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = void 0;
+    }
+    const unsubscribe = this.unsubscribeEvents;
+    this.unsubscribeEvents = void 0;
+    if (unsubscribe) {
+      try {
+        await unsubscribe();
+      } catch {
+      }
+    }
+    this.connection?.close();
+    this.connection = void 0;
+    this.backoffMs = RETRY_BASE_MS;
+  }
+  handleStateChanged(event3) {
+    const entityId = event3.data?.entity_id;
+    const newState = event3.data?.new_state;
+    if (!entityId || !newState?.state) return;
+    if (event3.data?.old_state?.state === newState.state) return;
+    this.handleTriggerEvent(
+      entityId,
+      newState.state,
+      newState.attributes?.device_class
+    );
+  }
+};
+
 // src/plugins/builtin/index.ts
 var BUILTIN_PLUGINS = [
-  CameraPlugin
+  CameraPlugin,
+  SecurityPlugin
 ];
 
 // src/services/bridges/bridge-endpoint-manager.ts
@@ -175796,8 +176880,13 @@ var BridgeEndpointManager = class extends Service {
       if (behaviorId === "pluginDevice") continue;
       const behaviorEvents = allEvents[behaviorId];
       if (!behaviorEvents || typeof behaviorEvents !== "object") continue;
-      for (const eventName of Object.keys(behaviorEvents)) {
-        if (!eventName.endsWith("$Changed")) 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);
@@ -175910,8 +176999,8 @@ var BridgeEndpointManager = class extends Service {
   async isolateEntity(entityName) {
     const endpoints = this.root.parts.map((p) => p);
     const endpoint = endpoints.find(
-      (e) => e.id === entityName || e.entityId === entityName
-    );
+      (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`
@@ -175923,6 +177012,17 @@ var BridgeEndpointManager = class extends Service {
       }
       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.delete();
+          } catch (e) {
+            this.log.warn(`Failed to remove area switch ${sw.id}:`, e);
+          }
+        }
+      }
     }
   }
   // refreshDevices only runs on registry-fingerprint changes, which may not
@@ -176008,7 +177108,7 @@ var BridgeEndpointManager = class extends Service {
   async refreshDevices() {
     this.registry.refresh();
     this._failedEntities = [];
-    const endpoints = this.root.parts.map((p) => p);
+    const endpoints = this.root.parts.map((p) => p).filter((p) => !(p instanceof VacuumAreaSwitchEndpoint));
     this.entityIds = this.registry.entityIds;
     if (this.registry.isAutoComposedDevicesEnabled()) {
       for (const eid of this.entityIds) {
@@ -176071,6 +177171,19 @@ var BridgeEndpointManager = class extends Service {
       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);
+      }
+    }
     const existingEndpoints = [];
     const now = Date.now();
     for (const endpoint of endpoints) {
@@ -176230,10 +177343,117 @@ var BridgeEndpointManager = class extends Service {
         }
       }
     }
+    await this.reconcileAreaSwitches();
     if (this.unsubscribe) {
       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
+        );
+        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) {
+          this.log.warn(
+            `Skipping area switch ${switchId} for ${entityId}: id taken by entity ${holder.entityId}`
+          );
+          continue;
+        }
+        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;
@@ -176349,7 +177569,7 @@ var BridgeEndpointManager = class extends Service {
 init_dist();
 init_esm();
 init_send_ha_message();
-import { callService as callService2 } from "home-assistant-js-websocket";
+import { callService as callService3 } from "home-assistant-js-websocket";
 import { keys as keys2, pickBy, values as values3 } from "lodash-es";
 var BridgeRegistry = class _BridgeRegistry {
   constructor(registry3, dataProvider, client) {
@@ -176735,7 +177955,7 @@ var BridgeRegistry = class _BridgeRegistry {
   async resolveRoborockRooms(entityId) {
     if (!this.client) return [];
     try {
-      const raw = await callService2(
+      const raw = await callService3(
         this.client.connection,
         "roborock",
         "get_maps",