@matter/protocol 0.11.0-alpha.0-20241005-e3e4e4a7a

package/dist/esm/interaction/InteractionServer.js

@@ -0,0 +1,1027 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Crypto, Diagnostic, InternalError, Logger, MatterFlowError } from "#general";
+import { AttributeModel, ClusterModel, CommandModel, GLOBAL_IDS, MatterModel, Specification } from "#model";
+import {
+  ArraySchema,
+  DEFAULT_MAX_PATHS_PER_INVOKE,
+  EventNumber,
+  INTERACTION_PROTOCOL_ID,
+  StatusCode,
+  StatusResponseError,
+  TlvAny,
+  TlvInvokeResponseData,
+  TlvInvokeResponseForSend,
+  TlvNoArguments,
+  TlvNoResponse,
+  TlvSubscribeResponse,
+  ValidationError
+} from "#types";
+import { AttributeServer, FabricScopedAttributeServer } from "../cluster/server/AttributeServer.js";
+import { SessionType } from "../codec/MessageCodec.js";
+import { NoAssociatedFabricError, assertSecureSession } from "../session/SecureSession.js";
+import {
+  decodeAttributeValueWithSchema,
+  decodeListAttributeValueWithSchema,
+  expandPathsInAttributeData
+} from "./AttributeDataDecoder.js";
+import {
+  InteractionServerMessenger,
+  MessageType
+} from "./InteractionMessenger.js";
+import { ServerSubscription } from "./ServerSubscription.js";
+import { ServerSubscriptionConfig } from "./SubscriptionOptions.js";
+const logger = Logger.get("InteractionServer");
+function genericElementPathToId(endpointId, clusterId, elementId) {
+  return `${endpointId}/${clusterId}/${elementId}`;
+}
+function commandPathToId({ endpointId, clusterId, commandId }) {
+  return genericElementPathToId(endpointId, clusterId, commandId);
+}
+function attributePathToId({ endpointId, clusterId, attributeId }) {
+  return genericElementPathToId(endpointId, clusterId, attributeId);
+}
+function eventPathToId({ endpointId, clusterId, eventId }) {
+  return genericElementPathToId(endpointId, clusterId, eventId);
+}
+function clusterPathToId({ nodeId, endpointId, clusterId }) {
+  return `${nodeId}/${endpointId}/${clusterId}`;
+}
+function isConcreteAttributePath(path) {
+  const { endpointId, clusterId, attributeId } = path;
+  return endpointId !== void 0 && clusterId !== void 0 && attributeId !== void 0;
+}
+function validateReadAttributesPath(path, isGroupSession = false) {
+  if (isGroupSession) {
+    throw new StatusResponseError("Illegal read request with group session", StatusCode.InvalidAction);
+  }
+  const { clusterId, attributeId } = path;
+  if (clusterId === void 0 && attributeId !== void 0) {
+    if (!GLOBAL_IDS.has(attributeId)) {
+      throw new StatusResponseError(
+        `Illegal read request for wildcard cluster and non global attribute ${attributeId}`,
+        StatusCode.InvalidAction
+      );
+    }
+  }
+}
+function validateWriteAttributesPath(path, isGroupSession = false) {
+  const { endpointId, clusterId, attributeId } = path;
+  if (clusterId === void 0 || attributeId === void 0) {
+    throw new StatusResponseError(
+      "Illegal write request with wildcard cluster or attribute ID",
+      StatusCode.InvalidAction
+    );
+  }
+  if (isGroupSession && endpointId !== void 0) {
+    throw new StatusResponseError("Illegal write request with group ID and endpoint ID", StatusCode.InvalidAction);
+  }
+}
+function isConcreteEventPath(path) {
+  const { endpointId, clusterId, eventId } = path;
+  return endpointId !== void 0 && clusterId !== void 0 && eventId !== void 0;
+}
+function validateReadEventPath(path, isGroupSession = false) {
+  const { clusterId, eventId } = path;
+  if (clusterId === void 0 && eventId !== void 0) {
+    throw new StatusResponseError("Illegal read request with wildcard cluster ID", StatusCode.InvalidAction);
+  }
+  if (isGroupSession) {
+    throw new StatusResponseError("Illegal read request with group session", StatusCode.InvalidAction);
+  }
+}
+function isConcreteCommandPath(path) {
+  const { endpointId, clusterId, commandId } = path;
+  return endpointId !== void 0 && clusterId !== void 0 && commandId !== void 0;
+}
+function validateCommandPath(path, isGroupSession = false) {
+  const { endpointId, clusterId, commandId } = path;
+  if (clusterId === void 0 || commandId === void 0) {
+    throw new StatusResponseError(
+      "Illegal write request with wildcard cluster or attribute ID",
+      StatusCode.InvalidAction
+    );
+  }
+  if (isGroupSession && endpointId !== void 0) {
+    throw new StatusResponseError("Illegal write request with group ID and endpoint ID", StatusCode.InvalidAction);
+  }
+}
+function getMatterModelCluster(clusterId) {
+  return MatterModel.standard.get(ClusterModel, clusterId);
+}
+function getMatterModelClusterAttribute(clusterId, attributeId) {
+  return getMatterModelCluster(clusterId)?.get(AttributeModel, attributeId);
+}
+function getMatterModelClusterCommand(clusterId, commandId) {
+  return getMatterModelCluster(clusterId)?.get(CommandModel, commandId);
+}
+class InteractionServer {
+  #context;
+  #nextSubscriptionId = Crypto.getRandomUInt32();
+  #isClosing = false;
+  #subscriptionConfig;
+  #maxPathsPerInvoke;
+  constructor(context) {
+    this.#context = context;
+    this.#subscriptionConfig = ServerSubscriptionConfig.of(context.subscriptionOptions);
+    this.#maxPathsPerInvoke = context.maxPathsPerInvoke ?? DEFAULT_MAX_PATHS_PER_INVOKE;
+    this.#context.structure.change.on(async () => {
+      this.#context.sessions.updateAllSubscriptions();
+    });
+  }
+  getId() {
+    return INTERACTION_PROTOCOL_ID;
+  }
+  get isClosing() {
+    return this.#isClosing;
+  }
+  get maxPathsPerInvoke() {
+    return this.#maxPathsPerInvoke;
+  }
+  async onNewExchange(exchange) {
+    if (this.#isClosing) return;
+    await new InteractionServerMessenger(exchange).handleRequest(this);
+  }
+  async handleReadRequest(exchange, {
+    attributeRequests,
+    dataVersionFilters,
+    eventRequests,
+    eventFilters,
+    isFabricFiltered,
+    interactionModelRevision
+  }, message) {
+    logger.debug(
+      `Received read request from ${exchange.channel.name}: attributes:${attributeRequests?.map((path) => this.#endpointStructure.resolveAttributeName(path)).join(", ") ?? "none"}, events:${eventRequests?.map((path) => this.#endpointStructure.resolveEventName(path)).join(", ") ?? "none"} isFabricFiltered=${isFabricFiltered}`
+    );
+    if (interactionModelRevision > Specification.INTERACTION_MODEL_REVISION) {
+      logger.debug(
+        `Interaction model revision of sender ${interactionModelRevision} is higher than supported ${Specification.INTERACTION_MODEL_REVISION}.`
+      );
+    }
+    if (attributeRequests === void 0 && eventRequests === void 0) {
+      throw new StatusResponseError(
+        "Only Read requests with attributeRequests or eventRequests are supported right now",
+        StatusCode.UnsupportedRead
+      );
+    }
+    if (message.packetHeader.sessionType !== SessionType.Unicast) {
+      throw new StatusResponseError(
+        "Subscriptions are only allowed on unicast sessions",
+        StatusCode.InvalidAction
+      );
+    }
+    const dataVersionFilterMap = new Map(
+      dataVersionFilters?.map(({ path, dataVersion }) => [clusterPathToId(path), dataVersion]) ?? []
+    );
+    if (dataVersionFilterMap.size > 0) {
+      logger.debug(
+        `DataVersionFilters: ${Array.from(dataVersionFilterMap.entries()).map(([path, version]) => `${path}=${version}`).join(", ")}`
+      );
+    }
+    const attributeReportsPayload = new Array();
+    for (const requestPath of attributeRequests ?? []) {
+      validateReadAttributesPath(requestPath);
+      const attributes = this.#endpointStructure.getAttributes([requestPath]);
+      if (attributes.length === 0) {
+        if (isConcreteAttributePath(requestPath)) {
+          const { endpointId, clusterId, attributeId } = requestPath;
+          try {
+            this.#endpointStructure.validateConcreteAttributePath(endpointId, clusterId, attributeId);
+            throw new InternalError(
+              "validateConcreteAttributePath should throw StatusResponseError but did not."
+            );
+          } catch (e) {
+            StatusResponseError.accept(e);
+            logger.debug(
+              `Error reading attribute from ${exchange.channel.name}: ${this.#endpointStructure.resolveAttributeName(requestPath)}: unsupported path: Status=${e.code}`
+            );
+            attributeReportsPayload.push({
+              hasFabricSensitiveData: false,
+              attributeStatus: { path: requestPath, status: { status: e.code } }
+            });
+          }
+        }
+        logger.debug(
+          `Read from ${exchange.channel.name}: ${this.#endpointStructure.resolveAttributeName(
+            requestPath
+          )}: ${this.#endpointStructure.resolveAttributeName(requestPath)}: ignore non-existing attribute`
+        );
+        continue;
+      }
+      for (const { path, attribute } of attributes) {
+        const { nodeId, endpointId, clusterId } = path;
+        try {
+          if (getMatterModelClusterAttribute(clusterId, attribute.id)?.readable === false) {
+            throw new StatusResponseError(
+              `Attribute ${attribute.id} is not readable.`,
+              StatusCode.UnsupportedRead
+            );
+          }
+          let value, version;
+          try {
+            ({ value, version } = await this.readAttribute(
+              path,
+              attribute,
+              exchange,
+              isFabricFiltered,
+              message,
+              this.#endpointStructure.getEndpoint(endpointId)
+            ));
+          } catch (e) {
+            NoAssociatedFabricError.accept(e);
+            if (endpointId === void 0 || clusterId === void 0) {
+              throw new MatterFlowError("Should never happen");
+            }
+            const cluster = this.#endpointStructure.getClusterServer(endpointId, clusterId);
+            if (cluster === void 0 || cluster.datasource == void 0) {
+              throw new MatterFlowError("Should never happen");
+            }
+            version = cluster.datasource.version;
+            value = [];
+          }
+          const versionFilterValue = endpointId !== void 0 && clusterId !== void 0 ? dataVersionFilterMap.get(clusterPathToId({ nodeId, endpointId, clusterId })) : void 0;
+          if (versionFilterValue !== void 0 && versionFilterValue === version) {
+            logger.debug(
+              `Read attribute from ${exchange.channel.name}: ${this.#endpointStructure.resolveAttributeName(
+                path
+              )}=${Logger.toJSON(value)} (version=${version}) ignored because of dataVersionFilter`
+            );
+            continue;
+          }
+          logger.debug(
+            `Read attribute from ${exchange.channel.name}: ${this.#endpointStructure.resolveAttributeName(
+              path
+            )}=${Logger.toJSON(value)} (version=${version})`
+          );
+          const { schema } = attribute;
+          attributeReportsPayload.push({
+            hasFabricSensitiveData: attribute.hasFabricSensitiveData,
+            attributeData: { path, dataVersion: version, payload: value, schema }
+          });
+        } catch (error) {
+          logger.error(
+            `Error while reading attribute from ${exchange.channel.name} to ${this.#endpointStructure.resolveAttributeName(path)}:`,
+            error
+          );
+          StatusResponseError.accept(error);
+          if (isConcreteAttributePath(requestPath)) {
+            attributeReportsPayload.push({
+              hasFabricSensitiveData: false,
+              attributeStatus: { path, status: { status: error.code } }
+            });
+          }
+        }
+      }
+    }
+    let eventReportsPayload;
+    if (eventRequests) {
+      eventReportsPayload = [];
+      for (const requestPath of eventRequests) {
+        validateReadEventPath(requestPath);
+        const events = this.#endpointStructure.getEvents([requestPath]);
+        if (events.length === 0) {
+          if (isConcreteEventPath(requestPath)) {
+            const { endpointId, clusterId, eventId } = requestPath;
+            try {
+              this.#endpointStructure.validateConcreteEventPath(endpointId, clusterId, eventId);
+              throw new InternalError(
+                "validateConcreteEventPath should throw StatusResponseError but did not."
+              );
+            } catch (e) {
+              StatusResponseError.accept(e);
+              logger.debug(
+                `Read event from ${exchange.channel.name}: ${this.#endpointStructure.resolveEventName(requestPath)}: unsupported path: Status=${e.code}`
+              );
+              eventReportsPayload?.push({
+                hasFabricSensitiveData: false,
+                eventStatus: { path: requestPath, status: { status: e.code } }
+              });
+            }
+          }
+          logger.debug(
+            `Read event from ${exchange.channel.name}: ${this.#endpointStructure.resolveEventName(
+              requestPath
+            )}: ignore non-existing event`
+          );
+          continue;
+        }
+        const reportsForPath = new Array();
+        for (const { path, event } of events) {
+          try {
+            const { endpointId } = path;
+            const matchingEvents = await this.readEvent(
+              path,
+              eventFilters,
+              event,
+              exchange,
+              isFabricFiltered,
+              message,
+              this.#endpointStructure.getEndpoint(endpointId)
+            );
+            logger.debug(
+              `Read event from ${exchange.channel.name}: ${this.#endpointStructure.resolveEventName(
+                path
+              )}=${Logger.toJSON(matchingEvents)}`
+            );
+            const { schema } = event;
+            reportsForPath.push(
+              ...matchingEvents.map(({ eventNumber, priority, epochTimestamp, data }) => ({
+                hasFabricSensitiveData: event.hasFabricSensitiveData,
+                eventData: {
+                  path,
+                  eventNumber,
+                  priority,
+                  epochTimestamp,
+                  payload: data,
+                  schema
+                }
+              }))
+            );
+          } catch (error) {
+            logger.error(
+              `Error while reading event from ${exchange.channel.name} to ${this.#endpointStructure.resolveEventName(path)}:`,
+              error
+            );
+            StatusResponseError.accept(error);
+            if (isConcreteEventPath(requestPath)) {
+              eventReportsPayload?.push({
+                hasFabricSensitiveData: false,
+                eventStatus: { path, status: { status: error.code } }
+              });
+            }
+          }
+        }
+        eventReportsPayload.push(
+          ...reportsForPath.sort((a, b) => {
+            const eventNumberA = a.eventData?.eventNumber ?? EventNumber(0);
+            const eventNumberB = b.eventData?.eventNumber ?? EventNumber(0);
+            if (eventNumberA > eventNumberB) {
+              return 1;
+            } else if (eventNumberA < eventNumberB) {
+              return -1;
+            } else {
+              return 0;
+            }
+          })
+        );
+      }
+    }
+    return {
+      interactionModelRevision: Specification.INTERACTION_MODEL_REVISION,
+      suppressResponse: true,
+      attributeReportsPayload,
+      eventReportsPayload
+    };
+  }
+  async readAttribute(_path, attribute, exchange, isFabricFiltered, message, _endpoint, offline = false) {
+    return attribute.getWithVersion(exchange.session, isFabricFiltered, offline ? void 0 : message);
+  }
+  async readEvent(_path, eventFilters, event, exchange, isFabricFiltered, message, _endpoint) {
+    return event.get(exchange.session, isFabricFiltered, message, eventFilters);
+  }
+  async handleWriteRequest(exchange, { suppressResponse, timedRequest, writeRequests, interactionModelRevision, moreChunkedMessages }, message) {
+    const sessionType = message.packetHeader.sessionType;
+    logger.debug(
+      `Received write request from ${exchange.channel.name}: ${writeRequests.map((req) => this.#endpointStructure.resolveAttributeName(req.path)).join(", ")}, suppressResponse=${suppressResponse}, moreChunkedMessages=${moreChunkedMessages}`
+    );
+    if (moreChunkedMessages && suppressResponse) {
+      throw new StatusResponseError(
+        "MoreChunkedMessages and SuppressResponse cannot be used together in write messages",
+        StatusCode.InvalidAction
+      );
+    }
+    if (interactionModelRevision > Specification.INTERACTION_MODEL_REVISION) {
+      logger.debug(
+        `Interaction model revision of sender ${interactionModelRevision} is higher than supported ${Specification.INTERACTION_MODEL_REVISION}.`
+      );
+    }
+    const receivedWithinTimedInteraction = exchange.hasActiveTimedInteraction();
+    if (receivedWithinTimedInteraction && moreChunkedMessages) {
+      throw new StatusResponseError(
+        "Write Request action that is part of a Timed Write Interaction SHALL NOT be chunked.",
+        StatusCode.InvalidAction
+      );
+    }
+    if (exchange.hasExpiredTimedInteraction()) {
+      exchange.clearTimedInteraction();
+      throw new StatusResponseError(`Timed request window expired. Decline write request.`, StatusCode.Timeout);
+    }
+    if (timedRequest !== exchange.hasTimedInteraction()) {
+      throw new StatusResponseError(
+        `timedRequest flag of write interaction (${timedRequest}) mismatch with expected timed interaction (${receivedWithinTimedInteraction}).`,
+        StatusCode.TimedRequestMismatch
+      );
+    }
+    if (receivedWithinTimedInteraction) {
+      logger.debug(
+        `Write request from ${exchange.channel.name} successfully received while timed interaction is running.`
+      );
+      exchange.clearTimedInteraction();
+      if (sessionType !== SessionType.Unicast) {
+        throw new StatusResponseError(
+          "Write requests are only allowed on unicast sessions when a timed interaction is running.",
+          StatusCode.InvalidAction
+        );
+      }
+    }
+    if (sessionType === SessionType.Group && !suppressResponse) {
+      throw new StatusResponseError(
+        "Write requests are only allowed as group casts when suppressResponse=true.",
+        StatusCode.InvalidAction
+      );
+    }
+    const writeData = expandPathsInAttributeData(writeRequests, true);
+    const writeResults = new Array();
+    const attributeListWrites = /* @__PURE__ */ new Set();
+    const clusterDataVersionInfo = /* @__PURE__ */ new Map();
+    const inaccessiblePaths = /* @__PURE__ */ new Set();
+    for (const writeRequest of writeData) {
+      const { path: writePath, dataVersion } = writeRequest;
+      validateWriteAttributesPath(writePath);
+      const attributes = this.#endpointStructure.getAttributes([writePath], true);
+      if (attributes.length === 0) {
+        if (isConcreteAttributePath(writePath)) {
+          const { endpointId, clusterId, attributeId } = writePath;
+          try {
+            this.#endpointStructure.validateConcreteAttributePath(endpointId, clusterId, attributeId);
+            throw new StatusResponseError(
+              `Attribute ${attributeId} is not writable.`,
+              StatusCode.UnsupportedWrite
+            );
+          } catch (e) {
+            StatusResponseError.accept(e);
+            logger.debug(
+              `Write from ${exchange.channel.name}: ${this.#endpointStructure.resolveAttributeName(
+                writePath
+              )} not allowed: Status=${e.code}`
+            );
+            writeResults.push({ path: writePath, statusCode: e.code });
+          }
+        } else {
+          logger.debug(
+            `Write from ${exchange.channel.name}: ${this.#endpointStructure.resolveAttributeName(
+              writePath
+            )}: ignore non-existing (wildcard) attribute`
+          );
+        }
+        continue;
+      }
+      if (attributes.length === 1 && isConcreteAttributePath(writePath)) {
+        const { endpointId, clusterId } = writePath;
+        const { attribute } = attributes[0];
+        if (attribute.requiresTimedInteraction && !receivedWithinTimedInteraction) {
+          logger.debug(`This write requires a timed interaction which is not initialized.`);
+          writeResults.push({ path: writePath, statusCode: StatusCode.NeedsTimedInteraction });
+          continue;
+        }
+        if (attribute instanceof FabricScopedAttributeServer && (!exchange.session.isSecure || !exchange.session.fabric)) {
+          logger.debug(`This write requires a secure session with a fabric assigned which is missing.`);
+          writeResults.push({ path: writePath, statusCode: StatusCode.UnsupportedAccess });
+          continue;
+        }
+        if (dataVersion !== void 0) {
+          const datasource = this.#endpointStructure.getClusterServer(endpointId, clusterId)?.datasource;
+          const { nodeId } = writePath;
+          const clusterKey = clusterPathToId({ nodeId, endpointId, clusterId });
+          const currentDataVersion = clusterDataVersionInfo.get(clusterKey) ?? datasource?.version;
+          if (currentDataVersion !== void 0) {
+            if (dataVersion !== currentDataVersion) {
+              logger.debug(
+                `This write requires a specific data version (${dataVersion}) which do not match the current cluster data version (${currentDataVersion}).`
+              );
+              writeResults.push({ path: writePath, statusCode: StatusCode.DataVersionMismatch });
+              continue;
+            }
+            clusterDataVersionInfo.set(clusterKey, currentDataVersion);
+          }
+        }
+      }
+      for (const { path, attribute } of attributes) {
+        const { schema, defaultValue } = attribute;
+        const pathId = attributePathToId(path);
+        try {
+          if (!(attribute instanceof AttributeServer) && !(attribute instanceof FabricScopedAttributeServer)) {
+            throw new StatusResponseError(
+              "Fixed attributes cannot be written",
+              StatusCode.UnsupportedWrite
+            );
+          }
+          if (inaccessiblePaths.has(pathId)) {
+            logger.debug(`This write is not allowed due to previous access denied.`);
+            continue;
+          }
+          const { endpointId } = path;
+          const { listIndex } = writePath;
+          const value = listIndex === void 0 ? decodeAttributeValueWithSchema(schema, [writeRequest], defaultValue) : decodeListAttributeValueWithSchema(
+            schema,
+            [writeRequest],
+            (await this.readAttribute(
+              path,
+              attribute,
+              exchange,
+              true,
+              message,
+              this.#endpointStructure.getEndpoint(endpointId)
+            )).value ?? defaultValue
+          );
+          logger.debug(
+            `Handle write request from ${exchange.channel.name} resolved to: ${this.#endpointStructure.resolveAttributeName(path)}=${Logger.toJSON(
+              value
+            )} (listIndex=${listIndex}, for-version=${dataVersion})`
+          );
+          if (attribute.requiresTimedInteraction && !receivedWithinTimedInteraction) {
+            logger.debug(`This write requires a timed interaction which is not initialized.`);
+            throw new StatusResponseError(
+              "This write requires a timed interaction which is not initialized.",
+              StatusCode.NeedsTimedInteraction
+            );
+          }
+          await this.writeAttribute(
+            path,
+            attribute,
+            value,
+            exchange,
+            message,
+            this.#endpointStructure.getEndpoint(endpointId),
+            receivedWithinTimedInteraction,
+            schema instanceof ArraySchema
+          );
+          if (schema instanceof ArraySchema && !attributeListWrites.has(attribute)) {
+            attributeListWrites.add(attribute);
+          }
+        } catch (error) {
+          if (StatusResponseError.is(error, StatusCode.UnsupportedAccess)) {
+            inaccessiblePaths.add(pathId);
+          }
+          if (attributes.length === 1 && isConcreteAttributePath(writePath)) {
+            logger.error(
+              `Error while handling write request from ${exchange.channel.name} to ${this.#endpointStructure.resolveAttributeName(path)}:`,
+              error instanceof StatusResponseError ? error.message : error
+            );
+            if (error instanceof StatusResponseError) {
+              writeResults.push({ path, statusCode: error.code, clusterStatusCode: error.clusterCode });
+              continue;
+            }
+            writeResults.push({ path, statusCode: StatusCode.ConstraintError });
+            continue;
+          } else {
+            logger.debug(
+              `While handling write request from ${exchange.channel.name} to ${this.#endpointStructure.resolveAttributeName(path)} ignored: ${error.message}`
+            );
+          }
+        }
+        writeResults.push({ path, statusCode: StatusCode.Success });
+      }
+    }
+    const errorResults = writeResults.filter(({ statusCode }) => statusCode !== StatusCode.Success);
+    logger.debug(
+      `Write request from ${exchange.channel.name} done ${errorResults.length ? `with following errors: ${errorResults.map(
+        ({ path, statusCode }) => `${this.#endpointStructure.resolveAttributeName(path)}=${Logger.toJSON(statusCode)}`
+      ).join(", ")}` : "without errors"}`
+    );
+    const response = {
+      interactionModelRevision: Specification.INTERACTION_MODEL_REVISION,
+      writeResponses: writeResults.map(({ path, statusCode, clusterStatusCode }) => ({
+        path,
+        status: { status: statusCode, clusterStatus: clusterStatusCode }
+      }))
+    };
+    for (const attribute of attributeListWrites.values()) {
+      try {
+        attribute.triggerDelayedChangeEvents();
+      } catch (error) {
+        logger.error(
+          `Ignored Error while writing attribute from ${exchange.channel.name} to ${attribute.name}:`,
+          error
+        );
+      }
+    }
+    return response;
+  }
+  async writeAttribute(_path, attribute, value, exchange, message, _endpoint, _receivedWithinTimedInteraction, isListWrite = false) {
+    attribute.set(value, exchange.session, message, isListWrite);
+  }
+  async handleSubscribeRequest(exchange, {
+    minIntervalFloorSeconds,
+    maxIntervalCeilingSeconds,
+    attributeRequests,
+    dataVersionFilters,
+    eventRequests,
+    eventFilters,
+    keepSubscriptions,
+    isFabricFiltered,
+    interactionModelRevision
+  }, messenger, message) {
+    logger.debug(
+      `Received subscribe request from ${exchange.channel.name} (keepSubscriptions=${keepSubscriptions}, isFabricFiltered=${isFabricFiltered})`
+    );
+    if (interactionModelRevision > Specification.INTERACTION_MODEL_REVISION) {
+      logger.debug(
+        `Interaction model revision of sender ${interactionModelRevision} is higher than supported ${Specification.INTERACTION_MODEL_REVISION}.`
+      );
+    }
+    if (message.packetHeader.sessionType !== SessionType.Unicast) {
+      throw new StatusResponseError(
+        "Subscriptions are only allowed on unicast sessions",
+        StatusCode.InvalidAction
+      );
+    }
+    assertSecureSession(exchange.session, "Subscriptions are only implemented on secure sessions");
+    const session = exchange.session;
+    const fabric = session.fabric;
+    if (fabric === void 0)
+      throw new StatusResponseError(
+        "Subscriptions are only implemented after a fabric has been assigned",
+        StatusCode.InvalidAction
+      );
+    if (!keepSubscriptions) {
+      logger.debug(
+        `Clear subscriptions for Subscriber node ${session.peerNodeId} because keepSubscriptions=false`
+      );
+      await this.#context.sessions.clearSubscriptionsForNode(fabric.fabricIndex, session.peerNodeId, true);
+    }
+    if ((!Array.isArray(attributeRequests) || attributeRequests.length === 0) && (!Array.isArray(eventRequests) || eventRequests.length === 0)) {
+      throw new StatusResponseError("No attributes or events requested", StatusCode.InvalidAction);
+    }
+    logger.debug(
+      `Subscribe to attributes:${attributeRequests?.map((path) => this.#endpointStructure.resolveAttributeName(path)).join(", ") ?? "none"}, events:${eventRequests?.map((path) => this.#endpointStructure.resolveEventName(path)).join(", ") ?? "none"}`
+    );
+    if (dataVersionFilters !== void 0 && dataVersionFilters.length > 0) {
+      logger.debug(
+        `DataVersionFilters: ${dataVersionFilters.map(
+          ({ path: { nodeId, endpointId, clusterId }, dataVersion }) => `${clusterPathToId({ nodeId, endpointId, clusterId })}=${dataVersion}`
+        ).join(", ")}`
+      );
+    }
+    if (eventFilters !== void 0 && eventFilters.length > 0)
+      logger.debug(
+        `Event filters: ${eventFilters.map((filter) => `${filter.nodeId}/${filter.eventMin}`).join(", ")}`
+      );
+    attributeRequests?.forEach((path) => validateReadAttributesPath(path));
+    eventRequests?.forEach((path) => validateReadEventPath(path));
+    if (minIntervalFloorSeconds < 0) {
+      throw new StatusResponseError(
+        "minIntervalFloorSeconds should be greater or equal to 0",
+        StatusCode.InvalidAction
+      );
+    }
+    if (maxIntervalCeilingSeconds < 0) {
+      throw new StatusResponseError(
+        "maxIntervalCeilingSeconds should be greater or equal to 1",
+        StatusCode.InvalidAction
+      );
+    }
+    if (maxIntervalCeilingSeconds < minIntervalFloorSeconds) {
+      throw new StatusResponseError(
+        "maxIntervalCeilingSeconds should be greater or equal to minIntervalFloorSeconds",
+        StatusCode.InvalidAction
+      );
+    }
+    if (this.#nextSubscriptionId === 4294967295) this.#nextSubscriptionId = 0;
+    const subscriptionId = this.#nextSubscriptionId++;
+    const context = {
+      session,
+      structure: this.#endpointStructure,
+      readAttribute: (path, attribute, offline) => this.readAttribute(
+        path,
+        attribute,
+        exchange,
+        isFabricFiltered,
+        message,
+        this.#endpointStructure.getEndpoint(path.endpointId),
+        offline
+      ),
+      readEvent: (path, event, eventFilters2) => this.readEvent(
+        path,
+        eventFilters2,
+        event,
+        exchange,
+        isFabricFiltered,
+        message,
+        this.#endpointStructure.getEndpoint(path.endpointId)
+      ),
+      initiateExchange: (address, protocolId) => this.#context.initiateExchange(address, protocolId)
+    };
+    const subscription = new ServerSubscription({
+      id: subscriptionId,
+      context,
+      criteria: {
+        attributeRequests,
+        dataVersionFilters,
+        eventRequests,
+        eventFilters,
+        isFabricFiltered
+      },
+      minIntervalFloor: minIntervalFloorSeconds,
+      maxIntervalCeiling: maxIntervalCeilingSeconds,
+      subscriptionOptions: this.#subscriptionConfig
+    });
+    try {
+      await subscription.sendInitialReport(messenger);
+    } catch (error) {
+      logger.error(
+        `Subscription ${subscriptionId} for Session ${session.id}: Error while sending initial data reports`,
+        error
+      );
+      await subscription.close();
+      if (error instanceof StatusResponseError) {
+        logger.info(`Sending status response ${error.code} for interaction error: ${error.message}`);
+        await messenger.sendStatus(error.code);
+      }
+      await messenger.close();
+      return;
+    }
+    const maxInterval = subscription.maxInterval;
+    logger.info(
+      `Successfully created subscription ${subscriptionId} for Session ${session.id}. Updates: ${minIntervalFloorSeconds} - ${maxIntervalCeilingSeconds} => ${maxInterval} seconds (sendInterval = ${subscription.sendInterval} seconds)`
+    );
+    await messenger.send(
+      MessageType.SubscribeResponse,
+      TlvSubscribeResponse.encode({
+        subscriptionId,
+        maxInterval,
+        interactionModelRevision: Specification.INTERACTION_MODEL_REVISION
+      })
+    );
+    subscription.activateSendingUpdates();
+  }
+  async handleInvokeRequest(exchange, { invokeRequests, timedRequest, suppressResponse, interactionModelRevision }, messenger, message) {
+    logger.debug(
+      `Received invoke request from ${exchange.channel.name}${invokeRequests.length > 0 ? ` with ${invokeRequests.length} commands` : ""}: ${invokeRequests.map(
+        ({ commandPath: { endpointId, clusterId, commandId } }) => this.#endpointStructure.resolveCommandName({ endpointId, clusterId, commandId })
+      ).join(", ")}, suppressResponse=${suppressResponse}`
+    );
+    if (interactionModelRevision > Specification.INTERACTION_MODEL_REVISION) {
+      logger.debug(
+        `Interaction model revision of sender ${interactionModelRevision} is higher than supported ${Specification.INTERACTION_MODEL_REVISION}.`
+      );
+    }
+    const receivedWithinTimedInteraction = exchange.hasActiveTimedInteraction();
+    if (exchange.hasExpiredTimedInteraction()) {
+      exchange.clearTimedInteraction();
+      throw new StatusResponseError(`Timed request window expired. Decline invoke request.`, StatusCode.Timeout);
+    }
+    if (timedRequest !== exchange.hasTimedInteraction()) {
+      throw new StatusResponseError(
+        `timedRequest flag of invoke interaction (${timedRequest}) mismatch with expected timed interaction (${receivedWithinTimedInteraction}).`,
+        StatusCode.TimedRequestMismatch
+      );
+    }
+    if (receivedWithinTimedInteraction) {
+      logger.debug(`Invoke request from ${exchange.channel.name} received while timed interaction is running.`);
+      exchange.clearTimedInteraction();
+      if (message.packetHeader.sessionType !== SessionType.Unicast) {
+        throw new StatusResponseError(
+          "Invoke requests are only allowed on unicast sessions when a timed interaction is running.",
+          StatusCode.InvalidAction
+        );
+      }
+    }
+    if (invokeRequests.length > this.#maxPathsPerInvoke) {
+      throw new StatusResponseError(
+        `Only ${this.#maxPathsPerInvoke} invoke requests are supported in one message. This message contains ${invokeRequests.length}`,
+        StatusCode.InvalidAction
+      );
+    }
+    invokeRequests.forEach(({ commandPath }) => validateCommandPath(commandPath));
+    if (invokeRequests.length > 1) {
+      const invokeUniqueSet = /* @__PURE__ */ new Set();
+      invokeRequests.forEach(({ commandPath }) => {
+        if (!isConcreteCommandPath(commandPath)) {
+          throw new StatusResponseError(
+            "Wildcard paths are not supported in multi-command invoke requests",
+            StatusCode.InvalidAction
+          );
+        }
+        const commandPathId = commandPathToId(commandPath);
+        if (invokeUniqueSet.has(commandPathId)) {
+          throw new StatusResponseError(
+            `Duplicate command paths (${commandPathId}) are not allowed in multi-command invoke requests`,
+            StatusCode.InvalidAction
+          );
+        }
+        invokeUniqueSet.add(commandPathId);
+      });
+    }
+    const isGroupSession = message.packetHeader.sessionType === SessionType.Group;
+    const invokeResponseMessage = {
+      suppressResponse: false,
+      // Deprecated but must be present
+      interactionModelRevision: Specification.INTERACTION_MODEL_REVISION,
+      invokeResponses: [],
+      moreChunkedMessages: invokeRequests.length > 1
+      // Assume for now we have multiple responses when having multiple invokes
+    };
+    const emptyInvokeResponseBytes = TlvInvokeResponseForSend.encode(invokeResponseMessage);
+    let messageSize = emptyInvokeResponseBytes.length;
+    let invokeResultsProcessed = 0;
+    const processResponseResult = async (invokeResponse) => {
+      invokeResultsProcessed++;
+      if (isGroupSession) {
+        return;
+      }
+      const encodedInvokeResponse = TlvInvokeResponseData.encodeTlv(invokeResponse);
+      const invokeResponseBytes = TlvAny.getEncodedByteLength(encodedInvokeResponse);
+      if (messageSize + invokeResponseBytes > exchange.maxPayloadSize || invokeResultsProcessed === invokeRequests.length) {
+        let lastMessageProcessed = false;
+        if (messageSize + invokeResponseBytes <= exchange.maxPayloadSize) {
+          invokeResponseMessage.invokeResponses.push(encodedInvokeResponse);
+          lastMessageProcessed = true;
+        }
+        if (invokeResponseMessage.invokeResponses.length > 0) {
+          if (invokeRequests.length > 1) {
+            logger.debug(
+              `Send ${lastMessageProcessed ? "final " : ""}invoke response for ${invokeResponseMessage.invokeResponses} commands`
+            );
+          }
+          await messenger.send(
+            MessageType.InvokeResponse,
+            TlvInvokeResponseForSend.encode({
+              ...invokeResponseMessage,
+              moreChunkedMessages: invokeResultsProcessed < invokeRequests.length ? true : void 0
+            })
+          );
+          invokeResponseMessage.invokeResponses = [];
+          messageSize = emptyInvokeResponseBytes.length;
+        }
+        if (!lastMessageProcessed) {
+          invokeResultsProcessed--;
+          return processResponseResult(invokeResponse);
+        }
+      } else {
+        invokeResponseMessage.invokeResponses.push(encodedInvokeResponse);
+        messageSize += invokeResponseBytes;
+      }
+    };
+    for (const { commandPath, commandFields, commandRef } of invokeRequests) {
+      const commands = this.#endpointStructure.getCommands([commandPath]);
+      if (commands.length === 0) {
+        if (isConcreteCommandPath(commandPath)) {
+          const { endpointId, clusterId, commandId } = commandPath;
+          let result;
+          try {
+            this.#endpointStructure.validateConcreteCommandPath(endpointId, clusterId, commandId);
+            throw new InternalError(
+              "validateConcreteCommandPath should throw StatusResponseError but did not."
+            );
+          } catch (e) {
+            StatusResponseError.accept(e);
+            logger.debug(
+              `Invoke from ${exchange.channel.name}: ${this.#endpointStructure.resolveCommandName(
+                commandPath
+              )} unsupported path: Status=${e.code}`
+            );
+            result = { status: { commandPath, status: { status: e.code }, commandRef } };
+          }
+          await processResponseResult(result);
+        } else {
+          logger.debug(
+            `Invoke from ${exchange.channel.name}: ${this.#endpointStructure.resolveCommandName(
+              commandPath
+            )} ignore non-existing command`
+          );
+        }
+        continue;
+      }
+      const isConcretePath = isConcreteCommandPath(commandPath);
+      for (const { command, path } of commands) {
+        const { endpointId, clusterId, commandId } = path;
+        if (endpointId === void 0) {
+          logger.error(
+            `Invoke from ${exchange.channel.name}: ${this.#endpointStructure.resolveCommandName(
+              path
+            )} invalid path because empty endpoint!`
+          );
+          if (isConcretePath) {
+            await processResponseResult({
+              status: {
+                commandPath: path,
+                status: { status: StatusCode.UnsupportedEndpoint },
+                commandRef
+              }
+            });
+          }
+          continue;
+        }
+        const endpoint = this.#endpointStructure.getEndpoint(endpointId);
+        if (endpoint === void 0) {
+          logger.error(
+            `Invoke from ${exchange.channel.name}: ${this.#endpointStructure.resolveCommandName(
+              path
+            )} invalid path because endpoint not found!`
+          );
+          if (isConcretePath) {
+            await processResponseResult({
+              status: {
+                commandPath: path,
+                status: { status: StatusCode.UnsupportedEndpoint },
+                commandRef
+              }
+            });
+          }
+          continue;
+        }
+        if (command.requiresTimedInteraction && !receivedWithinTimedInteraction) {
+          logger.debug(`This invoke requires a timed interaction which is not initialized.`);
+          if (isConcretePath) {
+            await processResponseResult({
+              status: {
+                commandPath: path,
+                status: { status: StatusCode.NeedsTimedInteraction },
+                commandRef
+              }
+            });
+          }
+          continue;
+        }
+        if (getMatterModelClusterCommand(clusterId, commandId)?.fabricScoped && (!exchange.session.isSecure || !exchange.session.fabric)) {
+          logger.debug(`This invoke requires a secure session with a fabric assigned which is missing.`);
+          if (isConcretePath) {
+            await processResponseResult({
+              status: { commandPath: path, status: { status: StatusCode.UnsupportedAccess }, commandRef }
+            });
+          }
+          continue;
+        }
+        let result;
+        try {
+          result = await this.invokeCommand(
+            path,
+            command,
+            exchange,
+            commandFields ?? TlvNoArguments.encodeTlv(commandFields),
+            message,
+            endpoint,
+            receivedWithinTimedInteraction
+          );
+        } catch (e) {
+          StatusResponseError.accept(e);
+          let errorCode = e.code;
+          const errorLogText = `Error ${Diagnostic.hex(errorCode)}${e.clusterCode !== void 0 ? `/${Diagnostic.hex(e.clusterCode)}` : ""} while invoking command: ${e.message}`;
+          if (e instanceof ValidationError) {
+            logger.info(
+              `Validation-${errorLogText}${e.fieldName !== void 0 ? ` in field ${e.fieldName}` : ""}`
+            );
+            if (errorCode === StatusCode.InvalidAction) {
+              errorCode = StatusCode.InvalidCommand;
+            }
+          } else {
+            logger.info(errorLogText);
+          }
+          result = {
+            code: errorCode,
+            clusterCode: e.clusterCode,
+            responseId: command.responseId,
+            response: TlvNoResponse.encodeTlv()
+          };
+        }
+        const { code, clusterCode, responseId, response } = result;
+        if (response.length === 0) {
+          await processResponseResult({
+            status: { commandPath: path, status: { status: code, clusterStatus: clusterCode }, commandRef }
+          });
+        } else {
+          await processResponseResult({
+            command: {
+              commandPath: { ...path, commandId: responseId },
+              commandFields: response,
+              commandRef
+            }
+          });
+        }
+      }
+    }
+  }
+  async invokeCommand(_path, command, exchange, commandFields, message, endpoint, _receivedWithinTimedInteraction = false) {
+    return command.invoke(exchange.session, commandFields, message, endpoint);
+  }
+  handleTimedRequest(exchange, { timeout, interactionModelRevision }) {
+    logger.debug(`Received timed request (${timeout}ms) from ${exchange.channel.name}`);
+    if (interactionModelRevision > Specification.INTERACTION_MODEL_REVISION) {
+      logger.debug(
+        `Interaction model revision of sender ${interactionModelRevision} is higher than supported ${Specification.INTERACTION_MODEL_REVISION}.`
+      );
+    }
+    exchange.startTimedInteraction(timeout);
+  }
+  async close() {
+    this.#isClosing = true;
+  }
+  get #endpointStructure() {
+    return this.#context.structure;
+  }
+}
+export {
+  InteractionServer,
+  attributePathToId,
+  clusterPathToId,
+  commandPathToId,
+  eventPathToId,
+  genericElementPathToId,
+  validateReadAttributesPath,
+  validateReadEventPath
+};
+//# sourceMappingURL=InteractionServer.js.map