@matter/thread-br-client 0.0.1

package/dist/esm/tlv/BasicTlvCodec.js

@@ -0,0 +1,77 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { InternalError, MatterError } from "@matter/general";
+class ThreadTlvError extends MatterError {
+}
+var BasicTlv;
+((BasicTlv2) => {
+  function walk(blob) {
+    const out = new Array();
+    let offset = 0;
+    while (offset < blob.length) {
+      if (offset + 2 > blob.length) {
+        throw new ThreadTlvError(`Truncated TLV header at offset ${offset}`);
+      }
+      const type = blob[offset];
+      const lenByte = blob[offset + 1];
+      let length;
+      let valueStart;
+      if (lenByte === 255) {
+        if (offset + 4 > blob.length) {
+          throw new ThreadTlvError(`Truncated extended-length TLV header at offset ${offset}`);
+        }
+        length = blob[offset + 2] << 8 | blob[offset + 3];
+        valueStart = offset + 4;
+      } else {
+        length = lenByte;
+        valueStart = offset + 2;
+      }
+      const valueEnd = valueStart + length;
+      if (valueEnd > blob.length) {
+        throw new ThreadTlvError(`Truncated TLV value at offset ${offset} (type=${type}, length=${length})`);
+      }
+      out.push({ type, value: blob.slice(valueStart, valueEnd) });
+      offset = valueEnd;
+    }
+    return out;
+  }
+  BasicTlv2.walk = walk;
+  function encode(entries) {
+    let totalLength = 0;
+    for (const entry of entries) {
+      if (!Number.isInteger(entry.type) || entry.type < 0 || entry.type > 255) {
+        throw new InternalError(`Invalid TLV type ${entry.type}: must be 0..255`);
+      }
+      const valueLen = entry.value.length;
+      if (valueLen > 65535) {
+        throw new InternalError(`Invalid TLV length ${valueLen}: must be <= 0xFFFF`);
+      }
+      totalLength += valueLen + (valueLen >= 255 ? 4 : 2);
+    }
+    const out = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const entry of entries) {
+      const valueLen = entry.value.length;
+      out[offset++] = entry.type;
+      if (valueLen >= 255) {
+        out[offset++] = 255;
+        out[offset++] = valueLen >> 8 & 255;
+        out[offset++] = valueLen & 255;
+      } else {
+        out[offset++] = valueLen;
+      }
+      out.set(entry.value, offset);
+      offset += valueLen;
+    }
+    return out;
+  }
+  BasicTlv2.encode = encode;
+})(BasicTlv || (BasicTlv = {}));
+export {
+  BasicTlv,
+  ThreadTlvError
+};
+//# sourceMappingURL=BasicTlvCodec.js.map

package/dist/esm/tlv/BasicTlvCodec.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/tlv/BasicTlvCodec.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAS,eAAe,mBAAmB;AAGpC,MAAM,uBAAuB,YAAY;AAAC;AAW1C,IAAU;AAAA,CAAV,CAAUA,cAAV;AACI,WAAS,KAAK,MAAmC;AACpD,UAAM,MAAM,IAAI,MAAqB;AACrC,QAAI,SAAS;AACb,WAAO,SAAS,KAAK,QAAQ;AACzB,UAAI,SAAS,IAAI,KAAK,QAAQ;AAC1B,cAAM,IAAI,eAAe,kCAAkC,MAAM,EAAE;AAAA,MACvE;AACA,YAAM,OAAO,KAAK,MAAM;AACxB,YAAM,UAAU,KAAK,SAAS,CAAC;AAC/B,UAAI;AACJ,UAAI;AACJ,UAAI,YAAY,KAAM;AAClB,YAAI,SAAS,IAAI,KAAK,QAAQ;AAC1B,gBAAM,IAAI,eAAe,kDAAkD,MAAM,EAAE;AAAA,QACvF;AACA,iBAAU,KAAK,SAAS,CAAC,KAAK,IAAK,KAAK,SAAS,CAAC;AAClD,qBAAa,SAAS;AAAA,MAC1B,OAAO;AACH,iBAAS;AACT,qBAAa,SAAS;AAAA,MAC1B;AACA,YAAM,WAAW,aAAa;AAC9B,UAAI,WAAW,KAAK,QAAQ;AACxB,cAAM,IAAI,eAAe,iCAAiC,MAAM,UAAU,IAAI,YAAY,MAAM,GAAG;AAAA,MACvG;AACA,UAAI,KAAK,EAAE,MAAM,OAAO,KAAK,MAAM,YAAY,QAAQ,EAAE,CAAC;AAC1D,eAAS;AAAA,IACb;AACA,WAAO;AAAA,EACX;AA7BO,EAAAA,UAAS;AA+BT,WAAS,OAAO,SAAmD;AACtE,QAAI,cAAc;AAClB,eAAW,SAAS,SAAS;AACzB,UAAI,CAAC,OAAO,UAAU,MAAM,IAAI,KAAK,MAAM,OAAO,KAAK,MAAM,OAAO,KAAM;AACtE,cAAM,IAAI,cAAc,oBAAoB,MAAM,IAAI,kBAAkB;AAAA,MAC5E;AACA,YAAM,WAAW,MAAM,MAAM;AAC7B,UAAI,WAAW,OAAQ;AACnB,cAAM,IAAI,cAAc,sBAAsB,QAAQ,qBAAqB;AAAA,MAC/E;AACA,qBAAe,YAAY,YAAY,MAAO,IAAI;AAAA,IACtD;AAEA,UAAM,MAAM,IAAI,WAAW,WAAW;AACtC,QAAI,SAAS;AACb,eAAW,SAAS,SAAS;AACzB,YAAM,WAAW,MAAM,MAAM;AAC7B,UAAI,QAAQ,IAAI,MAAM;AACtB,UAAI,YAAY,KAAM;AAClB,YAAI,QAAQ,IAAI;AAChB,YAAI,QAAQ,IAAK,YAAY,IAAK;AAClC,YAAI,QAAQ,IAAI,WAAW;AAAA,MAC/B,OAAO;AACH,YAAI,QAAQ,IAAI;AAAA,MACpB;AACA,UAAI,IAAI,MAAM,OAAO,MAAM;AAC3B,gBAAU;AAAA,IACd;AACA,WAAO;AAAA,EACX;AA7BO,EAAAA,UAAS;AAAA,GAhCH;",
+  "names": ["BasicTlv"]
+}

