Spaces:

RemiFabre
/

morse-code

Running

RemiFabre commited on Jun 1

Commit

843a4b2

0 Parent(s):

feat: initial Reachy Mini Morse Code app

Talk to Reachy Mini in Morse: the robot transmits by clapping its antennas
(each hit = an audible click), the phone/laptop transmits with beeps, and any
device (or a second Mini) decodes incoming hits live through its mic.

- Onset-only impulse wire code (dot=1 tap, dash=2 taps) so robot clicks,
phone beeps and robot<->robot all share one detector.
- Transient-onset detector ported from the Marionette audio-sync tests
(highpass -> 5ms energy -> spectral flux -> peak pick), offline + streaming.
- Compose / Listen / Learn UI, mobile-first, host-shell + CDN SDK (sdk: static).
- 42 unit tests (codec, detector round-trip, view DOM) + browser smoke tests.

Files changed (33) hide show

.gitattributes +2 -0
.gitignore +5 -0
README.md +82 -0
index.html +62 -0
lib/animation-helpers.js +15 -0
lib/detector.js +179 -0
lib/mic.js +106 -0
lib/morse.js +113 -0
lib/robot-tapper.js +119 -0
lib/synth.js +86 -0
lib/timing.js +59 -0
lib/version.js +3 -0
lib/viz.js +89 -0
lib/wire.js +114 -0
main.js +172 -0
package-lock.json +2018 -0
package.json +17 -0
plan.md +111 -0
playwright.config.js +19 -0
public/icon.svg +17 -0
style.css +290 -0
tests/e2e/smoke.spec.js +34 -0
tests/stubs/animation-helpers.js +10 -0
tests/unit/detector.test.js +98 -0
tests/unit/morse.test.js +71 -0
tests/unit/views.test.js +96 -0
tests/unit/wire.test.js +73 -0
views/compose.js +164 -0
views/dom.js +44 -0
views/learn.js +66 -0
views/listen.js +116 -0
views/settings.js +66 -0
vitest.config.js +20 -0

.gitattributes ADDED Viewed

	@@ -0,0 +1,2 @@


1	+ *.mp3 filter=lfs diff=lfs merge=lfs -text
2	+ *.wav filter=lfs diff=lfs merge=lfs -text

.gitignore ADDED Viewed

	@@ -0,0 +1,5 @@

+.DS_Store
+node_modules/
+test-results/
+playwright-report/
+.env

README.md ADDED Viewed

	@@ -0,0 +1,82 @@

+---
+title: Morse Code
+emoji: 📡
+colorFrom: blue
+colorTo: purple
+sdk: static
+pinned: false
+hf_oauth: true
+hf_oauth_expiration_minutes: 480
+hf_oauth_scopes:
+  - read-repos
+  - write-repos
+  - manage-repos
+short_description: Talk to Reachy Mini in Morse — antenna taps, beeps, mic decode.
+tags:
+- reachy_mini
+- reachy_mini_js_app
+---
+# Morse Code
+Make your Reachy Mini speak and understand **Morse code**. The robot transmits
+by *clapping its antennas together* — each hit is an audible click. Your phone
+or laptop can transmit too, with beeps. Either device (or a **second Reachy
+Mini** sitting across the table) listens through its microphone, detects the
+hits, and decodes them back to text in real time.
+Open the Space URL, sign in with Hugging Face, pick your robot. No install.
+## Three tabs
+- **Compose** — type a message, see its Morse, and pick who sends it: the
+  robot's antennas or this device's speaker. Watch it transmit.
+- **Listen** — turn on the mic and decode incoming clicks/beeps live, with a
+  scope that drops a marker on every detected hit.
+- **Learn** — the letter ↔ rhythm chart. Tap any tile to *feel* the rhythm
+  (a letter is just a pattern of short and long beats).
+## How it works (the impulse wire code)
+An antenna hit is **impulsive** — one short click. You can't hold a click long
+the way you hold a tone, so classic "short tone = dot, long tone = dash" can't
+work on the robot. Instead every channel here uses one **onset-only** code so a
+tapping robot, a beeping phone, and a second robot are all mutually
+intelligible through a single detector:
+- **dot** = one impulse
+- **dash** = a quick double-tap (two impulses)
+- letters and words are separated by progressively longer gaps
+It's still real Morse — the Learn chart shows the standard `·–` patterns — just
+carried as a rhythm of hits instead of tone length.
+Detection is a transient-onset detector (high-pass → short-term energy →
+spectral flux → peak pick) ported from the Marionette audio-sync tests and
+validated end-to-end against synthetic audio (`npm test`). All timing and
+detection thresholds live in Settings, so the robot clap and mic sensitivity
+can be calibrated on real hardware without code changes.
+## Develop
+```bash
+npm install
+npm test          # unit tests: morse codec, wire code, detector round-trip
+npm run test:e2e  # playwright (optional)
+```
+No build step — `sdk: static`, the host shell + SDK load from jsDelivr. Local
+dev: serve the folder (e.g. `python3 -m http.server`) and open with a
+`?embedded=1`-capable dev token, or just push to the Space.
+### SDK pin
+`@pollen-robotics/reachy-mini-sdk@1.8.0-rc1-main.dbe26af`, pinned in three
+places that must stay in sync: the two `modulepreload` links in `index.html`,
+the two import URLs in `main.js`, and the re-export in
+`lib/animation-helpers.js`.
+## Credits
+Built for Reachy Mini by Pollen Robotics. Antenna-collision recipe and the
+transient detector adapted from the Marionette project.

index.html ADDED Viewed

	@@ -0,0 +1,62 @@

+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover" />
+<title>Morse Code · Reachy Mini</title>
+<meta name="description" content="Talk to Reachy Mini in Morse code — antenna taps and beeps, decoded live through the mic." />
+<meta name="theme-color" content="#0d1117" />
+<link rel="icon" type="image/svg+xml" href="public/icon.svg" />
+<link rel="preconnect" href="https://fonts.googleapis.com" />
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+<link rel="preconnect" href="https://cdn.jsdelivr.net" crossorigin />
+<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800&family=JetBrains+Mono:wght@500;700&display=swap" rel="stylesheet" />
+<link rel="stylesheet" href="style.css" />
+<!-- Modern host-shell SDK entries (standalone → host/auto = mountHost;
+     embedded iframe → host/embed = connectToHost). Pinned to the exact
+     tarball the Pollen reference apps + marionette-js ship against so
+     SDK / host / daemon stay in lockstep. Bumping it means editing these
+     two links AND the two import URLs in main.js AND lib/animation-helpers.js. -->
+<link rel="modulepreload" href="https://cdn.jsdelivr.net/npm/@pollen-robotics/reachy-mini-sdk@1.8.0-rc1-main.dbe26af/host/dist/entry/auto.js" crossorigin />
+<link rel="modulepreload" href="https://cdn.jsdelivr.net/npm/@pollen-robotics/reachy-mini-sdk@1.8.0-rc1-main.dbe26af/host/dist/entry/embed.js" crossorigin />
+<!-- HF Spaces helper variables. In production (sdk: static + hf_oauth: true)
+     HF rewrites these placeholders at serve time and the SDK reads them off
+     window.huggingface.variables. Locally the placeholders stay raw (leading
+     __) so we drop the global and mountHost() falls back to the dev path. -->
+<script>
+  (function () {
+    var clientId = "__OAUTH_CLIENT_ID__";
+    var scopes = "__OAUTH_SCOPES__";
+    var spaceHost = "__SPACE_HOST__";
+    var spaceId = "__SPACE_ID__";
+    var looksSubstituted = clientId && clientId.indexOf("__") !== 0;
+    if (looksSubstituted) {
+      window.huggingface = window.huggingface || {};
+      window.huggingface.variables = {
+        OAUTH_CLIENT_ID: clientId,
+        OAUTH_SCOPES: scopes && scopes.indexOf("__") !== 0 ? scopes : "openid profile",
+        SPACE_HOST: spaceHost && spaceHost.indexOf("__") !== 0 ? spaceHost : "",
+        SPACE_ID: spaceId && spaceId.indexOf("__") !== 0 ? spaceId : "",
+      };
+    }
+  })();
+</script>
+<!-- `process` shim: the CDN-loaded host bundle expects a bundler to have
+     substituted process.env.NODE_ENV; loaded raw it would throw. -->
+<script>
+  globalThis.process ??= { env: {} };
+  globalThis.process.env ??= {};
+  globalThis.process.env.NODE_ENV ??= 'production';
+</script>
+</head>
+<body>
+<!-- Host shell mount point (standalone): sign-in, robot picker, top bar. -->
+<div id="root"></div>
+<!-- In-iframe app surface, revealed once connectToHost() resolves. -->
+<div id="app" hidden></div>
+<script type="module" src="main.js"></script>
+</body>
+</html>

lib/animation-helpers.js ADDED Viewed

	@@ -0,0 +1,15 @@

+// Re-export of the SDK's /animation subpath, indirected through this short
+// stable path so the rest of the app imports motion helpers from one place
+// AND vitest can alias this single module to a stub (Node's ESM loader can't
+// resolve `https:` imports). If you bump the SDK pin here, also bump the two
+// import URLs in main.js and the two modulepreload links in index.html — they
+// must all match (silent protocol drift otherwise). See README "SDK pin".
+export {
+    INIT_POSE,
+    INIT_ANTENNAS_RAD,
+    DEFAULT_SCALED_DURATION_PRESET,
+    distanceBetweenPoses,
+    scaledDuration,
+    safelyReturnToPose,
+    installShutdownHandler,
+} from "https://cdn.jsdelivr.net/npm/@pollen-robotics/reachy-mini-sdk@1.8.0-rc1-main.dbe26af/dist/animation/index.js";

lib/detector.js ADDED Viewed

	@@ -0,0 +1,179 @@

+/**
+ * Transient-onset detector — clicks (antenna hits) and short beeps.
+ *
+ * Ported from marionette/tests/audio_analysis.py `detect_transient_onsets`:
+ *   highpass -> short-term energy (5 ms windows) -> spectral flux
+ *   (positive energy differences) -> peak pick with min separation.
+ *
+ * Two entry points sharing the same DSP core:
+ *   - detectTransientOnsets(samples, sr, opts): pure, offline. Used by unit
+ *     tests (synthetic audio) and the visualizer (on recorded buffers).
+ *   - StreamingOnsetDetector: live mic. The highpass is done by a Web Audio
+ *     BiquadFilterNode upstream; this class consumes filtered blocks and
+ *     emits onsets in real time with an adaptive (noise-floor) threshold.
+ *
+ * Onset times are in MILLISECONDS to match wire.js / timing.js.
+ */
+// ──────── Pure DSP ────────────────────────────────────────────────
+/**
+ * Single 2nd-order Butterworth high-pass (RBJ cookbook). Cascade twice for
+ * a ~4th-order roll-off (matches the Python `butter(4, ...)` intent).
+ */
+export function biquadHighpassOnce(samples, sr, fc, q = Math.SQRT1_2) {
+    const w0 = (2 * Math.PI * fc) / sr;
+    const cos = Math.cos(w0);
+    const sin = Math.sin(w0);
+    const alpha = sin / (2 * q);
+    const b0 = (1 + cos) / 2;
+    const b1 = -(1 + cos);
+    const b2 = (1 + cos) / 2;
+    const a0 = 1 + alpha;
+    const a1 = -2 * cos;
+    const a2 = 1 - alpha;
+    const nb0 = b0 / a0, nb1 = b1 / a0, nb2 = b2 / a0, na1 = a1 / a0, na2 = a2 / a0;
+    const out = new Float64Array(samples.length);
+    let x1 = 0, x2 = 0, y1 = 0, y2 = 0;
+    for (let i = 0; i < samples.length; i++) {
+        const x0 = samples[i];
+        const y0 = nb0 * x0 + nb1 * x1 + nb2 * x2 - na1 * y1 - na2 * y2;
+        x2 = x1; x1 = x0; y2 = y1; y1 = y0;
+        out[i] = y0;
+    }
+    return out;
+}
+export function highpass(samples, sr, fc) {
+    return biquadHighpassOnce(biquadHighpassOnce(samples, sr, fc), sr, fc);
+}
+/**
+ * Short-term energy per non-overlapping window, then positive flux.
+ * @returns {{flux:Float64Array, winSamples:number}}
+ */
+export function energyFlux(filtered, sr, winMs = 5) {
+    const winSamples = Math.max(1, Math.round((winMs / 1000) * sr));
+    const nWin = Math.floor(filtered.length / winSamples);
+    const energy = new Float64Array(nWin);
+    for (let w = 0; w < nWin; w++) {
+        let e = 0;
+        const base = w * winSamples;
+        for (let j = 0; j < winSamples; j++) {
+            const v = filtered[base + j];
+            e += v * v;
+        }
+        energy[w] = e;
+    }
+    const flux = new Float64Array(Math.max(0, nWin - 1));
+    for (let i = 1; i < nWin; i++) flux[i - 1] = Math.max(0, energy[i] - energy[i - 1]);
+    return { flux, winSamples };
+}
+/**
+ * Offline transient detection on a full buffer.
+ * @returns {number[]} onset times in ms.
+ */
+export function detectTransientOnsets(samples, sr, opts = {}) {
+    const { highpassHz = 2000, winMs = 5, thresholdRatio = 0.1, minSepMs = 150 } = opts;
+    if (!samples || samples.length < sr * (winMs / 1000) * 2) return [];
+    const filtered = highpass(samples, sr, highpassHz);
+    const { flux, winSamples } = energyFlux(filtered, sr, winMs);
+    if (flux.length < 2) return [];
+    let peak = 0;
+    for (let i = 0; i < flux.length; i++) if (flux[i] > peak) peak = flux[i];
+    if (peak < 1e-12) return [];
+    const threshold = peak * thresholdRatio;
+    const minDistWin = Math.max(1, Math.round((minSepMs / 1000) * sr / winSamples));
+    // local-maxima peak pick with min distance (mirrors scipy find_peaks)
+    const onsets = [];
+    let lastPeakWin = -Infinity;
+    for (let i = 1; i < flux.length - 1; i++) {
+        if (flux[i] < threshold) continue;
+        if (flux[i] < flux[i - 1] || flux[i] < flux[i + 1]) continue; // local max
+        if (i - lastPeakWin < minDistWin) {
+            // keep the stronger of the two within the refractory window
+            if (onsets.length && flux[i] > flux[lastPeakWin]) {
+                onsets[onsets.length - 1] = ((i * winSamples) / sr) * 1000;
+                lastPeakWin = i;
+            }
+            continue;
+        }
+        onsets.push(((i * winSamples) / sr) * 1000);
+        lastPeakWin = i;
+    }
+    return onsets;
+}
+// ──────── Streaming (live mic) ─────────────────────────────────────
+/**
+ * Adaptive, real-time onset detector fed by filtered audio blocks.
+ *
+ * Threshold adapts to a slowly-tracked noise floor so it works without a
+ * global maximum (impossible to know live). An onset fires when the flux
+ * spikes well above the floor and the refractory window has elapsed.
+ */
+export class StreamingOnsetDetector {
+    /**
+     * @param {object} o
+     * @param {number} o.sampleRate
+     * @param {(timeMs:number, strength:number)=>void} o.onOnset
+     * @param {number} [o.winMs]            energy window (ms)
+     * @param {number} [o.refractoryMs]     min gap between onsets
+     * @param {number} [o.thresholdFactor]  flux must exceed floor*factor
+     * @param {number} [o.absMin]           absolute floor on flux energy
+     */
+    constructor(o) {
+        this.sr = o.sampleRate;
+        this.onOnset = o.onOnset;
+        this.winMs = o.winMs ?? 5;
+        this.refractoryMs = o.refractoryMs ?? 120;
+        this.thresholdFactor = o.thresholdFactor ?? 4.0;
+        this.absMin = o.absMin ?? 1e-5;
+        this.winSamples = Math.max(1, Math.round((this.winMs / 1000) * this.sr));
+        this._acc = 0; // energy accumulator for current window
+        this._accN = 0;
+        this._winIndex = 0; // running window counter since start
+        this._prevEnergy = null;
+        this._floor = this.absMin; // EMA noise floor of flux
+        this._lastOnsetMs = -Infinity;
+        // EMA coefficient (~300 ms time constant on the flux floor)
+        const tau = 0.3;
+        this._alpha = Math.exp(-(this.winMs / 1000) / tau);
+    }
+    /** Feed one block of already-highpassed samples. baseTimeMs = block start. */
+    process(block, baseTimeMs) {
+        for (let i = 0; i < block.length; i++) {
+            const v = block[i];
+            this._acc += v * v;
+            this._accN += 1;
+            if (this._accN >= this.winSamples) {
+                const energy = this._acc;
+                const winTimeMs = baseTimeMs + ((i + 1) / this.sr) * 1000;
+                this._onWindow(energy, winTimeMs);
+                this._acc = 0;
+                this._accN = 0;
+                this._winIndex += 1;
+            }
+        }
+    }
+    _onWindow(energy, timeMs) {
+        if (this._prevEnergy !== null) {
+            const flux = Math.max(0, energy - this._prevEnergy);
+            const trigger = Math.max(this.absMin, this._floor * this.thresholdFactor);
+            if (flux > trigger && timeMs - this._lastOnsetMs >= this.refractoryMs) {
+                this._lastOnsetMs = timeMs;
+                this.onOnset?.(timeMs, flux);
+            } else {
+                // only let the floor track quiet/background frames
+                this._floor = this._alpha * this._floor + (1 - this._alpha) * flux;
+            }
+        }
+        this._prevEnergy = energy;
+    }
+}

lib/mic.js ADDED Viewed

	@@ -0,0 +1,106 @@

+/**
+ * Live microphone capture → onset stream.
+ *
+ * Web Audio graph:
+ *   getUserMedia → MediaStreamSource → BiquadFilter(highpass) →
+ *   ScriptProcessor → (muted gain → destination, just to keep it pumping)
+ *
+ * The ScriptProcessor receives already-high-passed blocks and feeds them to
+ * the StreamingOnsetDetector (lib/detector.js). Each detected onset is
+ * reported with a session-relative timestamp (ms) suitable for wire.js
+ * decoding. A level callback drives the visualizer.
+ *
+ * Browser audio "enhancements" (echo cancellation, noise suppression, auto
+ * gain) are explicitly DISABLED — they treat sharp clicks as noise and would
+ * gut exactly the signal we need.
+ */
+import { StreamingOnsetDetector } from "./detector.js";
+export class Mic {
+    /**
+     * @param {object} o
+     * @param {(timeMs:number, strength:number)=>void} o.onOnset
+     * @param {(level:number, wave:Float32Array)=>void} [o.onLevel]
+     * @param {number} [o.highpassHz]
+     * @param {object} [o.detector] extra StreamingOnsetDetector options
+     */
+    constructor(o) {
+        this.opts = o;
+        this.highpassHz = o.highpassHz ?? 2000;
+        this.ctx = null;
+        this.stream = null;
+        this._nodes = [];
+        this._detector = null;
+        this._elapsedMs = 0;
+        this.running = false;
+    }
+    async start() {
+        const AC = window.AudioContext || window.webkitAudioContext;
+        this.stream = await navigator.mediaDevices.getUserMedia({
+            audio: {
+                echoCancellation: false,
+                noiseSuppression: false,
+                autoGainControl: false,
+                channelCount: 1,
+            },
+        });
+        this.ctx = new AC();
+        if (this.ctx.state === "suspended") await this.ctx.resume();
+        const sr = this.ctx.sampleRate;
+        const src = this.ctx.createMediaStreamSource(this.stream);
+        const hp = this.ctx.createBiquadFilter();
+        hp.type = "highpass";
+        hp.frequency.value = this.highpassHz;
+        hp.Q.value = Math.SQRT1_2;
+        const bufferSize = 2048;
+        const proc = this.ctx.createScriptProcessor(bufferSize, 1, 1);
+        const mute = this.ctx.createGain();
+        mute.gain.value = 0;
+        this._detector = new StreamingOnsetDetector({
+            sampleRate: sr,
+            onOnset: (timeMs, strength) => this.opts.onOnset?.(timeMs, strength),
+            ...(this.opts.detector || {}),
+        });
+        this._elapsedMs = 0;
+        this.running = true;
+        proc.onaudioprocess = (e) => {
+            if (!this.running) return;
+            const block = e.inputBuffer.getChannelData(0);
+            const base = this._elapsedMs;
+            this._detector.process(block, base);
+            this._elapsedMs += (block.length / sr) * 1000;
+            if (this.opts.onLevel) {
+                let sum = 0;
+                for (let i = 0; i < block.length; i++) sum += block[i] * block[i];
+                this.opts.onLevel(Math.sqrt(sum / block.length), block);
+            }
+        };
+        src.connect(hp);
+        hp.connect(proc);
+        proc.connect(mute);
+        mute.connect(this.ctx.destination);
+        this._nodes = [src, hp, proc, mute];
+    }
+    /** Current session clock (ms since start) — handy to time out a message. */
+    now() {
+        return this._elapsedMs;
+    }
+    async stop() {
+        this.running = false;
+        this._nodes.forEach((n) => { try { n.disconnect(); } catch { /* */ } });
+        this._nodes = [];
+        if (this.stream) {
+            this.stream.getTracks().forEach((t) => t.stop());
+            this.stream = null;
+        }
+        if (this.ctx) { try { await this.ctx.close(); } catch { /* */ } this.ctx = null; }
+    }
+}

