@matter/thread-br-client 0.0.1 → 0.17.5-alpha.0-20260706-fd4c49e2e

package/src/tlv/diag/Primitives.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { InternalError } from "@matter/general";
+import { Bytes, InternalError } from "@matter/general";
 import { ThreadDiagError } from "../../diagnostic/errors.js";
 
 /**
@@ -24,49 +24,52 @@ import { ThreadDiagError } from "../../diagnostic/errors.js";
  * `Client::GetNextDiagTlv` parser.
  */
 
-function eui64Decode(value: Uint8Array, name: string): Uint8Array {
-    if (value.length !== 8) {
-        throw new ThreadDiagError(`${name} TLV must be 8 bytes, got ${value.length}`);
+function eui64Decode(value: Bytes, name: string): Bytes {
+    const buf = Bytes.of(value);
+    if (buf.length !== 8) {
+        throw new ThreadDiagError(`${name} TLV must be 8 bytes, got ${buf.length}`);
     }
-    return value.slice();
+    return buf.slice();
 }
 
-function eui64Encode(addr: Uint8Array, name: string): Uint8Array {
-    if (addr.length !== 8) {
-        throw new InternalError(`${name} must be 8 bytes, got ${addr.length}`);
+function eui64Encode(addr: Bytes, name: string): Bytes {
+    const buf = Bytes.of(addr);
+    if (buf.length !== 8) {
+        throw new InternalError(`${name} must be 8 bytes, got ${buf.length}`);
     }
-    return addr.slice();
+    return buf.slice();
 }
 
 export namespace ExtMacAddress {
-    export function decode(value: Uint8Array): Uint8Array {
+    export function decode(value: Bytes): Bytes {
         return eui64Decode(value, "ExtMacAddress");
     }
 
-    export function encode(addr: Uint8Array): Uint8Array {
+    export function encode(addr: Bytes): Bytes {
         return eui64Encode(addr, "ExtMacAddress");
     }
 }
 
 export namespace Eui64 {
-    export function decode(value: Uint8Array): Uint8Array {
+    export function decode(value: Bytes): Bytes {
         return eui64Decode(value, "Eui64");
     }
 
-    export function encode(addr: Uint8Array): Uint8Array {
+    export function encode(addr: Bytes): Bytes {
         return eui64Encode(addr, "Eui64");
     }
 }
 
 export namespace Address16 {
-    export function decode(value: Uint8Array): number {
-        if (value.length !== 2) {
-            throw new ThreadDiagError(`Address16 TLV must be 2 bytes, got ${value.length}`);
+    export function decode(value: Bytes): number {
+        const buf = Bytes.of(value);
+        if (buf.length !== 2) {
+            throw new ThreadDiagError(`Address16 TLV must be 2 bytes, got ${buf.length}`);
         }
-        return (value[0] << 8) | value[1];
+        return (buf[0] << 8) | buf[1];
     }
 
-    export function encode(rloc16: number): Uint8Array {
+    export function encode(rloc16: number): Bytes {
         if (!Number.isInteger(rloc16) || rloc16 < 0 || rloc16 > 0xffff) {
             throw new InternalError(`Address16 out of range: ${rloc16}`);
         }
@@ -75,14 +78,15 @@ export namespace Address16 {
 }
 
 export namespace BatteryLevel {
-    export function decode(value: Uint8Array): number {
-        if (value.length !== 1) {
-            throw new ThreadDiagError(`BatteryLevel TLV must be 1 byte, got ${value.length}`);
+    export function decode(value: Bytes): number {
+        const buf = Bytes.of(value);
+        if (buf.length !== 1) {
+            throw new ThreadDiagError(`BatteryLevel TLV must be 1 byte, got ${buf.length}`);
         }
-        return value[0];
+        return buf[0];
     }
 
-    export function encode(percent: number): Uint8Array {
+    export function encode(percent: number): Bytes {
         if (!Number.isInteger(percent) || percent < 0 || percent > 0xff) {
             throw new InternalError(`BatteryLevel out of range: ${percent}`);
         }
@@ -91,14 +95,15 @@ export namespace BatteryLevel {
 }
 
 export namespace SupplyVoltage {
-    export function decode(value: Uint8Array): number {
-        if (value.length !== 2) {
-            throw new ThreadDiagError(`SupplyVoltage TLV must be 2 bytes, got ${value.length}`);
+    export function decode(value: Bytes): number {
+        const buf = Bytes.of(value);
+        if (buf.length !== 2) {
+            throw new ThreadDiagError(`SupplyVoltage TLV must be 2 bytes, got ${buf.length}`);
         }
-        return (value[0] << 8) | value[1];
+        return (buf[0] << 8) | buf[1];
     }
 
-    export function encode(millivolts: number): Uint8Array {
+    export function encode(millivolts: number): Bytes {
         if (!Number.isInteger(millivolts) || millivolts < 0 || millivolts > 0xffff) {
             throw new InternalError(`SupplyVoltage out of range: ${millivolts}`);
         }
@@ -107,14 +112,15 @@ export namespace SupplyVoltage {
 }
 
 export namespace MaxChildTimeout {
-    export function decode(value: Uint8Array): number {
-        if (value.length !== 4) {
-            throw new ThreadDiagError(`MaxChildTimeout TLV must be 4 bytes, got ${value.length}`);
+    export function decode(value: Bytes): number {
+        const buf = Bytes.of(value);
+        if (buf.length !== 4) {
+            throw new ThreadDiagError(`MaxChildTimeout TLV must be 4 bytes, got ${buf.length}`);
         }
-        return ((value[0] << 24) | (value[1] << 16) | (value[2] << 8) | value[3]) >>> 0;
+        return ((buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3]) >>> 0;
     }
 
-    export function encode(seconds: number): Uint8Array {
+    export function encode(seconds: number): Bytes {
         if (!Number.isInteger(seconds) || seconds < 0 || seconds > 0xffffffff) {
             throw new InternalError(`MaxChildTimeout out of range: ${seconds}`);
         }
@@ -128,11 +134,11 @@ export namespace MaxChildTimeout {
 }
 
 export namespace ChannelPages {
-    export function decode(value: Uint8Array): number[] {
-        return Array.from(value);
+    export function decode(value: Bytes): number[] {
+        return Array.from(Bytes.of(value));
     }
 
-    export function encode(pages: ReadonlyArray<number>): Uint8Array {
+    export function encode(pages: ReadonlyArray<number>): Bytes {
         const out = new Uint8Array(pages.length);
         for (let i = 0; i < pages.length; i++) {
             const p = pages[i];

package/src/tlv/diag/Route64.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { InternalError } from "@matter/general";
+import { Bytes, InternalError } from "@matter/general";
 import { ThreadDiagError } from "../../diagnostic/errors.js";
 
 /**
@@ -60,27 +60,28 @@ function setRouterIdBit(mask: Uint8Array, routerId: number): void {
 }
 
 export namespace Route64 {
-    export function decode(value: Uint8Array): Route64 {
-        if (value.length < HEADER_BYTES) {
-            throw new ThreadDiagError(`Route64 TLV too short: ${value.length} bytes (need >=${HEADER_BYTES})`);
+    export function decode(value: Bytes): Route64 {
+        const buf = Bytes.of(value);
+        if (buf.length < HEADER_BYTES) {
+            throw new ThreadDiagError(`Route64 TLV too short: ${buf.length} bytes (need >=${HEADER_BYTES})`);
         }
-        const idSequence = value[0];
-        const mask = value.subarray(1, HEADER_BYTES);
+        const idSequence = buf[0];
+        const mask = buf.subarray(1, HEADER_BYTES);
 
         const allocatedIds = new Array<number>();
         for (let id = 0; id <= MAX_ROUTER_ID; id++) {
             if (isRouterIdSet(mask, id)) allocatedIds.push(id);
         }
 
-        if (value.length !== HEADER_BYTES + allocatedIds.length) {
+        if (buf.length !== HEADER_BYTES + allocatedIds.length) {
             throw new ThreadDiagError(
-                `Route64 TLV size mismatch: ${value.length} bytes for ${allocatedIds.length} allocated routers`,
+                `Route64 TLV size mismatch: ${buf.length} bytes for ${allocatedIds.length} allocated routers`,
             );
         }
 
         const entries = new Array<Route64Entry>();
         for (let i = 0; i < allocatedIds.length; i++) {
-            const data = value[HEADER_BYTES + i];
+            const data = buf[HEADER_BYTES + i];
             entries.push({
                 routerId: allocatedIds[i],
                 linkQualityOut: (data & LINK_QUALITY_OUT_MASK) >> LINK_QUALITY_OUT_SHIFT,
@@ -91,7 +92,7 @@ export namespace Route64 {
         return { idSequence, entries };
     }
 
-    export function encode(route: Route64): Uint8Array {
+    export function encode(route: Route64): Bytes {
         const sortedEntries = [...route.entries].sort((a, b) => a.routerId - b.routerId);
 
         const out = new Uint8Array(HEADER_BYTES + sortedEntries.length);

package/src/tlv/diag/RouterNeighbor.ts

@@ -4,6 +4,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { Bytes } from "@matter/general";
+
 /**
  * One decoded Router Neighbor entry from Network Diagnostic TLV type 31.
  *
@@ -24,7 +26,7 @@
 export interface RouterNeighborEntry {
     rloc16: number;
     /** 8-byte IEEE EUI-64 extended address. */
-    extAddress: Uint8Array;
+    extAddress: Bytes;
     version: number;
     /** Seconds elapsed since link establishment. */
     connectionTime: number;
@@ -47,24 +49,25 @@ const ENTRY_BYTES = 24;
 const FLAGS_TRACK_ERR_RATE = 0x80; // kFlagsTrackErrRate = 1 << 7
 
 export namespace RouterNeighbor {
-    export function decode(value: Uint8Array): RouterNeighborEntry[] {
-        const entryCount = Math.floor(value.length / ENTRY_BYTES);
+    export function decode(value: Bytes): RouterNeighborEntry[] {
+        const buf = Bytes.of(value);
+        const entryCount = Math.floor(buf.length / ENTRY_BYTES);
         const entries = new Array<RouterNeighborEntry>();
 
         for (let i = 0; i < entryCount; i++) {
             const off = i * ENTRY_BYTES;
-            const flags = value[off];
-            const rloc16 = (value[off + 1] << 8) | value[off + 2];
-            const extAddress = value.slice(off + 3, off + 11);
-            const version = (value[off + 11] << 8) | value[off + 12];
+            const flags = buf[off];
+            const rloc16 = (buf[off + 1] << 8) | buf[off + 2];
+            const extAddress = buf.slice(off + 3, off + 11);
+            const version = (buf[off + 11] << 8) | buf[off + 12];
             const connectionTime =
-                ((value[off + 13] << 24) | (value[off + 14] << 16) | (value[off + 15] << 8) | value[off + 16]) >>> 0;
-            const linkMargin = value[off + 17];
+                ((buf[off + 13] << 24) | (buf[off + 14] << 16) | (buf[off + 15] << 8) | buf[off + 16]) >>> 0;
+            const linkMargin = buf[off + 17];
             // int8 signed decode: values >= 128 are negative (two's complement).
-            const averageRssi = value[off + 18] > 127 ? value[off + 18] - 256 : value[off + 18];
-            const lastRssi = value[off + 19] > 127 ? value[off + 19] - 256 : value[off + 19];
-            const frameErrorRate = (value[off + 20] << 8) | value[off + 21];
-            const messageErrorRate = (value[off + 22] << 8) | value[off + 23];
+            const averageRssi = buf[off + 18] > 127 ? buf[off + 18] - 256 : buf[off + 18];
+            const lastRssi = buf[off + 19] > 127 ? buf[off + 19] - 256 : buf[off + 19];
+            const frameErrorRate = (buf[off + 20] << 8) | buf[off + 21];
+            const messageErrorRate = (buf[off + 22] << 8) | buf[off + 23];
 
             entries.push({
                 rloc16,

package/src/tlv/diag/Timeout.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { InternalError } from "@matter/general";
+import { Bytes, InternalError } from "@matter/general";
 import { ThreadDiagError } from "../../diagnostic/errors.js";
 
 /**
@@ -15,14 +15,15 @@ import { ThreadDiagError } from "../../diagnostic/errors.js";
  * `network_diagnostic.cpp` parser.
  */
 export namespace Timeout {
-    export function decode(value: Uint8Array): number {
-        if (value.length !== 4) {
-            throw new ThreadDiagError(`Timeout TLV must be 4 bytes, got ${value.length}`);
+    export function decode(value: Bytes): number {
+        const buf = Bytes.of(value);
+        if (buf.length !== 4) {
+            throw new ThreadDiagError(`Timeout TLV must be 4 bytes, got ${buf.length}`);
         }
-        return ((value[0] << 24) | (value[1] << 16) | (value[2] << 8) | value[3]) >>> 0;
+        return ((buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3]) >>> 0;
     }
 
-    export function encode(seconds: number): Uint8Array {
+    export function encode(seconds: number): Bytes {
         if (!Number.isInteger(seconds) || seconds < 0 || seconds > 0xffffffff) {
             throw new InternalError(`Timeout TLV out of range: ${seconds}`);
         }

package/src/tlv/diag/VendorInfo.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { InternalError } from "@matter/general";
+import { Bytes, InternalError } from "@matter/general";
 import { ThreadDiagError } from "../../diagnostic/errors.js";
 
 /**
@@ -28,11 +28,11 @@ import { ThreadDiagError } from "../../diagnostic/errors.js";
 const TEXT_DECODER = new TextDecoder("utf-8", { fatal: false });
 const TEXT_ENCODER = new TextEncoder();
 
-function decodeUtf8(value: Uint8Array): string {
+function decodeUtf8(value: Bytes): string {
     return TEXT_DECODER.decode(value);
 }
 
-function encodeUtf8(text: string, maxBytes: number, name: string): Uint8Array {
+function encodeUtf8(text: string, maxBytes: number, name: string): Bytes {
     const encoded = TEXT_ENCODER.encode(text);
     if (encoded.length > maxBytes) {
         throw new InternalError(`${name} value too long: ${encoded.length} bytes (max ${maxBytes})`);
@@ -47,14 +47,15 @@ export const THREAD_STACK_VERSION_MAX = 64;
 export const VENDOR_APP_URL_MAX = 96;
 
 export namespace Version {
-    export function decode(value: Uint8Array): number {
-        if (value.length !== 2) {
-            throw new ThreadDiagError(`Version TLV must be 2 bytes, got ${value.length}`);
+    export function decode(value: Bytes): number {
+        const buf = Bytes.of(value);
+        if (buf.length !== 2) {
+            throw new ThreadDiagError(`Version TLV must be 2 bytes, got ${buf.length}`);
         }
-        return (value[0] << 8) | value[1];
+        return (buf[0] << 8) | buf[1];
     }
 
-    export function encode(version: number): Uint8Array {
+    export function encode(version: number): Bytes {
         if (!Number.isInteger(version) || version < 0 || version > 0xffff) {
             throw new InternalError(`Version TLV out of range: ${version}`);
         }
@@ -63,51 +64,51 @@ export namespace Version {
 }
 
 export namespace VendorName {
-    export function decode(value: Uint8Array): string {
+    export function decode(value: Bytes): string {
         return decodeUtf8(value);
     }
 
-    export function encode(name: string): Uint8Array {
+    export function encode(name: string): Bytes {
         return encodeUtf8(name, VENDOR_NAME_MAX, "VendorName");
     }
 }
 
 export namespace VendorModel {
-    export function decode(value: Uint8Array): string {
+    export function decode(value: Bytes): string {
         return decodeUtf8(value);
     }
 
-    export function encode(model: string): Uint8Array {
+    export function encode(model: string): Bytes {
         return encodeUtf8(model, VENDOR_MODEL_MAX, "VendorModel");
     }
 }
 
 export namespace VendorSwVersion {
-    export function decode(value: Uint8Array): string {
+    export function decode(value: Bytes): string {
         return decodeUtf8(value);
     }
 
-    export function encode(version: string): Uint8Array {
+    export function encode(version: string): Bytes {
         return encodeUtf8(version, VENDOR_SW_VERSION_MAX, "VendorSwVersion");
     }
 }
 
 export namespace ThreadStackVersion {
-    export function decode(value: Uint8Array): string {
+    export function decode(value: Bytes): string {
         return decodeUtf8(value);
     }
 
-    export function encode(version: string): Uint8Array {
+    export function encode(version: string): Bytes {
         return encodeUtf8(version, THREAD_STACK_VERSION_MAX, "ThreadStackVersion");
     }
 }
 
 export namespace VendorAppUrl {
-    export function decode(value: Uint8Array): string {
+    export function decode(value: Bytes): string {
         return decodeUtf8(value);
     }
 
-    export function encode(url: string): Uint8Array {
+    export function encode(url: string): Bytes {
         return encodeUtf8(url, VENDOR_APP_URL_MAX, "VendorAppUrl");
     }
 }

package/src/tlv/meshcop/Ip6AddressTlv.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { Bytes } from "@matter/general";
 import { ThreadTlvError } from "../BasicTlvCodec.js";
 
 /**
@@ -18,14 +19,16 @@ import { ThreadTlvError } from "../BasicTlvCodec.js";
  * `src/core/meshcop/meshcop_tlvs.hpp` `IPv6AddressTlv` (`kIPv6Address = 49`).
  */
 export namespace Ip6AddressTlv {
-    export function encode(addr: Uint8Array): Uint8Array {
-        assertLength(addr);
-        return addr.slice();
+    export function encode(addr: Bytes): Bytes {
+        const buf = Bytes.of(addr);
+        assertLength(buf);
+        return buf.slice();
     }
 
-    export function decode(bytes: Uint8Array): Uint8Array {
-        assertLength(bytes);
-        return bytes.slice();
+    export function decode(bytes: Bytes): Bytes {
+        const buf = Bytes.of(bytes);
+        assertLength(buf);
+        return buf.slice();
     }
 }
 

package/src/tlv/meshcop/UdpEncapsulationTlv.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { InternalError } from "@matter/general";
+import { Bytes, InternalError } from "@matter/general";
 import { ThreadTlvError } from "../BasicTlvCodec.js";
 
 /**
@@ -22,30 +22,32 @@ import { ThreadTlvError } from "../BasicTlvCodec.js";
 export interface UdpEncapsulation {
     sourcePort: number;
     destinationPort: number;
-    payload: Uint8Array;
+    payload: Bytes;
 }
 
 export namespace UdpEncapsulationTlv {
-    export function encode({ sourcePort, destinationPort, payload }: UdpEncapsulation): Uint8Array {
+    export function encode({ sourcePort, destinationPort, payload }: UdpEncapsulation): Bytes {
         assertPort(sourcePort, "sourcePort");
         assertPort(destinationPort, "destinationPort");
-        const out = new Uint8Array(4 + payload.length);
+        const payloadBytes = Bytes.of(payload);
+        const out = new Uint8Array(4 + payloadBytes.length);
         out[0] = (sourcePort >> 8) & 0xff;
         out[1] = sourcePort & 0xff;
         out[2] = (destinationPort >> 8) & 0xff;
         out[3] = destinationPort & 0xff;
-        out.set(payload, 4);
+        out.set(payloadBytes, 4);
         return out;
     }
 
-    export function decode(bytes: Uint8Array): UdpEncapsulation {
-        if (bytes.length < 4) {
-            throw new ThreadTlvError(`UdpEncapsulationTlv: value must be at least 4 bytes, got ${bytes.length}`);
+    export function decode(bytes: Bytes): UdpEncapsulation {
+        const buf = Bytes.of(bytes);
+        if (buf.length < 4) {
+            throw new ThreadTlvError(`UdpEncapsulationTlv: value must be at least 4 bytes, got ${buf.length}`);
         }
         return {
-            sourcePort: (bytes[0] << 8) | bytes[1],
-            destinationPort: (bytes[2] << 8) | bytes[3],
-            payload: bytes.slice(4),
+            sourcePort: (buf[0] << 8) | buf[1],
+            destinationPort: (buf[2] << 8) | buf[3],
+            payload: buf.slice(4),
         };
     }
 }

package/src/util/meshLocalAddr.ts

@@ -4,18 +4,18 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { ImplementationError } from "@matter/general";
+import { Bytes, ImplementationError } from "@matter/general";
 
 /**
  * Realm-local all-Thread-nodes multicast address (`ff03::1`).
  */
-export const ALL_THREAD_NODES_REALM_LOCAL: Uint8Array = realmLocal(0x01);
+export const ALL_THREAD_NODES_REALM_LOCAL: Bytes = realmLocal(0x01);
 
 /**
  * Realm-local all-Thread-routers multicast address (`ff03::2`). Diagnostic
  * multicast queries (`MGMT_DIAG_GET.qry`) target this group.
  */
-export const ALL_THREAD_ROUTERS_REALM_LOCAL: Uint8Array = realmLocal(0x02);
+export const ALL_THREAD_ROUTERS_REALM_LOCAL: Bytes = realmLocal(0x02);
 
 /**
  * Derive the mesh-local IPv6 address of a node from its RLOC16.
@@ -23,15 +23,16 @@ export const ALL_THREAD_ROUTERS_REALM_LOCAL: Uint8Array = realmLocal(0x02);
  * Layout: `mlPrefix(8) || 0x0000 00FF FE00 || rloc16(2 BE)` — the well-known
  * Thread RLOC interface identifier with the locator in the low 16 bits.
  */
-export function deriveMeshLocalAddress(mlPrefix: Uint8Array, rloc16: number): Uint8Array {
-    if (mlPrefix.length !== 8) {
-        throw new ImplementationError(`deriveMeshLocalAddress: mlPrefix must be 8 bytes, got ${mlPrefix.length}`);
+export function deriveMeshLocalAddress(mlPrefix: Bytes, rloc16: number): Bytes {
+    const prefix = Bytes.of(mlPrefix);
+    if (prefix.length !== 8) {
+        throw new ImplementationError(`deriveMeshLocalAddress: mlPrefix must be 8 bytes, got ${prefix.length}`);
     }
     if (!Number.isInteger(rloc16) || rloc16 < 0 || rloc16 > 0xffff) {
         throw new ImplementationError(`deriveMeshLocalAddress: rloc16 out of range: ${rloc16}`);
     }
     const addr = new Uint8Array(16);
-    addr.set(mlPrefix, 0);
+    addr.set(prefix, 0);
     addr[11] = 0xff;
     addr[12] = 0xfe;
     addr[14] = (rloc16 >> 8) & 0xff;
@@ -43,7 +44,8 @@ export function deriveMeshLocalAddress(mlPrefix: Uint8Array, rloc16: number): Ui
  * Format a 16-byte IPv6 address as colon-separated hextets with leading zeros
  * trimmed. No `::` compression — for logs, where unambiguity beats brevity.
  */
-export function formatIp6(addr: Uint8Array): string {
+export function formatIp6(input: Bytes): string {
+    const addr = Bytes.of(input);
     if (addr.length !== 16) {
         throw new ImplementationError(`formatIp6: address must be 16 bytes, got ${addr.length}`);
     }