@matter/thread-br-client 0.0.1

package/README.md

@@ -0,0 +1,192 @@
+# @matter/thread-br-client - Thread Border Router communication for Matter.js
+
+Thread Border Router support for matter.js: mDNS BR discovery, dataset codec, MeshCoP/CoAP/DTLS-EC-JPAKE diagnostic queries, and OpenThread Border Router (OTBR) REST adapter.
+
+For more information about matter.js, see the [matter.js README](../../README.md).
+
+It provides Thread BR-perspective routing, link-quality, child-table, and vendor data for an entire Thread mesh — including non-Matter nodes.
+
+> **Runtime: Node.js (for now).** The MeshCoP DTLS stack uses AES-CCM-8 and AES-CMAC via Node's
+> `crypto`, which keeps the package Node-bound. The UDP transport and CoAP codec are
+> platform-agnostic (matter.js `Network` + an inline RFC 7252 codec), so only the crypto pins it
+> to Node. Browser/React-Native support can be revisited if matter.js `Crypto` gains
+> configurable-tag CCM and AES-CMAC.
+
+## Scope
+
+This package targets **read-only Thread diagnostics** — the data needed to visualise a Thread mesh
+from the Border Router's perspective. Implemented today:
+
+- **Discovery:** passive `_meshcop` mDNS Border Router discovery (`BorderRouterRegistry`).
+- **Dataset:** Operational Dataset decode/encode (`OperationalDataset`).
+- **Diagnostics — OTBR REST:** node info, network diagnostics, active-dataset read, energy-scan and
+  diagnostic-counter-reset actions, plus the read-only `/node/*` surface — role/state, addresses,
+  leader data, active/pending dataset, co-processor version, commissioner state and joiners
+  (`OtbrRestClient` / `OtbrRestDiagnosticSource`).
+- **Diagnostics — MeshCoP:** commissioner petition + CoAP-over-DTLS-EC-JPAKE diagnostic queries
+  (`d/dq`/`d/dr`, energy scan `c/es`, PAN-ID query `c/pq`) via `connectMeshcop` / `MeshCopDiagnosticSource`.
+
+`OtbrRestClient` also exposes the OTBR **mutating** operations — active/pending **dataset push**,
+Border Router **state change**, **factory reset**, and commissioner **joiner** onboarding. These can
+silently partition or brick a network, so the library provides the capability but leaves the
+orchestration and confirmation UX to the consumer; nothing here triggers them on its own. Still
+unimplemented: MeshCoP-side dataset management (`c/as`/`c/ps`), list-connected-devices, and the
+newer `/api/diagnostics` task-queue REST endpoint.
+
+## Using this package
+
+### Discover Thread Border Routers (passive mDNS)
+
+```ts
+import { Environment } from "@matter/main";
+import { BorderRouterRegistry } from "@matter/thread-br-client";
+
+const registry = new BorderRouterRegistry(Environment.default);
+await registry.start();
+registry.events.added.on(br => console.log(br.networkName, br.extAddressHex, br.addresses));
+// … later: await registry.stop();
+```
+
+### Decode a Thread Operational Dataset
+
+```ts
+import { OperationalDataset } from "@matter/thread-br-client";
+
+const ds = OperationalDataset.decode("0e08...");   // hex from `ot-ctl dataset active -x`
+console.log(ds.networkName, ds.channel);
+const safe = OperationalDataset.redact(ds);        // clears pskc / networkKey for display
+console.log(safe.networkName, safe.channel);       // secrets are undefined
+```
+
+### Query network diagnostics
+
+Two paths, picked per Border Router:
+
+- **OTBR REST** (auto-detected): when the BR exposes the OpenThread REST API.
+- **MeshCoP** (CoAP over DTLS-EC-JPAKE): requires the network's credentials (PSKc), looked
+  up by extended PAN ID from a `ThreadCredentialsRegistry`.
+
+```ts
+import { DefaultTlvSet, OtbrRestClient, OtbrRestDiagnosticSource, OtbrRestProbe } from "@matter/thread-br-client";
+
+const cap = await OtbrRestProbe.probe(host, 8081, 1500);
+if (cap) {
+    const client = new OtbrRestClient({ host, port: 8081 });
+    const source = new OtbrRestDiagnosticSource(client, cap);
+    const handle = source.queryMulticast("ff03::2", { tlvTypes: [...DefaultTlvSet] });
+    handle.onNode.on(node => console.log(node.extMacAddress, node.rloc16));
+    await handle.done;
+}
+```
+
+(For the MeshCoP path see `connectMeshcop` + `ThreadCredentialsRegistry`.)
+
+## Development
+
+Examples and integration scripts target a local OpenThread CLI simulator:
+
+```bash
+brew install openthread
+```
+
+## Live integration testing with ot-cli-ftd
+
+The `noble` DTLS backend implements the DTLS 1.2 + EC-JPAKE handshake from scratch. Beyond the unit-test gate (recorded mbedtls flights replayed against our state machine) we also exercise it against a live mbedtls peer — the OpenThread CLI simulator (`ot-cli-ftd`), which uses mbedtls for its MeshCoP commissioner port. A successful handshake against `ot-cli-ftd` proves byte-level interop across every flight.
+
+### Build prerequisite
+
+Build `ot-cli-ftd` once. If you haven't:
+
+```bash
+git clone https://github.com/openthread/openthread.git ~/src/openthread
+cd ~/src/openthread
+./script/bootstrap
+./script/cmake-build simulation
+```
+
+The binary lands at `~/src/openthread/build/simulation/examples/apps/cli/ot-cli-ftd`.
+
+### Step-by-step procedure
+
+**Terminal A — start the simulator and capture the dataset:**
+
+```bash
+cd ~/src/openthread
+./build/simulation/examples/apps/cli/ot-cli-ftd 1
+```
+
+At the OT CLI prompt:
+
+```
+> dataset init new
+Done
+> dataset commit active
+Done
+> ifconfig up
+Done
+> thread start
+Done
+```
+
+Wait a few seconds, then confirm the node has come up:
+
+```
+> state
+leader
+Done
+> dataset active -x
+0e08...   <-- copy this hex blob
+Done
+```
+
+The simulator's MeshCoP DTLS service binds to a UDP port on the loopback. `DtlsConnectOpts.port` documents 49191 as the typical default, but real ports drift — confirm yours:
+
+```bash
+# In a third shell, find the actual port:
+lsof -nP -iUDP -p $(pgrep -f ot-cli-ftd | head -1)
+```
+
+Look for an entry like `*:49191` or `*:49xxx` — that's the MeshCoP port.
+
+**Terminal B — extract the PSKc and drive the handshake:**
+
+```bash
+cd <repo-root>
+npm run build -w @matter/thread-br-client
+
+cd packages/thread-br-client
+PSKC=$(npm run --silent example -- examples/extract-pskc.ts <dataset-hex> 2>/dev/null)
+npm run example -- examples/handshake-dtls.ts 127.0.0.1 <port> "$PSKC"
+```
+
+### Expected outcome
+
+```
+DTLS handshake established in NNNms.
+```
+
+If you see this, the noble EC-JPAKE backend interops with mbedtls byte-for-byte across the full DTLS 1.2 handshake (ClientHello → HelloVerifyRequest → ClientHello with cookie → ServerHello + ServerKeyExchange + ServerHelloDone → ClientKeyExchange + ChangeCipherSpec + Finished → ChangeCipherSpec + Finished).
+
+### Failure modes
+
+Errors surface as plain `Error` instances; the example prints `<name>: <message>`. Common patterns:
+
+- **`Error: NobleDtlsChannel: connect timed out after 30000ms`** — UDP datagrams are not reaching the peer or no reply is coming back. Wrong port (re-run `lsof`), simulator stopped, or the peer rejected the ClientHello silently. On macOS, also check the firewall.
+- **`Error: NobleDtlsChannel: peer alert level=2 desc=NN`** — the peer aborted with a fatal alert. `desc=20` (`bad_record_mac`) on the post-handshake AEAD is the classic PSKc-mismatch signature; `desc=40` (`handshake_failure`) shows up when EC-JPAKE state diverges.
+- **`Error: DtlsClient: server round-1/round-2 ZKP verification failed`** — the peer's EC-JPAKE proof didn't validate. PSKc mismatch is the expected cause; if the PSKc is right, this is a wire-format bug worth capturing.
+- **`Error: DtlsClient: server Finished verify_data mismatch`** — handshake transcript hashes diverge between client and server. Almost certainly a PRF / handshake-message-serialization bug — capture pcap and triage.
+- **`Error: DtlsClient: handshake gave up after max retransmits`** — RFC 6347 §4.2.4 give-up. Same root causes as the connect timeout.
+- **Anything else thrown from `DtlsClient` / record codecs** — wire-format mismatch with mbedtls. This is the bug class the live test is meant to surface; capture the failure log + handshake datagrams and triage.
+
+### Capturing handshake bytes for triage
+
+```bash
+sudo tcpdump -i lo0 -w /tmp/dtls.pcap "udp port <port>" &
+TCPDUMP_PID=$!
+# ... run the test ...
+sudo kill $TCPDUMP_PID
+```
+
+Open `/tmp/dtls.pcap` in Wireshark. Without the Thread / MeshCoP dissector you still see DTLS 1.2 record headers, fragment offsets, and epoch transitions, which is enough to locate where client and server diverge.
+
+For more information about matter.js, see the [matter.js README](../../README.md).

