@matter/thread-br-client 0.0.1

package/dist/esm/dtls/handshake/HandshakeMessage.js

@@ -0,0 +1,97 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { InternalError } from "@matter/general";
+import { DtlsError } from "../channel/DtlsChannel.js";
+import { isHandshakeType } from "./HandshakeType.js";
+const DTLS_HANDSHAKE_HEADER_LEN = 12;
+const TLS_HANDSHAKE_HEADER_LEN = 4;
+const UINT24_MAX = (1 << 24) - 1;
+const UINT16_MAX = 65535;
+function writeUint16BE(buf, offset, value) {
+  buf[offset] = value >>> 8 & 255;
+  buf[offset + 1] = value & 255;
+}
+function writeUint24BE(buf, offset, value) {
+  buf[offset] = value >>> 16 & 255;
+  buf[offset + 1] = value >>> 8 & 255;
+  buf[offset + 2] = value & 255;
+}
+function readUint16BE(buf, offset) {
+  return buf[offset] << 8 | buf[offset + 1];
+}
+function readUint24BE(buf, offset) {
+  return buf[offset] << 16 | buf[offset + 1] << 8 | buf[offset + 2];
+}
+var HandshakeMessage;
+((HandshakeMessage2) => {
+  function encode(message) {
+    const { msgType, messageSeq, body } = message;
+    if (!isHandshakeType(msgType)) {
+      throw new InternalError(`HandshakeMessage unknown msg_type: ${msgType}`);
+    }
+    if (messageSeq < 0 || messageSeq > UINT16_MAX) {
+      throw new InternalError(`HandshakeMessage message_seq ${messageSeq} out of range`);
+    }
+    if (body.length > UINT24_MAX) {
+      throw new InternalError(`HandshakeMessage body length ${body.length} exceeds 24-bit max`);
+    }
+    const out = new Uint8Array(DTLS_HANDSHAKE_HEADER_LEN + body.length);
+    out[0] = msgType;
+    writeUint24BE(out, 1, body.length);
+    writeUint16BE(out, 4, messageSeq);
+    writeUint24BE(out, 6, 0);
+    writeUint24BE(out, 9, body.length);
+    out.set(body, DTLS_HANDSHAKE_HEADER_LEN);
+    return out;
+  }
+  HandshakeMessage2.encode = encode;
+  function encodeForTranscript(message) {
+    return encode(message);
+  }
+  HandshakeMessage2.encodeForTranscript = encodeForTranscript;
+  function decode(bytes) {
+    if (bytes.length < DTLS_HANDSHAKE_HEADER_LEN) {
+      throw new DtlsError(
+        `HandshakeMessage header truncated: have ${bytes.length}, need ${DTLS_HANDSHAKE_HEADER_LEN}`
+      );
+    }
+    const msgType = bytes[0];
+    if (!isHandshakeType(msgType)) {
+      throw new DtlsError(`HandshakeMessage unknown msg_type: ${msgType}`);
+    }
+    const length = readUint24BE(bytes, 1);
+    const messageSeq = readUint16BE(bytes, 4);
+    const fragmentOffset = readUint24BE(bytes, 6);
+    const fragmentLength = readUint24BE(bytes, 9);
+    if (fragmentOffset !== 0 || fragmentLength !== length) {
+      throw new DtlsError(
+        `HandshakeMessage fragmented input not supported: offset=${fragmentOffset} fragLen=${fragmentLength} totalLen=${length}`
+      );
+    }
+    const total = DTLS_HANDSHAKE_HEADER_LEN + length;
+    if (bytes.length < total) {
+      throw new DtlsError(
+        `HandshakeMessage body truncated: header says ${length}, have ${bytes.length - DTLS_HANDSHAKE_HEADER_LEN}`
+      );
+    }
+    return {
+      message: {
+        msgType,
+        messageSeq,
+        body: bytes.slice(DTLS_HANDSHAKE_HEADER_LEN, total)
+      },
+      consumed: total
+    };
+  }
+  HandshakeMessage2.decode = decode;
+})(HandshakeMessage || (HandshakeMessage = {}));
+export {
+  DTLS_HANDSHAKE_HEADER_LEN,
+  HandshakeMessage,
+  TLS_HANDSHAKE_HEADER_LEN,
+  UINT24_MAX
+};
+//# sourceMappingURL=HandshakeMessage.js.map

