bump version

Merge pull request #241 from jwetzell/dependabot/npm_and_yarn/eslint-10.5.0
Merge pull request #242 from jwetzell/dependabot/npm_and_yarn/prettier-3.8.4
2026-08-17 13:23:43 +00:00 · 2026-06-21 12:56:37 -05:00 · 2026-06-21 10:41:59 -05:00 · 2026-06-21 10:41:46 -05:00 · 2026-06-21 10:41:34 -05:00 · 2026-06-15 12:33:48 +00:00
73 changed files with 3921 additions and 885 deletions
@@ -4,3 +4,6 @@ updates:
    directory: '/'
    schedule:
      interval: 'weekly'
+    ignore:
+      - dependency-name: "@types*"
+        update-types: ["version-update:semver-major", "version-update:semver-minor"]
@@ -4,7 +4,7 @@ on:
    branches:
      - main
 jobs:
-  build-webui:
+  build:
    runs-on: ubuntu-latest
    steps:
      - name: Check out repository
@@ -22,5 +22,3 @@ jobs:

      - name: Publish to NPM
        run: npm publish --provenance --access=public
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
@@ -0,0 +1,25 @@
+name: Run @jwetzell/posistagenet tests
+on:
+  pull_request:
+    branches:
+      - main
+    paths:
+      - 'src/**'
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938 # v4.2.0
+
+      - name: Set up Node.js
+        uses: actions/setup-node@0a44ba7841725637a19e28fa30b79a866c81b0a6 # v4.0.4
+        with:
+          node-version-file: '.nvmrc'
+          cache: 'npm'
+          cache-dependency-path: './package-lock.json'
+
+      - name: Install Node.js dependencies
+        run: npm ci
+
+      - run: npm run test
@@ -1 +1 @@
-v20.15.1
+v24.15.0
@@ -2,7 +2,7 @@
  "editor.defaultFormatter": "esbenp.prettier-vscode",
  "editor.formatOnSave": true,
  "editor.codeActionsOnSave": {
-    "source.fixAll": true,
-    "source.organizeImports": true
+    "source.fixAll": "explicit",
+    "source.organizeImports": "explicit"
  }
 }
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Joel Wetzell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
@@ -13,14 +13,22 @@ typesecript implementation of the [PosiStageNet protocol](https://github.com/vyv
 const { Decoder } = require('@jwetzell/posistagenet')
 const decoder = new Decoder()

-const infoPacketBuffer = Buffer.from('5667348000000c0001000000000000000203010101000b00536572766572204e616d650200118001000d8000000900547261636b65722031','hex')
-const dataPacketBuffer = Buffer.from('5567288000000c00010000000000000002030101010014800100108000000c000000803f0000803f0000803f','hex')
+const infoPacketBuffer = new Uint8Array([
+  0x56, 0x67, 0x34, 0x80, 0x00, 0x00, 0x0c, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x03, 0x01,
+  0x01, 0x01, 0x00, 0x0b, 0x00, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x4e, 0x61, 0x6d, 0x65, 0x02, 0x00, 0x11,
+  0x80, 0x01, 0x00, 0x0d, 0x80, 0x00, 0x00, 0x09, 0x00, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x65, 0x72, 0x20, 0x31,
+]);
+const dataPacketBuffer = new Uint8Array([
+  0x55, 0x67, 0x28, 0x80, 0x00, 0x00, 0x0c, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x03, 0x01,
+  0x01, 0x01, 0x00, 0x14, 0x80, 0x01, 0x00, 0x10, 0x80, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00,
+  0x80, 0x3f, 0x00, 0x00, 0x80, 0x3f,
+]);

 decoder.decode(infoPacketBuffer)
 decoder.decode(dataPacketBuffer)

 // the system_name from info packets if available
-console.log(decoder.system_name)
+console.log(decoder.systemName)

 // map of trackers populated with any data that has been received
 // this merges both info and data packet properties into one
@@ -49,12 +57,12 @@ const infoPackets = encoder.getInfoPackets(timestamp, trackers)

 dataPackets.forEach((dataPacket)=>{
    console.log('send packet somehow')
-    console.log(dataPacket.toString('hex'))
+    console.log(dataPacket)
 })

 infoPackets.forEach((infoPacket)=>{
    console.log('send packet somehow')
-    console.log(infoPacket.toString('hex'))
+    console.log(infoPacket)
 })

 ```
@@ -1,4 +1,4 @@
-const { Encoder, Decoder, Tracker } = require('./dist');
+const { Encoder, Decoder, Tracker } = require('./dist/cjs');

 const testSizes = [1, 10, 100, 1000];

@@ -40,7 +40,7 @@ function benchmark(trackerCount, iterations) {
  for (let index = 0; index < iterations; index += 1) {
    latestEncodedPackets = encoder.getDataPackets(Date.now(), trackers);
  }
-  benchmarkResults.data.encode = `${(performance.now() - dataEncoderStart).toFixed(2)}ms`;
+  benchmarkResults.data.encode = performance.now() - dataEncoderStart;

  const dataDecodedStart = performance.now();
  for (let index = 0; index < iterations; index += 1) {
@@ -48,14 +48,14 @@ function benchmark(trackerCount, iterations) {
      decoder.decode(packet);
    });
  }
-  benchmarkResults.data.decode = `${(performance.now() - dataDecodedStart).toFixed(2)}ms`;
+  benchmarkResults.data.decode = performance.now() - dataDecodedStart;

  // INFO
  const infoEncoderStart = performance.now();
  for (let index = 0; index < iterations; index += 1) {
    latestEncodedPackets = encoder.getInfoPackets(Date.now(), trackers);
  }
-  benchmarkResults.info.encode = `${(performance.now() - infoEncoderStart).toFixed(2)}ms`;
+  benchmarkResults.info.encode = performance.now() - infoEncoderStart;

  const infoDecodeStart = performance.now();
  for (let index = 0; index < iterations; index += 1) {
@@ -63,9 +63,9 @@ function benchmark(trackerCount, iterations) {
      decoder.decode(packet);
    });
  }
-  benchmarkResults.info.decode = `${(performance.now() - infoDecodeStart).toFixed(2)}ms`;
+  benchmarkResults.info.decode = performance.now() - infoDecodeStart;

-  console.table(benchmarkResults);
+  console.log(benchmarkResults);
 }

 testSizes.forEach((iterations) => {
@@ -0,0 +1,13 @@
+import pluginJs from '@eslint/js';
+import eslintPluginPrettierRecommended from 'eslint-plugin-prettier/recommended';
+import globals from 'globals';
+import tseslint from 'typescript-eslint';
+
+/** @type {import('eslint').Linter.Config[]} */
+export default [
+  { files: ['**/*.{js,mjs,cjs,ts}'] },
+  { languageOptions: { globals: { ...globals.browser, ...globals.node } } },
+  pluginJs.configs.recommended,
+  ...tseslint.configs.recommended,
+  eslintPluginPrettierRecommended,
+];
@@ -0,0 +1,24 @@
+const { Decoder } = require('../dist/cjs');
+
+const decoder = new Decoder();
+
+const infoPacketBuffer = new Uint8Array([
+  0x56, 0x67, 0x34, 0x80, 0x00, 0x00, 0x0c, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x03, 0x01,
+  0x01, 0x01, 0x00, 0x0b, 0x00, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x4e, 0x61, 0x6d, 0x65, 0x02, 0x00, 0x11,
+  0x80, 0x01, 0x00, 0x0d, 0x80, 0x00, 0x00, 0x09, 0x00, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x65, 0x72, 0x20, 0x31,
+]);
+const dataPacketBuffer = new Uint8Array([
+  0x55, 0x67, 0x28, 0x80, 0x00, 0x00, 0x0c, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x03, 0x01,
+  0x01, 0x01, 0x00, 0x14, 0x80, 0x01, 0x00, 0x10, 0x80, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x80, 0x3f, 0x00, 0x00,
+  0x80, 0x3f, 0x00, 0x00, 0x80, 0x3f,
+]);
+
+decoder.decode(infoPacketBuffer);
+decoder.decode(dataPacketBuffer);
+
+// the system_name from info packets if available
+console.log(decoder.systemName);
+
+// map of trackers populated with any data that has been received
+// this merges both info and data packet properties into one
+console.log(decoder.trackers);
@@ -0,0 +1,26 @@
+const { Encoder, Tracker } = require('../dist/cjs');
+
+const encoder = new Encoder('Server Name', 2, 3); // server name, version high, version low
+
+const trackers = [];
+
+const tracker = new Tracker(1, 'Tracker 1'); // id, name
+tracker.setPos(1.0, 1.0, 1.0); // x, y, z
+
+trackers.push(tracker);
+
+const timestamp = 1;
+
+// these two calls return an array of Buffers due to potential splitting that might take place because of max UDP packet size
+const dataPackets = encoder.getDataPackets(timestamp, trackers);
+const infoPackets = encoder.getInfoPackets(timestamp, trackers);
+
+dataPackets.forEach((dataPacket) => {
+  console.log('send packet somehow');
+  console.log(dataPacket);
+});
+
+infoPackets.forEach((infoPacket) => {
+  console.log('send packet somehow');
+  console.log(infoPacket);
+});
@@ -1,6 +1,6 @@
 // recreation of psn_client.cpp example from https://github.com/vyv/psn-cpp
 const dgram = require('dgram');
-const { Decoder } = require('../dist');
+const { Decoder } = require('../dist/cjs');

 const client = dgram.createSocket('udp4');
 const decoder = new Decoder();
@@ -23,18 +23,18 @@ setInterval(() => {
  }

  Object.entries(decoder.trackers).forEach(([trackerId, tracker]) => {
-    const trackerName = decoder.trackers[trackerId]?.tracker_name?.tracker_name;
+    const trackerName = decoder.trackers[trackerId]?.name;
    console.log(`Tracker - id: ${trackerId} | name: ${trackerName || ''}`);
    if (tracker.pos) {
-      console.log(`\tpos: ${tracker.pos.pos_x}, ${tracker.pos.pos_y}, ${tracker.pos.pos_z}`);
+      console.log(`\tpos: ${tracker.pos.x}, ${tracker.pos.x}, ${tracker.pos.x}`);
    }

    if (tracker.speed) {
-      console.log(`\tspeed: ${tracker.speed.speed_x}, ${tracker.speed.speed_y}, ${tracker.speed.speed_z}`);
+      console.log(`\tspeed: ${tracker.speed.x}, ${tracker.speed.y}, ${tracker.speed.z}`);
    }

    if (tracker.ori) {
-      console.log(`\tori: ${tracker.ori.ori_x}, ${tracker.ori.ori_y}, ${tracker.ori.ori_z}`);
+      console.log(`\tori: ${tracker.ori.x}, ${tracker.ori.y}, ${tracker.ori.z}`);
    }

    if (tracker.status) {
@@ -42,17 +42,15 @@ setInterval(() => {
    }

    if (tracker.accel) {
-      console.log(`\taccel: ${tracker.accel.accel_x}, ${tracker.accel.accel_y}, ${tracker.accel.accel_z}`);
+      console.log(`\taccel: ${tracker.accel.x}, ${tracker.accel.y}, ${tracker.accel.z}`);
    }

    if (tracker.trgtpos) {
-      console.log(
-        `\ttrgtpos: ${tracker.trgtpos.trgtpos_x}, ${tracker.trgtpos.trgtpos_y}, ${tracker.trgtpos.trgtpos_z}`
-      );
+      console.log(`\ttrgtpos: ${tracker.trgtpos.x}, ${tracker.trgtpos.y}, ${tracker.trgtpos.z}`);
    }

    if (tracker.timestamp) {
-      console.log(`\ttimestamp: ${tracker.timestamp.tracker_timestamp}`);
+      console.log(`\ttimestamp: ${tracker.timestamp}`);
    }
  });
 }, 1000);
@@ -1,10 +1,9 @@
 // recreation of psn_server.cpp example from https://github.com/vyv/psn-cpp
 const dgram = require('dgram');
-const { Encoder, Tracker, Decoder } = require('../dist');
+const { Encoder, Tracker } = require('../dist/cjs');

 const client = dgram.createSocket('udp4');
 const encoder = new Encoder('Test PSN Server', 2, 0);
-const decoder = new Decoder();

 const trackers = [];

@@ -40,25 +39,18 @@ setInterval(() => {
    trackers[index].setTimestamp(timestamp);
  });

+  console.log(`Sending Data Packets`);
  const dataPackets = encoder.getDataPackets(timestamp, trackers);
-  dataPackets.forEach((packet, index) => {
-    const decodedPacket = decoder.decode(packet);
-    console.log(
-      `Sending PSN_DATA_PACKET : Frame Id = ${decodedPacket.packet_header.frame_id} , Packet Count = ${index + 1}`
-    );
+  dataPackets.forEach((packet) => {
    client.send(packet, 56565, '236.10.10.10');
  });
  timestamp += 1;
 }, 5);

 setInterval(() => {
+  console.log(`Sending Info Packets`);
  const infoPackets = encoder.getInfoPackets(timestamp, trackers);
-  infoPackets.forEach((packet, index) => {
-    const decodedPacket = decoder.decode(packet);
-    console.log(
-      `Sending PSN_INFO_PACKET : Frame Id = ${decodedPacket.packet_header.frame_id} , Packet Count = ${index + 1}`
-    );
-
+  infoPackets.forEach((packet) => {
    client.send(packet, 56565, '236.10.10.10');
  });
 }, 500);
@@ -1,15 +1,28 @@
 {
  "name": "@jwetzell/posistagenet",
-  "version": "0.4.7",
+  "version": "2.1.2",
  "description": "",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
  "scripts": {
    "prebuild": "rimraf dist",
-    "build": "tsc",
+    "build": "tsdown",
    "example:client": "node examples/psn_client.js",
    "example:server": "node examples/psn_server.js",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "lint:check": "eslint ./src",
+    "format:check": "prettier ./ --check",
+    "format:write": "prettier ./ --write",
+    "pretest": "npm run build",
+    "test": "node --test --experimental-test-coverage"
  },
  "files": [
    "dist"
@@ -20,11 +33,18 @@
    "url": "https://jwetzell.com"
  },
  "repository": "https://github.com/jwetzell/psn-js",
-  "license": "ISC",
+  "license": "MIT",
  "devDependencies": {
-    "@types/node": "22.7.4",
-    "prettier": "3.3.3",
-    "rimraf": "6.0.1",
-    "typescript": "5.6.2"
+    "@eslint/js": "10.0.1",
+    "@types/node": "24.7.2",
+    "eslint": "10.5.0",
+    "eslint-config-prettier": "10.1.8",
+    "eslint-plugin-prettier": "5.5.6",
+    "globals": "17.6.0",
+    "prettier": "3.8.4",
+    "rimraf": "6.1.3",
+    "tsdown": "0.22.2",
+    "typescript": "6.0.3",
+    "typescript-eslint": "8.61.0"
  }
 }
@@ -1,33 +1,38 @@
-import { Decoders } from '.';
-import { DataPacketChunk, InfoPacketChunk, InfoTrackerChunk, PacketHeaderChunk } from './models';
+import { Decoders } from './index.js';
+import {
+  type DataPacketChunk,
+  type InfoPacketChunk,
+  Tracker,
+  TrackerFromData,
+  TrackerFromInfo,
+} from './models/index.js';

 export class Decoder {
-  // TODO(jwetzell): check if these last packet headers are necessary to hold on to
-  lastInfoPacketHeader?: PacketHeaderChunk;
-
-  lastDataPacketHeader?: PacketHeaderChunk;
-
  infoPacketFrames: { [key: number]: InfoPacketChunk[] } = {};

  dataPacketFrames: { [key: number]: DataPacketChunk[] } = {};

-  trackers: { [key: string]: InfoTrackerChunk } = {};
+  trackers: { [key: string]: Tracker } = {};

-  system_name: string = '';
+  systemName: string = '';
  constructor() {}

  updateInfo(framePackets: InfoPacketChunk[]) {
    framePackets.forEach((packet) => {
-      if (packet.system_name) {
-        this.system_name = packet.system_name.system_name;
+      if (packet.data.systemName?.data) {
+        this.systemName = packet.data.systemName?.data.systemName;
      }

-      if (packet.tracker_list?.trackers) {
-        Object.entries(packet.tracker_list.trackers).forEach(([trackerId, tracker]) => {
-          if (!this.trackers[trackerId]) {
-            this.trackers[trackerId] = {};
+      if (packet.data.trackerList?.data) {
+        packet.data.trackerList.data.trackers.forEach((infoTrackerChunk) => {
+          if (!this.trackers[infoTrackerChunk.chunk.header.id]) {
+            const tracker = TrackerFromInfo(infoTrackerChunk);
+            if (tracker) {
+              this.trackers[infoTrackerChunk.chunk.header.id] = tracker;
+            }
          }
-          this.trackers[trackerId].tracker_name = tracker.tracker_name;
+          const tracker = this.trackers[infoTrackerChunk.chunk.header.id];
+          tracker.updateInfo(infoTrackerChunk);
        });
      }
    });
@@ -35,97 +40,80 @@ export class Decoder {

  updateData(framePackets: DataPacketChunk[]) {
    framePackets.forEach((packet) => {
-      if (packet.tracker_list) {
-        Object.entries(packet.tracker_list.trackers).forEach(([trackerId, tracker]) => {
-          this.trackers[trackerId] = {
-            ...this.trackers[trackerId],
-            ...tracker,
-          };
+      if (packet.data.trackerList) {
+        packet.data.trackerList?.data.trackers.forEach((dataTrackerChunk) => {
+          if (!this.trackers[dataTrackerChunk.chunk.header.id]) {
+            const tracker = TrackerFromData(dataTrackerChunk);
+            if (tracker) {
+              this.trackers[dataTrackerChunk.chunk.header.id] = tracker;
+            }
+          }
+          const tracker = this.trackers[dataTrackerChunk.chunk.header.id];
+          tracker.updateData(dataTrackerChunk);
        });
      }
    });
  }

  // TODO(jwetzell): add invalid frame id decoding. Scenario where a frame id is reused before one is complete
-  decode(packetBuf: Buffer): DataPacketChunk | InfoPacketChunk | undefined {
-    const packet = Decoders.Packet(packetBuf);
+  decode(packetBuf: Uint8Array) {
+    const packet = Decoders.Chunk(packetBuf);
    if (packet === undefined) {
      return packet;
    }

-    if (packet.id === 0x6756) {
-      const infoPacket = packet as InfoPacketChunk;
-      if (infoPacket && infoPacket.has_subchunks) {
-        const currentInfoPacketHeader = infoPacket.packet_header;
+    if (packet.header.id === 0x6756) {
+      const infoPacket = Decoders.InfoPacketChunk(packetBuf);
+      if (infoPacket && infoPacket.chunk.header.hasSubchunks) {
+        const currentInfoPacketHeader = infoPacket.data.packetHeader;
        if (!currentInfoPacketHeader) {
          // NOTE(jwetzell): not sure that info packets without a header subchunk are valid?
          throw new Error('malformed packet');
        }

-        const systemSubChunk = infoPacket.system_name;
+        const systemSubChunk = infoPacket.data.systemName;
        if (!systemSubChunk) {
          // NOTE(jwetzell): not sure that info packets without a system subchunk are valid?
          throw new Error('malformed packet');
        }
-        if (currentInfoPacketHeader.frame_id) {
-          if (this.infoPacketFrames[currentInfoPacketHeader.frame_id] === undefined) {
-            this.infoPacketFrames[currentInfoPacketHeader.frame_id] = [];
+        if (currentInfoPacketHeader.data.frameId) {
+          if (this.infoPacketFrames[currentInfoPacketHeader.data.frameId] === undefined) {
+            this.infoPacketFrames[currentInfoPacketHeader.data.frameId] = [];
          }
-          this.infoPacketFrames[currentInfoPacketHeader.frame_id].push(infoPacket);
+          this.infoPacketFrames[currentInfoPacketHeader.data.frameId].push(infoPacket);

          if (
-            this.infoPacketFrames[currentInfoPacketHeader.frame_id].length ===
-            currentInfoPacketHeader.frame_packet_count
+            this.infoPacketFrames[currentInfoPacketHeader.data.frameId].length ===
+            currentInfoPacketHeader.data.framePacketCount
          ) {
-            this.updateInfo(this.infoPacketFrames[currentInfoPacketHeader.frame_id]);
-            delete this.infoPacketFrames[currentInfoPacketHeader.frame_id];
+            this.updateInfo(this.infoPacketFrames[currentInfoPacketHeader.data.frameId]);
+            delete this.infoPacketFrames[currentInfoPacketHeader.data.frameId];
          }
        }
-
-        this.lastInfoPacketHeader = currentInfoPacketHeader;
      }
-    } else if (packet.id === 0x6755) {
-      const dataPacket = packet as DataPacketChunk;
-      if (dataPacket.has_subchunks) {
-        const currentDataPacketHeader = dataPacket.packet_header;
+    } else if (packet.header.id === 0x6755) {
+      const dataPacket = Decoders.DataPacketChunk(packetBuf);
+      if (dataPacket.chunk.header.hasSubchunks) {
+        const currentDataPacketHeader = dataPacket.data.packetHeader;
        if (!currentDataPacketHeader) {
          // NOTE(jwetzell): not sure that info packets without a header subchunk are valid?
          throw new Error('malformed packet');
        }

-        if (currentDataPacketHeader.frame_id) {
-          if (this.dataPacketFrames[currentDataPacketHeader.frame_id] === undefined) {
-            this.dataPacketFrames[currentDataPacketHeader.frame_id] = [];
+        if (currentDataPacketHeader.data.frameId) {
+          if (this.dataPacketFrames[currentDataPacketHeader.data.frameId] === undefined) {
+            this.dataPacketFrames[currentDataPacketHeader.data.frameId] = [];
          }
-          this.dataPacketFrames[currentDataPacketHeader.frame_id].push(dataPacket);
+          this.dataPacketFrames[currentDataPacketHeader.data.frameId].push(dataPacket);
          if (
-            this.dataPacketFrames[currentDataPacketHeader.frame_id].length ===
-            currentDataPacketHeader.frame_packet_count
+            this.dataPacketFrames[currentDataPacketHeader.data.frameId].length ===
+            currentDataPacketHeader.data.framePacketCount
          ) {
-            this.updateData(this.dataPacketFrames[currentDataPacketHeader.frame_id]);
-            delete this.dataPacketFrames[currentDataPacketHeader.frame_id];
+            this.updateData(this.dataPacketFrames[currentDataPacketHeader.data.frameId]);
+            delete this.dataPacketFrames[currentDataPacketHeader.data.frameId];
          }
        }
-        this.lastDataPacketHeader = currentDataPacketHeader;
      }
    }
-    return packet;
-  }
-
-  // NOTE(jwetzell): gets merged set of tracker field keys minus the guaranteed properties
-  getTrackerFields(): Set<string> {
-    const keys = new Set(
-      Object.values(this.trackers)
-        .map((tracker) => Object.keys(tracker))
-        .flat(1)
-    );
-
-    // NOTE(jwetzell): remove fields that definitely exist
-    keys.delete('id');
-    keys.delete('has_subchunks');
-    keys.delete('data_len');
-    keys.delete('chunk_data');
-
-    return keys;
  }
 }
@@ -1,18 +1,29 @@
-import { Chunk } from '../models/chunk';
+import type { Chunk } from '../models/chunk.js';

-export default (buffer: Buffer, dataDecoder: Function): Chunk => {
-  let offset = 0;
-  const chunk: Chunk = {};
-  chunk.id = buffer.readUInt16LE(offset);
-  offset += 2;
+export default (buffer: Uint8Array): Chunk => {
+  if (buffer.length < 4) {
+    throw new Error('Chunk buffer must be at least 4 bytes');
+  }

-  // NOTE(jwetzell): this data is split up as 1 bit for has_subchunks and 15 bits for the data_len
-  const combinedLengthAndFlag = buffer.readUInt16LE(offset);
-  chunk.has_subchunks = combinedLengthAndFlag > 32768;
-  chunk.data_len = chunk.has_subchunks ? combinedLengthAndFlag - 32768 : combinedLengthAndFlag;
-  offset += 2;
-  chunk.chunk_data = buffer.subarray(offset, offset + chunk.data_len);
+  const id = (buffer[1] << 8) + buffer[0];
+
+  // NOTE(jwetzell): this data is split up as 1 bit for hasSubchunks and 15 bits for the dataLen
+  const combinedLengthAndFlag = (buffer[3] << 8) + buffer[2];
+  const hasSubchunks = combinedLengthAndFlag > 32768;
+  const dataLen = hasSubchunks ? combinedLengthAndFlag - 32768 : combinedLengthAndFlag;
+
+  const header = {
+    id,
+    dataLen,
+    hasSubchunks,
+  };
+
+  const chunkData = buffer.subarray(4, 4 + header.dataLen);
+
+  const chunk = {
+    chunkData,
+    header,
+  };

-  dataDecoder(chunk);
  return chunk;
 };
@@ -1,25 +1,29 @@
-import { Decoders } from '..';
-import { Constants } from '../../constants';
-import { DataPacketChunk } from '../../models/data/data-packet-chunk';
+import { Constants } from '../../constants.js';
+import type { DataPacketChunk, DataPacketChunkData } from '../../models/data/data-packet-chunk.js';
+import { Decoders } from '../index.js';

-function decodeDataPacketChunk(dataPacketChunk: DataPacketChunk) {
-  if (dataPacketChunk.has_subchunks && dataPacketChunk.chunk_data && dataPacketChunk.data_len) {
+export default (buffer: Uint8Array): DataPacketChunk => {
+  const chunk = Decoders.Chunk(buffer);
+
+  const data: DataPacketChunkData = {};
+
+  if (chunk.header.hasSubchunks && chunk.chunkData && chunk.header.dataLen) {
    let offset = 0;
-    while (offset < dataPacketChunk.data_len) {
-      const chunkId = dataPacketChunk.chunk_data.readUInt16LE(offset);
+    while (offset < chunk.header.dataLen) {
+      const chunkId = (chunk.chunkData.subarray(offset)[1] << 8) + chunk.chunkData.subarray(offset)[0];
      switch (chunkId) {
        case 0x0000:
-          dataPacketChunk.packet_header = Decoders.PacketHeaderChunk(dataPacketChunk.chunk_data.subarray(offset));
+          data.packetHeader = Decoders.PacketHeaderChunk(chunk.chunkData.subarray(offset));
          offset += Constants.CHUNK_HEADER_SIZE;
-          if (dataPacketChunk.packet_header?.data_len) {
-            offset += dataPacketChunk.packet_header.data_len;
+          if (data.packetHeader.chunk.header.dataLen) {
+            offset += data.packetHeader.chunk.header.dataLen;
          }
          break;
        case 0x0001:
-          dataPacketChunk.tracker_list = Decoders.DataTrackerListChunk(dataPacketChunk.chunk_data.subarray(offset));
+          data.trackerList = Decoders.DataTrackerListChunk(chunk.chunkData.subarray(offset));
          offset += Constants.CHUNK_HEADER_SIZE;
-          if (dataPacketChunk.tracker_list.data_len) {
-            offset += dataPacketChunk.tracker_list.data_len;
+          if (data.trackerList.chunk.header.dataLen) {
+            offset += data.trackerList.chunk.header.dataLen;
          }
          break;
        default:
@@ -27,6 +31,9 @@ function decodeDataPacketChunk(dataPacketChunk: DataPacketChunk) {
      }
    }
  }
-}

-export default (buffer: Buffer): DataPacketChunk => Decoders.Chunk(buffer, decodeDataPacketChunk) as DataPacketChunk;
+  return {
+    chunk,
+    data,
+  };
+};
@@ -1,43 +1,46 @@
-import { Decoders } from '..';
-import { Constants } from '../../constants';
-import { DataTrackerChunk } from '../../models/data/data-tracker-chunk';
+import { Constants } from '../../constants.js';
+import type { DataTrackerChunk, DataTrackerChunkData } from '../../models/data/data-tracker-chunk.js';
+import { Decoders } from '../index.js';

-function decodeTrackerChunk(trackerChunk: DataTrackerChunk) {
-  if (trackerChunk.chunk_data && trackerChunk.data_len) {
+export default (buffer: Uint8Array): DataTrackerChunk => {
+  const chunk = Decoders.Chunk(buffer);
+  const data: DataTrackerChunkData = {};
+  if (chunk.chunkData && chunk.header.dataLen) {
    let offset = 0;
-    while (offset < trackerChunk.data_len) {
-      const trackerFieldChunk = Decoders.DataTrackerFieldChunk(trackerChunk.chunk_data.subarray(offset));
-      offset += Constants.CHUNK_HEADER_SIZE;
-      if (trackerFieldChunk.data_len) {
-        offset += trackerFieldChunk.data_len;
-        switch (trackerFieldChunk.id) {
-          case 0x0000:
-            trackerChunk.pos = trackerFieldChunk;
-            break;
-          case 0x0001:
-            trackerChunk.speed = trackerFieldChunk;
-            break;
-          case 0x0002:
-            trackerChunk.ori = trackerFieldChunk;
-            break;
-          case 0x0003:
-            trackerChunk.status = trackerFieldChunk;
-            break;
-          case 0x0004:
-            trackerChunk.accel = trackerFieldChunk;
-            break;
-          case 0x0005:
-            trackerChunk.trgtpos = trackerFieldChunk;
-            break;
-          case 0x0006:
-            trackerChunk.timestamp = trackerFieldChunk;
-            break;
-          default:
-            break;
-        }
+    while (offset < chunk.header.dataLen) {
+      const trackerFieldChunk = Decoders.Chunk(chunk.chunkData.subarray(offset));
+      switch (trackerFieldChunk.header.id) {
+        case 0x0000:
+          data.pos = Decoders.DataTrackerXYZChunk(chunk.chunkData.subarray(offset));
+          break;
+        case 0x0001:
+          data.speed = Decoders.DataTrackerXYZChunk(chunk.chunkData.subarray(offset));
+          break;
+        case 0x0002:
+          data.ori = Decoders.DataTrackerXYZChunk(chunk.chunkData.subarray(offset));
+          break;
+        case 0x0003:
+          data.status = Decoders.DataTrackerStatusChunk(chunk.chunkData.subarray(offset));
+          break;
+        case 0x0004:
+          data.accel = Decoders.DataTrackerXYZChunk(chunk.chunkData.subarray(offset));
+          break;
+        case 0x0005:
+          data.trgtpos = Decoders.DataTrackerXYZChunk(chunk.chunkData.subarray(offset));
+          break;
+        case 0x0006:
+          data.timestamp = Decoders.DataTrackerTimestampChunk(chunk.chunkData.subarray(offset));
+          break;
+        default:
+          break;
      }
+      offset += Constants.CHUNK_HEADER_SIZE;
+      offset += trackerFieldChunk.header.dataLen;
    }
  }
-}

-export default (buffer: Buffer): DataTrackerChunk => Decoders.Chunk(buffer, decodeTrackerChunk) as DataTrackerChunk;
+  return {
+    chunk,
+    data,
+  };
+};
@@ -1,48 +0,0 @@
-/* eslint-disable no-case-declarations */
-
-import { Decoders } from '..';
-import { DataTrackerFieldChunk } from '../../models/data/data-tracker-field-chunk';
-
-function readXYZ(trackerFieldChunk: DataTrackerFieldChunk, prefix: string = '') {
-  if (trackerFieldChunk.chunk_data) {
-    trackerFieldChunk[`${prefix}x`] = trackerFieldChunk.chunk_data.readFloatLE(0);
-    trackerFieldChunk[`${prefix}y`] = trackerFieldChunk.chunk_data.readFloatLE(4);
-    trackerFieldChunk[`${prefix}z`] = trackerFieldChunk.chunk_data.readFloatLE(8);
-  }
-}
-function decodeTrackerFieldChunk(trackerFieldChunk: DataTrackerFieldChunk) {
-  if (trackerFieldChunk.id !== undefined) {
-    switch (trackerFieldChunk.id) {
-      case 0x0000:
-        readXYZ(trackerFieldChunk, 'pos_');
-        break;
-      case 0x0001:
-        readXYZ(trackerFieldChunk, 'speed_');
-        break;
-      case 0x0002:
-        readXYZ(trackerFieldChunk, 'ori_');
-        break;
-      case 0x0003:
-        if (trackerFieldChunk.chunk_data) {
-          trackerFieldChunk.validity = trackerFieldChunk.chunk_data.readFloatLE();
-        }
-        break;
-      case 0x0004:
-        readXYZ(trackerFieldChunk, 'accel_');
-        break;
-      case 0x0005:
-        readXYZ(trackerFieldChunk, 'trgtpos_');
-        break;
-      case 0x0006:
-        if (trackerFieldChunk.chunk_data) {
-          trackerFieldChunk.tracker_timestamp = trackerFieldChunk.chunk_data.readBigUInt64LE();
-        }
-        break;
-      default:
-        break;
-    }
-  }
-}
-
-export default (buffer: Buffer): DataTrackerFieldChunk =>
-  Decoders.Chunk(buffer, decodeTrackerFieldChunk) as DataTrackerFieldChunk;
@@ -1,24 +1,33 @@
-import { Decoders } from '..';
-import { Constants } from '../../constants';
-import { DataTrackerListChunk } from '../../models/data/data-tracker-list-chunk';
+import { Constants } from '../../constants.js';
+import type { DataTrackerListChunk, DataTrackerListChunkData } from '../../models/data/data-tracker-list-chunk.js';
+import type { DataTrackerChunk } from '../../models/index.js';
+import { Decoders } from '../index.js';

-function decodeDataTrackerListChunk(dataTrackerListChunk: DataTrackerListChunk) {
-  dataTrackerListChunk.trackers = {};
+export default (buffer: Uint8Array): DataTrackerListChunk => {
+  const chunk = Decoders.Chunk(buffer);
+  const trackers: DataTrackerChunk[] = [];

  // TODO(jwetzell): add error handling
-  let offset = 0;
-  if (dataTrackerListChunk.chunk_data) {
-    while (offset < dataTrackerListChunk.chunk_data.length) {
-      const trackerChunk = Decoders.DataTrackerChunk(dataTrackerListChunk.chunk_data.subarray(offset));
+  if (chunk.chunkData) {
+    let offset = 0;
+    while (offset < chunk.chunkData.length) {
+      const trackerChunk = Decoders.DataTrackerChunk(chunk.chunkData.subarray(offset));
      offset += Constants.CHUNK_HEADER_SIZE;
-      if (trackerChunk.data_len) {
-        offset += trackerChunk.data_len;
+      if (trackerChunk.chunk.header.dataLen) {
+        offset += trackerChunk.chunk.header.dataLen;
      }
-      if (trackerChunk.id !== undefined) {
-        dataTrackerListChunk.trackers[trackerChunk.id] = trackerChunk;
+      if (trackerChunk.chunk.header.id !== undefined) {
+        trackers.push(trackerChunk);
      }
    }
  }
-}
-export default (buffer: Buffer): DataTrackerListChunk =>
-  Decoders.Chunk(buffer, decodeDataTrackerListChunk) as DataTrackerListChunk;
+
+  const data: DataTrackerListChunkData = {
+    trackers,
+  };
+
+  return {
+    chunk,
+    data,
+  };
+};
@@ -0,0 +1,21 @@
+import type {
+  DataTrackerStatusChunk,
+  DataTrackerStatusChunkData,
+} from '../../models/data/data-tracker-status-chunk.js';
+import { Decoders } from '../index.js';
+
+export default (buffer: Uint8Array): DataTrackerStatusChunk => {
+  const chunk = Decoders.Chunk(buffer);
+
+  const view = new DataView(chunk.chunkData.buffer, chunk.chunkData.byteOffset, chunk.chunkData.byteLength);
+  const validity = view.getFloat32(0, true);
+
+  const data: DataTrackerStatusChunkData = {
+    validity,
+  };
+
+  return {
+    chunk,
+    data,
+  };
+};
@@ -0,0 +1,21 @@
+import type {
+  DataTrackerTimestampChunk,
+  DataTrackerTimestampChunkData,
+} from '../../models/data/data-tracker-timestamp-chunk.js';
+import { Decoders } from '../index.js';
+
+export default (buffer: Uint8Array): DataTrackerTimestampChunk => {
+  const chunk = Decoders.Chunk(buffer);
+
+  const view = new DataView(chunk.chunkData.buffer, chunk.chunkData.byteOffset, chunk.chunkData.byteLength);
+  const timestamp = view.getBigUint64(0, true);
+
+  const data: DataTrackerTimestampChunkData = {
+    timestamp,
+  };
+
+  return {
+    chunk,
+    data,
+  };
+};
@@ -0,0 +1,20 @@
+import type { DataTrackerXYZChunk, DataTrackerXYZChunkData } from '../../models/data/data-tracker-xyz-chunk.js';
+import { Decoders } from '../index.js';
+
+export default (buffer: Uint8Array): DataTrackerXYZChunk => {
+  const chunk = Decoders.Chunk(buffer);
+
+  // TODO(jwetzell): add error handling
+  const view = new DataView(chunk.chunkData.buffer, chunk.chunkData.byteOffset, chunk.chunkData.byteLength);
+
+  const data: DataTrackerXYZChunkData = {
+    x: view.getFloat32(0, true),
+    y: view.getFloat32(4, true),
+    z: view.getFloat32(8, true),
+  };
+
+  return {
+    chunk,
+    data,
+  };
+};
@@ -1,25 +1,27 @@
-import Chunk from './chunk';
-import Packet from './packet';
-import PacketHeaderChunk from './packet-header-chunk';
+import Chunk from './chunk.js';
+import PacketHeaderChunk from './packet-header-chunk.js';

-import DataPacketChunk from './data/data-packet-chunk';
-import DataTrackerChunk from './data/data-tracker-chunk';
-import DataTrackerFieldChunk from './data/data-tracker-field-chunk';
-import DataTrackerListChunk from './data/data-tracker-list-chunk';
+import DataPacketChunk from './data/data-packet-chunk.js';
+import DataTrackerChunk from './data/data-tracker-chunk.js';
+import DataTrackerListChunk from './data/data-tracker-list-chunk.js';
+import DataTrackerStatusChunk from './data/data-tracker-status-chunk.js';
+import DataTrackerTimestampChunk from './data/data-tracker-timestamp-chunk.js';
+import DataTrackerXYZChunk from './data/data-tracker-xyz-chunk.js';

-import InfoPacketChunk from './info/info-packet-chunk';
-import InfoSystemNameChunk from './info/info-system-name-chunk';
-import InfoTrackerChunk from './info/info-tracker-chunk';
-import InfoTrackerListChunk from './info/info-tracker-list-chunk';
-import InfoTrackerNameChunk from './info/info-tracker-name-chunk';
+import InfoPacketChunk from './info/info-packet-chunk.js';
+import InfoSystemNameChunk from './info/info-system-name-chunk.js';
+import InfoTrackerChunk from './info/info-tracker-chunk.js';
+import InfoTrackerListChunk from './info/info-tracker-list-chunk.js';
+import InfoTrackerNameChunk from './info/info-tracker-name-chunk.js';

 export const Decoders = {
  Chunk,
  PacketHeaderChunk,
-  Packet,
  DataPacketChunk,
  DataTrackerChunk,
-  DataTrackerFieldChunk,
+  DataTrackerXYZChunk,
+  DataTrackerStatusChunk,
+  DataTrackerTimestampChunk,
  DataTrackerListChunk,
  InfoPacketChunk,
  InfoSystemNameChunk,
@@ -1,32 +1,36 @@
-import { Decoders } from '..';
-import { Constants } from '../../constants';
-import { InfoPacketChunk } from '../../models/info/info-packet-chunk';
+import { Constants } from '../../constants.js';
+import type { InfoPacketChunk, InfoPacketChunkData } from '../../models/info/info-packet-chunk.js';
+import { Decoders } from '../index.js';

-function decodeInfoPacketChunk(infoPacketChunk: InfoPacketChunk) {
-  if (infoPacketChunk.has_subchunks && infoPacketChunk.chunk_data && infoPacketChunk.data_len) {
+export default (buffer: Uint8Array): InfoPacketChunk => {
+  const chunk = Decoders.Chunk(buffer);
+
+  const data: InfoPacketChunkData = {};
+
+  if (chunk.header.hasSubchunks && chunk.chunkData && chunk.header.dataLen) {
    let offset = 0;
-    while (offset < infoPacketChunk.data_len) {
-      const chunkId = infoPacketChunk.chunk_data.readUInt16LE(offset);
+    while (offset < chunk.header.dataLen) {
+      const chunkId = (chunk.chunkData.subarray(offset)[1] << 8) + chunk.chunkData.subarray(offset)[0];
      switch (chunkId) {
        case 0x0000:
-          infoPacketChunk.packet_header = Decoders.PacketHeaderChunk(infoPacketChunk.chunk_data.subarray(offset));
+          data.packetHeader = Decoders.PacketHeaderChunk(chunk.chunkData.subarray(offset));
          offset += Constants.CHUNK_HEADER_SIZE;
-          if (infoPacketChunk.packet_header?.data_len) {
-            offset += infoPacketChunk.packet_header.data_len;
+          if (data.packetHeader?.chunk.header.dataLen) {
+            offset += data.packetHeader.chunk.header.dataLen;
          }
          break;
        case 0x0001:
-          infoPacketChunk.system_name = Decoders.InfoSystemNameChunk(infoPacketChunk.chunk_data.subarray(offset));
+          data.systemName = Decoders.InfoSystemNameChunk(chunk.chunkData.subarray(offset));
          offset += Constants.CHUNK_HEADER_SIZE;
-          if (infoPacketChunk.system_name?.data_len) {
-            offset += infoPacketChunk.system_name.data_len;
+          if (data.systemName?.chunk.header.dataLen) {
+            offset += data.systemName?.chunk.header.dataLen;
          }
          break;
        case 0x0002:
-          infoPacketChunk.tracker_list = Decoders.InfoTrackerListChunk(infoPacketChunk.chunk_data.subarray(offset));
+          data.trackerList = Decoders.InfoTrackerListChunk(chunk.chunkData.subarray(offset));
          offset += Constants.CHUNK_HEADER_SIZE;
-          if (infoPacketChunk.tracker_list?.data_len) {
-            offset += infoPacketChunk.tracker_list.data_len;
+          if (data.trackerList?.chunk.header.dataLen) {
+            offset += data.trackerList.chunk.header.dataLen;
          }
          break;
        default:
@@ -34,6 +38,9 @@ function decodeInfoPacketChunk(infoPacketChunk: InfoPacketChunk) {
      }
    }
  }
-}

-export default (buffer: Buffer): InfoPacketChunk => Decoders.Chunk(buffer, decodeInfoPacketChunk) as InfoPacketChunk;
+  return {
+    chunk,
+    data,
+  };
+};
@@ -1,11 +1,16 @@
-import { Decoders } from '..';
-import { InfoSystemNameChunk } from '../../models/info/info-system-name-chunk';
+import type { InfoSystemNameChunk, InfoSystemNameChunkData } from '../../models/info/info-system-name-chunk.js';
+import { Decoders } from '../index.js';

-function decodeSystemNameChunk(systemNameChunk: InfoSystemNameChunk) {
-  if (systemNameChunk.chunk_data !== undefined && systemNameChunk.data_len !== undefined) {
-    systemNameChunk.system_name = systemNameChunk.chunk_data.subarray(0, systemNameChunk.data_len).toString();
-  }
-}
+const nameDecoder = new TextDecoder();
+export default (buffer: Uint8Array): InfoSystemNameChunk => {
+  const chunk = Decoders.Chunk(buffer);

-export default (buffer: Buffer): InfoSystemNameChunk =>
-  Decoders.Chunk(buffer, decodeSystemNameChunk) as InfoSystemNameChunk;
+  const data: InfoSystemNameChunkData = {
+    systemName: nameDecoder.decode(chunk.chunkData.subarray(0, chunk.header.dataLen)),
+  };
+
+  return {
+    chunk,
+    data,
+  };
+};
@@ -1,26 +1,35 @@
-import { Decoders } from '..';
-import { Constants } from '../../constants';
-import { InfoTrackerChunk } from '../../models/info/info-tracker-chunk';
+import { Constants } from '../../constants.js';
+import type { InfoTrackerChunk, InfoTrackerChunkData } from '../../models/info/info-tracker-chunk.js';
+import { Decoders } from '../index.js';

-function decodeInfoTrackerChunk(infoTrackerChunk: InfoTrackerChunk) {
-  if (infoTrackerChunk.has_subchunks && infoTrackerChunk.chunk_data && infoTrackerChunk.data_len) {
+export default (buffer: Uint8Array): InfoTrackerChunk => {
+  const chunk = Decoders.Chunk(buffer);
+
+  if (chunk.header.hasSubchunks && chunk.chunkData && chunk.header.dataLen) {
    let offset = 0;
-    while (offset < infoTrackerChunk.data_len) {
-      const chunkId = infoTrackerChunk.chunk_data.readUInt16LE(offset);
+    while (offset < chunk.header.dataLen) {
+      const chunkId = (chunk.chunkData.subarray(offset)[1] << 8) + chunk.chunkData.subarray(offset)[0];
      switch (chunkId) {
-        case 0x0000:
-          infoTrackerChunk.tracker_name = Decoders.InfoTrackerNameChunk(infoTrackerChunk.chunk_data.subarray(offset));
+        case 0x0000: {
+          const data: InfoTrackerChunkData = {
+            trackerName: Decoders.InfoTrackerNameChunk(chunk.chunkData.subarray(offset)),
+          };
          offset += Constants.CHUNK_HEADER_SIZE;
-          if (infoTrackerChunk.tracker_name?.data_len) {
-            offset += infoTrackerChunk?.tracker_name?.data_len;
+          if (data.trackerName.chunk.header.dataLen) {
+            offset += data.trackerName.chunk.header.dataLen;
          }
-          break;
-
+          return {
+            chunk,
+            data,
+          };
+        }
        default:
          break;
      }
    }
  }
-}

-export default (buffer: Buffer): InfoTrackerChunk => Decoders.Chunk(buffer, decodeInfoTrackerChunk);
+  return {
+    chunk,
+  };
+};
@@ -1,24 +1,33 @@
-import { Decoders } from '..';
-import { Constants } from '../../constants';
-import { InfoTrackerListChunk } from '../../models/info/info-tracker-list-chunk';
+import { Constants } from '../../constants.js';
+import type { InfoTrackerChunk } from '../../models/info/info-tracker-chunk.js';
+import type { InfoTrackerListChunk, InfoTrackerListChunkData } from '../../models/info/info-tracker-list-chunk.js';
+import { Decoders } from '../index.js';

-function decodeInfoTrackerListChunk(infoTrackerListChunk: InfoTrackerListChunk) {
-  infoTrackerListChunk.trackers = {};
-  if (infoTrackerListChunk.has_subchunks && infoTrackerListChunk.chunk_data) {
+export default (buffer: Uint8Array): InfoTrackerListChunk => {
+  const chunk = Decoders.Chunk(buffer);
+
+  const trackers: InfoTrackerChunk[] = [];
+
+  if (chunk.header.hasSubchunks && chunk.chunkData) {
    let offset = 0;
-    if (infoTrackerListChunk.data_len) {
-      while (offset < infoTrackerListChunk.data_len) {
-        const trackerChunk = Decoders.InfoTrackerChunk(infoTrackerListChunk.chunk_data.subarray(offset));
+    if (chunk.header.dataLen) {
+      while (offset < chunk.header.dataLen) {
+        const trackerChunk = Decoders.InfoTrackerChunk(chunk.chunkData.subarray(offset));
        offset += Constants.CHUNK_HEADER_SIZE;
-        if (trackerChunk.data_len) {
-          offset += trackerChunk.data_len;
+        if (trackerChunk.chunk.header.dataLen) {
+          offset += trackerChunk.chunk.header.dataLen;
        }
-        if (trackerChunk.id !== undefined) {
-          infoTrackerListChunk.trackers[trackerChunk.id] = trackerChunk;
+        if (trackerChunk.chunk.header.id !== undefined) {
+          trackers.push(trackerChunk);
        }
      }
    }
  }
-}
-export default (buffer: Buffer): InfoTrackerListChunk =>
-  Decoders.Chunk(buffer, decodeInfoTrackerListChunk) as InfoTrackerListChunk;
+  const data: InfoTrackerListChunkData = {
+    trackers,
+  };
+  return {
+    chunk,
+    data,
+  };
+};
@@ -1,10 +1,16 @@
-import { Decoders } from '..';
-import { InfoTrackerNameChunk } from '../../models/info/info-tracker-name-chunk';
+import type { InfoTrackerNameChunk, InfoTrackerNameChunkData } from '../../models/info/info-tracker-name-chunk.js';
+import { Decoders } from '../index.js';

-function decodeTrackerNameChunk(trackerNameChunk: InfoTrackerNameChunk) {
-  if (trackerNameChunk.chunk_data !== undefined && trackerNameChunk.data_len !== undefined) {
-    trackerNameChunk.tracker_name = trackerNameChunk.chunk_data.subarray(0, trackerNameChunk.data_len).toString();
-  }
-}
-export default (buffer: Buffer): InfoTrackerNameChunk =>
-  Decoders.Chunk(buffer, decodeTrackerNameChunk) as InfoTrackerNameChunk;
+const nameDecoder = new TextDecoder();
+export default (buffer: Uint8Array): InfoTrackerNameChunk => {
+  const chunk = Decoders.Chunk(buffer);
+
+  const data: InfoTrackerNameChunkData = {
+    trackerName: nameDecoder.decode(chunk.chunkData.subarray(0, chunk.header.dataLen)),
+  };
+
+  return {
+    chunk,
+    data,
+  };
+};
@@ -1,14 +1,27 @@
-import { Decoders } from '.';
-import { PacketHeaderChunk } from '../models/packet-header-chunk';
+import type { PacketHeaderChunk, PacketHeaderChunkData } from '../models/packet-header-chunk.js';
+import { Decoders } from './index.js';

-function decodePacketHeaderChunk(packetHeaderChunk: PacketHeaderChunk) {
-  if (packetHeaderChunk.chunk_data) {
-    packetHeaderChunk.packet_timestamp = packetHeaderChunk.chunk_data.readBigUInt64LE(0);
-    packetHeaderChunk.version_high = packetHeaderChunk.chunk_data.readUInt8(8);
-    packetHeaderChunk.version_low = packetHeaderChunk.chunk_data.readUInt8(9);
-    packetHeaderChunk.frame_id = packetHeaderChunk.chunk_data.readUInt8(10);
-    packetHeaderChunk.frame_packet_count = packetHeaderChunk.chunk_data.readUInt8(11);
-  }
-}
+export default (buffer: Uint8Array): PacketHeaderChunk => {
+  const chunk = Decoders.Chunk(buffer);

-export default (buffer: Buffer): PacketHeaderChunk => Decoders.Chunk(buffer, decodePacketHeaderChunk);
+  let packetTimestamp = BigInt(chunk.chunkData[7]) << BigInt(56);
+  packetTimestamp += BigInt(chunk.chunkData[6]) << BigInt(48);
+  packetTimestamp += BigInt(chunk.chunkData[5]) << BigInt(40);
+  packetTimestamp += BigInt(chunk.chunkData[4]) << BigInt(32);
+  packetTimestamp += BigInt(chunk.chunkData[3]) << BigInt(24);
+  packetTimestamp += BigInt(chunk.chunkData[2]) << BigInt(16);
+  packetTimestamp += BigInt(chunk.chunkData[1]) << BigInt(8);
+  packetTimestamp += BigInt(chunk.chunkData[0]);
+  const data: PacketHeaderChunkData = {
+    packetTimestamp,
+    versionHigh: chunk.chunkData[8],
+    versionLow: chunk.chunkData[9],
+    frameId: chunk.chunkData[10],
+    framePacketCount: chunk.chunkData[11],
+  };
+
+  return {
+    chunk,
+    data,
+  };
+};
@@ -1,15 +0,0 @@
-import { Decoders } from '.';
-import { DataPacketChunk } from '../models/data/data-packet-chunk';
-import { InfoPacketChunk } from '../models/info/info-packet-chunk';
-
-export default (buffer: Buffer): InfoPacketChunk | DataPacketChunk | undefined => {
-  const chunkId = buffer.readUInt16LE();
-  switch (chunkId) {
-    case 0x6756:
-      return Decoders.InfoPacketChunk(buffer);
-    case 0x6755:
-      return Decoders.DataPacketChunk(buffer);
-    default:
-      return undefined;
-  }
-};
@@ -1,5 +1,5 @@
-import { Encoders, Tracker } from '.';
-import { Constants } from './constants';
+import { Constants } from './constants.js';
+import { Encoders, Tracker } from './index.js';

 export class Encoder {
  private systemName: string;
@@ -47,14 +47,14 @@ export class Encoder {

    const trackerChunks = trackers.map((tracker: Tracker) => tracker.getInfoChunk());

-    const infoPackets: Buffer[] = [];
+    const infoPackets: Uint8Array[] = [];

-    const trackerChunksLists: Buffer[][] = [];
-    let currentTrackerList: Buffer[] = [];
+    const trackerChunksLists: Uint8Array[][] = [];
+    let currentTrackerList: Uint8Array[] = [];

    let currentInfoPacketSize = Constants.PACKET_HEADER_SIZE + systemNameChunk.length + Constants.CHUNK_HEADER_SIZE;

-    trackerChunks.forEach((trackerChunk: Buffer) => {
+    trackerChunks.forEach((trackerChunk: Uint8Array) => {
      if (currentInfoPacketSize + trackerChunk.length > Constants.MAX_UDP_PACKET_SIZE) {
        trackerChunksLists.push(currentTrackerList);
        currentTrackerList = [];
@@ -95,10 +95,10 @@ export class Encoder {
    }

    const allTrackerChunks = trackers.map((tracker) => tracker.getDataChunk());
-    const dataPackets: Buffer[] = [];
+    const dataPackets: Uint8Array[] = [];

-    const trackerChunksLists: Buffer[][] = [];
-    let currentTrackerList: Buffer[] = [];
+    const trackerChunksLists: Uint8Array[][] = [];
+    let currentTrackerList: Uint8Array[] = [];

    let currentDataPacketSize = Constants.PACKET_HEADER_SIZE + Constants.CHUNK_HEADER_SIZE;

@@ -1,4 +1,5 @@
-export default (id: number, chunkData: Buffer, hasSubchunks: boolean): Buffer => {
+const header = new DataView(new ArrayBuffer(4));
+export default (id: number, chunkData: Uint8Array, hasSubchunks: boolean): Uint8Array => {
  if (!Number.isInteger(id)) {
    throw new Error('chunk id must be an integer');
  }
@@ -11,10 +12,14 @@ export default (id: number, chunkData: Buffer, hasSubchunks: boolean): Buffer =>
    throw new Error('chunkData can not be greater than 32767 bytes');
  }

-  const header = Buffer.alloc(4);
-  header.writeUInt16LE(id);
+  header.setUint16(0, id, true);
  const hasSubChunksBit = (hasSubchunks ? 1 : 0) << 15;
-  header.writeUInt16LE(hasSubChunksBit + chunkData.length, 2);
+  header.setUint16(2, hasSubChunksBit + chunkData.length, true);

-  return Buffer.concat([header, chunkData]);
+  const headerBytes = new Uint8Array(header.buffer);
+
+  const bytes = new Uint8Array(headerBytes.length + chunkData.length);
+  bytes.set(headerBytes);
+  bytes.set(chunkData, headerBytes.length);
+  return bytes;
 };
@@ -1,3 +1,7 @@
-import chunk from '../chunk';
-export default (packetHeaderChunk: Buffer, trackerListChunk: Buffer): Buffer =>
-  chunk(0x6755, Buffer.concat([packetHeaderChunk, trackerListChunk]), true);
+import chunk from '../chunk.js';
+export default (packetHeaderChunk: Uint8Array, trackerListChunk: Uint8Array): Uint8Array => {
+  const chunkData = new Uint8Array(packetHeaderChunk.length + trackerListChunk.length);
+  chunkData.set(packetHeaderChunk);
+  chunkData.set(trackerListChunk, packetHeaderChunk.length);
+  return chunk(0x6755, chunkData, true);
+};
@@ -1,9 +1,9 @@
-import chunk from '../chunk';
+import chunk from '../chunk.js';

-export default (x: number, y: number, z: number): Buffer => {
-  const buf = Buffer.alloc(12);
-  buf.writeFloatLE(x);
-  buf.writeFloatLE(y, 4);
-  buf.writeFloatLE(z, 8);
-  return chunk(0x0004, buf, false);
+const floatArray = new Float32Array(3);
+export default (x: number, y: number, z: number): Uint8Array => {
+  floatArray[0] = x;
+  floatArray[1] = y;
+  floatArray[2] = z;
+  return chunk(0x0004, new Uint8Array(floatArray.buffer), false);
 };
@@ -1,4 +1,20 @@
-import chunk from '../chunk';
+import chunk from '../chunk.js';

-export default (trackerId: number, fieldChunks: Buffer[]): Buffer =>
-  chunk(trackerId, Buffer.concat(fieldChunks), fieldChunks.length > 0);
+export default (trackerId: number, fieldChunks: Uint8Array[]): Uint8Array => {
+  let fieldChunksTotalLength = 0;
+
+  fieldChunks.forEach((fieldChunk) => {
+    fieldChunksTotalLength += fieldChunk.length;
+  });
+
+  const fieldChunksBytes = new Uint8Array(fieldChunksTotalLength);
+
+  let offset = 0;
+
+  fieldChunks.forEach((fieldChunk) => {
+    fieldChunksBytes.set(fieldChunk, offset);
+    offset += fieldChunk.length;
+  });
+
+  return chunk(trackerId, fieldChunksBytes, fieldChunks.length > 0);
+};
@@ -1,3 +1,20 @@
-import chunk from '../chunk';
+import chunk from '../chunk.js';

-export default (trackerChunks: Buffer[]) => chunk(0x0001, Buffer.concat(trackerChunks), true);
+export default (trackerChunks: Uint8Array[]) => {
+  let trackerChunksTotalLength = 0;
+
+  trackerChunks.forEach((trackerChunk) => {
+    trackerChunksTotalLength += trackerChunk.length;
+  });
+
+  const trackerChunksBytes = new Uint8Array(trackerChunksTotalLength);
+
+  let offset = 0;
+
+  trackerChunks.forEach((trackerChunk) => {
+    trackerChunksBytes.set(trackerChunk, offset);
+    offset += trackerChunk.length;
+  });
+
+  return chunk(0x0001, trackerChunksBytes, true);
+};
@@ -1,9 +1,9 @@
-import chunk from '../chunk';
+import chunk from '../chunk.js';

-export default (x: number, y: number, z: number): Buffer => {
-  const buf = Buffer.alloc(12);
-  buf.writeFloatLE(x);
-  buf.writeFloatLE(y, 4);
-  buf.writeFloatLE(z, 8);
-  return chunk(0x0002, buf, false);
+const floatArray = new Float32Array(3);
+export default (x: number, y: number, z: number): Uint8Array => {
+  floatArray[0] = x;
+  floatArray[1] = y;
+  floatArray[2] = z;
+  return chunk(0x0002, new Uint8Array(floatArray.buffer), false);
 };
@@ -1,9 +1,10 @@
-import chunk from '../chunk';
+import chunk from '../chunk.js';

-export default (x: number, y: number, z: number): Buffer => {
-  const buf = Buffer.alloc(12);
-  buf.writeFloatLE(x);
-  buf.writeFloatLE(y, 4);
-  buf.writeFloatLE(z, 8);
-  return chunk(0x0000, buf, false);
+const floatArray = new Float32Array(3);
+export default (x: number, y: number, z: number): Uint8Array => {
+  floatArray[0] = x;
+  floatArray[1] = y;
+  floatArray[2] = z;
+
+  return chunk(0x0000, new Uint8Array(floatArray.buffer), false);
 };
@@ -1,9 +1,10 @@
-import chunk from '../chunk';
+import chunk from '../chunk.js';

-export default (x: number, y: number, z: number): Buffer => {
-  const buf = Buffer.alloc(12);
-  buf.writeFloatLE(x);
-  buf.writeFloatLE(y, 4);
-  buf.writeFloatLE(z, 8);
-  return chunk(0x0001, buf, false);
+const floatArray = new Float32Array(3);
+export default (x: number, y: number, z: number): Uint8Array => {
+  floatArray[0] = x;
+  floatArray[1] = y;
+  floatArray[2] = z;
+
+  return chunk(0x0001, new Uint8Array(floatArray.buffer), false);
 };
@@ -1,7 +1,7 @@
-import chunk from '../chunk';
+import chunk from '../chunk.js';

-export default (validity: number): Buffer => {
-  const buf = Buffer.alloc(4);
-  buf.writeFloatLE(validity);
-  return chunk(0x0003, buf, false);
+const floatArray = new Float32Array(1);
+export default (validity: number): Uint8Array => {
+  floatArray[0] = validity;
+  return chunk(0x0003, new Uint8Array(floatArray.buffer), false);
 };
@@ -1,7 +1,7 @@
-import chunk from '../chunk';
+import chunk from '../chunk.js';

-export default (timestamp: bigint): Buffer => {
-  const buf = Buffer.alloc(8);
-  buf.writeBigUInt64LE(BigInt(timestamp));
-  return chunk(0x0006, buf, false);
+const buf = new DataView(new ArrayBuffer(8));
+export default (timestamp: bigint): Uint8Array => {
+  buf.setBigUint64(0, BigInt(timestamp), true);
+  return chunk(0x0006, new Uint8Array(buf.buffer), false);
 };
@@ -1,9 +1,10 @@
-import chunk from '../chunk';
+import chunk from '../chunk.js';

-export default (x: number, y: number, z: number): Buffer => {
-  const buf = Buffer.alloc(12);
-  buf.writeFloatLE(x);
-  buf.writeFloatLE(y, 4);
-  buf.writeFloatLE(z, 8);
-  return chunk(0x0005, buf, false);
+const floatArray = new Float32Array(3);
+export default (x: number, y: number, z: number): Uint8Array => {
+  floatArray[0] = x;
+  floatArray[1] = y;
+  floatArray[2] = z;
+
+  return chunk(0x0005, new Uint8Array(floatArray.buffer), false);
 };
@@ -1,21 +1,21 @@
-import Chunk from './chunk';
-import DataPacketChunk from './data/data-packet-chunk';
-import DataTrackerAccelChunk from './data/data-tracker-accel-chunk';
-import DataTrackerChunk from './data/data-tracker-chunk';
-import DataTrackerListChunk from './data/data-tracker-list-chunk';
-import DataTrackerOriChunk from './data/data-tracker-ori-chunk';
-import DataTrackerPosChunk from './data/data-tracker-pos-chunk';
-import DataTrackerSpeedChunk from './data/data-tracker-speed-chunk';
-import DataTrackerStatusChunk from './data/data-tracker-status-chunk';
-import DataTrackerTimestampChunk from './data/data-tracker-timestamp-chunk';
-import DataTrackerTrgtposChunk from './data/data-tracker-trgtpos-chunk';
-import PacketHeaderChunk from './packet-header-chunk';
+import Chunk from './chunk.js';
+import DataPacketChunk from './data/data-packet-chunk.js';
+import DataTrackerAccelChunk from './data/data-tracker-accel-chunk.js';
+import DataTrackerChunk from './data/data-tracker-chunk.js';
+import DataTrackerListChunk from './data/data-tracker-list-chunk.js';
+import DataTrackerOriChunk from './data/data-tracker-ori-chunk.js';
+import DataTrackerPosChunk from './data/data-tracker-pos-chunk.js';
+import DataTrackerSpeedChunk from './data/data-tracker-speed-chunk.js';
+import DataTrackerStatusChunk from './data/data-tracker-status-chunk.js';
+import DataTrackerTimestampChunk from './data/data-tracker-timestamp-chunk.js';
+import DataTrackerTrgtposChunk from './data/data-tracker-trgtpos-chunk.js';
+import PacketHeaderChunk from './packet-header-chunk.js';

-import InfoPacketChunk from './info/info-packet-chunk';
-import InfoSystemNameChunk from './info/info-system-name-chunk';
-import InfoTrackerChunk from './info/info-tracker-chunk';
-import InfoTrackerListChunk from './info/info-tracker-list-chunk';
-import InfoTrackerNameChunk from './info/info-tracker-name-chunk';
+import InfoPacketChunk from './info/info-packet-chunk.js';
+import InfoSystemNameChunk from './info/info-system-name-chunk.js';
+import InfoTrackerChunk from './info/info-tracker-chunk.js';
+import InfoTrackerListChunk from './info/info-tracker-list-chunk.js';
+import InfoTrackerNameChunk from './info/info-tracker-name-chunk.js';

 export const Encoders = {
  DataPacketChunk,
@@ -1,4 +1,14 @@
-import chunk from '../chunk';
+import chunk from '../chunk.js';

-export default (packetHeaderChunk: Buffer, systemNameChunk: Buffer, trackerListChunk: Buffer): Buffer =>
-  chunk(0x6756, Buffer.concat([packetHeaderChunk, systemNameChunk, trackerListChunk]), true);
+export default (
+  packetHeaderChunk: Uint8Array,
+  systemNameChunk: Uint8Array,
+  trackerListChunk: Uint8Array
+): Uint8Array => {
+  const chunkData = new Uint8Array(packetHeaderChunk.length + systemNameChunk.length + trackerListChunk.length);
+
+  chunkData.set(packetHeaderChunk);
+  chunkData.set(systemNameChunk, packetHeaderChunk.length);
+  chunkData.set(trackerListChunk, packetHeaderChunk.length + systemNameChunk.length);
+  return chunk(0x6756, chunkData, true);
+};
@@ -1,3 +1,3 @@
-import chunk from '../chunk';
-
-export default (systemName: string): Buffer => chunk(0x0001, Buffer.from(systemName), false);
+import chunk from '../chunk.js';
+const nameEncoder = new TextEncoder();
+export default (systemName: string): Uint8Array => chunk(0x0001, nameEncoder.encode(systemName), false);
@@ -1,3 +1,4 @@
-import chunk from '../chunk';
+import chunk from '../chunk.js';

-export default (trackerId: number, trackerNameChunk: Buffer): Buffer => chunk(trackerId, trackerNameChunk, true);
+export default (trackerId: number, trackerNameChunk: Uint8Array): Uint8Array =>
+  chunk(trackerId, trackerNameChunk, true);
@@ -1,3 +1,19 @@
-import chunk from '../chunk';
+import chunk from '../chunk.js';

-export default (trackerChunks: Buffer[]): Buffer => chunk(0x0002, Buffer.concat(trackerChunks), true);
+export default (trackerChunks: Uint8Array[]): Uint8Array => {
+  let trackerChunksTotalLength = 0;
+
+  trackerChunks.forEach((trackerChunk) => {
+    trackerChunksTotalLength += trackerChunk.length;
+  });
+
+  const trackerChunksBytes = new Uint8Array(trackerChunksTotalLength);
+
+  let offset = 0;
+
+  trackerChunks.forEach((trackerChunk) => {
+    trackerChunksBytes.set(trackerChunk, offset);
+    offset += trackerChunk.length;
+  });
+  return chunk(0x0002, trackerChunksBytes, true);
+};
@@ -1,3 +1,4 @@
-import chunk from '../chunk';
+import chunk from '../chunk.js';

-export default (trackerName: string) => chunk(0x0000, Buffer.from(trackerName), false);
+const nameEncoder = new TextEncoder();
+export default (trackerName: string) => chunk(0x0000, nameEncoder.encode(trackerName), false);
@@ -1,12 +1,13 @@
-import chunk from './chunk';
+import chunk from './chunk.js';

+const packetHeader = new DataView(new ArrayBuffer(12));
 export default (
  timestamp: bigint,
  versionHigh: number,
  versionLow: number,
  frameId: number,
  framePacketCount: number
-): Buffer => {
+): Uint8Array => {
  if (!Number.isInteger(versionHigh)) {
    throw new Error('version high must be an integer');
  }
@@ -33,12 +34,11 @@ export default (
    throw new Error('frame packet count must be >= 0 and <= 255');
  }

-  const packetHeader = Buffer.alloc(12);
-  packetHeader.writeBigUInt64LE(BigInt(timestamp));
-  packetHeader.writeUint8(versionHigh, 8);
-  packetHeader.writeUint8(versionLow, 9);
-  packetHeader.writeUint8(frameId, 10);
-  packetHeader.writeUint8(framePacketCount, 11);
+  packetHeader.setBigUint64(0, BigInt(timestamp), true);
+  packetHeader.setUint8(8, versionHigh);
+  packetHeader.setUint8(9, versionLow);
+  packetHeader.setUint8(10, frameId);
+  packetHeader.setUint8(11, framePacketCount);

-  return chunk(0x0000, packetHeader, false);
+  return chunk(0x0000, new Uint8Array(packetHeader.buffer), false);
 };
@@ -1,5 +1,5 @@
-export { Decoder } from './decoder';
-export * from './decoders';
-export { Encoder } from './encoder';
-export * from './encoders';
-export * from './models';
+export { Decoder } from './decoder.js';
+export * from './decoders/index.js';
+export { Encoder } from './encoder.js';
+export * from './encoders/index.js';
+export * from './models/index.js';
@@ -1,6 +1,10 @@
-export interface Chunk {
-  id?: number;
-  has_subchunks?: boolean;
-  data_len?: number;
-  chunk_data?: Buffer;
+export interface ChunkHeader {
+  id: number;
+  dataLen: number;
+  hasSubchunks: boolean;
+}
+
+export interface Chunk {
+  chunkData: Uint8Array;
+  header: ChunkHeader;
 }
@@ -1,8 +1,13 @@
-import { Chunk } from '../chunk';
-import { PacketHeaderChunk } from '../packet-header-chunk';
-import { DataTrackerListChunk } from './data-tracker-list-chunk';
+import type { Chunk } from '../chunk.js';
+import type { PacketHeaderChunk } from '../packet-header-chunk.js';
+import type { DataTrackerListChunk } from './data-tracker-list-chunk.js';

-export interface DataPacketChunk extends Chunk {
-  packet_header: PacketHeaderChunk;
-  tracker_list: DataTrackerListChunk;
+export interface DataPacketChunkData {
+  packetHeader?: PacketHeaderChunk;
+  trackerList?: DataTrackerListChunk;
+}
+
+export interface DataPacketChunk {
+  chunk: Chunk;
+  data: DataPacketChunkData;
 }
@@ -1,12 +1,19 @@
-import { Chunk } from '../chunk';
-import { DataTrackerFieldChunk } from './data-tracker-field-chunk';
+import type { Chunk } from '../chunk.js';
+import type { DataTrackerStatusChunk } from './data-tracker-status-chunk.js';
+import type { DataTrackerTimestampChunk } from './data-tracker-timestamp-chunk.js';
+import type { DataTrackerXYZChunk } from './data-tracker-xyz-chunk.js';

-export interface DataTrackerChunk extends Chunk {
-  pos?: DataTrackerFieldChunk;
-  speed?: DataTrackerFieldChunk;
-  ori?: DataTrackerFieldChunk;
-  status?: DataTrackerFieldChunk;
-  accel?: DataTrackerFieldChunk;
-  trgtpos?: DataTrackerFieldChunk;
-  timestamp?: DataTrackerFieldChunk;
+export interface DataTrackerChunkData {
+  pos?: DataTrackerXYZChunk;
+  speed?: DataTrackerXYZChunk;
+  ori?: DataTrackerXYZChunk;
+  status?: DataTrackerStatusChunk;
+  accel?: DataTrackerXYZChunk;
+  trgtpos?: DataTrackerXYZChunk;
+  timestamp?: DataTrackerTimestampChunk;
+}
+
+export interface DataTrackerChunk {
+  chunk: Chunk;
+  data: DataTrackerChunkData;
 }
@@ -1,5 +0,0 @@
-import { Chunk } from '../chunk';
-
-export interface DataTrackerFieldChunk extends Chunk {
-  [key: string]: number | bigint | number[] | Buffer | undefined | boolean;
-}
@@ -1,8 +1,11 @@
-import { Chunk } from '../chunk';
-import { DataTrackerChunk } from './data-tracker-chunk';
+import type { Chunk } from '../chunk.js';
+import type { DataTrackerChunk } from './data-tracker-chunk.js';

-export interface DataTrackerListChunk extends Chunk {
-  trackers: {
-    [key: number]: DataTrackerChunk;
-  };
+export interface DataTrackerListChunkData {
+  trackers: DataTrackerChunk[];
+}
+
+export interface DataTrackerListChunk {
+  chunk: Chunk;
+  data: DataTrackerListChunkData;
 }
@@ -0,0 +1,10 @@
+import type { Chunk } from '../chunk.js';
+
+export interface DataTrackerStatusChunkData {
+  validity: number;
+}
+
+export interface DataTrackerStatusChunk {
+  chunk: Chunk;
+  data: DataTrackerStatusChunkData;
+}
@@ -0,0 +1,10 @@
+import type { Chunk } from '../chunk.js';
+
+export interface DataTrackerTimestampChunkData {
+  timestamp: bigint;
+}
+
+export interface DataTrackerTimestampChunk {
+  chunk: Chunk;
+  data: DataTrackerTimestampChunkData;
+}
@@ -0,0 +1,12 @@
+import type { Chunk } from '../chunk.js';
+
+export interface DataTrackerXYZChunkData {
+  x: number;
+  y: number;
+  z: number;
+}
+
+export interface DataTrackerXYZChunk {
+  chunk: Chunk;
+  data: DataTrackerXYZChunkData;
+}
@@ -1,12 +1,11 @@
-export * from './chunk';
-export * from './data/data-packet-chunk';
-export * from './data/data-tracker-chunk';
-export * from './data/data-tracker-field-chunk';
-export * from './data/data-tracker-list-chunk';
-export * from './info/info-packet-chunk';
-export * from './info/info-system-name-chunk';
-export * from './info/info-tracker-chunk';
-export * from './info/info-tracker-list-chunk';
-export * from './info/info-tracker-name-chunk';
-export * from './packet-header-chunk';
-export * from './tracker';
+export * from './chunk.js';
+export * from './data/data-packet-chunk.js';
+export * from './data/data-tracker-chunk.js';
+export * from './data/data-tracker-list-chunk.js';
+export * from './info/info-packet-chunk.js';
+export * from './info/info-system-name-chunk.js';
+export * from './info/info-tracker-chunk.js';
+export * from './info/info-tracker-list-chunk.js';
+export * from './info/info-tracker-name-chunk.js';
+export * from './packet-header-chunk.js';
+export * from './tracker.js';
@@ -1,10 +1,14 @@
-import { Chunk } from '../chunk';
-import { PacketHeaderChunk } from '../packet-header-chunk';
-import { InfoSystemNameChunk } from './info-system-name-chunk';
-import { InfoTrackerListChunk } from './info-tracker-list-chunk';
+import type { Chunk } from '../chunk.js';
+import type { PacketHeaderChunk } from '../packet-header-chunk.js';
+import type { InfoSystemNameChunk } from './info-system-name-chunk.js';
+import type { InfoTrackerListChunk } from './info-tracker-list-chunk.js';

-export interface InfoPacketChunk extends Chunk {
-  packet_header: PacketHeaderChunk;
-  system_name: InfoSystemNameChunk;
-  tracker_list: InfoTrackerListChunk;
+export interface InfoPacketChunkData {
+  packetHeader?: PacketHeaderChunk;
+  systemName?: InfoSystemNameChunk;
+  trackerList?: InfoTrackerListChunk;
+}
+export interface InfoPacketChunk {
+  chunk: Chunk;
+  data: InfoPacketChunkData;
 }
@@ -1,5 +1,10 @@
-import { Chunk } from '../chunk';
+import type { Chunk } from '../chunk.js';

-export interface InfoSystemNameChunk extends Chunk {
-  system_name: string;
+export interface InfoSystemNameChunkData {
+  systemName: string;
+}
+
+export interface InfoSystemNameChunk {
+  chunk: Chunk;
+  data: InfoSystemNameChunkData;
 }
@@ -1,6 +1,11 @@
-import { Chunk } from '../chunk';
-import { InfoTrackerNameChunk } from './info-tracker-name-chunk';
+import type { Chunk } from '../chunk.js';
+import type { InfoTrackerNameChunk } from './info-tracker-name-chunk.js';

-export interface InfoTrackerChunk extends Chunk {
-  tracker_name?: InfoTrackerNameChunk;
+export interface InfoTrackerChunkData {
+  trackerName: InfoTrackerNameChunk;
+}
+
+export interface InfoTrackerChunk {
+  chunk: Chunk;
+  data?: InfoTrackerChunkData;
 }
@@ -1,8 +1,11 @@
-import { Chunk } from '../chunk';
-import { InfoTrackerChunk } from './info-tracker-chunk';
+import type { Chunk } from '../chunk.js';
+import type { InfoTrackerChunk } from './info-tracker-chunk.js';

-export interface InfoTrackerListChunk extends Chunk {
-  trackers: {
-    [key: number]: InfoTrackerChunk;
-  };
+export interface InfoTrackerListChunkData {
+  trackers: InfoTrackerChunk[];
+}
+
+export interface InfoTrackerListChunk {
+  chunk: Chunk;
+  data: InfoTrackerListChunkData;
 }
@@ -1,5 +1,10 @@
-import { Chunk } from '../chunk';
+import type { Chunk } from '../chunk.js';

-export interface InfoTrackerNameChunk extends Chunk {
-  tracker_name: string;
+export interface InfoTrackerNameChunkData {
+  trackerName: string;
+}
+
+export interface InfoTrackerNameChunk {
+  chunk: Chunk;
+  data: InfoTrackerNameChunkData;
 }
@@ -1,9 +1,14 @@
-import { Chunk } from './chunk';
+import type { Chunk } from './chunk.js';

-export interface PacketHeaderChunk extends Chunk {
-  packet_timestamp?: bigint;
-  version_high?: number;
-  version_low?: number;
-  frame_id?: number;
-  frame_packet_count?: number;
+export interface PacketHeaderChunkData {
+  packetTimestamp: bigint;
+  versionHigh: number;
+  versionLow: number;
+  frameId: number;
+  framePacketCount: number;
+}
+
+export interface PacketHeaderChunk {
+  chunk: Chunk;
+  data: PacketHeaderChunkData;
 }
@@ -1,23 +1,31 @@
-import dataTrackerAccelChunk from '../encoders/data/data-tracker-accel-chunk';
-import dataTrackerChunk from '../encoders/data/data-tracker-chunk';
-import dataTrackerOriChunk from '../encoders/data/data-tracker-ori-chunk';
-import dataTrackerPosChunk from '../encoders/data/data-tracker-pos-chunk';
-import dataTrackerSpeedChunk from '../encoders/data/data-tracker-speed-chunk';
-import dataTrackerStatusChunk from '../encoders/data/data-tracker-status-chunk';
-import dataTrackerTimestampChunk from '../encoders/data/data-tracker-timestamp-chunk';
-import dataTrackerTrgtposChunk from '../encoders/data/data-tracker-trgtpos-chunk';
-import infoTrackerChunk from '../encoders/info/info-tracker-chunk';
-import infoTrackerNameChunk from '../encoders/info/info-tracker-name-chunk';
+import dataTrackerAccelChunk from '../encoders/data/data-tracker-accel-chunk.js';
+import dataTrackerChunk from '../encoders/data/data-tracker-chunk.js';
+import dataTrackerOriChunk from '../encoders/data/data-tracker-ori-chunk.js';
+import dataTrackerPosChunk from '../encoders/data/data-tracker-pos-chunk.js';
+import dataTrackerSpeedChunk from '../encoders/data/data-tracker-speed-chunk.js';
+import dataTrackerStatusChunk from '../encoders/data/data-tracker-status-chunk.js';
+import dataTrackerTimestampChunk from '../encoders/data/data-tracker-timestamp-chunk.js';
+import dataTrackerTrgtposChunk from '../encoders/data/data-tracker-trgtpos-chunk.js';
+import infoTrackerChunk from '../encoders/info/info-tracker-chunk.js';
+import infoTrackerNameChunk from '../encoders/info/info-tracker-name-chunk.js';
+import type { DataTrackerChunk } from './data/data-tracker-chunk.js';
+import type { InfoTrackerChunk } from './info/info-tracker-chunk.js';
+
+export type XYZData = {
+  x: number;
+  y: number;
+  z: number;
+};

 export class Tracker {
  id: number;
  name: string;
-  pos?: [number, number, number];
-  speed?: [number, number, number];
-  ori?: [number, number, number];
+  pos?: XYZData;
+  speed?: XYZData;
+  ori?: XYZData;
  validity?: number;
-  accel?: [number, number, number];
-  trgtpos?: [number, number, number];
+  accel?: XYZData;
+  trgtpos?: XYZData;
  timestamp?: bigint;

  constructor(id: number, name: string) {
@@ -33,15 +41,45 @@ export class Tracker {
  }

  setPos(x: number, y: number, z: number) {
-    this.pos = [x, y, z];
+    if (this.pos === undefined) {
+      this.pos = {
+        x,
+        y,
+        z,
+      };
+    } else {
+      this.pos.x = x;
+      this.pos.y = y;
+      this.pos.z = z;
+    }
  }

  setSpeed(x: number, y: number, z: number) {
-    this.speed = [x, y, z];
+    if (this.speed === undefined) {
+      this.speed = {
+        x,
+        y,
+        z,
+      };
+    } else {
+      this.speed.x = x;
+      this.speed.y = y;
+      this.speed.z = z;
+    }
  }

  setOri(x: number, y: number, z: number) {
-    this.ori = [x, y, z];
+    if (this.ori === undefined) {
+      this.ori = {
+        x,
+        y,
+        z,
+      };
+    } else {
+      this.ori.x = x;
+      this.ori.y = y;
+      this.ori.z = z;
+    }
  }

  setStatus(validity: number) {
@@ -49,11 +87,31 @@ export class Tracker {
  }

  setAccel(x: number, y: number, z: number) {
-    this.accel = [x, y, z];
+    if (this.accel === undefined) {
+      this.accel = {
+        x,
+        y,
+        z,
+      };
+    } else {
+      this.accel.x = x;
+      this.accel.y = y;
+      this.accel.z = z;
+    }
  }

  setTrgtPos(x: number, y: number, z: number) {
-    this.trgtpos = [x, y, z];
+    if (this.trgtpos === undefined) {
+      this.trgtpos = {
+        x,
+        y,
+        z,
+      };
+    } else {
+      this.trgtpos.x = x;
+      this.trgtpos.y = y;
+      this.trgtpos.z = z;
+    }
  }

  setTimestamp(timestamp: bigint) {
@@ -61,18 +119,18 @@ export class Tracker {
  }

  getDataChunk() {
-    const fieldChunks: Buffer[] = [];
+    const fieldChunks: Uint8Array[] = [];

    if (this.pos) {
-      fieldChunks.push(dataTrackerPosChunk(...this.pos));
+      fieldChunks.push(dataTrackerPosChunk(this.pos.x, this.pos.y, this.pos.z));
    }

    if (this.speed) {
-      fieldChunks.push(dataTrackerSpeedChunk(...this.speed));
+      fieldChunks.push(dataTrackerSpeedChunk(this.speed.x, this.speed.y, this.speed.z));
    }

    if (this.ori) {
-      fieldChunks.push(dataTrackerOriChunk(...this.ori));
+      fieldChunks.push(dataTrackerOriChunk(this.ori.x, this.ori.y, this.ori.z));
    }

    if (this.validity) {
@@ -80,11 +138,11 @@ export class Tracker {
    }

    if (this.accel) {
-      fieldChunks.push(dataTrackerAccelChunk(...this.accel));
+      fieldChunks.push(dataTrackerAccelChunk(this.accel.x, this.accel.y, this.accel.z));
    }

    if (this.trgtpos) {
-      fieldChunks.push(dataTrackerTrgtposChunk(...this.trgtpos));
+      fieldChunks.push(dataTrackerTrgtposChunk(this.trgtpos.x, this.trgtpos.y, this.trgtpos.z));
    }

    if (this.timestamp) {
@@ -97,4 +155,68 @@ export class Tracker {
  getInfoChunk() {
    return infoTrackerChunk(this.id, infoTrackerNameChunk(this.name));
  }
+
+  updateInfo(infoTrackerChunk: InfoTrackerChunk) {
+    if (infoTrackerChunk.data) {
+      this.name = infoTrackerChunk.data.trackerName.data.trackerName;
+    }
+  }
+
+  updateData(dataTrackerChunk: DataTrackerChunk) {
+    if (dataTrackerChunk.data.pos) {
+      this.setPos(dataTrackerChunk.data.pos.data.x, dataTrackerChunk.data.pos.data.y, dataTrackerChunk.data.pos.data.z);
+    }
+
+    if (dataTrackerChunk.data.speed) {
+      this.setSpeed(
+        dataTrackerChunk.data.speed.data.x,
+        dataTrackerChunk.data.speed.data.y,
+        dataTrackerChunk.data.speed.data.z
+      );
+    }
+
+    if (dataTrackerChunk.data.ori) {
+      this.setOri(dataTrackerChunk.data.ori.data.x, dataTrackerChunk.data.ori.data.y, dataTrackerChunk.data.ori.data.z);
+    }
+
+    if (dataTrackerChunk.data.status) {
+      this.setStatus(dataTrackerChunk.data.status.data.validity);
+    }
+
+    if (dataTrackerChunk.data.accel) {
+      this.setAccel(
+        dataTrackerChunk.data.accel.data.x,
+        dataTrackerChunk.data.accel.data.y,
+        dataTrackerChunk.data.accel.data.z
+      );
+    }
+
+    if (dataTrackerChunk.data.trgtpos) {
+      this.setTrgtPos(
+        dataTrackerChunk.data.trgtpos.data.x,
+        dataTrackerChunk.data.trgtpos.data.y,
+        dataTrackerChunk.data.trgtpos.data.z
+      );
+    }
+
+    if (dataTrackerChunk.data.timestamp) {
+      this.setTimestamp(dataTrackerChunk.data.timestamp.data.timestamp);
+    }
+  }
+}
+
+export function TrackerFromInfo(infoTrackerChunk: InfoTrackerChunk) {
+  if (infoTrackerChunk.data) {
+    return new Tracker(infoTrackerChunk.chunk.header.id, infoTrackerChunk.data.trackerName.data.trackerName);
+  }
+  return undefined;
+}
+
+export function TrackerFromData(dataTrackerChunk: DataTrackerChunk) {
+  if (dataTrackerChunk.data) {
+    const tracker = new Tracker(dataTrackerChunk.chunk.header.id, '');
+    tracker.updateData(dataTrackerChunk);
+    return tracker;
+  }
+  return undefined;
 }
@@ -0,0 +1,647 @@
+import { Decoders } from '@jwetzell/posistagenet';
+import { deepEqual, throws } from 'assert';
+import { describe, it } from 'node:test';
+
+const goodTests = [
+  {
+    description: 'DataTrackerPosChunk',
+    bytes: new Uint8Array([0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+    expected: {
+      chunk: {
+        chunkData: new Uint8Array([0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+        header: { dataLen: 12, id: 0, hasSubchunks: false },
+      },
+      data: {
+        x: 1.0,
+        y: 2.0,
+        z: 3.0,
+      },
+    },
+    decoder: Decoders.DataTrackerXYZChunk,
+  },
+  {
+    description: 'DataTrackerSpeedChunk',
+    bytes: new Uint8Array([1, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+    expected: {
+      chunk: {
+        chunkData: new Uint8Array([0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+        header: { dataLen: 12, id: 1, hasSubchunks: false },
+      },
+      data: {
+        x: 1.0,
+        y: 2.0,
+        z: 3.0,
+      },
+    },
+    decoder: Decoders.DataTrackerXYZChunk,
+  },
+  {
+    description: 'DataTrackerOriChunk',
+    bytes: new Uint8Array([2, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+    expected: {
+      chunk: {
+        chunkData: new Uint8Array([0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+        header: { dataLen: 12, id: 2, hasSubchunks: false },
+      },
+      data: {
+        x: 1.0,
+        y: 2.0,
+        z: 3.0,
+      },
+    },
+    decoder: Decoders.DataTrackerXYZChunk,
+  },
+  {
+    description: 'DataTrackerStatusChunk',
+    bytes: new Uint8Array([3, 0, 4, 0, 0, 0, 128, 63]),
+    expected: {
+      chunk: {
+        chunkData: new Uint8Array([0, 0, 128, 63]),
+        header: { dataLen: 4, id: 3, hasSubchunks: false },
+      },
+      data: {
+        validity: 1.0,
+      },
+    },
+    decoder: Decoders.DataTrackerStatusChunk,
+  },
+  {
+    description: 'DataTrackerAccelChunk',
+    bytes: new Uint8Array([4, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+    expected: {
+      chunk: {
+        chunkData: new Uint8Array([0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+        header: { dataLen: 12, id: 4, hasSubchunks: false },
+      },
+      data: {
+        x: 1.0,
+        y: 2.0,
+        z: 3.0,
+      },
+    },
+    decoder: Decoders.DataTrackerXYZChunk,
+  },
+  {
+    description: 'DataTrackerTrgtPosChunk',
+    bytes: new Uint8Array([5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+    expected: {
+      chunk: {
+        chunkData: new Uint8Array([0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+        header: { dataLen: 12, id: 5, hasSubchunks: false },
+      },
+      data: {
+        x: 1.0,
+        y: 2.0,
+        z: 3.0,
+      },
+    },
+    decoder: Decoders.DataTrackerXYZChunk,
+  },
+  {
+    description: 'DataTrackerTimestampChunk',
+    bytes: new Uint8Array([6, 0, 8, 0, 210, 2, 150, 73, 0, 0, 0, 0]),
+    expected: {
+      chunk: {
+        chunkData: new Uint8Array([210, 2, 150, 73, 0, 0, 0, 0]),
+        header: { dataLen: 8, id: 6, hasSubchunks: false },
+      },
+      data: {
+        timestamp: 1234567890n,
+      },
+    },
+    decoder: Decoders.DataTrackerTimestampChunk,
+  },
+  {
+    description: 'DataTrackerChunk',
+    bytes: new Uint8Array([
+      1, 0, 100, 128, 0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 1, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0,
+      0, 64, 64, 2, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128, 63, 4, 0, 12, 0, 0, 0,
+      128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 6, 0, 8, 0, 210, 2,
+      150, 73, 0, 0, 0, 0,
+    ]),
+    expected: {
+      chunk: {
+        chunkData: new Uint8Array([
+          0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 1, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64,
+          2, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128, 63, 4, 0, 12, 0, 0, 0, 128, 63,
+          0, 0, 0, 64, 0, 0, 64, 64, 5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 6, 0, 8, 0, 210, 2, 150, 73,
+          0, 0, 0, 0,
+        ]),
+        header: { dataLen: 100, id: 1, hasSubchunks: true },
+      },
+      data: {
+        pos: {
+          chunk: {
+            chunkData: new Uint8Array([0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+            header: { dataLen: 12, id: 0, hasSubchunks: false },
+          },
+          data: {
+            x: 1.0,
+            y: 2.0,
+            z: 3.0,
+          },
+        },
+        speed: {
+          chunk: {
+            chunkData: new Uint8Array([0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+            header: { dataLen: 12, id: 1, hasSubchunks: false },
+          },
+          data: {
+            x: 1.0,
+            y: 2.0,
+            z: 3.0,
+          },
+        },
+        ori: {
+          chunk: {
+            chunkData: new Uint8Array([0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+            header: { dataLen: 12, id: 2, hasSubchunks: false },
+          },
+          data: {
+            x: 1.0,
+            y: 2.0,
+            z: 3.0,
+          },
+        },
+        status: {
+          chunk: {
+            chunkData: new Uint8Array([0, 0, 128, 63]),
+            header: { dataLen: 4, id: 3, hasSubchunks: false },
+          },
+          data: {
+            validity: 1.0,
+          },
+        },
+        accel: {
+          chunk: {
+            chunkData: new Uint8Array([0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+            header: { dataLen: 12, id: 4, hasSubchunks: false },
+          },
+          data: {
+            x: 1.0,
+            y: 2.0,
+            z: 3.0,
+          },
+        },
+        trgtpos: {
+          chunk: {
+            chunkData: new Uint8Array([0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+            header: { dataLen: 12, id: 5, hasSubchunks: false },
+          },
+          data: {
+            x: 1.0,
+            y: 2.0,
+            z: 3.0,
+          },
+        },
+        timestamp: {
+          chunk: {
+            chunkData: new Uint8Array([210, 2, 150, 73, 0, 0, 0, 0]),
+            header: { dataLen: 8, id: 6, hasSubchunks: false },
+          },
+          data: {
+            timestamp: 1234567890n,
+          },
+        },
+      },
+    },
+    decoder: Decoders.DataTrackerChunk,
+  },
+  {
+    description: 'DataTrackerListChunk',
+    bytes: new Uint8Array([
+      1, 0, 104, 128, 1, 0, 100, 128, 0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 1, 0, 12, 0, 0, 0, 128, 63,
+      0, 0, 0, 64, 0, 0, 64, 64, 2, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128, 63, 4, 0,
+      12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 6, 0, 8,
+      0, 210, 2, 150, 73, 0, 0, 0, 0,
+    ]),
+    expected: {
+      chunk: {
+        chunkData: new Uint8Array([
+          1, 0, 100, 128, 0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 1, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0,
+          64, 0, 0, 64, 64, 2, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128, 63, 4, 0, 12,
+          0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 6, 0, 8,
+          0, 210, 2, 150, 73, 0, 0, 0, 0,
+        ]),
+        header: { dataLen: 104, id: 1, hasSubchunks: true },
+      },
+      data: {
+        trackers: [
+          {
+            chunk: {
+              chunkData: new Uint8Array([
+                0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 1, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0,
+                64, 64, 2, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128, 63, 4, 0, 12, 0,
+                0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 6, 0,
+                8, 0, 210, 2, 150, 73, 0, 0, 0, 0,
+              ]),
+              header: { dataLen: 100, id: 1, hasSubchunks: true },
+            },
+            data: {
+              pos: {
+                chunk: {
+                  chunkData: new Uint8Array([0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+                  header: { dataLen: 12, id: 0, hasSubchunks: false },
+                },
+                data: {
+                  x: 1.0,
+                  y: 2.0,
+                  z: 3.0,
+                },
+              },
+              speed: {
+                chunk: {
+                  chunkData: new Uint8Array([0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+                  header: { dataLen: 12, id: 1, hasSubchunks: false },
+                },
+                data: {
+                  x: 1.0,
+                  y: 2.0,
+                  z: 3.0,
+                },
+              },
+              ori: {
+                chunk: {
+                  chunkData: new Uint8Array([0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+                  header: { dataLen: 12, id: 2, hasSubchunks: false },
+                },
+                data: {
+                  x: 1.0,
+                  y: 2.0,
+                  z: 3.0,
+                },
+              },
+              status: {
+                chunk: {
+                  chunkData: new Uint8Array([0, 0, 128, 63]),
+                  header: { dataLen: 4, id: 3, hasSubchunks: false },
+                },
+                data: {
+                  validity: 1.0,
+                },
+              },
+              accel: {
+                chunk: {
+                  chunkData: new Uint8Array([0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+                  header: { dataLen: 12, id: 4, hasSubchunks: false },
+                },
+                data: {
+                  x: 1.0,
+                  y: 2.0,
+                  z: 3.0,
+                },
+              },
+              trgtpos: {
+                chunk: {
+                  chunkData: new Uint8Array([0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+                  header: { dataLen: 12, id: 5, hasSubchunks: false },
+                },
+                data: {
+                  x: 1.0,
+                  y: 2.0,
+                  z: 3.0,
+                },
+              },
+              timestamp: {
+                chunk: {
+                  chunkData: new Uint8Array([210, 2, 150, 73, 0, 0, 0, 0]),
+                  header: { dataLen: 8, id: 6, hasSubchunks: false },
+                },
+                data: {
+                  timestamp: 1234567890n,
+                },
+              },
+            },
+          },
+        ],
+      },
+    },
+    decoder: Decoders.DataTrackerListChunk,
+  },
+  {
+    description: 'DataPacketChunk',
+    bytes: new Uint8Array([
+      85, 103, 124, 128, 0, 0, 12, 0, 210, 2, 150, 73, 0, 0, 0, 0, 2, 3, 1, 123, 1, 0, 104, 128, 1, 0, 100, 128, 0, 0,
+      12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 1, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 2, 0, 12,
+      0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128, 63, 4, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64,
+      0, 0, 64, 64, 5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 6, 0, 8, 0, 210, 2, 150, 73, 0, 0, 0, 0,
+    ]),
+    expected: {
+      chunk: {
+        chunkData: new Uint8Array([
+          0, 0, 12, 0, 210, 2, 150, 73, 0, 0, 0, 0, 2, 3, 1, 123, 1, 0, 104, 128, 1, 0, 100, 128, 0, 0, 12, 0, 0, 0,
+          128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 1, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 2, 0, 12, 0, 0, 0,
+          128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128, 63, 4, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0,
+          64, 64, 5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 6, 0, 8, 0, 210, 2, 150, 73, 0, 0, 0, 0,
+        ]),
+        header: { dataLen: 124, id: 26453, hasSubchunks: true },
+      },
+      data: {
+        packetHeader: {
+          chunk: {
+            chunkData: new Uint8Array([210, 2, 150, 73, 0, 0, 0, 0, 2, 3, 1, 123]),
+            header: { dataLen: 12, id: 0, hasSubchunks: false },
+          },
+          data: {
+            packetTimestamp: 1234567890n,
+            versionHigh: 2,
+            versionLow: 3,
+            frameId: 1,
+            framePacketCount: 123,
+          },
+        },
+        trackerList: {
+          chunk: {
+            chunkData: new Uint8Array([
+              1, 0, 100, 128, 0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 1, 0, 12, 0, 0, 0, 128, 63, 0, 0,
+              0, 64, 0, 0, 64, 64, 2, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128, 63, 4,
+              0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64,
+              6, 0, 8, 0, 210, 2, 150, 73, 0, 0, 0, 0,
+            ]),
+            header: { dataLen: 104, id: 1, hasSubchunks: true },
+          },
+          data: {
+            trackers: [
+              {
+                chunk: {
+                  chunkData: new Uint8Array([
+                    0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 1, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0,
+                    0, 64, 64, 2, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128, 63, 4, 0,
+                    12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64,
+                    64, 6, 0, 8, 0, 210, 2, 150, 73, 0, 0, 0, 0,
+                  ]),
+                  header: { dataLen: 100, id: 1, hasSubchunks: true },
+                },
+                data: {
+                  pos: {
+                    chunk: {
+                      chunkData: new Uint8Array([0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+                      header: { dataLen: 12, id: 0, hasSubchunks: false },
+                    },
+                    data: {
+                      x: 1.0,
+                      y: 2.0,
+                      z: 3.0,
+                    },
+                  },
+                  speed: {
+                    chunk: {
+                      chunkData: new Uint8Array([0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+                      header: { dataLen: 12, id: 1, hasSubchunks: false },
+                    },
+                    data: {
+                      x: 1.0,
+                      y: 2.0,
+                      z: 3.0,
+                    },
+                  },
+                  ori: {
+                    chunk: {
+                      chunkData: new Uint8Array([0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+                      header: { dataLen: 12, id: 2, hasSubchunks: false },
+                    },
+                    data: {
+                      x: 1.0,
+                      y: 2.0,
+                      z: 3.0,
+                    },
+                  },
+                  status: {
+                    chunk: {
+                      chunkData: new Uint8Array([0, 0, 128, 63]),
+                      header: { dataLen: 4, id: 3, hasSubchunks: false },
+                    },
+                    data: {
+                      validity: 1.0,
+                    },
+                  },
+                  accel: {
+                    chunk: {
+                      chunkData: new Uint8Array([0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+                      header: { dataLen: 12, id: 4, hasSubchunks: false },
+                    },
+                    data: {
+                      x: 1.0,
+                      y: 2.0,
+                      z: 3.0,
+                    },
+                  },
+                  trgtpos: {
+                    chunk: {
+                      chunkData: new Uint8Array([0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+                      header: { dataLen: 12, id: 5, hasSubchunks: false },
+                    },
+                    data: {
+                      x: 1.0,
+                      y: 2.0,
+                      z: 3.0,
+                    },
+                  },
+                  timestamp: {
+                    chunk: {
+                      chunkData: new Uint8Array([210, 2, 150, 73, 0, 0, 0, 0]),
+                      header: { dataLen: 8, id: 6, hasSubchunks: false },
+                    },
+                    data: {
+                      timestamp: 1234567890n,
+                    },
+                  },
+                },
+              },
+            ],
+          },
+        },
+      },
+    },
+    decoder: Decoders.DataPacketChunk,
+  },
+  {
+    description: 'InfoTrackerNameChunk',
+    bytes: new Uint8Array([0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49]),
+    expected: {
+      chunk: {
+        chunkData: new Uint8Array([84, 114, 97, 99, 107, 101, 114, 32, 49]),
+        header: { dataLen: 9, id: 0, hasSubchunks: false },
+      },
+      data: {
+        trackerName: 'Tracker 1',
+      },
+    },
+    decoder: Decoders.InfoTrackerNameChunk,
+  },
+  {
+    description: 'InfoSystemNameChunk',
+    bytes: new Uint8Array([1, 0, 10, 0, 80, 83, 78, 32, 83, 101, 114, 118, 101, 114]),
+    expected: {
+      chunk: {
+        chunkData: new Uint8Array([80, 83, 78, 32, 83, 101, 114, 118, 101, 114]),
+        header: { dataLen: 10, id: 1, hasSubchunks: false },
+      },
+      data: {
+        systemName: 'PSN Server',
+      },
+    },
+    decoder: Decoders.InfoSystemNameChunk,
+  },
+  {
+    description: 'InfoTrackerChunk',
+    bytes: new Uint8Array([1, 0, 13, 128, 0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49]),
+    expected: {
+      chunk: {
+        chunkData: new Uint8Array([0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49]),
+        header: { dataLen: 13, id: 1, hasSubchunks: true },
+      },
+      data: {
+        trackerName: {
+          chunk: {
+            chunkData: new Uint8Array([84, 114, 97, 99, 107, 101, 114, 32, 49]),
+            header: { dataLen: 9, id: 0, hasSubchunks: false },
+          },
+          data: {
+            trackerName: 'Tracker 1',
+          },
+        },
+      },
+    },
+    decoder: Decoders.InfoTrackerChunk,
+  },
+  {
+    description: 'InfoTrackerListChunk',
+    bytes: new Uint8Array([2, 0, 17, 128, 1, 0, 13, 128, 0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49]),
+    expected: {
+      chunk: {
+        chunkData: new Uint8Array([1, 0, 13, 128, 0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49]),
+        header: { dataLen: 17, id: 2, hasSubchunks: true },
+      },
+      data: {
+        trackers: [
+          {
+            chunk: {
+              chunkData: new Uint8Array([0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49]),
+              header: { dataLen: 13, id: 1, hasSubchunks: true },
+            },
+            data: {
+              trackerName: {
+                chunk: {
+                  chunkData: new Uint8Array([84, 114, 97, 99, 107, 101, 114, 32, 49]),
+                  header: { dataLen: 9, id: 0, hasSubchunks: false },
+                },
+                data: {
+                  trackerName: 'Tracker 1',
+                },
+              },
+            },
+          },
+        ],
+      },
+    },
+    decoder: Decoders.InfoTrackerListChunk,
+  },
+  {
+    description: 'PacketHeaderChunk',
+    bytes: new Uint8Array([0, 0, 12, 0, 210, 2, 150, 73, 0, 0, 0, 0, 2, 3, 1, 123]),
+    expected: {
+      chunk: {
+        chunkData: new Uint8Array([210, 2, 150, 73, 0, 0, 0, 0, 2, 3, 1, 123]),
+        header: { dataLen: 12, id: 0, hasSubchunks: false },
+      },
+      data: {
+        packetTimestamp: 1234567890n,
+        versionHigh: 2,
+        versionLow: 3,
+        frameId: 1,
+        framePacketCount: 123,
+      },
+    },
+    decoder: Decoders.PacketHeaderChunk,
+  },
+  {
+    description: 'InfoPacketChunk',
+    bytes: new Uint8Array([
+      86, 103, 51, 128, 0, 0, 12, 0, 210, 2, 150, 73, 0, 0, 0, 0, 2, 3, 1, 123, 1, 0, 10, 0, 80, 83, 78, 32, 83, 101,
+      114, 118, 101, 114, 2, 0, 17, 128, 1, 0, 13, 128, 0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49,
+    ]),
+    expected: {
+      chunk: {
+        chunkData: new Uint8Array([
+          0, 0, 12, 0, 210, 2, 150, 73, 0, 0, 0, 0, 2, 3, 1, 123, 1, 0, 10, 0, 80, 83, 78, 32, 83, 101, 114, 118, 101,
+          114, 2, 0, 17, 128, 1, 0, 13, 128, 0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49,
+        ]),
+        header: { dataLen: 51, id: 26454, hasSubchunks: true },
+      },
+      data: {
+        packetHeader: {
+          chunk: {
+            chunkData: new Uint8Array([210, 2, 150, 73, 0, 0, 0, 0, 2, 3, 1, 123]),
+            header: { dataLen: 12, id: 0, hasSubchunks: false },
+          },
+          data: {
+            packetTimestamp: 1234567890n,
+            versionHigh: 2,
+            versionLow: 3,
+            frameId: 1,
+            framePacketCount: 123,
+          },
+        },
+        systemName: {
+          chunk: {
+            chunkData: new Uint8Array([80, 83, 78, 32, 83, 101, 114, 118, 101, 114]),
+            header: { dataLen: 10, id: 1, hasSubchunks: false },
+          },
+          data: {
+            systemName: 'PSN Server',
+          },
+        },
+        trackerList: {
+          chunk: {
+            chunkData: new Uint8Array([1, 0, 13, 128, 0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49]),
+            header: { dataLen: 17, id: 2, hasSubchunks: true },
+          },
+          data: {
+            trackers: [
+              {
+                chunk: {
+                  chunkData: new Uint8Array([0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49]),
+                  header: { dataLen: 13, id: 1, hasSubchunks: true },
+                },
+                data: {
+                  trackerName: {
+                    chunk: {
+                      chunkData: new Uint8Array([84, 114, 97, 99, 107, 101, 114, 32, 49]),
+                      header: { dataLen: 9, id: 0, hasSubchunks: false },
+                    },
+                    data: {
+                      trackerName: 'Tracker 1',
+                    },
+                  },
+                },
+              },
+            ],
+          },
+        },
+      },
+    },
+    decoder: Decoders.InfoPacketChunk,
+  },
+];
+
+describe('PSN Bytes Decoding', () => {
+  goodTests.forEach((bytesTest) => {
+    it(bytesTest.description, () => {
+      const decoded = bytesTest.decoder(bytesTest.bytes);
+      deepEqual(decoded, bytesTest.expected);
+    });
+  });
+});
+
+// TODO(jwetzell): add error tests
+const badTests = [];
+describe('PSN Bytes Decoding Throws', () => {
+  badTests.forEach((bytesTest) => {
+    it(bytesTest.description, () => {
+      throws(() => {
+        bytesTest.decoder(bytesTest.bytes);
+      }, bytesTest.throwsMessage);
+    });
+  });
+});
@@ -0,0 +1,152 @@
+import { Encoders } from '@jwetzell/posistagenet';
+import { deepEqual, throws } from 'assert';
+import { describe, it } from 'node:test';
+
+const goodTests = [
+  {
+    description: 'DataTrackerPosChunk',
+    expected: new Uint8Array([0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+    bytes: Encoders.DataTrackerPosChunk(1.0, 2.0, 3.0),
+  },
+  {
+    description: 'DataTrackerSpeedChunk',
+    expected: new Uint8Array([1, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+    bytes: Encoders.DataTrackerSpeedChunk(1.0, 2.0, 3.0),
+  },
+  {
+    description: 'DataTrackerOriChunk',
+    expected: new Uint8Array([2, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+    bytes: Encoders.DataTrackerOriChunk(1.0, 2.0, 3.0),
+  },
+  {
+    description: 'DataTrackerStatusChunk',
+    expected: new Uint8Array([3, 0, 4, 0, 0, 0, 128, 63]),
+    bytes: Encoders.DataTrackerStatusChunk(1.0),
+  },
+  {
+    description: 'DataTrackerAccelChunk',
+    expected: new Uint8Array([4, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+    bytes: Encoders.DataTrackerAccelChunk(1.0, 2.0, 3.0),
+  },
+  {
+    description: 'DataTrackerTrgtposChunk',
+    expected: new Uint8Array([5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+    bytes: Encoders.DataTrackerTrgtposChunk(1.0, 2.0, 3.0),
+  },
+  {
+    description: 'DataTrackerTimestampChunk',
+    expected: new Uint8Array([6, 0, 8, 0, 210, 2, 150, 73, 0, 0, 0, 0]),
+    bytes: Encoders.DataTrackerTimestampChunk(1234567890n),
+  },
+  {
+    description: 'DataTrackerChunk',
+    expected: new Uint8Array([
+      1, 0, 100, 128, 0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 1, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0,
+      0, 64, 64, 2, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128, 63, 4, 0, 12, 0, 0, 0,
+      128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 6, 0, 8, 0, 210, 2,
+      150, 73, 0, 0, 0, 0,
+    ]),
+    bytes: Encoders.DataTrackerChunk(1, [
+      new Uint8Array([0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+      new Uint8Array([1, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+      new Uint8Array([2, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+      new Uint8Array([3, 0, 4, 0, 0, 0, 128, 63]),
+      new Uint8Array([4, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+      new Uint8Array([5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64]),
+      new Uint8Array([6, 0, 8, 0, 210, 2, 150, 73, 0, 0, 0, 0]),
+    ]),
+  },
+  {
+    description: 'DataTrackerListChunk',
+    expected: new Uint8Array([
+      1, 0, 104, 128, 1, 0, 100, 128, 0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 1, 0, 12, 0, 0, 0, 128, 63,
+      0, 0, 0, 64, 0, 0, 64, 64, 2, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128, 63, 4, 0,
+      12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 6, 0, 8,
+      0, 210, 2, 150, 73, 0, 0, 0, 0,
+    ]),
+    bytes: Encoders.DataTrackerListChunk([
+      new Uint8Array([
+        1, 0, 100, 128, 0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 1, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64,
+        0, 0, 64, 64, 2, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128, 63, 4, 0, 12, 0, 0,
+        0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 6, 0, 8, 0, 210,
+        2, 150, 73, 0, 0, 0, 0,
+      ]),
+    ]),
+  },
+  {
+    description: 'DataPacketChunk',
+    expected: new Uint8Array([
+      85, 103, 124, 128, 0, 0, 12, 0, 210, 2, 150, 73, 0, 0, 0, 0, 2, 3, 1, 123, 1, 0, 104, 128, 1, 0, 100, 128, 0, 0,
+      12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 1, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 2, 0, 12,
+      0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128, 63, 4, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64,
+      0, 0, 64, 64, 5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 6, 0, 8, 0, 210, 2, 150, 73, 0, 0, 0, 0,
+    ]),
+    bytes: Encoders.DataPacketChunk(
+      new Uint8Array([0, 0, 12, 0, 210, 2, 150, 73, 0, 0, 0, 0, 2, 3, 1, 123]),
+      new Uint8Array([
+        1, 0, 104, 128, 1, 0, 100, 128, 0, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 1, 0, 12, 0, 0, 0, 128,
+        63, 0, 0, 0, 64, 0, 0, 64, 64, 2, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 3, 0, 4, 0, 0, 0, 128, 63,
+        4, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 5, 0, 12, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 6,
+        0, 8, 0, 210, 2, 150, 73, 0, 0, 0, 0,
+      ])
+    ),
+  },
+  {
+    description: 'InfoTrackerNameChunk',
+    expected: new Uint8Array([0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49]),
+    bytes: Encoders.InfoTrackerNameChunk('Tracker 1'),
+  },
+  {
+    description: 'InfoSystemNameChunk',
+    expected: new Uint8Array([1, 0, 10, 0, 80, 83, 78, 32, 83, 101, 114, 118, 101, 114]),
+    bytes: Encoders.InfoSystemNameChunk('PSN Server'),
+  },
+  {
+    description: 'InfoTrackerChunk',
+    expected: new Uint8Array([1, 0, 13, 128, 0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49]),
+    bytes: Encoders.InfoTrackerChunk(1, new Uint8Array([0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49])),
+  },
+  {
+    description: 'InfoTrackerListChunk',
+    expected: new Uint8Array([2, 0, 17, 128, 1, 0, 13, 128, 0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49]),
+    bytes: Encoders.InfoTrackerListChunk([
+      new Uint8Array([1, 0, 13, 128, 0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49]),
+    ]),
+  },
+  {
+    description: 'PacketHeaderChunk',
+    expected: new Uint8Array([0, 0, 12, 0, 210, 2, 150, 73, 0, 0, 0, 0, 2, 3, 1, 123]),
+    bytes: Encoders.PacketHeaderChunk(1234567890n, 2, 3, 1, 123),
+  },
+  {
+    description: 'InfoPacketChunk',
+    expected: new Uint8Array([
+      86, 103, 51, 128, 0, 0, 12, 0, 210, 2, 150, 73, 0, 0, 0, 0, 2, 3, 1, 123, 1, 0, 10, 0, 80, 83, 78, 32, 83, 101,
+      114, 118, 101, 114, 2, 0, 17, 128, 1, 0, 13, 128, 0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49,
+    ]),
+    bytes: Encoders.InfoPacketChunk(
+      new Uint8Array([0, 0, 12, 0, 210, 2, 150, 73, 0, 0, 0, 0, 2, 3, 1, 123]),
+      new Uint8Array([1, 0, 10, 0, 80, 83, 78, 32, 83, 101, 114, 118, 101, 114]),
+      new Uint8Array([2, 0, 17, 128, 1, 0, 13, 128, 0, 0, 9, 0, 84, 114, 97, 99, 107, 101, 114, 32, 49])
+    ),
+  },
+];
+
+describe('PSN Message Encoding', () => {
+  goodTests.forEach((messageTest) => {
+    it(messageTest.description, () => {
+      deepEqual(messageTest.bytes, messageTest.expected);
+    });
+  });
+});
+
+//TODO(jwetzell): add tests that handle errors
+const badTests = [];
+
+describe('PSN Message Encoding Throws', () => {
+  badTests.forEach((messageTest) => {
+    it(messageTest.description, () => {
+      throws(() => {}, messageTest.throwsMessage);
+    });
+  });
+});
@@ -1,12 +1,20 @@
 {
  "compilerOptions": {
-    "esModuleInterop": true,
-    "module": "commonjs",
-    "target": "ES2020",
-    "declaration": true,
-    "rootDir": "./src",
+    "target": "esnext",
+    "lib": ["es2023"],
+    "moduleDetection": "force",
+    "module": "preserve",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "types": ["node"],
    "strict": true,
-    "outDir": "dist"
+    "noUnusedLocals": true,
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "esModuleInterop": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true,
+    "skipLibCheck": true
  },
-  "exclude": ["node_modules", "dist", "examples"]
+  "include": ["src"]
 }
@@ -0,0 +1,10 @@
+import { defineConfig } from 'tsdown'
+
+export default defineConfig({
+  entry: 'src/index.ts',
+  exports: true,
+  format: {
+    esm: {},
+    cjs: {},
+  },
+})