accelr8 3.0.0 → 3.0.1

package/dist/chunks/{chunk-SF6NNSYZ.js → chunk-GXDRLI6N.js}

@@ -36,7 +36,11 @@ var LIMITS = {
   agentQueueCap: 5,
   agentMaxDepth: 3,
   agentBudgetPerTrigger: 5,
-  agentRepeatPerChain: 2
+  agentRepeatPerChain: 2,
+  voiceFramesPerSec: 50,
+  // ~25/s real, 2x headroom; exempt from framesPerWindow
+  voiceFrameMaxB64: 4096
+  // a 40ms s16le mono chunk is ~1.7KB base64; cap slack
 };
 var DEFAULT_ACCESS = { mode: "owner", users: [] };
 function encode(msg) {

package/dist/chunks/{client-7BVK2DEW.js → client-36OXOMLV.js}

@@ -7,7 +7,7 @@ import {
   VERSION,
   decode,
   encode
-} from "./chunk-SF6NNSYZ.js";
+} from "./chunk-GXDRLI6N.js";
 import {
   DEFAULT_MODEL,
   addAccount,
@@ -25,7 +25,7 @@ import {
 // src/client.ts
 import tk from "terminal-kit";
 import { WebSocket } from "ws";
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
@@ -1173,6 +1173,291 @@ function microLine(w, engine, frame2, info) {
   return clampTo(tiny, Math.max(0, w));
 }
 
+// src/voice.ts
+import { spawn, spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+var SAMPLE_RATE = 16e3;
+var CHUNK_BYTES = 1280;
+var KILL_GRACE_MS = 300;
+var SPEAKER_IDLE_MS = 2e3;
+var DRAIN_KILL_MS = 2e3;
+var MAX_PLAYERS = 8;
+var STDERR_TAIL = 400;
+var VERIFY_MIN_BYTES = SAMPLE_RATE * 2 / 10;
+var PLAYBACK_ARGS = [
+  "-hide_banner",
+  "-loglevel",
+  "error",
+  "-nodisp",
+  "-autoexit",
+  "-f",
+  "s16le",
+  "-ar",
+  String(SAMPLE_RATE),
+  "-ch_layout",
+  "mono",
+  "-i",
+  "-"
+];
+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(path.delimiter).filter(Boolean)) {
+    for (const ext of exts) {
+      const candidate = path.join(dir, bin + ext);
+      try {
+        if (!fs.existsSync(candidate)) continue;
+        fs.accessSync(candidate, fs.constants.X_OK);
+        if (fs.statSync(candidate).isFile()) return candidate;
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
+function captureArgs(platform, device) {
+  const base = ["-hide_banner", "-loglevel", "error"];
+  const output = ["-ac", "1", "-ar", String(SAMPLE_RATE), "-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;
+  }
+  /** 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.kill("SIGINT");
+    } catch {
+    }
+    const t = setTimeout(() => {
+      try {
+        s.child.kill("SIGKILL");
+      } catch {
+      }
+    }, KILL_GRACE_MS);
+    t.unref();
+  }
+  spawnSession(opts, args, backend) {
+    let child;
+    try {
+      child = spawn(this.tools.ffmpegPath, args, { stdio: ["ignore", "pipe", "pipe"] });
+    } catch (e) {
+      queueMicrotask(() => opts.onError("mic capture failed to start: " + errMsg(e)));
+      return null;
+    }
+    const s = { child, onChunk: opts.onChunk, buf: Buffer.alloc(0), stderrTail: "", produced: false, stopped: false };
+    child.stdout?.on("data", (chunk) => {
+      if (s.stopped) return;
+      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;
+      opts.onError(e.code === "ENOENT" ? "ffmpeg not found" : "mic capture error: " + errMsg(e));
+    });
+    child.on("close", (code) => {
+      if (s.stopped || this.session !== s) return;
+      if (backend === "primary" && process.platform === "linux" && !s.produced && code !== 0) {
+        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();
+  /** ids with an active player */
+  get speakers() {
+    return [...this.players.keys()];
+  }
+  /** 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 (!this.write(p, bytes)) {
+      this.reap(speakerId, p);
+      const fresh = this.players.size < MAX_PLAYERS ? this.spawnPlayer(speakerId) : null;
+      if (!fresh || !this.write(fresh, bytes)) return;
+      p = fresh;
+    }
+    this.touch(speakerId, p);
+  }
+  /** Graceful close for one speaker (voiceStop): end stdin so ffplay
+   *  drains buffered audio and -autoexit's; SIGKILL backstop after 2s. */
+  end(speakerId) {
+    const p = this.players.get(speakerId);
+    if (!p) return;
+    this.players.delete(speakerId);
+    if (p.idleTimer) {
+      clearTimeout(p.idleTimer);
+      p.idleTimer = null;
+    }
+    try {
+      p.child.stdin?.end();
+    } catch {
+    }
+    const t = setTimeout(() => {
+      try {
+        p.child.kill("SIGKILL");
+      } catch {
+      }
+    }, DRAIN_KILL_MS);
+    t.unref();
+  }
+  /** Hard cleanup on quit: kill every player immediately. */
+  stopAll() {
+    for (const [, p] of this.players) {
+      if (p.idleTimer) {
+        clearTimeout(p.idleTimer);
+        p.idleTimer = null;
+      }
+      p.alive = false;
+      try {
+        p.child.kill("SIGKILL");
+      } catch {
+      }
+    }
+    this.players.clear();
+  }
+  spawnPlayer(speakerId) {
+    let child;
+    try {
+      child = spawn(this.tools.ffplayPath, PLAYBACK_ARGS, { stdio: ["pipe", "ignore", "ignore"] });
+    } catch {
+      return null;
+    }
+    const p = { child, alive: true, idleTimer: null };
+    child.stdin?.on("error", () => {
+      p.alive = false;
+    });
+    child.on("error", () => {
+      p.alive = false;
+      if (this.players.get(speakerId) === p) this.reap(speakerId, p);
+    });
+    child.on("close", () => {
+      p.alive = false;
+      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;
+    try {
+      p.child.kill("SIGKILL");
+    } catch {
+    }
+    if (this.players.get(speakerId) === p) this.players.delete(speakerId);
+  }
+};
+function errMsg(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+
 // src/client.ts
 var term = tk.terminal;
 var ScreenBuffer = tk.ScreenBuffer;
@@ -1243,6 +1528,65 @@ function startUpdate() {
     updating = { line: "", done: "fail", message: "could not load the updater \xB7 npm i -g accelr8@latest" };
   });
 }
+var voiceTools = null;
+var voiceOn = false;
+var voiceTransmit = false;
+var voiceCapture = null;
+var voicePlayback = null;
+function toggleVoice() {
+  if (voiceOn) return leaveVoice();
+  if (!state.project) {
+    state.status = "join a project first";
+    return;
+  }
+  voiceTools = voiceTools ?? detectVoiceTools();
+  if (!voiceTools.capture && !voiceTools.playback) {
+    state.status = "voice needs ffmpeg \xB7 install it, then /voice";
+    return;
+  }
+  voicePlayback = new VoicePlayback(voiceTools);
+  voiceCapture = new VoiceCapture(voiceTools);
+  voiceOn = true;
+  voiceTransmit = false;
+  sendMsg({ t: "voiceJoin" });
+  state.status = voiceTools.capture ? "voice on \xB7 ctrl-g to talk" : "voice on \xB7 listen only (no mic found)";
+}
+function leaveVoice() {
+  if (!voiceOn) return;
+  voiceCapture?.stop();
+  voicePlayback?.stopAll();
+  voiceCapture = null;
+  voicePlayback = null;
+  voiceOn = false;
+  voiceTransmit = false;
+  state.voicePeers = [];
+  sendMsg({ t: "voiceLeave" });
+  state.status = "voice off";
+}
+function toggleTalk() {
+  if (!voiceOn || !voiceCapture) return;
+  if (!voiceTools?.capture) {
+    state.status = "no mic \xB7 install ffmpeg to talk";
+    return;
+  }
+  if (voiceTransmit) {
+    voiceCapture.stop();
+    voiceTransmit = false;
+    state.status = "muted \xB7 ctrl-g to talk";
+  } else {
+    voiceTransmit = true;
+    state.status = "\u25CF live \xB7 ctrl-g to mute";
+    voiceCapture.start({
+      onChunk: (b64) => {
+        if (voiceTransmit) sendMsg({ t: "voiceFrame", data: b64 });
+      },
+      onError: (m) => {
+        voiceTransmit = false;
+        state.status = "mic error \xB7 " + m.slice(0, 44);
+      }
+    });
+  }
+}
 function openHelp() {
   overlay = "help";
   overlayFocus = 0;
@@ -1253,6 +1597,7 @@ function openSettings() {
 }
 function goHome() {
   if (state.project) {
+    if (voiceOn) leaveVoice();
     overlay = null;
     state.screen = "home";
     sendMsg({ t: "tab", tab: "home" });
@@ -1270,6 +1615,7 @@ var state = {
   sessions: [],
   agents: [],
   secrets: [],
+  voicePeers: [],
   status: "",
   modal: null
 };
@@ -1664,6 +2010,12 @@ function handleServer(msg) {
     case "secrets":
       state.secrets = Array.isArray(msg.list) ? msg.list : [];
       break;
+    case "voice":
+      state.voicePeers = Array.isArray(msg.peers) ? msg.peers : [];
+      break;
+    case "voiceFrame":
+      if (voiceOn) voicePlayback?.feed(msg.sid, msg.data);
+      break;
     case "error": {
       if (msg.code === "chatRate" || msg.code === "msgTooLarge") {
         const failed = msg.ref ? chatLog.failOptimistic(msg.ref) : null;
@@ -2297,7 +2649,12 @@ function renderStatusBar(rung) {
   puts(0, sy, " ".repeat(w), { bgColor: C.panel });
   const agentBit = state.agents.length ? ` \xB7 \u2726${state.agents.length} agents` : "";
   const left = state.project ? ` ${state.project.name} \xB7 ${state.project.code} \xB7 ${onlineUserIds().size} online${agentBit} ` : " no project open ";
-  puts(0, sy, left.slice(0, w - 24), { bgColor: C.panel, color: C.dim });
+  const drawn = left.slice(0, w - 24);
+  puts(0, sy, drawn, { bgColor: C.panel, color: C.dim });
+  if (voiceOn) {
+    const label = voiceTransmit ? " \u25CF live \xB7 ctrl-g mute" : ` \u25CB voice ${state.voicePeers.length} \xB7 ctrl-g talk`;
+    if (drawn.length + label.length < w - 24) puts(drawn.length, sy, label, { bgColor: C.panel, color: voiceTransmit ? C.good : C.accent, bold: voiceTransmit });
+  }
   const hint = state.modal ? "[enter] ok \xB7 [esc] cancel " : "[tab] tabs \xB7 [^C] quit ";
   puts(w - hint.length, sy, hint, { bgColor: C.panel, color: C.dim });
   if (state.status) {
@@ -2954,7 +3311,7 @@ function copyToClipboard(text, tools) {
     return;
   }
   try {
-    const p = spawn(tool, args, { stdio: ["pipe", "ignore", "ignore"] });
+    const p = spawn2(tool, args, { stdio: ["pipe", "ignore", "ignore"] });
     p.on("error", () => copyToClipboard(text, candidatesList.slice(1)));
     p.on("close", (code) => {
       state.status = code === 0 ? "copied join command" : "copy failed";
@@ -3092,6 +3449,10 @@ function slashCommand(text) {
     ghostsOff = cmd.endsWith("off");
     state.status = ghostsOff ? "draft broadcasting off" : "draft broadcasting on";
     draftDirty = true;
+  } else if (cmd === "/voice") {
+    toggleVoice();
+  } else if (cmd === "/talk" || cmd === "/mute") {
+    toggleTalk();
   } else {
     state.status = `unknown command: ${cmd.split(" ")[0]}`;
   }
@@ -3118,6 +3479,7 @@ function sendChat() {
 }
 function onKey(name) {
   if (name === "CTRL_C") return shutdown();
+  if (name === "CTRL_G" && voiceOn) return toggleTalk();
   if (boot) return skipBoot();
   const rung = rungFor(W(), H());
   if (rung === "micro" || rung === "orb") return;
@@ -3358,6 +3720,11 @@ function restoreTerminal() {
 }
 function shutdown() {
   restoreTerminal();
+  try {
+    voiceCapture?.stop();
+    voicePlayback?.stopAll();
+  } catch {
+  }
   for (const h of runningExec.values()) {
     try {
       h.abort();

package/dist/chunks/{server-ZP2DV4IO.js → server-NWTBQYCW.js}

@@ -6,7 +6,7 @@ import {
   LIMITS,
   PORT,
   PROTO
-} from "./chunk-SF6NNSYZ.js";
+} from "./chunk-GXDRLI6N.js";
 
 // src/server.ts
 import { WebSocketServer, WebSocket } from "ws";
@@ -109,7 +109,6 @@ function sanitizeText(v, maxCp) {
   return out;
 }
 var RoomCore = class {
-  // userId -> trigger times
   constructor(host) {
     this.host = host;
   }
@@ -135,6 +134,11 @@ var RoomCore = class {
   invokeWindow = /* @__PURE__ */ new Map();
   // projectId -> invocation times
   triggerWindow = /* @__PURE__ */ new Map();
+  // userId -> trigger times
+  // voice channel (realtime, loss-tolerant): sids currently in voice, and a
+  // per-sid rate window (voiceFrame is exempt from the general frame flood cap)
+  voiceSids = /* @__PURE__ */ new Set();
+  voiceWindow = /* @__PURE__ */ new Map();
   // ---------- lifecycle ----------
   async onMessage(conn, raw) {
     let msg;
@@ -145,14 +149,16 @@ var RoomCore = class {
     }
     if (!msg || typeof msg !== "object" || typeof msg.t !== "string") return;
     const now = this.host.now();
-    const win = (this.frameWindow.get(conn) ?? []).filter((t) => now - t < 1e4);
-    if (win.length >= LIMITS.framesPerWindow) {
+    if (msg.t !== "voiceFrame") {
+      const win = (this.frameWindow.get(conn) ?? []).filter((t) => now - t < 1e4);
+      if (win.length >= LIMITS.framesPerWindow) {
+        this.frameWindow.set(conn, win);
+        this.host.close(conn, 1008, "frame flood");
+        return;
+      }
+      win.push(now);
       this.frameWindow.set(conn, win);
-      this.host.close(conn, 1008, "frame flood");
-      return;
     }
-    win.push(now);
-    this.frameWindow.set(conn, win);
     try {
       await this.dispatch(conn, msg);
     } catch (e) {
@@ -322,6 +328,34 @@ var RoomCore = class {
         for (const c of this.roomConns(s.projectId)) this.host.send(c, { t: "cleared" });
         break;
       }
+      case "voiceJoin": {
+        if (!s.projectId || this.voiceSids.has(s.sid)) break;
+        this.voiceSids.add(s.sid);
+        this.broadcastVoice(s.projectId);
+        await this.systemLine(s.projectId, `${s.name} joined voice`);
+        break;
+      }
+      case "voiceLeave": {
+        if (!s.projectId || !this.voiceSids.has(s.sid)) break;
+        this.voiceSids.delete(s.sid);
+        this.voiceWindow.delete(s.sid);
+        this.broadcastVoice(s.projectId);
+        await this.systemLine(s.projectId, `${s.name} left voice`);
+        break;
+      }
+      case "voiceFrame": {
+        if (!s.projectId || !this.voiceSids.has(s.sid)) break;
+        const data = typeof msg.data === "string" ? msg.data : "";
+        if (!data || data.length > LIMITS.voiceFrameMaxB64) break;
+        if (!this.rateOk(this.voiceWindow, s.sid, LIMITS.voiceFramesPerSec, 1e3)) break;
+        for (const c of this.roomConns(s.projectId)) {
+          const peer = this.host.getSession(c);
+          if (peer && peer.sid !== s.sid && this.voiceSids.has(peer.sid)) {
+            this.host.send(c, { t: "voiceFrame", sid: s.sid, data });
+          }
+        }
+        break;
+      }
       case "chatSend": {
         if (!s.projectId) break;
         const cmid = String(msg.cmid || "").slice(0, 40);
@@ -519,12 +553,18 @@ var RoomCore = class {
       if (inv && inv.projectId === pid) void this.finalizeInvocation(inv, "partial");
       this.queues.delete(agentId);
     }
+    const wasInVoice = this.voiceSids.delete(s.sid);
+    this.voiceWindow.delete(s.sid);
     s.projectId = null;
     this.host.setSession(conn, s);
     for (const c of this.roomPeers(pid, conn)) {
       this.host.send(c, { t: "cursorGone", sid: s.sid });
     }
     this.broadcastSessions(pid);
+    if (wasInVoice) {
+      this.broadcastVoice(pid);
+      void this.systemLine(pid, `${s.name} left voice`);
+    }
     if (agentsChanged) {
       const p = this.projectsSync?.get(pid);
       if (p) this.broadcastAgents(pid);
@@ -757,6 +797,11 @@ var RoomCore = class {
     const sessions = this.sessionsFor(projectId);
     for (const c of this.roomConns(projectId)) this.host.send(c, { t: "sessions", sessions });
   }
+  /** who is in voice for this project (join/leave presence, not per-frame). */
+  broadcastVoice(projectId) {
+    const peers = this.roomConns(projectId).map((c) => this.host.getSession(c)).filter((s) => !!s && this.voiceSids.has(s.sid)).map((s) => ({ sid: s.sid, userId: s.userId, name: s.name, color: s.color }));
+    for (const c of this.roomConns(projectId)) this.host.send(c, { t: "voice", peers });
+  }
   onlineIds(projectId) {
     return [...new Set(this.sessionsFor(projectId).map((s) => s.userId))];
   }

package/dist/cli.js

@@ -3,7 +3,7 @@ import {
   DEFAULT_SERVER,
   PORT,
   VERSION
-} from "./chunks/chunk-SF6NNSYZ.js";
+} from "./chunks/chunk-GXDRLI6N.js";
 
 // src/cli.ts
 var HELP = `
@@ -52,7 +52,7 @@ async function main() {
       console.error(`invalid port: ${argVal(args, "--port")}`);
       process.exit(1);
     }
-    const { runServer } = await import("./chunks/server-ZP2DV4IO.js");
+    const { runServer } = await import("./chunks/server-NWTBQYCW.js");
     runServer(port);
     return;
   }
@@ -76,7 +76,7 @@ async function main() {
   const { cachedUpdate, refreshUpdateCache } = await import("./chunks/update-UEPNGB6Y.js");
   refreshUpdateCache();
   const update = cachedUpdate(VERSION);
-  const { runClient } = await import("./chunks/client-7BVK2DEW.js");
+  const { runClient } = await import("./chunks/client-36OXOMLV.js");
   runClient({
     name: argVal(args, "--name"),
     server: argVal(args, "--server"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "accelr8",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Collaborative ascii canvas in your terminal. Real multiplayer, live cursors, mouse-driven TUI.",
   "type": "module",
   "license": "ISC",
@@ -53,7 +53,8 @@
     "accountstest": "tsx src/accountstest.ts",
     "executortest": "tsx src/executortest.ts",
     "agentcontexttest": "tsx src/agentcontexttest.ts",
-    "chaintest": "tsx src/chaintest.ts"
+    "chaintest": "tsx src/chaintest.ts",
+    "voicetransporttest": "tsx src/voicetransporttest.ts"
   },
   "dependencies": {
     "terminal-kit": "3.1.2",