@treyorr/voca-client 0.1.0

package/README.md

@@ -0,0 +1,118 @@
+# @treyorr/voca-client
+
+Core TypeScript SDK for Voca WebRTC signaling.
+
+## Installation
+
+```bash
+npm install @treyorr/voca-client
+```
+
+## Quick Start
+
+### Option 1: Create a New Room
+
+```typescript
+import { VocaClient } from '@treyorr/voca-client';
+
+// Create a room and get a connected client
+const client = await VocaClient.createRoom({
+  serverUrl: 'wss://your-server.com',
+});
+
+console.log('Room ID:', client.roomId); // Share this with others
+await client.connect();
+```
+
+### Option 2: Join an Existing Room
+
+```typescript
+import { VocaClient } from '@treyorr/voca-client';
+
+const client = new VocaClient('abc123', {
+  serverUrl: 'wss://your-server.com',
+});
+
+await client.connect();
+```
+
+## Common Use Cases
+
+### Voice Chat App (Create + Share Link)
+```typescript
+const client = await VocaClient.createRoom();
+const inviteLink = `https://myapp.com/room/${client.roomId}`;
+// Share inviteLink with friends
+await client.connect();
+```
+
+### Game Lobby (Join by Code)
+```typescript
+const roomCode = prompt('Enter room code:');
+const client = new VocaClient(roomCode);
+await client.connect();
+```
+
+### Check if Room is Full Before Joining
+```typescript
+const response = await fetch(`/api/room/${roomId}`);
+const { exists, full, peers, capacity } = await response.json();
+
+if (!exists) {
+  alert('Room not found');
+} else if (full) {
+  alert(`Room is full (${peers}/${capacity})`);
+} else {
+  const client = new VocaClient(roomId);
+  await client.connect();
+}
+```
+
+## API Reference
+
+### `VocaClient.createRoom(config?)`
+
+Creates a new room on the server and returns a client instance.
+
+```typescript
+const client = await VocaClient.createRoom({
+  serverUrl: 'wss://your-server.com', // Required in Node.js
+});
+```
+
+### `new VocaClient(roomId, config?)`
+
+Creates a client for joining an existing room.
+
+### Config Options
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `serverUrl` | string | WebSocket server URL |
+| `turnApiKey` | string | TURN API key for NAT traversal |
+| `reconnect.enabled` | boolean | Enable auto-reconnect (default: true) |
+| `reconnect.maxAttempts` | number | Max reconnection attempts (default: 5) |
+| `reconnect.baseDelayMs` | number | Base delay for exponential backoff |
+
+### Methods
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `connect()` | Promise | Connect to room |
+| `disconnect()` | void | Leave room |
+| `toggleMute()` | boolean | Toggle mute, returns new state |
+| `on(event, callback)` | Function | Subscribe to events |
+
+### Events
+
+- `status` - Connection status changes
+- `error` - Error events with typed codes
+- `warning` - Non-fatal warnings
+- `peer-joined` - Peer joined the room
+- `peer-left` - Peer left the room
+- `peer-audio-level` - Peer audio level (0-1)
+- `local-audio-level` - Local audio level (0-1)
+
+## License
+
+MIT

package/dist/errors.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Voca Error Codes
+ *
+ * Unified error codes used across all Voca SDKs and the signaling server.
+ */
+export declare const VocaErrorCode: {
+    readonly ROOM_NOT_FOUND: "room_not_found";
+    readonly ROOM_FULL: "room_full";
+    readonly MAX_ROOMS_REACHED: "max_rooms_reached";
+    readonly INVALID_ROOM_ID: "invalid_room_id";
+    readonly CONNECTION_FAILED: "connection_failed";
+    readonly WEBSOCKET_ERROR: "websocket_error";
+    readonly HEARTBEAT_TIMEOUT: "heartbeat_timeout";
+    readonly MICROPHONE_NOT_FOUND: "microphone_not_found";
+    readonly MICROPHONE_PERMISSION_DENIED: "microphone_permission_denied";
+    readonly INSECURE_CONTEXT: "insecure_context";
+    readonly INVALID_MESSAGE: "invalid_message";
+    readonly PEER_NOT_FOUND: "peer_not_found";
+};
+export type VocaErrorCode = typeof VocaErrorCode[keyof typeof VocaErrorCode];
+/**
+ * Human-readable error messages for each error code
+ */
+export declare const VocaErrorMessages: Record<VocaErrorCode, string>;
+/**
+ * Voca error with code and message
+ */
+export interface VocaError {
+    code: VocaErrorCode;
+    message: string;
+}
+/**
+ * Create a VocaError from a code
+ */
+export declare function createVocaError(code: VocaErrorCode, customMessage?: string): VocaError;

package/dist/index.d.ts

@@ -0,0 +1,83 @@
+import { type VocaError } from './errors';
+export { VocaErrorCode, VocaErrorMessages, type VocaError, createVocaError } from './errors';
+export type ConnectionStatus = 'connecting' | 'connected' | 'reconnecting' | 'full' | 'error' | 'disconnected';
+export interface VocaConfig {
+    debug?: boolean;
+    iceServers?: RTCIceServer[];
+    serverUrl?: string;
+    apiKey?: string;
+    /**
+     * Reconnection options. Enabled by default.
+     */
+    reconnect?: {
+        /** Enable automatic reconnection. Default: true */
+        enabled?: boolean;
+        /** Maximum reconnection attempts. Default: 5 */
+        maxAttempts?: number;
+        /** Base delay in milliseconds. Default: 1000 */
+        baseDelayMs?: number;
+    };
+}
+export interface Peer {
+    id: string;
+    connection: RTCPeerConnection;
+    audioLevel: number;
+    stream?: MediaStream;
+}
+interface VocaEvents {
+    'status': (status: ConnectionStatus) => void;
+    'error': (error: VocaError) => void;
+    'warning': (warning: {
+        code: string;
+        message: string;
+    }) => void;
+    'peer-joined': (peerId: string) => void;
+    'peer-left': (peerId: string) => void;
+    'peer-audio-level': (peerId: string, level: number) => void;
+    'local-audio-level': (level: number) => void;
+    'track': (peerId: string, track: MediaStreamTrack, stream: MediaStream) => void;
+}
+export declare class VocaClient {
+    peers: Map<string, Peer>;
+    localStream: MediaStream | null;
+    isMuted: boolean;
+    status: ConnectionStatus;
+    roomId: string;
+    private events;
+    private ws;
+    private audioContext;
+    private analyser;
+    private animationFrame;
+    private iceServers;
+    private config;
+    private reconnectAttempts;
+    private reconnectTimeout;
+    private shouldReconnect;
+    private peerAnalysers;
+    /**
+     * Create a new room and return a VocaClient connected to it.
+     * This is a convenience method that handles room creation via the API.
+     *
+     * @param config - VocaClient configuration (serverUrl required for non-browser environments)
+     * @returns Promise<VocaClient> - A new client instance for the created room
+     */
+    static createRoom(config?: VocaConfig): Promise<VocaClient>;
+    constructor(roomId: string, config?: VocaConfig);
+    on<E extends keyof VocaEvents>(event: E, callback: VocaEvents[E]): import("nanoevents", { with: { "resolution-mode": "import" } }).Unsubscribe;
+    connect(): Promise<void>;
+    disconnect(): void;
+    toggleMute(): boolean;
+    private setupMediaAndAudio;
+    private setupAudioAnalysis;
+    /**
+     * Infer the WebSocket server URL from config or environment.
+     */
+    private getServerUrl;
+    private connectSocket;
+    private handleSignal;
+    private createPeer;
+    private removePeer;
+    private setupRemoteAudio;
+    private send;
+    private handleError;
+}

package/dist/index.js

@@ -0,0 +1,3 @@
+var Q=()=>({emit(h,...q){for(let B=this.events[h]||[],z=0,G=B.length;z<G;z++)B[z](...q)},events:{},on(h,q){return(this.events[h]||=[]).push(q),()=>{this.events[h]=this.events[h]?.filter((B)=>q!==B)}}});var H={ROOM_NOT_FOUND:"room_not_found",ROOM_FULL:"room_full",MAX_ROOMS_REACHED:"max_rooms_reached",INVALID_ROOM_ID:"invalid_room_id",CONNECTION_FAILED:"connection_failed",WEBSOCKET_ERROR:"websocket_error",HEARTBEAT_TIMEOUT:"heartbeat_timeout",MICROPHONE_NOT_FOUND:"microphone_not_found",MICROPHONE_PERMISSION_DENIED:"microphone_permission_denied",INSECURE_CONTEXT:"insecure_context",INVALID_MESSAGE:"invalid_message",PEER_NOT_FOUND:"peer_not_found"},N={[H.ROOM_NOT_FOUND]:"Room not found",[H.ROOM_FULL]:"Room is at maximum capacity",[H.MAX_ROOMS_REACHED]:"Maximum number of rooms reached",[H.INVALID_ROOM_ID]:"Invalid room ID format",[H.CONNECTION_FAILED]:"Failed to connect to signaling server",[H.WEBSOCKET_ERROR]:"WebSocket connection error",[H.HEARTBEAT_TIMEOUT]:"Connection lost due to heartbeat timeout",[H.MICROPHONE_NOT_FOUND]:"No microphone found. Please connect a microphone and try again.",[H.MICROPHONE_PERMISSION_DENIED]:"Microphone permission denied. Please allow microphone access.",[H.INSECURE_CONTEXT]:"HTTPS is required for microphone access",[H.INVALID_MESSAGE]:"Invalid signaling message received",[H.PEER_NOT_FOUND]:"Peer not found in room"};function Z(h,q){return{code:h,message:q??N[h]}}var $=[{urls:"stun:stun.l.google.com:19302"},{urls:"stun:stun1.l.google.com:19302"}];class W{peers=new Map;localStream=null;isMuted=!1;status="connecting";roomId;events=Q();ws=null;audioContext=null;analyser=null;animationFrame=null;iceServers=$;config;reconnectAttempts=0;reconnectTimeout=null;shouldReconnect=!0;peerAnalysers=new Map;static async createRoom(h={}){let q=h.serverUrl?h.serverUrl.replace(/^ws/,"http"):typeof window<"u"?`${window.location.protocol}//${window.location.host}`:"";if(!q)throw Error("VocaConfig.serverUrl is required in non-browser environments");let B={"Content-Type":"application/json"};if(h.apiKey)B["x-api-key"]=h.apiKey;let z=await fetch(`${q}/api/room`,{method:"POST",headers:B,body:JSON.stringify(h)});if(!z.ok){let J=await z.json().catch(()=>({error:"unknown",message:"Failed to create room"}));throw Error(J.message||"Failed to create room")}let{room:G}=await z.json();return new W(G,h)}constructor(h,q={}){if(this.roomId=h,this.config=q,q.iceServers)this.iceServers=q.iceServers}on(h,q){return this.events.on(h,q)}async connect(){this.status="connecting",this.events.emit("status","connecting");try{await this.setupMediaAndAudio(),this.connectSocket()}catch(h){throw this.handleError(H.CONNECTION_FAILED,h instanceof Error?h.message:"Failed to connect"),h}}disconnect(){if(this.shouldReconnect=!1,this.reconnectTimeout)clearTimeout(this.reconnectTimeout),this.reconnectTimeout=null;if(this.animationFrame)cancelAnimationFrame(this.animationFrame);if(this.peers.forEach((h)=>h.connection.close()),this.peers.clear(),this.ws?.close(),this.localStream?.getTracks().forEach((h)=>h.stop()),this.audioContext&&this.audioContext.state!=="closed")this.audioContext.close().catch((h)=>console.warn("Error closing AudioContext",h));this.status="disconnected",this.events.emit("status","disconnected")}toggleMute(){let h=this.localStream?.getAudioTracks()[0];if(h)h.enabled=!h.enabled,this.isMuted=!h.enabled;return this.isMuted}async setupMediaAndAudio(){if(typeof window<"u"&&!window.isSecureContext)throw Error(N[H.INSECURE_CONTEXT]);try{this.localStream=await navigator.mediaDevices.getUserMedia({audio:{echoCancellation:!0,noiseSuppression:!0,autoGainControl:!0,latency:0,channelCount:1},video:!1})}catch(h){try{this.localStream=await navigator.mediaDevices.getUserMedia({audio:!0,video:!1})}catch(q){if(q.name==="NotFoundError"||q.message.includes("Requested device not found"))throw Error(N[H.MICROPHONE_NOT_FOUND]);if(q.name==="NotAllowedError"||q.message.includes("Permission denied"))throw Error(N[H.MICROPHONE_PERMISSION_DENIED]);throw q}}this.setupAudioAnalysis(this.localStream)}setupAudioAnalysis(h){let q=window.AudioContext||window.webkitAudioContext;this.audioContext=new q;let B=this.audioContext.createMediaStreamSource(h);this.analyser=this.audioContext.createAnalyser(),this.analyser.fftSize=256,B.connect(this.analyser);let z=new Uint8Array(this.analyser.frequencyBinCount),G=()=>{if(!this.analyser)return;this.analyser.getByteFrequencyData(z);let J=z.reduce((P,O)=>P+O,0)/z.length,K=Math.min(J/128,1);this.events.emit("local-audio-level",K),this.animationFrame=requestAnimationFrame(G)};G()}getServerUrl(){let h,q=this.config;if(typeof window>"u"){if(!q.serverUrl)throw Error("VocaConfig.serverUrl is required in non-browser environments");h=q.serverUrl}else if(q.serverUrl)h=q.serverUrl;else h=`${window.location.protocol==="https:"?"wss:":"ws:"}//${window.location.host}`;if(q.apiKey){let B=h.includes("?")?"&":"?";h+=`${B}apiKey=${encodeURIComponent(q.apiKey)}`}return`${h}/ws/${this.roomId}`}connectSocket(){let h=this.getServerUrl();this.ws=new WebSocket(h),this.ws.onopen=()=>{this.send({type:"hello",version:"1.0",client:"@treyorr/voca-client"}),this.status="connected",this.events.emit("status","connected"),this.reconnectAttempts=0},this.ws.onclose=()=>{if(this.status==="full"||this.status==="error")return;let q=this.config.reconnect?.enabled!==!1,B=this.config.reconnect?.maxAttempts??5,z=this.config.reconnect?.baseDelayMs??1000;if(q&&this.shouldReconnect&&this.reconnectAttempts<B){this.status="reconnecting",this.events.emit("status","reconnecting");let G=Math.min(z*Math.pow(2,this.reconnectAttempts),30000);this.reconnectAttempts++,this.reconnectTimeout=setTimeout(()=>{this.connectSocket()},G)}else this.status="disconnected",this.events.emit("status","disconnected")},this.ws.onerror=()=>this.handleError(H.WEBSOCKET_ERROR,"WebSocket connection failed"),this.ws.onmessage=(q)=>{let B=JSON.parse(q.data);this.handleSignal(B)}}async handleSignal(h){switch(h.type){case"welcome":console.debug("[Voca] Protocol version:",h.version,"Peer ID:",h.peer_id);break;case"join":await this.createPeer(h.from,!0);break;case"offer":await this.createPeer(h.from,!1,h.sdp);break;case"answer":let q=this.peers.get(h.from);if(q)await q.connection.setRemoteDescription({type:"answer",sdp:h.sdp});break;case"ice":let B=this.peers.get(h.from);if(B)try{await B.connection.addIceCandidate(JSON.parse(h.candidate))}catch(z){console.warn("[Voca] Invalid ICE candidate:",z)}break;case"ping":this.ws?.send(JSON.stringify({from:"",type:"pong"}));break;case"leave":this.removePeer(h.from);break;case"error":this.handleError(h.code??"unknown",h.message??"Unknown error");break}}async createPeer(h,q,B){let z=new RTCPeerConnection({iceServers:this.iceServers});if(z.onicecandidate=(G)=>{if(G.candidate)this.send({type:"ice",to:h,candidate:JSON.stringify(G.candidate)})},z.ontrack=(G)=>{this.events.emit("track",h,G.track,G.streams[0]),this.setupRemoteAudio(h,G.streams[0]);let J=this.peers.get(h);if(J)J.stream=G.streams[0]},this.localStream?.getTracks().forEach((G)=>z.addTrack(G,this.localStream)),this.peers.set(h,{id:h,connection:z,audioLevel:0}),this.events.emit("peer-joined",h),q){let G=await z.createOffer();await z.setLocalDescription(G),this.send({type:"offer",to:h,sdp:G.sdp})}else if(B){await z.setRemoteDescription({type:"offer",sdp:B});let G=await z.createAnswer();await z.setLocalDescription(G),this.send({type:"answer",to:h,sdp:G.sdp})}}removePeer(h){this.peers.get(h)?.connection.close(),this.peers.delete(h);let B=this.peerAnalysers.get(h);if(B)B.source.disconnect(),B.analyser.disconnect(),this.peerAnalysers.delete(h);this.events.emit("peer-left",h)}setupRemoteAudio(h,q){if(!this.audioContext){let K=window.AudioContext||window.webkitAudioContext;this.audioContext=new K}let B=this.audioContext.createMediaStreamSource(q),z=this.audioContext.createAnalyser();z.fftSize=256,B.connect(z),B.connect(this.audioContext.destination),this.peerAnalysers.set(h,{source:B,analyser:z});let G=new Uint8Array(z.frequencyBinCount),J=()=>{let K=this.peers.get(h);if(!K)return;z.getByteFrequencyData(G);let P=G.reduce((X,Y)=>X+Y,0)/G.length,O=Math.min(P/128,1);this.events.emit("peer-audio-level",h,O),K.audioLevel=O,requestAnimationFrame(J)};J()}send(h){if(this.ws?.readyState===WebSocket.OPEN)this.ws.send(JSON.stringify({from:"",...h}))}handleError(h,q){this.status=h===H.ROOM_FULL||h==="room_full"?"full":"error",this.events.emit("status",this.status),this.events.emit("error",{code:h,message:q})}}export{Z as createVocaError,N as VocaErrorMessages,H as VocaErrorCode,W as VocaClient};
+
+//# debugId=6D5B0730A9EDB40E64756E2164756E21

