readback 0.0.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Boris Diakur
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/index.ts

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+
+import {Command} from 'commander';
+import {cleanTranscript} from '../src/cleaner.ts';
+import {startCapture} from '../src/capture.ts';
+import packageJson from "../package.json" with {type: "json"};
+
+const PREFIX = '📻'
+
+const program = new Command();
+program
+  .version(packageJson.version)
+  .description(`${PREFIX} ${packageJson.name}\n${packageJson.description}`)
+  .option('--raw', 'Disable all cleaning and formatting')
+  .option('--no-callsigns', 'Disable callsign detection and normalization')
+  .option('--no-phonetic', 'Disable phonetic formatting')
+  .option('--no-fl', 'Disable flight level abbreviation')
+  .option('--no-numbers', 'Disable number-word conversion')
+  .option('--no-runways', 'Disable runway formatting')
+  .option('--no-heading', 'Disable heading formatting')
+  .option('--no-speed', 'Disable speed formatting')
+  .option('--no-altitude', 'Disable altitude formatting')
+  .option('--no-keywords', 'Disable keyword highlighting')
+  .helpOption("-h, --help", "Display this help text")
+  .parse(process.argv);
+
+const opts = program.opts();
+
+startCapture(async (text: string) => {
+  const output = opts.raw
+    ? text
+    : cleanTranscript(text, {
+      callsigns: opts.callsigns,
+      phonetic: opts.phonetic,
+      fl: opts.fl,
+      numbers: opts.numbers,
+      runways: opts.runways,
+      heading: opts.runways,
+      speed: opts.speed,
+      altitude: opts.altitude,
+      keywords: opts.keywords
+    });
+
+  console.log('📻 ' + output);
+});

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "readback",
+  "version": "0.0.0-alpha.0",
+  "description": "Transcribes ATC transmissions into readable text.",
+  "keywords": [
+    "ATC",
+    "aviation"
+  ],
+  "homepage": "https://github.com/borisdiakur/readback#readme",
+  "bugs": {
+    "url": "https://github.com/borisdiakur/readback/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/borisdiakur/readback.git"
+  },
+  "license": "MIT",
+  "author": "Boris Diakur (https://borisdiakur.de)",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "readback": "./bin/index.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "node ./bin/index.ts"
+  },
+  "dependencies": {
+    "@ricky0123/vad-node": "^0.0.3",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "native-recorder-nodejs": "^1.2.0",
+    "wav": "^1.0.2"
+  },
+  "devDependencies": {
+    "@types/node": "^25.1.0",
+    "@types/wav": "^1.0.4",
+    "cmake-js": "^8.0.0"
+  },
+  "engines": {
+    "node": ">=22.18.0"
+  }
+}

package/src/altitude.ts

@@ -0,0 +1,52 @@
+import chalk from 'chalk';
+import {numberWordsToDigits} from './numbers.ts';
+
+export function normalizeAltitude(text: string): string {
+  return text.replace(
+    /\b(?:climb(?:\s+and\s+maintain)?|descend(?:\s+and\s+maintain)?|maintain|altitude)\s+([a-zA-Z0-9\s-]+)\b/gi,
+    (_, raw: string) => {
+      // Normalize number words first
+      const normalized = numberWordsToDigits(raw.toLowerCase()).replace(/-/g, ' ');
+      const tokens = normalized.split(/\s+/).filter(Boolean);
+
+      if (tokens.length === 0) return `altitude ${raw}`;
+
+      // Remove trailing "feet", "ft"
+      const cleanTokens = tokens.filter(t => !/^(feet|foot|ft)$/.test(t));
+
+      // Case 1: spoken digits ("1 8 0 0 0")
+      if (cleanTokens.every(t => /^\d$/.test(t)) && cleanTokens.length >= 2) {
+        const alt = cleanTokens.join('');
+        return chalk.yellow.bold(`${alt} ft`);
+      }
+
+      // Case 2: single number ("3000")
+      if (cleanTokens.length === 1 && /^\d{2,5}$/.test(cleanTokens[0])) {
+        return chalk.yellow.bold(`${cleanTokens[0]} ft`);
+      }
+
+      // Case 3: patterns like "3 1000" → 3000
+      if (
+        cleanTokens.length === 2 &&
+        /^\d+$/.test(cleanTokens[0]) &&
+        cleanTokens[1] === '1000'
+      ) {
+        const alt = parseInt(cleanTokens[0], 10) * 1000;
+        return chalk.yellow.bold(`${alt} ft`);
+      }
+
+      // Case 4: patterns like "2 500" → 2500
+      if (
+        cleanTokens.length === 2 &&
+        /^\d+$/.test(cleanTokens[0]) &&
+        /^\d+$/.test(cleanTokens[1])
+      ) {
+        const alt = parseInt(cleanTokens[0] + cleanTokens[1], 10);
+        return chalk.yellow.bold(`${alt} ft`);
+      }
+
+      // Fallback
+      return `altitude ${raw}`;
+    }
+  );
+}

