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

package/dist/esm/protocol/MessageReceptionState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageReceptionState.d.ts","sourceRoot":"","sources":["../../../src/protocol/MessageReceptionState.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAiB,WAAW,EAAE,MAAM,UAAU,CAAC;AAStD,qBAAa,qBAAsB,SAAQ,WAAW;CAAG;AAEzD,8BAAsB,qBAAqB;IACvC,QAAQ,CAAC,oBAAoB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;CAC9D;AAED;;;;;;GAMG;AACH,qBAAa,6CAA8C,SAAQ,qBAAqB;IACpF,SAAS,CAAC,qBAAqB,EAAE,MAAM,GAAG,SAAS,CAAC;IACpD,OAAO,CAAC,oBAAoB,CAAc;gBAE9B,cAAc,CAAC,EAAE,MAAM;IAOnC,4CAA4C;IAC5C,OAAO,CAAC,UAAU;IAKlB;;;;;;;OAOG;IACH,SAAS,CAAC,aAAa,CAAC,cAAc,EAAE,MAAM;IAO9C,iDAAiD;IACjD,OAAO,CAAC,6BAA6B;IAuBrC,6CAA6C;IAC7C,OAAO,CAAC,6BAA6B;IAarC,2DAA2D;IAC3D,OAAO,CAAC,sBAAsB;IAQ9B;;OAEG;IACH,oBAAoB,CAAC,cAAc,EAAE,MAAM;CA2B9C;AAED;;;;;GAKG;AACH,qBAAa,0CAA2C,SAAQ,6CAA6C;cACtF,aAAa,CAAC,cAAc,EAAE,MAAM;CAuB1D;AAED;;;;;;;GAOG;AACH,qBAAa,4CAA6C,SAAQ,6CAA6C;cACxF,aAAa,CAAC,cAAc,EAAE,MAAM;CA0B1D"}

package/dist/esm/protocol/MessageReceptionState.js