package/dist/esm/tlv/NetworkDiagnosticTlv.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type BasicTlvEntry } from "./BasicTlvCodec.js";
+/**
+ * One Network Diagnostic TLV entry as walked from the response payload.
+ *
+ * The {@link type} numeric values are listed in {@link NetworkDiagTlvType}.
+ * {@link value} holds the raw inner bytes; per-TLV typed decoders in
+ * `./diag/` interpret it.
+ */
+export type NetworkDiagnosticEntry = BasicTlvEntry;
+/**
+ * Outer Network Diagnostic TLV codec.
+ *
+ * MGMT_DIAG_GET responses (and `.qry` payloads, on the request side) are a
+ * concatenation of TLVs framed by the same basic + extended-length scheme as
+ * MeshCoP. This namespace just specializes {@link BasicTlv} for the diagnostic
+ * registry so callers get an idiomatic name.
+ *
+ * Unknown TLV types are preserved as raw {@link NetworkDiagnosticEntry}
+ * records; per-TLV typed decoders are layered on top in `./diag/`.
+ */
+export declare namespace NetworkDiagnosticTlv {
+    function decode(blob: Uint8Array): NetworkDiagnosticEntry[];
+    function encode(entries: ReadonlyArray<NetworkDiagnosticEntry>): Uint8Array;
+}
+//# sourceMappingURL=NetworkDiagnosticTlv.d.ts.map

package/dist/esm/tlv/NetworkDiagnosticTlv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NetworkDiagnosticTlv.d.ts","sourceRoot":"","sources":["../../../src/tlv/NetworkDiagnosticTlv.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAY,KAAK,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAElE;;;;;;GAMG;AACH,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC;AAEnD;;;;;;;;;;GAUG;AACH,yBAAiB,oBAAoB,CAAC,CAAC;IACnC,SAAgB,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,sBAAsB,EAAE,CAEjE;IAED,SAAgB,MAAM,CAAC,OAAO,EAAE,aAAa,CAAC,sBAAsB,CAAC,GAAG,UAAU,CAEjF;CACJ"}

package/dist/esm/tlv/NetworkDiagnosticTlv.js

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BasicTlv } from "./BasicTlvCodec.js";
+var NetworkDiagnosticTlv;
+((NetworkDiagnosticTlv2) => {
+  function decode(blob) {
+    return BasicTlv.walk(blob);
+  }
+  NetworkDiagnosticTlv2.decode = decode;
+  function encode(entries) {
+    return BasicTlv.encode(entries);
+  }
+  NetworkDiagnosticTlv2.encode = encode;
+})(NetworkDiagnosticTlv || (NetworkDiagnosticTlv = {}));
+export {
+  NetworkDiagnosticTlv
+};
+//# sourceMappingURL=NetworkDiagnosticTlv.js.map

package/dist/esm/tlv/NetworkDiagnosticTlv.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/tlv/NetworkDiagnosticTlv.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAS,gBAAoC;AAsBtC,IAAU;AAAA,CAAV,CAAUA,0BAAV;AACI,WAAS,OAAO,MAA4C;AAC/D,WAAO,SAAS,KAAK,IAAI;AAAA,EAC7B;AAFO,EAAAA,sBAAS;AAIT,WAAS,OAAO,SAA4D;AAC/E,WAAO,SAAS,OAAO,OAAO;AAAA,EAClC;AAFO,EAAAA,sBAAS;AAAA,GALH;",
+  "names": ["NetworkDiagnosticTlv"]
+}

package/dist/esm/tlv/TypeListTlv.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Type List TLV value codec (Network Diagnostic TLV type 18).
+ *
+ * The "value" of a Type List TLV is just the concatenation of the TLV-type
+ * bytes the requester wants — one byte per requested type. The outer TLV(18,
+ * ...) framing comes from the regular {@link NetworkDiagnosticTlv.encode}
+ * caller, e.g.:
+ *
+ *   NetworkDiagnosticTlv.encode([{ type: NetworkDiagTlvType.TYPE_LIST, value: TypeListTlv.encode([0, 1, 5]) }])
+ *
+ * Source: OpenThread `network_diagnostic_tlvs.hpp` `TypeListTlv` (a plain
+ * `TlvInfo<kTypeList>`) and `network_diagnostic.cpp` request payload handling.
+ */
+export declare namespace TypeListTlv {
+    function encode(types: ReadonlyArray<number>): Uint8Array;
+    function decode(value: Uint8Array): number[];
+}
+//# sourceMappingURL=TypeListTlv.d.ts.map

