@hamradio/meshcore 1.2.1 → 1.3.1

package/dist/{index.mjs → index.cjs}

@@ -1,3 +1,44 @@
+"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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Contact: () => Contact,
+  Contacts: () => Contacts,
+  Group: () => Group,
+  Identity: () => Identity,
+  LocalIdentity: () => LocalIdentity,
+  NodeType: () => NodeType,
+  Packet: () => Packet,
+  PayloadType: () => PayloadType,
+  PrivateKey: () => PrivateKey,
+  PublicKey: () => PublicKey,
+  RequestType: () => RequestType,
+  RouteType: () => RouteType,
+  SharedSecret: () => SharedSecret,
+  StaticSecret: () => StaticSecret,
+  TextType: () => TextType,
+  parseNodeHash: () => parseNodeHash
+});
+module.exports = __toCommonJS(index_exports);
+
 // src/packet.types.ts
 var RouteType = /* @__PURE__ */ ((RouteType2) => {
   RouteType2[RouteType2["TRANSPORT_FLOOD"] = 0] = "TRANSPORT_FLOOD";
@@ -45,127 +86,8 @@ var NodeType = /* @__PURE__ */ ((NodeType2) => {
 })(NodeType || {});
 
 // src/packet.ts
-import { sha256 } from "@noble/hashes/sha2.js";
-
-// src/parser.ts
-import { equalBytes } from "@noble/ciphers/utils.js";
-import { bytesToHex, hexToBytes as nobleHexToBytes } from "@noble/hashes/utils.js";
-var base64ToBytes = (base64, size) => {
-  let normalized = base64.replace(/-/g, "+").replace(/_/g, "/");
-  while (normalized.length % 4 !== 0) {
-    normalized += "=";
-  }
-  const binaryString = atob(normalized);
-  const bytes = new Uint8Array(binaryString.length);
-  for (let i = 0; i < binaryString.length; i++) {
-    bytes[i] = binaryString.charCodeAt(i);
-  }
-  if (size !== void 0 && bytes.length !== size) {
-    throw new Error(`Invalid base64 length: expected ${size} bytes, got ${bytes.length}`);
-  }
-  return bytes;
-};
-var hexToBytes = (hex, size) => {
-  const bytes = nobleHexToBytes(hex);
-  if (size !== void 0 && bytes.length !== size) {
-    throw new Error(`Invalid hex length: expected ${size} bytes, got ${bytes.length}`);
-  }
-  return bytes;
-};
-var BufferReader = class {
-  constructor(buffer) {
-    this.buffer = buffer;
-    this.offset = 0;
-  }
-  readByte() {
-    if (!this.hasMore()) throw new Error("read past end");
-    return this.buffer[this.offset++];
-  }
-  readBytes(length) {
-    if (length === void 0) {
-      length = this.buffer.length - this.offset;
-    }
-    if (this.remainingBytes() < length) throw new Error("read past end");
-    const bytes = this.buffer.slice(this.offset, this.offset + length);
-    this.offset += length;
-    return bytes;
-  }
-  hasMore() {
-    return this.offset < this.buffer.length;
-  }
-  remainingBytes() {
-    return this.buffer.length - this.offset;
-  }
-  peekByte() {
-    if (!this.hasMore()) throw new Error("read past end");
-    return this.buffer[this.offset];
-  }
-  readUint16LE() {
-    if (this.remainingBytes() < 2) throw new Error("read past end");
-    const value = this.buffer[this.offset] | this.buffer[this.offset + 1] << 8;
-    this.offset += 2;
-    return value;
-  }
-  readUint32LE() {
-    if (this.remainingBytes() < 4) throw new Error("read past end");
-    const value = (this.buffer[this.offset] | this.buffer[this.offset + 1] << 8 | this.buffer[this.offset + 2] << 16 | this.buffer[this.offset + 3] << 24) >>> 0;
-    this.offset += 4;
-    return value;
-  }
-  readInt16LE() {
-    if (this.remainingBytes() < 2) throw new Error("read past end");
-    const value = this.buffer[this.offset] | this.buffer[this.offset + 1] << 8;
-    this.offset += 2;
-    return value < 32768 ? value : value - 65536;
-  }
-  readInt32LE() {
-    if (this.remainingBytes() < 4) throw new Error("read past end");
-    const u = (this.buffer[this.offset] | this.buffer[this.offset + 1] << 8 | this.buffer[this.offset + 2] << 16 | this.buffer[this.offset + 3] << 24) >>> 0;
-    this.offset += 4;
-    return u < 2147483648 ? u : u - 4294967296;
-  }
-  readTimestamp() {
-    const timestamp = this.readUint32LE();
-    return new Date(timestamp * 1e3);
-  }
-};
-var BufferWriter = class {
-  constructor() {
-    this.buffer = [];
-  }
-  writeByte(value) {
-    this.buffer.push(value & 255);
-  }
-  writeBytes(bytes) {
-    this.buffer.push(...bytes);
-  }
-  writeUint16LE(value) {
-    this.buffer.push(value & 255, value >> 8 & 255);
-  }
-  writeUint32LE(value) {
-    this.buffer.push(
-      value & 255,
-      value >> 8 & 255,
-      value >> 16 & 255,
-      value >> 24 & 255
-    );
-  }
-  writeInt16LE(value) {
-    this.writeUint16LE(value < 0 ? value + 65536 : value);
-  }
-  writeInt32LE(value) {
-    this.writeUint32LE(value < 0 ? value + 4294967296 : value);
-  }
-  writeTimestamp(date) {
-    const timestamp = Math.floor(date.getTime() / 1e3);
-    this.writeUint32LE(timestamp);
-  }
-  toBytes() {
-    return new Uint8Array(this.buffer);
-  }
-};
-
-// src/packet.ts
+var import_sha2 = require("@noble/hashes/sha2.js");
+var import_packet2 = require("@hamradio/packet");
 var Packet = class _Packet {
   constructor(header, transport, pathLength, path, payload) {
     this.header = header;
@@ -182,13 +104,13 @@ var Packet = class _Packet {
     this.pathHashes = [];
     for (let i = 0; i < this.pathHashBytes; i += this.pathHashSize) {
       const hashBytes = this.path.slice(i, i + this.pathHashSize);
-      const hashHex = bytesToHex(hashBytes);
+      const hashHex = (0, import_packet2.bytesToHex)(hashBytes);
       this.pathHashes.push(hashHex);
     }
   }
   static fromBytes(bytes) {
     if (typeof bytes === "string") {
-      bytes = base64ToBytes(bytes);
+      bytes = (0, import_packet2.base64ToBytes)(bytes);
     }
     let offset = 0;
     const header = bytes[offset++];
@@ -209,14 +131,14 @@ var Packet = class _Packet {
     return routeType === 0 /* TRANSPORT_FLOOD */ || routeType === 3 /* TRANSPORT_DIRECT */;
   }
   hash() {
-    const hash = sha256.create();
+    const hash = import_sha2.sha256.create();
     hash.update(new Uint8Array([this.payloadType]));
     if (this.payloadType === 9 /* TRACE */) {
       hash.update(new Uint8Array([this.pathLength]));
     }
     hash.update(this.payload);
     const digest = hash.digest();
-    return bytesToHex(digest.slice(0, 8));
+    return (0, import_packet2.bytesToHex)(digest.slice(0, 8));
   }
   ensureStructure() {
     if (typeof this.structure !== "undefined") {
@@ -225,60 +147,83 @@ var Packet = class _Packet {
     let pathHashType;
     switch (this.pathHashSize) {
       case 1:
-        pathHashType = 6 /* BYTES */;
+        pathHashType = import_packet2.FieldType.BYTES;
         break;
       case 2:
-        pathHashType = 7 /* WORDS */;
+        pathHashType = import_packet2.FieldType.WORDS;
         break;
       case 4:
-        pathHashType = 8 /* DWORDS */;
+        pathHashType = import_packet2.FieldType.DWORDS;
         break;
       default:
         throw new Error(`Unsupported path hash size: ${this.pathHashSize}`);
     }
     this.structure = [
       /* Header segment */
-      { name: "header", data: new Uint8Array([this.header, this.pathLength, ...this.path]), fields: [
-        /* Header flags */
+      {
+        name: "header",
+        data: new Uint8Array([this.header]).buffer,
+        fields: [
+          /* Header flags */
+          {
+            name: "flags",
+            type: import_packet2.FieldType.BITS,
+            length: 1,
+            bits: [
+              { name: "payload version", size: 2 },
+              { name: "payload type", size: 4 },
+              { name: "route type", size: 2 }
+            ]
+          }
+        ]
+      },
+      /* Transport codes */
+      ..._Packet.hasTransportCodes(this.routeType) ? [
         {
-          name: "flags",
-          type: 0 /* BITS */,
-          size: 1,
-          bits: [
-            { name: "payload version", size: 2 },
-            { name: "payload type", size: 4 },
-            { name: "route type", size: 2 }
+          name: "transport codes",
+          data: new Uint8Array([
+            this.transport[0] >> 8 & 255,
+            this.transport[0] & 255,
+            this.transport[1] >> 8 & 255,
+            this.transport[1] & 255
+          ]).buffer,
+          fields: [
+            {
+              name: "transport code 1",
+              type: import_packet2.FieldType.UINT16_BE,
+              length: 2,
+              value: this.transport[0]
+            },
+            {
+              name: "transport code 2",
+              type: import_packet2.FieldType.UINT16_BE,
+              length: 2,
+              value: this.transport[1]
+            }
           ]
-        },
-        /* Transport codes */
-        ..._Packet.hasTransportCodes(this.routeType) ? [
+        }
+      ] : [],
+      /* Path length and hashes */
+      {
+        name: "path",
+        data: new Uint8Array([this.pathLength, ...this.path]).buffer,
+        fields: [
           {
-            name: "transport code 1",
-            type: 3 /* UINT16_BE */,
-            size: 2
+            name: "path length",
+            type: import_packet2.FieldType.UINT8,
+            length: 1,
+            bits: [
+              { name: "path hash size", size: 2 },
+              { name: "path hash count", size: 6 }
+            ]
           },
           {
-            name: "transport code 2",
-            type: 3 /* UINT16_BE */,
-            size: 2
+            name: "path hashes",
+            type: pathHashType,
+            length: this.path.length
           }
-        ] : [],
-        /* Path length and hashes */
-        {
-          name: "path length",
-          type: 1 /* UINT8 */,
-          size: 1,
-          bits: [
-            { name: "path hash size", size: 2 },
-            { name: "path hash count", size: 6 }
-          ]
-        },
-        {
-          name: "path hashes",
-          type: pathHashType,
-          size: this.path.length
-        }
-      ] }
+        ]
+      }
     ];
   }
   decode(withStructure) {
@@ -320,7 +265,6 @@ var Packet = class _Packet {
       default:
         throw new Error(`Unsupported payload type: ${this.payloadType}`);
     }
-    console.log("packet decode with structure:", typeof withStructure, withStructure, { result });
     if (typeof withStructure === "boolean" && withStructure && "segment" in result && "payload" in result) {
       this.ensureStructure();
       const structure = [...this.structure, result.segment];
@@ -329,17 +273,17 @@ var Packet = class _Packet {
     return result;
   }
   decodeEncryptedPayload(reader) {
-    const cipherMAC = reader.readBytes(2);
-    const cipherText = reader.readBytes(reader.remainingBytes());
+    const cipherMAC = reader.bytes(2);
+    const cipherText = reader.bytes();
     return { cipherMAC, cipherText };
   }
   decodeRequest(withSegment) {
     if (this.payload.length < 4) {
       throw new Error("Invalid request payload: too short");
     }
-    const reader = new BufferReader(this.payload);
-    const dst = reader.readByte();
-    const src = reader.readByte();
+    const reader = import_packet2.Reader.fromBytes(this.payload);
+    const dst = reader.uint8();
+    const src = reader.uint8();
     const encrypted = this.decodeEncryptedPayload(reader);
     const payload = {
       type: 0 /* REQUEST */,
@@ -350,12 +294,17 @@ var Packet = class _Packet {
     if (typeof withSegment === "boolean" && withSegment) {
       const segment = {
         name: "request payload",
-        data: this.payload,
+        data: new Uint8Array(this.payload).buffer,
         fields: [
-          { name: "destination hash", type: 1 /* UINT8 */, size: 1, value: dst },
-          { name: "source hash", type: 1 /* UINT8 */, size: 1, value: src },
-          { name: "cipher MAC", type: 6 /* BYTES */, size: 2, value: encrypted.cipherMAC },
-          { name: "cipher text", type: 6 /* BYTES */, size: encrypted.cipherText.length, value: encrypted.cipherText }
+          { name: "destination hash", type: import_packet2.FieldType.UINT8, length: 1, value: dst },
+          { name: "source hash", type: import_packet2.FieldType.UINT8, length: 1, value: src },
+          { name: "cipher MAC", type: import_packet2.FieldType.BYTES, length: 2, value: encrypted.cipherMAC },
+          {
+            name: "cipher text",
+            type: import_packet2.FieldType.BYTES,
+            length: encrypted.cipherText.length,
+            value: encrypted.cipherText
+          }
         ]
       };
       return { payload, segment };
@@ -366,9 +315,9 @@ var Packet = class _Packet {
     if (this.payload.length < 4) {
       throw new Error("Invalid response payload: too short");
     }
-    const reader = new BufferReader(this.payload);
-    const dst = reader.readByte();
-    const src = reader.readByte();
+    const reader = import_packet2.Reader.fromBytes(this.payload);
+    const dst = reader.uint8();
+    const src = reader.uint8();
     const encrypted = this.decodeEncryptedPayload(reader);
     const payload = {
       type: 1 /* RESPONSE */,
@@ -379,12 +328,17 @@ var Packet = class _Packet {
     if (typeof withSegment === "boolean" && withSegment) {
       const segment = {
         name: "response payload",
-        data: this.payload,
+        data: new Uint8Array(this.payload).buffer,
         fields: [
-          { name: "destination hash", type: 1 /* UINT8 */, size: 1, value: dst },
-          { name: "source hash", type: 1 /* UINT8 */, size: 1, value: src },
-          { name: "cipher MAC", type: 6 /* BYTES */, size: 2, value: encrypted.cipherMAC },
-          { name: "cipher text", type: 6 /* BYTES */, size: encrypted.cipherText.length, value: encrypted.cipherText }
+          { name: "destination hash", type: import_packet2.FieldType.UINT8, length: 1, value: dst },
+          { name: "source hash", type: import_packet2.FieldType.UINT8, length: 1, value: src },
+          { name: "cipher MAC", type: import_packet2.FieldType.BYTES, length: 2, value: encrypted.cipherMAC },
+          {
+            name: "cipher text",
+            type: import_packet2.FieldType.BYTES,
+            length: encrypted.cipherText.length,
+            value: encrypted.cipherText
+          }
         ]
       };
       return { payload, segment };
@@ -395,9 +349,9 @@ var Packet = class _Packet {
     if (this.payload.length < 4) {
       throw new Error("Invalid text payload: too short");
     }
-    const reader = new BufferReader(this.payload);
-    const dst = reader.readByte();
-    const src = reader.readByte();
+    const reader = import_packet2.Reader.fromBytes(this.payload);
+    const dst = reader.uint8();
+    const src = reader.uint8();
     const encrypted = this.decodeEncryptedPayload(reader);
     const payload = {
       type: 2 /* TEXT */,
@@ -408,12 +362,17 @@ var Packet = class _Packet {
     if (typeof withSegment === "boolean" && withSegment) {
       const segment = {
         name: "text payload",
-        data: this.payload,
+        data: new Uint8Array(this.payload).buffer,
         fields: [
-          { name: "destination hash", type: 1 /* UINT8 */, size: 1, value: dst },
-          { name: "source hash", type: 1 /* UINT8 */, size: 1, value: src },
-          { name: "cipher MAC", type: 6 /* BYTES */, size: 2, value: encrypted.cipherMAC },
-          { name: "cipher text", type: 6 /* BYTES */, size: encrypted.cipherText.length, value: encrypted.cipherText }
+          { name: "destination hash", type: import_packet2.FieldType.UINT8, length: 1, value: dst },
+          { name: "source hash", type: import_packet2.FieldType.UINT8, length: 1, value: src },
+          { name: "cipher MAC", type: import_packet2.FieldType.BYTES, length: 2, value: encrypted.cipherMAC },
+          {
+            name: "cipher text",
+            type: import_packet2.FieldType.BYTES,
+            length: encrypted.cipherText.length,
+            value: encrypted.cipherText
+          }
         ]
       };
       return { payload, segment };
@@ -424,8 +383,8 @@ var Packet = class _Packet {
     if (this.payload.length < 4) {
       throw new Error("Invalid ack payload: too short");
     }
-    const reader = new BufferReader(this.payload);
-    const checksum = reader.readBytes(4);
+    const reader = import_packet2.Reader.fromBytes(this.payload);
+    const checksum = reader.bytes(4);
     const payload = {
       type: 3 /* ACK */,
       checksum
@@ -433,10 +392,8 @@ var Packet = class _Packet {
     if (typeof withSegment === "boolean" && withSegment) {
       const segment = {
         name: "ack payload",
-        data: this.payload,
-        fields: [
-          { name: "checksum", type: 6 /* BYTES */, size: 4, value: checksum }
-        ]
+        data: new Uint8Array(this.payload).buffer,
+        fields: [{ name: "checksum", type: import_packet2.FieldType.BYTES, length: 4, value: checksum }]
       };
       return { payload, segment };
     }
@@ -446,26 +403,26 @@ var Packet = class _Packet {
     if (this.payload.length < 4) {
       throw new Error("Invalid advert payload: too short");
     }
-    const reader = new BufferReader(this.payload);
+    const reader = import_packet2.Reader.fromBytes(this.payload);
     const payload = {
       type: 4 /* ADVERT */,
-      publicKey: reader.readBytes(32),
-      timestamp: reader.readTimestamp(),
-      signature: reader.readBytes(64)
+      publicKey: reader.bytes(32),
+      timestamp: reader.date32(),
+      signature: reader.bytes(64)
     };
     let segment;
     if (typeof withSegment === "boolean" && withSegment) {
       segment = {
         name: "advert payload",
-        data: this.payload,
+        data: new Uint8Array(this.payload).buffer,
         fields: [
-          { type: 6 /* BYTES */, name: "public key", size: 32 },
-          { type: 4 /* UINT32_LE */, name: "timestamp", size: 4, value: payload.timestamp },
-          { type: 6 /* BYTES */, name: "signature", size: 64 }
+          { type: import_packet2.FieldType.BYTES, name: "public key", length: 32 },
+          { type: import_packet2.FieldType.UINT32_LE, name: "timestamp", length: 4, value: payload.timestamp },
+          { type: import_packet2.FieldType.BYTES, name: "signature", length: 64 }
         ]
       };
     }
-    const flags = reader.readByte();
+    const flags = reader.uint8();
     const appdata = {
       nodeType: flags & 15,
       hasLocation: (flags & 16 /* HAS_LOCATION */) !== 0,
@@ -474,44 +431,50 @@ var Packet = class _Packet {
       hasName: (flags & 128 /* HAS_NAME */) !== 0
     };
     if (typeof withSegment === "boolean" && withSegment) {
-      segment.fields.push({ type: 0 /* BITS */, name: "flags", size: 1, value: flags, bits: [
-        { size: 1, name: "name flag" },
-        { size: 1, name: "feature2 flag" },
-        { size: 1, name: "feature1 flag" },
-        { size: 1, name: "location flag" },
-        { size: 4, name: "node type" }
-      ] });
+      segment.fields.push({
+        type: import_packet2.FieldType.BITS,
+        name: "flags",
+        length: 1,
+        value: flags,
+        bits: [
+          { size: 1, name: "name flag" },
+          { size: 1, name: "feature2 flag" },
+          { size: 1, name: "feature1 flag" },
+          { size: 1, name: "location flag" },
+          { size: 4, name: "node type" }
+        ]
+      });
     }
     if (appdata.hasLocation) {
-      const lat = reader.readInt32LE() / 1e5;
-      const lon = reader.readInt32LE() / 1e5;
+      const lat = reader.int32() / 1e6;
+      const lon = reader.int32() / 1e6;
       appdata.location = [lat, lon];
       if (typeof withSegment === "boolean" && withSegment) {
-        segment.fields.push({ type: 4 /* UINT32_LE */, name: "latitude", size: 4, value: lat });
-        segment.fields.push({ type: 4 /* UINT32_LE */, name: "longitude", size: 4, value: lon });
+        segment.fields.push({ type: import_packet2.FieldType.UINT32_LE, name: "latitude", length: 4, value: lat });
+        segment.fields.push({ type: import_packet2.FieldType.UINT32_LE, name: "longitude", length: 4, value: lon });
       }
     }
     if (appdata.hasFeature1) {
-      appdata.feature1 = reader.readUint16LE();
+      appdata.feature1 = reader.uint16();
       if (typeof withSegment === "boolean" && withSegment) {
-        segment.fields.push({ type: 2 /* UINT16_LE */, name: "feature1", size: 2, value: appdata.feature1 });
+        segment.fields.push({ type: import_packet2.FieldType.UINT16_LE, name: "feature1", length: 2, value: appdata.feature1 });
       }
     }
     if (appdata.hasFeature2) {
-      appdata.feature2 = reader.readUint16LE();
+      appdata.feature2 = reader.uint16();
       if (typeof withSegment === "boolean" && withSegment) {
-        segment.fields.push({ type: 2 /* UINT16_LE */, name: "feature2", size: 2, value: appdata.feature2 });
+        segment.fields.push({ type: import_packet2.FieldType.UINT16_LE, name: "feature2", length: 2, value: appdata.feature2 });
       }
     }
     if (appdata.hasName) {
-      const nameBytes = reader.readBytes();
-      let nullPos = nameBytes.indexOf(0);
-      if (nullPos === -1) {
-        nullPos = nameBytes.length;
-      }
-      appdata.name = new TextDecoder("utf-8").decode(nameBytes.subarray(0, nullPos));
+      appdata.name = reader.cString();
       if (typeof withSegment === "boolean" && withSegment) {
-        segment.fields.push({ type: 10 /* C_STRING */, name: "name", size: nameBytes.length, value: appdata.name });
+        segment.fields.push({
+          type: import_packet2.FieldType.C_STRING,
+          name: "name",
+          length: appdata.name.length,
+          value: appdata.name
+        });
       }
     }
     if (typeof withSegment === "boolean" && withSegment && typeof segment !== "undefined") {
@@ -523,8 +486,8 @@ var Packet = class _Packet {
     if (this.payload.length < 3) {
       throw new Error("Invalid group text payload: too short");
     }
-    const reader = new BufferReader(this.payload);
-    const channelHash = reader.readByte();
+    const reader = import_packet2.Reader.fromBytes(this.payload);
+    const channelHash = reader.uint8();
     const encrypted = this.decodeEncryptedPayload(reader);
     const payload = {
       type: 5 /* GROUP_TEXT */,
@@ -534,11 +497,16 @@ var Packet = class _Packet {
     if (typeof withSegment === "boolean" && withSegment) {
       const segment = {
         name: "group text payload",
-        data: this.payload,
+        data: new Uint8Array(this.payload).buffer,
         fields: [
-          { name: "channel hash", type: 1 /* UINT8 */, size: 1, value: channelHash },
-          { name: "cipher MAC", type: 6 /* BYTES */, size: 2, value: encrypted.cipherMAC },
-          { name: "cipher text", type: 6 /* BYTES */, size: encrypted.cipherText.length, value: encrypted.cipherText }
+          { name: "channel hash", type: import_packet2.FieldType.UINT8, length: 1, value: channelHash },
+          { name: "cipher MAC", type: import_packet2.FieldType.BYTES, length: 2, value: encrypted.cipherMAC },
+          {
+            name: "cipher text",
+            type: import_packet2.FieldType.BYTES,
+            length: encrypted.cipherText.length,
+            value: encrypted.cipherText
+          }
         ]
       };
       return { payload, segment };
@@ -549,20 +517,25 @@ var Packet = class _Packet {
     if (this.payload.length < 3) {
       throw new Error("Invalid group data payload: too short");
     }
-    const reader = new BufferReader(this.payload);
+    const reader = import_packet2.Reader.fromBytes(this.payload);
     const payload = {
       type: 6 /* GROUP_DATA */,
-      channelHash: reader.readByte(),
+      channelHash: reader.uint8(),
       encrypted: this.decodeEncryptedPayload(reader)
     };
     if (typeof withSegment === "boolean" && withSegment) {
       const segment = {
         name: "group data payload",
-        data: this.payload,
+        data: new Uint8Array(this.payload).buffer,
         fields: [
-          { name: "channel hash", type: 1 /* UINT8 */, size: 1, value: payload.channelHash },
-          { name: "cipher MAC", type: 6 /* BYTES */, size: 2, value: payload.encrypted.cipherMAC },
-          { name: "cipher text", type: 6 /* BYTES */, size: payload.encrypted.cipherText.length, value: payload.encrypted.cipherText }
+          { name: "channel hash", type: import_packet2.FieldType.UINT8, length: 1, value: payload.channelHash },
+          { name: "cipher MAC", type: import_packet2.FieldType.BYTES, length: 2, value: payload.encrypted.cipherMAC },
+          {
+            name: "cipher text",
+            type: import_packet2.FieldType.BYTES,
+            length: payload.encrypted.cipherText.length,
+            value: payload.encrypted.cipherText
+          }
         ]
       };
       return { payload, segment };
@@ -573,22 +546,27 @@ var Packet = class _Packet {
     if (this.payload.length < 1 + 32 + 2) {
       throw new Error("Invalid anon req payload: too short");
     }
-    const reader = new BufferReader(this.payload);
+    const reader = import_packet2.Reader.fromBytes(this.payload);
     const payload = {
       type: 7 /* ANON_REQ */,
-      dst: reader.readByte(),
-      publicKey: reader.readBytes(32),
+      dst: reader.uint8(),
+      publicKey: reader.bytes(32),
       encrypted: this.decodeEncryptedPayload(reader)
     };
     if (typeof withSegment === "boolean" && withSegment) {
       const segment = {
         name: "anon req payload",
-        data: this.payload,
+        data: new Uint8Array(this.payload).buffer,
         fields: [
-          { name: "destination hash", type: 1 /* UINT8 */, size: 1, value: payload.dst },
-          { name: "public key", type: 6 /* BYTES */, size: 32, value: payload.publicKey },
-          { name: "cipher MAC", type: 6 /* BYTES */, size: 2, value: payload.encrypted.cipherMAC },
-          { name: "cipher text", type: 6 /* BYTES */, size: payload.encrypted.cipherText.length, value: payload.encrypted.cipherText }
+          { name: "destination hash", type: import_packet2.FieldType.UINT8, length: 1, value: payload.dst },
+          { name: "public key", type: import_packet2.FieldType.BYTES, length: 32, value: payload.publicKey },
+          { name: "cipher MAC", type: import_packet2.FieldType.BYTES, length: 2, value: payload.encrypted.cipherMAC },
+          {
+            name: "cipher text",
+            type: import_packet2.FieldType.BYTES,
+            length: payload.encrypted.cipherText.length,
+            value: payload.encrypted.cipherText
+          }
         ]
       };
       return { payload, segment };
@@ -599,19 +577,19 @@ var Packet = class _Packet {
     if (this.payload.length < 2) {
       throw new Error("Invalid path payload: too short");
     }
-    const reader = new BufferReader(this.payload);
+    const reader = import_packet2.Reader.fromBytes(this.payload);
     const payload = {
       type: 8 /* PATH */,
-      dst: reader.readByte(),
-      src: reader.readByte()
+      dst: reader.uint8(),
+      src: reader.uint8()
     };
     if (typeof withSegment === "boolean" && withSegment) {
       const segment = {
         name: "path payload",
-        data: this.payload,
+        data: new Uint8Array(this.payload).buffer,
         fields: [
-          { name: "destination hash", type: 1 /* UINT8 */, size: 1, value: payload.dst },
-          { name: "source hash", type: 1 /* UINT8 */, size: 1, value: payload.src }
+          { name: "destination hash", type: import_packet2.FieldType.UINT8, length: 1, value: payload.dst },
+          { name: "source hash", type: import_packet2.FieldType.UINT8, length: 1, value: payload.src }
         ]
       };
       return { payload, segment };
@@ -622,23 +600,23 @@ var Packet = class _Packet {
     if (this.payload.length < 9) {
       throw new Error("Invalid trace payload: too short");
     }
-    const reader = new BufferReader(this.payload);
+    const reader = import_packet2.Reader.fromBytes(this.payload);
     const payload = {
       type: 9 /* TRACE */,
-      tag: reader.readUint32LE() >>> 0,
-      authCode: reader.readUint32LE() >>> 0,
-      flags: reader.readByte() & 3,
-      nodes: reader.readBytes()
+      tag: reader.uint32(),
+      authCode: reader.uint32(),
+      flags: reader.uint8() & 3,
+      nodes: reader.bytes()
     };
     if (typeof withSegment === "boolean" && withSegment) {
       const segment = {
         name: "trace payload",
-        data: this.payload,
+        data: new Uint8Array(this.payload).buffer,
         fields: [
-          { name: "tag", type: 8 /* DWORDS */, size: 4, value: payload.tag },
-          { name: "auth code", type: 8 /* DWORDS */, size: 4, value: payload.authCode },
-          { name: "flags", type: 1 /* UINT8 */, size: 1, value: payload.flags },
-          { name: "nodes", type: 6 /* BYTES */, size: payload.nodes.length, value: payload.nodes }
+          { name: "tag", type: import_packet2.FieldType.DWORDS, length: 4, value: payload.tag },
+          { name: "auth code", type: import_packet2.FieldType.DWORDS, length: 4, value: payload.authCode },
+          { name: "flags", type: import_packet2.FieldType.UINT8, length: 1, value: payload.flags },
+          { name: "nodes", type: import_packet2.FieldType.BYTES, length: payload.nodes.length, value: payload.nodes }
         ]
       };
       return { payload, segment };
@@ -653,10 +631,8 @@ var Packet = class _Packet {
     if (typeof withSegment === "boolean" && withSegment) {
       const segment = {
         name: "raw custom payload",
-        data: this.payload,
-        fields: [
-          { name: "data", type: 6 /* BYTES */, size: this.payload.length, value: this.payload }
-        ]
+        data: new Uint8Array(this.payload).buffer,
+        fields: [{ name: "data", type: import_packet2.FieldType.BYTES, length: this.payload.length, value: this.payload }]
       };
       return { payload, segment };
     }
@@ -665,35 +641,39 @@ var Packet = class _Packet {
 };
 
 // src/crypto.ts
-import { ed25519, x25519 } from "@noble/curves/ed25519.js";
-import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
-import { hmac } from "@noble/hashes/hmac.js";
-import { ecb } from "@noble/ciphers/aes.js";
+var import_ed25519 = require("@noble/curves/ed25519.js");
+var import_sha22 = require("@noble/hashes/sha2.js");
+var import_hmac = require("@noble/hashes/hmac.js");
+var import_aes = require("@noble/ciphers/aes.js");
+var import_packet3 = require("@hamradio/packet");
 var PUBLIC_KEY_SIZE = 32;
 var SEED_SIZE = 32;
 var HMAC_SIZE = 2;
-var SHARED_SECRET_SIZE = 32;
+var SHARED_SECRET_SIZE = 16;
 var SIGNATURE_SIZE = 64;
 var STATIC_SECRET_SIZE = 32;
-var publicSecret = hexToBytes("8b3387e9c5cdea6ac9e5edbaa115cd72", 16);
+var publicSecret = (0, import_packet3.hexToBytes)("8b3387e9c5cdea6ac9e5edbaa115cd72");
 var PublicKey = class _PublicKey {
   constructor(key) {
     if (typeof key === "string") {
-      this.key = hexToBytes(key, PUBLIC_KEY_SIZE);
+      this.key = (0, import_packet3.hexToBytes)(key);
     } else if (key instanceof Uint8Array) {
       this.key = key;
     } else {
       throw new Error("Invalid type for PublicKey constructor");
     }
+    if (this.key.length !== PUBLIC_KEY_SIZE) {
+      throw new Error(`Invalid public key length: expected ${PUBLIC_KEY_SIZE} bytes, got ${this.key.length}`);
+    }
   }
   toHash() {
-    return sha2562.create().update(this.key).digest()[0];
+    return import_sha22.sha256.create().update(this.key).digest()[0];
   }
   toBytes() {
     return this.key;
   }
   toString() {
-    return bytesToHex(this.key);
+    return (0, import_packet3.bytesToHex)(this.key);
   }
   equals(other) {
     let otherKey;
@@ -702,28 +682,39 @@ var PublicKey = class _PublicKey {
     } else if (other instanceof Uint8Array) {
       otherKey = other;
     } else if (typeof other === "string") {
-      otherKey = hexToBytes(other, PUBLIC_KEY_SIZE);
+      otherKey = (0, import_packet3.hexToBytes)(other);
     } else {
       throw new Error("Invalid type for PublicKey comparison");
     }
-    return equalBytes(this.key, otherKey);
+    if (otherKey.length !== PUBLIC_KEY_SIZE) {
+      throw new Error(
+        `Invalid public key length for comparison: expected ${PUBLIC_KEY_SIZE} bytes, got ${otherKey.length}`
+      );
+    }
+    return (0, import_packet3.equalBytes)(this.key, otherKey);
   }
   verify(message, signature) {
     if (signature.length !== SIGNATURE_SIZE) {
       throw new Error(`Invalid signature length: expected ${SIGNATURE_SIZE} bytes, got ${signature.length}`);
     }
-    return ed25519.verify(signature, message, this.key);
+    return import_ed25519.ed25519.verify(signature, message, this.key);
+  }
+  static fromBytes(key) {
+    return new _PublicKey(key);
+  }
+  static fromString(key) {
+    return new _PublicKey(key);
   }
 };
 var PrivateKey = class _PrivateKey {
   constructor(seed) {
     if (typeof seed === "string") {
-      seed = hexToBytes(seed, SEED_SIZE);
+      seed = (0, import_packet3.hexToBytes)(seed);
     }
     if (seed.length !== SEED_SIZE) {
       throw new Error(`Invalid seed length: expected ${SEED_SIZE} bytes, got ${seed.length}`);
     }
-    const { secretKey, publicKey } = ed25519.keygen(seed);
+    const { secretKey, publicKey } = import_ed25519.ed25519.keygen(seed);
     this.secretKey = secretKey;
     this.publicKey = new PublicKey(publicKey);
   }
@@ -734,10 +725,10 @@ var PrivateKey = class _PrivateKey {
     return this.secretKey;
   }
   toString() {
-    return bytesToHex(this.secretKey);
+    return (0, import_packet3.bytesToHex)(this.secretKey);
   }
   sign(message) {
-    return ed25519.sign(message, this.secretKey);
+    return import_ed25519.ed25519.sign(message, this.secretKey);
   }
   calculateSharedSecret(other) {
     let otherPublicKey;
@@ -750,43 +741,40 @@ var PrivateKey = class _PrivateKey {
     } else {
       throw new Error("Invalid type for calculateSharedSecret comparison");
     }
-    return x25519.getSharedSecret(this.secretKey, otherPublicKey.toBytes());
+    return import_ed25519.x25519.getSharedSecret(this.secretKey, otherPublicKey.toBytes());
   }
   static generate() {
-    const { secretKey } = ed25519.keygen();
+    const { secretKey } = import_ed25519.ed25519.keygen();
     return new _PrivateKey(secretKey);
   }
 };
 var SharedSecret = class _SharedSecret {
   constructor(secret) {
-    if (secret.length === SHARED_SECRET_SIZE / 2) {
-      const padded = new Uint8Array(SHARED_SECRET_SIZE);
-      padded.set(secret, SHARED_SECRET_SIZE - secret.length);
-      secret = padded;
-    }
     if (secret.length !== SHARED_SECRET_SIZE) {
       throw new Error(`Invalid shared secret length: expected ${SHARED_SECRET_SIZE} bytes, got ${secret.length}`);
     }
-    this.secret = secret;
+    this.secret = new Uint8Array(SHARED_SECRET_SIZE * 2);
+    this.secret.set(secret, 0);
   }
   toHash() {
-    return this.secret[0];
+    const hash = import_sha22.sha256.create().update(this.secret.slice(0, 16)).digest();
+    return hash[0];
   }
   toBytes() {
-    return this.secret;
+    return this.secret.slice(0, 16);
   }
   toString() {
-    return bytesToHex(this.secret);
+    return (0, import_packet3.bytesToHex)(this.secret.slice(0, 16));
   }
   decrypt(hmac2, ciphertext) {
     if (hmac2.length !== HMAC_SIZE) {
       throw new Error(`Invalid HMAC length: expected ${HMAC_SIZE} bytes, got ${hmac2.length}`);
     }
     const expectedHmac = this.calculateHmac(ciphertext);
-    if (!equalBytes(hmac2, expectedHmac)) {
-      throw new Error(`Invalid HMAC: decryption failed: expected ${bytesToHex(expectedHmac)}, got ${bytesToHex(hmac2)}`);
+    if (!(0, import_packet3.equalBytes)(hmac2, expectedHmac)) {
+      throw new Error(`Invalid HMAC: decryption failed: expected ${(0, import_packet3.bytesToHex)(expectedHmac)}, got ${(0, import_packet3.bytesToHex)(hmac2)}`);
     }
-    const cipher = ecb(this.secret.slice(0, 16), { disablePadding: true });
+    const cipher = (0, import_aes.ecb)(this.secret.slice(0, 16), { disablePadding: true });
     const plaintext = new Uint8Array(ciphertext.length);
     for (let i = 0; i < ciphertext.length; i += 16) {
       const block = ciphertext.slice(i, i + 16);
@@ -801,7 +789,7 @@ var SharedSecret = class _SharedSecret {
   }
   encrypt(data) {
     const key = this.secret.slice(0, 16);
-    const cipher = ecb(key, { disablePadding: true });
+    const cipher = (0, import_aes.ecb)(key, { disablePadding: true });
     const fullBlocks = Math.floor(data.length / 16);
     const remaining = data.length % 16;
     const ciphertext = new Uint8Array((fullBlocks + (remaining > 0 ? 1 : 0)) * 16);
@@ -820,7 +808,7 @@ var SharedSecret = class _SharedSecret {
     return { hmac: hmac2, ciphertext };
   }
   calculateHmac(data) {
-    return hmac(sha2562, this.secret, data).slice(0, HMAC_SIZE);
+    return (0, import_hmac.hmac)(import_sha22.sha256, this.secret, data).slice(0, HMAC_SIZE);
   }
   static fromName(name) {
     if (name === "Public") {
@@ -828,14 +816,14 @@ var SharedSecret = class _SharedSecret {
     } else if (!/^#/.test(name)) {
       throw new Error("Only the 'Public' group or groups starting with '#' are supported");
     }
-    const hash = sha2562.create().update(new TextEncoder().encode(name)).digest();
+    const hash = import_sha22.sha256.create().update(new TextEncoder().encode(name)).digest();
     return new _SharedSecret(hash.slice(0, SHARED_SECRET_SIZE));
   }
 };
 var StaticSecret = class {
   constructor(secret) {
     if (typeof secret === "string") {
-      secret = hexToBytes(secret, STATIC_SECRET_SIZE);
+      secret = (0, import_packet3.hexToBytes)(secret);
     }
     if (secret.length !== STATIC_SECRET_SIZE) {
       throw new Error(`Invalid static secret length: expected ${STATIC_SECRET_SIZE} bytes, got ${secret.length}`);
@@ -843,16 +831,17 @@ var StaticSecret = class {
     this.secret = secret;
   }
   publicKey() {
-    const publicKey = x25519.getPublicKey(this.secret);
+    const publicKey = import_ed25519.x25519.getPublicKey(this.secret);
     return new PublicKey(publicKey);
   }
   diffieHellman(otherPublicKey) {
-    const sharedSecret = x25519.getSharedSecret(this.secret, otherPublicKey.toBytes());
-    return new SharedSecret(sharedSecret);
+    const sharedSecret = import_ed25519.x25519.getSharedSecret(this.secret, otherPublicKey.toBytes());
+    return new SharedSecret(sharedSecret.slice(0, 16));
   }
 };
 
 // src/identity.ts
+var import_packet4 = require("@hamradio/packet");
 var parseNodeHash = (hash) => {
   if (hash instanceof Uint8Array) {
     return hash[0];
@@ -863,7 +852,7 @@ var parseNodeHash = (hash) => {
     }
     return hash;
   } else if (typeof hash === "string") {
-    const parsed = hexToBytes(hash);
+    const parsed = (0, import_packet4.hexToBytes)(hash);
     if (parsed.length !== 1) {
       throw new Error("NodeHash string must represent a single byte");
     }
@@ -879,7 +868,7 @@ var toPublicKeyBytes = (key) => {
   } else if (key instanceof Uint8Array) {
     return key;
   } else if (typeof key === "string") {
-    return hexToBytes(key);
+    return (0, import_packet4.hexToBytes)(key);
   } else {
     throw new Error("Invalid type for toPublicKeyBytes");
   }
@@ -938,7 +927,7 @@ var LocalIdentity = class extends Identity {
     } else {
       throw new Error("Invalid type for calculateSharedSecret comparison");
     }
-    return new SharedSecret(this.privateKey.calculateSharedSecret(otherPublicKey));
+    return new SharedSecret(this.privateKey.calculateSharedSecret(otherPublicKey).slice(0, 16));
   }
 };
 var Contact = class {
@@ -982,12 +971,12 @@ var Group = class {
     if (data.length < 5) {
       throw new Error("Invalid ciphertext");
     }
-    const reader = new BufferReader(data);
-    const timestamp = reader.readTimestamp();
-    const flags = reader.readByte();
+    const reader = new import_packet4.Reader(data);
+    const timestamp = reader.date32();
+    const flags = reader.uint8();
     const textType = flags >> 2 & 63;
     const attempt = flags & 3;
-    const message = new TextDecoder("utf-8").decode(reader.readBytes());
+    const message = new TextDecoder("utf-8").decode(reader.bytes());
     return {
       timestamp,
       textType,
@@ -996,11 +985,11 @@ var Group = class {
     };
   }
   encryptText(plain) {
-    const writer = new BufferWriter();
-    writer.writeTimestamp(plain.timestamp);
+    const writer = new import_packet4.Writer(4 + 1 + new TextEncoder().encode(plain.message).length);
+    writer.date32(plain.timestamp);
     const flags = (plain.textType & 63) << 2 | plain.attempt & 3;
-    writer.writeByte(flags);
-    writer.writeBytes(new TextEncoder().encode(plain.message));
+    writer.uint8(flags);
+    writer.utf8String(plain.message);
     const data = writer.toBytes();
     return this.secret.encrypt(data);
   }
@@ -1009,16 +998,16 @@ var Group = class {
     if (data.length < 4) {
       throw new Error("Invalid ciphertext");
     }
-    const reader = new BufferReader(data);
+    const reader = new import_packet4.Reader(data);
     return {
-      timestamp: reader.readTimestamp(),
-      data: reader.readBytes(reader.remainingBytes())
+      timestamp: reader.date32(),
+      data: reader.bytes()
     };
   }
   encryptData(plain) {
-    const writer = new BufferWriter();
-    writer.writeTimestamp(plain.timestamp);
-    writer.writeBytes(plain.data);
+    const writer = new import_packet4.Writer(4 + plain.data.length);
+    writer.date32(plain.timestamp);
+    writer.bytes(plain.data);
     const data = writer.toBytes();
     return this.secret.encrypt(data);
   }
@@ -1028,6 +1017,8 @@ var Contacts = class {
     this.localIdentities = [];
     this.contacts = {};
     this.groups = {};
+    this.addGroup(new Group("Public"));
+    this.addGroup(new Group("#test"));
   }
   addLocalIdentity(identity) {
     this.localIdentities.push({ identity, sharedSecrets: {} });
@@ -1039,6 +1030,23 @@ var Contacts = class {
     }
     this.contacts[hash].push(contact);
   }
+  hasContact(nameOrHash) {
+    if (typeof nameOrHash === "string") {
+      return Object.values(this.contacts).flat().some((contact) => contact.name.toLowerCase() === nameOrHash.toLowerCase());
+    } else {
+      const hash = parseNodeHash(nameOrHash);
+      return (this.contacts[hash] || []).length > 0;
+    }
+  }
+  getContactByName(name) {
+    const contact = Object.values(this.contacts).flat().find((contact2) => contact2.name.toLowerCase() === name.toLowerCase());
+    return contact || null;
+  }
+  getContacts() {
+    const contacts = Object.values(this.contacts).flat();
+    contacts.sort((a, b) => a.name.localeCompare(b.name));
+    return contacts;
+  }
   decrypt(src, dst, hmac2, ciphertext) {
     let contacts = [];
     if (src instanceof PublicKey) {
@@ -1086,17 +1094,45 @@ var Contacts = class {
     return sharedSecret;
   }
   addGroup(group) {
-    const hash = parseNodeHash(group.hash());
+    for (const key of Object.keys(this.groups)) {
+      const hash2 = Number(key);
+      this.groups[hash2] = this.groups[hash2].filter((g) => g.name.toLowerCase() !== group.name.toLowerCase());
+      if (this.groups[hash2].length === 0) {
+        delete this.groups[hash2];
+      }
+    }
+    const hash = group.hash();
     if (!this.groups[hash]) {
       this.groups[hash] = [];
     }
     this.groups[hash].push(group);
   }
+  hasGroup(nameOrHash) {
+    if (typeof nameOrHash === "string") {
+      return Object.values(this.groups).flat().some((group) => group.name.toLowerCase() === nameOrHash.toLowerCase());
+    } else {
+      const hash = parseNodeHash(nameOrHash);
+      return (this.groups[hash] || []).length > 0;
+    }
+  }
+  getGroupByName(name) {
+    const group = Object.values(this.groups).flat().find((group2) => group2.name.toLowerCase() === name.toLowerCase());
+    return group || null;
+  }
+  getGroups() {
+    const groups = Object.values(this.groups).flat();
+    groups.sort((a, b) => {
+      if (a.name === "Public") return -1;
+      if (b.name === "Public") return 1;
+      return a.name.localeCompare(b.name);
+    });
+    return groups;
+  }
   decryptGroupText(channelHash, hmac2, ciphertext) {
     const hash = parseNodeHash(channelHash);
     const groups = this.groups[hash] || [];
     if (groups.length === 0) {
-      throw new Error("Unknown group hash");
+      throw new Error(`Unknown group hash ${hash.toString(16).padStart(2, "0")}`);
     }
     for (const group of groups) {
       try {
@@ -1105,13 +1141,13 @@ var Contacts = class {
       } catch {
       }
     }
-    throw new Error("Decryption failed with all known groups");
+    throw new Error(`Decryption failed with all known groups with hash ${hash.toString(16).padStart(2, "0")}`);
   }
   decryptGroupData(channelHash, hmac2, ciphertext) {
     const hash = parseNodeHash(channelHash);
     const groups = this.groups[hash] || [];
     if (groups.length === 0) {
-      throw new Error("Unknown group hash");
+      throw new Error(`Unknown group hash ${hash.toString(16).padStart(2, "0")}`);
     }
     for (const group of groups) {
       try {
@@ -1120,10 +1156,11 @@ var Contacts = class {
       } catch {
       }
     }
-    throw new Error("Decryption failed with all known groups");
+    throw new Error(`Decryption failed with all known groups with hash ${hash.toString(16).padStart(2, "0")}`);
   }
 };
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   Contact,
   Contacts,
   Group,
@@ -1140,4 +1177,4 @@ export {
   StaticSecret,
   TextType,
   parseNodeHash
-};
+});