@@ -0,0 +1,153 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { InternalError, MatterError } from "#general";
+import { MAX_COUNTER_VALUE_32BIT } from "./MessageCounter.js";
+const MAX_COUNTER_INCREASE_2POW31 = Math.pow(2, 31);
+const MSG_COUNTER_WINDOW_SIZE = 32;
+class DuplicateMessageError extends MatterError {
+}
+class MessageReceptionState {
+}
+class MessageReceptionStateEncryptedWithoutRollover extends MessageReceptionState {
+  maximumMessageCounter;
+  messageCounterBitmap = 4294967295;
+  // All bits set to 1
+  constructor(messageCounter) {
+    super();
+    if (messageCounter !== void 0) {
+      this.initialize(messageCounter);
+    }
+  }
+  /** Initialize the message counter state. */
+  initialize(messageCounter) {
+    this.maximumMessageCounter = messageCounter;
+    this.messageCounterBitmap = 4294967295;
+  }
+  /**
+   * Calculate plain diff without rollover.
+   * This method is mainly overridden for other counter types and follow the following semantic
+   * Return number is:
+   * * negative if the new message counter is smaller than the current maximum. Smaller values within the Window size
+   *   are check separately within the window. Other smaller values are considered DUPLICATE
+   * * positive if the new message counter is larger than the current maximum and are always NEW
+   */
+  calculateDiff(messageCounter) {
+    if (this.maximumMessageCounter === void 0) {
+      return 0;
+    }
+    return messageCounter - this.maximumMessageCounter;
+  }
+  /** Update or move the message counter window. */
+  calculateMessageCounterBitmap(messageCounterBitmap, diff) {
+    if (diff < 0) {
+      if (diff < -MSG_COUNTER_WINDOW_SIZE) {
+        throw new InternalError(`Message counter difference too large: ${diff}`);
+      }
+      const bit = 1 << -diff - 1;
+      messageCounterBitmap |= bit;
+    } else if (diff > 0) {
+      if (diff <= MSG_COUNTER_WINDOW_SIZE) {
+        const bit = 1 << diff - 1;
+        messageCounterBitmap = messageCounterBitmap << diff >>> 0 | bit;
+      } else {
+        messageCounterBitmap = 0;
+      }
+    }
+    return messageCounterBitmap >>> 0;
+  }
+  /** Update the message counter and window. */
+  updateMessageCounterAndBitmap(messageCounter, diff) {
+    if (this.maximumMessageCounter === void 0) {
+      this.initialize(messageCounter);
+      return;
+    }
+    this.messageCounterBitmap = this.calculateMessageCounterBitmap(this.messageCounterBitmap, diff);
+    if (diff > 0 || diff < -MSG_COUNTER_WINDOW_SIZE) {
+      this.maximumMessageCounter = messageCounter;
+    }
+  }
+  /** Check if the message counter is known in the bitmap. */
+  isCounterKnownInBitmap(diff) {
+    if (diff < -MSG_COUNTER_WINDOW_SIZE || diff >= 0) {
+      throw new InternalError(`Invalid Message counter difference for check: ${diff}`);
+    }
+    const bit = 1 << -diff - 1;
+    return (this.messageCounterBitmap & bit) !== 0;
+  }
+  /**
+   * Returns true if the message counter is a duplicate.
+   */
+  updateMessageCounter(messageCounter) {
+    if (messageCounter < 0 || messageCounter > MAX_COUNTER_VALUE_32BIT) {
+      throw new InternalError(`Invalid message counter value: ${messageCounter}`);
+    }
+    if (this.maximumMessageCounter === void 0) {
+      this.updateMessageCounterAndBitmap(messageCounter, 0);
+      return;
+    }
+    if (messageCounter === this.maximumMessageCounter) {
+      throw new DuplicateMessageError("Message counter equals the maximum message counter.");
+    }
+    const diff = this.calculateDiff(messageCounter);
+    if (diff < 0) {
+      if (diff < -MSG_COUNTER_WINDOW_SIZE) {
+        throw new DuplicateMessageError("Message counter is considered duplicate.");
+      }
+      if (this.isCounterKnownInBitmap(diff)) {
+        throw new DuplicateMessageError("Message counter is within the message counter window and duplicate.");
+      }
+    }
+    this.updateMessageCounterAndBitmap(messageCounter, diff);
+  }
+}
+class MessageReceptionStateEncryptedWithRollover extends MessageReceptionStateEncryptedWithoutRollover {
+  calculateDiff(messageCounter) {
+    if (this.maximumMessageCounter === void 0) {
+      return 0;
+    }
+    const diff = messageCounter - this.maximumMessageCounter;
+    if (diff > 0) {
+      if (diff < MAX_COUNTER_INCREASE_2POW31) {
+        return diff;
+      }
+      return diff - MAX_COUNTER_VALUE_32BIT - 1;
+    } else if (diff < 0) {
+      if (diff >= -MAX_COUNTER_INCREASE_2POW31) {
+        return diff;
+      }
+      return diff + MAX_COUNTER_VALUE_32BIT + 1;
+    }
+    return 0;
+  }
+}
+class MessageReceptionStateUnencryptedWithRollover extends MessageReceptionStateEncryptedWithoutRollover {
+  calculateDiff(messageCounter) {
+    if (this.maximumMessageCounter === void 0) {
+      return 0;
+    }
+    const diff = messageCounter - this.maximumMessageCounter;
+    if (diff > 0) {
+      if (-diff + MAX_COUNTER_VALUE_32BIT < MSG_COUNTER_WINDOW_SIZE) {
+        return diff - MAX_COUNTER_VALUE_32BIT - 1;
+      }
+      return diff;
+    } else if (diff < 0) {
+      if (diff < -MSG_COUNTER_WINDOW_SIZE) {
+        return MAX_COUNTER_VALUE_32BIT + diff;
+      }
+      return diff;
+    }
+    return 0;
+  }
+}
+export {
+  DuplicateMessageError,
+  MessageReceptionState,
+  MessageReceptionStateEncryptedWithRollover,
+  MessageReceptionStateEncryptedWithoutRollover,
+  MessageReceptionStateUnencryptedWithRollover
+};
+//# sourceMappingURL=MessageReceptionState.js.map