package/dist/esm/tlv/TypeListTlv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeListTlv.d.ts","sourceRoot":"","sources":["../../../src/tlv/TypeListTlv.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH;;;;;;;;;;;;GAYG;AACH,yBAAiB,WAAW,CAAC,CAAC;IAC1B,SAAgB,MAAM,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,UAAU,CAU/D;IAED,SAAgB,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,EAAE,CAElD;CACJ"}

package/dist/esm/tlv/TypeListTlv.js

@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { InternalError } from "@matter/general";
+var TypeListTlv;
+((TypeListTlv2) => {
+  function encode(types) {
+    const out = new Uint8Array(types.length);
+    for (let i = 0; i < types.length; i++) {
+      const t = types[i];
+      if (!Number.isInteger(t) || t < 0 || t > 255) {
+        throw new InternalError(`TypeList entry out of range: ${t}`);
+      }
+      out[i] = t;
+    }
+    return out;
+  }
+  TypeListTlv2.encode = encode;
+  function decode(value) {
+    return Array.from(value);
+  }
+  TypeListTlv2.decode = decode;
+})(TypeListTlv || (TypeListTlv = {}));
+export {
+  TypeListTlv
+};
+//# sourceMappingURL=TypeListTlv.js.map

package/dist/esm/tlv/TypeListTlv.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/tlv/TypeListTlv.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAS,qBAAqB;AAevB,IAAU;AAAA,CAAV,CAAUA,iBAAV;AACI,WAAS,OAAO,OAA0C;AAC7D,UAAM,MAAM,IAAI,WAAW,MAAM,MAAM;AACvC,aAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACnC,YAAM,IAAI,MAAM,CAAC;AACjB,UAAI,CAAC,OAAO,UAAU,CAAC,KAAK,IAAI,KAAK,IAAI,KAAM;AAC3C,cAAM,IAAI,cAAc,gCAAgC,CAAC,EAAE;AAAA,MAC/D;AACA,UAAI,CAAC,IAAI;AAAA,IACb;AACA,WAAO;AAAA,EACX;AAVO,EAAAA,aAAS;AAYT,WAAS,OAAO,OAA6B;AAChD,WAAO,MAAM,KAAK,KAAK;AAAA,EAC3B;AAFO,EAAAA,aAAS;AAAA,GAbH;",
+  "names": ["TypeListTlv"]
+}

package/dist/esm/tlv/diag/ChildIpv6AddressList.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Decoded Child IPv6 Address List TLV (Network Diagnostic TLV type 30).
+ *
+ * Layout per OpenThread `include/openthread/netdiag.h` `otNetworkDiagChildEntry`
+ * and `src/core/thread/network_diagnostic.cpp`:
+ *
+ *   [0..1]  uint16-be  RLOC16 of the child
+ *   [2..]   bytes[N*16] N IPv6 addresses, each 16 bytes, network byte order
+ */
+export interface ChildIpv6Addresses {
+    rloc16: number;
+    addresses: Uint8Array[];
+}
+export declare namespace ChildIpv6AddressList {
+    function decode(value: Uint8Array): ChildIpv6Addresses;
+}
+//# sourceMappingURL=ChildIpv6AddressList.d.ts.map

package/dist/esm/tlv/diag/ChildIpv6AddressList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChildIpv6AddressList.d.ts","sourceRoot":"","sources":["../../../../src/tlv/diag/ChildIpv6AddressList.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;GAQG;AACH,MAAM,WAAW,kBAAkB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,UAAU,EAAE,CAAC;CAC3B;AAKD,yBAAiB,oBAAoB,CAAC,CAAC;IACnC,SAAgB,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,kBAAkB,CAe5D;CACJ"}

package/dist/esm/tlv/diag/ChildIpv6AddressList.js

@@ -0,0 +1,28 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const RLOC16_BYTES = 2;
+const IPV6_ADDRESS_BYTES = 16;
+var ChildIpv6AddressList;
+((ChildIpv6AddressList2) => {
+  function decode(value) {
+    if (value.length < RLOC16_BYTES) {
+      return { rloc16: 0, addresses: [] };
+    }
+    const rloc16 = value[0] << 8 | value[1];
+    const addressPayload = value.subarray(RLOC16_BYTES);
+    const addressCount = Math.floor(addressPayload.length / IPV6_ADDRESS_BYTES);
+    const addresses = new Array();
+    for (let i = 0; i < addressCount; i++) {
+      addresses.push(addressPayload.slice(i * IPV6_ADDRESS_BYTES, (i + 1) * IPV6_ADDRESS_BYTES));
+    }
+    return { rloc16, addresses };
+  }
+  ChildIpv6AddressList2.decode = decode;
+})(ChildIpv6AddressList || (ChildIpv6AddressList = {}));
+export {
+  ChildIpv6AddressList
+};
+//# sourceMappingURL=ChildIpv6AddressList.js.map

