@matter/protocol 0.17.2 → 0.17.3-alpha.0-20260617-ea3690abc

package/src/protocol/ExchangeProvider.ts

@@ -32,6 +32,12 @@ export interface NewExchangeOptions extends Omit<InteractionSettings, "transacti
      */
     network?: string;
 
+    /**
+     * Per-call override for the peer-medium MRP retransmission margin.  When omitted the margin derives from the
+     * peer's network medium, independent of any {@link network} throttle override.
+     */
+    additionalMrpDelay?: Duration;
+
     /**
      * Optional address override for the exchange.  When set, messages are sent to this address
      * instead of the session's default peer address.
@@ -100,8 +106,12 @@ export class DedicatedChannelExchangeProvider extends ExchangeProvider {
         return this.#session.parameters.maxPathsPerInvoke;
     }
 
-    async initiateExchange(): Promise<MessageExchange> {
-        return this.exchangeManager.initiateExchangeForSession(this.#session, INTERACTION_PROTOCOL_ID);
+    async initiateExchange(options?: NewExchangeOptions): Promise<MessageExchange> {
+        // This provider has no peer/medium context, so the medium-derived margin is unavailable; only an explicit
+        // per-call override can apply here.
+        return this.exchangeManager.initiateExchangeForSession(this.#session, INTERACTION_PROTOCOL_ID, {
+            peerAdditionalMrpDelay: options?.additionalMrpDelay,
+        });
     }
 
     get channelType() {

package/src/protocol/MRP.ts

@@ -20,7 +20,7 @@ export namespace MRP {
     /** The scaler for random jitter in the backoff equation. */
     export const BACKOFF_JITTER = 0.25;
 
-    /** The scaler margin increase to backoff over the peer sleepy interval. */
+    /** The scaler margin increase to backoff over the applicable (active/idle) interval. */
     export const BACKOFF_MARGIN = 1.1;
 
     /** The number of retransmissions before transitioning from linear to exponential backoff. */