package/src/callsigns.ts

@@ -0,0 +1,57 @@
+import chalk from 'chalk';
+import {numberWordsToDigits} from './numbers.ts';
+import {phoneticToLetter} from './phonetic.ts';
+
+// Spoken airline names
+const telephonyNames = [
+  'american', 'delta', 'united', 'southwest', 'alaska', 'jetblue', 'spirit', 'frontier',
+  'lufthansa', 'swiss', 'austrian', 'eurowings', 'air berlin', 'air france', 'klm',
+  'british airways', 'iberia', 'vueling', 'ryanair', 'easyjet', 'wizz', 'sas', 'finnair',
+  'tap', 'lot', 'condor', 'tui', 'norwegian', 'icelandair', 'ice air', 'play', 'qatar',
+  'emirates', 'etihad', 'turkish', 'saudia', 'singapore', 'cathay', 'ana', 'jal', 'qantas'
+];
+
+// Phonetic alphabet
+const phonetic = [
+  'alpha', 'bravo', 'charlie', 'delta', 'echo', 'foxtrot', 'golf', 'hotel', 'india',
+  'juliet', 'kilo', 'lima', 'mike', 'november', 'oscar', 'papa', 'quebec', 'romeo',
+  'sierra', 'tango', 'uniform', 'victor', 'whiskey', 'xray', 'x-ray', 'yankee', 'zulu'
+];
+
+export function detectAndNormalizeCallsign(text: string): string | null {
+  const words = text.toLowerCase().split(/\s+/);
+
+  // 1. TELEPHONY MODE
+  const telephony = telephonyNames.find(name => {
+    const parts = name.split(' ');
+    return chalk.green.bold(parts.every((p, i) => words[i] === p));
+  });
+
+  if (telephony) {
+    const telephonyParts = telephony.split(' ');
+    const rest = words.slice(telephonyParts.length);
+
+    const converted = rest
+      .map(w => phonetic.includes(w) ? phoneticToLetter(w) : numberWordsToDigits(w))
+      .join('');
+
+    const capitalized = telephony
+      .split(' ')
+      .map(w => w[0].toUpperCase() + w.slice(1))
+      .join(' ');
+
+    return chalk.green.bold(`${capitalized} ${converted}`);
+  }
+
+  // 2. PURE PHONETIC MODE
+  if (phonetic.includes(words[0])) {
+    const letters = words
+      .map(w => phonetic.includes(w) ? phoneticToLetter(w) : numberWordsToDigits(w))
+      .join('')
+      .toUpperCase();
+
+    return chalk.green.bold(letters);
+  }
+
+  return null;
+}

package/src/capture.ts

