@packet-net/pdn-aprs 0.2.0 → 0.3.0

package/src/builder.ts

@@ -13,6 +13,8 @@
 // `build()` encodes the packet, so anything the spec does not allow is refused there, with an
 // `AprsEncodeError` that says why.
 
+import { nearest, refuse } from './encode/common.js';
+import { ALTITUDE_GIVEN_IN_FEET } from './encode/position.js';
 import { encodeInformation, encodeAx25, encodeTnc2, encodeTnc2Bytes, wrapKiss, type PacketToEncode } from './encode/index.js';
 import { symbolOf } from './symbols.js';
 import type {
@@ -74,6 +76,36 @@ function built(header: Header, data: AprsData): BuiltPacket {
   });
 }
 
+/**
+ * Weather as a program may have it: the units APRS sends (Fahrenheit, inches), or Celsius and
+ * millimetres, which the builder converts (vectors rulings, B2). Give each value in one unit.
+ */
+export interface WeatherInput extends Weather {
+  readonly temperatureC?: number;
+  readonly rain1hMm?: number;
+  readonly rain24hMm?: number;
+  readonly rainMidnightMm?: number;
+}
+
+const MM_PER_INCH = 25.4;
+
+/** Weather in the units APRS sends; a value in two units is refused. */
+function weatherOf(input: WeatherInput): Weather {
+  const { temperatureC, rain1hMm, rain24hMm, rainMidnightMm, ...rest } = input;
+  const w: Mutable<Weather> = { ...rest };
+  const convert = (metric: number | undefined, key: 'temperatureF' | 'rain1hIn' | 'rain24hIn' | 'rainMidnightIn', f: (v: number) => number): void => {
+    if (metric === undefined) return;
+    if (w[key] !== undefined) refuse(`weather ${key} is given in two units`);
+    w[key] = f(metric);
+  };
+  // Converted here and rounded once, when the report is written.
+  convert(temperatureC, 'temperatureF', (c) => (c * 9) / 5 + 32);
+  convert(rain1hMm, 'rain1hIn', (mm) => mm / MM_PER_INCH);
+  convert(rain24hMm, 'rain24hIn', (mm) => mm / MM_PER_INCH);
+  convert(rainMidnightMm, 'rainMidnightIn', (mm) => mm / MM_PER_INCH);
+  return w;
+}
+
 function asSymbol(symbol: AprsSymbol | string): AprsSymbol {
   return typeof symbol === 'string' ? symbolOf(symbol) : symbol;
 }
@@ -122,7 +154,7 @@ export class PacketBuilder {
   }
 
   /** A weather report at a position (the weather station symbol, unless you pick another `_`). */
