accelr8 3.8.0 → 3.8.2

package/dist/chunks/{app-DCVVDS5A.js → app-SYLCS3QX.js}

@@ -5,11 +5,15 @@ import {
   tzToCoords
 } from "./chunk-HY6ULYGH.js";
 import {
-  DEFAULT_SERVER
-} from "./chunk-YUZORFN4.js";
+  DEFAULT_SERVER,
+  VERSION
+} from "./chunk-7JSMON7M.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";
 
 // src/radio/asciivideo.ts
@@ -314,7 +318,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++) {
@@ -341,7 +345,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) };
       }
@@ -5341,128 +5345,197 @@ function renderOverlay(ctx, opts) {
 }
 
 // src/radio/audio.ts
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn2, spawnSync } from "node:child_process";
+var SR = 44100;
+var CH = 2;
 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 };
+  if (pos.item.id !== mem.playingTrackId || !mem.procAlive) return { kind: "play", track: pos.item, offsetMs: pos.offsetMs };
+  const implied = mem.spawnedOffsetMs + (serverNowMs - mem.spawnedAtServerMs);
+  if (Math.abs(implied - pos.offsetMs) > driftBudgetMs) return { kind: "play", track: pos.item, offsetMs: pos.offsetMs };
+  return { kind: "none" };
+}
+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);
   }
-  const impliedOffset = mem.spawnedOffsetMs + (serverNowMs - mem.spawnedAtServerMs);
-  if (Math.abs(impliedOffset - pos.offsetMs) > driftBudgetMs) {
-    return { kind: "play", track: pos.item, offsetMs: pos.offsetMs };
+  return g;
+}
+function decoderArgs(url, offsetMs) {
+  const args = ["-hide_banner", "-loglevel", "error", "-re"];
+  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 {
   }
-  return { kind: "none" };
+  chFlagCache = modern ? ["-ch_layout", "stereo"] : ["-ac", String(CH)];
+  return chFlagCache;
 }
-function ffplayArgs(url, offsetMs, volume = 70) {
-  const args = [
+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;
 }
 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;
   start(opts) {
     this.stop();
     this.opts = opts;
+    this.startSink();
     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;
   }
   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 sink = spawn2(this.opts.ffplayPath, sinkArgs(this.opts.ffplayPath), { stdio: ["pipe", "ignore", "pipe"] });
+    this.sink = sink;
+    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") 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.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 };
     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;
+      this.gain = applyGain(chunk, this.gain, this.effTarget());
+      const sink = this.sink;
+      if (!sink || !sink.stdin || sink.stdin.destroyed) return;
+      const ok = sink.stdin.write(chunk);
+      if (ok === 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();
+    this.killDecoder();
+    if (this.sink) {
+      try {
+        this.sink.kill("SIGKILL");
+      } catch {
+      }
+      this.sink = null;
+    }
     this.mem = { playingTrackId: null, spawnedAtServerMs: 0, spawnedOffsetMs: 0, procAlive: false };
   }
 };
 
 // src/radio/app.ts
+function rlog(msg) {
+  try {
+    const dir = path.join(os.homedir(), ".accelr8");
+    fs.mkdirSync(dir, { recursive: true });
+    fs.appendFileSync(path.join(dir, "radio.log"), `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
+`);
+  } catch {
+  }
+}
 var term = tk.terminal;
 var ScreenBuffer = tk.ScreenBuffer;
 var RENDER_FPS = 20;
@@ -5593,9 +5666,9 @@ 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 });
   }
 }
 function makeScreen() {
@@ -5666,21 +5739,26 @@ function blitOverlay(cells) {
     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 || " ");
   }
 }
