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

package/dist/backend/cli.js

@@ -135040,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;
@@ -135085,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({});
@@ -135188,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);
@@ -137207,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(
@@ -139028,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");
@@ -139041,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,
@@ -139079,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: {}
@@ -139088,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()) : [];
@@ -139181,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 === "") {
@@ -157888,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();
@@ -172925,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;
@@ -173047,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;
@@ -173068,6 +173313,7 @@ var BridgeEndpointManager = class extends Service {
   client;
   registry;
   mappingStorage;
+  identityStorage;
   bridgeId;
   log;
   pluginManager;
@@ -173465,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) {
@@ -173784,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.
@@ -175805,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(
@@ -175816,6 +176079,7 @@ var ServerModeEndpointManager = class extends Service {
   client;
   registry;
   mappingStorage;
+  identityStorage;
   dataProvider;
   log;
   entityIds = [];
@@ -175915,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");