lunibee 0.3.3 → 0.4.0

package/dist/chunks/index-yh76b55h.js

@@ -0,0 +1,3449 @@
+// @bun
+import {
+  GatewayHeartbeat2
+} from "./index-fdvgk2sw.js";
+
+// packages/voice/src/crypto.ts
+import { createCipheriv, createDecipheriv, getCiphers } from "crypto";
+
+// node_modules/.bun/@noble+ciphers@1.3.0/node_modules/@noble/ciphers/esm/utils.js
+/*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) */
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function abool(b) {
+  if (typeof b !== "boolean")
+    throw new Error(`boolean expected, not ${b}`);
+}
+function anumber(n) {
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new Error("positive integer expected, got " + n);
+}
+function abytes(b, ...lengths) {
+  if (!isBytes(b))
+    throw new Error("Uint8Array expected");
+  if (lengths.length > 0 && !lengths.includes(b.length))
+    throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput(out, instance) {
+  abytes(out);
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error("digestInto() expects output buffer of length at least " + min);
+  }
+}
+function u32(arr) {
+  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+function clean(...arrays) {
+  for (let i = 0;i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+var isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+function utf8ToBytes(str) {
+  if (typeof str !== "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+function toBytes(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes(data);
+  else if (isBytes(data))
+    data = copyBytes(data);
+  else
+    throw new Error("Uint8Array expected, got " + typeof data);
+  return data;
+}
+function checkOpts(defaults, opts) {
+  if (opts == null || typeof opts !== "object")
+    throw new Error("options must be defined");
+  const merged = Object.assign(defaults, opts);
+  return merged;
+}
+function equalBytes(a, b) {
+  if (a.length !== b.length)
+    return false;
+  let diff = 0;
+  for (let i = 0;i < a.length; i++)
+    diff |= a[i] ^ b[i];
+  return diff === 0;
+}
+var wrapCipher = (params, constructor) => {
+  function wrappedCipher(key, ...args) {
+    abytes(key);
+    if (!isLE)
+      throw new Error("Non little-endian hardware is not yet supported");
+    if (params.nonceLength !== undefined) {
+      const nonce = args[0];
+      if (!nonce)
+        throw new Error("nonce / iv required");
+      if (params.varSizeNonce)
+        abytes(nonce);
+      else
+        abytes(nonce, params.nonceLength);
+    }
+    const tagl = params.tagLength;
+    if (tagl && args[1] !== undefined) {
+      abytes(args[1]);
+    }
+    const cipher = constructor(key, ...args);
+    const checkOutput = (fnLength, output) => {
+      if (output !== undefined) {
+        if (fnLength !== 2)
+          throw new Error("cipher output not supported");
+        abytes(output);
+      }
+    };
+    let called = false;
+    const wrCipher = {
+      encrypt(data, output) {
+        if (called)
+          throw new Error("cannot encrypt() twice with same key + nonce");
+        called = true;
+        abytes(data);
+        checkOutput(cipher.encrypt.length, output);
+        return cipher.encrypt(data, output);
+      },
+      decrypt(data, output) {
+        abytes(data);
+        if (tagl && data.length < tagl)
+          throw new Error("invalid ciphertext length: smaller than tagLength=" + tagl);
+        checkOutput(cipher.decrypt.length, output);
+        return cipher.decrypt(data, output);
+      }
+    };
+    return wrCipher;
+  }
+  Object.assign(wrappedCipher, params);
+  return wrappedCipher;
+};
+function getOutput(expectedLength, out, onlyAligned = true) {
+  if (out === undefined)
+    return new Uint8Array(expectedLength);
+  if (out.length !== expectedLength)
+    throw new Error("invalid output length, expected " + expectedLength + ", got: " + out.length);
+  if (onlyAligned && !isAligned32(out))
+    throw new Error("invalid output, must be aligned");
+  return out;
+}
+function setBigUint64(view, byteOffset, value, isLE) {
+  if (typeof view.setBigUint64 === "function")
+    return view.setBigUint64(byteOffset, value, isLE);
+  const _32n = BigInt(32);
+  const _u32_max = BigInt(4294967295);
+  const wh = Number(value >> _32n & _u32_max);
+  const wl = Number(value & _u32_max);
+  const h = isLE ? 4 : 0;
+  const l = isLE ? 0 : 4;
+  view.setUint32(byteOffset + h, wh, isLE);
+  view.setUint32(byteOffset + l, wl, isLE);
+}
+function u64Lengths(dataLength, aadLength, isLE) {
+  abool(isLE);
+  const num = new Uint8Array(16);
+  const view = createView(num);
+  setBigUint64(view, 0, BigInt(aadLength), isLE);
+  setBigUint64(view, 8, BigInt(dataLength), isLE);
+  return num;
+}
+function isAligned32(bytes) {
+  return bytes.byteOffset % 4 === 0;
+}
+function copyBytes(bytes) {
+  return Uint8Array.from(bytes);
+}
+
+// node_modules/.bun/@noble+ciphers@1.3.0/node_modules/@noble/ciphers/esm/_arx.js
+var _utf8ToBytes = (str) => Uint8Array.from(str.split("").map((c) => c.charCodeAt(0)));
+var sigma16 = _utf8ToBytes("expand 16-byte k");
+var sigma32 = _utf8ToBytes("expand 32-byte k");
+var sigma16_32 = u32(sigma16);
+var sigma32_32 = u32(sigma32);
+function rotl(a, b) {
+  return a << b | a >>> 32 - b;
+}
+function isAligned322(b) {
+  return b.byteOffset % 4 === 0;
+}
+var BLOCK_LEN = 64;
+var BLOCK_LEN32 = 16;
+var MAX_COUNTER = 2 ** 32 - 1;
+var U32_EMPTY = new Uint32Array;
+function runCipher(core, sigma, key, nonce, data, output, counter, rounds) {
+  const len = data.length;
+  const block = new Uint8Array(BLOCK_LEN);
+  const b32 = u32(block);
+  const isAligned = isAligned322(data) && isAligned322(output);
+  const d32 = isAligned ? u32(data) : U32_EMPTY;
+  const o32 = isAligned ? u32(output) : U32_EMPTY;
+  for (let pos = 0;pos < len; counter++) {
+    core(sigma, key, nonce, b32, counter, rounds);
+    if (counter >= MAX_COUNTER)
+      throw new Error("arx: counter overflow");
+    const take = Math.min(BLOCK_LEN, len - pos);
+    if (isAligned && take === BLOCK_LEN) {
+      const pos32 = pos / 4;
+      if (pos % 4 !== 0)
+        throw new Error("arx: invalid block position");
+      for (let j = 0, posj;j < BLOCK_LEN32; j++) {
+        posj = pos32 + j;
+        o32[posj] = d32[posj] ^ b32[j];
+      }
+      pos += BLOCK_LEN;
+      continue;
+    }
+    for (let j = 0, posj;j < take; j++) {
+      posj = pos + j;
+      output[posj] = data[posj] ^ block[j];
+    }
+    pos += take;
+  }
+}
+function createCipher(core, opts) {
+  const { allowShortKeys, extendNonceFn, counterLength, counterRight, rounds } = checkOpts({ allowShortKeys: false, counterLength: 8, counterRight: false, rounds: 20 }, opts);
+  if (typeof core !== "function")
+    throw new Error("core must be a function");
+  anumber(counterLength);
+  anumber(rounds);
+  abool(counterRight);
+  abool(allowShortKeys);
+  return (key, nonce, data, output, counter = 0) => {
+    abytes(key);
+    abytes(nonce);
+    abytes(data);
+    const len = data.length;
+    if (output === undefined)
+      output = new Uint8Array(len);
+    abytes(output);
+    anumber(counter);
+    if (counter < 0 || counter >= MAX_COUNTER)
+      throw new Error("arx: counter overflow");
+    if (output.length < len)
+      throw new Error(`arx: output (${output.length}) is shorter than data (${len})`);
+    const toClean = [];
+    let l = key.length;
+    let k;
+    let sigma;
+    if (l === 32) {
+      toClean.push(k = copyBytes(key));
+      sigma = sigma32_32;
+    } else if (l === 16 && allowShortKeys) {
+      k = new Uint8Array(32);
+      k.set(key);
+      k.set(key, 16);
+      sigma = sigma16_32;
+      toClean.push(k);
+    } else {
+      throw new Error(`arx: invalid 32-byte key, got length=${l}`);
+    }
+    if (!isAligned322(nonce))
+      toClean.push(nonce = copyBytes(nonce));
+    const k32 = u32(k);
+    if (extendNonceFn) {
+      if (nonce.length !== 24)
+        throw new Error(`arx: extended nonce must be 24 bytes`);
+      extendNonceFn(sigma, k32, u32(nonce.subarray(0, 16)), k32);
+      nonce = nonce.subarray(16);
+    }
+    const nonceNcLen = 16 - counterLength;
+    if (nonceNcLen !== nonce.length)
+      throw new Error(`arx: nonce must be ${nonceNcLen} or 16 bytes`);
+    if (nonceNcLen !== 12) {
+      const nc = new Uint8Array(12);
+      nc.set(nonce, counterRight ? 0 : 12 - nonce.length);
+      nonce = nc;
+      toClean.push(nonce);
+    }
+    const n32 = u32(nonce);
+    runCipher(core, sigma, k32, n32, data, output, counter, rounds);
+    clean(...toClean);
+    return output;
+  };
+}
+
+// node_modules/.bun/@noble+ciphers@1.3.0/node_modules/@noble/ciphers/esm/_poly1305.js
+var u8to16 = (a, i) => a[i++] & 255 | (a[i++] & 255) << 8;
+
+class Poly1305 {
+  constructor(key) {
+    this.blockLen = 16;
+    this.outputLen = 16;
+    this.buffer = new Uint8Array(16);
+    this.r = new Uint16Array(10);
+    this.h = new Uint16Array(10);
+    this.pad = new Uint16Array(8);
+    this.pos = 0;
+    this.finished = false;
+    key = toBytes(key);
+    abytes(key, 32);
+    const t0 = u8to16(key, 0);
+    const t1 = u8to16(key, 2);
+    const t2 = u8to16(key, 4);
+    const t3 = u8to16(key, 6);
+    const t4 = u8to16(key, 8);
+    const t5 = u8to16(key, 10);
+    const t6 = u8to16(key, 12);
+    const t7 = u8to16(key, 14);
+    this.r[0] = t0 & 8191;
+    this.r[1] = (t0 >>> 13 | t1 << 3) & 8191;
+    this.r[2] = (t1 >>> 10 | t2 << 6) & 7939;
+    this.r[3] = (t2 >>> 7 | t3 << 9) & 8191;
+    this.r[4] = (t3 >>> 4 | t4 << 12) & 255;
+    this.r[5] = t4 >>> 1 & 8190;
+    this.r[6] = (t4 >>> 14 | t5 << 2) & 8191;
+    this.r[7] = (t5 >>> 11 | t6 << 5) & 8065;
+    this.r[8] = (t6 >>> 8 | t7 << 8) & 8191;
+    this.r[9] = t7 >>> 5 & 127;
+    for (let i = 0;i < 8; i++)
+      this.pad[i] = u8to16(key, 16 + 2 * i);
+  }
+  process(data, offset, isLast = false) {
+    const hibit = isLast ? 0 : 1 << 11;
+    const { h, r } = this;
+    const r0 = r[0];
+    const r1 = r[1];
+    const r2 = r[2];
+    const r3 = r[3];
+    const r4 = r[4];
+    const r5 = r[5];
+    const r6 = r[6];
+    const r7 = r[7];
+    const r8 = r[8];
+    const r9 = r[9];
+    const t0 = u8to16(data, offset + 0);
+    const t1 = u8to16(data, offset + 2);
+    const t2 = u8to16(data, offset + 4);
+    const t3 = u8to16(data, offset + 6);
+    const t4 = u8to16(data, offset + 8);
+    const t5 = u8to16(data, offset + 10);
+    const t6 = u8to16(data, offset + 12);
+    const t7 = u8to16(data, offset + 14);
+    let h0 = h[0] + (t0 & 8191);
+    let h1 = h[1] + ((t0 >>> 13 | t1 << 3) & 8191);
+    let h2 = h[2] + ((t1 >>> 10 | t2 << 6) & 8191);
+    let h3 = h[3] + ((t2 >>> 7 | t3 << 9) & 8191);
+    let h4 = h[4] + ((t3 >>> 4 | t4 << 12) & 8191);
+    let h5 = h[5] + (t4 >>> 1 & 8191);
+    let h6 = h[6] + ((t4 >>> 14 | t5 << 2) & 8191);
+    let h7 = h[7] + ((t5 >>> 11 | t6 << 5) & 8191);
+    let h8 = h[8] + ((t6 >>> 8 | t7 << 8) & 8191);
+    let h9 = h[9] + (t7 >>> 5 | hibit);
+    let c = 0;
+    let d0 = c + h0 * r0 + h1 * (5 * r9) + h2 * (5 * r8) + h3 * (5 * r7) + h4 * (5 * r6);
+    c = d0 >>> 13;
+    d0 &= 8191;
+    d0 += h5 * (5 * r5) + h6 * (5 * r4) + h7 * (5 * r3) + h8 * (5 * r2) + h9 * (5 * r1);
+    c += d0 >>> 13;
+    d0 &= 8191;
+    let d1 = c + h0 * r1 + h1 * r0 + h2 * (5 * r9) + h3 * (5 * r8) + h4 * (5 * r7);
+    c = d1 >>> 13;
+    d1 &= 8191;
+    d1 += h5 * (5 * r6) + h6 * (5 * r5) + h7 * (5 * r4) + h8 * (5 * r3) + h9 * (5 * r2);
+    c += d1 >>> 13;
+    d1 &= 8191;
+    let d2 = c + h0 * r2 + h1 * r1 + h2 * r0 + h3 * (5 * r9) + h4 * (5 * r8);
+    c = d2 >>> 13;
+    d2 &= 8191;
+    d2 += h5 * (5 * r7) + h6 * (5 * r6) + h7 * (5 * r5) + h8 * (5 * r4) + h9 * (5 * r3);
+    c += d2 >>> 13;
+    d2 &= 8191;
+    let d3 = c + h0 * r3 + h1 * r2 + h2 * r1 + h3 * r0 + h4 * (5 * r9);
+    c = d3 >>> 13;
+    d3 &= 8191;
+    d3 += h5 * (5 * r8) + h6 * (5 * r7) + h7 * (5 * r6) + h8 * (5 * r5) + h9 * (5 * r4);
+    c += d3 >>> 13;
+    d3 &= 8191;
+    let d4 = c + h0 * r4 + h1 * r3 + h2 * r2 + h3 * r1 + h4 * r0;
+    c = d4 >>> 13;
+    d4 &= 8191;
+    d4 += h5 * (5 * r9) + h6 * (5 * r8) + h7 * (5 * r7) + h8 * (5 * r6) + h9 * (5 * r5);
+    c += d4 >>> 13;
+    d4 &= 8191;
+    let d5 = c + h0 * r5 + h1 * r4 + h2 * r3 + h3 * r2 + h4 * r1;
+    c = d5 >>> 13;
+    d5 &= 8191;
+    d5 += h5 * r0 + h6 * (5 * r9) + h7 * (5 * r8) + h8 * (5 * r7) + h9 * (5 * r6);
+    c += d5 >>> 13;
+    d5 &= 8191;
+    let d6 = c + h0 * r6 + h1 * r5 + h2 * r4 + h3 * r3 + h4 * r2;
+    c = d6 >>> 13;
+    d6 &= 8191;
+    d6 += h5 * r1 + h6 * r0 + h7 * (5 * r9) + h8 * (5 * r8) + h9 * (5 * r7);
+    c += d6 >>> 13;
+    d6 &= 8191;
+    let d7 = c + h0 * r7 + h1 * r6 + h2 * r5 + h3 * r4 + h4 * r3;
+    c = d7 >>> 13;
+    d7 &= 8191;
+    d7 += h5 * r2 + h6 * r1 + h7 * r0 + h8 * (5 * r9) + h9 * (5 * r8);
+    c += d7 >>> 13;
+    d7 &= 8191;
+    let d8 = c + h0 * r8 + h1 * r7 + h2 * r6 + h3 * r5 + h4 * r4;
+    c = d8 >>> 13;
+    d8 &= 8191;
+    d8 += h5 * r3 + h6 * r2 + h7 * r1 + h8 * r0 + h9 * (5 * r9);
+    c += d8 >>> 13;
+    d8 &= 8191;
+    let d9 = c + h0 * r9 + h1 * r8 + h2 * r7 + h3 * r6 + h4 * r5;
+    c = d9 >>> 13;
+    d9 &= 8191;
+    d9 += h5 * r4 + h6 * r3 + h7 * r2 + h8 * r1 + h9 * r0;
+    c += d9 >>> 13;
+    d9 &= 8191;
+    c = (c << 2) + c | 0;
+    c = c + d0 | 0;
+    d0 = c & 8191;
+    c = c >>> 13;
+    d1 += c;
+    h[0] = d0;
+    h[1] = d1;
+    h[2] = d2;
+    h[3] = d3;
+    h[4] = d4;
+    h[5] = d5;
+    h[6] = d6;
+    h[7] = d7;
+    h[8] = d8;
+    h[9] = d9;
+  }
+  finalize() {
+    const { h, pad } = this;
+    const g = new Uint16Array(10);
+    let c = h[1] >>> 13;
+    h[1] &= 8191;
+    for (let i = 2;i < 10; i++) {
+      h[i] += c;
+      c = h[i] >>> 13;
+      h[i] &= 8191;
+    }
+    h[0] += c * 5;
+    c = h[0] >>> 13;
+    h[0] &= 8191;
+    h[1] += c;
+    c = h[1] >>> 13;
+    h[1] &= 8191;
+    h[2] += c;
+    g[0] = h[0] + 5;
+    c = g[0] >>> 13;
+    g[0] &= 8191;
+    for (let i = 1;i < 10; i++) {
+      g[i] = h[i] + c;
+      c = g[i] >>> 13;
+      g[i] &= 8191;
+    }
+    g[9] -= 1 << 13;
+    let mask = (c ^ 1) - 1;
+    for (let i = 0;i < 10; i++)
+      g[i] &= mask;
+    mask = ~mask;
+    for (let i = 0;i < 10; i++)
+      h[i] = h[i] & mask | g[i];
+    h[0] = (h[0] | h[1] << 13) & 65535;
+    h[1] = (h[1] >>> 3 | h[2] << 10) & 65535;
+    h[2] = (h[2] >>> 6 | h[3] << 7) & 65535;
+    h[3] = (h[3] >>> 9 | h[4] << 4) & 65535;
+    h[4] = (h[4] >>> 12 | h[5] << 1 | h[6] << 14) & 65535;
+    h[5] = (h[6] >>> 2 | h[7] << 11) & 65535;
+    h[6] = (h[7] >>> 5 | h[8] << 8) & 65535;
+    h[7] = (h[8] >>> 8 | h[9] << 5) & 65535;
+    let f = h[0] + pad[0];
+    h[0] = f & 65535;
+    for (let i = 1;i < 8; i++) {
+      f = (h[i] + pad[i] | 0) + (f >>> 16) | 0;
+      h[i] = f & 65535;
+    }
+    clean(g);
+  }
+  update(data) {
+    aexists(this);
+    data = toBytes(data);
+    abytes(data);
+    const { buffer, blockLen } = this;
+    const len = data.length;
+    for (let pos = 0;pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      if (take === blockLen) {
+        for (;blockLen <= len - pos; pos += blockLen)
+          this.process(data, pos);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(buffer, 0, false);
+        this.pos = 0;
+      }
+    }
+    return this;
+  }
+  destroy() {
+    clean(this.h, this.r, this.buffer, this.pad);
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { buffer, h } = this;
+    let { pos } = this;
+    if (pos) {
+      buffer[pos++] = 1;
+      for (;pos < 16; pos++)
+        buffer[pos] = 0;
+      this.process(buffer, 0, true);
+    }
+    this.finalize();
+    let opos = 0;
+    for (let i = 0;i < 8; i++) {
+      out[opos++] = h[i] >>> 0;
+      out[opos++] = h[i] >>> 8;
+    }
+    return out;
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+}
+function wrapConstructorWithKey(hashCons) {
+  const hashC = (msg, key) => hashCons(key).update(toBytes(msg)).digest();
+  const tmp = hashCons(new Uint8Array(32));
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = (key) => hashCons(key);
+  return hashC;
+}
+var poly1305 = wrapConstructorWithKey((key) => new Poly1305(key));
+
+// node_modules/.bun/@noble+ciphers@1.3.0/node_modules/@noble/ciphers/esm/chacha.js
+function chachaCore(s, k, n, out, cnt, rounds = 20) {
+  let y00 = s[0], y01 = s[1], y02 = s[2], y03 = s[3], y04 = k[0], y05 = k[1], y06 = k[2], y07 = k[3], y08 = k[4], y09 = k[5], y10 = k[6], y11 = k[7], y12 = cnt, y13 = n[0], y14 = n[1], y15 = n[2];
+  let x00 = y00, x01 = y01, x02 = y02, x03 = y03, x04 = y04, x05 = y05, x06 = y06, x07 = y07, x08 = y08, x09 = y09, x10 = y10, x11 = y11, x12 = y12, x13 = y13, x14 = y14, x15 = y15;
+  for (let r = 0;r < rounds; r += 2) {
+    x00 = x00 + x04 | 0;
+    x12 = rotl(x12 ^ x00, 16);
+    x08 = x08 + x12 | 0;
+    x04 = rotl(x04 ^ x08, 12);
+    x00 = x00 + x04 | 0;
+    x12 = rotl(x12 ^ x00, 8);
+    x08 = x08 + x12 | 0;
+    x04 = rotl(x04 ^ x08, 7);
+    x01 = x01 + x05 | 0;
+    x13 = rotl(x13 ^ x01, 16);
+    x09 = x09 + x13 | 0;
+    x05 = rotl(x05 ^ x09, 12);
+    x01 = x01 + x05 | 0;
+    x13 = rotl(x13 ^ x01, 8);
+    x09 = x09 + x13 | 0;
+    x05 = rotl(x05 ^ x09, 7);
+    x02 = x02 + x06 | 0;
+    x14 = rotl(x14 ^ x02, 16);
+    x10 = x10 + x14 | 0;
+    x06 = rotl(x06 ^ x10, 12);
+    x02 = x02 + x06 | 0;
+    x14 = rotl(x14 ^ x02, 8);
+    x10 = x10 + x14 | 0;
+    x06 = rotl(x06 ^ x10, 7);
+    x03 = x03 + x07 | 0;
+    x15 = rotl(x15 ^ x03, 16);
+    x11 = x11 + x15 | 0;
+    x07 = rotl(x07 ^ x11, 12);
+    x03 = x03 + x07 | 0;
+    x15 = rotl(x15 ^ x03, 8);
+    x11 = x11 + x15 | 0;
+    x07 = rotl(x07 ^ x11, 7);
+    x00 = x00 + x05 | 0;
+    x15 = rotl(x15 ^ x00, 16);
+    x10 = x10 + x15 | 0;
+    x05 = rotl(x05 ^ x10, 12);
+    x00 = x00 + x05 | 0;
+    x15 = rotl(x15 ^ x00, 8);
+    x10 = x10 + x15 | 0;
+    x05 = rotl(x05 ^ x10, 7);
+    x01 = x01 + x06 | 0;
+    x12 = rotl(x12 ^ x01, 16);
+    x11 = x11 + x12 | 0;
+    x06 = rotl(x06 ^ x11, 12);
+    x01 = x01 + x06 | 0;
+    x12 = rotl(x12 ^ x01, 8);
+    x11 = x11 + x12 | 0;
+    x06 = rotl(x06 ^ x11, 7);
+    x02 = x02 + x07 | 0;
+    x13 = rotl(x13 ^ x02, 16);
+    x08 = x08 + x13 | 0;
+    x07 = rotl(x07 ^ x08, 12);
+    x02 = x02 + x07 | 0;
+    x13 = rotl(x13 ^ x02, 8);
+    x08 = x08 + x13 | 0;
+    x07 = rotl(x07 ^ x08, 7);
+    x03 = x03 + x04 | 0;
+    x14 = rotl(x14 ^ x03, 16);
+    x09 = x09 + x14 | 0;
+    x04 = rotl(x04 ^ x09, 12);
+    x03 = x03 + x04 | 0;
+    x14 = rotl(x14 ^ x03, 8);
+    x09 = x09 + x14 | 0;
+    x04 = rotl(x04 ^ x09, 7);
+  }
+  let oi = 0;
+  out[oi++] = y00 + x00 | 0;
+  out[oi++] = y01 + x01 | 0;
+  out[oi++] = y02 + x02 | 0;
+  out[oi++] = y03 + x03 | 0;
+  out[oi++] = y04 + x04 | 0;
+  out[oi++] = y05 + x05 | 0;
+  out[oi++] = y06 + x06 | 0;
+  out[oi++] = y07 + x07 | 0;
+  out[oi++] = y08 + x08 | 0;
+  out[oi++] = y09 + x09 | 0;
+  out[oi++] = y10 + x10 | 0;
+  out[oi++] = y11 + x11 | 0;
+  out[oi++] = y12 + x12 | 0;
+  out[oi++] = y13 + x13 | 0;
+  out[oi++] = y14 + x14 | 0;
+  out[oi++] = y15 + x15 | 0;
+}
+function hchacha(s, k, i, o32) {
+  let x00 = s[0], x01 = s[1], x02 = s[2], x03 = s[3], x04 = k[0], x05 = k[1], x06 = k[2], x07 = k[3], x08 = k[4], x09 = k[5], x10 = k[6], x11 = k[7], x12 = i[0], x13 = i[1], x14 = i[2], x15 = i[3];
+  for (let r = 0;r < 20; r += 2) {
+    x00 = x00 + x04 | 0;
+    x12 = rotl(x12 ^ x00, 16);
+    x08 = x08 + x12 | 0;
+    x04 = rotl(x04 ^ x08, 12);
+    x00 = x00 + x04 | 0;
+    x12 = rotl(x12 ^ x00, 8);
+    x08 = x08 + x12 | 0;
+    x04 = rotl(x04 ^ x08, 7);
+    x01 = x01 + x05 | 0;
+    x13 = rotl(x13 ^ x01, 16);
+    x09 = x09 + x13 | 0;
+    x05 = rotl(x05 ^ x09, 12);
+    x01 = x01 + x05 | 0;
+    x13 = rotl(x13 ^ x01, 8);
+    x09 = x09 + x13 | 0;
+    x05 = rotl(x05 ^ x09, 7);
+    x02 = x02 + x06 | 0;
+    x14 = rotl(x14 ^ x02, 16);
+    x10 = x10 + x14 | 0;
+    x06 = rotl(x06 ^ x10, 12);
+    x02 = x02 + x06 | 0;
+    x14 = rotl(x14 ^ x02, 8);
+    x10 = x10 + x14 | 0;
+    x06 = rotl(x06 ^ x10, 7);
+    x03 = x03 + x07 | 0;
+    x15 = rotl(x15 ^ x03, 16);
+    x11 = x11 + x15 | 0;
+    x07 = rotl(x07 ^ x11, 12);
+    x03 = x03 + x07 | 0;
+    x15 = rotl(x15 ^ x03, 8);
+    x11 = x11 + x15 | 0;
+    x07 = rotl(x07 ^ x11, 7);
+    x00 = x00 + x05 | 0;
+    x15 = rotl(x15 ^ x00, 16);
+    x10 = x10 + x15 | 0;
+    x05 = rotl(x05 ^ x10, 12);
+    x00 = x00 + x05 | 0;
+    x15 = rotl(x15 ^ x00, 8);
+    x10 = x10 + x15 | 0;
+    x05 = rotl(x05 ^ x10, 7);
+    x01 = x01 + x06 | 0;
+    x12 = rotl(x12 ^ x01, 16);
+    x11 = x11 + x12 | 0;
+    x06 = rotl(x06 ^ x11, 12);
+    x01 = x01 + x06 | 0;
+    x12 = rotl(x12 ^ x01, 8);
+    x11 = x11 + x12 | 0;
+    x06 = rotl(x06 ^ x11, 7);
+    x02 = x02 + x07 | 0;
+    x13 = rotl(x13 ^ x02, 16);
+    x08 = x08 + x13 | 0;
+    x07 = rotl(x07 ^ x08, 12);
+    x02 = x02 + x07 | 0;
+    x13 = rotl(x13 ^ x02, 8);
+    x08 = x08 + x13 | 0;
+    x07 = rotl(x07 ^ x08, 7);
+    x03 = x03 + x04 | 0;
+    x14 = rotl(x14 ^ x03, 16);
+    x09 = x09 + x14 | 0;
+    x04 = rotl(x04 ^ x09, 12);
+    x03 = x03 + x04 | 0;
+    x14 = rotl(x14 ^ x03, 8);
+    x09 = x09 + x14 | 0;
+    x04 = rotl(x04 ^ x09, 7);
+  }
+  let oi = 0;
+  o32[oi++] = x00;
+  o32[oi++] = x01;
+  o32[oi++] = x02;
+  o32[oi++] = x03;
+  o32[oi++] = x12;
+  o32[oi++] = x13;
+  o32[oi++] = x14;
+  o32[oi++] = x15;
+}
+var chacha20 = /* @__PURE__ */ createCipher(chachaCore, {
+  counterRight: false,
+  counterLength: 4,
+  allowShortKeys: false
+});
+var xchacha20 = /* @__PURE__ */ createCipher(chachaCore, {
+  counterRight: false,
+  counterLength: 8,
+  extendNonceFn: hchacha,
+  allowShortKeys: false
+});
+var ZEROS16 = /* @__PURE__ */ new Uint8Array(16);
+var updatePadded = (h, msg) => {
+  h.update(msg);
+  const left = msg.length % 16;
+  if (left)
+    h.update(ZEROS16.subarray(left));
+};
+var ZEROS32 = /* @__PURE__ */ new Uint8Array(32);
+function computeTag(fn, key, nonce, data, AAD) {
+  const authKey = fn(key, nonce, ZEROS32);
+  const h = poly1305.create(authKey);
+  if (AAD)
+    updatePadded(h, AAD);
+  updatePadded(h, data);
+  const num = u64Lengths(data.length, AAD ? AAD.length : 0, true);
+  h.update(num);
+  const res = h.digest();
+  clean(authKey, num);
+  return res;
+}
+var _poly1305_aead = (xorStream) => (key, nonce, AAD) => {
+  const tagLength = 16;
+  return {
+    encrypt(plaintext, output) {
+      const plength = plaintext.length;
+      output = getOutput(plength + tagLength, output, false);
+      output.set(plaintext);
+      const oPlain = output.subarray(0, -tagLength);
+      xorStream(key, nonce, oPlain, oPlain, 1);
+      const tag = computeTag(xorStream, key, nonce, oPlain, AAD);
+      output.set(tag, plength);
+      clean(tag);
+      return output;
+    },
+    decrypt(ciphertext, output) {
+      output = getOutput(ciphertext.length - tagLength, output, false);
+      const data = ciphertext.subarray(0, -tagLength);
+      const passedTag = ciphertext.subarray(-tagLength);
+      const tag = computeTag(xorStream, key, nonce, data, AAD);
+      if (!equalBytes(passedTag, tag))
+        throw new Error("invalid tag");
+      output.set(ciphertext.subarray(0, -tagLength));
+      xorStream(key, nonce, output, output, 1);
+      clean(tag);
+      return output;
+    }
+  };
+};
+var chacha20poly1305 = /* @__PURE__ */ wrapCipher({ blockSize: 64, nonceLength: 12, tagLength: 16 }, _poly1305_aead(chacha20));
+var xchacha20poly1305 = /* @__PURE__ */ wrapCipher({ blockSize: 64, nonceLength: 24, tagLength: 16 }, _poly1305_aead(xchacha20));
+
+// packages/voice/src/protocol.ts
+var VOICE_GATEWAY_VERSION2 = 8;
+var VoiceOpcodes2 = {
+  Identify: 0,
+  SelectProtocol: 1,
+  Ready: 2,
+  Heartbeat: 3,
+  SessionDescription: 4,
+  Speaking: 5,
+  HeartbeatAck: 6,
+  Resume: 7,
+  Hello: 8,
+  Resumed: 9,
+  ClientsConnect: 11,
+  ClientDisconnect: 13,
+  DavePrepareTransition: 21,
+  DaveExecuteTransition: 22,
+  DaveTransitionReady: 23,
+  DavePrepareEpoch: 24,
+  DaveMlsExternalSender: 25,
+  DaveMlsKeyPackage: 26,
+  DaveMlsProposals: 27,
+  DaveMlsCommitWelcome: 28,
+  DaveMlsAnnounceCommitTransition: 29,
+  DaveMlsWelcome: 30,
+  DaveMlsInvalidCommitWelcome: 31
+};
+var VoiceCloseCodes2 = {
+  UnknownOpcode: 4001,
+  FailedToDecode: 4002,
+  NotAuthenticated: 4003,
+  AuthenticationFailed: 4004,
+  AlreadyAuthenticated: 4005,
+  SessionNoLongerValid: 4006,
+  SessionTimeout: 4009,
+  ServerNotFound: 4011,
+  UnknownProtocol: 4012,
+  Disconnected: 4014,
+  VoiceServerCrashed: 4015,
+  UnknownEncryptionMode: 4016,
+  DaveProtocolRequired: 4017,
+  BadRequest: 4020,
+  RateLimited: 4021,
+  CallTerminated: 4022
+};
+function canResumeVoice2(code) {
+  return code < 4000 || code === VoiceCloseCodes2.VoiceServerCrashed;
+}
+var RTP_OPUS_PAYLOAD_TYPE2 = 120;
+var FRAME_DURATION_MS2 = 20;
+var FRAME_SAMPLES2 = 960;
+var PCM_FRAME_BYTES2 = FRAME_SAMPLES2 * 2 * 2;
+var SILENCE_FRAME2 = Uint8Array.of(248, 255, 254);
+var SpeakingFlags2 = {
+  Microphone: 1,
+  Soundshare: 2,
+  Priority: 4
+};
+
+class VoiceError2 extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "VoiceError";
+  }
+}
+
+// packages/voice/src/crypto.ts
+var TAG_BYTES = 16;
+var NONCE_SUFFIX_BYTES = 4;
+var SUPPORTED_ENCRYPTION_MODES2 = getCiphers().includes("aes-256-gcm") ? ["aead_aes256_gcm_rtpsize", "aead_xchacha20_poly1305_rtpsize"] : ["aead_xchacha20_poly1305_rtpsize"];
+function chooseEncryptionMode2(offered) {
+  const mode = SUPPORTED_ENCRYPTION_MODES2.find((m) => offered.includes(m));
+  if (!mode)
+    throw new VoiceError2(`No supported voice encryption mode offered (got: ${offered.join(", ") || "none"}).`);
+  return mode;
+}
+function rtpHeader2(sequence, timestamp, ssrc) {
+  const header = new Uint8Array(12);
+  const view = new DataView(header.buffer);
+  header[0] = 128;
+  header[1] = RTP_OPUS_PAYLOAD_TYPE2;
+  view.setUint16(2, sequence & 65535);
+  view.setUint32(4, timestamp >>> 0);
+  view.setUint32(8, ssrc >>> 0);
+  return header;
+}
+function parseRtpHeader2(packet) {
+  if (packet.length < 12)
+    return;
+  const view = new DataView(packet.buffer, packet.byteOffset, packet.byteLength);
+  const first = packet[0];
+  const version = first >> 6;
+  if (version !== 2)
+    return;
+  const extension = (first & 16) !== 0;
+  let headerSize = 12 + (first & 15) * 4;
+  let extensionWords = 0;
+  if (extension) {
+    if (packet.length < headerSize + 4)
+      return;
+    extensionWords = view.getUint16(headerSize + 2);
+    headerSize += 4;
+  }
+  if (packet.length < headerSize)
+    return;
+  return {
+    version,
+    padding: (first & 32) !== 0,
+    extension,
+    payloadType: packet[1] & 127,
+    sequence: view.getUint16(2),
+    timestamp: view.getUint32(4),
+    ssrc: view.getUint32(8),
+    headerSize,
+    extensionWords
+  };
+}
+
+class PacketCipher2 {
+  mode;
+  #key;
+  #counter = 0;
+  constructor(mode, key, counter = 0) {
+    if (key.length !== 32)
+      throw new VoiceError2("The voice secret key must be 32 bytes.");
+    if (!SUPPORTED_ENCRYPTION_MODES2.includes(mode))
+      throw new VoiceError2(`Unsupported voice encryption mode: ${mode}`);
+    this.mode = mode;
+    this.#key = Uint8Array.from(key);
+    this.#counter = counter >>> 0;
+  }
+  get counter() {
+    return this.#counter;
+  }
+  #nonce(suffix) {
+    const nonce = new Uint8Array(this.mode === "aead_aes256_gcm_rtpsize" ? 12 : 24);
+    nonce.set(suffix, 0);
+    return nonce;
+  }
+  seal(header, payload) {
+    const suffix = new Uint8Array(NONCE_SUFFIX_BYTES);
+    new DataView(suffix.buffer).setUint32(0, this.#counter);
+    this.#counter = this.#counter + 1 >>> 0;
+    const nonce = this.#nonce(suffix);
+    let sealed;
+    if (this.mode === "aead_aes256_gcm_rtpsize") {
+      const cipher = createCipheriv("aes-256-gcm", this.#key, nonce);
+      cipher.setAAD(header);
+      const body = Buffer.concat([
+        cipher.update(payload),
+        cipher.final()
+      ]);
+      sealed = Buffer.concat([body, cipher.getAuthTag()]);
+    } else
+      sealed = xchacha20poly1305(this.#key, nonce, header).encrypt(payload);
+    const out = new Uint8Array(header.length + sealed.length + NONCE_SUFFIX_BYTES);
+    out.set(header, 0);
+    out.set(sealed, header.length);
+    out.set(suffix, header.length + sealed.length);
+    return out;
+  }
+  open(packet) {
+    const header = parseRtpHeader2(packet);
+    if (!header)
+      return;
+    const bodyEnd = packet.length - NONCE_SUFFIX_BYTES;
+    const tagStart = bodyEnd - TAG_BYTES;
+    if (tagStart < header.headerSize)
+      return;
+    const aad = packet.subarray(0, header.headerSize);
+    const nonce = this.#nonce(packet.subarray(bodyEnd));
+    let plain;
+    try {
+      if (this.mode === "aead_aes256_gcm_rtpsize") {
+        const decipher = createDecipheriv("aes-256-gcm", this.#key, nonce);
+        decipher.setAAD(aad);
+        decipher.setAuthTag(packet.subarray(tagStart, bodyEnd));
+        plain = Buffer.concat([
+          decipher.update(packet.subarray(header.headerSize, tagStart)),
+          decipher.final()
+        ]);
+      } else
+        plain = xchacha20poly1305(this.#key, nonce, aad).decrypt(packet.subarray(header.headerSize, bodyEnd));
+    } catch {
+      return;
+    }
+    if (header.padding && plain.length > 0) {
+      const pad = plain[plain.length - 1];
+      if (pad > plain.length)
+        return;
+      plain = plain.subarray(0, plain.length - pad);
+    }
+    const skip = header.extensionWords * 4;
+    if (skip > plain.length)
+      return;
+    return { header, payload: plain.subarray(skip) };
+  }
+}
+
+// packages/voice/src/dave.ts
+var davey;
+async function loadDave2() {
+  if (davey !== undefined)
+    return davey;
+  try {
+    const name = "@snazzah/davey";
+    const mod = await import(name);
+    davey = mod.default?.DAVESession ? mod.default : mod;
+  } catch {
+    davey = null;
+  }
+  return davey;
+}
+async function maxDaveProtocolVersion2() {
+  return (await loadDave2())?.DAVE_PROTOCOL_VERSION ?? 0;
+}
+var TRANSITION_EXPIRY_S = 10;
+var TRANSITION_EXPIRY_DOWNGRADE_S = 24;
+var DECRYPTION_FAILURE_TOLERANCE = 36;
+var AUDIO = 0;
+function equalBytes2(a, b) {
+  return a.length === b.length && a.every((byte, i) => byte === b[i]);
+}
+
+class DaveSession2 {
+  protocolVersion;
+  #module;
+  #userId;
+  #channelId;
+  #hooks;
+  #session;
+  #pending = new Map;
+  #lastTransition;
+  #downgraded = false;
+  #reinitializing = false;
+  #upgrading = false;
+  #failures = 0;
+  constructor(module, protocolVersion, userId, channelId, hooks) {
+    this.#module = module;
+    this.protocolVersion = protocolVersion;
+    this.#userId = userId;
+    this.#channelId = channelId;
+    this.#hooks = hooks;
+  }
+  get active() {
+    return this.protocolVersion > 0 && Boolean(this.#session?.ready);
+  }
+  get voicePrivacyCode() {
+    return this.protocolVersion > 0 && this.#session?.voicePrivacyCode ? this.#session.voicePrivacyCode : null;
+  }
+  reinit() {
+    if (this.protocolVersion > 0) {
+      if (this.#session)
+        this.#session.reinit(this.protocolVersion, this.#userId, this.#channelId);
+      else
+        this.#session = new this.#module.DAVESession(this.protocolVersion, this.#userId, this.#channelId);
+      this.#hooks.keyPackage(this.#session.getSerializedKeyPackage());
+    } else if (this.#session) {
+      this.#session.reset();
+      this.#session.setPassthroughMode(true, TRANSITION_EXPIRY_S);
+    }
+  }
+  setExternalSender(payload) {
+    this.#native().setExternalSender(Buffer.from(payload));
+  }
+  prepareTransition(transitionId, protocolVersion) {
+    this.#pending.set(transitionId, protocolVersion);
+    if (transitionId === 0) {
+      this.executeTransition(0);
+      return false;
+    }
+    if (protocolVersion === 0)
+      this.#session?.setPassthroughMode(true, TRANSITION_EXPIRY_DOWNGRADE_S);
+    return true;
+  }
+  executeTransition(transitionId) {
+    const next = this.#pending.get(transitionId);
+    if (next === undefined)
+      return false;
+    const previous = this.protocolVersion;
+    this.protocolVersion = next;
+    if (previous !== next && next === 0)
+      this.#downgraded = true;
+    else if (transitionId > 0 && this.#downgraded) {
+      this.#downgraded = false;
+      this.#session?.setPassthroughMode(true, TRANSITION_EXPIRY_S);
+    }
+    this.#reinitializing = false;
+    this.#upgrading = false;
+    this.#lastTransition = transitionId;
+    this.#pending.delete(transitionId);
+    this.#hooks.debug?.(`DAVE transition ${transitionId}: v${previous} -> v${next}`);
+    return true;
+  }
+  prepareEpoch(epoch, protocolVersion) {
+    if (epoch === 1) {
+      if (this.protocolVersion === 0 && protocolVersion > 0)
+        this.#upgrading = true;
+      this.protocolVersion = protocolVersion;
+      this.reinit();
+    }
+  }
+  processProposals(payload, connectedUserIds) {
+    if (payload.length < 1)
+      return;
+    const { commit, welcome } = this.#native().processProposals(payload[0], Buffer.from(payload.subarray(1)), [...connectedUserIds]);
+    if (!commit)
+      return;
+    return welcome ? Buffer.concat([commit, welcome]) : commit;
+  }
+  process(kind, payload) {
+    const transitionId = payload.length >= 2 ? payload[0] << 8 | payload[1] : 0;
+    try {
+      const body = Buffer.from(payload.subarray(2));
+      if (kind === "commit")
+        this.#native().processCommit(body);
+      else
+        this.#native().processWelcome(body);
+      if (transitionId === 0) {
+        this.#reinitializing = false;
+        this.#lastTransition = 0;
+      } else
+        this.#pending.set(transitionId, this.protocolVersion);
+      return { transitionId, ok: true };
+    } catch (error) {
+      this.#hooks.debug?.(`DAVE ${kind} failed: ${String(error)}`);
+      this.#recover(transitionId);
+      return { transitionId, ok: false };
+    }
+  }
+  #recover(transitionId) {
+    if (this.#reinitializing)
+      return;
+    this.#reinitializing = true;
+    this.#failures = 0;
+    this.#hooks.invalidTransition(transitionId);
+    this.reinit();
+  }
+  encrypt(frame) {
+    if (this.protocolVersion === 0 || equalBytes2(frame, SILENCE_FRAME2))
+      return frame;
+    if (!this.#session?.ready)
+      return this.#upgrading ? frame : null;
+    return this.#session.encryptOpus(Buffer.from(frame));
+  }
+  decrypt(frame, userId) {
+    const session = this.#session;
+    const canDecrypt = session?.ready && (this.protocolVersion !== 0 || session.canPassthrough(userId));
+    if (!session || !canDecrypt || equalBytes2(frame, SILENCE_FRAME2))
+      return frame;
+    try {
+      const out = session.decrypt(userId, AUDIO, Buffer.from(frame));
+      this.#failures = 0;
+      return out;
+    } catch {
+      if (!this.#reinitializing && this.#pending.size === 0) {
+        this.#failures++;
+        if (this.#failures > DECRYPTION_FAILURE_TOLERANCE && this.#lastTransition !== undefined)
+          this.#recover(this.#lastTransition);
+      }
+      return null;
+    }
+  }
+  #native() {
+    if (!this.#session)
+      throw new VoiceError2("No DAVE session.");
+    return this.#session;
+  }
+  destroy() {
+    try {
+      this.#session?.reset();
+    } catch {}
+    this.#session = undefined;
+  }
+}
+
+// packages/voice/src/gateway.ts
+var globalVoiceSocket = (url) => new WebSocket(url);
+var HEARTBEAT_TIMEOUT_CLOSE2 = 3001;
+function voiceGatewayURL2(endpoint) {
+  const host = endpoint.replace(/^wss?:\/\//, "").replace(/\/.*$/, "");
+  return `wss://${host}/?v=${VOICE_GATEWAY_VERSION2}`;
+}
+
+class VoiceGateway2 {
+  sequence;
+  #socket;
+  #handlers;
+  #heartbeat;
+  #closed = false;
+  constructor(url, handlers, options = {}) {
+    this.sequence = options.sequence ?? -1;
+    this.#handlers = handlers;
+    this.#socket = (options.factory ?? globalVoiceSocket)(url);
+    this.#socket.binaryType = "arraybuffer";
+    this.#heartbeat = new GatewayHeartbeat2({
+      ackTimeout: 15000,
+      zombieTimeout: 60000,
+      sequence: () => this.sequence,
+      isConnected: () => this.#socket.readyState === 1,
+      send: () => this.sendJSON({
+        op: VoiceOpcodes2.Heartbeat,
+        d: { t: Date.now(), seq_ack: this.sequence }
+      }),
+      onTimeout: () => this.close(HEARTBEAT_TIMEOUT_CLOSE2, "Heartbeat timed out."),
+      onError: (error) => this.#handlers.error(error)
+    });
+    this.#socket.addEventListener("open", () => {
+      this.#heartbeat.watch();
+      this.#handlers.open();
+    });
+    this.#socket.addEventListener("message", (event) => this.#message(event.data));
+    this.#socket.addEventListener("error", () => {});
+    this.#socket.addEventListener("close", (event) => {
+      this.#heartbeat.stop();
+      if (this.#closed)
+        return;
+      this.#closed = true;
+      this.#handlers.close(event.code, event.reason ?? "");
+    });
+  }
+  get ping() {
+    return this.#heartbeat.latency;
+  }
+  #message(data) {
+    this.#heartbeat.receivedMessage();
+    if (data instanceof ArrayBuffer || data instanceof Uint8Array) {
+      const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+      if (bytes.length < 3)
+        return;
+      const seq = bytes[0] << 8 | bytes[1];
+      this.sequence = seq;
+      this.#handlers.binary({
+        seq,
+        op: bytes[2],
+        payload: bytes.subarray(3)
+      });
+      return;
+    }
+    if (typeof data !== "string")
+      return;
+    let packet;
+    try {
+      packet = JSON.parse(data);
+    } catch {
+      this.#handlers.error(new Error("The voice gateway sent invalid JSON."));
+      return;
+    }
+    if (!packet || typeof packet.op !== "number")
+      return;
+    if (typeof packet.seq === "number")
+      this.sequence = packet.seq;
+    if (packet.op === VoiceOpcodes2.Hello) {
+      const interval = packet.d?.heartbeat_interval;
+      if (typeof interval === "number" && interval > 0)
+        this.#heartbeat.start(interval);
+    } else if (packet.op === VoiceOpcodes2.HeartbeatAck)
+      this.#heartbeat.acknowledge();
+    this.#handlers.packet(packet);
+  }
+  sendJSON(packet) {
+    if (this.#socket.readyState !== 1)
+      return false;
+    try {
+      this.#socket.send(JSON.stringify(packet));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  sendBinary(op, payload) {
+    if (this.#socket.readyState !== 1)
+      return false;
+    const frame = new Uint8Array(payload.length + 1);
+    frame[0] = op;
+    frame.set(payload, 1);
+    try {
+      this.#socket.send(frame);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  close(code = 1000, reason = "") {
+    this.#heartbeat.stop();
+    const reported = this.#closed;
+    this.#closed = true;
+    try {
+      this.#socket.close(code, reason);
+    } catch {}
+    if (!reported && code !== 1000)
+      this.#handlers.close(code, reason);
+  }
+}
+
+// packages/voice/src/udp.ts
+var bunUdpSocket2 = async (onData) => await Bun.udpSocket({
+  socket: {
+    data: (_socket, data) => onData(new Uint8Array(data)),
+    error: () => {
+      return;
+    }
+  }
+});
+var KEEPALIVE_MS = 5000;
+var DISCOVERY_TIMEOUT_MS = 5000;
+function discoveryRequest2(ssrc) {
+  const packet = new Uint8Array(74);
+  const view = new DataView(packet.buffer);
+  view.setUint16(0, 1);
+  view.setUint16(2, 70);
+  view.setUint32(4, ssrc >>> 0);
+  return packet;
+}
+function parseDiscoveryResponse2(packet) {
+  if (packet.length !== 74)
+    return;
+  const view = new DataView(packet.buffer, packet.byteOffset, packet.byteLength);
+  if (view.getUint16(0) !== 2 || view.getUint16(2) !== 70)
+    return;
+  const end = packet.indexOf(0, 8);
+  const ip = new TextDecoder().decode(packet.subarray(8, end === -1 || end > 72 ? 72 : end));
+  if (!/^\d{1,3}(?:\.\d{1,3}){3}$/.test(ip))
+    return;
+  return { ip, port: view.getUint16(72) };
+}
+
+class VoiceUdp2 {
+  #socket;
+  #ip;
+  #port;
+  #keepalive;
+  #listeners = new Set;
+  #discoveries = new Set;
+  #counter = 0;
+  #closed = false;
+  constructor(socket, ip, port) {
+    this.#socket = socket;
+    this.#ip = ip;
+    this.#port = port;
+    this.#keepalive = setInterval(() => this.#sendKeepalive(), KEEPALIVE_MS);
+    this.#keepalive.unref?.();
+  }
+  static async open(ip, port, factory = bunUdpSocket2) {
+    let udp;
+    const socket = await factory((data) => {
+      if (udp)
+        udp.#receive(data);
+    });
+    udp = new VoiceUdp2(socket, ip, port);
+    return udp;
+  }
+  get closed() {
+    return this.#closed;
+  }
+  onPacket(listener) {
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
+  }
+  send(packet) {
+    if (this.#closed)
+      return false;
+    try {
+      return this.#socket.send(packet, this.#port, this.#ip);
+    } catch {
+      return false;
+    }
+  }
+  discover(ssrc, timeoutMs = DISCOVERY_TIMEOUT_MS) {
+    return new Promise((resolve, reject) => {
+      const settle = (error, found) => {
+        clearTimeout(timer);
+        remove();
+        this.#discoveries.delete(abort);
+        if (error)
+          reject(error);
+        else
+          resolve(found);
+      };
+      const abort = () => settle(new VoiceError2("The voice UDP socket is closed."));
+      const timer = setTimeout(() => settle(new VoiceError2("IP discovery timed out.")), timeoutMs);
+      const remove = this.onPacket((packet) => {
+        const found = parseDiscoveryResponse2(packet);
+        if (found)
+          settle(undefined, found);
+      });
+      this.#discoveries.add(abort);
+      if (!this.send(discoveryRequest2(ssrc)))
+        abort();
+    });
+  }
+  #sendKeepalive() {
+    const packet = new Uint8Array(8);
+    new DataView(packet.buffer).setUint32(0, this.#counter, true);
+    this.#counter = this.#counter + 1 >>> 0;
+    this.send(packet);
+  }
+  #receive(data) {
+    if (this.#closed)
+      return;
+    for (const listener of [...this.#listeners])
+      try {
+        listener(data);
+      } catch {}
+  }
+  close() {
+    if (this.#closed)
+      return;
+    this.#closed = true;
+    clearInterval(this.#keepalive);
+    for (const abort of [...this.#discoveries])
+      abort();
+    this.#listeners.clear();
+    try {
+      this.#socket.close();
+    } catch {}
+  }
+}
+
+// packages/voice/src/networking.ts
+var RESUME_ATTEMPTS = 5;
+var RESUME_DELAY_MS = 250;
+var RESUME_MAX_DELAY_MS = 1e4;
+
+class VoiceNetworking2 {
+  state = "opening";
+  ssrc = 0;
+  mode;
+  #info;
+  #options;
+  #handlers;
+  #gateway;
+  #udp;
+  #cipher;
+  #dave;
+  #maxDave = 0;
+  #daveModule = null;
+  #sequence = Math.floor(Math.random() * 65536);
+  #timestamp = Math.floor(Math.random() * 4294967296);
+  #speaking = false;
+  #resumeAttempts = 0;
+  #resumeTimer;
+  #encryptFailing = false;
+  #users = new Map;
+  #connected = new Set;
+  constructor(info, handlers = {}, options = {}) {
+    this.#info = info;
+    this.#handlers = handlers;
+    this.#options = options;
+    this.#gateway = this.#openGateway();
+  }
+  get ping() {
+    return this.#gateway.ping;
+  }
+  get dave() {
+    return this.#dave;
+  }
+  get connectedUsers() {
+    return this.#connected;
+  }
+  #debug(message) {
+    this.#options.debug?.(message);
+  }
+  #setState(next) {
+    if (this.state === next)
+      return;
+    const previous = this.state;
+    this.state = next;
+    this.#handlers.state?.(next, previous);
+  }
+  #error(error) {
+    this.#handlers.error?.(error instanceof Error ? error : new VoiceError2(String(error)));
+  }
+  #openGateway(sequence) {
+    return new VoiceGateway2(typeof this.#options.url === "function" ? this.#options.url(this.#info.endpoint) : this.#options.url ?? voiceGatewayURL2(this.#info.endpoint), {
+      open: () => void this.#onOpen(),
+      packet: (packet) => this.#onPacket(packet),
+      binary: (packet) => this.#onBinary(packet),
+      close: (code, reason) => this.#onClose(code, reason),
+      error: (error) => this.#error(error)
+    }, { factory: this.#options.socketFactory, sequence });
+  }
+  async#onOpen() {
+    const { guildId, userId, sessionId, token } = this.#info;
+    if (this.state === "resuming") {
+      this.#gateway.sendJSON({
+        op: VoiceOpcodes2.Resume,
+        d: {
+          server_id: guildId,
+          session_id: sessionId,
+          token,
+          seq_ack: this.#gateway.sequence
+        }
+      });
+      return;
+    }
+    if (this.state !== "opening")
+      return;
+    this.#daveModule = this.#options.dave === false ? null : this.#options.daveModule ?? await loadDave2();
+    this.#maxDave = this.#daveModule?.DAVE_PROTOCOL_VERSION ?? 0;
+    if (this.state !== "opening")
+      return;
+    this.#gateway.sendJSON({
+      op: VoiceOpcodes2.Identify,
+      d: {
+        server_id: guildId,
+        user_id: userId,
+        session_id: sessionId,
+        token,
+        max_dave_protocol_version: this.#maxDave
+      }
+    });
+    this.#setState("identifying");
+  }
+  #onPacket(packet) {
+    const d = packet.d ?? {};
+    switch (packet.op) {
+      case VoiceOpcodes2.Ready:
+        if (this.state === "identifying")
+          this.#onReady(d);
+        return;
+      case VoiceOpcodes2.SessionDescription:
+        if (this.state === "selecting")
+          this.#onSession(d);
+        return;
+      case VoiceOpcodes2.Resumed:
+        if (this.state === "resuming") {
+          this.#speaking = false;
+          this.#resumeAttempts = 0;
+          this.#setState("ready");
+        }
+        return;
+      case VoiceOpcodes2.Speaking:
+        if (typeof d.user_id === "string" && typeof d.ssrc === "number") {
+          this.#users.set(d.ssrc, d.user_id);
+          this.#handlers.speaking?.(d.user_id, d.ssrc);
+        }
+        return;
+      case VoiceOpcodes2.ClientsConnect:
+        if (Array.isArray(d.user_ids)) {
+          for (const id of d.user_ids)
+            if (typeof id === "string")
+              this.#connected.add(id);
+        }
+        return;
+      case VoiceOpcodes2.ClientDisconnect:
+        if (typeof d.user_id === "string") {
+          this.#connected.delete(d.user_id);
+          for (const [ssrc, user] of this.#users)
+            if (user === d.user_id)
+              this.#users.delete(ssrc);
+          this.#handlers.clientDisconnect?.(d.user_id);
+        }
+        return;
+    }
+    const dave = this.#dave;
+    if (!dave || this.state !== "ready" && this.state !== "resuming")
+      return;
+    const transitionId = Number(d.transition_id ?? 0);
+    if (packet.op === VoiceOpcodes2.DavePrepareTransition) {
+      if (dave.prepareTransition(transitionId, Number(d.protocol_version ?? 0)))
+        this.#gateway.sendJSON({
+          op: VoiceOpcodes2.DaveTransitionReady,
+          d: { transition_id: transitionId }
+        });
+    } else if (packet.op === VoiceOpcodes2.DaveExecuteTransition)
+      dave.executeTransition(transitionId);
+    else if (packet.op === VoiceOpcodes2.DavePrepareEpoch)
+      dave.prepareEpoch(Number(d.epoch ?? 0), Number(d.protocol_version ?? 0));
+  }
+  #onBinary(packet) {
+    const dave = this.#dave;
+    if (!dave || this.state !== "ready")
+      return;
+    try {
+      switch (packet.op) {
+        case VoiceOpcodes2.DaveMlsExternalSender:
+          dave.setExternalSender(packet.payload);
+          return;
+        case VoiceOpcodes2.DaveMlsProposals: {
+          const reply = dave.processProposals(packet.payload, this.#connected);
+          if (reply)
+            this.#gateway.sendBinary(VoiceOpcodes2.DaveMlsCommitWelcome, reply);
+          return;
+        }
+        case VoiceOpcodes2.DaveMlsAnnounceCommitTransition:
+        case VoiceOpcodes2.DaveMlsWelcome: {
+          const { transitionId, ok } = dave.process(packet.op === VoiceOpcodes2.DaveMlsWelcome ? "welcome" : "commit", packet.payload);
+          if (ok && transitionId !== 0)
+            this.#gateway.sendJSON({
+              op: VoiceOpcodes2.DaveTransitionReady,
+              d: { transition_id: transitionId }
+            });
+          return;
+        }
+      }
+    } catch (error) {
+      this.#error(error);
+    }
+  }
+  async#onReady(d) {
+    const { ssrc, ip, port, modes } = d;
+    this.ssrc = ssrc;
+    this.#setState("discovering");
+    try {
+      const mode = chooseEncryptionMode2(Array.isArray(modes) ? modes : []);
+      const udp = await VoiceUdp2.open(ip, port, this.#options.udpFactory);
+      if (this.state !== "discovering")
+        return void udp.close();
+      this.#udp = udp;
+      udp.onPacket((packet) => this.#receive(packet));
+      const local = await udp.discover(ssrc);
+      if (this.state !== "discovering")
+        return;
+      this.#gateway.sendJSON({
+        op: VoiceOpcodes2.SelectProtocol,
+        d: {
+          protocol: "udp",
+          data: { address: local.ip, port: local.port, mode }
+        }
+      });
+      this.#setState("selecting");
+    } catch (error) {
+      if (this.state === "closed")
+        return;
+      this.#error(error);
+      this.destroy();
+      this.#handlers.close?.(4000, error instanceof Error ? error.message : String(error));
+    }
+  }
+  #onSession(d) {
+    const key = d.secret_key;
+    if (!Array.isArray(key) || typeof d.mode !== "string")
+      return;
+    try {
+      this.#cipher = new PacketCipher2(d.mode, Uint8Array.from(key));
+    } catch (error) {
+      this.#error(error);
+      return;
+    }
+    this.mode = this.#cipher.mode;
+    const daveVersion = Number(d.dave_protocol_version ?? 0);
+    const module = this.#daveModule;
+    if (module && this.#maxDave > 0) {
+      this.#dave = new DaveSession2(module, daveVersion, this.#info.userId, this.#info.channelId, {
+        keyPackage: (payload) => this.#gateway.sendBinary(VoiceOpcodes2.DaveMlsKeyPackage, payload),
+        invalidTransition: (transitionId) => this.#gateway.sendJSON({
+          op: VoiceOpcodes2.DaveMlsInvalidCommitWelcome,
+          d: { transition_id: transitionId }
+        }),
+        debug: (message) => this.#debug(message)
+      });
+    }
+    this.#setState("ready");
+    this.#dave?.reinit();
+  }
+  #onClose(code, reason) {
+    if (this.state === "closed")
+      return;
+    if (canResumeVoice2(code) && (this.state === "ready" || this.state === "resuming")) {
+      const resume = this.#options.resume ?? {};
+      if (this.#resumeAttempts < (resume.attempts ?? RESUME_ATTEMPTS)) {
+        const base = Math.min((resume.delay ?? RESUME_DELAY_MS) * 2 ** this.#resumeAttempts, resume.maxDelay ?? RESUME_MAX_DELAY_MS);
+        const delay = Math.round(base / 2 + Math.random() * base / 2);
+        this.#resumeAttempts++;
+        this.#debug(`Voice gateway closed (${code}); resuming in ${delay} ms (attempt ${this.#resumeAttempts}).`);
+        this.#setState("resuming");
+        const sequence = this.#gateway.sequence;
+        this.#resumeTimer = setTimeout(() => {
+          this.#resumeTimer = undefined;
+          if (this.state === "resuming")
+            this.#gateway = this.#openGateway(sequence);
+        }, delay);
+        this.#resumeTimer.unref?.();
+        return;
+      }
+      this.destroy();
+      this.#handlers.close?.(code, `${reason ? `${reason} ` : ""}Could not resume the voice session after ${this.#resumeAttempts} attempts.`);
+      return;
+    }
+    this.destroy();
+    const hint = code === VoiceCloseCodes2.DaveProtocolRequired && this.#maxDave === 0 ? " Discord requires end-to-end encryption (DAVE): install @snazzah/davey." : "";
+    this.#handlers.close?.(code, `${reason}${hint}`.trim());
+  }
+  #receive(packet) {
+    const cipher = this.#cipher;
+    if (!cipher)
+      return;
+    const header = parseRtpHeader2(packet);
+    if (!header || header.payloadType !== RTP_OPUS_PAYLOAD_TYPE2)
+      return;
+    const userId = this.#users.get(header.ssrc);
+    if (!userId)
+      return;
+    const opened = cipher.open(packet);
+    if (!opened)
+      return;
+    const frame = this.#dave ? this.#dave.decrypt(opened.payload, userId) : opened.payload;
+    if (frame)
+      this.#handlers.audio?.(userId, frame);
+  }
+  setSpeaking(speaking, flags = 1) {
+    if (this.state !== "ready" || this.#speaking === speaking)
+      return;
+    this.#speaking = speaking;
+    this.#gateway.sendJSON({
+      op: VoiceOpcodes2.Speaking,
+      d: { speaking: speaking ? flags : 0, delay: 0, ssrc: this.ssrc }
+    });
+  }
+  sendFrame(frame) {
+    const cipher = this.#cipher;
+    const udp = this.#udp;
+    if (this.state !== "ready" || !cipher || !udp)
+      return false;
+    this.setSpeaking(true);
+    const header = rtpHeader2(this.#sequence, this.#timestamp, this.ssrc);
+    this.#sequence = this.#sequence + 1 & 65535;
+    this.#timestamp = this.#timestamp + FRAME_SAMPLES2 >>> 0;
+    let payload = frame;
+    if (this.#dave)
+      try {
+        payload = this.#dave.encrypt(frame);
+        this.#encryptFailing = false;
+      } catch (error) {
+        if (!this.#encryptFailing)
+          this.#error(new VoiceError2(`DAVE could not encrypt a frame; frames are dropped until it can: ${error instanceof Error ? error.message : String(error)}`, { cause: error }));
+        this.#encryptFailing = true;
+        return false;
+      }
+    if (!payload)
+      return false;
+    return udp.send(cipher.seal(header, payload));
+  }
+  destroy() {
+    if (this.state === "closed")
+      return;
+    this.#setState("closed");
+    if (this.#resumeTimer)
+      clearTimeout(this.#resumeTimer);
+    this.#resumeTimer = undefined;
+    this.#gateway.close(1000, "Voice session ended.");
+    this.#udp?.close();
+    this.#udp = undefined;
+    this.#dave?.destroy();
+    this.#dave = undefined;
+    this.#cipher = undefined;
+    this.#users.clear();
+    this.#connected.clear();
+  }
+}
+
+// packages/voice/src/emitter.ts
+class Emitter {
+  #listeners = new Map;
+  on(event, listener) {
+    if (typeof listener !== "function")
+      throw new TypeError("Listener must be a function.");
+    let set = this.#listeners.get(event);
+    if (!set)
+      this.#listeners.set(event, set = new Set);
+    set.add(listener);
+    return this;
+  }
+  off(event, listener) {
+    this.#listeners.get(event)?.delete(listener);
+    return this;
+  }
+  emit(event, ...args) {
+    const set = this.#listeners.get(event);
+    if (!set)
+      return;
+    for (const listener of [...set])
+      try {
+        listener(...args);
+      } catch {}
+  }
+  removeAllListeners() {
+    this.#listeners.clear();
+  }
+}
+
+// packages/voice/src/ogg.ts
+var CAPTURE = [79, 103, 103, 83];
+var OPUS_HEAD = "OpusHead";
+var OPUS_TAGS = "OpusTags";
+var MAX_PAGE = 27 + 255 + 255 * 255;
+var MAX_PACKET = 64 * 1024;
+function startsWith(bytes, text) {
+  if (bytes.length < text.length)
+    return false;
+  for (let i = 0;i < text.length; i++)
+    if (bytes[i] !== text.charCodeAt(i))
+      return false;
+  return true;
+}
+function findCapture(buffer, from) {
+  for (let i = from;i + 4 <= buffer.length; i++)
+    if (buffer[i] === CAPTURE[0] && buffer[i + 1] === CAPTURE[1] && buffer[i + 2] === CAPTURE[2] && buffer[i + 3] === CAPTURE[3])
+      return i;
+  return -1;
+}
+async function* demuxOggOpus2(chunks) {
+  let buffer = new Uint8Array(0);
+  let partial = [];
+  let partialSize = 0;
+  let sawHead = false;
+  let skipped = 0;
+  const take = (bytes) => {
+    if (partial.length === 0)
+      return bytes;
+    partial.push(bytes);
+    const out = new Uint8Array(partialSize + bytes.length);
+    let offset = 0;
+    for (const part of partial) {
+      out.set(part, offset);
+      offset += part.length;
+    }
+    partial = [];
+    partialSize = 0;
+    return out;
+  };
+  for await (const chunk of chunks) {
+    const merged = new Uint8Array(buffer.length + chunk.length);
+    merged.set(buffer, 0);
+    merged.set(chunk, buffer.length);
+    buffer = merged;
+    let offset = 0;
+    for (;; ) {
+      const start = findCapture(buffer, offset);
+      if (start === -1) {
+        offset = Math.max(offset, buffer.length - 3);
+        break;
+      }
+      if (buffer.length < start + 27) {
+        offset = start;
+        break;
+      }
+      const segments = buffer[start + 26];
+      const dataStart = start + 27 + segments;
+      if (buffer.length < dataStart) {
+        offset = start;
+        break;
+      }
+      let size = 0;
+      for (let i = 0;i < segments; i++)
+        size += buffer[start + 27 + i];
+      if (buffer.length < dataStart + size) {
+        offset = start;
+        break;
+      }
+      let cursor = dataStart;
+      for (let i = 0;i < segments; i++) {
+        const length = buffer[start + 27 + i];
+        const segment = buffer.slice(cursor, cursor + length);
+        cursor += length;
+        if (length === 255) {
+          partial.push(segment);
+          partialSize += length;
+          if (partialSize > MAX_PACKET)
+            throw new VoiceError2("An Ogg packet is too large to be Opus audio.");
+          continue;
+        }
+        const packet = take(segment);
+        if (!packet || packet.length === 0)
+          continue;
+        if (startsWith(packet, OPUS_HEAD)) {
+          const channels = packet[9] ?? 0;
+          if (channels < 1 || channels > 2)
+            throw new VoiceError2(`Unsupported Opus channel count: ${channels}.`);
+          sawHead = true;
+          continue;
+        }
+        if (startsWith(packet, OPUS_TAGS))
+          continue;
+        if (!sawHead)
+          throw new VoiceError2("The Ogg stream does not carry Opus audio.");
+        yield packet;
+      }
+      offset = cursor;
+    }
+    if (!sawHead && findCapture(buffer, 0) === -1)
+      skipped += offset;
+    buffer = buffer.slice(offset);
+    if (buffer.length > MAX_PAGE || skipped > MAX_PAGE)
+      throw new VoiceError2("The input is not an Ogg stream.");
+  }
+  if (!sawHead && (skipped > 0 || buffer.length > 0))
+    throw new VoiceError2("The input is not an Ogg/Opus stream.");
+}
+var CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let i = 0;i < 256; i++) {
+    let r = i << 24;
+    for (let j = 0;j < 8; j++)
+      r = r & 2147483648 ? r << 1 ^ 79764919 : r << 1;
+    table[i] = r >>> 0;
+  }
+  return table;
+})();
+function oggCrc(bytes) {
+  let crc = 0;
+  for (const byte of bytes)
+    crc = (crc << 8 ^ CRC_TABLE[(crc >>> 24 ^ byte) & 255]) >>> 0;
+  return crc;
+}
+
+class OggOpusWriter2 {
+  #serial;
+  #sequence = 0;
+  #granule = 0n;
+  #packets = [];
+  #lacing = 0;
+  #ended = false;
+  constructor(serial = Math.random() * 4294967296 >>> 0) {
+    this.#serial = serial;
+  }
+  header(vendor = "lunibee") {
+    const head = new Uint8Array(19);
+    head.set(new TextEncoder().encode(OPUS_HEAD));
+    const view = new DataView(head.buffer);
+    head[8] = 1;
+    head[9] = 2;
+    view.setUint16(10, 0, true);
+    view.setUint32(12, 48000, true);
+    const vendorBytes = new TextEncoder().encode(vendor);
+    const tags = new Uint8Array(8 + 4 + vendorBytes.length + 4);
+    tags.set(new TextEncoder().encode(OPUS_TAGS));
+    const tagsView = new DataView(tags.buffer);
+    tagsView.setUint32(8, vendorBytes.length, true);
+    tags.set(vendorBytes, 12);
+    return concat([
+      this.#page([head], 2, 0n),
+      this.#page([tags], 0, 0n)
+    ]);
+  }
+  write(packet) {
+    if (this.#ended)
+      throw new VoiceError2("The Ogg stream has ended.");
+    const lacing = Math.floor(packet.length / 255) + 1;
+    if (lacing > 255)
+      throw new VoiceError2("An Opus packet is too large for one page.");
+    const before = this.#lacing + lacing > 255 ? this.flush() : undefined;
+    this.#packets.push(packet);
+    this.#lacing += lacing;
+    this.#granule += 960n;
+    const after = this.#packets.length >= 50 ? this.flush() : new Uint8Array(0);
+    return before ? concat([before, after]) : after;
+  }
+  flush() {
+    if (this.#packets.length === 0)
+      return new Uint8Array(0);
+    const packets = this.#packets;
+    this.#packets = [];
+    this.#lacing = 0;
+    return this.#page(packets, 0, this.#granule);
+  }
+  end() {
+    if (this.#ended)
+      return new Uint8Array(0);
+    this.#ended = true;
+    const packets = this.#packets;
+    this.#packets = [];
+    this.#lacing = 0;
+    return this.#page(packets, 4, this.#granule);
+  }
+  #page(packets, flags, granule) {
+    const lacing = [];
+    for (const packet of packets) {
+      let left = packet.length;
+      while (left >= 255) {
+        lacing.push(255);
+        left -= 255;
+      }
+      lacing.push(left);
+    }
+    const body = concat(packets);
+    const page = new Uint8Array(27 + lacing.length + body.length);
+    const view = new DataView(page.buffer);
+    page.set(CAPTURE);
+    page[5] = flags;
+    view.setBigUint64(6, granule, true);
+    view.setUint32(14, this.#serial, true);
+    view.setUint32(18, this.#sequence++, true);
+    page[26] = lacing.length;
+    page.set(lacing, 27);
+    page.set(body, 27 + lacing.length);
+    view.setUint32(22, oggCrc(page), true);
+    return page;
+  }
+}
+function concat(parts) {
+  let length = 0;
+  for (const part of parts)
+    length += part.length;
+  const out = new Uint8Array(length);
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+
+// packages/voice/src/receiver.ts
+var GAP_MS = 60;
+var MAX_GAP_FRAMES = 3600000 / FRAME_DURATION_MS2;
+function isSilence(frame) {
+  return frame.length === SILENCE_FRAME2.length && frame.every((byte, i) => byte === SILENCE_FRAME2[i]);
+}
+
+class VoiceReceiver2 {
+  #subscriptions = new Map;
+  #ssrcs = new Map;
+  #speaking = new Map;
+  #listeners = new Map;
+  ssrcOf(userId) {
+    return this.#ssrcs.get(userId);
+  }
+  get speaking() {
+    return new Set(this.#speaking.keys());
+  }
+  on(event, listener) {
+    let set = this.#listeners.get(event);
+    if (!set)
+      this.#listeners.set(event, set = new Set);
+    set.add(listener);
+    return this;
+  }
+  off(event, listener) {
+    this.#listeners.get(event)?.delete(listener);
+    return this;
+  }
+  #emit(event, userId) {
+    for (const listener of this.#listeners.get(event) ?? [])
+      try {
+        listener(userId);
+      } catch {}
+  }
+  subscribe(userId, options = {}) {
+    const end = options.end ?? { behavior: "silence" };
+    let subscription;
+    return new ReadableStream({
+      start: (controller) => {
+        subscription = {
+          end,
+          deliver: (frame) => {
+            if ((controller.desiredSize ?? 1) > 0)
+              controller.enqueue(frame);
+          },
+          close: () => controller.close()
+        };
+        this.#add(userId, subscription);
+      },
+      cancel: () => {
+        if (subscription)
+          this.#remove(userId, subscription);
+      }
+    }, { highWaterMark: options.highWaterMark ?? 50 });
+  }
+  record(userId, options = {}) {
+    const end = options.end ?? { behavior: "manual" };
+    const writer = new OggOpusWriter2;
+    let subscription;
+    return new ReadableStream({
+      start: (controller) => {
+        const emit = (bytes) => {
+          if (bytes.length > 0)
+            controller.enqueue(bytes);
+        };
+        emit(writer.header());
+        let last = performance.now();
+        subscription = {
+          end,
+          deliver: (frame) => {
+            if ((controller.desiredSize ?? 1) <= 0)
+              return;
+            const now = performance.now();
+            const gap = now - last;
+            if (gap > GAP_MS) {
+              const missing = Math.min(Math.round(gap / FRAME_DURATION_MS2) - 1, MAX_GAP_FRAMES);
+              for (let i = 0;i < missing && (controller.desiredSize ?? 1) > 0; i++)
+                emit(writer.write(SILENCE_FRAME2));
+            }
+            last = now;
+            emit(writer.write(frame));
+          },
+          close: () => {
+            emit(writer.end());
+            controller.close();
+          }
+        };
+        this.#add(userId, subscription);
+      },
+      cancel: () => {
+        if (subscription)
+          this.#remove(userId, subscription);
+      }
+    }, new ByteLengthQueuingStrategy({
+      highWaterMark: options.highWaterMark ?? 1024 * 1024
+    }));
+  }
+  #add(userId, subscription) {
+    let set = this.#subscriptions.get(userId);
+    if (!set)
+      this.#subscriptions.set(userId, set = new Set);
+    set.add(subscription);
+    this.#arm(userId, subscription);
+  }
+  unsubscribe(userId) {
+    const set = this.#subscriptions.get(userId);
+    if (!set)
+      return false;
+    for (const subscription of [...set])
+      this.#close(userId, subscription);
+    return true;
+  }
+  #arm(userId, subscription) {
+    if (subscription.end.behavior !== "silence")
+      return;
+    if (subscription.timer)
+      clearTimeout(subscription.timer);
+    subscription.timer = setTimeout(() => this.#close(userId, subscription), subscription.end.duration ?? 1000);
+  }
+  #remove(userId, subscription) {
+    if (subscription.timer)
+      clearTimeout(subscription.timer);
+    const set = this.#subscriptions.get(userId);
+    set?.delete(subscription);
+    if (set?.size === 0)
+      this.#subscriptions.delete(userId);
+  }
+  #close(userId, subscription) {
+    this.#remove(userId, subscription);
+    try {
+      subscription.close();
+    } catch {}
+  }
+  mapUser(userId, ssrc) {
+    this.#ssrcs.set(userId, ssrc);
+  }
+  forgetUser(userId) {
+    this.#ssrcs.delete(userId);
+    this.unsubscribe(userId);
+  }
+  push(userId, frame) {
+    const silent = isSilence(frame);
+    if (!silent)
+      this.#markSpeaking(userId);
+    const set = this.#subscriptions.get(userId);
+    if (!set)
+      return;
+    for (const subscription of set) {
+      if (!silent)
+        this.#arm(userId, subscription);
+      try {
+        subscription.deliver(frame);
+      } catch {}
+    }
+  }
+  #markSpeaking(userId) {
+    const timer = this.#speaking.get(userId);
+    if (timer)
+      clearTimeout(timer);
+    else
+      this.#emit("start", userId);
+    this.#speaking.set(userId, setTimeout(() => {
+      this.#speaking.delete(userId);
+      this.#emit("end", userId);
+    }, 100));
+  }
+  close() {
+    for (const [userId, set] of [...this.#subscriptions])
+      for (const subscription of [...set])
+        this.#close(userId, subscription);
+    for (const timer of this.#speaking.values())
+      clearTimeout(timer);
+    this.#speaking.clear();
+    this.#ssrcs.clear();
+  }
+}
+
+// packages/voice/src/connection.ts
+var VoiceConnectionStatus2 = {
+  Signalling: "signalling",
+  Connecting: "connecting",
+  Ready: "ready",
+  Disconnected: "disconnected",
+  Destroyed: "destroyed"
+};
+
+class VoiceConnection2 extends Emitter {
+  status = "signalling";
+  guildId;
+  channelId;
+  selfMute;
+  selfDeaf;
+  disconnectReason;
+  receiver = new VoiceReceiver2;
+  #options;
+  #adapter;
+  #networking;
+  #sessionId;
+  #sessionChannel;
+  #userId;
+  #token;
+  #endpoint;
+  #timer;
+  #leaving = false;
+  #subscription;
+  #sink;
+  constructor(options) {
+    super();
+    if (!options.guildId?.trim())
+      throw new TypeError("A guild ID is required.");
+    if (!options.channelId?.trim())
+      throw new TypeError("A voice channel ID is required.");
+    if (typeof options.adapterCreator !== "function")
+      throw new TypeError("An adapterCreator is required.");
+    this.#options = { ...options };
+    this.guildId = options.guildId;
+    this.channelId = options.channelId;
+    this.selfMute = options.selfMute ?? false;
+    this.selfDeaf = options.selfDeaf ?? false;
+    const self = this;
+    this.#sink = {
+      get ready() {
+        return self.status === "ready";
+      },
+      sendFrame: (frame) => this.#networking?.sendFrame(frame) ?? false,
+      setSpeaking: (speaking) => this.#networking?.setSpeaking(speaking)
+    };
+    this.#adapter = options.adapterCreator({
+      onVoiceStateUpdate: (data) => this.#onState(data),
+      onVoiceServerUpdate: (data) => this.#onServer(data),
+      destroy: () => this.destroy(false)
+    });
+    this.#signal();
+  }
+  get ping() {
+    return this.#networking?.ping ?? -1;
+  }
+  get voicePrivacyCode() {
+    return this.#networking?.dave?.voicePrivacyCode ?? null;
+  }
+  get endToEndEncrypted() {
+    return this.#networking?.dave?.active ?? false;
+  }
+  get subscription() {
+    return this.#subscription;
+  }
+  #debug(message) {
+    this.#options.debug?.(message);
+    this.emit("debug", message);
+  }
+  #setStatus(next, reason) {
+    if (this.status === "destroyed")
+      return;
+    this.disconnectReason = next === "disconnected" ? reason : undefined;
+    if (next === "ready" || next === "disconnected" || next === "destroyed")
+      this.#clearTimer();
+    if (this.status === next)
+      return;
+    const previous = this.status;
+    this.status = next;
+    this.emit("stateChange", next, previous);
+    this.#subscription?.player.refresh();
+  }
+  #clearTimer() {
+    if (this.#timer)
+      clearTimeout(this.#timer);
+    this.#timer = undefined;
+  }
+  #signal() {
+    this.#leaving = false;
+    this.#setStatus("signalling");
+    this.#clearTimer();
+    const timeout = this.#options.timeout ?? 15000;
+    this.#timer = setTimeout(() => {
+      this.#timer = undefined;
+      if (this.status !== "signalling" && this.status !== "connecting")
+        return;
+      this.#networking?.destroy();
+      this.#networking = undefined;
+      this.#setStatus("disconnected", {
+        reason: "timeout",
+        message: `No voice connection within ${timeout} ms.`
+      });
+      this.emit("error", new VoiceError2(`Joining the voice channel timed out after ${timeout} ms.`));
+    }, timeout);
+    this.#timer.unref?.();
+    if (this.#send(this.channelId))
+      return true;
+    this.#setStatus("disconnected", {
+      reason: "unsent",
+      message: "The voice state update could not be sent: the client is not connected, or the guild is on another shard."
+    });
+    return false;
+  }
+  #send(channelId) {
+    try {
+      return this.#adapter.sendPayload({
+        op: 4,
+        d: {
+          guild_id: this.guildId,
+          channel_id: channelId,
+          self_mute: this.selfMute,
+          self_deaf: this.selfDeaf
+        }
+      });
+    } catch (error) {
+      this.emit("error", error instanceof Error ? error : new VoiceError2(String(error)));
+      return false;
+    }
+  }
+  #onState(data) {
+    if (this.status === "destroyed")
+      return;
+    if (data.channel_id === null) {
+      this.#networking?.destroy();
+      this.#networking = undefined;
+      this.receiver.close();
+      this.#sessionChannel = undefined;
+      this.#setStatus("disconnected", {
+        reason: this.#leaving ? "left" : "removed"
+      });
+      return;
+    }
+    const moved = data.channel_id !== this.#sessionChannel;
+    const newSession = data.session_id !== this.#sessionId;
+    this.#sessionId = data.session_id;
+    this.#userId = data.user_id;
+    this.channelId = data.channel_id;
+    if (moved || newSession || !this.#networking)
+      this.#connect();
+    else if (this.status === "signalling" && this.#networking.state === "ready")
+      this.#setStatus("ready");
+  }
+  #onServer(data) {
+    if (this.status === "destroyed")
+      return;
+    if (data.endpoint === null) {
+      this.#networking?.destroy();
+      this.#networking = undefined;
+      if (this.status === "ready")
+        this.#setStatus("connecting");
+      if (this.status === "connecting" && !this.#timer)
+        this.#armReconnectTimeout();
+      return;
+    }
+    this.#token = data.token;
+    this.#endpoint = data.endpoint;
+    this.#connect();
+  }
+  #connect() {
+    const { channelId } = this;
+    const sessionId = this.#sessionId;
+    const userId = this.#userId;
+    const token = this.#token;
+    const endpoint = this.#endpoint;
+    if (!sessionId || !userId || !token || !endpoint)
+      return;
+    this.#sessionChannel = channelId;
+    this.#networking?.destroy();
+    this.#setStatus("connecting");
+    if (!this.#timer)
+      this.#armReconnectTimeout();
+    this.#debug(`Connecting to voice server ${endpoint}.`);
+    const networking = new VoiceNetworking2({
+      guildId: this.guildId,
+      channelId,
+      userId,
+      sessionId,
+      token,
+      endpoint
+    }, {
+      state: (state) => {
+        if (this.#networking !== networking)
+          return;
+        if (state === "ready")
+          this.#setStatus("ready");
+        else if (state === "resuming") {
+          this.#setStatus("connecting");
+          if (!this.#timer)
+            this.#armReconnectTimeout();
+        }
+      },
+      close: (code, reason) => {
+        if (this.#networking !== networking)
+          return;
+        this.#networking = undefined;
+        this.#setStatus("disconnected", {
+          reason: "closed",
+          code,
+          message: reason
+        });
+        if (reason)
+          this.emit("error", new VoiceError2(`Voice server closed the session (${code}): ${reason}`));
+      },
+      error: (error) => {
+        if (this.#networking === networking)
+          this.emit("error", error);
+      },
+      audio: (user, frame) => this.receiver.push(user, frame),
+      speaking: (user, ssrc) => this.receiver.mapUser(user, ssrc),
+      clientDisconnect: (user) => this.receiver.forgetUser(user)
+    }, {
+      dave: this.#options.dave,
+      debug: (message) => this.#debug(message),
+      ...this.#options.networking
+    });
+    this.#networking = networking;
+  }
+  #armReconnectTimeout() {
+    const timeout = this.#options.timeout ?? 15000;
+    this.#timer = setTimeout(() => {
+      this.#timer = undefined;
+      if (this.status !== "connecting")
+        return;
+      this.#networking?.destroy();
+      this.#networking = undefined;
+      this.#setStatus("disconnected", {
+        reason: "timeout",
+        message: `No voice server connection within ${timeout} ms.`
+      });
+    }, timeout);
+    this.#timer.unref?.();
+  }
+  rejoin(options = {}) {
+    if (this.status === "destroyed")
+      throw new VoiceError2("The voice connection was destroyed.");
+    if (options.channelId !== undefined) {
+      if (!options.channelId.trim())
+        throw new TypeError("A voice channel ID is required.");
+      this.channelId = options.channelId;
+    }
+    if (options.selfMute !== undefined)
+      this.selfMute = options.selfMute;
+    if (options.selfDeaf !== undefined)
+      this.selfDeaf = options.selfDeaf;
+    if (this.status === "ready" && (options.channelId === undefined || options.channelId === this.#sessionChannel))
+      return this.#send(this.channelId);
+    return this.#signal();
+  }
+  disconnect() {
+    if (this.status === "destroyed")
+      return false;
+    this.#leaving = true;
+    this.#clearTimer();
+    const sent = this.#send(null);
+    this.#networking?.destroy();
+    this.#networking = undefined;
+    this.receiver.close();
+    this.#setStatus("disconnected", { reason: "left" });
+    return sent;
+  }
+  destroy(leave = true) {
+    if (this.status === "destroyed")
+      return;
+    this.#clearTimer();
+    if (leave) {
+      this.#leaving = true;
+      this.#send(null);
+    }
+    this.#networking?.destroy();
+    this.#networking = undefined;
+    this.receiver.close();
+    this.#subscription?.unsubscribe();
+    const previous = this.status;
+    this.status = "destroyed";
+    this.disconnectReason = undefined;
+    this.emit("stateChange", "destroyed", previous);
+    try {
+      this.#adapter.destroy();
+    } catch {}
+    this.removeAllListeners();
+  }
+  subscribe(player) {
+    if (this.status === "destroyed")
+      throw new VoiceError2("The voice connection was destroyed.");
+    this.#subscription?.unsubscribe();
+    const subscription = {
+      connection: this,
+      player,
+      unsubscribe: () => {
+        player.detach(this.#sink);
+        if (this.#subscription === subscription)
+          this.#subscription = undefined;
+      }
+    };
+    this.#subscription = subscription;
+    player.attach(this.#sink);
+    return subscription;
+  }
+  setSpeaking(speaking) {
+    this.#networking?.setSpeaking(speaking);
+  }
+  playOpusPacket(frame) {
+    return this.#networking?.sendFrame(frame) ?? false;
+  }
+}
+var tracked = new Map;
+function joinVoiceChannel2(options) {
+  const existing = tracked.get(options.guildId);
+  if (existing && existing.status !== "destroyed") {
+    existing.rejoin(options);
+    return existing;
+  }
+  const connection = new VoiceConnection2(options);
+  tracked.set(options.guildId, connection);
+  connection.on("stateChange", (next) => {
+    if (next === "destroyed" && tracked.get(connection.guildId) === connection)
+      tracked.delete(connection.guildId);
+  });
+  return connection;
+}
+function getVoiceConnection2(guildId) {
+  return tracked.get(guildId);
+}
+
+class VoiceManager2 {
+  #client;
+  #connections = new Map;
+  #adapters = new Map;
+  #defaults;
+  constructor(client, defaults = {}) {
+    this.#client = client;
+    this.#defaults = defaults;
+  }
+  get connections() {
+    return this.#connections;
+  }
+  get(guildId) {
+    return this.#connections.get(guildId);
+  }
+  join(options) {
+    const merged = { ...this.#defaults, ...options };
+    if (this.#client.canSendVoiceState && !this.#client.canSendVoiceState(options.guildId))
+      return Promise.reject(new VoiceError2("Cannot send the voice state update: the client is not connected, or the guild is on another shard."));
+    let connection = this.#connections.get(options.guildId);
+    if (connection && connection.status !== "destroyed")
+      connection.rejoin(merged);
+    else {
+      connection = new VoiceConnection2({
+        ...merged,
+        adapterCreator: (methods) => {
+          this.#adapters.set(options.guildId, methods);
+          return {
+            sendPayload: (payload) => this.#client.sendVoiceState(payload.d.guild_id, payload.d.channel_id, {
+              selfMute: payload.d.self_mute,
+              selfDeaf: payload.d.self_deaf
+            }),
+            destroy: () => {
+              if (this.#adapters.get(options.guildId) === methods)
+                this.#adapters.delete(options.guildId);
+            }
+          };
+        }
+      });
+      const created = connection;
+      this.#connections.set(options.guildId, created);
+      created.on("stateChange", (next) => {
+        if (next === "destroyed" && this.#connections.get(created.guildId) === created)
+          this.#connections.delete(created.guildId);
+      });
+    }
+    return waitReady(connection, merged.timeout ?? 15000);
+  }
+  leave(guildId) {
+    const connection = this.#connections.get(guildId);
+    if (!connection)
+      return false;
+    connection.destroy();
+    return true;
+  }
+  handleVoiceState(data) {
+    if (!data.guild_id || data.user_id !== this.#client.userId)
+      return;
+    this.#adapters.get(data.guild_id)?.onVoiceStateUpdate(data);
+  }
+  handleVoiceServer(data) {
+    this.#adapters.get(data.guild_id)?.onVoiceServerUpdate(data);
+  }
+  handleGuildRemove(guildId) {
+    this.#connections.get(guildId)?.destroy(false);
+  }
+  destroy(leave = true) {
+    for (const connection of [...this.#connections.values()])
+      connection.destroy(leave);
+    this.#connections.clear();
+    this.#adapters.clear();
+  }
+}
+function waitReady(connection, timeoutMs) {
+  if (connection.status === "ready")
+    return Promise.resolve(connection);
+  return new Promise((resolve, reject) => {
+    const done = (error) => {
+      clearTimeout(timer);
+      connection.off("stateChange", onChange);
+      if (error)
+        reject(error);
+      else
+        resolve(connection);
+    };
+    const onChange = (next) => {
+      if (next === "ready")
+        done();
+      else if (next === "destroyed")
+        done(new VoiceError2("The voice connection was destroyed."));
+      else if (next === "disconnected")
+        done(new VoiceError2(`Could not join the voice channel: ${connection.disconnectReason?.message ?? connection.disconnectReason?.reason ?? "disconnected"}.`));
+    };
+    const timer = setTimeout(() => done(new VoiceError2(`Joining the voice channel timed out after ${timeoutMs} ms.`)), Math.min(timeoutMs + 50, 2147483647));
+    connection.on("stateChange", onChange);
+  });
+}
+
+// packages/voice/src/libopus.ts
+import { CString, dlopen, FFIType, ptr } from "bun:ffi";
+var OpusApplication2 = {
+  Voip: 2048,
+  Audio: 2049,
+  RestrictedLowDelay: 2051
+};
+var SYMBOLS = {
+  opus_encoder_create: {
+    args: [FFIType.i32, FFIType.i32, FFIType.i32, FFIType.ptr],
+    returns: FFIType.ptr
+  },
+  opus_encode: {
+    args: [FFIType.ptr, FFIType.ptr, FFIType.i32, FFIType.ptr, FFIType.i32],
+    returns: FFIType.i32
+  },
+  opus_encoder_destroy: { args: [FFIType.ptr], returns: FFIType.void },
+  opus_decoder_create: {
+    args: [FFIType.i32, FFIType.i32, FFIType.ptr],
+    returns: FFIType.ptr
+  },
+  opus_decode: {
+    args: [
+      FFIType.ptr,
+      FFIType.ptr,
+      FFIType.i32,
+      FFIType.ptr,
+      FFIType.i32,
+      FFIType.i32
+    ],
+    returns: FFIType.i32
+  },
+  opus_decoder_destroy: { args: [FFIType.ptr], returns: FFIType.void },
+  opus_strerror: { args: [FFIType.i32], returns: FFIType.ptr },
+  opus_get_version_string: { args: [], returns: FFIType.ptr }
+};
+function candidates() {
+  const own = process.env.LUNIBEE_OPUS_LIBRARY;
+  if (own === "none")
+    return [];
+  const byPlatform = process.platform === "darwin" ? [
+    "libopus.0.dylib",
+    "libopus.dylib",
+    "/opt/homebrew/lib/libopus.dylib",
+    "/usr/local/lib/libopus.dylib"
+  ] : process.platform === "win32" ? ["opus.dll", "libopus-0.dll", "libopus.dll"] : ["libopus.so.0", "libopus.so"];
+  return own ? [own, ...byPlatform] : byPlatform;
+}
+var loaded;
+function loadLibopus2(paths = candidates()) {
+  for (const path of paths)
+    try {
+      const library = dlopen(path, SYMBOLS);
+      return { symbols: library.symbols, path };
+    } catch {}
+  return null;
+}
+function hasLibopus2() {
+  loaded ??= loadLibopus2();
+  return loaded !== null;
+}
+function library() {
+  loaded ??= loadLibopus2();
+  if (!loaded)
+    throw new VoiceError2("libopus is not installed (apt install libopus0, brew install opus), or set LUNIBEE_OPUS_LIBRARY to its path.");
+  return loaded;
+}
+function libopusVersion2() {
+  loaded ??= loadLibopus2();
+  if (!loaded)
+    return null;
+  return new CString(loaded.symbols.opus_get_version_string()).toString();
+}
+function check(code, what) {
+  if (code < 0)
+    throw new VoiceError2(`${what} failed: ${new CString(library().symbols.opus_strerror(code)).toString()}`);
+  return code;
+}
+var MAX_PACKET2 = 1275;
+
+class Opus2 {
+  #symbols;
+  #encoder;
+  #decoder;
+  #packet = new Uint8Array(MAX_PACKET2);
+  #pcm = new Int16Array(FRAME_SAMPLES2 * 2);
+  static #registry = new FinalizationRegistry(({ symbols, encoder, decoder }) => {
+    symbols.opus_encoder_destroy(encoder);
+    symbols.opus_decoder_destroy(decoder);
+  });
+  constructor(application = OpusApplication2.Audio) {
+    this.#symbols = library().symbols;
+    const error = new Int32Array(1);
+    this.#encoder = this.#symbols.opus_encoder_create(48000, 2, application, ptr(error));
+    check(error[0], "Creating the Opus encoder");
+    this.#decoder = this.#symbols.opus_decoder_create(48000, 2, ptr(error));
+    if (error[0] < 0) {
+      this.#symbols.opus_encoder_destroy(this.#encoder);
+      check(error[0], "Creating the Opus decoder");
+    }
+    Opus2.#registry.register(this, {
+      symbols: this.#symbols,
+      encoder: this.#encoder,
+      decoder: this.#decoder
+    }, this);
+  }
+  static get libraryPath() {
+    return library().path;
+  }
+  encode(pcm) {
+    if (!this.#encoder)
+      throw new VoiceError2("The Opus codec was destroyed.");
+    if (pcm.byteLength !== PCM_FRAME_BYTES2)
+      throw new VoiceError2(`Opus encodes one 20 ms frame of ${PCM_FRAME_BYTES2} bytes, got ${pcm.byteLength}.`);
+    const samples = this.#pcm;
+    const view = new DataView(pcm.buffer, pcm.byteOffset, pcm.byteLength);
+    for (let i = 0;i < samples.length; i++)
+      samples[i] = view.getInt16(i * 2, true);
+    const length = check(this.#symbols.opus_encode(this.#encoder, ptr(samples), FRAME_SAMPLES2, ptr(this.#packet), MAX_PACKET2), "Opus encoding");
+    return this.#packet.slice(0, length);
+  }
+  decode(packet) {
+    if (!this.#decoder)
+      throw new VoiceError2("The Opus codec was destroyed.");
+    const frame = packet.byteLength ? 5760 : FRAME_SAMPLES2;
+    const out = new Int16Array(frame * 2);
+    const samples = check(this.#symbols.opus_decode(this.#decoder, packet.byteLength ? ptr(packet) : null, packet.byteLength, ptr(out), frame, 0), "Opus decoding");
+    const pcm = new Uint8Array(samples * 4);
+    const view = new DataView(pcm.buffer);
+    for (let i = 0;i < samples * 2; i++)
+      view.setInt16(i * 2, out[i], true);
+    return pcm;
+  }
+  destroy() {
+    if (!this.#encoder)
+      return;
+    Opus2.#registry.unregister(this);
+    this.#symbols.opus_encoder_destroy(this.#encoder);
+    this.#symbols.opus_decoder_destroy(this.#decoder);
+    this.#encoder = null;
+    this.#decoder = null;
+  }
+}
+
+// packages/voice/src/opus.ts
+var native = () => {
+  const codec = new Opus2;
+  return {
+    library: "libopus",
+    encode: (pcm) => codec.encode(pcm),
+    decode: (packet) => codec.decode(packet),
+    destroy: () => codec.destroy()
+  };
+};
+var wasm = async () => {
+  const name = "opusscript";
+  const mod = await import(name);
+  const OpusScript = mod.default;
+  const codec = new OpusScript(48000, 2, OpusScript.Application.AUDIO);
+  let destroyed = false;
+  return {
+    library: "opusscript",
+    encode: (pcm) => codec.encode(Buffer.from(pcm), FRAME_SAMPLES2),
+    decode: (packet) => codec.decode(Buffer.from(packet)),
+    destroy: () => {
+      if (destroyed)
+        return;
+      destroyed = true;
+      codec.delete();
+    }
+  };
+};
+async function createOpusCodec2() {
+  if (hasLibopus2())
+    return native();
+  try {
+    return await wasm();
+  } catch {
+    throw new VoiceError2("Encoding or decoding Opus needs an Opus library: install libopus (apt install libopus0, brew install opus) or opusscript.");
+  }
+}
+// packages/voice/src/effects.ts
+var RATE = 48000;
+var CHANNELS = 2;
+function check2(name, value, min, max) {
+  if (!Number.isFinite(value) || value < min || value > max)
+    throw new RangeError(`${name} must be between ${min} and ${max}.`);
+}
+var clip = (value) => value > 32767 ? 32767 : value < -32768 ? -32768 : Math.round(value);
+function pitchShift2(semitones) {
+  check2("semitones", semitones, -24, 24);
+  const ratio = 2 ** (semitones / 12);
+  const window = 2048;
+  const size = 4096;
+  const buffers = [new Float32Array(size), new Float32Array(size)];
+  let write = 0;
+  let phase = 0;
+  const step = (1 - ratio) / window;
+  const tap = (buffer, delay) => {
+    const position = write - delay;
+    const base = Math.floor(position);
+    const frac = position - base;
+    const a = buffer[base & size - 1];
+    const b = buffer[base + 1 & size - 1];
+    return a + (b - a) * frac;
+  };
+  return {
+    process(samples) {
+      if (semitones === 0)
+        return;
+      for (let i = 0;i < samples.length; i += CHANNELS) {
+        const p2 = (phase + 0.5) % 1;
+        const g1 = 1 - Math.abs(2 * phase - 1);
+        const g2 = 1 - g1;
+        for (let c = 0;c < CHANNELS; c++) {
+          const buffer = buffers[c];
+          buffer[write & size - 1] = samples[i + c];
+          samples[i + c] = clip(g1 * tap(buffer, 1 + phase * window) + g2 * tap(buffer, 1 + p2 * window));
+        }
+        write = write + 1 & 1073741823;
+        phase = ((phase + step) % 1 + 1) % 1;
+      }
+    }
+  };
+}
+function robot2(frequency = 50) {
+  check2("frequency", frequency, 1, 2000);
+  const increment = 2 * Math.PI * frequency / RATE;
+  let angle = 0;
+  return {
+    process(samples) {
+      for (let i = 0;i < samples.length; i += CHANNELS) {
+        const carrier = Math.sin(angle);
+        for (let c = 0;c < CHANNELS; c++)
+          samples[i + c] = clip(samples[i + c] * carrier);
+        angle += increment;
+        if (angle > 2 * Math.PI)
+          angle -= 2 * Math.PI;
+      }
+    }
+  };
+}
+function echo2(options = {}) {
+  const { delay = 250, feedback = 0.4, mix = 0.5 } = options;
+  check2("delay", delay, 1, 2000);
+  check2("feedback", feedback, 0, 0.95);
+  check2("mix", mix, 0, 1);
+  const buffer = new Float32Array(Math.round(delay * RATE / 1000) * CHANNELS);
+  let index = 0;
+  return {
+    process(samples) {
+      for (let i = 0;i < samples.length; i++) {
+        const delayed = buffer[index];
+        const input = samples[i];
+        buffer[index] = input + delayed * feedback;
+        samples[i] = clip(input + delayed * mix);
+        if (++index === buffer.length)
+          index = 0;
+      }
+    }
+  };
+}
+function gain2(factor) {
+  check2("factor", factor, 0, 16);
+  return {
+    process(samples) {
+      if (factor === 1)
+        return;
+      for (let i = 0;i < samples.length; i++)
+        samples[i] = clip(samples[i] * factor);
+    }
+  };
+}
+function applyEffects(effects, pcm) {
+  if (effects.length === 0)
+    return pcm;
+  const view = new DataView(pcm.buffer, pcm.byteOffset, pcm.byteLength);
+  const samples = new Int16Array(PCM_FRAME_BYTES2 >> 1);
+  const count = Math.min(pcm.byteLength, PCM_FRAME_BYTES2) >> 1;
+  for (let i = 0;i < count; i++)
+    samples[i] = view.getInt16(i * 2, true);
+  for (const effect of effects)
+    effect.process(samples);
+  const out = new Uint8Array(samples.length * 2);
+  const outView = new DataView(out.buffer);
+  for (let i = 0;i < samples.length; i++)
+    outView.setInt16(i * 2, samples[i], true);
+  return out;
+}
+// packages/voice/src/resource.ts
+var LIVE_BACKLOG = 5;
+
+class VolumeControl2 {
+  volume = 1;
+  set(volume) {
+    if (!Number.isFinite(volume) || volume < 0)
+      throw new RangeError("Volume must be a finite number of at least 0.");
+    this.volume = volume;
+  }
+  setDecibels(db) {
+    this.set(10 ** (db / 20));
+  }
+  apply(pcm) {
+    if (this.volume === 1)
+      return pcm;
+    const view = new DataView(pcm.buffer, pcm.byteOffset, pcm.byteLength);
+    for (let i = 0;i + 1 < pcm.length; i += 2) {
+      const scaled = Math.round(view.getInt16(i, true) * this.volume);
+      view.setInt16(i, Math.max(-32768, Math.min(32767, scaled)), true);
+    }
+    return pcm;
+  }
+}
+async function* chunksOf(input) {
+  if (input instanceof Uint8Array) {
+    yield input;
+    return;
+  }
+  if (input instanceof ReadableStream) {
+    const reader = input.getReader();
+    try {
+      for (;; ) {
+        const { done, value } = await reader.read();
+        if (done)
+          return;
+        yield value;
+      }
+    } finally {
+      await reader.cancel().catch(() => {
+        return;
+      });
+    }
+  }
+  yield* input;
+}
+async function* pcmFrames(chunks) {
+  let pending = new Uint8Array(0);
+  for await (const chunk of chunks) {
+    const merged = new Uint8Array(pending.length + chunk.length);
+    merged.set(pending, 0);
+    merged.set(chunk, pending.length);
+    let offset = 0;
+    while (merged.length - offset >= PCM_FRAME_BYTES2) {
+      yield merged.slice(offset, offset + PCM_FRAME_BYTES2);
+      offset += PCM_FRAME_BYTES2;
+    }
+    pending = merged.slice(offset);
+  }
+  if (pending.length > 0) {
+    const last = new Uint8Array(PCM_FRAME_BYTES2);
+    last.set(pending, 0);
+    yield last;
+  }
+}
+function inferType(path) {
+  const lower = path.toLowerCase();
+  if (lower.endsWith(".ogg") || lower.endsWith(".opus"))
+    return "ogg/opus";
+  if (lower.endsWith(".pcm") || lower.endsWith(".raw"))
+    return "raw";
+  return "arbitrary";
+}
+
+class AudioResource2 {
+  metadata;
+  volume;
+  effects;
+  live;
+  playbackDuration = 0;
+  started = false;
+  #frames;
+  #queue = [];
+  #prefetch;
+  #cleanup = [];
+  #filling = false;
+  #done = false;
+  #error;
+  constructor(frames, options) {
+    this.#frames = frames;
+    this.metadata = options.metadata;
+    this.volume = options.volume;
+    this.effects = options.effects;
+    this.live = options.live ?? false;
+    this.#prefetch = this.live ? Math.max(1, options.prefetch ?? 1) : Math.max(1, options.prefetch ?? 10);
+    if (options.cleanup)
+      this.#cleanup.push(options.cleanup);
+    this.#fill();
+  }
+  get ended() {
+    return this.#done && this.#queue.length === 0;
+  }
+  get error() {
+    return this.#error;
+  }
+  get readable() {
+    return this.#queue.length > 0;
+  }
+  #fill() {
+    if (this.#filling || this.#done)
+      return;
+    this.#filling = true;
+    (async () => {
+      try {
+        while (!this.#done && (this.live || this.#queue.length < this.#prefetch)) {
+          const next = await this.#frames.next();
+          if (next.done) {
+            this.#finish();
+            break;
+          }
+          if (this.#done)
+            break;
+          this.#queue.push(next.value);
+          if (this.live && this.#queue.length > LIVE_BACKLOG)
+            this.#queue.shift();
+        }
+      } catch (error) {
+        this.#error = error instanceof Error ? error : new VoiceError2(String(error));
+        this.#finish();
+      } finally {
+        this.#filling = false;
+      }
+    })();
+  }
+  #finish() {
+    if (this.#done)
+      return;
+    this.#done = true;
+    for (const cleanup of this.#cleanup.splice(0))
+      try {
+        cleanup();
+      } catch {}
+  }
+  read() {
+    const frame = this.#queue.shift();
+    if (frame) {
+      this.started = true;
+      this.#fill();
+      return frame;
+    }
+    if (this.#done)
+      return null;
+    this.#fill();
+    return;
+  }
+  destroy() {
+    this.#queue.length = 0;
+    this.#finish();
+    this.#frames.return(undefined).catch(() => {
+      return;
+    });
+  }
+}
+function spawnFFmpeg(input, path, output) {
+  const fromURL = typeof input === "string" && /^https?:\/\//i.test(input);
+  const args = [
+    path,
+    "-hide_banner",
+    "-loglevel",
+    "error",
+    "-analyzeduration",
+    "0",
+    "-i",
+    fromURL ? input : "pipe:0",
+    "-vn",
+    "-ar",
+    "48000",
+    "-ac",
+    "2",
+    ...output === "raw" ? ["-f", "s16le"] : [
+      "-c:a",
+      "libopus",
+      "-b:a",
+      "128k",
+      "-frame_duration",
+      "20",
+      "-f",
+      "opus"
+    ],
+    "pipe:1"
+  ];
+  const proc = Bun.spawn(args, {
+    stdin: fromURL ? "ignore" : "pipe",
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  let killed = false;
+  const stderr = (async () => {
+    let tail = "";
+    const decoder = new TextDecoder;
+    try {
+      for await (const chunk of proc.stderr)
+        tail = (tail + decoder.decode(chunk, { stream: true })).slice(-1000);
+    } catch {}
+    return tail.trim();
+  })();
+  if (!fromURL) {
+    const sink = proc.stdin;
+    const source = typeof input === "string" ? chunksOf(Bun.file(input).stream()) : chunksOf(input);
+    (async () => {
+      try {
+        for await (const chunk of source)
+          await sink.write(chunk);
+      } catch {} finally {
+        try {
+          await sink.end();
+        } catch {}
+      }
+    })();
+  }
+  return {
+    stdout: proc.stdout,
+    kill: () => {
+      killed = true;
+      try {
+        proc.kill();
+      } catch {}
+    },
+    exited: async () => {
+      const code = await proc.exited;
+      if (code === 0 || killed)
+        return;
+      const output = await stderr;
+      throw new VoiceError2(`FFmpeg exited with code ${code}${output ? `: ${output}` : "."}`);
+    }
+  };
+}
+function createAudioResource2(input, options = {}) {
+  let type = options.inputType ?? (typeof input === "string" ? inferType(input) : "arbitrary");
+  const volume = options.inlineVolume ? new VolumeControl2 : undefined;
+  const effects = options.effects ? [...options.effects] : undefined;
+  const pcmOut = Boolean(volume || effects);
+  const transform = (pcm) => {
+    const out = effects ? applyEffects(effects, pcm) : pcm;
+    return volume ? volume.apply(out) : out;
+  };
+  const cleanups = [];
+  let chunks;
+  if (type === "arbitrary") {
+    const ffmpeg = spawnFFmpeg(input, options.ffmpegPath ?? "ffmpeg", pcmOut ? "raw" : "ogg/opus");
+    cleanups.push(ffmpeg.kill);
+    chunks = async function* () {
+      yield* chunksOf(ffmpeg.stdout);
+      await ffmpeg.exited();
+    }();
+    type = pcmOut ? "raw" : "ogg/opus";
+  } else if (typeof input === "string") {
+    if (/^https?:\/\//i.test(input))
+      throw new VoiceError2(`A URL needs inputType "arbitrary" (FFmpeg).`);
+    chunks = chunksOf(Bun.file(input).stream());
+  } else
+    chunks = chunksOf(input);
+  let codec;
+  let destroyed = false;
+  const getCodec = async () => {
+    if (!codec) {
+      const created = await (options.codecFactory ?? createOpusCodec2)();
+      if (destroyed) {
+        created.destroy();
+        return;
+      }
+      codec = created;
+      cleanups.push(() => created.destroy());
+    }
+    return destroyed ? undefined : codec;
+  };
+  let frames;
+  if (type === "raw") {
+    const source = pcmFrames(chunks);
+    frames = async function* () {
+      for await (const pcm of source) {
+        const c = await getCodec();
+        if (!c)
+          return;
+        yield c.encode(transform(pcm));
+      }
+    }();
+  } else {
+    const packets = type === "ogg/opus" ? demuxOggOpus2(chunks) : chunks;
+    frames = pcmOut ? async function* () {
+      for await (const packet of packets) {
+        const c = await getCodec();
+        if (!c)
+          return;
+        yield c.encode(transform(c.decode(packet)));
+      }
+    }() : async function* () {
+      yield* packets;
+    }();
+  }
+  return new AudioResource2(frames, {
+    metadata: options.metadata,
+    volume,
+    effects,
+    live: options.live,
+    prefetch: options.prefetch,
+    cleanup: () => {
+      destroyed = true;
+      for (const cleanup of cleanups)
+        cleanup();
+    }
+  });
+}
+// packages/voice/src/player.ts
+var AudioPlayerStatus2 = {
+  Idle: "idle",
+  Buffering: "buffering",
+  Playing: "playing",
+  Paused: "paused",
+  AutoPaused: "autopaused"
+};
+var SILENCE_PADDING = 5;
+var MAX_LATENESS_MS = 100;
+
+class AudioPlayer2 extends Emitter {
+  #state = "idle";
+  #resource;
+  #sinks = new Set;
+  #options;
+  #timer;
+  #next = 0;
+  #silence = 0;
+  #missed = 0;
+  constructor(options = {}) {
+    super();
+    this.#options = {
+      noSubscriber: options.noSubscriber ?? "pause",
+      maxMissedFrames: options.maxMissedFrames ?? 250
+    };
+  }
+  get state() {
+    return this.#state;
+  }
+  get resource() {
+    return this.#resource;
+  }
+  get subscribers() {
+    return this.#sinks;
+  }
+  get ticking() {
+    return this.#timer !== undefined;
+  }
+  #transition(next) {
+    if (this.#state === next)
+      return;
+    const from = this.#state;
+    this.#state = next;
+    this.emit("stateChange", from, next);
+  }
+  play(resource) {
+    if (resource.ended || resource.started)
+      throw new VoiceError2("This audio resource has already been played; create a new one.");
+    if (this.#resource && this.#resource !== resource)
+      this.#resource.destroy();
+    this.#resource = resource;
+    this.#missed = 0;
+    this.#silence = 0;
+    this.#transition(resource.readable ? "playing" : "buffering");
+    this.#start();
+  }
+  pause(silence = true) {
+    if (this.#state !== "playing" && this.#state !== "buffering")
+      return false;
+    this.#transition("paused");
+    this.#silence = silence ? SILENCE_PADDING : 0;
+    if (silence)
+      this.#start();
+    else
+      this.#quiet();
+    return true;
+  }
+  unpause() {
+    if (this.#state !== "paused")
+      return false;
+    this.#silence = 0;
+    this.#transition(this.#resource?.readable ? "playing" : "buffering");
+    this.#start();
+    return true;
+  }
+  resume() {
+    return this.unpause();
+  }
+  stop(force = false) {
+    if (this.#state === "idle")
+      return false;
+    this.#resource?.destroy();
+    this.#resource = undefined;
+    this.#transition("idle");
+    this.#silence = force ? 0 : SILENCE_PADDING;
+    if (force)
+      this.#quiet();
+    else
+      this.#start();
+    return true;
+  }
+  attach(sink) {
+    this.#sinks.add(sink);
+    this.refresh();
+  }
+  detach(sink) {
+    if (!this.#sinks.delete(sink))
+      return;
+    try {
+      sink.setSpeaking(false);
+    } catch {}
+    this.refresh();
+  }
+  refresh() {
+    if (this.#state === "autopaused" && this.#hasReadySink()) {
+      this.#transition(this.#resource?.readable ? "playing" : "buffering");
+      this.#start();
+    } else if (this.#state === "playing" || this.#state === "buffering")
+      this.#start();
+  }
+  #hasReadySink() {
+    for (const sink of this.#sinks)
+      if (sink.ready)
+        return true;
+    return false;
+  }
+  #start() {
+    if (this.#timer)
+      return;
+    this.#next = performance.now();
+    this.#schedule();
+  }
+  #schedule() {
+    this.#next += FRAME_DURATION_MS2;
+    const now = performance.now();
+    if (now - this.#next > MAX_LATENESS_MS)
+      this.#next = now + FRAME_DURATION_MS2;
+    this.#timer = setTimeout(() => {
+      this.#timer = undefined;
+      this.#tick();
+    }, Math.max(0, this.#next - now));
+  }
+  #quiet() {
+    if (this.#timer)
+      clearTimeout(this.#timer);
+    this.#timer = undefined;
+    for (const sink of this.#sinks)
+      try {
+        sink.setSpeaking(false);
+      } catch {}
+  }
+  #send(frame) {
+    for (const sink of this.#sinks)
+      if (sink.ready)
+        try {
+          sink.sendFrame(frame);
+        } catch {}
+  }
+  #tick() {
+    if (this.#state === "idle" || this.#state === "paused") {
+      if (this.#silence > 0) {
+        this.#silence--;
+        this.#send(SILENCE_FRAME2);
+        if (this.#silence > 0)
+          return this.#schedule();
+      }
+      return this.#quiet();
+    }
+    if (this.#state === "autopaused")
+      return this.#quiet();
+    const resource = this.#resource;
+    if (!resource)
+      return this.#quiet();
+    if (!this.#hasReadySink()) {
+      if (this.#options.noSubscriber === "pause") {
+        this.#transition("autopaused");
+        return this.#quiet();
+      }
+      if (this.#options.noSubscriber === "stop") {
+        this.stop(true);
+        return;
+      }
+    }
+    const frame = resource.read();
+    if (frame === null)
+      return this.#end(resource);
+    if (frame === undefined) {
+      if (resource.live) {
+        if (!resource.started)
+          this.#transition("buffering");
+        return this.#schedule();
+      }
+      this.#transition("buffering");
+      if (++this.#missed > this.#options.maxMissedFrames) {
+        this.#fail(resource, new VoiceError2("The audio resource stopped producing frames."));
+        return;
+      }
+      return this.#schedule();
+    }
+    this.#missed = 0;
+    this.#transition("playing");
+    this.#send(frame);
+    resource.playbackDuration += FRAME_DURATION_MS2;
+    this.#schedule();
+  }
+  #end(resource) {
+    if (resource.error)
+      return this.#fail(resource, resource.error);
+    this.#resource = undefined;
+    this.#transition("idle");
+    this.emit("finish", resource);
+    this.#silence = SILENCE_PADDING;
+    this.#tick();
+  }
+  #fail(resource, error) {
+    resource.destroy();
+    this.#resource = undefined;
+    this.#transition("idle");
+    this.emit("error", error, resource);
+    this.#silence = SILENCE_PADDING;
+    this.#tick();
+  }
+}
+function createAudioPlayer2(options) {
+  return new AudioPlayer2(options);
+}
+
+// packages/voice/src/index.ts
+function entersState2(target, status, timeoutMs) {
+  const current = target instanceof VoiceConnection2 ? target.status : target.state;
+  if (current === status)
+    return Promise.resolve(target);
+  const emitter = target;
+  const isConnection = target instanceof VoiceConnection2;
+  return new Promise((resolve, reject) => {
+    const onChange = (first, second) => {
+      if ((isConnection ? first : second) !== status)
+        return;
+      clearTimeout(timer);
+      emitter.off("stateChange", onChange);
+      resolve(target);
+    };
+    const timer = setTimeout(() => {
+      emitter.off("stateChange", onChange);
+      reject(new VoiceError2(`Did not enter state "${String(status)}" within ${timeoutMs} ms.`));
+    }, Math.min(timeoutMs, 2147483647));
+    emitter.on("stateChange", onChange);
+  });
+}
+async function generateDependencyReport2() {
+  const dave = await loadDave2();
+  let opus = null;
+  try {
+    const codec = await createOpusCodec2();
+    opus = codec.library;
+    codec.destroy();
+  } catch {
+    opus = null;
+  }
+  let ffmpeg = null;
+  try {
+    const proc = Bun.spawnSync(["ffmpeg", "-version"], {
+      stdout: "pipe",
+      stderr: "ignore"
+    });
+    if (proc.exitCode === 0)
+      ffmpeg = new TextDecoder().decode(proc.stdout).split(`
+`)[0] ?? "ffmpeg";
+  } catch {
+    ffmpeg = null;
+  }
+  return {
+    dave: dave ? `@snazzah/davey (DAVE v${dave.DAVE_PROTOCOL_VERSION})` : null,
+    opus,
+    ffmpeg
+  };
+}
+
+export { VOICE_GATEWAY_VERSION2, VoiceOpcodes2, VoiceCloseCodes2, canResumeVoice2, RTP_OPUS_PAYLOAD_TYPE2, FRAME_DURATION_MS2, FRAME_SAMPLES2, PCM_FRAME_BYTES2, SILENCE_FRAME2, SpeakingFlags2, VoiceError2, SUPPORTED_ENCRYPTION_MODES2, chooseEncryptionMode2, rtpHeader2, parseRtpHeader2, PacketCipher2, loadDave2, maxDaveProtocolVersion2, DaveSession2, HEARTBEAT_TIMEOUT_CLOSE2, voiceGatewayURL2, VoiceGateway2, bunUdpSocket2, discoveryRequest2, parseDiscoveryResponse2, VoiceUdp2, VoiceNetworking2, demuxOggOpus2, OggOpusWriter2, VoiceReceiver2, VoiceConnectionStatus2, VoiceConnection2, joinVoiceChannel2, getVoiceConnection2, VoiceManager2, OpusApplication2, loadLibopus2, hasLibopus2, libopusVersion2, Opus2, createOpusCodec2, pitchShift2, robot2, echo2, gain2, VolumeControl2, AudioResource2, createAudioResource2, AudioPlayerStatus2, AudioPlayer2, createAudioPlayer2, entersState2, generateDependencyReport2 };
+
+//# debugId=EA1F81AA6907139F64756E2164756E21