package/dist/esm/protocol/MessageReceptionState.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/protocol/MessageReceptionState.ts"],
+  "mappings": "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",
+  "names": []
+}

package/dist/esm/protocol/ProtocolHandler.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Message } from "../codec/MessageCodec.js";
+import { MessageExchange } from "./MessageExchange.js";
+export interface ProtocolHandler {
+    getId(): number;
+    onNewExchange(exchange: MessageExchange, message: Message): Promise<void>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=ProtocolHandler.d.ts.map

package/dist/esm/protocol/ProtocolHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtocolHandler.d.ts","sourceRoot":"","sources":["../../../src/protocol/ProtocolHandler.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD,MAAM,WAAW,eAAe;IAC5B,KAAK,IAAI,MAAM,CAAC;IAChB,aAAa,CAAC,QAAQ,EAAE,eAAe,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1E,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B"}

package/dist/esm/protocol/ProtocolHandler.js

@@ -0,0 +1,6 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+//# sourceMappingURL=ProtocolHandler.js.map

package/dist/esm/protocol/ProtocolHandler.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/protocol/ProtocolHandler.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;",
+  "names": []
+}

package/dist/esm/protocol/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from "./ChannelManager.js";
+export * from "./DeviceAdvertiser.js";
+export * from "./DeviceCommissioner.js";
+export * from "./ExchangeManager.js";
+export * from "./MessageCounter.js";
+export * from "./MessageExchange.js";
+export * from "./MessageReceptionState.js";
+export * from "./ProtocolHandler.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/protocol/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/protocol/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC"}

package/dist/esm/protocol/index.js

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from "./ChannelManager.js";
+export * from "./DeviceAdvertiser.js";
+export * from "./DeviceCommissioner.js";
+export * from "./ExchangeManager.js";
+export * from "./MessageCounter.js";
+export * from "./MessageExchange.js";
+export * from "./MessageReceptionState.js";
+export * from "./ProtocolHandler.js";
+//# sourceMappingURL=index.js.map

package/dist/esm/protocol/index.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/protocol/index.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;",
+  "names": []
+}

