accelr8 3.8.1 → 4.0.0-next.1

package/dist/chunks/{app-7YGYMFSZ.js → app-JMUXGMWK.js}

@@ -1,18 +1,22 @@
 #!/usr/bin/env node
 import {
-  detectVoiceTools,
   tzCity,
   tzToCoords
-} from "./chunk-HY6ULYGH.js";
+} from "./chunk-CUUNLVID.js";
+import {
+  detectVoiceTools
+} from "./chunk-UMPU6SAD.js";
 import {
   DEFAULT_SERVER,
   VERSION
-} from "./chunk-UTWXIX5N.js";
+} from "./chunk-5QXGOLQ3.js";
+import {
+  accelr8Dir
+} from "./chunk-62O2F73J.js";
 
 // src/radio/app.ts
 import tk from "terminal-kit";
 import fs from "node:fs";
-import os from "node:os";
 import path from "node:path";
 import { WebSocket } from "ws";
 
@@ -318,7 +322,7 @@ var matrix = {
   frame(tMs, w, h) {
     const out = new Array(w * h);
     const t = tMs / 1e3;
-    const CH = "01<>+*=~^:;|/\\ACELR8#$%&?!";
+    const CH2 = "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++) {
@@ -345,7 +349,7 @@ var matrix = {
           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 ch = CH2[Math.floor(hashU(x * 31 + y * 57 + Math.floor(t * rate) * 7919) * CH2.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) };
       }
@@ -5345,123 +5349,273 @@ function renderOverlay(ctx, opts) {
 }
 
 // src/radio/audio.ts
-import { spawn as spawn2 } from "node:child_process";
-function nextAudioAction(sched, serverNowMs, mem, driftBudgetMs = 1500) {
+import { spawn as spawn2, spawnSync } from "node:child_process";
+var SR = 44100;
+var CH = 2;
+function nextAudioAction(sched, serverNowMs, mem, driftBudgetMs = 1500, stallMs = 4e3) {
   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 };
-  }
+  const play = (reason) => ({ kind: "play", track: pos.item, offsetMs: pos.offsetMs, reason });
+  if (pos.item.id !== mem.playingTrackId) return play(mem.playingTrackId ? "track" : "start");
+  if (!mem.procAlive) return play("dead");
+  if (mem.lastDataAtServerMs !== void 0) {
+    const quietFor = serverNowMs - (mem.lastDataAtServerMs || mem.spawnedAtServerMs);
+    if (quietFor > (mem.lastDataAtServerMs ? stallMs : stallMs * 2)) return play("stall");
+  }
+  const implied = mem.spawnedOffsetMs + (serverNowMs - mem.spawnedAtServerMs);
+  if (Math.abs(implied - pos.offsetMs) > driftBudgetMs) return play("drift");
   return { kind: "none" };
 }
-function ffplayArgs(url, offsetMs, volume = 70) {
-  const args = [
+function applyGain(buf, fromGain, target, rampPerSample = 1 / 1400) {
+  let g = fromGain;
+  for (let i = 0; i + 1 < buf.length; i += 2) {
+    if (g < target) g = g + rampPerSample > target ? target : g + rampPerSample;
+    else if (g > target) g = g - rampPerSample < target ? target : g - rampPerSample;
+    let s = Math.round(buf.readInt16LE(i) * g);
+    if (s > 32767) s = 32767;
+    else if (s < -32768) s = -32768;
+    buf.writeInt16LE(s, i);
+  }
+  return g;
+}
+function decoderArgs(url, offsetMs) {
+  const args = ["-hide_banner", "-loglevel", "error", "-re"];
+  if (/^https?:/i.test(url)) args.push("-rw_timeout", "8000000");
+  if (offsetMs > 0) args.push("-ss", (offsetMs / 1e3).toFixed(3));
+  args.push("-i", url, "-f", "s16le", "-ar", String(SR), "-ac", String(CH), "-");
+  return args;
+}
+var chFlagCache = null;
+function ffplayStereoFlag(ffplayPath) {
+  if (chFlagCache) return chFlagCache;
+  let modern = true;
+  try {
+    const out = spawnSync(ffplayPath, ["-hide_banner", "-version"], { encoding: "utf8", timeout: 3e3 });
+    const m = ((out.stdout || "") + (out.stderr || "")).match(/version\s+n?(\d+)\.(\d+)/i);
+    if (m) {
+      const major = +m[1], minor = +m[2];
+      modern = major > 5 || major === 5 && minor >= 1;
+    }
+  } catch {
+  }
+  chFlagCache = modern ? ["-ch_layout", "stereo"] : ["-ac", String(CH)];
+  return chFlagCache;
+}
+function sinkArgs(ffplayPath) {
+  return [
     "-hide_banner",
     "-loglevel",
     "error",
     "-nodisp",
-    "-autoexit",
-    "-volume",
-    String(Math.max(0, Math.min(100, Math.round(volume))))
+    "-sync",
+    "audio",
+    "-infbuf",
+    "-f",
+    "s16le",
+    "-ar",
+    String(SR),
+    ...ffplayStereoFlag(ffplayPath),
+    "-i",
+    "-"
   ];
-  if (offsetMs > 0) args.push("-ss", (offsetMs / 1e3).toFixed(3));
-  args.push("-i", url);
-  return args;
+}
+function coreAudioSinkArgs(ffmpegPath) {
+  return [
+    "-hide_banner",
+    "-loglevel",
+    "error",
+    "-f",
+    "s16le",
+    "-ar",
+    String(SR),
+    ...ffplayStereoFlag(ffmpegPath),
+    "-i",
+    "-",
+    "-f",
+    "audiotoolbox",
+    "-"
+  ];
+}
+var coreAudioCache = null;
+function hasCoreAudioSink(ffmpegPath) {
+  if (coreAudioCache !== null) return coreAudioCache;
+  coreAudioCache = false;
+  if (process.platform !== "darwin") return false;
+  try {
+    const out = spawnSync(ffmpegPath, ["-hide_banner", "-devices"], { encoding: "utf8", timeout: 3e3 });
+    coreAudioCache = /\baudiotoolbox\b/.test((out.stdout || "") + (out.stderr || ""));
+  } catch {
+  }
+  return coreAudioCache;
+}
+function pickSink(ffmpegPath, ffplayPath, pref = "auto") {
+  const core = pref === "coreaudio" || pref === "auto" && hasCoreAudioSink(ffmpegPath);
+  return core ? { kind: "coreaudio", bin: ffmpegPath, args: coreAudioSinkArgs(ffmpegPath) } : { kind: "ffplay", bin: ffplayPath, args: sinkArgs(ffplayPath) };
 }
 var SyncedAudio = class {
-  proc = null;
+  sink = null;
+  decoder = null;
   mem = { playingTrackId: null, spawnedAtServerMs: 0, spawnedOffsetMs: 0, procAlive: false };
   opts = null;
   timer = null;
-  vol = 70;
-  // 0..100
+  gain = 0.7;
+  // current (ramping) gain
+  target = 0.7;
+  // desired volume (0..1)
   muted = false;
+  sinkKind = "";
+  lastFeedAt = 0;
+  // wall ms of the last write to the sink (music or silence)
+  written = 0;
+  // bytes into the current sink, to keep whole s16 stereo frames
+  keepalive = null;
   start(opts) {
     this.stop();
     this.opts = opts;
+    this.startSink();
     this.tick();
     this.timer = setInterval(() => this.tick(), 1e3);
+    this.keepalive = setInterval(() => {
+      const quiet = Date.now() - this.lastFeedAt;
+      if (quiet > 60) this.feed(Buffer.alloc(Math.floor(Math.min(quiet, 250) * SR / 1e3) * CH * 2));
+    }, 40);
+  }
+  /** Every write to the sink goes through here. Pads to a whole 4-byte frame
+   *  first, so a decoder killed mid-frame can't shift the stream into noise. */
+  feed(buf) {
+    const sink = this.sink;
+    if (!sink || !sink.stdin || sink.stdin.destroyed) return true;
+    const pad = (4 - this.written % 4) % 4;
+    if (pad && buf.length) {
+      sink.stdin.write(Buffer.alloc(pad));
+      this.written += pad;
+    }
+    this.written += buf.length;
+    this.lastFeedAt = Date.now();
+    return sink.stdin.write(buf);
+  }
+  /** Open a fresh sink, so it binds to whatever output is current NOW (the TV
+   *  while screen sharing, the speakers after). The old one is dropped first
+   *  so its exit handler doesn't treat this as a crash. */
+  restartSink() {
+    const old = this.sink;
+    this.sink = null;
+    this.startSink();
+    if (old) {
+      try {
+        old.kill("SIGKILL");
+      } catch {
+      }
+    }
   }
-  /** Swap in a new schedule (worker pushed a new playlist) without a restart. */
   setSchedule(sched) {
     if (this.opts) this.opts.schedule = sched;
   }
   get volume() {
-    return this.vol;
+    return Math.round(this.target * 100);
   }
   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). */
+  get nowTrackId() {
+    return this.mem.playingTrackId;
+  }
+  /** Smooth: just move the target; the per-chunk gain ramp glides to it. */
   setVolume(v) {
-    this.vol = Math.max(0, Math.min(100, Math.round(v)));
-    if (!this.muted) this.respawnCurrent();
+    this.target = Math.max(0, Math.min(100, Math.round(v))) / 100;
+    this.muted = false;
   }
-  /** 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() {
+  // gain ramps to 0 / back, no cut
+  effTarget() {
+    return this.muted ? 0 : this.target;
+  }
+  startSink() {
     if (!this.opts) return;
-    const pos = nowPlaying(this.opts.schedule, this.opts.serverNow());
-    if (pos && pos.item.url) this.spawn(pos.item, pos.offsetMs);
+    const env = process.env.ACCELR8_RADIO_SINK;
+    const pref = env === "ffplay" || env === "coreaudio" ? env : this.opts.sink ?? "auto";
+    const pick4 = pickSink(this.opts.ffmpegPath, this.opts.ffplayPath, pref);
+    this.opts.onSink?.(pick4.kind);
+    const sink = spawn2(pick4.bin, pick4.args, { stdio: ["pipe", "ignore", "pipe"] });
+    this.sink = sink;
+    this.sinkKind = pick4.kind;
+    this.written = 0;
+    sink.stdin?.on("error", () => {
+    });
+    sink.stdin?.on("drain", () => this.decoder?.stdout?.resume());
+    let err = "";
+    sink.stderr?.on("data", (d) => {
+      err = (err + d.toString()).slice(-200);
+    });
+    sink.on("exit", () => {
+      if (this.sink !== sink) return;
+      this.sink = null;
+      if (err) this.opts?.onError?.(err.split("\n").pop() || err);
+      if (this.opts) {
+        this.startSink();
+        this.mem.procAlive = false;
+      }
+    });
   }
   tick() {
-    if (!this.opts || this.muted) return;
+    if (!this.opts) return;
+    if (!this.sink) this.startSink();
     const action = nextAudioAction(this.opts.schedule, this.opts.serverNow(), this.mem);
-    if (action.kind === "play") this.spawn(action.track, action.offsetMs);
+    if (action.kind === "play") {
+      if (action.reason !== "track") this.opts.onRespawn?.(action.reason, action.track, action.offsetMs);
+      if (action.reason === "track" && this.sinkKind === "coreaudio") this.restartSink();
+      this.spawnDecoder(action.track, action.offsetMs);
+    }
   }
-  spawn(track, offsetMs) {
+  spawnDecoder(track, offsetMs) {
     if (!this.opts) return;
-    this.killProc();
-    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.killDecoder();
+    const dec = spawn2(this.opts.ffmpegPath, decoderArgs(track.url, offsetMs), { stdio: ["ignore", "pipe", "ignore"] });
+    this.decoder = dec;
+    this.mem = { playingTrackId: track.id, spawnedAtServerMs: this.opts.serverNow(), spawnedOffsetMs: offsetMs, procAlive: true, lastDataAtServerMs: 0 };
     this.opts.onTrack?.(track);
-    let err = "";
-    proc.stderr?.on("data", (d) => {
-      err = (err + d.toString()).slice(-200);
+    dec.stdout?.on("data", (chunk) => {
+      if (this.decoder !== dec) return;
+      if (this.opts) this.mem.lastDataAtServerMs = this.opts.serverNow();
+      this.gain = applyGain(chunk, this.gain, this.effTarget());
+      if (this.feed(chunk) === false) dec.stdout?.pause();
     });
-    proc.on("error", (e) => {
-      this.mem.procAlive = false;
-      this.opts?.onError?.(e.message);
+    dec.on("error", () => {
+      if (this.decoder === dec) this.mem.procAlive = false;
     });
-    proc.on("exit", () => {
-      if (this.proc !== proc) return;
-      this.mem.procAlive = false;
-      if (err) this.opts?.onError?.(err.split("\n").pop() || err);
+    dec.on("exit", () => {
+      if (this.decoder === dec) this.mem.procAlive = false;
     });
   }
-  killProc() {
-    if (this.proc) {
+  killDecoder() {
+    if (this.decoder) {
       try {
-        this.proc.kill("SIGKILL");
+        this.decoder.kill("SIGKILL");
       } catch {
       }
-      this.proc = null;
+      this.decoder = null;
     }
   }
-  get nowTrackId() {
-    return this.mem.playingTrackId;
-  }
   stop() {
     if (this.timer) {
       clearInterval(this.timer);
       this.timer = null;
     }
-    this.killProc();
+    if (this.keepalive) {
+      clearInterval(this.keepalive);
+      this.keepalive = null;
+    }
+    this.killDecoder();
+    if (this.sink) {
+      try {
+        this.sink.kill("SIGKILL");
+      } catch {
+      }
+      this.sink = null;
+    }
     this.mem = { playingTrackId: null, spawnedAtServerMs: 0, spawnedOffsetMs: 0, procAlive: false };
   }
 };
@@ -5469,7 +5623,7 @@ var SyncedAudio = class {
 // src/radio/app.ts
 function rlog(msg) {
   try {
-    const dir = path.join(os.homedir(), ".accelr8");
+    const dir = accelr8Dir();
     fs.mkdirSync(dir, { recursive: true });
     fs.appendFileSync(path.join(dir, "radio.log"), `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
 `);
@@ -5490,6 +5644,7 @@ var frameH = 0;
 var renderTimer = null;
 var running = false;
 var startedAt = Date.now();
+var VISUAL_EPOCH = Date.UTC(2026, 0, 1);
 var skewMs = 0;
 var serverNow = () => Date.now() + skewMs;
 var W = () => Math.max(20, term.width || process.stdout.columns || 100);
@@ -5535,10 +5690,29 @@ function connectStation(opts) {
     return;
   }
   stationWs = ws;
+  let lastHeard = Date.now();
+  const beat = setInterval(() => {
+    if (ws.readyState !== WebSocket.OPEN) return;
+    if (Date.now() - lastHeard > 25e3) {
+      rlog("station socket silent 25s, reconnecting");
+      ws.terminate();
+      return;
+    }
+    try {
+      ws.ping();
+    } catch {
+    }
+  }, 1e4);
+  ws.on("pong", () => {
+    lastHeard = Date.now();
+  });
   ws.on("open", () => {
+    lastHeard = Date.now();
     ws.send(JSON.stringify({ t: "hello", id: me.id, name: me.name, tz: me.tz, color: me.color }));
+    if (youVoted && skipTrackId) ws.send(JSON.stringify({ t: "voteSkip", trackId: skipTrackId }));
   });
   ws.on("message", (raw) => {
+    lastHeard = Date.now();
     let m;
     try {
       m = JSON.parse(raw.toString());
@@ -5548,6 +5722,7 @@ function connectStation(opts) {
     if (m && m.t === "radioState") applyStation(m);
   });
   ws.on("close", () => {
+    clearInterval(beat);
     if (stationWs === ws) {
       state = { ...state, connected: false };
       scheduleReconnect(opts);
@@ -5555,7 +5730,7 @@ function connectStation(opts) {
   });
   ws.on("error", () => {
     try {
-      ws.close();
+      ws.terminate();
     } catch {
     }
   });
@@ -5578,8 +5753,14 @@ function applyStation(m) {
     skipVotes = m.skip.votes ?? 0;
     skipNeeded = m.skip.needed ?? 1;
     if (m.skip.trackId && m.skip.trackId !== skipTrackId) {
+      if (youVoted && skipTrackId) {
+        skipNote = "skipped \u2713";
+        skipNoteUntil = Date.now() + 4e3;
+      }
       skipTrackId = m.skip.trackId;
       youVoted = false;
+    } else if (Array.isArray(m.skip.voters) && Date.now() - lastToggleAt > 2e3) {
+      youVoted = m.skip.voters.includes(me.id);
     }
   }
 }
@@ -5606,9 +5787,16 @@ function startBackground(opts) {
   } else {
     visuals = new Showrunner(ALL_SCENES);
   }
-  if (tools.ffplayPath) {
+  if (tools.ffmpegPath && tools.ffplayPath) {
     audio = new SyncedAudio();
-    audio.start({ ffplayPath: tools.ffplayPath, schedule: state.schedule, serverNow });
+    audio.start({
+      ffplayPath: tools.ffplayPath,
+      ffmpegPath: tools.ffmpegPath,
+      schedule: state.schedule,
+      serverNow,
+      onRespawn: (reason, track, offsetMs) => rlog(`audio respawn: ${reason} \xB7 ${track.id} @ ${(offsetMs / 1e3).toFixed(1)}s`),
+      onSink: (kind) => rlog(`audio sink: ${kind}`)
+    });
   }
 }
 function makeScreen() {
@@ -5634,9 +5822,18 @@ var skipVotes = 0;
 var skipNeeded = 1;
 var youVoted = false;
 var skipTrackId = "";
+var skipNote = "";
+var skipNoteUntil = 0;
+var lastToggleAt = 0;
 function toggleSkip() {
+  if (!stationWs || stationWs.readyState !== WebSocket.OPEN) {
+    skipNote = "offline, retrying";
+    skipNoteUntil = Date.now() + 3e3;
+    return;
+  }
   youVoted = !youVoted;
-  if (stationWs && stationWs.readyState === 1) stationWs.send(JSON.stringify({ t: youVoted ? "voteSkip" : "unvoteSkip" }));
+  lastToggleAt = Date.now();
+  stationWs.send(JSON.stringify({ t: youVoted ? "voteSkip" : "unvoteSkip", trackId: skipTrackId || void 0 }));
 }
 function drawControls() {
   const w = screen.width, y = 1;
@@ -5648,7 +5845,7 @@ function drawControls() {
   const vol = audio ? audio.isMuted ? "MUTED" : `vol ${audio.volume}%` : "no audio";
   put2(1, `\u266A ${vol}   [m] mute   [+/-] volume   [q] quit`);
   const met = skipVotes >= skipNeeded && skipVotes > 0;
-  const label = youVoted ? "[s] voted \u2713" : "[s] vote skip";
+  const label = Date.now() < skipNoteUntil ? `[s] ${skipNote}` : youVoted ? "[s] voted \u2713" : "[s] vote skip";
   const right = `${label}   skip ${skipVotes}/${skipNeeded} `;
   put2(w - right.length, right, met ? C_GOOD : 231, youVoted);
 }
@@ -5683,7 +5880,7 @@ var renderErrs = 0;
 function renderFrame() {
   if (!running) return;
   try {
-    const tMs = Date.now() - startedAt;
+    const tMs = serverNow() - VISUAL_EPOCH;
     if (visuals) {
       lastFrame = visuals.frame(tMs, screen.width, screen.height);
       frameW = screen.width;
@@ -5750,7 +5947,7 @@ function runRadio(opts) {
     const detail = err instanceof Error ? err.stack || err.message : String(err);
     rlog(`CRASH: ${detail}`);
     teardown();
-    console.error("\naccelr8 radio crashed:\n" + detail + "\n\nlog: " + path.join(os.homedir(), ".accelr8", "radio.log") + "\n(press any key to close)");
+    console.error("\naccelr8 radio crashed:\n" + detail + "\n\nlog: " + path.join(accelr8Dir(), "radio.log") + "\n(press any key to close)");
     try {
       process.stdin.setRawMode?.(true);
       process.stdin.resume();

package/dist/chunks/authclient-AUBBFWCI.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import {
+  AuthNetworkError,
+  approveSignIn,
+  approveUrl,
+  deviceLogin,
+  ensureSignedIn,
+  getAccessToken,
+  httpBase,
+  legacyProofs,
+  logout,
+  olderServerMessage,
+  pendingSignIn,
+  refreshCredentials,
+  whoami
+} from "./chunk-3OTVRBTJ.js";
+import "./chunk-FVC2UPMV.js";
+import "./chunk-5QXGOLQ3.js";
+import "./chunk-62O2F73J.js";
+export {
+  AuthNetworkError,
+  approveSignIn,
+  approveUrl,
+  deviceLogin,
+  ensureSignedIn,
+  getAccessToken,
+  httpBase,
+  legacyProofs,
+  logout,
+  olderServerMessage,
+  pendingSignIn,
+  refreshCredentials,
+  whoami
+};

package/dist/chunks/authpage-X2AKCMVH.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import {
+  DIFFERENT_NETWORK,
+  ago,
+  confirmPage,
+  deniedPage,
+  donePage,
+  enterCodePage,
+  esc,
+  platformName
+} from "./chunk-RZ4OBBLX.js";
+export {
+  DIFFERENT_NETWORK,
+  ago,
+  confirmPage,
+  deniedPage,
+  donePage,
+  enterCodePage,
+  esc,
+  platformName
+};