accelr8 3.8.2 → 4.0.0-next.1

package/dist/chunks/chunk-UMPU6SAD.js

@@ -0,0 +1,860 @@
+#!/usr/bin/env node
+import {
+  accelr8Dir
+} from "./chunk-62O2F73J.js";
+
+// src/voicelog.ts
+import fs from "node:fs";
+import path from "node:path";
+var logPath = null;
+var enabled = true;
+function file() {
+  if (!logPath) {
+    const dir = accelr8Dir();
+    try {
+      fs.mkdirSync(dir, { recursive: true });
+    } catch {
+    }
+    logPath = path.join(dir, "voice.log");
+  }
+  return logPath;
+}
+function stamp(nowMs) {
+  const d = new Date(nowMs);
+  const p = (n, w = 2) => String(n).padStart(w, "0");
+  return `${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}.${p(d.getMilliseconds(), 3)}`;
+}
+function vlog(nowMs, stage, msg, data) {
+  if (!enabled) return;
+  try {
+    const extra = data ? " " + Object.entries(data).map(([k, v]) => `${k}=${String(v).slice(0, 80)}`).join(" ") : "";
+    fs.appendFileSync(file(), `${stamp(nowMs)} [${stage}] ${msg}${extra}
+`);
+  } catch {
+  }
+}
+function vlogSession(nowMs, header) {
+  vlog(nowMs, "session", "\u2500\u2500\u2500\u2500 voice session \u2500\u2500\u2500\u2500", header);
+}
+function voiceLogPath() {
+  return file();
+}
+
+// src/voice.ts
+import { spawn, spawnSync } from "node:child_process";
+import fs2 from "node:fs";
+import path2 from "node:path";
+var SAMPLE_RATE = 16e3;
+var CHUNK_BYTES = 1280;
+var KILL_GRACE_MS = 300;
+var SPEAKER_IDLE_MS = 2e3;
+var PREBUFFER_BYTES = 4800;
+var DRAIN_KILL_MS = 2e3;
+var MAX_PLAYERS = 8;
+var STDERR_TAIL = 400;
+var VERIFY_MIN_BYTES = SAMPLE_RATE * 2 / 10;
+var liveHelpers = /* @__PURE__ */ new Set();
+var groupLeaders = /* @__PURE__ */ new WeakSet();
+var exitHookInstalled = false;
+function installExitHook() {
+  if (exitHookInstalled) return;
+  exitHookInstalled = true;
+  process.once("exit", () => killAllHelpers());
+}
+function spawnHelper(command, args, stdio, opts = {}) {
+  const detached = !!opts.group && process.platform !== "win32";
+  const child = spawn(command, args, { stdio, detached, windowsHide: true });
+  if (detached) groupLeaders.add(child);
+  liveHelpers.add(child);
+  const forget = () => {
+    liveHelpers.delete(child);
+  };
+  child.once("exit", forget);
+  child.once("error", forget);
+  installExitHook();
+  return child;
+}
+function killHelper(child, signal = "SIGKILL") {
+  if (child.exitCode !== null || child.signalCode !== null) return;
+  if (groupLeaders.has(child) && typeof child.pid === "number") {
+    try {
+      process.kill(-child.pid, signal);
+      return;
+    } catch {
+    }
+  }
+  try {
+    child.kill(signal);
+  } catch {
+  }
+}
+function killAllHelpers() {
+  for (const child of [...liveHelpers]) killHelper(child, "SIGKILL");
+}
+function liveHelperPids() {
+  return [...liveHelpers].map((c) => c.pid).filter((p) => typeof p === "number");
+}
+function playbackArgs(ffplayPath) {
+  const ch = ffplayChannelFlag(ffplayPath);
+  return [
+    "-hide_banner",
+    "-loglevel",
+    "error",
+    "-nodisp",
+    "-autoexit",
+    "-sync",
+    "audio",
+    "-infbuf",
+    "-f",
+    "s16le",
+    "-ar",
+    String(SAMPLE_RATE),
+    ...ch,
+    "-i",
+    "-"
+  ];
+}
+function voiceSinkCommand(tools, rate, platform = process.platform, hasCoreAudio = ffmpegHasAudioToolbox) {
+  if (platform === "darwin" && tools.ffmpegPath && hasCoreAudio(tools.ffmpegPath)) {
+    return { kind: "coreaudio", bin: tools.ffmpegPath, args: [
+      "-hide_banner",
+      "-loglevel",
+      "error",
+      "-f",
+      "s16le",
+      "-ar",
+      String(rate),
+      ...ffplayChannelFlag(tools.ffmpegPath),
+      "-i",
+      "-",
+      "-f",
+      "audiotoolbox",
+      "-"
+    ] };
+  }
+  if (!tools.ffplayPath) return null;
+  return { kind: "ffplay", bin: tools.ffplayPath, args: [
+    "-hide_banner",
+    "-loglevel",
+    "error",
+    "-nodisp",
+    "-autoexit",
+    "-f",
+    "s16le",
+    "-ar",
+    String(rate),
+    ...ffplayChannelFlag(tools.ffplayPath),
+    "-i",
+    "-"
+  ] };
+}
+var audioToolboxCache = null;
+function ffmpegHasAudioToolbox(ffmpegPath) {
+  if (audioToolboxCache !== null) return audioToolboxCache;
+  audioToolboxCache = false;
+  try {
+    const out = spawnSync(ffmpegPath, ["-hide_banner", "-devices"], { encoding: "utf8", timeout: 3e3 });
+    audioToolboxCache = /\baudiotoolbox\b/.test((out.stdout || "") + (out.stderr || ""));
+  } catch {
+  }
+  return audioToolboxCache;
+}
+var chFlagCache = null;
+function ffplayChannelFlag(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", "mono"] : ["-ac", "1"];
+  return chFlagCache;
+}
+function detectVoiceTools() {
+  const ffmpegPath = which("ffmpeg");
+  const ffplayPath = which("ffplay");
+  const out = { capture: !!ffmpegPath, playback: !!ffplayPath };
+  if (ffmpegPath) out.ffmpegPath = ffmpegPath;
+  if (ffplayPath) out.ffplayPath = ffplayPath;
+  if (!ffmpegPath || !ffplayPath) {
+    const missing = [ffmpegPath ? "" : "ffmpeg", ffplayPath ? "" : "ffplay"].filter(Boolean).join(" + ");
+    out.reason = `${missing} not found on PATH (voice needs ffmpeg; brew/apt install ffmpeg)`;
+  }
+  return out;
+}
+function which(bin) {
+  const exts = process.platform === "win32" ? [".exe", ".cmd", ".bat", ""] : [""];
+  for (const dir of (process.env.PATH ?? "").split(path2.delimiter).filter(Boolean)) {
+    for (const ext of exts) {
+      const candidate = path2.join(dir, bin + ext);
+      try {
+        if (!fs2.existsSync(candidate)) continue;
+        fs2.accessSync(candidate, fs2.constants.X_OK);
+        if (fs2.statSync(candidate).isFile()) return candidate;
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
+function captureArgs(platform, device, sampleRate = SAMPLE_RATE) {
+  const base = ["-hide_banner", "-loglevel", "error"];
+  const output = ["-ac", "1", "-ar", String(sampleRate), "-f", "s16le", "-"];
+  if (platform === "darwin") return [...base, "-f", "avfoundation", "-i", ":" + (device ?? "default"), ...output];
+  if (platform === "win32") return [...base, "-f", "dshow", "-i", "audio=" + (device ?? "default"), ...output];
+  return [...base, "-f", "alsa", "-i", device ?? "default", ...output];
+}
+function chunkPcm(buf, chunkBytes) {
+  if (!Number.isInteger(chunkBytes) || chunkBytes <= 0) throw new RangeError("chunkBytes must be a positive integer");
+  const b = Buffer.isBuffer(buf) ? buf : Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+  const out = [];
+  for (let i = 0; i < b.length; i += chunkBytes) out.push(b.subarray(i, i + chunkBytes).toString("base64"));
+  return out;
+}
+var VoiceCapture = class {
+  constructor(tools) {
+    this.tools = tools;
+  }
+  tools;
+  session = null;
+  get active() {
+    return this.session !== null;
+  }
+  /** pid of the running ffmpeg (diagnostics/tests) */
+  get pid() {
+    return this.session?.child.pid;
+  }
+  /** Spawn ffmpeg mic->PCM and stream ~40ms base64 chunks to onChunk.
+   *  No-op while a capture is already active. */
+  start(opts) {
+    if (this.session) return;
+    if (!this.tools.capture || !this.tools.ffmpegPath) {
+      const why = this.tools.reason ?? "ffmpeg not found on PATH";
+      queueMicrotask(() => opts.onError(why));
+      return;
+    }
+    this.session = this.spawnSession(opts, captureArgs(process.platform, opts.device), "primary");
+  }
+  /** Flush the sub-chunk remainder, then SIGINT -> SIGKILL after 300ms. */
+  stop() {
+    const s = this.session;
+    if (!s) return;
+    this.session = null;
+    s.stopped = true;
+    if (s.buf.length) {
+      s.onChunk(s.buf.toString("base64"));
+      s.buf = Buffer.alloc(0);
+    }
+    try {
+      s.child.stdout?.destroy();
+    } catch {
+    }
+    killHelper(s.child, "SIGINT");
+    const t = setTimeout(() => killHelper(s.child, "SIGKILL"), KILL_GRACE_MS);
+    t.unref();
+  }
+  spawnSession(opts, args, backend) {
+    let child;
+    try {
+      child = spawnHelper(this.tools.ffmpegPath, args, ["ignore", "pipe", "pipe"]);
+    } catch (e) {
+      vlog(Date.now(), "capture", "ffmpeg spawn threw", { backend, err: errMsg(e) });
+      queueMicrotask(() => opts.onError("mic capture failed to start: " + errMsg(e)));
+      return null;
+    }
+    vlog(Date.now(), "capture", "ffmpeg spawned", { backend, device: opts.device ?? "default", args: args.join(" ") });
+    const s = { child, onChunk: opts.onChunk, buf: Buffer.alloc(0), stderrTail: "", produced: false, stopped: false };
+    child.stdout?.on("data", (chunk) => {
+      if (s.stopped) return;
+      if (!s.produced) vlog(Date.now(), "capture", "first audio bytes from mic", { backend, bytes: chunk.length });
+      s.produced = true;
+      s.buf = s.buf.length ? Buffer.concat([s.buf, chunk]) : chunk;
+      const whole = Math.floor(s.buf.length / CHUNK_BYTES) * CHUNK_BYTES;
+      if (whole === 0) return;
+      for (const b64 of chunkPcm(s.buf.subarray(0, whole), CHUNK_BYTES)) opts.onChunk(b64);
+      s.buf = s.buf.subarray(whole);
+    });
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", (c) => {
+      s.stderrTail = (s.stderrTail + c).slice(-STDERR_TAIL);
+    });
+    child.on("error", (e) => {
+      if (s.stopped || this.session !== s) return;
+      this.session = null;
+      vlog(Date.now(), "capture", "ffmpeg error", { backend, code: e.code, produced: s.produced, stderr: s.stderrTail.trim() });
+      opts.onError(e.code === "ENOENT" ? "ffmpeg not found" : "mic capture error: " + errMsg(e));
+    });
+    child.on("close", (code) => {
+      if (s.stopped || this.session !== s) return;
+      vlog(Date.now(), "capture", "ffmpeg exited", { backend, code, producedAudio: s.produced, stderr: s.stderrTail.trim() });
+      if (backend === "primary" && process.platform === "linux" && !s.produced && code !== 0) {
+        vlog(Date.now(), "capture", "alsa failed, retrying on pulse");
+        const pulse = captureArgs("linux", opts.device).map((a) => a === "alsa" ? "pulse" : a);
+        this.session = this.spawnSession(opts, pulse, "pulse");
+        return;
+      }
+      this.session = null;
+      const tail = s.stderrTail.trim();
+      opts.onError(code === 0 ? "mic capture ended unexpectedly" : "mic capture failed: " + (tail || `ffmpeg exited with code ${code}`));
+    });
+    return s;
+  }
+};
+var VoicePlayback = class {
+  constructor(tools) {
+    this.tools = tools;
+  }
+  tools;
+  players = /* @__PURE__ */ new Map();
+  // players end() let go of: still draining their last audio, still ours to kill
+  draining = /* @__PURE__ */ new Set();
+  /** ids with an active player */
+  get speakers() {
+    return [...this.players.keys()];
+  }
+  /** pids of every player this instance still owns, draining ones included */
+  get pids() {
+    return [...this.players.values(), ...this.draining].map((p) => p.child.pid).filter((n) => typeof n === "number");
+  }
+  /** Feed a received chunk; lazily spawns one ffplay per speaker. Chunks
+   *  are dropped silently when playback is unavailable, the speaker cap
+   *  is hit, or a player cannot be (re)spawned. */
+  feed(speakerId, b64) {
+    if (!this.tools.playback || !this.tools.ffplayPath) return;
+    const bytes = Buffer.from(b64, "base64");
+    if (bytes.length === 0) return;
+    let p = this.players.get(speakerId);
+    if (p && !p.alive) {
+      this.reap(speakerId, p);
+      p = void 0;
+    }
+    if (!p) {
+      if (this.players.size >= MAX_PLAYERS) return;
+      const spawned = this.spawnPlayer(speakerId);
+      if (!spawned) return;
+      p = spawned;
+    }
+    if (!p.flowing) {
+      p.pre.push(bytes);
+      if (p.pre.reduce((n, b) => n + b.length, 0) >= PREBUFFER_BYTES) {
+        const cushion = Buffer.concat(p.pre);
+        p.pre = [];
+        p.flowing = true;
+        const np2 = this.writeOrRespawn(speakerId, p, cushion);
+        if (np2) this.touch(speakerId, np2);
+      } else {
+        this.touch(speakerId, p);
+      }
+      return;
+    }
+    const np = this.writeOrRespawn(speakerId, p, bytes);
+    if (np) this.touch(speakerId, np);
+  }
+  /** Write to a player; on EPIPE (it died) respawn once and write there. Returns
+   *  the live player, or null if it couldn't be (re)spawned. */
+  writeOrRespawn(speakerId, p, buf) {
+    if (this.write(p, buf)) return p;
+    this.reap(speakerId, p);
+    const fresh = this.players.size < MAX_PLAYERS ? this.spawnPlayer(speakerId) : null;
+    if (!fresh || !this.write(fresh, buf)) return null;
+    fresh.flowing = true;
+    return fresh;
+  }
+  /** Graceful close for one speaker: end stdin so ffplay drains its buffered
+   *  audio and -autoexit's; a group-kill backstop fires after 2s. The player
+   *  stays owned (stopAll() and the exit hook still reach it) until it exits. */
+  end(speakerId) {
+    const p = this.players.get(speakerId);
+    if (!p) return;
+    this.players.delete(speakerId);
+    if (p.idleTimer) {
+      clearTimeout(p.idleTimer);
+      p.idleTimer = null;
+    }
+    if (p.alive) this.draining.add(p);
+    try {
+      p.child.stdin?.end();
+    } catch {
+    }
+    const t = setTimeout(() => {
+      this.draining.delete(p);
+      killHelper(p.child, "SIGKILL");
+    }, DRAIN_KILL_MS);
+    t.unref();
+  }
+  /** Hard cleanup on quit: kill every player immediately, draining ones too. */
+  stopAll() {
+    for (const [, p] of this.players) {
+      if (p.idleTimer) {
+        clearTimeout(p.idleTimer);
+        p.idleTimer = null;
+      }
+      p.alive = false;
+      killHelper(p.child, "SIGKILL");
+    }
+    this.players.clear();
+    for (const p of this.draining) killHelper(p.child, "SIGKILL");
+    this.draining.clear();
+  }
+  spawnPlayer(speakerId) {
+    const args = playbackArgs(this.tools.ffplayPath);
+    let child;
+    try {
+      child = spawnHelper(this.tools.ffplayPath, args, ["pipe", "ignore", "pipe"], { group: true });
+    } catch (e) {
+      vlog(Date.now(), "playback", "ffplay spawn threw", { speaker: speakerId, err: errMsg(e) });
+      return null;
+    }
+    vlog(Date.now(), "playback", "ffplay spawned", { speaker: speakerId, args: args.join(" ") });
+    const p = { child, alive: true, idleTimer: null, pre: [], flowing: false };
+    let stderrTail = "";
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", (c) => {
+      stderrTail = (stderrTail + c).slice(-STDERR_TAIL);
+    });
+    child.stdin?.on("error", () => {
+      p.alive = false;
+    });
+    child.on("error", (e) => {
+      p.alive = false;
+      this.draining.delete(p);
+      vlog(Date.now(), "playback", "ffplay error", { speaker: speakerId, code: e.code, msg: errMsg(e) });
+      if (this.players.get(speakerId) === p) this.reap(speakerId, p);
+    });
+    child.on("close", (code) => {
+      p.alive = false;
+      this.draining.delete(p);
+      vlog(Date.now(), "playback", "ffplay exited", { speaker: speakerId, code, stderr: stderrTail.trim() });
+      if (this.players.get(speakerId) === p) {
+        if (p.idleTimer) {
+          clearTimeout(p.idleTimer);
+          p.idleTimer = null;
+        }
+        this.players.delete(speakerId);
+      }
+    });
+    this.players.set(speakerId, p);
+    return p;
+  }
+  write(p, bytes) {
+    const sin = p.child.stdin;
+    if (!p.alive || !sin || sin.destroyed || !sin.writable) return false;
+    try {
+      sin.write(bytes);
+      return true;
+    } catch {
+      p.alive = false;
+      return false;
+    }
+  }
+  touch(speakerId, p) {
+    if (p.idleTimer) clearTimeout(p.idleTimer);
+    p.idleTimer = setTimeout(() => this.end(speakerId), SPEAKER_IDLE_MS);
+    p.idleTimer.unref();
+  }
+  reap(speakerId, p) {
+    if (p.idleTimer) {
+      clearTimeout(p.idleTimer);
+      p.idleTimer = null;
+    }
+    p.alive = false;
+    killHelper(p.child, "SIGKILL");
+    if (this.players.get(speakerId) === p) this.players.delete(speakerId);
+  }
+};
+function listMicDevices() {
+  try {
+    if (process.platform === "darwin") {
+      const text = runForOutput(["-hide_banner", "-f", "avfoundation", "-list_devices", "true", "-i", ""]);
+      const out = [];
+      let inAudio = false;
+      for (const line of text.split("\n")) {
+        if (/audio devices/i.test(line)) {
+          inAudio = true;
+          continue;
+        }
+        if (/video devices/i.test(line)) {
+          inAudio = false;
+          continue;
+        }
+        if (!inAudio) continue;
+        const m = line.match(/\[(\d+)\]\s+(.+?)\s*$/);
+        if (m) out.push({ index: m[1], name: m[2] });
+      }
+      return out;
+    }
+    if (process.platform === "linux") {
+      const text = runForOutput(["-hide_banner", "-sources", "pulse"]);
+      const out = [];
+      for (const line of text.split("\n")) {
+        if (/auto-detected/i.test(line)) continue;
+        const m = line.match(/^\s*\*?\s*(\S+)\s+\[(.+)\]\s*$/);
+        if (m) out.push({ index: m[1], name: m[2] });
+      }
+      return out;
+    }
+    if (process.platform === "win32") {
+      const text = runForOutput(["-hide_banner", "-list_devices", "true", "-f", "dshow", "-i", "dummy"]);
+      const out = [];
+      for (const line of text.split("\n")) {
+        const m = line.match(/"(.+)"\s+\(audio\)/);
+        if (m) out.push({ index: m[1], name: m[1] });
+      }
+      return out;
+    }
+    return [];
+  } catch {
+    return [];
+  }
+}
+function autoPickMic(list = listMicDevices) {
+  if (process.platform === "darwin") {
+    const mics = list();
+    if (!mics.length) return void 0;
+    const builtin = mics.find((m) => /macbook|built.?in|internal/i.test(m.name));
+    if (builtin) return builtin.index;
+    const notPhone = mics.find((m) => !/iphone|ipad|continuity|desk view/i.test(m.name));
+    return notPhone?.index;
+  }
+  if (process.platform === "win32") {
+    const mics = list();
+    return mics[0]?.index;
+  }
+  return void 0;
+}
+function runForOutput(args) {
+  const res = spawnSync("ffmpeg", args, { encoding: "utf8", timeout: 5e3 });
+  return (res.stderr ?? "") + (res.stdout ?? "");
+}
+function errMsg(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+var RELAY_STATS_SILENCE_MS = 4e3;
+var RELAY_JOIN = { t: "voiceJoin", via: "relay" };
+var RelayVoice = class {
+  constructor(host, parts = {}, device) {
+    this.host = host;
+    this.parts = parts;
+    this.device = device;
+  }
+  host;
+  parts;
+  kind = "relay";
+  on = false;
+  // local INTENT to be in voice (we've sent voiceJoin)
+  ready = false;
+  // server ACKed our membership (voiceJoined): the ONLY truth
+  // that our frames will fan out. Survives a reconnect only
+  // after we re-send voiceJoin and get re-ACKed.
+  transmit = false;
+  // mic hot (push-to-talk latch)
+  projectId = null;
+  device;
+  tools = null;
+  retries = 0;
+  // consecutive capture restarts (flaky-mic self-heal)
+  sent = 0;
+  // frames transmitted this session (diagnostics)
+  peers = 0;
+  recv = /* @__PURE__ */ new Map();
+  // frames received per speaker sid
+  capture = null;
+  playback = null;
+  rejoinAt = 0;
+  // last self-heal re-join (throttle notInVoice storms)
+  liveAt = 0;
+  // when the mic last went hot
+  lastSentAt = 0;
+  // last frame handed to the socket
+  lastStatsAt = 0;
+  // last voiceStats from the server
+  warned = "";
+  timer = null;
+  now() {
+    return this.host.now ? this.host.now() : Date.now();
+  }
+  /** Join voice for `projectId`. 'install' = no ffmpeg at all (caller offers the installer). */
+  start(projectId, meta = {}) {
+    if (this.on) return "ok";
+    this.tools = this.parts.tools ?? this.tools ?? detectVoiceTools();
+    if (!this.tools.capture && !this.tools.playback) return "install";
+    this.playback = this.parts.playback ?? new VoicePlayback(this.tools);
+    this.capture = this.parts.capture ?? new VoiceCapture(this.tools);
+    this.on = true;
+    this.ready = false;
+    this.transmit = false;
+    this.sent = 0;
+    this.warned = "";
+    this.recv.clear();
+    this.projectId = projectId;
+    if (this.device === void 0 && this.tools.capture) this.device = (this.parts.pickMic ?? autoPickMic)();
+    vlogSession(this.now(), {
+      platform: process.platform,
+      version: meta.version ?? "",
+      name: meta.name ?? "",
+      ffmpeg: this.tools.ffmpegPath ?? "MISSING",
+      ffplay: this.tools.ffplayPath ?? "MISSING",
+      capture: this.tools.capture,
+      playback: this.tools.playback,
+      mic: this.device ?? "default"
+    });
+    this.host.send({ ...RELAY_JOIN });
+    this.host.status("voice \xB7 connecting\u2026");
+    if (this.parts.timers !== false && !this.timer) {
+      this.timer = setInterval(() => this.tick(), 1e3);
+      this.timer.unref?.();
+    }
+    return "ok";
+  }
+  /** Leave voice. `quiet` skips the status line (the caller shows its own). */
+  leave(quiet = false) {
+    if (!this.on) return;
+    vlog(this.now(), "session", "leaving voice", { sent: this.sent, recvSpeakers: this.recv.size, recvTotal: this.recvTotal() });
+    this.capture?.stop();
+    this.playback?.stopAll();
+    this.capture = null;
+    this.playback = null;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.on = false;
+    this.ready = false;
+    this.transmit = false;
+    this.projectId = null;
+    this.peers = 0;
+    this.host.setPeers([]);
+    this.host.send({ t: "voiceLeave" });
+    if (!quiet) this.host.status("voice off");
+  }
+  /** ctrl-g / talk / mute: latch the mic on or off. */
+  toggleTalk() {
+    if (!this.on || !this.capture) return;
+    if (!this.tools?.capture) {
+      this.host.status("no mic \xB7 install ffmpeg to talk");
+      return;
+    }
+    if (this.transmit) {
+      this.transmit = false;
+      this.retries = 0;
+      this.warned = "";
+      this.capture.stop();
+      this.host.status("muted \xB7 /talk (or ctrl-g) to speak");
+      return;
+    }
+    if (!this.ready) {
+      const now = this.now();
+      if (now - this.rejoinAt > 1e3) {
+        this.rejoinAt = now;
+        this.host.send({ ...RELAY_JOIN });
+      }
+    }
+    this.transmit = true;
+    this.retries = 0;
+    this.warned = "";
+    this.liveAt = this.now();
+    this.lastStatsAt = 0;
+    this.lastSentAt = 0;
+    this.host.status("\u25CF live \xB7 /mute (or ctrl-g) to stop");
+    this.startCapture();
+  }
+  /** /talk and /mute: set the mic to a state instead of flipping it, so a
+   *  typed /mute can never open the mic. */
+  setTalk(on) {
+    if (!this.on) return;
+    if (on === this.transmit) {
+      this.host.status(on ? "\u25CF live \xB7 /mute (or ctrl-g) to stop" : "muted \xB7 /talk (or ctrl-g) to speak");
+      return;
+    }
+    this.toggleTalk();
+  }
+  /** Forget detected tools (after the ffmpeg installer ran). */
+  resetTools() {
+    if (!this.on) this.tools = null;
+  }
+  /** Switch mic; applied live if the mic is hot. */
+  setDevice(device) {
+    this.device = device;
+    if (this.transmit && this.capture) {
+      this.capture.stop();
+      this.retries = 0;
+      this.startCapture();
+    }
+  }
+  /** The room socket (re)joined a project. Same project: re-assert membership
+   *  (a fresh socket is NOT in voice until we say so). Another project: voice
+   *  never follows you there, so the session ends. */
+  onJoined(projectId) {
+    if (!this.on) return;
+    if (projectId !== this.projectId) {
+      this.leave(true);
+      this.host.status("voice off \xB7 you switched projects");
+      return;
+    }
+    this.ready = false;
+    vlog(this.now(), "transport", "re-sending voiceJoin after (re)connect");
+    this.host.send({ ...RELAY_JOIN });
+  }
+  /** Voice frames and acks from the server. Returns true when handled. */
+  handle(msg) {
+    switch (msg.t) {
+      case "voiceJoined": {
+        if (!this.on) return true;
+        const first = !this.ready;
+        this.ready = true;
+        const peers = Array.isArray(msg.peers) ? msg.peers : [];
+        this.peers = peers.length;
+        this.host.setPeers(peers);
+        vlog(this.now(), "transport", "voiceJoined ACK", { peers: peers.length });
+        if (first) this.host.status(this.tools?.capture ? "voice on \xB7 /talk (or ctrl-g) to speak" : "voice on \xB7 listen only (no mic found)");
+        return true;
+      }
+      case "voiceDrop": {
+        vlog(this.now(), "transport", "voiceDrop", { reason: msg.reason });
+        if (!this.on) return true;
+        if (msg.reason === "notInVoice") {
+          if (this.host.currentProject() !== this.projectId) {
+            this.leave(true);
+            this.host.status("voice off \xB7 you left that project");
+            return true;
+          }
+          this.ready = false;
+          const now = this.now();
+          if (now - this.rejoinAt > 1e3) {
+            this.rejoinAt = now;
+            vlog(now, "transport", "auto re-join after notInVoice drop");
+            this.host.send({ ...RELAY_JOIN });
+          }
+        } else if (msg.reason === "rateCapped") {
+          this.host.status("voice \xB7 sending too fast (throttled)");
+        }
+        return true;
+      }
+      case "voiceStats": {
+        vlog(this.now(), "transport", "voiceStats", { heardFromYou: msg.heardFromYou });
+        this.lastStatsAt = this.now();
+        if (this.warned === "deaf") {
+          this.warned = "";
+          if (this.transmit) this.host.status("\u25CF live \xB7 the server hears you again");
+        }
+        return true;
+      }
+      case "voiceFrame": {
+        if (!this.on || typeof msg.sid !== "string" || typeof msg.data !== "string") return true;
+        const n = (this.recv.get(msg.sid) ?? 0) + 1;
+        this.recv.set(msg.sid, n);
+        if (n === 1) vlog(this.now(), "receive", "first frame received from a peer", { sid: msg.sid.slice(0, 8) });
+        this.playback?.feed(msg.sid, msg.data);
+        return true;
+      }
+    }
+    return false;
+  }
+  /** Watchdog, once a second while in voice. */
+  tick(now = this.now()) {
+    if (!this.on || !this.transmit) return;
+    const since = Math.max(this.liveAt, this.lastStatsAt);
+    if (now - since < RELAY_STATS_SILENCE_MS) return;
+    if (this.lastSentAt === 0 || now - this.lastSentAt > RELAY_STATS_SILENCE_MS) {
+      if (this.warned !== "silent") {
+        this.warned = "silent";
+        this.host.status("mic is live but sends no audio \xB7 /voice mics to switch");
+      }
+      return;
+    }
+    if (this.warned !== "deaf") {
+      this.warned = "deaf";
+      vlog(now, "transport", "no voiceStats while sending", { sinceMs: now - since, sent: this.sent });
+      this.host.status("mic is live but the server hears nothing \xB7 /voice to rejoin");
+    }
+  }
+  /** Status-bar indicator (connecting until the server ACKs, then live or count). */
+  indicator(peerCount) {
+    if (!this.on) return null;
+    const live = this.ready && this.transmit;
+    const label = !this.ready ? " \u25CC connecting\u2026" : this.transmit ? " \u25CF live \xB7 /mute" : ` \u25CB voice ${peerCount} \xB7 /talk`;
+    return { label, live };
+  }
+  debugLines(peerCount) {
+    return [
+      `transport: relay \xB7 on: ${this.on} \xB7 acked: ${this.ready} \xB7 live: ${this.transmit}`,
+      `tools: ffmpeg ${this.tools?.ffmpegPath ? "ok" : "MISSING"} \xB7 ffplay ${this.tools?.ffplayPath ? "ok" : "MISSING"}`,
+      `mic: ${this.device ?? "default"} \xB7 peers: ${peerCount}`,
+      `sent: ${this.sent} \xB7 received: ${this.recvTotal()} from ${this.recv.size}`,
+      `helpers: ${liveHelperPids().join(" ") || "none"}`,
+      `log: ${voiceLogPath()}`,
+      "send me that file if voice fails"
+    ];
+  }
+  /** Quit path: stop every helper now; no messages (the socket is closing). */
+  shutdown() {
+    try {
+      this.capture?.stop();
+      this.playback?.stopAll();
+    } catch {
+    }
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.capture = null;
+    this.playback = null;
+    this.on = false;
+  }
+  recvTotal() {
+    return [...this.recv.values()].reduce((a, b) => a + b, 0);
+  }
+  // (Re)start mic capture. On an unexpected ffmpeg death (a device blip: the
+  // classic macOS Continuity-mic drop) we self-heal by restarting, instead of
+  // going silently dead until the user rejoins. A successful chunk resets the
+  // retry budget so occasional blips never exhaust it.
+  startCapture() {
+    const cap = this.capture;
+    if (!cap) return;
+    cap.start({
+      device: this.device,
+      onChunk: (b64) => {
+        this.retries = 0;
+        if (!this.transmit) return;
+        this.sent++;
+        this.lastSentAt = this.now();
+        if (this.sent === 1) vlog(this.now(), "transmit", "first frame sent to server");
+        else if (this.sent % 125 === 0) vlog(this.now(), "transmit", "still sending", { frames: this.sent });
+        this.host.send({ t: "voiceFrame", data: b64 });
+      },
+      onError: (m) => {
+        if (!this.transmit) return;
+        this.retries++;
+        if (this.retries <= 6) {
+          this.host.status(`mic dropped \xB7 reconnecting ${this.retries}\u2026`);
+          const t = setTimeout(() => {
+            if (this.transmit && this.capture === cap && !cap.active) this.startCapture();
+          }, 200);
+          t.unref?.();
+        } else {
+          this.transmit = false;
+          this.retries = 0;
+          this.host.status("mic keeps dropping \xB7 /voice mics to pick another \xB7 " + m.slice(0, 30));
+        }
+      }
+    });
+  }
+};
+
+export {
+  vlog,
+  voiceLogPath,
+  spawnHelper,
+  killHelper,
+  killAllHelpers,
+  voiceSinkCommand,
+  detectVoiceTools,
+  captureArgs,
+  listMicDevices,
+  RelayVoice
+};