package/dist/esm/dtls/handshake/HandshakeMessage.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/dtls/handshake/HandshakeMessage.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAS,qBAAqB;AAC9B,SAAS,iBAAiB;AAC1B,SAAwB,uBAAuB;AAGxC,MAAM,4BAA4B;AAGlC,MAAM,2BAA2B;AAGjC,MAAM,cAAc,KAAK,MAAM;AAGtC,MAAM,aAAa;AAmBnB,SAAS,cAAc,KAAiB,QAAgB,OAAqB;AACzE,MAAI,MAAM,IAAK,UAAU,IAAK;AAC9B,MAAI,SAAS,CAAC,IAAI,QAAQ;AAC9B;AAEA,SAAS,cAAc,KAAiB,QAAgB,OAAqB;AACzE,MAAI,MAAM,IAAK,UAAU,KAAM;AAC/B,MAAI,SAAS,CAAC,IAAK,UAAU,IAAK;AAClC,MAAI,SAAS,CAAC,IAAI,QAAQ;AAC9B;AAEA,SAAS,aAAa,KAAiB,QAAwB;AAC3D,SAAQ,IAAI,MAAM,KAAK,IAAK,IAAI,SAAS,CAAC;AAC9C;AAEA,SAAS,aAAa,KAAiB,QAAwB;AAC3D,SAAQ,IAAI,MAAM,KAAK,KAAO,IAAI,SAAS,CAAC,KAAK,IAAK,IAAI,SAAS,CAAC;AACxE;AAsBO,IAAU;AAAA,CAAV,CAAUA,sBAAV;AACI,WAAS,OAAO,SAAuC;AAC1D,UAAM,EAAE,SAAS,YAAY,KAAK,IAAI;AACtC,QAAI,CAAC,gBAAgB,OAAO,GAAG;AAC3B,YAAM,IAAI,cAAc,sCAAsC,OAAO,EAAE;AAAA,IAC3E;AACA,QAAI,aAAa,KAAK,aAAa,YAAY;AAC3C,YAAM,IAAI,cAAc,gCAAgC,UAAU,eAAe;AAAA,IACrF;AACA,QAAI,KAAK,SAAS,YAAY;AAC1B,YAAM,IAAI,cAAc,gCAAgC,KAAK,MAAM,qBAAqB;AAAA,IAC5F;AACA,UAAM,MAAM,IAAI,WAAW,4BAA4B,KAAK,MAAM;AAClE,QAAI,CAAC,IAAI;AACT,kBAAc,KAAK,GAAG,KAAK,MAAM;AACjC,kBAAc,KAAK,GAAG,UAAU;AAChC,kBAAc,KAAK,GAAG,CAAC;AACvB,kBAAc,KAAK,GAAG,KAAK,MAAM;AACjC,QAAI,IAAI,MAAM,yBAAyB;AACvC,WAAO;AAAA,EACX;AAnBO,EAAAA,kBAAS;AAqBT,WAAS,oBAAoB,SAAuC;AACvE,WAAO,OAAO,OAAO;AAAA,EACzB;AAFO,EAAAA,kBAAS;AAST,WAAS,OAAO,OAAiC;AACpD,QAAI,MAAM,SAAS,2BAA2B;AAC1C,YAAM,IAAI;AAAA,QACN,2CAA2C,MAAM,MAAM,UAAU,yBAAyB;AAAA,MAC9F;AAAA,IACJ;AACA,UAAM,UAAU,MAAM,CAAC;AACvB,QAAI,CAAC,gBAAgB,OAAO,GAAG;AAC3B,YAAM,IAAI,UAAU,sCAAsC,OAAO,EAAE;AAAA,IACvE;AACA,UAAM,SAAS,aAAa,OAAO,CAAC;AACpC,UAAM,aAAa,aAAa,OAAO,CAAC;AACxC,UAAM,iBAAiB,aAAa,OAAO,CAAC;AAC5C,UAAM,iBAAiB,aAAa,OAAO,CAAC;AAC5C,QAAI,mBAAmB,KAAK,mBAAmB,QAAQ;AACnD,YAAM,IAAI;AAAA,QACN,2DAA2D,cAAc,YAAY,cAAc,aAAa,MAAM;AAAA,MAC1H;AAAA,IACJ;AACA,UAAM,QAAQ,4BAA4B;AAC1C,QAAI,MAAM,SAAS,OAAO;AACtB,YAAM,IAAI;AAAA,QACN,gDAAgD,MAAM,UAAU,MAAM,SAAS,yBAAyB;AAAA,MAC5G;AAAA,IACJ;AACA,WAAO;AAAA,MACH,SAAS;AAAA,QACL;AAAA,QACA;AAAA,QACA,MAAM,MAAM,MAAM,2BAA2B,KAAK;AAAA,MACtD;AAAA,MACA,UAAU;AAAA,IACd;AAAA,EACJ;AAjCO,EAAAA,kBAAS;AAAA,GA/BH;",
+  "names": ["HandshakeMessage"]
+}