package/dist/esm/tlv/diag/ChildIpv6AddressList.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/tlv/diag/ChildIpv6AddressList.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAoBA,MAAM,eAAe;AACrB,MAAM,qBAAqB;AAEpB,IAAU;AAAA,CAAV,CAAUA,0BAAV;AACI,WAAS,OAAO,OAAuC;AAC1D,QAAI,MAAM,SAAS,cAAc;AAC7B,aAAO,EAAE,QAAQ,GAAG,WAAW,CAAC,EAAE;AAAA,IACtC;AAEA,UAAM,SAAU,MAAM,CAAC,KAAK,IAAK,MAAM,CAAC;AACxC,UAAM,iBAAiB,MAAM,SAAS,YAAY;AAClD,UAAM,eAAe,KAAK,MAAM,eAAe,SAAS,kBAAkB;AAE1E,UAAM,YAAY,IAAI,MAAkB;AACxC,aAAS,IAAI,GAAG,IAAI,cAAc,KAAK;AACnC,gBAAU,KAAK,eAAe,MAAM,IAAI,qBAAqB,IAAI,KAAK,kBAAkB,CAAC;AAAA,IAC7F;AAEA,WAAO,EAAE,QAAQ,UAAU;AAAA,EAC/B;AAfO,EAAAA,sBAAS;AAAA,GADH;",
+  "names": ["ChildIpv6AddressList"]
+}

package/dist/esm/tlv/diag/ChildTable.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Mode } from "./Mode.js";
+/**
+ * One Child Table entry — 3 bytes per OpenThread `ChildTableTlvEntry`:
+ *
+ *   uint16 BE: [bits 15..11 timeout-exponent][bits 10..9 incoming link quality][bits 8..0 child id]
+ *   uint8     : MLE Mode bitmap (same layout as the Mode TLV)
+ *
+ * `timeout-exponent` 4..31 maps to `2^(exp - 4)` seconds; values <4 clamp to 4
+ * per OpenThread `ChildTableTlvEntry::DetermineTimeoutFromExponent`.
+ */
+export interface ChildTableEntry {
+    /** Timeout exponent (4..31) — wire form. {@link timeoutSeconds} is the resolved value. */
+    timeoutExponent: number;
+    /** Resolved timeout in seconds (`2^(exp-4)`). */
+    timeoutSeconds: number;
+    incomingLinkQuality: number;
+    childId: number;
+    mode: Mode;
+}
+export declare namespace ChildTable {
+    function decode(value: Uint8Array): ChildTableEntry[];
+    function encode(entries: ReadonlyArray<ChildTableEntry>): Uint8Array;
+}
+//# sourceMappingURL=ChildTable.d.ts.map

package/dist/esm/tlv/diag/ChildTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChildTable.d.ts","sourceRoot":"","sources":["../../../../src/tlv/diag/ChildTable.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC;;;;;;;;GAQG;AACH,MAAM,WAAW,eAAe;IAC5B,0FAA0F;IAC1F,eAAe,EAAE,MAAM,CAAC;IACxB,iDAAiD;IACjD,cAAc,EAAE,MAAM,CAAC;IACvB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,IAAI,CAAC;CACd;AAqBD,yBAAiB,UAAU,CAAC,CAAC;IACzB,SAAgB,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,eAAe,EAAE,CAiB3D;IAED,SAAgB,MAAM,CAAC,OAAO,EAAE,aAAa,CAAC,eAAe,CAAC,GAAG,UAAU,CAsB1E;CACJ"}

package/dist/esm/tlv/diag/ChildTable.js

@@ -0,0 +1,71 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { InternalError } from "@matter/general";
+import { ThreadDiagError } from "../../diagnostic/errors.js";
+import { Mode } from "./Mode.js";
+const ENTRY_BYTES = 3;
+const TIMEOUT_MASK = 63488;
+const TIMEOUT_SHIFT = 11;
+const ILQ_MASK = 1536;
+const ILQ_SHIFT = 9;
+const CHILD_ID_MASK = 511;
+const TIMEOUT_EXP_MIN = 4;
+const TIMEOUT_EXP_MAX = 31;
+function clampedExponent(exp) {
+  if (exp < TIMEOUT_EXP_MIN) return TIMEOUT_EXP_MIN;
+  if (exp > TIMEOUT_EXP_MAX) return TIMEOUT_EXP_MAX;
+  return exp;
+}
+function timeoutFromExponent(exp) {
+  return 1 << clampedExponent(exp) - TIMEOUT_EXP_MIN;
+}
+var ChildTable;
+((ChildTable2) => {
+  function decode(value) {
+    if (value.length % ENTRY_BYTES !== 0) {
+      throw new ThreadDiagError(`ChildTable TLV length ${value.length} not a multiple of ${ENTRY_BYTES}`);
+    }
+    const entries = new Array();
+    for (let offset = 0; offset < value.length; offset += ENTRY_BYTES) {
+      const word = value[offset] << 8 | value[offset + 1];
+      const timeoutExponent = (word & TIMEOUT_MASK) >> TIMEOUT_SHIFT;
+      entries.push({
+        timeoutExponent,
+        timeoutSeconds: timeoutFromExponent(timeoutExponent),
+        incomingLinkQuality: (word & ILQ_MASK) >> ILQ_SHIFT,
+        childId: word & CHILD_ID_MASK,
+        mode: Mode.decode(value.subarray(offset + 2, offset + 3))
+      });
+    }
+    return entries;
+  }
+  ChildTable2.decode = decode;
+  function encode(entries) {
+    const out = new Uint8Array(entries.length * ENTRY_BYTES);
+    for (let i = 0; i < entries.length; i++) {
+      const e = entries[i];
+      if (e.timeoutExponent < 0 || e.timeoutExponent > TIMEOUT_EXP_MAX) {
+        throw new InternalError(`ChildTable timeoutExponent out of range: ${e.timeoutExponent}`);
+      }
+      if (e.incomingLinkQuality < 0 || e.incomingLinkQuality > 3) {
+        throw new InternalError(`ChildTable incomingLinkQuality out of range: ${e.incomingLinkQuality}`);
+      }
+      if (e.childId < 0 || e.childId > 511) {
+        throw new InternalError(`ChildTable childId out of range: ${e.childId}`);
+      }
+      const word = e.timeoutExponent << TIMEOUT_SHIFT & TIMEOUT_MASK | e.incomingLinkQuality << ILQ_SHIFT & ILQ_MASK | e.childId & CHILD_ID_MASK;
+      out[i * ENTRY_BYTES] = word >> 8 & 255;
+      out[i * ENTRY_BYTES + 1] = word & 255;
+      out[i * ENTRY_BYTES + 2] = Mode.encode(e.mode)[0];
+    }
+    return out;
+  }
+  ChildTable2.encode = encode;
+})(ChildTable || (ChildTable = {}));
+export {
+  ChildTable
+};
+//# sourceMappingURL=ChildTable.js.map

