@e04/ft8ts 0.0.3 → 0.0.8

package/dist/{ft8js.cjs → cli.js}

@@ -1,10 +1,12 @@
-'use strict';
+#!/usr/bin/env node
+import { writeFileSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
 
-const SAMPLE_RATE = 12_000;
+const SAMPLE_RATE$1 = 12_000;
 const NSPS = 1920;
 const NFFT1 = 2 * NSPS; // 3840
 const NSTEP = NSPS / 4; // 480
-const NMAX = 15 * SAMPLE_RATE; // 180000
+const NMAX = 15 * SAMPLE_RATE$1; // 180000
 const NHSYM = Math.floor(NMAX / NSTEP) - 3; // 372
 const NDOWN = 60;
 const NN = 79;
@@ -568,6 +570,10 @@ function fftComplex(re, im, inverse) {
     const n = re.length;
     if (n <= 1)
         return;
+    if ((n & (n - 1)) !== 0) {
+        bluestein(re, im, inverse);
+        return;
+    }
     // Bit-reversal permutation
     let j = 0;
     for (let i = 0; i < n; i++) {
@@ -586,7 +592,7 @@ function fftComplex(re, im, inverse) {
         }
         j += m;
     }
-    const sign = -1;
+    const sign = inverse ? 1 : -1;
     for (let size = 2; size <= n; size <<= 1) {
         const halfsize = size >> 1;
         const step = (sign * Math.PI) / halfsize;
@@ -610,6 +616,53 @@ function fftComplex(re, im, inverse) {
             }
         }
     }
+    if (inverse) {
+        for (let i = 0; i < n; i++) {
+            re[i] /= n;
+            im[i] /= n;
+        }
+    }
+}
+function bluestein(re, im, inverse) {
+    const n = re.length;
+    const m = nextPow2(n * 2 - 1);
+    const s = inverse ? 1 : -1;
+    const aRe = new Float64Array(m);
+    const aIm = new Float64Array(m);
+    const bRe = new Float64Array(m);
+    const bIm = new Float64Array(m);
+    for (let i = 0; i < n; i++) {
+        const angle = (s * Math.PI * ((i * i) % (2 * n))) / n;
+        const cosA = Math.cos(angle);
+        const sinA = Math.sin(angle);
+        aRe[i] = re[i] * cosA - im[i] * sinA;
+        aIm[i] = re[i] * sinA + im[i] * cosA;
+        bRe[i] = cosA;
+        bIm[i] = -sinA;
+    }
+    for (let i = 1; i < n; i++) {
+        bRe[m - i] = bRe[i];
+        bIm[m - i] = bIm[i];
+    }
+    fftComplex(aRe, aIm, false);
+    fftComplex(bRe, bIm, false);
+    for (let i = 0; i < m; i++) {
+        const r = aRe[i] * bRe[i] - aIm[i] * bIm[i];
+        const iIm = aRe[i] * bIm[i] + aIm[i] * bRe[i];
+        aRe[i] = r;
+        aIm[i] = iIm;
+    }
+    fftComplex(aRe, aIm, true);
+    const scale = inverse ? 1 / n : 1;
+    for (let i = 0; i < n; i++) {
+        const angle = (s * Math.PI * ((i * i) % (2 * n))) / n;
+        const cosA = Math.cos(angle);
+        const sinA = Math.sin(angle);
+        const r = aRe[i] * cosA - aIm[i] * sinA;
+        const iIm = aRe[i] * sinA + aIm[i] * cosA;
+        re[i] = r * scale;
+        im[i] = iIm * scale;
+    }
 }
 /** Next power of 2 >= n */
 function nextPow2(n) {
@@ -635,7 +688,7 @@ function bitsToUint(bits, start, len) {
     }
     return val;
 }
