accelr8 3.3.0 → 3.4.0

package/dist/chunks/{app-VQ33JVDI.js → app-OT4DOHQ7.js}

@@ -4,9 +4,13 @@ import {
   tzCity,
   tzToCoords
 } from "./chunk-HY6ULYGH.js";
+import {
+  DEFAULT_SERVER
+} from "./chunk-SK7QPMLG.js";
 
 // src/radio/app.ts
 import tk from "terminal-kit";
+import { WebSocket } from "ws";
 
 // src/radio/asciivideo.ts
 import { spawn } from "node:child_process";
@@ -117,6 +121,389 @@ var AsciiVideo = class {
   }
 };
 
+// src/radio/visualizers.ts
+var TAU = Math.PI * 2;
+function clamp01(v) {
+  return v < 0 ? 0 : v > 1 ? 1 : v;
+}
+function col(r, g, b) {
+  const c = (v) => v < 0 ? 0 : v > 255 ? 255 : Math.round(v);
+  return xterm256(c(r), c(g), c(b));
+}
+function hashU(n) {
+  let h = n | 0;
+  h = Math.imul(h ^ h >>> 15, 2246822507);
+  h = Math.imul(h ^ h >>> 13, 3266489909);
+  h ^= h >>> 16;
+  return (h >>> 0) / 4294967296;
+}
+function hash2(x, y) {
+  return hashU(Math.imul(x | 0, 374761393) + Math.imul(y | 0, 668265263));
+}
+function vnoise(x, y) {
+  const xi = Math.floor(x), yi = Math.floor(y);
+  const fx = x - xi, fy = y - yi;
+  const sx = fx * fx * (3 - 2 * fx), sy = fy * fy * (3 - 2 * fy);
+  const a = hash2(xi, yi), b = hash2(xi + 1, yi);
+  const c = hash2(xi, yi + 1), d = hash2(xi + 1, yi + 1);
+  return a + (b - a) * sx + (c - a) * sy + (a - b - c + d) * sx * sy;
+}
+function brand(t, bright = 1) {
+  const k = Math.cos(TAU * t);
+  return col((150.5 + 104.5 * k) * bright, (130.5 - 37.5 * k) * bright, (216 - 39 * k) * bright);
+}
+var INK = xterm256(10, 12, 20);
+function dark() {
+  return { ch: " ", color: INK };
+}
+var RAMP = " .:-=+*#%@";
+var SHADE = " \u2591\u2592\u2593\u2588";
+var PART = "\u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588";
+var plasma = {
+  name: "plasma",
+  frame(tMs, w, h) {
+    const out = new Array(w * h);
+    const t = tMs / 1e3;
+    const iw = 2 / Math.max(1, w - 1), ih = 2 / Math.max(1, h - 1);
+    const last = RAMP.length - 1;
+    for (let y = 0; y < h; y++) {
+      const v = y * ih;
+      for (let x = 0; x < w; x++) {
+        const u = x * iw;
+        const du = u - 1, dv = v - 1;
+        let p = Math.sin(u * 3.1 + t * 0.9) + Math.sin(v * 2.3 - u * 1.1 + t * 0.6) + Math.sin(Math.sqrt(du * du + dv * dv) * 4.2 - t * 1.4) + Math.sin((u + v) * 1.7 + t * 0.35);
+        p = (p + 4) / 8;
+        out[y * w + x] = {
+          ch: RAMP[Math.min(last, Math.max(0, Math.round(p * last)))],
+          color: brand(p * 0.9 + t * 0.03, 0.3 + 0.8 * p)
+        };
+      }
+    }
+    return out;
+  }
+};
+var starfield = {
+  name: "starfield",
+  frame(tMs, w, h) {
+    const out = new Array(w * h);
+    const t = tMs / 1e3;
+    for (let y = 0; y < h; y++) {
+      for (let x = 0; x < w; x++) {
+        const r = hash2(x, y);
+        if (r > 0.994) {
+          const tw = 0.4 + 0.6 * (0.5 + 0.5 * Math.sin(t * 2 + r * 900));
+          out[y * w + x] = { ch: "\xB7", color: col(60 * tw + 30, 70 * tw + 35, 110 * tw + 45) };
+        } else out[y * w + x] = dark();
+      }
+    }
+    const cx = (w - 1) / 2, cy = (h - 1) / 2;
+    const maxR = Math.sqrt(cx * cx + cy * cy * 4) + 2;
+    const travel = 0.14 * t - 0.112 * Math.cos(t * 0.5);
+    const n = Math.min(900, Math.max(40, Math.round(w * h / 26)));
+    const STREAK = "\u2500\u2572\u2502\u2571\u2500\u2572\u2502\u2571";
+    for (let i = 0; i < n; i++) {
+      const a = hashU(i * 5 + 1) * TAU;
+      const rate = 0.5 + hashU(i * 5 + 2);
+      const ph = hashU(i * 5 + 3);
+      const ca = Math.cos(a), sa = Math.sin(a);
+      const u0 = ((travel * rate + ph) % 1 + 1) % 1;
+      for (let k = 0; k < 4; k++) {
+        const u = u0 - k * 0.014;
+        if (u < 0 || k > 0 && u0 < 0.3) continue;
+        const r = u * u * maxR;
+        const x = Math.round(cx + ca * r);
+        const y = Math.round(cy + sa * r * 0.5);
+        if (x < 0 || x >= w || y < 0 || y >= h) continue;
+        const b = clamp01(u * (1 - k * 0.24) * (0.72 + 0.28 * Math.sin(t * 3 + i * 0.7)));
+        let ch;
+        if (k > 0 && u > 0.65) ch = STREAK[(Math.round(a / (Math.PI / 4)) % 8 + 8) % 8];
+        else ch = b > 0.75 ? "\u25CF" : b > 0.5 ? "\u2022" : b > 0.28 ? "\u2218" : "\xB7";
+        out[y * w + x] = { ch, color: col(90 + 165 * b, 150 + 105 * b, 215 + 40 * b) };
+      }
+    }
+    return out;
+  }
+};
+var matrix = {
+  name: "matrix",
+  frame(tMs, w, h) {
+    const out = new Array(w * h);
+    const t = tMs / 1e3;
+    const CH = "01<>+*=~^:;|/\\ACELR8#$%&?!";
+    for (let x = 0; x < w; x++) {
+      let h0 = 0, l0 = 1, h1 = 0, l1 = 1;
+      for (let d = 0; d < 2; d++) {
+        const seed = x * 2 + d * 8191;
+        const speed = 5 + 9 * hashU(seed * 3 + 1);
+        const len = 4 + Math.floor(hashU(seed * 3 + 2) * 9);
+        const span = h + len + 4;
+        const head = (t * speed + hashU(seed * 3 + 3) * span * 9) % span;
+        if (d === 0) {
+          h0 = head;
+          l0 = len;
+        } else {
+          h1 = head;
+          l1 = len;
+        }
+      }
+      for (let y = 0; y < h; y++) {
+        const d0 = h0 - y, d1 = h1 - y;
+        const q0 = d0 >= 0 && d0 < l0 ? 1 - d0 / l0 : 0;
+        const q1 = d1 >= 0 && d1 < l1 ? 1 - d1 / l1 : 0;
+        const q = Math.max(q0, q1);
+        if (q <= 0.04) {
+          out[y * w + x] = dark();
+          continue;
+        }
+        const rate = 1.5 + 4 * hash2(x, y);
+        const ch = CH[Math.floor(hashU(x * 31 + y * 57 + Math.floor(t * rate) * 7919) * CH.length)];
+        const isHead = q0 > 0 && d0 < 1 || q1 > 0 && d1 < 1;
+        out[y * w + x] = isHead ? { ch, color: col(200 + 55 * q, 252, 252) } : { ch, color: col(18 + 40 * q, 55 + 155 * q, 60 + 195 * q) };
+      }
+    }
+    return out;
+  }
+};
+var spectrum = {
+  name: "spectrum",
+  frame(tMs, w, h) {
+    const out = new Array(w * h);
+    const t = tMs / 1e3;
+    const barW = w >= 40 ? 2 : 1;
+    const unit = w >= 40 ? 3 : 1;
+    const nBars = Math.max(1, Math.ceil(w / unit));
+    const kick = Math.exp(-2.5 * (t * 2.05 % 1));
+    const denom = Math.max(1, h - 1);
+    for (let x = 0; x < w; x++) {
+      const i = Math.floor(x / unit);
+      const isGap = x % unit >= barW;
+      const m = Math.min(i, nBars - 1 - i);
+      const f = nBars <= 1 ? 1 : m / Math.max(0.5, (nBars - 1) / 2);
+      const profile = 0.3 + 0.7 * Math.pow(f, 0.8);
+      const s1 = 0.5 + 0.5 * Math.sin(t * 2.2 + m * 1.31);
+      const s2 = 0.5 + 0.5 * Math.sin(t * 3.7 + m * 2.71 + Math.sin(t * 0.9 + m));
+      const v = clamp01(0.05 + profile * (0.24 + 0.36 * s1 + 0.2 * s2 + 0.34 * kick));
+      const filled = v * h;
+      const full = Math.floor(filled);
+      const frac = filled - full;
+      for (let y = 0; y < h; y++) {
+        const up = h - 1 - y;
+        if (isGap || up > full || up === full && frac < 0.06) {
+          out[y * w + x] = dark();
+          continue;
+        }
+        const q = up / denom;
+        const color = brand(0.5 - 0.45 * clamp01(q * 1.15), 0.5 + 0.55 * q);
+        const ch = up < full ? "\u2588" : PART[Math.min(7, Math.floor(frac * 8))];
+        out[y * w + x] = { ch, color };
+      }
+    }
+    return out;
+  }
+};
+var tunnel = {
+  name: "tunnel",
+  frame(tMs, w, h) {
+    const out = new Array(w * h);
+    const t = tMs / 1e3;
+    const cx = (w - 1) / 2, cy = (h - 1) / 2;
+    const norm = Math.max(1, Math.min(w, h * 2) * 0.5);
+    const last = SHADE.length - 1;
+    for (let y = 0; y < h; y++) {
+      const dy = (y - cy) * 2;
+      for (let x = 0; x < w; x++) {
+        const dx = x - cx;
+        const r = Math.sqrt(dx * dx + dy * dy) / norm;
+        const rr = Math.max(r, 0.05);
+        const ang = Math.atan2(dy, dx) + t * 0.25 + 0.6 * rr * Math.sin(t * 0.4);
+        const depth = 0.9 / rr + t * 1.8;
+        const ring = Math.floor(depth * 2.2);
+        const sector = Math.floor(ang / TAU * 14 + 140);
+        const checker = ((ring + sector) % 2 + 2) % 2;
+        const fog = clamp01((r - 0.04) * 2.4);
+        const shade = fog * (checker ? 0.95 : 0.4) * (0.8 + 0.2 * Math.sin(ring * 0.9 + t));
+        const hue = checker ? 0.5 + 0.05 * Math.sin(ang * 3) : 0.04 + 0.05 * Math.sin(ring * 0.5);
+        out[y * w + x] = {
+          ch: SHADE[Math.min(last, Math.max(0, Math.round(shade * last)))],
+          color: brand(hue, 0.25 + 0.75 * shade)
+        };
+      }
+    }
+    return out;
+  }
+};
+var scope = {
+  name: "scope",
+  frame(tMs, w, h) {
+    const out = new Array(w * h);
+    const t = tMs / 1e3;
+    const midY = (h - 1) / 2;
+    for (let y = 0; y < h; y++) {
+      for (let x = 0; x < w; x++) {
+        if (y === Math.round(midY)) out[y * w + x] = { ch: "\u2500", color: col(30, 40, 62) };
+        else if (x % 10 === 5 && y % 4 === 1) out[y * w + x] = { ch: "\xB7", color: col(38, 48, 72) };
+        else out[y * w + x] = dark();
+      }
+    }
+    const TR = [
+      { f1: 2, f2: 5, w1: 1.1, w2: 1.4, rgb: [46, 168, 255] },
+      { f1: 3, f2: 4, w1: -0.9, w2: 2, rgb: [255, 93, 177] },
+      { f1: 1, f2: 7, w1: 0.6, w2: -1.6, rgb: [158, 108, 255] }
+    ];
+    const iw = TAU / Math.max(1, w - 1);
+    const yAt = (j, x) => {
+      const tr = TR[j];
+      const A = midY * (0.55 + 0.35 * Math.sin(t * 0.5 + j * 1.9));
+      const ph = x * iw;
+      const yv = midY + A * (0.62 * Math.sin(ph * tr.f1 + t * tr.w1 + j * 2.1) + 0.38 * Math.sin(ph * tr.f2 - t * tr.w2 + j));
+      return Math.min(h - 1, Math.max(0, yv));
+    };
+    for (let pass = 0; pass < 2; pass++) {
+      for (let j = 0; j < 3; j++) {
+        const [cr, cg, cb] = TR[j].rgb;
+        let prev = Math.round(yAt(j, 0));
+        for (let x = 0; x < w; x++) {
+          const yv = yAt(j, x);
+          const iy = Math.round(yv);
+          if (pass === 0) {
+            const glow = { ch: "\xB7", color: col(cr * 0.35, cg * 0.35, cb * 0.35) };
+            if (iy - 1 >= 0) out[(iy - 1) * w + x] = { ...glow };
+            if (iy + 1 < h) out[(iy + 1) * w + x] = { ...glow };
+          } else {
+            const shimmer = 0.82 + 0.18 * Math.sin(t * 5 + x * 0.3 + j);
+            const core = col(cr * shimmer, cg * shimmer, cb * shimmer);
+            const lo = Math.min(prev, iy), hi = Math.max(prev, iy);
+            for (let yy = lo + 1; yy < hi; yy++) out[yy * w + x] = { ch: "\u2502", color: core };
+            const dy = iy - prev;
+            const ch = dy > 1 || dy < -1 ? "\u2502" : dy === 1 ? "\u2572" : dy === -1 ? "\u2571" : "\u2500";
+            out[iy * w + x] = { ch, color: core };
+          }
+          prev = iy;
+        }
+      }
+    }
+    return out;
+  }
+};
+var ripples = {
+  name: "ripples",
+  frame(tMs, w, h) {
+    const out = new Array(w * h);
+    const t = tMs / 1e3;
+    const cx = (w - 1) / 2, cy = (h - 1) / 2;
+    const S = [
+      { x: cx + w * 0.32 * Math.sin(t * 0.31), y: cy + h * 0.3 * Math.cos(t * 0.23) },
+      { x: cx + w * 0.34 * Math.sin(t * 0.19 + 2.1), y: cy + h * 0.32 * Math.cos(t * 0.37 + 4) },
+      { x: cx + w * 0.28 * Math.sin(t * 0.41 + 4.4), y: cy + h * 0.28 * Math.cos(t * 0.29 + 1.3) }
+    ];
+    const RIP = " .\xB7:~=+*#@";
+    const last = RIP.length - 1;
+    for (let y = 0; y < h; y++) {
+      for (let x = 0; x < w; x++) {
+        let wave = 0;
+        for (let s = 0; s < 3; s++) {
+          const dx = x - S[s].x, dy = (y - S[s].y) * 2;
+          const d = Math.sqrt(dx * dx + dy * dy);
+          wave += Math.sin(d * 0.55 - t * 4 + s * 1.7) / (1 + d * 0.05);
+        }
+        const p = clamp01(0.5 + wave * 0.31);
+        let r, g, b;
+        if (p < 0.5) {
+          const q = p * 2;
+          r = 10 + 36 * q;
+          g = 26 + 142 * q;
+          b = 48 + 207 * q;
+        } else {
+          const q = (p - 0.5) * 2;
+          r = 46 + 179 * q;
+          g = 168 + 84 * q;
+          b = 255;
+        }
+        out[y * w + x] = {
+          ch: RIP[Math.min(last, Math.max(0, Math.round(p * last)))],
+          color: col(r, g, b)
+        };
+      }
+    }
+    return out;
+  }
+};
+var bloom = {
+  name: "bloom",
+  frame(tMs, w, h) {
+    const out = new Array(w * h);
+    const t = tMs / 1e3;
+    const sx = 0.085, sy = 0.17;
+    for (let y = 0; y < h; y++) {
+      for (let x = 0; x < w; x++) {
+        const q = vnoise(x * sx * 0.7 + t * 0.32, y * sy * 0.7 - t * 0.11);
+        const n = 0.62 * vnoise(x * sx + q * 1.8 + t * 0.2, y * sy + q * 1.8 + t * 0.07) + 0.38 * vnoise(x * sx * 2.3 - t * 0.26, y * sy * 2.3 + q * 1.5);
+        const p = clamp01((n - 0.16) * 1.55);
+        const ch = p < 0.2 ? " " : p < 0.33 ? "\xB7" : p < 0.48 ? "\u2591" : p < 0.63 ? "\u2592" : p < 0.8 ? "\u2593" : "\u2588";
+        out[y * w + x] = {
+          ch,
+          color: brand(0.16 + 0.3 * n + 0.04 * Math.sin(t * 0.4), 0.22 + 0.88 * p)
+        };
+      }
+    }
+    return out;
+  }
+};
+var VISUALIZERS = [
+  plasma,
+  starfield,
+  matrix,
+  spectrum,
+  tunnel,
+  scope,
+  ripples,
+  bloom
+];
+var VisualizerRotation = class {
+  holdMs;
+  fadeMs;
+  order;
+  constructor(opts) {
+    this.holdMs = Math.max(1, opts?.holdMs ?? 2e4);
+    this.fadeMs = Math.max(0, opts?.fadeMs ?? 1500);
+    const all = VISUALIZERS.map((_, i) => i);
+    const order = (opts?.order ?? all).filter((i) => Number.isInteger(i) && i >= 0 && i < VISUALIZERS.length);
+    this.order = order.length ? order : all;
+  }
+  /** Which visualizer holds slot tMs, which is next, and the fade mix 0..1. */
+  slot(tMs) {
+    const span = this.holdMs + this.fadeMs;
+    const idx = Math.floor(tMs / span);
+    const n = this.order.length;
+    const k = (idx % n + n) % n;
+    const phase = tMs - idx * span;
+    const a = VISUALIZERS[this.order[k]];
+    const b = VISUALIZERS[this.order[(k + 1) % n]];
+    const mix = this.fadeMs > 0 ? clamp01((phase - this.holdMs) / this.fadeMs) : 0;
+    return { a, b, mix };
+  }
+  frame(tMs, w, h) {
+    const { a, b, mix } = this.slot(tMs);
+    const fa = a.frame(tMs, w, h);
+    if (mix <= 0 || a === b) return fa;
+    const fb = b.frame(tMs, w, h);
+    const m = mix * mix * (3 - 2 * mix);
+    const out = new Array(w * h);
+    for (let y = 0; y < h; y++) {
+      for (let x = 0; x < w; x++) {
+        const i = y * w + x;
+        out[i] = hash2(x * 7 + 3, y * 13 + 1) < m ? fb[i] : fa[i];
+      }
+    }
+    return out;
+  }
+  /** name(s) currently on screen, for optional display. */
+  current(tMs) {
+    const { a, b, mix } = this.slot(tMs);
+    return mix > 0 && a !== b ? `${a.name} -> ${b.name}` : a.name;
+  }
+};
+
 // src/radio/station.ts
 function totalLoopMs(items) {
   let sum = 0;
@@ -549,8 +936,16 @@ function nextAudioAction(sched, serverNowMs, mem, driftBudgetMs = 1500) {
   }
   return { kind: "none" };
 }