package/dist/esm/tlv/diag/ChildTable.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/tlv/diag/ChildTable.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAS,qBAAqB;AAC9B,SAAS,uBAAuB;AAChC,SAAS,YAAY;AAqBrB,MAAM,cAAc;AACpB,MAAM,eAAe;AACrB,MAAM,gBAAgB;AACtB,MAAM,WAAW;AACjB,MAAM,YAAY;AAClB,MAAM,gBAAgB;AACtB,MAAM,kBAAkB;AACxB,MAAM,kBAAkB;AAExB,SAAS,gBAAgB,KAAqB;AAC1C,MAAI,MAAM,gBAAiB,QAAO;AAClC,MAAI,MAAM,gBAAiB,QAAO;AAClC,SAAO;AACX;AAEA,SAAS,oBAAoB,KAAqB;AAC9C,SAAO,KAAM,gBAAgB,GAAG,IAAI;AACxC;AAEO,IAAU;AAAA,CAAV,CAAUA,gBAAV;AACI,WAAS,OAAO,OAAsC;AACzD,QAAI,MAAM,SAAS,gBAAgB,GAAG;AAClC,YAAM,IAAI,gBAAgB,yBAAyB,MAAM,MAAM,sBAAsB,WAAW,EAAE;AAAA,IACtG;AACA,UAAM,UAAU,IAAI,MAAuB;AAC3C,aAAS,SAAS,GAAG,SAAS,MAAM,QAAQ,UAAU,aAAa;AAC/D,YAAM,OAAQ,MAAM,MAAM,KAAK,IAAK,MAAM,SAAS,CAAC;AACpD,YAAM,mBAAmB,OAAO,iBAAiB;AACjD,cAAQ,KAAK;AAAA,QACT;AAAA,QACA,gBAAgB,oBAAoB,eAAe;AAAA,QACnD,sBAAsB,OAAO,aAAa;AAAA,QAC1C,SAAS,OAAO;AAAA,QAChB,MAAM,KAAK,OAAO,MAAM,SAAS,SAAS,GAAG,SAAS,CAAC,CAAC;AAAA,MAC5D,CAAC;AAAA,IACL;AACA,WAAO;AAAA,EACX;AAjBO,EAAAA,YAAS;AAmBT,WAAS,OAAO,SAAqD;AACxE,UAAM,MAAM,IAAI,WAAW,QAAQ,SAAS,WAAW;AACvD,aAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACrC,YAAM,IAAI,QAAQ,CAAC;AACnB,UAAI,EAAE,kBAAkB,KAAK,EAAE,kBAAkB,iBAAiB;AAC9D,cAAM,IAAI,cAAc,4CAA4C,EAAE,eAAe,EAAE;AAAA,MAC3F;AACA,UAAI,EAAE,sBAAsB,KAAK,EAAE,sBAAsB,GAAG;AACxD,cAAM,IAAI,cAAc,gDAAgD,EAAE,mBAAmB,EAAE;AAAA,MACnG;AACA,UAAI,EAAE,UAAU,KAAK,EAAE,UAAU,KAAO;AACpC,cAAM,IAAI,cAAc,oCAAoC,EAAE,OAAO,EAAE;AAAA,MAC3E;AACA,YAAM,OACA,EAAE,mBAAmB,gBAAiB,eACtC,EAAE,uBAAuB,YAAa,WACvC,EAAE,UAAU;AACjB,UAAI,IAAI,WAAW,IAAK,QAAQ,IAAK;AACrC,UAAI,IAAI,cAAc,CAAC,IAAI,OAAO;AAClC,UAAI,IAAI,cAAc,CAAC,IAAI,KAAK,OAAO,EAAE,IAAI,EAAE,CAAC;AAAA,IACpD;AACA,WAAO;AAAA,EACX;AAtBO,EAAAA,YAAS;AAAA,GApBH;",
+  "names": ["ChildTable"]
+}