package/dist/esm/securechannel/SecureChannelMessenger.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { MatterError } from "#general";
+import { GeneralStatusCode, ProtocolStatusCode, TlvSchema } from "#types";
+import { Message } from "../codec/MessageCodec.js";
+import { ExchangeSendOptions, MessageExchange } from "../protocol/MessageExchange.js";
+/** Error base Class for all errors related to the status response messages. */
+export declare class ChannelStatusResponseError extends MatterError {
+    readonly generalStatusCode: GeneralStatusCode;
+    readonly protocolStatusCode: ProtocolStatusCode;
+    constructor(message: string, generalStatusCode: GeneralStatusCode, protocolStatusCode: ProtocolStatusCode);
+}
+/** This value is used by chip SDK when performance wise heavy crypto operations are expected. */
+export declare const EXPECTED_CRYPTO_PROCESSING_TIME_MS = 30000;
+/** This value is used by chip SDK when normal processing time is expected. */
+export declare const DEFAULT_NORMAL_PROCESSING_TIME_MS = 2000;
+export declare class SecureChannelMessenger {
+    #private;
+    protected readonly exchange: MessageExchange;
+    constructor(exchange: MessageExchange, defaultExpectedProcessingTimeMs?: number);
+    /**
+     * Waits for the next message and returns it.
+     * When no expectedProcessingTimeMs is provided, the default value of EXPECTED_CRYPTO_PROCESSING_TIME_MS is used.
+     */
+    nextMessage(expectedMessageInfo: string, expectedMessageType?: number, expectedProcessingTimeMs?: number): Promise<Message>;
+    /**
+     * Waits for the next message and decodes it.
+     * When no expectedProcessingTimeMs is provided, the default value of EXPECTED_CRYPTO_PROCESSING_TIME_MS is used.
+     */
+    nextMessageDecoded<T>(expectedMessageType: number, schema: TlvSchema<T>, expectedMessageInfo: string, expectedProcessingTimeMs?: number): Promise<T>;
+    /**
+     * Waits for the next message and returns it.
+     * When no expectedProcessingTimeMs is provided, the default value of EXPECTED_CRYPTO_PROCESSING_TIME_MS is used.
+     */
+    waitForSuccess(expectedMessageInfo: string, expectedProcessingTimeMs?: number): Promise<void>;
+    /**
+     * Sends a message of the given type with the given payload.
+     * If no ExchangeSendOptions are provided, the expectedProcessingTimeMs will be set to
+     * EXPECTED_CRYPTO_PROCESSING_TIME_MS.
+     */
+    send<T>(message: T, type: number, schema: TlvSchema<T>, options?: ExchangeSendOptions): Promise<Uint8Array>;
+    sendError(code: ProtocolStatusCode): Promise<void>;
+    sendSuccess(): Promise<void>;
+    sendCloseSession(): Promise<void>;
+    getChannelName(): string;
+    close(): Promise<void>;
+    private sendStatusReport;
+    protected throwIfErrorStatusReport(message: Message, logHint?: string): void;
+}
+//# sourceMappingURL=SecureChannelMessenger.d.ts.map

package/dist/esm/securechannel/SecureChannelMessenger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SecureChannelMessenger.d.ts","sourceRoot":"","sources":["../../../src/securechannel/SecureChannelMessenger.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAuB,MAAM,UAAU,CAAC;AAC5D,OAAO,EACH,iBAAiB,EACjB,kBAAkB,EAGlB,SAAS,EACZ,MAAM,QAAQ,CAAC;AAChB,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAGtF,+EAA+E;AAC/E,qBAAa,0BAA2B,SAAQ,WAAW;aAGnC,iBAAiB,EAAE,iBAAiB;aACpC,kBAAkB,EAAE,kBAAkB;gBAFtD,OAAO,EAAE,MAAM,EACC,iBAAiB,EAAE,iBAAiB,EACpC,kBAAkB,EAAE,kBAAkB;CAI7D;AAED,iGAAiG;AACjG,eAAO,MAAM,kCAAkC,QAAS,CAAC;AAEzD,8EAA8E;AAC9E,eAAO,MAAM,iCAAiC,OAAQ,CAAC;AAEvD,qBAAa,sBAAsB;;IAI3B,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,eAAe;gBAAzB,QAAQ,EAAE,eAAe,EAC5C,+BAA+B,SAAqC;IAKxE;;;OAGG;IACG,WAAW,CACb,mBAAmB,EAAE,MAAM,EAC3B,mBAAmB,CAAC,EAAE,MAAM,EAC5B,wBAAwB,SAAwC;IAYpE;;;OAGG;IACG,kBAAkB,CAAC,CAAC,EACtB,mBAAmB,EAAE,MAAM,EAC3B,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,EACpB,mBAAmB,EAAE,MAAM,EAC3B,wBAAwB,SAAwC;IAOpE;;;OAGG;IACG,cAAc,CAChB,mBAAmB,EAAE,MAAM,EAC3B,wBAAwB,SAAwC;IAMpE;;;;OAIG;IACG,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,mBAAmB;IAU3F,SAAS,CAAC,IAAI,EAAE,kBAAkB;IAIlC,WAAW;IAIX,gBAAgB;IAIhB,cAAc;IAIR,KAAK;YAIG,gBAAgB;IAgB9B,SAAS,CAAC,wBAAwB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM;CAuBxE"}

package/dist/esm/securechannel/SecureChannelMessenger.js