lib/morse.js ADDED Viewed

	@@ -0,0 +1,113 @@

+/**
+ * Morse code tables + text <-> morse-string conversion.
+ *
+ * A "morse string" here uses the conventional ASCII rendering:
+ *   - '.'  dot
+ *   - '-'  dash
+ *   - ' '  (single space) gap between letters
+ *   - '/'  gap between words (we accept ' / ' or '/' on input)
+ *
+ * Example: "SOS" <-> "... --- ..."
+ *
+ * This module is pure (no DOM, no audio, no SDK) so it is unit-tested
+ * directly in Node. The physical *timing* of dots/dashes lives in
+ * wire.js + timing.js; this layer is purely symbolic.
+ */
+// International Morse (ITU): letters, digits, and the common punctuation
+// that survives an impulse channel. Prosigns are intentionally omitted.
+export const CHAR_TO_MORSE = Object.freeze({
+    A: ".-", B: "-...", C: "-.-.", D: "-..", E: ".", F: "..-.",
+    G: "--.", H: "....", I: "..", J: ".---", K: "-.-", L: ".-..",
+    M: "--", N: "-.", O: "---", P: ".--.", Q: "--.-", R: ".-.",
+    S: "...", T: "-", U: "..-", V: "...-", W: ".--", X: "-..-",
+    Y: "-.--", Z: "--..",
+    0: "-----", 1: ".----", 2: "..---", 3: "...--", 4: "....-",
+    5: ".....", 6: "-....", 7: "--...", 8: "---..", 9: "----.",
+    ".": ".-.-.-", ",": "--..--", "?": "..--..", "'": ".----.",
+    "!": "-.-.--", "/": "-..-.", "(": "-.--.", ")": "-.--.-",
+    "&": ".-...", ":": "---...", ";": "-.-.-.", "=": "-...-",
+    "+": ".-.-.", "-": "-....-", "_": "..--.-", '"': ".-..-.",
+    "$": "...-..-", "@": ".--.-.",
+});
+// Reverse lookup: morse pattern -> character.
+export const MORSE_TO_CHAR = Object.freeze(
+    Object.fromEntries(Object.entries(CHAR_TO_MORSE).map(([c, m]) => [m, c])),
+);
+/** True if `ch` (single char) can be transmitted. Case-insensitive. */
+export function isEncodable(ch) {
+    return Object.prototype.hasOwnProperty.call(CHAR_TO_MORSE, ch.toUpperCase());
+}
+/**
+ * Encode arbitrary text to a morse string.
+ *
+ * - Case-insensitive.
+ * - Runs of whitespace collapse to a single word break ('/').
+ * - Unknown characters are dropped, but reported in `.skipped` so the UI
+ *   can warn ("é, 😀 can't be sent in Morse").
+ *
+ * Returns { morse, skipped }.
+ */
+export function textToMorse(text) {
+    const words = String(text).trim().toUpperCase().split(/\s+/).filter(Boolean);
+    const skipped = [];
+    const encodedWords = words.map((word) => {
+        const letters = [];
+        for (const ch of word) {
+            const code = CHAR_TO_MORSE[ch];
+            if (code) letters.push(code);
+            else skipped.push(ch);
+        }
+        return letters.join(" ");
+    }).filter(Boolean);
+    return { morse: encodedWords.join(" / "), skipped };
+}
+/**
+ * Decode a morse string back to text. Tolerant of input shape:
+ *   "... --- ...", "...|---|...", "-.-. -.-- / -.-." etc.
+ * Letter separators: one or more spaces. Word separators: '/' (optionally
+ * space-padded). Unknown patterns become '?'.
+ */
+export function morseToText(morse) {
+    return String(morse)
+        .trim()
+        .split(/\s*\/\s*|\s{2,}\/?\s*/) // word breaks
+        .map((word) =>
+            word
+                .trim()
+                .split(/\s+/)
+                .filter(Boolean)
+                .map((pat) => MORSE_TO_CHAR[pat] ?? (pat ? "?" : ""))
+                .join(""),
+        )
+        .filter((w) => w.length > 0)
+        .join(" ");
+}
+/**
+ * Flatten a morse string into the element/gap token stream the wire layer
+ * consumes. Tokens:
+ *   'dot' | 'dah' | 'elemGap' | 'letterGap' | 'wordGap'
+ *
+ * No leading/trailing gaps are emitted.
+ */
+export function morseToTokens(morse) {
+    const tokens = [];
+    const words = String(morse).trim().split(/\s*\/\s*/).filter(Boolean);
+    words.forEach((word, wi) => {
+        if (wi > 0) tokens.push("wordGap");
+        const letters = word.trim().split(/\s+/).filter(Boolean);
+        letters.forEach((letter, li) => {
+            if (li > 0) tokens.push("letterGap");
+            [...letter].forEach((sym, si) => {
+                if (si > 0) tokens.push("elemGap");
+                tokens.push(sym === "." ? "dot" : "dah");
+            });
+        });
+    });
+    return tokens;
+}

lib/robot-tapper.js ADDED Viewed

	@@ -0,0 +1,119 @@

+/**
+ * Robot transmitter: claps the two antennas together on schedule so each
+ * onset produces an audible click. Consumes the same onset schedule from
+ * wire.js that the speaker Synth uses, so robot and device speak one wire code.
+ *
+ * Physics (from marionette/tests/test_antenna_collision.py, proven safe):
+ *   - Right antenna held at a fixed angle.
+ *   - Left antenna slams in past the contact point and is commanded to hold
+ *     briefly — the low-PID antennas stall at contact (no damage) and make a
+ *     crisp click — then returns to rest.
+ *
+ * We drive it in real time with `reachy.setAntennasDeg(right, left)` at
+ * ~50 Hz, shaping the left antenna's target as a function of time. All
+ * geometry/timing is configurable so it can be calibrated on hardware
+ * (contact angle, hold, command→sound latency) without touching logic.
+ */
+export const DEFAULT_TAP_PROFILE = Object.freeze({
+    rightRestDeg: -39, // right antenna held here (≈ -0.68 rad)
+    leftRestDeg: 0, // left antenna resting position
+    collisionDeg: 40, // left commanded past contact (~34°) so it stalls + clicks
+    approachMs: 80, // ramp rest → collision
+    holdMs: 50, // dwell at collision (stall against right antenna)
+    returnMs: 80, // ramp back to rest
+    rateHz: 50, // command rate
+    leadMs: 0, // advance whole timeline to offset command→sound latency
+});
+export class RobotTapper {
+    constructor(reachy, profile = {}) {
+        this.reachy = reachy;
+        this.p = { ...DEFAULT_TAP_PROFILE, ...profile };
+        this._timer = null;
+    }
+    /** Left-antenna angle (deg) at time `t` ms, given the slam windows. */
+    _leftAngleAt(t, onsets) {
+        const { leftRestDeg, collisionDeg, approachMs, holdMs } = this.p;
+        for (const T of onsets) {
+            const a0 = T - approachMs; // start approaching
+            const hEnd = T + holdMs; // end of hold
+            const rEnd = hEnd + this.p.returnMs; // back to rest
+            if (t < a0 || t > rEnd) continue;
+            if (t <= T) {
+                const f = approachMs > 0 ? (t - a0) / approachMs : 1;
+                return leftRestDeg + (collisionDeg - leftRestDeg) * easeIn(f);
+            }
+            if (t <= hEnd) return collisionDeg;
+            const f = (t - hEnd) / this.p.returnMs;
+            return collisionDeg + (leftRestDeg - collisionDeg) * easeOut(f);
+        }
+        return leftRestDeg;
+    }
+    /**
+     * Run the clap timeline.
+     * @param {number[]} onsetsMs
+     * @param {object} [o]
+     * @param {(i:number)=>void} [o.onTap] fires near each impact (UI highlight)
+     * @param {AbortSignal} [o.signal]
+     * @returns {Promise<void>} resolves when the sequence completes/aborts
+     */
+    tap(onsetsMs, { onTap, signal } = {}) {
+        const onsets = onsetsMs.map((t) => t - this.p.leadMs);
+        const period = Math.max(10, Math.round(1000 / this.p.rateHz));
+        const endMs = (onsets.length ? onsets[onsets.length - 1] : 0)
+            + this.p.holdMs + this.p.returnMs + 200;
+        return new Promise((resolve) => {
+            const t0 = performance.now();
+            let nextTapIdx = 0;
+            const tapMarks = onsetsMs.slice(); // original (UI) onset times
+            const finish = () => {
+                clearInterval(this._timer);
+                this._timer = null;
+                // settle antennas back to rest
+                try { this.reachy.setAntennasDeg(this.p.rightRestDeg, this.p.leftRestDeg); } catch { /* ignore */ }
+                resolve();
+            };
+            signal?.addEventListener("abort", finish, { once: true });
+            this._timer = setInterval(() => {
+                const t = performance.now() - t0;
+                if (t > endMs || signal?.aborted) return finish();
+                const left = this._leftAngleAt(t, onsets);
+                try {
+                    this.reachy.setAntennasDeg(this.p.rightRestDeg, left);
+                } catch { /* transient send errors are non-fatal */ }
+                // UI tap highlight when we cross an original onset time
+                while (nextTapIdx < tapMarks.length && t >= tapMarks[nextTapIdx]) {
+                    onTap?.(nextTapIdx);
+                    nextTapIdx += 1;
+                }
+            }, period);
+        });
+    }
+    /** One calibration clap right now (no schedule). */
+    async testClap() {
+        await this.tap([100]);
+    }
+    stop() {
+        if (this._timer) {
+            clearInterval(this._timer);
+            this._timer = null;
+        }
+        try { this.reachy.setAntennasDeg(this.p.rightRestDeg, this.p.leftRestDeg); } catch { /* ignore */ }
+    }
+}
+function easeIn(x) {
+    const c = Math.min(1, Math.max(0, x));
+    return c * c; // accelerate into the impact
+}
+function easeOut(x) {
+    const c = Math.min(1, Math.max(0, x));
+    return 1 - (1 - c) * (1 - c);
+}

lib/synth.js ADDED Viewed

	@@ -0,0 +1,86 @@

+/**
+ * Web Audio emitter — plays an onset schedule as audible clicks/beeps from
+ * the device speaker (phone or laptop). This is the "device transmits" path;
+ * the robot path lives in robot-tapper.js. Both consume the same schedule
+ * from wire.js, so a beeping phone and a tapping robot are interoperable.
+ *
+ * Each onset is a short percussive blip: a fast-decaying tone with a hard
+ * attack so the listener's onset detector keys cleanly off its start. The
+ * default tone sits in the detector's high-pass band (~2 kHz+) for a clean,
+ * Morse-buzzer feel.
+ */
+export class Synth {
+    constructor({ freq = 2200, clickMs = 50 } = {}) {
+        this.freq = freq;
+        this.clickMs = clickMs;
+        this.ctx = null;
+        this._stopFns = [];
+    }
+    _ensureCtx() {
+        if (!this.ctx) {
+            const AC = window.AudioContext || window.webkitAudioContext;
+            this.ctx = new AC();
+        }
+        if (this.ctx.state === "suspended") this.ctx.resume();
+        return this.ctx;
+    }
+    /** Schedule one blip at AudioContext time `when` (seconds). */
+    _blip(when, { freq = this.freq, durMs = this.clickMs } = {}) {
+        const ctx = this.ctx;
+        const osc = ctx.createOscillator();
+        const gain = ctx.createGain();
+        osc.type = "sine";
+        osc.frequency.value = freq;
+        const dur = durMs / 1000;
+        // Hard attack (1 ms), exponential-ish decay → percussive click.
+        gain.gain.setValueAtTime(0.0001, when);
+        gain.gain.exponentialRampToValueAtTime(0.9, when + 0.001);
+        gain.gain.exponentialRampToValueAtTime(0.0001, when + dur);
+        osc.connect(gain).connect(ctx.destination);
+        osc.start(when);
+        osc.stop(when + dur + 0.02);
+    }
+    /**
+     * Play a schedule (onset times in ms from start).
+     * @param {number[]} onsetsMs
+     * @param {object} [o]
+     * @param {(i:number, total:number)=>void} [o.onBlip] progress per blip
+     * @param {()=>void} [o.onDone]
+     * @returns {()=>void} cancel function
+     */
+    play(onsetsMs, { onBlip, onDone, clickMs } = {}) {
+        const ctx = this._ensureCtx();
+        const t0 = ctx.currentTime + 0.08; // small lead so the first blip isn't clipped
+        const dur = clickMs ?? this.clickMs;
+        onsetsMs.forEach((ms) => this._blip(t0 + ms / 1000, { durMs: dur }));
+        // UI progress + completion via wall-clock timers (audio is sample-accurate;
+        // these are just for the highlight animation).
+        const startWall = performance.now();
+        const total = onsetsMs.length;
+        const timers = [];
+        onsetsMs.forEach((ms, i) => {
+            timers.push(setTimeout(() => onBlip?.(i, total), ms + 80));
+        });
+        const endMs = (onsetsMs.length ? onsetsMs[onsetsMs.length - 1] : 0) + dur + 120;
+        const doneTimer = setTimeout(() => onDone?.(), endMs);
+        const cancel = () => {
+            timers.forEach(clearTimeout);
+            clearTimeout(doneTimer);
+        };
+        this._stopFns.push(cancel);
+        void startWall;
+        return cancel;
+    }
+    /** Cancel any pending UI timers (scheduled audio blips are tiny and let ring). */
+    stop() {
+        this._stopFns.forEach((fn) => fn());
+        this._stopFns = [];
+    }
+}

lib/timing.js ADDED Viewed

	@@ -0,0 +1,59 @@

+/**
+ * Timing configuration for the impulse wire code.
+ *
+ * Everything is expressed as a multiple of one base `unitMs`, the single
+ * speed knob. The gap hierarchy must stay well-separated so the decoder can
+ * bin each inter-onset interval unambiguously:
+ *
+ *   dahGapMs  < elemGapMs < letterGapMs < wordGapMs
+ *
+ * Defaults are deliberately *slow and robust* (large gaps) — through-air
+ * impulse detection with room reverb needs generous spacing. Calibration on
+ * real hardware can tighten these; nothing in the codec hard-codes a value.
+ *
+ * Note: the detector enforces a minimum onset separation (~150-200 ms) to
+ * reject reverb tails, so `dahGapMs` (the *smallest* meaningful gap, between
+ * the two taps of a dash) must stay comfortably above that floor.
+ */
+/**
+ * Build a full timing profile from a base unit.
+ *
+ * @param {number} unitMs base time unit in milliseconds
+ * @returns {{unitMs:number, dahGapMs:number, elemGapMs:number,
+ *            letterGapMs:number, wordGapMs:number, clickMs:number,
+ *            decisions:{elem:number, letter:number, word:number}}}
+ */
+export function makeTiming(unitMs = 120) {
+    const u = Math.max(40, Math.round(unitMs));
+    const dahGapMs = 2 * u; // between the two taps of a dash
+    const elemGapMs = 4 * u; // between elements of one letter
+    const letterGapMs = 8 * u; // between letters
+    const wordGapMs = 14 * u; // between words
+    return Object.freeze({
+        unitMs: u,
+        dahGapMs,
+        elemGapMs,
+        letterGapMs,
+        wordGapMs,
+        // Nominal audible click length on the speaker (synth only). The
+        // detector keys off onsets, so this does not affect decoding.
+        clickMs: Math.min(60, Math.round(u * 0.5)),
+        // Decision boundaries (geometric midpoints) used by the decoder to
+        // classify an observed inter-onset interval into a gap class.
+        decisions: Object.freeze({
+            elem: Math.round(Math.sqrt(dahGapMs * elemGapMs)), // dah|elem split
+            letter: Math.round(Math.sqrt(elemGapMs * letterGapMs)),
+            word: Math.round(Math.sqrt(letterGapMs * wordGapMs)),
+        }),
+    });
+}
+/** Named speed presets (unit in ms). Smaller = faster. */
+export const SPEED_PRESETS = Object.freeze({
+    relaxed: 160,
+    normal: 120,
+    brisk: 90,
+});
+export const DEFAULT_TIMING = makeTiming(SPEED_PRESETS.normal);

lib/version.js ADDED Viewed

	@@ -0,0 +1,3 @@

+// Deployment version label, shown in Settings so you can verify which build
+// is actually loaded after a push. Format: "YYYY-MM-DD rN", bumped on push.
+export const APP_VERSION = "2026-06-01 r1 initial";

lib/viz.js ADDED Viewed

	@@ -0,0 +1,89 @@

+/**
+ * Canvas visualizer: a scrolling level meter with vertical markers at each
+ * detected onset, plus a recent-waveform trace. Purely presentational; it
+ * reads values pushed from the Mic level callback and onset events.
+ */
+export class Scope {
+    constructor(canvas) {
+        this.canvas = canvas;
+        this.ctx = canvas.getContext("2d");
+        this.level = new Float32Array(600); // ring buffer of recent levels
+        this.head = 0;
+        this.onsets = []; // {age} markers scrolling left
+        this._raf = null;
+        this._peak = 0.02;
+    }
+    pushLevel(level) {
+        this.level[this.head] = level;
+        this.head = (this.head + 1) % this.level.length;
+        if (level > this._peak) this._peak = level;
+        else this._peak = this._peak * 0.999 + level * 0.001;
+    }
+    markOnset() {
+        // a marker positioned at the current write head
+        this.onsets.push({ pos: this.head });
+        if (this.onsets.length > 64) this.onsets.shift();
+    }
+    start() {
+        const draw = () => {
+            this._draw();
+            this._raf = requestAnimationFrame(draw);
+        };
+        draw();
+    }
+    stop() {
+        if (this._raf) cancelAnimationFrame(this._raf);
+        this._raf = null;
+    }
+    _draw() {
+        const { ctx, canvas } = this;
+        const dpr = window.devicePixelRatio || 1;
+        const w = canvas.clientWidth, h = canvas.clientHeight;
+        if (canvas.width !== w * dpr || canvas.height !== h * dpr) {
+            canvas.width = w * dpr; canvas.height = h * dpr;
+        }
+        ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+        const css = getComputedStyle(canvas);
+        ctx.clearRect(0, 0, w, h);
+        const n = this.level.length;
+        const scale = 1 / (this._peak * 1.4 + 1e-6);
+        const mid = h / 2;
+        // level fill
+        ctx.beginPath();
+        ctx.moveTo(0, mid);
+        for (let i = 0; i < n; i++) {
+            const idx = (this.head + i) % n;
+            const x = (i / n) * w;
+            const v = Math.min(1, this.level[idx] * scale);
+            ctx.lineTo(x, mid - v * (h * 0.45));
+        }
+        for (let i = n - 1; i >= 0; i--) {
+            const idx = (this.head + i) % n;
+            const x = (i / n) * w;
+            const v = Math.min(1, this.level[idx] * scale);
+            ctx.lineTo(x, mid + v * (h * 0.45));
+        }
+        ctx.closePath();
+        ctx.fillStyle = css.getPropertyValue("--scope-fill") || "rgba(120,160,255,0.5)";
+        ctx.fill();
+        // onset markers (their stored head pos maps to a position in the ring)
+        ctx.strokeStyle = css.getPropertyValue("--scope-mark") || "rgba(255,90,120,0.9)";
+        ctx.lineWidth = 2;
+        for (const o of this.onsets) {
+            let rel = (o.pos - this.head + n) % n; // distance behind head
+            const x = (rel / n) * w;
+            ctx.beginPath();
+            ctx.moveTo(x, 4);
+            ctx.lineTo(x, h - 4);
+            ctx.stroke();
+        }
+    }
+}