package/dist/esm/tlv/diag/Connectivity.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Decoded Connectivity TLV (Network Diagnostic TLV type 4).
+ *
+ * Layout per OpenThread `mle_tlvs.hpp` `ConnectivityTlvValue` and
+ * `mle_tlvs.cpp` `ConnectivityTlvValue::ParseFrom`:
+ *
+ *   [0]     flags        bits 7..6 = parent priority (signed 2-bit), 5..0 reserved
+ *   [1]     linkQuality3 number of neighbors with link quality 3
+ *   [2]     linkQuality2 number of neighbors with link quality 2
+ *   [3]     linkQuality1 number of neighbors with link quality 1
+ *   [4]     leaderCost
+ *   [5]     idSequence
+ *   [6]     activeRouters
+ *   [7..8]  sedBufferSize     uint16 BE   (optional)
+ *   [9]     sedDatagramCount  uint8       (optional)
+ *
+ * The trailing 3 bytes are optional and are included as a pair-and-byte; if
+ * absent the spec defaults are 1280 / 1.
+ *
+ * Parent priority encoding (`Preference::From2BitUint`):
+ *   0b01 (1) = high (+1), 0b00 (0) = medium (0),
+ *   0b11 (3) = low (-1),  0b10 (2) = reserved-high mapped to medium per RFC-4191.
+ */
+export type ParentPriority = -1 | 0 | 1;
+export interface Connectivity {
+    parentPriority: ParentPriority;
+    linkQuality3: number;
+    linkQuality2: number;
+    linkQuality1: number;
+    leaderCost: number;
+    idSequence: number;
+    activeRouters: number;
+    sedBufferSize: number;
+    sedDatagramCount: number;
+}
+export declare namespace Connectivity {
+    function decode(value: Uint8Array): Connectivity;
+    function encode(c: Connectivity): Uint8Array;
+}
+//# sourceMappingURL=Connectivity.d.ts.map

package/dist/esm/tlv/diag/Connectivity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Connectivity.d.ts","sourceRoot":"","sources":["../../../../src/tlv/diag/Connectivity.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAExC,MAAM,WAAW,YAAY;IACzB,cAAc,EAAE,cAAc,CAAC;IAC/B,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,MAAM,CAAC;CAC5B;AA+BD,yBAAiB,YAAY,CAAC,CAAC;IAC3B,SAAgB,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,YAAY,CAuBtD;IAED,SAAgB,MAAM,CAAC,CAAC,EAAE,YAAY,GAAG,UAAU,CAalD;CACJ"}

package/dist/esm/tlv/diag/Connectivity.js

@@ -0,0 +1,79 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ThreadDiagError } from "../../diagnostic/errors.js";
+const FLAGS_PARENT_PRIORITY_MASK = 192;
+const FLAGS_PARENT_PRIORITY_SHIFT = 6;
+const MIN_SIZE = 7;
+const FULL_SIZE = 10;
+const DEFAULT_SED_BUFFER_SIZE = 1280;
+const DEFAULT_SED_DATAGRAM_COUNT = 1;
+function parentPriorityFrom2Bit(raw) {
+  switch (raw & 3) {
+    case 1:
+      return 1;
+    case 3:
+      return -1;
+    default:
+      return 0;
+  }
+}
+function parentPriorityTo2Bit(prio) {
+  switch (prio) {
+    case 1:
+      return 1;
+    case -1:
+      return 3;
+    default:
+      return 0;
+  }
+}
+var Connectivity;
+((Connectivity2) => {
+  function decode(value) {
+    if (value.length !== MIN_SIZE && value.length !== FULL_SIZE) {
+      throw new ThreadDiagError(
+        `Connectivity TLV must be ${MIN_SIZE} or ${FULL_SIZE} bytes, got ${value.length}`
+      );
+    }
+    const priorityBits = (value[0] & FLAGS_PARENT_PRIORITY_MASK) >> FLAGS_PARENT_PRIORITY_SHIFT;
+    const partial = {
+      parentPriority: parentPriorityFrom2Bit(priorityBits),
+      linkQuality3: value[1],
+      linkQuality2: value[2],
+      linkQuality1: value[3],
+      leaderCost: value[4],
+      idSequence: value[5],
+      activeRouters: value[6],
+      sedBufferSize: DEFAULT_SED_BUFFER_SIZE,
+      sedDatagramCount: DEFAULT_SED_DATAGRAM_COUNT
+    };
+    if (value.length === FULL_SIZE) {
+      partial.sedBufferSize = value[7] << 8 | value[8];
+      partial.sedDatagramCount = value[9];
+    }
+    return partial;
+  }
+  Connectivity2.decode = decode;
+  function encode(c) {
+    const out = new Uint8Array(FULL_SIZE);
+    out[0] = parentPriorityTo2Bit(c.parentPriority) << FLAGS_PARENT_PRIORITY_SHIFT & FLAGS_PARENT_PRIORITY_MASK;
+    out[1] = c.linkQuality3 & 255;
+    out[2] = c.linkQuality2 & 255;
+    out[3] = c.linkQuality1 & 255;
+    out[4] = c.leaderCost & 255;
+    out[5] = c.idSequence & 255;
+    out[6] = c.activeRouters & 255;
+    out[7] = c.sedBufferSize >>> 8 & 255;
+    out[8] = c.sedBufferSize & 255;
+    out[9] = c.sedDatagramCount & 255;
+    return out;
+  }
+  Connectivity2.encode = encode;
+})(Connectivity || (Connectivity = {}));
+export {
+  Connectivity
+};
+//# sourceMappingURL=Connectivity.js.map

