readback 0.0.0-alpha.6 → 0.0.0-alpha.8

package/README.md

@@ -1,8 +1,12 @@
 ```
-█▀▄ █▀▀ █▀█ █▀▄ █▀▄ █▀█ █▀▀ █ █ 
-█▀▄ █▀▀ █▀█ █ █ █▀▄ █▀█ █   █▀▄ 
-█ █ █   █ █ █ █ █ █ █ █ █   █ █ 
-▀ ▀ ▀▀▀ ▀ ▀ ▀▀  ▀▀  ▀ ▀ ▀▀▀ ▀ ▀
+       ◣               █▀▄ █▀▀ █▀█ █▀▄ █▀▄ █▀█ █▀▀ █ █
+       █◣         ║┇   █ █ █   █ █ █ █ █ █ █ █ █   █ █
+  ◣    ██◣❚       ║┇   █ █ █   █ █ █ █ █ █ █ █ █   █ █
+━╸█►◄█████████ ◗╺━║┇━━ █▀▄ █▀▀ █▀█ █ █ █▀▄ █▀█ █   █▀▄
+  ◤    ██◤❚       ║┇   █ █ █   █ █ █ █ █ █ █ █ █   █ █
+       █◤         ║┇   █ █ █   █ █ █ █ █ █ █ █ █   █ █
+       ◤               ▀ ▀ ▀▀▀ ▀ ▀ ▀▀  ▀▀  ▀ ▀ ▀▀▀ ▀ ▀
+                       • • • • • • • • • • • • • • • •
 ```
 
 **readback** is a real-time ATC (Air Traffic Control) transcription tool that captures system audio, transcribes it using local ATC-fine-tuned [Whisper](https://en.wikipedia.org/wiki/Whisper_(speech_recognition_system)) models, and formats the output with aviation-specific syntax highlighting. Useful for flight simmers on [VATSIM](https://vatsim.net) and [IVAO](https://www.ivao.aero) networks who (like me) struggle with following ATC communications.
@@ -119,8 +123,16 @@ This project would not be possible without the ATC-fine-tuned Whisper models pro
 
 ## Issues and contributions
 
-Found a bug or want to add features? Submit issues or pull requests on the [GitHub repository](https://github.com/borisdiakur/readback).
+Found a bug or want to add features? Submit issues or pull requests on the [GitHub repository](https://github.com/borisdiakur/readback/issues).
+
+### Reporting issues
+
+When filing a bug, please attach your session log from:
+
+```
+~/.readback/logs/
+```
 
 ---
 
-Happy flying!
+Happy flying!

package/dist/bin/index.js

@@ -9,6 +9,7 @@ import { startupCleanup } from "../src/startup-cleanup.js";
 import packageJson from "../package.json" with { type: "json" };
 import { BottomStatusLine } from "../src/status-line.js";
 import { printTranscript } from "../src/presentation/renderer.js";
+import { initLogger, logTranscript } from "../src/logger.js";
 await startupCleanup();
 const program = new Command();
 program
@@ -47,6 +48,7 @@ process.on("SIGINT", () => {
     process.exit(0);
 });
 const paths = await ensureAllModels();
+await initLogger(paths.asr, opts);
 const status = new BottomStatusLine();
 startCapture(async (text) => {
     if (opts.raw) {
@@ -71,6 +73,7 @@ startCapture(async (text) => {
         squawk: opts.squawk,
         waypoints: opts.waypoints,
     });
+    await logTranscript(text, result.tokens);
     if (opts.debug) {
         console.log("   " + styleText("dim", JSON.stringify(result.tokens)));
     }

package/dist/package.json

@@ -1,10 +1,15 @@
 {
     "name": "readback",
-    "version": "0.0.0-alpha.6",
+    "version": "0.0.0-alpha.7",
     "description": "Transcribes ATC transmissions into readable text.",
     "keywords": [
-        "ATC",
-        "aviation"
+        "atc",
+        "aviation",
+        "speech-to-text",
+        "transcription",
+        "flight-simulator",
+        "vatsim",
+        "ivao"
     ],
     "homepage": "https://github.com/borisdiakur/readback#readme",
     "bugs": {
@@ -34,7 +39,7 @@
         "build:start": "tsc && npm start",
         "build:watch": "tsc --watch",
         "extractNavData": "node scripts/extract-nav-data.ts",
-        "test": "node --test tests/**/*.spec.ts",
+        "test": "node --test ./tests/**/*.spec.ts",
         "test:cover": "node --experimental-test-coverage --test tests/**/*.spec.ts"
     },
     "dependencies": {
@@ -43,6 +48,7 @@
         "commander": "^14.0.3",
         "native-recorder-nodejs": "^1.2.0",
         "onnxruntime-node": "^1.24.1",
+        "ora": "^9.3.0",
         "smart-whisper": "^0.8.1",
         "speex-resampler": "^3.0.1",
         "wrap-ansi": "^9.0.2"

package/dist/src/banner.js

@@ -1,19 +1,50 @@
 import { styleText } from "node:util";
 import packageJson from "../package.json" with { type: "json" };
-const g = (t) => styleText(["dim", "white"], t);
-const w = (t) => styleText(["whiteBright"], t);
-const a = (t) => t
+const cols = [
+    "blue",
+    "cyan",
+    "magenta",
+    "green",
+    "red",
+    "blueBright",
+    "cyanBright",
+    "magentaBright",
+    "greenBright",
+    "redBright",
+    "whiteBright",
+];
+const stripes = (t) => t
     .split("")
     .map((c, i) => i < 2 ||
     i > t.length - 2 ||
     i === Math.floor(t.length / 2) - 1 ||
     i === Math.floor(t.length / 2) + 1 ||
     (i + 1) % 2 === 0
-    ? g(c)
-    : w(c))
+    ? styleText(["dim", "white"], c)
+    : styleText(["whiteBright"], c))
     .join("");
-const v = styleText("dim", " v" + packageJson.version);
-console.log(a("█▀▄ █▀▀ █▀█ █▀▄ █▀▄ █▀█ █▀▀ █ █"));
-console.log(a("█▀▄ █▀▀ █▀█ █ █ █▀▄ █▀█ █   █▀▄"));
-console.log(a("█ █ █   █ █ █ █ █ █ █ █ █   █ █"));
-console.log(a("▀ ▀ ▀▀▀ ▀ ▀ ▀▀  ▀▀  ▀ ▀ ▀▀▀ ▀ ▀") + v);
+const version = styleText(["dim", "cyan"], "  v" + packageJson.version);
+const stop = styleText("yellow", "║┇   ");
+const blob = styleText("yellow", "║┇━━ ");
+const chop = "     ";
+const cp = cols[Math.floor(Math.random() * cols.length)];
+const cs = cols[Math.floor(Math.random() * cols.length)];
+const csd = (t) => styleText([cs, "dim"], t);
+const csr = (t) => styleText(cs, t);
+const cpr = (t) => styleText(cp, t);
+const y = (t) => styleText(["yellow"], t);
+let l1 = chop + stripes("█▀▄ █▀▀ █▀█ █▀▄ █▀▄ █▀█ █▀▀ █ █");
+let l2 = stop + stripes("█ █ █   █ █ █ █ █ █ █ █ █   █ █");
+let l3 = stop + stripes("█ █ █   █ █ █ █ █ █ █ █ █   █ █");
+let l4 = blob + stripes("█▀▄ █▀▀ █▀█ █ █ █▀▄ █▀█ █   █▀▄");
+let l5 = stop + stripes("█ █ █   █ █ █ █ █ █ █ █ █   █ █");
+let l6 = stop + stripes("█ █ █   █ █ █ █ █ █ █ █ █   █ █");
+let l7 = chop + stripes("▀ ▀ ▀▀▀ ▀ ▀ ▀▀  ▀▀  ▀ ▀ ▀▀▀ ▀ ▀") + version;
+console.log(" " + cpr("      ◣          ") + l1);
+console.log(" " + csd("      █◣         ") + l2);
+console.log(" " + cpr(" ◣") + csd("    ██◣") + csr("❚       ") + l3);
+console.log(y("━╸") + csd("█►") + cpr("◄█████████ ◗") + y("╺━") + l4);
+console.log(" " + cpr(" ◤") + csd("    ██◤") + csr("❚       ") + l5);
+console.log(" " + csd("      █◤         ") + l6);
+console.log(" " + cpr("      ◤          ") + l7);
+console.log(styleText("greenBright", "                       • • • • • • • • • • • • • • • •"));

package/dist/src/cleaner.js

@@ -5,6 +5,7 @@ import { normalizeCallsigns } from "./normalization/callsigns.js";
 import { normalizeNavData } from "./normalization/nav-data.js";
 import { normalizeFlightLevel } from "./normalization/flight-level.js";
 import { normalizeHeading } from "./normalization/heading.js";
+import { normalizeBreak } from "./normalization/break.js";
 import { normalizeSpeed } from "./normalization/speed.js";
 import { normalizeRunway } from "./normalization/runway.js";
 import { normalizeSquawk } from "./normalization/squawk.js";
@@ -15,6 +16,7 @@ import { highlightKeywords } from "./normalization/keywords.js";
 import { renderToAnsi } from "./presentation/renderer.js";
 export function cleanTranscript(text, opts) {
     let tokens = tokenize(text);
+    tokens = normalizeBreak(tokens, opts);
     tokens = normalizePhonetics(tokens, opts);
     tokens = normalizeNumbers(tokens, opts);
     tokens = normalizeCallsigns(tokens, opts);

package/dist/src/logger.js

@@ -0,0 +1,78 @@
+import { appendFile, mkdir, readdir, rm } from "fs/promises";
+import { join } from "path";
+import { DATA_ROOT } from "./setup-manager.js";
+import packageJson from "../package.json" with { type: "json" };
+import { basename } from "node:path";
+const LOGS_DIR = join(DATA_ROOT, "logs");
+const MAX_LOG_FILES = 5;
+let logFilePath = null;
+/**
+ * Call once at startup. Creates the log file for this session and
+ * rotates old log files so we keep at most MAX_LOG_FILES.
+ */
+export async function initLogger(asrModelPath, opts) {
+    await mkdir(LOGS_DIR, { recursive: true });
+    await rotateLogs();
+    const filename = `session-${new Date().toISOString().replace(/[:.]/g, "-")}.jsonl`;
+    logFilePath = join(LOGS_DIR, filename);
+    const entry = {
+        type: "session_start",
+        timestamp: new Date().toISOString(),
+        env: {
+            nodeVersion: process.version,
+            platform: process.platform,
+            arch: process.arch,
+            readbackVersion: packageJson.version,
+            asrModel: basename(asrModelPath),
+            opts,
+        },
+    };
+    await writeEntry(entry);
+}
+/**
+ * Log a single transcript result including its token stream.
+ */
+export async function logTranscript(raw, tokens) {
+    if (!logFilePath)
+        return;
+    const entry = {
+        type: "transcript",
+        timestamp: new Date().toISOString(),
+        raw,
+        tokens,
+    };
+    await writeEntry(entry);
+}
+/**
+ * Returns the path of the current session log file, useful for
+ * printing to the user so they know where to find it.
+ */
+export function getLogFilePath() {
+    return logFilePath;
+}
+// --------------- internals ---------------
+async function writeEntry(entry) {
+    if (!logFilePath)
+        return;
+    try {
+        await appendFile(logFilePath, JSON.stringify(entry) + "\n", "utf-8");
+    }
+    catch {
+        // Logging must never crash the main process
+    }
+}
+async function rotateLogs() {
+    try {
+        const files = (await readdir(LOGS_DIR))
+            .filter((f) => f.startsWith("session-") && f.endsWith(".jsonl"))
+            .sort(); // ISO timestamp names sort lexicographically = chronologically
+        const excess = files.length - (MAX_LOG_FILES - 1); // -1 to make room for the new one
+        if (excess > 0) {
+            const toDelete = files.slice(0, excess);
+            await Promise.all(toDelete.map((f) => rm(join(LOGS_DIR, f), { force: true })));
+        }
+    }
+    catch {
+        // Non-fatal
+    }
+}

package/dist/src/normalization/airlines.js

@@ -2,7 +2,6 @@
 // JSON.stringify(
 //   Array.from($$('.main-content td:first-child'))
 //     .map(td => td.innerText.toLowerCase().replace('-', ' '))
-//     .filter(a => a !== 'tower')
 // )
 export const KNOWN_AIRLINES = new Set([
     "abaco",

package/dist/src/normalization/altitude.js

@@ -10,25 +10,32 @@ export function normalizeAltitude(tokens, opts) {
         let isAltitude = false;
         let startOffset = 0;
         const val = t.value.toLowerCase();
-        // Pattern 1: "altitude" + NUMBER
+        // "altitude" + NUMBER
         if (val === "altitude" && next?.type === TokenType.NUMBER) {
             isAltitude = true;
             startOffset = 1;
         }
-        // Pattern 2: "descend/climb/maintain" + NUMBER
+        // "descend/climb/maintain" + NUMBER
         else if (["descend", "climb", "maintain"].includes(val) &&
             next?.type === TokenType.NUMBER) {
             isAltitude = true;
             startOffset = 1;
         }
-        // Pattern 2b: "descend/climb" + "maintain" + NUMBER
+        // "descend/climb" + "maintain" + NUMBER
         else if (["descend", "climb"].includes(val) &&
             next?.value.toLowerCase() === "maintain" &&
             next2?.type === TokenType.NUMBER) {
             isAltitude = true;
             startOffset = 2;
         }
-        // Pattern 3/4: Heuristic on bare number
+        // descend/climb to NUMBER
+        else if (["descend", "climb"].includes(val) &&
+            next?.value.toLowerCase() === "to" &&
+            next2?.type === TokenType.NUMBER) {
+            isAltitude = true;
+            startOffset = 2; // skip both "to" and land on NUMBER
+        }
+        // Heuristic on bare number
         else if (t.type === TokenType.NUMBER) {
             const nextVal = next?.value.toLowerCase();
             if (nextVal && ["feet", "foot", "ft"].includes(nextVal)) {
@@ -45,7 +52,7 @@ export function normalizeAltitude(tokens, opts) {
         if (isAltitude) {
             const numberToken = tokens[i + startOffset];
             const valNum = parseInt(numberToken.value, 10);
-            // Heuristic 1: Detect QNH/Altimeter disguised as Altitude
+            // Detect QNH/Altimeter disguised as Altitude
             // Condition: Keyword is "altitude", value is in altimeter range, and NOT a clean altitude
             const isAltimeterRange = (valNum >= 2800 && valNum <= 3100) || // inHg * 100 (e.g. 2992)
                 (valNum >= 960 && valNum <= 1070); // hPa (e.g. 1013)

package/dist/src/normalization/break.js

@@ -0,0 +1,20 @@
+import { TokenType } from "../types.js";
+const BREAK_EXCLUSIONS = new Set(["off", "out", "away"]);
+export function normalizeBreak(tokens, opts) {
+    if (!opts.keywords)
+        return tokens;
+    const output = [];
+    for (let i = 0; i < tokens.length; i++) {
+        const t = tokens[i];
+        const next = tokens[i + 1];
+        if (t.value.toLowerCase() === "break") {
+            const nextVal = next?.value.toLowerCase();
+            if (!nextVal || !BREAK_EXCLUSIONS.has(nextVal)) {
+                output.push({ value: "BREAK", raw: t.raw, type: TokenType.BREAK });
+                continue;
+            }
+        }
+        output.push(t);
+    }
+    return output;
+}

package/dist/src/normalization/callsigns.js

@@ -1,33 +1,74 @@
 import { TokenType } from "../types.js";
 import { KNOWN_AIRLINES } from "./airlines.js";
 const MAX_FLIGHT_ID_LENGTH = 6;
+const MAX_FLIGHT_NUMBER_DIGITS = 4;
+const lastHeardCallsigns = [];
+const MAX_TRACKED = 10;
+function trackCallsign(entry) {
+    // Deduplicate by full callsign
+    const idx = lastHeardCallsigns.findIndex((c) => c.full === entry.full);
+    if (idx !== -1)
+        lastHeardCallsigns.splice(idx, 1);
+    lastHeardCallsigns.unshift(entry);
+    if (lastHeardCallsigns.length > MAX_TRACKED)
+        lastHeardCallsigns.pop();
+}
+/** Exported for use in heading.ts or other normalizers if needed */
+export function getLastHeardCallsigns() {
+    return lastHeardCallsigns;
+}
 export function normalizeCallsigns(tokens, opts) {
     if (!opts.callsigns)
         return tokens;
     const output = [];
     for (let i = 0; i < tokens.length; i++) {
         const t = tokens[i];
-        const match = matchAirline(tokens, i);
-        if (match) {
-            const airlineName = match.name;
-            const airlineTokens = match.tokens;
-            let j = i + match.length;
+        // --- 1. Try GA callsign FIRST (more specific, needs 4+ tokens) ---
+        const gaMatch = matchGACallsign(tokens, i);
+        if (gaMatch) {
+            trackCallsign({
+                full: gaMatch.icao,
+                suffix: gaMatch.suffix,
+                raw: gaMatch.displayValue,
+            });
+            output.push({
+                value: gaMatch.displayValue,
+                raw: gaMatch.rawTokens.map((x) => x.raw).join(" "),
+                type: TokenType.CALLSIGN,
+            });
+            i += gaMatch.consumed - 1;
+            continue;
+        }
+        // --- 2. Try airline callsign ---
+        const airlineMatch = matchAirline(tokens, i);
+        if (airlineMatch) {
+            const airlineName = airlineMatch.name;
+            const airlineTokens = airlineMatch.tokens;
+            let j = i + airlineMatch.length;
             const flightNumTokens = [];
+            let idLength = 0;
             let letterCount = 0;
-            while (j < tokens.length &&
-                flightNumTokens.length < MAX_FLIGHT_ID_LENGTH) {
+            while (j < tokens.length && idLength < MAX_FLIGHT_ID_LENGTH) {
                 const next = tokens[j];
                 if (next.type === TokenType.NUMBER) {
+                    const currentDigits = flightNumTokens
+                        .filter((ft) => ft.type === TokenType.NUMBER)
+                        .reduce((acc, ft) => acc + ft.value.length, 0);
+                    if (currentDigits + next.value.length > MAX_FLIGHT_NUMBER_DIGITS)
+                        break;
+                    if (idLength + next.value.length > MAX_FLIGHT_ID_LENGTH)
+                        break;
                     flightNumTokens.push(next);
+                    idLength += next.value.length;
                     j++;
                 }
                 else if (next.type === TokenType.PHONETIC ||
-                    (next.type === TokenType.WORD && /^[a-zA-Z]$/.test(next.value))) {
-                    // Limit to max 2 consecutive letters
-                    if (letterCount >= 2) {
+                    (next.type === TokenType.WORD &&
+                        /^[a-zA-Z]$/.test(next.value))) {
+                    if (letterCount >= 2)
                         break;
-                    }
                     flightNumTokens.push(next);
+                    idLength++;
                     letterCount++;
                     j++;
                 }
@@ -38,14 +79,20 @@ export function normalizeCallsigns(tokens, opts) {
             if (flightNumTokens.length > 0) {
                 const idStr = flightNumTokens
                     .map((ft) => {
-                    if (ft.type === TokenType.PHONETIC && ft.metadata?.letter) {
+                    if (ft.type === TokenType.PHONETIC &&
+                        ft.metadata?.letter)
                         return ft.metadata.letter;
-                    }
                     return ft.value;
                 })
                     .join("");
+                const displayValue = `${airlineName} ${idStr}`;
+                const suffix = flightNumTokens
+                    .filter((ft) => ft.type === TokenType.PHONETIC && ft.metadata?.letter)
+                    .map((ft) => ft.metadata.letter)
+                    .join("");
+                trackCallsign({ full: displayValue, suffix, raw: displayValue });
                 output.push({
-                    value: `${airlineName} ${idStr}`,
+                    value: displayValue,
                     raw: [...airlineTokens, ...flightNumTokens]
                         .map((x) => x.raw)
                         .join(" "),
@@ -55,14 +102,148 @@ export function normalizeCallsigns(tokens, opts) {
                 continue;
             }
         }
+        // --- 3. Try abbreviated readback: suffix-only callsign (e.g. "Mike Sierra") ---
+        const abbrMatch = matchAbbreviatedCallsign(tokens, i);
+        if (abbrMatch) {
+            output.push({
+                value: abbrMatch.tracked.full,
+                raw: abbrMatch.rawTokens.map((x) => x.raw).join(" "),
+                type: TokenType.CALLSIGN,
+                metadata: {
+                    abbreviated: true,
+                    originalSuffix: abbrMatch.tracked.suffix,
+                },
+            });
+            i += abbrMatch.consumed - 1;
+            continue;
+        }
         output.push(t);
     }
     return output;
 }
+const MAX_ICAO_LENGTH = 6; // ICAO registrations are max 5-6 chars (e.g. N422MS, DBOBS, D-BOBS)
+function matchGACallsign(tokens, startIndex) {
+    const t = tokens[startIndex];
+    if (t.type !== TokenType.PHONETIC || !t.metadata?.letter)
+        return null;
+    let j = startIndex + 1;
+    const restTokens = [];
+    while (j < tokens.length && restTokens.length < 4) {
+        const next = tokens[j];
+        const isPhonetic = next.type === TokenType.PHONETIC && !!next.metadata?.letter;
+        const isNumber = next.type === TokenType.NUMBER;
+        if (!isPhonetic && !isNumber)
+            break;
+        // Check we won't exceed max ICAO length
+        const nextChars = isPhonetic ? 1 : next.value.length;
+        const currentLength = restTokens.reduce((acc, ct) => acc +
+            (ct.type === TokenType.PHONETIC ? 1 : ct.value.length), 1); // 1 for leading phonetic
+        if (currentLength + nextChars > MAX_ICAO_LENGTH)
+            break;
+        restTokens.push(next);
+        j++;
+    }
+    if (restTokens.length < 3)
+        return null;
+    const allTokens = [t, ...restTokens];
+    const icaoParts = allTokens.map((ct) => ct.type === TokenType.PHONETIC
+        ? ct.metadata.letter
+        : ct.value);
+    const icao = icaoParts.join("");
+    if (icao.length > MAX_ICAO_LENGTH)
+        return null; // hard stop
+    const letterCount = icao.replace(/[0-9]/g, "").length;
+    if (letterCount < 2)
+        return null;
+    const suffix = icaoParts
+        .filter((p) => /[A-Z]/.test(p))
+        .slice(-2)
+        .join("");
+    return {
+        icao,
+        suffix,
+        displayValue: icao,
+        rawTokens: allTokens,
+        consumed: allTokens.length,
+    };
+}
+function matchAbbreviatedCallsign(tokens, startIndex) {
+    if (lastHeardCallsigns.length === 0)
+        return null;
+    const t = tokens[startIndex];
+    const isNumber = t.type === TokenType.NUMBER;
+    const isPhonetic = t.type === TokenType.PHONETIC && !!t.metadata?.letter;
+    if (!isNumber && !isPhonetic)
+        return null;
+    // Greedily collect up to 4 consecutive NUMBER or PHONETIC tokens
+    const candidateTokens = [];
+    let j = startIndex;
+    while (j < tokens.length && candidateTokens.length < 4) {
+        const next = tokens[j];
+        const nextIsNumber = next.type === TokenType.NUMBER;
+        const nextIsPhonetic = next.type === TokenType.PHONETIC && !!next.metadata?.letter;
+        if (!nextIsNumber && !nextIsPhonetic)
+            break;
+        candidateTokens.push(next);
+        j++;
+    }
+    if (candidateTokens.length < 1)
+        return null;
+    // For a NUMBER token, generate all possible trailing substrings.
+    // e.g. "0902" → ["0902", "902", "02", "2"]
+    // For a PHONETIC token, it's just the single letter.
+    function tokenSuffixCandidates(ct) {
+        if (ct.type === TokenType.PHONETIC)
+            return [ct.metadata.letter];
+        const v = ct.value;
+        return Array.from({ length: v.length }, (_, i) => v.slice(i));
+    }
+    // Build all candidate suffix strings by combining token suffix candidates
+    // Try from the longest token slice down to 1 token
+    for (let len = candidateTokens.length; len >= 1; len--) {
+        const slice = candidateTokens.slice(0, len);
+        // Generate cartesian product of suffix candidates per token
+        const candidates = slice.reduce((acc, ct) => {
+            const parts = tokenSuffixCandidates(ct);
+            if (acc.length === 0)
+                return parts;
+            return acc.flatMap((prefix) => parts.map((part) => prefix + part));
+        }, []);
+        // Only consider candidates that are >= 3 chars
+        for (const candidateSuffix of candidates) {
+            if (candidateSuffix.length < 3)
+                continue;
+            const match = lastHeardCallsigns.find((c) => c.full.endsWith(candidateSuffix));
+            if (match) {
+                return { tracked: match, rawTokens: slice, consumed: len };
+            }
+        }
+    }
+    return null;
+}
+// --- Existing airline matcher ---
+// Words that are ATC instructions/keywords and should never be treated as airline names
+const AIRLINE_BLOCKLIST = new Set([
+    "approach",
+    "departure",
+    "tower",
+    "ground",
+    "center",
+    "centre",
+    "control",
+    "delivery",
+    "radar",
+    "director",
+    "information",
+    "radio",
+]);
 function matchAirline(tokens, startIndex) {
     if (startIndex + 1 < tokens.length) {
         const twoWords = `${tokens[startIndex].value} ${tokens[startIndex + 1].value}`.toLowerCase();
         if (KNOWN_AIRLINES.has(twoWords)) {
+            const firstWord = tokens[startIndex].value.toLowerCase();
+            if (AIRLINE_BLOCKLIST.has(firstWord))
+                return null;
             const niceName = twoWords
                 .split(" ")
                 .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
@@ -76,12 +257,10 @@ function matchAirline(tokens, startIndex) {
     }
     const oneWord = tokens[startIndex].value.toLowerCase();
     if (KNOWN_AIRLINES.has(oneWord)) {
+        if (AIRLINE_BLOCKLIST.has(oneWord))
+            return null;
         const niceName = oneWord.charAt(0).toUpperCase() + oneWord.slice(1);
-        return {
-            name: niceName,
-            length: 1,
-            tokens: [tokens[startIndex]],
-        };
+        return { name: niceName, length: 1, tokens: [tokens[startIndex]] };
     }
     return null;
 }