lib/wire.js ADDED Viewed

	@@ -0,0 +1,114 @@

+/**
+ * The "wire code": the bridge between symbolic Morse and physical impulses.
+ *
+ * Encoding (emit):  morse tokens -> a schedule of onset times (ms from start).
+ *   - dot  = 1 impulse
+ *   - dash = 2 impulses spaced by `dahGapMs`
+ *   - elem/letter/word gaps advance the cursor between elements
+ *
+ * Decoding (listen): a list of detected onset times (ms) -> morse -> text.
+ *   - Cluster onsets separated by < the dah/elem decision boundary into one
+ *     element (1 impulse = dot, >=2 = dash).
+ *   - Classify the gap between clusters as elem / letter / word.
+ *
+ * Onset-only: nothing here depends on how *long* a sound is, so a robot's
+ * antenna click and a phone's short beep are the same on the wire. Pure
+ * module (no DOM / audio / SDK) — unit-tested directly.
+ */
+import { morseToTokens, morseToText, textToMorse } from "./morse.js";
+import { DEFAULT_TIMING } from "./timing.js";
+/**
+ * morse tokens -> onset schedule.
+ * @returns {number[]} onset times in ms, starting at 0, sorted ascending.
+ */
+export function tokensToOnsets(tokens, timing = DEFAULT_TIMING) {
+    const onsets = [];
+    let cursor = 0;
+    for (const tok of tokens) {
+        switch (tok) {
+            case "dot":
+                onsets.push(cursor);
+                break;
+            case "dah":
+                onsets.push(cursor);
+                cursor += timing.dahGapMs;
+                onsets.push(cursor);
+                break;
+            case "elemGap":
+                cursor += timing.elemGapMs;
+                break;
+            case "letterGap":
+                cursor += timing.letterGapMs;
+                break;
+            case "wordGap":
+                cursor += timing.wordGapMs;
+                break;
+            default:
+                break;
+        }
+    }
+    return onsets;
+}
+/**
+ * text -> everything an emitter needs.
+ * @returns {{morse:string, onsets:number[], durationMs:number, skipped:string[]}}
+ */
+export function textToSchedule(text, timing = DEFAULT_TIMING) {
+    const { morse, skipped } = textToMorse(text);
+    const onsets = tokensToOnsets(morseToTokens(morse), timing);
+    const durationMs = onsets.length ? onsets[onsets.length - 1] + timing.clickMs : 0;
+    return { morse, onsets, durationMs, skipped };
+}
+/**
+ * Detected onset times (ms, any order) -> reconstructed morse string.
+ * Robust to jitter via the geometric decision boundaries in `timing`.
+ */
+export function onsetsToMorse(onsetTimes, timing = DEFAULT_TIMING) {
+    const onsets = [...onsetTimes].sort((a, b) => a - b);
+    if (onsets.length === 0) return "";
+    // 1) Cluster impulses into elements. A gap below the dah/elem boundary
+    //    means "same element" (the two taps of a dash).
+    const clusters = []; // { size, gapBefore }  gapBefore = ioi from prev cluster's last onset
+    let size = 1;
+    let prevClusterLast = null;
+    for (let i = 1; i <= onsets.length; i++) {
+        const ioi = i < onsets.length ? onsets[i] - onsets[i - 1] : Infinity;
+        if (i < onsets.length && ioi < timing.decisions.elem) {
+            size += 1; // still same element
+            continue;
+        }
+        // close current cluster
+        const gapBefore = prevClusterLast === null
+            ? null
+            : onsets[i - size] - prevClusterLast;
+        clusters.push({ size, gapBefore });
+        prevClusterLast = onsets[i - 1];
+        size = 1;
+    }
+    // 2) Walk clusters, emitting symbols and letter/word separators.
+    const d = timing.decisions;
+    let out = "";
+    clusters.forEach((c, idx) => {
+        if (idx > 0) {
+            const g = c.gapBefore;
+            if (g >= d.word) out += " / ";
+            else if (g >= d.letter) out += " ";
+            // else elem gap -> no separator (same letter)
+        }
+        out += c.size >= 2 ? "-" : ".";
+    });
+    return out;
+}
+/**
+ * Detected onsets -> { morse, text }.
+ */
+export function decodeOnsets(onsetTimes, timing = DEFAULT_TIMING) {
+    const morse = onsetsToMorse(onsetTimes, timing);
+    return { morse, text: morseToText(morse) };
+}

main.js ADDED Viewed

	@@ -0,0 +1,172 @@

+/**
+ * Reachy Mini — Morse Code. App entry.
+ *
+ *   index.html → #root (host shell mount) + #app (in-iframe surface)
+ *   main.js    → dispatcher: standalone mountHost() | embed connectToHost()
+ *
+ * Standalone visit: mountHost() owns OAuth + robot picker + top bar, then
+ * iframes back here with ?embedded=1. Embed visit: connectToHost() brings up
+ * the WebRTC session and hands us a live `handle.reachy`. We build the UI on
+ * it and register onLeave for safe teardown. (Mirrors marionette-js.)
+ *
+ * The robot is optional to the app's value: Compose→"This device", Listen,
+ * and Learn all work with just a phone/laptop. The robot unlocks antenna
+ * transmission and lets two Minis talk to each other.
+ */
+import { mountHost } from "https://cdn.jsdelivr.net/npm/@pollen-robotics/reachy-mini-sdk@1.8.0-rc1-main.dbe26af/host/dist/entry/auto.js";
+import { connectToHost } from "https://cdn.jsdelivr.net/npm/@pollen-robotics/reachy-mini-sdk@1.8.0-rc1-main.dbe26af/host/dist/entry/embed.js";
+import { safelyReturnToPose } from "./lib/animation-helpers.js";
+import { makeTiming, SPEED_PRESETS } from "./lib/timing.js";
+import { Synth } from "./lib/synth.js";
+import { RobotTapper, DEFAULT_TAP_PROFILE } from "./lib/robot-tapper.js";
+import { Mic } from "./lib/mic.js";
+import { el, clear } from "./views/dom.js";
+import { createCompose } from "./views/compose.js";
+import { createListen } from "./views/listen.js";
+import { createLearn } from "./views/learn.js";
+import { createSettings } from "./views/settings.js";
+const params = new URLSearchParams(window.location.search);
+const isEmbed = params.get("embedded") === "1" || params.get("embed") === "1";
+if (!isEmbed) {
+    mountHost({
+        appName: "Morse Code",
+        appIconUrl: "public/icon.svg",
+        appEmoji: "📡",
+        // We capture the LAPTOP/PHONE mic via getUserMedia for decoding; we do
+        // not need the robot's inbound audio track, so no enableMicrophone.
+    });
+} else {
+    bootEmbed().catch((err) => {
+        console.error("[morse] bootEmbed failed:", err);
+        document.body.innerHTML =
+            `<pre style="padding:24px;color:#c00;font:14px ui-monospace">` +
+            `Morse Code failed to start in the iframe:\n\n${err?.message || err}\n\n` +
+            `Try reloading the Space; check the daemon version and the SDK pin in main.js.</pre>`;
+    });
+}
+async function bootEmbed() {
+    const handle = await connectToHost();
+    const reachy = handle.reachy;
+    document.documentElement.setAttribute("data-theme", handle.theme || "dark");
+    handle.onThemeChange?.((t) => document.documentElement.setAttribute("data-theme", t));
+    // ─── Shared, mutable config ───────────────────────────────────────
+    const config = {
+        speed: "normal",
+        unitMs: SPEED_PRESETS.normal,
+        emitter: reachy ? "robot" : "device",
+        beepFreq: 2200,
+        detector: { highpassHz: 2000, thresholdFactor: 4.0 },
+        tap: { ...DEFAULT_TAP_PROFILE },
+    };
+    const synth = new Synth({ freq: config.beepFreq });
+    let tapper = reachy ? new RobotTapper(reachy, config.tap) : null;
+    const ctx = {
+        reachy,
+        state: config,
+        timing: () => makeTiming(config.unitMs),
+        setSpeed(preset) {
+            config.speed = preset;
+            if (SPEED_PRESETS[preset]) config.unitMs = SPEED_PRESETS[preset];
+        },
+        synth: () => { synth.freq = config.beepFreq; return synth; },
+        tapper: () => {
+            if (!tapper && reachy) tapper = new RobotTapper(reachy, config.tap);
+            if (tapper) tapper.p = { ...DEFAULT_TAP_PROFILE, ...config.tap };
+            return tapper;
+        },
+        makeMic: (cbs) => new Mic({
+            highpassHz: config.detector.highpassHz,
+            detector: { thresholdFactor: config.detector.thresholdFactor },
+            ...cbs,
+        }),
+        toast,
+    };
+    // ─── Views ────────────────────────────────────────────────────────
+    const views = {
+        compose: createCompose(ctx),
+        listen: createListen(ctx),
+        learn: createLearn(ctx),
+    };
+    const order = ["compose", "listen", "learn"];
+    const labels = { compose: "Compose", listen: "Listen", learn: "Learn" };
+    const icons = { compose: "✏️", listen: "🎧", learn: "📖" };
+    const app = document.getElementById("app");
+    clear(app);
+    const viewHost = el("main.view-host");
+    let current = null;
+    function show(name) {
+        if (current === name) return;
+        if (current && views[current].onHide) views[current].onHide();
+        current = name;
+        clear(viewHost);
+        viewHost.append(views[name].node);
+        views[name].onShow?.();
+        [...tabbar.children].forEach((b) =>
+            b.classList.toggle("active", b.dataset.view === name));
+    }
+    const tabbar = el("nav.tabbar");
+    order.forEach((name) => {
+        tabbar.append(el("button.tab", {
+            "data-view": name,
+            onclick: () => show(name),
+        }, [el("span.tab-ico", {}, icons[name]), el("span.tab-label", {}, labels[name])]));
+    });
+    const header = el("header.appbar", {}, [
+        el("div.brand", {}, [el("span.brand-logo", {}, "📡"), el("span", {}, "Morse Code")]),
+        el("button.icon-btn", { title: "Settings", onclick: openSettings }, "⚙️"),
+    ]);
+    app.append(header, viewHost, tabbar);
+    app.hidden = false;
+    show("compose");
+    // ─── Settings modal ─────────────────────────────────────────────
+    function openSettings() {
+        const sheet = createSettings(ctx);
+        const overlay = el("div.overlay", { onclick: (e) => { if (e.target === overlay) close(); } });
+        const close = () => overlay.remove();
+        const panel = el("div.sheet", {}, [
+            el("div.sheet-head", {}, [el("h2", {}, "Settings"),
+                el("button.icon-btn", { onclick: close }, "✕")]),
+            sheet.node,
+        ]);
+        overlay.append(panel);
+        document.body.append(overlay);
+    }
+    // ─── Safe teardown ────────────────────────────────────────────────
+    handle.onLeave?.(() => {
+        try { tapper?.stop(); } catch { /* */ }
+        try { synth.stop(); } catch { /* */ }
+        if (reachy) return safelyReturnToPose(reachy);
+    });
+    window.addEventListener("error", (e) => console.error("[morse] uncaught", e.message));
+}
+// ─── Toast ────────────────────────────────────────────────────────────
+let toastTimer = null;
+function toast(msg) {
+    let t = document.getElementById("toast");
+    if (!t) {
+        t = el("div#toast.toast");
+        document.body.append(t);
+    }
+    t.textContent = msg;
+    t.classList.add("show");
+    clearTimeout(toastTimer);
+    toastTimer = setTimeout(() => t.classList.remove("show"), 2600);
+}

package-lock.json ADDED Viewed

	@@ -0,0 +1,2018 @@