@@ -0,0 +1,128 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { MatterError, UnexpectedDataError } from "#general";
+import {
+  GeneralStatusCode,
+  ProtocolStatusCode,
+  SECURE_CHANNEL_PROTOCOL_ID,
+  SecureMessageType
+} from "#types";
+import { TlvSecureChannelStatusMessage } from "./SecureChannelStatusMessageSchema.js";
+class ChannelStatusResponseError extends MatterError {
+  constructor(message, generalStatusCode, protocolStatusCode) {
+    super(`(${generalStatusCode}/${protocolStatusCode}) ${message}`);
+    this.generalStatusCode = generalStatusCode;
+    this.protocolStatusCode = protocolStatusCode;
+  }
+}
+const EXPECTED_CRYPTO_PROCESSING_TIME_MS = 3e4;
+const DEFAULT_NORMAL_PROCESSING_TIME_MS = 2e3;
+class SecureChannelMessenger {
+  constructor(exchange, defaultExpectedProcessingTimeMs = EXPECTED_CRYPTO_PROCESSING_TIME_MS) {
+    this.exchange = exchange;
+    this.#defaultExpectedProcessingTimeMs = defaultExpectedProcessingTimeMs;
+  }
+  #defaultExpectedProcessingTimeMs;
+  /**
+   * Waits for the next message and returns it.
+   * When no expectedProcessingTimeMs is provided, the default value of EXPECTED_CRYPTO_PROCESSING_TIME_MS is used.
+   */
+  async nextMessage(expectedMessageInfo, expectedMessageType, expectedProcessingTimeMs = this.#defaultExpectedProcessingTimeMs) {
+    const message = await this.exchange.nextMessage(expectedProcessingTimeMs);
+    const messageType = message.payloadHeader.messageType;
+    this.throwIfErrorStatusReport(message, expectedMessageInfo);
+    if (expectedMessageType !== void 0 && messageType !== expectedMessageType)
+      throw new UnexpectedDataError(
+        `Received unexpected message type: ${messageType}, expected: ${expectedMessageType} (${expectedMessageInfo})`
+      );
+    return message;
+  }
+  /**
+   * Waits for the next message and decodes it.
+   * When no expectedProcessingTimeMs is provided, the default value of EXPECTED_CRYPTO_PROCESSING_TIME_MS is used.
+   */
+  async nextMessageDecoded(expectedMessageType, schema, expectedMessageInfo, expectedProcessingTimeMs = this.#defaultExpectedProcessingTimeMs) {
+    return schema.decode(
+      (await this.nextMessage(expectedMessageInfo, expectedMessageType, expectedProcessingTimeMs)).payload
+    );
+  }
+  /**
+   * Waits for the next message and returns it.
+   * When no expectedProcessingTimeMs is provided, the default value of EXPECTED_CRYPTO_PROCESSING_TIME_MS is used.
+   */
+  async waitForSuccess(expectedMessageInfo, expectedProcessingTimeMs = this.#defaultExpectedProcessingTimeMs) {
+    await this.nextMessage(expectedMessageInfo, SecureMessageType.StatusReport, expectedProcessingTimeMs);
+  }
+  /**
+   * Sends a message of the given type with the given payload.
+   * If no ExchangeSendOptions are provided, the expectedProcessingTimeMs will be set to
+   * EXPECTED_CRYPTO_PROCESSING_TIME_MS.
+   */
+  async send(message, type, schema, options) {
+    options = {
+      ...options,
+      expectedProcessingTimeMs: options?.expectedProcessingTimeMs ?? this.#defaultExpectedProcessingTimeMs
+    };
+    const payload = schema.encode(message);
+    await this.exchange.send(type, payload, options);
+    return payload;
+  }
+  sendError(code) {
+    return this.sendStatusReport(GeneralStatusCode.Failure, code);
+  }
+  sendSuccess() {
+    return this.sendStatusReport(GeneralStatusCode.Success, ProtocolStatusCode.Success);
+  }
+  sendCloseSession() {
+    return this.sendStatusReport(GeneralStatusCode.Success, ProtocolStatusCode.CloseSession, false);
+  }
+  getChannelName() {
+    return this.exchange.channel.channel.name;
+  }
+  async close() {
+    await this.exchange.close();
+  }
+  async sendStatusReport(generalStatus, protocolStatus, requiresAck) {
+    await this.exchange.send(
+      SecureMessageType.StatusReport,
+      TlvSecureChannelStatusMessage.encode({
+        generalStatus,
+        protocolId: SECURE_CHANNEL_PROTOCOL_ID,
+        protocolStatus
+      }),
+      { requiresAck }
+    );
+  }
+  throwIfErrorStatusReport(message, logHint) {
+    const {
+      payloadHeader: { messageType },
+      payload
+    } = message;
+    if (messageType !== SecureMessageType.StatusReport) return;
+    const { generalStatus, protocolId, protocolStatus } = TlvSecureChannelStatusMessage.decode(payload);
+    if (generalStatus !== GeneralStatusCode.Success) {
+      throw new ChannelStatusResponseError(
+        `Received general error status for protocol ${protocolId}${logHint ? ` (${logHint})` : ""}`,
+        generalStatus,
+        protocolStatus
+      );
+    }
+    if (protocolStatus !== ProtocolStatusCode.Success) {
+      throw new ChannelStatusResponseError(
+        `Received general success status, but protocol status is not Success${logHint ? ` (${logHint})` : ""}`,
+        generalStatus,
+        protocolStatus
+      );
+    }
+  }
+}
+export {
+  ChannelStatusResponseError,
+  DEFAULT_NORMAL_PROCESSING_TIME_MS,
+  EXPECTED_CRYPTO_PROCESSING_TIME_MS,
+  SecureChannelMessenger
+};
+//# sourceMappingURL=SecureChannelMessenger.js.map

