@aeroswarm/codec 0.1.10 → 0.1.12

package/dist/index.js

@@ -116,11 +116,15 @@ function parseBits(s) {
   }
   return out;
 }
+function repetitionBytes(body, fallback) {
+  if (/<BDS[\s/>]/.test(body)) return 8;
+  const m = body.match(/<Fixed\s+length="(\d+)"/);
+  return m ? parseInt(m[1]) : fallback;
+}
 function parseRepetitive(s) {
   const inner = firstContent(s, "Repetitive");
   const repAttr = inner.match(/<Repetitive\s+rep="(\d+)"/);
-  const m = inner.match(/<Fixed\s+length="(\d+)"/);
-  return { type: "repetitive", repBytes: repAttr ? parseInt(repAttr[1]) : 1, itemBytes: m ? parseInt(m[1]) : 0 };
+  return { type: "repetitive", repBytes: repAttr ? parseInt(repAttr[1]) : 1, itemBytes: repetitionBytes(inner, 0) };
 }
 function parseCompound(s) {
   const inner = firstContent(s, "Compound");
@@ -130,27 +134,47 @@ function parseCompound(s) {
   const varEnd = inner.indexOf("</Variable>");
   const afterVar = varEnd >= 0 ? inner.slice(varEnd + "</Variable>".length) : "";
   const subs = [];
-  const subRe = /<(Fixed|Variable|Repetitive|Explicit)\s/g;
-  let sm;
-  while ((sm = subRe.exec(afterVar)) !== null) {
-    const tag = sm[1];
-    const rest = afterVar.slice(sm.index);
-    if (tag === "Fixed") {
-      const lm = rest.match(/<Fixed\s+length="(\d+)"/);
+  for (const child of topLevelChildren(afterVar)) {
+    const first = child.body.match(/<Fixed\s+length="(\d+)"/);
+    if (child.tag === "Fixed") {
+      const lm = child.open.match(/length="(\d+)"/);
       if (lm) subs.push({ type: "fixed", bytes: parseInt(lm[1]) });
-    } else if (tag === "Variable") {
-      const lm = rest.match(/<Fixed\s+length="(\d+)"/);
-      subs.push({ type: "variable", chunkBytes: lm ? parseInt(lm[1]) : 1 });
-    } else if (tag === "Repetitive") {
-      const repAttr = rest.match(/<Repetitive\s+rep="(\d+)"/);
-      const lm = rest.match(/<Fixed\s+length="(\d+)"/);
-      subs.push({ type: "repetitive", repBytes: repAttr ? parseInt(repAttr[1]) : 1, itemBytes: lm ? parseInt(lm[1]) : 1 });
+    } else if (child.tag === "Variable") {
+      subs.push({ type: "variable", chunkBytes: first ? parseInt(first[1]) : 1 });
+    } else if (child.tag === "Repetitive") {
+      const repAttr = child.open.match(/rep="(\d+)"/);
+      subs.push({ type: "repetitive", repBytes: repAttr ? parseInt(repAttr[1]) : 1, itemBytes: repetitionBytes(child.body, 1) });
     } else {
       subs.push({ type: "explicit" });
     }
   }
   return { type: "compound", indicatorChunk, subs };
 }
+function topLevelChildren(s) {
+  const out = [];
+  const re = /<(\/?)(Fixed|Variable|Repetitive|Explicit|Compound)\b([^>]*?)(\/?)>/g;
+  let depth = 0;
+  let current = null;
+  let m;
+  while ((m = re.exec(s)) !== null) {
+    const closing = m[1] === "/";
+    const selfClosing = m[4] === "/";
+    if (!closing) {
+      if (depth === 0) {
+        if (selfClosing) out.push({ tag: m[2], open: m[0], body: "" });
+        else current = { tag: m[2], open: m[0], start: m.index + m[0].length };
+      }
+      if (!selfClosing) depth++;
+    } else {
+      depth--;
+      if (depth === 0 && current) {
+        out.push({ tag: current.tag, open: current.open, body: s.slice(current.start, m.index) });
+        current = null;
+      }
+    }
+  }
+  return out;
+}
 function firstContent(s, tag) {
   return s.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`))?.[1] ?? "";
 }
@@ -168,23 +192,23 @@ function parseFspec(buf, start = 0) {
   return { bits, end: i };
 }
 function skipItem(buf, off, def) {
-  if (off >= buf.length) return buf.length;
+  if (off >= buf.length) return buf.length + 1;
   switch (def.type) {
     case "fixed":
-      return Math.min(off + def.bytes, buf.length);
+      return off + def.bytes;
     case "variable": {
       while (off + def.chunkBytes <= buf.length) {
         const last = buf[off + def.chunkBytes - 1];
         off += def.chunkBytes;
         if ((last & 1) === 0) break;
       }
-      return Math.min(off, buf.length);
+      return off;
     }
     case "repetitive": {
-      if (off + def.repBytes > buf.length) return buf.length;
+      if (off + def.repBytes > buf.length) return buf.length + 1;
       let rep = 0;
       for (let i = 0; i < def.repBytes; i++) rep = rep << 8 | buf[off + i];
-      return Math.min(off + def.repBytes + rep * def.itemBytes, buf.length);
+      return off + def.repBytes + rep * def.itemBytes;
     }
     case "compound": {
       const presentIdxs = [];
@@ -202,13 +226,12 @@ function skipItem(buf, off, def) {
         if (idx >= def.subs.length) break;
         off = skipItem(buf, off, def.subs[idx]);
       }
-      return Math.min(off, buf.length);
+      return off;
     }
     case "explicit": {
-      if (off >= buf.length) return off;
+      if (off >= buf.length) return buf.length + 1;
       const len = buf[off];
-      off++;
-      return Math.min(off + len - 1, buf.length);
+      return off + Math.max(len, 1);
     }
   }
 }
@@ -218,16 +241,18 @@ function decodeBlock(block, def, onField) {
   const uapMap = new Map(def.uap.map((e) => [e.bit, e.id]));
   for (let i = 0; i < bits.length; i++) {
     if (!bits[i]) continue;
-    if (off >= block.length) break;
+    if (off >= block.length) return { end: block.length, complete: true, overrun: true };
     const uapPos = i + Math.floor(i / 7);
     const id = uapMap.get(uapPos);
-    if (id === void 0) break;
+    if (id === void 0) return { end: off, complete: false, overrun: false };
     const itemDef = def.items.get(id);
-    if (!itemDef) break;
+    if (!itemDef) return { end: off, complete: false, overrun: false };
     const start = off;
     off = skipItem(block, off, itemDef);
-    onField(id, block.slice(start, off), itemDef);
+    onField(id, block.slice(start, Math.min(off, block.length)), itemDef);
+    if (off > block.length) return { end: block.length, complete: true, overrun: true };
   }
+  return { end: off, complete: true, overrun: false };
 }
 
 // src/surveillance/asterix/fields.ts
@@ -616,6 +641,19 @@ function cat010(id, d, out, raw) {
   }
 }
 var MS_TO_KT = 1 / 0.514444;
+function flightPlanCallsign(d) {
+  let indicators = 0;
+  while (indicators < d.length) {
+    indicators++;
+    if ((d[indicators - 1] & 1) === 0) break;
+  }
+  const first = d[0] ?? 0;
+  if ((first & 64) === 0) return void 0;
+  const at = indicators + ((first & 128) !== 0 ? 2 : 0);
+  if (d.length < at + 7) return void 0;
+  const text = d.subarray(at, at + 7).toString("latin1").trim();
+  return text.length > 0 && /^[A-Z0-9 ]+$/.test(text) ? text : void 0;
+}
 function cat062(id, d, out, raw) {
   switch (id) {
     case "080":
@@ -667,14 +705,33 @@ function cat062(id, d, out, raw) {
       out.targetType = "vehicle";
       break;
     }
+    case "245": {
+      const cs = str(raw, "TId");
+      const text = cs !== void 0 ? cs : d.length >= 7 ? readCallsign(d.subarray(1)) : "";
+      if (text) out.callsign = text;
+      break;
+    }
+    case "390": {
+      if (out.callsign === void 0) {
+        const csn = flightPlanCallsign(d);
+        if (csn) out.callsign = csn;
+      }
+      break;
+    }
     case "380": {
       let fsLen = 0;
       while (fsLen < d.length) {
         fsLen++;
         if ((d[fsLen - 1] & 1) === 0) break;
       }
-      if (fsLen < d.length && (d[0] & 128) !== 0 && d.length >= fsLen + 3) {
-        out.icao24 = d.readUIntBE(fsLen, 3).toString(16).padStart(6, "0");
+      let at = fsLen;
+      if (fsLen < d.length && (d[0] & 128) !== 0 && d.length >= at + 3) {
+        out.icao24 = d.readUIntBE(at, 3).toString(16).padStart(6, "0");
+        at += 3;
+      }
+      if (fsLen < d.length && (d[0] & 64) !== 0 && d.length >= at + 6 && out.callsign === void 0) {
+        const id2 = readCallsign(d.subarray(at, at + 6));
+        if (id2) out.callsign = id2;
       }
       break;
     }
@@ -863,6 +920,14 @@ var EDITIONS = {
 };
 function parseAsterix(buf, defaultEdition) {
   const records = [];
+  for (const block of parseAsterixBlocks(buf, defaultEdition)) {
+    if (block.edition === null) continue;
+    for (const fields of block.records) records.push({ category: block.category, edition: block.edition, fields });
+  }
+  return records;
+}
+function parseAsterixBlocks(buf, defaultEdition) {
+  const blocks = [];
   let offset = 0;
   while (offset + 3 <= buf.length) {
     const cat = buf[offset];
@@ -875,26 +940,56 @@ function parseAsterix(buf, defaultEdition) {
     for (const edition of toTry) {
       const def = loadDef(cat, edition);
       if (!def) continue;
-      const fields = {};
-      try {
-        decodeBlock(block, def, (id, data, itemDef) => {
-          const bits = itemDef.type === "fixed" || itemDef.type === "variable" ? itemDef.bits : void 0;
-          const bitData = itemDef.type === "variable" ? data.subarray(0, itemDef.chunkBytes) : data;
-          const raw = bits?.length ? extractBitFields(bitData, bits) : {};
-          decodeKnownField(cat, id, data, fields, raw);
-        });
-      } catch {
-        continue;
-      }
-      if (!isPlausible(fields)) continue;
-      const score = plausibilityScore(fields);
-      if (!best || score > best.score) {
-        best = { edition, fields, score };
+      const { all, consumed, full } = decodeRecords(block, def, cat);
+      const first = all[0];
+      if (!first) continue;
+      const score = plausibilityScore(first);
+      if (!best || full && !best.full || full === best.full && score > best.score) {
+        best = { edition, all, consumed, score, full };
       }
     }
-    if (best) records.push({ category: cat, edition: best.edition, fields: best.fields });
+    blocks.push({
+      category: cat,
+      edition: best?.edition ?? null,
+      length: block.length,
+      consumed: best?.consumed ?? 0,
+      clean: best?.full ?? false,
+      records: best?.all ?? []
+    });
   }
-  return records;
+  return blocks;
+}
+function decodeRecords(block, def, cat) {
+  const records = [];
+  let pos = 0;
+  let clean = false;
+  while (pos < block.length) {
+    const fields = {};
+    let result;
+    try {
+      result = decodeBlock(block.subarray(pos), def, (id, data, itemDef) => {
+        const bits = itemDef.type === "fixed" || itemDef.type === "variable" ? itemDef.bits : void 0;
+        const bitData = itemDef.type === "variable" ? data.subarray(0, itemDef.chunkBytes) : data;
+        const raw = bits?.length ? extractBitFields(bitData, bits) : {};
+        decodeKnownField(cat, id, data, fields, raw);
+      });
+    } catch {
+      break;
+    }
+    if (!isPlausible(fields)) break;
+    if (result.overrun && records.length > 0) break;
+    records.push({ fields, end: pos + result.end });
+    if (!result.complete || result.end <= 0 || result.overrun) break;
+    pos += result.end;
+    clean = pos >= block.length;
+  }
+  if (clean) {
+    const kept = records.filter((r, i) => i === 0 || Object.keys(r.fields).length > 0).map((r) => r.fields);
+    return { all: kept, consumed: block.length, full: true };
+  }
+  const firstEmpty = records.findIndex((r, i) => i > 0 && Object.keys(r.fields).length === 0);
+  const usable = firstEmpty === -1 ? records : records.slice(0, firstEmpty);
+  return { all: usable.map((r) => r.fields), consumed: usable.length > 0 ? usable[usable.length - 1].end : 0, full: false };
 }
 function isPlausible(f) {
   if (f.lat !== void 0 && (f.lat < -90 || f.lat > 90)) return false;
@@ -1249,6 +1344,7 @@ export {
   decodeMlatFrame,
   parseAftn,
   parseAsterix,
+  parseAsterixBlocks,
   resolveAsterixAltitudeFt,
   resolveAsterixPosition,
   splitAftnStream

package/dist/surveillance/asterix/cat062.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cat062.test.d.ts.map

package/dist/surveillance/asterix/cat062.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cat062.test.d.ts","sourceRoot":"","sources":["../../../src/surveillance/asterix/cat062.test.ts"],"names":[],"mappings":""}

package/dist/surveillance/asterix/decoder.d.ts

@@ -4,11 +4,21 @@ export declare function parseFspec(buf: Buffer, start?: number): {
     bits: boolean[];
     end: number;
 };
-/** Advance offset past one DataItem, returning new offset. */
+/**
+ * Advance offset past one DataItem, returning new offset. The result is NOT clamped to the buffer: an offset past
+ * `buf.length` means the item needs more octets than there are (an overrun), which `decodeBlock` reports.
+ */
 export declare function skipItem(buf: Buffer, off: number, def: ItemDef): number;
 /**
- * Decode one ASTERIX data block (everything after the 3-byte header).
- * Calls `onField(id, bytes, itemDef)` for each present DataItem.
+ * Decode ONE record at the start of `block` (a data block can carry many records back to back, each with its own
+ * FSPEC). Calls `onField(id, bytes, itemDef)` for each present DataItem. Returns where the record ended, so the caller
+ * can go on with the next one, and whether that position can be trusted: `complete` is false when an item the
+ * definition does not know stopped the decode (the length of what follows is then unknown); `overrun` is true when an
+ * item needed more octets than the block has (the record is cut short or an item was sized wrongly).
  */
-export declare function decodeBlock(block: Buffer, def: AsterixDef, onField: (id: string, data: Buffer, itemDef: ItemDef) => void): void;
+export declare function decodeBlock(block: Buffer, def: AsterixDef, onField: (id: string, data: Buffer, itemDef: ItemDef) => void): {
+    end: number;
+    complete: boolean;
+    overrun: boolean;
+};
 //# sourceMappingURL=decoder.d.ts.map

package/dist/surveillance/asterix/decoder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decoder.d.ts","sourceRoot":"","sources":["../../../src/surveillance/asterix/decoder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAI3D,sFAAsF;AACtF,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,SAAI,GAAG;IAAE,IAAI,EAAE,OAAO,EAAE,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAUnF;AAID,8DAA8D;AAC9D,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,GAAG,MAAM,CAiDvE;AAID;;;GAGG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,UAAU,EACf,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,GAC5D,IAAI,CAyBN"}
+{"version":3,"file":"decoder.d.ts","sourceRoot":"","sources":["../../../src/surveillance/asterix/decoder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAI3D,sFAAsF;AACtF,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,SAAI,GAAG;IAAE,IAAI,EAAE,OAAO,EAAE,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAUnF;AAID;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,GAAG,MAAM,CAiDvE;AAID;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,UAAU,EACf,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,GAC5D;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CA2BtD"}

package/dist/surveillance/asterix/index.d.ts

@@ -1,4 +1,5 @@
-export { parseAsterix } from './parser.js';
+export { parseAsterix, parseAsterixBlocks } from './parser.js';
+export type { AsterixBlockInfo } from './parser.js';
 export { resolveAsterixPosition, resolveAsterixAltitudeFt } from './resolvers.js';
 export type { RadarSite } from './resolvers.js';
 export type { AsterixRecord, AsterixFields } from './types.js';

package/dist/surveillance/asterix/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/surveillance/asterix/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,sBAAsB,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAClF,YAAY,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/surveillance/asterix/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAC/D,YAAY,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAAE,sBAAsB,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAClF,YAAY,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC"}

package/dist/surveillance/asterix/parser.d.ts

@@ -1,4 +1,4 @@
-import type { AsterixRecord } from './types.js';
+import type { AsterixRecord, AsterixFields } from './types.js';
 /**
  * Parse raw ASTERIX UDP datagram into structured records.
  *
@@ -13,4 +13,21 @@ import type { AsterixRecord } from './types.js';
  *                       Use when you know the sender's edition for certainty.
  */
 export declare function parseAsterix(buf: Buffer, defaultEdition?: Record<number, string>): AsterixRecord[];
+/** What became of one data block: the edition that fit (null = none, the block is dropped), its records, and how much of the block they used. */
+export interface AsterixBlockInfo {
+    category: number;
+    edition: string | null;
+    /** Octets of the block after its 3-octet header. */
+    length: number;
+    /** Octets taken up by the decoded records. */
+    consumed: number;
+    /** The records tile the block exactly: no octets left over, none missing, no item that ran past the end. False points at an item sized wrongly or a tail that was not understood. */
+    clean: boolean;
+    records: AsterixFields[];
+}
+/**
+ * Same decoding as `parseAsterix`, block by block, with the facts needed to judge it (see `AsterixBlockInfo`). For tools
+ * that check a decoder against a capture; `parseAsterix` is built on it.
+ */
+export declare function parseAsterixBlocks(buf: Buffer, defaultEdition?: Record<number, string>): AsterixBlockInfo[];
 //# sourceMappingURL=parser.d.ts.map

package/dist/surveillance/asterix/parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../src/surveillance/asterix/parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAiB,MAAM,YAAY,CAAC;AAsB/D;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,MAAM,EACX,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACtC,aAAa,EAAE,CA6CjB"}
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../src/surveillance/asterix/parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAsB/D;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,MAAM,EACX,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACtC,aAAa,EAAE,CAOjB;AAED,iJAAiJ;AACjJ,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,oDAAoD;IACpD,MAAM,EAAE,MAAM,CAAC;IACf,8CAA8C;IAC9C,QAAQ,EAAE,MAAM,CAAC;IACjB,qLAAqL;IACrL,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,aAAa,EAAE,CAAC;CAC1B;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,MAAM,EACX,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACtC,gBAAgB,EAAE,CA2CpB"}

package/dist/surveillance/asterix/repetitive.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=repetitive.test.d.ts.map

package/dist/surveillance/asterix/repetitive.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repetitive.test.d.ts","sourceRoot":"","sources":["../../../src/surveillance/asterix/repetitive.test.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aeroswarm/codec",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",