+{
+    "name": "reachy-mini-morse-code",
+    "version": "0.0.0",
+    "lockfileVersion": 3,
+    "requires": true,
+    "packages": {
+        "": {
+            "name": "reachy-mini-morse-code",
+            "version": "0.0.0",
+            "devDependencies": {
+                "@playwright/test": "^1.48.0",
+                "jsdom": "^29.1.1",
+                "vitest": "^2.1.0"
+            }
+        },
+        "node_modules/@asamuzakjp/css-color": {
+            "version": "5.1.11",
+            "resolved": "https://registry.npmjs.org/@asamuzakjp/css-color/-/css-color-5.1.11.tgz",
+            "integrity": "sha512-KVw6qIiCTUQhByfTd78h2yD1/00waTmm9uy/R7Ck/ctUyAPj+AEDLkQIdJW0T8+qGgj3j5bpNKK7Q3G+LedJWg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@asamuzakjp/generational-cache": "^1.0.1",
+                "@csstools/css-calc": "^3.2.0",
+                "@csstools/css-color-parser": "^4.1.0",
+                "@csstools/css-parser-algorithms": "^4.0.0",
+                "@csstools/css-tokenizer": "^4.0.0"
+            },
+            "engines": {
+                "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+            }
+        },
+        "node_modules/@asamuzakjp/dom-selector": {
+            "version": "7.1.1",
+            "resolved": "https://registry.npmjs.org/@asamuzakjp/dom-selector/-/dom-selector-7.1.1.tgz",
+            "integrity": "sha512-67RZDnYRc8H/8MLDgQCDE//zoqVFwajkepHZgmXrbwybzXOEwOWGPYGmALYl9J2DOLfFPPs6kKCqmbzV895hTQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@asamuzakjp/generational-cache": "^1.0.1",
+                "@asamuzakjp/nwsapi": "^2.3.9",
+                "bidi-js": "^1.0.3",
+                "css-tree": "^3.2.1",
+                "is-potential-custom-element-name": "^1.0.1"
+            },
+            "engines": {
+                "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+            }
+        },
+        "node_modules/@asamuzakjp/generational-cache": {
+            "version": "1.0.1",
+            "resolved": "https://registry.npmjs.org/@asamuzakjp/generational-cache/-/generational-cache-1.0.1.tgz",
+            "integrity": "sha512-wajfB8KqzMCN2KGNFdLkReeHncd0AslUSrvHVvvYWuU8ghncRJoA50kT3zP9MVL0+9g4/67H+cdvBskj9THPzg==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+            }
+        },
+        "node_modules/@asamuzakjp/nwsapi": {
+            "version": "2.3.9",
+            "resolved": "https://registry.npmjs.org/@asamuzakjp/nwsapi/-/nwsapi-2.3.9.tgz",
+            "integrity": "sha512-n8GuYSrI9bF7FFZ/SjhwevlHc8xaVlb/7HmHelnc/PZXBD2ZR49NnN9sMMuDdEGPeeRQ5d0hqlSlEpgCX3Wl0Q==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/@bramus/specificity": {
+            "version": "2.4.2",
+            "resolved": "https://registry.npmjs.org/@bramus/specificity/-/specificity-2.4.2.tgz",
+            "integrity": "sha512-ctxtJ/eA+t+6q2++vj5j7FYX3nRu311q1wfYH3xjlLOsczhlhxAg2FWNUXhpGvAw3BWo1xBcvOV6/YLc2r5FJw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "css-tree": "^3.0.0"
+            },
+            "bin": {
+                "specificity": "bin/cli.js"
+            }
+        },
+        "node_modules/@csstools/color-helpers": {
+            "version": "6.0.2",
+            "resolved": "https://registry.npmjs.org/@csstools/color-helpers/-/color-helpers-6.0.2.tgz",
+            "integrity": "sha512-LMGQLS9EuADloEFkcTBR3BwV/CGHV7zyDxVRtVDTwdI2Ca4it0CCVTT9wCkxSgokjE5Ho41hEPgb8OEUwoXr6Q==",
+            "dev": true,
+            "funding": [
+                {
+                    "type": "github",
+                    "url": "https://github.com/sponsors/csstools"
+                },
+                {
+                    "type": "opencollective",
+                    "url": "https://opencollective.com/csstools"
+                }
+            ],
+            "license": "MIT-0",
+            "engines": {
+                "node": ">=20.19.0"
+            }
+        },
+        "node_modules/@csstools/css-calc": {
+            "version": "3.2.1",
+            "resolved": "https://registry.npmjs.org/@csstools/css-calc/-/css-calc-3.2.1.tgz",
+            "integrity": "sha512-DtdHlgXh5ZkA43cwBcAm+huzgJiwx3ZTWVjBs94kwz2xKqSimDA3lBgCjphYgwgVUMWatSM0pDd8TILB1yrVVg==",
+            "dev": true,
+            "funding": [
+                {
+                    "type": "github",
+                    "url": "https://github.com/sponsors/csstools"
+                },
+                {
+                    "type": "opencollective",
+                    "url": "https://opencollective.com/csstools"
+                }
+            ],
+            "license": "MIT",
+            "engines": {
+                "node": ">=20.19.0"
+            },
+            "peerDependencies": {
+                "@csstools/css-parser-algorithms": "^4.0.0",
+                "@csstools/css-tokenizer": "^4.0.0"
+            }
+        },
+        "node_modules/@csstools/css-color-parser": {
+            "version": "4.1.1",
+            "resolved": "https://registry.npmjs.org/@csstools/css-color-parser/-/css-color-parser-4.1.1.tgz",
+            "integrity": "sha512-eZ5XOtyhK+mggRafYUWzA0tvaYOFgdY8AkgQiCJF9qNAePnUo/zmsqqYubBBb3sQ8uNUaSKTY9s9klfRaAXL0g==",
+            "dev": true,
+            "funding": [
+                {
+                    "type": "github",
+                    "url": "https://github.com/sponsors/csstools"
+                },
+                {
+                    "type": "opencollective",
+                    "url": "https://opencollective.com/csstools"
+                }
+            ],
+            "license": "MIT",
+            "dependencies": {
+                "@csstools/color-helpers": "^6.0.2",
+                "@csstools/css-calc": "^3.2.1"
+            },
+            "engines": {
+                "node": ">=20.19.0"
+            },
+            "peerDependencies": {
+                "@csstools/css-parser-algorithms": "^4.0.0",
+                "@csstools/css-tokenizer": "^4.0.0"
+            }
+        },
+        "node_modules/@csstools/css-parser-algorithms": {
+            "version": "4.0.0",
+            "resolved": "https://registry.npmjs.org/@csstools/css-parser-algorithms/-/css-parser-algorithms-4.0.0.tgz",
+            "integrity": "sha512-+B87qS7fIG3L5h3qwJ/IFbjoVoOe/bpOdh9hAjXbvx0o8ImEmUsGXN0inFOnk2ChCFgqkkGFQ+TpM5rbhkKe4w==",
+            "dev": true,
+            "funding": [
+                {
+                    "type": "github",
+                    "url": "https://github.com/sponsors/csstools"
+                },
+                {
+                    "type": "opencollective",
+                    "url": "https://opencollective.com/csstools"
+                }
+            ],
+            "license": "MIT",
+            "engines": {
+                "node": ">=20.19.0"
+            },
+            "peerDependencies": {
+                "@csstools/css-tokenizer": "^4.0.0"
+            }
+        },
+        "node_modules/@csstools/css-syntax-patches-for-csstree": {
+            "version": "1.1.4",
+            "resolved": "https://registry.npmjs.org/@csstools/css-syntax-patches-for-csstree/-/css-syntax-patches-for-csstree-1.1.4.tgz",
+            "integrity": "sha512-wgsqt92b7C7tQhIdPNxj0n9zuUbQlvAuI1exyzeNrOKOi62SD7ren8zqszmpVREjAOqg8cD2FqYhQfAuKjk4sw==",
+            "dev": true,
+            "funding": [
+                {
+                    "type": "github",
+                    "url": "https://github.com/sponsors/csstools"
+                },
+                {
+                    "type": "opencollective",
+                    "url": "https://opencollective.com/csstools"
+                }
+            ],
+            "license": "MIT-0",
+            "peerDependencies": {
+                "css-tree": "^3.2.1"
+            },
+            "peerDependenciesMeta": {
+                "css-tree": {
+                    "optional": true
+                }
+            }
+        },
+        "node_modules/@csstools/css-tokenizer": {
+            "version": "4.0.0",
+            "resolved": "https://registry.npmjs.org/@csstools/css-tokenizer/-/css-tokenizer-4.0.0.tgz",
+            "integrity": "sha512-QxULHAm7cNu72w97JUNCBFODFaXpbDg+dP8b/oWFAZ2MTRppA3U00Y2L1HqaS4J6yBqxwa/Y3nMBaxVKbB/NsA==",
+            "dev": true,
+            "funding": [
+                {
+                    "type": "github",
+                    "url": "https://github.com/sponsors/csstools"
+                },
+                {
+                    "type": "opencollective",
+                    "url": "https://opencollective.com/csstools"
+                }
+            ],
+            "license": "MIT",
+            "engines": {
+                "node": ">=20.19.0"
+            }
+        },
+        "node_modules/@esbuild/aix-ppc64": {
+            "version": "0.21.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",
+            "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==",
+            "cpu": [
+                "ppc64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "aix"
+            ],
+            "engines": {
+                "node": ">=12"
+            }
+        },
+        "node_modules/@esbuild/android-arm": {
+            "version": "0.21.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz",
+            "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==",
+            "cpu": [
+                "arm"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "android"
+            ],
+            "engines": {
+                "node": ">=12"
+            }
+        },
+        "node_modules/@esbuild/android-arm64": {
+            "version": "0.21.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz",
+            "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==",
+            "cpu": [
+                "arm64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "android"
+            ],
+            "engines": {
+                "node": ">=12"
+            }
+        },
+        "node_modules/@esbuild/android-x64": {
+            "version": "0.21.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz",
+            "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "android"
+            ],
+            "engines": {
+                "node": ">=12"
+            }
+        },
+        "node_modules/@esbuild/darwin-arm64": {
+            "version": "0.21.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz",
+            "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==",
+            "cpu": [
+                "arm64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "darwin"
+            ],
+            "engines": {
+                "node": ">=12"
+            }
+        },
+        "node_modules/@esbuild/darwin-x64": {
+            "version": "0.21.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz",
+            "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "darwin"
+            ],
+            "engines": {
+                "node": ">=12"
+            }
+        },
+        "node_modules/@esbuild/freebsd-arm64": {
+            "version": "0.21.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz",
+            "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==",
+            "cpu": [
+                "arm64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "freebsd"
+            ],
+            "engines": {
+                "node": ">=12"
+            }
+        },
+        "node_modules/@esbuild/freebsd-x64": {
+            "version": "0.21.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz",
+            "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "freebsd"
+            ],
+            "engines": {
+                "node": ">=12"
+            }
+        },
+        "node_modules/@esbuild/linux-arm": {
+            "version": "0.21.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz",
+            "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==",
+            "cpu": [
+                "arm"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ],
+            "engines": {
+                "node": ">=12"
+            }
+        },
+        "node_modules/@esbuild/linux-arm64": {
+            "version": "0.21.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz",
+            "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==",
+            "cpu": [
+                "arm64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ],
+            "engines": {
+                "node": ">=12"
+            }
+        },
+        "node_modules/@esbuild/linux-ia32": {
+            "version": "0.21.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz",
+            "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==",
+            "cpu": [
+                "ia32"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ],
+            "engines": {
+                "node": ">=12"
+            }
+        },
+        "node_modules/@esbuild/linux-loong64": {
+            "version": "0.21.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz",
+            "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==",
+            "cpu": [
+                "loong64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ],
+            "engines": {
+                "node": ">=12"
+            }
+        },
+        "node_modules/@esbuild/linux-mips64el": {
+            "version": "0.21.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz",
+            "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==",
+            "cpu": [
+                "mips64el"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ],
+            "engines": {
+                "node": ">=12"
+            }
+        },
+        "node_modules/@esbuild/linux-ppc64": {
+            "version": "0.21.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz",
+            "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==",
+            "cpu": [
+                "ppc64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ],
+            "engines": {
+                "node": ">=12"
+            }
+        },
+        "node_modules/@esbuild/linux-riscv64": {
+            "version": "0.21.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz",
+            "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==",
+            "cpu": [
+                "riscv64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ],
+            "engines": {
+                "node": ">=12"
+            }
+        },
+        "node_modules/@esbuild/linux-s390x": {
+            "version": "0.21.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz",
+            "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==",
+            "cpu": [
+                "s390x"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ],
+            "engines": {
+                "node": ">=12"
+            }
+        },
+        "node_modules/@esbuild/linux-x64": {
+            "version": "0.21.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz",
+            "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ],
+            "engines": {
+                "node": ">=12"
+            }
+        },
+        "node_modules/@esbuild/netbsd-x64": {
+            "version": "0.21.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz",
+            "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "netbsd"
+            ],
+            "engines": {
+                "node": ">=12"
+            }
+        },
+        "node_modules/@esbuild/openbsd-x64": {
+            "version": "0.21.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz",
+            "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "openbsd"
+            ],
+            "engines": {
+                "node": ">=12"
+            }
+        },
+        "node_modules/@esbuild/sunos-x64": {
+            "version": "0.21.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz",
+            "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "sunos"
+            ],
+            "engines": {
+                "node": ">=12"
+            }
+        },
+        "node_modules/@esbuild/win32-arm64": {
+            "version": "0.21.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz",
+            "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==",
+            "cpu": [
+                "arm64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "win32"
+            ],
+            "engines": {
+                "node": ">=12"
+            }
+        },
+        "node_modules/@esbuild/win32-ia32": {
+            "version": "0.21.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz",
+            "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==",
+            "cpu": [
+                "ia32"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "win32"
+            ],
+            "engines": {
+                "node": ">=12"
+            }
+        },
+        "node_modules/@esbuild/win32-x64": {
+            "version": "0.21.5",
+            "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz",
+            "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "win32"
+            ],
+            "engines": {
+                "node": ">=12"
+            }
+        },
+        "node_modules/@exodus/bytes": {
+            "version": "1.15.1",
+            "resolved": "https://registry.npmjs.org/@exodus/bytes/-/bytes-1.15.1.tgz",
+            "integrity": "sha512-S6mL0yNB/Abt9Ei4tq8gDhcczc4S3+vQ4ra7vxnAf+YHC02srtqxKKZghx2Dq6p0e66THKwR6r8N6P95wEty7Q==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+            },
+            "peerDependencies": {
+                "@noble/hashes": "^1.8.0 || ^2.0.0"
+            },
+            "peerDependenciesMeta": {
+                "@noble/hashes": {
+                    "optional": true
+                }
+            }
+        },
+        "node_modules/@jridgewell/sourcemap-codec": {
+            "version": "1.5.5",
+            "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+            "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/@playwright/test": {
+            "version": "1.60.0",
+            "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.60.0.tgz",
+            "integrity": "sha512-O71yZIbAh/PxDMNGns37GHBIfrVkEVyn+AXyIa5dOTfb4/xNvRWV+Vv/NMbNCtODB/pO7vLlF2OTmMVLhmr7Ag==",
+            "dev": true,
+            "license": "Apache-2.0",
+            "dependencies": {
+                "playwright": "1.60.0"
+            },
+            "bin": {
+                "playwright": "cli.js"
+            },
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/@rollup/rollup-android-arm-eabi": {
+            "version": "4.61.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.61.0.tgz",
+            "integrity": "sha512-dnxczajOqt0gesZlN5pGQ1s1imQVrsmCw5G2Ci4oM+0WvNz3pyRnlWrT7McoZIb8VlFwCawdmbWRmxRn7HI+VQ==",
+            "cpu": [
+                "arm"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "android"
+            ]
+        },
+        "node_modules/@rollup/rollup-android-arm64": {
+            "version": "4.61.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.61.0.tgz",
+            "integrity": "sha512-Bp3JpGP00Vu3f238ivRrjf7z3xSzVPXqCmaJYA9t2c+c8vKYvOzmXF7LkkeUalTEGd6cZcSWe+PFIP3Vy48fRg==",
+            "cpu": [
+                "arm64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "android"
+            ]
+        },
+        "node_modules/@rollup/rollup-darwin-arm64": {
+            "version": "4.61.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.61.0.tgz",
+            "integrity": "sha512-zaYIpr670mUmmZ1tVzUFplbQbG7h3Gugx3L5FoqhsC2m/YnLlR1a7zVLmXNPy+iY1tFPEbNG+HHBXZGyId0G5w==",
+            "cpu": [
+                "arm64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "darwin"
+            ]
+        },
+        "node_modules/@rollup/rollup-darwin-x64": {
+            "version": "4.61.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.61.0.tgz",
+            "integrity": "sha512-+P49fvkv2dSoeevUW+lgZ/I2JHSsJCK1Lyjj7Cu6E4UHG4tS9XIefzIjo5qhgELjAclnen1rLzK2PMKJdo+Dyg==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "darwin"
+            ]
+        },
+        "node_modules/@rollup/rollup-freebsd-arm64": {
+            "version": "4.61.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.61.0.tgz",
+            "integrity": "sha512-l3FAAOyKJXH2ea6KNFN+MMgC/rnE94YGLXs2ehYqDcCoHt1DpvgWX75BhUJxN38XojP7Ul+4H8PRn7EdyqSDrw==",
+            "cpu": [
+                "arm64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "freebsd"
+            ]
+        },
+        "node_modules/@rollup/rollup-freebsd-x64": {
+            "version": "4.61.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.61.0.tgz",
+            "integrity": "sha512-VokPN3TSctKj65cyCNPaUh4vMFA8awxOot/0sp+4J7ZlNRKQEhXhawqPwajoi8H5ZFt61i0ugZJuTKXBjGJ17Q==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "freebsd"
+            ]
+        },
+        "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+            "version": "4.61.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.61.0.tgz",
+            "integrity": "sha512-DxH0P3wxm+Yzs/p3zrk9dw1rURu8p0Nv5+MRK/L7OtnLNg5rLZraSBFZ8iUXOd9f2BlhJyEpIZUH/emjq4UJ4g==",
+            "cpu": [
+                "arm"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ]
+        },
+        "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+            "version": "4.61.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.61.0.tgz",
+            "integrity": "sha512-T6ZvMNe84kAz6TBWHC7hGAoEtzP1LWYw/AqayGWEF6uISt3Abk/st06LqRD9THd7Xz3NxzurUpzAuEAUbZf+nw==",
+            "cpu": [
+                "arm"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ]
+        },
+        "node_modules/@rollup/rollup-linux-arm64-gnu": {
+            "version": "4.61.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.61.0.tgz",
+            "integrity": "sha512-q/4hzvQkDs8b4jIBab1pnLiiM0ayTZsN2amBFPDzuyZxjEd4wDwx0UJFYM3cOZzSf5Kw8fnWSprJzIBMkcR44Q==",
+            "cpu": [
+                "arm64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ]
+        },
+        "node_modules/@rollup/rollup-linux-arm64-musl": {
+            "version": "4.61.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.61.0.tgz",
+            "integrity": "sha512-vvYWX3akdEAY6km+9wAqFDnk6pQsbJKVnj7xawcvs/+fdlYBGp+U+Qq/lLfpIxYIZvZLHMAKD9HLdacSx/r3dw==",
+            "cpu": [
+                "arm64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ]
+        },
+        "node_modules/@rollup/rollup-linux-loong64-gnu": {
+            "version": "4.61.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.61.0.tgz",
+            "integrity": "sha512-DePa5cqOxDP/Zp0VOXpeWaGew5iIv5DXp9NYbzkX5PFQyWVX9184WCTh3hvr/7lhXo8ZVlbFLkz8+o/q1dU6gA==",
+            "cpu": [
+                "loong64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ]
+        },
+        "node_modules/@rollup/rollup-linux-loong64-musl": {
+            "version": "4.61.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.61.0.tgz",
+            "integrity": "sha512-LV8aWMB8UChglMCEzs7RkN0GsH29RJaLLqwm9fCIjlqwxQTiWAqNcc7wjBkH31hV0PU/yVxGYvrYsgfea2qw6g==",
+            "cpu": [
+                "loong64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ]
+        },
+        "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+            "version": "4.61.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.61.0.tgz",
+            "integrity": "sha512-QoNSnwQtaeNu5grdBbsL0tt1uyl5EnS8DA8Mr3nluMXbhdQNyhN+G4tBax7VCdxLKj8YJ0/4OO9Ho84jMnJtKA==",
+            "cpu": [
+                "ppc64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ]
+        },
+        "node_modules/@rollup/rollup-linux-ppc64-musl": {
+            "version": "4.61.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.61.0.tgz",
+            "integrity": "sha512-/zZp5MKapIIApE8trN8qLGNSiRN9TUoaUZ1cmVu4XnVdd5LQLOXTtyi+vtfUbNnT3iyjzpPqYeKXmvJ+gJGYWw==",
+            "cpu": [
+                "ppc64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ]
+        },
+        "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+            "version": "4.61.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.61.0.tgz",
+            "integrity": "sha512-RbrzcD3aJ1k3UbtMRRBNwojdVVyXjuVAFTfn/xPa6EEl6GE9Sm/akPgFTb9aAC9pMKGJ6CtWxaGrqWcabH+ySg==",
+            "cpu": [
+                "riscv64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ]
+        },
+        "node_modules/@rollup/rollup-linux-riscv64-musl": {
+            "version": "4.61.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.61.0.tgz",
+            "integrity": "sha512-ZF+onDsBso8PJf1XaG9lB+O9RnBpKGnY6OrzC4CSHrtC1jb6jWLTKK4bRqdoCXHd22gyr2hiYmEAm8Wns/BOCw==",
+            "cpu": [
+                "riscv64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ]
+        },
+        "node_modules/@rollup/rollup-linux-s390x-gnu": {
+            "version": "4.61.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.61.0.tgz",
+            "integrity": "sha512-Atk0aSIk5Zx2Wuh9dgRQgLP0Koc8hOeYpbWryMXyk8G8/HmPkwPPkMqIIDhrXHHYqfUzSJA/I7IWSBv8xSmRBA==",
+            "cpu": [
+                "s390x"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ]
+        },
+        "node_modules/@rollup/rollup-linux-x64-gnu": {
+            "version": "4.61.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.61.0.tgz",
+            "integrity": "sha512-0uMOcf3eZ5K+K4cYHkdxShFMPlPXCOdfDFEFn9dNYAEEd2cVvmOfH7zFgRVoDgmtQ1m9k5q7qfrHzyMAubKYUA==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ]
+        },
+        "node_modules/@rollup/rollup-linux-x64-musl": {
+            "version": "4.61.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.61.0.tgz",
+            "integrity": "sha512-mvFtE4A/t/7hRJ7X8Ozmu8FsIkAUat2nzl12pgU337BRmq87AQUJztwHz2Zv5/tjo9/C95E66CK03SI/ToEDJw==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "linux"
+            ]
+        },
+        "node_modules/@rollup/rollup-openbsd-x64": {
+            "version": "4.61.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.61.0.tgz",
+            "integrity": "sha512-z9b9+aTxvt8n2rNltMPvyaUfB8NJ+CVyOrGK/MdIKHx7B+lXmZpm/XbRsU7Rpf3fRqJ2uS6mBJiJveCtq8LHDg==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "openbsd"
+            ]
+        },
+        "node_modules/@rollup/rollup-openharmony-arm64": {
+            "version": "4.61.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.61.0.tgz",
+            "integrity": "sha512-jXaXFqKMehsOc+g8R6oo33RRC6w07G9jDBxAE5eAKX7mOcCbZloYIPNhfG9Wl+P9O9IWHFO4OJgPi1Ml2qkt7w==",
+            "cpu": [
+                "arm64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "openharmony"
+            ]
+        },
+        "node_modules/@rollup/rollup-win32-arm64-msvc": {
+            "version": "4.61.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.61.0.tgz",
+            "integrity": "sha512-OXNWVFocS2IA4+QplhTZZ2a+8hPZR7T8KuozsNmJKK8y7cp83StHvGksfHzPG3wczWTczyWHVQuqeiTUbjiyBg==",
+            "cpu": [
+                "arm64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "win32"
+            ]
+        },
+        "node_modules/@rollup/rollup-win32-ia32-msvc": {
+            "version": "4.61.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.61.0.tgz",
+            "integrity": "sha512-AlAbNtBO637LxSldqV43z0FfXoGfl2TW1DgAg/bs7aQswFbDewz2SJm3BUhiGfbOVtW571xbc9p+REdxhyN/Eg==",
+            "cpu": [
+                "ia32"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "win32"
+            ]
+        },
+        "node_modules/@rollup/rollup-win32-x64-gnu": {
+            "version": "4.61.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.61.0.tgz",
+            "integrity": "sha512-QRSrQXyJ1M4tjNXdR0/G/IgV6lzfQQJYBjlWIEYkY2Xs86DRl/iEpQ4blMDjJxSl7n19eDKKXMg0AmuBVYy8pQ==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "win32"
+            ]
+        },
+        "node_modules/@rollup/rollup-win32-x64-msvc": {
+            "version": "4.61.0",
+            "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.61.0.tgz",
+            "integrity": "sha512-tkuFxhvKO/HlGd0VsINF6vHSYH8AF8W0TcNxKDK6JZmrehngFj78pToc8iemtnvwilDjs2G/qSzYFhe9U8q+fw==",
+            "cpu": [
+                "x64"
+            ],
+            "dev": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "win32"
+            ]
+        },
+        "node_modules/@types/estree": {
+            "version": "1.0.9",
+            "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.9.tgz",
+            "integrity": "sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/@vitest/expect": {
+            "version": "2.1.9",
+            "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-2.1.9.tgz",
+            "integrity": "sha512-UJCIkTBenHeKT1TTlKMJWy1laZewsRIzYighyYiJKZreqtdxSos/S1t+ktRMQWu2CKqaarrkeszJx1cgC5tGZw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@vitest/spy": "2.1.9",
+                "@vitest/utils": "2.1.9",
+                "chai": "^5.1.2",
+                "tinyrainbow": "^1.2.0"
+            },
+            "funding": {
+                "url": "https://opencollective.com/vitest"
+            }
+        },
+        "node_modules/@vitest/mocker": {
+            "version": "2.1.9",
+            "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-2.1.9.tgz",
+            "integrity": "sha512-tVL6uJgoUdi6icpxmdrn5YNo3g3Dxv+IHJBr0GXHaEdTcw3F+cPKnsXFhli6nO+f/6SDKPHEK1UN+k+TQv0Ehg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@vitest/spy": "2.1.9",
+                "estree-walker": "^3.0.3",
+                "magic-string": "^0.30.12"
+            },
+            "funding": {
+                "url": "https://opencollective.com/vitest"
+            },
+            "peerDependencies": {
+                "msw": "^2.4.9",
+                "vite": "^5.0.0"
+            },
+            "peerDependenciesMeta": {
+                "msw": {
+                    "optional": true
+                },
+                "vite": {
+                    "optional": true
+                }
+            }
+        },
+        "node_modules/@vitest/pretty-format": {
+            "version": "2.1.9",
+            "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-2.1.9.tgz",
+            "integrity": "sha512-KhRIdGV2U9HOUzxfiHmY8IFHTdqtOhIzCpd8WRdJiE7D/HUcZVD0EgQCVjm+Q9gkUXWgBvMmTtZgIG48wq7sOQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "tinyrainbow": "^1.2.0"
+            },
+            "funding": {
+                "url": "https://opencollective.com/vitest"
+            }
+        },
+        "node_modules/@vitest/runner": {
+            "version": "2.1.9",
+            "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-2.1.9.tgz",
+            "integrity": "sha512-ZXSSqTFIrzduD63btIfEyOmNcBmQvgOVsPNPe0jYtESiXkhd8u2erDLnMxmGrDCwHCCHE7hxwRDCT3pt0esT4g==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@vitest/utils": "2.1.9",
+                "pathe": "^1.1.2"
+            },
+            "funding": {
+                "url": "https://opencollective.com/vitest"
+            }
+        },
+        "node_modules/@vitest/snapshot": {
+            "version": "2.1.9",
+            "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-2.1.9.tgz",
+            "integrity": "sha512-oBO82rEjsxLNJincVhLhaxxZdEtV0EFHMK5Kmx5sJ6H9L183dHECjiefOAdnqpIgT5eZwT04PoggUnW88vOBNQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@vitest/pretty-format": "2.1.9",
+                "magic-string": "^0.30.12",
+                "pathe": "^1.1.2"
+            },
+            "funding": {
+                "url": "https://opencollective.com/vitest"
+            }
+        },
+        "node_modules/@vitest/spy": {
+            "version": "2.1.9",
+            "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-2.1.9.tgz",
+            "integrity": "sha512-E1B35FwzXXTs9FHNK6bDszs7mtydNi5MIfUWpceJ8Xbfb1gBMscAnwLbEu+B44ed6W3XjL9/ehLPHR1fkf1KLQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "tinyspy": "^3.0.2"
+            },
+            "funding": {
+                "url": "https://opencollective.com/vitest"
+            }
+        },
+        "node_modules/@vitest/utils": {
+            "version": "2.1.9",
+            "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-2.1.9.tgz",
+            "integrity": "sha512-v0psaMSkNJ3A2NMrUEHFRzJtDPFn+/VWZ5WxImB21T9fjucJRmS7xCS3ppEnARb9y11OAzaD+P2Ps+b+BGX5iQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@vitest/pretty-format": "2.1.9",
+                "loupe": "^3.1.2",
+                "tinyrainbow": "^1.2.0"
+            },
+            "funding": {
+                "url": "https://opencollective.com/vitest"
+            }
+        },
+        "node_modules/assertion-error": {
+            "version": "2.0.1",
+            "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
+            "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=12"
+            }
+        },
+        "node_modules/bidi-js": {
+            "version": "1.0.3",
+            "resolved": "https://registry.npmjs.org/bidi-js/-/bidi-js-1.0.3.tgz",
+            "integrity": "sha512-RKshQI1R3YQ+n9YJz2QQ147P66ELpa1FQEg20Dk8oW9t2KgLbpDLLp9aGZ7y8WHSshDknG0bknqGw5/tyCs5tw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "require-from-string": "^2.0.2"
+            }
+        },
+        "node_modules/cac": {
+            "version": "6.7.14",
+            "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz",
+            "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=8"
+            }
+        },
+        "node_modules/chai": {
+            "version": "5.3.3",
+            "resolved": "https://registry.npmjs.org/chai/-/chai-5.3.3.tgz",
+            "integrity": "sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "assertion-error": "^2.0.1",
+                "check-error": "^2.1.1",
+                "deep-eql": "^5.0.1",
+                "loupe": "^3.1.0",
+                "pathval": "^2.0.0"
+            },
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/check-error": {
+            "version": "2.1.3",
+            "resolved": "https://registry.npmjs.org/check-error/-/check-error-2.1.3.tgz",
+            "integrity": "sha512-PAJdDJusoxnwm1VwW07VWwUN1sl7smmC3OKggvndJFadxxDRyFJBX/ggnu/KE4kQAB7a3Dp8f/YXC1FlUprWmA==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 16"
+            }
+        },
+        "node_modules/css-tree": {
+            "version": "3.2.1",
+            "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-3.2.1.tgz",
+            "integrity": "sha512-X7sjQzceUhu1u7Y/ylrRZFU2FS6LRiFVp6rKLPg23y3x3c3DOKAwuXGDp+PAGjh6CSnCjYeAul8pcT8bAl+lSA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "mdn-data": "2.27.1",
+                "source-map-js": "^1.2.1"
+            },
+            "engines": {
+                "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0"
+            }
+        },
+        "node_modules/data-urls": {
+            "version": "7.0.0",
+            "resolved": "https://registry.npmjs.org/data-urls/-/data-urls-7.0.0.tgz",
+            "integrity": "sha512-23XHcCF+coGYevirZceTVD7NdJOqVn+49IHyxgszm+JIiHLoB2TkmPtsYkNWT1pvRSGkc35L6NHs0yHkN2SumA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "whatwg-mimetype": "^5.0.0",
+                "whatwg-url": "^16.0.0"
+            },
+            "engines": {
+                "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+            }
+        },
+        "node_modules/debug": {
+            "version": "4.4.3",
+            "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+            "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "ms": "^2.1.3"
+            },
+            "engines": {
+                "node": ">=6.0"
+            },
+            "peerDependenciesMeta": {
+                "supports-color": {
+                    "optional": true
+                }
+            }
+        },
+        "node_modules/decimal.js": {
+            "version": "10.6.0",
+            "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.6.0.tgz",
+            "integrity": "sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/deep-eql": {
+            "version": "5.0.2",
+            "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.2.tgz",
+            "integrity": "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=6"
+            }
+        },
+        "node_modules/entities": {
+            "version": "8.0.0",
+            "resolved": "https://registry.npmjs.org/entities/-/entities-8.0.0.tgz",
+            "integrity": "sha512-zwfzJecQ/Uej6tusMqwAqU/6KL2XaB2VZ2Jg54Je6ahNBGNH6Ek6g3jjNCF0fG9EWQKGZNddNjU5F1ZQn/sBnA==",
+            "dev": true,
+            "license": "BSD-2-Clause",
+            "engines": {
+                "node": ">=20.19.0"
+            },
+            "funding": {
+                "url": "https://github.com/fb55/entities?sponsor=1"
+            }
+        },
+        "node_modules/es-module-lexer": {
+            "version": "1.7.0",
+            "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.7.0.tgz",
+            "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/esbuild": {
+            "version": "0.21.5",
+            "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",
+            "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",
+            "dev": true,
+            "hasInstallScript": true,
+            "license": "MIT",
+            "bin": {
+                "esbuild": "bin/esbuild"
+            },
+            "engines": {
+                "node": ">=12"
+            },
+            "optionalDependencies": {
+                "@esbuild/aix-ppc64": "0.21.5",
+                "@esbuild/android-arm": "0.21.5",
+                "@esbuild/android-arm64": "0.21.5",
+                "@esbuild/android-x64": "0.21.5",
+                "@esbuild/darwin-arm64": "0.21.5",
+                "@esbuild/darwin-x64": "0.21.5",
+                "@esbuild/freebsd-arm64": "0.21.5",
+                "@esbuild/freebsd-x64": "0.21.5",
+                "@esbuild/linux-arm": "0.21.5",
+                "@esbuild/linux-arm64": "0.21.5",
+                "@esbuild/linux-ia32": "0.21.5",
+                "@esbuild/linux-loong64": "0.21.5",
+                "@esbuild/linux-mips64el": "0.21.5",
+                "@esbuild/linux-ppc64": "0.21.5",
+                "@esbuild/linux-riscv64": "0.21.5",
+                "@esbuild/linux-s390x": "0.21.5",
+                "@esbuild/linux-x64": "0.21.5",
+                "@esbuild/netbsd-x64": "0.21.5",
+                "@esbuild/openbsd-x64": "0.21.5",
+                "@esbuild/sunos-x64": "0.21.5",
+                "@esbuild/win32-arm64": "0.21.5",
+                "@esbuild/win32-ia32": "0.21.5",
+                "@esbuild/win32-x64": "0.21.5"
+            }
+        },
+        "node_modules/estree-walker": {
+            "version": "3.0.3",
+            "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz",
+            "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@types/estree": "^1.0.0"
+            }
+        },
+        "node_modules/expect-type": {
+            "version": "1.3.0",
+            "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.3.0.tgz",
+            "integrity": "sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==",
+            "dev": true,
+            "license": "Apache-2.0",
+            "engines": {
+                "node": ">=12.0.0"
+            }
+        },
+        "node_modules/fsevents": {
+            "version": "2.3.2",
+            "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz",
+            "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==",
+            "dev": true,
+            "hasInstallScript": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "darwin"
+            ],
+            "engines": {
+                "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+            }
+        },
+        "node_modules/html-encoding-sniffer": {
+            "version": "6.0.0",
+            "resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-6.0.0.tgz",
+            "integrity": "sha512-CV9TW3Y3f8/wT0BRFc1/KAVQ3TUHiXmaAb6VW9vtiMFf7SLoMd1PdAc4W3KFOFETBJUb90KatHqlsZMWV+R9Gg==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@exodus/bytes": "^1.6.0"
+            },
+            "engines": {
+                "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+            }
+        },
+        "node_modules/is-potential-custom-element-name": {
+            "version": "1.0.1",
+            "resolved": "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz",
+            "integrity": "sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/jsdom": {
+            "version": "29.1.1",
+            "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-29.1.1.tgz",
+            "integrity": "sha512-ECi4Fi2f7BdJtUKTflYRTiaMxIB0O6zfR1fX0GXpUrf6flp8QIYn1UT20YQqdSOfk2dfkCwS8LAFoJDEppNK5Q==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@asamuzakjp/css-color": "^5.1.11",
+                "@asamuzakjp/dom-selector": "^7.1.1",
+                "@bramus/specificity": "^2.4.2",
+                "@csstools/css-syntax-patches-for-csstree": "^1.1.3",
+                "@exodus/bytes": "^1.15.0",
+                "css-tree": "^3.2.1",
+                "data-urls": "^7.0.0",
+                "decimal.js": "^10.6.0",
+                "html-encoding-sniffer": "^6.0.0",
+                "is-potential-custom-element-name": "^1.0.1",
+                "lru-cache": "^11.3.5",
+                "parse5": "^8.0.1",
+                "saxes": "^6.0.0",
+                "symbol-tree": "^3.2.4",
+                "tough-cookie": "^6.0.1",
+                "undici": "^7.25.0",
+                "w3c-xmlserializer": "^5.0.0",
+                "webidl-conversions": "^8.0.1",
+                "whatwg-mimetype": "^5.0.0",
+                "whatwg-url": "^16.0.1",
+                "xml-name-validator": "^5.0.0"
+            },
+            "engines": {
+                "node": "^20.19.0 || ^22.13.0 || >=24.0.0"
+            },
+            "peerDependencies": {
+                "canvas": "^3.0.0"
+            },
+            "peerDependenciesMeta": {
+                "canvas": {
+                    "optional": true
+                }
+            }
+        },
+        "node_modules/loupe": {
+            "version": "3.2.1",
+            "resolved": "https://registry.npmjs.org/loupe/-/loupe-3.2.1.tgz",
+            "integrity": "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/lru-cache": {
+            "version": "11.5.1",
+            "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.1.tgz",
+            "integrity": "sha512-RPimw/7aMdv2oqRrxKwvZXcPfwBrn/JZ2xYcY9Hus/6LaS3VOAKVWKWgNLCFSiOm1ESXinjsDlidVU7JlnCN2A==",
+            "dev": true,
+            "license": "BlueOak-1.0.0",
+            "engines": {
+                "node": "20 || >=22"
+            }
+        },
+        "node_modules/magic-string": {
+            "version": "0.30.21",
+            "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
+            "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@jridgewell/sourcemap-codec": "^1.5.5"
+            }
+        },
+        "node_modules/mdn-data": {
+            "version": "2.27.1",
+            "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.27.1.tgz",
+            "integrity": "sha512-9Yubnt3e8A0OKwxYSXyhLymGW4sCufcLG6VdiDdUGVkPhpqLxlvP5vl1983gQjJl3tqbrM731mjaZaP68AgosQ==",
+            "dev": true,
+            "license": "CC0-1.0"
+        },
+        "node_modules/ms": {
+            "version": "2.1.3",
+            "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+            "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/nanoid": {
+            "version": "3.3.12",
+            "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.12.tgz",
+            "integrity": "sha512-ZB9RH/39qpq5Vu6Y+NmUaFhQR6pp+M2Xt76XBnEwDaGcVAqhlvxrl3B2bKS5D3NH3QR76v3aSrKaF/Kiy7lEtQ==",
+            "dev": true,
+            "funding": [
+                {
+                    "type": "github",
+                    "url": "https://github.com/sponsors/ai"
+                }
+            ],
+            "license": "MIT",
+            "bin": {
+                "nanoid": "bin/nanoid.cjs"
+            },
+            "engines": {
+                "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+            }
+        },
+        "node_modules/parse5": {
+            "version": "8.0.1",
+            "resolved": "https://registry.npmjs.org/parse5/-/parse5-8.0.1.tgz",
+            "integrity": "sha512-z1e/HMG90obSGeidlli3hj7cbocou0/wa5HacvI3ASx34PecNjNQeaHNo5WIZpWofN9kgkqV1q5YvXe3F0FoPw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "entities": "^8.0.0"
+            },
+            "funding": {
+                "url": "https://github.com/inikulin/parse5?sponsor=1"
+            }
+        },
+        "node_modules/pathe": {
+            "version": "1.1.2",
+            "resolved": "https://registry.npmjs.org/pathe/-/pathe-1.1.2.tgz",
+            "integrity": "sha512-whLdWMYL2TwI08hn8/ZqAbrVemu0LNaNNJZX73O6qaIdCTfXutsLhMkjdENX0qhsQ9uIimo4/aQOmXkoon2nDQ==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/pathval": {
+            "version": "2.0.1",
+            "resolved": "https://registry.npmjs.org/pathval/-/pathval-2.0.1.tgz",
+            "integrity": "sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 14.16"
+            }
+        },
+        "node_modules/picocolors": {
+            "version": "1.1.1",
+            "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+            "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+            "dev": true,
+            "license": "ISC"
+        },
+        "node_modules/playwright": {
+            "version": "1.60.0",
+            "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.60.0.tgz",
+            "integrity": "sha512-hheHdokM8cdqCb0lcE3s+zT4t4W+vvjpGxsZlDnikarzx8tSzMebh3UiFtgqwFwnTnjYQcsyMF8ei2mCO/tpeA==",
+            "dev": true,
+            "license": "Apache-2.0",
+            "dependencies": {
+                "playwright-core": "1.60.0"
+            },
+            "bin": {
+                "playwright": "cli.js"
+            },
+            "engines": {
+                "node": ">=18"
+            },
+            "optionalDependencies": {
+                "fsevents": "2.3.2"
+            }
+        },
+        "node_modules/playwright-core": {
+            "version": "1.60.0",
+            "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.60.0.tgz",
+            "integrity": "sha512-9bW6zvX/m0lEbgTKJ6YppOKx8H3VOPBMOCFh2irXFOT4BbHgrx5hPjwJYLT40Lu+4qtD36qKc/Hn56StUW57IA==",
+            "dev": true,
+            "license": "Apache-2.0",
+            "bin": {
+                "playwright-core": "cli.js"
+            },
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/postcss": {
+            "version": "8.5.15",
+            "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.15.tgz",
+            "integrity": "sha512-FfR8sjd4em2T6fb3I2MwAJU7HWVMr9zba+enmQeeWFfCbm+UOC/0X4DS8XtpUTMwWMGbjKYP7xjfNekzyGmB3A==",
+            "dev": true,
+            "funding": [
+                {
+                    "type": "opencollective",
+                    "url": "https://opencollective.com/postcss/"
+                },
+                {
+                    "type": "tidelift",
+                    "url": "https://tidelift.com/funding/github/npm/postcss"
+                },
+                {
+                    "type": "github",
+                    "url": "https://github.com/sponsors/ai"
+                }
+            ],
+            "license": "MIT",
+            "dependencies": {
+                "nanoid": "^3.3.12",
+                "picocolors": "^1.1.1",
+                "source-map-js": "^1.2.1"
+            },
+            "engines": {
+                "node": "^10 || ^12 || >=14"
+            }
+        },
+        "node_modules/punycode": {
+            "version": "2.3.1",
+            "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
+            "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=6"
+            }
+        },
+        "node_modules/require-from-string": {
+            "version": "2.0.2",
+            "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
+            "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=0.10.0"
+            }
+        },
+        "node_modules/rollup": {
+            "version": "4.61.0",
+            "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.61.0.tgz",
+            "integrity": "sha512-T9mWdbWfQtp0B5lv/HX+wrhYsmXRlcWnXXmJbXqKJhlRaoS6KMhq0gpyzW4UJfclcxrEdLnTgjT2NjruLONu0g==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@types/estree": "1.0.9"
+            },
+            "bin": {
+                "rollup": "dist/bin/rollup"
+            },
+            "engines": {
+                "node": ">=18.0.0",
+                "npm": ">=8.0.0"
+            },
+            "optionalDependencies": {
+                "@rollup/rollup-android-arm-eabi": "4.61.0",
+                "@rollup/rollup-android-arm64": "4.61.0",
+                "@rollup/rollup-darwin-arm64": "4.61.0",
+                "@rollup/rollup-darwin-x64": "4.61.0",
+                "@rollup/rollup-freebsd-arm64": "4.61.0",
+                "@rollup/rollup-freebsd-x64": "4.61.0",
+                "@rollup/rollup-linux-arm-gnueabihf": "4.61.0",
+                "@rollup/rollup-linux-arm-musleabihf": "4.61.0",
+                "@rollup/rollup-linux-arm64-gnu": "4.61.0",
+                "@rollup/rollup-linux-arm64-musl": "4.61.0",
+                "@rollup/rollup-linux-loong64-gnu": "4.61.0",
+                "@rollup/rollup-linux-loong64-musl": "4.61.0",
+                "@rollup/rollup-linux-ppc64-gnu": "4.61.0",
+                "@rollup/rollup-linux-ppc64-musl": "4.61.0",
+                "@rollup/rollup-linux-riscv64-gnu": "4.61.0",
+                "@rollup/rollup-linux-riscv64-musl": "4.61.0",
+                "@rollup/rollup-linux-s390x-gnu": "4.61.0",
+                "@rollup/rollup-linux-x64-gnu": "4.61.0",
+                "@rollup/rollup-linux-x64-musl": "4.61.0",
+                "@rollup/rollup-openbsd-x64": "4.61.0",
+                "@rollup/rollup-openharmony-arm64": "4.61.0",
+                "@rollup/rollup-win32-arm64-msvc": "4.61.0",
+                "@rollup/rollup-win32-ia32-msvc": "4.61.0",
+                "@rollup/rollup-win32-x64-gnu": "4.61.0",
+                "@rollup/rollup-win32-x64-msvc": "4.61.0",
+                "fsevents": "~2.3.2"
+            }
+        },
+        "node_modules/saxes": {
+            "version": "6.0.0",
+            "resolved": "https://registry.npmjs.org/saxes/-/saxes-6.0.0.tgz",
+            "integrity": "sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==",
+            "dev": true,
+            "license": "ISC",
+            "dependencies": {
+                "xmlchars": "^2.2.0"
+            },
+            "engines": {
+                "node": ">=v12.22.7"
+            }
+        },
+        "node_modules/siginfo": {
+            "version": "2.0.0",
+            "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz",
+            "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==",
+            "dev": true,
+            "license": "ISC"
+        },
+        "node_modules/source-map-js": {
+            "version": "1.2.1",
+            "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+            "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+            "dev": true,
+            "license": "BSD-3-Clause",
+            "engines": {
+                "node": ">=0.10.0"
+            }
+        },
+        "node_modules/stackback": {
+            "version": "0.0.2",
+            "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz",
+            "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/std-env": {
+            "version": "3.10.0",
+            "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.10.0.tgz",
+            "integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/symbol-tree": {
+            "version": "3.2.4",
+            "resolved": "https://registry.npmjs.org/symbol-tree/-/symbol-tree-3.2.4.tgz",
+            "integrity": "sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/tinybench": {
+            "version": "2.9.0",
+            "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz",
+            "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/tinyexec": {
+            "version": "0.3.2",
+            "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.2.tgz",
+            "integrity": "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/tinypool": {
+            "version": "1.1.1",
+            "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-1.1.1.tgz",
+            "integrity": "sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": "^18.0.0 || >=20.0.0"
+            }
+        },
+        "node_modules/tinyrainbow": {
+            "version": "1.2.0",
+            "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-1.2.0.tgz",
+            "integrity": "sha512-weEDEq7Z5eTHPDh4xjX789+fHfF+P8boiFB+0vbWzpbnbsEr/GRaohi/uMKxg8RZMXnl1ItAi/IUHWMsjDV7kQ==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=14.0.0"
+            }
+        },
+        "node_modules/tinyspy": {
+            "version": "3.0.2",
+            "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-3.0.2.tgz",
+            "integrity": "sha512-n1cw8k1k0x4pgA2+9XrOkFydTerNcJ1zWCO5Nn9scWHTD+5tp8dghT2x1uduQePZTZgd3Tupf+x9BxJjeJi77Q==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=14.0.0"
+            }
+        },
+        "node_modules/tldts": {
+            "version": "7.4.2",
+            "resolved": "https://registry.npmjs.org/tldts/-/tldts-7.4.2.tgz",
+            "integrity": "sha512-kCwffuaH8ntKtygnWe1b4BJKWiCUH30n5KfoTr6IchcXOwR7chAOFJxFrH3vjANafUYrIA4a7SDL+nn7SiR4Sw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "tldts-core": "^7.4.2"
+            },
+            "bin": {
+                "tldts": "bin/cli.js"
+            }
+        },
+        "node_modules/tldts-core": {
+            "version": "7.4.2",
+            "resolved": "https://registry.npmjs.org/tldts-core/-/tldts-core-7.4.2.tgz",
+            "integrity": "sha512-nwEyF4vl4RSJjwSjBUmOSxc3BFPoIFdlRthJ6e+5v9P3bHNsoD06UjuqMUspqp7vsEZ1beaHi1km+optiE17yA==",
+            "dev": true,
+            "license": "MIT"
+        },
+        "node_modules/tough-cookie": {
+            "version": "6.0.1",
+            "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-6.0.1.tgz",
+            "integrity": "sha512-LktZQb3IeoUWB9lqR5EWTHgW/VTITCXg4D21M+lvybRVdylLrRMnqaIONLVb5mav8vM19m44HIcGq4qASeu2Qw==",
+            "dev": true,
+            "license": "BSD-3-Clause",
+            "dependencies": {
+                "tldts": "^7.0.5"
+            },
+            "engines": {
+                "node": ">=16"
+            }
+        },
+        "node_modules/tr46": {
+            "version": "6.0.0",
+            "resolved": "https://registry.npmjs.org/tr46/-/tr46-6.0.0.tgz",
+            "integrity": "sha512-bLVMLPtstlZ4iMQHpFHTR7GAGj2jxi8Dg0s2h2MafAE4uSWF98FC/3MomU51iQAMf8/qDUbKWf5GxuvvVcXEhw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "punycode": "^2.3.1"
+            },
+            "engines": {
+                "node": ">=20"
+            }
+        },
+        "node_modules/undici": {
+            "version": "7.27.0",
+            "resolved": "https://registry.npmjs.org/undici/-/undici-7.27.0.tgz",
+            "integrity": "sha512-+t2Z/GwkZQDtu00813aP66ygViGtPHKhhoFZpQKpKrE+9jIgES+Zw+mFNaDWOVRKiuJjuqKHzD3B1sfGg8+ZOQ==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=20.18.1"
+            }
+        },
+        "node_modules/vite": {
+            "version": "5.4.21",
+            "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz",
+            "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "esbuild": "^0.21.3",
+                "postcss": "^8.4.43",
+                "rollup": "^4.20.0"
+            },
+            "bin": {
+                "vite": "bin/vite.js"
+            },
+            "engines": {
+                "node": "^18.0.0 || >=20.0.0"
+            },
+            "funding": {
+                "url": "https://github.com/vitejs/vite?sponsor=1"
+            },
+            "optionalDependencies": {
+                "fsevents": "~2.3.3"
+            },
+            "peerDependencies": {
+                "@types/node": "^18.0.0 || >=20.0.0",
+                "less": "*",
+                "lightningcss": "^1.21.0",
+                "sass": "*",
+                "sass-embedded": "*",
+                "stylus": "*",
+                "sugarss": "*",
+                "terser": "^5.4.0"
+            },
+            "peerDependenciesMeta": {
+                "@types/node": {
+                    "optional": true
+                },
+                "less": {
+                    "optional": true
+                },
+                "lightningcss": {
+                    "optional": true
+                },
+                "sass": {
+                    "optional": true
+                },
+                "sass-embedded": {
+                    "optional": true
+                },
+                "stylus": {
+                    "optional": true
+                },
+                "sugarss": {
+                    "optional": true
+                },
+                "terser": {
+                    "optional": true
+                }
+            }
+        },
+        "node_modules/vite-node": {
+            "version": "2.1.9",
+            "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-2.1.9.tgz",
+            "integrity": "sha512-AM9aQ/IPrW/6ENLQg3AGY4K1N2TGZdR5e4gu/MmmR2xR3Ll1+dib+nook92g4TV3PXVyeyxdWwtaCAiUL0hMxA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "cac": "^6.7.14",
+                "debug": "^4.3.7",
+                "es-module-lexer": "^1.5.4",
+                "pathe": "^1.1.2",
+                "vite": "^5.0.0"
+            },
+            "bin": {
+                "vite-node": "vite-node.mjs"
+            },
+            "engines": {
+                "node": "^18.0.0 || >=20.0.0"
+            },
+            "funding": {
+                "url": "https://opencollective.com/vitest"
+            }
+        },
+        "node_modules/vite/node_modules/fsevents": {
+            "version": "2.3.3",
+            "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+            "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+            "dev": true,
+            "hasInstallScript": true,
+            "license": "MIT",
+            "optional": true,
+            "os": [
+                "darwin"
+            ],
+            "engines": {
+                "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+            }
+        },
+        "node_modules/vitest": {
+            "version": "2.1.9",
+            "resolved": "https://registry.npmjs.org/vitest/-/vitest-2.1.9.tgz",
+            "integrity": "sha512-MSmPM9REYqDGBI8439mA4mWhV5sKmDlBKWIYbA3lRb2PTHACE0mgKwA8yQ2xq9vxDTuk4iPrECBAEW2aoFXY0Q==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@vitest/expect": "2.1.9",
+                "@vitest/mocker": "2.1.9",
+                "@vitest/pretty-format": "^2.1.9",
+                "@vitest/runner": "2.1.9",
+                "@vitest/snapshot": "2.1.9",
+                "@vitest/spy": "2.1.9",
+                "@vitest/utils": "2.1.9",
+                "chai": "^5.1.2",
+                "debug": "^4.3.7",
+                "expect-type": "^1.1.0",
+                "magic-string": "^0.30.12",
+                "pathe": "^1.1.2",
+                "std-env": "^3.8.0",
+                "tinybench": "^2.9.0",
+                "tinyexec": "^0.3.1",
+                "tinypool": "^1.0.1",
+                "tinyrainbow": "^1.2.0",
+                "vite": "^5.0.0",
+                "vite-node": "2.1.9",
+                "why-is-node-running": "^2.3.0"
+            },
+            "bin": {
+                "vitest": "vitest.mjs"
+            },
+            "engines": {
+                "node": "^18.0.0 || >=20.0.0"
+            },
+            "funding": {
+                "url": "https://opencollective.com/vitest"
+            },
+            "peerDependencies": {
+                "@edge-runtime/vm": "*",
+                "@types/node": "^18.0.0 || >=20.0.0",
+                "@vitest/browser": "2.1.9",
+                "@vitest/ui": "2.1.9",
+                "happy-dom": "*",
+                "jsdom": "*"
+            },
+            "peerDependenciesMeta": {
+                "@edge-runtime/vm": {
+                    "optional": true
+                },
+                "@types/node": {
+                    "optional": true
+                },
+                "@vitest/browser": {
+                    "optional": true
+                },
+                "@vitest/ui": {
+                    "optional": true
+                },
+                "happy-dom": {
+                    "optional": true
+                },
+                "jsdom": {
+                    "optional": true
+                }
+            }
+        },
+        "node_modules/w3c-xmlserializer": {
+            "version": "5.0.0",
+            "resolved": "https://registry.npmjs.org/w3c-xmlserializer/-/w3c-xmlserializer-5.0.0.tgz",
+            "integrity": "sha512-o8qghlI8NZHU1lLPrpi2+Uq7abh4GGPpYANlalzWxyWteJOCsr/P+oPBA49TOLu5FTZO4d3F9MnWJfiMo4BkmA==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "xml-name-validator": "^5.0.0"
+            },
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/webidl-conversions": {
+            "version": "8.0.1",
+            "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-8.0.1.tgz",
+            "integrity": "sha512-BMhLD/Sw+GbJC21C/UgyaZX41nPt8bUTg+jWyDeg7e7YN4xOM05YPSIXceACnXVtqyEw/LMClUQMtMZ+PGGpqQ==",
+            "dev": true,
+            "license": "BSD-2-Clause",
+            "engines": {
+                "node": ">=20"
+            }
+        },
+        "node_modules/whatwg-mimetype": {
+            "version": "5.0.0",
+            "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-5.0.0.tgz",
+            "integrity": "sha512-sXcNcHOC51uPGF0P/D4NVtrkjSU2fNsm9iog4ZvZJsL3rjoDAzXZhkm2MWt1y+PUdggKAYVoMAIYcs78wJ51Cw==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=20"
+            }
+        },
+        "node_modules/whatwg-url": {
+            "version": "16.0.1",
+            "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-16.0.1.tgz",
+            "integrity": "sha512-1to4zXBxmXHV3IiSSEInrreIlu02vUOvrhxJJH5vcxYTBDAx51cqZiKdyTxlecdKNSjj8EcxGBxNf6Vg+945gw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@exodus/bytes": "^1.11.0",
+                "tr46": "^6.0.0",
+                "webidl-conversions": "^8.0.1"
+            },
+            "engines": {
+                "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+            }
+        },
+        "node_modules/why-is-node-running": {
+            "version": "2.3.0",
+            "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz",
+            "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "siginfo": "^2.0.0",
+                "stackback": "0.0.2"
+            },
+            "bin": {
+                "why-is-node-running": "cli.js"
+            },
+            "engines": {
+                "node": ">=8"
+            }
+        },
+        "node_modules/xml-name-validator": {
+            "version": "5.0.0",
+            "resolved": "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-5.0.0.tgz",
+            "integrity": "sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==",
+            "dev": true,
+            "license": "Apache-2.0",
+            "engines": {
+                "node": ">=18"
+            }
+        },
+        "node_modules/xmlchars": {
+            "version": "2.2.0",
+            "resolved": "https://registry.npmjs.org/xmlchars/-/xmlchars-2.2.0.tgz",
+            "integrity": "sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==",
+            "dev": true,
+            "license": "MIT"
+        }
+    }
+}

