@matter/thread-br-client 0.0.1

package/src/tlv/diag/ChildIpv6AddressList.ts

@@ -0,0 +1,41 @@
+/**
+ * @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[];
+}
+
+const RLOC16_BYTES = 2;
+const IPV6_ADDRESS_BYTES = 16;
+
+export namespace ChildIpv6AddressList {
+    export function decode(value: Uint8Array): ChildIpv6Addresses {
+        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<Uint8Array>();
+        for (let i = 0; i < addressCount; i++) {
+            addresses.push(addressPayload.slice(i * IPV6_ADDRESS_BYTES, (i + 1) * IPV6_ADDRESS_BYTES));
+        }
+
+        return { rloc16, addresses };
+    }
+}

package/src/tlv/diag/ChildTable.ts

@@ -0,0 +1,92 @@
+/**
+ * @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";
+
+/**
+ * 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;
+}
+
+const ENTRY_BYTES = 3;
+const TIMEOUT_MASK = 0xf800;
+const TIMEOUT_SHIFT = 11;
+const ILQ_MASK = 0x0600;
+const ILQ_SHIFT = 9;
+const CHILD_ID_MASK = 0x01ff;
+const TIMEOUT_EXP_MIN = 4;
+const TIMEOUT_EXP_MAX = 0x1f;
+
+function clampedExponent(exp: number): number {
+    if (exp < TIMEOUT_EXP_MIN) return TIMEOUT_EXP_MIN;
+    if (exp > TIMEOUT_EXP_MAX) return TIMEOUT_EXP_MAX;
+    return exp;
+}
+
+function timeoutFromExponent(exp: number): number {
+    return 1 << (clampedExponent(exp) - TIMEOUT_EXP_MIN);
+}
+
+export namespace ChildTable {
+    export function decode(value: Uint8Array): ChildTableEntry[] {
+        if (value.length % ENTRY_BYTES !== 0) {
+            throw new ThreadDiagError(`ChildTable TLV length ${value.length} not a multiple of ${ENTRY_BYTES}`);
+        }
+        const entries = new Array<ChildTableEntry>();
+        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;
+    }
+
+    export function encode(entries: ReadonlyArray<ChildTableEntry>): Uint8Array {
+        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 > 0x1ff) {
+                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) & 0xff;
+            out[i * ENTRY_BYTES + 1] = word & 0xff;
+            out[i * ENTRY_BYTES + 2] = Mode.encode(e.mode)[0];
+        }
+        return out;
+    }
+}

package/src/tlv/diag/Connectivity.ts

@@ -0,0 +1,115 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { ThreadDiagError } from "../../diagnostic/errors.js";
+
+/**
+ * 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;
+}
+
+const FLAGS_PARENT_PRIORITY_MASK = 0xc0;
+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: number): ParentPriority {
+    switch (raw & 0x3) {
+        case 0b01:
+            return 1;
+        case 0b11:
+            return -1;
+        default:
+            return 0;
+    }
+}
+
+function parentPriorityTo2Bit(prio: ParentPriority): number {
+    switch (prio) {
+        case 1:
+            return 0b01;
+        case -1:
+            return 0b11;
+        default:
+            return 0b00;
+    }
+}
+
+export namespace Connectivity {
+    export function decode(value: Uint8Array): Connectivity {
+        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: Connectivity = {
+            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;
+    }
+
+    export function encode(c: Connectivity): Uint8Array {
+        const out = new Uint8Array(FULL_SIZE);
+        out[0] = (parentPriorityTo2Bit(c.parentPriority) << FLAGS_PARENT_PRIORITY_SHIFT) & FLAGS_PARENT_PRIORITY_MASK;
+        out[1] = c.linkQuality3 & 0xff;
+        out[2] = c.linkQuality2 & 0xff;
+        out[3] = c.linkQuality1 & 0xff;
+        out[4] = c.leaderCost & 0xff;
+        out[5] = c.idSequence & 0xff;
+        out[6] = c.activeRouters & 0xff;
+        out[7] = (c.sedBufferSize >>> 8) & 0xff;
+        out[8] = c.sedBufferSize & 0xff;
+        out[9] = c.sedDatagramCount & 0xff;
+        return out;
+    }
+}

package/src/tlv/diag/Ipv6AddressList.ts

@@ -0,0 +1,47 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { InternalError } from "@matter/general";
+import { ThreadDiagError } from "../../diagnostic/errors.js";
+
+/**
+ * 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 const IPV6_ADDRESS_BYTES = 16;
+
+export namespace Ipv6AddressList {
+    export function decode(value: Uint8Array): Uint8Array[] {
+        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<Uint8Array>();
+        for (let offset = 0; offset < value.length; offset += IPV6_ADDRESS_BYTES) {
+            out.push(value.slice(offset, offset + IPV6_ADDRESS_BYTES));
+        }
+        return out;
+    }
+
+    export function encode(addresses: ReadonlyArray<Uint8Array>): Uint8Array {
+        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;
+    }
+}

package/src/tlv/diag/LeaderData.ts

@@ -0,0 +1,59 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { InternalError } from "@matter/general";
+import { ThreadDiagError } from "../../diagnostic/errors.js";
+
+/**
+ * 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 namespace LeaderData {
+    export function decode(value: Uint8Array): LeaderData {
+        if (value.length !== 8) {
+            throw new ThreadDiagError(`LeaderData TLV must be 8 bytes, got ${value.length}`);
+        }
+        const partitionId = ((value[0] << 24) | (value[1] << 16) | (value[2] << 8) | value[3]) >>> 0;
+        return {
+            partitionId,
+            weighting: value[4],
+            dataVersion: value[5],
+            stableDataVersion: value[6],
+            leaderRouterId: value[7],
+        };
+    }
+
+    export function encode(data: LeaderData): Uint8Array {
+        if (data.partitionId < 0 || data.partitionId > 0xffffffff) {
+            throw new InternalError(`LeaderData partitionId out of range: ${data.partitionId}`);
+        }
+        const out = new Uint8Array(8);
+        out[0] = (data.partitionId >>> 24) & 0xff;
+        out[1] = (data.partitionId >>> 16) & 0xff;
+        out[2] = (data.partitionId >>> 8) & 0xff;
+        out[3] = data.partitionId & 0xff;
+        out[4] = data.weighting & 0xff;
+        out[5] = data.dataVersion & 0xff;
+        out[6] = data.stableDataVersion & 0xff;
+        out[7] = data.leaderRouterId & 0xff;
+        return out;
+    }
+}

package/src/tlv/diag/MacCounters.ts

@@ -0,0 +1,84 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { InternalError } from "@matter/general";
+import { ThreadDiagError } from "../../diagnostic/errors.js";
+
+/**
+ * Decoded MAC Counters TLV (Network Diagnostic TLV type 9).
+ *
+ * Field layout per OpenThread `MacCountersTlv` (`network_diagnostic_tlvs.hpp`)
+ * — nine consecutive big-endian uint32 fields, total 36 bytes. Field names
+ * mirror the SNMP-style RFC 2233 names used by OpenThread.
+ */
+export interface MacCounters {
+    ifInUnknownProtos: number;
+    ifInErrors: number;
+    ifOutErrors: number;
+    ifInUcastPkts: number;
+    ifInBroadcastPkts: number;
+    ifInDiscards: number;
+    ifOutUcastPkts: number;
+    ifOutBroadcastPkts: number;
+    ifOutDiscards: number;
+}
+
+const FIELD_COUNT = 9;
+const TOTAL_BYTES = FIELD_COUNT * 4;
+
+const FIELD_ORDER: ReadonlyArray<keyof MacCounters> = [
+    "ifInUnknownProtos",
+    "ifInErrors",
+    "ifOutErrors",
+    "ifInUcastPkts",
+    "ifInBroadcastPkts",
+    "ifInDiscards",
+    "ifOutUcastPkts",
+    "ifOutBroadcastPkts",
+    "ifOutDiscards",
+];
+
+function readU32BE(bytes: Uint8Array, offset: number): number {
+    return ((bytes[offset] << 24) | (bytes[offset + 1] << 16) | (bytes[offset + 2] << 8) | bytes[offset + 3]) >>> 0;
+}
+
+function writeU32BE(bytes: Uint8Array, offset: number, value: number): void {
+    bytes[offset] = (value >>> 24) & 0xff;
+    bytes[offset + 1] = (value >>> 16) & 0xff;
+    bytes[offset + 2] = (value >>> 8) & 0xff;
+    bytes[offset + 3] = value & 0xff;
+}
+
+export namespace MacCounters {
+    export function decode(value: Uint8Array): MacCounters {
+        if (value.length !== TOTAL_BYTES) {
+            throw new ThreadDiagError(`MacCounters TLV must be ${TOTAL_BYTES} bytes, got ${value.length}`);
+        }
+        return {
+            ifInUnknownProtos: readU32BE(value, 0),
+            ifInErrors: readU32BE(value, 4),
+            ifOutErrors: readU32BE(value, 8),
+            ifInUcastPkts: readU32BE(value, 12),
+            ifInBroadcastPkts: readU32BE(value, 16),
+            ifInDiscards: readU32BE(value, 20),
+            ifOutUcastPkts: readU32BE(value, 24),
+            ifOutBroadcastPkts: readU32BE(value, 28),
+            ifOutDiscards: readU32BE(value, 32),
+        };
+    }
+
+    export function encode(counters: MacCounters): Uint8Array {
+        const out = new Uint8Array(TOTAL_BYTES);
+        for (let i = 0; i < FIELD_ORDER.length; i++) {
+            const v = counters[FIELD_ORDER[i]];
+            if (!Number.isInteger(v) || v < 0 || v > 0xffffffff) {
+                throw new InternalError(`MacCounters.${FIELD_ORDER[i]} out of range: ${v}`);
+            }
+            writeU32BE(out, i * 4, v);
+        }
+        return out;
+    }
+}