package/dist/esm/dtls/handshake/HandshakeType.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * TLS 1.2 / DTLS 1.2 HandshakeType values used by the EC-JPAKE flight diagram
+ * (RFC 5246 §7.4, RFC 6347 §4.2). Only the subset needed for
+ * `TLS_ECJPAKE_WITH_AES_128_CCM_8` is declared; any other byte triggers a
+ * decode error in {@link HandshakeMessage.decode}.
+ *
+ * `HELLO_REQUEST` is included for completeness — we do not send it (we are
+ * always the client) but mbedTLS will silently ignore it from the server side
+ * and we want a known constant if a peer ever sends one.
+ */
+export declare const HandshakeType: {
+    readonly HELLO_REQUEST: 0;
+    readonly CLIENT_HELLO: 1;
+    readonly SERVER_HELLO: 2;
+    readonly HELLO_VERIFY_REQUEST: 3;
+    readonly CERTIFICATE: 11;
+    readonly SERVER_KEY_EXCHANGE: 12;
+    readonly SERVER_HELLO_DONE: 14;
+    readonly CLIENT_KEY_EXCHANGE: 16;
+    readonly FINISHED: 20;
+};
+export type HandshakeType = (typeof HandshakeType)[keyof typeof HandshakeType];
+export declare function isHandshakeType(value: number): value is HandshakeType;
+//# sourceMappingURL=HandshakeType.d.ts.map

package/dist/esm/dtls/handshake/HandshakeType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HandshakeType.d.ts","sourceRoot":"","sources":["../../../../src/dtls/handshake/HandshakeType.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa;aACtB,aAAa,EAAE,CAAC;aAChB,YAAY,EAAE,CAAC;aACf,YAAY,EAAE,CAAC;aACf,oBAAoB,EAAE,CAAC;aACvB,WAAW,EAAE,EAAE;aACf,mBAAmB,EAAE,EAAE;aACvB,iBAAiB,EAAE,EAAE;aACrB,mBAAmB,EAAE,EAAE;aACvB,QAAQ,EAAE,EAAE;CACN,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC;AAI/E,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,aAAa,CAErE"}

package/dist/esm/dtls/handshake/HandshakeType.js

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const HandshakeType = {
+  HELLO_REQUEST: 0,
+  CLIENT_HELLO: 1,
+  SERVER_HELLO: 2,
+  HELLO_VERIFY_REQUEST: 3,
+  CERTIFICATE: 11,
+  SERVER_KEY_EXCHANGE: 12,
+  SERVER_HELLO_DONE: 14,
+  CLIENT_KEY_EXCHANGE: 16,
+  FINISHED: 20
+};
+const VALID_TYPES = /* @__PURE__ */ new Set([0, 1, 2, 3, 11, 12, 14, 16, 20]);
+function isHandshakeType(value) {
+  return VALID_TYPES.has(value);
+}
+export {
+  HandshakeType,
+  isHandshakeType
+};
+//# sourceMappingURL=HandshakeType.js.map

package/dist/esm/dtls/handshake/HandshakeType.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/dtls/handshake/HandshakeType.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAgBO,MAAM,gBAAgB;AAAA,EACzB,eAAe;AAAA,EACf,cAAc;AAAA,EACd,cAAc;AAAA,EACd,sBAAsB;AAAA,EACtB,aAAa;AAAA,EACb,qBAAqB;AAAA,EACrB,mBAAmB;AAAA,EACnB,qBAAqB;AAAA,EACrB,UAAU;AACd;AAIA,MAAM,cAAc,oBAAI,IAAY,CAAC,GAAG,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI,EAAE,CAAC;AAE7D,SAAS,gBAAgB,OAAuC;AACnE,SAAO,YAAY,IAAI,KAAK;AAChC;",
+  "names": []
+}

package/dist/esm/dtls/handshake/HelloVerifyRequestMessage.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare const HelloVerifyRequestMessage: {
+    parse(body: Uint8Array): {
+        cookie: Uint8Array;
+    };
+};
+//# sourceMappingURL=HelloVerifyRequestMessage.d.ts.map

package/dist/esm/dtls/handshake/HelloVerifyRequestMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HelloVerifyRequestMessage.d.ts","sourceRoot":"","sources":["../../../../src/dtls/handshake/HelloVerifyRequestMessage.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAuBH,eAAO,MAAM,yBAAyB;IAClC,KAAK,OAAO,UAAU,GAAG;QAAE,MAAM,EAAE,UAAU,CAAA;KAAE;CAkBzC,CAAC"}

