@matter/thread-br-client 0.0.1

package/dist/cjs/selection/withExtPanIdLock.js

@@ -0,0 +1,50 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var withExtPanIdLock_exports = {};
+__export(withExtPanIdLock_exports, {
+  ExtPanIdLockManager: () => ExtPanIdLockManager
+});
+module.exports = __toCommonJS(withExtPanIdLock_exports);
+var import_general = require("@matter/general");
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class ExtPanIdLockManager {
+  #queues = /* @__PURE__ */ new Map();
+  /**
+   * Run `fn` with mutual exclusion against any other invocation for the same `extPanId`.
+   * Errors thrown by `fn` propagate to the caller but never poison the queue —
+   * the next caller for the same key still runs.
+   */
+  withLock(extPanId, fn) {
+    const key = import_general.Bytes.toHex(extPanId);
+    const previous = this.#queues.get(key) ?? Promise.resolve();
+    const result = previous.then(() => fn());
+    const chained = result.catch(() => void 0).finally(() => {
+      if (this.#queues.get(key) === chained) {
+        this.#queues.delete(key);
+      }
+    });
+    this.#queues.set(key, chained);
+    return result;
+  }
+}
+//# sourceMappingURL=withExtPanIdLock.js.map

package/dist/cjs/selection/withExtPanIdLock.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/selection/withExtPanIdLock.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,qBAAsB;AANtB;AAAA;AAAA;AAAA;AAAA;AAgBO,MAAM,oBAAoB;AAAA,EACpB,UAAU,oBAAI,IAA8B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOrD,SAAY,UAAsB,IAAkC;AAChE,UAAM,MAAM,qBAAM,MAAM,QAAQ;AAChC,UAAM,WAAW,KAAK,QAAQ,IAAI,GAAG,KAAK,QAAQ,QAAQ;AAC1D,UAAM,SAAS,SAAS,KAAK,MAAM,GAAG,CAAC;AACvC,UAAM,UAA4B,OAC7B,MAAM,MAAM,MAAS,EACrB,QAAQ,MAAM;AAEX,UAAI,KAAK,QAAQ,IAAI,GAAG,MAAM,SAAS;AACnC,aAAK,QAAQ,OAAO,GAAG;AAAA,MAC3B;AAAA,IACJ,CAAC;AACL,SAAK,QAAQ,IAAI,KAAK,OAAO;AAC7B,WAAO;AAAA,EACX;AACJ;",
+  "names": []
+}

package/dist/cjs/tlv/BasicTlvCodec.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { MatterError } from "@matter/general";
+/** Low-level MeshCoP/base TLV codec parse failure (truncated stream, bad length, ...). */
+export declare class ThreadTlvError extends MatterError {
+}
+/**
+ * MeshCoP TLV stream (Thread spec §8.10) is a sequence of [type:1][length:1][value:length] frames.
+ * Length 0xFF escapes to a 2-byte big-endian extended length following the type byte.
+ */
+export interface BasicTlvEntry {
+    type: number;
+    value: Uint8Array;
+}
+export declare namespace BasicTlv {
+    function walk(blob: Uint8Array): BasicTlvEntry[];
+    function encode(entries: ReadonlyArray<BasicTlvEntry>): Uint8Array;
+}
+//# sourceMappingURL=BasicTlvCodec.d.ts.map

package/dist/cjs/tlv/BasicTlvCodec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BasicTlvCodec.d.ts","sourceRoot":"","sources":["../../../src/tlv/BasicTlvCodec.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAiB,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAE7D,0FAA0F;AAC1F,qBAAa,cAAe,SAAQ,WAAW;CAAG;AAElD;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,UAAU,CAAC;CACrB;AAED,yBAAiB,QAAQ,CAAC,CAAC;IACvB,SAAgB,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,aAAa,EAAE,CA6BtD;IAED,SAAgB,MAAM,CAAC,OAAO,EAAE,aAAa,CAAC,aAAa,CAAC,GAAG,UAAU,CA6BxE;CACJ"}

package/dist/cjs/tlv/BasicTlvCodec.js

