@riddix/hamh 2.1.0-alpha.835 → 2.1.0-alpha.837

package/dist/backend/cli.js

@@ -132058,6 +132058,12 @@ var init_bridge_config_schema = __esm({
           description: "Anchor each device to its Home Assistant entity registry id instead of the entity id, so renaming an entity no longer re-adds it in your controller (Alexa, Google Home, Apple Home) and keeps groups and automations. Records are seeded from the start, so enabling this later is safe and never re-adds existing devices. Default off.",
           type: "boolean",
           default: false
+        },
+        wedgeWatchdog: {
+          title: "Wedge Watchdog (Apple 'Updating' workaround)",
+          description: "Rotate the one session that looks wedged, subscriptions still alive but no inbound request from the controller for about 45 minutes, earlier than the blind session rotation. Targets Apple Home tiles stuck on 'Updating' where the controller keeps acking but stops consuming data. A false positive only triggers a transparent reconnect, the same as normal rotation. Default off.",
+          type: "boolean",
+          default: false
         }
       }
     };
@@ -135034,6 +135040,298 @@ function resolveLabelValue(value, labels) {
   return value.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
 }
 
+// src/matter/endpoints/entity-endpoint.ts
+init_esm7();
+var EntityEndpoint = class extends Endpoint {
+  constructor(type, entityId, customName, mappedEntityIds, endpointId) {
+    super(type, { id: endpointId ?? createEndpointId(entityId, customName) });
+    this.entityId = entityId;
+    this.mappedEntityIds = mappedEntityIds ?? [];
+  }
+  entityId;
+  mappedEntityIds;
+  lastMappedStates = {};
+  hasMappedEntityChanged(states) {
+    let changed = false;
+    for (const mappedId of this.mappedEntityIds) {
+      const mappedState = states[mappedId];
+      if (!mappedState) continue;
+      const fp = mappedState.state;
+      if (fp !== this.lastMappedStates[mappedId]) {
+        this.lastMappedStates[mappedId] = fp;
+        changed = true;
+      }
+    }
+    return changed;
+  }
+};
+function createEndpointId(entityId, customName) {
+  const baseName = customName || entityId;
+  return baseName.replace(/\./g, "_").replace(/\s+/g, "_");
+}
+function getMappedEntityIds(mapping) {
+  if (!mapping) return [];
+  const ids = [];
+  if (mapping.batteryEntity && !mapping.disableBatteryMapping) {
+    ids.push(mapping.batteryEntity);
+  }
+  if (mapping.faultEntity) ids.push(mapping.faultEntity);
+  if (mapping.chargingStateEntity) ids.push(mapping.chargingStateEntity);
+  if (mapping.temperatureEntity) ids.push(mapping.temperatureEntity);
+  if (mapping.humidityEntity) ids.push(mapping.humidityEntity);
+  if (mapping.pressureEntity) ids.push(mapping.pressureEntity);
+  if (mapping.cleaningModeEntity) ids.push(mapping.cleaningModeEntity);
+  if (mapping.suctionLevelEntity) ids.push(mapping.suctionLevelEntity);
+  if (mapping.mopIntensityEntity) ids.push(mapping.mopIntensityEntity);
+  if (mapping.filterLifeEntity) ids.push(mapping.filterLifeEntity);
+  if (mapping.powerEntity) ids.push(mapping.powerEntity);
+  if (mapping.energyEntity) ids.push(mapping.energyEntity);
+  if (mapping.voltageEntity) ids.push(mapping.voltageEntity);
+  if (mapping.currentEntity) ids.push(mapping.currentEntity);
+  if (mapping.batteryPowerEntity) ids.push(mapping.batteryPowerEntity);
+  if (mapping.batteryEnergyEntity) ids.push(mapping.batteryEnergyEntity);
+  if (mapping.currentRoomEntity) ids.push(mapping.currentRoomEntity);
+  if (mapping.cleanedAreaEntity) ids.push(mapping.cleanedAreaEntity);
+  if (mapping.composedEntities) {
+    for (const sub of mapping.composedEntities) {
+      if (sub.entityId) ids.push(sub.entityId);
+    }
+  }
+  return ids;
+}
+
+// src/services/bridges/identity-resolver.ts
+var SEP = "\0";
+function identityKey(entity) {
+  const uniqueId = entity.registry?.unique_id;
+  const platform = entity.registry?.platform;
+  if (!uniqueId || !platform) {
+    return null;
+  }
+  const domain = entity.entity_id.split(".")[0];
+  return platform + SEP + domain + SEP + uniqueId;
+}
+var IdentityResolver = class {
+  constructor(identityStorage, mappingStorage) {
+    this.identityStorage = identityStorage;
+    this.mappingStorage = mappingStorage;
+  }
+  identityStorage;
+  mappingStorage;
+  async resolveIdentity(bridgeId, entity, mapping, opts) {
+    const entityId = entity.entity_id;
+    const key = identityKey(entity);
+    if (key == null) {
+      return {
+        endpointId: createEndpointId(entityId, mapping?.customName),
+        anchorEntityId: entityId,
+        protected: false
+      };
+    }
+    const existing = this.identityStorage.getIdentity(bridgeId, key);
+    if (existing) {
+      const renamedFrom = existing.lastEntityId !== entityId ? existing.lastEntityId ?? existing.anchorEntityId : void 0;
+      if (opts.stableIdentity) {
+        if (renamedFrom) {
+          this.identityStorage.setIdentity(bridgeId, key, {
+            ...existing,
+            lastEntityId: entityId
+          });
+          await this.rekeyMapping(bridgeId, renamedFrom, entityId);
+        }
+        return {
+          endpointId: existing.endpointId,
+          anchorEntityId: existing.anchorEntityId,
+          protected: true,
+          renamedFrom
+        };
+      }
+      const liveEndpointId = createEndpointId(entityId, mapping?.customName);
+      if (existing.endpointId !== liveEndpointId || existing.anchorEntityId !== entityId || existing.lastEntityId !== entityId) {
+        this.identityStorage.setIdentity(bridgeId, key, {
+          ...existing,
+          endpointId: liveEndpointId,
+          anchorEntityId: entityId,
+          lastEntityId: entityId
+        });
+      }
+      return {
+        endpointId: liveEndpointId,
+        anchorEntityId: entityId,
+        protected: false,
+        renamedFrom
+      };
+    }
+    const desired = createEndpointId(entityId, mapping?.customName);
+    let endpointId = desired;
+    if (opts.stableIdentity) {
+      let n = 2;
+      while (opts.isEndpointIdTaken(endpointId, key)) {
+        endpointId = `${desired}_${n++}`;
+      }
+    }
+    const record = {
+      endpointId,
+      anchorEntityId: entityId,
+      lastEntityId: entityId,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.identityStorage.setIdentity(bridgeId, key, record);
+    if (opts.stableIdentity) {
+      return {
+        endpointId: record.endpointId,
+        anchorEntityId: record.anchorEntityId,
+        protected: true
+      };
+    }
+    return {
+      endpointId: desired,
+      anchorEntityId: entityId,
+      protected: false
+    };
+  }
+  // Carry a mapping from the old entity_id to the new one on rename. anchorEntityId
+  // never changes, only the mapping key. Skips when no old mapping exists or a new
+  // one already does, so a manual mapping under the new id is never clobbered.
+  async rekeyMapping(bridgeId, oldEntityId, newEntityId) {
+    if (oldEntityId === newEntityId) {
+      return;
+    }
+    const old = this.mappingStorage.getMapping(bridgeId, oldEntityId);
+    if (!old) {
+      return;
+    }
+    if (this.mappingStorage.getMapping(bridgeId, newEntityId)) {
+      return;
+    }
+    await this.mappingStorage.setMapping({
+      ...old,
+      bridgeId,
+      entityId: newEntityId
+    });
+    await this.mappingStorage.deleteMapping(bridgeId, oldEntityId);
+  }
+};
+
+// src/services/storage/orphan-cleanup.ts
+var ORPHAN_TOMBSTONE_MS = 7 * 24 * 60 * 60 * 1e3;
+function buildPresentIdentityKeys(entities) {
+  const keys3 = /* @__PURE__ */ new Set();
+  for (const entity of Object.values(entities ?? {})) {
+    if (!entity?.entity_id) continue;
+    const key = identityKey({ entity_id: entity.entity_id, registry: entity });
+    if (key != null) keys3.add(key);
+  }
+  return keys3;
+}
+function buildPresentEntityIds(entities) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const entity of Object.values(entities ?? {})) {
+    if (entity?.entity_id) ids.add(entity.entity_id);
+  }
+  return ids;
+}
+function stampIdentityPresence(store, bridgeId, presentKeys, now = Date.now()) {
+  const nowIso = new Date(now).toISOString();
+  for (const key of [...store.getBridgeIdentities(bridgeId).keys()]) {
+    if (presentKeys.has(key)) {
+      store.clearIdentityMissing(bridgeId, key);
+    } else {
+      store.markIdentityMissing(bridgeId, key, nowIso);
+    }
+  }
+}
+function stampMappingPresence(store, bridgeId, presentEntityIds, now = Date.now()) {
+  const nowIso = new Date(now).toISOString();
+  const entityIds = store.getMappingsForBridge(bridgeId).map((m) => m.entityId);
+  for (const entityId of entityIds) {
+    if (presentEntityIds.has(entityId)) {
+      store.clearMappingMissing(bridgeId, entityId);
+    } else {
+      store.markMappingMissing(bridgeId, entityId, nowIso);
+    }
+  }
+}
+function computeOrphanCandidates(input) {
+  const now = input.now ?? Date.now();
+  const candidates = [];
+  for (const [key, record] of input.identities) {
+    if (!record.missingSince) continue;
+    const missingFor = now - Date.parse(record.missingSince);
+    if (!(missingFor >= ORPHAN_TOMBSTONE_MS)) continue;
+    if (input.presentKeys.has(key)) continue;
+    const lastEntityId = record.lastEntityId ?? record.anchorEntityId;
+    candidates.push({
+      identityKey: key,
+      lastEntityId,
+      missingSince: record.missingSince,
+      // Only a true orphan mapping, not one a live entity holds under a reused
+      // entity_id (a different identity key). Guards the sweep from clobbering
+      // that live entity's custom mapping.
+      hasMapping: input.hasMapping(lastEntityId) && !input.presentEntityIds.has(lastEntityId),
+      kind: "identity"
+    });
+  }
+  if (input.mappings) {
+    const linkedByIdentity = /* @__PURE__ */ new Set();
+    for (const candidate of candidates) {
+      if (candidate.hasMapping) linkedByIdentity.add(candidate.lastEntityId);
+    }
+    for (const mapping of input.mappings) {
+      if (!mapping.missingSince) continue;
+      const missingFor = now - Date.parse(mapping.missingSince);
+      if (!(missingFor >= ORPHAN_TOMBSTONE_MS)) continue;
+      if (input.presentEntityIds.has(mapping.entityId)) continue;
+      if (linkedByIdentity.has(mapping.entityId)) continue;
+      candidates.push({
+        identityKey: mapping.entityId,
+        lastEntityId: mapping.entityId,
+        missingSince: mapping.missingSince,
+        hasMapping: true,
+        kind: "mapping"
+      });
+    }
+  }
+  return candidates;
+}
+async function executeOrphanCleanup(input) {
+  const candidates = computeOrphanCandidates({
+    bridgeId: input.bridgeId,
+    identities: input.identities,
+    presentKeys: input.presentKeys,
+    presentEntityIds: input.presentEntityIds,
+    hasMapping: (entityId) => input.getMapping(input.bridgeId, entityId) != null,
+    mappings: input.mappings,
+    now: input.now
+  });
+  const byKey = new Map(candidates.map((c) => [c.identityKey, c]));
+  const results = [];
+  for (const key of input.requestedKeys) {
+    const candidate = byKey.get(key);
+    if (!candidate) {
+      results.push({
+        identityKey: key,
+        deleted: false,
+        reason: "not a current orphan candidate"
+      });
+      continue;
+    }
+    if (candidate.kind === "mapping") {
+      if (!input.presentEntityIds.has(candidate.lastEntityId)) {
+        await input.deleteMapping(input.bridgeId, candidate.lastEntityId);
+      }
+      results.push({ identityKey: key, deleted: true });
+      continue;
+    }
+    if (candidate.hasMapping && !input.presentEntityIds.has(candidate.lastEntityId)) {
+      await input.deleteMapping(input.bridgeId, candidate.lastEntityId);
+    }
+    await input.deleteIdentity(input.bridgeId, key);
+    results.push({ identityKey: key, deleted: true });
+  }
+  return results;
+}
+
 // src/utils/json/endpoint-to-json.ts
 function safeClone(value, depth = 0) {
   if (depth > 20 || value === null || value === void 0) return value;
@@ -135079,7 +135377,7 @@ function endpointToJson(endpoint, parentId) {
 
 // src/api/matter-api.ts
 var ajv = new Ajv();
-function matterApi(bridgeService, haRegistry, identityStorage) {
+function matterApi(bridgeService, haRegistry, identityStorage, mappingStorage) {
   const router = express11.Router();
   router.get("/", (_, res) => {
     res.status(200).json({});
@@ -135182,6 +135480,64 @@ function matterApi(bridgeService, haRegistry, identityStorage) {
       });
     }
   });
+  router.get("/bridges/:bridgeId/orphans", async (req, res) => {
+    const bridgeId = req.params.bridgeId;
+    const bridge = bridgeService.bridges.find((b) => b.id === bridgeId);
+    if (!bridge) {
+      res.status(404).send("Not Found");
+      return;
+    }
+    if (!haRegistry || !identityStorage) {
+      res.status(503).json({ error: "Orphan cleanup is not available" });
+      return;
+    }
+    const presentKeys = buildPresentIdentityKeys(haRegistry.entities);
+    const presentEntityIds = buildPresentEntityIds(haRegistry.entities);
+    const candidates = computeOrphanCandidates({
+      bridgeId,
+      identities: identityStorage.getBridgeIdentities(bridgeId),
+      presentKeys,
+      presentEntityIds,
+      hasMapping: (entityId) => mappingStorage?.getMapping(bridgeId, entityId) != null,
+      mappings: mappingStorage?.getMappingsForBridge(bridgeId)
+    });
+    res.status(200).json({ candidates });
+  });
+  router.post(
+    "/bridges/:bridgeId/actions/cleanup-orphans",
+    async (req, res) => {
+      const bridgeId = req.params.bridgeId;
+      const bridge = bridgeService.bridges.find((b) => b.id === bridgeId);
+      if (!bridge) {
+        res.status(404).send("Not Found");
+        return;
+      }
+      if (!haRegistry || !identityStorage || !mappingStorage) {
+        res.status(503).json({ error: "Orphan cleanup is not available" });
+        return;
+      }
+      const body = req.body;
+      const requestedKeys = Array.isArray(body?.identityKeys) ? body.identityKeys.filter((k) => typeof k === "string") : [];
+      try {
+        const results = await executeOrphanCleanup({
+          bridgeId,
+          requestedKeys,
+          identities: identityStorage.getBridgeIdentities(bridgeId),
+          presentKeys: buildPresentIdentityKeys(haRegistry.entities),
+          presentEntityIds: buildPresentEntityIds(haRegistry.entities),
+          getMapping: (b, e) => mappingStorage.getMapping(b, e),
+          deleteMapping: (b, e) => mappingStorage.deleteMapping(b, e),
+          deleteIdentity: (b, k) => identityStorage.deleteIdentity(b, k),
+          mappings: mappingStorage.getMappingsForBridge(bridgeId)
+        });
+        res.status(200).json({ results });
+      } catch (e) {
+        res.status(500).json({
+          error: e instanceof Error ? e.message : "Unknown error"
+        });
+      }
+    }
+  );
   router.get("/bridges/:bridgeId/devices", async (req, res) => {
     const bridgeId = req.params.bridgeId;
     const bridge = bridgeService.bridges.find((b) => b.id === bridgeId);
@@ -137201,7 +137557,12 @@ var WebApi = class extends Service {
     const api = express17.Router();
     api.use(express17.json()).use(nocache()).use(
       "/matter",
-      matterApi(this.bridgeService, this.haRegistry, this.identityStorage)
+      matterApi(
+        this.bridgeService,
+        this.haRegistry,
+        this.identityStorage,
+        this.mappingStorage
+      )
     ).use(
       "/health",
       healthApi(
@@ -139022,11 +139383,37 @@ var EntityIdentityStorage = class extends Service {
     this.identities.delete(bridgeId);
     await this.flush();
   }
+  // Drop a single identity record. Used by the manual orphan cleanup after the
+  // 7-day tombstone; flush immediately since it is a user-initiated deletion.
+  async deleteIdentity(bridgeId, key) {
+    const bridgeMap = this.identities.get(bridgeId);
+    if (bridgeMap?.delete(key)) {
+      await this.flush();
+    }
+  }
+  // Stamp the tombstone the first time a record's entity is absent from HA. Keeps
+  // the first-seen time on later passes and no-ops once stamped, so a steady
+  // absence does not churn the debounced persist.
+  markIdentityMissing(bridgeId, key, nowIso) {
+    const record = this.identities.get(bridgeId)?.get(key);
+    if (!record || record.missingSince != null) return;
+    record.missingSince = nowIso;
+    this.schedulePersist();
+  }
+  // Clear the tombstone when the entity is present again. No-ops when there is
+  // nothing to clear, so an all-present bridge writes nothing on refresh.
+  clearIdentityMissing(bridgeId, key) {
+    const record = this.identities.get(bridgeId)?.get(key);
+    if (!record || record.missingSince == null) return;
+    delete record.missingSince;
+    this.schedulePersist();
+  }
 };
 
 // src/services/storage/entity-mapping-storage.ts
 init_service();
 var CURRENT_VERSION2 = 1;
+var PERSIST_DEBOUNCE_MS2 = 500;
 var EntityMappingStorage = class extends Service {
   constructor(appStorage) {
     super("EntityMappingStorage");
@@ -139035,10 +139422,14 @@ var EntityMappingStorage = class extends Service {
   appStorage;
   storage;
   mappings = /* @__PURE__ */ new Map();
+  persistTimer = null;
   async initialize() {
     this.storage = this.appStorage.createContext("entity-mappings");
     await this.load();
   }
+  async dispose() {
+    await this.flush();
+  }
   async load() {
     const stored = await this.storage.get("data", {
       version: CURRENT_VERSION2,
@@ -139073,6 +139464,10 @@ var EntityMappingStorage = class extends Service {
     }
   }
   async persist() {
+    if (this.persistTimer) {
+      clearTimeout(this.persistTimer);
+      this.persistTimer = null;
+    }
     const data = {
       version: CURRENT_VERSION2,
       mappings: {}
@@ -139082,6 +139477,17 @@ var EntityMappingStorage = class extends Service {
     }
     await this.storage.set("data", data);
   }
+  schedulePersist() {
+    if (this.persistTimer) return;
+    this.persistTimer = setTimeout(() => {
+      this.persistTimer = null;
+      void this.persist();
+    }, PERSIST_DEBOUNCE_MS2);
+  }
+  // Flush any pending debounced write, used on dispose and by tests.
+  async flush() {
+    await this.persist();
+  }
   getMappingsForBridge(bridgeId) {
     const bridgeMap = this.mappings.get(bridgeId);
     return bridgeMap ? Array.from(bridgeMap.values()) : [];
@@ -139175,6 +139581,23 @@ var EntityMappingStorage = class extends Service {
     this.mappings.delete(bridgeId);
     await this.persist();
   }
+  // Stamp the tombstone the first time a mapping's entity is absent from HA.
+  // Keeps the first-seen time on later passes and no-ops once stamped, so a
+  // steady absence does not churn the debounced persist.
+  markMappingMissing(bridgeId, entityId, nowIso) {
+    const record = this.mappings.get(bridgeId)?.get(entityId);
+    if (!record || record.missingSince != null) return;
+    record.missingSince = nowIso;
+    this.schedulePersist();
+  }
+  // Clear the tombstone when the entity is present again. No-ops when there is
+  // nothing to clear, so an all-present bridge writes nothing on refresh.
+  clearMappingMissing(bridgeId, entityId) {
+    const record = this.mappings.get(bridgeId)?.get(entityId);
+    if (!record || record.missingSince == null) return;
+    delete record.missingSince;
+    this.schedulePersist();
+  }
 };
 function sanitizeVendorId(value) {
   if (value === void 0 || value === null || value === "") {
@@ -156805,7 +157228,23 @@ function seedExistingSessionStarts(startedAt, sessions, now = Date.now()) {
   }
 }
 
+// src/services/bridges/wedge-watchdog.ts
+var WEDGE_WARMUP_MS = 15 * 60 * 1e3;
+var WEDGE_IM_SILENCE_MS = 45 * 60 * 1e3;
+var WEDGE_MIN_ROTATE_INTERVAL_MS = 60 * 60 * 1e3;
+function decideWedgeRotation(input) {
+  const {
+    subscriptionCount,
+    sessionAgeMs,
+    lastImRequestMsAgo,
+    lastRotatedMsAgo
+  } = input;
+  const imSilenceMs = lastImRequestMsAgo == null ? sessionAgeMs : lastImRequestMsAgo;
+  return subscriptionCount > 0 && sessionAgeMs > WEDGE_WARMUP_MS && imSilenceMs > WEDGE_IM_SILENCE_MS && (lastRotatedMsAgo == null || lastRotatedMsAgo > WEDGE_MIN_ROTATE_INTERVAL_MS);
+}
+
 // src/services/bridges/bridge.ts
+var imWrapMarker = /* @__PURE__ */ Symbol("hamh.wedgeImWrap");
 var AUTO_FORCE_SYNC_INTERVAL_MS = 9e4;
 var SHUTDOWN_SESSION_CLOSE_TIMEOUT_MS = 2500;
 var MDNS_ADDRESS_CHECK_INTERVAL_MS = 6e4;
@@ -156853,6 +157292,12 @@ var Bridge = class {
   sessionStartedAt = /* @__PURE__ */ new Map();
   rotationTimer = null;
   maxSessionAgeMs = 0;
+  // Wedge watchdog: last inbound Interaction Model request time per session and
+  // last time the watchdog rotated it, both keyed by the long-lived session
+  // object so they clear when the session goes away.
+  lastImRequestAt = /* @__PURE__ */ new WeakMap();
+  wedgeLastRotatedAt = /* @__PURE__ */ new WeakMap();
+  wedgeWatchdogTimer = null;
   // Watches the advertised interface addresses so a dynamic ISP IPv6 prefix
   // change forces a fresh operational announcement (#415).
   mdnsAddressTimer = null;
@@ -156912,6 +157357,8 @@ var Bridge = class {
         const nowMs = Date.now();
         const lastActiveMsAgo = typeof s.activeTimestamp === "number" && s.activeTimestamp > 0 ? nowMs - s.activeTimestamp : null;
         const lastAnyActivityMsAgo = typeof s.timestamp === "number" ? nowMs - s.timestamp : null;
+        const lastImAt = this.lastImRequestAt.get(s);
+        const lastImRequestMsAgo = lastImAt != null ? nowMs - lastImAt : null;
         const startedAt = this.sessionStartedAt.get(s.id);
         return {
           id: s.id,
@@ -156920,6 +157367,7 @@ var Bridge = class {
           subscriptionCount: subCount,
           lastActiveMsAgo,
           lastAnyActivityMsAgo,
+          lastImRequestMsAgo,
           isPeerActive: Boolean(s.isPeerActive),
           ageMsFromOpen: startedAt != null ? nowMs - startedAt : null
         };
@@ -157086,6 +157534,7 @@ var Bridge = class {
       this.wireSessionDiagnostics();
       this.wireFabricWarnings();
       this.startSessionRotation();
+      this.startWedgeWatchdog();
       this.startMdnsAddressWatch();
       logMemoryUsage(this.log, "bridge running");
       diagnosticEventBus.emit("bridge_started", `Bridge started`, {
@@ -157285,6 +157734,29 @@ ${e?.toString()}`);
       };
       sessionManager.sessions.added.on(this.sessionAddedHandler);
       sessionManager.sessions.deleted.on(this.sessionDeletedHandler);
+      this.wireImRequestTracking();
+    } catch {
+    }
+  }
+  // Stamp the time of every inbound Interaction Model request per session by
+  // wrapping InteractionServer.onNewExchange. The wedge watchdog reads these to
+  // tell a live-but-consuming controller from one that only keeps acking.
+  wireImRequestTracking() {
+    try {
+      const is = this.server.env.get(InteractionServer);
+      const marked = is;
+      if (marked[imWrapMarker]) {
+        return;
+      }
+      const original = is.onNewExchange.bind(is);
+      is.onNewExchange = (exchange, message) => {
+        const session = exchange.session;
+        if (session) {
+          this.lastImRequestAt.set(session, Date.now());
+        }
+        return original(exchange, message);
+      };
+      marked[imWrapMarker] = true;
     } catch {
     }
   }
@@ -157447,6 +157919,7 @@ ${e?.toString()}`);
     }
     this.staleSessionTimers.clear();
     this.stopSessionRotation();
+    this.stopWedgeWatchdog();
     this.stopMdnsAddressWatch();
     this.sessionStartedAt.clear();
   }
@@ -157512,6 +157985,72 @@ ${e?.toString()}`);
       this.rotationTimer = null;
     }
   }
+  // Opt-in wedge watchdog: reuse the rotation check cadence (5min) to look for
+  // the one session wedged on "Updating" and rotate just that one.
+  startWedgeWatchdog() {
+    this.stopWedgeWatchdog();
+    if (!this.dataProvider.featureFlags?.wedgeWatchdog) {
+      return;
+    }
+    this.wedgeWatchdogTimer = setInterval(
+      () => this.runWedgeWatchdogCheck(),
+      ROTATION_CHECK_INTERVAL_MS
+    );
+    this.log.info(
+      `Wedge watchdog: checking every ${ROTATION_CHECK_INTERVAL_MS / 6e4}min`
+    );
+  }
+  stopWedgeWatchdog() {
+    if (this.wedgeWatchdogTimer) {
+      clearInterval(this.wedgeWatchdogTimer);
+      this.wedgeWatchdogTimer = null;
+    }
+  }
+  // Rotate exactly the sessions the pure rule flags as wedged. Closing is the
+  // same graceful-then-force path age rotation uses, so a false positive just
+  // re-CASEs the controller.
+  runWedgeWatchdogCheck() {
+    try {
+      const sessionManager = this.server.env.get(SessionManager);
+      const now = Date.now();
+      const closes = [];
+      for (const s of [...sessionManager.sessions]) {
+        if (s.isClosing) continue;
+        const startedAt = this.sessionStartedAt.get(s.id);
+        const sessionAgeMs = startedAt != null ? now - startedAt : 0;
+        const lastImAt = this.lastImRequestAt.get(s);
+        const lastImRequestMsAgo = lastImAt != null ? now - lastImAt : null;
+        const lastRotatedAt = this.wedgeLastRotatedAt.get(s);
+        const lastRotatedMsAgo = lastRotatedAt != null ? now - lastRotatedAt : null;
+        if (!decideWedgeRotation({
+          subscriptionCount: s.subscriptions.size,
+          sessionAgeMs,
+          lastImRequestMsAgo,
+          lastRotatedMsAgo
+        })) {
+          continue;
+        }
+        const silenceMin = Math.round(
+          (lastImRequestMsAgo ?? sessionAgeMs) / 6e4
+        );
+        this.log.info(
+          `Wedge watchdog: rotating session ${s.id}, no inbound interaction for ${silenceMin}min`
+        );
+        this.wedgeLastRotatedAt.set(s, now);
+        closes.push(
+          s.initiateClose().catch(() => {
+            return s.initiateForceClose({
+              cause: new Error("wedge watchdog, forcing")
+            });
+          })
+        );
+      }
+      if (closes.length > 0) {
+        Promise.allSettled(closes).then(() => this.triggerMdnsReAnnounce());
+      }
+    } catch {
+    }
+  }
   // Poll the interface addresses mDNS advertises and re-announce when they
   // change. matter.js caches the operational records at first announcement, so
   // a dynamic ISP IPv6 prefix change keeps advertising the dead global address
@@ -157643,6 +158182,7 @@ ${e?.toString()}`);
       if (this.status.code === BridgeStatus.Running) {
         this.startAutoForceSyncIfEnabled();
         this.startSessionRotation();
+        this.startWedgeWatchdog();
       }
     } catch (e) {
       const reason = "Failed to update bridge due to error:";
@@ -157765,66 +158305,6 @@ var AggregatorEndpoint2 = class extends Endpoint {
   }
 };
 
-// src/matter/endpoints/entity-endpoint.ts
-init_esm7();
-var EntityEndpoint = class extends Endpoint {
-  constructor(type, entityId, customName, mappedEntityIds, endpointId) {
-    super(type, { id: endpointId ?? createEndpointId(entityId, customName) });
-    this.entityId = entityId;
-    this.mappedEntityIds = mappedEntityIds ?? [];
-  }
-  entityId;
-  mappedEntityIds;
-  lastMappedStates = {};
-  hasMappedEntityChanged(states) {
-    let changed = false;
-    for (const mappedId of this.mappedEntityIds) {
-      const mappedState = states[mappedId];
-      if (!mappedState) continue;
-      const fp = mappedState.state;
-      if (fp !== this.lastMappedStates[mappedId]) {
-        this.lastMappedStates[mappedId] = fp;
-        changed = true;
-      }
-    }
-    return changed;
-  }
-};
-function createEndpointId(entityId, customName) {
-  const baseName = customName || entityId;
-  return baseName.replace(/\./g, "_").replace(/\s+/g, "_");
-}
-function getMappedEntityIds(mapping) {
-  if (!mapping) return [];
-  const ids = [];
-  if (mapping.batteryEntity && !mapping.disableBatteryMapping) {
-    ids.push(mapping.batteryEntity);
-  }
-  if (mapping.faultEntity) ids.push(mapping.faultEntity);
-  if (mapping.chargingStateEntity) ids.push(mapping.chargingStateEntity);
-  if (mapping.temperatureEntity) ids.push(mapping.temperatureEntity);
-  if (mapping.humidityEntity) ids.push(mapping.humidityEntity);
-  if (mapping.pressureEntity) ids.push(mapping.pressureEntity);
-  if (mapping.cleaningModeEntity) ids.push(mapping.cleaningModeEntity);
-  if (mapping.suctionLevelEntity) ids.push(mapping.suctionLevelEntity);
-  if (mapping.mopIntensityEntity) ids.push(mapping.mopIntensityEntity);
-  if (mapping.filterLifeEntity) ids.push(mapping.filterLifeEntity);
-  if (mapping.powerEntity) ids.push(mapping.powerEntity);
-  if (mapping.energyEntity) ids.push(mapping.energyEntity);
-  if (mapping.voltageEntity) ids.push(mapping.voltageEntity);
-  if (mapping.currentEntity) ids.push(mapping.currentEntity);
-  if (mapping.batteryPowerEntity) ids.push(mapping.batteryPowerEntity);
-  if (mapping.batteryEnergyEntity) ids.push(mapping.batteryEnergyEntity);
-  if (mapping.currentRoomEntity) ids.push(mapping.currentRoomEntity);
-  if (mapping.cleanedAreaEntity) ids.push(mapping.cleanedAreaEntity);
-  if (mapping.composedEntities) {
-    for (const sub of mapping.composedEntities) {
-      if (sub.entityId) ids.push(sub.entityId);
-    }
-  }
-  return ids;
-}
-
 // src/matter/endpoints/legacy/legacy-endpoint.ts
 init_dist();
 init_esm();
@@ -172802,119 +173282,6 @@ var EntityIsolationServiceImpl = class {
 };
 var EntityIsolationService = new EntityIsolationServiceImpl();
 
-// src/services/bridges/identity-resolver.ts
-var SEP = "\0";
-function identityKey(entity) {
-  const uniqueId = entity.registry?.unique_id;
-  const platform = entity.registry?.platform;
-  if (!uniqueId || !platform) {
-    return null;
-  }
-  const domain = entity.entity_id.split(".")[0];
-  return platform + SEP + domain + SEP + uniqueId;
-}
-var IdentityResolver = class {
-  constructor(identityStorage, mappingStorage) {
-    this.identityStorage = identityStorage;
-    this.mappingStorage = mappingStorage;
-  }
-  identityStorage;
-  mappingStorage;
-  async resolveIdentity(bridgeId, entity, mapping, opts) {
-    const entityId = entity.entity_id;
-    const key = identityKey(entity);
-    if (key == null) {
-      return {
-        endpointId: createEndpointId(entityId, mapping?.customName),
-        anchorEntityId: entityId,
-        protected: false
-      };
-    }
-    const existing = this.identityStorage.getIdentity(bridgeId, key);
-    if (existing) {
-      const renamedFrom = existing.lastEntityId !== entityId ? existing.lastEntityId ?? existing.anchorEntityId : void 0;
-      if (opts.stableIdentity) {
-        if (renamedFrom) {
-          this.identityStorage.setIdentity(bridgeId, key, {
-            ...existing,
-            lastEntityId: entityId
-          });
-          await this.rekeyMapping(bridgeId, renamedFrom, entityId);
-        }
-        return {
-          endpointId: existing.endpointId,
-          anchorEntityId: existing.anchorEntityId,
-          protected: true,
-          renamedFrom
-        };
-      }
-      const liveEndpointId = createEndpointId(entityId, mapping?.customName);
-      if (existing.endpointId !== liveEndpointId || existing.anchorEntityId !== entityId || existing.lastEntityId !== entityId) {
-        this.identityStorage.setIdentity(bridgeId, key, {
-          ...existing,
-          endpointId: liveEndpointId,
-          anchorEntityId: entityId,
-          lastEntityId: entityId
-        });
-      }
-      return {
-        endpointId: liveEndpointId,
-        anchorEntityId: entityId,
-        protected: false,
-        renamedFrom
-      };
-    }
-    const desired = createEndpointId(entityId, mapping?.customName);
-    let endpointId = desired;
-    if (opts.stableIdentity) {
-      let n = 2;
-      while (opts.isEndpointIdTaken(endpointId, key)) {
-        endpointId = `${desired}_${n++}`;
-      }
-    }
-    const record = {
-      endpointId,
-      anchorEntityId: entityId,
-      lastEntityId: entityId,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this.identityStorage.setIdentity(bridgeId, key, record);
-    if (opts.stableIdentity) {
-      return {
-        endpointId: record.endpointId,
-        anchorEntityId: record.anchorEntityId,
-        protected: true
-      };
-    }
-    return {
-      endpointId: desired,
-      anchorEntityId: entityId,
-      protected: false
-    };
-  }
-  // Carry a mapping from the old entity_id to the new one on rename. anchorEntityId
-  // never changes, only the mapping key. Skips when no old mapping exists or a new
-  // one already does, so a manual mapping under the new id is never clobbered.
-  async rekeyMapping(bridgeId, oldEntityId, newEntityId) {
-    if (oldEntityId === newEntityId) {
-      return;
-    }
-    const old = this.mappingStorage.getMapping(bridgeId, oldEntityId);
-    if (!old) {
-      return;
-    }
-    if (this.mappingStorage.getMapping(bridgeId, newEntityId)) {
-      return;
-    }
-    await this.mappingStorage.setMapping({
-      ...old,
-      bridgeId,
-      entityId: newEntityId
-    });
-    await this.mappingStorage.deleteMapping(bridgeId, oldEntityId);
-  }
-};
-
 // src/services/bridges/bridge-endpoint-manager.ts
 var MAX_ENTITY_ID_LENGTH = 150;
 var ENDPOINT_REMOVAL_GRACE_MS = 6e4;
@@ -172924,6 +173291,7 @@ var BridgeEndpointManager = class extends Service {
     this.client = client;
     this.registry = registry2;
     this.mappingStorage = mappingStorage;
+    this.identityStorage = identityStorage;
     this.bridgeId = bridgeId;
     this.log = log;
     this.pluginManager = pluginManager;
@@ -172945,6 +173313,7 @@ var BridgeEndpointManager = class extends Service {
   client;
   registry;
   mappingStorage;
+  identityStorage;
   bridgeId;
   log;
   pluginManager;
@@ -173342,6 +173711,17 @@ var BridgeEndpointManager = class extends Service {
         this.mappingFingerprints.set(entityId, fp);
       }
     }
+    const fullEntities = this.registry.fullEntities;
+    stampIdentityPresence(
+      this.identityStorage,
+      this.bridgeId,
+      buildPresentIdentityKeys(fullEntities)
+    );
+    stampMappingPresence(
+      this.mappingStorage,
+      this.bridgeId,
+      buildPresentEntityIds(fullEntities)
+    );
     const existingEndpoints = [];
     const now = Date.now();
     for (const endpoint of endpoints) {
@@ -173661,6 +174041,11 @@ var BridgeRegistry = class _BridgeRegistry {
   initialState(entityId) {
     return this._states[entityId];
   }
+  // The complete HA entity set (unfiltered). Used by orphan tombstone stamping
+  // so a filter change or a scope narrowing never looks like a removal.
+  get fullEntities() {
+    return this.registry.entities;
+  }
   // composed sub-entities may sit outside the bridge filter (#408), so these
   // fall back to the full HA registry. keep them separate from the strict
   // accessors above, every other caller must stay filtered.
@@ -174378,6 +174763,7 @@ init_dist();
 init_esm7();
 import * as os10 from "node:os";
 init_diagnostic_event_bus();
+var imWrapMarker2 = /* @__PURE__ */ Symbol("hamh.wedgeImWrap");
 var AUTO_FORCE_SYNC_INTERVAL_MS2 = 9e4;
 var SHUTDOWN_SESSION_CLOSE_TIMEOUT_MS2 = 2500;
 var MDNS_ADDRESS_CHECK_INTERVAL_MS2 = 6e4;
@@ -174410,6 +174796,12 @@ var ServerModeBridge = class {
   sessionStartedAt = /* @__PURE__ */ new Map();
   rotationTimer = null;
   maxSessionAgeMs = 0;
+  // Wedge watchdog: last inbound Interaction Model request time per session and
+  // last time the watchdog rotated it, both keyed by the long-lived session
+  // object so they clear when the session goes away.
+  lastImRequestAt = /* @__PURE__ */ new WeakMap();
+  wedgeLastRotatedAt = /* @__PURE__ */ new WeakMap();
+  wedgeWatchdogTimer = null;
   // Watches the advertised interface addresses so a dynamic ISP IPv6 prefix
   // change forces a fresh operational announcement (#415).
   mdnsAddressTimer = null;
@@ -174486,6 +174878,8 @@ var ServerModeBridge = class {
         const nowMs = Date.now();
         const lastActiveMsAgo = typeof s.activeTimestamp === "number" && s.activeTimestamp > 0 ? nowMs - s.activeTimestamp : null;
         const lastAnyActivityMsAgo = typeof s.timestamp === "number" ? nowMs - s.timestamp : null;
+        const lastImAt = this.lastImRequestAt.get(s);
+        const lastImRequestMsAgo = lastImAt != null ? nowMs - lastImAt : null;
         const startedAt = this.sessionStartedAt.get(s.id);
         return {
           id: s.id,
@@ -174494,6 +174888,7 @@ var ServerModeBridge = class {
           subscriptionCount: subCount,
           lastActiveMsAgo,
           lastAnyActivityMsAgo,
+          lastImRequestMsAgo,
           isPeerActive: Boolean(s.isPeerActive),
           ageMsFromOpen: startedAt != null ? nowMs - startedAt : null
         };
@@ -174557,6 +174952,7 @@ var ServerModeBridge = class {
       this.wireSessionDiagnostics();
       this.wireFabricWarnings();
       this.startSessionRotation();
+      this.startWedgeWatchdog();
       this.startMdnsAddressWatch();
       this.scheduleWarmStart();
       logMemoryUsage(this.log, "server mode bridge running");
@@ -174574,6 +174970,7 @@ ${e?.toString()}`);
   }
   async stop(code = BridgeStatus.Stopped, reason = "Manually stopped") {
     this.stopSessionRotation();
+    this.stopWedgeWatchdog();
     this.stopMdnsAddressWatch();
     this.unwireSessionDiagnostics();
     this.unwireFabricWarnings();
@@ -174606,6 +175003,7 @@ ${e?.toString()}`);
       if (this.status.code === BridgeStatus.Running) {
         this.startAutoForceSyncIfEnabled();
         this.startSessionRotation();
+        this.startWedgeWatchdog();
       }
     } catch (e) {
       const reason = "Failed to update server mode bridge due to error:";
@@ -174790,6 +175188,29 @@ ${e?.toString()}`);
       sessionManager.sessions.added.on(this.sessionAddedHandler);
       sessionManager.sessions.deleted.on(this.sessionDeletedHandler);
       seedExistingSessionStarts(this.sessionStartedAt, sessionManager.sessions);
+      this.wireImRequestTracking();
+    } catch {
+    }
+  }
+  // Stamp the time of every inbound Interaction Model request per session by
+  // wrapping InteractionServer.onNewExchange. The wedge watchdog reads these to
+  // tell a live-but-consuming controller from one that only keeps acking.
+  wireImRequestTracking() {
+    try {
+      const is = this.server.env.get(InteractionServer);
+      const marked = is;
+      if (marked[imWrapMarker2]) {
+        return;
+      }
+      const original = is.onNewExchange.bind(is);
+      is.onNewExchange = (exchange, message) => {
+        const session = exchange.session;
+        if (session) {
+          this.lastImRequestAt.set(session, Date.now());
+        }
+        return original(exchange, message);
+      };
+      marked[imWrapMarker2] = true;
     } catch {
     }
   }
@@ -175007,6 +175428,72 @@ ${e?.toString()}`);
       this.rotationTimer = null;
     }
   }
+  // Opt-in wedge watchdog: reuse the rotation check cadence (5min) to look for
+  // the one session wedged on "Updating" and rotate just that one.
+  startWedgeWatchdog() {
+    this.stopWedgeWatchdog();
+    if (!this.dataProvider.featureFlags?.wedgeWatchdog) {
+      return;
+    }
+    this.wedgeWatchdogTimer = setInterval(
+      () => this.runWedgeWatchdogCheck(),
+      ROTATION_CHECK_INTERVAL_MS
+    );
+    this.log.info(
+      `Wedge watchdog: checking every ${ROTATION_CHECK_INTERVAL_MS / 6e4}min`
+    );
+  }
+  stopWedgeWatchdog() {
+    if (this.wedgeWatchdogTimer) {
+      clearInterval(this.wedgeWatchdogTimer);
+      this.wedgeWatchdogTimer = null;
+    }
+  }
+  // Rotate exactly the sessions the pure rule flags as wedged. Closing is the
+  // same graceful-then-force path age rotation uses, so a false positive just
+  // re-CASEs the controller.
+  runWedgeWatchdogCheck() {
+    try {
+      const sessionManager = this.server.env.get(SessionManager);
+      const now = Date.now();
+      const closes = [];
+      for (const s of [...sessionManager.sessions]) {
+        if (s.isClosing) continue;
+        const startedAt = this.sessionStartedAt.get(s.id);
+        const sessionAgeMs = startedAt != null ? now - startedAt : 0;
+        const lastImAt = this.lastImRequestAt.get(s);
+        const lastImRequestMsAgo = lastImAt != null ? now - lastImAt : null;
+        const lastRotatedAt = this.wedgeLastRotatedAt.get(s);
+        const lastRotatedMsAgo = lastRotatedAt != null ? now - lastRotatedAt : null;
+        if (!decideWedgeRotation({
+          subscriptionCount: s.subscriptions.size,
+          sessionAgeMs,
+          lastImRequestMsAgo,
+          lastRotatedMsAgo
+        })) {
+          continue;
+        }
+        const silenceMin = Math.round(
+          (lastImRequestMsAgo ?? sessionAgeMs) / 6e4
+        );
+        this.log.info(
+          `Wedge watchdog: rotating session ${s.id}, no inbound interaction for ${silenceMin}min`
+        );
+        this.wedgeLastRotatedAt.set(s, now);
+        closes.push(
+          s.initiateClose().catch(() => {
+            return s.initiateForceClose({
+              cause: new Error("wedge watchdog, forcing")
+            });
+          })
+        );
+      }
+      if (closes.length > 0) {
+        Promise.allSettled(closes).then(() => this.triggerMdnsReAnnounce());
+      }
+    } catch {
+    }
+  }
   // Poll the interface addresses mDNS advertises and re-announce when they
   // change. matter.js caches the operational records at first announcement, so
   // a dynamic ISP IPv6 prefix change keeps advertising the dead global address
@@ -175580,6 +176067,7 @@ var ServerModeEndpointManager = class extends Service {
     this.client = client;
     this.registry = registry2;
     this.mappingStorage = mappingStorage;
+    this.identityStorage = identityStorage;
     this.dataProvider = dataProvider;
     this.log = log;
     this.identityResolver = new IdentityResolver(
@@ -175591,6 +176079,7 @@ var ServerModeEndpointManager = class extends Service {
   client;
   registry;
   mappingStorage;
+  identityStorage;
   dataProvider;
   log;
   entityIds = [];
@@ -175690,6 +176179,17 @@ var ServerModeEndpointManager = class extends Service {
     this.registry.refresh();
     this._failedEntities = [];
     this.entityIds = this.registry.entityIds;
+    const fullEntities = this.registry.fullEntities;
+    stampIdentityPresence(
+      this.identityStorage,
+      this.dataProvider.id,
+      buildPresentIdentityKeys(fullEntities)
+    );
+    stampMappingPresence(
+      this.mappingStorage,
+      this.dataProvider.id,
+      buildPresentEntityIds(fullEntities)
+    );
     try {
       if (this.entityIds.length === 0) {
         this.log.warn("Server mode bridge has no entities configured");