+var renderErrs = 0;
 function renderFrame() {
   if (!running) return;
-  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, state });
-  blitOverlay(cells);
-  drawControls();
-  if (screen.dst) screen.draw({ delta: true });
+  try {
+    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, state });
+    blitOverlay(cells);
+    drawControls();
+    if (screen.dst) screen.draw({ delta: true });
+  } catch (e) {
+    if (renderErrs++ < 5) rlog(`renderFrame error @${screen?.width}x${screen?.height}: ${e?.stack || e?.message || e}`);
+  }
 }
 function teardown() {
   running = false;
@@ -5715,23 +5793,46 @@ function quit() {
   process.exit(0);
 }
 function runRadio(opts) {
-  const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  let tz = "UTC";
+  try {
+    tz = Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+  } catch {
+  }
   me = { id: "me_" + Math.random().toString(36).slice(2, 10), name: opts.name || "you", tz, color: 39 };
   state = baseState(me);
+  try {
+    const tools = detectVoiceTools();
+    rlog(`\u2500\u2500 radio start v${VERSION} \xB7 ${process.platform} \xB7 node ${process.version} \xB7 term ${process.stdout.columns}x${process.stdout.rows} \xB7 TERM=${process.env.TERM} \xB7 ffmpeg=${!!tools.ffmpegPath} ffplay=${!!tools.ffplayPath}`);
+  } catch (e) {
+    rlog(`start probe failed: ${e?.stack || e}`);
+  }
   const die = (err) => {
+    const detail = err instanceof Error ? err.stack || err.message : String(err);
+    rlog(`CRASH: ${detail}`);
     teardown();
-    console.error("accelr8 radio crashed:", err instanceof Error ? err.stack || err.message : err);
-    process.exit(1);
+    console.error("\naccelr8 radio crashed:\n" + detail + "\n\nlog: " + path.join(os.homedir(), ".accelr8", "radio.log") + "\n(press any key to close)");
+    try {
+      process.stdin.setRawMode?.(true);
+      process.stdin.resume();
+      process.stdin.once("data", () => process.exit(1));
+      setTimeout(() => process.exit(1), 3e4);
+    } catch {
+      process.exit(1);
+    }
   };
   process.on("uncaughtException", die);
   process.on("unhandledRejection", die);
-  term.fullscreen(true);
-  term.hideCursor();
-  term.grabInput(true);
-  makeScreen();
-  running = true;
-  startBackground(opts);
-  connectStation(opts);
+  try {
+    term.fullscreen(true);
+    term.hideCursor();
+    term.grabInput(true);
+    makeScreen();
+    running = true;
+    startBackground(opts);
+    connectStation(opts);
+  } catch (e) {
+    return die(e);
+  }
   term.on("key", (name) => {
     if (name === "CTRL_C" || name === "q" || name === "ESCAPE") return quit();
     if (name === "m") return muteToggle();

package/dist/chunks/{chunk-YUZORFN4.js → chunk-7JSMON7M.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/protocol.ts
-var VERSION = true ? "3.8.0" : "3.8.0";
+var VERSION = true ? "3.8.2" : "3.8.2";
 var PROTO = 3;
 var PORT = 8787;
 var DEFAULT_SERVER = "wss://accelr8-canvas.patonchain.workers.dev";

package/dist/chunks/{client-Y2PNGYRP.js → client-BKQLCKVT.js}

@@ -32,7 +32,7 @@ import {
   VERSION,
   decode,
   encode
-} from "./chunk-YUZORFN4.js";
+} from "./chunk-7JSMON7M.js";
 
 // src/client.ts
 import tk from "terminal-kit";

package/dist/chunks/{server-6VK3AAAJ.js → server-IRLRECZ7.js}

@@ -6,7 +6,7 @@ import {
   LIMITS,
   PORT,
   PROTO
-} from "./chunk-YUZORFN4.js";
+} from "./chunk-7JSMON7M.js";
 
 // src/server.ts
 import { WebSocketServer, WebSocket } from "ws";

package/dist/cli.js

@@ -3,7 +3,7 @@ import {
   DEFAULT_SERVER,
   PORT,
   VERSION
-} from "./chunks/chunk-YUZORFN4.js";
+} from "./chunks/chunk-7JSMON7M.js";
 
 // src/cli.ts
 var HELP = `
@@ -53,7 +53,7 @@ async function main() {
       console.error(`invalid port: ${argVal(args, "--port")}`);
       process.exit(1);
     }
-    const { runServer } = await import("./chunks/server-6VK3AAAJ.js");
+    const { runServer } = await import("./chunks/server-IRLRECZ7.js");
     runServer(port);
     return;
   }
@@ -67,7 +67,7 @@ async function main() {
       console.error("accelr8 radio needs an interactive terminal (TTY).");
       process.exit(1);
     }
-    const { runRadio } = await import("./chunks/app-DCVVDS5A.js");
+    const { runRadio } = await import("./chunks/app-SYLCS3QX.js");
     runRadio({
       name: argVal(args, "--name"),
       server: argVal(args, "--server"),
@@ -90,7 +90,7 @@ async function main() {
   const { cachedUpdate, refreshUpdateCache } = await import("./chunks/update-UEPNGB6Y.js");
   refreshUpdateCache();
   const update = cachedUpdate(VERSION);
-  const { runClient } = await import("./chunks/client-Y2PNGYRP.js");
+  const { runClient } = await import("./chunks/client-BKQLCKVT.js");
   runClient({
     name: argVal(args, "--name"),
     server: argVal(args, "--server"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "accelr8",
-  "version": "3.8.0",
+  "version": "3.8.2",
   "description": "Collaborative ascii canvas in your terminal. Real multiplayer, live cursors, mouse-driven TUI.",
   "type": "module",
   "license": "ISC",