package.json ADDED Viewed

	@@ -0,0 +1,17 @@

+{
+    "name": "reachy-mini-morse-code",
+    "private": true,
+    "version": "0.0.0",
+    "type": "module",
+    "description": "Talk to Reachy Mini in Morse code — antenna taps & beeps, heard through the mic.",
+    "scripts": {
+        "test": "vitest run",
+        "test:watch": "vitest",
+        "test:e2e": "playwright test"
+    },
+    "devDependencies": {
+        "@playwright/test": "^1.48.0",
+        "jsdom": "^29.1.1",
+        "vitest": "^2.1.0"
+    }
+}

plan.md ADDED Viewed

	@@ -0,0 +1,111 @@

+# Reachy Mini Morse Code — plan
+## Goal
+A shareable browser app (HF Space, JS, bare-HTML + CDN host shell, mirroring
+`marionette-js`) that lets a Reachy Mini **communicate in Morse code**:
+- The **robot** transmits by *hitting its antennas together* — each hit makes
+  an audible click.
+- A **phone / laptop** transmits by *beeping* through its speaker.
+- Either device (or a second robot) **listens** through a microphone, detects
+  the impulses, and decodes them back to text.
+- Two Reachy Minis face-to-face can therefore talk to each other.
+## Why an "impulse" wire code (the key design decision)
+An antenna hit is **impulsive**: it produces one short click. You cannot make a
+click "longer" the way a tone can be held, so we **cannot** use the classic
+Morse discriminator (dot = short tone, dash = long tone) on the robot channel.
+To keep *every* channel interoperable through *one* detector (robot-clicks,
+phone-beeps, robot↔robot), the on-the-wire code is built from **onsets only**
+(the instant each sound starts), and dot vs dash is carried by **rhythm**:
+- **dot**  = 1 impulse
+- **dash** = 2 impulses spaced by `dahGapMs` (a quick double-tap)
+- elements within a letter separated by `elemGapMs`
+- letters separated by `letterGapMs`
+- words separated by `wordGapMs`
+with `dahGapMs < elemGapMs < letterGapMs < wordGapMs` (well separated so the
+decoder can bin each inter-onset interval unambiguously). This is still real
+Morse semantically — the learn-chart shows the standard `.-` patterns — it is
+just transmitted as an impulse rhythm instead of tone length. The user
+explicitly framed Morse as "an equivalence between letters and rhythm", which
+is exactly this.
+Beeps use the *same* impulse code (short clicks) so a beeping phone and a
+tapping robot are mutually intelligible. (An "audible long-tone" cosmetic mode
+can be added later; it is not the machine-decodable wire format.)
+All timings live in one `timing.js` config with a single `unitMs` speed knob,
+so they can be **calibrated on real hardware** (click sharpness, room
+reverb, mic latency) without touching logic.
+## Detection algorithm (ported from `marionette/tests/audio_analysis.py`)
+`detect_transient_onsets`, proven in the Marionette audio-sync tests:
+1. High-pass filter (~2 kHz) to isolate sharp clicks from room rumble / voice.
+2. Short-term energy in 5 ms windows.
+3. Spectral flux = positive energy differences.
+4. Normalise, peak-pick with a min-separation guard.
+Ported to the Web Audio API (`BiquadFilter` highpass + per-frame energy/flux in
+an `AudioWorklet`/`ScriptProcessor`) for live mic decoding, and to a pure-JS
+offline function reused verbatim in unit tests against synthetic audio.
+## Architecture (bare-HTML + CDN host shell, like marionette-js)
+```
+index.html   #root (host shell mount) + #app (in-iframe surface), CDN SDK pin
+main.js      dispatcher: standalone mountHost() | embed connectToHost()
+style.css    mobile-first, OKLCH palette, dark/light from handle.theme
+lib/
+  morse.js        text <-> morse string ('.- ...') tables + encode/decode  [pure, tested]
+  timing.js       unit/gap config + WPM-ish speed presets                  [pure, tested]
+  wire.js         morse <-> timed impulse schedule (emit) and onset-times
+                  -> morse decode (gap binning)                            [pure, tested]
+  detector.js     offline + streaming transient-onset detector (Web Audio) [DSP core tested]
+  synth.js        Web Audio click/beep emitter (plays a wire schedule)
+  robot-tapper.js drives antennas to clap on schedule (setAntennasDeg)
+  mic.js          getUserMedia -> streaming detector -> onset times
+  viz.js          canvas waveform + live onset markers
+  animation-helpers.js  re-export SDK /animation (safelyReturnToPose)      [stubbed in tests]
+views/
+  composer.js     type text -> choose emitter (robot antennas | this device) -> send
+  listener.js     live mic visualization + decoded text
+  learn.js        Morse chart (letter <-> .- <-> rhythm), tap-to-hear
+  topbar.js / settings.js  speed + detector threshold + theme
+tests/unit/       morse, wire, detector (synthetic round-trip) — vitest
+public/icon.svg
+README.md         HF Space frontmatter (sdk: static, hf_oauth, tags)
+```
+## Robot antenna "clap" (from `marionette/tests/test_antenna_collision.py`)
+Right antenna held, left antenna slams in to contact and back — low-PID
+antennas make this safe and audible. In the JS SDK we drive it in real time
+with `setAntennasDeg(right, left)` on a timed schedule from `wire.js`. Exact
+contact angles + hold time get **calibrated on hardware**; defaults seeded from
+the Marionette recipe (right ≈ −39°, left rest 0° → slam ≈ +40°).
+## What needs hardware (deferred — will ping Rémi)
+1. **Mic + speaker calibration**: emit the impulse schedule from the Mac
+   speaker, record with the Mac mic, confirm the detector recovers the onsets
+   through-air and tune `unitMs` / thresholds / highpass. (Noise — needs Rémi.)
+2. **Robot antenna-click test**: confirm the clap is audible + detectable and
+   tune the contact angles / hold. (Needs the robot connected.)
+Everything else (codec, detector DSP, full UI, synth, robot-tapper wiring) is
+built and validated in software first (synthetic-audio round-trip, no
+mic/speaker/robot).
+## Open questions (defaulted; will confirm with Rémi, non-blocking)
+- App/Space name: `morse-code` / "Reachy Mini Morse Code". Deploy to
+  `RemiFabre/<name>` (user is logged in as RemiFabre, org pollen-robotics).
+- Default speed: ~`unitMs = 120 ms` (slow & robust) — final value from calibration.
+- Long-tone cosmetic beep mode: out of scope for v1 (impulse code only).

