@playninja/voice-room 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PlayNinja (Ninja Tech Solutions)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,107 @@
+# @playninja/voice-room
+
+Tiny, **transport-agnostic** voice/audio rooms on top of the [Cloudflare Realtime SFU](https://developers.cloudflare.com/realtime/). Bring your own signaling — wire it to a game WebSocket, a Durable Object, anything.
+
+- **One peer connection per client** (SFU topology) — you push your mic once, the SFU forwards it to everyone.
+- **No media servers to run.** Cloudflare's SFU does the routing; TURN is built in and free alongside it.
+- **Zero runtime dependencies.** ~1 small file of client code.
+- **Your secret stays server-side** via a thin proxy helper.
+- Built-in **mute**, **speaking detection / levels**, and **reconnection**.
+
+> Audio-first (perfect for party games & social deduction). Video is a future addition — the SFU and API already support it.
+
+## Why "bring your own signaling"?
+WebRTC needs a side-channel to announce "I'm here, here's my session/track id." Most apps already have one (a game socket). This library rides on *yours* via a 2-method `Transport`, so it drops into an existing realtime app without standing up anything new. It never relays SDP/ICE peer-to-peer — only tiny roster messages.
+
+## Install
+```bash
+npm install @playninja/voice-room
+```
+
+## Quick start
+
+### 1. Server — proxy the SFU (keeps your secret off the client)
+```ts
+import { handleRealtimeProxy } from '@playninja/voice-room/server';
+
+// in your Worker fetch handler:
+if (url.pathname.startsWith('/voice')) {
+  return handleRealtimeProxy(request, '/voice', {
+    appId: env.REALTIME_APP_ID,
+    token: env.REALTIME_APP_SECRET, // wrangler secret put REALTIME_APP_SECRET
+  });
+}
+```
+
+### 2. Client — join the room
+```ts
+import { createVoiceRoom } from '@playninja/voice-room';
+
+const voice = createVoiceRoom({
+  apiBase: '/voice',          // your proxy route from step 1
+  localId: myPlayerId,        // stable id
+  transport: {                // wire to your existing socket
+    send: (msg) => socket.send(JSON.stringify({ type: 'voice', msg })),
+    onMessage: (handler) => {
+      const fn = (e) => { const d = JSON.parse(e.data); if (d.type === 'voice') handler(d.msg); };
+      socket.addEventListener('message', fn);
+      return () => socket.removeEventListener('message', fn);
+    },
+  },
+});
+
+voice.on('peers', (peers) => renderSpeakingIndicators(peers)); // [{id, speaking, level, muted, connected}]
+voice.on('status', (s) => console.log('voice', s));
+
+await voice.join();          // call from a click (mic permission + autoplay)
+voice.setMuted(true);
+await voice.leave();
+```
+
+> Your server must also **relay** the `voice` messages to the other players in the room (the same fan-out you already do for chat/game state). The SDK only produces/consumes the payloads.
+
+## API
+| | |
+|---|---|
+| `createVoiceRoom(options)` | Create a room (doesn't join). |
+| `voice.join()` | Mic permission → push track → pull peers. Call from a user gesture. |
+| `voice.setMuted(bool)` | Enable/disable your mic (no renegotiation). |
+| `voice.resumeAudio()` | Call from a gesture if `needsgesture` fired (autoplay blocked). |
+| `voice.leave()` | Tear everything down. |
+| `voice.peers` / `voice.status` / `voice.muted` | Current state. |
+
+**Events:** `status`, `peers`, `level` (`{id, level, speaking}`, frequent), `error`, `needsgesture`.
+
+**Options:** `apiBase`, `transport`, `localId`, `iceServers?`, `audio?`, `speakingThreshold?`.
+
+## Run the demo (your spike)
+Two tabs on one machine hearing each other through real Cloudflare media:
+
+1. Create a **Realtime app** in the Cloudflare dashboard → copy the **App ID** + **App Secret**.
+2. `npm install`
+3. `npm run build:demo`
+4. Create `demo/.dev.vars`:
+   ```
+   REALTIME_APP_ID = "your-app-id"
+   REALTIME_APP_SECRET = "your-app-secret"
+   ```
+5. `wrangler dev --config demo/wrangler.jsonc` → open `http://localhost:8787` in **two tabs**, same room code, Join in both.
+
+(The demo uses `BroadcastChannel` for signaling, which works across tabs in one browser. Real cross-device use needs a real transport like your game socket.)
+
+## How it works
+```
+ each client                         Cloudflare Realtime SFU
+ ┌──────────┐   push mic (1 track)   ┌──────────────────────┐
+ │ browser  │ ─────────────────────▶ │   forwards to all     │
+ │  (1 PC)  │ ◀───────────────────── │   pullers             │
+ └──────────┘   pull N peer tracks   └──────────────────────┘
+      ▲  roster (sessionId + trackName) over YOUR transport
+      ▼
+ ┌──────────┐
+ │ your app │  (game WebSocket / Durable Object)
+ └──────────┘
+```
+
+## License
+MIT

package/dist/server/proxy.d.ts

@@ -0,0 +1,16 @@
+export interface RealtimeProxyConfig {
+    appId: string;
+    token: string;
+    /** Override for testing; defaults to the public SFU base. */
+    sfuBase?: string;
+}
+/** Forward a single SFU subpath (e.g. "/sessions/new"). */
+export declare function proxyRealtime(subpath: string, init: {
+    method: string;
+    body?: string | null;
+}, cfg: RealtimeProxyConfig): Promise<Response>;
+/**
+ * Handle a Worker `Request` whose path starts with `apiBasePath`. Only
+ * `/sessions...` subpaths are forwarded; everything else 404s.
+ */
+export declare function handleRealtimeProxy(request: Request, apiBasePath: string, cfg: RealtimeProxyConfig): Promise<Response>;

package/dist/server/proxy.js

@@ -0,0 +1,36 @@
+// Framework-agnostic proxy for the Cloudflare Realtime SFU.
+//
+// The browser SDK POSTs to `${apiBase}/sessions/...` on YOUR origin. This helper
+// forwards those to the real SFU API, injecting `apps/{appId}` and the bearer
+// secret so the secret never reaches the client. Drop it into a Worker:
+//
+//   import { handleRealtimeProxy } from '@playninja/voice-room/server';
+//   if (url.pathname.startsWith('/voice')) {
+//     return handleRealtimeProxy(request, '/voice', { appId: env.REALTIME_APP_ID, token: env.REALTIME_APP_SECRET });
+//   }
+const SFU_BASE = 'https://rtc.live.cloudflare.com/v1';
+/** Forward a single SFU subpath (e.g. "/sessions/new"). */
+export async function proxyRealtime(subpath, init, cfg) {
+    const base = cfg.sfuBase ?? SFU_BASE;
+    const res = await fetch(`${base}/apps/${cfg.appId}${subpath}`, {
+        method: init.method,
+        headers: { authorization: `Bearer ${cfg.token}`, 'content-type': 'application/json' },
+        body: init.body ?? undefined,
+    });
+    return new Response(res.body, {
+        status: res.status,
+        headers: { 'content-type': res.headers.get('content-type') ?? 'application/json' },
+    });
+}
+/**
+ * Handle a Worker `Request` whose path starts with `apiBasePath`. Only
+ * `/sessions...` subpaths are forwarded; everything else 404s.
+ */
+export async function handleRealtimeProxy(request, apiBasePath, cfg) {
+    const sub = new URL(request.url).pathname.slice(apiBasePath.replace(/\/$/, '').length);
+    if (!sub.startsWith('/sessions'))
+        return new Response('Not found', { status: 404 });
+    const method = request.method.toUpperCase();
+    const body = method === 'GET' || method === 'HEAD' ? null : await request.text();
+    return proxyRealtime(sub, { method, body }, cfg);
+}

package/dist/src/emitter.d.ts

@@ -0,0 +1,6 @@
+export declare class Emitter<Events extends Record<string, any>> {
+    #private;
+    on<K extends keyof Events>(event: K, handler: (payload: Events[K]) => void): () => void;
+    off<K extends keyof Events>(event: K, handler: (payload: Events[K]) => void): void;
+    emit<K extends keyof Events>(event: K, payload: Events[K]): void;
+}

package/dist/src/emitter.js

@@ -0,0 +1,31 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Emitter_handlers;
+// Minimal typed event emitter — zero deps.
+export class Emitter {
+    constructor() {
+        _Emitter_handlers.set(this, {});
+    }
+    on(event, handler) {
+        var _a;
+        ((_a = __classPrivateFieldGet(this, _Emitter_handlers, "f"))[event] ?? (_a[event] = new Set())).add(handler);
+        return () => this.off(event, handler);
+    }
+    off(event, handler) {
+        __classPrivateFieldGet(this, _Emitter_handlers, "f")[event]?.delete(handler);
+    }
+    emit(event, payload) {
+        __classPrivateFieldGet(this, _Emitter_handlers, "f")[event]?.forEach((h) => {
+            try {
+                h(payload);
+            }
+            catch (err) {
+                console.error('[voice-room] listener error', err);
+            }
+        });
+    }
+}
+_Emitter_handlers = new WeakMap();

package/dist/src/index.d.ts

@@ -0,0 +1,6 @@
+import { VoiceRoom } from './voice-room.js';
+import type { VoiceRoomOptions } from './types.js';
+export { VoiceRoom } from './voice-room.js';
+export type { Transport, VoiceRoomOptions, VoicePeer, VoiceStatus, VoiceRoomEvents, } from './types.js';
+/** Create (but don't join) a voice room. Call `.join()` from a user gesture. */
+export declare function createVoiceRoom(options: VoiceRoomOptions): VoiceRoom;

package/dist/src/index.js

@@ -0,0 +1,6 @@
+import { VoiceRoom } from './voice-room.js';
+export { VoiceRoom } from './voice-room.js';
+/** Create (but don't join) a voice room. Call `.join()` from a user gesture. */
+export function createVoiceRoom(options) {
+    return new VoiceRoom(options);
+}

package/dist/src/realtime.d.ts

@@ -0,0 +1,13 @@
+import type { NewSessionResponse, SessionDescription, TrackObject, TracksResponse } from './types.js';
+export declare class RealtimeApi {
+    #private;
+    private readonly apiBase;
+    constructor(apiBase: string);
+    newSession(): Promise<NewSessionResponse>;
+    newTracks(sessionId: string, body: {
+        tracks: TrackObject[];
+        sessionDescription?: SessionDescription;
+    }): Promise<TracksResponse>;
+    renegotiate(sessionId: string, sessionDescription: SessionDescription): Promise<unknown>;
+    closeTracks(sessionId: string, mids: string[], sessionDescription: SessionDescription): Promise<unknown>;
+}

package/dist/src/realtime.js

@@ -0,0 +1,53 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _RealtimeApi_instances, _RealtimeApi_req;
+// Thin client for the Cloudflare Realtime SFU REST API, talking to YOUR proxy
+// (which injects `apps/{appId}` + the bearer secret server-side). Paths mirror
+// the SFU API: POST /sessions/new, POST /sessions/{id}/tracks/new,
+// PUT /sessions/{id}/renegotiate, PUT /sessions/{id}/tracks/close.
+export class RealtimeApi {
+    constructor(apiBase) {
+        _RealtimeApi_instances.add(this);
+        this.apiBase = apiBase;
+    }
+    newSession() {
+        return __classPrivateFieldGet(this, _RealtimeApi_instances, "m", _RealtimeApi_req).call(this, '/sessions/new', 'POST');
+    }
+    newTracks(sessionId, body) {
+        return __classPrivateFieldGet(this, _RealtimeApi_instances, "m", _RealtimeApi_req).call(this, `/sessions/${sessionId}/tracks/new`, 'POST', body);
+    }
+    renegotiate(sessionId, sessionDescription) {
+        return __classPrivateFieldGet(this, _RealtimeApi_instances, "m", _RealtimeApi_req).call(this, `/sessions/${sessionId}/renegotiate`, 'PUT', { sessionDescription });
+    }
+    closeTracks(sessionId, mids, sessionDescription) {
+        return __classPrivateFieldGet(this, _RealtimeApi_instances, "m", _RealtimeApi_req).call(this, `/sessions/${sessionId}/tracks/close`, 'PUT', {
+            tracks: mids.map((mid) => ({ mid })),
+            sessionDescription,
+            force: false,
+        });
+    }
+}
+_RealtimeApi_instances = new WeakSet(), _RealtimeApi_req = async function _RealtimeApi_req(path, method, body) {
+    const res = await fetch(this.apiBase + path, {
+        method,
+        headers: body === undefined ? undefined : { 'content-type': 'application/json' },
+        body: body === undefined ? undefined : JSON.stringify(body),
+    });
+    if (!res.ok)
+        throw new Error(`Realtime ${method} ${path} → ${res.status} ${await safeText(res)}`);
+    const json = (res.status === 204 ? {} : await res.json());
+    if (json.errorCode)
+        throw new Error(`Realtime ${path}: ${json.errorCode} ${json.errorDescription ?? ''}`);
+    return json;
+};
+async function safeText(res) {
+    try {
+        return await res.text();
+    }
+    catch {
+        return '';
+    }
+}

package/dist/src/types.d.ts

@@ -0,0 +1,70 @@
+export interface SessionDescription {
+    type: 'offer' | 'answer';
+    sdp: string;
+}
+export interface TrackObject {
+    location?: 'local' | 'remote';
+    trackName?: string;
+    sessionId?: string;
+    mid?: string | null;
+    errorCode?: string;
+    errorDescription?: string;
+}
+export interface NewSessionResponse {
+    sessionId: string;
+    sessionDescription?: SessionDescription;
+    errorCode?: string;
+    errorDescription?: string;
+}
+export interface TracksResponse {
+    sessionDescription: SessionDescription;
+    requiresImmediateRenegotiation?: boolean;
+    tracks?: TrackObject[];
+    errorCode?: string;
+    errorDescription?: string;
+}
+export interface Transport {
+    send(message: unknown): void;
+    /** Register a handler for incoming messages. Returns an unsubscribe fn. */
+    onMessage(handler: (message: any) => void): () => void;
+}
+export interface VoiceRoomOptions {
+    /**
+     * Base URL of YOUR media proxy (a Worker route that forwards to the Realtime
+     * SFU with your app secret). The SDK POSTs `${apiBase}/sessions/new` etc.
+     * e.g. "/undermine/play/voice".
+     */
+    apiBase: string;
+    /** Your signaling channel (game WebSocket, BroadcastChannel for local demos, …). */
+    transport: Transport;
+    /** Stable identity for this participant (e.g. the player id). */
+    localId: string;
+    /** Optional ICE servers (TURN). Cloudflare's SFU usually connects without TURN. */
+    iceServers?: RTCIceServer[];
+    /** Mic constraints. Defaults to echo cancellation + noise suppression on. */
+    audio?: MediaTrackConstraints | boolean;
+    /** Speaking-detection threshold on a 0..1 RMS scale (default 0.02). */
+    speakingThreshold?: number;
+}
+export interface VoicePeer {
+    id: string;
+    /** True once their audio is flowing. */
+    connected: boolean;
+    speaking: boolean;
+    level: number;
+    muted: boolean;
+}
+export type VoiceStatus = 'idle' | 'connecting' | 'connected' | 'reconnecting' | 'error';
+export interface VoiceRoomEvents {
+    status: VoiceStatus;
+    peers: VoicePeer[];
+    /** Frequent: per-participant audio level (includes your own id). */
+    level: {
+        id: string;
+        level: number;
+        speaking: boolean;
+    };
+    error: Error;
+    /** Browser blocked audio autoplay — call resumeAudio() from a user gesture. */
+    needsgesture: void;
+}

package/dist/src/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/voice-room.d.ts

@@ -0,0 +1,21 @@
+import { Emitter } from './emitter.js';
+import type { VoicePeer, VoiceRoomEvents, VoiceRoomOptions, VoiceStatus } from './types.js';
+/**
+ * A voice room over the Cloudflare Realtime SFU. One peer connection per client;
+ * you push your mic once and pull everyone else. Signaling (who's here + their
+ * track ids) rides on YOUR transport — this class never relays SDP between peers.
+ */
+export declare class VoiceRoom extends Emitter<VoiceRoomEvents> {
+    #private;
+    constructor(opts: VoiceRoomOptions);
+    get status(): VoiceStatus;
+    get muted(): boolean;
+    get peers(): VoicePeer[];
+    join(): Promise<void>;
+    setMuted(muted: boolean): void;
+    /** Drop a peer (e.g. they left/disconnected from your app). Safe if unknown. */
+    removePeer(id: string): void;
+    /** Call from a user gesture if `needsgesture` fired (autoplay was blocked). */
+    resumeAudio(): void;
+    leave(): Promise<void>;
+}

package/dist/src/voice-room.js

@@ -0,0 +1,377 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _VoiceRoom_instances, _VoiceRoom_api, _VoiceRoom_opts, _VoiceRoom_peers, _VoiceRoom_midToPeer, _VoiceRoom_transport, _VoiceRoom_unsub, _VoiceRoom_pc, _VoiceRoom_sessionId, _VoiceRoom_localStream, _VoiceRoom_localTrack, _VoiceRoom_audioCtx, _VoiceRoom_localAnalyser, _VoiceRoom_levelTimer, _VoiceRoom_disconnectTimer, _VoiceRoom_chain, _VoiceRoom_status, _VoiceRoom_muted, _VoiceRoom_destroyed, _VoiceRoom_reconnecting, _VoiceRoom_pendingAutoplay, _VoiceRoom_connect, _VoiceRoom_reconnect, _VoiceRoom_maybePull, _VoiceRoom_pull, _VoiceRoom_queue, _VoiceRoom_onMessage, _VoiceRoom_send, _VoiceRoom_attachRemote, _VoiceRoom_detachRemote, _VoiceRoom_setupLevels, _VoiceRoom_makeAnalyser, _VoiceRoom_sampleLevels, _VoiceRoom_peer, _VoiceRoom_snapshot, _VoiceRoom_emitPeers, _VoiceRoom_setStatus, _VoiceRoom_armDisconnectTimer, _VoiceRoom_clearDisconnectTimer, _VoiceRoom_teardown;
+import { Emitter } from './emitter.js';
+import { RealtimeApi } from './realtime.js';
+const TAG = '__vr'; // namespaces our roster messages on the shared transport
+const LOCAL_TRACK = 'mic';
+/**
+ * A voice room over the Cloudflare Realtime SFU. One peer connection per client;
+ * you push your mic once and pull everyone else. Signaling (who's here + their
+ * track ids) rides on YOUR transport — this class never relays SDP between peers.
+ */
+export class VoiceRoom extends Emitter {
+    constructor(opts) {
+        super();
+        _VoiceRoom_instances.add(this);
+        _VoiceRoom_api.set(this, void 0);
+        _VoiceRoom_opts.set(this, void 0);
+        _VoiceRoom_peers.set(this, new Map());
+        _VoiceRoom_midToPeer.set(this, new Map());
+        _VoiceRoom_transport.set(this, void 0);
+        _VoiceRoom_unsub.set(this, void 0);
+        _VoiceRoom_pc.set(this, void 0);
+        _VoiceRoom_sessionId.set(this, void 0);
+        _VoiceRoom_localStream.set(this, void 0);
+        _VoiceRoom_localTrack.set(this, void 0);
+        _VoiceRoom_audioCtx.set(this, void 0);
+        _VoiceRoom_localAnalyser.set(this, void 0);
+        _VoiceRoom_levelTimer.set(this, void 0);
+        _VoiceRoom_disconnectTimer.set(this, void 0);
+        _VoiceRoom_chain.set(this, Promise.resolve());
+        _VoiceRoom_status.set(this, 'idle');
+        _VoiceRoom_muted.set(this, false);
+        _VoiceRoom_destroyed.set(this, false);
+        _VoiceRoom_reconnecting.set(this, false);
+        _VoiceRoom_pendingAutoplay.set(this, []);
+        __classPrivateFieldSet(this, _VoiceRoom_opts, { speakingThreshold: 0.02, ...opts }, "f");
+        __classPrivateFieldSet(this, _VoiceRoom_api, new RealtimeApi(opts.apiBase.replace(/\/$/, '')), "f");
+        __classPrivateFieldSet(this, _VoiceRoom_transport, opts.transport, "f");
+    }
+    get status() { return __classPrivateFieldGet(this, _VoiceRoom_status, "f"); }
+    get muted() { return __classPrivateFieldGet(this, _VoiceRoom_muted, "f"); }
+    get peers() { return __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_snapshot).call(this); }
+    // ── Public API ──────────────────────────────────────────────────────────────
+    async join() {
+        if (__classPrivateFieldGet(this, _VoiceRoom_status, "f") !== 'idle' && __classPrivateFieldGet(this, _VoiceRoom_status, "f") !== 'error')
+            return;
+        __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_setStatus).call(this, 'connecting');
+        __classPrivateFieldSet(this, _VoiceRoom_unsub, __classPrivateFieldGet(this, _VoiceRoom_transport, "f").onMessage((m) => __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_onMessage).call(this, m)), "f");
+        try {
+            __classPrivateFieldSet(this, _VoiceRoom_localStream, await navigator.mediaDevices.getUserMedia({ audio: __classPrivateFieldGet(this, _VoiceRoom_opts, "f").audio ?? defaultAudio() }), "f");
+            __classPrivateFieldSet(this, _VoiceRoom_localTrack, __classPrivateFieldGet(this, _VoiceRoom_localStream, "f").getAudioTracks()[0], "f");
+            if (__classPrivateFieldGet(this, _VoiceRoom_localTrack, "f"))
+                __classPrivateFieldGet(this, _VoiceRoom_localTrack, "f").enabled = !__classPrivateFieldGet(this, _VoiceRoom_muted, "f");
+            __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_setupLevels).call(this);
+            await __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_connect).call(this);
+            __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_setStatus).call(this, 'connected');
+        }
+        catch (err) {
+            __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_setStatus).call(this, 'error');
+            this.emit('error', err);
+            throw err;
+        }
+    }
+    setMuted(muted) {
+        __classPrivateFieldSet(this, _VoiceRoom_muted, muted, "f");
+        if (__classPrivateFieldGet(this, _VoiceRoom_localTrack, "f"))
+            __classPrivateFieldGet(this, _VoiceRoom_localTrack, "f").enabled = !muted;
+        __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_send).call(this, { [TAG]: 1, kind: 'mute', id: __classPrivateFieldGet(this, _VoiceRoom_opts, "f").localId, muted });
+        __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_emitPeers).call(this);
+    }
+    /** Drop a peer (e.g. they left/disconnected from your app). Safe if unknown. */
+    removePeer(id) {
+        const p = __classPrivateFieldGet(this, _VoiceRoom_peers, "f").get(id);
+        if (!p)
+            return;
+        __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_detachRemote).call(this, p);
+        __classPrivateFieldGet(this, _VoiceRoom_peers, "f").delete(id);
+        for (const [mid, pid] of __classPrivateFieldGet(this, _VoiceRoom_midToPeer, "f"))
+            if (pid === id)
+                __classPrivateFieldGet(this, _VoiceRoom_midToPeer, "f").delete(mid);
+        __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_emitPeers).call(this);
+    }
+    /** Call from a user gesture if `needsgesture` fired (autoplay was blocked). */
+    resumeAudio() {
+        __classPrivateFieldGet(this, _VoiceRoom_audioCtx, "f")?.resume().catch(() => { });
+        const pending = __classPrivateFieldGet(this, _VoiceRoom_pendingAutoplay, "f");
+        __classPrivateFieldSet(this, _VoiceRoom_pendingAutoplay, [], "f");
+        for (const el of pending)
+            el.play().catch(() => __classPrivateFieldGet(this, _VoiceRoom_pendingAutoplay, "f").push(el));
+    }
+    async leave() {
+        if (__classPrivateFieldGet(this, _VoiceRoom_destroyed, "f"))
+            return;
+        __classPrivateFieldSet(this, _VoiceRoom_destroyed, true, "f");
+        __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_send).call(this, { [TAG]: 1, kind: 'leave', id: __classPrivateFieldGet(this, _VoiceRoom_opts, "f").localId });
+        __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_teardown).call(this);
+        __classPrivateFieldGet(this, _VoiceRoom_unsub, "f")?.call(this);
+        __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_setStatus).call(this, 'idle');
+    }
+}
+_VoiceRoom_api = new WeakMap(), _VoiceRoom_opts = new WeakMap(), _VoiceRoom_peers = new WeakMap(), _VoiceRoom_midToPeer = new WeakMap(), _VoiceRoom_transport = new WeakMap(), _VoiceRoom_unsub = new WeakMap(), _VoiceRoom_pc = new WeakMap(), _VoiceRoom_sessionId = new WeakMap(), _VoiceRoom_localStream = new WeakMap(), _VoiceRoom_localTrack = new WeakMap(), _VoiceRoom_audioCtx = new WeakMap(), _VoiceRoom_localAnalyser = new WeakMap(), _VoiceRoom_levelTimer = new WeakMap(), _VoiceRoom_disconnectTimer = new WeakMap(), _VoiceRoom_chain = new WeakMap(), _VoiceRoom_status = new WeakMap(), _VoiceRoom_muted = new WeakMap(), _VoiceRoom_destroyed = new WeakMap(), _VoiceRoom_reconnecting = new WeakMap(), _VoiceRoom_pendingAutoplay = new WeakMap(), _VoiceRoom_instances = new WeakSet(), _VoiceRoom_connect = 
+// ── Connection lifecycle ──────────────────────────────────────────────────────
+async function _VoiceRoom_connect() {
+    const pc = new RTCPeerConnection({ iceServers: __classPrivateFieldGet(this, _VoiceRoom_opts, "f").iceServers ?? [] });
+    __classPrivateFieldSet(this, _VoiceRoom_pc, pc, "f");
+    pc.ontrack = (e) => {
+        const peerId = e.transceiver.mid ? __classPrivateFieldGet(this, _VoiceRoom_midToPeer, "f").get(e.transceiver.mid) : undefined;
+        if (peerId)
+            __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_attachRemote).call(this, peerId, e.track);
+    };
+    pc.onconnectionstatechange = () => {
+        const s = pc.connectionState;
+        if (s === 'connected') {
+            __classPrivateFieldSet(this, _VoiceRoom_reconnecting, false, "f");
+            __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_setStatus).call(this, 'connected');
+            __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_clearDisconnectTimer).call(this);
+        }
+        else if (s === 'failed') {
+            void __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_reconnect).call(this);
+        }
+        else if (s === 'disconnected') {
+            __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_armDisconnectTimer).call(this);
+        }
+    };
+    const { sessionId } = await __classPrivateFieldGet(this, _VoiceRoom_api, "f").newSession();
+    __classPrivateFieldSet(this, _VoiceRoom_sessionId, sessionId, "f");
+    // push our mic (one sendonly transceiver)
+    if (__classPrivateFieldGet(this, _VoiceRoom_localTrack, "f")) {
+        const tx = pc.addTransceiver(__classPrivateFieldGet(this, _VoiceRoom_localTrack, "f"), { direction: 'sendonly' });
+        const offer = await pc.createOffer();
+        await pc.setLocalDescription(offer);
+        const res = await __classPrivateFieldGet(this, _VoiceRoom_api, "f").newTracks(sessionId, {
+            sessionDescription: { type: 'offer', sdp: offer.sdp },
+            tracks: [{ location: 'local', mid: tx.mid, trackName: LOCAL_TRACK }],
+        });
+        await pc.setRemoteDescription(res.sessionDescription);
+    }
+    // announce ourselves and ask existing peers to (re-)announce so we can pull them
+    __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_send).call(this, { [TAG]: 1, kind: 'join', id: __classPrivateFieldGet(this, _VoiceRoom_opts, "f").localId, sessionId, trackName: LOCAL_TRACK, muted: __classPrivateFieldGet(this, _VoiceRoom_muted, "f") });
+    __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_send).call(this, { [TAG]: 1, kind: 'hello', id: __classPrivateFieldGet(this, _VoiceRoom_opts, "f").localId });
+    // pull anyone we already learned about
+    for (const p of __classPrivateFieldGet(this, _VoiceRoom_peers, "f").values())
+        __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_maybePull).call(this, p);
+}, _VoiceRoom_reconnect = async function _VoiceRoom_reconnect() {
+    if (__classPrivateFieldGet(this, _VoiceRoom_destroyed, "f") || __classPrivateFieldGet(this, _VoiceRoom_reconnecting, "f"))
+        return;
+    __classPrivateFieldSet(this, _VoiceRoom_reconnecting, true, "f");
+    __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_setStatus).call(this, 'reconnecting');
+    __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_clearDisconnectTimer).call(this);
+    try {
+        __classPrivateFieldGet(this, _VoiceRoom_pc, "f")?.close();
+    }
+    catch { /* noop */ }
+    __classPrivateFieldGet(this, _VoiceRoom_midToPeer, "f").clear();
+    for (const p of __classPrivateFieldGet(this, _VoiceRoom_peers, "f").values()) {
+        p.connected = false;
+        p.pulledFrom = undefined;
+        __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_detachRemote).call(this, p);
+    }
+    // small backoff before re-establishing
+    await new Promise((r) => setTimeout(r, 500));
+    if (__classPrivateFieldGet(this, _VoiceRoom_destroyed, "f"))
+        return;
+    try {
+        await __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_connect).call(this);
+        __classPrivateFieldSet(this, _VoiceRoom_reconnecting, false, "f");
+    }
+    catch (err) {
+        this.emit('error', err);
+        // try again shortly
+        setTimeout(() => { __classPrivateFieldSet(this, _VoiceRoom_reconnecting, false, "f"); void __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_reconnect).call(this); }, 2000);
+    }
+}, _VoiceRoom_maybePull = function _VoiceRoom_maybePull(p) {
+    if (__classPrivateFieldGet(this, _VoiceRoom_destroyed, "f") || !__classPrivateFieldGet(this, _VoiceRoom_pc, "f") || !__classPrivateFieldGet(this, _VoiceRoom_sessionId, "f"))
+        return;
+    if (p.id === __classPrivateFieldGet(this, _VoiceRoom_opts, "f").localId)
+        return;
+    if (!p.sessionId || !p.trackName)
+        return;
+    if (p.pulledFrom === p.sessionId)
+        return; // already pulling this session
+    p.pulledFrom = p.sessionId;
+    __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_queue).call(this, () => __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_pull).call(this, p)).catch((err) => {
+        p.pulledFrom = undefined; // allow retry
+        this.emit('error', err);
+    });
+}, _VoiceRoom_pull = async function _VoiceRoom_pull(p) {
+    const pc = __classPrivateFieldGet(this, _VoiceRoom_pc, "f");
+    if (!pc || !__classPrivateFieldGet(this, _VoiceRoom_sessionId, "f") || !p.sessionId || !p.trackName)
+        return;
+    const res = await __classPrivateFieldGet(this, _VoiceRoom_api, "f").newTracks(__classPrivateFieldGet(this, _VoiceRoom_sessionId, "f"), {
+        tracks: [{ location: 'remote', sessionId: p.sessionId, trackName: p.trackName }],
+    });
+    const mid = res.tracks?.[0]?.mid;
+    if (mid)
+        __classPrivateFieldGet(this, _VoiceRoom_midToPeer, "f").set(mid, p.id);
+    if (res.requiresImmediateRenegotiation) {
+        await pc.setRemoteDescription(res.sessionDescription); // server offer
+        const answer = await pc.createAnswer();
+        await pc.setLocalDescription(answer);
+        await __classPrivateFieldGet(this, _VoiceRoom_api, "f").renegotiate(__classPrivateFieldGet(this, _VoiceRoom_sessionId, "f"), { type: 'answer', sdp: answer.sdp });
+    }
+}, _VoiceRoom_queue = function _VoiceRoom_queue(task) {
+    const run = __classPrivateFieldGet(this, _VoiceRoom_chain, "f").then(task, task);
+    __classPrivateFieldSet(this, _VoiceRoom_chain, run.then(() => { }, () => { }), "f");
+    return run;
+}, _VoiceRoom_onMessage = function _VoiceRoom_onMessage(m) {
+    if (!m || m[TAG] !== 1 || __classPrivateFieldGet(this, _VoiceRoom_destroyed, "f"))
+        return;
+    const msg = m;
+    if (msg.kind !== 'hello' && msg.id === __classPrivateFieldGet(this, _VoiceRoom_opts, "f").localId)
+        return; // ignore our own echoes
+    switch (msg.kind) {
+        case 'join': {
+            const p = __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_peer).call(this, msg.id);
+            p.sessionId = msg.sessionId;
+            p.trackName = msg.trackName;
+            p.muted = msg.muted;
+            __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_maybePull).call(this, p);
+            __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_emitPeers).call(this);
+            break;
+        }
+        case 'hello': {
+            if (msg.id === __classPrivateFieldGet(this, _VoiceRoom_opts, "f").localId)
+                break;
+            // a newcomer asked everyone to announce — re-broadcast our info
+            if (__classPrivateFieldGet(this, _VoiceRoom_sessionId, "f")) {
+                __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_send).call(this, { [TAG]: 1, kind: 'join', id: __classPrivateFieldGet(this, _VoiceRoom_opts, "f").localId, sessionId: __classPrivateFieldGet(this, _VoiceRoom_sessionId, "f"), trackName: LOCAL_TRACK, muted: __classPrivateFieldGet(this, _VoiceRoom_muted, "f") });
+            }
+            break;
+        }
+        case 'mute': {
+            const p = __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_peer).call(this, msg.id);
+            p.muted = msg.muted;
+            __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_emitPeers).call(this);
+            break;
+        }
+        case 'leave': {
+            const p = __classPrivateFieldGet(this, _VoiceRoom_peers, "f").get(msg.id);
+            if (p) {
+                __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_detachRemote).call(this, p);
+                __classPrivateFieldGet(this, _VoiceRoom_peers, "f").delete(msg.id);
+                __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_emitPeers).call(this);
+            }
+            break;
+        }
+    }
+}, _VoiceRoom_send = function _VoiceRoom_send(msg) { try {
+    __classPrivateFieldGet(this, _VoiceRoom_transport, "f").send(msg);
+}
+catch (err) {
+    console.error('[voice-room] transport send failed', err);
+} }, _VoiceRoom_attachRemote = function _VoiceRoom_attachRemote(peerId, track) {
+    const p = __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_peer).call(this, peerId);
+    __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_detachRemote).call(this, p);
+    const stream = new MediaStream([track]);
+    const el = document.createElement('audio');
+    el.autoplay = true;
+    el.srcObject = stream;
+    el.playsInline = true;
+    el.style.display = 'none';
+    document.body.appendChild(el);
+    el.play().catch(() => { __classPrivateFieldGet(this, _VoiceRoom_pendingAutoplay, "f").push(el); this.emit('needsgesture', undefined); });
+    p.audio = el;
+    p.connected = true;
+    p.analyser = __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_makeAnalyser).call(this, stream);
+    __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_emitPeers).call(this);
+}, _VoiceRoom_detachRemote = function _VoiceRoom_detachRemote(p) {
+    if (p.audio) {
+        try {
+            p.audio.srcObject = null;
+            p.audio.remove();
+        }
+        catch { /* noop */ }
+        p.audio = undefined;
+    }
+    p.analyser = undefined;
+}, _VoiceRoom_setupLevels = function _VoiceRoom_setupLevels() {
+    try {
+        __classPrivateFieldSet(this, _VoiceRoom_audioCtx, new (window.AudioContext || window.webkitAudioContext)(), "f");
+        if (__classPrivateFieldGet(this, _VoiceRoom_localStream, "f"))
+            __classPrivateFieldSet(this, _VoiceRoom_localAnalyser, __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_makeAnalyser).call(this, __classPrivateFieldGet(this, _VoiceRoom_localStream, "f")), "f");
+        const buf = new Uint8Array(1024);
+        __classPrivateFieldSet(this, _VoiceRoom_levelTimer, setInterval(() => __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_sampleLevels).call(this, buf), 120), "f");
+    }
+    catch (err) {
+        console.warn('[voice-room] level metering unavailable', err);
+    }
+}, _VoiceRoom_makeAnalyser = function _VoiceRoom_makeAnalyser(stream) {
+    if (!__classPrivateFieldGet(this, _VoiceRoom_audioCtx, "f"))
+        return undefined;
+    try {
+        const src = __classPrivateFieldGet(this, _VoiceRoom_audioCtx, "f").createMediaStreamSource(stream);
+        const an = __classPrivateFieldGet(this, _VoiceRoom_audioCtx, "f").createAnalyser();
+        an.fftSize = 256;
+        src.connect(an);
+        return an;
+    }
+    catch {
+        return undefined;
+    }
+}, _VoiceRoom_sampleLevels = function _VoiceRoom_sampleLevels(buf) {
+    const report = (id, an, rec) => {
+        if (!an)
+            return;
+        an.getByteTimeDomainData(buf);
+        let sum = 0;
+        for (let i = 0; i < an.fftSize; i++) {
+            const v = (buf[i] - 128) / 128;
+            sum += v * v;
+        }
+        const level = Math.min(1, Math.sqrt(sum / an.fftSize) * 3);
+        const speaking = level >= __classPrivateFieldGet(this, _VoiceRoom_opts, "f").speakingThreshold && !(rec ? rec.muted : __classPrivateFieldGet(this, _VoiceRoom_muted, "f"));
+        if (rec) {
+            const changed = rec.speaking !== speaking;
+            rec.level = level;
+            rec.speaking = speaking;
+            if (changed)
+                __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_emitPeers).call(this);
+        }
+        this.emit('level', { id, level, speaking });
+    };
+    report(__classPrivateFieldGet(this, _VoiceRoom_opts, "f").localId, __classPrivateFieldGet(this, _VoiceRoom_localAnalyser, "f"));
+    for (const p of __classPrivateFieldGet(this, _VoiceRoom_peers, "f").values())
+        report(p.id, p.analyser, p);
+}, _VoiceRoom_peer = function _VoiceRoom_peer(id) {
+    let p = __classPrivateFieldGet(this, _VoiceRoom_peers, "f").get(id);
+    if (!p) {
+        p = { id, connected: false, speaking: false, level: 0, muted: false };
+        __classPrivateFieldGet(this, _VoiceRoom_peers, "f").set(id, p);
+    }
+    return p;
+}, _VoiceRoom_snapshot = function _VoiceRoom_snapshot() {
+    return [...__classPrivateFieldGet(this, _VoiceRoom_peers, "f").values()].map((p) => ({ id: p.id, connected: p.connected, speaking: p.speaking, level: p.level, muted: p.muted }));
+}, _VoiceRoom_emitPeers = function _VoiceRoom_emitPeers() { this.emit('peers', __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_snapshot).call(this)); }, _VoiceRoom_setStatus = function _VoiceRoom_setStatus(s) { if (__classPrivateFieldGet(this, _VoiceRoom_status, "f") !== s) {
+    __classPrivateFieldSet(this, _VoiceRoom_status, s, "f");
+    this.emit('status', s);
+} }, _VoiceRoom_armDisconnectTimer = function _VoiceRoom_armDisconnectTimer() {
+    __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_clearDisconnectTimer).call(this);
+    __classPrivateFieldSet(this, _VoiceRoom_disconnectTimer, setTimeout(() => { if (__classPrivateFieldGet(this, _VoiceRoom_pc, "f")?.connectionState !== 'connected')
+        void __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_reconnect).call(this); }, 6000), "f");
+}, _VoiceRoom_clearDisconnectTimer = function _VoiceRoom_clearDisconnectTimer() { if (__classPrivateFieldGet(this, _VoiceRoom_disconnectTimer, "f")) {
+    clearTimeout(__classPrivateFieldGet(this, _VoiceRoom_disconnectTimer, "f"));
+    __classPrivateFieldSet(this, _VoiceRoom_disconnectTimer, undefined, "f");
+} }, _VoiceRoom_teardown = function _VoiceRoom_teardown() {
+    __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_clearDisconnectTimer).call(this);
+    if (__classPrivateFieldGet(this, _VoiceRoom_levelTimer, "f"))
+        clearInterval(__classPrivateFieldGet(this, _VoiceRoom_levelTimer, "f"));
+    for (const p of __classPrivateFieldGet(this, _VoiceRoom_peers, "f").values())
+        __classPrivateFieldGet(this, _VoiceRoom_instances, "m", _VoiceRoom_detachRemote).call(this, p);
+    __classPrivateFieldGet(this, _VoiceRoom_peers, "f").clear();
+    __classPrivateFieldGet(this, _VoiceRoom_midToPeer, "f").clear();
+    try {
+        __classPrivateFieldGet(this, _VoiceRoom_pc, "f")?.close();
+    }
+    catch { /* noop */ }
+    __classPrivateFieldGet(this, _VoiceRoom_localStream, "f")?.getTracks().forEach((t) => t.stop());
+    __classPrivateFieldGet(this, _VoiceRoom_audioCtx, "f")?.close().catch(() => { });
+    __classPrivateFieldSet(this, _VoiceRoom_pc, undefined, "f");
+    __classPrivateFieldSet(this, _VoiceRoom_localStream, undefined, "f");
+    __classPrivateFieldSet(this, _VoiceRoom_localTrack, undefined, "f");
+    __classPrivateFieldSet(this, _VoiceRoom_audioCtx, undefined, "f");
+    __classPrivateFieldSet(this, _VoiceRoom_localAnalyser, undefined, "f");
+};
+function defaultAudio() {
+    return { echoCancellation: true, noiseSuppression: true, autoGainControl: true };
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@playninja/voice-room",
+  "version": "0.1.0",
+  "description": "Tiny, transport-agnostic voice/audio rooms on top of the Cloudflare Realtime SFU. Bring your own signaling.",
+  "type": "module",
+  "main": "./dist/src/index.js",
+  "module": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "exports": {
+    ".": { "types": "./dist/src/index.d.ts", "import": "./dist/src/index.js" },
+    "./server": { "types": "./dist/server/proxy.d.ts", "import": "./dist/server/proxy.js" }
+  },
+  "files": ["dist", "README.md", "LICENSE"],
+  "publishConfig": { "access": "public" },
+  "scripts": {
+    "prepublishOnly": "npm run build",
+    "build": "tsc -p tsconfig.json",
+    "build:demo": "esbuild src/index.ts --bundle --format=esm --outfile=demo/public/voice-room.js",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "demo": "npm run build:demo && wrangler dev --config demo/wrangler.jsonc"
+  },
+  "keywords": ["webrtc", "voice", "audio", "cloudflare", "realtime", "sfu", "calls", "voice-chat", "game"],
+  "license": "MIT",
+  "author": "PlayNinja",
+  "repository": { "type": "git", "url": "https://github.com/sanjeev0291/voice-room" },
+  "devDependencies": {
+    "esbuild": "^0.23.0",
+    "typescript": "^5.5.0"
+  }
+}