openmeet-terminal 0.1.0

package/dist/index.js

@@ -0,0 +1,2253 @@
+#!/usr/bin/env node
+
+// src/index.tsx
+import { execSync as execSync3, spawnSync } from "node:child_process";
+import { platform as platform2 } from "node:os";
+import { parseArgs } from "node:util";
+import { render } from "ink";
+
+// src/app.tsx
+import { Box as Box9 } from "ink";
+import { useEffect as useEffect6, useState as useState7 } from "react";
+
+// src/components/device-picker.tsx
+import { Box, Text, useInput } from "ink";
+import SelectInput from "ink-select-input";
+import { useEffect, useRef, useState } from "react";
+
+// src/lib/audio-test.ts
+import { spawn } from "node:child_process";
+var SAMPLE_RATE = 48e3;
+var FRAME_SIZE = 480;
+var BYTES_PER_FRAME = FRAME_SIZE * 2;
+function buildEnv(extra) {
+  if (Object.keys(extra).length === 0) return void 0;
+  return { ...process.env, ...extra };
+}
+function computeRMS(samples) {
+  let sum = 0;
+  for (let i = 0; i < samples.length; i++) {
+    sum += samples[i] * samples[i];
+  }
+  return Math.sqrt(sum / samples.length);
+}
+var MicTester = class {
+  process = null;
+  onLevel = null;
+  setLevelCallback(cb) {
+    this.onLevel = cb;
+  }
+  start(envs) {
+    this.stop();
+    const cmd = envs.recDeviceName ? "sox" : "rec";
+    const args = envs.recDeviceName ? [
+      "-q",
+      "-t",
+      "coreaudio",
+      envs.recDeviceName,
+      "-t",
+      "raw",
+      "-b",
+      "16",
+      "-e",
+      "signed-integer",
+      "-c",
+      "1",
+      "-r",
+      String(SAMPLE_RATE),
+      "-"
+    ] : ["-q", "-t", "raw", "-b", "16", "-e", "signed-integer", "-c", "1", "-r", String(SAMPLE_RATE), "-"];
+    this.process = spawn(cmd, args, {
+      env: buildEnv(envs.recExtra),
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let buffer = Buffer.alloc(0);
+    this.process.stdout?.on("data", (chunk) => {
+      buffer = Buffer.concat([buffer, chunk]);
+      while (buffer.length >= BYTES_PER_FRAME) {
+        const frameBuffer = buffer.subarray(0, BYTES_PER_FRAME);
+        buffer = buffer.subarray(BYTES_PER_FRAME);
+        const samples = new Int16Array(FRAME_SIZE);
+        for (let i = 0; i < FRAME_SIZE; i++) {
+          samples[i] = frameBuffer.readInt16LE(i * 2);
+        }
+        this.onLevel?.(computeRMS(samples));
+      }
+    });
+    this.process.on("error", () => {
+    });
+    this.process.on("close", () => {
+      this.process = null;
+    });
+  }
+  stop() {
+    if (this.process) {
+      this.process.kill();
+      this.process = null;
+    }
+  }
+};
+function playTestTone(envs) {
+  const cmd = envs.playDeviceName ? "sox" : "play";
+  const args = envs.playDeviceName ? [
+    "-q",
+    "-n",
+    "-t",
+    "coreaudio",
+    envs.playDeviceName,
+    "synth",
+    "0.5",
+    "sine",
+    "880",
+    "fade",
+    "h",
+    "0.05",
+    "0.5",
+    "0.05"
+  ] : ["-q", "-n", "synth", "0.5", "sine", "880", "fade", "h", "0.05", "0.5", "0.05"];
+  const proc = spawn(cmd, args, {
+    env: buildEnv(envs.playExtra),
+    stdio: ["ignore", "ignore", "pipe"]
+  });
+  proc.on("error", () => {
+  });
+}
+
+// src/lib/devices.ts
+import { execSync } from "node:child_process";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { dirname, join } from "node:path";
+var CONFIG_DIR = join(homedir(), ".config", "openmeet");
+var INPUT_DEVICE_FILE = join(CONFIG_DIR, "audio-input");
+var OUTPUT_DEVICE_FILE = join(CONFIG_DIR, "audio-output");
+async function listAudioDevices() {
+  const os = platform();
+  if (os === "darwin") {
+    return listMacOSDevices();
+  }
+  if (os === "linux") {
+    return listLinuxDevices();
+  }
+  return { inputs: [], outputs: [] };
+}
+function listMacOSDevices() {
+  const inputs = [];
+  const outputs = [];
+  try {
+    const json = execSync("system_profiler SPAudioDataType -json", { encoding: "utf-8" });
+    const data = JSON.parse(json);
+    const sections = data.SPAudioDataType ?? [];
+    for (const section of sections) {
+      const devices = section._items ?? [];
+      for (const device of devices) {
+        const name = device._name;
+        if (!name) continue;
+        if (device.coreaudio_device_input) {
+          inputs.push({ id: name, name, type: "input" });
+        }
+        if (device.coreaudio_device_output) {
+          outputs.push({ id: name, name, type: "output" });
+        }
+      }
+    }
+  } catch {
+  }
+  return { inputs, outputs };
+}
+function listLinuxDevices() {
+  const inputs = [];
+  const outputs = [];
+  try {
+    const sourcesRaw = execSync("pactl list sources short", { encoding: "utf-8" });
+    for (const line of sourcesRaw.trim().split("\n")) {
+      const parts = line.split("	");
+      if (parts.length >= 2) {
+        const name = parts[1];
+        inputs.push({ id: name, name, type: "input" });
+      }
+    }
+  } catch {
+  }
+  try {
+    const sinksRaw = execSync("pactl list sinks short", { encoding: "utf-8" });
+    for (const line of sinksRaw.trim().split("\n")) {
+      const parts = line.split("	");
+      if (parts.length >= 2) {
+        const name = parts[1];
+        outputs.push({ id: name, name, type: "output" });
+      }
+    }
+  } catch {
+  }
+  return { inputs, outputs };
+}
+function getSavedInputDevice() {
+  try {
+    const val = readFileSync(INPUT_DEVICE_FILE, "utf-8").trim();
+    return val || null;
+  } catch {
+    return null;
+  }
+}
+function getSavedOutputDevice() {
+  try {
+    const val = readFileSync(OUTPUT_DEVICE_FILE, "utf-8").trim();
+    return val || null;
+  } catch {
+    return null;
+  }
+}
+function saveDevicePreferences(input, output) {
+  try {
+    mkdirSync(dirname(INPUT_DEVICE_FILE), { recursive: true });
+    writeFileSync(INPUT_DEVICE_FILE, input?.id ?? "", "utf-8");
+    writeFileSync(OUTPUT_DEVICE_FILE, output?.id ?? "", "utf-8");
+  } catch {
+  }
+}
+function getDeviceEnv(input, output) {
+  const os = platform();
+  const recExtra = {};
+  const playExtra = {};
+  let recDeviceName;
+  let playDeviceName;
+  if (os === "darwin") {
+    if (input) recDeviceName = input.name;
+    if (output) playDeviceName = output.name;
+  } else if (os === "linux") {
+    if (input) recExtra.PULSE_SOURCE = input.id;
+    if (output) playExtra.PULSE_SINK = output.id;
+  }
+  return { recExtra, playExtra, recDeviceName, playDeviceName };
+}
+
+// src/components/device-picker.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var BAR_WIDTH = 30;
+var MAX_RMS = 8e3;
+function renderBar(level) {
+  const normalized = Math.min(level / MAX_RMS, 1);
+  const filled = Math.round(normalized * BAR_WIDTH);
+  return "\u2588".repeat(filled) + "\u2591".repeat(BAR_WIDTH - filled);
+}
+function barColor(level) {
+  const normalized = Math.min(level / MAX_RMS, 1);
+  if (normalized > 0.75) return "red";
+  if (normalized > 0.4) return "yellow";
+  return "green";
+}
+function DevicePicker({ inputs, outputs, loading, savedInputId, savedOutputId, onConfirm }) {
+  const [step, setStep] = useState("input");
+  const [selectedInput, setSelectedInput] = useState();
+  const [selectedOutput, setSelectedOutput] = useState();
+  const [micLevel, setMicLevel] = useState(0);
+  const testerRef = useRef(null);
+  const smoothedRef = useRef(0);
+  useEffect(() => {
+    if (step !== "test") {
+      testerRef.current?.stop();
+      testerRef.current = null;
+      smoothedRef.current = 0;
+      setMicLevel(0);
+      return;
+    }
+    const envs = getDeviceEnv(selectedInput, selectedOutput);
+    const tester = new MicTester();
+    testerRef.current = tester;
+    let lastUpdate = 0;
+    tester.setLevelCallback((rms) => {
+      smoothedRef.current = smoothedRef.current * 0.7 + rms * 0.3;
+      const now = Date.now();
+      if (now - lastUpdate > 80) {
+        lastUpdate = now;
+        setMicLevel(smoothedRef.current);
+      }
+    });
+    tester.start(envs);
+    return () => {
+      tester.stop();
+    };
+  }, [step, selectedInput, selectedOutput]);
+  useInput((input, key) => {
+    if (loading) return;
+    if (inputs.length === 0 && outputs.length === 0) {
+      if (key.return) onConfirm();
+      return;
+    }
+    if (step === "test") {
+      if (input === "t") {
+        const envs = getDeviceEnv(selectedInput, selectedOutput);
+        playTestTone(envs);
+      }
+      if (key.return) {
+        onConfirm(selectedInput, selectedOutput);
+      }
+      if (key.escape) {
+        setStep("input");
+      }
+    }
+  });
+  if (loading) {
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", alignItems: "center", justifyContent: "center", flexGrow: 1, children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, color: "blue", children: "Audio Setup" }),
+      /* @__PURE__ */ jsx(Text, { children: "Loading audio devices..." })
+    ] });
+  }
+  if (inputs.length === 0 && outputs.length === 0) {
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", alignItems: "center", justifyContent: "center", flexGrow: 1, children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, color: "blue", children: "Audio Setup" }),
+      /* @__PURE__ */ jsx(Text, {}),
+      /* @__PURE__ */ jsx(Text, { children: "No specific audio devices found." }),
+      /* @__PURE__ */ jsx(Text, { children: "Using system default devices." }),
+      /* @__PURE__ */ jsx(Text, {}),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Press [Enter] to continue" })
+    ] });
+  }
+  const inputItems = [
+    { label: "System Default", value: "__default__" },
+    ...inputs.map((d) => ({ label: d.name, value: d.id }))
+  ];
+  const outputItems = [
+    { label: "System Default", value: "__default__" },
+    ...outputs.map((d) => ({ label: d.name, value: d.id }))
+  ];
+  const savedInputIndex = savedInputId ? inputItems.findIndex((item) => item.value === savedInputId) : 0;
+  const savedOutputIndex = savedOutputId ? outputItems.findIndex((item) => item.value === savedOutputId) : 0;
+  if (step === "input") {
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, color: "blue", children: "Audio Setup" }),
+      /* @__PURE__ */ jsx(Box, { height: 1, overflow: "hidden", children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2500".repeat(200) }) }),
+      /* @__PURE__ */ jsx(Text, { bold: true, children: "Input (Microphone):" }),
+      /* @__PURE__ */ jsx(
+        SelectInput,
+        {
+          items: inputItems,
+          initialIndex: savedInputIndex >= 0 ? savedInputIndex : 0,
+          onSelect: (item) => {
+            const device = inputs.find((d) => d.id === item.value);
+            setSelectedInput(device);
+            if (outputs.length === 0) {
+              setSelectedOutput(void 0);
+              setStep("test");
+            } else {
+              setStep("output");
+            }
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx(Text, {}),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "[\u2191\u2193] navigate [Enter] select" })
+    ] });
+  }
+  if (step === "output") {
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, color: "blue", children: "Audio Setup" }),
+      /* @__PURE__ */ jsx(Box, { height: 1, overflow: "hidden", children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2500".repeat(200) }) }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        "Input: ",
+        /* @__PURE__ */ jsx(Text, { bold: true, children: selectedInput?.name ?? "System Default" })
+      ] }),
+      /* @__PURE__ */ jsx(Text, {}),
+      /* @__PURE__ */ jsx(Text, { bold: true, children: "Output (Speakers):" }),
+      /* @__PURE__ */ jsx(
+        SelectInput,
+        {
+          items: outputItems,
+          initialIndex: savedOutputIndex >= 0 ? savedOutputIndex : 0,
+          onSelect: (item) => {
+            const device = outputs.find((d) => d.id === item.value);
+            setSelectedOutput(device);
+            setStep("test");
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx(Text, {}),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "[\u2191\u2193] navigate [Enter] select" })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, color: "blue", children: "Audio Test" }),
+    /* @__PURE__ */ jsx(Box, { height: 1, overflow: "hidden", children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2500".repeat(200) }) }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      "Input: ",
+      /* @__PURE__ */ jsx(Text, { bold: true, children: selectedInput?.name ?? "System Default" })
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      "Output: ",
+      /* @__PURE__ */ jsx(Text, { bold: true, children: selectedOutput?.name ?? "System Default" })
+    ] }),
+    /* @__PURE__ */ jsx(Text, {}),
+    /* @__PURE__ */ jsx(Text, { bold: true, children: "Mic level:" }),
+    /* @__PURE__ */ jsx(Text, { children: /* @__PURE__ */ jsx(Text, { color: barColor(micLevel), children: renderBar(micLevel) }) }),
+    /* @__PURE__ */ jsx(Text, {}),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: "[t] play test tone [Enter] confirm [Esc] re-select" })
+  ] });
+}
+
+// src/components/home-screen.tsx
+import { Box as Box2, Text as Text2, useInput as useInput2 } from "ink";
+import TextInput from "ink-text-input";
+import { useEffect as useEffect2, useRef as useRef2, useState as useState2 } from "react";
+import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function HomeScreen({ emoji: emoji2, loading, error, onCreateRoom, onJoinRoom, onQuit }) {
+  const [mode, setMode] = useState2("menu");
+  const [joinCode, setJoinCode] = useState2("");
+  const [escPressed, setEscPressed] = useState2(false);
+  const escTimerRef = useRef2(null);
+  useEffect2(() => {
+    if (escPressed) {
+      escTimerRef.current = setTimeout(() => setEscPressed(false), 2e3);
+      return () => {
+        if (escTimerRef.current) clearTimeout(escTimerRef.current);
+      };
+    }
+  }, [escPressed]);
+  useInput2((input, key) => {
+    if (mode === "join" && key.escape) {
+      setMode("menu");
+      setJoinCode("");
+      return;
+    }
+    if (mode === "menu" && key.escape) {
+      if (escPressed) {
+        onQuit();
+      } else {
+        setEscPressed(true);
+      }
+      return;
+    }
+    if (mode === "menu" && !loading) {
+      if (input === "c") onCreateRoom();
+      if (input === "j") setMode("join");
+    }
+  });
+  if (mode === "join") {
+    return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", alignItems: "center", justifyContent: "center", flexGrow: 1, children: [
+      /* @__PURE__ */ jsx2(Text2, { bold: true, color: "blue", children: "Join Room" }),
+      /* @__PURE__ */ jsx2(Box2, { height: 1 }),
+      /* @__PURE__ */ jsxs2(Box2, { children: [
+        /* @__PURE__ */ jsx2(Text2, { bold: true, children: "Room code: " }),
+        /* @__PURE__ */ jsx2(
+          TextInput,
+          {
+            value: joinCode,
+            onChange: setJoinCode,
+            placeholder: "Enter room code",
+            onSubmit: (value) => {
+              if (value.trim()) onJoinRoom(value.trim());
+            }
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx2(Box2, { height: 1 }),
+      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "[Enter] join [Esc] back" })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", alignItems: "center", justifyContent: "center", flexGrow: 1, children: [
+    /* @__PURE__ */ jsxs2(Text2, { bold: true, color: "blue", children: [
+      "\u{1F3A5}",
+      " OpenMeet Terminal"
+    ] }),
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "Lightweight video conferencing" }),
+    /* @__PURE__ */ jsx2(Box2, { height: 1 }),
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      "You are ",
+      /* @__PURE__ */ jsx2(Text2, { bold: true, children: emoji2 })
+    ] }),
+    /* @__PURE__ */ jsx2(Box2, { height: 1 }),
+    loading ? /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: "Creating room..." }) : /* @__PURE__ */ jsxs2(Fragment, { children: [
+      /* @__PURE__ */ jsxs2(Text2, { children: [
+        "[",
+        /* @__PURE__ */ jsx2(Text2, { bold: true, children: "c" }),
+        "] Create Room"
+      ] }),
+      /* @__PURE__ */ jsxs2(Text2, { children: [
+        "[",
+        /* @__PURE__ */ jsx2(Text2, { bold: true, children: "j" }),
+        "] Join Room"
+      ] })
+    ] }),
+    error && /* @__PURE__ */ jsxs2(Fragment, { children: [
+      /* @__PURE__ */ jsx2(Box2, { height: 1 }),
+      /* @__PURE__ */ jsx2(Text2, { color: "red", children: error })
+    ] }),
+    /* @__PURE__ */ jsx2(Box2, { height: 1 }),
+    escPressed ? /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: "Press Esc again to quit" }) : /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "[Esc] quit" })
+  ] });
+}
+
+// src/components/room-view.tsx
+import { Box as Box8, Text as Text8, useInput as useInput3 } from "ink";
+import SelectInput2 from "ink-select-input";
+import { useEffect as useEffect5, useRef as useRef4, useState as useState6 } from "react";
+
+// src/hooks/use-room.ts
+import { useCallback, useEffect as useEffect3, useRef as useRef3, useState as useState3 } from "react";
+
+// src/lib/audio.ts
+import { execSync as execSync2, spawn as spawn2 } from "node:child_process";
+import { createWriteStream, unlinkSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join2 } from "node:path";
+import wrtc from "@roamhq/wrtc";
+var { RTCAudioSink } = wrtc.nonstandard;
+var SAMPLE_RATE2 = 48e3;
+var FRAME_SIZE2 = 480;
+var BYTES_PER_FRAME2 = FRAME_SIZE2 * 2;
+var RMS_THRESHOLD = 800;
+var SPEAKING_HOLD_MS = 300;
+function computeRMS2(samples) {
+  let sum = 0;
+  for (let i = 0; i < samples.length; i++) {
+    sum += samples[i] * samples[i];
+  }
+  return Math.sqrt(sum / samples.length);
+}
+function buildEnv2(extra) {
+  if (Object.keys(extra).length === 0) return void 0;
+  return { ...process.env, ...extra };
+}
+var AudioManager = class {
+  audioSource;
+  recExtra;
+  playExtra;
+  recDeviceName;
+  playDeviceName;
+  recProcess = null;
+  peers = /* @__PURE__ */ new Map();
+  _isMuted = false;
+  capturing = false;
+  onSpeaking = null;
+  speakingTimers = /* @__PURE__ */ new Map();
+  speakingStates = /* @__PURE__ */ new Map();
+  volumes = /* @__PURE__ */ new Map();
+  audioLevels = /* @__PURE__ */ new Map();
+  constructor(audioSource, envs) {
+    this.audioSource = audioSource;
+    this.recExtra = envs.recExtra;
+    this.playExtra = envs.playExtra;
+    this.recDeviceName = envs.recDeviceName;
+    this.playDeviceName = envs.playDeviceName;
+  }
+  setSpeakingCallback(cb) {
+    this.onSpeaking = cb;
+  }
+  updateSpeaking(id, rms) {
+    const isSpeaking = rms > RMS_THRESHOLD;
+    const wasSpeaking = this.speakingStates.get(id) ?? false;
+    if (isSpeaking) {
+      const timer = this.speakingTimers.get(id);
+      if (timer) {
+        clearTimeout(timer);
+        this.speakingTimers.delete(id);
+      }
+      if (!wasSpeaking) {
+        this.speakingStates.set(id, true);
+        this.onSpeaking?.(id, true);
+      }
+    } else if (wasSpeaking && !this.speakingTimers.has(id)) {
+      const timer = setTimeout(() => {
+        this.speakingTimers.delete(id);
+        this.speakingStates.set(id, false);
+        this.onSpeaking?.(id, false);
+      }, SPEAKING_HOLD_MS);
+      this.speakingTimers.set(id, timer);
+    }
+  }
+  get isMuted() {
+    return this._isMuted;
+  }
+  setVolume(peerId, volume) {
+    this.volumes.set(peerId, Math.max(0, Math.min(1, volume)));
+  }
+  getVolume(peerId) {
+    return this.volumes.get(peerId) ?? 1;
+  }
+  getAudioLevel(peerId) {
+    return this.audioLevels.get(peerId) ?? 0;
+  }
+  getAllAudioLevels() {
+    const levels = {};
+    for (const [peerId, level] of this.audioLevels) {
+      levels[peerId] = level;
+    }
+    return levels;
+  }
+  startCapture() {
+    if (this.capturing) return;
+    this.capturing = true;
+    const cmd = this.recDeviceName ? "sox" : "rec";
+    const args = this.recDeviceName ? [
+      "-q",
+      "-t",
+      "coreaudio",
+      this.recDeviceName,
+      "-t",
+      "raw",
+      "-b",
+      "16",
+      "-e",
+      "signed-integer",
+      "-c",
+      "1",
+      "-r",
+      String(SAMPLE_RATE2),
+      "-"
+    ] : ["-q", "-t", "raw", "-b", "16", "-e", "signed-integer", "-c", "1", "-r", String(SAMPLE_RATE2), "-"];
+    this.recProcess = spawn2(cmd, args, {
+      env: buildEnv2(this.recExtra),
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    let buffer = Buffer.alloc(0);
+    this.recProcess.stdout?.on("data", (chunk) => {
+      buffer = Buffer.concat([buffer, chunk]);
+      while (buffer.length >= BYTES_PER_FRAME2) {
+        const frameBuffer = buffer.subarray(0, BYTES_PER_FRAME2);
+        buffer = buffer.subarray(BYTES_PER_FRAME2);
+        const realSamples = new Int16Array(FRAME_SIZE2);
+        for (let i = 0; i < FRAME_SIZE2; i++) {
+          realSamples[i] = frameBuffer.readInt16LE(i * 2);
+        }
+        const localRms = computeRMS2(realSamples);
+        this.updateSpeaking("__local__", localRms);
+        this.audioLevels.set("__local__", localRms);
+        const samples = this._isMuted ? new Int16Array(FRAME_SIZE2) : realSamples;
+        this.audioSource.onData({
+          samples,
+          sampleRate: SAMPLE_RATE2,
+          bitsPerSample: 16,
+          channelCount: 1,
+          numberOfFrames: FRAME_SIZE2
+        });
+      }
+    });
+    this.recProcess.on("error", () => {
+      this.capturing = false;
+    });
+    this.recProcess.on("close", () => {
+      this.capturing = false;
+    });
+  }
+  stopCapture() {
+    if (this.recProcess) {
+      this.recProcess.kill();
+      this.recProcess = null;
+    }
+    this.capturing = false;
+  }
+  mute() {
+    this._isMuted = true;
+  }
+  unmute() {
+    this._isMuted = false;
+  }
+  toggleMute() {
+    this._isMuted = !this._isMuted;
+    return this._isMuted;
+  }
+  spawnPlay(peerId, peer, channels, rate) {
+    const fifoPath = join2(tmpdir(), `openmeet-audio-${peerId}-${Date.now()}`);
+    try {
+      execSync2(`mkfifo "${fifoPath}"`);
+    } catch {
+      return;
+    }
+    peer.fifoPath = fifoPath;
+    const cmd = this.playDeviceName ? "sox" : "play";
+    const args = this.playDeviceName ? [
+      "-q",
+      "-t",
+      "raw",
+      "-b",
+      "16",
+      "-e",
+      "signed-integer",
+      "-c",
+      channels,
+      "-r",
+      rate,
+      fifoPath,
+      "-t",
+      "coreaudio",
+      this.playDeviceName
+    ] : ["-q", "-t", "raw", "-b", "16", "-e", "signed-integer", "-c", channels, "-r", rate, fifoPath];
+    const playProcess = spawn2(cmd, args, {
+      env: buildEnv2(this.playExtra),
+      stdio: ["ignore", "ignore", "ignore"]
+    });
+    peer.playProcess = playProcess;
+    peer.fifoStream = createWriteStream(fifoPath);
+    peer.fifoStream.on("error", () => {
+    });
+    playProcess.on("error", () => {
+    });
+    playProcess.on("close", () => {
+      if (peer.fifoPath) {
+        try {
+          unlinkSync(peer.fifoPath);
+        } catch {
+        }
+        peer.fifoPath = null;
+      }
+    });
+  }
+  wireSink(peerId, peer) {
+    let spawned = false;
+    peer.sink.ondata = (data) => {
+      const samplesCopy = new Int16Array(data.samples.length);
+      samplesCopy.set(data.samples);
+      const rms = computeRMS2(samplesCopy);
+      this.updateSpeaking(peerId, rms);
+      this.audioLevels.set(peerId, rms);
+      const vol = this.volumes.get(peerId) ?? 1;
+      if (vol !== 1) {
+        for (let i = 0; i < samplesCopy.length; i++) {
+          samplesCopy[i] = Math.max(-32768, Math.min(32767, Math.round(samplesCopy[i] * vol)));
+        }
+      }
+      const buf = Buffer.from(samplesCopy.buffer, samplesCopy.byteOffset, samplesCopy.byteLength);
+      if (!spawned) {
+        spawned = true;
+        this.spawnPlay(peerId, peer, "1", String(SAMPLE_RATE2));
+      }
+      if (peer.fifoStream?.writable) {
+        peer.fifoStream.write(buf);
+      }
+    };
+  }
+  addRemotePeer(peerId, track) {
+    this.removeRemotePeer(peerId);
+    try {
+      const sink = new RTCAudioSink(track);
+      const peer = { sink, playProcess: null, fifoPath: null, fifoStream: null, track };
+      this.peers.set(peerId, peer);
+      this.wireSink(peerId, peer);
+    } catch {
+    }
+  }
+  removeRemotePeer(peerId) {
+    const peer = this.peers.get(peerId);
+    if (peer) {
+      peer.sink.stop();
+      if (peer.fifoStream) {
+        peer.fifoStream.end();
+        peer.fifoStream = null;
+      }
+      if (peer.playProcess) {
+        peer.playProcess.kill();
+      }
+      if (peer.fifoPath) {
+        try {
+          unlinkSync(peer.fifoPath);
+        } catch {
+        }
+        peer.fifoPath = null;
+      }
+      this.peers.delete(peerId);
+    }
+    const timer = this.speakingTimers.get(peerId);
+    if (timer) clearTimeout(timer);
+    this.speakingTimers.delete(peerId);
+    this.speakingStates.delete(peerId);
+    this.volumes.delete(peerId);
+    this.audioLevels.delete(peerId);
+  }
+  updateDevices(envs) {
+    this.recExtra = envs.recExtra;
+    this.playExtra = envs.playExtra;
+    this.recDeviceName = envs.recDeviceName;
+    this.playDeviceName = envs.playDeviceName;
+    if (this.capturing) {
+      this.stopCapture();
+      this.startCapture();
+    }
+    for (const [peerId, peer] of this.peers) {
+      if (peer.fifoStream) {
+        peer.fifoStream.end();
+        peer.fifoStream = null;
+      }
+      if (peer.playProcess) {
+        peer.playProcess.kill();
+        peer.playProcess = null;
+      }
+      if (peer.fifoPath) {
+        try {
+          unlinkSync(peer.fifoPath);
+        } catch {
+        }
+        peer.fifoPath = null;
+      }
+      peer.sink.stop();
+      peer.sink = new RTCAudioSink(peer.track);
+      this.wireSink(peerId, peer);
+    }
+  }
+  shutdown() {
+    this.stopCapture();
+    for (const peerId of [...this.peers.keys()]) {
+      this.removeRemotePeer(peerId);
+    }
+    const localTimer = this.speakingTimers.get("__local__");
+    if (localTimer) clearTimeout(localTimer);
+    this.speakingTimers.clear();
+    this.speakingStates.clear();
+    this.volumes.clear();
+    this.audioLevels.clear();
+  }
+};
+
+// src/lib/webrtc.ts
+import wrtc2 from "@roamhq/wrtc";
+
+// src/lib/sdp.ts
+function boostOpusQuality(sdp) {
+  return sdp.replace(/a=fmtp:(\d+) (.+)/g, (match, pt, params) => {
+    if (params.includes("minptime")) {
+      let modified = params;
+      if (!modified.includes("maxaveragebitrate")) {
+        modified += ";maxaveragebitrate=128000";
+      }
+      return `a=fmtp:${pt} ${modified}`;
+    }
+    return match;
+  });
+}
+
+// src/lib/webrtc.ts
+var { RTCPeerConnection, RTCSessionDescription, RTCIceCandidate } = wrtc2;
+var ICE_SERVERS = {
+  iceServers: [{ urls: "stun:stun.l.google.com:19302" }, { urls: "stun:stun1.l.google.com:19302" }]
+};
+function createAudioSource() {
+  const { RTCAudioSource } = wrtc2.nonstandard;
+  const source = new RTCAudioSource();
+  const track = source.createTrack();
+  return { source, track };
+}
+var PeerConnectionManager = class _PeerConnectionManager {
+  connections = /* @__PURE__ */ new Map();
+  audioTrack;
+  sendSignal;
+  myId;
+  onRemoteAudioTrack;
+  onPeerDisconnected;
+  makingOffer = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.myId = options.myId;
+    this.audioTrack = options.audioTrack;
+    this.sendSignal = options.sendSignal;
+    this.onRemoteAudioTrack = options.onRemoteAudioTrack;
+    this.onPeerDisconnected = options.onPeerDisconnected;
+  }
+  setMyId(id) {
+    this.myId = id;
+  }
+  /** Create a bare peer connection with event handlers but NO transceivers. */
+  setupPeerConnection(peerId) {
+    if (this.connections.has(peerId)) {
+      this.connections.get(peerId).close();
+    }
+    const pc = new RTCPeerConnection(ICE_SERVERS);
+    this.connections.set(peerId, pc);
+    pc.ontrack = (event) => {
+      if (event.track.kind === "audio") {
+        this.onRemoteAudioTrack(peerId, event.track);
+      }
+    };
+    pc.onicecandidate = (event) => {
+      if (event.candidate) {
+        this.sendSignal({
+          type: "ice-candidate",
+          fromId: this.myId,
+          toId: peerId,
+          candidate: event.candidate.toJSON ? event.candidate.toJSON() : event.candidate
+        });
+      }
+    };
+    pc.onconnectionstatechange = () => {
+      if (pc.connectionState === "failed") {
+        this.removeConnection(peerId);
+      }
+    };
+    return pc;
+  }
+  /** Create a peer connection WITH 3 transceivers (offerer path). */
+  createOffererConnection(peerId) {
+    const pc = this.setupPeerConnection(peerId);
+    pc.addTransceiver("audio", {
+      direction: "sendrecv",
+      sendEncodings: [{ priority: "high", networkPriority: "high" }]
+    });
+    if (this.audioTrack) {
+      pc.getTransceivers()[0].sender.replaceTrack(this.audioTrack);
+    }
+    pc.addTransceiver("video", {
+      direction: "sendrecv",
+      sendEncodings: [{ priority: "low", networkPriority: "low", maxFramerate: 30 }]
+    });
+    pc.addTransceiver("video", {
+      direction: "recvonly"
+    });
+    return pc;
+  }
+  /** Extract a plain { type, sdp } object for safe JSON serialization. */
+  static extractSdp(desc) {
+    return { type: desc.type, sdp: desc.sdp };
+  }
+  async createConnection(peerId) {
+    try {
+      const pc = this.createOffererConnection(peerId);
+      const offer = await pc.createOffer();
+      await pc.setLocalDescription({
+        ...offer,
+        sdp: boostOpusQuality(offer.sdp ?? "")
+      });
+      this.sendSignal({
+        type: "offer",
+        fromId: this.myId,
+        toId: peerId,
+        sdp: _PeerConnectionManager.extractSdp(pc.localDescription)
+      });
+    } catch {
+    }
+  }
+  async handleOffer(peerId, sdp) {
+    let pc = this.connections.get(peerId);
+    if (pc && pc.signalingState === "have-local-offer") {
+      pc.close();
+      this.connections.delete(peerId);
+      pc = void 0;
+    }
+    if (!pc) {
+      pc = this.setupPeerConnection(peerId);
+      if (this.audioTrack) {
+        pc.addTrack(this.audioTrack);
+      }
+    }
+    try {
+      await pc.setRemoteDescription(new RTCSessionDescription(sdp));
+      const answer = await pc.createAnswer();
+      let modifiedSdp = answer.sdp ?? "";
+      const mSections = modifiedSdp.split(/(?=m=)/);
+      const audioIdx = mSections.findIndex((s) => s.startsWith("m=audio"));
+      if (audioIdx >= 0 && !mSections[audioIdx].includes("a=sendrecv")) {
+        mSections[audioIdx] = mSections[audioIdx].replace(/a=recvonly|a=inactive/, "a=sendrecv");
+        modifiedSdp = mSections.join("");
+      }
+      modifiedSdp = boostOpusQuality(modifiedSdp);
+      await pc.setLocalDescription({ ...answer, sdp: modifiedSdp });
+      this.sendSignal({
+        type: "answer",
+        fromId: this.myId,
+        toId: peerId,
+        sdp: _PeerConnectionManager.extractSdp(pc.localDescription)
+      });
+    } catch {
+    }
+  }
+  async handleAnswer(peerId, sdp) {
+    const pc = this.connections.get(peerId);
+    if (!pc) return;
+    try {
+      await pc.setRemoteDescription(new RTCSessionDescription(sdp));
+    } catch {
+    }
+  }
+  async handleIceCandidate(peerId, candidate) {
+    const pc = this.connections.get(peerId);
+    if (!pc) return;
+    try {
+      await pc.addIceCandidate(new RTCIceCandidate(candidate));
+    } catch {
+    }
+  }
+  removeConnection(peerId) {
+    const pc = this.connections.get(peerId);
+    if (pc) {
+      pc.close();
+      this.connections.delete(peerId);
+      this.makingOffer.delete(peerId);
+      this.onPeerDisconnected(peerId);
+    }
+  }
+  closeAll() {
+    for (const peerId of [...this.connections.keys()]) {
+      this.removeConnection(peerId);
+    }
+  }
+  getConnection(peerId) {
+    return this.connections.get(peerId);
+  }
+  getAllPeerIds() {
+    return [...this.connections.keys()];
+  }
+};
+
+// src/lib/websocket.ts
+import WS from "ws";
+var WebSocketClient = class {
+  ws = null;
+  handlers = /* @__PURE__ */ new Set();
+  connectionHandlers = /* @__PURE__ */ new Set();
+  reconnectAttempts = 0;
+  maxReconnectAttempts = 10;
+  reconnectTimer = null;
+  url;
+  _connected = false;
+  disposed = false;
+  constructor(url) {
+    this.url = url;
+  }
+  get connected() {
+    return this._connected;
+  }
+  connect() {
+    this.ws = new WS(this.url);
+    this.ws.on("open", () => {
+      this._connected = true;
+      this.reconnectAttempts = 0;
+      for (const handler of this.connectionHandlers) {
+        handler(true);
+      }
+    });
+    this.ws.on("message", (data) => {
+      try {
+        const message = JSON.parse(data.toString());
+        for (const handler of this.handlers) {
+          handler(message);
+        }
+      } catch {
+      }
+    });
+    this.ws.on("close", () => {
+      if (this.disposed) return;
+      this._connected = false;
+      for (const handler of this.connectionHandlers) {
+        handler(false);
+      }
+      this.scheduleReconnect();
+    });
+    this.ws.on("error", () => {
+      if (this.disposed) return;
+    });
+  }
+  send(message) {
+    if (this.ws?.readyState === WS.OPEN) {
+      this.ws.send(JSON.stringify(message));
+    }
+  }
+  subscribe(handler) {
+    this.handlers.add(handler);
+    return () => this.handlers.delete(handler);
+  }
+  onConnectionChange(handler) {
+    this.connectionHandlers.add(handler);
+    return () => this.connectionHandlers.delete(handler);
+  }
+  disconnect() {
+    this.disposed = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.ws?.close();
+    this.ws = null;
+    this._connected = false;
+  }
+  scheduleReconnect() {
+    if (this.reconnectAttempts < this.maxReconnectAttempts) {
+      const delay = Math.min(1e3 * 2 ** this.reconnectAttempts, 1e4);
+      this.reconnectTimer = setTimeout(() => {
+        this.reconnectAttempts++;
+        this.connect();
+      }, delay);
+    }
+  }
+};
+
+// src/hooks/use-room.ts
+function useRoom(options) {
+  const { serverUrl, roomId, username, deviceEnvs } = options;
+  const [connected, setConnected] = useState3(false);
+  const [joined, setJoined] = useState3(false);
+  const [myId, setMyId] = useState3(null);
+  const [participants, setParticipants] = useState3([]);
+  const [chatMessages, setChatMessages] = useState3([]);
+  const [remoteMuteStates, setRemoteMuteStates] = useState3({});
+  const [remoteScreenShareStates, setRemoteScreenShareStates] = useState3({});
+  const [speakingStates, setSpeakingStates] = useState3({});
+  const [audioLevels, setAudioLevels] = useState3({});
+  const [peerVolumes, setPeerVolumes] = useState3({});
+  const [connectionStats, setConnectionStats] = useState3(null);
+  const [roomEvents, setRoomEvents] = useState3([]);
+  const [joinedAt, setJoinedAt] = useState3(null);
+  const [isMuted, setIsMuted] = useState3(false);
+  const [error, setError] = useState3(null);
+  const addEvent = useCallback((message, type) => {
+    setRoomEvents((prev) => [...prev, { timestamp: Date.now(), message, type }]);
+  }, []);
+  const resolveName = useCallback((peerId) => {
+    return participantsRef.current.find((p) => p.id === peerId)?.username ?? peerId.slice(0, 6);
+  }, []);
+  const wsRef = useRef3(null);
+  const peerManagerRef = useRef3(null);
+  const audioManagerRef = useRef3(null);
+  const myIdRef = useRef3(null);
+  const joinedRef = useRef3(false);
+  const participantsRef = useRef3([]);
+  const remoteMuteRef = useRef3({});
+  const remoteScreenRef = useRef3({});
+  const send = useCallback((msg) => {
+    wsRef.current?.send(msg);
+  }, []);
+  const sendMessage = useCallback(
+    (content) => {
+      if (!content.trim()) return;
+      send({
+        type: "chat-message",
+        id: "",
+        roomId,
+        username,
+        content: content.trim(),
+        contentType: "text",
+        timestamp: 0
+      });
+    },
+    [send, roomId, username]
+  );
+  const toggleMute = useCallback(() => {
+    const audioManager = audioManagerRef.current;
+    if (audioManager) {
+      const newMuted = audioManager.toggleMute();
+      setIsMuted(newMuted);
+      if (myIdRef.current && joinedRef.current) {
+        send({
+          type: "mute-state",
+          fromId: myIdRef.current,
+          isAudioMuted: newMuted,
+          isVideoMuted: true
+        });
+      }
+    }
+  }, [send]);
+  const setPeerVolume = useCallback((peerId, volume) => {
+    const clamped = Math.max(0, Math.min(1, volume));
+    setPeerVolumes((prev) => ({ ...prev, [peerId]: clamped }));
+    audioManagerRef.current?.setVolume(peerId, clamped);
+  }, []);
+  const updateDevices = useCallback((envs) => {
+    audioManagerRef.current?.updateDevices(envs);
+  }, []);
+  const leave = useCallback(() => {
+    audioManagerRef.current?.shutdown();
+    peerManagerRef.current?.closeAll();
+    wsRef.current?.disconnect();
+  }, []);
+  useEffect3(() => {
+    const ws = new WebSocketClient(serverUrl);
+    wsRef.current = ws;
+    const { source, track } = createAudioSource();
+    const audioManager = new AudioManager(source, deviceEnvs);
+    audioManager.setSpeakingCallback((id, speaking) => {
+      setSpeakingStates((prev) => ({ ...prev, [id]: speaking }));
+    });
+    audioManagerRef.current = audioManager;
+    const peerManager = new PeerConnectionManager({
+      myId: "",
+      audioTrack: track,
+      sendSignal: (msg) => ws.send(msg),
+      onRemoteAudioTrack: (peerId, remoteTrack) => {
+        audioManager.addRemotePeer(peerId, remoteTrack);
+      },
+      onPeerDisconnected: (peerId) => {
+        audioManager.removeRemotePeer(peerId);
+      }
+    });
+    peerManagerRef.current = peerManager;
+    const unsubMessage = ws.subscribe((msg) => {
+      switch (msg.type) {
+        case "room-joined": {
+          setJoined(true);
+          joinedRef.current = true;
+          setMyId(msg.yourId);
+          myIdRef.current = msg.yourId;
+          peerManager.setMyId(msg.yourId);
+          setParticipants(msg.participants);
+          participantsRef.current = msg.participants;
+          setJoinedAt(Date.now());
+          addEvent("You joined the room", "info");
+          for (const p of msg.participants) {
+            addEvent(`${p.username} is in the room`, "info");
+          }
+          audioManager.startCapture();
+          for (const p of msg.participants) {
+            peerManager.createConnection(p.id);
+          }
+          ws.send({
+            type: "mute-state",
+            fromId: msg.yourId,
+            isAudioMuted: false,
+            isVideoMuted: true
+          });
+          ws.send({
+            type: "screen-share-state",
+            fromId: msg.yourId,
+            isScreenSharing: false
+          });
+          break;
+        }
+        case "participant-joined": {
+          setParticipants((prev) => {
+            const next = [...prev, msg.participant];
+            participantsRef.current = next;
+            return next;
+          });
+          addEvent(`${msg.participant.username} joined`, "join");
+          break;
+        }
+        case "participant-left": {
+          const leaving = participantsRef.current.find((p) => p.id === msg.participantId);
+          if (leaving) addEvent(`${leaving.username} left`, "leave");
+          setParticipants((prev) => {
+            const next = prev.filter((p) => p.id !== msg.participantId);
+            participantsRef.current = next;
+            return next;
+          });
+          peerManager.removeConnection(msg.participantId);
+          delete remoteMuteRef.current[msg.participantId];
+          setRemoteMuteStates((prev) => {
+            const next = { ...prev };
+            delete next[msg.participantId];
+            return next;
+          });
+          delete remoteScreenRef.current[msg.participantId];
+          setRemoteScreenShareStates((prev) => {
+            const next = { ...prev };
+            delete next[msg.participantId];
+            return next;
+          });
+          break;
+        }
+        case "offer": {
+          peerManager.handleOffer(msg.fromId, msg.sdp);
+          break;
+        }
+        case "answer": {
+          peerManager.handleAnswer(msg.fromId, msg.sdp);
+          break;
+        }
+        case "ice-candidate": {
+          peerManager.handleIceCandidate(msg.fromId, msg.candidate);
+          break;
+        }
+        case "mute-state": {
+          const wasMuted = remoteMuteRef.current[msg.fromId];
+          if (wasMuted !== void 0 && wasMuted !== msg.isAudioMuted) {
+            addEvent(`${resolveName(msg.fromId)} ${msg.isAudioMuted ? "muted" : "unmuted"}`, "mute");
+          }
+          remoteMuteRef.current[msg.fromId] = msg.isAudioMuted;
+          setRemoteMuteStates((prev) => ({ ...prev, [msg.fromId]: msg.isAudioMuted }));
+          break;
+        }
+        case "screen-share-state": {
+          const wasSharing = remoteScreenRef.current[msg.fromId];
+          if (wasSharing !== void 0 && wasSharing !== msg.isScreenSharing) {
+            addEvent(
+              `${resolveName(msg.fromId)} ${msg.isScreenSharing ? "started" : "stopped"} screen sharing`,
+              "screen"
+            );
+          }
+          remoteScreenRef.current[msg.fromId] = msg.isScreenSharing;
+          setRemoteScreenShareStates((prev) => ({ ...prev, [msg.fromId]: msg.isScreenSharing }));
+          break;
+        }
+        case "chat-broadcast": {
+          setChatMessages((prev) => [...prev, msg.message]);
+          break;
+        }
+        case "error": {
+          setError(msg.message);
+          break;
+        }
+      }
+    });
+    const unsubConnection = ws.onConnectionChange((isConnected) => {
+      setConnected(isConnected);
+      if (isConnected && !joinedRef.current) {
+        ws.send({ type: "join-room", roomId, username });
+      }
+      if (!isConnected) {
+        setJoined(false);
+        joinedRef.current = false;
+        peerManager.closeAll();
+      }
+    });
+    ws.connect();
+    return () => {
+      unsubMessage();
+      unsubConnection();
+      audioManager.shutdown();
+      peerManager.closeAll();
+      ws.disconnect();
+    };
+  }, [serverUrl, roomId, username, deviceEnvs, addEvent, resolveName]);
+  useEffect3(() => {
+    if (myId && joined) {
+      send({
+        type: "mute-state",
+        fromId: myId,
+        isAudioMuted: isMuted,
+        isVideoMuted: true
+      });
+      send({
+        type: "screen-share-state",
+        fromId: myId,
+        isScreenSharing: false
+      });
+    }
+  }, [participants.length, myId, joined, send]);
+  useEffect3(() => {
+    const interval = setInterval(() => {
+      const am = audioManagerRef.current;
+      if (!am) return;
+      setAudioLevels(am.getAllAudioLevels());
+    }, 100);
+    return () => clearInterval(interval);
+  }, []);
+  useEffect3(() => {
+    let prev = null;
+    const poll = async () => {
+      const pm = peerManagerRef.current;
+      if (!pm) return;
+      const peerIds = pm.getAllPeerIds();
+      if (peerIds.length === 0) {
+        setConnectionStats(null);
+        prev = null;
+        return;
+      }
+      let totalAudioBytesSent = 0;
+      let totalAudioBytesRecv = 0;
+      let totalPacketsRecv = 0;
+      let totalPacketsLost = 0;
+      let rttSum = 0;
+      let rttCount = 0;
+      for (const peerId of peerIds) {
+        const pc = pm.getConnection(peerId);
+        if (!pc || typeof pc.getStats !== "function") continue;
+        try {
+          const report = await pc.getStats();
+          const stats = report.values ? [...report.values()] : [];
+          for (const stat of stats) {
+            if (stat.type === "outbound-rtp" && stat.kind === "audio") {
+              totalAudioBytesSent += stat.bytesSent ?? 0;
+            }
+            if (stat.type === "inbound-rtp" && stat.kind === "audio") {
+              totalAudioBytesRecv += stat.bytesReceived ?? 0;
+              totalPacketsRecv += stat.packetsReceived ?? 0;
+              totalPacketsLost += stat.packetsLost ?? 0;
+            }
+            if (stat.type === "candidate-pair" && stat.state === "succeeded") {
+              if (stat.currentRoundTripTime != null) {
+                rttSum += stat.currentRoundTripTime * 1e3;
+                rttCount++;
+              }
+            }
+            if (stat.type === "remote-inbound-rtp" && stat.roundTripTime != null) {
+              rttSum += stat.roundTripTime * 1e3;
+              rttCount++;
+            }
+          }
+        } catch {
+        }
+      }
+      if (prev) {
+        const timeDelta = (Date.now() - prev.timestamp) / 1e3;
+        if (timeDelta > 0) {
+          const sendBitrate = (totalAudioBytesSent - prev.audioBytesSent) * 8 / timeDelta / 1e3;
+          const recvBitrate = (totalAudioBytesRecv - prev.audioBytesRecv) * 8 / timeDelta / 1e3;
+          const newPacketsRecv = totalPacketsRecv - prev.packetsRecv;
+          const newPacketsLost = totalPacketsLost - prev.packetsLost;
+          const totalNew = newPacketsRecv + newPacketsLost;
+          setConnectionStats({
+            sendBitrateKbps: Math.max(0, Math.round(sendBitrate)),
+            recvBitrateKbps: Math.max(0, Math.round(recvBitrate)),
+            rttMs: rttCount > 0 ? Math.round(rttSum / rttCount) : 0,
+            packetLossPercent: totalNew > 0 ? Math.round(newPacketsLost / totalNew * 1e3) / 10 : 0
+          });
+        }
+      }
+      prev = {
+        audioBytesSent: totalAudioBytesSent,
+        audioBytesRecv: totalAudioBytesRecv,
+        packetsRecv: totalPacketsRecv,
+        packetsLost: totalPacketsLost,
+        timestamp: Date.now()
+      };
+    };
+    const interval = setInterval(poll, 2e3);
+    return () => clearInterval(interval);
+  }, []);
+  return {
+    connected,
+    joined,
+    myId,
+    participants,
+    chatMessages,
+    remoteMuteStates,
+    remoteScreenShareStates,
+    speakingStates,
+    audioLevels,
+    peerVolumes,
+    connectionStats,
+    roomEvents,
+    joinedAt,
+    isMuted,
+    error,
+    sendMessage,
+    toggleMute,
+    setPeerVolume,
+    updateDevices,
+    leave
+  };
+}
+
+// src/components/chat-input.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import TextInput2 from "ink-text-input";
+import { useState as useState4 } from "react";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function ChatInput({ focused, onSend }) {
+  const [value, setValue] = useState4("");
+  return /* @__PURE__ */ jsxs3(Box3, { paddingX: 1, children: [
+    /* @__PURE__ */ jsx3(Text3, { bold: true, color: focused ? "green" : "gray", children: "> " }),
+    focused ? /* @__PURE__ */ jsx3(
+      TextInput2,
+      {
+        value,
+        onChange: setValue,
+        onSubmit: (val) => {
+          if (val.trim()) {
+            onSend(val);
+            setValue("");
+          }
+        },
+        placeholder: "Type message..."
+      }
+    ) : /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "Press [Tab] to type a message" })
+  ] });
+}
+
+// src/components/chat-log.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var COLORS = ["red", "green", "yellow", "blue", "magenta", "cyan"];
+function usernameColor(name) {
+  let hash = 0;
+  for (const char of name) {
+    hash = (hash << 5) - hash + char.charCodeAt(0) | 0;
+  }
+  return COLORS[Math.abs(hash) % COLORS.length];
+}
+function formatTime(timestamp) {
+  const date = new Date(timestamp);
+  return `${date.getHours().toString().padStart(2, "0")}:${date.getMinutes().toString().padStart(2, "0")}`;
+}
+function ChatLog({ messages }) {
+  const visible = messages.slice(-20);
+  return /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", paddingX: 1, flexGrow: 1, justifyContent: "flex-end", children: visible.length === 0 ? /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "No messages yet" }) : visible.map((msg, i) => /* @__PURE__ */ jsxs4(Box4, { children: [
+    /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+      "[",
+      formatTime(msg.timestamp),
+      "] "
+    ] }),
+    /* @__PURE__ */ jsx4(Text4, { color: usernameColor(msg.username), bold: true, children: msg.username }),
+    /* @__PURE__ */ jsxs4(Text4, { children: [
+      ": ",
+      msg.content
+    ] })
+  ] }, msg.id || i)) });
+}
+
+// src/components/participant-list.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var BAR_COUNT = 20;
+var MAX_RMS2 = 8e3;
+function vuColor(level, volume) {
+  const normalized = Math.min(level / MAX_RMS2, 1) * volume;
+  if (normalized > 0.75) return "red";
+  if (normalized > 0.4) return "yellow";
+  return "green";
+}
+function VuMeter({ level, volume = 1 }) {
+  const activeBars = Math.round(volume * BAR_COUNT);
+  const normalized = Math.min(level / MAX_RMS2, 1);
+  const filled = Math.round(normalized * activeBars);
+  const emptyActive = activeBars - filled;
+  const inactive = BAR_COUNT - activeBars;
+  const color = vuColor(level, volume);
+  return /* @__PURE__ */ jsxs5(Text5, { children: [
+    /* @__PURE__ */ jsx5(Text5, { color, children: "\u2588".repeat(filled) }),
+    /* @__PURE__ */ jsx5(Text5, { color: "green", children: "\u2591".repeat(emptyActive) }),
+    /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "\u2591".repeat(inactive) })
+  ] });
+}
+function ParticipantList({
+  participants,
+  username,
+  isMuted,
+  remoteMuteStates,
+  remoteScreenShareStates,
+  speakingStates,
+  audioLevels,
+  peerVolumes,
+  selectedPeerIdx
+}) {
+  const localSpeaking = speakingStates.__local__ && !isMuted;
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Participants:" }),
+    /* @__PURE__ */ jsxs5(Box5, { paddingLeft: 1, justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsxs5(Text5, { children: [
+        /* @__PURE__ */ jsx5(Text5, { color: localSpeaking ? "green" : void 0, children: localSpeaking ? "\u25CF " : "\u25CB " }),
+        /* @__PURE__ */ jsxs5(Text5, { children: [
+          username,
+          " (you)"
+        ] }),
+        isMuted && /* @__PURE__ */ jsx5(Text5, { color: "yellow", children: " [muted]" })
+      ] }),
+      /* @__PURE__ */ jsx5(VuMeter, { level: audioLevels.__local__ ?? 0 })
+    ] }),
+    participants.map((p, idx) => {
+      const speaking = speakingStates[p.id] && !remoteMuteStates[p.id];
+      const isSelected = idx === selectedPeerIdx;
+      const level = audioLevels[p.id] ?? 0;
+      const vol = peerVolumes[p.id] ?? 1;
+      return /* @__PURE__ */ jsxs5(Box5, { paddingLeft: 1, justifyContent: "space-between", children: [
+        /* @__PURE__ */ jsxs5(Text5, { children: [
+          /* @__PURE__ */ jsx5(Text5, { color: speaking ? "green" : void 0, children: speaking ? "\u25CF " : "\u25CB " }),
+          /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: isSelected ? "> " : "  " }),
+          /* @__PURE__ */ jsx5(Text5, { children: p.username }),
+          remoteMuteStates[p.id] && /* @__PURE__ */ jsx5(Text5, { color: "yellow", children: " [muted]" }),
+          remoteScreenShareStates[p.id] && /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: " [scr]" })
+        ] }),
+        /* @__PURE__ */ jsxs5(Box5, { children: [
+          /* @__PURE__ */ jsxs5(Text5, { children: [
+            "vol:",
+            Math.round(vol * 100).toString().padStart(3),
+            "%",
+            " "
+          ] }),
+          /* @__PURE__ */ jsx5(VuMeter, { level, volume: vol })
+        ] })
+      ] }, p.id);
+    })
+  ] });
+}
+
+// src/components/room-log.tsx
+import { Box as Box6, Text as Text6 } from "ink";
+import { useEffect as useEffect4, useState as useState5 } from "react";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+var EVENT_COLORS = {
+  join: "green",
+  leave: "red",
+  screen: "cyan",
+  mute: "yellow",
+  info: "blue"
+};
+var EVENT_ICONS = {
+  join: "+",
+  leave: "-",
+  screen: "\u25A3",
+  mute: "\u266A",
+  info: "\xB7"
+};
+function formatTime2(timestamp) {
+  const d = new Date(timestamp);
+  return `${d.getHours().toString().padStart(2, "0")}:${d.getMinutes().toString().padStart(2, "0")}:${d.getSeconds().toString().padStart(2, "0")}`;
+}
+function formatElapsed(ms) {
+  const totalSec = Math.floor(ms / 1e3);
+  const h = Math.floor(totalSec / 3600);
+  const m = Math.floor(totalSec % 3600 / 60);
+  const s = totalSec % 60;
+  if (h > 0) return `${h}h${m.toString().padStart(2, "0")}m`;
+  if (m > 0) return `${m}m${s.toString().padStart(2, "0")}s`;
+  return `${s}s`;
+}
+function RoomLog({ events, joinedAt }) {
+  const [elapsed, setElapsed] = useState5("");
+  useEffect4(() => {
+    if (!joinedAt) return;
+    const update = () => setElapsed(formatElapsed(Date.now() - joinedAt));
+    update();
+    const interval = setInterval(update, 1e3);
+    return () => clearInterval(interval);
+  }, [joinedAt]);
+  const visible = events.slice(-30);
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
+    /* @__PURE__ */ jsxs6(Box6, { justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsx6(Text6, { bold: true, children: "Room Log" }),
+      elapsed && /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+        "in room: ",
+        elapsed
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx6(Box6, { flexDirection: "column", flexGrow: 1, justifyContent: "flex-end", children: visible.length === 0 ? /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "No events yet" }) : visible.map((event) => /* @__PURE__ */ jsxs6(Box6, { children: [
+      /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+        "[",
+        formatTime2(event.timestamp),
+        "] "
+      ] }),
+      /* @__PURE__ */ jsxs6(Text6, { color: EVENT_COLORS[event.type], children: [
+        EVENT_ICONS[event.type],
+        " ",
+        event.message
+      ] })
+    ] }, `${event.timestamp}-${event.message}`)) })
+  ] });
+}
+
+// src/components/status-bar.tsx
+import { Box as Box7, Text as Text7 } from "ink";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+function StatusBar({ isMuted, connected }) {
+  return /* @__PURE__ */ jsxs7(Box7, { paddingX: 1, justifyContent: "space-between", children: [
+    /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+      "[Esc] Leave [Tab] Chat [m] ",
+      isMuted ? "unmute" : "mute",
+      " [d] Devices [\u2191\u2193] Select [[-]/[+]] Vol"
+    ] }),
+    /* @__PURE__ */ jsx7(Text7, { color: connected ? "green" : "red", children: connected ? "\u25CF Connected" : "\u25CB Disconnected" })
+  ] });
+}
+
+// src/components/room-view.tsx
+import { Fragment as Fragment2, jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+var BAR_WIDTH2 = 30;
+var MAX_RMS3 = 8e3;
+function renderBar2(level) {
+  const normalized = Math.min(level / MAX_RMS3, 1);
+  const filled = Math.round(normalized * BAR_WIDTH2);
+  return "\u2588".repeat(filled) + "\u2591".repeat(BAR_WIDTH2 - filled);
+}
+function barColor2(level) {
+  const normalized = Math.min(level / MAX_RMS3, 1);
+  if (normalized > 0.75) return "red";
+  if (normalized > 0.4) return "yellow";
+  return "green";
+}
+function RoomView({ serverUrl, roomId, username, deviceEnvs, onBack }) {
+  const room = useRoom({ serverUrl, roomId, username, deviceEnvs });
+  const [inputFocused, setInputFocused] = useState6(true);
+  const [deviceStep, setDeviceStep] = useState6(null);
+  const [devices, setDevices] = useState6({
+    inputs: [],
+    outputs: []
+  });
+  const [selectedInput, setSelectedInput] = useState6();
+  const [selectedOutput, setSelectedOutput] = useState6();
+  const [micLevel, setMicLevel] = useState6(0);
+  const [selectedPeerIdx, setSelectedPeerIdx] = useState6(0);
+  const testerRef = useRef4(null);
+  const smoothedRef = useRef4(0);
+  useEffect5(() => {
+    if (deviceStep === "loading") {
+      listAudioDevices().then((d) => {
+        setDevices(d);
+        setDeviceStep(d.inputs.length > 0 ? "input" : d.outputs.length > 0 ? "output" : null);
+      });
+    }
+  }, [deviceStep]);
+  useEffect5(() => {
+    if (deviceStep !== "test") {
+      testerRef.current?.stop();
+      testerRef.current = null;
+      smoothedRef.current = 0;
+      setMicLevel(0);
+      return;
+    }
+    const envs = getDeviceEnv(selectedInput, selectedOutput);
+    const tester = new MicTester();
+    testerRef.current = tester;
+    let lastUpdate = 0;
+    tester.setLevelCallback((rms) => {
+      smoothedRef.current = smoothedRef.current * 0.7 + rms * 0.3;
+      const now = Date.now();
+      if (now - lastUpdate > 80) {
+        lastUpdate = now;
+        setMicLevel(smoothedRef.current);
+      }
+    });
+    tester.start(envs);
+    return () => {
+      tester.stop();
+    };
+  }, [deviceStep, selectedInput, selectedOutput]);
+  const applyDevices = (newInput, newOutput) => {
+    saveDevicePreferences(newInput, newOutput);
+    const newEnvs = getDeviceEnv(newInput, newOutput);
+    room.updateDevices(newEnvs);
+    setDeviceStep(null);
+  };
+  useInput3((input, key) => {
+    if (deviceStep && deviceStep !== "loading") {
+      if (deviceStep === "test") {
+        if (input === "t") {
+          const envs = getDeviceEnv(selectedInput, selectedOutput);
+          playTestTone(envs);
+          return;
+        }
+        if (key.return) {
+          applyDevices(selectedInput, selectedOutput);
+          return;
+        }
+        if (key.escape) {
+          setDeviceStep("input");
+          return;
+        }
+        return;
+      }
+      if (key.escape) {
+        setDeviceStep(null);
+      }
+      return;
+    }
+    if (key.escape) {
+      room.leave();
+      onBack();
+      return;
+    }
+    if (key.tab) {
+      setInputFocused((prev) => !prev);
+      return;
+    }
+    if (!inputFocused) {
+      if (input === "m") {
+        room.toggleMute();
+      }
+      if (input === "d") {
+        setDeviceStep("loading");
+      }
+      if (key.upArrow) {
+        setSelectedPeerIdx((prev) => Math.max(0, prev - 1));
+      }
+      if (key.downArrow) {
+        setSelectedPeerIdx((prev) => Math.min(room.participants.length - 1, prev + 1));
+      }
+      if (input === "[" || input === "-") {
+        const peerId = room.participants[selectedPeerIdx]?.id;
+        if (peerId) {
+          const current = room.peerVolumes[peerId] ?? 1;
+          room.setPeerVolume(peerId, Math.round((current - 0.02) * 100) / 100);
+        }
+      }
+      if (input === "]" || input === "=" || input === "+") {
+        const peerId = room.participants[selectedPeerIdx]?.id;
+        if (peerId) {
+          const current = room.peerVolumes[peerId] ?? 1;
+          room.setPeerVolume(peerId, Math.round((current + 0.02) * 100) / 100);
+        }
+      }
+    }
+  });
+  if (deviceStep && deviceStep !== "loading") {
+    if (deviceStep === "test") {
+      return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", flexGrow: 1, paddingX: 1, paddingY: 1, children: [
+        /* @__PURE__ */ jsx8(Text8, { bold: true, color: "blue", children: "Audio Test" }),
+        /* @__PURE__ */ jsx8(Box8, { height: 1, overflow: "hidden", children: /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "\u2500".repeat(200) }) }),
+        /* @__PURE__ */ jsxs8(Text8, { children: [
+          "Input: ",
+          /* @__PURE__ */ jsx8(Text8, { bold: true, children: selectedInput?.name ?? "System Default" })
+        ] }),
+        /* @__PURE__ */ jsxs8(Text8, { children: [
+          "Output: ",
+          /* @__PURE__ */ jsx8(Text8, { bold: true, children: selectedOutput?.name ?? "System Default" })
+        ] }),
+        /* @__PURE__ */ jsx8(Text8, {}),
+        /* @__PURE__ */ jsx8(Text8, { bold: true, children: "Mic level:" }),
+        /* @__PURE__ */ jsx8(Text8, { children: /* @__PURE__ */ jsx8(Text8, { color: barColor2(micLevel), children: renderBar2(micLevel) }) }),
+        /* @__PURE__ */ jsx8(Text8, {}),
+        /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "[t] play test tone [Enter] confirm [Esc] re-select" })
+      ] });
+    }
+    const inputItems = [
+      { label: "System Default", value: "__default__" },
+      ...devices.inputs.map((d) => ({ label: d.name, value: d.id }))
+    ];
+    const outputItems = [
+      { label: "System Default", value: "__default__" },
+      ...devices.outputs.map((d) => ({ label: d.name, value: d.id }))
+    ];
+    if (deviceStep === "input") {
+      return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", flexGrow: 1, paddingX: 1, paddingY: 1, children: [
+        /* @__PURE__ */ jsx8(Text8, { bold: true, color: "blue", children: "Change Audio Device" }),
+        /* @__PURE__ */ jsx8(Box8, { height: 1, overflow: "hidden", children: /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "\u2500".repeat(200) }) }),
+        /* @__PURE__ */ jsx8(Text8, { bold: true, children: "Input (Microphone):" }),
+        /* @__PURE__ */ jsx8(
+          SelectInput2,
+          {
+            items: inputItems,
+            onSelect: (item) => {
+              const device = devices.inputs.find((d) => d.id === item.value);
+              setSelectedInput(device);
+              if (devices.outputs.length === 0) {
+                setSelectedOutput(void 0);
+                setDeviceStep("test");
+              } else {
+                setDeviceStep("output");
+              }
+            }
+          }
+        ),
+        /* @__PURE__ */ jsx8(Text8, {}),
+        /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "[\u2191\u2193] navigate [Enter] select [Esc] cancel" })
+      ] });
+    }
+    return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", flexGrow: 1, paddingX: 1, paddingY: 1, children: [
+      /* @__PURE__ */ jsx8(Text8, { bold: true, color: "blue", children: "Change Audio Device" }),
+      /* @__PURE__ */ jsx8(Box8, { height: 1, overflow: "hidden", children: /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "\u2500".repeat(200) }) }),
+      /* @__PURE__ */ jsxs8(Text8, { children: [
+        "Input: ",
+        /* @__PURE__ */ jsx8(Text8, { bold: true, children: selectedInput?.name ?? "System Default" })
+      ] }),
+      /* @__PURE__ */ jsx8(Text8, {}),
+      /* @__PURE__ */ jsx8(Text8, { bold: true, children: "Output (Speakers):" }),
+      /* @__PURE__ */ jsx8(
+        SelectInput2,
+        {
+          items: outputItems,
+          onSelect: (item) => {
+            const device = devices.outputs.find((d) => d.id === item.value);
+            setSelectedOutput(device);
+            setDeviceStep("test");
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx8(Text8, {}),
+      /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "[\u2191\u2193] navigate [Enter] select [Esc] cancel" })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", flexGrow: 1, children: [
+    /* @__PURE__ */ jsxs8(Box8, { paddingX: 1, gap: 1, justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsxs8(Box8, { gap: 1, children: [
+        /* @__PURE__ */ jsx8(Text8, { bold: true, color: "blue", children: "OpenMeet" }),
+        /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "|" }),
+        /* @__PURE__ */ jsxs8(Text8, { children: [
+          "Room: ",
+          /* @__PURE__ */ jsx8(Text8, { bold: true, children: roomId })
+        ] }),
+        /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "|" }),
+        /* @__PURE__ */ jsxs8(Text8, { children: [
+          room.participants.length + 1,
+          "p"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs8(Box8, { gap: 1, children: [
+        room.connectionStats ? /* @__PURE__ */ jsxs8(Fragment2, { children: [
+          /* @__PURE__ */ jsxs8(Text8, { color: "green", children: [
+            "\u2191",
+            room.connectionStats.sendBitrateKbps,
+            "k"
+          ] }),
+          /* @__PURE__ */ jsxs8(Text8, { color: "cyan", children: [
+            "\u2193",
+            room.connectionStats.recvBitrateKbps,
+            "k"
+          ] }),
+          /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "|" }),
+          /* @__PURE__ */ jsxs8(
+            Text8,
+            {
+              color: room.connectionStats.rttMs > 150 ? "red" : room.connectionStats.rttMs > 80 ? "yellow" : void 0,
+              children: [
+                "RTT:",
+                room.connectionStats.rttMs,
+                "ms"
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxs8(
+            Text8,
+            {
+              color: room.connectionStats.packetLossPercent > 5 ? "red" : room.connectionStats.packetLossPercent > 1 ? "yellow" : void 0,
+              children: [
+                "Loss:",
+                room.connectionStats.packetLossPercent,
+                "%"
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "|" })
+        ] }) : null,
+        /* @__PURE__ */ jsx8(Text8, { color: room.connected ? "green" : "red", children: "\u25CF" })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx8(Box8, { height: 1, overflow: "hidden", children: /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "\u2500".repeat(200) }) }),
+    deviceStep === "loading" && /* @__PURE__ */ jsx8(Box8, { paddingX: 1, children: /* @__PURE__ */ jsx8(Text8, { color: "yellow", children: "Loading audio devices..." }) }),
+    /* @__PURE__ */ jsx8(
+      ParticipantList,
+      {
+        participants: room.participants,
+        myId: room.myId,
+        username,
+        isMuted: room.isMuted,
+        remoteMuteStates: room.remoteMuteStates,
+        remoteScreenShareStates: room.remoteScreenShareStates,
+        speakingStates: room.speakingStates,
+        audioLevels: room.audioLevels,
+        peerVolumes: room.peerVolumes,
+        selectedPeerIdx
+      }
+    ),
+    /* @__PURE__ */ jsx8(Box8, { height: 1, overflow: "hidden", children: /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "\u2500".repeat(200) }) }),
+    /* @__PURE__ */ jsxs8(Box8, { flexGrow: 1, flexBasis: 0, overflow: "hidden", children: [
+      /* @__PURE__ */ jsx8(Box8, { flexDirection: "column", flexGrow: 1, flexBasis: "50%", children: /* @__PURE__ */ jsx8(ChatLog, { messages: room.chatMessages }) }),
+      /* @__PURE__ */ jsx8(
+        Box8,
+        {
+          flexDirection: "column",
+          flexGrow: 1,
+          flexBasis: "50%",
+          borderStyle: "single",
+          borderRight: false,
+          borderTop: false,
+          borderBottom: false,
+          borderDimColor: true,
+          children: /* @__PURE__ */ jsx8(RoomLog, { events: room.roomEvents, joinedAt: room.joinedAt })
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx8(Box8, { height: 1, overflow: "hidden", children: /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "\u2500".repeat(200) }) }),
+    /* @__PURE__ */ jsx8(ChatInput, { focused: inputFocused, onSend: room.sendMessage }),
+    /* @__PURE__ */ jsx8(Box8, { height: 1, overflow: "hidden", children: /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "\u2500".repeat(200) }) }),
+    /* @__PURE__ */ jsx8(StatusBar, { isMuted: room.isMuted, connected: room.connected }),
+    room.error && /* @__PURE__ */ jsx8(Box8, { paddingX: 1, children: /* @__PURE__ */ jsxs8(Text8, { color: "red", children: [
+      "Error: ",
+      room.error
+    ] }) })
+  ] });
+}
+
+// src/app.tsx
+import { jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
+function wsToHttpUrl(wsUrl) {
+  const url = new URL(wsUrl);
+  url.protocol = url.protocol === "wss:" ? "https:" : "http:";
+  url.pathname = "";
+  return url.origin;
+}
+function FullScreen({ children }) {
+  const [size, setSize] = useState7({
+    columns: process.stdout.columns || 80,
+    rows: process.stdout.rows || 24
+  });
+  useEffect6(() => {
+    const onResize = () => {
+      setSize({
+        columns: process.stdout.columns || 80,
+        rows: process.stdout.rows || 24
+      });
+    };
+    process.stdout.on("resize", onResize);
+    return () => {
+      process.stdout.off("resize", onResize);
+    };
+  }, []);
+  return /* @__PURE__ */ jsx9(
+    Box9,
+    {
+      width: size.columns,
+      height: size.rows,
+      borderStyle: "round",
+      borderColor: "blue",
+      flexDirection: "column",
+      overflow: "hidden",
+      children
+    }
+  );
+}
+function App({ serverUrl, emoji: emoji2, initialRoom, inputDevice, outputDevice }) {
+  const [screen, setScreen] = useState7(initialRoom ? "devices" : "home");
+  const [roomId, setRoomId] = useState7(initialRoom ?? "");
+  const [devices, setDevices] = useState7({
+    inputs: [],
+    outputs: []
+  });
+  const [devicesLoaded, setDevicesLoaded] = useState7(false);
+  const [deviceEnvs, setDeviceEnvs] = useState7({ recExtra: {}, playExtra: {} });
+  const [creating, setCreating] = useState7(false);
+  const [homeError, setHomeError] = useState7(null);
+  const [savedInputId] = useState7(() => getSavedInputDevice());
+  const [savedOutputId] = useState7(() => getSavedOutputDevice());
+  useEffect6(() => {
+    listAudioDevices().then((d) => {
+      setDevices(d);
+      setDevicesLoaded(true);
+    });
+  }, []);
+  useEffect6(() => {
+    if (screen !== "devices" || !devicesLoaded) return;
+    if (inputDevice && outputDevice) {
+      const input = devices.inputs.find((d) => d.name === inputDevice);
+      const output = devices.outputs.find((d) => d.name === outputDevice);
+      setDeviceEnvs(getDeviceEnv(input, output));
+      setScreen("room");
+      return;
+    }
+    if (savedInputId !== null || savedOutputId !== null) {
+      const inputStillExists = !savedInputId || devices.inputs.some((d) => d.id === savedInputId);
+      const outputStillExists = !savedOutputId || devices.outputs.some((d) => d.id === savedOutputId);
+      if (inputStillExists && outputStillExists) {
+        const input = savedInputId ? devices.inputs.find((d) => d.id === savedInputId) : void 0;
+        const output = savedOutputId ? devices.outputs.find((d) => d.id === savedOutputId) : void 0;
+        setDeviceEnvs(getDeviceEnv(input, output));
+        setScreen("room");
+      }
+    }
+  }, [screen, inputDevice, outputDevice, devices, devicesLoaded, savedInputId, savedOutputId]);
+  const handleCreateRoom = async () => {
+    setCreating(true);
+    setHomeError(null);
+    try {
+      const httpUrl = wsToHttpUrl(serverUrl);
+      const res = await fetch(`${httpUrl}/api/rooms`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ name: "Room" })
+      });
+      if (res.ok) {
+        const room = await res.json();
+        setRoomId(room.id);
+        setScreen("devices");
+      } else {
+        setHomeError("Failed to create room");
+      }
+    } catch {
+      setHomeError("Cannot reach server");
+    } finally {
+      setCreating(false);
+    }
+  };
+  const handleJoinRoom = (id) => {
+    setRoomId(id);
+    setScreen("devices");
+  };
+  return /* @__PURE__ */ jsxs9(FullScreen, { children: [
+    screen === "home" && /* @__PURE__ */ jsx9(
+      HomeScreen,
+      {
+        emoji: emoji2,
+        loading: creating,
+        error: homeError,
+        onCreateRoom: handleCreateRoom,
+        onJoinRoom: handleJoinRoom,
+        onQuit: () => process.exit(0)
+      }
+    ),
+    screen === "devices" && /* @__PURE__ */ jsx9(
+      DevicePicker,
+      {
+        inputs: devices.inputs,
+        outputs: devices.outputs,
+        loading: !devicesLoaded,
+        savedInputId,
+        savedOutputId,
+        onConfirm: (input, output) => {
+          saveDevicePreferences(input, output);
+          setDeviceEnvs(getDeviceEnv(input, output));
+          setScreen("room");
+        }
+      }
+    ),
+    screen === "room" && /* @__PURE__ */ jsx9(
+      RoomView,
+      {
+        serverUrl,
+        roomId,
+        username: emoji2,
+        deviceEnvs,
+        onBack: () => setScreen("home")
+      }
+    )
+  ] });
+}
+
+// src/lib/emoji.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname2, join as join3 } from "node:path";
+var EMOJI_FILE = join3(homedir2(), ".config", "openmeet", "emoji");
+var EMOJI_POOL = [
+  // Animals
+  "\u{1F436}",
+  "\u{1F431}",
+  "\u{1F43B}",
+  "\u{1F43C}",
+  "\u{1F428}",
+  "\u{1F435}",
+  "\u{1F981}",
+  "\u{1F984}",
+  "\u{1F98A}",
+  "\u{1F989}",
+  "\u{1F427}",
+  "\u{1F40A}",
+  "\u{1F422}",
+  "\u{1F41D}",
+  "\u{1F419}",
+  "\u{1F433}",
+  "\u{1F418}",
+  "\u{1F992}",
+  "\u{1F98E}",
+  "\u{1F40C}",
+  "\u{1F99C}",
+  "\u{1F9A9}",
+  "\u{1F40B}",
+  "\u{1F99A}",
+  // Fruits
+  "\u{1F34E}",
+  "\u{1F34A}",
+  "\u{1F34B}",
+  "\u{1F349}",
+  "\u{1F353}",
+  "\u{1F351}",
+  "\u{1F352}",
+  "\u{1F347}",
+  "\u{1F34D}",
+  "\u{1F95D}",
+  "\u{1F951}",
+  "\u{1FAD0}",
+  "\u{1F965}",
+  "\u{1F346}",
+  "\u{1F955}",
+  // Funny faces
+  "\u{1F92A}",
+  "\u{1F913}",
+  "\u{1F978}",
+  "\u{1F920}",
+  "\u{1F47B}",
+  "\u{1F916}",
+  "\u{1F47D}",
+  "\u{1F9B8}",
+  "\u{1F9DB}",
+  "\u{1F9D9}",
+  "\u{1F9DA}",
+  "\u{1F9DC}",
+  "\u{1F9DE}",
+  "\u{1F383}",
+  "\u{1F47E}",
+  "\u{1F479}"
+];
+function getOrCreateEmoji() {
+  try {
+    const stored = readFileSync2(EMOJI_FILE, "utf-8").trim();
+    if (stored) return stored;
+  } catch {
+  }
+  const emoji2 = EMOJI_POOL[Math.floor(Math.random() * EMOJI_POOL.length)];
+  try {
+    mkdirSync2(dirname2(EMOJI_FILE), { recursive: true });
+    writeFileSync2(EMOJI_FILE, emoji2, "utf-8");
+  } catch {
+  }
+  return emoji2;
+}
+
+// src/index.tsx
+import { jsx as jsx10 } from "react/jsx-runtime";
+function checkSox() {
+  try {
+    execSync3("which rec", { stdio: "ignore" });
+    execSync3("which play", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function checkMicPermission() {
+  if (platform2() !== "darwin") return "unknown";
+  try {
+    const result = spawnSync(
+      "rec",
+      ["-q", "-t", "raw", "-b", "16", "-e", "signed-integer", "-c", "1", "-r", "48000", "-", "trim", "0", "0.1"],
+      {
+        timeout: 5e3,
+        stdio: ["ignore", "pipe", "pipe"]
+      }
+    );
+    if (result.error) return "unknown";
+    if (result.stdout && result.stdout.length > 0) return "granted";
+    const stderr = result.stderr?.toString() ?? "";
+    if (stderr.includes("permission") || stderr.includes("not authorized") || result.status !== 0) {
+      return "denied";
+    }
+    return "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+var { values } = parseArgs({
+  options: {
+    server: { type: "string", default: "ws://localhost:3001/ws" },
+    room: { type: "string" },
+    "input-device": { type: "string" },
+    "output-device": { type: "string" },
+    help: { type: "boolean", short: "h" }
+  }
+});
+if (values.help) {
+  process.stdout.write(`Usage: openmeet [options]
+
+  --server <url>         WebSocket URL (default: ws://localhost:3001/ws)
+  --room <id>            Room ID to join
+  --input-device <name>  Input device name (skip device picker)
+  --output-device <name> Output device name (skip device picker)
+  -h, --help             Show help
+`);
+  process.exit(0);
+}
+if (!checkSox()) {
+  process.stderr.write(`Error: sox is required but not found on PATH.
+
+Install sox:
+  macOS:   brew install sox
+  Ubuntu:  sudo apt install sox
+  Fedora:  sudo dnf install sox
+`);
+  process.exit(1);
+}
+var micStatus = checkMicPermission();
+if (micStatus === "denied") {
+  process.stderr.write(`Error: Microphone access denied.
+
+Your terminal app needs microphone permission on macOS:
+  1. Open System Settings > Privacy & Security > Microphone
+  2. Enable the toggle for your terminal app (Terminal, iTerm2, Warp, etc.)
+  3. Restart the terminal and try again
+`);
+  process.exit(1);
+}
+var emoji = getOrCreateEmoji();
+console.log = () => {
+};
+console.error = () => {
+};
+console.warn = () => {
+};
+process.stdout.write("\x1B[?1049h");
+process.on("exit", () => {
+  process.stdout.write("\x1B[?1049l");
+});
+render(
+  /* @__PURE__ */ jsx10(
+    App,
+    {
+      serverUrl: values.server ?? "ws://localhost:3001/ws",
+      emoji,
+      initialRoom: values.room,
+      inputDevice: values["input-device"],
+      outputDevice: values["output-device"]
+    }
+  )
+);