@@ -0,0 +1,211 @@
+import {AudioRecorder, SYSTEM_AUDIO_DEVICE_ID} from 'native-recorder-nodejs';
+import {spawn} from 'child_process';
+import {Writer} from 'wav';
+import fs from 'fs';
+import {NonRealTimeVAD} from '@ricky0123/vad-node';
+
+const WHISPER_BIN = process.env.WHISPER_BIN || '../whisper.cpp/build/bin/whisper-cli';
+const MODEL_PATH = process.env.MODEL_PATH || './ggml-whisper-atc.bin';
+
+export async function startCapture(onTranscript: (text: string) => void) {
+  if (!fs.existsSync(MODEL_PATH)) {
+    console.error(`⚡️ Model not found at: ${MODEL_PATH}`);
+    process.exit(1);
+  }
+
+  let seqNum = 0;
+  const results = new Map<number, string>();
+  let nextToPrint = 0;
+  const queue: Array<{ data: Buffer; seq: number }> = [];
+  let activeCount = 0;
+  const MAX_CONCURRENT = 4;
+
+  const audioState = {
+    buffer: [] as Buffer[],
+    size: 0,
+    utterance: [] as Buffer[],
+    utteranceSize: 0
+  };
+
+  const MIN_UTTERANCE_SIZE = 48000;
+  const WINDOW_SIZE = 96000;
+
+  const vad = await NonRealTimeVAD.new({
+    positiveSpeechThreshold: 0.3,
+    negativeSpeechThreshold: 0.15,
+    redemptionFrames: 10,
+    preSpeechPadFrames: 1
+  });
+
+  const systemRecorder = new AudioRecorder();
+  const outputs = AudioRecorder.getDevices('output');
+  const systemAudio =
+    outputs.find(d => d.id === SYSTEM_AUDIO_DEVICE_ID) ||
+    outputs.find(d => d.isDefault);
+
+  if (!systemAudio) {
+    throw new Error('Missing audio devices');
+  }
+
+  const permissions = AudioRecorder.checkPermission();
+  if (!permissions.system) AudioRecorder.requestPermission('system');
+  if (!permissions.mic) AudioRecorder.requestPermission('mic');
+
+  systemRecorder.on('data', async (chunk: Buffer) => {
+    await processAudioChunk(chunk);
+  });
+
+  systemRecorder.on('error', (err) => {
+    console.error('⚡️ System recorder error:', err);
+  });
+
+  process.on('SIGINT', async () => {
+    console.log('\nStopping...');
+    await systemRecorder.stop();
+    process.exit(0);
+  });
+
+  await systemRecorder.start({
+    deviceType: 'output',
+    deviceId: systemAudio.id
+  });
+
+  console.info('🗼 Capturing system audio...');
+
+  // -----------------------------
+  // Internal helper functions
+  // -----------------------------
+
+  async function processAudioChunk(chunk: Buffer) {
+    const state = audioState;
+    state.buffer.push(chunk);
+    state.size += chunk.length;
+
+    while (state.size >= WINDOW_SIZE) {
+      const windowChunk = Buffer.concat(
+        state.buffer.splice(0, Math.ceil(WINDOW_SIZE / state.buffer[0].length))
+      );
+      state.size -= windowChunk.length;
+
+      const mono = stereoToMono(windowChunk);
+      const resampled = resample48to16(mono);
+      const float32 = bufferToFloat32(resampled);
+
+      let hasSpeech = false;
+      for await (const _ of vad.run(float32, 16000)) {
+        hasSpeech = true;
+        break;
+      }
+
+      if (hasSpeech) {
+        state.utterance.push(windowChunk);
+        state.utteranceSize += windowChunk.length;
+      } else if (state.utterance.length > 0) {
+        state.utterance.push(windowChunk);
+        state.utteranceSize += windowChunk.length;
+
+        if (state.utteranceSize >= MIN_UTTERANCE_SIZE) {
+          const utterance = Buffer.concat(state.utterance);
+          queue.push({data: utterance, seq: seqNum++});
+          processNext();
+        }
+
+        state.utterance = [];
+        state.utteranceSize = 0;
+      }
+    }
+  }
+
+  function processNext() {
+    while (activeCount < MAX_CONCURRENT && queue.length > 0) {
+      const item = queue.shift()!;
+      activeCount++;
+      transcribe(item.data, item.seq);
+    }
+  }
+
+  function transcribe(pcmData: Buffer, seq: number) {
+    const wavFile = `./tmp/temp-${seq}.wav`;
+
+    const writer = new Writer({
+      sampleRate: 48000,
+      channels: 2,
+      bitDepth: 16
+    });
+
+    const wavStream = fs.createWriteStream(wavFile);
+    writer.pipe(wavStream);
+    writer.write(pcmData);
+    writer.end();
+
+    wavStream.on('finish', () => {
+      const whisper = spawn(WHISPER_BIN, [
+        '-m', MODEL_PATH,
+        '-f', wavFile,
+        '--best-of', '5',
+        '--prompt', 'Air traffic control radio communication',
+        '--no-timestamps',
+        '--language', 'en'
+      ]);
+
+      let output = '';
+      whisper.stdout.on('data', (data) => output += data);
+      whisper.stderr.on('data', () => {
+      });
+
+      whisper.on('close', () => {
+        results.set(seq, output.trim());
+        fs.unlink(wavFile, () => {
+        });
+        activeCount--;
+        processNext();
+        flushOrdered();
+      });
+    });
+  }
+
+  function flushOrdered() {
+    while (results.has(nextToPrint)) {
+      const text = results.get(nextToPrint)!;
+      results.delete(nextToPrint);
+      nextToPrint++;
+
+      // Send raw text to the CLI layer
+      onTranscript(text);
+    }
+  }
+}
+
+// -----------------------------
+// Audio helpers
+// -----------------------------
+
+function stereoToMono(stereo: Buffer): Buffer {
+  const mono = Buffer.alloc(stereo.length / 2);
+  for (let i = 0; i < mono.length / 2; i++) {
+    const left = stereo.readInt16LE(i * 4);
+    const right = stereo.readInt16LE(i * 4 + 2);
+    mono.writeInt16LE(Math.round((left + right) / 2), i * 2);
+  }
+  return mono;
+}
+
+function resample48to16(pcm48k: Buffer): Buffer {
+  const samples = pcm48k.length / 2;
+  const pcm16k = Buffer.alloc(Math.floor(samples / 3) * 2);
+
+  for (let i = 0; i < pcm16k.length / 2; i++) {
+    const val = pcm48k.readInt16LE(i * 3 * 2);
+    pcm16k.writeInt16LE(val, i * 2);
+  }
+  return pcm16k;
+}
+
+function bufferToFloat32(buffer: Buffer): Float32Array {
+  const float32 = new Float32Array(buffer.length / 2);
+  for (let i = 0; i < float32.length; i++) {
+    const int16 = buffer.readInt16LE(i * 2);
+    float32[i] = int16 / 32768.0;
+  }
+  return float32;
+}