-function ffplayArgs(url, offsetMs) {
-  const args = ["-hide_banner", "-loglevel", "error", "-nodisp", "-autoexit"];
+function ffplayArgs(url, offsetMs, volume = 70) {
+  const args = [
+    "-hide_banner",
+    "-loglevel",
+    "error",
+    "-nodisp",
+    "-autoexit",
+    "-volume",
+    String(Math.max(0, Math.min(100, Math.round(volume))))
+  ];
   if (offsetMs > 0) args.push("-ss", (offsetMs / 1e3).toFixed(3));
   args.push("-i", url);
   return args;
@@ -560,6 +955,9 @@ var SyncedAudio = class {
   mem = { playingTrackId: null, spawnedAtServerMs: 0, spawnedOffsetMs: 0, procAlive: false };
   opts = null;
   timer = null;
+  vol = 70;
+  // 0..100
+  muted = false;
   start(opts) {
     this.stop();
     this.opts = opts;
@@ -570,15 +968,42 @@ var SyncedAudio = class {
   setSchedule(sched) {
     if (this.opts) this.opts.schedule = sched;
   }
-  tick() {
+  get volume() {
+    return this.vol;
+  }
+  get isMuted() {
+    return this.muted;
+  }
+  /** Set volume 0..100. Respawns the current track at its live offset so the
+   *  change is audible immediately (unless muted). */
+  setVolume(v) {
+    this.vol = Math.max(0, Math.min(100, Math.round(v)));
+    if (!this.muted) this.respawnCurrent();
+  }
+  /** Toggle mute. Muting stops the process (no CPU); unmuting resyncs + resumes. */
+  toggleMute() {
+    this.muted = !this.muted;
+    if (this.muted) {
+      this.killProc();
+      this.mem.playingTrackId = null;
+      this.mem.procAlive = false;
+    } else this.tick();
+    return this.muted;
+  }
+  respawnCurrent() {
     if (!this.opts) return;
+    const pos = nowPlaying(this.opts.schedule, this.opts.serverNow());
+    if (pos && pos.item.url) this.spawn(pos.item, pos.offsetMs);
+  }
+  tick() {
+    if (!this.opts || this.muted) return;
     const action = nextAudioAction(this.opts.schedule, this.opts.serverNow(), this.mem);
     if (action.kind === "play") this.spawn(action.track, action.offsetMs);
   }
   spawn(track, offsetMs) {
     if (!this.opts) return;
     this.killProc();
-    const proc = spawn2(this.opts.ffplayPath, ffplayArgs(track.url, offsetMs), { stdio: ["ignore", "ignore", "pipe"] });
+    const proc = spawn2(this.opts.ffplayPath, ffplayArgs(track.url, offsetMs, this.vol), { stdio: ["ignore", "ignore", "pipe"] });
     this.proc = proc;
     this.mem = { playingTrackId: track.id, spawnedAtServerMs: this.opts.serverNow(), spawnedOffsetMs: offsetMs, procAlive: true };
     this.opts.onTrack?.(track);
@@ -623,9 +1048,9 @@ var term = tk.terminal;
 var ScreenBuffer = tk.ScreenBuffer;
 var RENDER_FPS = 20;
 var VIDEO_FPS = 15;
-var SEED_INPUT = "lavfi:mandelbrot=size=480x270:rate=15:maxiter=800";
 var screen;
 var video = null;
+var visuals = null;
 var audio = null;
 var lastFrame = null;
 var frameW = 0;
@@ -633,75 +1058,159 @@ var frameH = 0;
 var renderTimer = null;
 var running = false;
 var startedAt = Date.now();
+var skewMs = 0;
+var serverNow = () => Date.now() + skewMs;
 var W = () => Math.max(20, term.width || process.stdout.columns || 100);
 var H = () => Math.max(6, term.height || process.stdout.rows || 30);
-function demoState(you) {
-  const min = 6e4;
-  const schedule = {
-    name: "ACCELR8 FM",
-    epoch: startedAt - 7 * 6e4 - 12e3,
-    // "on air" for a bit already
-    tracks: [
-      { id: "t1", title: "neon district", artist: "sunset arch", url: "", durationMs: 3 * min + 2e4 },
-      { id: "t2", title: "downtown drift", artist: "kilowatt", url: "", durationMs: 4 * min + 5e3 },
-      { id: "t3", title: "after hours protocol", artist: "v.helix", url: "", durationMs: 3 * min + 48e3 }
-    ],
-    clips: []
-  };
-  const listeners = [
-    you,
-    { id: "l1", name: "nori", tz: "Asia/Tokyo", color: 213 },
-    { id: "l2", name: "brand", tz: "America/Los_Angeles", color: 39 },
-    { id: "l3", name: "mara", tz: "Europe/London", color: 202 },
-    { id: "l4", name: "dev", tz: "America/New_York", color: 46 },
-    { id: "l5", name: "kenji", tz: "Asia/Tokyo", color: 51 }
-  ];
-  const serverNowMs = Date.now();
+var FALLBACK = {
+  name: "ACCELR8 FM",
+  epoch: startedAt,
+  tracks: [{
+    id: "flim",
+    title: "Flim",
+    artist: "The Bad Plus",
+    durationMs: 244637,
+    url: "https://accelr8-canvas.patonchain.workers.dev/audio/flim.mp3"
+  }],
+  clips: []
+};
+var me;
+var state;
+function baseState(you) {
+  const now = serverNow();
   return {
-    schedule,
-    serverNowMs,
-    nowPlaying: nowPlaying(schedule, serverNowMs),
-    nowShowing: nowShowing(schedule, serverNowMs),
-    listeners,
+    schedule: FALLBACK,
+    serverNowMs: now,
+    nowPlaying: nowPlaying(FALLBACK, now),
+    nowShowing: nowShowing(FALLBACK, now),
+    listeners: [you],
+    // just you until the station reports real listeners
     you,
     broadcast: null,
-    connected: true
+    connected: false
   };
 }
-var state;
-function startVideo(opts) {
-  const tools = detectVoiceTools();
-  if (!tools.ffmpegPath) return;
-  video = new AsciiVideo();
-  video.start({
-    ffmpegPath: tools.ffmpegPath,
-    input: opts.clip || SEED_INPUT,
-    width: W(),
-    height: H(),
-    fps: VIDEO_FPS,
-    ramp: RAMPS.broadcast,
-    onFrame: (frame, w, h) => {
-      lastFrame = frame;
-      frameW = w;
-      frameH = h;
-    },
-    onError: () => {
+var stationWs = null;
+var reconnectTimer = null;
+function connectStation(opts) {
+  const base = (opts.server || DEFAULT_SERVER).replace(/\/$/, "");
+  const url = base + "/radio";
+  let ws;
+  try {
+    ws = new WebSocket(url);
+  } catch {
+    scheduleReconnect(opts);
+    return;
+  }
+  stationWs = ws;
+  ws.on("open", () => {
+    ws.send(JSON.stringify({ t: "hello", id: me.id, name: me.name, tz: me.tz, color: me.color }));
+  });
+  ws.on("message", (raw) => {
+    let m;
+    try {
+      m = JSON.parse(raw.toString());
+    } catch {
+      return;
+    }
+    if (m && m.t === "radioState") applyStation(m);
+  });
+  ws.on("close", () => {
+    if (stationWs === ws) {
+      state = { ...state, connected: false };
+      scheduleReconnect(opts);
+    }
+  });
+  ws.on("error", () => {
+    try {
+      ws.close();
+    } catch {
     }
   });
+}
+function scheduleReconnect(opts) {
+  if (reconnectTimer || !running) return;
+  reconnectTimer = setTimeout(() => {
+    reconnectTimer = null;
+    if (running) connectStation(opts);
+  }, 2e3);
+}
+function applyStation(m) {
+  if (typeof m.serverNow === "number") skewMs = m.serverNow - Date.now();
+  const sched = m.station && Array.isArray(m.station.tracks) && m.station.tracks.length ? { name: m.station.name || "ACCELR8 FM", epoch: m.station.epoch || startedAt, tracks: m.station.tracks, clips: m.station.clips || [] } : state.schedule;
+  const listeners = Array.isArray(m.listeners) && m.listeners.length ? m.listeners.map((l) => ({ id: l.id, name: l.name, tz: l.tz, color: l.color })) : [me];
+  const broadcast = m.broadcast || null;
+  state = { ...state, schedule: sched, listeners, broadcast, connected: true };
+  if (audio) audio.setSchedule(sched);
+}
+function startBackground(opts) {
+  const tools = detectVoiceTools();
+  if (opts.clip && tools.ffmpegPath) {
+    video = new AsciiVideo();
+    video.start({
+      ffmpegPath: tools.ffmpegPath,
+      input: opts.clip,
+      width: W(),
+      height: H(),
+      fps: VIDEO_FPS,
+      ramp: RAMPS.broadcast,
+      onFrame: (frame, w, h) => {
+        lastFrame = frame;
+        frameW = w;
+        frameH = h;
+      },
+      onError: () => {
+        video = null;
+      }
+    });
+  } else {
+    visuals = new VisualizerRotation();
+  }
   if (tools.ffplayPath) {
     audio = new SyncedAudio();
-    audio.start({
-      ffplayPath: tools.ffplayPath,
-      schedule: state.schedule,
-      serverNow: () => Date.now()
-      // TODO: swap for skew-corrected worker clock
-    });
+    audio.start({ ffplayPath: tools.ffplayPath, schedule: state.schedule, serverNow });
   }
 }
 function makeScreen() {
   screen = new ScreenBuffer({ dst: term, width: W(), height: H() });
   video?.resize(W(), H());
 }
+var volMsg = "";
+var volMsgUntil = 0;
+function flashVol() {
+  if (!audio) return;
+  const v = audio.volume, bars = 12, on = Math.round(v / 100 * bars);
+  volMsg = audio.isMuted ? "\u266B  muted  (m to unmute)" : `\u266B  ${"\u2588".repeat(on)}${"\u2591".repeat(bars - on)}  ${v}%`;
+  volMsgUntil = Date.now() + 1800;
+}
+function volUp() {
+  if (audio) {
+    if (audio.isMuted) audio.toggleMute();
+    audio.setVolume(audio.volume + 10);
+    flashVol();
+  }
+}
+function volDown() {
+  if (audio) {
+    if (audio.isMuted) audio.toggleMute();
+    audio.setVolume(audio.volume - 10);
+    flashVol();
+  }
+}
+function muteToggle() {
+  if (audio) {
+    audio.toggleMute();
+    flashVol();
+  }
+}
+function drawVolToast() {
+  if (Date.now() >= volMsgUntil || !volMsg) return;
+  const y = Math.max(1, Math.floor(screen.height / 3));
+  const s = `  ${volMsg}  `;
+  const x = Math.max(0, Math.floor((screen.width - s.length) / 2));
+  for (let i = 0; i < s.length && x + i < screen.width; i++)
+    screen.put({ x: x + i, y, attr: { color: 231, bgColor: 16, bold: true }, dx: 1, dy: 0, wrap: false }, s[i]);
+}
 function blitVideo() {
   const w = screen.width, h = screen.height;
   if (lastFrame && frameW === w && frameH === h) {
@@ -733,12 +1242,18 @@ function blitOverlay(cells) {
 }
 function renderFrame() {
   if (!running) return;
-  const you = state.you;
-  const serverNowMs = Date.now();
+  const tMs = Date.now() - startedAt;
+  if (visuals) {
+    lastFrame = visuals.frame(tMs, screen.width, screen.height);
+    frameW = screen.width;
+    frameH = screen.height;
+  }
+  const serverNowMs = serverNow();
   state = { ...state, serverNowMs, nowPlaying: nowPlaying(state.schedule, serverNowMs), nowShowing: nowShowing(state.schedule, serverNowMs) };
   blitVideo();
-  const cells = renderOverlay({ w: screen.width, h: screen.height, tMs: Date.now() - startedAt, state });
+  const cells = renderOverlay({ w: screen.width, h: screen.height, tMs, state });
   blitOverlay(cells);
+  drawVolToast();
   if (screen.dst) screen.draw({ delta: true });
 }
 function teardown() {
@@ -747,8 +1262,18 @@ function teardown() {
     clearInterval(renderTimer);
     renderTimer = null;
   }
+  if (reconnectTimer) {
+    clearTimeout(reconnectTimer);
+    reconnectTimer = null;
+  }
+  try {
+    stationWs?.close();
+  } catch {
+  }
+  stationWs = null;
   video?.stop();
   video = null;
+  visuals = null;
   audio?.stop();
   audio = null;
   try {
@@ -764,8 +1289,9 @@ function quit() {
   process.exit(0);
 }
 function runRadio(opts) {
-  const you = { id: "you", name: opts.name || "you", tz: Intl.DateTimeFormat().resolvedOptions().timeZone };
-  state = demoState(you);
+  const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  me = { id: "me_" + Math.random().toString(36).slice(2, 10), name: opts.name || "you", tz, color: 39 };
+  state = baseState(me);
   const die = (err) => {
     teardown();
     console.error("accelr8 radio crashed:", err instanceof Error ? err.stack || err.message : err);
@@ -777,14 +1303,19 @@ function runRadio(opts) {
   term.hideCursor();
   term.grabInput(true);
   makeScreen();
-  startVideo(opts);
   running = true;
+  startBackground(opts);
+  connectStation(opts);
   term.on("key", (name) => {
     if (name === "CTRL_C" || name === "q" || name === "ESCAPE") return quit();
+    if (name === "m") return muteToggle();
+    if (name === "+" || name === "=" || name === "UP") return volUp();
+    if (name === "-" || name === "_" || name === "DOWN") return volDown();
   });
   term.on("resize", () => makeScreen());
   process.on("SIGINT", quit);
   process.on("SIGTERM", quit);
+  flashVol();
   renderTimer = setInterval(renderFrame, Math.round(1e3 / RENDER_FPS));
   renderFrame();
 }