package/dist/esm/securechannel/SecureChannelMessenger.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/securechannel/SecureChannelMessenger.ts"],
+  "mappings": "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",
+  "names": []
+}

package/dist/esm/securechannel/SecureChannelProtocol.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FabricManager } from "#fabric/FabricManager.js";
+import { AsyncObservable } from "#general";
+import { SessionManager } from "#session/SessionManager.js";
+import { Message } from "../codec/MessageCodec.js";
+import { MessageExchange } from "../protocol/MessageExchange.js";
+import { ProtocolHandler } from "../protocol/ProtocolHandler.js";
+import { PaseServer } from "../session/pase/PaseServer.js";
+export declare class StatusReportOnlySecureChannelProtocol implements ProtocolHandler {
+    getId(): number;
+    onNewExchange(exchange: MessageExchange, message: Message): Promise<void>;
+    handleInitialStatusReport(exchange: MessageExchange, message: Message): Promise<void>;
+    close(): Promise<void>;
+}
+export declare class SecureChannelProtocol extends StatusReportOnlySecureChannelProtocol {
+    #private;
+    constructor(sessions: SessionManager, fabrics: FabricManager);
+    /**
+     * Emitted when the active PASE session hits the maximum error threshold.
+     */
+    get tooManyPaseErrors(): AsyncObservable<[], void>;
+    setPaseCommissioner(paseServer: PaseServer): void;
+    removePaseCommissioner(): void;
+    onNewExchange(exchange: MessageExchange, message: Message): Promise<void>;
+    static isStandaloneAck(protocolId: number, messageType: number): boolean;
+}
+//# sourceMappingURL=SecureChannelProtocol.d.ts.map