package/src/cleaner.ts

@@ -0,0 +1,88 @@
+import chalk from 'chalk';
+import {numberWordsToDigits} from './numbers.ts';
+import {abbreviateFlightLevel} from './flightlevel.ts';
+import {formatPhoneticWord} from './phonetic.ts';
+import {detectAndNormalizeCallsign} from './callsigns.ts';
+import {normalizeRunways} from './runway.ts';
+import {normalizeHeadings} from './heading.ts';
+import {normalizeSpeed} from "./speed.ts";
+import {normalizeAltitude} from "./altitude.ts";
+import {highlightKeywords} from './keywords.ts';
+
+export function cleanTranscript(
+  text: string,
+  opts: {
+    callsigns: boolean;
+    phonetic: boolean;
+    fl: boolean;
+    numbers: boolean;
+    runways: boolean;
+    heading: boolean;
+    speed: boolean;
+    altitude: boolean;
+    keywords: boolean;
+  }
+) {
+  let out = text.trim();
+
+  // Normalize whitespace early
+  out = out.replace(/\s+/g, ' ');
+
+  let normalizedCallsign: string | null = null;
+
+  if (opts.callsigns) {
+    normalizedCallsign = detectAndNormalizeCallsign(out);
+    if (normalizedCallsign) {
+      // Highlight callsign
+      const highlighted = chalk.green.bold(normalizedCallsign);
+
+      // Replace only the callsign portion
+      // (We assume callsign is at the beginning of the utterance)
+      const firstWords = out.split(' ').slice(0, normalizedCallsign.split(' ').length).join(' ');
+      out = out.replace(firstWords, highlighted);
+    }
+  }
+
+  if (opts.numbers) {
+    out = numberWordsToDigits(out);
+  }
+
+  if (opts.fl) {
+    out = abbreviateFlightLevel(out);
+  }
+
+  if (opts.runways) {
+    out = normalizeRunways(out);
+  }
+
+  if (opts.heading) {
+    out = normalizeHeadings(out);
+  }
+
+  if (opts.speed) {
+    out = normalizeSpeed(out);
+  }
+
+  if (opts.altitude) {
+    out = normalizeAltitude(out);
+  }
+
+  if (opts.keywords) {
+    out = highlightKeywords(out);
+  }
+
+  if (opts.phonetic) {
+    out = out.replace(
+      /\b(alpha|bravo|charlie|delta|echo|foxtrot|golf|hotel|india|juliet|kilo|lima|mike|november|oscar|papa|quebec|romeo|sierra|tango|uniform|victor|whiskey|xray|x-ray|yankee|zulu)\b/gi,
+      (match) => {
+        // If this phonetic word is part of the callsign, skip formatting
+        if (normalizedCallsign && normalizedCallsign.toLowerCase().includes(match.toLowerCase())) {
+          return match;
+        }
+        return formatPhoneticWord(match);
+      }
+    );
+  }
+
+  return out;
+}

