accelr8 3.1.1 → 3.3.0

package/dist/chunks/app-VQ33JVDI.js

@@ -0,0 +1,793 @@
+#!/usr/bin/env node
+import {
+  detectVoiceTools,
+  tzCity,
+  tzToCoords
+} from "./chunk-HY6ULYGH.js";
+
+// src/radio/app.ts
+import tk from "terminal-kit";
+
+// src/radio/asciivideo.ts
+import { spawn } from "node:child_process";
+var RAMPS = {
+  broadcast: " .'`^\",:;Il!i~+_-?][}{1)(|/tfjrxnuvczXYUJCLQ0OZmwqpdbkhao*#MW&8%B@$",
+  blocks: " \u2591\u2592\u2593\u2588",
+  classic: " .:-=+*#%@"
+};
+function xterm256(r, g, b) {
+  const max = Math.max(r, g, b), min = Math.min(r, g, b);
+  if (max - min < 12) {
+    if (max < 8) return 16;
+    if (max > 248) return 231;
+    return 232 + Math.min(23, Math.round((max - 8) / 230 * 23));
+  }
+  const q = (v) => Math.round(v / 255 * 5);
+  return 16 + 36 * q(r) + 6 * q(g) + q(b);
+}
+function frameToCells(rgb, w, h, ramp = RAMPS.broadcast) {
+  const out = new Array(w * h);
+  const last = ramp.length - 1;
+  for (let i = 0, p = 0; i < w * h; i++, p += 3) {
+    const r = rgb[p], g = rgb[p + 1], b = rgb[p + 2];
+    const lum = (r * 299 + g * 587 + b * 114) / 1e3;
+    const ch = ramp[Math.min(last, Math.max(0, Math.round(lum / 255 * last)))];
+    out[i] = { ch, color: xterm256(r, g, b) };
+  }
+  return out;
+}
+function ffmpegArgs(o) {
+  const fps = o.fps ?? 15;
+  const isLavfi = o.input.startsWith("lavfi:");
+  const args = ["-hide_banner", "-loglevel", "error"];
+  if (isLavfi) {
+    args.push("-f", "lavfi", "-i", o.input.slice("lavfi:".length));
+  } else {
+    if (o.loop !== false) args.push("-stream_loop", "-1");
+    if (o.seekMs && o.seekMs > 0) args.push("-ss", (o.seekMs / 1e3).toFixed(3));
+    args.push("-i", o.input);
+  }
+  args.push(
+    "-vf",
+    `scale=${o.width}:${o.height}:flags=bilinear,setsar=1`,
+    "-r",
+    String(fps),
+    "-f",
+    "rawvideo",
+    "-pix_fmt",
+    "rgb24",
+    "-"
+  );
+  return args;
+}
+var AsciiVideo = class {
+  proc = null;
+  buf = Buffer.alloc(0);
+  opts = null;
+  start(opts) {
+    this.stop();
+    this.opts = opts;
+    this.buf = Buffer.alloc(0);
+    const frameBytes = opts.width * opts.height * 3;
+    if (frameBytes <= 0) return;
+    const proc = spawn(opts.ffmpegPath, ffmpegArgs(opts), { stdio: ["ignore", "pipe", "pipe"] });
+    this.proc = proc;
+    proc.stdout.on("data", (chunk) => {
+      this.buf = this.buf.length ? Buffer.concat([this.buf, chunk]) : chunk;
+      while (this.buf.length >= frameBytes) {
+        const frame = this.buf.subarray(0, frameBytes);
+        this.buf = this.buf.subarray(frameBytes);
+        try {
+          opts.onFrame(frameToCells(frame, opts.width, opts.height, opts.ramp), opts.width, opts.height);
+        } catch {
+        }
+      }
+    });
+    let err = "";
+    proc.stderr.on("data", (d) => {
+      err = (err + d.toString()).slice(-240);
+    });
+    proc.on("error", (e) => {
+      opts.onError?.(e.message);
+    });
+    proc.on("exit", (code) => {
+      if (this.proc !== proc) return;
+      this.proc = null;
+      if (code && code !== 0) opts.onError?.(`ffmpeg exited ${code}${err ? ": " + err.split("\n").pop() : ""}`);
+    });
+  }
+  /** Re-decode at a new cell grid (terminal resize). Keeps input + seek. */
+  resize(width, height) {
+    if (!this.opts) return;
+    if (width === this.opts.width && height === this.opts.height) return;
+    this.start({ ...this.opts, width, height });
+  }
+  get active() {
+    return !!this.proc;
+  }
+  stop() {
+    if (this.proc) {
+      try {
+        this.proc.kill("SIGKILL");
+      } catch {
+      }
+      this.proc = null;
+    }
+    this.buf = Buffer.alloc(0);
+  }
+};
+
+// src/radio/station.ts
+function totalLoopMs(items) {
+  let sum = 0;
+  for (const it of items) sum += Math.max(0, it.durationMs);
+  return sum;
+}
+function mod(n, m) {
+  if (m <= 0) return 0;
+  return (n % m + m) % m;
+}
+function timelineAt(items, epoch, serverNowMs) {
+  if (!items.length) return null;
+  const loopMs = totalLoopMs(items);
+  if (loopMs <= 0) return null;
+  const posInLoopMs = mod(serverNowMs - epoch, loopMs);
+  let acc = 0;
+  for (let i = 0; i < items.length; i++) {
+    const dur = Math.max(0, items[i].durationMs);
+    if (dur === 0) continue;
+    if (posInLoopMs < acc + dur) {
+      const offsetMs = posInLoopMs - acc;
+      let ni = (i + 1) % items.length;
+      let guard = items.length;
+      while (items[ni].durationMs <= 0 && guard-- > 0) ni = (ni + 1) % items.length;
+      return {
+        item: items[i],
+        index: i,
+        offsetMs,
+        remainingMs: dur - offsetMs,
+        posInLoopMs,
+        loopMs,
+        next: items[ni]
+      };
+    }
+    acc += dur;
+  }
+  for (let i = items.length - 1; i >= 0; i--) {
+    if (items[i].durationMs > 0) {
+      return {
+        item: items[i],
+        index: i,
+        offsetMs: items[i].durationMs,
+        remainingMs: 0,
+        posInLoopMs,
+        loopMs,
+        next: items[(i + 1) % items.length]
+      };
+    }
+  }
+  return null;
+}
+function nowPlaying(sched, serverNowMs) {
+  return timelineAt(sched.tracks, sched.epoch, serverNowMs);
+}
+function nowShowing(sched, serverNowMs) {
+  return timelineAt(sched.clips, sched.epoch, serverNowMs);
+}
+function uptimeLabel(epoch, serverNowMs) {
+  const s = Math.max(0, Math.floor((serverNowMs - epoch) / 1e3));
+  const d = Math.floor(s / 86400);
+  const h = Math.floor(s % 86400 / 3600);
+  const m = Math.floor(s % 3600 / 60);
+  const sec = s % 60;
+  if (d > 0) return `${d}d ${h}h`;
+  if (h > 0) return `${h}h ${m}m`;
+  if (m > 0) return `${m}m ${sec}s`;
+  return `${sec}s`;
+}
+function clock(ms) {
+  const s = Math.max(0, Math.floor(ms / 1e3));
+  const m = Math.floor(s / 60);
+  return `${m}:${String(s % 60).padStart(2, "0")}`;
+}
+
+// src/radio/funfacts.ts
+var EARTH_RADIUS_KM = 6371;
+function haversineKm(a, b) {
+  const rad = (deg) => deg * Math.PI / 180;
+  const dLat = rad(b.lat - a.lat);
+  const dLon = rad(b.lon - a.lon);
+  const s = Math.sin(dLat / 2) ** 2 + Math.cos(rad(a.lat)) * Math.cos(rad(b.lat)) * Math.sin(dLon / 2) ** 2;
+  return 2 * EARTH_RADIUS_KM * Math.asin(Math.min(1, Math.sqrt(s)));
+}
+function thousands(n) {
+  return String(n).replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+}
+function localClock(tz, atMs) {
+  try {
+    const parts = new Intl.DateTimeFormat("en-US", {
+      timeZone: tz,
+      hour: "numeric",
+      minute: "2-digit",
+      hour12: true
+    }).formatToParts(new Date(atMs));
+    const get = (t) => parts.find((p) => p.type === t)?.value ?? "";
+    const hour12 = Number(get("hour"));
+    const minute = get("minute");
+    const period = get("dayPeriod").toLowerCase();
+    if (!Number.isFinite(hour12) || !minute || period !== "am" && period !== "pm") return null;
+    const h24 = hour12 % 12 + (period === "pm" ? 12 : 0);
+    return { minutesOfDay: h24 * 60 + Number(minute), label: `${hour12}:${minute}${period}` };
+  } catch {
+    return null;
+  }
+}
+function tzOffsetMinutes(tz, atMs) {
+  try {
+    const parts = new Intl.DateTimeFormat("en-US", {
+      timeZone: tz,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      hour12: false
+    }).formatToParts(new Date(atMs));
+    const get = (t) => Number(parts.find((p) => p.type === t)?.value);
+    const wallUtc = Date.UTC(
+      get("year"),
+      get("month") - 1,
+      get("day"),
+      get("hour") % 24,
+      get("minute"),
+      get("second")
+    );
+    if (!Number.isFinite(wallUtc)) return null;
+    return Math.round((wallUtc - atMs) / 6e4);
+  } catch {
+    return null;
+  }
+}
+function hoursLabel(minutes) {
+  const half = Math.round(minutes / 60 * 2) / 2;
+  return Number.isInteger(half) ? String(half) : half.toFixed(1);
+}
+function funFacts(listeners, serverNowMs) {
+  if (listeners.length < 2) return [];
+  const facts = [];
+  const placed = listeners.flatMap((l) => {
+    const at = tzToCoords(l.tz);
+    return at ? [{ l, at }] : [];
+  });
+  let bestKm = 0;
+  let far = null;
+  for (let i = 0; i < placed.length; i++) {
+    for (let j = i + 1; j < placed.length; j++) {
+      const km = haversineKm(placed[i].at, placed[j].at);
+      if (km > bestKm) {
+        bestKm = km;
+        far = [placed[i], placed[j]];
+      }
+    }
+  }
+  const farKm = Math.round(bestKm / 100) * 100;
+  if (far && farKm > 0) {
+    facts.push(
+      `${far[0].l.name} in ${tzCity(far[0].l.tz)} and ${far[1].l.name} in ${tzCity(far[1].l.tz)} are furthest apart right now (${thousands(farKm)} km)`
+    );
+  }
+  let odd = null;
+  for (const l of listeners) {
+    if (!l.tz) continue;
+    const clock2 = localClock(l.tz, serverNowMs);
+    if (!clock2) continue;
+    const m = clock2.minutesOfDay;
+    if (m < 60 || m >= 360) continue;
+    const dist = Math.abs(m - 240);
+    if (!odd || dist < odd.dist) odd = { l, label: clock2.label, dist };
+  }
+  if (odd) facts.push(`it's ${odd.label} for ${odd.l.name} in ${tzCity(odd.l.tz)}`);
+  const zones = new Set(listeners.map((l) => l.tz).filter((tz) => !!tz));
+  if (zones.size >= 2) facts.push(`${listeners.length} listening across ${zones.size} time zones`);
+  const offsets = listeners.flatMap((l) => {
+    const off = l.tz ? tzOffsetMinutes(l.tz, serverNowMs) : null;
+    return off === null ? [] : [{ l, off }];
+  });
+  let spread = 0;
+  let wide = null;
+  for (let i = 0; i < offsets.length; i++) {
+    for (let j = i + 1; j < offsets.length; j++) {
+      const d = Math.abs(offsets[i].off - offsets[j].off);
+      if (d > spread) {
+        spread = d;
+        wide = [offsets[i], offsets[j]];
+      }
+    }
+  }
+  if (wide && spread >= 120) {
+    facts.push(
+      `${wide[0].l.name} in ${tzCity(wide[0].l.tz)} and ${wide[1].l.name} in ${tzCity(wide[1].l.tz)} are ${hoursLabel(spread)} hours apart on the clock`
+    );
+  }
+  return facts;
+}
+function pickFact(listeners, serverNowMs, tick) {
+  const facts = funFacts(listeners, serverNowMs);
+  if (facts.length === 0) return "";
+  const n = facts.length;
+  return facts[(Math.trunc(tick) % n + n) % n];
+}
+
+// src/radio/overlay.ts
+var ACCENT = 39;
+var PINK = 213;
+var RED = 196;
+var WHITE = 231;
+var DIM = 245;
+var FAINT = 238;
+var BAR_BG = 235;
+var DOT_OFF = 24;
+var BLINK_PERIOD_MS = 1e3;
+var BLINK_ON_MS = 600;
+var TICKER_MS_PER_CELL = 120;
+var FACT_ROTATE_MS = 8e3;
+var SEP = "   ///   ";
+var EQ_GLYPHS = ["\u2581", "\u2582", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2588"];
+var FALLBACK_FACTS = [
+  "ACCELR8 FM \u2022 broadcasting live from San Francisco",
+  "stay locked in \u2022 the vibe is curated",
+  "206 rooms, one frequency",
+  "founders tune in \u2022 the dial stays hot"
+];
+function liveBadgeOn(tMs) {
+  const cycle = (tMs % BLINK_PERIOD_MS + BLINK_PERIOD_MS) % BLINK_PERIOD_MS;
+  return cycle < BLINK_ON_MS;
+}
+function tickerOffset(tMs) {
+  return Math.floor(Math.max(0, tMs) / TICKER_MS_PER_CELL);
+}
+function broadcastActive(state2) {
+  const b = state2.broadcast;
+  if (!b || !b.headline) return false;
+  return state2.serverNowMs < b.startedAt + b.durationMs;
+}
+function sanitize(s) {
+  return s.replace(/\u2014/g, "\u2022");
+}
+function tickerText(state2, tick, facts) {
+  if (!state2.connected) return "signal lost \u2022 re-syncing with the tower";
+  if (broadcastActive(state2)) {
+    return `\u25C7 BREAKING \u25C7 ${sanitize(state2.broadcast.headline)}`;
+  }
+  const pick = facts ?? pickFact;
+  try {
+    const fact = pick(state2.listeners, state2.serverNowMs, tick);
+    if (fact && fact.trim().length > 0) return sanitize(fact);
+  } catch {
+  }
+  const n = FALLBACK_FACTS.length;
+  return FALLBACK_FACTS[(tick % n + n) % n];
+}
+function put(cells, w, h, x, y, ch, st) {
+  if (x < 0 || x >= w || y < 0 || y >= h) return;
+  const cell = { x, y, ch };
+  if (st.color !== void 0) cell.color = st.color;
+  if (st.bg !== void 0) cell.bg = st.bg;
+  if (st.bold) cell.bold = true;
+  cells.push(cell);
+}
+function write(cells, w, h, x, y, text, st) {
+  let cx = x;
+  for (const ch of text) {
+    put(cells, w, h, cx, y, ch, st);
+    cx++;
+  }
+  return cx;
+}
+function makeBar(w, base) {
+  return { chs: new Array(w).fill(" "), sts: new Array(w).fill(base) };
+}
+function barWrite(bar, x, text, st, limitX = Infinity) {
+  let cx = x;
+  for (const ch of text) {
+    if (cx >= 0 && cx < bar.chs.length && cx < limitX) {
+      bar.chs[cx] = ch;
+      bar.sts[cx] = st;
+    }
+    cx++;
+  }
+  return cx;
+}
+function barEmit(cells, w, h, bar, y) {
+  if (y < 0 || y >= h) return;
+  for (let x = 0; x < bar.chs.length && x < w; x++) {
+    put(cells, w, h, x, y, bar.chs[x], bar.sts[x]);
+  }
+}
+function clip(text, max) {
+  const glyphs = [...text];
+  if (glyphs.length <= max) return text;
+  if (max <= 0) return "";
+  if (max === 1) return "\u2026";
+  return glyphs.slice(0, max - 1).join("") + "\u2026";
+}
+function badgeSegments(connected, tMs) {
+  if (!connected) {
+    return [[" \u25CC NO SIGNAL ", { color: WHITE, bg: FAINT, bold: true }]];
+  }
+  const dot = liveBadgeOn(tMs) ? ["\u25CF", { color: PINK, bg: ACCENT, bold: true }] : ["\xB7", { color: DOT_OFF, bg: ACCENT }];
+  return [
+    [" ", { bg: ACCENT }],
+    dot,
+    [" LIVE ", { color: WHITE, bg: ACCENT, bold: true }]
+  ];
+}
+function drawEq(cells, w, h, x, y, tMs) {
+  let cx = x;
+  for (let i = 0; i < 5; i++) {
+    const phase = tMs / 160 + i * 1.7;
+    const lvl = Math.round((Math.sin(phase) + 1) / 2 * (EQ_GLYPHS.length - 1));
+    cx = write(cells, w, h, cx, y, EQ_GLYPHS[lvl], { color: ACCENT });
+  }
+  return cx;
+}
+function drawTopBar(cells, w, h, tMs, state2) {
+  const bar = makeBar(w, { color: DIM, bg: BAR_BG });
+  let cx = 1;
+  for (const [text, st] of badgeSegments(state2.connected, tMs)) {
+    cx = barWrite(bar, cx, text, st);
+  }
+  let rightStart;
+  if (state2.connected) {
+    const n = state2.listeners.length;
+    const label = `\u25C9 ${n} listening`;
+    rightStart = Math.max(cx + 2, w - 1 - [...label].length);
+    let rx = barWrite(bar, rightStart, "\u25C9 ", { color: ACCENT, bg: BAR_BG, bold: true });
+    rx = barWrite(bar, rx, String(n), { color: WHITE, bg: BAR_BG, bold: true });
+    barWrite(bar, rx, " listening", { color: DIM, bg: BAR_BG });
+  } else {
+    const dots = ".".repeat(1 + Math.floor(Math.max(0, tMs) / 400) % 3);
+    rightStart = Math.max(cx + 2, w - 17);
+    barWrite(bar, rightStart, `reconnecting${dots}`, { color: DIM, bg: BAR_BG });
+  }
+  const limit = rightStart - 1;
+  let sx = cx + 2;
+  sx = barWrite(bar, sx, sanitize(state2.schedule.name), { color: WHITE, bg: BAR_BG, bold: true }, limit);
+  if (state2.connected) {
+    sx = barWrite(bar, sx, " \u2022 ", { color: DIM, bg: BAR_BG }, limit);
+    sx = barWrite(bar, sx, "ON AIR ", { color: ACCENT, bg: BAR_BG, bold: true }, limit);
+    barWrite(bar, sx, uptimeLabel(state2.schedule.epoch, state2.serverNowMs), { color: WHITE, bg: BAR_BG }, limit);
+  }
+  barEmit(cells, w, h, bar, 0);
+}
+function drawLowerThird(cells, w, h, tMs, state2) {
+  const yChip = h - 4;
+  const yTitle = h - 3;
+  const yBar = h - 2;
+  const np = state2.nowPlaying;
+  if (!np) {
+    const cx2 = write(cells, w, h, 1, yChip, " STANDBY ", { color: WHITE, bg: FAINT, bold: true });
+    drawEq(cells, w, h, cx2 + 1, yChip, tMs);
+    write(cells, w, h, 1, yTitle, clip("ACCELR8 FM \u2022 curating the vibe", Math.max(0, w - 2)), { color: DIM });
+    return;
+  }
+  const cx = write(cells, w, h, 1, yChip, " NOW PLAYING ", { color: WHITE, bg: ACCENT, bold: true });
+  drawEq(cells, w, h, cx + 1, yChip, tMs);
+  let tx = write(cells, w, h, 1, yTitle, "\u25B6 ", { color: ACCENT, bold: true });
+  tx = write(cells, w, h, tx, yTitle, clip(sanitize(np.item.title), Math.max(0, w - 1 - tx)), { color: WHITE, bold: true });
+  if (np.item.artist) {
+    write(cells, w, h, tx, yTitle, clip(` \u2022 ${sanitize(np.item.artist)}`, Math.max(0, w - 1 - tx)), { color: DIM });
+  }
+  const times = ` ${clock(np.offsetMs)} / ${clock(np.item.durationMs)}`;
+  const barW = Math.min(26, Math.max(0, w - 2 - times.length));
+  let px = 1;
+  if (barW >= 6) {
+    const frac = np.item.durationMs > 0 ? Math.min(1, Math.max(0, np.offsetMs / np.item.durationMs)) : 0;
+    const filled = Math.round(frac * barW);
+    px = write(cells, w, h, px, yBar, "\u2588".repeat(filled), { color: ACCENT });
+    px = write(cells, w, h, px, yBar, "\u2591".repeat(barW - filled), { color: FAINT });
+  }
+  write(cells, w, h, px, yBar, times, { color: DIM });
+}
+function drawTicker(cells, w, h, y, tMs, text, state2, withChip) {
+  if (y < 0 || y >= h) return;
+  const bar = makeBar(w, { color: WHITE, bg: BAR_BG });
+  let startX = 0;
+  if (withChip) {
+    const breaking = state2.connected && broadcastActive(state2);
+    const chip = breaking ? " \u25C6 BREAKING " : " \u25C6 A8 WIRE ";
+    startX = barWrite(bar, 0, chip, { color: WHITE, bg: breaking ? RED : ACCENT, bold: true }) + 1;
+  }
+  const unit = [...text + SEP];
+  if (unit.length > 0) {
+    const off = tickerOffset(tMs) % unit.length;
+    for (let x = startX; x < w; x++) {
+      const ch = unit[(off + (x - startX)) % unit.length];
+      const st = ch === "\u25C7" ? { color: ACCENT, bg: BAR_BG, bold: true } : ch === "/" ? { color: FAINT, bg: BAR_BG } : { color: WHITE, bg: BAR_BG };
+      if (x >= 0 && x < bar.chs.length) {
+        bar.chs[x] = ch;
+        bar.sts[x] = st;
+      }
+    }
+  }
+  barEmit(cells, w, h, bar, y);
+}
+function renderOverlay(ctx, opts) {
+  const { w, h, tMs, state: state2 } = ctx;
+  const cells = [];
+  if (w <= 0 || h <= 0) return cells;
+  const tick = Math.floor(Math.max(0, tMs) / FACT_ROTATE_MS);
+  const marquee = tickerText(state2, tick, opts?.facts);
+  const tiny = w < 40 || h < 12;
+  if (tiny) {
+    let cx = 1;
+    for (const [text, st] of badgeSegments(state2.connected, tMs)) {
+      cx = write(cells, w, h, cx, 0, text, st);
+    }
+    if (h >= 2) drawTicker(cells, w, h, h - 1, tMs, marquee, state2, false);
+    return cells;
+  }
+  drawTopBar(cells, w, h, tMs, state2);
+  if (state2.connected) drawLowerThird(cells, w, h, tMs, state2);
+  drawTicker(cells, w, h, h - 1, tMs, marquee, state2, true);
+  return cells;
+}
+
+// src/radio/audio.ts
+import { spawn as spawn2 } from "node:child_process";
+function nextAudioAction(sched, serverNowMs, mem, driftBudgetMs = 1500) {
+  const pos = nowPlaying(sched, serverNowMs);
+  if (!pos || !pos.item.url) return { kind: "none" };
+  const trackChanged = pos.item.id !== mem.playingTrackId;
+  if (trackChanged || !mem.procAlive) {
+    return { kind: "play", track: pos.item, offsetMs: pos.offsetMs };
+  }
+  const impliedOffset = mem.spawnedOffsetMs + (serverNowMs - mem.spawnedAtServerMs);
+  if (Math.abs(impliedOffset - pos.offsetMs) > driftBudgetMs) {
+    return { kind: "play", track: pos.item, offsetMs: pos.offsetMs };
+  }
+  return { kind: "none" };
+}
+function ffplayArgs(url, offsetMs) {
+  const args = ["-hide_banner", "-loglevel", "error", "-nodisp", "-autoexit"];
+  if (offsetMs > 0) args.push("-ss", (offsetMs / 1e3).toFixed(3));
+  args.push("-i", url);
+  return args;
+}
+var SyncedAudio = class {
+  proc = null;
+  mem = { playingTrackId: null, spawnedAtServerMs: 0, spawnedOffsetMs: 0, procAlive: false };
+  opts = null;
+  timer = null;
+  start(opts) {
+    this.stop();
+    this.opts = opts;
+    this.tick();
+    this.timer = setInterval(() => this.tick(), 1e3);
+  }
+  /** Swap in a new schedule (worker pushed a new playlist) without a restart. */
+  setSchedule(sched) {
+    if (this.opts) this.opts.schedule = sched;
+  }
+  tick() {
+    if (!this.opts) 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"] });
+    this.proc = proc;
+    this.mem = { playingTrackId: track.id, spawnedAtServerMs: this.opts.serverNow(), spawnedOffsetMs: offsetMs, procAlive: true };
+    this.opts.onTrack?.(track);
+    let err = "";
+    proc.stderr?.on("data", (d) => {
+      err = (err + d.toString()).slice(-200);
+    });
+    proc.on("error", (e) => {
+      this.mem.procAlive = false;
+      this.opts?.onError?.(e.message);
+    });
+    proc.on("exit", () => {
+      if (this.proc !== proc) return;
+      this.mem.procAlive = false;
+      if (err) this.opts?.onError?.(err.split("\n").pop() || err);
+    });
+  }
+  killProc() {
+    if (this.proc) {
+      try {
+        this.proc.kill("SIGKILL");
+      } catch {
+      }
+      this.proc = null;
+    }
+  }
+  get nowTrackId() {
+    return this.mem.playingTrackId;
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.killProc();
+    this.mem = { playingTrackId: null, spawnedAtServerMs: 0, spawnedOffsetMs: 0, procAlive: false };
+  }
+};
+
+// src/radio/app.ts
+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 audio = null;
+var lastFrame = null;
+var frameW = 0;
+var frameH = 0;
+var renderTimer = null;
+var running = false;
+var startedAt = Date.now();
+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();
+  return {
+    schedule,
+    serverNowMs,
+    nowPlaying: nowPlaying(schedule, serverNowMs),
+    nowShowing: nowShowing(schedule, serverNowMs),
+    listeners,
+    you,
+    broadcast: null,
+    connected: true
+  };
+}
+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: () => {
+    }
+  });
+  if (tools.ffplayPath) {
+    audio = new SyncedAudio();
+    audio.start({
+      ffplayPath: tools.ffplayPath,
+      schedule: state.schedule,
+      serverNow: () => Date.now()
+      // TODO: swap for skew-corrected worker clock
+    });
+  }
+}
+function makeScreen() {
+  screen = new ScreenBuffer({ dst: term, width: W(), height: H() });
+  video?.resize(W(), H());
+}
+function blitVideo() {
+  const w = screen.width, h = screen.height;
+  if (lastFrame && frameW === w && frameH === h) {
+    for (let y = 0; y < h; y++) {
+      for (let x = 0; x < w; x++) {
+        const c = lastFrame[y * w + x];
+        if (c) screen.put({ x, y, attr: { color: c.color, bgColor: c.color }, dx: 1, dy: 0, wrap: false }, c.ch);
+      }
+    }
+  } else {
+    for (let y = 0; y < h; y++)
+      screen.put({ x: 0, y, attr: { color: 233, bgColor: 233 }, dx: 1, dy: 0, wrap: false }, " ".repeat(w));
+  }
+}
+function videoColorAt(x, y) {
+  if (lastFrame && frameW === screen.width && x < frameW && y < frameH) {
+    const c = lastFrame[y * frameW + x];
+    if (c) return c.color;
+  }
+  return 233;
+}
+function blitOverlay(cells) {
+  const w = screen.width, h = screen.height;
+  for (const c of cells) {
+    if (c.x < 0 || c.y < 0 || c.x >= w || c.y >= h) continue;
+    const bg = c.bg ?? videoColorAt(c.x, c.y);
+    screen.put({ x: c.x, y: c.y, attr: { color: c.color ?? 231, bgColor: bg, bold: !!c.bold }, dx: 1, dy: 0, wrap: false }, c.ch || " ");
+  }
+}
+function renderFrame() {
+  if (!running) return;
+  const you = state.you;
+  const serverNowMs = Date.now();
+  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 });
+  blitOverlay(cells);
+  if (screen.dst) screen.draw({ delta: true });
+}
+function teardown() {
+  running = false;
+  if (renderTimer) {
+    clearInterval(renderTimer);
+    renderTimer = null;
+  }
+  video?.stop();
+  video = null;
+  audio?.stop();
+  audio = null;
+  try {
+    term.grabInput(false);
+    term.hideCursor(false);
+    term.fullscreen(false);
+    term.styleReset();
+  } catch {
+  }
+}
+function quit() {
+  teardown();
+  process.exit(0);
+}
+function runRadio(opts) {
+  const you = { id: "you", name: opts.name || "you", tz: Intl.DateTimeFormat().resolvedOptions().timeZone };
+  state = demoState(you);
+  const die = (err) => {
+    teardown();
+    console.error("accelr8 radio crashed:", err instanceof Error ? err.stack || err.message : err);
+    process.exit(1);
+  };
+  process.on("uncaughtException", die);
+  process.on("unhandledRejection", die);
+  term.fullscreen(true);
+  term.hideCursor();
+  term.grabInput(true);
+  makeScreen();
+  startVideo(opts);
+  running = true;
+  term.on("key", (name) => {
+    if (name === "CTRL_C" || name === "q" || name === "ESCAPE") return quit();
+  });
+  term.on("resize", () => makeScreen());
+  process.on("SIGINT", quit);
+  process.on("SIGTERM", quit);
+  renderTimer = setInterval(renderFrame, Math.round(1e3 / RENDER_FPS));
+  renderFrame();
+}
+export {
+  runRadio
+};