package/dist/esm/securechannel/SecureChannelProtocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SecureChannelProtocol.d.ts","sourceRoot":"","sources":["../../../src/securechannel/SecureChannelProtocol.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,EAAE,eAAe,EAA2B,MAAM,UAAU,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAS5D,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAGjE,OAAO,EAAwC,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAMjG,qBAAa,qCAAsC,YAAW,eAAe;IACzE,KAAK,IAAI,MAAM;IAIT,aAAa,CAAC,QAAQ,EAAE,eAAe,EAAE,OAAO,EAAE,OAAO;IAkBzD,yBAAyB,CAAC,QAAQ,EAAE,eAAe,EAAE,OAAO,EAAE,OAAO;IAoCrE,KAAK;CAGd;AAED,qBAAa,qBAAsB,SAAQ,qCAAqC;;gBAKhE,QAAQ,EAAE,cAAc,EAAE,OAAO,EAAE,aAAa;IAK5D;;OAEG;IACH,IAAI,iBAAiB,8BAEpB;IAED,mBAAmB,CAAC,UAAU,EAAE,UAAU;IAI1C,sBAAsB;IAIP,aAAa,CAAC,QAAQ,EAAE,eAAe,EAAE,OAAO,EAAE,OAAO;IA6BxE,MAAM,CAAC,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;CAGjE"}

package/dist/esm/securechannel/SecureChannelProtocol.js

@@ -0,0 +1,127 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AsyncObservable, Logger, MatterFlowError } from "#general";
+import {
+  GeneralStatusCode,
+  ProtocolStatusCode,
+  SECURE_CHANNEL_PROTOCOL_ID,
+  SecureMessageType,
+  StatusCode,
+  StatusResponseError
+} from "#types";
+import { assertSecureSession } from "../session/SecureSession.js";
+import { CaseServer } from "../session/case/CaseServer.js";
+import { MaximumPasePairingErrorsReachedError } from "../session/pase/PaseServer.js";
+import { ChannelStatusResponseError, SecureChannelMessenger } from "./SecureChannelMessenger.js";
+import { TlvSecureChannelStatusMessage } from "./SecureChannelStatusMessageSchema.js";
+const logger = Logger.get("SecureChannelProtocol");
+class StatusReportOnlySecureChannelProtocol {
+  getId() {
+    return SECURE_CHANNEL_PROTOCOL_ID;
+  }
+  async onNewExchange(exchange, message) {
+    const messageType = message.payloadHeader.messageType;
+    switch (messageType) {
+      case SecureMessageType.StatusReport:
+        await this.handleInitialStatusReport(exchange, message);
+        break;
+      default:
+        if (messageType !== SecureMessageType.StandaloneAck) {
+          throw new StatusResponseError(
+            `Unexpected initial message on secure channel protocol: ${messageType.toString(16)}`,
+            StatusCode.InvalidAction
+          );
+        }
+    }
+  }
+  async handleInitialStatusReport(exchange, message) {
+    const {
+      payloadHeader: { messageType },
+      payload
+    } = message;
+    if (messageType !== SecureMessageType.StatusReport) {
+      throw new MatterFlowError(
+        `Unexpected message type on secure channel protocol, expected StatusReport: ${messageType.toString(
+          16
+        )}`
+      );
+    }
+    const { generalStatus, protocolId, protocolStatus } = TlvSecureChannelStatusMessage.decode(payload);
+    if (generalStatus !== GeneralStatusCode.Success) {
+      throw new ChannelStatusResponseError(
+        `Received general error status (${protocolId})`,
+        generalStatus,
+        protocolStatus
+      );
+    }
+    if (protocolStatus !== ProtocolStatusCode.CloseSession) {
+      throw new ChannelStatusResponseError(
+        `Received general success status, but protocol status is not CloseSession`,
+        generalStatus,
+        protocolStatus
+      );
+    }
+    const { session } = exchange;
+    assertSecureSession(session);
+    logger.debug(`Peer requested to close session ${session.name}. Remove session now.`);
+    await session.destroy(false, false);
+  }
+  async close() {
+  }
+}
+class SecureChannelProtocol extends StatusReportOnlySecureChannelProtocol {
+  #paseCommissioner;
+  #caseCommissioner;
+  #tooManyPaseErrors = AsyncObservable();
+  constructor(sessions, fabrics) {
+    super();
+    this.#caseCommissioner = new CaseServer(sessions, fabrics);
+  }
+  /**
+   * Emitted when the active PASE session hits the maximum error threshold.
+   */
+  get tooManyPaseErrors() {
+    return this.#tooManyPaseErrors;
+  }
+  setPaseCommissioner(paseServer) {
+    this.#paseCommissioner = paseServer;
+  }
+  removePaseCommissioner() {
+    this.#paseCommissioner = void 0;
+  }
+  async onNewExchange(exchange, message) {
+    const messageType = message.payloadHeader.messageType;
+    switch (messageType) {
+      case SecureMessageType.PbkdfParamRequest:
+        if (this.#paseCommissioner === void 0) {
+          const messenger = new SecureChannelMessenger(exchange);
+          await messenger.sendError(ProtocolStatusCode.InvalidParam);
+          await messenger.close();
+          return;
+        }
+        try {
+          await this.#paseCommissioner.onNewExchange(exchange);
+        } catch (error) {
+          MaximumPasePairingErrorsReachedError.accept(error);
+          await this.#tooManyPaseErrors.emit();
+        }
+        break;
+      case SecureMessageType.Sigma1:
+        await this.#caseCommissioner.onNewExchange(exchange);
+        break;
+      default:
+        await super.onNewExchange(exchange, message);
+    }
+  }
+  static isStandaloneAck(protocolId, messageType) {
+    return protocolId === SECURE_CHANNEL_PROTOCOL_ID && messageType === SecureMessageType.StandaloneAck;
+  }
+}
+export {
+  SecureChannelProtocol,
+  StatusReportOnlySecureChannelProtocol
+};
+//# sourceMappingURL=SecureChannelProtocol.js.map

