@e04/ft8ts 0.0.8 → 0.0.10

package/dist/cli.js

@@ -2,19 +2,10 @@
 import { writeFileSync, readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 
+/** Shared constants used by FT8, FT4, pack77, etc. */
 const SAMPLE_RATE$1 = 12_000;
-const NSPS = 1920;
-const NFFT1 = 2 * NSPS; // 3840
-const NSTEP = NSPS / 4; // 480
-const NMAX = 15 * SAMPLE_RATE$1; // 180000
-const NHSYM = Math.floor(NMAX / NSTEP) - 3; // 372
-const NDOWN = 60;
-const NN = 79;
-const KK = 91;
+/** LDPC(174,91) code (shared by FT8 and FT4). */
 const N_LDPC = 174;
-const M_LDPC = N_LDPC - KK; // 83
-const icos7 = [3, 1, 4, 0, 6, 5, 2];
-const graymap = [0, 1, 3, 2, 5, 6, 4, 7];
 const gHex = [
     "8329ce11bf31eaf509f27fc",
     "761c264e25c259335493132",
@@ -239,6 +230,8 @@ for (let i = 0; i < 83; i++) {
  * LDPC (174,91) Belief Propagation decoder for FT8.
  * Port of bpdecode174_91.f90 and decode174_91.f90.
  */
+const KK = 91;
+const M_LDPC = N_LDPC - KK; // 83
 function platanh(x) {
     if (x > 0.9999999)
         return 18.71;
@@ -387,36 +380,48 @@ function osdDecode174_91(llr, apmask, norder) {
     const N = N_LDPC;
     const K = KK;
     const gen = getGenerator();
+    const absllr = new Float64Array(N);
+    for (let i = 0; i < N; i++)
+        absllr[i] = Math.abs(llr[i]);
     // Sort by reliability (descending)
-    const indices = Array.from({ length: N }, (_, i) => i);
-    indices.sort((a, b) => Math.abs(llr[b]) - Math.abs(llr[a]));
+    const indices = new Array(N);
+    for (let i = 0; i < N; i++)
+        indices[i] = i;
+    indices.sort((a, b) => absllr[b] - absllr[a]);
     // Reorder generator matrix columns
     const genmrb = new Uint8Array(K * N);
-    for (let i = 0; i < N; i++) {
-        for (let k = 0; k < K; k++) {
-            genmrb[k * N + i] = gen[k * N + indices[i]];
+    for (let k = 0; k < K; k++) {
+        const row = k * N;
+        for (let i = 0; i < N; i++) {
+            genmrb[row + i] = gen[row + indices[i]];
         }
     }
     // Gaussian elimination to get systematic form on the K most-reliable bits
+    const maxPivotCol = Math.min(K + 20, N);
     for (let id = 0; id < K; id++) {
         let found = false;
-        for (let icol = id; icol < Math.min(K + 20, N); icol++) {
-            if (genmrb[id * N + icol] === 1) {
+        const idRow = id * N;
+        for (let icol = id; icol < maxPivotCol; icol++) {
+            if (genmrb[idRow + icol] === 1) {
                 if (icol !== id) {
                     // Swap columns
                     for (let k = 0; k < K; k++) {
-                        const tmp = genmrb[k * N + id];
-                        genmrb[k * N + id] = genmrb[k * N + icol];
-                        genmrb[k * N + icol] = tmp;
+                        const row = k * N;
+                        const tmp = genmrb[row + id];
+                        genmrb[row + id] = genmrb[row + icol];
+                        genmrb[row + icol] = tmp;
                     }
                     const tmp = indices[id];
                     indices[id] = indices[icol];
                     indices[icol] = tmp;
                 }
                 for (let ii = 0; ii < K; ii++) {
-                    if (ii !== id && genmrb[ii * N + id] === 1) {
+                    if (ii === id)
+                        continue;
+                    const iiRow = ii * N;
+                    if (genmrb[iiRow + id] === 1) {
                         for (let c = 0; c < N; c++) {
-                            genmrb[ii * N + c] ^= genmrb[id * N + c];
+                            genmrb[iiRow + c] ^= genmrb[idRow + c];
                         }
                     }
                 }
@@ -430,80 +435,82 @@ function osdDecode174_91(llr, apmask, norder) {
     // Hard decisions on reordered received word
     const hdec = new Int8Array(N);
     for (let i = 0; i < N; i++) {
-        hdec[i] = llr[indices[i]] >= 0 ? 1 : 0;
+        const idx = indices[i];
+        hdec[i] = llr[idx] >= 0 ? 1 : 0;
     }
     const absrx = new Float64Array(N);
     for (let i = 0; i < N; i++) {
-        absrx[i] = Math.abs(llr[indices[i]]);
+        absrx[i] = absllr[indices[i]];
     }
-    // Transpose of reordered gen matrix
-    const g2 = new Uint8Array(N * K);
+    // Encode hard decision on MRB (c0): xor selected rows of genmrb.
+    const c0 = new Int8Array(N);
     for (let i = 0; i < K; i++) {
+        if (hdec[i] !== 1)
+            continue;
+        const row = i * N;
         for (let j = 0; j < N; j++) {
-            g2[j * K + i] = genmrb[i * N + j];
-        }
-    }
-    function mrbencode(me) {
-        const codeword = new Int8Array(N);
-        for (let i = 0; i < K; i++) {
-            if (me[i] === 1) {
-                for (let j = 0; j < N; j++) {
-                    codeword[j] ^= g2[j * K + i];
-                }
-            }
+            c0[j] ^= genmrb[row + j];
         }
-        return codeword;
     }
-    const m0 = hdec.slice(0, K);
-    const c0 = mrbencode(m0);
-    const bestCw = new Int8Array(c0);
     let dmin = 0;
     for (let i = 0; i < N; i++) {
         const x = c0[i] ^ hdec[i];
         dmin += x * absrx[i];
     }
+    let bestFlip1 = -1;
+    let bestFlip2 = -1;
     // Order-1: flip single bits in the info portion
     for (let i1 = K - 1; i1 >= 0; i1--) {
         if (apmask[indices[i1]] === 1)
             continue;
-        const me = new Int8Array(m0);
-        me[i1] ^= 1;
-        const ce = mrbencode(me);
+        const row1 = i1 * N;
         let dd = 0;
         for (let j = 0; j < N; j++) {
-            const x = ce[j] ^ hdec[j];
+            const x = c0[j] ^ genmrb[row1 + j] ^ hdec[j];
             dd += x * absrx[j];
         }
         if (dd < dmin) {
             dmin = dd;
-            bestCw.set(ce);
+            bestFlip1 = i1;
+            bestFlip2 = -1;
         }
     }
     // Order-2: flip pairs of least-reliable info bits (limited search)
     if (norder >= 2) {
-        const ntry = Math.min(40, K);
-        for (let i1 = K - 1; i1 >= K - ntry; i1--) {
+        const ntry = Math.min(64, K);
+        const iMin = Math.max(0, K - ntry);
+        for (let i1 = K - 1; i1 >= iMin; i1--) {
             if (apmask[indices[i1]] === 1)
                 continue;
-            for (let i2 = i1 - 1; i2 >= K - ntry; i2--) {
+            const row1 = i1 * N;
+            for (let i2 = i1 - 1; i2 >= iMin; i2--) {
                 if (apmask[indices[i2]] === 1)
                     continue;
-                const me = new Int8Array(m0);
-                me[i1] ^= 1;
-                me[i2] ^= 1;
-                const ce = mrbencode(me);
+                const row2 = i2 * N;
                 let dd = 0;
                 for (let j = 0; j < N; j++) {
-                    const x = ce[j] ^ hdec[j];
+                    const x = c0[j] ^ genmrb[row1 + j] ^ genmrb[row2 + j] ^ hdec[j];
                     dd += x * absrx[j];
                 }
                 if (dd < dmin) {
                     dmin = dd;
-                    bestCw.set(ce);
+                    bestFlip1 = i1;
+                    bestFlip2 = i2;
                 }
             }
         }
     }
+    const bestCw = new Int8Array(c0);
+    if (bestFlip1 >= 0) {
+        const row1 = bestFlip1 * N;
+        for (let j = 0; j < N; j++)
+            bestCw[j] ^= genmrb[row1 + j];
+        if (bestFlip2 >= 0) {
+            const row2 = bestFlip2 * N;
+            for (let j = 0; j < N; j++)
+                bestCw[j] ^= genmrb[row2 + j];
+        }
+    }
     // Reorder codeword back to original order
     const finalCw = new Int8Array(N);
     for (let i = 0; i < N; i++) {
@@ -514,14 +521,12 @@ function osdDecode174_91(llr, apmask, norder) {
         return null;
     // Compute dmin in original order
     let dminOrig = 0;
-    const hdecOrig = new Int8Array(N);
-    for (let i = 0; i < N; i++)
-        hdecOrig[i] = llr[i] >= 0 ? 1 : 0;
     let nhe = 0;
     for (let i = 0; i < N; i++) {
-        const x = finalCw[i] ^ hdecOrig[i];
+        const hard = llr[i] >= 0 ? 1 : 0;
+        const x = finalCw[i] ^ hard;
         nhe += x;
-        dminOrig += x * Math.abs(llr[i]);
+        dminOrig += x * absllr[i];
     }
     return {
         message91: bits91,
@@ -566,6 +571,8 @@ function getGenerator() {
  * Radix-2 Cooley-Tukey FFT for FT8 decoding.
  * Supports real-to-complex, complex-to-complex, and inverse transforms.
  */
+const RADIX2_PLAN_CACHE = new Map();
+const BLUESTEIN_PLAN_CACHE = new Map();
 function fftComplex(re, im, inverse) {
     const n = re.length;
     if (n <= 1)
@@ -574,9 +581,10 @@ function fftComplex(re, im, inverse) {
         bluestein(re, im, inverse);
         return;
     }
+    const { bitReversed } = getRadix2Plan(n);
     // Bit-reversal permutation
-    let j = 0;
     for (let i = 0; i < n; i++) {
+        const j = bitReversed[i];
         if (j > i) {
             let tmp = re[i];
             re[i] = re[j];
@@ -585,12 +593,6 @@ function fftComplex(re, im, inverse) {
             im[i] = im[j];
             im[j] = tmp;
         }
-        let m = n >> 1;
-        while (m >= 1 && j >= m) {
-            j -= m;
-            m >>= 1;
-        }
-        j += m;
     }
     const sign = inverse ? 1 : -1;
     for (let size = 2; size <= n; size <<= 1) {
@@ -617,53 +619,98 @@ function fftComplex(re, im, inverse) {
         }
     }
     if (inverse) {
+        const scale = 1 / n;
         for (let i = 0; i < n; i++) {
-            re[i] /= n;
-            im[i] /= n;
+            re[i] = re[i] * scale;
+            im[i] = im[i] * scale;
         }
     }
 }
 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);
+    const { m, chirpRe, chirpIm, bFftRe, bFftIm, aRe, aIm } = getBluesteinPlan(n, inverse);
+    aRe.fill(0);
+    aIm.fill(0);
     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];
+        const cosA = chirpRe[i];
+        const sinA = chirpIm[i];
+        const inRe = re[i];
+        const inIm = im[i];
+        aRe[i] = inRe * cosA - inIm * sinA;
+        aIm[i] = inRe * sinA + inIm * cosA;
     }
     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;
+        const ar = aRe[i];
+        const ai = aIm[i];
+        const br = bFftRe[i];
+        const bi = bFftIm[i];
+        aRe[i] = ar * br - ai * bi;
+        aIm[i] = ar * bi + ai * br;
     }
     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 cosA = chirpRe[i];
+        const sinA = chirpIm[i];
         const r = aRe[i] * cosA - aIm[i] * sinA;
         const iIm = aRe[i] * sinA + aIm[i] * cosA;
         re[i] = r * scale;
         im[i] = iIm * scale;
     }
 }
+function getRadix2Plan(n) {
+    let plan = RADIX2_PLAN_CACHE.get(n);
+    if (plan)
+        return plan;
+    const bits = 31 - Math.clz32(n);
+    const bitReversed = new Uint32Array(n);
+    for (let i = 1; i < n; i++) {
+        bitReversed[i] = (bitReversed[i >> 1] >> 1) | ((i & 1) << (bits - 1));
+    }
+    plan = { bitReversed };
+    RADIX2_PLAN_CACHE.set(n, plan);
+    return plan;
+}
+function getBluesteinPlan(n, inverse) {
+    const key = `${n}:${inverse ? 1 : 0}`;
+    const cached = BLUESTEIN_PLAN_CACHE.get(key);
+    if (cached)
+        return cached;
+    const m = nextPow2(n * 2 - 1);
+    const s = inverse ? 1 : -1;
+    const chirpRe = new Float64Array(n);
+    const chirpIm = new Float64Array(n);
+    for (let i = 0; i < n; i++) {
+        const angle = (s * Math.PI * ((i * i) % (2 * n))) / n;
+        chirpRe[i] = Math.cos(angle);
+        chirpIm[i] = Math.sin(angle);
+    }
+    const bFftRe = new Float64Array(m);
+    const bFftIm = new Float64Array(m);
+    for (let i = 0; i < n; i++) {
+        const cosA = chirpRe[i];
+        const sinA = chirpIm[i];
+        bFftRe[i] = cosA;
+        bFftIm[i] = -sinA;
+    }
+    for (let i = 1; i < n; i++) {
+        bFftRe[m - i] = bFftRe[i];
+        bFftIm[m - i] = bFftIm[i];
+    }
+    fftComplex(bFftRe, bFftIm, false);
+    const plan = {
+        m,
+        chirpRe,
+        chirpIm,
+        bFftRe,
+        bFftIm,
+        aRe: new Float64Array(m),
+        aIm: new Float64Array(m),
+    };
+    BLUESTEIN_PLAN_CACHE.set(key, plan);
+    return plan;
+}
 /** Next power of 2 >= n */
 function nextPow2(n) {
     let v = 1;
@@ -923,607 +970,789 @@ function unpack77(bits77, book) {
     return { msg: "", success: false };
 }
 
+/** FT4-specific constants (lib/ft4/ft4_params.f90). */
+const GRAYMAP = [0, 1, 3, 2];
+
+// Message scrambling vector (rvec) from WSJT-X.
+const RVEC = [
+    0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1,
+    0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0,
+    1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1,
+];
+function xorWithScrambler(bits77) {
+    const out = new Array(77);
+    for (let i = 0; i < 77; i++) {
+        out[i] = ((bits77[i] ?? 0) + RVEC[i]) & 1;
+    }
+    return out;
+}
+
+const COSTAS_A = [0, 1, 3, 2];
+const COSTAS_B = [1, 0, 2, 3];
+const COSTAS_C = [2, 3, 1, 0];
+const COSTAS_D = [3, 2, 0, 1];
+const NSPS$1 = 576;
+const NFFT1$1 = 4 * NSPS$1; // 2304
+const NH1 = NFFT1$1 / 2; // 1152
+const NMAX$1 = 21 * 3456; // 72576
+const NHSYM$1 = Math.floor((NMAX$1 - NFFT1$1) / NSPS$1); // 122
+const NDOWN$1 = 18;
+const NN$1 = 103;
+const NFFT2$1 = NMAX$1 / NDOWN$1; // 4032
+const NSS = NSPS$1 / NDOWN$1; // 32
+const FS2$1 = SAMPLE_RATE$1 / NDOWN$1; // 666.67 Hz
+const MAX_FREQ = 4910;
+const SYNC_PASS_MIN = 1.2;
+const TWO_PI$2 = 2 * Math.PI;
+const HARD_SYNC_PATTERNS = [
+    { offset: 0, bits: [0, 0, 0, 1, 1, 0, 1, 1] },
+    { offset: 66, bits: [0, 1, 0, 0, 1, 1, 1, 0] },
+    { offset: 132, bits: [1, 1, 1, 0, 0, 1, 0, 0] },
+    { offset: 198, bits: [1, 0, 1, 1, 0, 0, 0, 1] },
+];
+const COSTAS_BLOCKS$1 = 4;
+const FT4_SYNC_STRIDE = 33 * NSS;
+const FT4_MAX_TWEAK = 16;
+const LDPC_BITS = 174;
+const BITMETRIC_LEN = 2 * NN$1;
+const FRAME_LEN = NN$1 * NSS;
+const NUTTALL_WINDOW = makeNuttallWindow(NFFT1$1);
+const DOWNSAMPLE_CTX = createDownsampleContext();
+const TWEAKED_SYNC_TEMPLATES = createTweakedSyncTemplates();
 /**
- * Decode all FT8 signals in an audio buffer.
- * Input: mono audio samples at `sampleRate` Hz, duration ~15s.
+ * Decode all FT4 signals in a buffer.
+ * Input: mono audio samples at `sampleRate` Hz, duration ~6s.
  */
-function decode(samples, options = {}) {
+function decode$1(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 freqLow = options.freqLow ?? 200;
+    const freqHigh = options.freqHigh ?? 3000;
+    const syncMin = options.syncMin ?? 1.2;
     const depth = options.depth ?? 2;
-    const maxCandidates = options.maxCandidates ?? 300;
+    const maxCandidates = options.maxCandidates ?? 100;
     const book = options.hashCallBook;
-    // Resample to 12000 Hz if needed
-    let dd;
-    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$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++) {
+    const dd = sampleRate === SAMPLE_RATE$1
+        ? copySamplesToDecodeWindow$1(samples)
+        : resample$1(samples, sampleRate, SAMPLE_RATE$1, NMAX$1);
+    const cxRe = new Float64Array(NMAX$1);
+    const cxIm = new Float64Array(NMAX$1);
+    for (let i = 0; i < NMAX$1; 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 candidates = getCandidates4(dd, freqLow, freqHigh, syncMin, maxCandidates);
+    if (candidates.length === 0)
+        return [];
+    const workspace = createDecodeWorkspace$1();
     const decoded = [];
     const seenMessages = new Set();
-    for (const cand of candidates) {
-        const result = ft8b(dd, cxRe, cxIm, cand.freq, cand.dt, sbase, depth, book);
-        if (!result)
+    for (const candidate of candidates) {
+        const one = decodeCandidate(candidate, cxRe, cxIm, depth, book, workspace);
+        if (!one)
             continue;
-        if (seenMessages.has(result.msg))
+        if (seenMessages.has(one.msg))
             continue;
-        seenMessages.add(result.msg);
-        decoded.push({
-            freq: result.freq,
-            dt: result.dt - 0.5,
-            snr: result.snr,
-            msg: result.msg,
-            sync: cand.sync,
-        });
+        seenMessages.add(one.msg);
+        decoded.push(one);
     }
     return decoded;
 }
-function sync8(dd, nfa, nfb, syncmin, maxcand) {
-    const JZ = 62;
-    // 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$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);
-    const savg = new Float64Array(halfSize);
-    const xRe = new Float64Array(fftSize);
-    const xIm = new Float64Array(fftSize);
-    for (let j = 0; j < NHSYM; j++) {
-        const ia = j * NSTEP;
-        xRe.fill(0);
-        xIm.fill(0);
-        for (let i = 0; i < NSPS && ia + i < dd.length; i++) {
-            xRe[i] = fac * dd[ia + i];
-        }
-        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;
-            savg[i] = (savg[i] ?? 0) + power;
-        }
+function createDecodeWorkspace$1() {
+    return {
+        coarseRe: new Float64Array(NFFT2$1),
+        coarseIm: new Float64Array(NFFT2$1),
+        fineRe: new Float64Array(NFFT2$1),
+        fineIm: new Float64Array(NFFT2$1),
+        frameRe: new Float64Array(FRAME_LEN),
+        frameIm: new Float64Array(FRAME_LEN),
+        symbRe: new Float64Array(NSS),
+        symbIm: new Float64Array(NSS),
+        csRe: new Float64Array(4 * NN$1),
+        csIm: new Float64Array(4 * NN$1),
+        s4: new Float64Array(4 * NN$1),
+        s2: new Float64Array(1 << 8),
+        bitmetrics1: new Float64Array(BITMETRIC_LEN),
+        bitmetrics2: new Float64Array(BITMETRIC_LEN),
+        bitmetrics3: new Float64Array(BITMETRIC_LEN),
+        llra: new Float64Array(LDPC_BITS),
+        llrb: new Float64Array(LDPC_BITS),
+        llrc: new Float64Array(LDPC_BITS),
+        llr: new Float64Array(LDPC_BITS),
+        apmask: new Int8Array(LDPC_BITS),
+    };
+}
+function copySamplesToDecodeWindow$1(samples) {
+    const out = new Float64Array(NMAX$1);
+    const len = Math.min(samples.length, NMAX$1);
+    for (let i = 0; i < len; i++)
+        out[i] = samples[i];
+    return out;
+}
+function decodeCandidate(candidate, cxRe, cxIm, depth, book, workspace) {
+    ft4Downsample(cxRe, cxIm, candidate.freq, DOWNSAMPLE_CTX, workspace.coarseRe, workspace.coarseIm);
+    normalizeComplexPower(workspace.coarseRe, workspace.coarseIm, NMAX$1 / NDOWN$1);
+    for (let segment = 1; segment <= 3; segment++) {
+        const coarse = findBestSyncLocation(workspace.coarseRe, workspace.coarseIm, segment);
+        if (coarse.smax < SYNC_PASS_MIN)
+            continue;
+        const f1 = candidate.freq + coarse.idfbest;
+        if (f1 <= 10 || f1 >= 4990)
+            continue;
+        ft4Downsample(cxRe, cxIm, f1, DOWNSAMPLE_CTX, workspace.fineRe, workspace.fineIm);
+        normalizeComplexPower(workspace.fineRe, workspace.fineIm, NSS * NN$1);
+        extractFrame(workspace.fineRe, workspace.fineIm, coarse.ibest, workspace.frameRe, workspace.frameIm);
+        const badsync = buildBitMetrics$1(workspace.frameRe, workspace.frameIm, workspace);
+        if (badsync)
+            continue;
+        if (!passesHardSyncQuality(workspace.bitmetrics1))
+            continue;
+        buildLlrs(workspace);
+        const result = tryDecodePasses$1(workspace, depth);
+        if (!result)
+            continue;
+        const message77Scrambled = result.message91.slice(0, 77);
+        if (!hasNonZeroBit(message77Scrambled))
+            continue;
+        const message77 = xorWithScrambler(message77Scrambled);
+        const { msg, success } = unpack77(message77, book);
+        if (!success || msg.trim().length === 0)
+            continue;
+        return {
+            freq: f1,
+            dt: coarse.ibest / FS2$1 - 0.5,
+            snr: toFt4Snr(candidate.sync - 1.0),
+            msg,
+            sync: coarse.smax,
+        };
     }
-    // Compute baseline
-    const sbase = computeBaseline(savg, nfa, nfb, df, halfSize);
-    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$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));
-    const width = 2 * JZ + 1;
-    for (let i = ia; i <= ib; i++) {
-        for (let jj = -JZ; jj <= JZ; jj++) {
-            let ta = 0, tb = 0, tc = 0;
-            let t0a = 0, t0b = 0, t0c = 0;
-            for (let n = 0; n < 7; n++) {
-                const m = jj + jstrt + nssy * n;
-                const iCostas = i + nfos * icos7[n];
-                if (m >= 0 && m < NHSYM && iCostas < halfSize) {
-                    ta += s[iCostas * NHSYM + m];
-                    for (let tone = 0; tone <= 6; tone++) {
-                        const idx = i + nfos * tone;
-                        if (idx < halfSize)
-                            t0a += s[idx * NHSYM + m];
-                    }
-                }
-                const m36 = m + nssy * 36;
-                if (m36 >= 0 && m36 < NHSYM && iCostas < halfSize) {
-                    tb += s[iCostas * NHSYM + m36];
-                    for (let tone = 0; tone <= 6; tone++) {
-                        const idx = i + nfos * tone;
-                        if (idx < halfSize)
-                            t0b += s[idx * NHSYM + m36];
-                    }
-                }
-                const m72 = m + nssy * 72;
-                if (m72 >= 0 && m72 < NHSYM && iCostas < halfSize) {
-                    tc += s[iCostas * NHSYM + m72];
-                    for (let tone = 0; tone <= 6; tone++) {
-                        const idx = i + nfos * tone;
-                        if (idx < halfSize)
-                            t0c += s[idx * NHSYM + m72];
-                    }
-                }
+    return null;
+}
+function findBestSyncLocation(cdRe, cdIm, segment) {
+    let ibest = -1;
+    let idfbest = 0;
+    let smax = -99;
+    for (let isync = 1; isync <= 2; isync++) {
+        let idfmin;
+        let idfmax;
+        let idfstp;
+        let ibmin;
+        let ibmax;
+        let ibstp;
+        if (isync === 1) {
+            idfmin = -12;
+            idfmax = 12;
+            idfstp = 3;
+            ibmin = -344;
+            ibmax = 1012;
+            if (segment === 1) {
+                ibmin = 108;
+                ibmax = 560;
             }
-            const t = ta + tb + tc;
-            const t0total = t0a + t0b + t0c;
-            const t0 = (t0total - t) / 6.0;
-            const syncVal = t0 > 0 ? t / t0 : 0;
-            const tbc = tb + tc;
-            const t0bc = t0b + t0c;
-            const t0bc2 = (t0bc - tbc) / 6.0;
-            const syncBc = t0bc2 > 0 ? tbc / t0bc2 : 0;
-            sync2d[(i - ia) * width + (jj + JZ)] = Math.max(syncVal, syncBc);
-        }
-    }
-    // Find peaks
-    const candidates0 = [];
-    const mlag = 10;
-    for (let i = ia; i <= ib; i++) {
-        let bestSync = -1;
-        let bestJ = 0;
-        for (let j = -mlag; j <= mlag; j++) {
-            const v = sync2d[(i - ia) * width + (j + JZ)];
-            if (v > bestSync) {
-                bestSync = v;
-                bestJ = j;
+            else if (segment === 2) {
+                ibmin = 560;
+                ibmax = 1012;
             }
-        }
-        // Also check wider range
-        let bestSync2 = -1;
-        let bestJ2 = 0;
-        for (let j = -JZ; j <= JZ; j++) {
-            const v = sync2d[(i - ia) * width + (j + JZ)];
-            if (v > bestSync2) {
-                bestSync2 = v;
-                bestJ2 = j;
+            else {
+                ibmin = -344;
+                ibmax = 108;
             }
+            ibstp = 4;
         }
-        if (bestSync >= syncmin) {
-            candidates0.push({
-                freq: i * df,
-                dt: (bestJ - 0.5) * tstep,
-                sync: bestSync,
-            });
-        }
-        if (Math.abs(bestJ2 - bestJ) > 0 && bestSync2 >= syncmin) {
-            candidates0.push({
-                freq: i * df,
-                dt: (bestJ2 - 0.5) * tstep,
-                sync: bestSync2,
-            });
-        }
-    }
-    // Compute baseline normalization for sync values
-    const syncValues = candidates0.map((c) => c.sync);
-    syncValues.sort((a, b) => a - b);
-    const pctileIdx = Math.max(0, Math.round(0.4 * syncValues.length) - 1);
-    const base = syncValues[pctileIdx] ?? 1;
-    if (base > 0) {
-        for (const c of candidates0)
-            c.sync /= base;
-    }
-    // Remove near-duplicate candidates
-    for (let i = 0; i < candidates0.length; i++) {
-        for (let j = 0; j < i; j++) {
-            const fdiff = Math.abs(candidates0[i].freq - candidates0[j].freq);
-            const tdiff = Math.abs(candidates0[i].dt - candidates0[j].dt);
-            if (fdiff < 4.0 && tdiff < 0.04) {
-                if (candidates0[i].sync >= candidates0[j].sync) {
-                    candidates0[j].sync = 0;
-                }
-                else {
-                    candidates0[i].sync = 0;
+        else {
+            idfmin = idfbest - 4;
+            idfmax = idfbest + 4;
+            idfstp = 1;
+            ibmin = ibest - 5;
+            ibmax = ibest + 5;
+            ibstp = 1;
+        }
+        for (let idf = idfmin; idf <= idfmax; idf += idfstp) {
+            const templates = TWEAKED_SYNC_TEMPLATES.get(idf);
+            if (!templates)
+                continue;
+            for (let istart = ibmin; istart <= ibmax; istart += ibstp) {
+                const sync = sync4d(cdRe, cdIm, istart, templates);
+                if (sync > smax) {
+                    smax = sync;
+                    ibest = istart;
+                    idfbest = idf;
                 }
             }
         }
     }
-    // Sort by sync descending, take top maxcand
-    const filtered = candidates0.filter((c) => c.sync >= syncmin);
-    filtered.sort((a, b) => b.sync - a.sync);
-    return { candidates: filtered.slice(0, maxcand), sbase };
+    return { ibest, idfbest, smax };
 }
-function computeBaseline(savg, nfa, nfb, df, nh1) {
-    const sbase = new Float64Array(nh1);
-    const ia = Math.max(1, Math.round(nfa / df));
-    const ib = Math.min(nh1 - 1, Math.round(nfb / df));
-    // Smooth the spectrum to get baseline
-    const window = 50; // bins
-    for (let i = 0; i < nh1; i++) {
+function getCandidates4(dd, freqLow, freqHigh, syncMin, maxCandidates) {
+    const df = SAMPLE_RATE$1 / NFFT1$1;
+    const fac = 1 / 300;
+    const savg = new Float64Array(NH1);
+    const s = new Float64Array(NH1 * NHSYM$1);
+    const savsm = new Float64Array(NH1);
+    const xRe = new Float64Array(NFFT1$1);
+    const xIm = new Float64Array(NFFT1$1);
+    for (let j = 0; j < NHSYM$1; j++) {
+        const ia = j * NSPS$1;
+        const ib = ia + NFFT1$1;
+        if (ib > NMAX$1)
+            break;
+        xIm.fill(0);
+        for (let i = 0; i < NFFT1$1; i++)
+            xRe[i] = fac * dd[ia + i] * NUTTALL_WINDOW[i];
+        fftComplex(xRe, xIm, false);
+        for (let bin = 1; bin <= NH1; bin++) {
+            const idx = bin - 1;
+            const re = xRe[bin] ?? 0;
+            const im = xIm[bin] ?? 0;
+            const power = re * re + im * im;
+            s[idx * NHSYM$1 + j] = power;
+            savg[idx] = (savg[idx] ?? 0) + power;
+        }
+    }
+    for (let i = 0; i < NH1; i++)
+        savg[i] = (savg[i] ?? 0) / NHSYM$1;
+    for (let i = 7; i < NH1 - 7; i++) {
         let sum = 0;
-        let count = 0;
-        const lo = Math.max(ia, i - window);
-        const hi = Math.min(ib, i + window);
-        for (let j = lo; j <= hi; j++) {
+        for (let j = i - 7; j <= i + 7; j++)
             sum += savg[j];
-            count++;
+        savsm[i] = sum / 15;
+    }
+    let nfa = Math.round(freqLow / df);
+    if (nfa < Math.round(200 / df))
+        nfa = Math.round(200 / df);
+    let nfb = Math.round(freqHigh / df);
+    if (nfb > Math.round(MAX_FREQ / df))
+        nfb = Math.round(MAX_FREQ / df);
+    const sbase = ft4Baseline(savg, nfa, nfb, df);
+    for (let bin = nfa; bin <= nfb; bin++) {
+        if ((sbase[bin - 1] ?? 0) <= 0)
+            return [];
+    }
+    for (let bin = nfa; bin <= nfb; bin++) {
+        const idx = bin - 1;
+        savsm[idx] = (savsm[idx] ?? 0) / sbase[idx];
+    }
+    const fOffset = (-1.5 * SAMPLE_RATE$1) / NSPS$1;
+    const candidates = [];
+    for (let i = nfa + 1; i <= nfb - 1; i++) {
+        const left = savsm[i - 2] ?? 0;
+        const center = savsm[i - 1] ?? 0;
+        const right = savsm[i] ?? 0;
+        if (center >= left && center >= right && center >= syncMin) {
+            const den = left - 2 * center + right;
+            const del = den !== 0 ? (0.5 * (left - right)) / den : 0;
+            const fpeak = (i + del) * df + fOffset;
+            if (fpeak < 200 || fpeak > MAX_FREQ)
+                continue;
+            const speak = center - 0.25 * (left - right) * del;
+            candidates.push({ freq: fpeak, sync: speak });
         }
-        sbase[i] = count > 0 ? 10 * Math.log10(Math.max(1e-30, sum / count)) : 0;
     }
-    return sbase;
+    candidates.sort((a, b) => b.sync - a.sync);
+    return candidates.slice(0, maxCandidates);
 }
-function ft8b(_dd0, cxRe, cxIm, f1, xdt, _sbase, depth, book) {
-    const NFFT2 = 3200;
-    const NP2 = 2812;
-    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(cxRe, cxIm, f1, cd0Re, cd0Im);
-    // Find best time offset
-    const i0 = Math.round((xdt + 0.5) * fs2);
-    let smax = 0;
-    let ibest = i0;
-    for (let idt = i0 - 10; idt <= i0 + 10; idt++) {
-        const sync = sync8d(cd0Re, cd0Im, idt, null, null, false);
-        if (sync > smax) {
-            smax = sync;
-            ibest = idt;
-        }
+function makeNuttallWindow(n) {
+    const out = new Float64Array(n);
+    const a0 = 0.3635819;
+    const a1 = -0.4891775;
+    const a2 = 0.1365995;
+    const a3 = -0.0106411;
+    for (let i = 0; i < n; i++) {
+        out[i] =
+            a0 +
+                a1 * Math.cos((2 * Math.PI * i) / n) +
+                a2 * Math.cos((4 * Math.PI * i) / n) +
+                a3 * Math.cos((6 * Math.PI * i) / n);
     }
-    // Fine frequency search
-    smax = 0;
-    let delfbest = 0;
-    for (let ifr = -5; ifr <= 5; ifr++) {
-        const delf = ifr * 0.5;
-        const dphi = twopi * delf * dt2;
-        const twkRe = new Float64Array(32);
-        const twkIm = new Float64Array(32);
-        let phi = 0;
-        for (let i = 0; i < 32; i++) {
-            twkRe[i] = Math.cos(phi);
-            twkIm[i] = Math.sin(phi);
-            phi = (phi + dphi) % twopi;
-        }
-        const sync = sync8d(cd0Re, cd0Im, ibest, twkRe, twkIm, true);
-        if (sync > smax) {
-            smax = sync;
-            delfbest = delf;
+    return out;
+}
+function ft4Baseline(savg, nfa, nfb, df) {
+    const sbase = new Float64Array(NH1);
+    sbase.fill(1);
+    const ia = Math.max(Math.round(200 / df), nfa);
+    const ib = Math.min(NH1, nfb);
+    if (ib <= ia)
+        return sbase;
+    const sDb = new Float64Array(NH1);
+    for (let i = ia; i <= ib; i++)
+        sDb[i - 1] = 10 * Math.log10(Math.max(1e-30, savg[i - 1]));
+    const nseg = 10;
+    const npct = 10;
+    const nlen = Math.max(1, Math.trunc((ib - ia + 1) / nseg));
+    const i0 = Math.trunc((ib - ia + 1) / 2);
+    const x = [];
+    const y = [];
+    for (let seg = 0; seg < nseg; seg++) {
+        const ja = ia + seg * nlen;
+        if (ja > ib)
+            break;
+        const jb = Math.min(ib, ja + nlen - 1);
+        const vals = [];
+        for (let i = ja; i <= jb; i++)
+            vals.push(sDb[i - 1]);
+        const base = percentile(vals, npct);
+        for (let i = ja; i <= jb; i++) {
+            const v = sDb[i - 1];
+            if (v <= base) {
+                x.push(i - i0);
+                y.push(v);
+            }
         }
     }
-    // Apply frequency correction and re-downsample
-    f1 += delfbest;
-    ft8Downsample(cxRe, cxIm, f1, cd0Re, cd0Im);
-    // Refine time offset
-    const ss = new Float64Array(9);
-    for (let idt = -4; idt <= 4; idt++) {
-        ss[idt + 4] = sync8d(cd0Re, cd0Im, ibest + idt, null, null, false);
-    }
-    let maxss = -1;
-    let maxIdx = 4;
-    for (let i = 0; i < 9; i++) {
-        if (ss[i] > maxss) {
-            maxss = ss[i];
-            maxIdx = i;
+    const coeff = x.length >= 5 ? polyfitLeastSquares(x, y, 4) : null;
+    if (coeff) {
+        for (let i = ia; i <= ib; i++) {
+            const t = i - i0;
+            const db = coeff[0] + t * (coeff[1] + t * (coeff[2] + t * (coeff[3] + t * coeff[4]))) + 0.65;
+            sbase[i - 1] = 10 ** (db / 10);
         }
     }
-    ibest = ibest + maxIdx - 4;
-    xdt = (ibest - 1) * dt2;
-    // Extract 8-tone soft symbols for each of NN=79 symbols
-    const s8 = new Float64Array(8 * NN);
-    const csRe = new Float64Array(8 * NN);
-    const csIm = new Float64Array(8 * NN);
-    const symbRe = new Float64Array(32);
-    const symbIm = new Float64Array(32);
-    for (let k = 0; k < NN; k++) {
-        const i1 = ibest + k * 32;
-        symbRe.fill(0);
-        symbIm.fill(0);
-        if (i1 >= 0 && i1 + 31 < NP2) {
-            for (let j = 0; j < 32; j++) {
-                symbRe[j] = cd0Re[i1 + j];
-                symbIm[j] = cd0Im[i1 + j];
+    else {
+        const halfWindow = 25;
+        for (let i = ia; i <= ib; i++) {
+            const lo = Math.max(ia, i - halfWindow);
+            const hi = Math.min(ib, i + halfWindow);
+            let sum = 0;
+            let count = 0;
+            for (let j = lo; j <= hi; j++) {
+                sum += savg[j - 1];
+                count++;
             }
-        }
-        fftComplex(symbRe, symbIm, false);
-        for (let tone = 0; tone < 8; tone++) {
-            const re = symbRe[tone] / 1000;
-            const im = symbIm[tone] / 1000;
-            csRe[tone * NN + k] = re;
-            csIm[tone * NN + k] = im;
-            s8[tone * NN + k] = Math.sqrt(re * re + im * im);
+            sbase[i - 1] = count > 0 ? sum / count : 1;
         }
     }
-    // Sync quality check
-    let nsync = 0;
-    for (let k = 0; k < 7; k++) {
-        for (const offset of [0, 36, 72]) {
-            let maxTone = 0;
-            let maxVal = -1;
-            for (let t = 0; t < 8; t++) {
-                const v = s8[t * NN + k + offset];
-                if (v > maxVal) {
-                    maxVal = v;
-                    maxTone = t;
-                }
+    return sbase;
+}
+function percentile(values, pct) {
+    if (values.length === 0)
+        return 0;
+    const sorted = [...values].sort((a, b) => a - b);
+    const idx = Math.max(0, Math.min(sorted.length - 1, Math.floor((pct / 100) * (sorted.length - 1))));
+    return sorted[idx];
+}
+function polyfitLeastSquares(x, y, degree) {
+    const n = degree + 1;
+    const mat = Array.from({ length: n }, () => new Float64Array(n + 1));
+    const xPows = new Float64Array(2 * degree + 1);
+    for (let p = 0; p <= 2 * degree; p++) {
+        let sum = 0;
+        for (let i = 0; i < x.length; i++)
+            sum += x[i] ** p;
+        xPows[p] = sum;
+    }
+    for (let row = 0; row < n; row++) {
+        for (let col = 0; col < n; col++)
+            mat[row][col] = xPows[row + col];
+        let rhs = 0;
+        for (let i = 0; i < x.length; i++)
+            rhs += y[i] * x[i] ** row;
+        mat[row][n] = rhs;
+    }
+    for (let col = 0; col < n; col++) {
+        let pivot = col;
+        let maxAbs = Math.abs(mat[col][col]);
+        for (let row = col + 1; row < n; row++) {
+            const a = Math.abs(mat[row][col]);
+            if (a > maxAbs) {
+                maxAbs = a;
+                pivot = row;
             }
-            if (maxTone === icos7[k])
-                nsync++;
         }
-    }
-    if (nsync <= 6)
-        return null;
-    // Compute soft bit metrics for multiple nsym values (1, 2, 3)
-    // and a normalized version, matching the Fortran ft8b passes 1-4
-    const bmeta = new Float64Array(N_LDPC); // nsym=1
-    const bmetb = new Float64Array(N_LDPC); // nsym=2
-    const bmetc = new Float64Array(N_LDPC); // nsym=3
-    const bmetd = new Float64Array(N_LDPC); // nsym=1 normalized
-    for (let nsym = 1; nsym <= 3; nsym++) {
-        const nt = 1 << (3 * nsym); // 8, 64, 512
-        const ibmax = nsym === 1 ? 2 : nsym === 2 ? 5 : 8;
-        for (let ihalf = 1; ihalf <= 2; ihalf++) {
-            for (let k = 1; k <= 29; k += nsym) {
-                const ks = ihalf === 1 ? k + 7 : k + 43;
-                const s2 = new Float64Array(nt);
-                for (let i = 0; i < nt; i++) {
-                    const i1 = Math.floor(i / 64);
-                    const i2 = Math.floor((i & 63) / 8);
-                    const i3 = i & 7;
-                    if (nsym === 1) {
-                        const re = csRe[graymap[i3] * NN + ks - 1];
-                        const im = csIm[graymap[i3] * NN + ks - 1];
-                        s2[i] = Math.sqrt(re * re + im * im);
-                    }
-                    else if (nsym === 2) {
-                        const sRe = csRe[graymap[i2] * NN + ks - 1] + csRe[graymap[i3] * NN + ks];
-                        const sIm = csIm[graymap[i2] * NN + ks - 1] + csIm[graymap[i3] * NN + ks];
-                        s2[i] = Math.sqrt(sRe * sRe + sIm * sIm);
-                    }
-                    else {
-                        const sRe = csRe[graymap[i1] * NN + ks - 1] +
-                            csRe[graymap[i2] * NN + ks] +
-                            csRe[graymap[i3] * NN + ks + 1];
-                        const sIm = csIm[graymap[i1] * NN + ks - 1] +
-                            csIm[graymap[i2] * NN + ks] +
-                            csIm[graymap[i3] * NN + ks + 1];
-                        s2[i] = Math.sqrt(sRe * sRe + sIm * sIm);
-                    }
-                }
-                // Fortran: i32 = 1 + (k-1)*3 + (ihalf-1)*87  (1-based)
-                const i32 = 1 + (k - 1) * 3 + (ihalf - 1) * 87;
-                for (let ib = 0; ib <= ibmax; ib++) {
-                    // max of s2 where bit (ibmax-ib) of index is 1
-                    let max1 = -1e30, max0 = -1e30;
-                    for (let i = 0; i < nt; i++) {
-                        const bitSet = (i & (1 << (ibmax - ib))) !== 0;
-                        if (bitSet) {
-                            if (s2[i] > max1)
-                                max1 = s2[i];
-                        }
-                        else {
-                            if (s2[i] > max0)
-                                max0 = s2[i];
-                        }
-                    }
-                    const idx = i32 + ib - 1; // Convert to 0-based
-                    if (idx >= 0 && idx < N_LDPC) {
-                        const bm = max1 - max0;
-                        if (nsym === 1) {
-                            bmeta[idx] = bm;
-                            const den = Math.max(max1, max0);
-                            bmetd[idx] = den > 0 ? bm / den : 0;
-                        }
-                        else if (nsym === 2) {
-                            bmetb[idx] = bm;
-                        }
-                        else {
-                            bmetc[idx] = bm;
-                        }
-                    }
-                }
-            }
+        if (maxAbs < 1e-12)
+            return null;
+        if (pivot !== col) {
+            const tmp = mat[col];
+            mat[col] = mat[pivot];
+            mat[pivot] = tmp;
+        }
+        const pivotVal = mat[col][col];
+        for (let c = col; c <= n; c++)
+            mat[col][c] = mat[col][c] / pivotVal;
+        for (let row = 0; row < n; row++) {
+            if (row === col)
+                continue;
+            const factor = mat[row][col];
+            if (factor === 0)
+                continue;
+            for (let c = col; c <= n; c++)
+                mat[row][c] = mat[row][c] - factor * mat[col][c];
         }
     }
-    normalizeBmet(bmeta);
-    normalizeBmet(bmetb);
-    normalizeBmet(bmetc);
-    normalizeBmet(bmetd);
-    const bmetrics = [bmeta, bmetb, bmetc, bmetd];
-    const scalefac = 2.83;
-    const maxosd = depth >= 3 ? 2 : depth >= 2 ? 0 : -1;
-    const apmask = new Int8Array(N_LDPC);
-    // Try 4 passes with different soft-symbol metrics (matching Fortran)
-    let result = null;
-    for (let ipass = 0; ipass < 4; ipass++) {
-        const llr = new Float64Array(N_LDPC);
-        for (let i = 0; i < N_LDPC; i++)
-            llr[i] = scalefac * bmetrics[ipass][i];
-        result = decode174_91(llr, apmask, maxosd);
-        if (result && result.nharderrors >= 0 && result.nharderrors <= 36)
-            break;
-        result = null;
+    const coeff = new Array(n);
+    for (let i = 0; i < n; i++)
+        coeff[i] = mat[i][n];
+    return coeff;
+}
+function createDownsampleContext() {
+    const df = SAMPLE_RATE$1 / NMAX$1;
+    const baud = SAMPLE_RATE$1 / NSPS$1;
+    const bwTransition = 0.5 * baud;
+    const bwFlat = 4 * baud;
+    const iwt = Math.max(1, Math.trunc(bwTransition / df));
+    const iwf = Math.max(1, Math.trunc(bwFlat / df));
+    const iws = Math.trunc(baud / df);
+    const raw = new Float64Array(NFFT2$1);
+    for (let i = 0; i < iwt && i < raw.length; i++) {
+        raw[i] = 0.5 * (1 + Math.cos((Math.PI * (iwt - 1 - i)) / iwt));
+    }
+    for (let i = iwt; i < iwt + iwf && i < raw.length; i++)
+        raw[i] = 1;
+    for (let i = iwt + iwf; i < 2 * iwt + iwf && i < raw.length; i++) {
+        raw[i] = 0.5 * (1 + Math.cos((Math.PI * (i - (iwt + iwf))) / iwt));
+    }
+    const window = new Float64Array(NFFT2$1);
+    for (let i = 0; i < NFFT2$1; i++) {
+        const src = (i + iws) % NFFT2$1;
+        window[i] = raw[src];
+    }
+    return { df, window };
+}
+function ft4Downsample(cxRe, cxIm, f0, ctx, outRe, outIm) {
+    outRe.fill(0);
+    outIm.fill(0);
+    const i0 = Math.round(f0 / ctx.df);
+    if (i0 >= 0 && i0 <= NMAX$1 / 2) {
+        outRe[0] = cxRe[i0] ?? 0;
+        outIm[0] = cxIm[i0] ?? 0;
+    }
+    for (let i = 1; i <= NFFT2$1 / 2; i++) {
+        const hi = i0 + i;
+        if (hi >= 0 && hi <= NMAX$1 / 2) {
+            outRe[i] = cxRe[hi] ?? 0;
+            outIm[i] = cxIm[hi] ?? 0;
+        }
+        const lo = i0 - i;
+        if (lo >= 0 && lo <= NMAX$1 / 2) {
+            const idx = NFFT2$1 - i;
+            outRe[idx] = cxRe[lo] ?? 0;
+            outIm[idx] = cxIm[lo] ?? 0;
+        }
+    }
+    const scale = 1 / NFFT2$1;
+    for (let i = 0; i < NFFT2$1; i++) {
+        const w = (ctx.window[i] ?? 0) * scale;
+        outRe[i] = outRe[i] * w;
+        outIm[i] = outIm[i] * w;
+    }
+    fftComplex(outRe, outIm, true);
+}
+function normalizeComplexPower(re, im, denom) {
+    let sum = 0;
+    for (let i = 0; i < re.length; i++)
+        sum += re[i] * re[i] + im[i] * im[i];
+    if (sum <= 0)
+        return;
+    const scale = 1 / Math.sqrt(sum / denom);
+    for (let i = 0; i < re.length; i++) {
+        re[i] = re[i] * scale;
+        im[i] = im[i] * scale;
     }
-    if (!result || result.nharderrors < 0 || result.nharderrors > 36)
-        return null;
-    // Check for all-zero codeword
-    if (result.cw.every((b) => b === 0))
-        return null;
-    const message77 = result.message91.slice(0, 77);
-    // Validate message type
-    const n3v = (message77[71] << 2) | (message77[72] << 1) | message77[73];
-    const i3v = (message77[74] << 2) | (message77[75] << 1) | message77[76];
-    if (i3v > 5 || (i3v === 0 && n3v > 6))
-        return null;
-    if (i3v === 0 && n3v === 2)
-        return null;
-    // Unpack
-    const { msg, success } = unpack77(message77, book);
-    if (!success || msg.trim().length === 0)
-        return null;
-    // Estimate SNR
-    let xsig = 0;
-    let xnoi = 0;
-    const itone = getTones$1(result.cw);
-    for (let i = 0; i < 79; i++) {
-        xsig += s8[itone[i] * NN + i] ** 2;
-        const ios = (itone[i] + 4) % 7;
-        xnoi += s8[ios * NN + i] ** 2;
+}
+function extractFrame(cbRe, cbIm, ibest, outRe, outIm) {
+    for (let i = 0; i < outRe.length; i++) {
+        const src = ibest + i;
+        if (src >= 0 && src < cbRe.length) {
+            outRe[i] = cbRe[src];
+            outIm[i] = cbIm[src];
+        }
+        else {
+            outRe[i] = 0;
+            outIm[i] = 0;
+        }
     }
-    let snr = 0.001;
-    const arg = xsig / Math.max(xnoi, 1e-30) - 1.0;
-    if (arg > 0.1)
-        snr = arg;
-    snr = 10 * Math.log10(snr) - 27.0;
-    if (snr < -24)
-        snr = -24;
-    return { msg, freq: f1, dt: xdt, snr };
 }
-function getTones$1(cw) {
-    const tones = new Array(79).fill(0);
-    for (let i = 0; i < 7; i++)
-        tones[i] = icos7[i];
-    for (let i = 0; i < 7; i++)
-        tones[36 + i] = icos7[i];
-    for (let i = 0; i < 7; i++)
-        tones[72 + i] = icos7[i];
-    let k = 7;
-    for (let j = 1; j <= 58; j++) {
-        const i = (j - 1) * 3;
-        if (j === 30)
-            k += 7;
-        const indx = cw[i] * 4 + cw[i + 1] * 2 + cw[i + 2];
-        tones[k] = graymap[indx];
-        k++;
+function createTweakedSyncTemplates() {
+    const base = createBaseSyncTemplates();
+    const fsample = FS2$1 / 2;
+    const out = new Map();
+    for (let idf = -FT4_MAX_TWEAK; idf <= FT4_MAX_TWEAK; idf++) {
+        const tweak = createFrequencyTweak(idf, 2 * NSS, fsample);
+        out.set(idf, [
+            applyTweak(base[0], tweak),
+            applyTweak(base[1], tweak),
+            applyTweak(base[2], tweak),
+            applyTweak(base[3], tweak),
+        ]);
     }
-    return tones;
+    return out;
 }
-/**
- * Mix f0 to baseband and decimate by NDOWN (60x) by extracting frequency bins.
- * Identical to Fortran ft8_downsample.
- */
-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);
+function createBaseSyncTemplates() {
+    return [
+        buildSyncTemplate(COSTAS_A),
+        buildSyncTemplate(COSTAS_B),
+        buildSyncTemplate(COSTAS_C),
+        buildSyncTemplate(COSTAS_D),
+    ];
+}
+function buildSyncTemplate(tones) {
+    const re = new Float64Array(2 * NSS);
+    const im = new Float64Array(2 * NSS);
     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;
+    let phi = 0;
+    for (const tone of tones) {
+        const dphi = (TWO_PI$2 * tone * 2) / NSS;
+        for (let j = 0; j < NSS / 2; j++) {
+            re[k] = Math.cos(phi);
+            im[k] = Math.sin(phi);
+            phi = (phi + dphi) % TWO_PI$2;
+            k++;
         }
     }
-    // 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;
+    return { re, im };
+}
+function createFrequencyTweak(idf, npts, fsample) {
+    const re = new Float64Array(npts);
+    const im = new Float64Array(npts);
+    const dphi = (TWO_PI$2 * idf) / fsample;
+    const stepRe = Math.cos(dphi);
+    const stepIm = Math.sin(dphi);
+    let wRe = 1;
+    let wIm = 0;
+    for (let i = 0; i < npts; i++) {
+        const newRe = wRe * stepRe - wIm * stepIm;
+        const newIm = wRe * stepIm + wIm * stepRe;
+        wRe = newRe;
+        wIm = newIm;
+        re[i] = wRe;
+        im[i] = wIm;
+    }
+    return { re, im };
+}
+function applyTweak(template, tweak) {
+    const re = new Float64Array(template.re.length);
+    const im = new Float64Array(template.im.length);
+    for (let i = 0; i < template.re.length; i++) {
+        const sr = template.re[i];
+        const si = template.im[i];
+        const tr = tweak.re[i];
+        const ti = tweak.im[i];
+        re[i] = tr * sr - ti * si;
+        im[i] = tr * si + ti * sr;
+    }
+    return { re, im };
+}
+function sync4d(cdRe, cdIm, i0, templates) {
+    let sync = 0;
+    for (let i = 0; i < COSTAS_BLOCKS$1; i++) {
+        const start = i0 + i * FT4_SYNC_STRIDE;
+        const z = correlateStride2(cdRe, cdIm, start, templates[i].re, templates[i].im);
+        if (z.count <= 16)
+            continue;
+        sync += Math.hypot(z.re, z.im) / (2 * NSS);
     }
+    return sync;
 }
-function sync8d(cd0Re, cd0Im, i0, twkRe, twkIm, useTwk) {
-    const NP2 = 2812;
-    const twopi = 2 * Math.PI;
-    // Precompute Costas sync waveforms
-    const csyncRe = new Float64Array(7 * 32);
-    const csyncIm = new Float64Array(7 * 32);
-    for (let i = 0; i < 7; i++) {
-        let phi = 0;
-        const dphi = (twopi * icos7[i]) / 32;
-        for (let j = 0; j < 32; j++) {
-            csyncRe[i * 32 + j] = Math.cos(phi);
-            csyncIm[i * 32 + j] = Math.sin(phi);
-            phi = (phi + dphi) % twopi;
+function correlateStride2(cdRe, cdIm, start, templateRe, templateIm) {
+    let zRe = 0;
+    let zIm = 0;
+    let count = 0;
+    for (let i = 0; i < templateRe.length; i++) {
+        const idx = start + 2 * i;
+        if (idx < 0 || idx >= cdRe.length)
+            continue;
+        const sRe = templateRe[i];
+        const sIm = templateIm[i];
+        const dRe = cdRe[idx];
+        const dIm = cdIm[idx];
+        zRe += dRe * sRe + dIm * sIm;
+        zIm += dIm * sRe - dRe * sIm;
+        count++;
+    }
+    return { re: zRe, im: zIm, count };
+}
+function buildBitMetrics$1(cdRe, cdIm, workspace) {
+    const { csRe, csIm, s4, symbRe, symbIm, bitmetrics1, bitmetrics2, bitmetrics3, s2 } = workspace;
+    for (let k = 0; k < NN$1; k++) {
+        const i1 = k * NSS;
+        for (let i = 0; i < NSS; i++) {
+            symbRe[i] = cdRe[i1 + i];
+            symbIm[i] = cdIm[i1 + i];
+        }
+        fftComplex(symbRe, symbIm, false);
+        for (let tone = 0; tone < 4; tone++) {
+            const idx = tone * NN$1 + k;
+            const re = symbRe[tone];
+            const im = symbIm[tone];
+            csRe[idx] = re;
+            csIm[idx] = im;
+            s4[idx] = Math.hypot(re, im);
         }
     }
-    let sync = 0;
-    for (let i = 0; i < 7; i++) {
-        const i1 = i0 + i * 32;
-        const i2 = i1 + 36 * 32;
-        const i3 = i1 + 72 * 32;
-        for (const iStart of [i1, i2, i3]) {
-            let zRe = 0, zIm = 0;
-            if (iStart >= 0 && iStart + 31 < NP2) {
-                for (let j = 0; j < 32; j++) {
-                    let sRe = csyncRe[i * 32 + j];
-                    let sIm = csyncIm[i * 32 + j];
-                    if (useTwk && twkRe && twkIm) {
-                        const tRe = twkRe[j] * sRe - twkIm[j] * sIm;
-                        const tIm = twkRe[j] * sIm + twkIm[j] * sRe;
-                        sRe = tRe;
-                        sIm = tIm;
+    let nsync = 0;
+    for (let k = 0; k < 4; k++) {
+        if (maxTone(s4, k) === COSTAS_A[k])
+            nsync++;
+        if (maxTone(s4, 33 + k) === COSTAS_B[k])
+            nsync++;
+        if (maxTone(s4, 66 + k) === COSTAS_C[k])
+            nsync++;
+        if (maxTone(s4, 99 + k) === COSTAS_D[k])
+            nsync++;
+    }
+    bitmetrics1.fill(0);
+    bitmetrics2.fill(0);
+    bitmetrics3.fill(0);
+    if (nsync < 6)
+        return true;
+    for (let nseq = 1; nseq <= 3; nseq++) {
+        const nsym = nseq === 1 ? 1 : nseq === 2 ? 2 : 4;
+        const nt = 1 << (2 * nsym);
+        const ibmax = nseq === 1 ? 1 : nseq === 2 ? 3 : 7;
+        for (let ks = 1; ks <= NN$1 - nsym + 1; ks += nsym) {
+            for (let i = 0; i < nt; i++) {
+                const i1 = Math.floor(i / 64);
+                const i2 = Math.floor((i & 63) / 16);
+                const i3 = Math.floor((i & 15) / 4);
+                const i4 = i & 3;
+                if (nsym === 1) {
+                    const t = GRAYMAP[i4];
+                    const idx = t * NN$1 + (ks - 1);
+                    s2[i] = Math.hypot(csRe[idx], csIm[idx]);
+                }
+                else if (nsym === 2) {
+                    const t3 = GRAYMAP[i3];
+                    const t4 = GRAYMAP[i4];
+                    const iA = t3 * NN$1 + (ks - 1);
+                    const iB = t4 * NN$1 + ks;
+                    const re = csRe[iA] + csRe[iB];
+                    const im = csIm[iA] + csIm[iB];
+                    s2[i] = Math.hypot(re, im);
+                }
+                else {
+                    const t1 = GRAYMAP[i1];
+                    const t2 = GRAYMAP[i2];
+                    const t3 = GRAYMAP[i3];
+                    const t4 = GRAYMAP[i4];
+                    const iA = t1 * NN$1 + (ks - 1);
+                    const iB = t2 * NN$1 + ks;
+                    const iC = t3 * NN$1 + (ks + 1);
+                    const iD = t4 * NN$1 + (ks + 2);
+                    const re = csRe[iA] + csRe[iB] + csRe[iC] + csRe[iD];
+                    const im = csIm[iA] + csIm[iB] + csIm[iC] + csIm[iD];
+                    s2[i] = Math.hypot(re, im);
+                }
+            }
+            const ipt = 1 + (ks - 1) * 2;
+            for (let ib = 0; ib <= ibmax; ib++) {
+                const mask = 1 << (ibmax - ib);
+                let max1 = -1e30;
+                let max0 = -1e30;
+                for (let i = 0; i < nt; i++) {
+                    const v = s2[i];
+                    if ((i & mask) !== 0) {
+                        if (v > max1)
+                            max1 = v;
                     }
-                    // Conjugate multiply: cd0 * conj(csync)
-                    const dRe = cd0Re[iStart + j];
-                    const dIm = cd0Im[iStart + j];
-                    zRe += dRe * sRe + dIm * sIm;
-                    zIm += dIm * sRe - dRe * sIm;
+                    else if (v > max0) {
+                        max0 = v;
+                    }
+                }
+                const idx = ipt + ib;
+                if (idx > BITMETRIC_LEN)
+                    continue;
+                const bm = max1 - max0;
+                if (nseq === 1) {
+                    bitmetrics1[idx - 1] = bm;
+                }
+                else if (nseq === 2) {
+                    bitmetrics2[idx - 1] = bm;
+                }
+                else {
+                    bitmetrics3[idx - 1] = bm;
                 }
             }
-            sync += zRe * zRe + zIm * zIm;
         }
     }
-    return sync;
+    bitmetrics2[208] = bitmetrics1[208];
+    bitmetrics2[209] = bitmetrics1[209];
+    bitmetrics3[208] = bitmetrics1[208];
+    bitmetrics3[209] = bitmetrics1[209];
+    normalizeBitMetrics(bitmetrics1);
+    normalizeBitMetrics(bitmetrics2);
+    normalizeBitMetrics(bitmetrics3);
+    return false;
 }
-function normalizeBmet(bmet) {
-    const n = bmet.length;
-    let sum = 0, sum2 = 0;
-    for (let i = 0; i < n; i++) {
+function maxTone(s4, symbolIndex) {
+    let bestTone = 0;
+    let bestValue = -1;
+    for (let tone = 0; tone < 4; tone++) {
+        const v = s4[tone * NN$1 + symbolIndex];
+        if (v > bestValue) {
+            bestValue = v;
+            bestTone = tone;
+        }
+    }
+    return bestTone;
+}
+function normalizeBitMetrics(bmet) {
+    let sum = 0;
+    let sum2 = 0;
+    for (let i = 0; i < bmet.length; i++) {
         sum += bmet[i];
         sum2 += bmet[i] * bmet[i];
     }
-    const avg = sum / n;
-    const avg2 = sum2 / n;
+    const avg = sum / bmet.length;
+    const avg2 = sum2 / bmet.length;
     const variance = avg2 - avg * avg;
     const sigma = variance > 0 ? Math.sqrt(variance) : Math.sqrt(avg2);
-    if (sigma > 0) {
-        for (let i = 0; i < n; i++)
-            bmet[i] = bmet[i] / sigma;
+    if (sigma <= 0)
+        return;
+    for (let i = 0; i < bmet.length; i++)
+        bmet[i] = bmet[i] / sigma;
+}
+function passesHardSyncQuality(bitmetrics1) {
+    const hard = new Uint8Array(bitmetrics1.length);
+    for (let i = 0; i < bitmetrics1.length; i++)
+        hard[i] = bitmetrics1[i] >= 0 ? 1 : 0;
+    let score = 0;
+    for (const pattern of HARD_SYNC_PATTERNS) {
+        for (let i = 0; i < pattern.bits.length; i++) {
+            if (hard[pattern.offset + i] === pattern.bits[i])
+                score++;
+        }
+    }
+    return score >= 10;
+}
+function buildLlrs(workspace) {
+    const { bitmetrics1, bitmetrics2, bitmetrics3, llra, llrb, llrc } = workspace;
+    for (let i = 0; i < 58; i++) {
+        llra[i] = bitmetrics1[8 + i];
+        llra[58 + i] = bitmetrics1[74 + i];
+        llra[116 + i] = bitmetrics1[140 + i];
+        llrb[i] = bitmetrics2[8 + i];
+        llrb[58 + i] = bitmetrics2[74 + i];
+        llrb[116 + i] = bitmetrics2[140 + i];
+        llrc[i] = bitmetrics3[8 + i];
+        llrc[58 + i] = bitmetrics3[74 + i];
+        llrc[116 + i] = bitmetrics3[140 + i];
     }
 }
-function resample(input, fromRate, toRate, outLen) {
+function tryDecodePasses$1(workspace, depth) {
+    const maxosd = depth >= 3 ? 2 : depth >= 2 ? 0 : -1;
+    const scalefac = 2.83;
+    const sources = [workspace.llra, workspace.llrb, workspace.llrc];
+    workspace.apmask.fill(0);
+    for (const src of sources) {
+        for (let i = 0; i < LDPC_BITS; i++)
+            workspace.llr[i] = scalefac * src[i];
+        const result = decode174_91(workspace.llr, workspace.apmask, maxosd);
+        if (result)
+            return result;
+    }
+    return null;
+}
+function hasNonZeroBit(bits) {
+    for (const bit of bits) {
+        if (bit !== 0)
+            return true;
+    }
+    return false;
+}
+function toFt4Snr(syncMinusOne) {
+    if (syncMinusOne > 0) {
+        return Math.round(Math.max(-21, 10 * Math.log10(syncMinusOne) - 14.8));
+    }
+    return -21;
+}
+function resample$1(input, fromRate, toRate, outLen) {
     const out = new Float64Array(outLen);
     const ratio = fromRate / toRate;
     for (let i = 0; i < outLen; i++) {
@@ -2046,10 +2275,10 @@ function packFreeText(msg) {
     return bits; // 77 bits
 }
 
-const TWO_PI = 2 * Math.PI;
-const DEFAULT_SAMPLE_RATE = 12_000;
-const DEFAULT_SAMPLES_PER_SYMBOL = 1_920;
-const DEFAULT_BT = 2.0;
+const TWO_PI$1 = 2 * Math.PI;
+const FT8_DEFAULT_SAMPLE_RATE = 12_000;
+const FT8_DEFAULT_SAMPLES_PER_SYMBOL = 1_920;
+const FT8_DEFAULT_BT = 2.0;
 const MODULATION_INDEX = 1.0;
 function assertPositiveFinite(value, name) {
     if (!Number.isFinite(value) || value <= 0) {
@@ -2072,33 +2301,36 @@ function gfskPulse(bt, tt) {
     const scale = Math.PI * Math.sqrt(2 / Math.log(2)) * bt;
     return 0.5 * (erfApprox(scale * (tt + 0.5)) - erfApprox(scale * (tt - 0.5)));
 }
-function generateFT8Waveform(tones, options = {}) {
-    // Mirrors the FT8 path in lib/ft8/gen_ft8wave.f90.
+function generateGfskWaveform(tones, options, defaults, shape) {
     const nsym = tones.length;
     if (nsym === 0) {
         return new Float32Array(0);
     }
-    const sampleRate = options.sampleRate ?? DEFAULT_SAMPLE_RATE;
-    const nsps = options.samplesPerSymbol ?? DEFAULT_SAMPLES_PER_SYMBOL;
-    const bt = options.bt ?? DEFAULT_BT;
+    const sampleRate = options.sampleRate ?? defaults.sampleRate;
+    const nsps = options.samplesPerSymbol ?? defaults.samplesPerSymbol;
+    const bt = options.bt ?? defaults.bt;
     const f0 = options.baseFrequency ?? 0;
+    const initialPhase = options.initialPhase ?? 0;
     assertPositiveFinite(sampleRate, "sampleRate");
     assertPositiveFinite(nsps, "samplesPerSymbol");
     assertPositiveFinite(bt, "bt");
     if (!Number.isFinite(f0)) {
         throw new Error("baseFrequency must be finite");
     }
+    if (!Number.isFinite(initialPhase)) {
+        throw new Error("initialPhase must be finite");
+    }
     if (!Number.isInteger(nsps)) {
         throw new Error("samplesPerSymbol must be an integer");
     }
-    const nwave = nsym * nsps;
+    const nwave = (nsym) * nsps;
     const pulse = new Float64Array(3 * nsps);
     for (let i = 0; i < pulse.length; i++) {
         const tt = (i + 1 - 1.5 * nsps) / nsps;
         pulse[i] = gfskPulse(bt, tt);
     }
     const dphi = new Float64Array((nsym + 2) * nsps);
-    const dphiPeak = (TWO_PI * MODULATION_INDEX) / nsps;
+    const dphiPeak = (TWO_PI$1 * MODULATION_INDEX) / nsps;
     for (let j = 0; j < nsym; j++) {
         const tone = tones[j];
         const ib = j * nsps;
@@ -2113,33 +2345,52 @@ function generateFT8Waveform(tones, options = {}) {
         dphi[i] += dphiPeak * firstTone * pulse[nsps + i];
         dphi[tailBase + i] += dphiPeak * lastTone * pulse[i];
     }
-    const carrierDphi = (TWO_PI * f0) / sampleRate;
+    const carrierDphi = (TWO_PI$1 * f0) / sampleRate;
     for (let i = 0; i < dphi.length; i++) {
         dphi[i] += carrierDphi;
     }
     const wave = new Float32Array(nwave);
-    let phi = 0;
+    let phi = initialPhase % TWO_PI$1;
+    if (phi < 0)
+        phi += TWO_PI$1;
+    const phaseStart = nsps;
     for (let k = 0; k < nwave; k++) {
-        const j = nsps + k; // skip the leading dummy symbol
+        const j = phaseStart + k;
         wave[k] = Math.sin(phi);
         phi += dphi[j];
-        phi %= TWO_PI;
+        phi %= TWO_PI$1;
         if (phi < 0) {
-            phi += TWO_PI;
+            phi += TWO_PI$1;
         }
     }
-    const nramp = Math.round(nsps / 8);
-    for (let i = 0; i < nramp; i++) {
-        const up = (1 - Math.cos((TWO_PI * i) / (2 * nramp))) / 2;
-        wave[i] *= up;
-    }
-    const tailStart = nwave - nramp;
-    for (let i = 0; i < nramp; i++) {
-        const down = (1 + Math.cos((TWO_PI * i) / (2 * nramp))) / 2;
-        wave[tailStart + i] *= down;
+    {
+        const nramp = Math.round(nsps / 8);
+        for (let i = 0; i < nramp; i++) {
+            const up = (1 - Math.cos((TWO_PI$1 * i) / (2 * nramp))) / 2;
+            wave[i] *= up;
+        }
+        const tailStart = nwave - nramp;
+        for (let i = 0; i < nramp; i++) {
+            const down = (1 + Math.cos((TWO_PI$1 * i) / (2 * nramp))) / 2;
+            wave[tailStart + i] *= down;
+        }
     }
     return wave;
 }
+function generateFT8Waveform(tones, options = {}) {
+    // Mirrors the FT8 path in lib/ft8/gen_ft8wave.f90.
+    return generateGfskWaveform(tones, options, {
+        sampleRate: FT8_DEFAULT_SAMPLE_RATE,
+        samplesPerSymbol: FT8_DEFAULT_SAMPLES_PER_SYMBOL,
+        bt: FT8_DEFAULT_BT,
+    });
+}
+
+/** FT8-specific constants (lib/ft8/ft8_params.f90). */
+/** 7-symbol Costas array for sync. */
+const COSTAS = [3, 1, 4, 0, 6, 5, 2];
+/** 8-tone Gray mapping. */
+const GRAY_MAP = [0, 1, 3, 2, 5, 6, 4, 7];
 
 function generateLdpcGMatrix() {
     const K = 91;
@@ -2190,21 +2441,21 @@ function encode174_91(msg77) {
     }
     return codeword;
 }
-function getTones(codeword) {
+function getTones$1(codeword) {
     const tones = new Array(79).fill(0);
     for (let i = 0; i < 7; i++)
-        tones[i] = icos7[i];
+        tones[i] = COSTAS[i];
     for (let i = 0; i < 7; i++)
-        tones[36 + i] = icos7[i];
+        tones[36 + i] = COSTAS[i];
     for (let i = 0; i < 7; i++)
-        tones[72 + i] = icos7[i];
+        tones[72 + i] = COSTAS[i];
     let k = 7;
     for (let j = 1; j <= 58; j++) {
         const i = j * 3 - 3; // codeword is 0-indexed in JS, but the loop was j=1 to 58
         if (j === 30)
             k += 7;
         const indx = codeword[i] * 4 + codeword[i + 1] * 2 + codeword[i + 2];
-        tones[k] = graymap[indx];
+        tones[k] = GRAY_MAP[indx];
         k++;
     }
     return tones;
@@ -2212,54 +2463,830 @@ function getTones(codeword) {
 function encodeMessage(msg) {
     const bits77 = pack77(msg);
     const codeword = encode174_91(bits77);
-    return getTones(codeword);
+    return getTones$1(codeword);
 }
 function encode(msg, options = {}) {
     return generateFT8Waveform(encodeMessage(msg), options);
 }
 
-/// <reference types="node" />
+const NSPS = 1920;
+const NFFT1 = 2 * NSPS; // 3840
+const NSTEP = NSPS / 4; // 480
+const NMAX = 15 * 12_000; // 180000
+const NHSYM = Math.floor(NMAX / NSTEP) - 3; // 372
+const NDOWN = 60;
+const NN = 79;
+const NFFT1_LONG = 192000;
+const NFFT2 = 3200;
+const NP2 = 2812;
+const COSTAS_BLOCKS = 7;
+const COSTAS_SYMBOL_LEN = 32;
+const SYNC_TIME_SHIFTS = [0, 36, 72];
+const TAPER_SIZE = 101;
+const TAPER_LAST = TAPER_SIZE - 1;
+const TWO_PI = 2 * Math.PI;
+const MAX_DECODE_PASSES_DEPTH3 = 2;
+const SUBTRACTION_GAIN = 0.95;
+const SUBTRACTION_PHASE_SHIFT = Math.PI / 2;
+const MIN_SUBTRACTION_SNR = -22;
+const FS2 = SAMPLE_RATE$1 / NDOWN;
+const DT2 = 1.0 / FS2;
+const DOWNSAMPLE_DF = SAMPLE_RATE$1 / NFFT1_LONG;
+const DOWNSAMPLE_BAUD = SAMPLE_RATE$1 / NSPS;
+const DOWNSAMPLE_SCALE = Math.sqrt(NFFT2 / NFFT1_LONG);
+const TAPER = buildTaper(TAPER_SIZE);
+const COSTAS_SYNC = buildCostasSyncTemplates();
+const FREQ_SHIFT_SYNC = buildFrequencyShiftSyncTemplates();
 /**
- * Parse a WAV file buffer into sample rate and normalized float samples.
- * Supports PCM format 1, 8/16/32-bit samples.
+ * Decode all FT8 signals in an audio buffer.
+ * Input: mono audio samples at `sampleRate` Hz, duration ~15s.
  */
-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)`);
+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;
+    const dd = sampleRate === SAMPLE_RATE$1
+        ? copySamplesToDecodeWindow(samples)
+        : resample(samples, sampleRate, SAMPLE_RATE$1, NMAX);
+    const residual = new Float64Array(dd);
+    const cxRe = new Float64Array(NFFT1_LONG);
+    const cxIm = new Float64Array(NFFT1_LONG);
+    const workspace = createDecodeWorkspace();
+    const toneCache = new Map();
+    const decoded = [];
+    const seenMessages = new Set();
+    const maxPasses = depth >= 3 ? MAX_DECODE_PASSES_DEPTH3 : 1;
+    for (let pass = 0; pass < maxPasses; pass++) {
+        cxRe.fill(0);
+        cxIm.fill(0);
+        cxRe.set(residual);
+        fftComplex(cxRe, cxIm, false);
+        const { candidates, sbase } = sync8(residual, nfa, nfb, syncmin, maxCandidates);
+        const coarseFrequencyUses = countCandidateFrequencies(candidates);
+        const coarseDownsampleCache = new Map();
+        let decodedInPass = 0;
+        for (const cand of candidates) {
+            const result = ft8b(residual, cxRe, cxIm, cand.freq, cand.dt, sbase, depth, book, workspace, coarseDownsampleCache, coarseFrequencyUses);
+            if (!result)
+                continue;
+            const messageKey = normalizeMessageKey(result.msg);
+            if (seenMessages.has(messageKey))
+                continue;
+            seenMessages.add(messageKey);
+            decoded.push({
+                freq: result.freq,
+                dt: result.dt - 0.5,
+                snr: result.snr,
+                msg: result.msg,
+                sync: cand.sync,
+            });
+            decodedInPass++;
+            if (pass + 1 < maxPasses) {
+                subtractDecodedSignal(residual, result, toneCache);
+            }
+        }
+        if (decodedInPass === 0)
+            break;
+    }
+    return decoded;
+}
+function normalizeMessageKey(msg) {
+    return msg.trim().replace(/\s+/g, " ").toUpperCase();
+}
+function countCandidateFrequencies(candidates) {
+    const counts = new Map();
+    for (const c of candidates) {
+        counts.set(c.freq, (counts.get(c.freq) ?? 0) + 1);
+    }
+    return counts;
+}
+function createDecodeWorkspace() {
+    return {
+        cd0Re: new Float64Array(NFFT2),
+        cd0Im: new Float64Array(NFFT2),
+        shiftRe: new Float64Array(NFFT2),
+        shiftIm: new Float64Array(NFFT2),
+        s8: new Float64Array(8 * NN),
+        csRe: new Float64Array(8 * NN),
+        csIm: new Float64Array(8 * NN),
+        symbRe: new Float64Array(COSTAS_SYMBOL_LEN),
+        symbIm: new Float64Array(COSTAS_SYMBOL_LEN),
+        s2: new Float64Array(1 << 9),
+        bmeta: new Float64Array(N_LDPC),
+        bmetb: new Float64Array(N_LDPC),
+        bmetc: new Float64Array(N_LDPC),
+        bmetd: new Float64Array(N_LDPC),
+        llr: new Float64Array(N_LDPC),
+        apmask: new Int8Array(N_LDPC),
+        ss: new Float64Array(9),
+    };
+}
+function copySamplesToDecodeWindow(samples) {
+    const out = new Float64Array(NMAX);
+    const len = Math.min(samples.length, NMAX);
+    for (let i = 0; i < len; i++)
+        out[i] = samples[i];
+    return out;
+}
+function sync8(dd, nfa, nfb, syncmin, maxcand) {
+    const JZ = 62;
+    const fftSize = nextPow2(NFFT1); // 4096
+    const halfSize = fftSize / 2;
+    const tstep = NSTEP / SAMPLE_RATE$1;
+    const df = SAMPLE_RATE$1 / fftSize;
+    const fac = 1.0 / 300.0;
+    const s = new Float64Array(halfSize * NHSYM);
+    const savg = new Float64Array(halfSize);
+    const xRe = new Float64Array(fftSize);
+    const xIm = new Float64Array(fftSize);
+    for (let j = 0; j < NHSYM; j++) {
+        const ia = j * NSTEP;
+        xRe.fill(0);
+        xIm.fill(0);
+        for (let i = 0; i < NSPS && ia + i < dd.length; i++)
+            xRe[i] = fac * dd[ia + i];
+        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;
+            savg[i] = savg[i] + power;
+        }
+    }
+    const sbase = computeBaseline(savg, nfa, nfb, df, halfSize);
+    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$1 / NSPS / df);
+    const jstrt = Math.round(0.5 / tstep);
+    const width = 2 * JZ + 1;
+    const sync2d = new Float64Array((ib - ia + 1) * width);
+    for (let i = ia; i <= ib; i++) {
+        for (let jj = -JZ; jj <= JZ; jj++) {
+            let ta = 0;
+            let tb = 0;
+            let tc = 0;
+            let t0a = 0;
+            let t0b = 0;
+            let t0c = 0;
+            for (let n = 0; n < COSTAS_BLOCKS; n++) {
+                const m = jj + jstrt + nssy * n;
+                const iCostas = i + nfos * COSTAS[n];
+                if (m >= 0 && m < NHSYM && iCostas < halfSize) {
+                    ta += s[iCostas * NHSYM + m];
+                    for (let tone = 0; tone <= 6; tone++) {
+                        const idx = i + nfos * tone;
+                        if (idx < halfSize)
+                            t0a += s[idx * NHSYM + m];
+                    }
+                }
+                const m36 = m + nssy * 36;
+                if (m36 >= 0 && m36 < NHSYM && iCostas < halfSize) {
+                    tb += s[iCostas * NHSYM + m36];
+                    for (let tone = 0; tone <= 6; tone++) {
+                        const idx = i + nfos * tone;
+                        if (idx < halfSize)
+                            t0b += s[idx * NHSYM + m36];
+                    }
+                }
+                const m72 = m + nssy * 72;
+                if (m72 >= 0 && m72 < NHSYM && iCostas < halfSize) {
+                    tc += s[iCostas * NHSYM + m72];
+                    for (let tone = 0; tone <= 6; tone++) {
+                        const idx = i + nfos * tone;
+                        if (idx < halfSize)
+                            t0c += s[idx * NHSYM + m72];
+                    }
+                }
+            }
+            const t = ta + tb + tc;
+            const t0 = (t0a + t0b + t0c - t) / 6.0;
+            const syncVal = t0 > 0 ? t / t0 : 0;
+            const tbc = tb + tc;
+            const t0bc = (t0b + t0c - tbc) / 6.0;
+            const syncBc = t0bc > 0 ? tbc / t0bc : 0;
+            sync2d[(i - ia) * width + (jj + JZ)] = Math.max(syncVal, syncBc);
+        }
+    }
+    const candidates0 = [];
+    const mlag = 10;
+    for (let i = ia; i <= ib; i++) {
+        let bestSync = -1;
+        let bestJ = 0;
+        for (let j = -mlag; j <= mlag; j++) {
+            const v = sync2d[(i - ia) * width + (j + JZ)];
+            if (v > bestSync) {
+                bestSync = v;
+                bestJ = j;
+            }
+        }
+        let bestSync2 = -1;
+        let bestJ2 = 0;
+        for (let j = -JZ; j <= JZ; j++) {
+            const v = sync2d[(i - ia) * width + (j + JZ)];
+            if (v > bestSync2) {
+                bestSync2 = v;
+                bestJ2 = j;
+            }
+        }
+        if (bestSync >= syncmin) {
+            candidates0.push({
+                freq: i * df,
+                dt: (bestJ - 0.5) * tstep,
+                sync: bestSync,
+            });
+        }
+        if (bestJ2 !== bestJ && bestSync2 >= syncmin) {
+            candidates0.push({
+                freq: i * df,
+                dt: (bestJ2 - 0.5) * tstep,
+                sync: bestSync2,
+            });
+        }
+    }
+    const syncValues = candidates0.map((c) => c.sync);
+    syncValues.sort((a, b) => a - b);
+    const pctileIdx = Math.max(0, Math.round(0.4 * syncValues.length) - 1);
+    const base = syncValues[pctileIdx] ?? 1;
+    if (base > 0) {
+        for (const c of candidates0)
+            c.sync /= base;
+    }
+    for (let i = 0; i < candidates0.length; i++) {
+        for (let j = 0; j < i; j++) {
+            const fdiff = Math.abs(candidates0[i].freq - candidates0[j].freq);
+            const tdiff = Math.abs(candidates0[i].dt - candidates0[j].dt);
+            if (fdiff < 4.0 && tdiff < 0.04) {
+                if (candidates0[i].sync >= candidates0[j].sync) {
+                    candidates0[j].sync = 0;
+                }
+                else {
+                    candidates0[i].sync = 0;
+                }
+            }
+        }
+    }
+    const filtered = candidates0.filter((c) => c.sync >= syncmin);
+    filtered.sort((a, b) => b.sync - a.sync);
+    return { candidates: filtered.slice(0, maxcand), sbase };
+}
+function computeBaseline(savg, nfa, nfb, df, nh1) {
+    const sbase = new Float64Array(nh1);
+    const ia = Math.max(1, Math.round(nfa / df));
+    const ib = Math.min(nh1 - 1, Math.round(nfb / df));
+    const window = 50;
+    for (let i = 0; i < nh1; i++) {
+        let sum = 0;
+        let count = 0;
+        const lo = Math.max(ia, i - window);
+        const hi = Math.min(ib, i + window);
+        for (let j = lo; j <= hi; j++) {
+            sum += savg[j];
+            count++;
+        }
+        sbase[i] = count > 0 ? 10 * Math.log10(Math.max(1e-30, sum / count)) : 0;
+    }
+    return sbase;
+}
+function ft8b(_dd0, cxRe, cxIm, f1, xdt, _sbase, depth, book, workspace, coarseDownsampleCache, coarseFrequencyUses) {
+    loadCoarseDownsample(cxRe, cxIm, f1, workspace, coarseDownsampleCache, coarseFrequencyUses);
+    let ibest = findBestTimeOffset(workspace.cd0Re, workspace.cd0Im, xdt);
+    const delfbest = findBestFrequencyShift(workspace.cd0Re, workspace.cd0Im, ibest);
+    f1 += delfbest;
+    ft8Downsample(cxRe, cxIm, f1, workspace);
+    ibest = refineTimeOffset(workspace.cd0Re, workspace.cd0Im, ibest, workspace.ss);
+    xdt = (ibest - 1) * DT2;
+    extractSoftSymbols(workspace.cd0Re, workspace.cd0Im, ibest, workspace);
+    const minCostasHits = depth >= 3 ? 6 : 7;
+    if (!passesSyncGate(workspace.s8, minCostasHits))
+        return null;
+    buildBitMetrics(workspace);
+    const result = tryDecodePasses(workspace, depth);
+    if (!result)
+        return null;
+    if (result.cw.every((b) => b === 0))
+        return null;
+    const message77 = result.message91.slice(0, 77);
+    if (!isValidMessageType(message77))
+        return null;
+    const { msg, success } = unpack77(message77, book);
+    if (!success || msg.trim().length === 0)
+        return null;
+    const snr = estimateSnr(workspace.s8, result.cw);
+    return { msg, freq: f1, dt: xdt, snr };
+}
+function loadCoarseDownsample(cxRe, cxIm, f0, workspace, coarseDownsampleCache, coarseFrequencyUses) {
+    const cached = coarseDownsampleCache.get(f0);
+    if (cached) {
+        workspace.cd0Re.set(cached.re);
+        workspace.cd0Im.set(cached.im);
+    }
+    else {
+        ft8Downsample(cxRe, cxIm, f0, workspace);
+        const uses = coarseFrequencyUses.get(f0) ?? 0;
+        if (uses > 1) {
+            coarseDownsampleCache.set(f0, {
+                re: new Float64Array(workspace.cd0Re),
+                im: new Float64Array(workspace.cd0Im),
+            });
+        }
+    }
+    const remaining = (coarseFrequencyUses.get(f0) ?? 1) - 1;
+    if (remaining <= 0) {
+        coarseFrequencyUses.delete(f0);
+        coarseDownsampleCache.delete(f0);
+    }
+    else {
+        coarseFrequencyUses.set(f0, remaining);
+    }
+}
+function findBestTimeOffset(cd0Re, cd0Im, xdt) {
+    const i0 = Math.round((xdt + 0.5) * FS2);
+    let smax = 0;
+    let ibest = i0;
+    for (let idt = i0 - 10; idt <= i0 + 10; idt++) {
+        const sync = sync8d(cd0Re, cd0Im, idt, COSTAS_SYNC.re, COSTAS_SYNC.im);
+        if (sync > smax) {
+            smax = sync;
+            ibest = idt;
+        }
+    }
+    return ibest;
+}
+function findBestFrequencyShift(cd0Re, cd0Im, ibest) {
+    let smax = 0;
+    let delfbest = 0;
+    for (const tpl of FREQ_SHIFT_SYNC) {
+        const sync = sync8d(cd0Re, cd0Im, ibest, tpl.re, tpl.im);
+        if (sync > smax) {
+            smax = sync;
+            delfbest = tpl.delf;
+        }
+    }
+    return delfbest;
+}
+function refineTimeOffset(cd0Re, cd0Im, ibest, ss) {
+    for (let idt = -4; idt <= 4; idt++) {
+        ss[idt + 4] = sync8d(cd0Re, cd0Im, ibest + idt, COSTAS_SYNC.re, COSTAS_SYNC.im);
+    }
+    let maxss = -1;
+    let maxIdx = 4;
+    for (let i = 0; i < 9; i++) {
+        if (ss[i] > maxss) {
+            maxss = ss[i];
+            maxIdx = i;
+        }
+    }
+    return ibest + maxIdx - 4;
+}
+function extractSoftSymbols(cd0Re, cd0Im, ibest, workspace) {
+    const { s8, csRe, csIm, symbRe, symbIm } = workspace;
+    for (let k = 0; k < NN; k++) {
+        const i1 = ibest + k * COSTAS_SYMBOL_LEN;
+        symbRe.fill(0);
+        symbIm.fill(0);
+        if (i1 >= 0 && i1 + COSTAS_SYMBOL_LEN - 1 < NP2) {
+            for (let j = 0; j < COSTAS_SYMBOL_LEN; j++) {
+                symbRe[j] = cd0Re[i1 + j];
+                symbIm[j] = cd0Im[i1 + j];
+            }
+        }
+        fftComplex(symbRe, symbIm, false);
+        for (let tone = 0; tone < 8; tone++) {
+            const re = symbRe[tone] / 1000;
+            const im = symbIm[tone] / 1000;
+            const idx = tone * NN + k;
+            csRe[idx] = re;
+            csIm[idx] = im;
+            s8[idx] = Math.sqrt(re * re + im * im);
+        }
+    }
+}
+function passesSyncGate(s8, minCostasHits) {
+    let nsync = 0;
+    for (let k = 0; k < COSTAS_BLOCKS; k++) {
+        for (const offset of SYNC_TIME_SHIFTS) {
+            let maxTone = 0;
+            let maxVal = -1;
+            for (let t = 0; t < 8; t++) {
+                const v = s8[t * NN + k + offset];
+                if (v > maxVal) {
+                    maxVal = v;
+                    maxTone = t;
+                }
+            }
+            if (maxTone === COSTAS[k])
+                nsync++;
+        }
+    }
+    return nsync >= minCostasHits;
+}
+function buildBitMetrics(workspace) {
+    const { csRe, csIm, bmeta, bmetb, bmetc, bmetd, s2 } = workspace;
+    bmeta.fill(0);
+    bmetb.fill(0);
+    bmetc.fill(0);
+    bmetd.fill(0);
+    for (let nsym = 1; nsym <= 3; nsym++) {
+        const nt = 1 << (3 * nsym);
+        const ibmax = nsym === 1 ? 2 : nsym === 2 ? 5 : 8;
+        for (let ihalf = 1; ihalf <= 2; ihalf++) {
+            for (let k = 1; k <= 29; k += nsym) {
+                const ks = ihalf === 1 ? k + 7 : k + 43;
+                for (let i = 0; i < nt; i++) {
+                    const i1 = Math.floor(i / 64);
+                    const i2 = Math.floor((i & 63) / 8);
+                    const i3 = i & 7;
+                    if (nsym === 1) {
+                        const re = csRe[GRAY_MAP[i3] * NN + ks - 1];
+                        const im = csIm[GRAY_MAP[i3] * NN + ks - 1];
+                        s2[i] = Math.sqrt(re * re + im * im);
+                    }
+                    else if (nsym === 2) {
+                        const sRe = csRe[GRAY_MAP[i2] * NN + ks - 1] + csRe[GRAY_MAP[i3] * NN + ks];
+                        const sIm = csIm[GRAY_MAP[i2] * NN + ks - 1] + csIm[GRAY_MAP[i3] * NN + ks];
+                        s2[i] = Math.sqrt(sRe * sRe + sIm * sIm);
+                    }
+                    else {
+                        const sRe = csRe[GRAY_MAP[i1] * NN + ks - 1] +
+                            csRe[GRAY_MAP[i2] * NN + ks] +
+                            csRe[GRAY_MAP[i3] * NN + ks + 1];
+                        const sIm = csIm[GRAY_MAP[i1] * NN + ks - 1] +
+                            csIm[GRAY_MAP[i2] * NN + ks] +
+                            csIm[GRAY_MAP[i3] * NN + ks + 1];
+                        s2[i] = Math.sqrt(sRe * sRe + sIm * sIm);
+                    }
+                }
+                const i32 = 1 + (k - 1) * 3 + (ihalf - 1) * 87;
+                for (let ib = 0; ib <= ibmax; ib++) {
+                    let max1 = -1e30;
+                    let max0 = -1e30;
+                    for (let i = 0; i < nt; i++) {
+                        const bitSet = (i & (1 << (ibmax - ib))) !== 0;
+                        if (bitSet) {
+                            if (s2[i] > max1)
+                                max1 = s2[i];
+                        }
+                        else {
+                            if (s2[i] > max0)
+                                max0 = s2[i];
+                        }
+                    }
+                    const idx = i32 + ib - 1;
+                    if (idx < 0 || idx >= N_LDPC)
+                        continue;
+                    const bm = max1 - max0;
+                    if (nsym === 1) {
+                        bmeta[idx] = bm;
+                        const den = Math.max(max1, max0);
+                        bmetd[idx] = den > 0 ? bm / den : 0;
+                    }
+                    else if (nsym === 2) {
+                        bmetb[idx] = bm;
+                    }
+                    else {
+                        bmetc[idx] = bm;
+                    }
+                }
+            }
+        }
+    }
+    normalizeBmet(bmeta);
+    normalizeBmet(bmetb);
+    normalizeBmet(bmetc);
+    normalizeBmet(bmetd);
+}
+function tryDecodePasses(workspace, depth) {
+    const scalefac = 2.83;
+    const maxosd = depth >= 3 ? 2 : depth >= 2 ? 0 : -1;
+    const bmetrics = [workspace.bmeta, workspace.bmetb, workspace.bmetc, workspace.bmetd];
+    workspace.apmask.fill(0);
+    for (let ipass = 0; ipass < 4; ipass++) {
+        const metric = bmetrics[ipass];
+        for (let i = 0; i < N_LDPC; i++)
+            workspace.llr[i] = scalefac * metric[i];
+        const result = decode174_91(workspace.llr, workspace.apmask, maxosd);
+        if (result && result.nharderrors >= 0 && result.nharderrors <= 36)
+            return result;
+    }
+    return null;
+}
+function isValidMessageType(message77) {
+    const n3v = (message77[71] << 2) | (message77[72] << 1) | message77[73];
+    const i3v = (message77[74] << 2) | (message77[75] << 1) | message77[76];
+    if (i3v > 5 || (i3v === 0 && n3v > 6))
+        return false;
+    if (i3v === 0 && n3v === 2)
+        return false;
+    return true;
+}
+function estimateSnr(s8, cw) {
+    let xsig = 0;
+    let xnoi = 0;
+    const itone = getTones(cw);
+    for (let i = 0; i < 79; i++) {
+        xsig += s8[itone[i] * NN + i] ** 2;
+        const ios = (itone[i] + 4) % 7;
+        xnoi += s8[ios * NN + i] ** 2;
+    }
+    let snr = 0.001;
+    const arg = xsig / Math.max(xnoi, 1e-30) - 1.0;
+    if (arg > 0.1)
+        snr = arg;
+    snr = 10 * Math.log10(snr) - 27.0;
+    return snr < -24 ? -24 : snr;
+}
+function getTones(cw) {
+    const tones = new Array(79).fill(0);
+    for (let i = 0; i < 7; i++)
+        tones[i] = COSTAS[i];
+    for (let i = 0; i < 7; i++)
+        tones[36 + i] = COSTAS[i];
+    for (let i = 0; i < 7; i++)
+        tones[72 + i] = COSTAS[i];
+    let k = 7;
+    for (let j = 1; j <= 58; j++) {
+        const i = (j - 1) * 3;
+        if (j === 30)
+            k += 7;
+        const indx = cw[i] * 4 + cw[i + 1] * 2 + cw[i + 2];
+        tones[k] = GRAY_MAP[indx];
+        k++;
+    }
+    return tones;
+}
+/**
+ * Mix f0 to baseband and decimate by NDOWN (60x) by extracting frequency bins.
+ * Identical to Fortran ft8_downsample.
+ */
+function ft8Downsample(cxRe, cxIm, f0, workspace) {
+    const { cd0Re, cd0Im, shiftRe, shiftIm } = workspace;
+    const df = DOWNSAMPLE_DF;
+    const baud = DOWNSAMPLE_BAUD;
+    const i0 = Math.round(f0 / df);
+    const ft = f0 + 8.5 * baud;
+    const it = Math.min(Math.round(ft / df), NFFT1_LONG / 2);
+    const fb = f0 - 1.5 * baud;
+    const ib = Math.max(1, Math.round(fb / df));
+    cd0Re.fill(0);
+    cd0Im.fill(0);
+    let k = 0;
+    for (let i = ib; i <= it; i++) {
+        if (k >= NFFT2)
+            break;
+        cd0Re[k] = cxRe[i];
+        cd0Im[k] = cxIm[i];
+        k++;
+    }
+    for (let i = 0; i <= TAPER_LAST; i++) {
+        if (i >= NFFT2)
+            break;
+        const tap = TAPER[TAPER_LAST - i];
+        cd0Re[i] = cd0Re[i] * tap;
+        cd0Im[i] = cd0Im[i] * tap;
+    }
+    const endTap = k - 1;
+    for (let i = 0; i <= TAPER_LAST; i++) {
+        const idx = endTap - TAPER_LAST + i;
+        if (idx >= 0 && idx < NFFT2) {
+            const tap = TAPER[i];
+            cd0Re[idx] = cd0Re[idx] * tap;
+            cd0Im[idx] = cd0Im[idx] * tap;
+        }
+    }
+    const shift = i0 - ib;
+    for (let i = 0; i < NFFT2; i++) {
+        let srcIdx = (i + shift) % NFFT2;
+        if (srcIdx < 0)
+            srcIdx += NFFT2;
+        shiftRe[i] = cd0Re[srcIdx];
+        shiftIm[i] = cd0Im[srcIdx];
+    }
+    for (let i = 0; i < NFFT2; i++) {
+        cd0Re[i] = shiftRe[i];
+        cd0Im[i] = shiftIm[i];
+    }
+    fftComplex(cd0Re, cd0Im, true);
+    for (let i = 0; i < NFFT2; i++) {
+        cd0Re[i] = cd0Re[i] * DOWNSAMPLE_SCALE;
+        cd0Im[i] = cd0Im[i] * DOWNSAMPLE_SCALE;
+    }
+}
+function sync8d(cd0Re, cd0Im, i0, syncRe, syncIm) {
+    let sync = 0;
+    const stride = 36 * COSTAS_SYMBOL_LEN;
+    for (let i = 0; i < COSTAS_BLOCKS; i++) {
+        const base = i * COSTAS_SYMBOL_LEN;
+        let iStart = i0 + i * COSTAS_SYMBOL_LEN;
+        for (let block = 0; block < 3; block++, iStart += stride) {
+            if (iStart < 0 || iStart + COSTAS_SYMBOL_LEN - 1 >= NP2)
+                continue;
+            let zRe = 0;
+            let zIm = 0;
+            for (let j = 0; j < COSTAS_SYMBOL_LEN; j++) {
+                const sRe = syncRe[base + j];
+                const sIm = syncIm[base + j];
+                const dRe = cd0Re[iStart + j];
+                const dIm = cd0Im[iStart + j];
+                zRe += dRe * sRe + dIm * sIm;
+                zIm += dIm * sRe - dRe * sIm;
+            }
+            sync += zRe * zRe + zIm * zIm;
+        }
+    }
+    return sync;
+}
+function normalizeBmet(bmet) {
+    const n = bmet.length;
+    let sum = 0;
+    let sum2 = 0;
+    for (let i = 0; i < n; i++) {
+        sum += bmet[i];
+        sum2 += bmet[i] * bmet[i];
+    }
+    const avg = sum / n;
+    const avg2 = sum2 / n;
+    const variance = avg2 - avg * avg;
+    const sigma = variance > 0 ? Math.sqrt(variance) : Math.sqrt(avg2);
+    if (sigma > 0) {
+        for (let i = 0; i < n; i++)
+            bmet[i] = bmet[i] / sigma;
+    }
+}
+function resample(input, fromRate, toRate, outLen) {
+    const out = new Float64Array(outLen);
+    const ratio = fromRate / toRate;
+    for (let i = 0; i < outLen; i++) {
+        const srcIdx = i * ratio;
+        const lo = Math.floor(srcIdx);
+        const frac = srcIdx - lo;
+        const v0 = lo < input.length ? (input[lo] ?? 0) : 0;
+        const v1 = lo + 1 < input.length ? (input[lo + 1] ?? 0) : 0;
+        out[i] = v0 * (1 - frac) + v1 * frac;
+    }
+    return out;
+}
+function subtractDecodedSignal(residual, result, toneCache) {
+    if (result.snr < MIN_SUBTRACTION_SNR)
+        return;
+    const msgKey = normalizeMessageKey(result.msg);
+    let tones = toneCache.get(msgKey);
+    if (!tones) {
+        try {
+            tones = encodeMessage(result.msg);
+        }
+        catch {
+            return;
+        }
+        toneCache.set(msgKey, tones);
+    }
+    const waveI = generateFT8Waveform(tones, {
+        sampleRate: SAMPLE_RATE$1,
+        samplesPerSymbol: NSPS,
+        baseFrequency: result.freq,
+        initialPhase: 0,
+    });
+    const waveQ = generateFT8Waveform(tones, {
+        sampleRate: SAMPLE_RATE$1,
+        samplesPerSymbol: NSPS,
+        baseFrequency: result.freq,
+        initialPhase: SUBTRACTION_PHASE_SHIFT,
+    });
+    const start = Math.round(result.dt * SAMPLE_RATE$1);
+    let srcStart = start;
+    let tplStart = 0;
+    if (srcStart < 0) {
+        tplStart = -srcStart;
+        srcStart = 0;
+    }
+    const maxLen = Math.min(residual.length - srcStart, waveI.length - tplStart, waveQ.length - tplStart);
+    if (maxLen <= 0)
+        return;
+    let sii = 0;
+    let sqq = 0;
+    let siq = 0;
+    let sri = 0;
+    let srq = 0;
+    for (let i = 0; i < maxLen; i++) {
+        const wi = waveI[tplStart + i];
+        const wq = waveQ[tplStart + i];
+        const rv = residual[srcStart + i];
+        sii += wi * wi;
+        sqq += wq * wq;
+        siq += wi * wq;
+        sri += rv * wi;
+        srq += rv * wq;
+    }
+    const det = sii * sqq - siq * siq;
+    if (det <= 1e-9)
+        return;
+    const ampI = (sri * sqq - srq * siq) / det;
+    const ampQ = (srq * sii - sri * siq) / det;
+    for (let i = 0; i < maxLen; i++) {
+        const wi = waveI[tplStart + i];
+        const wq = waveQ[tplStart + i];
+        const idx = srcStart + i;
+        residual[idx] = residual[idx] - SUBTRACTION_GAIN * (ampI * wi + ampQ * wq);
+    }
+}
+function buildTaper(size) {
+    const taper = new Float64Array(size);
+    const last = size - 1;
+    for (let i = 0; i < size; i++)
+        taper[i] = 0.5 * (1.0 + Math.cos((i * Math.PI) / last));
+    return taper;
+}
+function buildCostasSyncTemplates() {
+    const re = new Float64Array(COSTAS_BLOCKS * COSTAS_SYMBOL_LEN);
+    const im = new Float64Array(COSTAS_BLOCKS * COSTAS_SYMBOL_LEN);
+    for (let i = 0; i < COSTAS_BLOCKS; i++) {
+        let phi = 0;
+        const dphi = (TWO_PI * COSTAS[i]) / COSTAS_SYMBOL_LEN;
+        for (let j = 0; j < COSTAS_SYMBOL_LEN; j++) {
+            re[i * COSTAS_SYMBOL_LEN + j] = Math.cos(phi);
+            im[i * COSTAS_SYMBOL_LEN + j] = Math.sin(phi);
+            phi = (phi + dphi) % TWO_PI;
+        }
+    }
+    return { re, im };
+}
+function buildFrequencyShiftSyncTemplates() {
+    const templates = [];
+    for (let ifr = -5; ifr <= 5; ifr++) {
+        const delf = ifr * 0.5;
+        const dphi = TWO_PI * delf * DT2;
+        const twkRe = new Float64Array(COSTAS_SYMBOL_LEN);
+        const twkIm = new Float64Array(COSTAS_SYMBOL_LEN);
+        let phi = 0;
+        for (let j = 0; j < COSTAS_SYMBOL_LEN; j++) {
+            twkRe[j] = Math.cos(phi);
+            twkIm[j] = Math.sin(phi);
+            phi = (phi + dphi) % TWO_PI;
+        }
+        const re = new Float64Array(COSTAS_BLOCKS * COSTAS_SYMBOL_LEN);
+        const im = new Float64Array(COSTAS_BLOCKS * COSTAS_SYMBOL_LEN);
+        for (let i = 0; i < COSTAS_BLOCKS; i++) {
+            const base = i * COSTAS_SYMBOL_LEN;
+            for (let j = 0; j < COSTAS_SYMBOL_LEN; j++) {
+                const idx = base + j;
+                const csRe = COSTAS_SYNC.re[idx];
+                const csIm = COSTAS_SYNC.im[idx];
+                const tRe = twkRe[j] * csRe - twkIm[j] * csIm;
+                const tIm = twkRe[j] * csIm + twkIm[j] * csRe;
+                re[idx] = tRe;
+                im[idx] = tIm;
+            }
+        }
+        templates.push({ delf, re, im });
+    }
+    return templates;
+}
+
+/// <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;
@@ -2341,9 +3368,11 @@ Usage:
   ft8ts encode "<message>" [options]
 
 Decode options:
+  --mode <ft8|ft4>  Mode: ft8 (default) or ft4
   --low <hz>     Lower frequency bound (default: 200)
   --high <hz>    Upper frequency bound (default: 3000)
   --depth <1|2|3>  Decoding depth (default: 2)
+  --max-candidates <n>  Max candidate signals to decode (default: 300)
 
 Encode options:
   --out <file>   Output WAV file (default: output.wav)
@@ -2364,9 +3393,19 @@ function runDecode(argv) {
     }
     const wavFile = argv[0];
     const options = {};
+    let mode = "ft8";
     for (let i = 1; i < argv.length; i++) {
         const arg = argv[i];
-        if (arg === "--low") {
+        if (arg === "--mode") {
+            const value = argv[++i];
+            if (value === "ft8" || value === "ft4") {
+                mode = value;
+            }
+            else {
+                throw new Error(`Invalid --mode: ${value ?? "(missing)"}. Use ft8 or ft4`);
+            }
+        }
+        else if (arg === "--low") {
             options.freqLow = Number(argv[++i]);
         }
         else if (arg === "--high") {
@@ -2375,6 +3414,9 @@ function runDecode(argv) {
         else if (arg === "--depth") {
             options.depth = Number(argv[++i]);
         }
+        else if (arg === "--max-candidates") {
+            options.maxCandidates = Number(argv[++i]);
+        }
         else {
             throw new Error(`Unknown argument: ${arg}`);
         }
@@ -2384,7 +3426,9 @@ function runDecode(argv) {
     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 decoded = mode === "ft4"
+        ? decode$1(samples, { ...options, sampleRate })
+        : 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");