package/src/tlv/diag/MleCounters.ts

@@ -0,0 +1,147 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { InternalError } from "@matter/general";
+import { ThreadDiagError } from "../../diagnostic/errors.js";
+
+/**
+ * Decoded MLE Counters TLV (Network Diagnostic TLV type 34).
+ *
+ * Field layout per OpenThread `MleCountersTlv`:
+ *
+ *   9 × uint16 BE  — role-entry counters and partition/parent change counters
+ *   6 × uint64 BE  — millisecond accumulators per role
+ *
+ * Total 66 bytes.
+ *
+ * The 64-bit time accumulators are exposed as JS `bigint` to keep the full
+ * range without precision loss (uptime in ms can exceed 2^53 over years of
+ * runtime).
+ */
+export interface MleCounters {
+    disabledRole: number;
+    detachedRole: number;
+    childRole: number;
+    routerRole: number;
+    leaderRole: number;
+    attachAttempts: number;
+    partitionIdChanges: number;
+    betterPartitionAttachAttempts: number;
+    parentChanges: number;
+    trackedTime: bigint;
+    disabledTime: bigint;
+    detachedTime: bigint;
+    childTime: bigint;
+    routerTime: bigint;
+    leaderTime: bigint;
+}
+
+type U16Key =
+    | "disabledRole"
+    | "detachedRole"
+    | "childRole"
+    | "routerRole"
+    | "leaderRole"
+    | "attachAttempts"
+    | "partitionIdChanges"
+    | "betterPartitionAttachAttempts"
+    | "parentChanges";
+
+type U64Key = "trackedTime" | "disabledTime" | "detachedTime" | "childTime" | "routerTime" | "leaderTime";
+
+const U16_FIELDS: ReadonlyArray<U16Key> = [
+    "disabledRole",
+    "detachedRole",
+    "childRole",
+    "routerRole",
+    "leaderRole",
+    "attachAttempts",
+    "partitionIdChanges",
+    "betterPartitionAttachAttempts",
+    "parentChanges",
+];
+
+const U64_FIELDS: ReadonlyArray<U64Key> = [
+    "trackedTime",
+    "disabledTime",
+    "detachedTime",
+    "childTime",
+    "routerTime",
+    "leaderTime",
+];
+
+const TOTAL_BYTES = U16_FIELDS.length * 2 + U64_FIELDS.length * 8;
+const U64_OFFSET = U16_FIELDS.length * 2;
+
+function readU16BE(bytes: Uint8Array, offset: number): number {
+    return (bytes[offset] << 8) | bytes[offset + 1];
+}
+
+function writeU16BE(bytes: Uint8Array, offset: number, value: number): void {
+    bytes[offset] = (value >> 8) & 0xff;
+    bytes[offset + 1] = value & 0xff;
+}
+
+function readU64BE(bytes: Uint8Array, offset: number): bigint {
+    let result = 0n;
+    for (let i = 0; i < 8; i++) {
+        result = (result << 8n) | BigInt(bytes[offset + i]);
+    }
+    return result;
+}
+
+function writeU64BE(bytes: Uint8Array, offset: number, value: bigint): void {
+    for (let i = 7; i >= 0; i--) {
+        bytes[offset + i] = Number(value & 0xffn);
+        value >>= 8n;
+    }
+}
+
+const U64_MAX = (1n << 64n) - 1n;
+
+export namespace MleCounters {
+    export function decode(value: Uint8Array): MleCounters {
+        if (value.length !== TOTAL_BYTES) {
+            throw new ThreadDiagError(`MleCounters TLV must be ${TOTAL_BYTES} bytes, got ${value.length}`);
+        }
+        return {
+            disabledRole: readU16BE(value, 0),
+            detachedRole: readU16BE(value, 2),
+            childRole: readU16BE(value, 4),
+            routerRole: readU16BE(value, 6),
+            leaderRole: readU16BE(value, 8),
+            attachAttempts: readU16BE(value, 10),
+            partitionIdChanges: readU16BE(value, 12),
+            betterPartitionAttachAttempts: readU16BE(value, 14),
+            parentChanges: readU16BE(value, 16),
+            trackedTime: readU64BE(value, 18),
+            disabledTime: readU64BE(value, 26),
+            detachedTime: readU64BE(value, 34),
+            childTime: readU64BE(value, 42),
+            routerTime: readU64BE(value, 50),
+            leaderTime: readU64BE(value, 58),
+        };
+    }
+
+    export function encode(counters: MleCounters): Uint8Array {
+        const out = new Uint8Array(TOTAL_BYTES);
+        for (let i = 0; i < U16_FIELDS.length; i++) {
+            const v = counters[U16_FIELDS[i]];
+            if (!Number.isInteger(v) || v < 0 || v > 0xffff) {
+                throw new InternalError(`MleCounters.${U16_FIELDS[i]} out of range: ${v}`);
+            }
+            writeU16BE(out, i * 2, v);
+        }
+        for (let i = 0; i < U64_FIELDS.length; i++) {
+            const v = counters[U64_FIELDS[i]];
+            if (typeof v !== "bigint" || v < 0n || v > U64_MAX) {
+                throw new InternalError(`MleCounters.${U64_FIELDS[i]} out of range: ${v}`);
+            }
+            writeU64BE(out, U64_OFFSET + i * 8, v);
+        }
+        return out;
+    }
+}