package/dist/esm/dtls/handshake/HelloVerifyRequestMessage.js

@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { DtlsError } from "../channel/DtlsChannel.js";
+const MAX_COOKIE_LEN = 255;
+const HelloVerifyRequestMessage = {
+  parse(body) {
+    if (body.length < 2 + 1) {
+      throw new DtlsError(`HelloVerifyRequest body truncated: have ${body.length}, need >= 3`);
+    }
+    const cookieLen = body[2];
+    if (cookieLen > MAX_COOKIE_LEN) {
+      throw new DtlsError(`HelloVerifyRequest cookie length ${cookieLen} exceeds ${MAX_COOKIE_LEN}`);
+    }
+    const expectedLen = 2 + 1 + cookieLen;
+    if (body.length !== expectedLen) {
+      throw new DtlsError(
+        `HelloVerifyRequest body length ${body.length} disagrees with cookie length ${cookieLen} (expected ${expectedLen})`
+      );
+    }
+    return { cookie: body.slice(3, 3 + cookieLen) };
+  }
+};
+export {
+  HelloVerifyRequestMessage
+};
+//# sourceMappingURL=HelloVerifyRequestMessage.js.map

package/dist/esm/dtls/handshake/HelloVerifyRequestMessage.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/dtls/handshake/HelloVerifyRequestMessage.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAuBA,SAAS,iBAAiB;AAE1B,MAAM,iBAAiB;AAEhB,MAAM,4BAA4B;AAAA,EACrC,MAAM,MAA0C;AAC5C,QAAI,KAAK,SAAS,IAAI,GAAG;AACrB,YAAM,IAAI,UAAU,2CAA2C,KAAK,MAAM,aAAa;AAAA,IAC3F;AAEA,UAAM,YAAY,KAAK,CAAC;AACxB,QAAI,YAAY,gBAAgB;AAC5B,YAAM,IAAI,UAAU,oCAAoC,SAAS,YAAY,cAAc,EAAE;AAAA,IACjG;AACA,UAAM,cAAc,IAAI,IAAI;AAC5B,QAAI,KAAK,WAAW,aAAa;AAC7B,YAAM,IAAI;AAAA,QACN,kCAAkC,KAAK,MAAM,iCAAiC,SAAS,cAAc,WAAW;AAAA,MACpH;AAAA,IACJ;AAEA,WAAO,EAAE,QAAQ,KAAK,MAAM,GAAG,IAAI,SAAS,EAAE;AAAA,EAClD;AACJ;",
+  "names": []
+}

package/dist/esm/dtls/handshake/ServerHelloDoneMessage.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * ServerHelloDone body parser (RFC 5246 §7.4.5). The body is empty; this
+ * exists only so the state machine has a uniform per-message entry point and
+ * a single place to fail loudly if a future BR ever sends payload bytes here.
+ */
+export declare const ServerHelloDoneMessage: {
+    parse(body: Uint8Array): void;
+};
+//# sourceMappingURL=ServerHelloDoneMessage.d.ts.map

package/dist/esm/dtls/handshake/ServerHelloDoneMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServerHelloDoneMessage.d.ts","sourceRoot":"","sources":["../../../../src/dtls/handshake/ServerHelloDoneMessage.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH;;;;GAIG;AACH,eAAO,MAAM,sBAAsB;IAC/B,KAAK,OAAO,UAAU,GAAG,IAAI;CAKvB,CAAC"}

package/dist/esm/dtls/handshake/ServerHelloDoneMessage.js

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { DtlsError } from "../channel/DtlsChannel.js";
+const ServerHelloDoneMessage = {
+  parse(body) {
+    if (body.length !== 0) {
+      throw new DtlsError(`ServerHelloDone body must be empty, got ${body.length} bytes`);
+    }
+  }
+};
+export {
+  ServerHelloDoneMessage
+};
+//# sourceMappingURL=ServerHelloDoneMessage.js.map

package/dist/esm/dtls/handshake/ServerHelloDoneMessage.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/dtls/handshake/ServerHelloDoneMessage.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAS,iBAAiB;AAOnB,MAAM,yBAAyB;AAAA,EAClC,MAAM,MAAwB;AAC1B,QAAI,KAAK,WAAW,GAAG;AACnB,YAAM,IAAI,UAAU,2CAA2C,KAAK,MAAM,QAAQ;AAAA,IACtF;AAAA,EACJ;AACJ;",
+  "names": []
+}