package/dist/cjs/coap/CoapClient.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type Environment, TimeoutError } from "@matter/general";
+import type { DtlsChannel } from "../dtls/channel/DtlsChannel.js";
+import { CoapMessage } from "./CoapMessage.js";
+/** Thrown when a CON request exhausts MAX_RETRANSMIT without receiving an ACK,
+ *  or when an empty ACK is received but no separate response arrives within
+ *  {@link SEPARATE_RESPONSE_TIMEOUT}. */
+export declare class CoapTimeoutError extends TimeoutError {
+    constructor(messageId: number);
+}
+export interface CoapClientOpts {
+    /** Override ACK_TIMEOUT for testing. Default: 2000ms per RFC 7252 §4.2. */
+    ackTimeoutMs?: number;
+    /** Override the separate-response wait window. Default: 30000ms. */
+    separateResponseTimeoutMs?: number;
+}
+export declare class CoapClient {
+    #private;
+    constructor(channel: DtlsChannel, environment: Environment, opts?: CoapClientOpts);
+    request(opts: {
+        type: "CON" | "NON";
+        code: string;
+        uriPath: string[];
+        payload?: Uint8Array;
+    }): Promise<CoapMessage>;
+    listen(uriPath: string[], handler: (msg: CoapMessage) => void): () => void;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=CoapClient.d.ts.map

package/dist/cjs/coap/CoapClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CoapClient.d.ts","sourceRoot":"","sources":["../../../src/coap/CoapClient.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAKH,KAAK,WAAW,EAMhB,YAAY,EAEf,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAI/C;;yCAEyC;AACzC,qBAAa,gBAAiB,SAAQ,YAAY;IAC9C,YAAY,SAAS,EAAE,MAAM,EAG5B;CACJ;AAaD,MAAM,WAAW,cAAc;IAC3B,2EAA2E;IAC3E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,oEAAoE;IACpE,yBAAyB,CAAC,EAAE,MAAM,CAAC;CACtC;AA8BD,qBAAa,UAAU;;IAenB,YAAY,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE,IAAI,CAAC,EAAE,cAAc,EAUhF;IAEK,OAAO,CAAC,IAAI,EAAE;QAChB,IAAI,EAAE,KAAK,GAAG,KAAK,CAAC;QACpB,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,EAAE,CAAC;QAClB,OAAO,CAAC,EAAE,UAAU,CAAC;KACxB,GAAG,OAAO,CAAC,WAAW,CAAC,CAoBvB;IAED,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,CAAC,GAAG,EAAE,WAAW,KAAK,IAAI,GAAG,MAAM,IAAI,CAMzE;IAEK,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAG3B;CAgNJ"}

package/dist/cjs/coap/CoapClient.js

@@ -0,0 +1,281 @@
+"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 CoapClient_exports = {};
+__export(CoapClient_exports, {
+  CoapClient: () => CoapClient,
+  CoapTimeoutError: () => CoapTimeoutError
+});
+module.exports = __toCommonJS(CoapClient_exports);
+var import_general = require("@matter/general");
+var import_CoapMessage = require("./CoapMessage.js");
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = import_general.Logger.get("CoapClient");
+class CoapTimeoutError extends import_general.TimeoutError {
+  constructor(messageId) {
+    super(`CoAP CON messageId=${messageId} timed out after MAX_RETRANSMIT`);
+    this.name = "CoapTimeoutError";
+  }
+}
+const RFC_ACK_TIMEOUT = (0, import_general.Seconds)(2);
+const RFC_ACK_RANDOM_FACTOR = 1.5;
+const MAX_RETRANSMIT = 4;
+const SEPARATE_RESPONSE_TIMEOUT = (0, import_general.Seconds)(30);
+function pathsEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+function tokenHex(token) {
+  let out = "";
+  for (const b of token) {
+    out += b.toString(16).padStart(2, "0");
+  }
+  return out;
+}
+class CoapClient {
+  #entropy;
+  #messageId;
+  #channel;
+  #ackTimeoutMs;
+  #separateResponseTimeout;
+  /** Tracks the per-message-id retransmit slot. Removed once the BR ACKs the
+   *  request — either with a piggybacked response or an empty ACK announcing
+   *  a separate response. */
+  #pendingByMsgId = /* @__PURE__ */ new Map();
+  /** Tracks the per-token response correlation slot. Removed only when the
+   *  response actually arrives (or the separate-response wait times out). */
+  #pendingByToken = /* @__PURE__ */ new Map();
+  #listeners = /* @__PURE__ */ new Set();
+  constructor(channel, environment, opts) {
+    this.#channel = channel;
+    this.#entropy = environment.get(import_general.Crypto);
+    this.#messageId = this.#entropy.randomUint16;
+    this.#ackTimeoutMs = opts?.ackTimeoutMs ?? RFC_ACK_TIMEOUT;
+    this.#separateResponseTimeout = opts?.separateResponseTimeoutMs !== void 0 ? (0, import_general.Millis)(opts.separateResponseTimeoutMs) : SEPARATE_RESPONSE_TIMEOUT;
+    void this.#runRecvLoop();
+  }
+  async request(opts) {
+    const messageId = this.#nextMessageId();
+    const token = this.#randomToken();
+    const msg = {
+      type: opts.type,
+      code: opts.code,
+      messageId,
+      token,
+      uriPath: opts.uriPath,
+      payload: opts.payload ?? new Uint8Array()
+    };
+    if (opts.type === "NON") {
+      await this.#channel.send(import_CoapMessage.CoapMessage.encode(msg));
+      return { type: "NON", code: "0.00", messageId, token, payload: new Uint8Array() };
+    }
+    return this.#sendCon(msg);
+  }
+  listen(uriPath, handler) {
+    const entry = { uriPath: [...uriPath], handler };
+    this.#listeners.add(entry);
+    return () => {
+      this.#listeners.delete(entry);
+    };
+  }
+  async close() {
+    this.#listeners.clear();
+    await this.#channel.close();
+  }
+  async #sendCon(msg) {
+    if (this.#pendingByMsgId.has(msg.messageId)) {
+      throw new import_general.ImplementationError(
+        `CoapClient: messageId collision at ${msg.messageId} \u2014 too many concurrent CON requests`
+      );
+    }
+    const reqTokenHex = tokenHex(msg.token);
+    if (this.#pendingByToken.has(reqTokenHex)) {
+      throw new import_general.ImplementationError(`CoapClient: token collision for ${reqTokenHex}`);
+    }
+    const encoded = import_CoapMessage.CoapMessage.encode(msg);
+    return new Promise((resolve, reject) => {
+      let retransmitTimer;
+      let separateTimer;
+      let attempt = 0;
+      const cleanup = () => {
+        if (retransmitTimer !== void 0) {
+          retransmitTimer.stop();
+          retransmitTimer = void 0;
+        }
+        if (separateTimer !== void 0) {
+          separateTimer.stop();
+          separateTimer = void 0;
+        }
+        this.#pendingByMsgId.delete(msg.messageId);
+        this.#pendingByToken.delete(reqTokenHex);
+      };
+      const state = {
+        resolve: (response) => {
+          cleanup();
+          resolve(response);
+        },
+        reject: (err) => {
+          cleanup();
+          reject(err);
+        },
+        tokenHex: reqTokenHex,
+        onEmptyAck: () => {
+          if (retransmitTimer !== void 0) {
+            retransmitTimer.stop();
+            retransmitTimer = void 0;
+          }
+          this.#pendingByMsgId.delete(msg.messageId);
+          separateTimer = import_general.Time.getTimer("coap-separate-response", this.#separateResponseTimeout, () => {
+            state.reject(new CoapTimeoutError(msg.messageId));
+          }).start();
+        }
+      };
+      const scheduleRetransmit = (delayMs) => {
+        retransmitTimer = import_general.Time.getTimer("coap-retransmit", (0, import_general.Millis)(Math.round(delayMs)), () => {
+          retransmitTimer = void 0;
+          if (!this.#pendingByMsgId.has(msg.messageId)) return;
+          if (attempt >= MAX_RETRANSMIT) {
+            state.reject(new CoapTimeoutError(msg.messageId));
+            return;
+          }
+          attempt++;
+          void this.#channel.send(encoded).catch(
+            (err) => logger.warn(`CoAP retransmit send failed for messageId=${msg.messageId}: ${err}`)
+          );
+          scheduleRetransmit(Math.min(delayMs * 2, this.#ackTimeoutMs * 2 ** MAX_RETRANSMIT));
+        }).start();
+      };
+      this.#pendingByMsgId.set(msg.messageId, state);
+      this.#pendingByToken.set(reqTokenHex, state);
+      const initialDelay = this.#ackTimeoutMs * (1 + Math.random() * (RFC_ACK_RANDOM_FACTOR - 1));
+      void this.#channel.send(encoded).then(() => {
+        scheduleRetransmit(initialDelay);
+      }).catch((err) => {
+        state.reject(err instanceof Error ? err : new Error(String(err)));
+      });
+    });
+  }
+  async #runRecvLoop() {
+    let channelError;
+    try {
+      for await (const bytes of this.#channel) {
+        let msg;
+        try {
+          msg = import_CoapMessage.CoapMessage.decode(import_general.Bytes.of(bytes));
+        } catch (err) {
+          logger.debug(`CoAP inbound decode failed, dropping: ${err}`);
+          continue;
+        }
+        await this.#dispatchInbound(msg);
+      }
+    } catch (err) {
+      channelError = err instanceof Error ? err : new Error(String(err));
+    } finally {
+      const err = channelError ?? new Error("CoapClient: channel closed");
+      for (const state of this.#pendingByToken.values()) {
+        state.reject(err);
+      }
+      this.#pendingByMsgId.clear();
+      this.#pendingByToken.clear();
+    }
+  }
+  async #dispatchInbound(msg) {
+    if (msg.type === "ACK") {
+      const state = this.#pendingByMsgId.get(msg.messageId);
+      if (state === void 0) {
+        return;
+      }
+      const isEmptyAck = msg.code === "0.00" && msg.payload.length === 0;
+      if (isEmptyAck) {
+        state.onEmptyAck();
+        return;
+      }
+      state.resolve(msg);
+      return;
+    }
+    if (msg.type === "RST") {
+      const state = this.#pendingByMsgId.get(msg.messageId);
+      if (state !== void 0) {
+        state.reject(new Error(`CoAP RST received for messageId=${msg.messageId}`));
+      }
+      return;
+    }
+    const inboundTokenHex = tokenHex(msg.token);
+    const pending = this.#pendingByToken.get(inboundTokenHex);
+    if (pending !== void 0) {
+      if (msg.type === "CON") {
+        await this.#sendEmptyAck(msg.messageId);
+      }
+      pending.resolve(msg);
+      return;
+    }
+    if (msg.type === "CON") {
+      await this.#sendEmptyAck(msg.messageId);
+    }
+    this.#dispatchToListeners(msg);
+  }
+  async #sendEmptyAck(messageId) {
+    const ack = {
+      type: "ACK",
+      code: "0.00",
+      messageId,
+      token: new Uint8Array(),
+      payload: new Uint8Array()
+    };
+    try {
+      await this.#channel.send(import_CoapMessage.CoapMessage.encode(ack));
+    } catch (err) {
+      logger.debug(`Failed to send ACK for messageId=${messageId}:`, err);
+    }
+  }
+  #dispatchToListeners(msg) {
+    const inbound = msg.uriPath ?? [];
+    const uri = inbound.length > 0 ? `/${inbound.join("/")}` : "(none)";
+    let delivered = 0;
+    for (const listener of this.#listeners) {
+      if (!pathsEqual(listener.uriPath, inbound)) continue;
+      delivered++;
+      try {
+        listener.handler(msg);
+      } catch (err) {
+        logger.warn("CoapClient listener handler threw:", err);
+      }
+    }
+    if (delivered === 0) {
+      logger.debug(
+        `CoAP inbound consumed by no request or listener: uri=${uri} type=${msg.type} code=${msg.code} payloadLen=${msg.payload.length}`
+      );
+    }
+  }
+  #nextMessageId() {
+    const id = this.#messageId;
+    this.#messageId = this.#messageId + 1 & 65535;
+    return id;
+  }
+  #randomToken() {
+    return import_general.Bytes.of(this.#entropy.randomBytes(4));
+  }
+}
+//# sourceMappingURL=CoapClient.js.map

