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

package/src/tlv/NetworkDiagnosticTlv.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import type { Bytes } from "@matter/general";
 import { BasicTlv, type BasicTlvEntry } from "./BasicTlvCodec.js";
 
 /**
@@ -27,11 +28,11 @@ export type NetworkDiagnosticEntry = BasicTlvEntry;
  * records; per-TLV typed decoders are layered on top in `./diag/`.
  */
 export namespace NetworkDiagnosticTlv {
-    export function decode(blob: Uint8Array): NetworkDiagnosticEntry[] {
+    export function decode(blob: Bytes): NetworkDiagnosticEntry[] {
         return BasicTlv.walk(blob);
     }
 
-    export function encode(entries: ReadonlyArray<NetworkDiagnosticEntry>): Uint8Array {
+    export function encode(entries: ReadonlyArray<NetworkDiagnosticEntry>): Bytes {
         return BasicTlv.encode(entries);
     }
 }

package/src/tlv/TypeListTlv.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { InternalError } from "@matter/general";
+import { Bytes, InternalError } from "@matter/general";
 
 /**
  * Type List TLV value codec (Network Diagnostic TLV type 18).
@@ -20,7 +20,7 @@ import { InternalError } from "@matter/general";
  * `TlvInfo<kTypeList>`) and `network_diagnostic.cpp` request payload handling.
  */
 export namespace TypeListTlv {
-    export function encode(types: ReadonlyArray<number>): Uint8Array {
+    export function encode(types: ReadonlyArray<number>): Bytes {
         const out = new Uint8Array(types.length);
         for (let i = 0; i < types.length; i++) {
             const t = types[i];
@@ -32,7 +32,7 @@ export namespace TypeListTlv {
         return out;
     }
 
-    export function decode(value: Uint8Array): number[] {
-        return Array.from(value);
+    export function decode(value: Bytes): number[] {
+        return Array.from(Bytes.of(value));
     }
 }

package/src/tlv/diag/ChildIpv6AddressList.ts

@@ -4,6 +4,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { Bytes } from "@matter/general";
+
 /**
  * Decoded Child IPv6 Address List TLV (Network Diagnostic TLV type 30).
  *
@@ -15,20 +17,21 @@
  */
 export interface ChildIpv6Addresses {
     rloc16: number;
-    addresses: Uint8Array[];
+    addresses: Bytes[];
 }
 
 const RLOC16_BYTES = 2;
 const IPV6_ADDRESS_BYTES = 16;
 
 export namespace ChildIpv6AddressList {
-    export function decode(value: Uint8Array): ChildIpv6Addresses {
-        if (value.length < RLOC16_BYTES) {
+    export function decode(value: Bytes): ChildIpv6Addresses {
+        const buf = Bytes.of(value);
+        if (buf.length < RLOC16_BYTES) {
             return { rloc16: 0, addresses: [] };
         }
 
-        const rloc16 = (value[0] << 8) | value[1];
-        const addressPayload = value.subarray(RLOC16_BYTES);
+        const rloc16 = (buf[0] << 8) | buf[1];
+        const addressPayload = buf.subarray(RLOC16_BYTES);
         const addressCount = Math.floor(addressPayload.length / IPV6_ADDRESS_BYTES);
 
         const addresses = new Array<Uint8Array>();

package/src/tlv/diag/ChildTable.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";
 import { Mode } from "./Mode.js";
 
@@ -47,26 +47,27 @@ function timeoutFromExponent(exp: number): number {
 }
 
 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}`);
+    export function decode(value: Bytes): ChildTableEntry[] {
+        const buf = Bytes.of(value);
+        if (buf.length % ENTRY_BYTES !== 0) {
+            throw new ThreadDiagError(`ChildTable TLV length ${buf.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];
+        for (let offset = 0; offset < buf.length; offset += ENTRY_BYTES) {
+            const word = (buf[offset] << 8) | buf[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)),
+                mode: Mode.decode(buf.subarray(offset + 2, offset + 3)),
             });
         }
         return entries;
     }
 
-    export function encode(entries: ReadonlyArray<ChildTableEntry>): Uint8Array {
+    export function encode(entries: ReadonlyArray<ChildTableEntry>): Bytes {
         const out = new Uint8Array(entries.length * ENTRY_BYTES);
         for (let i = 0; i < entries.length; i++) {
             const e = entries[i];
@@ -85,7 +86,7 @@ export namespace ChildTable {
                 (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];
+            out[i * ENTRY_BYTES + 2] = Bytes.of(Mode.encode(e.mode))[0];
         }
         return out;
     }

package/src/tlv/diag/Connectivity.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { Bytes } from "@matter/general";
 import { ThreadDiagError } from "../../diagnostic/errors.js";
 
 /**
@@ -73,32 +74,31 @@ function parentPriorityTo2Bit(prio: ParentPriority): number {
 }
 
 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}`,
-            );
+    export function decode(value: Bytes): Connectivity {
+        const buf = Bytes.of(value);
+        if (buf.length !== MIN_SIZE && buf.length !== FULL_SIZE) {
+            throw new ThreadDiagError(`Connectivity TLV must be ${MIN_SIZE} or ${FULL_SIZE} bytes, got ${buf.length}`);
         }
-        const priorityBits = (value[0] & FLAGS_PARENT_PRIORITY_MASK) >> FLAGS_PARENT_PRIORITY_SHIFT;
+        const priorityBits = (buf[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],
+            linkQuality3: buf[1],
+            linkQuality2: buf[2],
+            linkQuality1: buf[3],
+            leaderCost: buf[4],
+            idSequence: buf[5],
+            activeRouters: buf[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];
+        if (buf.length === FULL_SIZE) {
+            partial.sedBufferSize = (buf[7] << 8) | buf[8];
+            partial.sedDatagramCount = buf[9];
         }
         return partial;
     }
 
-    export function encode(c: Connectivity): Uint8Array {
+    export function encode(c: Connectivity): Bytes {
         const out = new Uint8Array(FULL_SIZE);
         out[0] = (parentPriorityTo2Bit(c.parentPriority) << FLAGS_PARENT_PRIORITY_SHIFT) & FLAGS_PARENT_PRIORITY_MASK;
         out[1] = c.linkQuality3 & 0xff;

package/src/tlv/diag/Ipv6AddressList.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";
 
 /**
@@ -20,23 +20,24 @@ import { ThreadDiagError } from "../../diagnostic/errors.js";
 export const IPV6_ADDRESS_BYTES = 16;
 
 export namespace Ipv6AddressList {
-    export function decode(value: Uint8Array): Uint8Array[] {
-        if (value.length % IPV6_ADDRESS_BYTES !== 0) {
+    export function decode(value: Bytes): Bytes[] {
+        const buf = Bytes.of(value);
+        if (buf.length % IPV6_ADDRESS_BYTES !== 0) {
             throw new ThreadDiagError(
-                `IPv6 address list TLV length ${value.length} not a multiple of ${IPV6_ADDRESS_BYTES}`,
+                `IPv6 address list TLV length ${buf.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));
+        for (let offset = 0; offset < buf.length; offset += IPV6_ADDRESS_BYTES) {
+            out.push(buf.slice(offset, offset + IPV6_ADDRESS_BYTES));
         }
         return out;
     }
 
-    export function encode(addresses: ReadonlyArray<Uint8Array>): Uint8Array {
+    export function encode(addresses: ReadonlyArray<Bytes>): Bytes {
         const out = new Uint8Array(addresses.length * IPV6_ADDRESS_BYTES);
         for (let i = 0; i < addresses.length; i++) {
-            const addr = addresses[i];
+            const addr = Bytes.of(addresses[i]);
             if (addr.length !== IPV6_ADDRESS_BYTES) {
                 throw new InternalError(`IPv6 address must be ${IPV6_ADDRESS_BYTES} bytes, got ${addr.length}`);
             }

package/src/tlv/diag/LeaderData.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";
 
 /**
@@ -27,21 +27,22 @@ export interface LeaderData {
 }
 
 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}`);
+    export function decode(value: Bytes): LeaderData {
+        const buf = Bytes.of(value);
+        if (buf.length !== 8) {
+            throw new ThreadDiagError(`LeaderData TLV must be 8 bytes, got ${buf.length}`);
         }
-        const partitionId = ((value[0] << 24) | (value[1] << 16) | (value[2] << 8) | value[3]) >>> 0;
+        const partitionId = ((buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3]) >>> 0;
         return {
             partitionId,
-            weighting: value[4],
-            dataVersion: value[5],
-            stableDataVersion: value[6],
-            leaderRouterId: value[7],
+            weighting: buf[4],
+            dataVersion: buf[5],
+            stableDataVersion: buf[6],
+            leaderRouterId: buf[7],
         };
     }
 
-    export function encode(data: LeaderData): Uint8Array {
+    export function encode(data: LeaderData): Bytes {
         if (data.partitionId < 0 || data.partitionId > 0xffffffff) {
             throw new InternalError(`LeaderData partitionId out of range: ${data.partitionId}`);
         }

package/src/tlv/diag/MacCounters.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";
 
 /**
@@ -53,24 +53,25 @@ function writeU32BE(bytes: Uint8Array, offset: number, value: number): void {
 }
 
 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}`);
+    export function decode(value: Bytes): MacCounters {
+        const buf = Bytes.of(value);
+        if (buf.length !== TOTAL_BYTES) {
+            throw new ThreadDiagError(`MacCounters TLV must be ${TOTAL_BYTES} bytes, got ${buf.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),
+            ifInUnknownProtos: readU32BE(buf, 0),
+            ifInErrors: readU32BE(buf, 4),
+            ifOutErrors: readU32BE(buf, 8),
+            ifInUcastPkts: readU32BE(buf, 12),
+            ifInBroadcastPkts: readU32BE(buf, 16),
+            ifInDiscards: readU32BE(buf, 20),
+            ifOutUcastPkts: readU32BE(buf, 24),
+            ifOutBroadcastPkts: readU32BE(buf, 28),
+            ifOutDiscards: readU32BE(buf, 32),
         };
     }
 
-    export function encode(counters: MacCounters): Uint8Array {
+    export function encode(counters: MacCounters): Bytes {
         const out = new Uint8Array(TOTAL_BYTES);
         for (let i = 0; i < FIELD_ORDER.length; i++) {
             const v = counters[FIELD_ORDER[i]];

package/src/tlv/diag/MleCounters.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";
 
 /**
@@ -103,30 +103,31 @@ function writeU64BE(bytes: Uint8Array, offset: number, value: bigint): void {
 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}`);
+    export function decode(value: Bytes): MleCounters {
+        const buf = Bytes.of(value);
+        if (buf.length !== TOTAL_BYTES) {
+            throw new ThreadDiagError(`MleCounters TLV must be ${TOTAL_BYTES} bytes, got ${buf.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),
+            disabledRole: readU16BE(buf, 0),
+            detachedRole: readU16BE(buf, 2),
+            childRole: readU16BE(buf, 4),
+            routerRole: readU16BE(buf, 6),
+            leaderRole: readU16BE(buf, 8),
+            attachAttempts: readU16BE(buf, 10),
+            partitionIdChanges: readU16BE(buf, 12),
+            betterPartitionAttachAttempts: readU16BE(buf, 14),
+            parentChanges: readU16BE(buf, 16),
+            trackedTime: readU64BE(buf, 18),
+            disabledTime: readU64BE(buf, 26),
+            detachedTime: readU64BE(buf, 34),
+            childTime: readU64BE(buf, 42),
+            routerTime: readU64BE(buf, 50),
+            leaderTime: readU64BE(buf, 58),
         };
     }
 
-    export function encode(counters: MleCounters): Uint8Array {
+    export function encode(counters: MleCounters): Bytes {
         const out = new Uint8Array(TOTAL_BYTES);
         for (let i = 0; i < U16_FIELDS.length; i++) {
             const v = counters[U16_FIELDS[i]];

package/src/tlv/diag/Mode.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { Bytes } from "@matter/general";
 import { ThreadDiagError } from "../../diagnostic/errors.js";
 
 /**
@@ -29,11 +30,12 @@ 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}`);
+    export function decode(value: Bytes): Mode {
+        const buf = Bytes.of(value);
+        if (buf.length !== 1) {
+            throw new ThreadDiagError(`Mode TLV must be 1 byte, got ${buf.length}`);
         }
-        const raw = value[0];
+        const raw = buf[0];
         return {
             rxOnWhenIdle: (raw & FLAG_RX_ON_WHEN_IDLE) !== 0,
             fullThreadDevice: (raw & FLAG_FULL_THREAD_DEVICE) !== 0,
@@ -41,7 +43,7 @@ export namespace Mode {
         };
     }
 
-    export function encode(mode: Mode): Uint8Array {
+    export function encode(mode: Mode): Bytes {
         // 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;

package/src/tlv/diag/NetworkData.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { Bytes } from "@matter/general";
 import { ThreadDiagError } from "../../diagnostic/errors.js";
 
 /**
@@ -57,7 +58,7 @@ import { ThreadDiagError } from "../../diagnostic/errors.js";
 export interface NetworkDataEntry {
     type: number;
     stable: boolean;
-    value: Uint8Array;
+    value: Bytes;
 }
 
 export interface HasRouteEntry {
@@ -73,21 +74,21 @@ export interface BorderRouterEntry {
 export interface NetworkDataPrefix {
     domainId: number;
     prefixLength: number;
-    prefix: Uint8Array;
+    prefix: Bytes;
     hasRoutes: HasRouteEntry[];
     borderRouters: BorderRouterEntry[];
 }
 
 export interface NetworkDataServer {
     rloc16: number;
-    serverData: Uint8Array;
+    serverData: Bytes;
 }
 
 export interface NetworkDataService {
     serviceId: number;
     threadEnterprise: boolean;
     enterpriseNumber?: number;
-    serviceData: Uint8Array;
+    serviceData: Bytes;
     servers: NetworkDataServer[];
 }
 
@@ -95,7 +96,7 @@ export interface ThreadNetworkData {
     entries: NetworkDataEntry[];
     prefixes: NetworkDataPrefix[];
     services: NetworkDataService[];
-    raw: Uint8Array;
+    raw: Bytes;
 }
 
 const enum NetworkDataTlvType {
@@ -158,63 +159,67 @@ function parseBorderRouters(value: Uint8Array): BorderRouterEntry[] {
     return out;
 }
 
-function parsePrefix(value: Uint8Array): NetworkDataPrefix {
-    const domainId = value[0];
-    const prefixLength = value[1];
+function parsePrefix(value: Bytes): NetworkDataPrefix {
+    const buf = Bytes.of(value);
+    const domainId = buf[0];
+    const prefixLength = buf[1];
     const prefixBytes = Math.ceil(prefixLength / 8);
-    const prefix = value.slice(2, 2 + prefixBytes);
+    const prefix = buf.slice(2, 2 + prefixBytes);
 
     const hasRoutes = new Array<HasRouteEntry>();
     const borderRouters = new Array<BorderRouterEntry>();
-    for (const sub of walkTlvs(value.subarray(2 + prefixBytes))) {
+    for (const sub of walkTlvs(buf.subarray(2 + prefixBytes))) {
         if (sub.type === NetworkDataTlvType.HasRoute) {
-            hasRoutes.push(...parseHasRoutes(sub.value));
+            hasRoutes.push(...parseHasRoutes(Bytes.of(sub.value)));
         } else if (sub.type === NetworkDataTlvType.BorderRouter) {
-            borderRouters.push(...parseBorderRouters(sub.value));
+            borderRouters.push(...parseBorderRouters(Bytes.of(sub.value)));
         }
     }
     return { domainId, prefixLength, prefix, hasRoutes, borderRouters };
 }
 
-function parseService(value: Uint8Array): NetworkDataService {
-    const flags = value[0];
+function parseService(value: Bytes): NetworkDataService {
+    const buf = Bytes.of(value);
+    const flags = buf[0];
     const threadEnterprise = (flags & SERVICE_THREAD_FLAG) !== 0;
     const serviceId = flags & SERVICE_ID_MASK;
 
     let offset = 1;
     let enterpriseNumber: number | undefined;
     if (!threadEnterprise) {
-        if (value.length < 5) {
-            throw new ThreadDiagError(`Truncated Service TLV: ${value.length} bytes, need 5 for enterprise number`);
+        if (buf.length < 5) {
+            throw new ThreadDiagError(`Truncated Service TLV: ${buf.length} bytes, need 5 for enterprise number`);
         }
-        enterpriseNumber = ((value[1] << 24) | (value[2] << 16) | (value[3] << 8) | value[4]) >>> 0;
+        enterpriseNumber = ((buf[1] << 24) | (buf[2] << 16) | (buf[3] << 8) | buf[4]) >>> 0;
         offset = 5;
     }
-    if (offset >= value.length) {
+    if (offset >= buf.length) {
         throw new ThreadDiagError(`Truncated Service TLV: missing service data length at offset ${offset}`);
     }
-    const serviceDataLength = value[offset];
+    const serviceDataLength = buf[offset];
     offset += 1;
-    const serviceData = value.slice(offset, offset + serviceDataLength);
+    const serviceData = buf.slice(offset, offset + serviceDataLength);
     offset += serviceDataLength;
 
     const servers = new Array<NetworkDataServer>();
-    for (const sub of walkTlvs(value.subarray(offset))) {
+    for (const sub of walkTlvs(buf.subarray(offset))) {
         if (sub.type === NetworkDataTlvType.Server) {
-            if (sub.value.length < 2) continue;
-            servers.push({ rloc16: (sub.value[0] << 8) | sub.value[1], serverData: sub.value.slice(2) });
+            const serverValue = Bytes.of(sub.value);
+            if (serverValue.length < 2) continue;
+            servers.push({ rloc16: (serverValue[0] << 8) | serverValue[1], serverData: serverValue.slice(2) });
         }
     }
     return { serviceId, threadEnterprise, enterpriseNumber, serviceData, servers };
 }
 
 export namespace NetworkData {
-    export function decode(value: Uint8Array): ThreadNetworkData {
-        const raw = value.slice();
+    export function decode(value: Bytes): ThreadNetworkData {
+        const buf = Bytes.of(value);
+        const raw = buf.slice();
 
         let entries: NetworkDataEntry[];
         try {
-            entries = walkTlvs(value);
+            entries = walkTlvs(buf);
         } catch {
             // A truncated top-level stream must not abort the whole node's diagnostic
             // decode; `raw` preserves the bytes for any consumer that wants them.