Version 1.1.0

.gitignore

@@ -103,6 +103,9 @@ web_modules/
 # Optional npm cache directory
 .npm
 
+# Optional npm package-lock.json
+package-lock.json
+
 # Optional eslint cache
 .eslintcache
 

.pre-commit-config.yaml

@@ -11,16 +11,22 @@ repos:
   hooks:
     - id: shellcheck
 
-- repo: https://github.com/pre-commit/mirrors-eslint
+- repo: local
-  rev: v10.0.3
+  hooks:
+    - id: prettier
+      name: prettier
+      entry: npx prettier --write
+      language: system
+      files: "\\.(js|jsx|ts|tsx)$"
+
+- repo: local
   hooks:
     - id: eslint
+      name: eslint
+      entry: npx eslint --fix
+      language: system
       files: "\\.(js|jsx|ts|tsx)$"
-      exclude: node_modules/
 
-# Use stylelint (local) instead of the deprecated scss-lint Ruby gem which
-# cannot parse modern Sass `@use` and module syntax. This invokes the
-# project's installed `stylelint` via `npx` so the devDependency is used.
 - repo: local
   hooks:
     - id: stylelint

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hamradio/aprs",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "APRS (Automatic Packet Reporting System) protocol support for Typescript",
   "keywords": [
     "APRS",
@@ -11,7 +11,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://git.maze.io/ham/aprs.js"
+    "url": "https://git.maze.io/ham/aprs.ts"
   },
   "license": "MIT",
   "author": "Wijnand Modderman-Lenstra",
@@ -38,7 +38,6 @@
     "lint": "eslint .",
     "prepare": "npm run build"
   },
-  "dependencies": {},
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@vitest/coverage-v8": "^4.0.18",
@@ -48,5 +47,9 @@
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.57.0",
     "vitest": "^4.0.18"
+  },
+  "dependencies": {
+    "@hamradio/packet": "^1.1.0",
+    "extended-nmea": "^2.1.3"
   }
 }

src/frame.types.ts