package/dist/index.js.map

@@ -0,0 +1,12 @@
+{
+  "version": 3,
+  "sources": ["../../../node_modules/.bun/nanoevents@9.1.0/node_modules/nanoevents/index.js", "../src/errors.ts", "../src/index.ts"],
+  "sourcesContent": [
+    "export let createNanoEvents = () => ({\n  emit(event, ...args) {\n    for (\n      let callbacks = this.events[event] || [],\n        i = 0,\n        length = callbacks.length;\n      i < length;\n      i++\n    ) {\n      callbacks[i](...args)\n    }\n  },\n  events: {},\n  on(event, cb) {\n    ;(this.events[event] ||= []).push(cb)\n    return () => {\n      this.events[event] = this.events[event]?.filter(i => cb !== i)\n    }\n  }\n})\n",
+    "/**\n * Voca Error Codes\n * \n * Unified error codes used across all Voca SDKs and the signaling server.\n */\n\nexport const VocaErrorCode = {\n    // Room errors\n    ROOM_NOT_FOUND: 'room_not_found',\n    ROOM_FULL: 'room_full',\n    MAX_ROOMS_REACHED: 'max_rooms_reached',\n    INVALID_ROOM_ID: 'invalid_room_id',\n\n    // Connection errors\n    CONNECTION_FAILED: 'connection_failed',\n    WEBSOCKET_ERROR: 'websocket_error',\n    HEARTBEAT_TIMEOUT: 'heartbeat_timeout',\n\n    // Media errors\n    MICROPHONE_NOT_FOUND: 'microphone_not_found',\n    MICROPHONE_PERMISSION_DENIED: 'microphone_permission_denied',\n    INSECURE_CONTEXT: 'insecure_context',\n\n    // Signaling errors\n    INVALID_MESSAGE: 'invalid_message',\n    PEER_NOT_FOUND: 'peer_not_found',\n} as const;\n\nexport type VocaErrorCode = typeof VocaErrorCode[keyof typeof VocaErrorCode];\n\n/**\n * Human-readable error messages for each error code\n */\nexport const VocaErrorMessages: Record<VocaErrorCode, string> = {\n    [VocaErrorCode.ROOM_NOT_FOUND]: 'Room not found',\n    [VocaErrorCode.ROOM_FULL]: 'Room is at maximum capacity',\n    [VocaErrorCode.MAX_ROOMS_REACHED]: 'Maximum number of rooms reached',\n    [VocaErrorCode.INVALID_ROOM_ID]: 'Invalid room ID format',\n    [VocaErrorCode.CONNECTION_FAILED]: 'Failed to connect to signaling server',\n    [VocaErrorCode.WEBSOCKET_ERROR]: 'WebSocket connection error',\n    [VocaErrorCode.HEARTBEAT_TIMEOUT]: 'Connection lost due to heartbeat timeout',\n    [VocaErrorCode.MICROPHONE_NOT_FOUND]: 'No microphone found. Please connect a microphone and try again.',\n    [VocaErrorCode.MICROPHONE_PERMISSION_DENIED]: 'Microphone permission denied. Please allow microphone access.',\n    [VocaErrorCode.INSECURE_CONTEXT]: 'HTTPS is required for microphone access',\n    [VocaErrorCode.INVALID_MESSAGE]: 'Invalid signaling message received',\n    [VocaErrorCode.PEER_NOT_FOUND]: 'Peer not found in room',\n};\n\n/**\n * Voca error with code and message\n */\nexport interface VocaError {\n    code: VocaErrorCode;\n    message: string;\n}\n\n/**\n * Create a VocaError from a code\n */\nexport function createVocaError(code: VocaErrorCode, customMessage?: string): VocaError {\n    return {\n        code,\n        message: customMessage ?? VocaErrorMessages[code],\n    };\n}\n",
+    "import { createNanoEvents } from 'nanoevents';\nimport { VocaErrorCode, VocaErrorMessages, type VocaError, createVocaError } from './errors';\n\nexport { VocaErrorCode, VocaErrorMessages, type VocaError, createVocaError } from './errors';\n\nexport type ConnectionStatus = 'connecting' | 'connected' | 'reconnecting' | 'full' | 'error' | 'disconnected';\n\nexport interface VocaConfig {\n    debug?: boolean;\n    iceServers?: RTCIceServer[];\n    serverUrl?: string; // e.g. \"ws://localhost:3001\" or \"wss://voca.vc\"\n    apiKey?: string; // optional API key for signaling server auth\n    /**\n     * Reconnection options. Enabled by default.\n     */\n    reconnect?: {\n        /** Enable automatic reconnection. Default: true */\n        enabled?: boolean;\n        /** Maximum reconnection attempts. Default: 5 */\n        maxAttempts?: number;\n        /** Base delay in milliseconds. Default: 1000 */\n        baseDelayMs?: number;\n    };\n}\n\nexport interface Peer {\n    id: string;\n    connection: RTCPeerConnection;\n    audioLevel: number;\n    stream?: MediaStream;\n}\n\ntype SignalMessage = {\n    from: string;\n    type: 'hello' | 'welcome' | 'join' | 'leave' | 'offer' | 'answer' | 'ice' | 'ping' | 'pong' | 'error';\n    peer_id?: string;\n    to?: string;\n    sdp?: string;\n    candidate?: string;\n    code?: string;\n    message?: string;\n    // Protocol versioning\n    version?: string;\n    client?: string;\n};\n\ninterface VocaEvents {\n    'status': (status: ConnectionStatus) => void;\n    'error': (error: VocaError) => void;\n    'warning': (warning: { code: string; message: string }) => void;\n    'peer-joined': (peerId: string) => void;\n    'peer-left': (peerId: string) => void;\n    'peer-audio-level': (peerId: string, level: number) => void;\n    'local-audio-level': (level: number) => void;\n    'track': (peerId: string, track: MediaStreamTrack, stream: MediaStream) => void;\n}\n\nconst DEFAULT_ICE_SERVERS: RTCIceServer[] = [\n    { urls: 'stun:stun.l.google.com:19302' },\n    { urls: 'stun:stun1.l.google.com:19302' },\n];\n\nexport class VocaClient {\n    public peers: Map<string, Peer> = new Map();\n    public localStream: MediaStream | null = null;\n    public isMuted: boolean = false;\n    public status: ConnectionStatus = 'connecting';\n    public roomId: string;\n\n    private events = createNanoEvents<VocaEvents>();\n    private ws: WebSocket | null = null;\n    private audioContext: AudioContext | null = null;\n    private analyser: AnalyserNode | null = null;\n    private animationFrame: number | null = null;\n    private iceServers: RTCIceServer[] = DEFAULT_ICE_SERVERS;\n    private config: VocaConfig;\n\n    // Reconnection state\n    private reconnectAttempts = 0;\n    private reconnectTimeout: ReturnType<typeof setTimeout> | null = null;\n    private shouldReconnect = true;\n\n    // Audio analysis nodes per peer (for cleanup)\n    private peerAnalysers: Map<string, { source: MediaStreamAudioSourceNode; analyser: AnalyserNode }> = new Map();\n\n    /**\n     * Create a new room and return a VocaClient connected to it.\n     * This is a convenience method that handles room creation via the API.\n     * \n     * @param config - VocaClient configuration (serverUrl required for non-browser environments)\n     * @returns Promise<VocaClient> - A new client instance for the created room\n     */\n    static async createRoom(config: VocaConfig = {}): Promise<VocaClient> {\n        // Determine the HTTP base URL from serverUrl or window.location\n        const serverUrl = config.serverUrl\n            ? config.serverUrl.replace(/^ws/, 'http')\n            : (typeof window !== 'undefined' ? `${window.location.protocol}//${window.location.host}` : '');\n\n        if (!serverUrl) {\n            throw new Error('VocaConfig.serverUrl is required in non-browser environments');\n        }\n\n        const headers: HeadersInit = {\n            'Content-Type': 'application/json',\n        };\n\n        if (config.apiKey) {\n            headers['x-api-key'] = config.apiKey;\n        }\n\n        const response = await fetch(`${serverUrl}/api/room`, {\n            method: 'POST',\n            headers,\n            body: JSON.stringify(config)\n        });\n\n        if (!response.ok) {\n            const error = await response.json().catch(() => ({ error: 'unknown', message: 'Failed to create room' }));\n            throw new Error(error.message || 'Failed to create room');\n        }\n\n        const { room } = await response.json();\n        return new VocaClient(room, config);\n    }\n\n    constructor(roomId: string, config: VocaConfig = {}) {\n        this.roomId = roomId;\n        this.config = config;\n        if (config.iceServers) this.iceServers = config.iceServers;\n        // turnServers is no longer part of VocaConfig, removed this line\n    }\n\n    public on<E extends keyof VocaEvents>(event: E, callback: VocaEvents[E]) {\n        return this.events.on(event, callback);\n    }\n\n    public async connect(): Promise<void> {\n        this.status = 'connecting';\n        this.events.emit('status', 'connecting');\n\n        try {\n            // Use default STUN servers (Google's public STUN servers)\n            await this.setupMediaAndAudio();\n            this.connectSocket();\n        } catch (err) {\n            this.handleError(VocaErrorCode.CONNECTION_FAILED, err instanceof Error ? err.message : 'Failed to connect');\n            throw err;\n        }\n    }\n\n    public disconnect() {\n        // Prevent reconnection attempts\n        this.shouldReconnect = false;\n        if (this.reconnectTimeout) {\n            clearTimeout(this.reconnectTimeout);\n            this.reconnectTimeout = null;\n        }\n\n        if (this.animationFrame) cancelAnimationFrame(this.animationFrame);\n        this.peers.forEach((p) => p.connection.close());\n        this.peers.clear();\n        this.ws?.close();\n        this.localStream?.getTracks().forEach((t) => t.stop());\n        if (this.audioContext && this.audioContext.state !== 'closed') {\n            this.audioContext.close().catch(e => console.warn('Error closing AudioContext', e));\n        }\n        this.status = 'disconnected';\n        this.events.emit('status', 'disconnected');\n    }\n\n    public toggleMute() {\n        const track = this.localStream?.getAudioTracks()[0];\n        if (track) {\n            track.enabled = !track.enabled;\n            this.isMuted = !track.enabled;\n        }\n        return this.isMuted;\n    }\n\n\n\n    private async setupMediaAndAudio() {\n        // Only verify secure context in browsers\n        if (typeof window !== 'undefined' && !window.isSecureContext) {\n            throw new Error(VocaErrorMessages[VocaErrorCode.INSECURE_CONTEXT]);\n        }\n\n        try {\n            this.localStream = await navigator.mediaDevices.getUserMedia({\n                audio: {\n                    echoCancellation: true,\n                    noiseSuppression: true,\n                    autoGainControl: true,\n                    latency: 0,\n                    channelCount: 1\n                } as any,\n                video: false,\n            });\n        } catch (err) {\n            try {\n                this.localStream = await navigator.mediaDevices.getUserMedia({ audio: true, video: false });\n            } catch (retryErr: any) {\n                if (retryErr.name === 'NotFoundError' || retryErr.message.includes('Requested device not found')) {\n                    throw new Error(VocaErrorMessages[VocaErrorCode.MICROPHONE_NOT_FOUND]);\n                }\n                if (retryErr.name === 'NotAllowedError' || retryErr.message.includes('Permission denied')) {\n                    throw new Error(VocaErrorMessages[VocaErrorCode.MICROPHONE_PERMISSION_DENIED]);\n                }\n                throw retryErr;\n            }\n        }\n\n        this.setupAudioAnalysis(this.localStream!);\n    }\n\n    private setupAudioAnalysis(stream: MediaStream) {\n        const AudioContextClass = window.AudioContext || (window as any).webkitAudioContext;\n        this.audioContext = new AudioContextClass();\n        const source = this.audioContext.createMediaStreamSource(stream);\n        this.analyser = this.audioContext.createAnalyser();\n        this.analyser.fftSize = 256;\n        source.connect(this.analyser);\n\n        const dataArray = new Uint8Array(this.analyser.frequencyBinCount);\n        const update = () => {\n            if (!this.analyser) return;\n            this.analyser.getByteFrequencyData(dataArray);\n            const avg = dataArray.reduce((a, b) => a + b, 0) / dataArray.length;\n            const level = Math.min(avg / 128, 1);\n            this.events.emit('local-audio-level', level);\n            this.animationFrame = requestAnimationFrame(update);\n        };\n        update();\n    }\n\n    /**\n     * Infer the WebSocket server URL from config or environment.\n     */\n    private getServerUrl(): string {\n        let url: string;\n        const config = this.config;\n\n        // Non-browser environments require explicit serverUrl\n        if (typeof window === 'undefined') {\n            if (!config.serverUrl) {\n                throw new Error('VocaConfig.serverUrl is required in non-browser environments');\n            }\n            url = config.serverUrl;\n        } else {\n            if (config.serverUrl) {\n                url = config.serverUrl;\n            } else {\n                const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';\n                url = `${protocol}//${window.location.host}`;\n            }\n        }\n\n        // Append apiKey if present\n        if (config.apiKey) {\n            const separator = url.includes('?') ? '&' : '?';\n            url += `${separator}apiKey=${encodeURIComponent(config.apiKey)}`;\n        }\n\n        return `${url}/ws/${this.roomId}`;\n    }\n\n    private connectSocket() {\n        const socketUrl = this.getServerUrl();\n\n        this.ws = new WebSocket(socketUrl);\n\n        this.ws.onopen = () => {\n            // Send hello message with version info\n            this.send({ type: 'hello', version: '1.0', client: '@treyorr/voca-client' });\n            this.status = 'connected';\n            this.events.emit('status', 'connected');\n            // Reset reconnect attempts on successful connection\n            this.reconnectAttempts = 0;\n        };\n\n        this.ws.onclose = () => {\n            // Don't reconnect on terminal states\n            if (this.status === 'full' || this.status === 'error') {\n                return;\n            }\n\n            const reconnectEnabled = this.config.reconnect?.enabled !== false;\n            const maxAttempts = this.config.reconnect?.maxAttempts ?? 5;\n            const baseDelay = this.config.reconnect?.baseDelayMs ?? 1000;\n\n            if (reconnectEnabled && this.shouldReconnect && this.reconnectAttempts < maxAttempts) {\n                this.status = 'reconnecting';\n                this.events.emit('status', 'reconnecting');\n\n                // Exponential backoff: 1s, 2s, 4s, 8s, 16s (capped at 30s)\n                const delay = Math.min(baseDelay * Math.pow(2, this.reconnectAttempts), 30000);\n                this.reconnectAttempts++;\n\n                this.reconnectTimeout = setTimeout(() => {\n                    this.connectSocket();\n                }, delay);\n            } else {\n                this.status = 'disconnected';\n                this.events.emit('status', 'disconnected');\n            }\n        };\n\n        this.ws.onerror = () => this.handleError(VocaErrorCode.WEBSOCKET_ERROR, 'WebSocket connection failed');\n\n        this.ws.onmessage = (e) => {\n            const msg: SignalMessage = JSON.parse(e.data);\n            this.handleSignal(msg);\n        };\n    }\n\n    private async handleSignal(msg: SignalMessage) {\n        switch (msg.type) {\n            case 'welcome':\n                // Protocol handshake complete - peer_id is managed server-side\n                console.debug('[Voca] Protocol version:', msg.version, 'Peer ID:', msg.peer_id);\n                break;\n            case 'join':\n                await this.createPeer(msg.from, true);\n                break;\n            case 'offer':\n                await this.createPeer(msg.from, false, msg.sdp);\n                break;\n            case 'answer':\n                const peer = this.peers.get(msg.from);\n                if (peer) {\n                    await peer.connection.setRemoteDescription({ type: 'answer', sdp: msg.sdp! });\n                }\n                break;\n            case 'ice':\n                const p = this.peers.get(msg.from);\n                if (p) {\n                    try {\n                        await p.connection.addIceCandidate(JSON.parse(msg.candidate!));\n                    } catch (e) {\n                        console.warn('[Voca] Invalid ICE candidate:', e);\n                    }\n                }\n                break;\n            case 'ping':\n                this.ws?.send(JSON.stringify({ from: '', type: 'pong' }));\n                break;\n            case 'leave':\n                this.removePeer(msg.from);\n                break;\n            case 'error':\n                this.handleError(msg.code ?? 'unknown', msg.message ?? 'Unknown error');\n                break;\n        }\n    }\n\n    private async createPeer(peerId: string, isInitiator: boolean, remoteSdp?: string) {\n        const pc = new RTCPeerConnection({ iceServers: this.iceServers });\n\n        pc.onicecandidate = (e) => {\n            if (e.candidate) this.send({ type: 'ice', to: peerId, candidate: JSON.stringify(e.candidate) });\n        };\n\n        pc.ontrack = (e) => {\n            // Emit track event so UI can handle the audio element/stream\n            this.events.emit('track', peerId, e.track, e.streams[0]);\n            this.setupRemoteAudio(peerId, e.streams[0]);\n            const peer = this.peers.get(peerId);\n            if (peer) peer.stream = e.streams[0];\n        };\n\n        // Add local tracks\n        this.localStream?.getTracks().forEach((track) => pc.addTrack(track, this.localStream!));\n\n        this.peers.set(peerId, { id: peerId, connection: pc, audioLevel: 0 });\n        this.events.emit('peer-joined', peerId);\n\n        if (isInitiator) {\n            const offer = await pc.createOffer();\n            await pc.setLocalDescription(offer);\n            this.send({ type: 'offer', to: peerId, sdp: offer.sdp });\n        } else if (remoteSdp) {\n            await pc.setRemoteDescription({ type: 'offer', sdp: remoteSdp });\n            const answer = await pc.createAnswer();\n            await pc.setLocalDescription(answer);\n            this.send({ type: 'answer', to: peerId, sdp: answer.sdp });\n        }\n    }\n\n    private removePeer(peerId: string) {\n        const peer = this.peers.get(peerId);\n        peer?.connection.close();\n        this.peers.delete(peerId);\n\n        // Clean up audio analysis nodes\n        const audio = this.peerAnalysers.get(peerId);\n        if (audio) {\n            audio.source.disconnect();\n            audio.analyser.disconnect();\n            this.peerAnalysers.delete(peerId);\n        }\n\n        this.events.emit('peer-left', peerId);\n    }\n\n    private setupRemoteAudio(peerId: string, stream: MediaStream) {\n        if (!this.audioContext) {\n            const AudioContextClass = window.AudioContext || (window as any).webkitAudioContext;\n            this.audioContext = new AudioContextClass();\n        }\n\n        const source = this.audioContext.createMediaStreamSource(stream);\n        const analyser = this.audioContext.createAnalyser();\n        analyser.fftSize = 256;\n        source.connect(analyser);\n\n        // CRITICAL: Connect to speakers so audio is actually played!\n        source.connect(this.audioContext.destination);\n\n        // Store for cleanup when peer leaves\n        this.peerAnalysers.set(peerId, { source, analyser });\n\n        const data = new Uint8Array(analyser.frequencyBinCount);\n        const update = () => {\n            const peer = this.peers.get(peerId);\n            if (!peer) return;\n\n            analyser.getByteFrequencyData(data);\n            const avg = data.reduce((a, b) => a + b, 0) / data.length;\n            const level = Math.min(avg / 128, 1);\n\n            this.events.emit('peer-audio-level', peerId, level);\n\n            // Store in peer object as well for convenience\n            peer.audioLevel = level;\n\n            requestAnimationFrame(update);\n        };\n        update();\n    }\n\n    private send(msg: Partial<SignalMessage>) {\n        if (this.ws?.readyState === WebSocket.OPEN) {\n            this.ws.send(JSON.stringify({ from: '', ...msg }));\n        }\n    }\n\n    private handleError(code: VocaErrorCode | string, message: string) {\n        this.status = code === VocaErrorCode.ROOM_FULL || code === 'room_full' ? 'full' : 'error';\n        this.events.emit('status', this.status);\n        this.events.emit('error', { code: code as VocaErrorCode, message });\n    }\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "6D5B0730A9EDB40E64756E2164756E21",
+  "names": []
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@treyorr/voca-client",
+  "version": "0.1.0",
+  "description": "Core TypeScript SDK for Voca Signaling",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "bun build src/index.ts --outdir dist --format esm --sourcemap=external --minify && tsc --emitDeclarationOnly --outDir dist",
+    "dev": "bun build src/index.ts --outdir dist --format esm --watch",
+    "lint": "tsc --noEmit",
+    "test": "bun test",
+    "test:watch": "bun test --watch"
+  },
+  "keywords": [
+    "webrtc",
+    "signaling",
+    "voca"
+  ],
+  "author": "Trey Orr",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/treyorr/voca.git",
+    "directory": "packages/voca-client"
+  },
+  "homepage": "https://voca.vc",
+  "bugs": "https://github.com/treyorr/voca/issues",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "nanoevents": "^9.1.0"
+  }
+}

