@riddix/hamh 2.1.0-alpha.735 → 2.1.0-alpha.737

package/dist/backend/cli.js

@@ -123729,7 +123729,7 @@ var init_bridge_templates = __esm({
       {
         id: "robot_vacuum",
         name: "Robot Vacuum (Server Mode)",
-        description: "Single vacuum bridge with Server Mode enabled. Required for Apple Home Siri commands and proper Alexa discovery. Add only ONE vacuum to this bridge.",
+        description: "Single vacuum bridge with Server Mode enabled. Required for Apple Home Siri commands and proper Alexa discovery. Best with just the vacuum on this bridge.",
         icon: "vacuum",
         filter: {
           include: [{ type: HomeAssistantMatcherType.Domain, value: "vacuum" }],
@@ -124663,8 +124663,8 @@ var init_bridge_config_schema = __esm({
           default: false
         },
         serverMode: {
-          title: "Server Mode (for Robot Vacuums)",
-          description: "Expose the device as a standalone Matter device instead of a bridged device. This is required for Apple Home to properly support Siri voice commands for Robot Vacuums. IMPORTANT: Only ONE device should be in this bridge when server mode is enabled.",
+          title: "Server Mode (standalone device)",
+          description: "Expose entities as standalone Matter devices instead of bridged ones. Works for any supported device type, e.g. robot vacuums need it for Apple Home Siri voice commands. One node carries up to 10 devices; the first entity is the primary and drives the node name and type (experimental beyond one device).",
           type: "boolean",
           default: false
         },
@@ -124822,7 +124822,10 @@ var init_create_bridge_request_schema = __esm({
   "../common/dist/schemas/create-bridge-request-schema.js"() {
     "use strict";
     init_bridge_config_schema();
-    createBridgeRequestSchema = bridgeConfigSchema;
+    createBridgeRequestSchema = {
+      ...bridgeConfigSchema,
+      required: ["name", "filter"]
+    };
   }
 });
 
@@ -130502,11 +130505,13 @@ var BridgeService = class extends Service {
     return this.bridges.find((bridge) => bridge.id === id);
   }
   async create(request) {
-    if (this.portUsed(request.port)) {
-      throw new Error(`Port already in use: ${request.port}`);
+    const port = request.port ?? this.getNextAvailablePort();
+    if (this.portUsed(port)) {
+      throw new Error(`Port already in use: ${port}`);
     }
     const bridge = await this.addBridge({
       ...request,
+      port,
       id: crypto3.randomUUID().replace(/-/g, ""),
       basicInformation: this.props.basicInformation
     });
@@ -145987,7 +145992,7 @@ function trimToLength(value, maxLength, suffix) {
 // src/matter/endpoints/server-mode-server-node.ts
 var logger183 = Logger.get("ServerModeServerNode");
 var ServerModeServerNode = class extends ServerNode {
-  deviceEndpoint;
+  deviceEndpoints = /* @__PURE__ */ new Map();
   featureFlags;
   serialNumberSuffix;
   constructor(env, bridgeData) {
@@ -146032,24 +146037,31 @@ var ServerModeServerNode = class extends ServerNode {
     this.featureFlags = bridgeData.featureFlags;
     this.serialNumberSuffix = bridgeData.serialNumberSuffix;
   }
+  /** Number of device endpoints currently attached. */
+  get deviceCount() {
+    return this.deviceEndpoints.size;
+  }
   /**
-   * Add the device endpoint to this server node.
-   * In server mode, only ONE device is allowed.
-   * This method is idempotent - if a device already exists, it's a no-op.
+   * Add a device endpoint to this server node. Several endpoints per node are
+   * supported (#301); the call is idempotent per endpoint id.
    */
   async addDevice(endpoint) {
-    if (this.deviceEndpoint) {
+    if (this.deviceEndpoints.has(endpoint.id)) {
       return;
     }
-    this.deviceEndpoint = endpoint;
+    this.deviceEndpoints.set(endpoint.id, endpoint);
     await this.add(endpoint);
   }
   /**
-   * Clear the device reference after the endpoint has been deleted externally.
-   * Must be called before addDevice() when replacing the device endpoint.
+   * Drop one device reference after the endpoint has been deleted externally.
+   * Must be called before re-adding an endpoint with the same id.
    */
-  clearDevice() {
-    this.deviceEndpoint = void 0;
+  forgetDevice(endpoint) {
+    this.deviceEndpoints.delete(endpoint.id);
+  }
+  /** Drop all device references after the endpoints were deleted externally. */
+  clearDevices() {
+    this.deviceEndpoints.clear();
   }
   /**
    * Update root-level BasicInformation with entity-specific data.
@@ -161492,7 +161504,12 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
         }
       }
     }
-    if (registry2.isAutoComposedDevicesEnabled() && effectiveMapping?.composedEntities && effectiveMapping.composedEntities.length > 0) {
+    if (standalone && ((effectiveMapping?.composedEntities?.length ?? 0) > 0 || effectiveMapping?.climateExposeFan === true)) {
+      logger228.warn(
+        `Composed mappings are not supported in server mode, exposing ${entityId} as a flat standalone endpoint`
+      );
+    }
+    if (!standalone && registry2.isAutoComposedDevicesEnabled() && effectiveMapping?.composedEntities && effectiveMapping.composedEntities.length > 0) {
       const composedAreaName = registry2.getAreaName(entityId);
       const composed = await UserComposedEndpoint.create({
         registry: registry2,
@@ -161509,7 +161526,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
         `User composed device creation failed for ${entityId}, falling back to standalone`
       );
     }
-    if (registry2.isAutoComposedDevicesEnabled()) {
+    if (!standalone && registry2.isAutoComposedDevicesEnabled()) {
       const attrs = state.attributes;
       if (entityId.startsWith("sensor.") && attrs.device_class === SensorDeviceClass.temperature && (effectiveMapping?.humidityEntity || effectiveMapping?.pressureEntity)) {
         const composedAreaName = registry2.getAreaName(entityId);
@@ -161550,7 +161567,7 @@ var LegacyEndpoint = class _LegacyEndpoint extends EntityEndpoint {
         }
       }
     }
-    if (entityId.startsWith("climate.") && effectiveMapping?.climateExposeFan === true) {
+    if (!standalone && entityId.startsWith("climate.") && effectiveMapping?.climateExposeFan === true) {
       const climateFeatures = state.attributes.supported_features ?? 0;
       if ((climateFeatures & ClimateDeviceFeature.FAN_MODE) !== 0) {
         const composedAreaName = registry2.getAreaName(entityId);
@@ -163188,6 +163205,22 @@ var BridgeRegistry = class _BridgeRegistry {
       }
     }
   }
+  /**
+   * The first already-matched entity the given matcher tests true for.
+   * Server mode pins the primary entity to the first include matcher with
+   * this, independent of HA registry order (#301).
+   */
+  firstEntityMatching(matcher) {
+    const labels = this.registry.labels;
+    for (const entity of values3(this._entities)) {
+      const device = this.registry.devices[entity.device_id];
+      const state = this.registry.states[entity.entity_id];
+      if (testMatchers([matcher], device, entity, "any", state, labels)) {
+        return entity.entity_id;
+      }
+    }
+    return void 0;
+  }
   matchesFilter(filter, entity, device, entityState) {
     const labels = this.registry.labels;
     if (filter.include.length > 0 && !testMatchers(
@@ -163251,7 +163284,7 @@ var ServerModeBridge = class {
   rotationTimer = null;
   maxSessionAgeMs = 0;
   // Tracks the last synced state JSON per entity to avoid pushing unchanged states.
-  lastSyncedState;
+  lastSyncedStates = /* @__PURE__ */ new Map();
   // Session lifecycle diagnostic handlers (non-destructive, logging only).
   // biome-ignore lint/suspicious/noExplicitAny: matter.js internal types
   sessionDiagHandler;
@@ -163266,7 +163299,7 @@ var ServerModeBridge = class {
     return this.dataProvider.withMetadata(
       this.status,
       this.server,
-      this.endpointManager.device ? 1 : 0,
+      this.endpointManager.devices.length,
       this.endpointManager.failedEntities
     );
   }
@@ -163323,7 +163356,7 @@ var ServerModeBridge = class {
     if (this.status.code === BridgeStatus.Running) {
       return;
     }
-    this.lastSyncedState = void 0;
+    this.lastSyncedStates.clear();
     try {
       this.setStatus({
         code: BridgeStatus.Starting,
@@ -163707,28 +163740,34 @@ ${e?.toString()}`);
     if (this.status.code !== BridgeStatus.Running) {
       return;
     }
-    const device = this.endpointManager.device;
-    if (!device) {
+    const devices = this.endpointManager.devices;
+    if (devices.length === 0) {
       return;
     }
-    try {
-      const { HomeAssistantEntityBehavior: HomeAssistantEntityBehavior2 } = await Promise.resolve().then(() => (init_home_assistant_entity_behavior(), home_assistant_entity_behavior_exports));
-      if (!device.behaviors.has(HomeAssistantEntityBehavior2)) {
-        return;
-      }
-      const behavior = device.stateOf(HomeAssistantEntityBehavior2);
-      const currentEntity = behavior.entity;
-      if (currentEntity?.state) {
-        await device.setStateOf(HomeAssistantEntityBehavior2, {
-          entity: {
-            ...currentEntity,
-            state: makeWarmStartState(currentEntity.state)
-          }
-        });
-        this.log.info("Warm-start: Pushed initial device state");
+    const { HomeAssistantEntityBehavior: HomeAssistantEntityBehavior2 } = await Promise.resolve().then(() => (init_home_assistant_entity_behavior(), home_assistant_entity_behavior_exports));
+    let pushed = 0;
+    for (const device of devices) {
+      try {
+        if (!device.behaviors.has(HomeAssistantEntityBehavior2)) {
+          continue;
+        }
+        const behavior = device.stateOf(HomeAssistantEntityBehavior2);
+        const currentEntity = behavior.entity;
+        if (currentEntity?.state) {
+          await device.setStateOf(HomeAssistantEntityBehavior2, {
+            entity: {
+              ...currentEntity,
+              state: makeWarmStartState(currentEntity.state)
+            }
+          });
+          pushed++;
+        }
+      } catch (e) {
+        this.log.debug("Warm-start: Failed to push state:", e);
       }
-    } catch (e) {
-      this.log.debug("Warm-start: Failed to push state:", e);
+    }
+    if (pushed > 0) {
+      this.log.info(`Warm-start: Pushed initial state for ${pushed} devices`);
     }
   }
   async delete() {
@@ -163746,38 +163785,43 @@ ${e?.toString()}`);
     if (!this.dataProvider.featureFlags?.autoForceSync) {
       return 0;
     }
-    const device = this.endpointManager.device;
-    if (!device) {
+    const devices = this.endpointManager.devices;
+    if (devices.length === 0) {
       return 0;
     }
-    try {
-      const { HomeAssistantEntityBehavior: HomeAssistantEntityBehavior2 } = await Promise.resolve().then(() => (init_home_assistant_entity_behavior(), home_assistant_entity_behavior_exports));
-      if (!device.behaviors.has(HomeAssistantEntityBehavior2)) {
-        return 0;
-      }
-      const behavior = device.stateOf(HomeAssistantEntityBehavior2);
-      const currentEntity = behavior.entity;
-      if (currentEntity?.state) {
-        const stateJson = JSON.stringify({
-          s: currentEntity.state.state,
-          a: currentEntity.state.attributes
-        });
-        if (stateJson !== this.lastSyncedState) {
-          await device.setStateOf(HomeAssistantEntityBehavior2, {
-            entity: {
-              ...currentEntity,
-              state: { ...currentEntity.state }
-            }
+    const { HomeAssistantEntityBehavior: HomeAssistantEntityBehavior2 } = await Promise.resolve().then(() => (init_home_assistant_entity_behavior(), home_assistant_entity_behavior_exports));
+    let synced = 0;
+    for (const device of devices) {
+      try {
+        if (!device.behaviors.has(HomeAssistantEntityBehavior2)) {
+          continue;
+        }
+        const behavior = device.stateOf(HomeAssistantEntityBehavior2);
+        const currentEntity = behavior.entity;
+        if (currentEntity?.state) {
+          const stateJson = JSON.stringify({
+            s: currentEntity.state.state,
+            a: currentEntity.state.attributes
           });
-          this.lastSyncedState = stateJson;
-          this.log.info("Force sync: Pushed 1 changed device");
-          return 1;
+          if (stateJson !== this.lastSyncedStates.get(device.entityId)) {
+            await device.setStateOf(HomeAssistantEntityBehavior2, {
+              entity: {
+                ...currentEntity,
+                state: { ...currentEntity.state }
+              }
+            });
+            this.lastSyncedStates.set(device.entityId, stateJson);
+            synced++;
+          }
         }
+      } catch (e) {
+        this.log.debug("Force sync: Failed due to error:", e);
       }
-    } catch (e) {
-      this.log.debug("Force sync: Failed due to error:", e);
     }
-    return 0;
+    if (synced > 0) {
+      this.log.info(`Force sync: Pushed ${synced} changed devices`);
+    }
+    return synced;
   }
 };
 
@@ -164104,38 +164148,36 @@ var ServerModeVacuumEndpoint = class _ServerModeVacuumEndpoint extends EntityEnd
 };
 
 // src/services/bridges/server-mode-endpoint-manager.ts
+var MAX_SERVER_MODE_DEVICES = 10;
 var ServerModeEndpointManager = class extends Service {
-  constructor(serverNode, client, registry2, mappingStorage, bridgeId, log) {
+  constructor(serverNode, client, registry2, mappingStorage, dataProvider, log) {
     super("ServerModeEndpointManager");
     this.serverNode = serverNode;
     this.client = client;
     this.registry = registry2;
     this.mappingStorage = mappingStorage;
-    this.bridgeId = bridgeId;
+    this.dataProvider = dataProvider;
     this.log = log;
   }
   serverNode;
   client;
   registry;
   mappingStorage;
-  bridgeId;
+  dataProvider;
   log;
   entityIds = [];
   unsubscribe;
   _failedEntities = [];
-  deviceEndpoint;
-  mappingFingerprint = "";
+  endpoints = /* @__PURE__ */ new Map();
   get failedEntities() {
     return this._failedEntities;
   }
-  /**
-   * Returns the device endpoint (for server mode, this is the single device)
-   */
-  get device() {
-    return this.deviceEndpoint;
+  /** All device endpoints, primary first. */
+  get devices() {
+    return [...this.endpoints.values()].map((entry) => entry.endpoint);
   }
   getEntityMapping(entityId) {
-    return this.mappingStorage.getMapping(this.bridgeId, entityId);
+    return this.mappingStorage.getMapping(this.dataProvider.id, entityId);
   }
   computeMappingFingerprint(mapping) {
     if (!mapping) return "";
@@ -164143,14 +164185,17 @@ var ServerModeEndpointManager = class extends Service {
   }
   async dispose() {
     this.stopObserving();
-    if (this.deviceEndpoint) {
+    for (const [entityId, entry] of this.endpoints) {
       try {
-        await this.deviceEndpoint.close();
+        await entry.endpoint.close();
       } catch (e) {
-        this.log.warn(`Failed to close device endpoint during dispose:`, e);
+        this.log.warn(
+          `Failed to close endpoint ${entityId} during dispose:`,
+          e
+        );
       }
-      this.deviceEndpoint = void 0;
     }
+    this.endpoints.clear();
   }
   async startObserving() {
     this.stopObserving();
@@ -164166,12 +164211,9 @@ var ServerModeEndpointManager = class extends Service {
   }
   collectSubscriptionEntityIds() {
     const ids = new Set(this.entityIds);
-    if (this.deviceEndpoint) {
-      const mappedIds = this.deviceEndpoint.mappedEntityIds;
-      if (mappedIds) {
-        for (const mappedId of mappedIds) {
-          ids.add(mappedId);
-        }
+    for (const entry of this.endpoints.values()) {
+      for (const mappedId of entry.endpoint.mappedEntityIds) {
+        ids.add(mappedId);
       }
     }
     return [...ids];
@@ -164180,128 +164222,173 @@ var ServerModeEndpointManager = class extends Service {
     this.unsubscribe?.();
     this.unsubscribe = void 0;
   }
+  /** Primary first (the entity the first include matcher tests true for). */
+  orderEntityIds(ids) {
+    const firstMatcher = this.dataProvider.filter?.include?.[0];
+    const primary = firstMatcher ? this.registry.firstEntityMatching(firstMatcher) : void 0;
+    if (!primary || !ids.includes(primary)) {
+      return [...ids];
+    }
+    return [primary, ...ids.filter((id) => id !== primary)];
+  }
+  async removeEndpoints(entityIds) {
+    for (const entityId of entityIds) {
+      const entry = this.endpoints.get(entityId);
+      if (!entry) continue;
+      try {
+        await entry.endpoint.delete();
+      } catch (e) {
+        this.log.warn(`Failed to delete endpoint ${entityId}:`, e);
+      }
+      this.serverNode.forgetDevice(entry.endpoint);
+      this.endpoints.delete(entityId);
+    }
+  }
   async refreshDevices() {
     this.registry.refresh();
     this._failedEntities = [];
     this.entityIds = this.registry.entityIds;
-    if (this.entityIds.length === 0) {
-      this.log.warn("Server mode bridge has no entities configured");
-      return;
-    }
-    if (this.entityIds.length > 1) {
-      this.log.warn(
-        `Server mode only supports a single device, but ${this.entityIds.length} entities are configured. Only the first entity will be exposed. Remove other entities from this bridge for proper operation.`
-      );
-      for (let i = 1; i < this.entityIds.length; i++) {
+    try {
+      if (this.entityIds.length === 0) {
+        this.log.warn("Server mode bridge has no entities configured");
+        await this.removeEndpoints([...this.endpoints.keys()]);
         this._failedEntities.push({
-          entityId: this.entityIds[i],
-          reason: "Server mode only supports a single device. Remove other entities from this bridge."
+          entityId: this.dataProvider.filter?.include?.[0]?.value ?? "(no entity configured)",
+          reason: "No Home Assistant entity matched this bridge's filter. Check for typos or renamed/removed entities."
         });
-      }
-      this.entityIds = [this.entityIds[0]];
-    }
-    const entityId = this.entityIds[0];
-    const mapping = this.getEntityMapping(entityId);
-    if (mapping?.disabled) {
-      this.log.warn(
-        `The only entity in server mode bridge is disabled: ${entityId}`
-      );
-      return;
-    }
-    const currentFp = this.computeMappingFingerprint(mapping);
-    if (this.deviceEndpoint) {
-      const entityChanged = this.deviceEndpoint.entityId !== entityId;
-      if (!entityChanged && currentFp === this.mappingFingerprint) {
-        this.log.debug(`Device endpoint already exists for ${entityId}`);
         return;
       }
-      this.log.info(
-        entityChanged ? `Entity changed from ${this.deviceEndpoint.entityId} to ${entityId}, recreating endpoint` : `Mapping changed for ${entityId}, recreating endpoint`
-      );
-      try {
-        await this.deviceEndpoint.delete();
-      } catch (e) {
+      const orderedIds = this.orderEntityIds(this.entityIds);
+      const surplus = orderedIds.splice(MAX_SERVER_MODE_DEVICES);
+      for (const entityId of surplus) {
+        this._failedEntities.push({
+          entityId,
+          reason: `Server mode exposes at most ${MAX_SERVER_MODE_DEVICES} devices per node. Remove extra entities or create another standalone device.`
+        });
+      }
+      if (surplus.length > 0) {
         this.log.warn(
-          `Failed to delete endpoint ${entityId} for mapping change:`,
-          e
+          `Server mode node is capped at ${MAX_SERVER_MODE_DEVICES} devices, ${surplus.length} entities skipped`
         );
       }
-      this.serverNode.clearDevice();
-      this.deviceEndpoint = void 0;
-      this.mappingFingerprint = "";
-    }
-    if (isHeapUnderPressure()) {
-      this.log.error(
-        "Memory pressure detected, cannot create device endpoint. Reduce entities on other bridges or increase the Node.js heap size (NODE_OPTIONS=--max-old-space-size=1024)."
-      );
-      this._failedEntities.push({
-        entityId,
-        reason: "Skipped due to memory pressure, reduce entities or increase heap size"
-      });
-      return;
-    }
-    try {
-      const domain = entityId.split(".")[0];
-      if (domain === "vacuum") {
-        const endpoint2 = await this.createServerModeVacuumEndpoint(
-          entityId,
-          mapping
+      const keep = new Set(orderedIds);
+      const removed = [...this.endpoints.keys()].filter((id) => !keep.has(id));
+      let structureChanged = removed.length > 0;
+      await this.removeEndpoints(removed);
+      for (const entityId of orderedIds) {
+        const mapping = this.getEntityMapping(entityId);
+        if (mapping?.disabled) {
+          this.log.warn(
+            `Entity in server mode bridge is disabled: ${entityId}`
+          );
+          if (this.endpoints.has(entityId)) {
+            await this.removeEndpoints([entityId]);
+            structureChanged = true;
+          }
+          this._failedEntities.push({
+            entityId,
+            reason: "The configured entity is disabled for this bridge."
+          });
+          continue;
+        }
+        const fingerprint = this.computeMappingFingerprint(mapping);
+        const existing = this.endpoints.get(entityId);
+        if (existing && existing.fingerprint === fingerprint) {
+          this.log.debug(`Device endpoint already exists for ${entityId}`);
+          continue;
+        }
+        if (existing) {
+          this.log.info(`Mapping changed for ${entityId}, recreating endpoint`);
+          await this.removeEndpoints([entityId]);
+          structureChanged = true;
+        }
+        const claimedBy = [...this.endpoints.entries()].find(
+          ([, entry]) => entry.endpoint.mappedEntityIds.includes(entityId)
         );
-        if (!endpoint2) {
+        if (claimedBy) {
           this._failedEntities.push({
             entityId,
-            reason: "Failed to create vacuum endpoint - unsupported device"
+            reason: `Already exposed through ${claimedBy[0]} on this node.`
           });
-          return;
+          continue;
         }
-        await this.serverNode.addDevice(endpoint2);
-        this.deviceEndpoint = endpoint2;
-        this.mappingFingerprint = currentFp;
-        await this.updateServerNodeIdentity(entityId, mapping);
-        this.log.info(
-          `Server mode: Added vacuum ${entityId} as standalone device`
+        const endpointId = createEndpointId(entityId, mapping?.customName);
+        const collision = [...this.endpoints.entries()].find(
+          ([, entry]) => entry.endpoint.id === endpointId
         );
-        return;
+        if (collision) {
+          this._failedEntities.push({
+            entityId,
+            reason: `Endpoint id collides with ${collision[0]}. Set distinct custom names.`
+          });
+          continue;
+        }
+        if (isHeapUnderPressure()) {
+          this.log.error(
+            "Memory pressure detected, cannot create device endpoint. Reduce entities on other bridges or increase the Node.js heap size (NODE_OPTIONS=--max-old-space-size=1024)."
+          );
+          this._failedEntities.push({
+            entityId,
+            reason: "Skipped due to memory pressure, reduce entities or increase heap size"
+          });
+          continue;
+        }
+        try {
+          const domain = entityId.split(".")[0];
+          const endpoint = domain === "vacuum" ? await this.createServerModeVacuumEndpoint(entityId, mapping) : await LegacyEndpoint.create(
+            this.registry,
+            entityId,
+            mapping,
+            void 0,
+            true
+          );
+          if (!endpoint) {
+            this._failedEntities.push({
+              entityId,
+              reason: "Failed to create endpoint - unsupported device type"
+            });
+            continue;
+          }
+          await this.serverNode.addDevice(endpoint);
+          this.endpoints.set(entityId, { endpoint, fingerprint });
+          structureChanged = true;
+          this.log.info(`Server mode: Added device ${entityId}`);
+        } catch (e) {
+          const reason = e instanceof Error ? e.message : String(e);
+          this.log.error(`Failed to create server mode device ${entityId}:`, e);
+          this._failedEntities.push({ entityId, reason });
+        }
       }
-      const endpoint = await LegacyEndpoint.create(
-        this.registry,
-        entityId,
-        mapping,
-        void 0,
-        true
-      );
-      if (!endpoint) {
-        this._failedEntities.push({
-          entityId,
-          reason: "Failed to create endpoint - unsupported device type"
-        });
-        return;
+      if (structureChanged) {
+        const primary = orderedIds.find((id) => this.endpoints.has(id));
+        if (primary) {
+          await this.updateServerNodeIdentity(
+            primary,
+            this.getEntityMapping(primary),
+            this.endpoints.get(primary)?.endpoint
+          );
+        }
+      }
+    } finally {
+      if (this.unsubscribe) {
+        this.startObserving();
       }
-      await this.serverNode.addDevice(endpoint);
-      this.deviceEndpoint = endpoint;
-      this.mappingFingerprint = currentFp;
-      await this.updateServerNodeIdentity(entityId, mapping);
-      this.log.info(`Server mode: Added device ${entityId}`);
-    } catch (e) {
-      const reason = e instanceof Error ? e.message : String(e);
-      this.log.error(`Failed to create server mode device ${entityId}:`, e);
-      this._failedEntities.push({ entityId, reason });
-    }
-    if (this.unsubscribe) {
-      this.startObserving();
     }
   }
   async updateStates(states) {
     this.registry.mergeExternalStates(states);
-    if (this.deviceEndpoint) {
+    for (const [entityId, entry] of this.endpoints) {
       try {
-        await this.deviceEndpoint.updateStates(states);
+        await entry.endpoint.updateStates(states);
       } catch (e) {
-        this.log.warn("State update failed for server mode endpoint:", e);
+        this.log.warn(
+          `State update failed for server mode endpoint ${entityId}:`,
+          e
+        );
       }
     }
   }
-  async updateServerNodeIdentity(entityId, mapping) {
+  async updateServerNodeIdentity(entityId, mapping, endpoint) {
     const device = this.registry.deviceOf(entityId);
     const state = this.registry.initialState(entityId);
     const friendlyName = state?.attributes?.friendly_name;
@@ -164311,7 +164398,7 @@ var ServerModeEndpointManager = class extends Service {
       mapping,
       friendlyName
     );
-    const deviceType = this.deviceEndpoint?.type?.deviceType;
+    const deviceType = endpoint?.type?.deviceType;
     if (deviceType != null) {
       await this.serverNode.updateAdvertisedDeviceType(deviceType);
     }
@@ -164482,7 +164569,7 @@ var BridgeEnvironmentFactory = class extends BridgeFactory {
       await env.load(HomeAssistantClient),
       env.get(BridgeRegistry),
       await env.load(EntityMappingStorage),
-      dataProvider.id,
+      dataProvider,
       loggerService.get("ServerModeEndpointManager")
     );
     class ServerModeBridgeWithEnvironment extends ServerModeBridge {