package/dist/esm/dtls/handshake/ServerHelloMessage.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export interface ParsedServerHello {
+    /** Server's 32-byte random — feeds the TLS PRF. */
+    serverRandom: Uint8Array;
+    /** Server's `ecjpake_kkpp` extension data (round-1 ECJPAKEKeyKPPairList). */
+    ecjpakeKkpp: Uint8Array;
+}
+export declare const ServerHelloMessage: {
+    parse(body: Uint8Array): ParsedServerHello;
+};
+//# sourceMappingURL=ServerHelloMessage.d.ts.map

package/dist/esm/dtls/handshake/ServerHelloMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServerHelloMessage.d.ts","sourceRoot":"","sources":["../../../../src/dtls/handshake/ServerHelloMessage.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAwCH,MAAM,WAAW,iBAAiB;IAC9B,mDAAmD;IACnD,YAAY,EAAE,UAAU,CAAC;IACzB,6EAA6E;IAC7E,WAAW,EAAE,UAAU,CAAC;CAC3B;AAED,eAAO,MAAM,kBAAkB;IAC3B,KAAK,OAAO,UAAU,GAAG,iBAAiB;CA4EpC,CAAC"}

package/dist/esm/dtls/handshake/ServerHelloMessage.js

@@ -0,0 +1,93 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { DtlsError } from "../channel/DtlsChannel.js";
+import { CIPHER_SUITE_ECJPAKE_WITH_AES_128_CCM_8, EXTENSION_TYPE_ECJPAKE_KKPP } from "./ClientHelloMessage.js";
+const DTLS_1_2_MAJOR = 254;
+const DTLS_1_2_MINOR = 253;
+const RANDOM_LEN = 32;
+const COMPRESSION_NULL = 0;
+function readUint16BE(buf, offset) {
+  return buf[offset] << 8 | buf[offset + 1];
+}
+const ServerHelloMessage = {
+  parse(body) {
+    if (body.length < 2 + RANDOM_LEN + 1 + 2 + 1) {
+      throw new DtlsError(`ServerHello body truncated: have ${body.length}`);
+    }
+    let p = 0;
+    const major = body[p++];
+    const minor = body[p++];
+    if (major !== DTLS_1_2_MAJOR || minor !== DTLS_1_2_MINOR) {
+      throw new DtlsError(`ServerHello version ${major.toString(16)}.${minor.toString(16)} is not DTLS 1.2`);
+    }
+    const serverRandom = body.slice(p, p + RANDOM_LEN);
+    p += RANDOM_LEN;
+    const sessionIdLen = body[p++];
+    if (p + sessionIdLen > body.length) {
+      throw new DtlsError(`ServerHello session_id length ${sessionIdLen} overruns body`);
+    }
+    p += sessionIdLen;
+    if (p + 2 + 1 > body.length) {
+      throw new DtlsError(`ServerHello truncated before cipher_suite/compression_method`);
+    }
+    const suite = readUint16BE(body, p);
+    p += 2;
+    if (suite !== CIPHER_SUITE_ECJPAKE_WITH_AES_128_CCM_8) {
+      throw new DtlsError(
+        `ServerHello selected unsupported cipher suite 0x${suite.toString(16).padStart(4, "0")}; require TLS_ECJPAKE_WITH_AES_128_CCM_8 (0xc0ff)`
+      );
+    }
+    const compression = body[p++];
+    if (compression !== COMPRESSION_NULL) {
+      throw new DtlsError(`ServerHello selected unsupported compression method 0x${compression.toString(16)}`);
+    }
+    let ecjpakeKkpp;
+    if (p < body.length) {
+      if (p + 2 > body.length) {
+        throw new DtlsError("ServerHello extensions block length truncated");
+      }
+      const extsLen = readUint16BE(body, p);
+      p += 2;
+      const extsEnd = p + extsLen;
+      if (extsEnd > body.length) {
+        throw new DtlsError(`ServerHello extensions length ${extsLen} overruns body`);
+      }
+      while (p < extsEnd) {
+        if (p + 4 > extsEnd) {
+          throw new DtlsError("ServerHello extension entry truncated");
+        }
+        const extType = readUint16BE(body, p);
+        p += 2;
+        const extDataLen = readUint16BE(body, p);
+        p += 2;
+        if (p + extDataLen > extsEnd) {
+          throw new DtlsError(`ServerHello extension type 0x${extType.toString(16)} data overruns`);
+        }
+        if (extType === EXTENSION_TYPE_ECJPAKE_KKPP) {
+          if (ecjpakeKkpp !== void 0) {
+            throw new DtlsError("ServerHello contains multiple ecjpake_kkpp extensions");
+          }
+          ecjpakeKkpp = body.slice(p, p + extDataLen);
+        }
+        p += extDataLen;
+      }
+      if (p !== extsEnd) {
+        throw new DtlsError(`ServerHello extensions block ended at ${p}, expected ${extsEnd}`);
+      }
+    }
+    if (p !== body.length) {
+      throw new DtlsError(`ServerHello has ${body.length - p} trailing bytes after extensions block`);
+    }
+    if (ecjpakeKkpp === void 0) {
+      throw new DtlsError("ServerHello missing required ecjpake_kkpp extension (type 0x0100)");
+    }
+    return { serverRandom, ecjpakeKkpp };
+  }
+};
+export {
+  ServerHelloMessage
+};
+//# sourceMappingURL=ServerHelloMessage.js.map