@@ -0,0 +1,97 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var BasicTlvCodec_exports = {};
+__export(BasicTlvCodec_exports, {
+  BasicTlv: () => BasicTlv,
+  ThreadTlvError: () => ThreadTlvError
+});
+module.exports = __toCommonJS(BasicTlvCodec_exports);
+var import_general = require("@matter/general");
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class ThreadTlvError extends import_general.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 import_general.InternalError(`Invalid TLV type ${entry.type}: must be 0..255`);
+      }
+      const valueLen = entry.value.length;
+      if (valueLen > 65535) {
+        throw new import_general.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 = {}));
+//# sourceMappingURL=BasicTlvCodec.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/tlv/BasicTlvCodec.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,qBAA2C;AAN3C;AAAA;AAAA;AAAA;AAAA;AASO,MAAM,uBAAuB,2BAAY;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,6BAAc,oBAAoB,MAAM,IAAI,kBAAkB;AAAA,MAC5E;AACA,YAAM,WAAW,MAAM,MAAM;AAC7B,UAAI,WAAW,OAAQ;AACnB,cAAM,IAAI,6BAAc,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/cjs/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/cjs/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/cjs/tlv/NetworkDiagnosticTlv.js

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var NetworkDiagnosticTlv_exports = {};
+__export(NetworkDiagnosticTlv_exports, {
+  NetworkDiagnosticTlv: () => NetworkDiagnosticTlv
+});
+module.exports = __toCommonJS(NetworkDiagnosticTlv_exports);
+var import_BasicTlvCodec = require("./BasicTlvCodec.js");
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var NetworkDiagnosticTlv;
+((NetworkDiagnosticTlv2) => {
+  function decode(blob) {
+    return import_BasicTlvCodec.BasicTlv.walk(blob);
+  }
+  NetworkDiagnosticTlv2.decode = decode;
+  function encode(entries) {
+    return import_BasicTlvCodec.BasicTlv.encode(entries);
+  }
+  NetworkDiagnosticTlv2.encode = encode;
+})(NetworkDiagnosticTlv || (NetworkDiagnosticTlv = {}));
+//# sourceMappingURL=NetworkDiagnosticTlv.js.map

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

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

package/dist/cjs/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/cjs/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/cjs/tlv/TypeListTlv.js

@@ -0,0 +1,49 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var TypeListTlv_exports = {};
+__export(TypeListTlv_exports, {
+  TypeListTlv: () => TypeListTlv
+});
+module.exports = __toCommonJS(TypeListTlv_exports);
+var import_general = require("@matter/general");
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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 import_general.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 = {}));
+//# sourceMappingURL=TypeListTlv.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/tlv/TypeListTlv.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,qBAA8B;AAN9B;AAAA;AAAA;AAAA;AAAA;AAqBO,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,6BAAc,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/cjs/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/cjs/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/cjs/tlv/diag/ChildIpv6AddressList.js

@@ -0,0 +1,48 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ChildIpv6AddressList_exports = {};
+__export(ChildIpv6AddressList_exports, {
+  ChildIpv6AddressList: () => ChildIpv6AddressList
+});
+module.exports = __toCommonJS(ChildIpv6AddressList_exports);
+/**
+ * @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 = {}));
+//# sourceMappingURL=ChildIpv6AddressList.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/tlv/diag/ChildIpv6AddressList.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;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/cjs/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/cjs/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/cjs/tlv/diag/ChildTable.js

@@ -0,0 +1,91 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ChildTable_exports = {};
+__export(ChildTable_exports, {
+  ChildTable: () => ChildTable
+});
+module.exports = __toCommonJS(ChildTable_exports);
+var import_general = require("@matter/general");
+var import_errors = require("../../diagnostic/errors.js");
+var import_Mode = require("./Mode.js");
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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 import_errors.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: import_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 import_general.InternalError(`ChildTable timeoutExponent out of range: ${e.timeoutExponent}`);
+      }
+      if (e.incomingLinkQuality < 0 || e.incomingLinkQuality > 3) {
+        throw new import_general.InternalError(`ChildTable incomingLinkQuality out of range: ${e.incomingLinkQuality}`);
+      }
+      if (e.childId < 0 || e.childId > 511) {
+        throw new import_general.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] = import_Mode.Mode.encode(e.mode)[0];
+    }
+    return out;
+  }
+  ChildTable2.encode = encode;
+})(ChildTable || (ChildTable = {}));
+//# sourceMappingURL=ChildTable.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/tlv/diag/ChildTable.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,qBAA8B;AAC9B,oBAAgC;AAChC,kBAAqB;AARrB;AAAA;AAAA;AAAA;AAAA;AA6BA,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,8BAAgB,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,iBAAK,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,6BAAc,4CAA4C,EAAE,eAAe,EAAE;AAAA,MAC3F;AACA,UAAI,EAAE,sBAAsB,KAAK,EAAE,sBAAsB,GAAG;AACxD,cAAM,IAAI,6BAAc,gDAAgD,EAAE,mBAAmB,EAAE;AAAA,MACnG;AACA,UAAI,EAAE,UAAU,KAAK,EAAE,UAAU,KAAO;AACpC,cAAM,IAAI,6BAAc,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,iBAAK,OAAO,EAAE,IAAI,EAAE,CAAC;AAAA,IACpD;AACA,WAAO;AAAA,EACX;AAtBO,EAAAA,YAAS;AAAA,GApBH;",
+  "names": ["ChildTable"]
+}

package/dist/cjs/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/cjs/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"}