playwright.config.js ADDED Viewed

	@@ -0,0 +1,19 @@

+import { defineConfig, devices } from "@playwright/test";
+// Smoke test only: serve the static folder and confirm the app's module
+// graph (including the CDN host-shell + SDK imports) loads in a real browser
+// without fatal errors. The full embed flow needs a live robot.
+export default defineConfig({
+    testDir: "./tests/e2e",
+    timeout: 45_000,
+    use: {
+        baseURL: "http://localhost:4321",
+        ...devices["Desktop Chrome"],
+    },
+    webServer: {
+        command: "python3 -m http.server 4321",
+        port: 4321,
+        reuseExistingServer: true,
+        timeout: 20_000,
+    },
+});

public/icon.svg ADDED Viewed

style.css ADDED Viewed

	@@ -0,0 +1,290 @@

+/* Morse Code · Reachy Mini — mobile-first, dark/light themed. */
+:root {
+    --bg: #0d1117;
+    --bg-soft: #161b22;
+    --panel: #1b222c;
+    --panel-2: #232c38;
+    --text: #e8edf3;
+    --muted: #93a1b3;
+    --line: #2b3442;
+    --accent: #5b8cff;
+    --accent-2: #8a6cff;
+    --danger: #ff5a78;
+    --good: #36d399;
+    --scope-fill: rgba(91, 140, 255, 0.45);
+    --scope-mark: rgba(255, 90, 120, 0.95);
+    --radius: 16px;
+    --shadow: 0 10px 30px rgba(0, 0, 0, 0.45);
+}
+:root[data-theme="light"] {
+    --bg: #f4f6fb;
+    --bg-soft: #ffffff;
+    --panel: #ffffff;
+    --panel-2: #eef2f9;
+    --text: #131923;
+    --muted: #5d6b7e;
+    --line: #dde3ee;
+    --accent: #2f6bff;
+    --accent-2: #7a4dff;
+    --scope-fill: rgba(47, 107, 255, 0.30);
+    --scope-mark: rgba(214, 40, 79, 0.95);
+    --shadow: 0 10px 30px rgba(20, 30, 60, 0.12);
+}
+* { box-sizing: border-box; }
+html, body {
+    margin: 0;
+    padding: 0;
+    background: var(--bg);
+    color: var(--text);
+    font-family: "Inter", system-ui, -apple-system, sans-serif;
+    -webkit-font-smoothing: antialiased;
+}
+#app {
+    min-height: 100dvh;
+    display: flex;
+    flex-direction: column;
+    max-width: 720px;
+    margin: 0 auto;
+}
+/* ─── App bar ─────────────────────────────────────────────── */
+.appbar {
+    position: sticky;
+    top: 0;
+    z-index: 10;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 14px 18px calc(14px + env(safe-area-inset-top));
+    padding-top: max(14px, env(safe-area-inset-top));
+    background: color-mix(in srgb, var(--bg) 88%, transparent);
+    backdrop-filter: blur(12px);
+    border-bottom: 1px solid var(--line);
+}
+.brand { display: flex; align-items: center; gap: 10px; font-weight: 800; font-size: 19px; letter-spacing: -0.02em; }
+.brand-logo { font-size: 22px; }
+.icon-btn {
+    appearance: none;
+    background: var(--panel);
+    border: 1px solid var(--line);
+    color: var(--text);
+    width: 40px; height: 40px;
+    border-radius: 12px;
+    font-size: 18px;
+    cursor: pointer;
+}
+.icon-btn:active { transform: scale(0.95); }
+/* ─── View host + tabbar ──────────────────────────────────── */
+.view-host { flex: 1; padding: 16px 16px 96px; }
+.view { display: flex; flex-direction: column; gap: 16px; }
+.view h2 { margin: 4px 0 0; font-size: 24px; letter-spacing: -0.02em; }
+.view h3 { margin: 6px 0; font-size: 15px; color: var(--muted); text-transform: uppercase; letter-spacing: 0.08em; }
+.muted { color: var(--muted); }
+.tabbar {
+    position: fixed;
+    left: 0; right: 0; bottom: 0;
+    z-index: 10;
+    display: flex;
+    justify-content: center;
+    gap: 6px;
+    padding: 8px 8px calc(8px + env(safe-area-inset-bottom));
+    background: color-mix(in srgb, var(--bg) 92%, transparent);
+    backdrop-filter: blur(12px);
+    border-top: 1px solid var(--line);
+}
+.tab {
+    flex: 1 1 0;
+    max-width: 160px;
+    appearance: none;
+    background: transparent;
+    border: 0;
+    color: var(--muted);
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 3px;
+    padding: 6px;
+    border-radius: 12px;
+    font-size: 12px;
+    font-weight: 600;
+    cursor: pointer;
+}
+.tab-ico { font-size: 20px; }
+.tab.active { color: var(--accent); background: color-mix(in srgb, var(--accent) 12%, transparent); }
+/* ─── Fields & controls ───────────────────────────────────── */
+.field { display: flex; flex-direction: column; gap: 8px; }
+.field-label { font-size: 13px; font-weight: 600; color: var(--muted); }
+.row { display: flex; gap: 10px; align-items: center; }
+.row.between { justify-content: space-between; }
+.send-row { margin-top: 4px; }
+.compose-input {
+    width: 100%;
+    resize: vertical;
+    min-height: 84px;
+    padding: 14px;
+    font-size: 18px;
+    font-family: inherit;
+    color: var(--text);
+    background: var(--panel);
+    border: 1px solid var(--line);
+    border-radius: var(--radius);
+    outline: none;
+}
+.compose-input:focus { border-color: var(--accent); }
+.btn {
+    appearance: none;
+    border: 1px solid var(--line);
+    background: var(--panel);
+    color: var(--text);
+    padding: 12px 18px;
+    border-radius: 14px;
+    font-size: 15px;
+    font-weight: 700;
+    cursor: pointer;
+}
+.btn:active { transform: scale(0.98); }
+.btn:disabled { opacity: 0.5; cursor: not-allowed; }
+.btn.primary { background: linear-gradient(135deg, var(--accent), var(--accent-2)); border: 0; color: #fff; }
+.btn.ghost { background: transparent; }
+.btn.big { flex: 1; padding: 16px; font-size: 17px; }
+.btn.listening { background: linear-gradient(135deg, var(--danger), #ff9a5a); }
+.segmented { display: flex; gap: 6px; background: var(--panel); border: 1px solid var(--line); border-radius: 14px; padding: 5px; }
+.seg {
+    flex: 1;
+    appearance: none;
+    background: transparent;
+    border: 0;
+    color: var(--muted);
+    padding: 10px 8px;
+    border-radius: 10px;
+    font-size: 14px;
+    font-weight: 600;
+    cursor: pointer;
+}
+.seg.active { background: var(--panel-2); color: var(--text); box-shadow: var(--shadow); }
+.range { width: 100%; accent-color: var(--accent); }
+.range-val { font-variant-numeric: tabular-nums; font-weight: 700; color: var(--text); }
+.status { font-size: 13px; min-height: 18px; }
+.warn { color: var(--danger); font-size: 14px; font-weight: 600; }
+/* ─── Morse chips ─────────────────────────────────────────── */
+.morse-out {
+    min-height: 48px;
+    display: flex;
+    flex-wrap: wrap;
+    align-items: center;
+    gap: 6px 12px;
+    padding: 14px;
+    background: var(--panel);
+    border: 1px solid var(--line);
+    border-radius: var(--radius);
+}
+.pattern { display: inline-flex; align-items: center; gap: 4px; }
+.pattern .dot, .pattern .dash {
+    display: inline-block;
+    height: 12px;
+    border-radius: 6px;
+    background: var(--accent);
+}
+.pattern .dot { width: 12px; }
+.pattern .dash { width: 30px; background: var(--accent-2); }
+.wordsep { color: var(--muted); font-weight: 800; padding: 0 2px; }
+/* ─── Listen ──────────────────────────────────────────────── */
+.scope {
+    width: 100%;
+    height: 130px;
+    background: var(--panel);
+    border: 1px solid var(--line);
+    border-radius: var(--radius);
+    display: block;
+}
+.decoded-text {
+    font-family: "JetBrains Mono", ui-monospace, monospace;
+    font-size: 26px;
+    font-weight: 700;
+    letter-spacing: 0.04em;
+    min-height: 34px;
+    word-break: break-word;
+}
+.decoded-morse { font-family: "JetBrains Mono", ui-monospace, monospace; font-size: 14px; word-break: break-all; }
+.transcript { display: flex; flex-direction: column; gap: 8px; }
+.line {
+    display: flex; flex-direction: column; gap: 2px;
+    padding: 10px 12px;
+    background: var(--panel);
+    border: 1px solid var(--line);
+    border-radius: 12px;
+}
+.line-text { font-family: "JetBrains Mono", monospace; font-weight: 700; font-size: 16px; }
+.line-morse { font-family: "JetBrains Mono", monospace; font-size: 12px; }
+/* ─── Learn chart ─────────────────────────────────────────── */
+.chart-section { display: flex; flex-direction: column; gap: 8px; }
+.chart-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(96px, 1fr)); gap: 8px; }
+.chart-cell {
+    appearance: none;
+    display: flex; flex-direction: column; align-items: center; gap: 8px;
+    padding: 12px 8px;
+    background: var(--panel);
+    border: 1px solid var(--line);
+    border-radius: 14px;
+    color: var(--text);
+    cursor: pointer;
+}
+.chart-cell:active { transform: scale(0.96); }
+.cell-char { font-size: 22px; font-weight: 800; }
+.chart-cell.ping { animation: ping 0.4s ease; border-color: var(--accent); }
+@keyframes ping { 0% { box-shadow: 0 0 0 0 color-mix(in srgb, var(--accent) 60%, transparent); } 100% { box-shadow: 0 0 0 14px transparent; } }
+.legend { display: flex; gap: 18px; flex-wrap: wrap; color: var(--muted); font-size: 14px; }
+.legend-item { display: inline-flex; align-items: center; gap: 8px; }
+/* ─── Settings sheet / overlay ────────────────────────────── */
+.overlay {
+    position: fixed; inset: 0; z-index: 50;
+    background: rgba(0, 0, 0, 0.5);
+    display: flex; align-items: flex-end; justify-content: center;
+}
+.sheet {
+    width: 100%;
+    max-width: 720px;
+    max-height: 88dvh;
+    overflow-y: auto;
+    background: var(--bg-soft);
+    border-radius: 22px 22px 0 0;
+    box-shadow: var(--shadow);
+    padding: 16px 18px calc(28px + env(safe-area-inset-bottom));
+}
+.sheet-head { display: flex; align-items: center; justify-content: space-between; position: sticky; top: 0; background: var(--bg-soft); padding-bottom: 8px; }
+.settings-body { display: flex; flex-direction: column; gap: 14px; }
+.version { text-align: center; font-size: 12px; margin-top: 6px; }
+/* ─── Toast ───────────────────────────────────────────────── */
+.toast {
+    position: fixed; left: 50%; bottom: 110px; transform: translateX(-50%) translateY(20px);
+    background: var(--panel-2); color: var(--text);
+    border: 1px solid var(--line);
+    padding: 12px 18px; border-radius: 12px;
+    box-shadow: var(--shadow);
+    opacity: 0; pointer-events: none; transition: all 0.25s ease;
+    z-index: 100; max-width: 90vw; text-align: center;
+}
+.toast.show { opacity: 1; transform: translateX(-50%) translateY(0); }
+@media (min-width: 560px) {
+    .tab-label { font-size: 13px; }
+}

tests/e2e/smoke.spec.js ADDED Viewed

	@@ -0,0 +1,34 @@

+import { test, expect } from "@playwright/test";
+// Fatal = the module graph failed to load (bad import URL, syntax error,
+// missing global). We tolerate runtime warnings the host shell may emit
+// before sign-in, but not these.
+const FATAL = /(SyntaxError|ReferenceError|is not defined|Failed to fetch dynamically imported module|Unexpected token)/;
+test("standalone page loads the module graph (host shell mounts, no fatal errors)", async ({ page }) => {
+    const fatals = [];
+    page.on("pageerror", (e) => { if (FATAL.test(String(e))) fatals.push(String(e)); });
+    page.on("console", (m) => { if (m.type() === "error" && FATAL.test(m.text())) fatals.push(m.text()); });
+    await page.goto("/");
+    // mountHost() renders the host shell (sign-in / picker) into #root.
+    // We only assert the module graph executed far enough to populate it.
+    await expect.poll(
+        async () => page.locator("#root").evaluate((n) => n.childElementCount),
+        { timeout: 30_000 },
+    ).toBeGreaterThan(0);
+    expect(fatals, `fatal load errors:\n${fatals.join("\n")}`).toEqual([]);
+});
+test("embedded boot path imports cleanly (no module-load error)", async ({ page }) => {
+    const fatals = [];
+    page.on("pageerror", (e) => { if (FATAL.test(String(e))) fatals.push(String(e)); });
+    // ?embedded=1 runs bootEmbed(): connectToHost() will not complete without
+    // a host, but importing it + our whole module graph must not throw.
+    await page.goto("/?embedded=1");
+    await page.waitForTimeout(4000);
+    expect(fatals, `fatal load errors:\n${fatals.join("\n")}`).toEqual([]);
+});

tests/stubs/animation-helpers.js ADDED Viewed

	@@ -0,0 +1,10 @@

+// Test stub for lib/animation-helpers.js (the SDK /animation re-export).
+// Unit tests never drive the robot; these are inert placeholders.
+export const INIT_POSE = {};
+export const INIT_ANTENNAS_RAD = [0, 0];
+export const DEFAULT_SCALED_DURATION_PRESET = {};
+export function safelyReturnToPose() {}
+export function scaledDuration() {
+    return { duration: 1 };
+}
+export function installShutdownHandler() {}

tests/unit/detector.test.js ADDED Viewed

	@@ -0,0 +1,98 @@

+import { describe, it, expect } from "vitest";
+import { detectTransientOnsets, highpass, energyFlux } from "../../lib/detector.js";
+import { textToSchedule, decodeOnsets } from "../../lib/wire.js";
+import { makeTiming } from "../../lib/timing.js";
+const SR = 48000;
+const T = makeTiming(120);
+/**
+ * Render an onset schedule (ms) into a synthetic mono buffer.
+ * Each impulse is a short decaying ~4 kHz burst (sharp click, energy well
+ * above the 2 kHz highpass). Optionally add a low 60 Hz hum + deterministic
+ * pseudo-noise to prove the highpass + flux stages are doing real work.
+ */
+function renderClicks(onsetsMs, { leadMs = 60, tailMs = 300, hum = 0, noise = 0 } = {}) {
+    // Lead-in silence: a real listener is already recording before the
+    // sender starts, so the very first click has a low-energy window before
+    // it for the rising-edge detector to key off.
+    const durMs = leadMs + (onsetsMs.length ? onsetsMs[onsetsMs.length - 1] : 0) + tailMs;
+    const n = Math.ceil((durMs / 1000) * SR);
+    const buf = new Float32Array(n);
+    const clickLen = Math.round(0.01 * SR); // 10 ms
+    const tau = 0.0015; // 1.5 ms decay
+    for (const t0 of onsetsMs) {
+        const start = Math.round(((t0 + leadMs) / 1000) * SR);
+        for (let j = 0; j < clickLen && start + j < n; j++) {
+            const tt = j / SR;
+            buf[start + j] += 0.6 * Math.exp(-tt / tau) * Math.sin(2 * Math.PI * 4000 * tt);
+        }
+    }
+    if (hum || noise) {
+        for (let i = 0; i < n; i++) {
+            const tt = i / SR;
+            if (hum) buf[i] += hum * Math.sin(2 * Math.PI * 60 * tt);
+            // deterministic low-level "noise": sum of a few incommensurate tones
+            if (noise) {
+                buf[i] += noise * (
+                    Math.sin(2 * Math.PI * 137 * tt) +
+                    Math.sin(2 * Math.PI * 311 * tt)
+                ) * 0.5;
+            }
+        }
+    }
+    return buf;
+}
+describe("highpass + energyFlux primitives", () => {
+    it("highpass removes a strong 60 Hz hum", () => {
+        const n = SR; // 1 s
+        const hum = new Float32Array(n);
+        for (let i = 0; i < n; i++) hum[i] = Math.sin(2 * Math.PI * 60 * (i / SR));
+        const filtered = highpass(hum, SR, 2000);
+        let rmsIn = 0, rmsOut = 0;
+        for (let i = 0; i < n; i++) { rmsIn += hum[i] ** 2; rmsOut += filtered[i] ** 2; }
+        expect(Math.sqrt(rmsOut / n)).toBeLessThan(Math.sqrt(rmsIn / n) * 0.05);
+    });
+    it("energyFlux returns positive spikes around clicks", () => {
+        const buf = renderClicks([100, 500]);
+        const { flux } = energyFlux(highpass(buf, SR, 2000), SR, 5);
+        let maxFlux = 0;
+        for (const f of flux) if (f > maxFlux) maxFlux = f;
+        expect(maxFlux).toBeGreaterThan(0);
+    });
+});
+describe("detectTransientOnsets — count + timing", () => {
+    it("finds all 12 impulses of SOS within 25 ms", () => {
+        const { onsets } = textToSchedule("SOS", T);
+        const detected = detectTransientOnsets(renderClicks(onsets), SR);
+        expect(detected.length).toBe(onsets.length);
+        // Compare spacing relative to the first onset (absorbs the constant
+        // lead-in offset + any fixed detection latency).
+        for (let i = 0; i < onsets.length; i++) {
+            const exp = onsets[i] - onsets[0];
+            const got = detected[i] - detected[0];
+            expect(Math.abs(got - exp)).toBeLessThan(25);
+        }
+    });
+});
+describe("end-to-end: text -> clicks -> detect -> decode", () => {
+    const phrases = ["SOS", "HI", "HELLO WORLD", "CQ CQ"];
+    for (const text of phrases) {
+        it(`recovers "${text}" from clean synthetic audio`, () => {
+            const { onsets } = textToSchedule(text, T);
+            const detected = detectTransientOnsets(renderClicks(onsets), SR);
+            expect(decodeOnsets(detected, T).text).toBe(text);
+        });
+        it(`recovers "${text}" through 60 Hz hum + tonal noise`, () => {
+            const { onsets } = textToSchedule(text, T);
+            const buf = renderClicks(onsets, { hum: 0.15, noise: 0.03 });
+            const detected = detectTransientOnsets(buf, SR);
+            expect(decodeOnsets(detected, T).text).toBe(text);
+        });
+    }
+});

tests/unit/morse.test.js ADDED Viewed

	@@ -0,0 +1,71 @@

+import { describe, it, expect } from "vitest";
+import {
+    textToMorse,
+    morseToText,
+    morseToTokens,
+    isEncodable,
+} from "../../lib/morse.js";
+describe("textToMorse", () => {
+    it("encodes SOS", () => {
+        expect(textToMorse("SOS").morse).toBe("... --- ...");
+    });
+    it("is case-insensitive", () => {
+        expect(textToMorse("sos").morse).toBe("... --- ...");
+    });
+    it("separates words with /", () => {
+        expect(textToMorse("HI YOU").morse).toBe(".... .. / -.-- --- ..-");
+    });
+    it("encodes digits and punctuation", () => {
+        expect(textToMorse("E1?").morse).toBe(". .---- ..--..");
+    });
+    it("reports skipped (non-encodable) characters", () => {
+        const r = textToMorse("Aé😀");
+        expect(r.morse).toBe(".-");
+        expect(r.skipped).toContain("É");
+    });
+});
+describe("morseToText", () => {
+    it("decodes SOS", () => {
+        expect(morseToText("... --- ...")).toBe("SOS");
+    });
+    it("decodes multi-word with /", () => {
+        expect(morseToText(".... .. / -.-- --- ..-")).toBe("HI YOU");
+    });
+    it("round-trips a sentence", () => {
+        const text = "HELLO WORLD 123";
+        expect(morseToText(textToMorse(text).morse)).toBe(text);
+    });
+    it("maps unknown pattern to ?", () => {
+        expect(morseToText("........")).toBe("?");
+    });
+});
+describe("morseToTokens", () => {
+    it("flattens A (.-) into dot, elemGap, dah", () => {
+        expect(morseToTokens(".-")).toEqual(["dot", "elemGap", "dah"]);
+    });
+    it("inserts letterGap between letters and wordGap between words", () => {
+        // "E E / E" -> dot, letterGap, dot, wordGap, dot
+        expect(morseToTokens(". . / .")).toEqual([
+            "dot", "letterGap", "dot", "wordGap", "dot",
+        ]);
+    });
+});
+describe("isEncodable", () => {
+    it("accepts letters/digits, rejects emoji", () => {
+        expect(isEncodable("a")).toBe(true);
+        expect(isEncodable("7")).toBe(true);
+        expect(isEncodable("😀")).toBe(false);
+    });
+});

tests/unit/views.test.js ADDED Viewed

	@@ -0,0 +1,96 @@

+// @vitest-environment jsdom
+import { describe, it, expect, vi } from "vitest";
+import { makeTiming, SPEED_PRESETS } from "../../lib/timing.js";
+import { createCompose } from "../../views/compose.js";
+import { createLearn } from "../../views/learn.js";
+import { createSettings } from "../../views/settings.js";
+import { createListen } from "../../views/listen.js";
+import { DEFAULT_TAP_PROFILE } from "../../lib/robot-tapper.js";
+function makeCtx(overrides = {}) {
+    const state = {
+        speed: "normal",
+        unitMs: SPEED_PRESETS.normal,
+        emitter: "device",
+        beepFreq: 2200,
+        detector: { highpassHz: 2000, thresholdFactor: 4.0 },
+        tap: { ...DEFAULT_TAP_PROFILE },
+    };
+    const synth = { play: vi.fn(), stop: vi.fn(), freq: 2200 };
+    return {
+        reachy: null,
+        state,
+        timing: () => makeTiming(state.unitMs),
+        setSpeed: (p) => { state.speed = p; if (SPEED_PRESETS[p]) state.unitMs = SPEED_PRESETS[p]; },
+        synth: () => synth,
+        tapper: () => null,
+        makeMic: () => ({ start: vi.fn(), stop: vi.fn(), now: () => 0 }),
+        toast: vi.fn(),
+        _synth: synth,
+        ...overrides,
+    };
+}
+describe("Compose view", () => {
+    it("renders Morse chips for the default message", () => {
+        const ctx = makeCtx();
+        const { node } = createCompose(ctx);
+        const input = node.querySelector(".compose-input");
+        expect(input.value).toBe("SOS");
+        // SOS = 3 + 3 + 3 = 9 symbol chips
+        expect(node.querySelectorAll(".morse-out .pattern").length).toBe(3);
+        expect(node.querySelectorAll(".morse-out .dot, .morse-out .dash").length).toBe(9);
+    });
+    it("updates preview on input and warns on non-encodable chars", () => {
+        const ctx = makeCtx();
+        const { node } = createCompose(ctx);
+        const input = node.querySelector(".compose-input");
+        input.value = "Aé";
+        input.dispatchEvent(new window.Event("input"));
+        expect(node.querySelector(".warn").hidden).toBe(false);
+        // 'A' -> .- = 2 chips
+        expect(node.querySelectorAll(".morse-out .dot, .morse-out .dash").length).toBe(2);
+    });
+    it("plays via synth when emitter is device", () => {
+        const ctx = makeCtx();
+        const { node } = createCompose(ctx);
+        node.querySelector(".btn.primary").click();
+        expect(ctx._synth.play).toHaveBeenCalled();
+    });
+});
+describe("Learn view", () => {
+    it("renders a tile per letter, digit and punctuation, and plays on tap", () => {
+        const ctx = makeCtx();
+        const { node } = createLearn(ctx);
+        const cells = node.querySelectorAll(".chart-cell");
+        expect(cells.length).toBe(26 + 10 + 12);
+        cells[0].click(); // 'A'
+        expect(ctx._synth.play).toHaveBeenCalled();
+    });
+});
+describe("Settings view", () => {
+    it("renders calibration sliders and mutates config", () => {
+        const ctx = makeCtx();
+        const { node } = createSettings(ctx);
+        const ranges = node.querySelectorAll("input.range");
+        expect(ranges.length).toBeGreaterThanOrEqual(8);
+        // first range is the speed unit
+        ranges[0].value = "200";
+        ranges[0].dispatchEvent(new window.Event("input"));
+        expect(ctx.state.unitMs).toBe(200);
+    });
+});
+describe("Listen view", () => {
+    it("builds without a mic and shows placeholder decode", () => {
+        const ctx = makeCtx();
+        const { node } = createListen(ctx);
+        expect(node.querySelector(".scope")).toBeTruthy();
+        expect(node.querySelector(".decoded-text").textContent).toBe("…");
+        expect(node.querySelector(".btn.primary").textContent).toMatch(/Start listening/);
+    });
+});

tests/unit/wire.test.js ADDED Viewed

	@@ -0,0 +1,73 @@

+import { describe, it, expect } from "vitest";
+import {
+    tokensToOnsets,
+    textToSchedule,
+    onsetsToMorse,
+    decodeOnsets,
+} from "../../lib/wire.js";
+import { morseToTokens } from "../../lib/morse.js";
+import { makeTiming } from "../../lib/timing.js";
+const T = makeTiming(120); // dah=240 elem=480 letter=960 word=1680
+describe("tokensToOnsets", () => {
+    it("dot = 1 impulse", () => {
+        expect(tokensToOnsets(["dot"], T)).toEqual([0]);
+    });
+    it("dash = 2 impulses spaced by dahGap", () => {
+        expect(tokensToOnsets(["dah"], T)).toEqual([0, T.dahGapMs]);
+    });
+    it("A (.-) spaces the dash element after elemGap from the dot", () => {
+        // dot@0, elemGap, dah@(elem), dah2@(elem+dah)
+        expect(tokensToOnsets(morseToTokens(".-"), T)).toEqual([
+            0,
+            T.elemGapMs,
+            T.elemGapMs + T.dahGapMs,
+        ]);
+    });
+});
+describe("onsetsToMorse round-trip (ideal timing)", () => {
+    const samples = ["SOS", "HELLO WORLD", "HI YOU", "CQ CQ", "E T 1 9", "ABCDE"];
+    for (const text of samples) {
+        it(`recovers "${text}"`, () => {
+            const { morse, onsets } = textToSchedule(text, T);
+            expect(onsetsToMorse(onsets, T)).toBe(morse);
+            expect(decodeOnsets(onsets, T).text).toBe(text);
+        });
+    }
+});
+describe("onsetsToMorse with timing jitter", () => {
+    // Deterministic pseudo-jitter (no Math.random): perturb each onset by a
+    // bounded sawtooth. Should still decode because gap classes are well
+    // separated (geometric midpoints).
+    function jitter(onsets, maxMs) {
+        return onsets.map((t, i) => t + (((i * 37) % 11) - 5) / 5 * maxMs);
+    }
+    it("decodes SOS with +-30ms jitter", () => {
+        const { onsets, text } = { ...textToSchedule("SOS", T) };
+        const jittered = jitter(onsets, 30);
+        expect(decodeOnsets(jittered, T).text).toBe("SOS");
+        expect(text).toBeUndefined; // sanity: textToSchedule has no .text
+    });
+    it("decodes a sentence with +-40ms jitter", () => {
+        const { onsets } = textToSchedule("HELLO WORLD", T);
+        expect(decodeOnsets(jitter(onsets, 40), T).text).toBe("HELLO WORLD");
+    });
+});
+describe("edge cases", () => {
+    it("empty onsets -> empty", () => {
+        expect(onsetsToMorse([], T)).toBe("");
+        expect(decodeOnsets([], T)).toEqual({ morse: "", text: "" });
+    });
+    it("single impulse -> E", () => {
+        expect(decodeOnsets([0], T).text).toBe("E");
+    });
+});

views/compose.js ADDED Viewed

	@@ -0,0 +1,164 @@

+/**
+ * Compose view: type a message, see its Morse, pick who transmits (the robot's
+ * antennas or this device's speaker), and send it.
+ */
+import { el, clear, morsePattern } from "./dom.js";
+import { textToMorse, morseToTokens } from "../lib/morse.js";
+import { tokensToOnsets } from "../lib/wire.js";
+export function createCompose(ctx) {
+    const root = el("section.view#view-compose");
+    const input = el("textarea.compose-input", {
+        placeholder: "Type a message… e.g. SOS",
+        rows: 3,
+        value: "SOS",
+        oninput: refresh,
+    });
+    const morseOut = el("div.morse-out");
+    const warn = el("div.warn", { hidden: true });
+    const duration = el("span.muted");
+    const emitter = segmented(
+        "Who sends it?",
+        [
+            { value: "robot", label: "🤖 Robot antennas" },
+            { value: "device", label: "📱 This device" },
+        ],
+        ctx.state.emitter,
+        (v) => { ctx.state.emitter = v; refresh(); },
+    );
+    const speed = segmented(
+        "Speed",
+        [
+            { value: "relaxed", label: "Relaxed" },
+            { value: "normal", label: "Normal" },
+            { value: "brisk", label: "Brisk" },
+        ],
+        ctx.state.speed,
+        (v) => { ctx.setSpeed(v); refresh(); },
+    );
+    const sendBtn = el("button.btn.primary.big", { onclick: send }, "Send ▶");
+    const stopBtn = el("button.btn.ghost", { onclick: stop, hidden: true }, "Stop ◼");
+    const status = el("div.status muted");
+    let cancelFn = null;
+    function currentSchedule() {
+        const { morse, skipped } = textToMorse(input.value);
+        const onsets = tokensToOnsets(morseToTokens(morse), ctx.timing());
+        return { morse, skipped, onsets };
+    }
+    function refresh() {
+        const { morse, skipped, onsets } = currentSchedule();
+        clear(morseOut);
+        if (!morse) {
+            morseOut.append(el("span.muted", {}, "Your Morse will appear here."));
+        } else {
+            morse.split(" / ").forEach((word, wi) => {
+                if (wi > 0) morseOut.append(el("span.wordsep", {}, "/"));
+                word.split(" ").forEach((p) => morseOut.append(morsePattern(p)));
+            });
+        }
+        if (skipped.length) {
+            warn.hidden = false;
+            warn.textContent = `Can't send in Morse: ${[...new Set(skipped)].join(" ")}`;
+        } else {
+            warn.hidden = true;
+        }
+        const secs = onsets.length ? (onsets[onsets.length - 1] / 1000 + 0.3) : 0;
+        duration.textContent = onsets.length ? `${onsets.length} taps · ~${secs.toFixed(1)}s` : "";
+        // reflect speed selection if changed elsewhere
+        speed.setValue(ctx.state.speed);
+        emitter.setValue(ctx.state.emitter);
+    }
+    async function send() {
+        const { onsets } = currentSchedule();
+        if (!onsets.length) return;
+        setSending(true);
+        const controller = new AbortController();
+        const highlight = (i) => flashTap(i, onsets.length);
+        try {
+            if (ctx.state.emitter === "robot") {
+                if (!ctx.reachy) { ctx.toast("No robot connected."); return; }
+                cancelFn = () => controller.abort();
+                await ctx.tapper().tap(onsets, { onTap: highlight, signal: controller.signal });
+            } else {
+                await new Promise((resolve) => {
+                    const cancel = ctx.synth().play(onsets, {
+                        onBlip: highlight,
+                        onDone: resolve,
+                        clickMs: ctx.timing().clickMs,
+                    });
+                    cancelFn = () => { cancel(); resolve(); };
+                });
+            }
+        } catch (e) {
+            ctx.toast(`Send failed: ${e?.message || e}`);
+        } finally {
+            setSending(false);
+            cancelFn = null;
+        }
+    }
+    function stop() {
+        cancelFn?.();
+        ctx.synth().stop();
+        ctx.tapper()?.stop?.();
+        setSending(false);
+    }
+    function setSending(on) {
+        sendBtn.hidden = on;
+        stopBtn.hidden = !on;
+        input.disabled = on;
+    }
+    function flashTap(i, total) {
+        status.textContent = `Transmitting… ${i + 1}/${total}`;
+        if (i + 1 >= total) setTimeout(() => { status.textContent = "Sent ✓"; }, 200);
+    }
+    root.append(
+        el("h2", {}, "Compose"),
+        el("label.field-label", {}, "Message"),
+        input,
+        el("div.row.between", {}, [el("span.muted", {}, "Morse preview"), duration]),
+        morseOut,
+        warn,
+        emitter.node,
+        speed.node,
+        el("div.row.send-row", {}, [sendBtn, stopBtn]),
+        status,
+    );
+    refresh();
+    return { node: root, onShow: refresh };
+}
+function segmented(label, options, value, onChange) {
+    const btns = new Map();
+    const group = el("div.segmented");
+    options.forEach((o) => {
+        const b = el("button.seg", {
+            onclick: () => { setValue(o.value); onChange(o.value); },
+        }, o.label);
+        btns.set(o.value, b);
+        group.append(b);
+    });
+    function setValue(v) {
+        value = v;
+        btns.forEach((b, k) => b.classList.toggle("active", k === v));
+    }
+    setValue(value);
+    return {
+        node: el("div.field", {}, [el("label.field-label", {}, label), group]),
+        setValue,
+    };
+}

views/dom.js ADDED Viewed

	@@ -0,0 +1,44 @@

+/** Tiny DOM helpers (no framework). */
+/** el("button.cls#id", {onclick, ...attrs}, [children|string]) */
+export function el(spec, attrs = {}, children = []) {
+    const m = spec.match(/^([a-z0-9]+)?(#[\w-]+)?((?:\.[\w-]+)*)$/i) || [];
+    const tag = m[1] || "div";
+    const node = document.createElement(tag);
+    if (m[2]) node.id = m[2].slice(1);
+    if (m[3]) node.className = m[3].split(".").filter(Boolean).join(" ");
+    for (const [k, v] of Object.entries(attrs)) {
+        if (v == null || v === false) continue;
+        if (k.startsWith("on") && typeof v === "function") {
+            node.addEventListener(k.slice(2).toLowerCase(), v);
+        } else if (k === "class") {
+            node.className = node.className ? `${node.className} ${v}` : v;
+        } else if (k === "html") {
+            node.innerHTML = v;
+        } else if (k in node && k !== "list") {
+            try { node[k] = v; } catch { node.setAttribute(k, v); }
+        } else {
+            node.setAttribute(k, v);
+        }
+    }
+    const kids = Array.isArray(children) ? children : [children];
+    for (const c of kids) {
+        if (c == null || c === false) continue;
+        node.append(c.nodeType ? c : document.createTextNode(String(c)));
+    }
+    return node;
+}
+export function clear(node) {
+    while (node.firstChild) node.removeChild(node.firstChild);
+    return node;
+}
+/** Render a morse pattern string ('.-') as styled dot/dash chips. */
+export function morsePattern(pattern) {
+    const wrap = el("span.pattern");
+    for (const ch of pattern) {
+        wrap.append(el(`span.${ch === "." ? "dot" : "dash"}`));
+    }
+    return wrap;
+}

views/learn.js ADDED Viewed

	@@ -0,0 +1,66 @@

+/**
+ * Learn view: the letter ↔ rhythm chart. Tap any entry to hear (or have the
+ * robot tap) its rhythm — the whole point is that a letter *is* a rhythm.
+ */
+import { el, clear, morsePattern } from "./dom.js";
+import { CHAR_TO_MORSE, morseToTokens } from "../lib/morse.js";
+import { tokensToOnsets } from "../lib/wire.js";
+const LETTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("");
+const DIGITS = "0123456789".split("");
+const PUNCT = [".", ",", "?", "/", "@", "=", "+", "-", "!", "'", "(", ")"];
+export function createLearn(ctx) {
+    const root = el("section.view#view-learn");
+    function playChar(ch) {
+        const pattern = CHAR_TO_MORSE[ch];
+        if (!pattern) return;
+        const onsets = tokensToOnsets(morseToTokens(pattern), ctx.timing());
+        if (ctx.state.emitter === "robot" && ctx.reachy) {
+            ctx.tapper().tap(onsets);
+        } else {
+            ctx.synth().play(onsets, { clickMs: ctx.timing().clickMs });
+        }
+    }
+    function grid(title, chars) {
+        const g = el("div.chart-grid");
+        chars.forEach((ch) => {
+            const cell = el("button.chart-cell", { onclick: () => {
+                playChar(ch);
+                cell.classList.remove("ping"); void cell.offsetWidth; cell.classList.add("ping");
+            } }, [
+                el("span.cell-char", {}, ch),
+                morsePattern(CHAR_TO_MORSE[ch]),
+            ]);
+            g.append(cell);
+        });
+        return el("div.chart-section", {}, [el("h3", {}, title), g]);
+    }
+    const emitterNote = el("div.status muted");
+    function refresh() {
+        emitterNote.textContent = ctx.state.emitter === "robot" && ctx.reachy
+            ? "Tapping plays on the robot's antennas."
+            : "Tapping plays a beep on this device. (Switch sender in Compose.)";
+    }
+    root.append(
+        el("h2", {}, "Learn Morse"),
+        el("p.muted", {}, "A letter is just a rhythm of short (·) and long (—) beats. Tap any tile to feel it."),
+        emitterNote,
+        grid("Letters", LETTERS),
+        grid("Numbers", DIGITS),
+        grid("Punctuation", PUNCT),
+        el("div.legend", {}, [
+            el("span.legend-item", {}, [morsePattern("."), " dot — 1 tap"]),
+            el("span.legend-item", {}, [morsePattern("-"), " dash — quick double-tap"]),
+        ]),
+    );
+    refresh();
+    return { node: root, onShow: refresh };
+}
+void clear;

views/listen.js ADDED Viewed

	@@ -0,0 +1,116 @@

+/**
+ * Listen view: turn on the mic, watch the live scope, and decode incoming
+ * clicks/beeps to Morse + text in real time. Works for a tapping robot, a
+ * beeping phone, or a second Reachy Mini across the table.
+ */
+import { el, clear } from "./dom.js";
+import { decodeOnsets } from "../lib/wire.js";
+import { Scope } from "../lib/viz.js";
+export function createListen(ctx) {
+    const root = el("section.view#view-listen");
+    const canvas = el("canvas.scope");
+    const scope = new Scope(canvas);
+    const liveText = el("div.decoded-text", {}, "—");
+    const liveMorse = el("div.decoded-morse muted");
+    const transcript = el("div.transcript");
+    const startBtn = el("button.btn.primary.big", { onclick: toggle }, "🎙 Start listening");
+    const clearBtn = el("button.btn.ghost", { onclick: reset }, "Clear");
+    const hint = el("div.status muted", {}, "Point the mic at the robot, then start.");
+    let mic = null;
+    let onsets = [];
+    let lastOnsetMs = 0;
+    let idleTimer = null;
+    function timing() { return ctx.timing(); }
+    async function toggle() {
+        if (mic) return stopMic();
+        try {
+            mic = ctx.makeMic({
+                onOnset: (t) => { onOnset(t); },
+                onLevel: (lvl) => scope.pushLevel(lvl),
+            });
+            await mic.start();
+            scope.start();
+            startBtn.textContent = "◼ Stop listening";
+            startBtn.classList.add("listening");
+            hint.textContent = "Listening… every detected hit drops a red marker.";
+            idleTimer = setInterval(checkIdle, 250);
+        } catch (e) {
+            ctx.toast(`Mic error: ${e?.message || e}`);
+            mic = null;
+        }
+    }
+    async function stopMic() {
+        if (idleTimer) { clearInterval(idleTimer); idleTimer = null; }
+        scope.stop();
+        if (mic) { await mic.stop(); mic = null; }
+        startBtn.textContent = "🎙 Start listening";
+        startBtn.classList.remove("listening");
+        hint.textContent = "Stopped. Decoded text is kept below.";
+        finalize();
+    }
+    function onOnset(timeMs) {
+        onsets.push(timeMs);
+        lastOnsetMs = timeMs;
+        scope.markOnset();
+        renderLive();
+    }
+    function renderLive() {
+        const { morse, text } = decodeOnsets(onsets, timing());
+        liveText.textContent = text || "…";
+        liveMorse.textContent = morse;
+    }
+    // After a long silence, commit the current decode as a finished line.
+    function checkIdle() {
+        if (!mic || onsets.length === 0) return;
+        const idle = mic.now() - lastOnsetMs;
+        if (idle > timing().wordGapMs * 2.5) finalize();
+    }
+    function finalize() {
+        if (onsets.length === 0) return;
+        const { morse, text } = decodeOnsets(onsets, timing());
+        if (text) {
+            transcript.prepend(el("div.line", {}, [
+                el("span.line-text", {}, text),
+                el("span.line-morse muted", {}, morse),
+            ]));
+        }
+        onsets = [];
+        renderLive();
+    }
+    function reset() {
+        onsets = [];
+        clear(transcript);
+        renderLive();
+    }
+    renderLive();
+    root.append(
+        el("h2", {}, "Listen"),
+        canvas,
+        el("div.row.between", {}, [startBtn, clearBtn]),
+        hint,
+        el("label.field-label", {}, "Decoding now"),
+        liveText,
+        liveMorse,
+        el("label.field-label", {}, "Transcript"),
+        transcript,
+    );
+    return {
+        node: root,
+        onShow: () => {},
+        onHide: () => { if (mic) stopMic(); },
+    };
+}

views/settings.js ADDED Viewed

	@@ -0,0 +1,66 @@

+/**
+ * Settings sheet: speed, beep tone, mic sensitivity, and the robot clap
+ * calibration knobs (contact angle / hold / latency lead). These are exactly
+ * the values we tune against real hardware, surfaced so calibration needs no
+ * code edit.
+ */
+import { el } from "./dom.js";
+import { SPEED_PRESETS, makeTiming } from "../lib/timing.js";
+import { APP_VERSION } from "../lib/version.js";
+export function createSettings(ctx) {
+    const c = ctx.state;
+    function rangeRow(label, get, set, { min, max, step, fmt = (v) => v }) {
+        const out = el("span.range-val", {}, fmt(get()));
+        const slider = el("input.range", {
+            type: "range", min, max, step, value: get(),
+            oninput: (e) => { set(parseFloat(e.target.value)); out.textContent = fmt(get()); },
+        });
+        return el("div.field", {}, [
+            el("div.row.between", {}, [el("label.field-label", {}, label), out]),
+            slider,
+        ]);
+    }
+    const body = el("div.settings-body", {}, [
+        el("h3", {}, "Transmission"),
+        rangeRow("Speed (unit)", () => c.unitMs, (v) => { c.unitMs = v; c.speed = "custom"; },
+            { min: 60, max: 240, step: 10, fmt: (v) => `${v} ms` }),
+        rangeRow("Beep tone", () => c.beepFreq, (v) => { c.beepFreq = v; },
+            { min: 600, max: 4000, step: 50, fmt: (v) => `${v} Hz` }),
+        el("h3", {}, "Microphone / detection"),
+        rangeRow("High-pass", () => c.detector.highpassHz, (v) => { c.detector.highpassHz = v; },
+            { min: 500, max: 4000, step: 100, fmt: (v) => `${v} Hz` }),
+        rangeRow("Sensitivity", () => c.detector.thresholdFactor,
+            (v) => { c.detector.thresholdFactor = v; },
+            { min: 1.5, max: 10, step: 0.5, fmt: (v) => `${v}×` }),
+        el("h3", {}, "Robot clap (calibration)"),
+        rangeRow("Contact angle", () => c.tap.collisionDeg, (v) => { c.tap.collisionDeg = v; },
+            { min: 10, max: 55, step: 1, fmt: (v) => `${v}°` }),
+        rangeRow("Right antenna", () => c.tap.rightRestDeg, (v) => { c.tap.rightRestDeg = v; },
+            { min: -55, max: 0, step: 1, fmt: (v) => `${v}°` }),
+        rangeRow("Hold", () => c.tap.holdMs, (v) => { c.tap.holdMs = v; },
+            { min: 20, max: 150, step: 10, fmt: (v) => `${v} ms` }),
+        rangeRow("Latency lead", () => c.tap.leadMs, (v) => { c.tap.leadMs = v; },
+            { min: -50, max: 250, step: 10, fmt: (v) => `${v} ms` }),
+        el("div.row", {}, [
+            el("button.btn.ghost", { onclick: () => testBeep() }, "Test beep"),
+            el("button.btn.ghost", { onclick: () => testClap(), disabled: !ctx.reachy },
+                ctx.reachy ? "Test clap" : "Test clap (no robot)"),
+        ]),
+        el("div.gap-preview muted"),
+        el("div.version muted", {}, APP_VERSION),
+    ]);
+    function testBeep() {
+        ctx.synth().play([0, makeTiming(c.unitMs).dahGapMs], { clickMs: makeTiming(c.unitMs).clickMs });
+    }
+    function testClap() {
+        if (ctx.reachy) ctx.tapper().testClap();
+    }
+    return { node: body };
+}

vitest.config.js ADDED Viewed

	@@ -0,0 +1,20 @@

+import { defineConfig } from "vitest/config";
+import { fileURLToPath } from "node:url";
+// Stub the SDK animation wrapper in unit tests: Node's ESM loader can't
+// resolve `https:` imports, and the unit suite never touches the live SDK.
+// Production loads the real wrapper from jsDelivr.
+const animationStub = fileURLToPath(
+    new URL("./tests/stubs/animation-helpers.js", import.meta.url),
+);
+export default defineConfig({
+    test: {
+        include: ["tests/unit/**/*.test.js"],
+        environment: "node",
+        globals: false,
+        alias: {
+            "./animation-helpers.js": animationStub,
+        },
+    },
+});