package/dist/esm/dtls/handshake/ServerHelloMessage.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/dtls/handshake/ServerHelloMessage.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAS,iBAAiB;AAC1B,SAAS,yCAAyC,mCAAmC;AA4BrF,MAAM,iBAAiB;AACvB,MAAM,iBAAiB;AACvB,MAAM,aAAa;AACnB,MAAM,mBAAmB;AAEzB,SAAS,aAAa,KAAiB,QAAwB;AAC3D,SAAQ,IAAI,MAAM,KAAK,IAAK,IAAI,SAAS,CAAC;AAC9C;AASO,MAAM,qBAAqB;AAAA,EAC9B,MAAM,MAAqC;AACvC,QAAI,KAAK,SAAS,IAAI,aAAa,IAAI,IAAI,GAAG;AAC1C,YAAM,IAAI,UAAU,oCAAoC,KAAK,MAAM,EAAE;AAAA,IACzE;AACA,QAAI,IAAI;AACR,UAAM,QAAQ,KAAK,GAAG;AACtB,UAAM,QAAQ,KAAK,GAAG;AACtB,QAAI,UAAU,kBAAkB,UAAU,gBAAgB;AACtD,YAAM,IAAI,UAAU,uBAAuB,MAAM,SAAS,EAAE,CAAC,IAAI,MAAM,SAAS,EAAE,CAAC,kBAAkB;AAAA,IACzG;AAEA,UAAM,eAAe,KAAK,MAAM,GAAG,IAAI,UAAU;AACjD,SAAK;AACL,UAAM,eAAe,KAAK,GAAG;AAC7B,QAAI,IAAI,eAAe,KAAK,QAAQ;AAChC,YAAM,IAAI,UAAU,iCAAiC,YAAY,gBAAgB;AAAA,IACrF;AAEA,SAAK;AACL,QAAI,IAAI,IAAI,IAAI,KAAK,QAAQ;AACzB,YAAM,IAAI,UAAU,8DAA8D;AAAA,IACtF;AACA,UAAM,QAAQ,aAAa,MAAM,CAAC;AAClC,SAAK;AACL,QAAI,UAAU,yCAAyC;AACnD,YAAM,IAAI;AAAA,QACN,mDAAmD,MAAM,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC;AAAA,MAC1F;AAAA,IACJ;AACA,UAAM,cAAc,KAAK,GAAG;AAC5B,QAAI,gBAAgB,kBAAkB;AAClC,YAAM,IAAI,UAAU,yDAAyD,YAAY,SAAS,EAAE,CAAC,EAAE;AAAA,IAC3G;AAEA,QAAI;AACJ,QAAI,IAAI,KAAK,QAAQ;AACjB,UAAI,IAAI,IAAI,KAAK,QAAQ;AACrB,cAAM,IAAI,UAAU,+CAA+C;AAAA,MACvE;AACA,YAAM,UAAU,aAAa,MAAM,CAAC;AACpC,WAAK;AACL,YAAM,UAAU,IAAI;AACpB,UAAI,UAAU,KAAK,QAAQ;AACvB,cAAM,IAAI,UAAU,iCAAiC,OAAO,gBAAgB;AAAA,MAChF;AACA,aAAO,IAAI,SAAS;AAChB,YAAI,IAAI,IAAI,SAAS;AACjB,gBAAM,IAAI,UAAU,uCAAuC;AAAA,QAC/D;AACA,cAAM,UAAU,aAAa,MAAM,CAAC;AACpC,aAAK;AACL,cAAM,aAAa,aAAa,MAAM,CAAC;AACvC,aAAK;AACL,YAAI,IAAI,aAAa,SAAS;AAC1B,gBAAM,IAAI,UAAU,gCAAgC,QAAQ,SAAS,EAAE,CAAC,gBAAgB;AAAA,QAC5F;AACA,YAAI,YAAY,6BAA6B;AACzC,cAAI,gBAAgB,QAAW;AAC3B,kBAAM,IAAI,UAAU,uDAAuD;AAAA,UAC/E;AACA,wBAAc,KAAK,MAAM,GAAG,IAAI,UAAU;AAAA,QAC9C;AACA,aAAK;AAAA,MACT;AACA,UAAI,MAAM,SAAS;AACf,cAAM,IAAI,UAAU,yCAAyC,CAAC,cAAc,OAAO,EAAE;AAAA,MACzF;AAAA,IACJ;AACA,QAAI,MAAM,KAAK,QAAQ;AACnB,YAAM,IAAI,UAAU,mBAAmB,KAAK,SAAS,CAAC,wCAAwC;AAAA,IAClG;AACA,QAAI,gBAAgB,QAAW;AAC3B,YAAM,IAAI,UAAU,mEAAmE;AAAA,IAC3F;AACA,WAAO,EAAE,cAAc,YAAY;AAAA,EACvC;AACJ;",
+  "names": []
+}

