nixamp 0.1.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,180 @@
+# nixamp
+
+It really whips the terminal's ass.
+
+```
+curl -fsSL https://nixamp.com/install.sh | sh
+```
+
+```
+nixamp ~/Music
+nixamp track.flac
+```
+
+```
+ ⣿ NIXAMP  ▶ PLAYING                                                              1 tracks  ~/Music
+╭─ Now Playing ────────────────────────────────────────────────────────────────────────────────────╮
+│ Meshuggah — Bleed                                                                                │
+│ obZen                                                                                            │
+│ 00:41  █████████████████████████───────────────────────────────────────────────────── 32%  07:27 │
+╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
+╭─ Spectrum Analyser ─────────────────────────────────╮ ╭─ Playlist (12) ──────────────────────────╮
+│ ⠉⠁⠉⠁⠤⠄⣀⡀                                            │ │  1  Meshuggah — Bleed         07:27      │
+│ ⣶⡆⣶⡆⣀⡀  ⠒⠂⠉⠁                                        │ │  2  SOAD — Aerials            03:55      │
+│ ⣿⡇⣿⡇⣿⡇⣿⡇⣤⡄⣶⡆⣀⡀⠒⠂⠉⠁  ⠤⠄⣀⡀                            │ │                                          │
+│ ⣿⡇⣿⡇⣿⡇⣿⡇⣿⡇⣿⡇⣿⡇⣿⡇⣿⡇⣀⡀⣿⡇⣿⡇⣤⡄⣤⡄⣀⡀    ⠉⠁⠤⠄⠒⠂    ⣀⡀      │ │                                          │
+│ ⣿⡇⣿⡇⣿⡇⣿⡇⣿⡇⣿⡇⣿⡇⣿⡇⣿⡇⣿⡇⣿⡇⣿⡇⣿⡇⣿⡇⣿⡇⣿⡇⣿⡇⣿⡇⣿⡇⣿⡇⣿⡇⣿⡇⣿⡇⣿⡇    │ │                                          │
+│ ▆▆▅▅▅▅▄▄▅▄▄▄▄▄▄▃▃▃▃▃▃▃▃▂            L▮▮▮▮·· R▮▮▮▮·· │ │                                          │
+╰─────────────────────────────────────────────────────╯ ╰──────────────────────────────────────────╯
+ Space Stop  ↑↓ Select  n/p Next/Prev  Enter Play  q Quit
+```
+
+## Installing
+
+```
+curl -fsSL https://nixamp.com/install.sh | sh
+```
+
+Everything lands under `~/.local`. No root, no package manager, no system files
+touched. On a machine with a desktop session it installs the app and the CLI
+together, and the CLI then runs on the Node inside the app, so there is no
+system Node to keep in step. Over SSH it detects that there is no desktop and
+installs the CLI alone.
+
+```
+curl -fsSL https://nixamp.com/install.sh | sh -s -- --cli-only
+curl -fsSL https://nixamp.com/install.sh | sh -s -- --desktop
+curl -fsSL https://nixamp.com/install.sh | sh -s -- --version 0.1.0
+curl -fsSL https://nixamp.com/install.sh | sh -s -- --prefix ~/opt
+```
+
+Then:
+
+```
+nixamp update            re-runs the installer, keeping the choices you made
+nixamp update 0.2.0      or pins a version
+nixamp uninstall         says what would go
+nixamp uninstall --yes   removes exactly what the installer created
+```
+
+Removal reads a manifest the installer wrote, so it is exact and works with no
+network. Your music is never touched.
+
+If you would rather not pipe a script into a shell, `npm i -g nixamp` and
+`bunx nixamp ~/Music` both work; that route needs Node 24 or newer.
+
+## How it works
+
+One decode feeds both your speakers and the display. `ffmpeg` writes raw 32-bit float samples to a pipe; nixamp reads every sample on its way past, runs an FFT over it, and hands the same bytes to `ffplay`.
+
+Running a second decoder just for the visualiser would be simpler and wrong: the two would drift apart within seconds and the bars would stop matching what you hear.
+
+The analyser is a radix-2 Cooley-Tukey FFT with a Hann window, about 120 lines and no dependency. Bands are spaced logarithmically because hearing is, and they are scaled in decibels for the same reason — linear bins put almost every bar above 10 kHz where there is nothing to see. Bars rise instantly and fall gradually, with a peak marker that sinks. That decay is what made Winamp's analyser readable rather than merely busy.
+
+Braille gives four vertical pixels per character cell, so a bar moves smoothly instead of stepping through eight block glyphs.
+
+## Three ways to run it
+
+The terminal player is the original and still the point, but the same engine
+now drives two more surfaces.
+
+### Server mode, and the browser remote
+
+```
+nixamp serve ~/Music --host 0.0.0.0
+```
+
+nixamp keeps playing through your speakers and hands out a remote: open the
+address it prints on your phone and you get the playlist, the transport and the
+same spectrum, pushed as it happens. State goes out over Server-Sent Events
+rather than a WebSocket, because SSE is plain HTTP — no dependency, and it
+reconnects by itself when the phone goes to sleep.
+
+Tick **Listen on this device** and the browser streams the track's bytes and
+plays it there instead, with its own analyser drawing the same picture.
+
+`--host 127.0.0.1` is the default, so nothing is reachable until you say so.
+Track paths never leave the machine; the remote sees titles.
+
+| Endpoint | Does |
+|---|---|
+| `GET /api/state` | one snapshot |
+| `GET /api/events` | snapshots, pushed |
+| `POST /api/command` | `play` `toggle` `stop` `next` `prev` `select` |
+| `GET /api/media/:n` | the track's bytes, with ranges (`--no-media` turns it off) |
+
+### The PWA — [nixamp.com](https://nixamp.com)
+
+```
+bun run web:dev      # or: bun run web:build && bun run serve
+```
+
+A player in the browser, installable, and the remote client above. It opens
+your own files — nothing is uploaded; the browser decodes them where they are —
+and it plays video as well as audio. Vanilla TypeScript and Vite, one 16 kB
+bundle, and a service worker that precaches the shell so the app opens with no
+network at all.
+
+The icons are drawn from source (`web/scripts/icons.ts`) rather than committed
+as opaque binaries, which is how the 192 and the 512 stay in step.
+
+### The desktop app
+
+```
+bun run desktop:dev
+bun run desktop:build      # AppImage + deb into desktop/release
+```
+
+Electron around the same PWA, with a real `nixamp serve` running as a child
+process — so the window is the browser player, the terminal player's engine and
+the remote-control server at once.
+
+The CLI travels inside the bundle and is run by Electron's own Node, which is
+the point: installing the app installs a working nixamp with no system Node
+anywhere near it. **Copy Bundled CLI Path** in the menu tells you how to call
+it.
+
+Building is unsigned on purpose — no code signing, no notarisation.
+
+## Requirements
+
+**ffmpeg** and **ffprobe** to decode, **ffplay** to make sound. All three ship together.
+
+```
+sudo apt install ffmpeg      # or: brew install ffmpeg
+```
+
+Without `ffplay`, nixamp still runs and still draws the spectrum — it just says so rather than pretending to play.
+
+A bare `ffmpeg` on `PATH` is used when there is one; `mise` shims are detected and invoked through `mise exec`, because the shim itself fails when no version is pinned.
+
+## Keys
+
+| Key | Does |
+|---|---|
+| `Space` | Play or stop |
+| `Enter` | Play the selected track from the start |
+| `↑` `↓` | Move through the playlist |
+| `n` `p` (or `→` `←`) | Next and previous track |
+| `s` | Stop |
+| `q` | Quit |
+
+## Formats
+
+Whatever your ffmpeg was built with: mp3, flac, ogg, opus, m4a, aac, wav, wma, aiff, alac, and the audio track of mp4 and webm.
+
+## Status
+
+Early. It plays a directory, shows tags and timings, and draws what it hears —
+in a terminal, in a browser and in a window, from one engine. The browser
+player seeks and has a volume slider; the terminal one still does not. Not yet,
+anywhere: shuffle, repeat, m3u playlists, or the visualiser presets that would
+make the name honest.
+
+## Built with
+
+[hqtui](https://hqtui.com) — the terminal UI library. Like [r3q](https://github.com/profullstack/r3q) and [g1tz](https://github.com/profullstack/g1tz), nixamp exists partly to keep hqtui honest: a real application finds the gaps a widget gallery does not.
+
+## Licence
+
+MIT

package/bin/nixamp.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { main } from "../dist/main.js";
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/dist/audio.d.ts

@@ -0,0 +1,60 @@
+export declare const RATE = 44100;
+export declare const CHANNELS = 2;
+export interface Track {
+    path: string;
+    title: string;
+    artist: string;
+    album: string;
+    /** Seconds; 0 when ffprobe could not tell us. */
+    duration: number;
+}
+export interface Tools {
+    ffmpeg: string[];
+    ffprobe: string[];
+    /** Argv prefix for the player, or null when nothing can make sound here. */
+    play: string[] | null;
+}
+/**
+ * Find the tools. A bare `ffmpeg` on PATH is tried first; mise shims are common
+ * on developer machines and need `mise exec` because the shim itself fails when
+ * no version is pinned.
+ */
+export declare function detectTools(): Tools;
+export declare function probe(tools: Tools, path: string): Track;
+export interface StreamHandlers {
+    /** Interleaved stereo f32 samples, as decoded. */
+    onSamples: (pcm: Float32Array) => void;
+    onEnd: (error?: string) => void;
+}
+/**
+ * A playing track: one ffmpeg decoding, one player consuming, and us in the
+ * middle reading every sample on its way past.
+ */
+export declare class Stream {
+    private readonly tools;
+    private readonly handlers;
+    private decoder;
+    private output;
+    private stopped;
+    /**
+     * Which start each callback belongs to. A killed ffmpeg still fires `close`,
+     * and without this its "exited null" lands on the track that replaced it —
+     * so skipping a track would report an error and stop the player.
+     */
+    private generation;
+    /** Samples handed to the output so far, per channel. */
+    private framesOut;
+    /** Leftover bytes when a chunk does not divide into whole f32 samples. */
+    private tail;
+    constructor(tools: Tools, handlers: StreamHandlers);
+    /** Seconds of audio delivered so far. */
+    get position(): number;
+    get silent(): boolean;
+    start(track: Track, from?: number): void;
+    stop(): void;
+}
+/** Left and right peak levels from an interleaved stereo frame, 0..1. */
+export declare function peaks(pcm: Float32Array): [number, number];
+/** Interleaved stereo down to mono, for the analyser. */
+export declare function toMono(pcm: Float32Array): Float32Array;
+export declare function formatTime(seconds: number): string;

package/dist/audio.js

@@ -0,0 +1,206 @@
+/**
+ * Decoding and playback, both by way of ffmpeg.
+ *
+ * One decode feeds both the speakers and the analyser: ffmpeg writes raw f32
+ * samples to our stdout pipe, we compute the spectrum from them and pass the
+ * same bytes to the output process. Running two decoders instead would drift
+ * apart within seconds and the bars would stop matching what you hear.
+ */
+import { spawn, spawnSync } from "node:child_process";
+export const RATE = 44100;
+export const CHANNELS = 2;
+function works(argv) {
+    const [cmd, ...rest] = argv;
+    if (!cmd)
+        return false;
+    const r = spawnSync(cmd, [...rest, "-version"], { encoding: "utf8", timeout: 10_000 });
+    return !r.error && r.status === 0;
+}
+/**
+ * Find the tools. A bare `ffmpeg` on PATH is tried first; mise shims are common
+ * on developer machines and need `mise exec` because the shim itself fails when
+ * no version is pinned.
+ */
+export function detectTools() {
+    const candidates = (name) => [
+        [name],
+        ["mise", "exec", `ffmpeg@latest`, "--", name],
+    ];
+    const pick = (name) => candidates(name).find((argv) => works(argv)) ?? null;
+    const ffmpeg = pick("ffmpeg");
+    const ffprobe = pick("ffprobe");
+    const play = pick("ffplay");
+    return {
+        ffmpeg: ffmpeg ?? ["ffmpeg"],
+        ffprobe: ffprobe ?? ["ffprobe"],
+        play,
+    };
+}
+export function probe(tools, path) {
+    const [cmd, ...rest] = tools.ffprobe;
+    const fallback = {
+        path,
+        title: path.split("/").pop() ?? path,
+        artist: "",
+        album: "",
+        duration: 0,
+    };
+    if (!cmd)
+        return fallback;
+    const result = spawnSync(cmd, [
+        ...rest,
+        "-v", "quiet", "-print_format", "json",
+        "-show_format", "-show_entries", "format_tags=title,artist,album",
+        path,
+    ], { encoding: "utf8", timeout: 20_000, maxBuffer: 4 * 1024 * 1024 });
+    if (result.error || result.status !== 0)
+        return fallback;
+    try {
+        const parsed = JSON.parse(result.stdout);
+        const tags = parsed.format?.tags ?? {};
+        const lower = {};
+        for (const [k, v] of Object.entries(tags))
+            lower[k.toLowerCase()] = v;
+        return {
+            path,
+            title: lower.title || fallback.title,
+            artist: lower.artist ?? "",
+            album: lower.album ?? "",
+            duration: Number(parsed.format?.duration ?? 0) || 0,
+        };
+    }
+    catch {
+        return fallback;
+    }
+}
+/**
+ * A playing track: one ffmpeg decoding, one player consuming, and us in the
+ * middle reading every sample on its way past.
+ */
+export class Stream {
+    tools;
+    handlers;
+    decoder = null;
+    output = null;
+    stopped = false;
+    /**
+     * Which start each callback belongs to. A killed ffmpeg still fires `close`,
+     * and without this its "exited null" lands on the track that replaced it —
+     * so skipping a track would report an error and stop the player.
+     */
+    generation = 0;
+    /** Samples handed to the output so far, per channel. */
+    framesOut = 0;
+    /** Leftover bytes when a chunk does not divide into whole f32 samples. */
+    tail = Buffer.alloc(0);
+    constructor(tools, handlers) {
+        this.tools = tools;
+        this.handlers = handlers;
+    }
+    /** Seconds of audio delivered so far. */
+    get position() {
+        return this.framesOut / RATE;
+    }
+    get silent() {
+        return this.tools.play === null;
+    }
+    start(track, from = 0) {
+        this.stop();
+        this.stopped = false;
+        const generation = ++this.generation;
+        this.framesOut = Math.round(from * RATE);
+        const [ff, ...ffRest] = this.tools.ffmpeg;
+        if (!ff) {
+            this.handlers.onEnd("ffmpeg not found");
+            return;
+        }
+        this.decoder = spawn(ff, [
+            ...ffRest,
+            "-hide_banner", "-loglevel", "error",
+            ...(from > 0 ? ["-ss", String(from)] : []),
+            "-i", track.path,
+            "-f", "f32le", "-ac", String(CHANNELS), "-ar", String(RATE), "-",
+        ], { stdio: ["ignore", "pipe", "pipe"] });
+        if (this.tools.play) {
+            const [player, ...playerRest] = this.tools.play;
+            this.output = spawn(player, [
+                ...playerRest,
+                "-hide_banner", "-loglevel", "quiet",
+                "-nodisp", "-autoexit",
+                "-f", "f32le", "-ac", String(CHANNELS), "-ar", String(RATE), "-i", "-",
+            ], { stdio: ["pipe", "ignore", "ignore"] });
+            // The player exiting first must not kill us with EPIPE.
+            this.output.stdin?.on("error", () => { });
+        }
+        let stderr = "";
+        this.decoder.stderr?.on("data", (c) => { stderr += c.toString(); });
+        this.decoder.stdout?.on("data", (chunk) => {
+            if (this.stopped || generation !== this.generation)
+                return;
+            this.output?.stdin?.write(chunk);
+            const joined = this.tail.length ? Buffer.concat([this.tail, chunk]) : chunk;
+            const usable = joined.length - (joined.length % 4);
+            this.tail = usable === joined.length ? Buffer.alloc(0) : joined.subarray(usable);
+            if (usable === 0)
+                return;
+            // Copy rather than view: the underlying buffer is reused by the stream.
+            const samples = new Float32Array(usable / 4);
+            for (let i = 0; i < samples.length; i++)
+                samples[i] = joined.readFloatLE(i * 4);
+            this.framesOut += samples.length / CHANNELS;
+            this.handlers.onSamples(samples);
+        });
+        this.decoder.on("close", (code) => {
+            if (this.stopped || generation !== this.generation)
+                return;
+            this.output?.stdin?.end();
+            this.handlers.onEnd(code === 0 ? undefined : stderr.trim() || `ffmpeg exited ${code}`);
+        });
+        this.decoder.on("error", (error) => {
+            if (this.stopped || generation !== this.generation)
+                return;
+            this.handlers.onEnd(error.message);
+        });
+    }
+    stop() {
+        this.stopped = true;
+        // Anything still in flight from the last start belongs to nobody now.
+        this.generation++;
+        this.decoder?.kill("SIGKILL");
+        this.output?.stdin?.end();
+        this.output?.kill("SIGKILL");
+        this.decoder = null;
+        this.output = null;
+        this.tail = Buffer.alloc(0);
+    }
+}
+/** Left and right peak levels from an interleaved stereo frame, 0..1. */
+export function peaks(pcm) {
+    let left = 0;
+    let right = 0;
+    for (let i = 0; i + 1 < pcm.length; i += 2) {
+        const l = Math.abs(pcm[i]);
+        const r = Math.abs(pcm[i + 1]);
+        if (l > left)
+            left = l;
+        if (r > right)
+            right = r;
+    }
+    return [Math.min(1, left), Math.min(1, right)];
+}
+/** Interleaved stereo down to mono, for the analyser. */
+export function toMono(pcm) {
+    const mono = new Float32Array(Math.floor(pcm.length / CHANNELS));
+    for (let i = 0; i < mono.length; i++) {
+        mono[i] = ((pcm[i * 2] + pcm[i * 2 + 1]) / 2);
+    }
+    return mono;
+}
+export function formatTime(seconds) {
+    if (!Number.isFinite(seconds) || seconds < 0)
+        return "--:--";
+    const total = Math.floor(seconds);
+    const m = Math.floor(total / 60);
+    const s = total % 60;
+    return `${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}`;
+}

package/dist/fft.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The analyser: real audio in, spectrum bands out.
+ *
+ * An iterative radix-2 Cooley-Tukey FFT, which is enough for a visualiser and
+ * small enough to read. No dependency, because pulling a DSP library in for
+ * one transform would be the largest thing in the tree.
+ */
+export declare function isPowerOfTwo(n: number): boolean;
+/**
+ * A Hann window, precomputed.
+ *
+ * Without one, a tone that does not complete a whole number of cycles in the
+ * frame leaks across every bin and the display turns to mush.
+ */
+export declare function hann(n: number): Float32Array;
+export declare class Analyser {
+    readonly size: number;
+    readonly sampleRate: number;
+    private readonly re;
+    private readonly im;
+    private readonly rev;
+    private readonly window;
+    /** Magnitudes for bins 0..size/2, reused between frames. */
+    readonly magnitudes: Float32Array;
+    constructor(size?: number, sampleRate?: number);
+    /** Frequency at the centre of a bin. */
+    frequencyOf(bin: number): number;
+    /**
+     * Transform one frame of mono samples. Shorter input is zero padded; longer
+     * is truncated, so a partial final frame still draws rather than throwing.
+     */
+    run(samples: Float32Array | number[]): Float32Array;
+    /** The loudest bin, ignoring DC. Useful for tests and for a tuner readout. */
+    peakBin(): number;
+}
+/**
+ * Edges of `count` logarithmically spaced bands between two frequencies.
+ *
+ * Linear bins would put nearly every bar above 10 kHz, where there is little to
+ * see; hearing is roughly logarithmic and the display should match it.
+ */
+export declare function bandEdges(count: number, sampleRate: number, size: number, low?: number, high?: number): number[];
+/** Peak magnitude in each band, in decibels, normalised to 0..1. */
+export declare function bands(magnitudes: Float32Array, edges: number[], floorDb?: number): number[];
+/**
+ * Bars fall smoothly and rise instantly.
+ *
+ * A spectrum drawn straight from each frame flickers badly at 30fps. Winamp's
+ * analyser rose immediately and decayed, which is both prettier and easier to
+ * read; this is that, as one pass over the previous frame.
+ */
+export declare function decay(previous: number[], next: number[], fall?: number): number[];

package/dist/fft.js

@@ -0,0 +1,154 @@
+/**
+ * The analyser: real audio in, spectrum bands out.
+ *
+ * An iterative radix-2 Cooley-Tukey FFT, which is enough for a visualiser and
+ * small enough to read. No dependency, because pulling a DSP library in for
+ * one transform would be the largest thing in the tree.
+ */
+/** Bit-reversal permutation table for a transform of size n (a power of two). */
+function reversalTable(n) {
+    const bits = Math.log2(n);
+    const table = new Uint32Array(n);
+    for (let i = 0; i < n; i++) {
+        let reversed = 0;
+        for (let b = 0; b < bits; b++)
+            if (i & (1 << b))
+                reversed |= 1 << (bits - 1 - b);
+        table[i] = reversed;
+    }
+    return table;
+}
+export function isPowerOfTwo(n) {
+    return n > 0 && (n & (n - 1)) === 0;
+}
+/**
+ * A Hann window, precomputed.
+ *
+ * Without one, a tone that does not complete a whole number of cycles in the
+ * frame leaks across every bin and the display turns to mush.
+ */
+export function hann(n) {
+    const w = new Float32Array(n);
+    for (let i = 0; i < n; i++)
+        w[i] = 0.5 * (1 - Math.cos((2 * Math.PI * i) / (n - 1)));
+    return w;
+}
+export class Analyser {
+    size;
+    sampleRate;
+    re;
+    im;
+    rev;
+    window;
+    /** Magnitudes for bins 0..size/2, reused between frames. */
+    magnitudes;
+    constructor(size = 2048, sampleRate = 44100) {
+        if (!isPowerOfTwo(size))
+            throw new Error(`FFT size must be a power of two, got ${size}`);
+        this.size = size;
+        this.sampleRate = sampleRate;
+        this.re = new Float64Array(size);
+        this.im = new Float64Array(size);
+        this.rev = reversalTable(size);
+        this.window = hann(size);
+        this.magnitudes = new Float32Array(size / 2 + 1);
+    }
+    /** Frequency at the centre of a bin. */
+    frequencyOf(bin) {
+        return (bin * this.sampleRate) / this.size;
+    }
+    /**
+     * Transform one frame of mono samples. Shorter input is zero padded; longer
+     * is truncated, so a partial final frame still draws rather than throwing.
+     */
+    run(samples) {
+        const { size, re, im, rev, window } = this;
+        for (let i = 0; i < size; i++) {
+            const s = samples[rev[i]] ?? 0;
+            re[i] = s * window[rev[i]];
+            im[i] = 0;
+        }
+        for (let len = 2; len <= size; len <<= 1) {
+            const step = (-2 * Math.PI) / len;
+            const half = len >> 1;
+            for (let i = 0; i < size; i += len) {
+                for (let j = 0; j < half; j++) {
+                    const angle = step * j;
+                    const wr = Math.cos(angle);
+                    const wi = Math.sin(angle);
+                    const a = i + j;
+                    const b = a + half;
+                    const tr = re[b] * wr - im[b] * wi;
+                    const ti = re[b] * wi + im[b] * wr;
+                    re[b] = re[a] - tr;
+                    im[b] = im[a] - ti;
+                    re[a] = re[a] + tr;
+                    im[a] = im[a] + ti;
+                }
+            }
+        }
+        const half = size / 2;
+        // 2/size normalises a full-scale sine to 1.0 in its bin; DC and Nyquist
+        // appear once rather than twice, so they are not doubled.
+        for (let k = 0; k <= half; k++) {
+            const scale = k === 0 || k === half ? 1 / size : 2 / size;
+            this.magnitudes[k] = Math.hypot(re[k], im[k]) * scale;
+        }
+        return this.magnitudes;
+    }
+    /** The loudest bin, ignoring DC. Useful for tests and for a tuner readout. */
+    peakBin() {
+        let best = 1;
+        for (let k = 2; k < this.magnitudes.length; k++) {
+            if (this.magnitudes[k] > this.magnitudes[best])
+                best = k;
+        }
+        return best;
+    }
+}
+/**
+ * Edges of `count` logarithmically spaced bands between two frequencies.
+ *
+ * Linear bins would put nearly every bar above 10 kHz, where there is little to
+ * see; hearing is roughly logarithmic and the display should match it.
+ */
+export function bandEdges(count, sampleRate, size, low = 40, high = 16000) {
+    const nyquist = sampleRate / 2;
+    const top = Math.min(high, nyquist);
+    const edges = [];
+    for (let i = 0; i <= count; i++) {
+        const hz = low * (top / low) ** (i / count);
+        edges.push(Math.min(size / 2, Math.max(1, Math.round((hz * size) / sampleRate))));
+    }
+    return edges;
+}
+/** Peak magnitude in each band, in decibels, normalised to 0..1. */
+export function bands(magnitudes, edges, floorDb = -70) {
+    const out = [];
+    for (let i = 0; i < edges.length - 1; i++) {
+        const lo = edges[i];
+        const hi = Math.max(lo + 1, edges[i + 1]);
+        let peak = 0;
+        for (let k = lo; k < hi && k < magnitudes.length; k++) {
+            const m = magnitudes[k];
+            if (m > peak)
+                peak = m;
+        }
+        const db = 20 * Math.log10(Math.max(peak, 1e-9));
+        out.push(Math.max(0, Math.min(1, (db - floorDb) / -floorDb)));
+    }
+    return out;
+}
+/**
+ * Bars fall smoothly and rise instantly.
+ *
+ * A spectrum drawn straight from each frame flickers badly at 30fps. Winamp's
+ * analyser rose immediately and decayed, which is both prettier and easier to
+ * read; this is that, as one pass over the previous frame.
+ */
+export function decay(previous, next, fall = 0.12) {
+    return next.map((value, i) => {
+        const was = previous[i] ?? 0;
+        return value >= was ? value : Math.max(value, was - fall);
+    });
+}