package/dist/cjs/coap/CoapClient.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/coap/CoapClient.ts"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/coap/CoapMessage.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { MatterError } from "@matter/general";
+export type CoapType = "CON" | "NON" | "ACK" | "RST";
+export interface CoapMessage {
+    type: CoapType;
+    code: string;
+    messageId: number;
+    token: Uint8Array;
+    uriPath?: string[];
+    payload: Uint8Array;
+}
+/** Thrown when a CoAP datagram cannot be decoded per RFC 7252 §3. */
+export declare class CoapError extends MatterError {
+}
+export declare namespace CoapMessage {
+    function encode(msg: CoapMessage): Uint8Array;
+    function decode(bytes: Uint8Array): CoapMessage;
+}
+//# sourceMappingURL=CoapMessage.d.ts.map

package/dist/cjs/coap/CoapMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CoapMessage.d.ts","sourceRoot":"","sources":["../../../src/coap/CoapMessage.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAS,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAErD,MAAM,MAAM,QAAQ,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;AAErD,MAAM,WAAW,WAAW;IACxB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,UAAU,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,EAAE,UAAU,CAAC;CACvB;AAED,qEAAqE;AACrE,qBAAa,SAAU,SAAQ,WAAW;CAAG;AAwD7C,yBAAiB,WAAW,CAAC,CAAC;IAC1B,SAAgB,MAAM,CAAC,GAAG,EAAE,WAAW,GAAG,UAAU,CA0BnD;IAED,SAAgB,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,CAmFrD;CACJ"}