@riddix/hamh 2.1.0-alpha.738 → 2.1.0-alpha.740

package/dist/backend/cli.js

@@ -1762,8 +1762,8 @@ var init_Cancelable = __esm({
         };
         return result;
       }
-      static set logger(logger233) {
-        this.#logger = logger233;
+      static set logger(logger234) {
+        this.#logger = logger234;
       }
       static get logger() {
         return this.#logger;
@@ -3454,13 +3454,13 @@ var init_Logger = __esm({
        *
        * @deprecated use {@link destinations}
        */
-      static addLogger(identifier, logger233, options) {
+      static addLogger(identifier, logger234, options) {
         if (identifier in this.destinations) {
           throw new ImplementationError(`Logger "${identifier}" already exists`);
         }
         const dest = LogDestination({ name: identifier });
         const legacy = adaptDestinationToLegacy(dest);
-        legacy.log = logger233;
+        legacy.log = logger234;
         if (options?.defaultLogLevel !== void 0) {
           legacy.defaultLogLevel = options.defaultLogLevel;
         }
@@ -5652,8 +5652,8 @@ var init_Construction = __esm({
           }
         }
         #unhandledError(...args) {
-          const logger233 = Logger.get(this.#subject.constructor.name);
-          logger233.error(...args);
+          const logger234 = Logger.get(this.#subject.constructor.name);
+          logger234.error(...args);
         }
         #createErrorHandler(name) {
           return (e) => {
@@ -62166,8 +62166,8 @@ var init_NodeSession = __esm({
         return session?.type === SessionType.Unicast;
       }
       NodeSession2.is = is;
-      function logNew(logger233, operation, session, messenger, fabric, peerNodeId) {
-        logger233.info(
+      function logNew(logger234, operation, session, messenger, fabric, peerNodeId) {
+        logger234.info(
           session.via,
           `${operation} session with`,
           Diagnostic.strong(PeerAddress({ fabricIndex: fabric.fabricIndex, nodeId: peerNodeId }).toString()),
@@ -111400,11 +111400,11 @@ var init_Api = __esm({
       }
       Api2.resourceFor = resourceFor;
       function log(level, facility, id, ...message) {
-        let logger233 = loggers.get(facility);
-        if (!logger233) {
-          loggers.set(facility, logger233 = Logger.get(facility));
+        let logger234 = loggers.get(facility);
+        if (!logger234) {
+          loggers.set(facility, logger234 = Logger.get(facility));
         }
-        logger233[level](Diagnostic.via(id || "(anon)"), message);
+        logger234[level](Diagnostic.via(id || "(anon)"), message);
       }
       Api2.log = log;
       function logRequest(facility, id, method, target) {
@@ -124074,7 +124074,6 @@ var init_binary_sensor = __esm({
       BinarySensorDeviceClass2["Power"] = "power";
       BinarySensorDeviceClass2["Presence"] = "presence";
       BinarySensorDeviceClass2["Problem"] = "problem";
-      BinarySensorDeviceClass2["Rain"] = "rain";
       BinarySensorDeviceClass2["Running"] = "running";
       BinarySensorDeviceClass2["Safety"] = "safety";
       BinarySensorDeviceClass2["Smoke"] = "smoke";
@@ -124190,6 +124189,26 @@ var init_humidifer = __esm({
   }
 });
 
+// ../common/dist/domains/lawn-mower.js
+var LawnMowerActivity, LawnMowerEntityFeature;
+var init_lawn_mower = __esm({
+  "../common/dist/domains/lawn-mower.js"() {
+    "use strict";
+    (function(LawnMowerActivity2) {
+      LawnMowerActivity2["error"] = "error";
+      LawnMowerActivity2["paused"] = "paused";
+      LawnMowerActivity2["mowing"] = "mowing";
+      LawnMowerActivity2["docked"] = "docked";
+      LawnMowerActivity2["returning"] = "returning";
+    })(LawnMowerActivity || (LawnMowerActivity = {}));
+    (function(LawnMowerEntityFeature2) {
+      LawnMowerEntityFeature2[LawnMowerEntityFeature2["START_MOWING"] = 1] = "START_MOWING";
+      LawnMowerEntityFeature2[LawnMowerEntityFeature2["PAUSE"] = 2] = "PAUSE";
+      LawnMowerEntityFeature2[LawnMowerEntityFeature2["DOCK"] = 4] = "DOCK";
+    })(LawnMowerEntityFeature || (LawnMowerEntityFeature = {}));
+  }
+});
+
 // ../common/dist/domains/light.js
 var LightDeviceColorMode;
 var init_light = __esm({
@@ -124406,6 +124425,7 @@ var init_domains = __esm({
     init_event2();
     init_fan();
     init_humidifer();
+    init_lawn_mower();
     init_light();
     init_lock();
     init_media_player();
@@ -124462,6 +124482,7 @@ var init_home_assistant_domain = __esm({
       HomeAssistantDomain2["input_boolean"] = "input_boolean";
       HomeAssistantDomain2["input_button"] = "input_button";
       HomeAssistantDomain2["input_select"] = "input_select";
+      HomeAssistantDomain2["lawn_mower"] = "lawn_mower";
       HomeAssistantDomain2["light"] = "light";
       HomeAssistantDomain2["lock"] = "lock";
       HomeAssistantDomain2["media_player"] = "media_player";
@@ -125292,10 +125313,10 @@ var init_home_assistant_actions = __esm({
       circuitBreakerResetMs: 3e4
     };
     HomeAssistantActions = class extends Service {
-      constructor(logger233, client, config11) {
+      constructor(logger234, client, config11) {
         super("HomeAssistantActions");
         this.client = client;
-        this.log = logger233.get(this);
+        this.log = logger234.get(this);
         this.config = { ...defaultConfig, ...config11 };
         this.circuitBreaker = new CircuitBreaker(
           this.config.circuitBreakerThreshold,
@@ -125635,10 +125656,10 @@ var DiagnosticService = class {
 };
 
 // src/api/access-log.ts
-function accessLogger(logger233) {
+function accessLogger(logger234) {
   return (req, res, next) => {
     res.on("finish", () => {
-      logger233.debug(
+      logger234.debug(
         `${req.method} ${decodeURI(req.originalUrl)} ${res.statusCode} ${res.statusMessage} from ${req.socket.remoteAddress}`
       );
     });
@@ -129518,7 +129539,7 @@ var WebSocketApi = class {
 
 // src/api/web-api.ts
 var WebApi = class extends Service {
-  constructor(logger233, bridgeService, haClient, haRegistry, bridgeStorage, mappingStorage, lockCredentialStorage, settingsStorage, backupService, props) {
+  constructor(logger234, bridgeService, haClient, haRegistry, bridgeStorage, mappingStorage, lockCredentialStorage, settingsStorage, backupService, props) {
     super("WebApi");
     this.bridgeService = bridgeService;
     this.haClient = haClient;
@@ -129529,8 +129550,8 @@ var WebApi = class extends Service {
     this.settingsStorage = settingsStorage;
     this.backupService = backupService;
     this.props = props;
-    this.logger = logger233;
-    this.log = logger233.get(this);
+    this.logger = logger234;
+    this.log = logger234.get(this);
     this.accessLogger = accessLogger(this.log.createChild("Access Log"));
     this.startTime = Date.now();
     this.wsApi = new WebSocketApi(
@@ -130621,10 +130642,10 @@ function isTransientConnectError(reason) {
   return msg.includes("socket hang up") || msg.includes("tls") || msg.includes("TLS");
 }
 var HomeAssistantClient = class extends Service {
-  constructor(logger233, options) {
+  constructor(logger234, options) {
     super("HomeAssistantClient");
     this.options = options;
-    this.log = logger233.get(this);
+    this.log = logger234.get(this);
   }
   options;
   static Options = /* @__PURE__ */ Symbol.for("HomeAssistantClientProps");
@@ -139320,10 +139341,10 @@ var UnsupportedModeError = class extends ImplementationError {
 };
 var ModeUtils;
 ((ModeUtils2) => {
-  function assertSupportedModes(supportedModes) {
+  function assertSupportedModes(supportedModes2) {
     const labels = /* @__PURE__ */ new Set();
     const modes = /* @__PURE__ */ new Set();
-    for (const { mode, label } of supportedModes) {
+    for (const { mode, label } of supportedModes2) {
       if (labels.has(label)) {
         throw new ImplementationError(`Duplicate label in supportedModes: ${label}`);
       }
@@ -139335,18 +139356,18 @@ var ModeUtils;
     }
   }
   ModeUtils2.assertSupportedModes = assertSupportedModes;
-  function assertMode(supportedModes, newMode) {
-    if (!supportedModes.some(({ mode }) => mode === newMode)) {
+  function assertMode(supportedModes2, newMode) {
+    if (!supportedModes2.some(({ mode }) => mode === newMode)) {
       throw new UnsupportedModeError(
-        `Can not use unsupported mode: ${newMode}. Allowed modes are ${supportedModes.map(({ mode }) => mode).join(", ")}`
+        `Can not use unsupported mode: ${newMode}. Allowed modes are ${supportedModes2.map(({ mode }) => mode).join(", ")}`
       );
     }
   }
   ModeUtils2.assertMode = assertMode;
-  function assertModeChange(supportedModes, currentMode, newMode) {
+  function assertModeChange(supportedModes2, currentMode, newMode) {
     if (currentMode !== newMode) {
       try {
-        assertMode(supportedModes, newMode);
+        assertMode(supportedModes2, newMode);
       } catch (error) {
         UnsupportedModeError.accept(error);
         return {
@@ -148167,10 +148188,10 @@ function seedExistingSessionStarts(startedAt, sessions, now = Date.now()) {
 var AUTO_FORCE_SYNC_INTERVAL_MS = 9e4;
 var DEAD_SESSION_TIMEOUT_MS = 6e4;
 var Bridge = class {
-  constructor(env, logger233, dataProvider, endpointManager) {
+  constructor(env, logger234, dataProvider, endpointManager) {
     this.dataProvider = dataProvider;
     this.endpointManager = endpointManager;
-    this.log = logger233.get(`Bridge / ${dataProvider.id}`);
+    this.log = logger234.get(`Bridge / ${dataProvider.id}`);
     this.server = new BridgeServerNode(
       env,
       this.dataProvider,
@@ -153169,8 +153190,7 @@ var deviceClasses = {
   [BinarySensorDeviceClass.Occupancy]: OccupancySensorType,
   [BinarySensorDeviceClass.Presence]: OccupancySensorType,
   [BinarySensorDeviceClass.Smoke]: SmokeAlarmType,
-  [BinarySensorDeviceClass.Moisture]: DetectorContactSensorType,
-  [BinarySensorDeviceClass.Rain]: DetectorContactSensorType
+  [BinarySensorDeviceClass.Moisture]: DetectorContactSensorType
 };
 var batteryTypes = /* @__PURE__ */ new Map([
   [ContactSensorType, ContactSensorWithBatteryType],
@@ -154410,6 +154430,771 @@ function InputButtonDevice(homeAssistantEntity) {
   return InputButtonEndpointType.set({ homeAssistantEntity });
 }
 
+// src/matter/endpoints/legacy/lawn-mower/index.ts
+init_home_assistant_entity_behavior();
+
+// src/matter/endpoints/legacy/lawn-mower/behaviors/lawn-mower-rvc-operational-state-server.ts
+init_dist();
+init_esm();
+init_home_assistant_entity_behavior();
+
+// src/matter/behaviors/rvc-operational-state-server.ts
+init_esm();
+
+// ../../node_modules/.pnpm/@matter+main@0.17.2/node_modules/@matter/main/dist/esm/forwards/behaviors/rvc-operational-state.js
+init_nodejs();
+
+// ../../node_modules/.pnpm/@matter+main@0.17.2/node_modules/@matter/main/dist/esm/forwards/clusters/rvc-operational-state.js
+init_nodejs();
+
+// src/matter/behaviors/rvc-operational-state-server.ts
+init_home_assistant_entity_behavior();
+var OperationalState4 = RvcOperationalState4.OperationalState;
+var ErrorState = RvcOperationalState4.ErrorState;
+var logger209 = Logger.get("RvcOperationalStateServer");
+var activeStates = /* @__PURE__ */ new Set([
+  OperationalState4.Running,
+  OperationalState4.SeekingCharger
+]);
+var advertisedOperationalStates = [
+  OperationalState4.Stopped,
+  OperationalState4.Running,
+  OperationalState4.Paused,
+  OperationalState4.Error,
+  OperationalState4.SeekingCharger,
+  OperationalState4.Charging,
+  OperationalState4.Docked
+];
+function makeRvcOperationalError(errorStateId) {
+  if (errorStateId === ErrorState.NoError) {
+    return { errorStateId };
+  }
+  return { errorStateId, errorStateDetails: ErrorState[errorStateId] };
+}
+var RvcOperationalStateServerBase = class extends RvcOperationalStateServer {
+  async initialize() {
+    this.state.operationalStateList = advertisedOperationalStates.map((id) => ({
+      operationalStateId: id
+    }));
+    this.state.operationalState = OperationalState4.Stopped;
+    this.state.operationalError = { errorStateId: ErrorState.NoError };
+    await super.initialize();
+    const homeAssistant = await this.agent.load(HomeAssistantEntityBehavior);
+    this.update(homeAssistant.entity);
+    this.reactTo(homeAssistant.onChange, this.update, { offline: true });
+  }
+  update(entity) {
+    if (!entity.state || !entity.state.attributes) {
+      return;
+    }
+    const newState = this.state.config.getOperationalState(
+      entity.state,
+      this.agent
+    );
+    const previousState = this.state.operationalState;
+    const errorStateId = newState === OperationalState4.Error ? ErrorState.Stuck : ErrorState.NoError;
+    const operationalError = makeRvcOperationalError(errorStateId);
+    applyPatchState(
+      this.state,
+      {
+        operationalState: newState,
+        operationalError
+      },
+      { force: true }
+    );
+    if (activeStates.has(previousState) && !activeStates.has(newState)) {
+      logger209.info(
+        `Operation completed: ${OperationalState4[previousState]} -> ${OperationalState4[newState]}`
+      );
+      try {
+        this.events.operationCompletion?.emit(
+          {
+            completionErrorCode: newState === OperationalState4.Error ? ErrorState.Stuck : ErrorState.NoError,
+            totalOperationalTime: null,
+            pausedTime: null
+          },
+          this.context
+        );
+      } catch (e) {
+        logger209.debug("Failed to emit operationCompletion event:", e);
+      }
+    }
+  }
+  pause() {
+    const homeAssistant = this.agent.get(HomeAssistantEntityBehavior);
+    homeAssistant.callAction(this.state.config.pause(void 0, this.agent));
+    return {
+      commandResponseState: {
+        errorStateId: ErrorState.NoError
+      }
+    };
+  }
+  resume() {
+    const homeAssistant = this.agent.get(HomeAssistantEntityBehavior);
+    homeAssistant.callAction(this.state.config.resume(void 0, this.agent));
+    return {
+      commandResponseState: {
+        errorStateId: ErrorState.NoError
+      }
+    };
+  }
+  goHome() {
+    if (this.state.operationalState === OperationalState4.Docked || this.state.operationalState === OperationalState4.Charging) {
+      return {
+        commandResponseState: {
+          errorStateId: ErrorState.NoError
+        }
+      };
+    }
+    const goHomeAction = this.state.config.goHome;
+    if (goHomeAction) {
+      const homeAssistant = this.agent.get(HomeAssistantEntityBehavior);
+      homeAssistant.callAction(goHomeAction(void 0, this.agent));
+    } else {
+      logger209.warn("GoHome command received but no goHome action configured");
+    }
+    return {
+      commandResponseState: {
+        errorStateId: ErrorState.NoError
+      }
+    };
+  }
+};
+((RvcOperationalStateServerBase2) => {
+  class State extends RvcOperationalStateServer.State {
+    config;
+  }
+  RvcOperationalStateServerBase2.State = State;
+})(RvcOperationalStateServerBase || (RvcOperationalStateServerBase = {}));
+function RvcOperationalStateServer2(config11) {
+  return RvcOperationalStateServerBase.set({ config: config11 });
+}
+
+// src/matter/endpoints/legacy/lawn-mower/behaviors/lawn-mower-rvc-operational-state-server.ts
+var logger210 = Logger.get("LawnMowerRvcOperationalStateServer");
+function mapLawnMowerOperationalState(entity) {
+  const state = entity.state;
+  switch (state) {
+    case LawnMowerActivity.mowing:
+      return RvcOperationalState4.OperationalState.Running;
+    case LawnMowerActivity.returning:
+      return RvcOperationalState4.OperationalState.SeekingCharger;
+    case LawnMowerActivity.docked:
+      return RvcOperationalState4.OperationalState.Docked;
+    case LawnMowerActivity.paused:
+      return RvcOperationalState4.OperationalState.Paused;
+    case LawnMowerActivity.error:
+    case "unavailable":
+      return RvcOperationalState4.OperationalState.Error;
+    default:
+      logger210.info(`Unknown lawn_mower state "${state}", treating as Stopped`);
+      return RvcOperationalState4.OperationalState.Stopped;
+  }
+}
+var LawnMowerRvcOperationalStateServer = RvcOperationalStateServer2({
+  getOperationalState: (entity) => mapLawnMowerOperationalState(entity),
+  // Pause requires the PAUSE feature; mowers without it can only be docked.
+  pause: (_, agent) => {
+    const features3 = agent.get(HomeAssistantEntityBehavior).entity.state.attributes.supported_features ?? 0;
+    if (testBit(features3, LawnMowerEntityFeature.PAUSE)) {
+      return { action: "lawn_mower.pause" };
+    }
+    return { action: "lawn_mower.dock" };
+  },
+  resume: () => ({ action: "lawn_mower.start_mowing" }),
+  goHome: () => ({ action: "lawn_mower.dock" })
+});
+
+// src/matter/endpoints/legacy/lawn-mower/behaviors/lawn-mower-rvc-run-mode-server.ts
+init_dist();
+init_home_assistant_entity_behavior();
+
+// src/matter/behaviors/rvc-run-mode-server.ts
+init_esm();
+
+// ../../node_modules/.pnpm/@matter+main@0.17.2/node_modules/@matter/main/dist/esm/forwards/clusters/mode-base.js
+init_nodejs();
+
+// ../../node_modules/.pnpm/@matter+main@0.17.2/node_modules/@matter/main/dist/esm/forwards/clusters/rvc-run-mode.js
+init_nodejs();
+
+// src/matter/behaviors/rvc-run-mode-server.ts
+init_home_assistant_entity_behavior();
+
+// src/matter/behaviors/infer-cleaned-area-progress.ts
+function inferCleanedAreaProgress(cleanedSqm, orderedAreas) {
+  if (orderedAreas.length === 0) {
+    return { currentArea: null, completed: [] };
+  }
+  const cleaned = Number.isFinite(cleanedSqm) ? Math.max(0, cleanedSqm) : 0;
+  let cumulative = 0;
+  const completed = [];
+  for (const area of orderedAreas) {
+    const size = Number.isFinite(area.sizeSqm) ? Math.max(0, area.sizeSqm) : 0;
+    cumulative += size;
+    if (cleaned < cumulative) {
+      return { currentArea: area.areaId, completed };
+    }
+    completed.push(area.areaId);
+  }
+  return { currentArea: null, completed };
+}
+
+// src/matter/behaviors/rvc-run-mode-server.ts
+var logger211 = Logger.get("RvcRunModeServer");
+var ROOM_MODE_BASE = 100;
+function isRoomMode(mode) {
+  return mode >= ROOM_MODE_BASE;
+}
+var cleaningSessions = /* @__PURE__ */ new WeakMap();
+function getSession(endpoint) {
+  let session = cleaningSessions.get(endpoint);
+  if (!session) {
+    session = {
+      completedAreas: /* @__PURE__ */ new Set(),
+      lastCurrentArea: null,
+      activeAreas: [],
+      loggedShortCircuits: /* @__PURE__ */ new Set(),
+      observedCleaning: false,
+      pendingDispatches: [],
+      cleanedAreaBaseline: null
+    };
+    cleaningSessions.set(endpoint, session);
+  }
+  return session;
+}
+var RvcRunModeServerBase = class extends RvcRunModeServer {
+  async initialize() {
+    await super.initialize();
+    const homeAssistant = await this.agent.load(HomeAssistantEntityBehavior);
+    this.update(homeAssistant.entity);
+    this.reactTo(homeAssistant.onChange, this.update, { offline: true });
+  }
+  update(entity) {
+    if (!entity.state || !entity.state.attributes) {
+      return;
+    }
+    const s = getSession(this.endpoint);
+    const previousMode = this.state.currentMode;
+    const newMode = this.state.config.getCurrentMode(entity.state, this.agent);
+    applyPatchState(
+      this.state,
+      {
+        currentMode: newMode,
+        supportedModes: this.state.config.getSupportedModes(
+          entity.state,
+          this.agent
+        )
+      },
+      { force: true }
+    );
+    if (newMode === 1 /* Cleaning */) {
+      s.observedCleaning = true;
+    }
+    if (previousMode !== newMode) {
+      if (newMode === 0 /* Idle */) {
+        if (s.lastCurrentArea !== null) {
+          s.completedAreas.add(s.lastCurrentArea);
+          s.lastCurrentArea = null;
+        }
+        if (s.pendingDispatches.length > 0 && s.observedCleaning) {
+          try {
+            const serviceArea = this.agent.get(ServiceAreaBehavior);
+            const prev = serviceArea.state.currentArea;
+            if (typeof prev === "number") {
+              s.completedAreas.add(prev);
+            }
+            const next = s.pendingDispatches.shift();
+            if (next) {
+              const homeAssistant = this.agent.get(HomeAssistantEntityBehavior);
+              homeAssistant.callAction(next.action);
+              this.trySetCurrentArea(next.areaId);
+            }
+          } catch {
+          }
+          s.loggedShortCircuits.clear();
+          return;
+        }
+        if (s.observedCleaning) {
+          try {
+            const serviceArea = this.agent.get(ServiceAreaBehavior);
+            const last = serviceArea.state.currentArea;
+            if (typeof last === "number") {
+              s.completedAreas.add(last);
+              serviceArea.state.currentArea = null;
+            }
+            this.updateProgressFromTracking(serviceArea);
+          } catch {
+          }
+          s.observedCleaning = false;
+        }
+        s.loggedShortCircuits.clear();
+      } else if (newMode === 1 /* Cleaning */) {
+        if (s.activeAreas.length > 0 && s.lastCurrentArea === null) {
+          const firstPending = s.activeAreas.find(
+            (id) => !s.completedAreas.has(id)
+          );
+          if (firstPending !== void 0) {
+            this.trySetCurrentArea(firstPending);
+          }
+        }
+      }
+    }
+    if (newMode === 0 /* Idle */ && s.activeAreas.length === 0) {
+      try {
+        const serviceArea = this.agent.get(ServiceAreaBehavior);
+        if (serviceArea.state.currentArea !== null) {
+          serviceArea.state.currentArea = null;
+        }
+      } catch {
+      }
+    }
+    if (newMode === 1 /* Cleaning */) {
+      const mapping = this.agent.get(HomeAssistantEntityBehavior).state.mapping;
+      if (mapping?.currentRoomEntity) {
+        this.updateCurrentRoomFromSensor();
+      } else if (mapping?.cleanedAreaEntity) {
+        this.updateCurrentRoomFromCleanedArea();
+      }
+    }
+  }
+  /**
+   * Emit a diagnostic INFO log exactly once per cleaning session for a
+   * given short-circuit reason. Prevents log flooding while still
+   * surfacing the silent paths that would otherwise be invisible.
+   */
+  logShortCircuitOnce(reason, message) {
+    const s = getSession(this.endpoint);
+    if (s.loggedShortCircuits.has(reason)) return;
+    s.loggedShortCircuits.add(reason);
+    logger211.info(message);
+  }
+  /**
+   * Read the currentRoomEntity sensor and update currentArea + progress
+   * to reflect which room the vacuum is actually in right now.
+   */
+  updateCurrentRoomFromSensor() {
+    try {
+      const s = getSession(this.endpoint);
+      const homeAssistant = this.agent.get(HomeAssistantEntityBehavior);
+      const currentRoomEntityId = homeAssistant.state.mapping?.currentRoomEntity;
+      if (!currentRoomEntityId) {
+        this.logShortCircuitOnce(
+          "no-mapping",
+          "currentRoom sensor: no currentRoomEntity in mapping, auto-detect did not run or sensor not on same HA device"
+        );
+        return;
+      }
+      const stateProvider = this.agent.env.get(EntityStateProvider);
+      const roomState = stateProvider.getState(currentRoomEntityId);
+      if (!roomState || !roomState.state) {
+        this.logShortCircuitOnce(
+          "no-state",
+          `currentRoom sensor: no state available for ${currentRoomEntityId}`
+        );
+        return;
+      }
+      const serviceArea = this.agent.get(ServiceAreaBehavior);
+      const externalSession = s.activeAreas.length === 0;
+      const supportedAreaIds = serviceArea.state.supportedAreas.map(
+        (a) => a.areaId
+      );
+      const isAllowedArea = (id) => externalSession ? supportedAreaIds.includes(id) : s.activeAreas.includes(id);
+      const sensorAttrs = roomState.attributes;
+      const segmentId = sensorAttrs.segment_id ?? sensorAttrs.room_id;
+      const roomName = roomState.state;
+      let matchedAreaId = null;
+      if (segmentId != null && isAllowedArea(segmentId)) {
+        matchedAreaId = segmentId;
+      }
+      if (matchedAreaId === null && segmentId != null) {
+        for (const area of serviceArea.state.supportedAreas) {
+          if (isAllowedArea(area.areaId) && area.areaId % 1e4 === segmentId) {
+            matchedAreaId = area.areaId;
+            break;
+          }
+        }
+      }
+      if (matchedAreaId === null && roomName) {
+        const area = serviceArea.state.supportedAreas.find(
+          (a) => a.areaInfo.locationInfo?.locationName?.toLowerCase() === roomName.toLowerCase()
+        );
+        if (area && isAllowedArea(area.areaId)) {
+          matchedAreaId = area.areaId;
+        }
+      }
+      if (matchedAreaId === null) {
+        logger211.info(
+          `currentRoom sensor: no match for "${roomName}" (segmentId=${segmentId}), activeAreas=[${s.activeAreas.join(", ")}], supportedAreas=[${serviceArea.state.supportedAreas.map((a) => `${a.areaId}:${a.areaInfo.locationInfo?.locationName}`).join(", ")}]`
+        );
+        return;
+      }
+      if (matchedAreaId === s.lastCurrentArea) return;
+      if (s.lastCurrentArea !== null) {
+        s.completedAreas.add(s.lastCurrentArea);
+      }
+      s.lastCurrentArea = matchedAreaId;
+      logger211.info(
+        `currentRoom sensor: transition to area ${matchedAreaId} ("${roomName}"), completed: [${[...s.completedAreas].join(", ")}]`
+      );
+      this.trySetCurrentArea(matchedAreaId);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      if (!msg.includes("No provider for") && !msg.includes("not supported")) {
+        logger211.warn(`currentRoom sensor update failed: ${msg}`);
+      }
+    }
+  }
+  /** Read the cumulative cleaned-area sensor (m2), or null if not configured. */
+  readCleanedAreaSqm() {
+    try {
+      const mapping = this.agent.get(HomeAssistantEntityBehavior).state.mapping;
+      const entityId = mapping?.cleanedAreaEntity;
+      if (!entityId) {
+        return null;
+      }
+      return this.agent.env.get(EntityStateProvider).getNumericState(entityId);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * For batch vacuums that report cumulative cleaned area but not the current
+   * room, infer currentArea + progress from the cleaned area and the per-room
+   * sizeSqm. Display-only and batch-only; skipped unless every selected area
+   * has a size. The currentRoom sensor path takes priority (#368).
+   */
+  updateCurrentRoomFromCleanedArea() {
+    try {
+      const s = getSession(this.endpoint);
+      if (s.pendingDispatches.length > 0 || s.activeAreas.length === 0) {
+        return;
+      }
+      const mapping = this.agent.get(HomeAssistantEntityBehavior).state.mapping;
+      const entityId = mapping?.cleanedAreaEntity;
+      if (!entityId) {
+        return;
+      }
+      const raw = this.agent.env.get(EntityStateProvider).getNumericState(entityId);
+      if (raw == null) {
+        this.logShortCircuitOnce(
+          "no-cleaned-area-state",
+          `cleanedArea sensor: no numeric state for ${entityId}`
+        );
+        return;
+      }
+      const customAreas = mapping?.customServiceAreas;
+      const ordered = [];
+      for (const areaId of [...s.activeAreas].sort((a, b) => a - b)) {
+        const size = customAreas?.[areaId - 1]?.sizeSqm;
+        if (typeof size !== "number" || !Number.isFinite(size) || size <= 0) {
+          this.logShortCircuitOnce(
+            "no-sizes",
+            "cleanedArea sensor: not every selected area has a sizeSqm"
+          );
+          return;
+        }
+        ordered.push({ areaId, sizeSqm: size });
+      }
+      if (s.cleanedAreaBaseline == null || raw < s.cleanedAreaBaseline) {
+        s.cleanedAreaBaseline = raw;
+      }
+      const cleaned = Math.max(0, raw - s.cleanedAreaBaseline);
+      const { currentArea, completed } = inferCleanedAreaProgress(
+        cleaned,
+        ordered
+      );
+      logger211.debug(
+        `cleanedArea: raw=${raw} baseline=${s.cleanedAreaBaseline} cleaned=${cleaned} sizes=[${ordered.map((o) => `${o.areaId}:${o.sizeSqm}`).join(",")}] -> current=${currentArea} completed=[${completed.join(",")}]`
+      );
+      for (const id of completed) {
+        s.completedAreas.add(id);
+      }
+      if (currentArea === s.lastCurrentArea) {
+        return;
+      }
+      s.lastCurrentArea = currentArea;
+      this.trySetCurrentArea(currentArea);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      if (!msg.includes("No provider for") && !msg.includes("not supported")) {
+        logger211.warn(`cleanedArea room update failed: ${msg}`);
+      }
+    }
+  }
+  /**
+   * Safely update ServiceArea.currentArea and progress.
+   * When areaId is set, marks it as Operating in progress.
+   * When areaId is null (Idle), marks all Operating/Pending as Completed.
+   * No-op if ServiceArea is not available on this endpoint.
+   */
+  trySetCurrentArea(areaId) {
+    try {
+      const serviceArea = this.agent.get(ServiceAreaBehavior);
+      if (serviceArea.state.currentArea !== areaId) {
+        serviceArea.state.currentArea = areaId;
+        logger211.debug(`currentArea set to ${areaId}`);
+      }
+      this.updateProgress(serviceArea, areaId);
+    } catch {
+    }
+  }
+  /**
+   * Update progress entries to reflect the current operating area.
+   * - null: mark all areas as Completed (cleaning done)
+   * - areaId: mark that area as Operating, others as Pending
+   *
+   * Uses the activeAreas snapshot (plain number array) instead of
+   * managed state entries, which avoids infinite recursion in
+   * matter.js property getters during transaction pre-commit.
+   */
+  updateProgress(serviceArea, areaId) {
+    const s = getSession(this.endpoint);
+    if (s.activeAreas.length === 0) return;
+    const state = serviceArea.state;
+    if (areaId === null) {
+      state.progress = s.activeAreas.map((id) => ({
+        areaId: id,
+        status: ServiceArea3.OperationalStatus.Completed
+      }));
+    } else {
+      state.progress = s.activeAreas.map((id) => ({
+        areaId: id,
+        status: id === areaId ? ServiceArea3.OperationalStatus.Operating : s.completedAreas.has(id) ? ServiceArea3.OperationalStatus.Completed : ServiceArea3.OperationalStatus.Pending
+      }));
+    }
+  }
+  /**
+   * Update progress entries from tracking state without any area
+   * operating. Used on mid-session transitions (e.g. vacuum-then-mop
+   * tool swap) where the vacuum is temporarily idle but the session
+   * is not finished: completed areas stay Completed, remaining areas
+   * stay Pending.
+   */
+  updateProgressFromTracking(serviceArea) {
+    const s = getSession(this.endpoint);
+    if (s.activeAreas.length === 0) return;
+    const state = serviceArea.state;
+    state.progress = s.activeAreas.map((id) => ({
+      areaId: id,
+      status: s.completedAreas.has(id) ? ServiceArea3.OperationalStatus.Completed : ServiceArea3.OperationalStatus.Pending
+    }));
+  }
+  /**
+   * Stop before finishing: mark the areas the vacuum actually reached as
+   * Completed and the rest as Skipped (an out-of-band stop per the Matter
+   * ServiceArea spec), then clear currentArea. The old path marked every
+   * area Completed, which told Apple Home rooms were cleaned when they were
+   * not, so they got dropped from the next selection (#367).
+   */
+  finalizeProgressOnStop() {
+    const s = getSession(this.endpoint);
+    try {
+      const serviceArea = this.agent.get(ServiceAreaBehavior);
+      if (s.activeAreas.length > 0) {
+        const last = serviceArea.state.currentArea;
+        const state = serviceArea.state;
+        state.progress = s.activeAreas.map((id) => ({
+          areaId: id,
+          status: s.completedAreas.has(id) || id === last ? ServiceArea3.OperationalStatus.Completed : ServiceArea3.OperationalStatus.Skipped
+        }));
+      }
+      serviceArea.state.currentArea = null;
+    } catch {
+    }
+  }
+  /**
+   * Find the ServiceArea area ID that corresponds to a run mode value
+   * by matching the mode label to the area location name.
+   */
+  findAreaIdForMode(mode) {
+    try {
+      const serviceArea = this.agent.get(ServiceAreaBehavior);
+      const modeEntry = this.state.supportedModes.find((m) => m.mode === mode);
+      if (!modeEntry) return null;
+      const area = serviceArea.state.supportedAreas.find(
+        (a) => a.areaInfo.locationInfo?.locationName === modeEntry.label
+      );
+      return area?.areaId ?? null;
+    } catch {
+      return null;
+    }
+  }
+  changeToMode(request) {
+    const s = getSession(this.endpoint);
+    const homeAssistant = this.agent.get(HomeAssistantEntityBehavior);
+    const { newMode } = request;
+    if (newMode !== this.state.currentMode && !this.state.supportedModes.some((m) => m.mode === newMode)) {
+      return {
+        status: ModeBase3.ModeChangeStatus.UnsupportedMode,
+        statusText: `Unsupported mode: ${newMode}`
+      };
+    }
+    if (isRoomMode(newMode)) {
+      try {
+        const serviceArea = this.agent.get(ServiceAreaBehavior);
+        if (serviceArea.state.selectedAreas?.length > 0) {
+          s.activeAreas = [...serviceArea.state.selectedAreas];
+          s.completedAreas.clear();
+          s.lastCurrentArea = null;
+          s.loggedShortCircuits.clear();
+          s.pendingDispatches = [];
+          s.cleanedAreaBaseline = this.readCleanedAreaSqm();
+          this.trySetCurrentArea(s.activeAreas[0]);
+          homeAssistant.callAction(this.state.config.start(void 0, this.agent));
+          this.state.currentMode = newMode;
+          return {
+            status: ModeBase3.ModeChangeStatus.Success,
+            statusText: "Starting room cleaning"
+          };
+        }
+      } catch {
+      }
+      if (this.state.config.cleanRoom) {
+        const areaId = this.findAreaIdForMode(newMode);
+        s.activeAreas = areaId !== null ? [areaId] : [];
+        s.completedAreas.clear();
+        s.lastCurrentArea = null;
+        s.loggedShortCircuits.clear();
+        s.pendingDispatches = [];
+        this.trySetCurrentArea(areaId);
+        homeAssistant.callAction(
+          this.state.config.cleanRoom(newMode, this.agent)
+        );
+        this.state.currentMode = newMode;
+        return {
+          status: ModeBase3.ModeChangeStatus.Success,
+          statusText: "Starting room cleaning"
+        };
+      }
+    }
+    switch (newMode) {
+      case 1 /* Cleaning */: {
+        try {
+          const serviceArea = this.agent.get(ServiceAreaBehavior);
+          if (serviceArea.state.selectedAreas?.length > 0) {
+            s.activeAreas = [...serviceArea.state.selectedAreas];
+            s.completedAreas.clear();
+            s.lastCurrentArea = null;
+            s.loggedShortCircuits.clear();
+            s.pendingDispatches = [];
+            s.cleanedAreaBaseline = this.readCleanedAreaSqm();
+            this.trySetCurrentArea(s.activeAreas[0]);
+          }
+        } catch {
+        }
+        homeAssistant.callAction(this.state.config.start(void 0, this.agent));
+        break;
+      }
+      case 0 /* Idle */:
+        this.finalizeProgressOnStop();
+        s.completedAreas.clear();
+        s.lastCurrentArea = null;
+        s.activeAreas = [];
+        s.loggedShortCircuits.clear();
+        s.pendingDispatches = [];
+        s.observedCleaning = false;
+        s.cleanedAreaBaseline = null;
+        homeAssistant.callAction(
+          this.state.config.returnToBase(void 0, this.agent)
+        );
+        break;
+      default:
+        homeAssistant.callAction(this.state.config.pause(void 0, this.agent));
+        break;
+    }
+    this.state.currentMode = newMode;
+    return {
+      status: ModeBase3.ModeChangeStatus.Success,
+      statusText: "Mode switched"
+    };
+  }
+};
+((RvcRunModeServerBase2) => {
+  class State extends RvcRunModeServer.State {
+    config;
+  }
+  RvcRunModeServerBase2.State = State;
+})(RvcRunModeServerBase || (RvcRunModeServerBase = {}));
+function RvcRunModeServer2(config11, initialState) {
+  const defaultModes = [
+    {
+      label: "Idle",
+      mode: 0 /* Idle */,
+      modeTags: [{ value: RvcRunMode3.ModeTag.Idle }]
+    },
+    {
+      label: "Cleaning",
+      mode: 1 /* Cleaning */,
+      modeTags: [{ value: RvcRunMode3.ModeTag.Cleaning }]
+    }
+  ];
+  return RvcRunModeServerBase.set({
+    config: config11,
+    supportedModes: initialState?.supportedModes ?? defaultModes,
+    currentMode: initialState?.currentMode ?? 0 /* Idle */
+  });
+}
+
+// src/matter/endpoints/legacy/lawn-mower/behaviors/lawn-mower-rvc-run-mode-server.ts
+var supportedModes = [
+  {
+    label: "Idle",
+    mode: 0 /* Idle */,
+    modeTags: [{ value: RvcRunMode3.ModeTag.Idle }]
+  },
+  {
+    label: "Mowing",
+    mode: 1 /* Cleaning */,
+    modeTags: [{ value: RvcRunMode3.ModeTag.Cleaning }]
+  }
+];
+function mapLawnMowerRunMode(entity) {
+  const state = entity.state;
+  const active = state === LawnMowerActivity.mowing || state === LawnMowerActivity.paused;
+  return active ? 1 /* Cleaning */ : 0 /* Idle */;
+}
+function createLawnMowerRvcRunModeServer() {
+  return RvcRunModeServer2(
+    {
+      getCurrentMode: (entity) => mapLawnMowerRunMode(entity),
+      getSupportedModes: () => supportedModes,
+      start: () => ({ action: "lawn_mower.start_mowing" }),
+      returnToBase: () => ({ action: "lawn_mower.dock" }),
+      pause: (_, agent) => {
+        const features3 = agent.get(HomeAssistantEntityBehavior).entity.state.attributes.supported_features ?? 0;
+        if (testBit(features3, LawnMowerEntityFeature.PAUSE)) {
+          return { action: "lawn_mower.pause" };
+        }
+        return { action: "lawn_mower.dock" };
+      }
+    },
+    { supportedModes, currentMode: 0 /* Idle */ }
+  );
+}
+
+// src/matter/endpoints/legacy/lawn-mower/index.ts
+var LawnMowerEndpointType = RoboticVacuumCleanerDevice.with(
+  BasicInformationServer2,
+  IdentifyServer2,
+  HomeAssistantEntityBehavior,
+  LawnMowerRvcOperationalStateServer
+);
+function LawnMowerDevice(homeAssistantEntity) {
+  if (homeAssistantEntity.entity.state === void 0) {
+    return void 0;
+  }
+  const attributes8 = homeAssistantEntity.entity.state.attributes;
+  let device = LawnMowerEndpointType.with(
+    createLawnMowerRvcRunModeServer()
+  ).set({ homeAssistantEntity });
+  const hasBattery = homeAssistantEntity.mapping?.batteryEntity != null || attributes8.battery_level != null || attributes8.battery != null;
+  if (hasBattery) {
+    device = device.with(DefaultPowerSourceServer);
+  }
+  return device;
+}
+
 // src/matter/endpoints/legacy/light/devices/color-temperature-light.ts
 init_home_assistant_entity_behavior();
 
@@ -154425,7 +155210,7 @@ init_nodejs();
 
 // src/matter/behaviors/color-control-server.ts
 init_home_assistant_entity_behavior();
-var logger209 = Logger.get("ColorControlServer");
+var logger212 = Logger.get("ColorControlServer");
 var optimisticColorState = /* @__PURE__ */ new Map();
 var OPTIMISTIC_TIMEOUT_MS3 = 3e3;
 var OPTIMISTIC_TOLERANCE2 = 5;
@@ -154464,7 +155249,7 @@ var ColorControlServerBase = class extends FeaturedBase7 {
       if (this.state.startUpColorTemperatureMireds == null) {
         this.state.startUpColorTemperatureMireds = defaultMireds;
       }
-      logger209.debug(
+      logger212.debug(
         `initialize: set ColorTemperature defaults - min=${this.state.colorTempPhysicalMinMireds}, max=${this.state.colorTempPhysicalMaxMireds}, current=${this.state.colorTemperatureMireds}`
       );
     }
@@ -154965,7 +155750,7 @@ init_home_assistant_entity_behavior();
 // src/matter/behaviors/lock-server.ts
 init_esm();
 init_home_assistant_entity_behavior();
-var logger210 = Logger.get("LockServer");
+var logger213 = Logger.get("LockServer");
 var SUPPORTED_SLOT = 1;
 function normalizeSupportedIndex(index) {
   if (index === 0 || index === SUPPORTED_SLOT) {
@@ -155236,7 +156021,7 @@ var LockServerWithPinBase = class extends PinCredentialBase {
     const homeAssistant = this.agent.get(HomeAssistantEntityBehavior);
     const action = this.state.config.lock(void 0, this.agent);
     const hasPinProvided = !!request.pinCode;
-    logger210.debug(
+    logger213.debug(
       `lockDoor called for ${homeAssistant.entityId}, PIN provided: ${hasPinProvided}`
     );
     if (request.pinCode) {
@@ -155249,12 +156034,12 @@ var LockServerWithPinBase = class extends PinCredentialBase {
     const homeAssistant = this.agent.get(HomeAssistantEntityBehavior);
     const action = this.state.config.unlock(void 0, this.agent);
     const hasPinProvided = !!request.pinCode;
-    logger210.debug(
+    logger213.debug(
       `unlockDoor called for ${homeAssistant.entityId}, PIN provided: ${hasPinProvided}, requirePin: ${this.state.requirePinForRemoteOperation}`
     );
     if (this.state.requirePinForRemoteOperation) {
       if (!request.pinCode) {
-        logger210.info(
+        logger213.info(
           `unlockDoor REJECTED for ${homeAssistant.entityId} - no PIN provided`
         );
         throw new StatusResponseError(
@@ -155264,12 +156049,12 @@ var LockServerWithPinBase = class extends PinCredentialBase {
       }
       const providedPin = new TextDecoder().decode(request.pinCode);
       if (!verifyStoredPinHelper(this.env, homeAssistant.entityId, providedPin)) {
-        logger210.info(
+        logger213.info(
           `unlockDoor REJECTED for ${homeAssistant.entityId} - invalid PIN`
         );
         throw new StatusResponseError("Invalid PIN code", StatusCode.Failure);
       }
-      logger210.debug(`unlockDoor PIN verified for ${homeAssistant.entityId}`);
+      logger213.debug(`unlockDoor PIN verified for ${homeAssistant.entityId}`);
       action.data = { ...action.data, code: providedPin };
     }
     homeAssistant.callAction(action);
@@ -155402,7 +156187,7 @@ var LockServerWithPinAndUnboltBase = class extends PinCredentialUnboltBase {
     const homeAssistant = this.agent.get(HomeAssistantEntityBehavior);
     const action = this.state.config.lock(void 0, this.agent);
     const hasPinProvided = !!request.pinCode;
-    logger210.debug(
+    logger213.debug(
       `lockDoor called for ${homeAssistant.entityId}, PIN provided: ${hasPinProvided}`
     );
     if (request.pinCode) {
@@ -155416,12 +156201,12 @@ var LockServerWithPinAndUnboltBase = class extends PinCredentialUnboltBase {
     const unlatchConfig = this.state.config.unlatch;
     const action = unlatchConfig ? unlatchConfig(void 0, this.agent) : this.state.config.unlock(void 0, this.agent);
     const hasPinProvided = !!request.pinCode;
-    logger210.debug(
+    logger213.debug(
       `unlockDoor called for ${homeAssistant.entityId}, PIN provided: ${hasPinProvided}, requirePin: ${this.state.requirePinForRemoteOperation}, usingUnlatch: ${!!unlatchConfig}`
     );
     if (this.state.requirePinForRemoteOperation) {
       if (!request.pinCode) {
-        logger210.info(
+        logger213.info(
           `unlockDoor REJECTED for ${homeAssistant.entityId} - no PIN provided`
         );
         throw new StatusResponseError(
@@ -155431,12 +156216,12 @@ var LockServerWithPinAndUnboltBase = class extends PinCredentialUnboltBase {
       }
       const providedPin = new TextDecoder().decode(request.pinCode);
       if (!verifyStoredPinHelper(this.env, homeAssistant.entityId, providedPin)) {
-        logger210.info(
+        logger213.info(
           `unlockDoor REJECTED for ${homeAssistant.entityId} - invalid PIN`
         );
         throw new StatusResponseError("Invalid PIN code", StatusCode.Failure);
       }
-      logger210.debug(`unlockDoor PIN verified for ${homeAssistant.entityId}`);
+      logger213.debug(`unlockDoor PIN verified for ${homeAssistant.entityId}`);
       action.data = { ...action.data, code: providedPin };
     }
     homeAssistant.callAction(action);
@@ -155451,12 +156236,12 @@ var LockServerWithPinAndUnboltBase = class extends PinCredentialUnboltBase {
     }
     const action = unlatchConfig(void 0, this.agent);
     const hasPinProvided = !!request.pinCode;
-    logger210.debug(
+    logger213.debug(
       `unboltDoor called for ${homeAssistant.entityId}, PIN provided: ${hasPinProvided}, requirePin: ${this.state.requirePinForRemoteOperation}`
     );
     if (this.state.requirePinForRemoteOperation) {
       if (!request.pinCode) {
-        logger210.info(
+        logger213.info(
           `unboltDoor REJECTED for ${homeAssistant.entityId} - no PIN provided`
         );
         throw new StatusResponseError(
@@ -155466,12 +156251,12 @@ var LockServerWithPinAndUnboltBase = class extends PinCredentialUnboltBase {
       }
       const providedPin = new TextDecoder().decode(request.pinCode);
       if (!verifyStoredPinHelper(this.env, homeAssistant.entityId, providedPin)) {
-        logger210.info(
+        logger213.info(
           `unboltDoor REJECTED for ${homeAssistant.entityId} - invalid PIN`
         );
         throw new StatusResponseError("Invalid PIN code", StatusCode.Failure);
       }
-      logger210.debug(`unboltDoor PIN verified for ${homeAssistant.entityId}`);
+      logger213.debug(`unboltDoor PIN verified for ${homeAssistant.entityId}`);
       action.data = { ...action.data, code: providedPin };
     }
     homeAssistant.callAction(action);
@@ -155603,7 +156388,7 @@ init_home_assistant_entity_behavior();
 init_dist();
 init_esm();
 init_home_assistant_entity_behavior();
-var logger211 = Logger.get("MediaPlayerKeypadInputServer");
+var logger214 = Logger.get("MediaPlayerKeypadInputServer");
 var MediaPlayerKeypadInputServer = class extends KeypadInputServer {
   sendKey(request) {
     const homeAssistant = this.agent.get(HomeAssistantEntityBehavior);
@@ -155614,12 +156399,12 @@ var MediaPlayerKeypadInputServer = class extends KeypadInputServer {
     const features3 = attributes8.supported_features ?? 0;
     const action = this.mapKeyToAction(request.keyCode, features3);
     if (!action) {
-      logger211.debug(
+      logger214.debug(
         `Unsupported key code ${request.keyCode} for ${homeAssistant.entityId}`
       );
       return { status: KeypadInput3.Status.UnsupportedKey };
     }
-    logger211.debug(
+    logger214.debug(
       `sendKey(${request.keyCode}) \u2192 ${action} for ${homeAssistant.entityId}`
     );
     homeAssistant.callAction({ action });
@@ -155898,7 +156683,7 @@ init_home_assistant_entity_behavior();
 // src/matter/behaviors/speaker-level-control-server.ts
 init_esm();
 init_home_assistant_entity_behavior();
-var logger212 = Logger.get("SpeakerLevelControlServer");
+var logger215 = Logger.get("SpeakerLevelControlServer");
 var optimisticLevelState2 = /* @__PURE__ */ new Map();
 var OPTIMISTIC_TIMEOUT_MS4 = 3e3;
 var OPTIMISTIC_TOLERANCE3 = 5;
@@ -155941,7 +156726,7 @@ var SpeakerLevelControlServerBase = class extends FeaturedBase8 {
       currentLevel = Math.min(Math.max(minLevel, currentLevel), maxLevel);
     }
     const entityId = this.agent.get(HomeAssistantEntityBehavior).entity.entity_id;
-    logger212.debug(
+    logger215.debug(
       `[${entityId}] Volume update: HA=${currentLevelPercent != null ? Math.round(currentLevelPercent * 100) : "null"}% -> currentLevel=${currentLevel}`
     );
     const optimistic = optimisticLevelState2.get(entity.entity_id);
@@ -155989,7 +156774,7 @@ var SpeakerLevelControlServerBase = class extends FeaturedBase8 {
     const config11 = this.state.config;
     const entityId = homeAssistant.entity.entity_id;
     const levelPercent = level / 254;
-    logger212.debug(
+    logger215.debug(
       `[${entityId}] Volume command: level=${level} -> HA volume_level=${levelPercent}`
     );
     const current = config11.getValuePercent(
@@ -157354,7 +158139,7 @@ var TvocConcentrationMeasurementServer = class extends TvocConcentrationMeasurem
 };
 
 // src/matter/endpoints/legacy/sensor/devices/tvoc-sensor.ts
-var logger213 = Logger.get("TvocSensor");
+var logger216 = Logger.get("TvocSensor");
 function airQualityFromUgm3(value) {
   if (value <= 300) return AirQuality3.AirQualityEnum.Good;
   if (value <= 1e3) return AirQuality3.AirQualityEnum.Fair;
@@ -157395,17 +158180,17 @@ var TvocAirQualityServer = class extends TvocAirQualityServerBase {
     const attributes8 = entity.state.attributes;
     const deviceClass = attributes8.device_class;
     let airQuality = AirQuality3.AirQualityEnum.Unknown;
-    logger213.debug(
+    logger216.debug(
       `[${entity.entity_id}] TVOC update: state="${state}", device_class="${deviceClass}"`
     );
     if (state != null && !Number.isNaN(+state)) {
       const value = +state;
       airQuality = deviceClass === SensorDeviceClass.volatile_organic_compounds ? airQualityFromUgm3(value) : airQualityFromPpb(value);
-      logger213.debug(
+      logger216.debug(
         `[${entity.entity_id}] TVOC value=${value} (${deviceClass}) -> airQuality=${AirQuality3.AirQualityEnum[airQuality]}`
       );
     } else {
-      logger213.warn(
+      logger216.warn(
         `[${entity.entity_id}] TVOC state not a valid number: "${state}"`
       );
     }
@@ -157619,7 +158404,7 @@ init_home_assistant_entity_behavior();
 // src/matter/behaviors/pm25-concentration-measurement-server.ts
 init_esm();
 init_home_assistant_entity_behavior();
-var logger214 = Logger.get("Pm25ConcentrationMeasurementServer");
+var logger217 = Logger.get("Pm25ConcentrationMeasurementServer");
 var Pm25ConcentrationMeasurementServerBase = Pm25ConcentrationMeasurementServer.with(
   ConcentrationMeasurement3.Feature.NumericMeasurement
 );
@@ -157643,11 +158428,11 @@ var Pm25ConcentrationMeasurementServer2 = class extends Pm25ConcentrationMeasure
     if (this.state.measurementMedium === void 0) {
       this.state.measurementMedium = ConcentrationMeasurement3.MeasurementMedium.Air;
     }
-    logger214.debug(
+    logger217.debug(
       "Pm25ConcentrationMeasurementServer: before super.initialize()"
     );
     await super.initialize();
-    logger214.debug(
+    logger217.debug(
       "Pm25ConcentrationMeasurementServer: after super.initialize()"
     );
     const homeAssistant = await this.agent.load(HomeAssistantEntityBehavior);
@@ -157670,7 +158455,7 @@ var Pm25ConcentrationMeasurementServer2 = class extends Pm25ConcentrationMeasure
 };
 
 // src/matter/endpoints/legacy/sensor/devices/pm25-sensor.ts
-var logger215 = Logger.get("Pm25AirQualityServer");
+var logger218 = Logger.get("Pm25AirQualityServer");
 var Pm25AirQualityServerBase = AirQualityServer.with(
   AirQuality3.Feature.Fair,
   AirQuality3.Feature.Moderate,
@@ -157682,9 +158467,9 @@ var Pm25AirQualityServer = class extends Pm25AirQualityServerBase {
     if (this.state.airQuality === void 0) {
       this.state.airQuality = AirQuality3.AirQualityEnum.Unknown;
     }
-    logger215.debug("Pm25AirQualityServer: before super.initialize()");
+    logger218.debug("Pm25AirQualityServer: before super.initialize()");
     await super.initialize();
-    logger215.debug("Pm25AirQualityServer: after super.initialize()");
+    logger218.debug("Pm25AirQualityServer: after super.initialize()");
     const homeAssistant = await this.agent.load(HomeAssistantEntityBehavior);
     this.update(homeAssistant.entity);
     this.reactTo(homeAssistant.onChange, this.update, { offline: true });
@@ -158073,7 +158858,7 @@ init_home_assistant_entity_behavior();
 init_dist();
 init_esm();
 init_home_assistant_entity_behavior();
-var logger216 = Logger.get("VacuumIdentifyServer");
+var logger219 = Logger.get("VacuumIdentifyServer");
 var IDENTIFY_BUTTON_SUFFIXES = ["_identify", "_locate", "_find_me"];
 var VacuumIdentifyServer = class extends IdentifyServer2 {
   triggerEffect(effect) {
@@ -158090,19 +158875,19 @@ var VacuumIdentifyServer = class extends IdentifyServer2 {
     const homeAssistant = this.agent.get(HomeAssistantEntityBehavior);
     const features3 = homeAssistant.entity.state.attributes.supported_features ?? 0;
     if (testBit(features3, VacuumDeviceFeature.LOCATE)) {
-      logger216.info(`${source} \u2192 vacuum.locate for ${homeAssistant.entityId}`);
+      logger219.info(`${source} \u2192 vacuum.locate for ${homeAssistant.entityId}`);
       homeAssistant.callAction({ action: "vacuum.locate" });
       return;
     }
     const sibling = this.#findIdentifyButton(homeAssistant);
     if (sibling) {
-      logger216.info(
+      logger219.info(
         `${source} \u2192 button.press ${sibling} for ${homeAssistant.entityId}`
       );
       homeAssistant.callAction({ action: "button.press", target: sibling });
       return;
     }
-    logger216.warn(
+    logger219.warn(
       `${source} for ${homeAssistant.entityId}, LOCATE not in supported_features (${features3}), trying vacuum.locate anyway`
     );
     homeAssistant.callAction({ action: "vacuum.locate" });
@@ -158125,533 +158910,6 @@ var VacuumIdentifyServer = class extends IdentifyServer2 {
   }
 };
 
-// src/matter/behaviors/rvc-run-mode-server.ts
-init_esm();
-
-// ../../node_modules/.pnpm/@matter+main@0.17.2/node_modules/@matter/main/dist/esm/forwards/clusters/mode-base.js
-init_nodejs();
-
-// ../../node_modules/.pnpm/@matter+main@0.17.2/node_modules/@matter/main/dist/esm/forwards/clusters/rvc-run-mode.js
-init_nodejs();
-
-// src/matter/behaviors/rvc-run-mode-server.ts
-init_home_assistant_entity_behavior();
-
-// src/matter/behaviors/infer-cleaned-area-progress.ts
-function inferCleanedAreaProgress(cleanedSqm, orderedAreas) {
-  if (orderedAreas.length === 0) {
-    return { currentArea: null, completed: [] };
-  }
-  const cleaned = Number.isFinite(cleanedSqm) ? Math.max(0, cleanedSqm) : 0;
-  let cumulative = 0;
-  const completed = [];
-  for (const area of orderedAreas) {
-    const size = Number.isFinite(area.sizeSqm) ? Math.max(0, area.sizeSqm) : 0;
-    cumulative += size;
-    if (cleaned < cumulative) {
-      return { currentArea: area.areaId, completed };
-    }
-    completed.push(area.areaId);
-  }
-  return { currentArea: null, completed };
-}
-
-// src/matter/behaviors/rvc-run-mode-server.ts
-var logger217 = Logger.get("RvcRunModeServer");
-var ROOM_MODE_BASE = 100;
-function isRoomMode(mode) {
-  return mode >= ROOM_MODE_BASE;
-}
-var cleaningSessions = /* @__PURE__ */ new WeakMap();
-function getSession(endpoint) {
-  let session = cleaningSessions.get(endpoint);
-  if (!session) {
-    session = {
-      completedAreas: /* @__PURE__ */ new Set(),
-      lastCurrentArea: null,
-      activeAreas: [],
-      loggedShortCircuits: /* @__PURE__ */ new Set(),
-      observedCleaning: false,
-      pendingDispatches: [],
-      cleanedAreaBaseline: null
-    };
-    cleaningSessions.set(endpoint, session);
-  }
-  return session;
-}
-var RvcRunModeServerBase = class extends RvcRunModeServer {
-  async initialize() {
-    await super.initialize();
-    const homeAssistant = await this.agent.load(HomeAssistantEntityBehavior);
-    this.update(homeAssistant.entity);
-    this.reactTo(homeAssistant.onChange, this.update, { offline: true });
-  }
-  update(entity) {
-    if (!entity.state || !entity.state.attributes) {
-      return;
-    }
-    const s = getSession(this.endpoint);
-    const previousMode = this.state.currentMode;
-    const newMode = this.state.config.getCurrentMode(entity.state, this.agent);
-    applyPatchState(
-      this.state,
-      {
-        currentMode: newMode,
-        supportedModes: this.state.config.getSupportedModes(
-          entity.state,
-          this.agent
-        )
-      },
-      { force: true }
-    );
-    if (newMode === 1 /* Cleaning */) {
-      s.observedCleaning = true;
-    }
-    if (previousMode !== newMode) {
-      if (newMode === 0 /* Idle */) {
-        if (s.lastCurrentArea !== null) {
-          s.completedAreas.add(s.lastCurrentArea);
-          s.lastCurrentArea = null;
-        }
-        if (s.pendingDispatches.length > 0 && s.observedCleaning) {
-          try {
-            const serviceArea = this.agent.get(ServiceAreaBehavior);
-            const prev = serviceArea.state.currentArea;
-            if (typeof prev === "number") {
-              s.completedAreas.add(prev);
-            }
-            const next = s.pendingDispatches.shift();
-            if (next) {
-              const homeAssistant = this.agent.get(HomeAssistantEntityBehavior);
-              homeAssistant.callAction(next.action);
-              this.trySetCurrentArea(next.areaId);
-            }
-          } catch {
-          }
-          s.loggedShortCircuits.clear();
-          return;
-        }
-        if (s.observedCleaning) {
-          try {
-            const serviceArea = this.agent.get(ServiceAreaBehavior);
-            const last = serviceArea.state.currentArea;
-            if (typeof last === "number") {
-              s.completedAreas.add(last);
-              serviceArea.state.currentArea = null;
-            }
-            this.updateProgressFromTracking(serviceArea);
-          } catch {
-          }
-          s.observedCleaning = false;
-        }
-        s.loggedShortCircuits.clear();
-      } else if (newMode === 1 /* Cleaning */) {
-        if (s.activeAreas.length > 0 && s.lastCurrentArea === null) {
-          const firstPending = s.activeAreas.find(
-            (id) => !s.completedAreas.has(id)
-          );
-          if (firstPending !== void 0) {
-            this.trySetCurrentArea(firstPending);
-          }
-        }
-      }
-    }
-    if (newMode === 0 /* Idle */ && s.activeAreas.length === 0) {
-      try {
-        const serviceArea = this.agent.get(ServiceAreaBehavior);
-        if (serviceArea.state.currentArea !== null) {
-          serviceArea.state.currentArea = null;
-        }
-      } catch {
-      }
-    }
-    if (newMode === 1 /* Cleaning */) {
-      const mapping = this.agent.get(HomeAssistantEntityBehavior).state.mapping;
-      if (mapping?.currentRoomEntity) {
-        this.updateCurrentRoomFromSensor();
-      } else if (mapping?.cleanedAreaEntity) {
-        this.updateCurrentRoomFromCleanedArea();
-      }
-    }
-  }
-  /**
-   * Emit a diagnostic INFO log exactly once per cleaning session for a
-   * given short-circuit reason. Prevents log flooding while still
-   * surfacing the silent paths that would otherwise be invisible.
-   */
-  logShortCircuitOnce(reason, message) {
-    const s = getSession(this.endpoint);
-    if (s.loggedShortCircuits.has(reason)) return;
-    s.loggedShortCircuits.add(reason);
-    logger217.info(message);
-  }
-  /**
-   * Read the currentRoomEntity sensor and update currentArea + progress
-   * to reflect which room the vacuum is actually in right now.
-   */
-  updateCurrentRoomFromSensor() {
-    try {
-      const s = getSession(this.endpoint);
-      const homeAssistant = this.agent.get(HomeAssistantEntityBehavior);
-      const currentRoomEntityId = homeAssistant.state.mapping?.currentRoomEntity;
-      if (!currentRoomEntityId) {
-        this.logShortCircuitOnce(
-          "no-mapping",
-          "currentRoom sensor: no currentRoomEntity in mapping, auto-detect did not run or sensor not on same HA device"
-        );
-        return;
-      }
-      const stateProvider = this.agent.env.get(EntityStateProvider);
-      const roomState = stateProvider.getState(currentRoomEntityId);
-      if (!roomState || !roomState.state) {
-        this.logShortCircuitOnce(
-          "no-state",
-          `currentRoom sensor: no state available for ${currentRoomEntityId}`
-        );
-        return;
-      }
-      const serviceArea = this.agent.get(ServiceAreaBehavior);
-      const externalSession = s.activeAreas.length === 0;
-      const supportedAreaIds = serviceArea.state.supportedAreas.map(
-        (a) => a.areaId
-      );
-      const isAllowedArea = (id) => externalSession ? supportedAreaIds.includes(id) : s.activeAreas.includes(id);
-      const sensorAttrs = roomState.attributes;
-      const segmentId = sensorAttrs.segment_id ?? sensorAttrs.room_id;
-      const roomName = roomState.state;
-      let matchedAreaId = null;
-      if (segmentId != null && isAllowedArea(segmentId)) {
-        matchedAreaId = segmentId;
-      }
-      if (matchedAreaId === null && segmentId != null) {
-        for (const area of serviceArea.state.supportedAreas) {
-          if (isAllowedArea(area.areaId) && area.areaId % 1e4 === segmentId) {
-            matchedAreaId = area.areaId;
-            break;
-          }
-        }
-      }
-      if (matchedAreaId === null && roomName) {
-        const area = serviceArea.state.supportedAreas.find(
-          (a) => a.areaInfo.locationInfo?.locationName?.toLowerCase() === roomName.toLowerCase()
-        );
-        if (area && isAllowedArea(area.areaId)) {
-          matchedAreaId = area.areaId;
-        }
-      }
-      if (matchedAreaId === null) {
-        logger217.info(
-          `currentRoom sensor: no match for "${roomName}" (segmentId=${segmentId}), activeAreas=[${s.activeAreas.join(", ")}], supportedAreas=[${serviceArea.state.supportedAreas.map((a) => `${a.areaId}:${a.areaInfo.locationInfo?.locationName}`).join(", ")}]`
-        );
-        return;
-      }
-      if (matchedAreaId === s.lastCurrentArea) return;
-      if (s.lastCurrentArea !== null) {
-        s.completedAreas.add(s.lastCurrentArea);
-      }
-      s.lastCurrentArea = matchedAreaId;
-      logger217.info(
-        `currentRoom sensor: transition to area ${matchedAreaId} ("${roomName}"), completed: [${[...s.completedAreas].join(", ")}]`
-      );
-      this.trySetCurrentArea(matchedAreaId);
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      if (!msg.includes("No provider for") && !msg.includes("not supported")) {
-        logger217.warn(`currentRoom sensor update failed: ${msg}`);
-      }
-    }
-  }
-  /** Read the cumulative cleaned-area sensor (m2), or null if not configured. */
-  readCleanedAreaSqm() {
-    try {
-      const mapping = this.agent.get(HomeAssistantEntityBehavior).state.mapping;
-      const entityId = mapping?.cleanedAreaEntity;
-      if (!entityId) {
-        return null;
-      }
-      return this.agent.env.get(EntityStateProvider).getNumericState(entityId);
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * For batch vacuums that report cumulative cleaned area but not the current
-   * room, infer currentArea + progress from the cleaned area and the per-room
-   * sizeSqm. Display-only and batch-only; skipped unless every selected area
-   * has a size. The currentRoom sensor path takes priority (#368).
-   */
-  updateCurrentRoomFromCleanedArea() {
-    try {
-      const s = getSession(this.endpoint);
-      if (s.pendingDispatches.length > 0 || s.activeAreas.length === 0) {
-        return;
-      }
-      const mapping = this.agent.get(HomeAssistantEntityBehavior).state.mapping;
-      const entityId = mapping?.cleanedAreaEntity;
-      if (!entityId) {
-        return;
-      }
-      const raw = this.agent.env.get(EntityStateProvider).getNumericState(entityId);
-      if (raw == null) {
-        this.logShortCircuitOnce(
-          "no-cleaned-area-state",
-          `cleanedArea sensor: no numeric state for ${entityId}`
-        );
-        return;
-      }
-      const customAreas = mapping?.customServiceAreas;
-      const ordered = [];
-      for (const areaId of [...s.activeAreas].sort((a, b) => a - b)) {
-        const size = customAreas?.[areaId - 1]?.sizeSqm;
-        if (typeof size !== "number" || !Number.isFinite(size) || size <= 0) {
-          this.logShortCircuitOnce(
-            "no-sizes",
-            "cleanedArea sensor: not every selected area has a sizeSqm"
-          );
-          return;
-        }
-        ordered.push({ areaId, sizeSqm: size });
-      }
-      if (s.cleanedAreaBaseline == null || raw < s.cleanedAreaBaseline) {
-        s.cleanedAreaBaseline = raw;
-      }
-      const cleaned = Math.max(0, raw - s.cleanedAreaBaseline);
-      const { currentArea, completed } = inferCleanedAreaProgress(
-        cleaned,
-        ordered
-      );
-      logger217.debug(
-        `cleanedArea: raw=${raw} baseline=${s.cleanedAreaBaseline} cleaned=${cleaned} sizes=[${ordered.map((o) => `${o.areaId}:${o.sizeSqm}`).join(",")}] -> current=${currentArea} completed=[${completed.join(",")}]`
-      );
-      for (const id of completed) {
-        s.completedAreas.add(id);
-      }
-      if (currentArea === s.lastCurrentArea) {
-        return;
-      }
-      s.lastCurrentArea = currentArea;
-      this.trySetCurrentArea(currentArea);
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      if (!msg.includes("No provider for") && !msg.includes("not supported")) {
-        logger217.warn(`cleanedArea room update failed: ${msg}`);
-      }
-    }
-  }
-  /**
-   * Safely update ServiceArea.currentArea and progress.
-   * When areaId is set, marks it as Operating in progress.
-   * When areaId is null (Idle), marks all Operating/Pending as Completed.
-   * No-op if ServiceArea is not available on this endpoint.
-   */
-  trySetCurrentArea(areaId) {
-    try {
-      const serviceArea = this.agent.get(ServiceAreaBehavior);
-      if (serviceArea.state.currentArea !== areaId) {
-        serviceArea.state.currentArea = areaId;
-        logger217.debug(`currentArea set to ${areaId}`);
-      }
-      this.updateProgress(serviceArea, areaId);
-    } catch {
-    }
-  }
-  /**
-   * Update progress entries to reflect the current operating area.
-   * - null: mark all areas as Completed (cleaning done)
-   * - areaId: mark that area as Operating, others as Pending
-   *
-   * Uses the activeAreas snapshot (plain number array) instead of
-   * managed state entries, which avoids infinite recursion in
-   * matter.js property getters during transaction pre-commit.
-   */
-  updateProgress(serviceArea, areaId) {
-    const s = getSession(this.endpoint);
-    if (s.activeAreas.length === 0) return;
-    const state = serviceArea.state;
-    if (areaId === null) {
-      state.progress = s.activeAreas.map((id) => ({
-        areaId: id,
-        status: ServiceArea3.OperationalStatus.Completed
-      }));
-    } else {
-      state.progress = s.activeAreas.map((id) => ({
-        areaId: id,
-        status: id === areaId ? ServiceArea3.OperationalStatus.Operating : s.completedAreas.has(id) ? ServiceArea3.OperationalStatus.Completed : ServiceArea3.OperationalStatus.Pending
-      }));
-    }
-  }
-  /**
-   * Update progress entries from tracking state without any area
-   * operating. Used on mid-session transitions (e.g. vacuum-then-mop
-   * tool swap) where the vacuum is temporarily idle but the session
-   * is not finished: completed areas stay Completed, remaining areas
-   * stay Pending.
-   */
-  updateProgressFromTracking(serviceArea) {
-    const s = getSession(this.endpoint);
-    if (s.activeAreas.length === 0) return;
-    const state = serviceArea.state;
-    state.progress = s.activeAreas.map((id) => ({
-      areaId: id,
-      status: s.completedAreas.has(id) ? ServiceArea3.OperationalStatus.Completed : ServiceArea3.OperationalStatus.Pending
-    }));
-  }
-  /**
-   * Stop before finishing: mark the areas the vacuum actually reached as
-   * Completed and the rest as Skipped (an out-of-band stop per the Matter
-   * ServiceArea spec), then clear currentArea. The old path marked every
-   * area Completed, which told Apple Home rooms were cleaned when they were
-   * not, so they got dropped from the next selection (#367).
-   */
-  finalizeProgressOnStop() {
-    const s = getSession(this.endpoint);
-    try {
-      const serviceArea = this.agent.get(ServiceAreaBehavior);
-      if (s.activeAreas.length > 0) {
-        const last = serviceArea.state.currentArea;
-        const state = serviceArea.state;
-        state.progress = s.activeAreas.map((id) => ({
-          areaId: id,
-          status: s.completedAreas.has(id) || id === last ? ServiceArea3.OperationalStatus.Completed : ServiceArea3.OperationalStatus.Skipped
-        }));
-      }
-      serviceArea.state.currentArea = null;
-    } catch {
-    }
-  }
-  /**
-   * Find the ServiceArea area ID that corresponds to a run mode value
-   * by matching the mode label to the area location name.
-   */
-  findAreaIdForMode(mode) {
-    try {
-      const serviceArea = this.agent.get(ServiceAreaBehavior);
-      const modeEntry = this.state.supportedModes.find((m) => m.mode === mode);
-      if (!modeEntry) return null;
-      const area = serviceArea.state.supportedAreas.find(
-        (a) => a.areaInfo.locationInfo?.locationName === modeEntry.label
-      );
-      return area?.areaId ?? null;
-    } catch {
-      return null;
-    }
-  }
-  changeToMode(request) {
-    const s = getSession(this.endpoint);
-    const homeAssistant = this.agent.get(HomeAssistantEntityBehavior);
-    const { newMode } = request;
-    if (newMode !== this.state.currentMode && !this.state.supportedModes.some((m) => m.mode === newMode)) {
-      return {
-        status: ModeBase3.ModeChangeStatus.UnsupportedMode,
-        statusText: `Unsupported mode: ${newMode}`
-      };
-    }
-    if (isRoomMode(newMode)) {
-      try {
-        const serviceArea = this.agent.get(ServiceAreaBehavior);
-        if (serviceArea.state.selectedAreas?.length > 0) {
-          s.activeAreas = [...serviceArea.state.selectedAreas];
-          s.completedAreas.clear();
-          s.lastCurrentArea = null;
-          s.loggedShortCircuits.clear();
-          s.pendingDispatches = [];
-          s.cleanedAreaBaseline = this.readCleanedAreaSqm();
-          this.trySetCurrentArea(s.activeAreas[0]);
-          homeAssistant.callAction(this.state.config.start(void 0, this.agent));
-          this.state.currentMode = newMode;
-          return {
-            status: ModeBase3.ModeChangeStatus.Success,
-            statusText: "Starting room cleaning"
-          };
-        }
-      } catch {
-      }
-      if (this.state.config.cleanRoom) {
-        const areaId = this.findAreaIdForMode(newMode);
-        s.activeAreas = areaId !== null ? [areaId] : [];
-        s.completedAreas.clear();
-        s.lastCurrentArea = null;
-        s.loggedShortCircuits.clear();
-        s.pendingDispatches = [];
-        this.trySetCurrentArea(areaId);
-        homeAssistant.callAction(
-          this.state.config.cleanRoom(newMode, this.agent)
-        );
-        this.state.currentMode = newMode;
-        return {
-          status: ModeBase3.ModeChangeStatus.Success,
-          statusText: "Starting room cleaning"
-        };
-      }
-    }
-    switch (newMode) {
-      case 1 /* Cleaning */: {
-        try {
-          const serviceArea = this.agent.get(ServiceAreaBehavior);
-          if (serviceArea.state.selectedAreas?.length > 0) {
-            s.activeAreas = [...serviceArea.state.selectedAreas];
-            s.completedAreas.clear();
-            s.lastCurrentArea = null;
-            s.loggedShortCircuits.clear();
-            s.pendingDispatches = [];
-            s.cleanedAreaBaseline = this.readCleanedAreaSqm();
-            this.trySetCurrentArea(s.activeAreas[0]);
-          }
-        } catch {
-        }
-        homeAssistant.callAction(this.state.config.start(void 0, this.agent));
-        break;
-      }
-      case 0 /* Idle */:
-        this.finalizeProgressOnStop();
-        s.completedAreas.clear();
-        s.lastCurrentArea = null;
-        s.activeAreas = [];
-        s.loggedShortCircuits.clear();
-        s.pendingDispatches = [];
-        s.observedCleaning = false;
-        s.cleanedAreaBaseline = null;
-        homeAssistant.callAction(
-          this.state.config.returnToBase(void 0, this.agent)
-        );
-        break;
-      default:
-        homeAssistant.callAction(this.state.config.pause(void 0, this.agent));
-        break;
-    }
-    this.state.currentMode = newMode;
-    return {
-      status: ModeBase3.ModeChangeStatus.Success,
-      statusText: "Mode switched"
-    };
-  }
-};
-((RvcRunModeServerBase2) => {
-  class State extends RvcRunModeServer.State {
-    config;
-  }
-  RvcRunModeServerBase2.State = State;
-})(RvcRunModeServerBase || (RvcRunModeServerBase = {}));
-function RvcRunModeServer2(config11, initialState) {
-  const defaultModes = [
-    {
-      label: "Idle",
-      mode: 0 /* Idle */,
-      modeTags: [{ value: RvcRunMode3.ModeTag.Idle }]
-    },
-    {
-      label: "Cleaning",
-      mode: 1 /* Cleaning */,
-      modeTags: [{ value: RvcRunMode3.ModeTag.Cleaning }]
-    }
-  ];
-  return RvcRunModeServerBase.set({
-    config: config11,
-    supportedModes: initialState?.supportedModes ?? defaultModes,
-    currentMode: initialState?.currentMode ?? 0 /* Idle */
-  });
-}
-
 // src/matter/endpoints/legacy/vacuum/behaviors/vacuum-rvc-run-mode-server.ts
 init_dist();
 init_esm();
@@ -158828,14 +159086,14 @@ init_esm();
 
 // src/matter/behaviors/service-area-server.ts
 init_esm();
-var logger218 = Logger.get("ServiceAreaServer");
+var logger220 = Logger.get("ServiceAreaServer");
 var ServiceAreaWithProgress = ServiceAreaBehavior.with(
   ServiceArea3.Feature.ProgressReporting
 );
 var ServiceAreaServerBase = class extends ServiceAreaWithProgress {
   selectAreas(request) {
     const { newAreas } = request;
-    logger218.info(
+    logger220.info(
       `ServiceArea selectAreas called with: ${JSON.stringify(newAreas)}`
     );
     const uniqueAreas = [...new Set(newAreas)];
@@ -158844,7 +159102,7 @@ var ServiceAreaServerBase = class extends ServiceAreaWithProgress {
       (id) => !supportedAreaIds.includes(id)
     );
     if (invalidAreas.length > 0) {
-      logger218.warn(`Invalid area IDs requested: ${invalidAreas.join(", ")}`);
+      logger220.warn(`Invalid area IDs requested: ${invalidAreas.join(", ")}`);
       return {
         status: ServiceArea3.SelectAreasStatus.UnsupportedArea,
         statusText: `Invalid area IDs: ${invalidAreas.join(", ")}`
@@ -158856,7 +159114,7 @@ var ServiceAreaServerBase = class extends ServiceAreaWithProgress {
       status: ServiceArea3.OperationalStatus.Pending
     }));
     this.state.currentArea = null;
-    logger218.info(
+    logger220.info(
       `ServiceArea: Stored ${uniqueAreas.length} areas for cleaning: ${uniqueAreas.join(", ")}`
     );
     return {
@@ -158877,7 +159135,7 @@ var ServiceAreaServerBase = class extends ServiceAreaWithProgress {
   ServiceAreaServerBase2.State = State;
 })(ServiceAreaServerBase || (ServiceAreaServerBase = {}));
 function ServiceAreaServer2(initialState) {
-  logger218.info(
+  logger220.info(
     `Creating ServiceAreaServer with ${initialState.supportedAreas.length} areas`
   );
   return ServiceAreaServerBase.set({
@@ -158894,7 +159152,7 @@ var ServiceAreaWithMapsAndProgress = ServiceAreaBehavior.with(
 var ServiceAreaServerWithMapsBase = class extends ServiceAreaWithMapsAndProgress {
   selectAreas(request) {
     const { newAreas } = request;
-    logger218.info(
+    logger220.info(
       `ServiceArea selectAreas called with: ${JSON.stringify(newAreas)}`
     );
     const uniqueAreas = [...new Set(newAreas)];
@@ -158903,7 +159161,7 @@ var ServiceAreaServerWithMapsBase = class extends ServiceAreaWithMapsAndProgress
       (id) => !supportedAreaIds.includes(id)
     );
     if (invalidAreas.length > 0) {
-      logger218.warn(`Invalid area IDs requested: ${invalidAreas.join(", ")}`);
+      logger220.warn(`Invalid area IDs requested: ${invalidAreas.join(", ")}`);
       return {
         status: ServiceArea3.SelectAreasStatus.UnsupportedArea,
         statusText: `Invalid area IDs: ${invalidAreas.join(", ")}`
@@ -158915,7 +159173,7 @@ var ServiceAreaServerWithMapsBase = class extends ServiceAreaWithMapsAndProgress
       status: ServiceArea3.OperationalStatus.Pending
     }));
     this.state.currentArea = null;
-    logger218.info(
+    logger220.info(
       `ServiceArea: Stored ${uniqueAreas.length} areas for cleaning: ${uniqueAreas.join(", ")}`
     );
     return {
@@ -158936,14 +159194,14 @@ var ServiceAreaServerWithMapsBase = class extends ServiceAreaWithMapsAndProgress
   ServiceAreaServerWithMapsBase2.State = State;
 })(ServiceAreaServerWithMapsBase || (ServiceAreaServerWithMapsBase = {}));
 function ServiceAreaServerWithMaps(initialState) {
-  logger218.info(
+  logger220.info(
     `Creating ServiceAreaServer with Maps: ${initialState.supportedAreas.length} areas, ${initialState.supportedMaps.length} maps`
   );
   for (const map of initialState.supportedMaps) {
     const areaCount = initialState.supportedAreas.filter(
       (a) => a.mapId === map.mapId
     ).length;
-    logger218.info(`  Map ${map.mapId}: "${map.name}" (${areaCount} areas)`);
+    logger220.info(`  Map ${map.mapId}: "${map.name}" (${areaCount} areas)`);
   }
   return ServiceAreaServerWithMapsBase.set({
     supportedAreas: initialState.supportedAreas,
@@ -158955,7 +159213,7 @@ function ServiceAreaServerWithMaps(initialState) {
 }
 
 // src/matter/endpoints/legacy/vacuum/behaviors/vacuum-service-area-server.ts
-var logger219 = Logger.get("VacuumServiceAreaServer");
+var logger221 = Logger.get("VacuumServiceAreaServer");
 function toAreaId(roomId) {
   if (typeof roomId === "number") {
     return roomId;
@@ -159034,13 +159292,13 @@ function createVacuumServiceAreaServer(attributes8, roomEntities, includeUnnamed
   let rooms;
   if (roomEntities && roomEntities.length > 0) {
     rooms = buttonEntitiesToRooms(roomEntities, attributes8);
-    logger219.info(
+    logger221.info(
       `Using ${rooms.length} button entities as rooms: ${rooms.map((r) => r.name).join(", ")}`
     );
   } else {
     rooms = parseVacuumRooms(attributes8, includeUnnamedRooms);
     if (rooms.length > 0) {
-      logger219.info(
+      logger221.info(
         `Using ${rooms.length} rooms from attributes: ${rooms.map((r) => r.name).join(", ")}`
       );
     }
@@ -159094,7 +159352,7 @@ function createCustomServiceAreaServer(customAreas) {
       landmarkInfo: null
     }
   }));
-  logger219.info(
+  logger221.info(
     `Using ${customAreas.length} custom service areas: ${customAreas.map((a) => a.name).join(", ")}`
   );
   return ServiceAreaServer2({
@@ -159116,7 +159374,7 @@ function createCleanAreaServiceAreaServer(cleanAreaRooms) {
       landmarkInfo: null
     }
   }));
-  logger219.info(
+  logger221.info(
     `Using ${cleanAreaRooms.length} HA areas via CLEAN_AREA: ${cleanAreaRooms.map((r) => r.name).join(", ")}`
   );
   return ServiceAreaServer2({
@@ -159127,11 +159385,11 @@ function createCleanAreaServiceAreaServer(cleanAreaRooms) {
 }
 
 // src/matter/endpoints/legacy/vacuum/behaviors/vacuum-rvc-run-mode-server.ts
-var logger220 = Logger.get("VacuumRvcRunModeServer");
+var logger222 = Logger.get("VacuumRvcRunModeServer");
 function buildValetudoSegmentAction(vacuumEntityId, segmentIds, valetudoIdentifier) {
   const identifier = valetudoIdentifier || vacuumEntityId.replace(/^vacuum\.valetudo_/, "");
   const topic = `valetudo/${identifier}/MapSegmentationCapability/clean/set`;
-  logger220.info(
+  logger222.info(
     `Valetudo: mqtt.publish to ${topic}, segments: ${segmentIds.join(", ")}`
   );
   return {
@@ -159236,14 +159494,14 @@ function mergeBatchData(areas) {
 function handleCustomServiceAreas(selectedAreas, customAreas, session) {
   const matched = selectedAreas.map((areaId) => ({ areaId, area: customAreas[areaId - 1] })).filter((m) => !!m.area);
   if (matched.length === 0) {
-    logger220.warn(
+    logger222.warn(
       `Custom service areas: no match for selected IDs ${selectedAreas.join(", ")}`
     );
     return { action: "vacuum.start" };
   }
   const batchArea = matched.find(({ area }) => area.batchDispatch === true);
   if (batchArea) {
-    logger220.info(
+    logger222.info(
       `Custom service areas (batch): single call for ${matched.length} room(s): ${matched.map(({ area }) => area.name).join(", ")}`
     );
     session.pendingDispatches = [];
@@ -159264,7 +159522,7 @@ function handleCustomServiceAreas(selectedAreas, customAreas, session) {
       }
     };
   }
-  logger220.info(
+  logger222.info(
     `Custom service areas: ${matched.length} room(s) queued: ${matched.map(({ area }) => `${area.service} (${area.name})`).join(", ")}`
   );
   session.pendingDispatches = matched.slice(1).map(({ areaId, area }) => ({
@@ -159300,7 +159558,7 @@ var vacuumRvcRunModeConfig = {
       VacuumState.paused
     ];
     const isCleaning = cleaningStates.includes(state);
-    logger220.debug(
+    logger222.debug(
       `Vacuum state: "${state}", isCleaning: ${isCleaning}, currentMode: ${isCleaning ? "Cleaning" : "Idle"}`
     );
     return isCleaning ? 1 /* Cleaning */ : 0 /* Idle */;
@@ -159334,7 +159592,7 @@ var vacuumRvcRunModeConfig = {
         if (cleanAreaRooms && cleanAreaRooms.length > 0) {
           const haAreaIds = resolveCleanAreaIds(selectedAreas, cleanAreaRooms);
           if (haAreaIds.length > 0) {
-            logger220.info(
+            logger222.info(
               `CLEAN_AREA: cleaning HA areas: ${haAreaIds.join(", ")}`
             );
             return {
@@ -159353,7 +159611,7 @@ var vacuumRvcRunModeConfig = {
             }
           }
           if (matched.length > 0) {
-            logger220.info(
+            logger222.info(
               `Roborock: ${matched.length} room button(s) queued: ${matched.map((m) => m.entityId).join(", ")}`
             );
             session.pendingDispatches = matched.slice(1).map(({ areaId, entityId }) => ({
@@ -159387,14 +159645,14 @@ var vacuumRvcRunModeConfig = {
           }
         }
         if (roomIds.length > 0) {
-          logger220.info(
+          logger222.info(
             `Starting cleaning with selected areas: ${roomIds.join(", ")}`
           );
           if (isDreameVacuum(attributes8)) {
             if (targetMapName) {
               const vacName = vacuumEntityId.replace("vacuum.", "");
               const selectedMapEntity = `select.${vacName}_selected_map`;
-              logger220.info(
+              logger222.info(
                 `Dreame multi-floor: switching to map "${targetMapName}" via ${selectedMapEntity}`
               );
               homeAssistant.callAction({
@@ -159421,7 +159679,7 @@ var vacuumRvcRunModeConfig = {
           }
           if (isEcovacsVacuum(attributes8)) {
             const roomIdStr = roomIds.join(",");
-            logger220.info(
+            logger222.info(
               `Ecovacs vacuum: Using spot_area for rooms: ${roomIdStr}`
             );
             return {
@@ -159436,14 +159694,14 @@ var vacuumRvcRunModeConfig = {
               }
             };
           }
-          logger220.warn(
+          logger222.warn(
             `Room cleaning via send_command not supported for this vacuum type. Rooms: ${roomIds.join(", ")}. Falling back to vacuum.start`
           );
         }
       }
     } catch {
     }
-    logger220.info("Starting regular cleaning (no areas selected)");
+    logger222.info("Starting regular cleaning (no areas selected)");
     return { action: "vacuum.start" };
   },
   returnToBase: () => ({ action: "vacuum.return_to_base" }),
@@ -159458,7 +159716,7 @@ var vacuumRvcRunModeConfig = {
     const homeAssistant = agent.get(HomeAssistantEntityBehavior);
     const entity = homeAssistant.entity;
     const attributes8 = entity.state.attributes;
-    logger220.info(`cleanRoom called: roomMode=${roomMode}`);
+    logger222.info(`cleanRoom called: roomMode=${roomMode}`);
     const cleanAreaRooms = homeAssistant.state.mapping?.cleanAreaRooms;
     if (cleanAreaRooms && cleanAreaRooms.length > 0) {
       const sorted = [...cleanAreaRooms].sort(
@@ -159467,7 +159725,7 @@ var vacuumRvcRunModeConfig = {
       const areaIndex = roomMode - ROOM_MODE_BASE2 - 1;
       if (areaIndex >= 0 && areaIndex < sorted.length) {
         const area = sorted[areaIndex];
-        logger220.info(
+        logger222.info(
           `cleanRoom: CLEAN_AREA "${area.name}" \u2192 vacuum.clean_area(${area.haAreaId})`
         );
         return {
@@ -159484,7 +159742,7 @@ var vacuumRvcRunModeConfig = {
       const areaIndex = roomMode - ROOM_MODE_BASE2 - 1;
       if (areaIndex >= 0 && areaIndex < sorted.length) {
         const area = sorted[areaIndex];
-        logger220.info(
+        logger222.info(
           `cleanRoom: custom service area "${area.name}" \u2192 ${area.service}`
         );
         return {
@@ -159505,7 +159763,7 @@ var vacuumRvcRunModeConfig = {
     }
     const rooms = parseVacuumRooms(attributes8);
     const numericIdFromMode = getRoomIdFromMode(roomMode);
-    logger220.info(
+    logger222.info(
       `cleanRoom: numericIdFromMode=${numericIdFromMode}, available rooms: ${JSON.stringify(rooms.map((r) => ({ id: r.id, name: r.name, modeValue: getRoomModeValue(r) })))}`
     );
     const room = rooms.find((r) => getRoomModeValue(r) === roomMode);
@@ -159515,7 +159773,7 @@ var vacuumRvcRunModeConfig = {
         if (room.mapName) {
           const vacuumName = vacuumEntityId.replace("vacuum.", "");
           const selectedMapEntity = `select.${vacuumName}_selected_map`;
-          logger220.info(
+          logger222.info(
             `Dreame multi-floor: switching to map "${room.mapName}" via ${selectedMapEntity}`
           );
           homeAssistant.callAction({
@@ -159524,7 +159782,7 @@ var vacuumRvcRunModeConfig = {
             data: { option: room.mapName }
           });
         }
-        logger220.debug(
+        logger222.debug(
           `Dreame vacuum detected, using dreame_vacuum.vacuum_clean_segment for room ${room.name} (commandId: ${commandId3}, id: ${room.id})`
         );
         return {
@@ -159535,7 +159793,7 @@ var vacuumRvcRunModeConfig = {
         };
       }
       if (isRoborockVacuum(attributes8) || isXiaomiMiotVacuum(attributes8)) {
-        logger220.debug(
+        logger222.debug(
           `Using vacuum.send_command with app_segment_clean for room ${room.name} (commandId: ${commandId3}, id: ${room.id})`
         );
         return {
@@ -159548,7 +159806,7 @@ var vacuumRvcRunModeConfig = {
       }
       if (isEcovacsVacuum(attributes8)) {
         const roomIdStr = String(commandId3);
-        logger220.info(
+        logger222.info(
           `Ecovacs vacuum: Using spot_area for room ${room.name} (id: ${roomIdStr})`
         );
         return {
@@ -159563,7 +159821,7 @@ var vacuumRvcRunModeConfig = {
           }
         };
       }
-      logger220.warn(
+      logger222.warn(
         `Room cleaning via send_command not supported for this vacuum type. Room: ${room.name} (id=${commandId3}). Falling back to vacuum.start`
       );
     }
@@ -159574,31 +159832,31 @@ function createVacuumRvcRunModeServer(attributes8, includeUnnamedRooms = false,
   const allRooms = parseVacuumRooms(attributes8, true);
   const rooms = includeUnnamedRooms ? allRooms : parseVacuumRooms(attributes8, false);
   const filteredCount = allRooms.length - rooms.length;
-  const supportedModes = buildSupportedModes2(
+  const supportedModes2 = buildSupportedModes2(
     attributes8,
     includeUnnamedRooms,
     customAreas,
     disableRoomModes
   );
-  logger220.info(
-    `Creating VacuumRvcRunModeServer with ${rooms.length} rooms, ${supportedModes.length} total modes`
+  logger222.info(
+    `Creating VacuumRvcRunModeServer with ${rooms.length} rooms, ${supportedModes2.length} total modes`
   );
   if (rooms.length > 0) {
-    logger220.info(`Rooms found: ${rooms.map((r) => r.name).join(", ")}`);
+    logger222.info(`Rooms found: ${rooms.map((r) => r.name).join(", ")}`);
   }
   if (filteredCount > 0) {
     const filtered = allRooms.filter((r) => !rooms.some((x) => x.id === r.id));
-    logger220.info(
+    logger222.info(
       `Filtered out ${filteredCount} unnamed room(s): ${filtered.map((r) => r.name).join(", ")}`
     );
   }
   if (allRooms.length === 0) {
-    logger220.debug(
+    logger222.debug(
       `No rooms found. Attributes: rooms=${JSON.stringify(attributes8.rooms)}, segments=${JSON.stringify(attributes8.segments)}, room_list=${attributes8.room_list}`
     );
   }
   return RvcRunModeServer2(vacuumRvcRunModeConfig, {
-    supportedModes,
+    supportedModes: supportedModes2,
     currentMode: 0 /* Idle */
   });
 }
@@ -159627,7 +159885,7 @@ function createCleanAreaRvcRunModeServer(cleanAreaRooms) {
       modeTags: [{ value: RvcRunMode3.ModeTag.Cleaning }]
     });
   }
-  logger220.info(
+  logger222.info(
     `Creating CLEAN_AREA RvcRunModeServer with ${cleanAreaRooms.length} HA areas, ${modes.length} total modes`
   );
   return RvcRunModeServer2(vacuumRvcRunModeConfig, {
@@ -159687,7 +159945,7 @@ init_nodejs();
 
 // src/matter/behaviors/rvc-clean-mode-server.ts
 init_home_assistant_entity_behavior();
-var logger221 = Logger.get("RvcCleanModeServerBase");
+var logger223 = Logger.get("RvcCleanModeServerBase");
 var RvcCleanModeServerBase = class _RvcCleanModeServerBase extends RvcCleanModeServer {
   // Pending mode from a recent changeToMode command.
   // Prevents stale HA state (from a different entity like select.xxx)
@@ -159734,14 +159992,14 @@ var RvcCleanModeServerBase = class _RvcCleanModeServerBase extends RvcCleanModeS
     const homeAssistant = this.agent.get(HomeAssistantEntityBehavior);
     const { newMode } = request;
     if (newMode !== this.state.currentMode && !this.state.supportedModes.some((m) => m.mode === newMode)) {
-      logger221.warn(`changeToMode(${newMode}) rejected: unsupported mode`);
+      logger223.warn(`changeToMode(${newMode}) rejected: unsupported mode`);
       return {
         status: ModeBase3.ModeChangeStatus.UnsupportedMode,
         statusText: `Unsupported mode: ${newMode}`
       };
     }
     const modeLabel = this.state.supportedModes.find((m) => m.mode === newMode);
-    logger221.info(
+    logger223.info(
       `changeToMode(${newMode}) "${modeLabel?.label ?? "unknown"}" for ${homeAssistant.entityId}`
     );
     this.pendingMode = newMode;
@@ -159749,7 +160007,7 @@ var RvcCleanModeServerBase = class _RvcCleanModeServerBase extends RvcCleanModeS
     this.state.currentMode = newMode;
     const action = this.state.config.setCleanMode(newMode, this.agent);
     if (action) {
-      logger221.info(
+      logger223.info(
         `changeToMode: dispatching action ${action.action} \u2192 ${action.target ?? homeAssistant.entityId}`
       );
       homeAssistant.callAction(action);
@@ -159782,7 +160040,7 @@ function RvcCleanModeServer2(config11, initialState) {
 }
 
 // src/matter/endpoints/legacy/vacuum/behaviors/vacuum-rvc-clean-mode-server.ts
-var logger222 = Logger.get("VacuumRvcCleanModeServer");
+var logger224 = Logger.get("VacuumRvcCleanModeServer");
 var MODE_VACUUM = 0;
 var MODE_VACUUM_AND_MOP = 1;
 var MODE_MOP = 2;
@@ -160052,7 +160310,7 @@ function findMatchingCleanOption(ct, availableOptions) {
     const match = availableOptions.find((o) => classifyCleanOption(o) === type);
     if (match) return match;
   }
-  logger222.warn(
+  logger224.warn(
     `No match for ${CLEAN_TYPE_LABELS[ct]} in [${availableOptions.join(", ")}]`
   );
   return availableOptions[0];
@@ -160061,7 +160319,7 @@ function buildCleaningModeAction(targetCleanType, agent) {
   const selectEntityId = getCleaningModeSelectEntity(agent);
   const { options } = readSelectEntity(selectEntityId, agent);
   const optionToUse = findMatchingCleanOption(targetCleanType, options);
-  logger222.info(
+  logger224.info(
     `Switching cleaning mode to: ${optionToUse} via ${selectEntityId}`
   );
   return {
@@ -160150,7 +160408,7 @@ function createCleanModeConfig(fanSpeedList, mopIntensityList, cleaningModeOptio
           }
         }
         if (speedMode !== void 0) {
-          logger222.debug(
+          logger224.debug(
             `Current mode: Vacuum + fan_speed="${speedState}" -> mode ${speedMode}`
           );
           return speedMode;
@@ -160171,7 +160429,7 @@ function createCleanModeConfig(fanSpeedList, mopIntensityList, cleaningModeOptio
           }
         }
         if (mopMode !== void 0) {
-          logger222.debug(
+          logger224.debug(
             `Current mode: Mop + intensity="${state}" -> mode ${mopMode}`
           );
           return mopMode;
@@ -160189,14 +160447,14 @@ function createCleanModeConfig(fanSpeedList, mopIntensityList, cleaningModeOptio
       const homeAssistant = agent.get(HomeAssistantEntityBehavior);
       const vacuumEntityId = homeAssistant.entityId;
       const mapping = homeAssistant.state.mapping;
-      logger222.info(
+      logger224.info(
         `setCleanMode(${mode}) for ${vacuumEntityId}, suctionEntity=${mapping?.suctionLevelEntity ?? "none"}, mopEntity=${mapping?.mopIntensityEntity ?? "none"}, fanSpeedList=${JSON.stringify(fanSpeedList ?? [])}, mopIntensityList=${JSON.stringify(mopIntensityList ?? [])}, customTags=${JSON.stringify(customFanSpeedTags ?? {})}`
       );
       if (mopIntensityList && mopIntensityList.length > 0 && isMopIntensityMode(mode)) {
         const mopIndex = mode - MOP_INTENSITY_MODE_BASE;
         const mopName = mopIntensityList[mopIndex];
         if (!mopName) {
-          logger222.warn(`Invalid mop intensity mode index: ${mopIndex}`);
+          logger224.warn(`Invalid mop intensity mode index: ${mopIndex}`);
           return void 0;
         }
         if (hasCleanTypes) {
@@ -160209,18 +160467,18 @@ function createCleanModeConfig(fanSpeedList, mopIntensityList, cleaningModeOptio
             mapping.mopIntensityEntity,
             agent
           );
-          logger222.info(
+          logger224.info(
             `Mop intensity entity ${mapping.mopIntensityEntity}: current="${state}", options=${JSON.stringify(options ?? [])}`
           );
           let option = matchMopIntensityOption(mopName, options);
           if (!option && options && mopIndex < options.length) {
             option = options[mopIndex];
-            logger222.info(
+            logger224.info(
               `Positional match for mop "${mopName}" -> "${option}" (index ${mopIndex})`
             );
           }
           if (option) {
-            logger222.info(
+            logger224.info(
               `Setting mop intensity to: ${option} via ${mapping.mopIntensityEntity}`
             );
             return {
@@ -160229,11 +160487,11 @@ function createCleanModeConfig(fanSpeedList, mopIntensityList, cleaningModeOptio
               target: mapping.mopIntensityEntity
             };
           }
-          logger222.warn(
+          logger224.warn(
             `No match for mop intensity "${mopName}" in options: [${(options ?? []).join(", ")}]`
           );
         } else {
-          logger222.warn(
+          logger224.warn(
             `Mop intensity mode ${mode} requested but no mopIntensityEntity configured`
           );
         }
@@ -160243,7 +160501,7 @@ function createCleanModeConfig(fanSpeedList, mopIntensityList, cleaningModeOptio
         const fanSpeedIndex = mode - FAN_SPEED_MODE_BASE;
         const fanSpeedName = fanSpeedList[fanSpeedIndex];
         if (!fanSpeedName) {
-          logger222.warn(`Invalid fan speed mode index: ${fanSpeedIndex}`);
+          logger224.warn(`Invalid fan speed mode index: ${fanSpeedIndex}`);
           return void 0;
         }
         if (mapping?.suctionLevelEntity) {
@@ -160256,7 +160514,7 @@ function createCleanModeConfig(fanSpeedList, mopIntensityList, cleaningModeOptio
             mapping.suctionLevelEntity,
             agent
           );
-          logger222.info(
+          logger224.info(
             `Suction entity ${mapping.suctionLevelEntity}: current="${state}", options=${JSON.stringify(options ?? [])}`
           );
           let option = matchFanSpeedOption(
@@ -160266,12 +160524,12 @@ function createCleanModeConfig(fanSpeedList, mopIntensityList, cleaningModeOptio
           );
           if (!option && options && fanSpeedIndex < options.length) {
             option = options[fanSpeedIndex];
-            logger222.info(
+            logger224.info(
               `Positional match for fan "${fanSpeedName}" -> "${option}" (index ${fanSpeedIndex})`
             );
           }
           if (option) {
-            logger222.info(
+            logger224.info(
               `Setting suction to: ${option} via ${mapping.suctionLevelEntity}`
             );
             return {
@@ -160280,7 +160538,7 @@ function createCleanModeConfig(fanSpeedList, mopIntensityList, cleaningModeOptio
               target: mapping.suctionLevelEntity
             };
           }
-          logger222.warn(
+          logger224.warn(
             `No match for fan speed "${fanSpeedName}" in suction options: [${(options ?? []).join(", ")}]`
           );
           return void 0;
@@ -160290,7 +160548,7 @@ function createCleanModeConfig(fanSpeedList, mopIntensityList, cleaningModeOptio
             buildCleaningModeAction(0 /* Sweeping */, agent)
           );
         }
-        logger222.info(
+        logger224.info(
           `Setting fan speed to: ${fanSpeedName} via vacuum.set_fan_speed`
         );
         return {
@@ -160300,7 +160558,7 @@ function createCleanModeConfig(fanSpeedList, mopIntensityList, cleaningModeOptio
         };
       }
       if (!hasCleanTypes) {
-        logger222.debug(
+        logger224.debug(
           `Ignoring cleaning type change (mode=${mode}): no cleaning mode entity`
         );
         return void 0;
@@ -160312,7 +160570,7 @@ function createCleanModeConfig(fanSpeedList, mopIntensityList, cleaningModeOptio
         agent
       );
       const optionToUse = findMatchingCleanOption(cleanType, availableOptions);
-      logger222.info(
+      logger224.info(
         `Setting cleaning mode to: ${optionToUse} (mode=${mode}) via ${selectEntityId}`
       );
       return {
@@ -160324,20 +160582,20 @@ function createCleanModeConfig(fanSpeedList, mopIntensityList, cleaningModeOptio
   };
 }
 function createVacuumRvcCleanModeServer(_attributes, fanSpeedList, mopIntensityList, cleaningModeOptions, customFanSpeedTags) {
-  const supportedModes = buildSupportedModes3(
+  const supportedModes2 = buildSupportedModes3(
     fanSpeedList,
     mopIntensityList,
     cleaningModeOptions,
     customFanSpeedTags
   );
-  logger222.info(
-    `Creating VacuumRvcCleanModeServer with ${supportedModes.length} modes (fanSpeedList=${JSON.stringify(fanSpeedList ?? [])}, mopIntensityList=${JSON.stringify(mopIntensityList ?? [])}, cleaningModeOptions=${JSON.stringify(cleaningModeOptions ?? [])}, customTags=${JSON.stringify(customFanSpeedTags ?? {})})`
+  logger224.info(
+    `Creating VacuumRvcCleanModeServer with ${supportedModes2.length} modes (fanSpeedList=${JSON.stringify(fanSpeedList ?? [])}, mopIntensityList=${JSON.stringify(mopIntensityList ?? [])}, cleaningModeOptions=${JSON.stringify(cleaningModeOptions ?? [])}, customTags=${JSON.stringify(customFanSpeedTags ?? {})})`
   );
-  logger222.info(
-    `Modes: ${supportedModes.map((m) => `${m.mode}:${m.label}[${m.modeTags.map((t) => t.value).join(",")}]`).join(", ")}`
+  logger224.info(
+    `Modes: ${supportedModes2.map((m) => `${m.mode}:${m.label}[${m.modeTags.map((t) => t.value).join(",")}]`).join(", ")}`
   );
   const initialState = {
-    supportedModes,
+    supportedModes: supportedModes2,
     currentMode: MODE_VACUUM
   };
   return RvcCleanModeServer2(
@@ -160396,141 +160654,7 @@ function resolveMopIntensityList(mopIntensityEntity) {
 init_dist();
 init_esm();
 init_home_assistant_entity_behavior();
-
-// src/matter/behaviors/rvc-operational-state-server.ts
-init_esm();
-
-// ../../node_modules/.pnpm/@matter+main@0.17.2/node_modules/@matter/main/dist/esm/forwards/behaviors/rvc-operational-state.js
-init_nodejs();
-
-// ../../node_modules/.pnpm/@matter+main@0.17.2/node_modules/@matter/main/dist/esm/forwards/clusters/rvc-operational-state.js
-init_nodejs();
-
-// src/matter/behaviors/rvc-operational-state-server.ts
-init_home_assistant_entity_behavior();
-var OperationalState4 = RvcOperationalState4.OperationalState;
-var ErrorState = RvcOperationalState4.ErrorState;
-var logger223 = Logger.get("RvcOperationalStateServer");
-var activeStates = /* @__PURE__ */ new Set([
-  OperationalState4.Running,
-  OperationalState4.SeekingCharger
-]);
-var advertisedOperationalStates = [
-  OperationalState4.Stopped,
-  OperationalState4.Running,
-  OperationalState4.Paused,
-  OperationalState4.Error,
-  OperationalState4.SeekingCharger,
-  OperationalState4.Charging,
-  OperationalState4.Docked
-];
-function makeRvcOperationalError(errorStateId) {
-  if (errorStateId === ErrorState.NoError) {
-    return { errorStateId };
-  }
-  return { errorStateId, errorStateDetails: ErrorState[errorStateId] };
-}
-var RvcOperationalStateServerBase = class extends RvcOperationalStateServer {
-  async initialize() {
-    this.state.operationalStateList = advertisedOperationalStates.map((id) => ({
-      operationalStateId: id
-    }));
-    this.state.operationalState = OperationalState4.Stopped;
-    this.state.operationalError = { errorStateId: ErrorState.NoError };
-    await super.initialize();
-    const homeAssistant = await this.agent.load(HomeAssistantEntityBehavior);
-    this.update(homeAssistant.entity);
-    this.reactTo(homeAssistant.onChange, this.update, { offline: true });
-  }
-  update(entity) {
-    if (!entity.state || !entity.state.attributes) {
-      return;
-    }
-    const newState = this.state.config.getOperationalState(
-      entity.state,
-      this.agent
-    );
-    const previousState = this.state.operationalState;
-    const errorStateId = newState === OperationalState4.Error ? ErrorState.Stuck : ErrorState.NoError;
-    const operationalError = makeRvcOperationalError(errorStateId);
-    applyPatchState(
-      this.state,
-      {
-        operationalState: newState,
-        operationalError
-      },
-      { force: true }
-    );
-    if (activeStates.has(previousState) && !activeStates.has(newState)) {
-      logger223.info(
-        `Operation completed: ${OperationalState4[previousState]} -> ${OperationalState4[newState]}`
-      );
-      try {
-        this.events.operationCompletion?.emit(
-          {
-            completionErrorCode: newState === OperationalState4.Error ? ErrorState.Stuck : ErrorState.NoError,
-            totalOperationalTime: null,
-            pausedTime: null
-          },
-          this.context
-        );
-      } catch (e) {
-        logger223.debug("Failed to emit operationCompletion event:", e);
-      }
-    }
-  }
-  pause() {
-    const homeAssistant = this.agent.get(HomeAssistantEntityBehavior);
-    homeAssistant.callAction(this.state.config.pause(void 0, this.agent));
-    return {
-      commandResponseState: {
-        errorStateId: ErrorState.NoError
-      }
-    };
-  }
-  resume() {
-    const homeAssistant = this.agent.get(HomeAssistantEntityBehavior);
-    homeAssistant.callAction(this.state.config.resume(void 0, this.agent));
-    return {
-      commandResponseState: {
-        errorStateId: ErrorState.NoError
-      }
-    };
-  }
-  goHome() {
-    if (this.state.operationalState === OperationalState4.Docked || this.state.operationalState === OperationalState4.Charging) {
-      return {
-        commandResponseState: {
-          errorStateId: ErrorState.NoError
-        }
-      };
-    }
-    const goHomeAction = this.state.config.goHome;
-    if (goHomeAction) {
-      const homeAssistant = this.agent.get(HomeAssistantEntityBehavior);
-      homeAssistant.callAction(goHomeAction(void 0, this.agent));
-    } else {
-      logger223.warn("GoHome command received but no goHome action configured");
-    }
-    return {
-      commandResponseState: {
-        errorStateId: ErrorState.NoError
-      }
-    };
-  }
-};
-((RvcOperationalStateServerBase2) => {
-  class State extends RvcOperationalStateServer.State {
-    config;
-  }
-  RvcOperationalStateServerBase2.State = State;
-})(RvcOperationalStateServerBase || (RvcOperationalStateServerBase = {}));
-function RvcOperationalStateServer2(config11) {
-  return RvcOperationalStateServerBase.set({ config: config11 });
-}
-
-// src/matter/endpoints/legacy/vacuum/behaviors/vacuum-rvc-operational-state-server.ts
-var logger224 = Logger.get("VacuumRvcOperationalStateServer");
+var logger225 = Logger.get("VacuumRvcOperationalStateServer");
 function isCharging(entity) {
   const attrs = entity.attributes;
   if (attrs.is_charging === true || attrs.charging === true) return true;
@@ -160575,16 +160699,16 @@ function mapVacuumOperationalState(entity) {
     operationalState = RvcOperationalState4.OperationalState.Error;
   } else {
     if (state.toLowerCase().includes("clean")) {
-      logger224.info(
+      logger225.info(
         `Unknown vacuum state "${state}" contains 'clean', treating as Running`
       );
       operationalState = RvcOperationalState4.OperationalState.Running;
     } else {
-      logger224.info(`Unknown vacuum state "${state}", treating as Stopped`);
+      logger225.info(`Unknown vacuum state "${state}", treating as Stopped`);
       operationalState = RvcOperationalState4.OperationalState.Stopped;
     }
   }
-  logger224.debug(
+  logger225.debug(
     `Vacuum operationalState: "${state}" -> ${RvcOperationalState4.OperationalState[operationalState]}`
   );
   return operationalState;
@@ -160609,7 +160733,7 @@ var VacuumRvcOperationalStateServer = RvcOperationalStateServer2({
 });
 
 // src/matter/endpoints/legacy/vacuum/index.ts
-var logger225 = Logger.get("VacuumDevice");
+var logger226 = Logger.get("VacuumDevice");
 var VacuumEndpointType = RoboticVacuumCleanerDevice.with(
   BasicInformationServer2,
   VacuumIdentifyServer,
@@ -160623,7 +160747,7 @@ function VacuumDevice(homeAssistantEntity, includeOnOff = false, cleaningModeOpt
   const entityId = homeAssistantEntity.entity.entity_id;
   const attributes8 = homeAssistantEntity.entity.state.attributes;
   const customAreas = homeAssistantEntity.mapping?.customServiceAreas;
-  logger225.info(
+  logger226.info(
     `Creating vacuum endpoint for ${entityId}, mapping: ${JSON.stringify(homeAssistantEntity.mapping ?? "none")}`
   );
   const cleanAreaRooms = homeAssistantEntity.mapping?.cleanAreaRooms;
@@ -160636,32 +160760,32 @@ function VacuumDevice(homeAssistantEntity, includeOnOff = false, cleaningModeOpt
     )
   ).set({ homeAssistantEntity });
   if (includeOnOff) {
-    logger225.info(`${entityId}: Adding OnOff cluster (vacuumOnOff flag enabled)`);
+    logger226.info(`${entityId}: Adding OnOff cluster (vacuumOnOff flag enabled)`);
     device = device.with(VacuumOnOffServer);
   }
   device = device.with(VacuumPowerSourceServer);
   const roomEntities = homeAssistantEntity.mapping?.roomEntities;
   const rooms = parseVacuumRooms(attributes8);
-  logger225.info(
+  logger226.info(
     `${entityId}: customAreas=${customAreas?.length ?? 0}, roomEntities=${JSON.stringify(roomEntities ?? [])}, parsedRooms=${rooms.length}, cleanAreaRooms=${cleanAreaRooms?.length ?? 0}`
   );
   if (cleanAreaRooms && cleanAreaRooms.length > 0) {
-    logger225.info(
+    logger226.info(
       `${entityId}: Adding ServiceArea (${cleanAreaRooms.length} HA areas via CLEAN_AREA)`
     );
     device = device.with(createCleanAreaServiceAreaServer(cleanAreaRooms));
   } else if (customAreas && customAreas.length > 0) {
-    logger225.info(
+    logger226.info(
       `${entityId}: Adding ServiceArea (${customAreas.length} custom areas)`
     );
     device = device.with(createCustomServiceAreaServer(customAreas));
   } else if (rooms.length > 0 || roomEntities && roomEntities.length > 0) {
-    logger225.info(`${entityId}: Adding ServiceArea (${rooms.length} rooms)`);
+    logger226.info(`${entityId}: Adding ServiceArea (${rooms.length} rooms)`);
     device = device.with(
       createVacuumServiceAreaServer(attributes8, roomEntities)
     );
   } else {
-    logger225.info(`${entityId}: Adding ServiceArea (default single-area)`);
+    logger226.info(`${entityId}: Adding ServiceArea (default single-area)`);
     device = device.with(createDefaultServiceAreaServer());
   }
   const fanSpeedList = resolveFanSpeedList(
@@ -160672,7 +160796,7 @@ function VacuumDevice(homeAssistantEntity, includeOnOff = false, cleaningModeOpt
     homeAssistantEntity.mapping?.mopIntensityEntity
   );
   if (cleaningModeOptions || fanSpeedList || mopIntensityList) {
-    logger225.info(
+    logger226.info(
       `${entityId}: Adding RvcCleanMode (multi-mode, cleaningModeOptions=${JSON.stringify(cleaningModeOptions ?? [])}, fanSpeedList=${JSON.stringify(fanSpeedList ?? [])}, mopIntensityList=${JSON.stringify(mopIntensityList ?? [])})`
     );
     device = device.with(
@@ -160685,7 +160809,7 @@ function VacuumDevice(homeAssistantEntity, includeOnOff = false, cleaningModeOpt
       )
     );
   } else {
-    logger225.info(`${entityId}: Adding RvcCleanMode (default single-mode)`);
+    logger226.info(`${entityId}: Adding RvcCleanMode (default single-mode)`);
     device = device.with(createDefaultRvcCleanModeServer());
   }
   return device;
@@ -160851,7 +160975,7 @@ var WaterHeaterThermostatServer = ThermostatServer2(
 );
 
 // src/matter/endpoints/legacy/water-heater/index.ts
-var logger226 = Logger.get("WaterHeaterDevice");
+var logger227 = Logger.get("WaterHeaterDevice");
 var WaterHeaterDeviceType = ThermostatDevice.with(
   BasicInformationServer2,
   IdentifyServer2,
@@ -160867,7 +160991,7 @@ function toMatterTemp2(value) {
 }
 function WaterHeaterDevice(homeAssistantEntity) {
   const attributes8 = homeAssistantEntity.entity.state.attributes;
-  logger226.debug(
+  logger227.debug(
     `Creating device for ${homeAssistantEntity.entity.entity_id}, min_temp=${attributes8.min_temp}, max_temp=${attributes8.max_temp}`
   );
   const minLimit = toMatterTemp2(attributes8.min_temp) ?? 0;
@@ -161015,6 +161139,7 @@ var deviceCtrs = {
   siren: SirenDevice,
   media_player: MediaPlayerDevice,
   humidifier: HumidifierDevice,
+  lawn_mower: LawnMowerDevice,
   vacuum: VacuumDevice,
   valve: ValveDevice,
   alarm_control_panel: AlarmControlPanelDevice,
@@ -161044,6 +161169,7 @@ var matterDeviceTypeFactories = {
   fan: FanDevice2,
   air_purifier: AirPurifierEndpoint,
   robot_vacuum_cleaner: (ha) => VacuumDevice(ha),
+  robotic_lawn_mower: (ha) => LawnMowerDevice(ha),
   humidifier_dehumidifier: HumidifierDevice,
   speaker: SpeakerMediaPlayerDevice,
   basic_video_player: VideoPlayerDevice,
@@ -161077,7 +161203,7 @@ var matterDeviceTypeFactories = {
 };
 
 // src/matter/endpoints/composed/user-composed-endpoint.ts
-var logger227 = Logger.get("UserComposedEndpoint");
+var logger228 = Logger.get("UserComposedEndpoint");
 function stripBasicInformation(type) {
   const behaviors = { ...type.behaviors };
   delete behaviors.bridgedDeviceBasicInformation;
@@ -161133,7 +161259,7 @@ var UserComposedEndpoint = class _UserComposedEndpoint extends Endpoint {
       { vacuumOnOff: registry2.isVacuumOnOffEnabled() }
     );
     if (!primaryType) {
-      logger227.warn(
+      logger228.warn(
         `Cannot create endpoint type for primary entity ${primaryEntityId}`
       );
       return void 0;
@@ -161148,7 +161274,7 @@ var UserComposedEndpoint = class _UserComposedEndpoint extends Endpoint {
       if (!sub.entityId) continue;
       const subPayload = buildEntityPayload4(registry2, sub.entityId);
       if (!subPayload) {
-        logger227.warn(
+        logger228.warn(
           `Cannot find entity state for composed sub-entity ${sub.entityId}`
         );
         continue;
@@ -161159,7 +161285,7 @@ var UserComposedEndpoint = class _UserComposedEndpoint extends Endpoint {
       };
       const subType = createLegacyEndpointType(subPayload, subMapping);
       if (!subType) {
-        logger227.warn(
+        logger228.warn(
           `Cannot create endpoint type for composed sub-entity ${sub.entityId}`
         );
         continue;
@@ -161172,7 +161298,7 @@ var UserComposedEndpoint = class _UserComposedEndpoint extends Endpoint {
       mappedIds.push(sub.entityId);
     }
     if (parts.length < 2) {
-      logger227.warn(
+      logger228.warn(
         `User composed device ${primaryEntityId}: only ${parts.length} sub-endpoint(s), need at least 2 (primary + one sub-entity). Falling back to standalone.`
       );
       return void 0;
@@ -161195,7 +161321,7 @@ var UserComposedEndpoint = class _UserComposedEndpoint extends Endpoint {
     const labels = parts.map(
       (_, i) => i === 0 ? primaryEntityId.split(".")[0] : composedEntities[i - 1]?.entityId?.split(".")[0] ?? "?"
     ).join("+");
-    logger227.info(
+    logger228.info(
       `Created user composed device ${primaryEntityId}: ${parts.length} sub-endpoint(s) [${labels}]`
     );
     return endpoint;
@@ -161283,7 +161409,7 @@ function asStandaloneEndpointType(type) {
 }
 
 // src/matter/endpoints/legacy/legacy-endpoint.ts
-var logger228 = Logger.get("LegacyEndpoint");
+var logger229 = Logger.get("LegacyEndpoint");
 var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
   static async create(registry2, entityId, mapping, pluginDomainMappings, standalone = false) {
     const deviceRegistry = registry2.deviceOf(entityId);
@@ -161293,25 +161419,25 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
       return;
     }
     if (registry2.isAutoBatteryMappingEnabled() && registry2.isBatteryEntityUsed(entityId)) {
-      logger228.debug(
+      logger229.debug(
         `Skipping ${entityId} - already auto-assigned as battery to another device`
       );
       return;
     }
     if (registry2.isAutoHumidityMappingEnabled() && registry2.isHumidityEntityUsed(entityId)) {
-      logger228.debug(
+      logger229.debug(
         `Skipping ${entityId} - already auto-assigned as humidity to a temperature sensor`
       );
       return;
     }
     if (registry2.isAutoPressureMappingEnabled() && registry2.isPressureEntityUsed(entityId)) {
-      logger228.debug(
+      logger229.debug(
         `Skipping ${entityId} - already auto-assigned as pressure to a temperature sensor`
       );
       return;
     }
     if (registry2.isAutoComposedDevicesEnabled() && registry2.isComposedSubEntityUsed(entityId)) {
-      logger228.debug(
+      logger229.debug(
         `Skipping ${entityId} - already consumed by a composed device`
       );
       return;
@@ -161331,7 +161457,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
               humidityEntity: humidityEntityId
             };
             registry2.markHumidityEntityUsed(humidityEntityId);
-            logger228.debug(
+            logger229.debug(
               `Auto-assigned humidity ${humidityEntityId} to ${entityId}`
             );
           }
@@ -161350,7 +161476,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
               pressureEntity: pressureEntityId
             };
             registry2.markPressureEntityUsed(pressureEntityId);
-            logger228.debug(
+            logger229.debug(
               `Auto-assigned pressure ${pressureEntityId} to ${entityId}`
             );
           }
@@ -161368,7 +161494,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
             batteryEntity: batteryEntityId
           };
           registry2.markBatteryEntityUsed(batteryEntityId);
-          logger228.debug(
+          logger229.debug(
             `Auto-assigned battery ${batteryEntityId} to ${entityId}`
           );
         }
@@ -161386,7 +161512,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
               powerEntity: powerEntityId
             };
             registry2.markPowerEntityUsed(powerEntityId);
-            logger228.debug(`Auto-assigned power ${powerEntityId} to ${entityId}`);
+            logger229.debug(`Auto-assigned power ${powerEntityId} to ${entityId}`);
           }
         }
       }
@@ -161403,7 +161529,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
               energyEntity: energyEntityId
             };
             registry2.markEnergyEntityUsed(energyEntityId);
-            logger228.debug(
+            logger229.debug(
               `Auto-assigned energy ${energyEntityId} to ${entityId}`
             );
           }
@@ -161419,7 +161545,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
             entityId: effectiveMapping?.entityId ?? entityId,
             cleaningModeEntity: vacuumEntities.cleaningModeEntity
           };
-          logger228.info(
+          logger229.info(
             `Auto-assigned cleaningMode ${vacuumEntities.cleaningModeEntity} to ${entityId}`
           );
         }
@@ -161429,7 +161555,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
             entityId: effectiveMapping?.entityId ?? entityId,
             suctionLevelEntity: vacuumEntities.suctionLevelEntity
           };
-          logger228.info(
+          logger229.info(
             `Auto-assigned suctionLevel ${vacuumEntities.suctionLevelEntity} to ${entityId}`
           );
         }
@@ -161439,7 +161565,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
             entityId: effectiveMapping?.entityId ?? entityId,
             mopIntensityEntity: vacuumEntities.mopIntensityEntity
           };
-          logger228.info(
+          logger229.info(
             `Auto-assigned mopIntensity ${vacuumEntities.mopIntensityEntity} to ${entityId}`
           );
         }
@@ -161449,7 +161575,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
             entityId: effectiveMapping?.entityId ?? entityId,
             currentRoomEntity: vacuumEntities.currentRoomEntity
           };
-          logger228.info(
+          logger229.info(
             `Auto-assigned currentRoom ${vacuumEntities.currentRoomEntity} to ${entityId}`
           );
         }
@@ -161464,7 +161590,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
             entityId: effectiveMapping?.entityId ?? entityId,
             cleanAreaRooms
           };
-          logger228.info(
+          logger229.info(
             `Using ${cleanAreaRooms.length} HA areas via CLEAN_AREA for ${entityId}`
           );
         }
@@ -161485,7 +161611,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
                 rooms: roomsObj
               }
             };
-            logger228.debug(
+            logger229.debug(
               `Auto-detected ${valetudoRooms.length} Valetudo segments for ${entityId}`
             );
           } else {
@@ -161502,7 +161628,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
                   rooms: roomsObj
                 }
               };
-              logger228.debug(
+              logger229.debug(
                 `Auto-detected ${roborockRooms.length} Roborock rooms for ${entityId}`
               );
             }
@@ -161511,7 +161637,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
       }
     }
     if (standalone && ((effectiveMapping?.composedEntities?.length ?? 0) > 0 || effectiveMapping?.climateExposeFan === true)) {
-      logger228.warn(
+      logger229.warn(
         `Composed mappings are not supported in server mode, exposing ${entityId} as a flat standalone endpoint`
       );
     }
@@ -161528,7 +161654,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
       if (composed) {
         return composed;
       }
-      logger228.warn(
+      logger229.warn(
         `User composed device creation failed for ${entityId}, falling back to standalone`
       );
     }
@@ -161587,7 +161713,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
         if (composed) {
           return composed;
         }
-        logger228.warn(
+        logger229.warn(
           `Companion fan creation failed for ${entityId}, falling back to standalone`
         );
       }
@@ -161654,11 +161780,11 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
     }
     if (mappedChanged) {
       this.pendingMappedChange = true;
-      logger228.debug(
+      logger229.debug(
         `Mapped entity change detected for ${this.entityId}, forcing update`
       );
     }
-    logger228.debug(
+    logger229.debug(
       `State update received for ${this.entityId}: state=${state.state}`
     );
     this.lastState = state;
@@ -161711,7 +161837,7 @@ import {
   getCollection
 } from "home-assistant-js-websocket";
 import { atLeastHaVersion } from "home-assistant-js-websocket/dist/util.js";
-var logger229 = Logger.get("SubscribeEntities");
+var logger230 = Logger.get("SubscribeEntities");
 function processEvent(store, updates) {
   const state = { ...store.state };
   if (updates.a) {
@@ -161737,7 +161863,7 @@ function processEvent(store, updates) {
     for (const entityId in updates.c) {
       let entityState = state[entityId];
       if (!entityState) {
-        logger229.warn("Received state update for unknown entity", entityId);
+        logger230.warn("Received state update for unknown entity", entityId);
         continue;
       }
       entityState = { ...entityState };
@@ -161826,7 +161952,7 @@ var subscribeEntities = (conn, onChange, entityIds) => {
 // src/services/bridges/entity-isolation-service.ts
 init_esm();
 init_diagnostic_event_bus();
-var logger230 = Logger.get("EntityIsolation");
+var logger231 = Logger.get("EntityIsolation");
 var EntityIsolationServiceImpl = class {
   isolatedEntities = /* @__PURE__ */ new Map();
   isolationCallbacks = /* @__PURE__ */ new Map();
@@ -161891,13 +162017,13 @@ var EntityIsolationServiceImpl = class {
     }
     const parsed = this.parseEndpointPath(msg);
     if (!parsed) {
-      logger230.warn("Could not parse entity from error:", msg);
+      logger231.warn("Could not parse entity from error:", msg);
       return false;
     }
     const { bridgeId, entityName } = parsed;
     const callback = this.isolationCallbacks.get(bridgeId);
     if (!callback) {
-      logger230.warn(
+      logger231.warn(
         `No isolation callback registered for bridge ${bridgeId}, entity: ${entityName}`
       );
       return false;
@@ -161908,7 +162034,7 @@ var EntityIsolationServiceImpl = class {
     }
     const reason = `${classification}. Entity isolated to protect bridge stability.`;
     this.isolatedEntities.set(key, { entityId: entityName, reason });
-    logger230.warn(
+    logger231.warn(
       `Isolating entity "${entityName}" from bridge ${bridgeId} due to: ${reason}`
     );
     diagnosticEventBus.emit("entity_error", `Entity isolated: ${entityName}`, {
@@ -161920,7 +162046,7 @@ var EntityIsolationServiceImpl = class {
       await callback(entityName);
       return true;
     } catch (e) {
-      logger230.error(`Failed to isolate entity ${entityName}:`, e);
+      logger231.error(`Failed to isolate entity ${entityName}:`, e);
       return false;
     }
   }
@@ -163264,11 +163390,11 @@ function makeWarmStartState(state, now = (/* @__PURE__ */ new Date()).toISOStrin
   return { ...state, last_updated: now };
 }
 var ServerModeBridge = class {
-  constructor(logger233, dataProvider, endpointManager, server) {
+  constructor(logger234, dataProvider, endpointManager, server) {
     this.dataProvider = dataProvider;
     this.endpointManager = endpointManager;
     this.server = server;
-    this.log = logger233.get(`ServerModeBridge / ${dataProvider.id}`);
+    this.log = logger234.get(`ServerModeBridge / ${dataProvider.id}`);
   }
   dataProvider;
   endpointManager;
@@ -163902,7 +164028,7 @@ function ServerModeVacuumDevice(homeAssistantEntity, includeOnOff = false, clean
 }
 
 // src/matter/endpoints/server-mode-vacuum-endpoint.ts
-var logger231 = Logger.get("ServerModeVacuumEndpoint");
+var logger232 = Logger.get("ServerModeVacuumEndpoint");
 var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEndpoint {
   static async create(registry2, entityId, mapping) {
     const deviceRegistry = registry2.deviceOf(entityId);
@@ -163912,7 +164038,7 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
       return void 0;
     }
     let effectiveMapping = mapping;
-    logger231.info(
+    logger232.info(
       `${entityId}: device_id=${entity.device_id}, manualBattery=${mapping?.batteryEntity ?? "none"}`
     );
     if (entity.device_id) {
@@ -163927,15 +164053,15 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
             batteryEntity: batteryEntityId
           };
           registry2.markBatteryEntityUsed(batteryEntityId);
-          logger231.info(`${entityId}: Auto-assigned battery ${batteryEntityId}`);
+          logger232.info(`${entityId}: Auto-assigned battery ${batteryEntityId}`);
         } else {
           const attrs = state.attributes;
           if (attrs.battery_level != null || attrs.battery != null) {
-            logger231.info(
+            logger232.info(
               `${entityId}: No battery entity found, using battery attribute from vacuum state`
             );
           } else {
-            logger231.warn(
+            logger232.warn(
               `${entityId}: No battery entity found for device ${entity.device_id}`
             );
           }
@@ -163950,7 +164076,7 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
           entityId: effectiveMapping?.entityId ?? entityId,
           cleaningModeEntity: vacuumEntities.cleaningModeEntity
         };
-        logger231.info(
+        logger232.info(
           `${entityId}: Auto-assigned cleaningMode ${vacuumEntities.cleaningModeEntity}`
         );
       }
@@ -163960,7 +164086,7 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
           entityId: effectiveMapping?.entityId ?? entityId,
           suctionLevelEntity: vacuumEntities.suctionLevelEntity
         };
-        logger231.info(
+        logger232.info(
           `${entityId}: Auto-assigned suctionLevel ${vacuumEntities.suctionLevelEntity}`
         );
       }
@@ -163970,7 +164096,7 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
           entityId: effectiveMapping?.entityId ?? entityId,
           mopIntensityEntity: vacuumEntities.mopIntensityEntity
         };
-        logger231.info(
+        logger232.info(
           `${entityId}: Auto-assigned mopIntensity ${vacuumEntities.mopIntensityEntity}`
         );
       }
@@ -163980,7 +164106,7 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
           entityId: effectiveMapping?.entityId ?? entityId,
           currentRoomEntity: vacuumEntities.currentRoomEntity
         };
-        logger231.info(
+        logger232.info(
           `${entityId}: Auto-assigned currentRoom ${vacuumEntities.currentRoomEntity}`
         );
       }
@@ -163995,7 +164121,7 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
           entityId: effectiveMapping?.entityId ?? entityId,
           cleanAreaRooms
         };
-        logger231.info(
+        logger232.info(
           `${entityId}: Using ${cleanAreaRooms.length} HA areas via CLEAN_AREA`
         );
       }
@@ -164016,7 +164142,7 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
               rooms: roomsObj
             }
           };
-          logger231.info(
+          logger232.info(
             `${entityId}: Auto-detected ${valetudoRooms.length} Valetudo segments`
           );
         } else {
@@ -164033,14 +164159,14 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
                 rooms: roomsObj
               }
             };
-            logger231.info(
+            logger232.info(
               `${entityId}: Auto-detected ${roborockRooms.length} Roborock rooms`
             );
           }
         }
       }
     } else {
-      logger231.warn(`${entityId}: No device_id, cannot auto-assign battery`);
+      logger232.warn(`${entityId}: No device_id, cannot auto-assign battery`);
     }
     const payload = {
       entity_id: entityId,
@@ -164112,11 +164238,11 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
     }
     if (mappedChanged) {
       this.pendingMappedChange = true;
-      logger231.debug(
+      logger232.debug(
         `Mapped entity change detected for ${this.entityId}, forcing update`
       );
     }
-    logger231.debug(
+    logger232.debug(
       `State update received for ${this.entityId}: state=${state.state}`
     );
     this.lastState = state;
@@ -164601,10 +164727,10 @@ var BridgeEnvironmentFactory = class extends BridgeFactory {
 // src/core/ioc/app-environment.ts
 var AppEnvironment = class _AppEnvironment extends EnvironmentBase {
   constructor(rootEnv, options) {
-    const logger233 = rootEnv.get(LoggerService);
+    const logger234 = rootEnv.get(LoggerService);
     super({
       id: "App",
-      log: logger233.get("AppContainer"),
+      log: logger234.get("AppContainer"),
       parent: rootEnv
     });
     this.options = options;
@@ -164618,8 +164744,8 @@ var AppEnvironment = class _AppEnvironment extends EnvironmentBase {
   }
   construction;
   async init() {
-    const logger233 = this.get(LoggerService);
-    this.set(LoggerService, logger233);
+    const logger234 = this.get(LoggerService);
+    this.set(LoggerService, logger234);
     this.set(AppStorage, new AppStorage(await this.load(StorageService)));
     this.set(BridgeStorage, new BridgeStorage(await this.load(AppStorage)));
     this.set(
@@ -164636,7 +164762,7 @@ var AppEnvironment = class _AppEnvironment extends EnvironmentBase {
     );
     this.set(
       HomeAssistantClient,
-      new HomeAssistantClient(logger233, this.options.homeAssistant)
+      new HomeAssistantClient(logger234, this.options.homeAssistant)
     );
     this.set(
       HomeAssistantConfig,
@@ -164644,7 +164770,7 @@ var AppEnvironment = class _AppEnvironment extends EnvironmentBase {
     );
     this.set(
       HomeAssistantActions,
-      new HomeAssistantActions(logger233, await this.load(HomeAssistantClient))
+      new HomeAssistantActions(logger234, await this.load(HomeAssistantClient))
     );
     this.set(
       HomeAssistantRegistry,
@@ -164680,7 +164806,7 @@ var AppEnvironment = class _AppEnvironment extends EnvironmentBase {
     this.set(
       WebApi,
       new WebApi(
-        logger233,
+        logger234,
         await this.load(BridgeService),
         await this.load(HomeAssistantClient),
         await this.load(HomeAssistantRegistry),
@@ -164705,7 +164831,7 @@ init_esm();
 init_nodejs();
 
 // src/matter/patches/patch-level-control-tlv.ts
-var logger232 = Logger.get("PatchLevelControlTlv");
+var logger233 = Logger.get("PatchLevelControlTlv");
 function patchLevelControlTlv() {
   let patched = 0;
   const moveToLevelFields = LevelControl3.MoveToLevelRequest.fieldDefinitions;
@@ -164719,11 +164845,11 @@ function patchLevelControlTlv() {
     patched++;
   }
   if (patched > 0) {
-    logger232.info(
+    logger233.info(
       `Patched ${patched} LevelControl TLV schema(s): transitionTime is now optional (Google Home compatibility)`
     );
   } else {
-    logger232.warn(
+    logger233.warn(
       "Failed to patch LevelControl TLV schemas, field definitions not found. Google Home brightness adjustment may not work."
     );
   }
@@ -167015,13 +167141,13 @@ export {
 @matter/main/dist/esm/forwards/behaviors/smoke-co-alarm.js:
 @matter/main/dist/esm/forwards/behaviors/operational-state.js:
 @matter/main/dist/esm/forwards/clusters/operational-state.js:
-@matter/main/dist/esm/forwards/behaviors/color-control.js:
-@matter/main/dist/esm/forwards/behaviors/pump-configuration-and-control.js:
+@matter/main/dist/esm/forwards/behaviors/rvc-operational-state.js:
+@matter/main/dist/esm/forwards/clusters/rvc-operational-state.js:
 @matter/main/dist/esm/forwards/clusters/mode-base.js:
 @matter/main/dist/esm/forwards/clusters/rvc-run-mode.js:
+@matter/main/dist/esm/forwards/behaviors/color-control.js:
+@matter/main/dist/esm/forwards/behaviors/pump-configuration-and-control.js:
 @matter/main/dist/esm/forwards/clusters/rvc-clean-mode.js:
-@matter/main/dist/esm/forwards/behaviors/rvc-operational-state.js:
-@matter/main/dist/esm/forwards/clusters/rvc-operational-state.js:
 @matter/main/dist/esm/forwards/clusters/level-control.js:
   (**
    * @license