package/src/flightlevel.ts

@@ -0,0 +1,35 @@
+import chalk from 'chalk';
+import {numberWordsToDigits} from './numbers.ts';
+
+export function abbreviateFlightLevel(text: string): string {
+  return text.replace(/\bflight level ([a-zA-Z0-9\s-]+)\b/gi, (_, rawPart: string) => {
+    // Normalize number words first
+    const normalized = numberWordsToDigits(rawPart.toLowerCase()).replace(/-/g, ' ');
+    const tokens = normalized.split(/\s+/).filter(Boolean);
+
+    let fl: number | null = null;
+
+    // Case 1: spoken digits: "1 8 0" → 180
+    if (tokens.length >= 2 && tokens.length <= 3 && tokens.every(t => /^\d$/.test(t))) {
+      fl = parseInt(tokens.join(''), 10);
+    }
+
+    // Case 2: "180"
+    if (fl === null && tokens.length === 1 && /^\d{2,3}$/.test(tokens[0])) {
+      fl = parseInt(tokens[0], 10);
+    }
+
+    // Case 3: "two hundred" → 200
+    if (fl === null && tokens.length === 2 && /^\d+$/.test(tokens[0]) && tokens[1] === '100') {
+      fl = parseInt(tokens[0], 10) * 100;
+    }
+
+    // Fallback
+    if (fl === null || isNaN(fl)) {
+      return `flight level ${rawPart}`;
+    }
+
+    // Apply color
+    return chalk.yellow.bold(`FL${fl}`);
+  });
+}

package/src/heading.ts