-  weather(latitude: number, longitude: number, weather: Weather): PositionBuilder {
+  weather(latitude: number, longitude: number, weather: WeatherInput): PositionBuilder {
     return new PositionBuilder(this.header, latitude, longitude).symbol('/_').weather(weather);
   }
 
@@ -166,10 +198,13 @@ export class PacketBuilder {
     return new StatusBuilder(this.header, text);
   }
 
-  /** A telemetry report: sequence, five analog values and eight bits (`'01101001'`, B1 first). */
+  /**
+   * A telemetry report: sequence, five analog values and eight bits (`'01101001'`, B1 first). A
+   * sequence given as a number is 0-999, written in three digits; a larger one is refused when
+   * the packet is built, not wrapped (vectors rulings, B6).
+   */
   telemetry(sequence: number | string, analog: readonly (number | null)[], bits: string): TelemetryBuilder {
-    const seq = typeof sequence === 'number' ? String(sequence).padStart(3, '0') : sequence;
-    return new TelemetryBuilder(this.header, seq, analog, bits);
+    return new TelemetryBuilder(this.header, sequence, analog, bits);
   }
 
   /** Telemetry channel names (`PARM.`), sent to the station whose telemetry they describe. */
@@ -195,7 +230,7 @@ export class PacketBuilder {
   }
 
   /** A positionless weather report (not recommended: a weather report with a position is better). */
-  weatherReport(weather: Weather, at: Date = new Date()): DataBuilder {
+  weatherReport(weather: WeatherInput, at: Date = new Date()): DataBuilder {
     const timestamp: AprsTimestamp = {
       kind: 'mdhm',
       month: at.getUTCMonth() + 1,
@@ -203,7 +238,7 @@ export class PacketBuilder {
       hour: at.getUTCHours(),
       minute: at.getUTCMinutes(),
     };
-    return new DataBuilder(this.header, { type: 'weather', timestamp, weather });
+    return new DataBuilder(this.header, { type: 'weather', timestamp, weather: weatherOf(weather) });
   }
 
   /** Any data, built by hand. */
@@ -250,7 +285,11 @@ abstract class PositionedBuilder<Self> {
     return this.self();
   }
 
-  /** Course over the ground, degrees 1-360 (360 is north). */
+  /**
+   * Course over the ground, degrees: 360 is north and 0 is unknown, as APRS has it (vectors
+   * rulings, B1). A course of 0 is written `000` in an uncompressed report, left out of a Mic-E
+   * report, and refused in a compressed one, whose bytes have no unknown course.
+   */
   course(degrees: number): Self {
     this.fields.courseDegrees = degrees;
     return this.self();
@@ -262,18 +301,32 @@ abstract class PositionedBuilder<Self> {
     return this.self();
   }
 
-  /** Altitude, feet. */
+  /** Speed, km/h (sent in knots, 1.852 km/h each, rounded once to the knot). */
+  speedKmh(kmh: number): Self {
+    this.fields.speedKnots = kmh / 1.852;
+    return this.self();
+  }
+
+  /** Altitude, feet, sent as a `/A=` in whole feet (rounded to the nearest, halves away from zero). */
   altitude(feet: number): Self {
     this.fields.altitudeFeet = feet;
+    this.altitudeUnit = 'feet';
     return this.self();
   }
 
-  /** Altitude, metres (sent in feet, rounded). */
+  /**
+   * Altitude, metres: converted to feet (0.3048 m each) and rounded once for a `/A=`; a Mic-E
+   * report sends it in its own altitude bytes, whose unit is the metre, rounded to the metre.
+   */
   altitudeMetres(metres: number): Self {
-    this.fields.altitudeFeet = Math.round(metres / 0.3048);
+    this.fields.altitudeFeet = metres / 0.3048;
+    this.altitudeUnit = 'metres';
     return this.self();
   }
 
+  /** The unit the altitude was given in. */
+  protected altitudeUnit: 'feet' | 'metres' | undefined;
+
   /** Free text. */
   comment(text: string): Self {
     this.fields.comment = text;
@@ -324,8 +377,8 @@ abstract class ReportBuilder<Self> extends PositionedBuilder<Self> {
   }
 
   /** Weather data (needs a weather station symbol, `_`). */
-  weather(weather: Weather): Self {
-    this.fields.weather = weather;
+  weather(weather: WeatherInput): Self {
+    this.fields.weather = weatherOf(weather);
     return this.self();
   }
 
@@ -487,6 +540,11 @@ export class MicEBuilder extends PositionedBuilder<MicEBuilder> {
 
   build(): BuiltPacket {
     const data: Mutable<Extract<AprsData, { type: 'mic-e' }>> = { type: 'mic-e', micEMessage: this.messageValue, ...this.fields };
+    // A course of 0 (after rounding) is unknown, which Mic-E writes as 0: no course (B1).
+    if (data.courseDegrees !== undefined && Number.isFinite(data.courseDegrees) && nearest(data.courseDegrees) === 0) delete data.courseDegrees;
+    // Metres go in the Mic-E altitude bytes, to the metre; feet in a /A= (B2).
+    if (data.altitudeFeet !== undefined && this.altitudeUnit === 'metres') data.altitudeFeet = nearest(data.altitudeFeet * 0.3048) / 0.3048;
+    if (data.altitudeFeet !== undefined && this.altitudeUnit === 'feet') ALTITUDE_GIVEN_IN_FEET.add(data);
     if (this.typeCodeValue !== undefined) data.typeCode = this.typeCodeValue;
     if (this.locatorValue !== undefined) data.locator = this.locatorValue;
     if (this.oldValue) data.oldData = true;
@@ -589,7 +647,7 @@ export class TelemetryBuilder {
 
   constructor(
     private readonly header: Header,
-    private readonly sequence: string,
+    private readonly sequence: number | string,
     private readonly analog: readonly (number | null)[],
     private readonly bits: string,
   ) {}
@@ -601,9 +659,14 @@ export class TelemetryBuilder {
   }
 
   build(): BuiltPacket {
+    let sequence = this.sequence;
+    if (typeof sequence === 'number') {
+      if (!Number.isInteger(sequence) || sequence < 0 || sequence > 999) refuse(`telemetry sequence ${sequence} is not 0-999`);
+      sequence = String(sequence).padStart(3, '0');
+    }
     const data: Mutable<Extract<AprsData, { type: 'telemetry' }>> = {
       type: 'telemetry',
-      sequence: this.sequence,
+      sequence,
       analog: [...this.analog],
       bits: this.bits,
     };

package/src/decode/index.ts

@@ -2,6 +2,7 @@
 
 import { binaryToBytes, bytesToBinary } from '../bytes.js';
 import type { Diagnostic, ParseOptions } from '../diagnostics.js';
+import { identifyDevice } from '../deviceid.js';
 import { parseHeaderText } from '../header.js';
 import type { AprsData, AprsPacket, ThirdParty } from '../types.js';
 import { DecodeContext, Rejected } from './context.js';
@@ -128,6 +129,9 @@ function decodeThirdParty(ctx: DecodeContext, s: string, options: ParseOptions):
     data: inner.data,
     diagnostics: [...headerDiags, ...inner.diagnostics],
   };
+  // The inner packet has its device too, from its own destination (vectors rulings, A2).
+  const device = identifyDevice(inner.data, header.destination);
+  if (device) packet.device = device;
   // A q-construct is read only in the outer header: the third-party path is kept as sent.
   return { type: 'third-party', packet };
 }

package/src/decode/other.ts

@@ -150,7 +150,7 @@ export function decodeQuery(ctx: DecodeContext, s: string): Query {
     const longitude = Number(f[2]);
     // A footprint is a real place (vectors interpretations.md).
     if (Math.abs(latitude) > 90 || Math.abs(longitude) > 180) ctx.fail('invalid-general-query');
-    out.footprint = { latitude, longitude, radiusMiles: Number(f[3]) };
+    out.footprint = { latitude, longitude, radiusMiles: Number(f[3]), latitudeText: f[1]!, longitudeText: f[2]! };
   }
   return out;
 }

package/src/decode/positioned.ts

@@ -618,6 +618,15 @@ interface LiftOptions {
   symbol: AprsSymbol;
   /** An area object's line shape, whose corridor width may be in braces. */
   areaLine?: boolean;
+  /** Telemetry and the `!DAO!`, already lifted out of the text (Mic-E status text). */
+  pre?: PreLifted;
+}
+
+/** Base-91 telemetry and a `!DAO!` lifted out of text, and the text left. */
+export interface PreLifted {
+  telemetry?: CommentTelemetry;
+  dao?: DaoFound;
+  rest: string;
 }
 
 /** What the comment lifting found. */
@@ -650,10 +659,10 @@ function removeRanges(s: string, ranges: readonly [number, number][]): string {
  * Lifts base-91 telemetry and the last `!DAO!` outside it. A `!DAO!` is five bytes as sent, so one
  * is never read across a `join`, a place in `s` where another element was already taken out.
  */
-function liftTelemetryAndDao(
+export function liftTelemetryAndDao(
   s: string,
   joins: readonly number[] = [],
-): { telemetry?: CommentTelemetry; dao?: DaoFound; rest: string } {
+): { telemetry?: CommentTelemetry; dao?: DaoFound; rest: string; cuts: number[] } {
   const tel = findCommentTelemetry(s);
   let dao: DaoFound | undefined;
   for (let p = s.length - 5; p >= 0; p--) {
@@ -668,7 +677,14 @@ function liftTelemetryAndDao(
   const ranges: [number, number][] = [];
   if (tel) ranges.push([tel.start, tel.end]);
   if (dao) ranges.push([dao.start, dao.start + 5]);
-  const out: { telemetry?: CommentTelemetry; dao?: DaoFound; rest: string } = { rest: removeRanges(s, ranges) };
+  // Where, in the text left, something was taken out.
+  let removed = 0;
+  const cuts: number[] = [];
+  for (const [a, b] of [...ranges].sort((x, y) => x[0] - y[0])) {
+    cuts.push(a - removed);
+    removed += b - a;
+  }
+  const out: { telemetry?: CommentTelemetry; dao?: DaoFound; rest: string; cuts: number[] } = { rest: removeRanges(s, ranges), cuts };
   if (tel) out.telemetry = tel.telemetry;
   if (dao) out.dao = dao;
   return out;
@@ -678,7 +694,7 @@ const ALTITUDE_RE = /\/A=(-[0-9]{5}|[0-9]{6})/;
 
 /** Lifts the structured elements out of a comment, in the order the vectors' README gives. */
 function liftComment(ctx: DecodeContext, text: string, options: LiftOptions): Lifted {
-  const first = liftTelemetryAndDao(text, options.joins);
+  const first = options.pre ? { ...options.pre, rest: text } : liftTelemetryAndDao(text, options.joins);
   const lifted: Lifted = { rest: first.rest };
   if (first.telemetry) lifted.telemetry = first.telemetry;
   if (first.dao) lifted.dao = first.dao;
@@ -857,6 +873,12 @@ function parseWeatherFields(ctx: DecodeContext, s: string, j: number, options: W
           j += 4;
           continue;
         }
+        // Exactly three spaces is a snowfall sent as unknown, as for any other field.
+        if (v === '   ') {
+          seen.add(key);
+          j += 4;
+          continue;
+        }
         // Only a run of dots may be shorter than three, and only when no digit follows it: s..6 is
         // not a field, so the fields end there.
         const dots = /^\.{1,3}/.exec(v)?.[0];
@@ -961,7 +983,7 @@ function weatherTail(
   rest: string,
   positioned: boolean,
 ): { comment?: string; telemetry?: CommentTelemetry; dao?: DaoFound } {
-  const lifted = positioned ? liftTelemetryAndDao(rest) : { rest };
+  const lifted: PreLifted = positioned ? liftTelemetryAndDao(rest) : { rest };
   const out: { comment?: string; telemetry?: CommentTelemetry; dao?: DaoFound } = {};
   if (lifted.telemetry) out.telemetry = lifted.telemetry;
   if (lifted.dao) out.dao = lifted.dao;
@@ -1118,7 +1140,8 @@ function applyLifted(ctx: DecodeContext, f: Fields, lifted: Lifted): void {
 const STORM_TYPES: Record<string, StormType> = { TS: 'tropical-storm', HC: 'hurricane', TD: 'tropical-depression' };
 
 function parseStorm(s: string): { storm: Storm; length: number } | undefined {
-  const m = /^\/(TS|HC|TD)\/([0-9 .]{3})\^([0-9 .]{3})\/([0-9 .]{4})>([0-9 .]{3})&([0-9 .]{3})(?:%([0-9 .]{3}))?/.exec(s);
+  // Each field is digits (vectors object-item/storm-data-with-a-space-in-a-field-is-text).
+  const m = /^\/(TS|HC|TD)\/([0-9]{3})\^([0-9]{3})\/([0-9]{4})>([0-9]{3})&([0-9]{3})(?:%([0-9]{3}))?/.exec(s);
   if (!m) return undefined;
   const num = (v: string | undefined): number | undefined => (v !== undefined && /^[0-9]+$/.test(v) ? Number(v) : undefined);
   const storm: { -readonly [K in keyof Storm]: Storm[K] } = { type: STORM_TYPES[m[1]!]! };
@@ -1190,11 +1213,12 @@ export function liftMicEComment(
   text: string,
   symbol: AprsSymbol,
   extension: ExtensionFound | undefined,
-  joins: readonly number[],
+  pre: PreLifted,
+  atStart = true,
 ): { lifted: Lifted } {
   const options: LiftOptions = extension
-    ? { extensionFound: true, extension, symbol, joins }
-    : { extensionFound: false, extensionAtStart: true, symbol, joins };
+    ? { extensionFound: true, extension, symbol, pre }
+    : { extensionFound: false, extensionAtStart: atStart, symbol, pre };
   return { lifted: liftComment(ctx, text, options) };
 }
 

package/src/decode/reports.ts

@@ -20,6 +20,7 @@ import {
   isDigit,
   isSymbolTable,
   liftMicEComment,
+  liftTelemetryAndDao,
   METRES_PER_FOOT,
   parsePosition,
   parsePositionlessWeather,
@@ -257,6 +258,8 @@ function micEMinutes(tens: number, units: number, hundredths: number, ambiguity:
 
 const TYPE_CODES = '`\'>] ';
 
+const MIC_E_LOCATOR = /^([A-Ra-r]{2}[0-9]{2}(?:[A-Xa-x]{2})?)\/G/;
+
 /** `` ` ``, `'`, 0x1c, 0x1d: a Mic-E report. */
 export function decodeMicE(ctx: DecodeContext, s: string): MicEReport {
   // The Rev 0 beta data type identifiers are obsolete: said at the DTI, before anything is checked.
@@ -348,6 +351,7 @@ export function decodeMicE(ctx: DecodeContext, s: string): MicEReport {
   }
   let altitudeFeet: number | undefined;
   let extension: ExtensionFound | undefined;
+  let extensionAfterLocator = false;
   // Where a later altitude was taken out of the text: a !DAO! is never read across it.
   let join: number | undefined;
   const altFirst = /^([!-{]{3})\}/.exec(text);
@@ -355,32 +359,52 @@ export function decodeMicE(ctx: DecodeContext, s: string): MicEReport {
     altitudeFeet = (base91Value(altFirst[1]!) - 10000) / METRES_PER_FOOT;
     text = text.slice(4);
   } else {
-    // A data extension straight after the type code is read first, so its bytes are never taken
-    // for an altitude later in the text (`0PH}` in `PHG3330PH}`).
-    extension = extensionAt(text, 0);
-    if (extension) text = text.slice(extension.length);
+    // A data extension straight after the type code, or after a locator there and its space, is
+    // read first, so its bytes are never taken for an altitude later in the text (`0PH}` in
+    // `PHG3330PH}`).
+    const loc = MIC_E_LOCATOR.exec(text);
+    const at = loc && text[loc[0].length] === ' ' ? loc[0].length + 1 : 0;
+    extension = extensionAt(text, at);
+    if (extension) {
+      text = text.slice(0, at) + text.slice(at + extension.length);
+      extensionAfterLocator = at > 0;
+    }
     const later = /([!-{]{3})\}/.exec(text);
     if (later && ctx.allows('mic-e-altitude-not-first')) {
       altitudeFeet = (base91Value(later[1]!) - 10000) / METRES_PER_FOOT;
       text = text.slice(0, later.index) + text.slice(later.index + 4);
       join = later.index;
+    } else if (!ctx.options.tolerates('mic-e-altitude-not-first')) {
+      // A later altitude declined is left as text; lifting telemetry or the !DAO! must then not
+      // join the bytes either side of its place into another one. With no later altitude, strict reads as lenient (vectors
+      // README, Mic-E).
+      const lifted = liftTelemetryAndDao(text);
+      const across = [...lifted.rest.matchAll(/(?=([!-{]{3})\})/g)].some((m) => lifted.cuts.some((c) => c > m.index && c < m.index + 4));
+      if (later && across) ctx.fail('mic-e-altitude-not-first');
     }
   }
   if (altitudeFeet !== undefined) f.altitudeFeet = altitudeFeet;
+  // Base-91 telemetry and the !DAO! are lifted before the locator is read, so a locator followed
+  // straight by either has no missing space (vectors rulings, F16).
+  const joins = join !== undefined && join > 0 ? [join] : [];
+  const pre = liftTelemetryAndDao(text, joins);
+  text = pre.rest;
+  // A locator is read only at the start of the status text, after any type code or a Mic-E
+  // altitude there; after a PHG or RNG, say, it is text (vectors rulings, F17).
   let locator: string | undefined;
-  const loc = /^([A-Ra-r]{2}[0-9]{2}(?:[A-Xa-x]{2})?)\/G/.exec(text);
+  const loc = extension && !extensionAfterLocator ? null : MIC_E_LOCATOR.exec(text);
   if (loc) {
     locator = loc[1]!.toUpperCase();
-    const before = text.length;
     text = text.slice(loc[0].length);
     if (text.length > 0) {
       if (text[0] === ' ') text = text.slice(1);
       else ctx.tolerate('missing-space-after-locator');
     }
-    if (join !== undefined) join -= before - text.length;
   }
-  const joins = join !== undefined && join > 0 ? [join] : [];
-  const { lifted } = liftMicEComment(ctx, text, pos.symbol, extension, joins);
+  // A PHG or RNG is straight after the type code only where it is so as sent: one that reaches
+  // there once a later altitude is lifted is late (vectors mic-e/an-rng-reached-only-by-lifting-an-altitude-is-late).
+  const startJoined = !extension && !loc && join !== undefined && (extensionAt(text, 0)?.length ?? 0) > join;
+  const { lifted } = liftMicEComment(ctx, text, pos.symbol, extension, pre, !startJoined);
   // The !DAO! is structure, so it is judged before the text's encoding.
   applyDao(ctx, f, pos, lifted.dao);
   applyLiftedTo(ctx, f, lifted);

package/src/decoder.ts

@@ -2,7 +2,7 @@
 
 import { encodeUtf8 } from './bytes.js';
 import { decodeInformation } from './decode/index.js';
-import { identifyMicE, identifyTocall } from './deviceid.js';
+import { identifyDevice } from './deviceid.js';
 import { ParseOptions } from './diagnostics.js';
 import { findQConstruct, parseAx25Frame, parseTnc2Header, type ParsedHeader } from './header.js';
 import type { AprsPacket } from './types.js';
@@ -19,10 +19,7 @@ function assemble(header: ParsedHeader, options: ParseOptions): AprsPacket {
   };
   const q = findQConstruct(header.path);
   if (q) packet.qConstruct = q;
-  const device =
-    decoded.data.type === 'mic-e'
-      ? identifyMicE(decoded.data.typeCode, decoded.data.deviceSuffix)
-      : identifyTocall(header.destination);
+  const device = identifyDevice(decoded.data, header.destination);
   if (device) packet.device = device;
   return packet;
 }

package/src/deviceid.ts

@@ -3,7 +3,7 @@
 // its type code and suffix.
 
 import { MICE, MICE_LEGACY, TOCALLS, type DeviceEntry } from './deviceid-data.js';
-import type { DeviceInfo } from './types.js';
+import type { AprsData, DeviceInfo } from './types.js';
 
 export { DEVICEID_SOURCE, DEVICE_CLASSES } from './deviceid-data.js';
 
@@ -53,9 +53,13 @@ function compile(): CompiledTocall[] {
 const tocallCache = new Map<string, DeviceInfo | undefined>();
 const TOCALL_CACHE_LIMIT = 4096;
 
-/** The device a destination address (tocall) identifies, e.g. `APDW18` is Dire Wolf. */
+/**
+ * The device a destination address (tocall) identifies, e.g. `APDW18` is Dire Wolf. The lookup is
+ * case-sensitive: the database lists tocalls in upper case and a destination is a callsign, so
+ * `APNl02` matches nothing (vectors rulings, A1).
+ */
 export function identifyTocall(destination: string): DeviceInfo | undefined {
-  const call = destination.split('-')[0]!.toUpperCase();
+  const call = destination.split('-')[0]!;
   if (tocallCache.has(call)) return tocallCache.get(call);
   let found: DeviceInfo | undefined;
   for (const t of compile()) {
@@ -96,3 +100,8 @@ export function identifyMicE(typeCode: string | undefined, suffix: string | unde
   }
   return undefined;
 }
+
+/** The device a packet identifies: by its Mic-E type code and suffix, else by its destination. */
+export function identifyDevice(data: AprsData, destination: string): DeviceInfo | undefined {
+  return data.type === 'mic-e' ? identifyMicE(data.typeCode, data.deviceSuffix) : identifyTocall(destination);
+}

package/src/encode/common.ts

@@ -19,10 +19,26 @@ export function pad(n: number, width: number): string {
   return String(n).padStart(width, '0');
 }
 
-/** A whole number within [min, max], else refused. */
+/**
+ * The nearest whole number, halves away from zero, as the vectors' rules round wherever they say
+ * "nearest" (`Math.round` takes a half towards +infinity, so -2.5 to -2). A value within 1e-6 of a
+ * half is the half: decimal text such as 58.585 is seldom exactly that in binary, and the half the
+ * text means wins (vectors rulings, F2).
+ */
+export function nearest(value: number): number {
+  const abs = Math.abs(value);
+  const below = Math.floor(abs);
+  const n = abs - below >= 0.5 - HALF_TOLERANCE ? below + 1 : below;
+  return value < 0 ? -n : n;
+}
+
+/** How near a half, in steps, a value is taken for the half. */
+const HALF_TOLERANCE = 1e-6;
+
+/** A whole number within [min, max], else refused; a fraction is rounded to the nearest. */
 export function whole(value: number, min: number, max: number, what: string): number {
   if (!Number.isFinite(value)) refuse(`${what} is not a number`);
-  const n = Math.round(value);
+  const n = nearest(value);
   if (n < min || n > max) refuse(`${what} ${value} is out of range (${min}-${max})`);
   return n;
 }
@@ -80,8 +96,22 @@ export function base91(value: number, width: number): string {
   return out;
 }
 
-/** Formats a number as short text: `0.53`, `-32`, `1e-7`. */
+/**
+ * A number as plain decimal text: the shortest that reads back as the same number, with no
+ * exponent and no `+`, a `0` before a leading point and no trailing `.0` (`0.53`, `-94`, 1e61 as
+ * `1` and 61 zeros, 1e-7 as `0.0000001`; vectors rulings, F11).
+ */
 export function numberText(v: number): string {
   if (!Number.isFinite(v)) refuse('a value is not a number');
-  return String(v);
+  if (Object.is(v, -0)) return '0';
+  const shortest = String(v);
+  const m = /^(-?)([0-9])(?:\.([0-9]+))?e([+-][0-9]+)$/.exec(shortest);
+  if (!m) return shortest;
+  const sign = m[1]!;
+  const digits = m[2]! + (m[3] ?? '');
+  // The point sits after the first digit; the exponent moves it.
+  const point = 1 + Number(m[4]);
+  if (point <= 0) return `${sign}0.${'0'.repeat(-point)}${digits}`;
+  if (point >= digits.length) return sign + digits + '0'.repeat(point - digits.length);
+  return `${sign}${digits.slice(0, point)}.${digits.slice(point)}`;
 }

package/src/encode/index.ts

@@ -1,7 +1,7 @@
 // The encoder: writes only what the spec allows and refuses anything else with a reason. Free
 // text is checked by decoding what was written: if the result does not read back as the same
-// data (a comment that would read as an altitude, say), a `/` delimiter is tried, then the
-// signpost or corridor braces before the comment, and if none of that helps the encoder refuses.
+// data (a comment that would read as an altitude, say), the comment is tried straight after a
+// frequency, then after a `/` delimiter, and if neither helps the encoder refuses.
 
 import { binaryToBytes, bytesToBinary, decodeUtf8 } from '../bytes.js';
 import { decodeInformation } from '../decode/index.js';
@@ -30,7 +30,7 @@ import {
   encodeThirdParty,
   encodeUserDefined,
 } from './other.js';
-import { encodeItem, encodeMicE, encodeObject, encodePositionReport, encodeWeatherReport, type CommentMode } from './position.js';
+import { DEFAULT_COMPRESSION, encodeItem, encodeMicE, encodeObject, encodePositionReport, encodeWeatherReport, type CommentMode } from './position.js';
 
 export { AprsEncodeError } from './common.js';
 
@@ -156,14 +156,19 @@ function expected(data: AprsData, a: Attempt): AprsData {
   let d = data;
   if ((d.type === 'position' || d.type === 'object' || d.type === 'item') && d.compressed && a.compression) {
     if (!d.compression) d = { ...d, compression: a.compression };
-    if (d.courseDegrees !== undefined && d.speedKnots === undefined) d = { ...d, speedKnots: 0 };
   }
-  if (d.type === 'mic-e') {
-    if (d.speedKnots === undefined) d = { ...d, speedKnots: 0 };
-    if (d.courseDegrees === 0) {
-      const copy: Record<string, unknown> = { ...d };
-      delete copy.courseDegrees;
-      d = copy as unknown as AprsData;
+  if (d.type === 'mic-e' && d.speedKnots === undefined) d = { ...d, speedKnots: 0 };
+  if (d.type === 'third-party' && d.packet.information.length === 0) {
+    // An inner packet written from its data: cs values with no compression type got the default.
+    const inner = d.packet.data;
+    if ((inner.type === 'position' || inner.type === 'object' || inner.type === 'item') && inner.compressed && !inner.compression) {
+      const w = inner.weather;
+      const carries =
+        inner.courseDegrees !== undefined ||
+        inner.speedKnots !== undefined ||
+        inner.rangeMiles !== undefined ||
+        (w !== undefined && (w.windDirectionDegrees !== undefined || w.windSpeedMph !== undefined));
+      if (carries) d = { ...d, packet: { ...d.packet, data: { ...inner, compression: DEFAULT_COMPRESSION } } };
     }
   }
   return d;
@@ -179,10 +184,24 @@ function check(data: AprsData, a: Attempt): string[] {
     return problems;
   }
   // An NMEA sentence is written as it is, so everything read from it must be what the data says.
-  shapeDifferences(toNeutralData(decoded.data), toNeutralData(expected(data, a)), '', problems, data.type === 'nmea');
+  shapeDifferences(withoutInnerInfo(toNeutralData(decoded.data)), withoutInnerInfo(toNeutralData(expected(data, a))), '', problems, data.type === 'nmea');
   return problems;
 }
 
+/**
+ * A third-party packet's neutral data without its inner packet's `info` diagnostics: an info is
+ * not a defect, so an inner packet that reads back with only those is written (vectors rulings, F10).
+ */
+function withoutInnerInfo(n: Record<string, unknown>): Record<string, unknown> {
+  const packet = n.packet as Record<string, unknown> | undefined;
+  if (n.type !== 'third-party' || !packet || !Array.isArray(packet.diagnostics)) return n;
+  const kept = (packet.diagnostics as string[]).filter((d) => !d.startsWith('info:'));
+  const copy: Record<string, unknown> = { ...packet };
+  if (kept.length > 0) copy.diagnostics = kept;
+  else delete copy.diagnostics;
+  return { ...n, packet: copy };
+}
+
 /**
  * Encodes data as an information field. Mic-E also gives the destination address it computed.
  * Throws `AprsEncodeError`, with the reason, for anything the spec does not allow.
@@ -192,9 +211,9 @@ export function encodeInformation(data: AprsData): EncodedInformation {
   let problems = check(data, first);
   let chosen = first;
   if (problems.length > 0 && typeof (data as { comment?: unknown }).comment === 'string') {
-    // The comment would read as something else: try it straight after a frequency, then after a /,
-    // then after the signpost or corridor braces.
-    for (const mode of ['joined', 'delimited', 'braces-first'] as const) {
+    // The comment would read as something else: try it straight after a frequency, then after a
+    // /, then after a space.
+    for (const mode of ['joined', 'delimited', 'spaced'] as const) {
       let next: Attempt | undefined;
       try {
         next = attempt(data, mode);

package/src/encode/other.ts

@@ -209,12 +209,22 @@ export function encodeQuery(d: Query): string {
   if (d.footprint) {
     const f = d.footprint;
     if (!(f.latitude >= -90 && f.latitude <= 90) || !(f.longitude >= -180 && f.longitude <= 180)) refuse('the footprint is out of range');
-    const coord = (v: number): string => (v < 0 ? numberText(v) : ` ${numberText(v)}`);
-    out += `${coord(f.latitude)},${numberText(f.longitude)},${pad(whole(f.radiusMiles, 0, 9999, 'radius'), 4)}`;
+    // Each value as sent, a leading space or its absence included, when that is the value (vectors
+    // rulings, E1); otherwise one that is not negative, 0 included, after a space (APRS12c ch. 15;
+    // vectors rulings, F11, F15).
+    const asSent = (text: string | undefined, v: number): string | undefined =>
+      text !== undefined && FOOTPRINT_VALUE.test(text) && Number(text) === v ? text : undefined;
+    const value = (v: number): string => (v < 0 ? numberText(v) : ` ${numberText(v)}`);
+    const lat = asSent(f.latitudeText, f.latitude) ?? value(f.latitude);
+    const lon = asSent(f.longitudeText, f.longitude) ?? value(f.longitude);
+    out += `${lat},${lon},${pad(whole(f.radiusMiles, 0, 9999, 'radius'), 4)}`;
   }
   return out;
 }
 
+/** A footprint value as a decoder reads it: a number as a telemetry value is, a positive one after at most one space. */
+const FOOTPRINT_VALUE = /^(?: ?(?:[0-9]+\.?[0-9]*|\.[0-9]+)|-(?:[0-9]+\.?[0-9]*|\.[0-9]+))$/;
+
 /** A control character: below U+0020, or U+007F. */
 const CONTROL_RE = /[\x00-\x1f\x7f]/;