omnirush 0.8.6 → 0.9.1

package/assets/extensions/omnirush/voice/capture.ts

@@ -0,0 +1,502 @@
+/**
+ * Microphone capture for the CLI: 16 kHz mono s16le PCM, in memory only.
+ *
+ * Recorder chain (first one that opens wins):
+ *   1. @picovoice/pvrecorder-node (optional dependency, Apache-2.0, no
+ *      access key): native, prebuilt for macOS x64/arm64, Windows
+ *      x64/arm64, Linux x64 and Raspberry Pi. Runs in a worker thread
+ *      because its read() blocks.
+ *   2. System tools writing raw PCM to stdout (never to a file):
+ *      Linux pw-record → parecord → arecord; SoX `rec` (Linux/macOS);
+ *      ffmpeg last (pulse/alsa, avfoundation, dshow).
+ *   3. Nothing works → one exact install command for this OS.
+ *
+ * OMNIRUSH_VOICE_INPUT_FILE=<wav> replaces the microphone with the file,
+ * paced in real time (tests and e2e); the file is only read.
+ *
+ * Audio is never written anywhere: tool output is piped, frames are handed
+ * to the caller and not retained here.
+ */
+
+import { spawn, type ChildProcess } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { rms, VOICE_SAMPLE_RATE as SAMPLE_RATE, VoiceError, WavFileSource, voiceInputFileFromEnv, type AudioSource } from "./core";
+
+/** A core AudioSource with a name for messages ("pvrecorder", "pw-record", "file", …). */
+export interface PcmSource extends AudioSource {
+  readonly name: string;
+}
+
+export interface Candidate {
+  name: string;
+  kind: "native" | "tool";
+  command?: string;
+  args?: string[];
+}
+
+export class RecorderUnavailableError extends Error {
+  constructor(
+    message: string,
+    readonly hint: string | null,
+    readonly tried: Array<{ name: string; reason: string }>,
+  ) {
+    super(message);
+    this.name = "RecorderUnavailableError";
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Environment checks
+
+export interface EnvProbe {
+  env: NodeJS.ProcessEnv;
+  platform: NodeJS.Platform;
+  exists: (p: string) => boolean;
+  readText: (p: string) => string | null;
+}
+
+export function realProbe(): EnvProbe {
+  return {
+    env: process.env,
+    platform: process.platform,
+    exists: (p) => {
+      try {
+        fs.accessSync(p);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    readText: (p) => {
+      try {
+        return fs.readFileSync(p, "utf8");
+      } catch {
+        return null;
+      }
+    },
+  };
+}
+
+/** WSL1 / WSL2 / not WSL. */
+export function wslVersion(probe: EnvProbe): 0 | 1 | 2 {
+  if (probe.platform !== "linux") return 0;
+  const version = (probe.readText("/proc/version") || "").toLowerCase();
+  if (!version.includes("microsoft")) return 0;
+  return version.includes("wsl2") || probe.exists("/run/WSL") || !!probe.env.WSL_INTEROP ? 2 : 1;
+}
+
+function hasSoundServer(probe: EnvProbe): boolean {
+  const env = probe.env;
+  if (env.PULSE_SERVER) return true;
+  const runtime = env.XDG_RUNTIME_DIR;
+  if (runtime && (probe.exists(path.join(runtime, "pulse", "native")) || probe.exists(path.join(runtime, "pipewire-0")))) return true;
+  return false;
+}
+
+/**
+ * Why a microphone can't be used here (remote session, cloud workspace,
+ * no audio device), or null when capture may work.
+ */
+export function remoteReason(probe: EnvProbe): string | null {
+  const env = probe.env;
+  if (env.OMNIRUSH_VOICE_INPUT_FILE) return null;
+  if (env.SSH_CONNECTION || env.SSH_CLIENT || env.SSH_TTY) {
+    return "this is an SSH session: the microphone is on your own machine, not on the host — run omnirush locally to dictate";
+  }
+  if (env.CODESPACES === "true" || env.GITPOD_WORKSPACE_ID || env.CLOUD_SHELL === "true" || env.DEVPOD === "true" || env.AWS_CLOUD9_USER) {
+    return "this is a cloud workspace with no microphone — run omnirush locally to dictate";
+  }
+  if (probe.platform === "linux") {
+    const wsl = wslVersion(probe);
+    if (wsl === 1) return "WSL 1 has no audio input — run omnirush in native Windows (or WSL 2 with WSLg)";
+    if (wsl === 2) return null; // WSLg exposes PulseAudio
+    if (!probe.exists("/dev/snd") && !hasSoundServer(probe)) {
+      const container = probe.exists("/.dockerenv") || probe.exists("/run/.containerenv");
+      return container
+        ? "no audio device is available in this container"
+        : "no audio device is available in this environment (no /dev/snd and no PulseAudio/PipeWire)";
+    }
+  }
+  return null;
+}
+
+/**
+ * Linux: the native recorder goes through ALSA, which prints its errors
+ * straight to the terminal (fd 2) when there is no sound card — so it is
+ * only tried when /proc/asound/cards lists one.
+ */
+export function nativeRecorderAllowed(probe: EnvProbe): boolean {
+  if (probe.platform !== "linux") return true;
+  const cards = probe.readText("/proc/asound/cards") || "";
+  return /^\s*\d+\s*\[/m.test(cards);
+}
+
+/** One exact command that gets a recorder working on this OS. */
+export function installHint(probe: EnvProbe): string {
+  if (probe.platform === "darwin") return "brew install sox";
+  if (probe.platform === "win32") return "npm install -g omnirush (reinstalls the bundled recorder), or: winget install ffmpeg";
+  if (wslVersion(probe) === 2) return "sudo apt install sox libsox-fmt-pulse";
+  const osRelease = probe.readText("/etc/os-release") || "";
+  const field = (name: string) => (new RegExp(`^${name}=["']?([^"'\\n]*)`, "m").exec(osRelease)?.[1] ?? "").toLowerCase();
+  const ids = `${field("ID")} ${field("ID_LIKE")}`;
+  if (/\b(debian|ubuntu)\b/.test(ids)) return "sudo apt install pulseaudio-utils   (or: sudo apt install alsa-utils)";
+  if (/\b(fedora|rhel|centos)\b/.test(ids)) return "sudo dnf install pipewire-utils";
+  if (/\barch\b/.test(ids)) return "sudo pacman -S pipewire   (or: sudo pacman -S alsa-utils)";
+  if (/\b(suse|opensuse)\b/.test(ids)) return "sudo zypper install pipewire-tools";
+  if (/\balpine\b/.test(ids)) return "sudo apk add alsa-utils";
+  return "install PipeWire (pw-record), PulseAudio (parecord) or ALSA (arecord) command-line tools, or SoX";
+}
+
+// ---------------------------------------------------------------------------
+// Candidates
+
+const PCM_OUT = ["-ac", "1", "-ar", String(SAMPLE_RATE), "-f", "s16le", "-"];
+
+/** The recorder chain for a platform, in order. */
+export function recorderCandidates(platform: NodeJS.Platform, withNative = true): Candidate[] {
+  const out: Candidate[] = [];
+  if (withNative) out.push({ name: "pvrecorder", kind: "native" });
+  const ffmpeg = (args: string[]): Candidate => ({ name: "ffmpeg", kind: "tool", command: "ffmpeg", args: ["-hide_banner", "-loglevel", "error", "-nostdin", ...args, ...PCM_OUT] });
+  const rec: Candidate = { name: "rec", kind: "tool", command: "rec", args: ["-q", "--buffer", "1024", "-t", "raw", "-r", String(SAMPLE_RATE), "-e", "signed", "-b", "16", "-c", "1", "-"] };
+  if (platform === "linux") {
+    out.push(
+      { name: "pw-record", kind: "tool", command: "pw-record", args: ["--rate", String(SAMPLE_RATE), "--channels", "1", "--format", "s16", "-"] },
+      { name: "parecord", kind: "tool", command: "parecord", args: ["--raw", `--rate=${SAMPLE_RATE}`, "--channels=1", "--format=s16le"] },
+      { name: "arecord", kind: "tool", command: "arecord", args: ["-f", "S16_LE", "-r", String(SAMPLE_RATE), "-c", "1", "-t", "raw", "-q", "-"] },
+      rec,
+      ffmpeg(["-f", "pulse", "-i", "default"]),
+      { ...ffmpeg(["-f", "alsa", "-i", "default"]), name: "ffmpeg-alsa" },
+    );
+  } else if (platform === "darwin") {
+    out.push(rec, ffmpeg(["-f", "avfoundation", "-i", ":0"]));
+  } else if (platform === "win32") {
+    out.push(ffmpeg(["-f", "dshow", "-i", "audio=default"]));
+  } else {
+    out.push(rec, ffmpeg(["-f", "pulse", "-i", "default"]));
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// Sources
+
+/** Raw s16le bytes → Int16Array, carrying an odd trailing byte to the next chunk. */
+export function createPcmDecoder(): (chunk: Uint8Array) => Int16Array {
+  let carry: Uint8Array | null = null;
+  return (chunk) => {
+    let bytes = chunk;
+    if (carry) {
+      const merged = new Uint8Array(carry.length + chunk.length);
+      merged.set(carry);
+      merged.set(chunk, carry.length);
+      bytes = merged;
+      carry = null;
+    }
+    const even = bytes.length - (bytes.length % 2);
+    if (even < bytes.length) carry = bytes.slice(even);
+    const out = new Int16Array(even / 2);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, even);
+    for (let i = 0; i < out.length; i++) out[i] = view.getInt16(i * 2, true);
+    return out;
+  };
+}
+
+export interface ToolSourceOptions {
+  spawnImpl?: typeof spawn;
+  /** How long to wait for the first audio before accepting a silent-but-alive tool. */
+  probeMs?: number;
+}
+
+/** A command-line recorder piping raw PCM on stdout. */
+export class ToolSource implements PcmSource {
+  readonly name: string;
+  private child: ChildProcess | null = null;
+  private stopped = false;
+
+  constructor(
+    private readonly candidate: Candidate,
+    private readonly o: ToolSourceOptions = {},
+  ) {
+    this.name = candidate.name;
+  }
+
+  start(onPcm: (pcm: Int16Array) => void, onEnd?: (error?: VoiceError) => void): Promise<void> {
+    const onError = (error: Error) => onEnd?.(new VoiceError("capture_failed", error.message));
+    const spawnImpl = this.o.spawnImpl ?? spawn;
+    const probeMs = this.o.probeMs ?? 400;
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      let stderr = "";
+      const decode = createPcmDecoder();
+      const settle = (error?: Error) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        if (error) reject(error);
+        else resolve();
+      };
+      let child: ChildProcess;
+      try {
+        child = spawnImpl(this.candidate.command!, this.candidate.args ?? [], { stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
+      } catch (error: any) {
+        settle(Object.assign(new Error(`${this.name}: ${error?.message ?? error}`), { code: error?.code }));
+        return;
+      }
+      this.child = child;
+      const timer = setTimeout(() => settle(), probeMs);
+      child.on("error", (error: any) => {
+        const wrapped = Object.assign(new Error(error?.code === "ENOENT" ? `${this.name} is not installed` : `${this.name}: ${error?.message ?? error}`), { code: error?.code });
+        if (!settled) settle(wrapped);
+        else if (!this.stopped) onError(wrapped);
+      });
+      child.stderr?.on("data", (chunk: Buffer) => {
+        if (stderr.length < 2048) stderr += chunk.toString("utf8");
+      });
+      child.stdout?.on("data", (chunk: Buffer) => {
+        if (this.stopped) return;
+        const pcm = decode(new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength));
+        settle();
+        if (pcm.length) onPcm(pcm);
+      });
+      child.on("exit", (code, signal) => {
+        if (this.stopped) return;
+        const detail = stderr.trim().split("\n")[0] || (signal ? `signal ${signal}` : `exit code ${code}`);
+        const error = new Error(`${this.name} stopped (${detail})`);
+        if (!settled) settle(error);
+        else onError(error);
+      });
+    });
+  }
+
+  stop(): void {
+    this.stopped = true;
+    const child = this.child;
+    this.child = null;
+    if (child && child.exitCode === null) {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+        /* already gone */
+      }
+    }
+  }
+}
+
+/**
+ * OMNIRUSH_VOICE_INPUT_FILE: the core's WavFileSource (real-time paced).
+ * The file is read here, once; it is never written.
+ */
+export class FileSource implements PcmSource {
+  readonly name = "file";
+  private inner: WavFileSource | null = null;
+
+  constructor(private readonly file: string) {}
+
+  async start(onPcm: (pcm: Int16Array) => void, onEnd?: (error?: VoiceError) => void): Promise<void> {
+    let bytes: Uint8Array;
+    try {
+      bytes = new Uint8Array(fs.readFileSync(this.file));
+    } catch (error: any) {
+      throw new VoiceError("capture_failed", `OMNIRUSH_VOICE_INPUT_FILE: ${error?.message ?? error}`);
+    }
+    this.inner = new WavFileSource(bytes);
+    await this.inner.start(onPcm, onEnd);
+  }
+
+  stop(): void {
+    this.inner?.stop();
+  }
+}
+
+/** The package root the launcher hands over (optional native deps live there). */
+export function packageRoot(env: NodeJS.ProcessEnv = process.env): string | null {
+  const root = (env.OMNIRUSH_PACKAGE_ROOT || "").trim();
+  return root || null;
+}
+
+/** Can @picovoice/pvrecorder-node be loaded on this machine? (Loads it on the main thread once.) */
+export function nativeRecorderPath(env: NodeJS.ProcessEnv = process.env): string | null {
+  const root = packageRoot(env);
+  if (!root) return null;
+  try {
+    const require = createRequire(path.join(root, "package.json"));
+    return require.resolve("@picovoice/pvrecorder-node");
+  } catch {
+    return null;
+  }
+}
+
+/** pvrecorder in a worker thread (its read() blocks until a frame is ready). */
+export class NativeSource implements PcmSource {
+  readonly name = "pvrecorder";
+  private worker: any = null;
+  private stopped = false;
+
+  constructor(
+    private readonly modulePath: string,
+    private readonly workerFile: string,
+    private readonly deviceIndex = -1,
+  ) {}
+
+  async start(onPcm: (pcm: Int16Array) => void, onEnd?: (error?: VoiceError) => void): Promise<void> {
+    const onError = (error: Error) => onEnd?.(new VoiceError("capture_failed", error.message));
+    const { Worker } = await import("node:worker_threads");
+    const worker = new Worker(this.workerFile, { workerData: { modulePath: this.modulePath, deviceIndex: this.deviceIndex } });
+    this.worker = worker;
+    await new Promise<void>((resolve, reject) => {
+      const timeout = setTimeout(() => reject(new Error("pvrecorder did not start")), 3000);
+      worker.on("message", (message: any) => {
+        if (message?.type === "started") {
+          clearTimeout(timeout);
+          resolve();
+        } else if (message?.type === "error") {
+          clearTimeout(timeout);
+          if (!this.stopped) {
+            const error = new Error(`pvrecorder: ${message.message}`);
+            reject(error);
+            onError(error);
+          }
+        } else if (message?.type === "pcm" && !this.stopped) {
+          onPcm(new Int16Array(message.pcm));
+        }
+      });
+      worker.on("error", (error: Error) => {
+        clearTimeout(timeout);
+        reject(error);
+        if (!this.stopped) onError(error);
+      });
+    });
+  }
+
+  stop(): void {
+    this.stopped = true;
+    const worker = this.worker;
+    this.worker = null;
+    if (!worker) return;
+    try {
+      worker.postMessage("stop");
+    } catch {
+      /* gone */
+    }
+    setTimeout(() => worker.terminate().catch?.(() => undefined), 500).unref?.();
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Opening the first working recorder
+
+export interface OpenOptions {
+  probe?: EnvProbe;
+  spawnImpl?: typeof spawn;
+  /** Override the native recorder (tests): a factory or null to skip it. */
+  native?: (() => PcmSource) | null;
+  candidates?: Candidate[];
+  probeMs?: number;
+  workerFile?: string;
+}
+
+export interface OpenedRecorder {
+  source: PcmSource;
+  tried: Array<{ name: string; reason: string }>;
+}
+
+function defaultWorkerFile(): string | null {
+  const root = packageRoot();
+  const candidates = [
+    root ? path.join(root, "assets", "extensions", "omnirush", "voice", "pvrecorder-worker.cjs") : null,
+    (() => {
+      try {
+        return path.join(path.dirname(new URL(import.meta.url).pathname), "pvrecorder-worker.cjs");
+      } catch {
+        return null;
+      }
+    })(),
+  ];
+  for (const file of candidates) if (file && fs.existsSync(file)) return file;
+  return null;
+}
+
+/**
+ * Starts the first recorder that delivers audio. `onPcm`/`onError` are
+ * wired to whichever wins. Throws RecorderUnavailableError (with the
+ * install hint) when none does.
+ */
+export async function openRecorder(
+  onPcm: (pcm: Int16Array) => void,
+  onEnd: (error?: VoiceError) => void,
+  options: OpenOptions = {},
+): Promise<OpenedRecorder> {
+  const probe = options.probe ?? realProbe();
+  const tried: Array<{ name: string; reason: string }> = [];
+  const file = voiceInputFileFromEnv(probe.env);
+  if (file) {
+    const source = new FileSource(file);
+    await source.start(onPcm, onEnd);
+    return { source, tried };
+  }
+  const reason = remoteReason(probe);
+  if (reason) throw new RecorderUnavailableError(`Voice can't use a microphone here: ${reason}.`, null, tried);
+  const candidates = options.candidates ?? recorderCandidates(probe.platform);
+  for (const candidate of candidates) {
+    let source: PcmSource | null = null;
+    if (candidate.kind === "native") {
+      if (options.native === null) continue;
+      if (options.native) source = options.native();
+      else if (!nativeRecorderAllowed(probe)) {
+        tried.push({ name: candidate.name, reason: "no ALSA sound card" });
+        continue;
+      }
+      else {
+        const modulePath = nativeRecorderPath(probe.env);
+        const workerFile = options.workerFile ?? defaultWorkerFile();
+        if (!modulePath || !workerFile) {
+          tried.push({ name: candidate.name, reason: "not installed" });
+          continue;
+        }
+        source = new NativeSource(modulePath, workerFile);
+      }
+    } else {
+      source = new ToolSource(candidate, { spawnImpl: options.spawnImpl, probeMs: options.probeMs });
+    }
+    try {
+      await source.start(onPcm, onEnd);
+      return { source, tried };
+    } catch (error: any) {
+      source.stop();
+      tried.push({ name: candidate.name, reason: String(error?.message ?? error) });
+    }
+  }
+  const installedButFailed = tried.filter((t) => !/not installed|no ALSA sound card/.test(t.reason));
+  if (installedButFailed.length) {
+    const detail = installedButFailed.map((t) => `${t.name}: ${t.reason}`).join("; ");
+    throw new RecorderUnavailableError(
+      `No microphone could be opened (${detail}). Check that an input device is connected and that this terminal may use the microphone.`,
+      null,
+      tried,
+    );
+  }
+  const hint = installHint(probe);
+  throw new RecorderUnavailableError(`No audio recorder found. Install one with:  ${hint}`, hint, tried);
+}
+
+/** Records `ms` of audio and returns the highest RMS seen (the /voice mic check). */
+export async function testCapture(ms: number, options: OpenOptions = {}): Promise<{ maxRms: number; recorder: string }> {
+  let maxRms = 0;
+  let failure: Error | null = null;
+  const opened = await openRecorder(
+    (pcm) => {
+      const value = rms(pcm);
+      if (value > maxRms) maxRms = value;
+    },
+    (error) => {
+      if (error) failure = error;
+    },
+    options,
+  );
+  await new Promise((resolve) => setTimeout(resolve, ms));
+  opened.source.stop();
+  if (failure) throw failure;
+  return { maxRms, recorder: opened.source.name };
+}

package/assets/extensions/omnirush/voice/core/UPSTREAM

@@ -0,0 +1,16 @@
+Copied from omnirush-ai/omnirush-gui @ 1850b71 (branch feat/voice-mode, PR #20;
+apps/app/src/app/lib/voice-core/, the desktop app's shared voice core), unchanged
+except for the CLI seam marked "CLI:" in the code:
+
+  session.ts    finalize() clears its 45 s deadline timer once the last upload
+                is back (otherwise every finished recording kept a timer alive
+                for 45 s; node --test waited on it)
+  everything else unchanged
+
+The CLI's own pieces live one level up: capture.ts (recorder chain, AudioSource
+implementations, remote/no-device checks), keys.ts + kitty.ts (push-to-talk
+key handling), settings.ts, and ../voice.ts (the /voice command and prompt
+editor integration).
+
+Resync: copy the folder again from the desktop repo, re-apply the seam (or drop
+it once upstream has it), then run `npm test` (test/voice-*.test.js).

package/assets/extensions/omnirush/voice/core/file-source.ts

@@ -0,0 +1,70 @@
+import { resampleTo16k } from "./resample";
+import { VOICE_SAMPLE_RATE, VoiceError, type AudioSource } from "./types";
+import { decodeWav } from "./wav";
+
+/** The test hook: a WAV file played in place of the microphone. */
+export const VOICE_INPUT_FILE_ENV = "OMNIRUSH_VOICE_INPUT_FILE";
+
+export function voiceInputFileFromEnv(env: Record<string, string | undefined>): string | null {
+  const value = env[VOICE_INPUT_FILE_ENV]?.trim();
+  return value ? value : null;
+}
+
+/**
+ * An AudioSource that plays a WAV file (any PCM format, resampled to 16 kHz
+ * mono) in chunks, paced in real time unless `realtime` is false. The caller
+ * reads the file; this module never touches a file system.
+ */
+export class WavFileSource implements AudioSource {
+  private readonly pcm: Int16Array;
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private stopped = false;
+
+  constructor(wavBytes: Uint8Array, private readonly options: { realtime?: boolean; chunkMs?: number } = {}) {
+    let decoded;
+    try {
+      decoded = decodeWav(wavBytes);
+    } catch (error) {
+      throw new VoiceError("capture_failed", `The voice input file could not be read: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    this.pcm = resampleTo16k(decoded.samples, decoded.sampleRate);
+  }
+
+  get durationMs(): number {
+    return (this.pcm.length / VOICE_SAMPLE_RATE) * 1000;
+  }
+
+  async start(onFrames: (frames: Int16Array) => void, onEnd?: (error?: VoiceError) => void): Promise<void> {
+    this.stopped = false;
+    const chunkMs = this.options.chunkMs ?? 100;
+    const chunk = Math.round((VOICE_SAMPLE_RATE * chunkMs) / 1000);
+    let offset = 0;
+    const step = () => {
+      if (this.stopped) return false;
+      if (offset >= this.pcm.length) {
+        this.stop();
+        onEnd?.();
+        return false;
+      }
+      onFrames(this.pcm.slice(offset, offset + chunk));
+      offset += chunk;
+      return true;
+    };
+    if (this.options.realtime === false) {
+      // Delivered after start() resolves, as a microphone would.
+      setTimeout(() => {
+        while (step()) {
+          // drain
+        }
+      }, 0);
+      return;
+    }
+    this.timer = setInterval(step, chunkMs);
+  }
+
+  stop(): void {
+    this.stopped = true;
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+  }
+}

package/assets/extensions/omnirush/voice/core/index.ts

@@ -0,0 +1,21 @@
+/**
+ * voice-core: dictation without a UI. Capture-agnostic (any AudioSource
+ * delivering 16 kHz mono Int16), dependency-free TypeScript that runs in a
+ * browser renderer and in Node 20+, so the CLI can vendor this folder as is.
+ *
+ *   source → Segmenter (energy VAD, pause-cut) → encodeWav → Transcriber
+ *          → ordered stitch → keyterm post-correction → text
+ *
+ * Audio is disposable: silence is dropped as it arrives, each speech
+ * segment's PCM and WAV are released once its text (or final failure) is
+ * known, and nothing is ever written to disk.
+ */
+export * from "./types";
+export { encodeWav, decodeWav, type DecodedWav } from "./wav";
+export { Downsampler, resampleTo16k } from "./resample";
+export { LevelMeter, Segmenter, levelFromRms, rms, type Segment, type SegmenterOptions } from "./segmenter";
+export { countWords, isCjk, isLikelyHallucination, padInsertion, stitch } from "./text";
+export { DEV_KEYTERMS, applyKeyterms, buildKeyterms, splitIdentifier, type KeytermContext } from "./keyterms";
+export { RemoteTranscriber, errorCode, multipartBody, voiceErrorFromResponse, type RemoteTranscriberOptions } from "./transcriber";
+export { CircuitBreaker, VoiceSession, type VoiceSessionOptions } from "./session";
+export { VOICE_INPUT_FILE_ENV, WavFileSource, voiceInputFileFromEnv } from "./file-source";