@@ -0,0 +1,39 @@
+import chalk from 'chalk';
+import {numberWordsToDigits} from './numbers.ts';
+
+export function normalizeHeadings(text: string): string {
+  return text.replace(
+    /\b(?:turn\s+(?:left|right)\s+)?(?:fly\s+)?heading\s+([a-zA-Z0-9\s-]+?)(?:\s+degrees?)?\b/gi,
+    (_, raw: string) => {
+      const normalized = numberWordsToDigits(raw.toLowerCase()).replace(/-/g, ' ');
+      const tokens = normalized.split(/\s+/).filter(Boolean);
+
+      if (tokens.length === 0) return `heading ${raw}`;
+
+      // Case 1: spoken digits
+      if (tokens.every(t => /^\d$/.test(t)) && tokens.length <= 3) {
+        const hdg = tokens.join('');
+        return chalk.magenta.bold(`HDG ${padHeading(hdg)}`);
+      }
+
+      // Case 2: single number
+      if (tokens.length === 1 && /^\d{1,3}$/.test(tokens[0])) {
+        return chalk.magenta.bold(`HDG ${padHeading(tokens[0])}`);
+      }
+
+      // Case 3: "two hundred"
+      if (tokens.length === 2 && /^\d+$/.test(tokens[0]) && tokens[1] === '100') {
+        const hdg = parseInt(tokens[0], 10) * 100;
+        return chalk.magenta.bold(`HDG ${padHeading(hdg.toString())}`);
+      }
+
+      return `heading ${raw}`;
+    }
+  );
+}
+
+function padHeading(hdg: string): string {
+  const n = parseInt(hdg, 10);
+  if (isNaN(n)) return hdg;
+  return n.toString().padStart(3, '0');
+}

package/src/keywords.ts

@@ -0,0 +1,32 @@
+import chalk from 'chalk';
+
+const keywordList = [
+  // Clearances
+  'cleared', 'clearance',
+
+  // Vertical
+  'climb', 'descend', 'maintain', 'level', 'altitude',
+
+  // Lateral
+  'turn', 'heading', 'direct', 'proceed',
+
+  // Ground
+  'taxi', 'hold short', 'cross', 'line up', 'runway',
+
+  // Comms
+  'contact', 'monitor', 'switch', 'frequency',
+
+  // Misc
+  'squawk', 'ident', 'report', 'traffic'
+];
+
+export function highlightKeywords(text: string): string {
+  let out = text;
+
+  for (const kw of keywordList) {
+    const regex = new RegExp(`\\b${kw}\\b`, 'gi');
+    out = out.replace(regex, match => chalk.hex('#FF8C00').bold(match));
+  }
+
+  return out;
+}

package/src/numbers.ts

@@ -0,0 +1,17 @@
+const map: Record<string, number> = {
+  zero: 0, one: 1, two: 2, three: 3, four: 4,
+  five: 5, six: 6, seven: 7, eight: 8, nine: 9,
+  ten: 10, eleven: 11, twelve: 12, thirteen: 13,
+  fourteen: 14, fifteen: 15, sixteen: 16,
+  seventeen: 17, eighteen: 18, nineteen: 19,
+  twenty: 20, thirty: 30, forty: 40, fifty: 50,
+  sixty: 60, seventy: 70, eighty: 80, ninety: 90,
+  hundred: 100, thousand: 1000
+};
+
+export function numberWordsToDigits(text: string): string {
+  return text.replace(
+    /\b(zero|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|thirteen|fourteen|fifteen|sixteen|seventeen|eighteen|nineteen|twenty|thirty|forty|fifty|sixty|seventy|eighty|ninety|hundred|thousand)\b/gi,
+    (m) => map[m.toLowerCase()].toString()
+  );
+}

package/src/phonetic.ts