@@ -128,11 +128,10 @@ export namespace MRP {
     ) {
         const { activeInterval, idleInterval } = sessionParameters;
 
-        // The first message of an exchange SHALL use the idle interval; subsequent ones SHOULD use the active
-        // interval "unless the sender has other means to determine whether the device is active or idle" —
-        // isPeerActive is that means, so honor it per retransmission like CHIP does (ICD correctness)
-        const peerActive = transmissionNumber > 0 && isPeerActive;
-        let baseInterval = peerActive ? activeInterval : idleInterval;
+        // Every transmission (including the initial one) selects its interval by PeerActiveMode, re-evaluated
+        // per (re)transmission, matching CHIP GetMRPBaseTimeout(). isPeerActive already yields idle for a
+        // genuinely quiet peer, so no position-based first-message rule is needed.
+        let baseInterval = isPeerActive ? activeInterval : idleInterval;
         if (!calculateMaximum) {
             baseInterval += additionalDelay;
         }

package/src/protocol/MessageExchange.ts

@@ -199,7 +199,7 @@ export class MessageExchange {
     readonly #onSend?: MessageExchange.SendNotifier;
     readonly #onReceive?: MessageExchange.ReceiveNotifier;
     readonly #addressOverride?: ServerAddressUdp;
-    readonly #network?: NetworkProfile;
+    readonly #peerAdditionalMrpDelay?: Duration;
     #receivedMessageToAck: Message | undefined;
     #receivedMessageAckTimer = Time.getTimer("ack receipt timeout", MRP.STANDALONE_ACK_TIMEOUT, () => {
         if (this.#receivedMessageToAck !== undefined) {
@@ -251,6 +251,7 @@ export class MessageExchange {
             onSend,
             onReceive,
             network,
+            peerAdditionalMrpDelay,
             addressOverride,
         } = config;
 
@@ -264,7 +265,7 @@ export class MessageExchange {
         this.#onSend = onSend;
         this.#onReceive = onReceive;
         this.#addressOverride = addressOverride;
-        this.#network = network;
+        this.#peerAdditionalMrpDelay = peerAdditionalMrpDelay;
 
         const { activeThreshold, activeInterval, idleInterval } = this.session.parameters;
 
@@ -991,12 +992,22 @@ export class MessageExchange {
     }
 
     get #mrpResubmissionBackOffTime() {
+        return this.#backOffFor(this.#retransmissionCounter);
+    }
+
+    /**
+     * Scheduled MRP backoff for a given (re)transmission number, after the send-option overrides.
+     *
+     * The cap never drops below the peer's idle interval: a peer whose idle base backoff already exceeds
+     * maxRetransmissionTime must not be retried faster than its own idle cadence.
+     */
+    #backOffFor(retransmissionCount: number) {
         const additionalDelay = Duration.max(
             this.#context.localAdditionalMrpDelay,
-            this.#network?.additionalMrpDelay ?? Millis(0),
+            this.#peerAdditionalMrpDelay ?? Millis(0),
         );
         let backOff = this.channel.getMrpResubmissionBackOffTime(
-            this.#retransmissionCounter,
+            retransmissionCount,
             undefined,
             false,
             additionalDelay,
@@ -1004,7 +1015,26 @@ export class MessageExchange {
         if (this.#sendOptions.initialRetransmissionTime !== undefined) {
             backOff = Millis(backOff + this.#sendOptions.initialRetransmissionTime);
         }
-        return Duration.min(backOff, this.#sendOptions.maxRetransmissionTime ?? Forever);
+        const cap = Duration.max(
+            this.#sendOptions.maxRetransmissionTime ?? Forever,
+            this.session.parameters.idleInterval ?? Instant,
+        );
+        return Duration.min(backOff, cap);
+    }
+
+    /**
+     * How much restarting the exchange (resetting the retransmission counter to 0) would shorten the wait until
+     * the next (re)transmission.  Roughly zero near the base interval — e.g. an idle peer, whose fresh interval is
+     * just as slow.
+     */
+    get retransmissionRestartSaving(): Duration {
+        // No pending retransmit → nothing for a restart to shorten → report no saving so the kick is suppressed.
+        const currentWait = this.#retransmissionTimer?.interval;
+        if (currentWait === undefined) {
+            return Instant;
+        }
+        // Read the live timer's real interval (margins/jitter/cap baked in), not a freshly recomputed random one.
+        return Duration.max(Instant, Millis(currentWait - this.#backOffFor(0)));
     }
 }
 
@@ -1021,10 +1051,18 @@ export namespace MessageExchange {
         onReceive?: ReceiveNotifier;
 
         /**
-         * Network Profile used
+         * Network profile governing exchange throttling.  Retained for diagnostics; MRP backoff derives from
+         * {@link peerAdditionalMrpDelay} instead, so an explicit throttle override (e.g. "unlimited") does not
+         * affect retransmission timing.
          */
         network?: NetworkProfile;
 
+        /**
+         * Additive MRP retransmission margin for the peer's network medium.  Sourced independently of
+         * {@link network} so concurrency overrides cannot strip the medium-correct margin (e.g. thread's).
+         */
+        peerAdditionalMrpDelay?: Duration;
+
         /**
          * Optional address override for this exchange.  When set, messages are sent to this address
          * instead of the session's default peer address.

package/src/session/pase/PaseClient.ts

@@ -21,7 +21,7 @@ import {
     Spake2p,
     UnexpectedDataError,
 } from "@matter/general";
-import { CommissioningOptions, NodeId, SecureChannelStatusCode } from "@matter/types";
+import { isValidPasscode, NodeId, SecureChannelStatusCode } from "@matter/types";
 import { TransientPeerCommunicationError } from "../../peer/PeerCommunicationError.js";
 import { MessageExchange } from "../../protocol/MessageExchange.js";
 import { RetransmissionLimitReachedError } from "../../protocol/errors.js";
@@ -47,11 +47,7 @@ export class PaseClient {
         // Generate 27-bit random candidates and reject invalid values to avoid modulo bias.
         for (let i = 0; i < MAX_PASSCODE_GENERATION_ATTEMPTS; i++) {
             const passcode = crypto.randomUint32 & 0x07ff_ffff;
-            if (
-                passcode >= 1 &&
-                passcode <= 99_999_998 &&
-                !CommissioningOptions.FORBIDDEN_PASSCODES.includes(passcode)
-            ) {
+            if (isValidPasscode(passcode)) {
                 return passcode;
             }
         }

package/src/session/pase/PaseServer.ts

@@ -7,6 +7,7 @@
 import { Mark } from "#common/Mark.js";
 import { SessionManager } from "#session/SessionManager.js";
 import {
+    asError,
     Bytes,
     causedBy,
     Channel,
@@ -124,7 +125,9 @@ export class PaseServer implements ProtocolHandler {
         logger.info("Received pairing request", Mark.INBOUND, Diagnostic.via(messenger.channelName));
 
         this.#pairingTimer = Time.getTimer("PASE pairing timeout", PASE_PAIRING_TIMEOUT, () =>
-            this.cancelPairing(messenger),
+            this.cancelPairing(messenger).catch(error =>
+                logger.warn("Error cancelling PASE pairing after timeout:", Diagnostic.errorMessage(asError(error))),
+            ),
         ).start();
 
         // Read pbkdfRequest and send pbkdfResponse
@@ -203,7 +206,14 @@ export class PaseServer implements ProtocolHandler {
 
     async cancelPairing(messenger: PaseServerMessenger, sendError = true) {
         if (sendError) {
-            await messenger.sendError(SecureChannelStatusCode.InvalidParam);
+            try {
+                await messenger.sendError(SecureChannelStatusCode.InvalidParam);
+            } catch (error) {
+                logger.info(
+                    "Could not send pairing-cancellation status report to peer:",
+                    Diagnostic.errorMessage(asError(error)),
+                );
+            }
         }
         await messenger.close();
     }