package/src/__tests__/client.test.ts

@@ -0,0 +1,184 @@
+import { describe, it, expect, beforeEach, afterEach, mock } from 'bun:test';
+import { VocaClient } from '../index';
+
+// Mock WebSocket
+class MockWebSocket {
+    static OPEN = 1;
+    static CLOSED = 3;
+
+    readyState = MockWebSocket.OPEN;
+    onopen: (() => void) | null = null;
+    onclose: (() => void) | null = null;
+    onmessage: ((e: { data: string }) => void) | null = null;
+    onerror: (() => void) | null = null;
+
+    constructor(public url: string) {
+        // Simulate async connection
+        setTimeout(() => this.onopen?.(), 0);
+    }
+
+    send = mock();
+    close = mock(() => {
+        this.readyState = MockWebSocket.CLOSED;
+        this.onclose?.();
+    });
+}
+
+// Mock navigator.mediaDevices
+const createMockMediaStream = () => {
+    const trackState = { enabled: true };
+    const mockTrack = {
+        stop: mock(),
+    };
+    Object.defineProperty(mockTrack, 'enabled', {
+        get: () => trackState.enabled,
+        set: (v: boolean) => { trackState.enabled = v; },
+    });
+
+    return {
+        getTracks: () => [mockTrack],
+        getAudioTracks: () => [mockTrack],
+    };
+};
+
+const mockGetUserMedia = mock().mockImplementation(() => Promise.resolve(createMockMediaStream()));
+
+// Mock AudioContext
+class MockAudioContext {
+    state = 'running';
+    createMediaStreamSource = mock(() => ({ connect: mock() }));
+    createAnalyser = mock(() => ({
+        fftSize: 256,
+        frequencyBinCount: 128,
+        getByteFrequencyData: mock(),
+    }));
+    close = mock().mockResolvedValue(undefined);
+}
+
+// Setup global mocks
+beforeEach(() => {
+    (globalThis as any).WebSocket = MockWebSocket;
+    (globalThis as any).navigator = {
+        mediaDevices: { getUserMedia: mockGetUserMedia },
+    };
+    (globalThis as any).AudioContext = MockAudioContext;
+    (globalThis as any).window = {
+        location: { protocol: 'https:', host: 'localhost:3001', origin: 'https://localhost:3001' },
+        isSecureContext: true,
+        AudioContext: MockAudioContext,
+    };
+    (globalThis as any).requestAnimationFrame = mock();
+    (globalThis as any).cancelAnimationFrame = mock();
+});
+
+afterEach(() => {
+    // Bun doesn't have restoreAllMocks, but we can manually clean up
+    mockGetUserMedia.mockClear();
+});
+
+describe('VocaClient', () => {
+    describe('constructor', () => {
+        it('should create a client with roomId', () => {
+            const client = new VocaClient('test-room');
+            expect(client).toBeDefined();
+        });
+
+        it('should accept custom config', () => {
+            const client = new VocaClient('test-room', {
+                signalingUrl: 'wss://custom.example.com',
+            });
+            expect(client).toBeDefined();
+        });
+
+        it('should accept custom config with apiKey', () => {
+            const client = new VocaClient('test-room', {
+                apiKey: 'test-key',
+            });
+            expect(client).toBeDefined();
+        });
+
+        it('should include apiKey in WebSocket URL', () => {
+            const client = new VocaClient('test-room', {
+                apiKey: 'test-api-key',
+            });
+            expect(client).toBeDefined();
+        });
+    });
+
+    describe('createRoom', () => {
+        it('should create a room via API and return client', async () => {
+            globalThis.fetch = mock(() => Promise.resolve({
+                ok: true,
+                json: () => Promise.resolve({ roomId: 'new-room' }),
+            } as Response));
+
+            const client = await VocaClient.createRoom();
+            expect(client).toBeDefined();
+        });
+
+        it('should include x-api-key header when apiKey is configured', async () => {
+            const fetchMock = mock(() => Promise.resolve({
+                ok: true,
+                json: () => Promise.resolve({ roomId: 'new-room' }),
+            } as Response));
+            globalThis.fetch = fetchMock;
+
+            await VocaClient.createRoom({ apiKey: 'test-key' });
+            expect(fetchMock).toHaveBeenCalled();
+        });
+
+        it('should throw on API error', async () => {
+            globalThis.fetch = mock(() => Promise.resolve({
+                ok: false,
+                status: 500,
+            } as Response));
+
+            await expect(VocaClient.createRoom()).rejects.toThrow();
+        });
+    });
+
+    describe('connect', () => {
+        it('should emit status events during connection', async () => {
+            const client = new VocaClient('test-room');
+            const statusEvents: string[] = [];
+
+            client.on('status', (status) => {
+                statusEvents.push(status);
+            });
+
+            await client.connect();
+
+            expect(statusEvents.length).toBeGreaterThan(0);
+        });
+    });
+
+    describe('disconnect', () => {
+        it('should clean up resources on disconnect', async () => {
+            const client = new VocaClient('test-room');
+            await client.connect();
+            client.disconnect();
+
+            expect(client).toBeDefined();
+        });
+    });
+
+    describe('toggleMute', () => {
+        it('should return mute state when called', async () => {
+            const client = new VocaClient('test-room');
+            await client.connect();
+
+            const result = client.toggleMute();
+            expect(typeof result).toBe('boolean');
+        });
+    });
+
+    describe('event emitter', () => {
+        it('should allow subscribing to events', () => {
+            const client = new VocaClient('test-room');
+            const handler = mock();
+
+            client.on('status', handler);
+            expect(handler).not.toHaveBeenCalled();
+        });
+    });
+});