package/dist/esm/tlv/diag/Connectivity.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/tlv/diag/Connectivity.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAS,uBAAuB;AAuChC,MAAM,6BAA6B;AACnC,MAAM,8BAA8B;AACpC,MAAM,WAAW;AACjB,MAAM,YAAY;AAClB,MAAM,0BAA0B;AAChC,MAAM,6BAA6B;AAEnC,SAAS,uBAAuB,KAA6B;AACzD,UAAQ,MAAM,GAAK;AAAA,IACf,KAAK;AACD,aAAO;AAAA,IACX,KAAK;AACD,aAAO;AAAA,IACX;AACI,aAAO;AAAA,EACf;AACJ;AAEA,SAAS,qBAAqB,MAA8B;AACxD,UAAQ,MAAM;AAAA,IACV,KAAK;AACD,aAAO;AAAA,IACX,KAAK;AACD,aAAO;AAAA,IACX;AACI,aAAO;AAAA,EACf;AACJ;AAEO,IAAU;AAAA,CAAV,CAAUA,kBAAV;AACI,WAAS,OAAO,OAAiC;AACpD,QAAI,MAAM,WAAW,YAAY,MAAM,WAAW,WAAW;AACzD,YAAM,IAAI;AAAA,QACN,4BAA4B,QAAQ,OAAO,SAAS,eAAe,MAAM,MAAM;AAAA,MACnF;AAAA,IACJ;AACA,UAAM,gBAAgB,MAAM,CAAC,IAAI,+BAA+B;AAChE,UAAM,UAAwB;AAAA,MAC1B,gBAAgB,uBAAuB,YAAY;AAAA,MACnD,cAAc,MAAM,CAAC;AAAA,MACrB,cAAc,MAAM,CAAC;AAAA,MACrB,cAAc,MAAM,CAAC;AAAA,MACrB,YAAY,MAAM,CAAC;AAAA,MACnB,YAAY,MAAM,CAAC;AAAA,MACnB,eAAe,MAAM,CAAC;AAAA,MACtB,eAAe;AAAA,MACf,kBAAkB;AAAA,IACtB;AACA,QAAI,MAAM,WAAW,WAAW;AAC5B,cAAQ,gBAAiB,MAAM,CAAC,KAAK,IAAK,MAAM,CAAC;AACjD,cAAQ,mBAAmB,MAAM,CAAC;AAAA,IACtC;AACA,WAAO;AAAA,EACX;AAvBO,EAAAA,cAAS;AAyBT,WAAS,OAAO,GAA6B;AAChD,UAAM,MAAM,IAAI,WAAW,SAAS;AACpC,QAAI,CAAC,IAAK,qBAAqB,EAAE,cAAc,KAAK,8BAA+B;AACnF,QAAI,CAAC,IAAI,EAAE,eAAe;AAC1B,QAAI,CAAC,IAAI,EAAE,eAAe;AAC1B,QAAI,CAAC,IAAI,EAAE,eAAe;AAC1B,QAAI,CAAC,IAAI,EAAE,aAAa;AACxB,QAAI,CAAC,IAAI,EAAE,aAAa;AACxB,QAAI,CAAC,IAAI,EAAE,gBAAgB;AAC3B,QAAI,CAAC,IAAK,EAAE,kBAAkB,IAAK;AACnC,QAAI,CAAC,IAAI,EAAE,gBAAgB;AAC3B,QAAI,CAAC,IAAI,EAAE,mBAAmB;AAC9B,WAAO;AAAA,EACX;AAbO,EAAAA,cAAS;AAAA,GA1BH;",
+  "names": ["Connectivity"]
+}

package/dist/esm/tlv/diag/Ipv6AddressList.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Decoded IPv6 Address List TLV (Network Diagnostic TLV type 8).
+ *
+ * Concatenation of zero or more 16-byte IPv6 addresses, in interface-list
+ * order. Source: OpenThread `network_diagnostic.cpp` `Server::AppendIp6AddressList`
+ * and `Client::ParseIp6AddrList`.
+ *
+ * Each entry is the 16-byte network-order address; rendering to text form
+ * is the responsibility of higher layers.
+ */
+export declare const IPV6_ADDRESS_BYTES = 16;
+export declare namespace Ipv6AddressList {
+    function decode(value: Uint8Array): Uint8Array[];
+    function encode(addresses: ReadonlyArray<Uint8Array>): Uint8Array;
+}
+//# sourceMappingURL=Ipv6AddressList.d.ts.map