@@ -1,4 +1,4 @@
-import { PacketSegment, PacketStructure } from "./parser.types";
+import { Dissected, Segment } from "@hamradio/packet";
 
 export interface IAddress {
   call: string;
@@ -16,51 +16,52 @@ export interface IFrame {
 // APRS Data Type Identifiers (first character of payload)
 export const DataTypeIdentifier = {
   // Position Reports
-  PositionNoTimestampNoMessaging: '!',
+  PositionNoTimestampNoMessaging: "!",
-  PositionNoTimestampWithMessaging: '=',
+  PositionNoTimestampWithMessaging: "=",
-  PositionWithTimestampNoMessaging: '/',
+  PositionWithTimestampNoMessaging: "/",
-  PositionWithTimestampWithMessaging: '@',
+  PositionWithTimestampWithMessaging: "@",
 
   // Mic-E
-  MicECurrent: '`',
+  MicECurrent: "`",
   MicEOld: "'",
 
   // Messages and Bulletins
-  Message: ':',
+  Message: ":",
 
   // Objects and Items
-  Object: ';',
+  Object: ";",
-  Item: ')',
+  Item: ")",
 
   // Status
-  Status: '>',
+  Status: ">",
 
   // Query
-  Query: '?',
+  Query: "?",
 
   // Telemetry
-  TelemetryData: 'T',
+  TelemetryData: "T",
 
   // Weather
-  WeatherReportNoPosition: '_',
+  WeatherReportNoPosition: "_",
 
   // Raw GPS Data
-  RawGPS: '$',
+  RawGPS: "$",
 
   // Station Capabilities
-  StationCapabilities: '<',
+  StationCapabilities: "<",
 
   // User-Defined
-  UserDefined: '{',
+  UserDefined: "{",
 
   // Third-Party Traffic
-  ThirdParty: '}',
+  ThirdParty: "}",
 
   // Invalid/Test Data
-  InvalidOrTest: ',',
+  InvalidOrTest: ",",
 } as const;
 
-export type DataTypeIdentifier = typeof DataTypeIdentifier[keyof typeof DataTypeIdentifier];
+export type DataTypeIdentifier =
+  (typeof DataTypeIdentifier)[keyof typeof DataTypeIdentifier];
 
 export interface ISymbol {
   table: string; // Symbol table identifier
@@ -91,14 +92,14 @@ export interface ITimestamp {
   hours: number;
   minutes: number;
   seconds?: number;
-  format: 'DHM' | 'HMS' | 'MDHM'; // Day-Hour-Minute, Hour-Minute-Second, Month-Day-Hour-Minute
+  format: "DHM" | "HMS" | "MDHM"; // Day-Hour-Minute, Hour-Minute-Second, Month-Day-Hour-Minute
   zulu?: boolean; // Is UTC/Zulu time
   toDate(): Date; // Convert to Date object respecting timezone
 }
 
 // Position Report Payload
 export interface PositionPayload {
-  type: 'position';
+  type: "position";
   timestamp?: ITimestamp;
   position: IPosition;
   messaging: boolean; // Whether APRS messaging is enabled
@@ -106,7 +107,7 @@ export interface PositionPayload {
     messageType?: string;
     isStandard?: boolean;
   };
-  sections?: PacketSegment[];
+  sections?: Segment[];
 }
 
 // Compressed Position Format
@@ -122,12 +123,12 @@ export interface CompressedPosition {
   range?: number; // Miles
   altitude?: number; // Feet
   radioRange?: number; // Miles
-  compression: 'old' | 'current';
+  compression: "old" | "current";
 }
 
 // Mic-E Payload (compressed in destination address)
 export interface MicEPayload {
-  type: 'mic-e';
+  type: "mic-e";
   position: IPosition;
   course?: number;
   speed?: number;
@@ -139,7 +140,7 @@ export interface MicEPayload {
 
 // Message Payload
 export interface MessagePayload {
-  type: 'message';
+  type: "message";
   addressee: string; // 9 character padded callsign
   text: string; // Message text
   messageNumber?: string; // Message ID for acknowledgment
@@ -149,7 +150,7 @@ export interface MessagePayload {
 
 // Bulletin/Announcement (variant of message)
 export interface BulletinPayload {
-  type: 'bulletin';
+  type: "bulletin";
   bulletinId: string; // Bulletin identifier (BLN#)
   text: string;
   group?: string; // Optional group bulletin
@@ -157,7 +158,7 @@ export interface BulletinPayload {
 
 // Object Payload
 export interface ObjectPayload {
-  type: 'object';
+  type: "object";
   name: string; // 9 character object name
   timestamp: ITimestamp;
   alive: boolean; // True if object is active, false if killed
@@ -168,7 +169,7 @@ export interface ObjectPayload {
 
 // Item Payload
 export interface ItemPayload {
-  type: 'item';
+  type: "item";
   name: string; // 3-9 character item name
   alive: boolean; // True if item is active, false if killed
   position: IPosition;
@@ -176,7 +177,7 @@ export interface ItemPayload {
 
 // Status Payload
 export interface StatusPayload {
-  type: 'status';
+  type: "status";
   timestamp?: ITimestamp;
   text: string;
   maidenhead?: string; // Optional Maidenhead grid locator
@@ -188,14 +189,14 @@ export interface StatusPayload {
 
 // Query Payload
 export interface QueryPayload {
-  type: 'query';
+  type: "query";
   queryType: string; // e.g., 'APRSD', 'APRST', 'PING'
   target?: string; // Target callsign or area
 }
 
 // Telemetry Data Payload
 export interface TelemetryDataPayload {
-  type: 'telemetry-data';
+  type: "telemetry-data";
   sequence: number;
   analog: number[]; // Up to 5 analog channels
   digital: number; // 8-bit digital value
@@ -203,19 +204,19 @@ export interface TelemetryDataPayload {
 
 // Telemetry Parameter Names
 export interface TelemetryParameterPayload {
-  type: 'telemetry-parameters';
+  type: "telemetry-parameters";
   names: string[]; // Parameter names
 }
 
 // Telemetry Unit/Label
 export interface TelemetryUnitPayload {
-  type: 'telemetry-units';
+  type: "telemetry-units";
   units: string[]; // Units for each parameter
 }
 
 // Telemetry Coefficients
 export interface TelemetryCoefficientsPayload {
-  type: 'telemetry-coefficients';
+  type: "telemetry-coefficients";
   coefficients: {
     a: number[]; // a coefficients
     b: number[]; // b coefficients
@@ -225,14 +226,14 @@ export interface TelemetryCoefficientsPayload {
 
 // Telemetry Bit Sense/Project Name
 export interface TelemetryBitSensePayload {
-  type: 'telemetry-bitsense';
+  type: "telemetry-bitsense";
   sense: number; // 8-bit sense value
   projectName?: string;
 }
 
 // Weather Report Payload
 export interface WeatherPayload {
-  type:                'weather';
+  type: "weather";
   timestamp?: ITimestamp;
   position?: IPosition;
   windDirection?: number; // Degrees
@@ -249,37 +250,39 @@ export interface WeatherPayload {
   rawRain?: number; // Raw rain counter
   software?: string; // Weather software type
   weatherUnit?: string; // Weather station type
+  comment?: string; // Additional comment
 }
 
 // Raw GPS Payload (NMEA sentences)
 export interface RawGPSPayload {
-  type: 'raw-gps';
+  type: "raw-gps";
   sentence: string; // Raw NMEA sentence
+  position?: IPosition; // Optional parsed position if available
 }
 
 // Station Capabilities Payload
 export interface StationCapabilitiesPayload {
-  type: 'capabilities';
+  type: "capabilities";
   capabilities: string[];
 }
 
 // User-Defined Payload
 export interface UserDefinedPayload {
-  type: 'user-defined';
+  type: "user-defined";
   userPacketType: string;
   data: string;
 }
 
 // Third-Party Traffic Payload
 export interface ThirdPartyPayload {
-  type: 'third-party';
+  type: "third-party";
-  header: string;      // Source path of third-party packet
+  frame?: IFrame; // Optional nested frame if payload contains another APRS frame
-  payload: string;     // Nested APRS packet
+  comment?: string; // Optional comment
 }
 
 // DF Report Payload
 export interface DFReportPayload {
-  type: 'df-report';
+  type: "df-report";
   timestamp?: ITimestamp;
   position: IPosition;
   course?: number;
@@ -296,7 +299,8 @@ export interface BasePayload {
 }
 
 // Union type for all decoded payload types
-export type Payload = BasePayload & (
+export type Payload = BasePayload &
+  (
     | PositionPayload
     | MicEPayload
     | MessagePayload
@@ -321,5 +325,5 @@ export type Payload = BasePayload & (
 // Extended Frame with decoded payload
 export interface DecodedFrame extends IFrame {
   decoded?: Payload;
-  structure?: PacketStructure; // Routing and other frame-level sections
+  structure?: Dissected; // Routing and other frame-level sections
 }

src/index.ts

@@ -1,14 +1,6 @@
-export {
+export { Frame, Address, Timestamp } from "./frame";
-  Frame,
-  Address,
-  Timestamp,
-} from "./frame";
 
-export {
+export { type IAddress, type IFrame, DataTypeIdentifier } from "./frame.types";
-  type IAddress,
-  type IFrame,
-  DataTypeIdentifier,
-} from "./frame.types";
 
 export {
   type ISymbol,
@@ -48,10 +40,3 @@ export {
   celsiusToFahrenheit,
   fahrenheitToCelsius,
 } from "./parser";
-export {
-  type PacketStructure,
-  type PacketSegment,
-  type PacketField,
-  type PacketFieldBit,
-  FieldType,
-} from "./parser.types";

src/parser.ts

@@ -15,14 +15,16 @@ export const base91ToNumber = (str: string): number => {
     const digit = charCode - 33; // Base91 uses chars 33-123 (! to {)
 
     if (digit < 0 || digit >= base) {
-      throw new Error(`Invalid Base91 character: '${str[i]}' (code ${charCode})`);
+      throw new Error(
+        `Invalid Base91 character: '${str[i]}' (code ${charCode})`,
+      );
     }
 
     value = value * base + digit;
   }
 
   return value;
-}
+};
 
 /* Conversions from Freedom Units to whatever the rest of the world uses and understands. */
 
@@ -38,7 +40,7 @@ const FAHRENHEIT_TO_CELSIUS_OFFSET = 32;
  */
 export const knotsToKmh = (knots: number): number => {
   return knots * KNOTS_TO_KMH;
-}
+};
 
 /**
  * Convert speed from kilometers per hour to knots.
@@ -48,7 +50,7 @@ export const knotsToKmh = (knots: number): number => {
  */
 export const kmhToKnots = (kmh: number): number => {
   return kmh / KNOTS_TO_KMH;
-}
+};
 
 /**
  * Convert altitude from feet to meters.
@@ -58,7 +60,7 @@ export const kmhToKnots = (kmh: number): number => {
  */
 export const feetToMeters = (feet: number): number => {
   return feet * FEET_TO_METERS;
-}
+};
 
 /**
  * Convert altitude from meters to feet.
@@ -68,7 +70,7 @@ export const feetToMeters = (feet: number): number => {
  */
 export const metersToFeet = (meters: number): number => {
   return meters / FEET_TO_METERS;
-}
+};
 
 /**
  * Convert temperature from Celsius to Fahrenheit.
@@ -77,8 +79,8 @@ export const metersToFeet = (meters: number): number => {
  * @returns equivalent temperature in Fahrenheit
  */
 export const celsiusToFahrenheit = (celsius: number): number => {
-  return (celsius * 9/5) + FAHRENHEIT_TO_CELSIUS_OFFSET;
+  return (celsius * 9) / 5 + FAHRENHEIT_TO_CELSIUS_OFFSET;
-}
+};
 
 /**
  * Convert temperature from Fahrenheit to Celsius.
@@ -87,5 +89,5 @@ export const celsiusToFahrenheit = (celsius: number): number => {
  * @returns equivalent temperature in Celsius
  */
 export const fahrenheitToCelsius = (fahrenheit: number): number => {
-  return (fahrenheit - FAHRENHEIT_TO_CELSIUS_OFFSET) * 5/9;
+  return ((fahrenheit - FAHRENHEIT_TO_CELSIUS_OFFSET) * 5) / 9;
-}
+};

src/parser.types.ts

@@ -1,37 +0,0 @@
-export enum FieldType {
-  BITS      = 0,
-  UINT8     = 1,
-  UINT16_LE = 2,
-  UINT16_BE = 3,
-  UINT32_LE = 4,
-  UINT32_BE = 5,
-  BYTES     = 6, // 8-bits per value
-  WORDS     = 7, // 16-bits per value
-  DWORDS    = 8, // 32-bits per value
-  QWORDS    = 9, // 64-bits per value
-  STRING    = 10,
-  C_STRING  = 11, // Null-terminated string
-  CHAR      = 12, // Single ASCII character
-}
-
-// Interface for the parsed packet segments, used for debugging and testing.
-export type PacketStructure = PacketSegment[];
-
-export interface PacketSegment {
-  name:   string;
-  data:   Uint8Array;
-  fields: PacketField[];
-}
-
-export interface PacketField {
-  type:   FieldType;
-  size:   number; // Size in bytes
-  name?:  string;
-  bits?:  PacketFieldBit[]; // Only for bit fields in FieldType.BITS
-  value?: any; // Optional decoded value
-}
-
-export interface PacketFieldBit {
-  name: string;
-  size: number; // Size in bits
-}

src/position.ts

@@ -10,7 +10,9 @@ export class Symbol implements ISymbol {
         this.code = table[1];
         this.table = table[0];
       } else {
-        throw new Error(`Invalid symbol format: '${table}' (expected 2 characters if code is not provided)`);
+        throw new Error(
+          `Invalid symbol format: '${table}' (expected 2 characters if code is not provided)`,
+        );
       }
     } else {
       this.table = table;
@@ -40,7 +42,7 @@ export class Position implements IPosition {
     this.altitude = data.altitude;
     this.speed = data.speed;
     this.course = data.course;
-    if (typeof data.symbol === 'string') {
+    if (typeof data.symbol === "string") {
       this.symbol = new Symbol(data.symbol);
     } else if (data.symbol) {
       this.symbol = new Symbol(data.symbol.table, data.symbol.code);
@@ -51,20 +53,20 @@ export class Position implements IPosition {
   public toString(): string {
     const latStr = this.latitude.toFixed(5);
     const lonStr = this.longitude.toFixed(5);
-    const altStr = this.altitude !== undefined ? `,${this.altitude}m` : '';
+    const altStr = this.altitude !== undefined ? `,${this.altitude}m` : "";
     return `${latStr},${lonStr}${altStr}`;
   }
 
   public distanceTo(other: IPosition): number {
     const R = 6371e3; // Earth radius in meters
-    const lat1 = this.latitude * Math.PI / 180;
+    const lat1 = (this.latitude * Math.PI) / 180;
-    const lat2 = other.latitude * Math.PI / 180;
+    const lat2 = (other.latitude * Math.PI) / 180;
-    const dLat = (other.latitude - this.latitude) * Math.PI / 180;
+    const dLat = ((other.latitude - this.latitude) * Math.PI) / 180;
-    const dLon = (other.longitude - this.longitude) * Math.PI / 180;
+    const dLon = ((other.longitude - this.longitude) * Math.PI) / 180;
 
-    const a = Math.sin(dLat/2) * Math.sin(dLat/2) +
+    const a =
-          Math.cos(lat1) * Math.cos(lat2) *
+      Math.sin(dLat / 2) * Math.sin(dLat / 2) +
-          Math.sin(dLon/2) * Math.sin(dLon/2);
+      Math.cos(lat1) * Math.cos(lat2) * Math.sin(dLon / 2) * Math.sin(dLon / 2);
     const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
 
     return R * c; // Distance in meters

test/frame.capabilities.test.ts

@@ -0,0 +1,34 @@
+import { describe, it, expect } from "vitest";
+import { Frame } from "../src/frame";
+import type { Payload, StationCapabilitiesPayload } from "../src/frame.types";
+import { Dissected } from "@hamradio/packet";
+
+describe("Frame.decodeCapabilities", () => {
+  it("parses comma separated capabilities", () => {
+    const data = "CALL>APRS:<IGATE,MSG_CNT";
+    const frame = Frame.fromString(data);
+    const decoded = frame.decode() as StationCapabilitiesPayload;
+    expect(decoded).not.toBeNull();
+    expect(decoded.type).toBe("capabilities");
+    expect(Array.isArray(decoded.capabilities)).toBeTruthy();
+    expect(decoded.capabilities).toContain("IGATE");
+    expect(decoded.capabilities).toContain("MSG_CNT");
+  });
+
+  it("emits structure sections when requested", () => {
+    const data = "CALL>APRS:<IGATE MSG_CNT>";
+    const frame = Frame.fromString(data);
+    const res = frame.decode(true) as {
+      payload: Payload | null;
+      structure: Dissected;
+    };
+    expect(res.payload).not.toBeNull();
+    if (res.payload && res.payload.type !== "capabilities")
+      throw new Error("expected capabilities payload");
+    expect(res.structure).toBeDefined();
+    const caps = res.structure.find((s) => s.name === "capabilities");
+    expect(caps).toBeDefined();
+    const capEntry = res.structure.find((s) => s.name === "capability");
+    expect(capEntry).toBeDefined();
+  });
+});

test/frame.query.test.ts

@@ -0,0 +1,39 @@
+import { expect } from "vitest";
+import { describe, it } from "vitest";
+import { Dissected } from "@hamradio/packet";
+import { Frame } from "../src/frame";
+import { QueryPayload } from "../src/frame.types";
+
+describe("Frame decode - Query", () => {
+  it("decodes simple query without target", () => {
+    const frame = Frame.fromString("SRC>DEST:?APRS");
+    const payload = frame.decode() as QueryPayload;
+    expect(payload).not.toBeNull();
+    expect(payload.type).toBe("query");
+    expect(payload.queryType).toBe("APRS");
+    expect(payload.target).toBeUndefined();
+  });
+
+  it("decodes query with target", () => {
+    const frame = Frame.fromString("SRC>DEST:?PING N0CALL");
+    const payload = frame.decode() as QueryPayload;
+    expect(payload).not.toBeNull();
+    expect(payload.type).toBe("query");
+    expect(payload.queryType).toBe("PING");
+    expect(payload.target).toBe("N0CALL");
+  });
+
+  it("returns structure sections when requested", () => {
+    const frame = Frame.fromString("SRC>DEST:?PING N0CALL");
+    const result = frame.decode(true) as {
+      payload: QueryPayload;
+      structure: Dissected;
+    };
+    expect(result).toHaveProperty("payload");
+    expect(result.payload.type).toBe("query");
+    expect(Array.isArray(result.structure)).toBe(true);
+    const names = result.structure.map((s) => s.name);
+    expect(names).toContain("query type");
+    expect(names).toContain("query target");
+  });
+});

test/frame.rawgps.test.ts

@@ -0,0 +1,48 @@
+import { describe, it, expect } from "vitest";
+import { Frame } from "../src/frame";
+import type { RawGPSPayload } from "../src/frame.types";
+import { Dissected } from "@hamradio/packet";
+
+describe("Raw GPS decoding", () => {
+  it("decodes simple NMEA sentence as raw-gps payload", () => {
+    const sentence =
+      "GPRMC,123519,A,4807.038,N,01131.000,E,022.4,084.4,230394,003.1,W*6A";
+    const frameStr = `SRC>DEST:$${sentence}`;
+
+    const f = Frame.parse(frameStr);
+    const payload = f.decode(false) as RawGPSPayload | null;
+
+    expect(payload).not.toBeNull();
+    expect(payload?.type).toBe("raw-gps");
+    expect(payload?.sentence).toBe(sentence);
+    expect(payload?.position).toBeDefined();
+    expect(typeof payload?.position?.latitude).toBe("number");
+    expect(typeof payload?.position?.longitude).toBe("number");
+  });
+
+  it("returns structure when requested", () => {
+    const sentence =
+      "GPGGA,092750.000,5321.6802,N,00630.3372,W,1,08,1.0,73.0,M,0.0,M,,*6A";
+    const frameStr = `SRC>DEST:$${sentence}`;
+
+    const f = Frame.parse(frameStr);
+    const result = f.decode(true) as {
+      payload: RawGPSPayload | null;
+      structure: Dissected;
+    };
+
+    expect(result.payload).not.toBeNull();
+    expect(result.payload?.type).toBe("raw-gps");
+    expect(result.payload?.sentence).toBe(sentence);
+    expect(result.payload?.position).toBeDefined();
+    expect(typeof result.payload?.position?.latitude).toBe("number");
+    expect(typeof result.payload?.position?.longitude).toBe("number");
+    expect(result.structure).toBeDefined();
+    const rawSection = result.structure.find((s) => s.name === "raw-gps");
+    expect(rawSection).toBeDefined();
+    const posSection = result.structure.find(
+      (s) => s.name === "raw-gps-position",
+    );
+    expect(posSection).toBeDefined();
+  });
+});

test/frame.telemetry.test.ts

@@ -0,0 +1,59 @@
+import { describe, it } from "vitest";
+import {
+  TelemetryDataPayload,
+  TelemetryParameterPayload,
+  TelemetryUnitPayload,
+  TelemetryCoefficientsPayload,
+  TelemetryBitSensePayload,
+} from "../src/frame.types";
+import { Frame } from "../src/frame";
+import { expect } from "vitest";
+
+describe("Frame decode - Telemetry", () => {
+  it("decodes telemetry data payload", () => {
+    const frame = Frame.fromString("SRC>DEST:T#1 10,20,30,40,50 7");
+    const payload = frame.decode() as TelemetryDataPayload;
+    expect(payload).not.toBeNull();
+    expect(payload.type).toBe("telemetry-data");
+    expect(payload.sequence).toBe(1);
+    expect(Array.isArray(payload.analog)).toBe(true);
+    expect(payload.analog.length).toBe(5);
+    expect(payload.digital).toBe(7);
+  });
+
+  it("decodes telemetry parameters list", () => {
+    const frame = Frame.fromString("SRC>DEST:TPARAM Temp,Hum,Wind");
+    const payload = frame.decode() as TelemetryParameterPayload;
+    expect(payload).not.toBeNull();
+    expect(payload.type).toBe("telemetry-parameters");
+    expect(Array.isArray(payload.names)).toBe(true);
+    expect(payload.names).toEqual(["Temp", "Hum", "Wind"]);
+  });
+
+  it("decodes telemetry units list", () => {
+    const frame = Frame.fromString("SRC>DEST:TUNIT C,% ,mph");
+    const payload = frame.decode() as TelemetryUnitPayload;
+    expect(payload).not.toBeNull();
+    expect(payload.type).toBe("telemetry-units");
+    expect(payload.units).toEqual(["C", "%", "mph"]);
+  });
+
+  it("decodes telemetry coefficients", () => {
+    const frame = Frame.fromString("SRC>DEST:TCOEFF A:1,2 B:3,4 C:5,6");
+    const payload = frame.decode() as TelemetryCoefficientsPayload;
+    expect(payload).not.toBeNull();
+    expect(payload.type).toBe("telemetry-coefficients");
+    expect(payload.coefficients.a).toEqual([1, 2]);
+    expect(payload.coefficients.b).toEqual([3, 4]);
+    expect(payload.coefficients.c).toEqual([5, 6]);
+  });
+
+  it("decodes telemetry bitsense with project", () => {
+    const frame = Frame.fromString("SRC>DEST:TBITS 255 ProjectX");
+    const payload = frame.decode() as TelemetryBitSensePayload;
+    expect(payload).not.toBeNull();
+    expect(payload.type).toBe("telemetry-bitsense");
+    expect(payload.sense).toBe(255);
+    expect(payload.projectName).toBe("ProjectX");
+  });
+});

test/frame.userdefined.test.ts

@@ -0,0 +1,38 @@
+import { describe, it, expect } from "vitest";
+import { Dissected } from "@hamradio/packet";
+import { Frame } from "../src/frame";
+import type { UserDefinedPayload } from "../src/frame.types";
+
+describe("Frame.decodeUserDefined", () => {
+  it("parses packet type only", () => {
+    const data = "CALL>APRS:{01";
+    const frame = Frame.fromString(data);
+    const decoded = frame.decode() as UserDefinedPayload;
+    expect(decoded).not.toBeNull();
+    expect(decoded.type).toBe("user-defined");
+    expect(decoded.userPacketType).toBe("01");
+    expect(decoded.data).toBe("");
+  });
+
+  it("parses packet type and data and emits sections", () => {
+    const data = "CALL>APRS:{TEX Hello world";
+    const frame = Frame.fromString(data);
+    const res = frame.decode(true) as {
+      payload: UserDefinedPayload;
+      structure: Dissected;
+    };
+    expect(res.payload).not.toBeNull();
+    expect(res.payload.type).toBe("user-defined");
+    expect(res.payload.userPacketType).toBe("TEX");
+    expect(res.payload.data).toBe("Hello world");
+
+    const raw = res.structure.find((s) => s.name === "user-defined");
+    const typeSection = res.structure.find(
+      (s) => s.name === "user-packet-type",
+    );
+    const dataSection = res.structure.find((s) => s.name === "user-data");
+    expect(raw).toBeDefined();
+    expect(typeSection).toBeDefined();
+    expect(dataSection).toBeDefined();
+  });
+});

test/frame.weather.test.ts

@@ -0,0 +1,37 @@
+import { describe, it, expect } from "vitest";
+import { Frame } from "../src/frame";
+import { WeatherPayload } from "../src/frame.types";
+import { Dissected } from "@hamradio/packet";
+
+describe("Frame decode - Weather", () => {
+  it("parses weather with timestamp, wind, temp, rain, humidity and pressure", () => {
+    const data = "SRC>DEST:_120345z180/10g15t072r000p025P050h50b10132";
+    const frame = Frame.fromString(data);
+    const payload = frame.decode() as WeatherPayload;
+    expect(payload).not.toBeNull();
+    expect(payload.type).toBe("weather");
+    expect(payload.timestamp).toBeDefined();
+    expect(payload.windDirection).toBe(180);
+    expect(payload.windSpeed).toBe(10);
+    expect(payload.windGust).toBe(15);
+    expect(payload.temperature).toBe(72);
+    expect(payload.rainLast24Hours).toBe(25);
+    expect(payload.rainSinceMidnight).toBe(50);
+    expect(payload.humidity).toBe(50);
+    expect(payload.pressure).toBe(10132);
+  });
+
+  it("emits structure when requested", () => {
+    const data = "SRC>DEST:_120345z180/10g15t072r000p025P050h50b10132";
+    const frame = Frame.fromString(data);
+    const res = frame.decode(true) as {
+      payload: WeatherPayload;
+      structure: Dissected;
+    };
+    expect(res.payload).not.toBeNull();
+    expect(Array.isArray(res.structure)).toBe(true);
+    const names = res.structure.map((s) => s.name);
+    expect(names).toContain("timestamp");
+    expect(names).toContain("weather");
+  });
+});

test/parser.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect } from "vitest";
 import {
   base91ToNumber,
   knotsToKmh,
@@ -7,79 +7,79 @@ import {
   metersToFeet,
   celsiusToFahrenheit,
   fahrenheitToCelsius,
-} from '../src/parser';
+} from "../src/parser";
 
-describe('parser utilities', () => {
+describe("parser utilities", () => {
-  describe('base91ToNumber', () => {
+  describe("base91ToNumber", () => {
-    it('decodes all-! to 0', () => {
+    it("decodes all-! to 0", () => {
-      expect(base91ToNumber('!!!!')).toBe(0);
+      expect(base91ToNumber("!!!!")).toBe(0);
     });
 
-    it('decodes single character correctly', () => {
+    it("decodes single character correctly", () => {
       // 'A' === 65, digit = 65 - 33 = 32
-      expect(base91ToNumber('A')).toBe(32);
+      expect(base91ToNumber("A")).toBe(32);
     });
 
-    it('should decode multiple Base91 characters', () => {
+    it("should decode multiple Base91 characters", () => {
       // "!!" = 0 * 91 + 0 = 0
-      expect(base91ToNumber('!!')).toBe(0);
+      expect(base91ToNumber("!!")).toBe(0);
 
       // "!#" = 0 * 91 + 2 = 2
-      expect(base91ToNumber('!#')).toBe(2);
+      expect(base91ToNumber("!#")).toBe(2);
 
       // "#!" = 2 * 91 + 0 = 182
-      expect(base91ToNumber('#!')).toBe(182);
+      expect(base91ToNumber("#!")).toBe(182);
 
       // "##" = 2 * 91 + 2 = 184
-      expect(base91ToNumber('##')).toBe(184);
+      expect(base91ToNumber("##")).toBe(184);
     });
 
-    it('should decode 4-character Base91 strings (used in APRS)', () => {
+    it("should decode 4-character Base91 strings (used in APRS)", () => {
       // Test with printable ASCII Base91 characters (33-123)
-      const testValue = base91ToNumber('!#%\'');
+      const testValue = base91ToNumber("!#%'");
       expect(testValue).toBeGreaterThan(0);
       expect(testValue).toBeLessThan(91 * 91 * 91 * 91);
     });
 
-    it('should decode maximum valid Base91 value', () => {
+    it("should decode maximum valid Base91 value", () => {
       // Maximum is '{' (ASCII 123, digit 90) repeated
-      const maxValue = base91ToNumber('{{{{');
+      const maxValue = base91ToNumber("{{{{");
       const expected = 90 * 91 * 91 * 91 + 90 * 91 * 91 + 90 * 91 + 90;
       expect(maxValue).toBe(expected);
     });
 
-    it('should handle APRS compressed position example', () => {
+    it("should handle APRS compressed position example", () => {
       // Using actual characters from APRS test vector
-      const latStr = '/:*E';
+      const latStr = "/:*E";
-      const lonStr = 'qZ=O';
+      const lonStr = "qZ=O";
 
       const latValue = base91ToNumber(latStr);
       const lonValue = base91ToNumber(lonStr);
 
       // Just verify they decode without error and produce valid numbers
-      expect(typeof latValue).toBe('number');
+      expect(typeof latValue).toBe("number");
-      expect(typeof lonValue).toBe('number');
+      expect(typeof lonValue).toBe("number");
       expect(latValue).toBeGreaterThanOrEqual(0);
       expect(lonValue).toBeGreaterThanOrEqual(0);
     });
 
-    it('throws on invalid character', () => {
+    it("throws on invalid character", () => {
-      expect(() => base91ToNumber(' ')).toThrow(); // space (code 32) is invalid
+      expect(() => base91ToNumber(" ")).toThrow(); // space (code 32) is invalid
     });
   });
 
-  describe('unit conversions', () => {
+  describe("unit conversions", () => {
-    it('converts knots <-> km/h', () => {
+    it("converts knots <-> km/h", () => {
       expect(knotsToKmh(10)).toBeCloseTo(18.52, 5);
       expect(kmhToKnots(18.52)).toBeCloseTo(10, 3);
     });
 
-    it('converts feet <-> meters', () => {
+    it("converts feet <-> meters", () => {
       expect(feetToMeters(10)).toBeCloseTo(3.048, 6);
       expect(metersToFeet(3.048)).toBeCloseTo(10, 6);
     });
 
-    it('converts celsius <-> fahrenheit', () => {
+    it("converts celsius <-> fahrenheit", () => {
       expect(celsiusToFahrenheit(0)).toBeCloseTo(32, 6);
       expect(fahrenheitToCelsius(32)).toBeCloseTo(0, 6);
       expect(celsiusToFahrenheit(100)).toBeCloseTo(212, 6);