package/src/errors.ts

@@ -0,0 +1,65 @@
+/**
+ * Voca Error Codes
+ * 
+ * Unified error codes used across all Voca SDKs and the signaling server.
+ */
+
+export const VocaErrorCode = {
+    // Room errors
+    ROOM_NOT_FOUND: 'room_not_found',
+    ROOM_FULL: 'room_full',
+    MAX_ROOMS_REACHED: 'max_rooms_reached',
+    INVALID_ROOM_ID: 'invalid_room_id',
+
+    // Connection errors
+    CONNECTION_FAILED: 'connection_failed',
+    WEBSOCKET_ERROR: 'websocket_error',
+    HEARTBEAT_TIMEOUT: 'heartbeat_timeout',
+
+    // Media errors
+    MICROPHONE_NOT_FOUND: 'microphone_not_found',
+    MICROPHONE_PERMISSION_DENIED: 'microphone_permission_denied',
+    INSECURE_CONTEXT: 'insecure_context',
+
+    // Signaling errors
+    INVALID_MESSAGE: 'invalid_message',
+    PEER_NOT_FOUND: 'peer_not_found',
+} as const;
+
+export type VocaErrorCode = typeof VocaErrorCode[keyof typeof VocaErrorCode];
+
+/**
+ * Human-readable error messages for each error code
+ */
+export const VocaErrorMessages: Record<VocaErrorCode, string> = {
+    [VocaErrorCode.ROOM_NOT_FOUND]: 'Room not found',
+    [VocaErrorCode.ROOM_FULL]: 'Room is at maximum capacity',
+    [VocaErrorCode.MAX_ROOMS_REACHED]: 'Maximum number of rooms reached',
+    [VocaErrorCode.INVALID_ROOM_ID]: 'Invalid room ID format',
+    [VocaErrorCode.CONNECTION_FAILED]: 'Failed to connect to signaling server',
+    [VocaErrorCode.WEBSOCKET_ERROR]: 'WebSocket connection error',
+    [VocaErrorCode.HEARTBEAT_TIMEOUT]: 'Connection lost due to heartbeat timeout',
+    [VocaErrorCode.MICROPHONE_NOT_FOUND]: 'No microphone found. Please connect a microphone and try again.',
+    [VocaErrorCode.MICROPHONE_PERMISSION_DENIED]: 'Microphone permission denied. Please allow microphone access.',
+    [VocaErrorCode.INSECURE_CONTEXT]: 'HTTPS is required for microphone access',
+    [VocaErrorCode.INVALID_MESSAGE]: 'Invalid signaling message received',
+    [VocaErrorCode.PEER_NOT_FOUND]: 'Peer not found in room',
+};
+
+/**
+ * Voca error with code and message
+ */
+export interface VocaError {
+    code: VocaErrorCode;
+    message: string;
+}
+
+/**
+ * Create a VocaError from a code
+ */
+export function createVocaError(code: VocaErrorCode, customMessage?: string): VocaError {
+    return {
+        code,
+        message: customMessage ?? VocaErrorMessages[code],
+    };
+}