@@ -0,0 +1,49 @@
+import chalk from 'chalk';
+
+export function formatPhoneticWord(word: string): string {
+  const idx = word.search(/[a-zA-Z]/);
+  if (idx === -1) return chalk.cyan.dim(word);
+
+  const before = word.slice(0, idx);
+  const first = word[idx].toUpperCase();
+  const rest = word.slice(idx + 1).toLowerCase();
+
+  return (
+    before +
+    chalk.cyan.bold(first) +
+    chalk.cyan.dim(rest)
+  );
+}
+
+export function phoneticToLetter(word: string): string {
+  const map: Record<string, string> = {
+    alpha: 'A',
+    bravo: 'B',
+    charlie: 'C',
+    delta: 'D',
+    echo: 'E',
+    foxtrot: 'F',
+    golf: 'G',
+    hotel: 'H',
+    india: 'I',
+    juliet: 'J',
+    kilo: 'K',
+    lima: 'L',
+    mike: 'M',
+    november: 'N',
+    oscar: 'O',
+    papa: 'P',
+    quebec: 'Q',
+    romeo: 'R',
+    sierra: 'S',
+    tango: 'T',
+    uniform: 'U',
+    victor: 'V',
+    whiskey: 'W',
+    'xray': 'X',
+    'x-ray': 'X',
+    yankee: 'Y',
+    zulu: 'Z'
+  };
+  return map[word.toLowerCase()] ?? word;
+}

package/src/runway.ts

@@ -0,0 +1,37 @@
+import chalk from 'chalk';
+import {numberWordsToDigits} from './numbers.ts';
+
+const sideMap: Record<string, string> = {
+  left: 'L',
+  right: 'R',
+  center: 'C',
+  centre: 'C'
+};
+
+export function normalizeRunways(text: string): string {
+  return text.replace(/\brunway ([a-zA-Z0-9\s-]+)\b/gi, (_, raw: string) => {
+    const normalized = numberWordsToDigits(raw.toLowerCase()).replace(/-/g, ' ');
+    const tokens = normalized.split(/\s+/).filter(Boolean);
+
+    if (tokens.length === 0) return `runway ${raw}`;
+
+    const numTokens: string[] = [];
+    const restTokens: string[] = [];
+
+    for (const t of tokens) {
+      if (/^\d+$/.test(t) && numTokens.length < 2) {
+        numTokens.push(t);
+      } else {
+        restTokens.push(t);
+      }
+    }
+
+    if (numTokens.length === 0) return `runway ${raw}`;
+
+    const runwayNumber = numTokens.join('');
+    const sideToken = restTokens[0];
+    const side = sideToken ? sideMap[sideToken] ?? '' : '';
+
+    return chalk.blue.bold(`RWY ${runwayNumber}${side}`);
+  });
+}

package/src/speed.ts

@@ -0,0 +1,39 @@
+import chalk from 'chalk';
+import {numberWordsToDigits} from './numbers.ts';
+
+export function normalizeSpeed(text: string): string {
+  return text.replace(
+    /\b(?:reduce|increase|maintain|adjust)?\s*speed\s+(?:to\s+)?([a-zA-Z0-9\s-]+?)(?:\s+knots?|\s+kts?|\s+kt)?\b/gi,
+    (_, raw: string) => {
+      // Normalize number words first
+      const normalized = numberWordsToDigits(raw.toLowerCase()).replace(/-/g, ' ');
+      const tokens = normalized.split(/\s+/).filter(Boolean);
+
+      if (tokens.length === 0) return `speed ${raw}`;
+
+      // Case 1: spoken digits ("2 5 0")
+      if (tokens.every(t => /^\d$/.test(t)) && tokens.length <= 3) {
+        const spd = tokens.join('');
+        return chalk.redBright.bold(`SPD ${spd}`);
+      }
+
+      // Case 2: single number ("250")
+      if (tokens.length === 1 && /^\d{1,3}$/.test(tokens[0])) {
+        return chalk.redBright.bold(`SPD ${tokens[0]}`);
+      }
+
+      // Case 3: "one hundred eighty" → 180
+      if (
+        tokens.length === 2 &&
+        /^\d+$/.test(tokens[0]) &&
+        tokens[1] === '100'
+      ) {
+        const spd = parseInt(tokens[0], 10) * 100;
+        return chalk.redBright.bold(`SPD ${spd}`);
+      }
+
+      // Fallback
+      return `speed ${raw}`;
+    }
+  );
+}