-function unpack28(n28) {
+function unpack28(n28, book) {
     if (n28 < 0 || n28 >= 268435456)
         return { call: "", success: false };
     if (n28 === 0)
@@ -649,7 +702,6 @@ function unpack28(n28) {
         return { call: `CQ ${nqsy.toString().padStart(3, "0")}`, success: true };
     }
     if (n28 >= 1003 && n28 < NTOKENS) {
-        // CQ with 4-letter directed call
         let m = n28 - 1003;
         let chars = "";
         for (let i = 3; i >= 0; i--) {
@@ -663,7 +715,10 @@ function unpack28(n28) {
         return { call: "CQ", success: true };
     }
     if (n28 >= NTOKENS && n28 < NTOKENS + MAX22) {
-        // Hashed call – we don't have a hash table, so show <...>
+        const n22 = n28 - NTOKENS;
+        const resolved = book?.lookup22(n22);
+        if (resolved)
+            return { call: `<${resolved}>`, success: true };
         return { call: "<...>", success: true };
     }
     // Standard callsign
@@ -743,8 +798,11 @@ function unpackText77(bits71) {
 }
 /**
  * Unpack a 77-bit FT8 message into a human-readable string.
+ *
+ * When a {@link HashCallBook} is provided, hashed callsigns are resolved from
+ * the book, and newly decoded standard callsigns are saved into it.
  */
-function unpack77(bits77) {
+function unpack77(bits77, book) {
     const n3 = bitsToUint(bits77, 71, 3);
     const i3 = bitsToUint(bits77, 74, 3);
     if (i3 === 0 && n3 === 0) {
@@ -762,8 +820,8 @@ function unpack77(bits77) {
         const ipb = bits77[57];
         const ir = bits77[58];
         const igrid4 = bitsToUint(bits77, 59, 15);
-        const { call: call1, success: ok1 } = unpack28(n28a);
-        const { call: call2Raw, success: ok2 } = unpack28(n28b);
+        const { call: call1, success: ok1 } = unpack28(n28a, book);
+        const { call: call2Raw, success: ok2 } = unpack28(n28b, book);
         if (!ok1 || !ok2)
             return { msg: "", success: false };
         let c1 = call1;
@@ -781,6 +839,9 @@ function unpack77(bits77) {
                 c2 += "/R";
             if (ipb === 1 && i3 === 2 && c2.length >= 3)
                 c2 += "/P";
+            // Save the "from" call (call_2) into the hash book
+            if (book && c2.length >= 3)
+                book.save(c2);
         }
         if (igrid4 <= MAXGRID4) {
             const { grid, success: gridOk } = toGrid4(igrid4);
@@ -813,6 +874,7 @@ function unpack77(bits77) {
     }
     if (i3 === 4) {
         // Type 4: One nonstandard call
+        const n12 = bitsToUint(bits77, 0, 12);
         let n58 = 0n;
         for (let i = 0; i < 58; i++) {
             n58 = n58 * 2n + BigInt(bits77[12 + i] ?? 0);
@@ -820,7 +882,6 @@ function unpack77(bits77) {
         const iflip = bits77[70];
         const nrpt = bitsToUint(bits77, 71, 2);
         const icq = bits77[73];
-        // Decode n58 to 11-char string using C38 alphabet
         const c11chars = [];
         let remain = n58;
         for (let i = 10; i >= 0; i--) {
@@ -829,12 +890,15 @@ function unpack77(bits77) {
             c11chars.unshift(C38[j] ?? " ");
         }
         const c11 = c11chars.join("").trim();
-        const call3 = "<...>"; // We don't have a hash table for n12
+        const resolved = book?.lookup12(n12);
+        const call3 = resolved ? `<${resolved}>` : "<...>";
         let call1;
         let call2;
         if (iflip === 0) {
             call1 = call3;
             call2 = c11;
+            if (book)
+                book.save(c11);
         }
         else {
             call1 = c11;
@@ -863,29 +927,39 @@ function unpack77(bits77) {
  * Decode all FT8 signals in an audio buffer.
  * Input: mono audio samples at `sampleRate` Hz, duration ~15s.
  */
-function decode(samples, sampleRate = SAMPLE_RATE, options = {}) {
+function decode(samples, options = {}) {
+    const sampleRate = options.sampleRate ?? SAMPLE_RATE$1;
     const nfa = options.freqLow ?? 200;
     const nfb = options.freqHigh ?? 3000;
     const syncmin = options.syncMin ?? 1.2;
     const depth = options.depth ?? 2;
     const maxCandidates = options.maxCandidates ?? 300;
+    const book = options.hashCallBook;
     // Resample to 12000 Hz if needed
     let dd;
-    if (sampleRate === SAMPLE_RATE) {
+    if (sampleRate === SAMPLE_RATE$1) {
         dd = new Float64Array(NMAX);
         const len = Math.min(samples.length, NMAX);
         for (let i = 0; i < len; i++)
             dd[i] = samples[i];
     }
     else {
-        dd = resample(samples, sampleRate, SAMPLE_RATE, NMAX);
+        dd = resample(samples, sampleRate, SAMPLE_RATE$1, NMAX);
+    }
+    // Compute huge FFT for downsampling caching
+    const NFFT1_LONG = 192000;
+    const cxRe = new Float64Array(NFFT1_LONG);
+    const cxIm = new Float64Array(NFFT1_LONG);
+    for (let i = 0; i < NMAX; i++) {
+        cxRe[i] = dd[i] ?? 0;
     }
+    fftComplex(cxRe, cxIm, false);
     // Compute spectrogram and find sync candidates
     const { candidates, sbase } = sync8(dd, nfa, nfb, syncmin, maxCandidates);
     const decoded = [];
     const seenMessages = new Set();
     for (const cand of candidates) {
-        const result = ft8b(dd, cand.freq, cand.dt, sbase, depth);
+        const result = ft8b(dd, cxRe, cxIm, cand.freq, cand.dt, sbase, depth, book);
         if (!result)
             continue;
         if (seenMessages.has(result.msg))
@@ -906,8 +980,8 @@ function sync8(dd, nfa, nfb, syncmin, maxcand) {
     // Fortran uses NFFT1=3840 for the spectrogram FFT; we need a power of 2
     const fftSize = nextPow2(NFFT1); // 4096
     const halfSize = fftSize / 2; // 2048
-    const tstep = NSTEP / SAMPLE_RATE;
-    const df = SAMPLE_RATE / fftSize;
+    const tstep = NSTEP / SAMPLE_RATE$1;
+    const df = SAMPLE_RATE$1 / fftSize;
     const fac = 1.0 / 300.0;
     // Compute symbol spectra, stepping by NSTEP
     const s = new Float64Array(halfSize * NHSYM);
@@ -921,7 +995,7 @@ function sync8(dd, nfa, nfb, syncmin, maxcand) {
         for (let i = 0; i < NSPS && ia + i < dd.length; i++) {
             xRe[i] = fac * dd[ia + i];
         }
-        fftComplex(xRe, xIm);
+        fftComplex(xRe, xIm, false);
         for (let i = 0; i < halfSize; i++) {
             const power = xRe[i] * xRe[i] + xIm[i] * xIm[i];
             s[i * NHSYM + j] = power;
@@ -933,7 +1007,7 @@ function sync8(dd, nfa, nfb, syncmin, maxcand) {
     const ia = Math.max(1, Math.round(nfa / df));
     const ib = Math.min(halfSize - 14, Math.round(nfb / df));
     const nssy = Math.floor(NSPS / NSTEP);
-    const nfos = Math.round(SAMPLE_RATE / NSPS / df); // ~2 bins per tone spacing
+    const nfos = Math.round(SAMPLE_RATE$1 / NSPS / df); // ~2 bins per tone spacing
     const jstrt = Math.round(0.5 / tstep);
     // 2D sync correlation
     const sync2d = new Float64Array((ib - ia + 1) * (2 * JZ + 1));
@@ -1069,17 +1143,16 @@ function computeBaseline(savg, nfa, nfb, df, nh1) {
     }
     return sbase;
 }
-function ft8b(dd0, f1, xdt, _sbase, depth) {
+function ft8b(_dd0, cxRe, cxIm, f1, xdt, _sbase, depth, book) {
     const NFFT2 = 3200;
     const NP2 = 2812;
-    const NFFT1_LONG = 192000;
-    const fs2 = SAMPLE_RATE / NDOWN;
+    const fs2 = SAMPLE_RATE$1 / NDOWN;
     const dt2 = 1.0 / fs2;
     const twopi = 2 * Math.PI;
     // Downsample: mix to baseband and filter
     const cd0Re = new Float64Array(NFFT2);
     const cd0Im = new Float64Array(NFFT2);
-    ft8Downsample(dd0, f1, cd0Re, cd0Im, NFFT1_LONG, NFFT2);
+    ft8Downsample(cxRe, cxIm, f1, cd0Re, cd0Im);
     // Find best time offset
     const i0 = Math.round((xdt + 0.5) * fs2);
     let smax = 0;
@@ -1113,7 +1186,7 @@ function ft8b(dd0, f1, xdt, _sbase, depth) {
     }
     // Apply frequency correction and re-downsample
     f1 += delfbest;
-    ft8Downsample(dd0, f1, cd0Re, cd0Im, NFFT1_LONG, NFFT2);
+    ft8Downsample(cxRe, cxIm, f1, cd0Re, cd0Im);
     // Refine time offset
     const ss = new Float64Array(9);
     for (let idt = -4; idt <= 4; idt++) {
@@ -1145,7 +1218,7 @@ function ft8b(dd0, f1, xdt, _sbase, depth) {
                 symbIm[j] = cd0Im[i1 + j];
             }
         }
-        fftComplex(symbRe, symbIm);
+        fftComplex(symbRe, symbIm, false);
         for (let tone = 0; tone < 8; tone++) {
             const re = symbRe[tone] / 1000;
             const im = symbIm[tone] / 1000;
@@ -1278,7 +1351,7 @@ function ft8b(dd0, f1, xdt, _sbase, depth) {
     if (i3v === 0 && n3v === 2)
         return null;
     // Unpack
-    const { msg, success } = unpack77(message77);
+    const { msg, success } = unpack77(message77, book);
     if (!success || msg.trim().length === 0)
         return null;
     // Estimate SNR
@@ -1319,44 +1392,75 @@ function getTones$1(cw) {
     return tones;
 }
 /**
- * Mix f0 to baseband and decimate by NDOWN (60x).
- * Time-domain approach: mix down, low-pass filter via moving average, decimate.
- * Output: complex baseband signal at 200 Hz sample rate (32 samples/symbol).
+ * Mix f0 to baseband and decimate by NDOWN (60x) by extracting frequency bins.
+ * Identical to Fortran ft8_downsample.
  */
-function ft8Downsample(dd, f0, outRe, outIm, _nfft1Long, nfft2) {
-    const twopi = 2 * Math.PI;
-    const len = Math.min(dd.length, NMAX);
-    const dphi = (twopi * f0) / SAMPLE_RATE;
-    // Mix to baseband
-    const mixRe = new Float64Array(len);
-    const mixIm = new Float64Array(len);
-    let phi = 0;
-    for (let i = 0; i < len; i++) {
-        mixRe[i] = dd[i] * Math.cos(phi);
-        mixIm[i] = -dd[i] * Math.sin(phi);
-        phi += dphi;
-        if (phi > twopi)
-            phi -= twopi;
-    }
-    // Low-pass filter: simple moving-average with window = NDOWN
-    // then decimate by NDOWN to get 200 Hz sample rate
-    const outLen = Math.min(nfft2, Math.floor(len / NDOWN));
-    outRe.fill(0);
-    outIm.fill(0);
-    // Running sum filter
-    const halfWin = NDOWN >> 1;
-    for (let k = 0; k < outLen; k++) {
-        const center = k * NDOWN + halfWin;
-        let sumRe = 0, sumIm = 0;
-        const start = Math.max(0, center - halfWin);
-        const end = Math.min(len, center + halfWin);
-        for (let j = start; j < end; j++) {
-            sumRe += mixRe[j];
-            sumIm += mixIm[j];
-        }
-        const n = end - start;
-        outRe[k] = sumRe / n;
-        outIm[k] = sumIm / n;
+function ft8Downsample(cxRe, cxIm, f0, c1Re, c1Im) {
+    const NFFT1 = 192000;
+    const NFFT2 = 3200;
+    const df = 12000.0 / NFFT1;
+    // NSPS is imported, should be 1920
+    const baud = 12000.0 / NSPS; // 6.25
+    const i0 = Math.round(f0 / df);
+    const ft = f0 + 8.5 * baud;
+    const it = Math.min(Math.round(ft / df), NFFT1 / 2);
+    const fb = f0 - 1.5 * baud;
+    const ib = Math.max(1, Math.round(fb / df));
+    c1Re.fill(0);
+    c1Im.fill(0);
+    let k = 0;
+    for (let i = ib; i <= it; i++) {
+        if (k >= NFFT2)
+            break;
+        c1Re[k] = cxRe[i] ?? 0;
+        c1Im[k] = cxIm[i] ?? 0;
+        k++;
+    }
+    // Taper
+    const pi = Math.PI;
+    const taper = new Float64Array(101);
+    for (let i = 0; i <= 100; i++) {
+        taper[i] = 0.5 * (1.0 + Math.cos((i * pi) / 100));
+    }
+    for (let i = 0; i <= 100; i++) {
+        if (i >= NFFT2)
+            break;
+        const tap = taper[100 - i];
+        c1Re[i] = c1Re[i] * tap;
+        c1Im[i] = c1Im[i] * tap;
+    }
+    const endTap = k - 1;
+    for (let i = 0; i <= 100; i++) {
+        const idx = endTap - 100 + i;
+        if (idx >= 0 && idx < NFFT2) {
+            const tap = taper[i];
+            c1Re[idx] = c1Re[idx] * tap;
+            c1Im[idx] = c1Im[idx] * tap;
+        }
+    }
+    // CSHIFT
+    const shift = i0 - ib;
+    const tempRe = new Float64Array(NFFT2);
+    const tempIm = new Float64Array(NFFT2);
+    for (let i = 0; i < NFFT2; i++) {
+        let srcIdx = (i + shift) % NFFT2;
+        if (srcIdx < 0)
+            srcIdx += NFFT2;
+        tempRe[i] = c1Re[srcIdx];
+        tempIm[i] = c1Im[srcIdx];
+    }
+    for (let i = 0; i < NFFT2; i++) {
+        c1Re[i] = tempRe[i];
+        c1Im[i] = tempIm[i];
+    }
+    // iFFT
+    fftComplex(c1Re, c1Im, true);
+    // Scale
+    // Fortran uses 1.0/sqrt(NFFT1 * NFFT2), but our fftComplex(true) scales by 1/NFFT2
+    const scale = Math.sqrt(NFFT2 / NFFT1);
+    for (let i = 0; i < NFFT2; i++) {
+        c1Re[i] = c1Re[i] * scale;
+        c1Im[i] = c1Im[i] * scale;
     }
 }
 function sync8d(cd0Re, cd0Im, i0, twkRe, twkIm, useTwk) {
@@ -2114,6 +2218,250 @@ function encode(msg, options = {}) {
     return generateFT8Waveform(encodeMessage(msg), options);
 }
 
-exports.decodeFT8 = decode;
-exports.encodeFT8 = encode;
-//# sourceMappingURL=ft8js.cjs.map
+/// <reference types="node" />
+/**
+ * Parse a WAV file buffer into sample rate and normalized float samples.
+ * Supports PCM format 1, 8/16/32-bit samples.
+ */
+function parseWavBuffer(buf) {
+    if (buf.length < 44)
+        throw new Error("File too small for WAV");
+    const riff = buf.toString("ascii", 0, 4);
+    const wave = buf.toString("ascii", 8, 12);
+    if (riff !== "RIFF" || wave !== "WAVE")
+        throw new Error("Not a WAV file");
+    let offset = 12;
+    let fmtFound = false;
+    let sampleRate = 0;
+    let bitsPerSample = 0;
+    let numChannels = 1;
+    let audioFormat = 0;
+    let dataOffset = 0;
+    let dataSize = 0;
+    while (offset < buf.length - 8) {
+        const chunkId = buf.toString("ascii", offset, offset + 4);
+        const chunkSize = buf.readUInt32LE(offset + 4);
+        offset += 8;
+        if (chunkId === "fmt ") {
+            audioFormat = buf.readUInt16LE(offset);
+            numChannels = buf.readUInt16LE(offset + 2);
+            sampleRate = buf.readUInt32LE(offset + 4);
+            bitsPerSample = buf.readUInt16LE(offset + 14);
+            fmtFound = true;
+        }
+        else if (chunkId === "data") {
+            dataOffset = offset;
+            dataSize = chunkSize;
+            break;
+        }
+        offset += chunkSize;
+    }
+    if (!fmtFound)
+        throw new Error("No fmt chunk found");
+    if (audioFormat !== 1)
+        throw new Error(`Unsupported audio format: ${audioFormat} (only PCM=1)`);
+    if (dataOffset === 0)
+        throw new Error("No data chunk found");
+    const bytesPerSample = bitsPerSample / 8;
+    const totalSamples = Math.floor(dataSize / (bytesPerSample * numChannels));
+    const samples = new Float32Array(totalSamples);
+    for (let i = 0; i < totalSamples; i++) {
+        const pos = dataOffset + i * numChannels * bytesPerSample;
+        let val;
+        if (bitsPerSample === 16) {
+            val = buf.readInt16LE(pos) / 32768;
+        }
+        else if (bitsPerSample === 32) {
+            val = buf.readInt32LE(pos) / 2147483648;
+        }
+        else if (bitsPerSample === 8) {
+            val = (buf.readUInt8(pos) - 128) / 128;
+        }
+        else {
+            throw new Error(`Unsupported bits per sample: ${bitsPerSample}`);
+        }
+        samples[i] = val;
+    }
+    return { sampleRate, samples };
+}
+function floatToInt16(sample) {
+    const clamped = Math.max(-1, Math.min(1, sample));
+    return clamped < 0 ? Math.round(clamped * 0x8000) : Math.round(clamped * 0x7fff);
+}
+/**
+ * Write mono 16-bit PCM WAV file from normalized float samples (-1..1).
+ */
+function writeMono16WavFile(filePath, samples, sampleRate) {
+    const numChannels = 1;
+    const bitsPerSample = 16;
+    const blockAlign = numChannels * (bitsPerSample / 8);
+    const dataSize = samples.length * blockAlign;
+    const wav = Buffer.alloc(44 + dataSize);
+    let offset = 0;
+    wav.write("RIFF", offset);
+    offset += 4;
+    wav.writeUInt32LE(36 + dataSize, offset);
+    offset += 4;
+    wav.write("WAVE", offset);
+    offset += 4;
+    wav.write("fmt ", offset);
+    offset += 4;
+    wav.writeUInt32LE(16, offset);
+    offset += 4; // PCM chunk size
+    wav.writeUInt16LE(1, offset);
+    offset += 2; // PCM format
+    wav.writeUInt16LE(numChannels, offset);
+    offset += 2;
+    wav.writeUInt32LE(sampleRate, offset);
+    offset += 4;
+    wav.writeUInt32LE(sampleRate * blockAlign, offset);
+    offset += 4;
+    wav.writeUInt16LE(blockAlign, offset);
+    offset += 2;
+    wav.writeUInt16LE(bitsPerSample, offset);
+    offset += 2;
+    wav.write("data", offset);
+    offset += 4;
+    wav.writeUInt32LE(dataSize, offset);
+    offset += 4;
+    for (let i = 0; i < samples.length; i++) {
+        wav.writeInt16LE(floatToInt16(samples[i]), offset + i * 2);
+    }
+    writeFileSync(filePath, wav);
+}
+
+const SAMPLE_RATE = 12_000;
+const DEFAULT_OUTPUT = "output.wav";
+const DEFAULT_DF_HZ = 1_000;
+function printUsage() {
+    console.error(`ft8ts - FT8 encoder/decoder
+
+Usage:
+  ft8ts decode <file.wav> [options]
+  ft8ts encode "<message>" [options]
+
+Decode options:
+  --low <hz>     Lower frequency bound (default: 200)
+  --high <hz>    Upper frequency bound (default: 3000)
+  --depth <1|2|3>  Decoding depth (default: 2)
+
+Encode options:
+  --out <file>   Output WAV file (default: output.wav)
+  --df <hz>      Base frequency in Hz (default: 1000)
+`);
+}
+function formatMessage(d) {
+    const freq = d.freq.toFixed(0).padStart(5);
+    const dt = (d.dt >= 0 ? "+" : "") + d.dt.toFixed(1);
+    const snr = (d.snr >= 0 ? "+" : "") + Math.round(d.snr).toString().padStart(3);
+    return `${dt.padStart(5)}  ${snr}  ${freq}  ${d.msg}`;
+}
+function runDecode(argv) {
+    if (argv.length === 0) {
+        console.error("Error: missing input file");
+        printUsage();
+        process.exit(1);
+    }
+    const wavFile = argv[0];
+    const options = {};
+    for (let i = 1; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--low") {
+            options.freqLow = Number(argv[++i]);
+        }
+        else if (arg === "--high") {
+            options.freqHigh = Number(argv[++i]);
+        }
+        else if (arg === "--depth") {
+            options.depth = Number(argv[++i]);
+        }
+        else {
+            throw new Error(`Unknown argument: ${arg}`);
+        }
+    }
+    const filePath = resolve(process.cwd(), wavFile);
+    console.log(`Reading ${filePath}...`);
+    const { sampleRate, samples } = parseWavBuffer(readFileSync(filePath));
+    console.log(`WAV: ${sampleRate} Hz, ${samples.length} samples, ${(samples.length / sampleRate).toFixed(1)}s`);
+    const startTime = performance.now();
+    const decoded = decode(samples, { ...options, sampleRate });
+    const elapsed = performance.now() - startTime;
+    console.log(`\nDecoded ${decoded.length} messages in ${(elapsed / 1000).toFixed(2)}s:\n`);
+    console.log("   dt  snr   freq  message");
+    console.log("  ---  ---  -----  -------");
+    for (const d of decoded) {
+        console.log(formatMessage(d));
+    }
+}
+function runEncode(argv) {
+    if (argv.length === 0) {
+        console.error("Error: missing message");
+        printUsage();
+        process.exit(1);
+    }
+    const message = argv[0];
+    let outputFile = DEFAULT_OUTPUT;
+    let dfHz = DEFAULT_DF_HZ;
+    for (let i = 1; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--out") {
+            i++;
+            const value = argv[i];
+            if (!value)
+                throw new Error("Missing value for --out");
+            outputFile = value;
+        }
+        else if (arg === "--df") {
+            i++;
+            const value = argv[i];
+            if (!value)
+                throw new Error("Missing value for --df");
+            const parsed = Number(value);
+            if (!Number.isFinite(parsed) || parsed < 0) {
+                throw new Error(`Invalid --df value: ${value}`);
+            }
+            dfHz = parsed;
+        }
+        else {
+            throw new Error(`Unknown argument: ${arg}`);
+        }
+    }
+    const waveform = encode(message, {
+        sampleRate: SAMPLE_RATE,
+        samplesPerSymbol: 1_920,
+        baseFrequency: dfHz,
+    });
+    const outPath = resolve(process.cwd(), outputFile);
+    writeMono16WavFile(outPath, waveform, SAMPLE_RATE);
+    console.log(`Wrote ${outPath} (${waveform.length} samples, ${(waveform.length / SAMPLE_RATE).toFixed(3)} s)`);
+}
+function main() {
+    const args = process.argv.slice(2);
+    const subcommand = args[0];
+    const subArgs = args.slice(1);
+    if (!subcommand || subcommand === "--help" || subcommand === "-h") {
+        printUsage();
+        process.exit(0);
+    }
+    try {
+        if (subcommand === "decode") {
+            runDecode(subArgs);
+        }
+        else if (subcommand === "encode") {
+            runEncode(subArgs);
+        }
+        else {
+            console.error(`Error: unknown subcommand '${subcommand}'`);
+            printUsage();
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(`Error: ${msg}`);
+        printUsage();
+        process.exit(1);
+    }
+}
+main();
+//# sourceMappingURL=cli.js.map