package/src/index.ts

@@ -0,0 +1,452 @@
+import { createNanoEvents } from 'nanoevents';
+import { VocaErrorCode, VocaErrorMessages, type VocaError, createVocaError } from './errors';
+
+export { VocaErrorCode, VocaErrorMessages, type VocaError, createVocaError } from './errors';
+
+export type ConnectionStatus = 'connecting' | 'connected' | 'reconnecting' | 'full' | 'error' | 'disconnected';
+
+export interface VocaConfig {
+    debug?: boolean;
+    iceServers?: RTCIceServer[];
+    serverUrl?: string; // e.g. "ws://localhost:3001" or "wss://voca.vc"
+    apiKey?: string; // optional API key for signaling server auth
+    /**
+     * Reconnection options. Enabled by default.
+     */
+    reconnect?: {
+        /** Enable automatic reconnection. Default: true */
+        enabled?: boolean;
+        /** Maximum reconnection attempts. Default: 5 */
+        maxAttempts?: number;
+        /** Base delay in milliseconds. Default: 1000 */
+        baseDelayMs?: number;
+    };
+}
+
+export interface Peer {
+    id: string;
+    connection: RTCPeerConnection;
+    audioLevel: number;
+    stream?: MediaStream;
+}
+
+type SignalMessage = {
+    from: string;
+    type: 'hello' | 'welcome' | 'join' | 'leave' | 'offer' | 'answer' | 'ice' | 'ping' | 'pong' | 'error';
+    peer_id?: string;
+    to?: string;
+    sdp?: string;
+    candidate?: string;
+    code?: string;
+    message?: string;
+    // Protocol versioning
+    version?: string;
+    client?: string;
+};
+
+interface VocaEvents {
+    'status': (status: ConnectionStatus) => void;
+    'error': (error: VocaError) => void;
+    'warning': (warning: { code: string; message: string }) => void;
+    'peer-joined': (peerId: string) => void;
+    'peer-left': (peerId: string) => void;
+    'peer-audio-level': (peerId: string, level: number) => void;
+    'local-audio-level': (level: number) => void;
+    'track': (peerId: string, track: MediaStreamTrack, stream: MediaStream) => void;
+}
+
+const DEFAULT_ICE_SERVERS: RTCIceServer[] = [
+    { urls: 'stun:stun.l.google.com:19302' },
+    { urls: 'stun:stun1.l.google.com:19302' },
+];
+
+export class VocaClient {
+    public peers: Map<string, Peer> = new Map();
+    public localStream: MediaStream | null = null;
+    public isMuted: boolean = false;
+    public status: ConnectionStatus = 'connecting';
+    public roomId: string;
+
+    private events = createNanoEvents<VocaEvents>();
+    private ws: WebSocket | null = null;
+    private audioContext: AudioContext | null = null;
+    private analyser: AnalyserNode | null = null;
+    private animationFrame: number | null = null;
+    private iceServers: RTCIceServer[] = DEFAULT_ICE_SERVERS;
+    private config: VocaConfig;
+
+    // Reconnection state
+    private reconnectAttempts = 0;
+    private reconnectTimeout: ReturnType<typeof setTimeout> | null = null;
+    private shouldReconnect = true;
+
+    // Audio analysis nodes per peer (for cleanup)
+    private peerAnalysers: Map<string, { source: MediaStreamAudioSourceNode; analyser: AnalyserNode }> = new Map();
+
+    /**
+     * Create a new room and return a VocaClient connected to it.
+     * This is a convenience method that handles room creation via the API.
+     * 
+     * @param config - VocaClient configuration (serverUrl required for non-browser environments)
+     * @returns Promise<VocaClient> - A new client instance for the created room
+     */
+    static async createRoom(config: VocaConfig = {}): Promise<VocaClient> {
+        // Determine the HTTP base URL from serverUrl or window.location
+        const serverUrl = config.serverUrl
+            ? config.serverUrl.replace(/^ws/, 'http')
+            : (typeof window !== 'undefined' ? `${window.location.protocol}//${window.location.host}` : '');
+
+        if (!serverUrl) {
+            throw new Error('VocaConfig.serverUrl is required in non-browser environments');
+        }
+
+        const headers: HeadersInit = {
+            'Content-Type': 'application/json',
+        };
+
+        if (config.apiKey) {
+            headers['x-api-key'] = config.apiKey;
+        }
+
+        const response = await fetch(`${serverUrl}/api/room`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(config)
+        });
+
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'unknown', message: 'Failed to create room' }));
+            throw new Error(error.message || 'Failed to create room');
+        }
+
+        const { room } = await response.json();
+        return new VocaClient(room, config);
+    }
+
+    constructor(roomId: string, config: VocaConfig = {}) {
+        this.roomId = roomId;
+        this.config = config;
+        if (config.iceServers) this.iceServers = config.iceServers;
+        // turnServers is no longer part of VocaConfig, removed this line
+    }
+
+    public on<E extends keyof VocaEvents>(event: E, callback: VocaEvents[E]) {
+        return this.events.on(event, callback);
+    }
+
+    public async connect(): Promise<void> {
+        this.status = 'connecting';
+        this.events.emit('status', 'connecting');
+
+        try {
+            // Use default STUN servers (Google's public STUN servers)
+            await this.setupMediaAndAudio();
+            this.connectSocket();
+        } catch (err) {
+            this.handleError(VocaErrorCode.CONNECTION_FAILED, err instanceof Error ? err.message : 'Failed to connect');
+            throw err;
+        }
+    }
+
+    public disconnect() {
+        // Prevent reconnection attempts
+        this.shouldReconnect = false;
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = null;
+        }
+
+        if (this.animationFrame) cancelAnimationFrame(this.animationFrame);
+        this.peers.forEach((p) => p.connection.close());
+        this.peers.clear();
+        this.ws?.close();
+        this.localStream?.getTracks().forEach((t) => t.stop());
+        if (this.audioContext && this.audioContext.state !== 'closed') {
+            this.audioContext.close().catch(e => console.warn('Error closing AudioContext', e));
+        }
+        this.status = 'disconnected';
+        this.events.emit('status', 'disconnected');
+    }
+
+    public toggleMute() {
+        const track = this.localStream?.getAudioTracks()[0];
+        if (track) {
+            track.enabled = !track.enabled;
+            this.isMuted = !track.enabled;
+        }
+        return this.isMuted;
+    }
+
+
+
+    private async setupMediaAndAudio() {
+        // Only verify secure context in browsers
+        if (typeof window !== 'undefined' && !window.isSecureContext) {
+            throw new Error(VocaErrorMessages[VocaErrorCode.INSECURE_CONTEXT]);
+        }
+
+        try {
+            this.localStream = await navigator.mediaDevices.getUserMedia({
+                audio: {
+                    echoCancellation: true,
+                    noiseSuppression: true,
+                    autoGainControl: true,
+                    latency: 0,
+                    channelCount: 1
+                } as any,
+                video: false,
+            });
+        } catch (err) {
+            try {
+                this.localStream = await navigator.mediaDevices.getUserMedia({ audio: true, video: false });
+            } catch (retryErr: any) {
+                if (retryErr.name === 'NotFoundError' || retryErr.message.includes('Requested device not found')) {
+                    throw new Error(VocaErrorMessages[VocaErrorCode.MICROPHONE_NOT_FOUND]);
+                }
+                if (retryErr.name === 'NotAllowedError' || retryErr.message.includes('Permission denied')) {
+                    throw new Error(VocaErrorMessages[VocaErrorCode.MICROPHONE_PERMISSION_DENIED]);
+                }
+                throw retryErr;
+            }
+        }
+
+        this.setupAudioAnalysis(this.localStream!);
+    }
+
+    private setupAudioAnalysis(stream: MediaStream) {
+        const AudioContextClass = window.AudioContext || (window as any).webkitAudioContext;
+        this.audioContext = new AudioContextClass();
+        const source = this.audioContext.createMediaStreamSource(stream);
+        this.analyser = this.audioContext.createAnalyser();
+        this.analyser.fftSize = 256;
+        source.connect(this.analyser);
+
+        const dataArray = new Uint8Array(this.analyser.frequencyBinCount);
+        const update = () => {
+            if (!this.analyser) return;
+            this.analyser.getByteFrequencyData(dataArray);
+            const avg = dataArray.reduce((a, b) => a + b, 0) / dataArray.length;
+            const level = Math.min(avg / 128, 1);
+            this.events.emit('local-audio-level', level);
+            this.animationFrame = requestAnimationFrame(update);
+        };
+        update();
+    }
+
+    /**
+     * Infer the WebSocket server URL from config or environment.
+     */
+    private getServerUrl(): string {
+        let url: string;
+        const config = this.config;
+
+        // Non-browser environments require explicit serverUrl
+        if (typeof window === 'undefined') {
+            if (!config.serverUrl) {
+                throw new Error('VocaConfig.serverUrl is required in non-browser environments');
+            }
+            url = config.serverUrl;
+        } else {
+            if (config.serverUrl) {
+                url = config.serverUrl;
+            } else {
+                const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+                url = `${protocol}//${window.location.host}`;
+            }
+        }
+
+        // Append apiKey if present
+        if (config.apiKey) {
+            const separator = url.includes('?') ? '&' : '?';
+            url += `${separator}apiKey=${encodeURIComponent(config.apiKey)}`;
+        }
+
+        return `${url}/ws/${this.roomId}`;
+    }
+
+    private connectSocket() {
+        const socketUrl = this.getServerUrl();
+
+        this.ws = new WebSocket(socketUrl);
+
+        this.ws.onopen = () => {
+            // Send hello message with version info
+            this.send({ type: 'hello', version: '1.0', client: '@treyorr/voca-client' });
+            this.status = 'connected';
+            this.events.emit('status', 'connected');
+            // Reset reconnect attempts on successful connection
+            this.reconnectAttempts = 0;
+        };
+
+        this.ws.onclose = () => {
+            // Don't reconnect on terminal states
+            if (this.status === 'full' || this.status === 'error') {
+                return;
+            }
+
+            const reconnectEnabled = this.config.reconnect?.enabled !== false;
+            const maxAttempts = this.config.reconnect?.maxAttempts ?? 5;
+            const baseDelay = this.config.reconnect?.baseDelayMs ?? 1000;
+
+            if (reconnectEnabled && this.shouldReconnect && this.reconnectAttempts < maxAttempts) {
+                this.status = 'reconnecting';
+                this.events.emit('status', 'reconnecting');
+
+                // Exponential backoff: 1s, 2s, 4s, 8s, 16s (capped at 30s)
+                const delay = Math.min(baseDelay * Math.pow(2, this.reconnectAttempts), 30000);
+                this.reconnectAttempts++;
+
+                this.reconnectTimeout = setTimeout(() => {
+                    this.connectSocket();
+                }, delay);
+            } else {
+                this.status = 'disconnected';
+                this.events.emit('status', 'disconnected');
+            }
+        };
+
+        this.ws.onerror = () => this.handleError(VocaErrorCode.WEBSOCKET_ERROR, 'WebSocket connection failed');
+
+        this.ws.onmessage = (e) => {
+            const msg: SignalMessage = JSON.parse(e.data);
+            this.handleSignal(msg);
+        };
+    }
+
+    private async handleSignal(msg: SignalMessage) {
+        switch (msg.type) {
+            case 'welcome':
+                // Protocol handshake complete - peer_id is managed server-side
+                console.debug('[Voca] Protocol version:', msg.version, 'Peer ID:', msg.peer_id);
+                break;
+            case 'join':
+                await this.createPeer(msg.from, true);
+                break;
+            case 'offer':
+                await this.createPeer(msg.from, false, msg.sdp);
+                break;
+            case 'answer':
+                const peer = this.peers.get(msg.from);
+                if (peer) {
+                    await peer.connection.setRemoteDescription({ type: 'answer', sdp: msg.sdp! });
+                }
+                break;
+            case 'ice':
+                const p = this.peers.get(msg.from);
+                if (p) {
+                    try {
+                        await p.connection.addIceCandidate(JSON.parse(msg.candidate!));
+                    } catch (e) {
+                        console.warn('[Voca] Invalid ICE candidate:', e);
+                    }
+                }
+                break;
+            case 'ping':
+                this.ws?.send(JSON.stringify({ from: '', type: 'pong' }));
+                break;
+            case 'leave':
+                this.removePeer(msg.from);
+                break;
+            case 'error':
+                this.handleError(msg.code ?? 'unknown', msg.message ?? 'Unknown error');
+                break;
+        }
+    }
+
+    private async createPeer(peerId: string, isInitiator: boolean, remoteSdp?: string) {
+        const pc = new RTCPeerConnection({ iceServers: this.iceServers });
+
+        pc.onicecandidate = (e) => {
+            if (e.candidate) this.send({ type: 'ice', to: peerId, candidate: JSON.stringify(e.candidate) });
+        };
+
+        pc.ontrack = (e) => {
+            // Emit track event so UI can handle the audio element/stream
+            this.events.emit('track', peerId, e.track, e.streams[0]);
+            this.setupRemoteAudio(peerId, e.streams[0]);
+            const peer = this.peers.get(peerId);
+            if (peer) peer.stream = e.streams[0];
+        };
+
+        // Add local tracks
+        this.localStream?.getTracks().forEach((track) => pc.addTrack(track, this.localStream!));
+
+        this.peers.set(peerId, { id: peerId, connection: pc, audioLevel: 0 });
+        this.events.emit('peer-joined', peerId);
+
+        if (isInitiator) {
+            const offer = await pc.createOffer();
+            await pc.setLocalDescription(offer);
+            this.send({ type: 'offer', to: peerId, sdp: offer.sdp });
+        } else if (remoteSdp) {
+            await pc.setRemoteDescription({ type: 'offer', sdp: remoteSdp });
+            const answer = await pc.createAnswer();
+            await pc.setLocalDescription(answer);
+            this.send({ type: 'answer', to: peerId, sdp: answer.sdp });
+        }
+    }
+
+    private removePeer(peerId: string) {
+        const peer = this.peers.get(peerId);
+        peer?.connection.close();
+        this.peers.delete(peerId);
+
+        // Clean up audio analysis nodes
+        const audio = this.peerAnalysers.get(peerId);
+        if (audio) {
+            audio.source.disconnect();
+            audio.analyser.disconnect();
+            this.peerAnalysers.delete(peerId);
+        }
+
+        this.events.emit('peer-left', peerId);
+    }
+
+    private setupRemoteAudio(peerId: string, stream: MediaStream) {
+        if (!this.audioContext) {
+            const AudioContextClass = window.AudioContext || (window as any).webkitAudioContext;
+            this.audioContext = new AudioContextClass();
+        }
+
+        const source = this.audioContext.createMediaStreamSource(stream);
+        const analyser = this.audioContext.createAnalyser();
+        analyser.fftSize = 256;
+        source.connect(analyser);
+
+        // CRITICAL: Connect to speakers so audio is actually played!
+        source.connect(this.audioContext.destination);
+
+        // Store for cleanup when peer leaves
+        this.peerAnalysers.set(peerId, { source, analyser });
+
+        const data = new Uint8Array(analyser.frequencyBinCount);
+        const update = () => {
+            const peer = this.peers.get(peerId);
+            if (!peer) return;
+
+            analyser.getByteFrequencyData(data);
+            const avg = data.reduce((a, b) => a + b, 0) / data.length;
+            const level = Math.min(avg / 128, 1);
+
+            this.events.emit('peer-audio-level', peerId, level);
+
+            // Store in peer object as well for convenience
+            peer.audioLevel = level;
+
+            requestAnimationFrame(update);
+        };
+        update();
+    }
+
+    private send(msg: Partial<SignalMessage>) {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify({ from: '', ...msg }));
+        }
+    }
+
+    private handleError(code: VocaErrorCode | string, message: string) {
+        this.status = code === VocaErrorCode.ROOM_FULL || code === 'room_full' ? 'full' : 'error';
+        this.events.emit('status', this.status);
+        this.events.emit('error', { code: code as VocaErrorCode, message });
+    }
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "dist",
+    "declaration": true
+  },
+  "include": [
+    "src"
+  ],
+  "exclude": [
+    "src/**/*.test.ts",
+    "src/**/__tests__/**/*"
+  ]
+}

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    test: {
+        environment: 'node',
+        globals: true,
+    },
+});