package/dist/esm/securechannel/SecureChannelProtocol.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/securechannel/SecureChannelProtocol.ts"],
+  "mappings": "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",
+  "names": []
+}

package/dist/esm/securechannel/SecureChannelStatusMessageSchema.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { GeneralStatusCode, ProtocolStatusCode, Schema } from "#types";
+export type StatusMessage = {
+    generalStatus: GeneralStatusCode;
+    protocolId: number;
+    protocolStatus: ProtocolStatusCode;
+    protocolData?: Uint8Array;
+};
+export declare class SecureChannelStatusMessageSchema extends Schema<StatusMessage, Uint8Array> {
+    encodeInternal({ generalStatus, protocolId, protocolStatus, protocolData }: StatusMessage): Uint8Array;
+    decodeInternal(bytes: Uint8Array): {
+        generalStatus: number;
+        protocolId: number;
+        protocolStatus: number;
+        remainingBytes: Uint8Array | undefined;
+    };
+}
+export declare const TlvSecureChannelStatusMessage: SecureChannelStatusMessageSchema;
+//# sourceMappingURL=SecureChannelStatusMessageSchema.d.ts.map

package/dist/esm/securechannel/SecureChannelStatusMessageSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SecureChannelStatusMessageSchema.d.ts","sourceRoot":"","sources":["../../../src/securechannel/SecureChannelStatusMessageSchema.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEvE,MAAM,MAAM,aAAa,GAAG;IACxB,aAAa,EAAE,iBAAiB,CAAC;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,kBAAkB,CAAC;IACnC,YAAY,CAAC,EAAE,UAAU,CAAC;CAC7B,CAAC;AAEF,qBAAa,gCAAiC,SAAQ,MAAM,CAAC,aAAa,EAAE,UAAU,CAAC;IACnF,cAAc,CAAC,EAAE,aAAa,EAAE,UAAU,EAAE,cAAc,EAAE,YAAY,EAAE,EAAE,aAAa;IAWzF,cAAc,CAAC,KAAK,EAAE,UAAU;;;;;;CASnC;AAED,eAAO,MAAM,6BAA6B,kCAAyC,CAAC"}