package/src/tlv/diag/Mode.ts

@@ -0,0 +1,52 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { ThreadDiagError } from "../../diagnostic/errors.js";
+
+/**
+ * Decoded MLE Mode TLV (Network Diagnostic TLV type 2).
+ *
+ * Single-byte bitmap. Layout per OpenThread `src/core/thread/mle_types.hpp`
+ * (`DeviceMode`):
+ *
+ *   bit 3: rx-on-when-idle (0 = sleepy, 1 = always-on)
+ *   bit 2: reserved (set on transmit, ignored on receive)
+ *   bit 1: full thread device (FTD = 1, MTD = 0)
+ *   bit 0: full network data (1 = full set, 0 = stable subset)
+ */
+export interface Mode {
+    rxOnWhenIdle: boolean;
+    fullThreadDevice: boolean;
+    fullNetworkData: boolean;
+}
+
+const FLAG_RX_ON_WHEN_IDLE = 1 << 3;
+const FLAG_RESERVED = 1 << 2;
+const FLAG_FULL_THREAD_DEVICE = 1 << 1;
+const FLAG_FULL_NETWORK_DATA = 1 << 0;
+
+export namespace Mode {
+    export function decode(value: Uint8Array): Mode {
+        if (value.length !== 1) {
+            throw new ThreadDiagError(`Mode TLV must be 1 byte, got ${value.length}`);
+        }
+        const raw = value[0];
+        return {
+            rxOnWhenIdle: (raw & FLAG_RX_ON_WHEN_IDLE) !== 0,
+            fullThreadDevice: (raw & FLAG_FULL_THREAD_DEVICE) !== 0,
+            fullNetworkData: (raw & FLAG_FULL_NETWORK_DATA) !== 0,
+        };
+    }
+
+    export function encode(mode: Mode): Uint8Array {
+        // The reserved bit must be set on transmit per Thread spec / OpenThread `DeviceMode::Set`.
+        let raw = FLAG_RESERVED;
+        if (mode.rxOnWhenIdle) raw |= FLAG_RX_ON_WHEN_IDLE;
+        if (mode.fullThreadDevice) raw |= FLAG_FULL_THREAD_DEVICE;
+        if (mode.fullNetworkData) raw |= FLAG_FULL_NETWORK_DATA;
+        return new Uint8Array([raw]);
+    }
+}