package/dist/esm/dtls/handshake/ServerKeyExchangeMessage.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type EcJpakeKeyKP } from "../ecjpake/EcJpakeRound.js";
+/**
+ * ServerKeyExchange body parser for `TLS_ECJPAKE_WITH_AES_128_CCM_8`
+ * (mbedTLS `ssl_tls12_server.c:2467-2507`):
+ *
+ * ```
+ * ECParameters curve_params         // 0x03 || 0x00 || 0x17  (named_curve, secp256r1)
+ * ECJPAKEKeyKP server_round2        // 1 + 65 + 1 + 65 + 1 + |r| bytes
+ * ```
+ *
+ * The 3-byte ECParameters header is *prepended by the TLS-binding layer*, not
+ * by the EC-JPAKE module — see the architecture notes section 2 — so we
+ * strip it here before handing the remainder to {@link EcJpakeRound.parseRound2}
+ * with `expectEcParameters: false`.
+ */
+export declare const ServerKeyExchangeMessage: {
+    parse(body: Uint8Array): EcJpakeKeyKP;
+};
+//# sourceMappingURL=ServerKeyExchangeMessage.d.ts.map

package/dist/esm/dtls/handshake/ServerKeyExchangeMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServerKeyExchangeMessage.d.ts","sourceRoot":"","sources":["../../../../src/dtls/handshake/ServerKeyExchangeMessage.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,YAAY,EAAgB,MAAM,4BAA4B,CAAC;AAE7E;;;;;;;;;;;;;GAaG;AAEH,eAAO,MAAM,wBAAwB;IACjC,KAAK,OAAO,UAAU,GAAG,YAAY;CAM/B,CAAC"}

package/dist/esm/dtls/handshake/ServerKeyExchangeMessage.js

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { EcJpakeRound } from "../ecjpake/EcJpakeRound.js";
+const ServerKeyExchangeMessage = {
+  parse(body) {
+    return EcJpakeRound.parseRound2(body, { expectEcParameters: true });
+  }
+};
+export {
+  ServerKeyExchangeMessage
+};
+//# sourceMappingURL=ServerKeyExchangeMessage.js.map

package/dist/esm/dtls/handshake/ServerKeyExchangeMessage.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/dtls/handshake/ServerKeyExchangeMessage.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAA4B,oBAAoB;AAiBzC,MAAM,2BAA2B;AAAA,EACpC,MAAM,MAAgC;AAIlC,WAAO,aAAa,YAAY,MAAM,EAAE,oBAAoB,KAAK,CAAC;AAAA,EACtE;AACJ;",
+  "names": []
+}

package/dist/esm/dtls/handshake/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * DTLS 1.2 client-side handshake driver for `TLS_ECJPAKE_WITH_AES_128_CCM_8`.
+ * Internal to `dtls/`; not re-exported from the package public API surface
+ * until the {@link DtlsChannel} interface ships in sub-batch 5. The per-message
+ * encoders/parsers (`ClientHelloMessage`, `ServerHelloMessage`, `HandshakeMessage`,
+ * etc.) are deliberately kept private to this module.
+ */
+export { DtlsClient, type DtlsClientConfig, type DtlsClientState, type DtlsClientStep } from "./DtlsClient.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/dtls/handshake/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/dtls/handshake/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;GAMG;AAEH,OAAO,EAAE,UAAU,EAAE,KAAK,gBAAgB,EAAE,KAAK,eAAe,EAAE,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/esm/dtls/handshake/index.js

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { DtlsClient } from "./DtlsClient.js";
+export {
+  DtlsClient
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/dtls/handshake/index.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/dtls/handshake/index.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAcA,SAAS,kBAAoF;",
+  "names": []
+}

