@aeroswarm/codec 0.1.10 → 0.1.11

package/dist/index.js

@@ -130,27 +130,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: first ? parseInt(first[1]) : 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] ?? "";
 }
@@ -218,16 +238,17 @@ 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 };
     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 };
     const itemDef = def.items.get(id);
-    if (!itemDef) break;
+    if (!itemDef) return { end: off, complete: false };
     const start = off;
     off = skipItem(block, off, itemDef);
     onField(id, block.slice(start, off), itemDef);
   }
+  return { end: off, complete: true };
 }
 
 // src/surveillance/asterix/fields.ts
@@ -616,6 +637,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 +701,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 +916,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 +936,49 @@ 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);
+      const { all, consumed } = decodeRecords(block, def, cat);
+      const first = all[0];
+      if (!first) continue;
+      const score = plausibilityScore(first);
       if (!best || score > best.score) {
-        best = { edition, fields, score };
+        best = { edition, all, consumed, score };
       }
     }
-    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,
+      records: best?.all ?? []
+    });
   }
-  return records;
+  return blocks;
+}
+function decodeRecords(block, def, cat) {
+  const out = [];
+  let pos = 0;
+  let consumed = 0;
+  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 (out.length > 0 && Object.keys(fields).length === 0) break;
+    out.push(fields);
+    if (!result.complete || result.end <= 0) break;
+    pos += result.end;
+    consumed = pos;
+  }
+  return { all: out, consumed };
 }
 function isPlausible(f) {
   if (f.lat !== void 0 && (f.lat < -90 || f.lat > 90)) return false;

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

@@ -7,8 +7,13 @@ export declare function parseFspec(buf: Buffer, start?: number): {
 /** Advance offset past one DataItem, returning new offset. */
 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).
  */
-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;
+};
 //# 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,8DAA8D;AAC9D,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,GAAG,MAAM,CAiDvE;AAID;;;;;GAKG;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,CAAA;CAAE,CA0BpC"}

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,19 @@ 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. Less than `length` means an item was sized wrongly or the tail was not understood. */
+    consumed: number;
+    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,iIAAiI;IACjI,QAAQ,EAAE,MAAM,CAAC;IACjB,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,CAwCpB"}

package/package.json

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