package/dist/esm/tlv/diag/Ipv6AddressList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Ipv6AddressList.d.ts","sourceRoot":"","sources":["../../../../src/tlv/diag/Ipv6AddressList.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,KAAK,CAAC;AAErC,yBAAiB,eAAe,CAAC,CAAC;IAC9B,SAAgB,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,EAAE,CAWtD;IAED,SAAgB,MAAM,CAAC,SAAS,EAAE,aAAa,CAAC,UAAU,CAAC,GAAG,UAAU,CAUvE;CACJ"}

package/dist/esm/tlv/diag/Ipv6AddressList.js

@@ -0,0 +1,41 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { InternalError } from "@matter/general";
+import { ThreadDiagError } from "../../diagnostic/errors.js";
+const IPV6_ADDRESS_BYTES = 16;
+var Ipv6AddressList;
+((Ipv6AddressList2) => {
+  function decode(value) {
+    if (value.length % IPV6_ADDRESS_BYTES !== 0) {
+      throw new ThreadDiagError(
+        `IPv6 address list TLV length ${value.length} not a multiple of ${IPV6_ADDRESS_BYTES}`
+      );
+    }
+    const out = new Array();
+    for (let offset = 0; offset < value.length; offset += IPV6_ADDRESS_BYTES) {
+      out.push(value.slice(offset, offset + IPV6_ADDRESS_BYTES));
+    }
+    return out;
+  }
+  Ipv6AddressList2.decode = decode;
+  function encode(addresses) {
+    const out = new Uint8Array(addresses.length * IPV6_ADDRESS_BYTES);
+    for (let i = 0; i < addresses.length; i++) {
+      const addr = addresses[i];
+      if (addr.length !== IPV6_ADDRESS_BYTES) {
+        throw new InternalError(`IPv6 address must be ${IPV6_ADDRESS_BYTES} bytes, got ${addr.length}`);
+      }
+      out.set(addr, i * IPV6_ADDRESS_BYTES);
+    }
+    return out;
+  }
+  Ipv6AddressList2.encode = encode;
+})(Ipv6AddressList || (Ipv6AddressList = {}));
+export {
+  IPV6_ADDRESS_BYTES,
+  Ipv6AddressList
+};
+//# sourceMappingURL=Ipv6AddressList.js.map

package/dist/esm/tlv/diag/Ipv6AddressList.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/tlv/diag/Ipv6AddressList.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAS,qBAAqB;AAC9B,SAAS,uBAAuB;AAYzB,MAAM,qBAAqB;AAE3B,IAAU;AAAA,CAAV,CAAUA,qBAAV;AACI,WAAS,OAAO,OAAiC;AACpD,QAAI,MAAM,SAAS,uBAAuB,GAAG;AACzC,YAAM,IAAI;AAAA,QACN,gCAAgC,MAAM,MAAM,sBAAsB,kBAAkB;AAAA,MACxF;AAAA,IACJ;AACA,UAAM,MAAM,IAAI,MAAkB;AAClC,aAAS,SAAS,GAAG,SAAS,MAAM,QAAQ,UAAU,oBAAoB;AACtE,UAAI,KAAK,MAAM,MAAM,QAAQ,SAAS,kBAAkB,CAAC;AAAA,IAC7D;AACA,WAAO;AAAA,EACX;AAXO,EAAAA,iBAAS;AAaT,WAAS,OAAO,WAAkD;AACrE,UAAM,MAAM,IAAI,WAAW,UAAU,SAAS,kBAAkB;AAChE,aAAS,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;AACvC,YAAM,OAAO,UAAU,CAAC;AACxB,UAAI,KAAK,WAAW,oBAAoB;AACpC,cAAM,IAAI,cAAc,wBAAwB,kBAAkB,eAAe,KAAK,MAAM,EAAE;AAAA,MAClG;AACA,UAAI,IAAI,MAAM,IAAI,kBAAkB;AAAA,IACxC;AACA,WAAO;AAAA,EACX;AAVO,EAAAA,iBAAS;AAAA,GAdH;",
+  "names": ["Ipv6AddressList"]
+}

package/dist/esm/tlv/diag/LeaderData.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Decoded Leader Data TLV (Network Diagnostic TLV type 6).
+ *
+ * Layout per OpenThread `mle_tlvs.hpp` `LeaderDataTlvValue`:
+ *
+ *   [0..3]  uint32 BE  partition ID
+ *   [4]     uint8      weighting
+ *   [5]     uint8      data version
+ *   [6]     uint8      stable data version
+ *   [7]     uint8      leader router ID
+ */
+export interface LeaderData {
+    partitionId: number;
+    weighting: number;
+    dataVersion: number;
+    stableDataVersion: number;
+    leaderRouterId: number;
+}
+export declare namespace LeaderData {
+    function decode(value: Uint8Array): LeaderData;
+    function encode(data: LeaderData): Uint8Array;
+}
+//# sourceMappingURL=LeaderData.d.ts.map

package/dist/esm/tlv/diag/LeaderData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LeaderData.d.ts","sourceRoot":"","sources":["../../../../src/tlv/diag/LeaderData.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH;;;;;;;;;;GAUG;AACH,MAAM,WAAW,UAAU;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,cAAc,EAAE,MAAM,CAAC;CAC1B;AAED,yBAAiB,UAAU,CAAC,CAAC;IACzB,SAAgB,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,CAYpD;IAED,SAAgB,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAcnD;CACJ"}