package/dist/esm/dtls/prf/HandshakeTranscript.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Running SHA-256 over the DTLS 1.2 handshake transcript that feeds the
+ * Finished MAC (RFC 5246 §7.4.9). The transcript covers every handshake
+ * message from the initial ClientHello up to (and EXCLUDING) the Finished
+ * being computed or verified.
+ *
+ * Callers feed the **full DTLS 1.2 handshake message bytes** (12-byte header
+ * including `message_seq` / `fragment_offset` / `fragment_length`, then body).
+ * mbedTLS — and OpenThread BRs built on it — hash the full DTLS form;
+ * stripping the DTLS-only fields makes the Finished MAC mismatch.
+ * `fragment_offset`/`fragment_length` are normalised to the unfragmented form
+ * regardless of how the message was actually fragmented on the wire (RFC 6347
+ * §4.2.6).
+ *
+ * Internal to `dtls/`; not re-exported from the package public API surface.
+ */
+export declare class HandshakeTranscript {
+    #private;
+    /**
+     * Append a handshake message in DTLS 1.2 form
+     * (`type(1) || length(3) || message_seq(2) || fragment_offset(3) || fragment_length(3) || body`).
+     */
+    appendHandshakeMessage(messageBytes: Uint8Array): void;
+    /**
+     * Snapshot the running SHA-256 digest without disturbing the transcript so
+     * the same accumulator can compute Finished for both peers and continue
+     * absorbing later messages. Backed by `Hash.copy()` (Node.js >= 13.10).
+     */
+    digest(): Uint8Array;
+}
+//# sourceMappingURL=HandshakeTranscript.d.ts.map

package/dist/esm/dtls/prf/HandshakeTranscript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HandshakeTranscript.d.ts","sourceRoot":"","sources":["../../../../src/dtls/prf/HandshakeTranscript.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,mBAAmB;;IAG5B;;;OAGG;IACH,sBAAsB,CAAC,YAAY,EAAE,UAAU,GAAG,IAAI,CAErD;IAED;;;;OAIG;IACH,MAAM,IAAI,UAAU,CAOnB;CACJ"}

package/dist/esm/dtls/prf/HandshakeTranscript.js

@@ -0,0 +1,35 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { InternalError } from "@matter/general";
+import { createHash } from "node:crypto";
+const SHA256_LEN = 32;
+class HandshakeTranscript {
+  #hash = createHash("sha256");
+  /**
+   * Append a handshake message in DTLS 1.2 form
+   * (`type(1) || length(3) || message_seq(2) || fragment_offset(3) || fragment_length(3) || body`).
+   */
+  appendHandshakeMessage(messageBytes) {
+    this.#hash.update(messageBytes);
+  }
+  /**
+   * Snapshot the running SHA-256 digest without disturbing the transcript so
+   * the same accumulator can compute Finished for both peers and continue
+   * absorbing later messages. Backed by `Hash.copy()` (Node.js >= 13.10).
+   */
+  digest() {
+    const snapshot = this.#hash.copy();
+    const out = new Uint8Array(snapshot.digest());
+    if (out.length !== SHA256_LEN) {
+      throw new InternalError(`HandshakeTranscript digest length ${out.length} != ${SHA256_LEN}`);
+    }
+    return out;
+  }
+}
+export {
+  HandshakeTranscript
+};
+//# sourceMappingURL=HandshakeTranscript.js.map

package/dist/esm/dtls/prf/HandshakeTranscript.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/dtls/prf/HandshakeTranscript.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAS,qBAAqB;AAC9B,SAAS,kBAA6B;AAEtC,MAAM,aAAa;AAkBZ,MAAM,oBAAoB;AAAA,EAC7B,QAAc,WAAW,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA,EAMjC,uBAAuB,cAAgC;AACnD,SAAK,MAAM,OAAO,YAAY;AAAA,EAClC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,SAAqB;AACjB,UAAM,WAAW,KAAK,MAAM,KAAK;AACjC,UAAM,MAAM,IAAI,WAAW,SAAS,OAAO,CAAC;AAC5C,QAAI,IAAI,WAAW,YAAY;AAC3B,YAAM,IAAI,cAAc,qCAAqC,IAAI,MAAM,OAAO,UAAU,EAAE;AAAA,IAC9F;AACA,WAAO;AAAA,EACX;AACJ;",
+  "names": []
+}