@riddix/hamh 2.1.0-alpha.566 → 2.1.0-alpha.568

package/dist/backend/cli.js

@@ -177925,18 +177925,6 @@ var RvcOperationalStateServerBase = class extends RvcOperationalStateServer {
     this.state.operationalError = { errorStateId: ErrorState.NoError };
     await super.initialize();
     const homeAssistant = await this.agent.load(HomeAssistantEntityBehavior);
-    try {
-      const events = this.events;
-      events.operationalError$Changed?.on(() => {
-        logger195.info(
-          `#287 diag[3]: operationalError$Changed fired for ${homeAssistant.entityId}`
-        );
-      });
-    } catch (e) {
-      logger195.warn(
-        `#287 diag[3]: failed to attach operationalError$Changed listener: ${e instanceof Error ? e.message : String(e)}`
-      );
-    }
     this.update(homeAssistant.entity);
     this.reactTo(homeAssistant.onChange, this.update);
   }
@@ -177949,9 +177937,6 @@ var RvcOperationalStateServerBase = class extends RvcOperationalStateServer {
       this.agent
     );
     const previousState = this.state.operationalState;
-    logger195.info(
-      `#287 diag[2]: update() reactor invoked for ${entity.entity_id} \u2014 prevState=${previousState} newState=${newState} nonceBefore=${this.keepaliveNonce}`
-    );
     this.keepaliveNonce = !this.keepaliveNonce;
     const errorStateId = newState === OperationalState4.Error ? ErrorState.Stuck : ErrorState.NoError;
     const operationalError = { errorStateId };
@@ -181186,20 +181171,32 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
   lastState;
   pendingMappedChange = false;
   flushUpdate;
-  /** Periodic keepalive timer that re-pushes the last known state so
-   *  Apple Home (iOS) doesn't show "Updating..." due to stale
-   *  subscription data when the vacuum is idle and no HA events fire. */
+  /** Periodic keepalive timer that writes directly to the
+   *  RvcOperationalState cluster in a fresh transaction so Apple Home
+   *  (iOS) doesn't show "Updating..." due to stale subscription data
+   *  when the vacuum is idle and no HA events fire.
+   *
+   *  Previous approaches that pushed state through
+   *  HomeAssistantEntityBehavior failed because the reactor writes
+   *  (RvcOperationalStateServer.update()) run inside the postCommit
+   *  phase of the HAEntityBehavior transaction — those writes are
+   *  buffered but never committed, so no attrsChanged event reaches
+   *  the ServerSubscription.
+   *
+   *  Writing directly via endpoint.act() creates an independent
+   *  transaction that goes through the full commit lifecycle. */
   keepaliveTimer;
+  /** Monotonic counter that ensures operationalError is structurally
+   *  different on every keepalive tick. matter.js's Datasource uses
+   *  isDeepEqual; a unique errorStateLabel value guarantees the struct
+   *  is never deep-equal to its predecessor. */
+  keepaliveCounter = 0;
   constructor(type, entityId, customName, mappedEntityIds) {
     super(type, entityId, customName, mappedEntityIds);
     this.flushUpdate = debounce6(this.flushPendingUpdate.bind(this), 50);
     this.keepaliveTimer = setInterval(() => {
       if (this.lastState) {
-        logger203.info(
-          `#287 diag[1]: keepalive tick for ${this.entityId} \u2014 scheduling flushUpdate`
-        );
-        this.pendingMappedChange = true;
-        this.flushUpdate(this.lastState);
+        this.pushKeepalive();
       }
     }, 55e3);
   }
@@ -181211,6 +181208,37 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
     this.flushUpdate.clear();
     await super.delete();
   }
+  /**
+   * Write directly to the RvcOperationalState cluster in a fresh
+   * transaction.  Each call produces a unique errorStateLabel value
+   * so the struct is never deep-equal to its predecessor,
+   * guaranteeing matter.js emits attrsChanged → subscription report.
+   */
+  async pushKeepalive() {
+    try {
+      this.keepaliveCounter++;
+      const counter = this.keepaliveCounter;
+      logger203.info(`Keepalive #${counter} for ${this.entityId}`);
+      await this.act("vacuum-keepalive", async (agent) => {
+        const opState = agent.get(RvcOperationalStateServer);
+        const errorStateId = opState.state.operationalError.errorStateId;
+        opState.state.operationalError = {
+          errorStateId,
+          errorStateLabel: `k${counter}`
+        };
+      });
+      logger203.info(`Keepalive #${counter} committed for ${this.entityId}`);
+    } catch (e) {
+      if (e instanceof TransactionDestroyedError || e instanceof DestroyedDependencyError) {
+        return;
+      }
+      const msg = e instanceof Error ? e.message : String(e);
+      if (msg.includes("Endpoint storage inaccessible")) {
+        return;
+      }
+      logger203.warn(`Keepalive failed for ${this.entityId}: ${msg}`);
+    }
+  }
   async updateStates(states) {
     const state = states[this.entityId] ?? {};
     const mappedChanged = this.hasMappedEntityChanged(states);