Js8 Test

Run an end-to-end JS8 message round-trip between two virtual rigs: each station sends a directed message from the compose box, and the other must decode it into its feed. Drive both browsers via Playwright MCP, screenshot both sides, tear down. Bench-only (virtual rigs, no hardware, no real RF) — this tests wfweb's JS8 codec against itself, not interop with real JS8Call.

Sibling of packet-test / ft8-test / cw-test; reuses the same bench (scripts/testrig.sh) and Playwright lifecycle. JS8 is browser-side WASM like FT8, so it shares FT8's RX-audio gate and slot timing. Read "Pitfalls" before debugging.

Prerequisites (verify before starting; fix and stop if missing)

1. ./wfweb and ./tools/virtualrig/virtualrig are built. If not: qmake wfweb.pro && make -j$(nproc) and cd tools/virtualrig && qmake && make -j$(nproc).
2. Repo .mcp.json includes --ignore-https-errors for the playwright MCP. Verify: pgrep -af @playwright/mcp must show --ignore-https-errors. If .mcp.json was just edited, the user must restart Claude Code (a /mcp reconnect re-uses cached args). Stop and tell them.
3. Load the playwright tools via ToolSearch: select:mcp__playwright__browser_navigate,mcp__playwright__browser_snapshot,mcp__playwright__browser_click,mcp__playwright__browser_type,mcp__playwright__browser_take_screenshot,mcp__playwright__browser_wait_for,mcp__playwright__browser_evaluate,mcp__playwright__browser_close,mcp__playwright__browser_tabs,mcp__playwright__browser_select_option.

Boot the bench

./scripts/testrig.sh up 2

Both rigs come up on 14.074.000. Opening the JS8 panel auto-retunes each rig to the JS8 dial frequency for the band (14.078.000 on 20 m) and forces USB — both move together, so they stay matched and audio gates.

• A → https://127.0.0.1:9080 (virtual-IC7300-A)
• B → https://127.0.0.1:9090 (virtual-IC7300-B)

Per-tab UI bring-up (do for both A and B)

The JS8 panel is an overlay (#js8Bar), opened from the MODE overlay's JS8 button — it's a peer of the FT8 DIGI bar (opening one closes the other).

1. browser_navigate to the rig URL.
2. Wipe stale browser state: browser_evaluate () => { localStorage.clear(); sessionStorage.clear(); }, then browser_navigate to the same URL again. (Note: JS8 persists js8Open=1, so without the wipe a reload reopens the panel mid-init.)
3. Click the CLICK TO START splash (gesture needed for AudioContext).
4. Wait for RX audio. JS8's decoder is fed by window._js8ProcessAudioChunk, which the host audio path only calls when audio is flowing. The splash enables it ~1 s asynchronously — poll until window.audioEnabled === true before continuing.
5. Open the JS8 panel: window.toggleJs8Bar() (equivalently MODE → JS8). This forces USB, retunes to the JS8 dial freq, creates the decoder, and enables RX. Confirm window.js8MessengerVisible() === true and window.js8Diag().rxEnabled === true.
6. Set MY CALL: open settings (#js8SettingsBtn), set #js8SettingMycall, then close (#js8SettingsCloseBtn). The callsign is committed to the shared station call (window.App.callsign) on close, not on input — so you must click close. Verify window.App.callsign.get() returns it.
   • A: W1AAA. B: W1BBB. (Shared station call — same field feeds CW/FT8/FreeDV/APRS.)
   • Submode is also read on close; the default JS8 Normal · 15 s (submode 0) is fine. RX decodes all submodes regardless, so the TX submode only affects the sender's frame timing.

When refs go stale across snapshots, drive directly via browser_evaluate with stable IDs (the normal path, not a fallback):

• Buttons: js8SettingsBtn, js8SettingsCloseBtn, js8SendBtn, js8RxToggle, js8TuneBtn, js8CloseBtn
• Fields: js8DxCall (the TO target — authoritative), js8Compose (message text), js8SettingMycall, js8SubmodeSel
• Feed (decoded + sent messages): #js8Feed .textContent ← assert on this. Rows read <ts><from>→<target>│<msg><snr>dB; your own sent rows show SENT n/n.
• Functions (global): toggleJs8Bar(), js8MessengerVisible(), js8Diag() (returns {rxEnabled, txBusy, submode, decodes, audioChunks, …}), js8ClearFeed()
• Note: the internal state object S is not on window (unlike window.Packet.state). Use js8Diag() for status and read #js8Feed for messages.

QSO sequence (single bidirectional run)

1. A → send directed message: on tab A, set #js8DxCall to W1BBB (dispatch input), set #js8Compose to HELLO (dispatch input), click #js8SendBtn. This routes through enqueueTx, which slot-aligns the transmission. Use the compose+send path — do NOT use window.txJs8() (a raw 12-char test hook that streams un-slot-aligned audio and won't reliably decode).
2. Confirm A transmits: poll window.js8Diag().txBusy — it goes true on the next slot boundary, then false when done. A's own feed row shows W1AAA→W1BBB │ HELLO SENT 2/2. A short message is ~2 frames; with the wait-for-slot + TX time this takes ~25–35 s at Normal.
3. Read B's copy: on tab B, poll #js8Feed.textContent until it contains both W1AAA and HELLO (allow ~30 s after A finishes). On the clean virtual channel the decode is solid (SNR ~+20 dB). Assert tolerantly — require the sender call and a recognizable chunk of the message, not byte-exact.
4. B → reply: on tab B, set #js8DxCall to W1AAA, #js8Compose to GE TNX, click #js8SendBtn.
5. Read A's copy: on tab A, poll #js8Feed until it contains W1BBB and GE.
6. Screenshot both with browser_take_screenshot, fullPage: true. Save as .playwright-mcp/wfweb-js8-A.png and ...-B.png. (Bare names land in the project root; /tmp is rejected — the MCP roots are the project dir and .playwright-mcp/.)