@xtr-dev/rondevu-client 0.3.1 → 0.3.2

package/README.md

@@ -1,8 +1,8 @@
 # Rondevu
 
-🎯 **Simple WebRTC peer signaling and discovery**
+🎯 **Simple WebRTC peer signaling**
 
-Meet peers by topic, by peer ID, or by connection ID.
+Connect peers directly by ID with automatic WebRTC negotiation.
 
 **Related repositories:**
 - [rondevu-server](https://github.com/xtr-dev/rondevu-server) - HTTP signaling server
@@ -30,68 +30,57 @@ npm install @xtr-dev/rondevu-client
 import { Rondevu } from '@xtr-dev/rondevu-client';
 
 const rdv = new Rondevu({
-  baseUrl: 'https://server.com',
+  baseUrl: 'https://api.ronde.vu',
   rtcConfig: {
     iceServers: [
-      // your ICE servers here
       { urls: 'stun:stun.l.google.com:19302' },
-      { urls: 'stun:stun1.l.google.com:19302' },
-      {
-        urls: 'turn:relay1.example.com:3480',
-        username: 'example',
-        credential: 'example'
-      }
+      { urls: 'stun:stun1.l.google.com:19302' }
     ]
   }
 });
 
-// Connect by topic
-const conn = await rdv.join('room');
+// Create a connection with custom ID
+const connection = await rdv.create('my-room-123');
 
-// Or connect by ID
-const conn = await rdv.connect('meeting-123');
+// Or connect to an existing connection
+const connection = await rdv.connect('my-room-123');
 
-// Use the connection
-conn.on('connect', () => {
-  const channel = conn.dataChannel('chat');
+// Use data channels
+connection.on('connect', () => {
+  const channel = connection.dataChannel('chat');
   channel.send('Hello!');
 });
+
+connection.on('datachannel', (channel) => {
+  if (channel.label === 'chat') {
+    channel.onmessage = (event) => {
+      console.log('Received:', event.data);
+    };
+  }
+});
 ```
 
 #### Node.js
 
-In Node.js, you need to provide a WebRTC polyfill since WebRTC APIs are not natively available:
-
-```bash
-npm install @roamhq/wrtc
-# or
-npm install wrtc
-```
-
 ```typescript
 import { Rondevu } from '@xtr-dev/rondevu-client';
 import wrtc from '@roamhq/wrtc';
 import fetch from 'node-fetch';
 
 const rdv = new Rondevu({
-  baseUrl: 'https://server.com',
+  baseUrl: 'https://api.ronde.vu',
   fetch: fetch as any,
   wrtc: {
     RTCPeerConnection: wrtc.RTCPeerConnection,
     RTCSessionDescription: wrtc.RTCSessionDescription,
     RTCIceCandidate: wrtc.RTCIceCandidate,
-  },
-  rtcConfig: {
-    iceServers: [
-      { urls: 'stun:stun.l.google.com:19302' }
-    ]
   }
 });
 
-// Rest is the same as browser usage
-const conn = await rdv.join('room');
-conn.on('connect', () => {
-  const channel = conn.dataChannel('chat');
+const connection = await rdv.create('my-room-123');
+
+connection.on('connect', () => {
+  const channel = connection.dataChannel('chat');
   channel.send('Hello from Node.js!');
 });
 ```
@@ -99,23 +88,24 @@ conn.on('connect', () => {
 ### API
 
 **Main Methods:**
-- `rdv.join(topic)` - Auto-connect to first peer in topic
-- `rdv.join(topic, {filter})` - Connect to specific peer by ID
-- `rdv.create(id, topic)` - Create connection for others to join
-- `rdv.connect(id)` - Join connection by ID
+- `rdv.create(id)` - Create connection with custom ID
+- `rdv.connect(id)` - Connect to existing connection by ID
 
 **Connection Events:**
 - `connect` - Connection established
 - `disconnect` - Connection closed
-- `datachannel` - Remote peer created data channel
-- `stream` - Remote media stream received
-- `error` - Error occurred
+- `error` - Connection error
+- `datachannel` - New data channel received
+- `stream` - Media stream received
 
 **Connection Methods:**
-- `conn.dataChannel(label)` - Get or create data channel
-- `conn.addStream(stream)` - Add media stream
-- `conn.getPeerConnection()` - Get underlying RTCPeerConnection
-- `conn.close()` - Close connection
+- `connection.dataChannel(label)` - Get or create data channel
+- `connection.addStream(stream)` - Add media stream
+- `connection.close()` - Close connection
+
+### Version Compatibility
+
+The client automatically checks server compatibility via the `/health` endpoint. If the server version is incompatible, an error will be thrown during initialization.
 
 ### License
 

package/dist/client.d.ts

@@ -1,6 +1,6 @@
-import { RondevuClientOptions, ListTopicsResponse, ListSessionsResponse, CreateOfferRequest, CreateOfferResponse, AnswerRequest, AnswerResponse, PollOffererResponse, PollAnswererResponse, VersionResponse, HealthResponse, Side } from './types.js';
+import { RondevuClientOptions, CreateOfferRequest, CreateOfferResponse, AnswerRequest, AnswerResponse, PollOffererResponse, PollAnswererResponse, VersionResponse, HealthResponse, Side } from './types.js';
 /**
- * HTTP API client for Rondevu peer signaling and discovery server
+ * HTTP API client for Rondevu peer signaling server
  */
 export declare class RondevuAPI {
     private readonly baseUrl;
@@ -17,7 +17,7 @@ export declare class RondevuAPI {
     /**
      * Gets server version information
      *
-     * @returns Server version (git commit hash)
+     * @returns Server version
      *
      * @example
      * ```typescript
@@ -28,56 +28,27 @@ export declare class RondevuAPI {
      */
     getVersion(): Promise<VersionResponse>;
     /**
-     * Lists all topics with peer counts
+     * Creates a new offer
      *
-     * @param page - Page number (starting from 1)
-     * @param limit - Results per page (max 1000)
-     * @returns List of topics with pagination info
+     * @param request - Offer details including peer ID, signaling data, and optional custom code
+     * @returns Unique offer code (UUID or custom code)
      *
      * @example
      * ```typescript
      * const api = new RondevuAPI({ baseUrl: 'https://example.com' });
-     * const { topics, pagination } = await api.listTopics();
-     * console.log(`Found ${topics.length} topics`);
-     * ```
-     */
-    listTopics(page?: number, limit?: number): Promise<ListTopicsResponse>;
-    /**
-     * Discovers available peers for a given topic
-     *
-     * @param topic - Topic identifier
-     * @returns List of available sessions
-     *
-     * @example
-     * ```typescript
-     * const api = new RondevuAPI({ baseUrl: 'https://example.com' });
-     * const { sessions } = await api.listSessions('my-room');
-     * const otherPeers = sessions.filter(s => s.peerId !== myPeerId);
-     * ```
-     */
-    listSessions(topic: string): Promise<ListSessionsResponse>;
-    /**
-     * Announces peer availability and creates a new session
-     *
-     * @param topic - Topic identifier for grouping peers (max 1024 characters)
-     * @param request - Offer details including peer ID and signaling data
-     * @returns Unique session code (UUID)
-     *
-     * @example
-     * ```typescript
-     * const api = new RondevuAPI({ baseUrl: 'https://example.com' });
-     * const { code } = await api.createOffer('my-room', {
+     * const { code } = await api.createOffer({
      *   peerId: 'peer-123',
-     *   offer: signalingData
+     *   offer: signalingData,
+     *   code: 'my-custom-code' // optional
      * });
-     * console.log('Session code:', code);
+     * console.log('Offer code:', code);
      * ```
      */
-    createOffer(topic: string, request: CreateOfferRequest): Promise<CreateOfferResponse>;
+    createOffer(request: CreateOfferRequest): Promise<CreateOfferResponse>;
     /**
-     * Sends an answer or candidate to an existing session
+     * Sends an answer or candidate to an existing offer
      *
-     * @param request - Answer details including session code and signaling data
+     * @param request - Answer details including offer code and signaling data
      * @returns Success confirmation
      *
      * @example
@@ -86,14 +57,14 @@ export declare class RondevuAPI {
      *
      * // Send answer
      * await api.sendAnswer({
-     *   code: sessionCode,
+     *   code: offerCode,
      *   answer: answerData,
      *   side: 'answerer'
      * });
      *
      * // Send candidate
      * await api.sendAnswer({
-     *   code: sessionCode,
+     *   code: offerCode,
      *   candidate: candidateData,
      *   side: 'offerer'
      * });
@@ -101,38 +72,39 @@ export declare class RondevuAPI {
      */
     sendAnswer(request: AnswerRequest): Promise<AnswerResponse>;
     /**
-     * Polls for session data from the other peer
+     * Polls for offer data from the other peer
      *
-     * @param code - Session UUID
+     * @param code - Offer code
      * @param side - Which side is polling ('offerer' or 'answerer')
-     * @returns Session data including offers, answers, and candidates
+     * @returns Offer data including offers, answers, and candidates
      *
      * @example
      * ```typescript
      * const api = new RondevuAPI({ baseUrl: 'https://example.com' });
      *
      * // Offerer polls for answer
-     * const offererData = await api.poll(sessionCode, 'offerer');
+     * const offererData = await api.poll(offerCode, 'offerer');
      * if (offererData.answer) {
      *   console.log('Received answer:', offererData.answer);
      * }
      *
      * // Answerer polls for offer
-     * const answererData = await api.poll(sessionCode, 'answerer');
+     * const answererData = await api.poll(offerCode, 'answerer');
      * console.log('Received offer:', answererData.offer);
      * ```
      */
     poll(code: string, side: Side): Promise<PollOffererResponse | PollAnswererResponse>;
     /**
-     * Checks server health
+     * Checks server health and version
      *
-     * @returns Health status and timestamp
+     * @returns Health status, timestamp, and version
      *
      * @example
      * ```typescript
      * const api = new RondevuAPI({ baseUrl: 'https://example.com' });
      * const health = await api.health();
      * console.log('Server status:', health.status);
+     * console.log('Server version:', health.version);
      * ```
      */
     health(): Promise<HealthResponse>;

package/dist/client.js

@@ -1,5 +1,5 @@
 /**
- * HTTP API client for Rondevu peer signaling and discovery server
+ * HTTP API client for Rondevu peer signaling server
  */
 export class RondevuAPI {
     /**
@@ -35,7 +35,7 @@ export class RondevuAPI {
     /**
      * Gets server version information
      *
-     * @returns Server version (git commit hash)
+     * @returns Server version
      *
      * @example
      * ```typescript
@@ -50,73 +50,32 @@ export class RondevuAPI {
         });
     }
     /**
-     * Lists all topics with peer counts
+     * Creates a new offer
      *
-     * @param page - Page number (starting from 1)
-     * @param limit - Results per page (max 1000)
-     * @returns List of topics with pagination info
+     * @param request - Offer details including peer ID, signaling data, and optional custom code
+     * @returns Unique offer code (UUID or custom code)
      *
      * @example
      * ```typescript
      * const api = new RondevuAPI({ baseUrl: 'https://example.com' });
-     * const { topics, pagination } = await api.listTopics();
-     * console.log(`Found ${topics.length} topics`);
-     * ```
-     */
-    async listTopics(page = 1, limit = 100) {
-        const params = new URLSearchParams({
-            page: page.toString(),
-            limit: limit.toString(),
-        });
-        return this.request(`/topics?${params}`, {
-            method: 'GET',
-        });
-    }
-    /**
-     * Discovers available peers for a given topic
-     *
-     * @param topic - Topic identifier
-     * @returns List of available sessions
-     *
-     * @example
-     * ```typescript
-     * const api = new RondevuAPI({ baseUrl: 'https://example.com' });
-     * const { sessions } = await api.listSessions('my-room');
-     * const otherPeers = sessions.filter(s => s.peerId !== myPeerId);
-     * ```
-     */
-    async listSessions(topic) {
-        return this.request(`/${encodeURIComponent(topic)}/sessions`, {
-            method: 'GET',
-        });
-    }
-    /**
-     * Announces peer availability and creates a new session
-     *
-     * @param topic - Topic identifier for grouping peers (max 1024 characters)
-     * @param request - Offer details including peer ID and signaling data
-     * @returns Unique session code (UUID)
-     *
-     * @example
-     * ```typescript
-     * const api = new RondevuAPI({ baseUrl: 'https://example.com' });
-     * const { code } = await api.createOffer('my-room', {
+     * const { code } = await api.createOffer({
      *   peerId: 'peer-123',
-     *   offer: signalingData
+     *   offer: signalingData,
+     *   code: 'my-custom-code' // optional
      * });
-     * console.log('Session code:', code);
+     * console.log('Offer code:', code);
      * ```
      */
-    async createOffer(topic, request) {
-        return this.request(`/${encodeURIComponent(topic)}/offer`, {
+    async createOffer(request) {
+        return this.request('/offer', {
             method: 'POST',
             body: JSON.stringify(request),
         });
     }
     /**
-     * Sends an answer or candidate to an existing session
+     * Sends an answer or candidate to an existing offer
      *
-     * @param request - Answer details including session code and signaling data
+     * @param request - Answer details including offer code and signaling data
      * @returns Success confirmation
      *
      * @example
@@ -125,14 +84,14 @@ export class RondevuAPI {
      *
      * // Send answer
      * await api.sendAnswer({
-     *   code: sessionCode,
+     *   code: offerCode,
      *   answer: answerData,
      *   side: 'answerer'
      * });
      *
      * // Send candidate
      * await api.sendAnswer({
-     *   code: sessionCode,
+     *   code: offerCode,
      *   candidate: candidateData,
      *   side: 'offerer'
      * });
@@ -145,24 +104,24 @@ export class RondevuAPI {
         });
     }
     /**
-     * Polls for session data from the other peer
+     * Polls for offer data from the other peer
      *
-     * @param code - Session UUID
+     * @param code - Offer code
      * @param side - Which side is polling ('offerer' or 'answerer')
-     * @returns Session data including offers, answers, and candidates
+     * @returns Offer data including offers, answers, and candidates
      *
      * @example
      * ```typescript
      * const api = new RondevuAPI({ baseUrl: 'https://example.com' });
      *
      * // Offerer polls for answer
-     * const offererData = await api.poll(sessionCode, 'offerer');
+     * const offererData = await api.poll(offerCode, 'offerer');
      * if (offererData.answer) {
      *   console.log('Received answer:', offererData.answer);
      * }
      *
      * // Answerer polls for offer
-     * const answererData = await api.poll(sessionCode, 'answerer');
+     * const answererData = await api.poll(offerCode, 'answerer');
      * console.log('Received offer:', answererData.offer);
      * ```
      */
@@ -174,15 +133,16 @@ export class RondevuAPI {
         });
     }
     /**
-     * Checks server health
+     * Checks server health and version
      *
-     * @returns Health status and timestamp
+     * @returns Health status, timestamp, and version
      *
      * @example
      * ```typescript
      * const api = new RondevuAPI({ baseUrl: 'https://example.com' });
      * const health = await api.health();
      * console.log('Server status:', health.status);
+     * console.log('Server version:', health.version);
      * ```
      */
     async health() {

package/dist/connection.d.ts

@@ -6,7 +6,6 @@ import { RondevuConnectionParams } from './types.js';
  */
 export declare class RondevuConnection extends EventEmitter {
     readonly id: string;
-    readonly topic: string;
     readonly role: 'offerer' | 'answerer';
     readonly remotePeerId: string;
     private pc;

package/dist/connection.js

@@ -8,7 +8,6 @@ export class RondevuConnection extends EventEmitter {
         this.isPolling = false;
         this.isClosed = false;
         this.id = params.id;
-        this.topic = params.topic;
         this.role = params.role;
         this.pc = params.pc;
         this.localPeerId = params.localPeerId;

package/dist/index.d.ts

@@ -5,4 +5,4 @@
 export { Rondevu } from './rondevu.js';
 export { RondevuConnection } from './connection.js';
 export { RondevuAPI } from './client.js';
-export type { RondevuOptions, JoinOptions, ConnectionRole, RondevuConnectionParams, RondevuConnectionEvents, WebRTCPolyfill, Side, Session, TopicInfo, Pagination, ListTopicsResponse, ListSessionsResponse, CreateOfferRequest, CreateOfferResponse, AnswerRequest, AnswerResponse, PollRequest, PollOffererResponse, PollAnswererResponse, PollResponse, VersionResponse, HealthResponse, ErrorResponse, RondevuClientOptions, } from './types.js';
+export type { RondevuOptions, ConnectionRole, RondevuConnectionParams, RondevuConnectionEvents, WebRTCPolyfill, Side, CreateOfferRequest, CreateOfferResponse, AnswerRequest, AnswerResponse, PollRequest, PollOffererResponse, PollAnswererResponse, PollResponse, VersionResponse, HealthResponse, ErrorResponse, RondevuClientOptions, } from './types.js';

package/dist/rondevu.d.ts

@@ -1,6 +1,6 @@
 import { RondevuAPI } from './client.js';
 import { RondevuConnection } from './connection.js';
-import { RondevuOptions, JoinOptions } from './types.js';
+import { RondevuOptions } from './types.js';
 /**
  * Main Rondevu WebRTC client with automatic connection management
  */
@@ -20,6 +20,15 @@ export declare class Rondevu {
      * @param options - Client configuration options
      */
     constructor(options?: RondevuOptions);
+    /**
+     * Check server version compatibility
+     */
+    private checkServerVersion;
+    /**
+     * Check if client and server versions are compatible
+     * For now, just check major version compatibility
+     */
+    private isVersionCompatible;
     /**
      * Generate a unique peer ID
      */
@@ -30,35 +39,22 @@ export declare class Rondevu {
     updatePeerId(newPeerId: string): void;
     /**
      * Create a new connection (offerer role)
-     * @param id - Connection identifier
-     * @param topic - Topic name for grouping connections
+     * @param id - Connection identifier (custom code)
      * @returns Promise that resolves to RondevuConnection
      */
-    create(id: string, topic: string): Promise<RondevuConnection>;
+    create(id: string): Promise<RondevuConnection>;
     /**
-     * Connect to an existing connection by ID (answerer role)
-     * @param id - Connection identifier
+     * Connect to an existing offer by ID (answerer role)
+     * @param id - Offer code
      * @returns Promise that resolves to RondevuConnection
      */
     connect(id: string): Promise<RondevuConnection>;
-    /**
-     * Join a topic and discover available peers (answerer role)
-     * @param topic - Topic name
-     * @param options - Optional join options for filtering and selection
-     * @returns Promise that resolves to RondevuConnection
-     */
-    join(topic: string, options?: JoinOptions): Promise<RondevuConnection>;
-    /**
-     * Select a session based on strategy
-     */
-    private selectSession;
     /**
      * Wait for ICE gathering to complete
      */
     private waitForIceGathering;
     /**
-     * Find a session by connection ID
-     * This requires polling since we don't know which topic it's in
+     * Find an offer by code
      */
-    private findSessionByIdWithClient;
+    private findOfferById;
 }

package/dist/rondevu.js

@@ -29,6 +29,37 @@ export class Rondevu {
                 'In Node.js, provide a WebRTC polyfill via the wrtc option. ' +
                 'Install: npm install @roamhq/wrtc or npm install wrtc');
         }
+        // Check server version compatibility (async, don't block constructor)
+        this.checkServerVersion().catch(() => {
+            // Silently fail version check - connection will work even if version check fails
+        });
+    }
+    /**
+     * Check server version compatibility
+     */
+    async checkServerVersion() {
+        try {
+            const { version: serverVersion } = await this.api.health();
+            const clientVersion = '0.3.2'; // Should match package.json
+            if (!this.isVersionCompatible(clientVersion, serverVersion)) {
+                console.warn(`[Rondevu] Version mismatch: client v${clientVersion}, server v${serverVersion}. ` +
+                    'This may cause compatibility issues.');
+            }
+        }
+        catch (error) {
+            // Version check failed - server might not support /health endpoint
+            console.debug('[Rondevu] Could not check server version');
+        }
+    }
+    /**
+     * Check if client and server versions are compatible
+     * For now, just check major version compatibility
+     */
+    isVersionCompatible(clientVersion, serverVersion) {
+        const clientMajor = parseInt(clientVersion.split('.')[0]);
+        const serverMajor = parseInt(serverVersion.split('.')[0]);
+        // Major versions must match
+        return clientMajor === serverMajor;
     }
     /**
      * Generate a unique peer ID
@@ -44,11 +75,10 @@ export class Rondevu {
     }
     /**
      * Create a new connection (offerer role)
-     * @param id - Connection identifier
-     * @param topic - Topic name for grouping connections
+     * @param id - Connection identifier (custom code)
      * @returns Promise that resolves to RondevuConnection
      */
-    async create(id, topic) {
+    async create(id) {
         // Create peer connection
         const pc = new this.RTCPeerConnection(this.rtcConfig);
         // Create initial data channel for negotiation (required for offer creation)
@@ -58,8 +88,8 @@ export class Rondevu {
         await pc.setLocalDescription(offer);
         // Wait for ICE gathering to complete
         await this.waitForIceGathering(pc);
-        // Create session on server with custom code
-        await this.api.createOffer(topic, {
+        // Create offer on server with custom code
+        await this.api.createOffer({
             peerId: this.peerId,
             offer: pc.localDescription.sdp,
             code: id,
@@ -67,7 +97,6 @@ export class Rondevu {
         // Create connection object
         const connectionParams = {
             id,
-            topic,
             role: 'offerer',
             pc,
             localPeerId: this.peerId,
@@ -82,22 +111,22 @@ export class Rondevu {
         return connection;
     }
     /**
-     * Connect to an existing connection by ID (answerer role)
-     * @param id - Connection identifier
+     * Connect to an existing offer by ID (answerer role)
+     * @param id - Offer code
      * @returns Promise that resolves to RondevuConnection
      */
     async connect(id) {
-        // Poll server to get session by ID
-        const sessionData = await this.findSessionByIdWithClient(id, this.api);
-        if (!sessionData) {
-            throw new Error(`Connection ${id} not found or expired`);
+        // Poll server to get offer by ID
+        const offerData = await this.findOfferById(id);
+        if (!offerData) {
+            throw new Error(`Offer ${id} not found or expired`);
         }
         // Create peer connection
         const pc = new this.RTCPeerConnection(this.rtcConfig);
         // Set remote offer
         await pc.setRemoteDescription({
             type: 'offer',
-            sdp: sessionData.offer,
+            sdp: offerData.offer,
         });
         // Generate answer
         const answer = await pc.createAnswer();
@@ -113,11 +142,10 @@ export class Rondevu {
         // Create connection object
         const connectionParams = {
             id,
-            topic: sessionData.topic || 'unknown',
             role: 'answerer',
             pc,
             localPeerId: this.peerId,
-            remotePeerId: sessionData.peerId,
+            remotePeerId: '', // Will be determined from peerId in offer
             pollingInterval: this.pollingInterval,
             connectionTimeout: this.connectionTimeout,
             wrtc: this.wrtc,
@@ -127,46 +155,6 @@ export class Rondevu {
         connection.startPolling();
         return connection;
     }
-    /**
-     * Join a topic and discover available peers (answerer role)
-     * @param topic - Topic name
-     * @param options - Optional join options for filtering and selection
-     * @returns Promise that resolves to RondevuConnection
-     */
-    async join(topic, options) {
-        // List sessions in topic
-        const { sessions } = await this.api.listSessions(topic);
-        // Filter out self (sessions with our peer ID)
-        let availableSessions = sessions.filter(session => session.peerId !== this.peerId);
-        // Apply custom filter if provided
-        if (options?.filter) {
-            availableSessions = availableSessions.filter(options.filter);
-        }
-        if (availableSessions.length === 0) {
-            throw new Error(`No available peers in topic: ${topic}`);
-        }
-        // Select session based on strategy
-        const selectedSession = this.selectSession(availableSessions, options?.select || 'first');
-        // Connect to selected session
-        return this.connect(selectedSession.code);
-    }
-    /**
-     * Select a session based on strategy
-     */
-    selectSession(sessions, strategy) {
-        switch (strategy) {
-            case 'first':
-                return sessions[0];
-            case 'newest':
-                return sessions.reduce((newest, session) => session.createdAt > newest.createdAt ? session : newest);
-            case 'oldest':
-                return sessions.reduce((oldest, session) => session.createdAt < oldest.createdAt ? session : oldest);
-            case 'random':
-                return sessions[Math.floor(Math.random() * sessions.length)];
-            default:
-                return sessions[0];
-        }
-    }
     /**
      * Wait for ICE gathering to complete
      */
@@ -190,27 +178,22 @@ export class Rondevu {
         });
     }
     /**
-     * Find a session by connection ID
-     * This requires polling since we don't know which topic it's in
+     * Find an offer by code
      */
-    async findSessionByIdWithClient(id, client) {
+    async findOfferById(id) {
         try {
-            // Try to poll for the session directly
-            // The poll endpoint should return the session data
-            const response = await client.poll(id, 'answerer');
+            // Poll for the offer directly
+            const response = await this.api.poll(id, 'answerer');
             const answererResponse = response;
             if (answererResponse.offer) {
                 return {
-                    code: id,
-                    peerId: '', // Will be populated from session data
                     offer: answererResponse.offer,
-                    topic: undefined,
                 };
             }
             return null;
         }
         catch (err) {
-            throw new Error(`Failed to find session ${id}: ${err.message}`);
+            throw new Error(`Failed to find offer ${id}: ${err.message}`);
         }
     }
 }

package/dist/types.d.ts

@@ -3,59 +3,7 @@
  */
 export type Side = 'offerer' | 'answerer';
 /**
- * Session information returned from discovery endpoints
- */
-export interface Session {
-    /** Unique session identifier (UUID) */
-    code: string;
-    /** Peer identifier/metadata */
-    peerId: string;
-    /** Signaling data for peer connection */
-    offer: string;
-    /** Additional signaling data from offerer */
-    offerCandidates: string[];
-    /** Unix timestamp when session was created */
-    createdAt: number;
-    /** Unix timestamp when session expires */
-    expiresAt: number;
-}
-/**
- * Topic information with peer count
- */
-export interface TopicInfo {
-    /** Topic identifier */
-    topic: string;
-    /** Number of available peers in this topic */
-    count: number;
-}
-/**
- * Pagination information
- */
-export interface Pagination {
-    /** Current page number */
-    page: number;
-    /** Results per page */
-    limit: number;
-    /** Total number of results */
-    total: number;
-    /** Whether there are more results available */
-    hasMore: boolean;
-}
-/**
- * Response from GET / - list all topics
- */
-export interface ListTopicsResponse {
-    topics: TopicInfo[];
-    pagination: Pagination;
-}
-/**
- * Response from GET /:topic/sessions - list sessions in a topic
- */
-export interface ListSessionsResponse {
-    sessions: Session[];
-}
-/**
- * Request body for POST /:topic/offer
+ * Request body for POST /offer
  */
 export interface CreateOfferRequest {
     /** Peer identifier/metadata (max 1024 characters) */
@@ -66,7 +14,7 @@ export interface CreateOfferRequest {
     code?: string;
 }
 /**
- * Response from POST /:topic/offer
+ * Response from POST /offer
  */
 export interface CreateOfferResponse {
     /** Unique session identifier (UUID) */
@@ -135,6 +83,7 @@ export interface VersionResponse {
 export interface HealthResponse {
     status: 'ok';
     timestamp: number;
+    version: string;
 }
 /**
  * Error response structure
@@ -178,18 +127,6 @@ export interface RondevuOptions {
     /** WebRTC polyfill for Node.js (e.g., wrtc or @roamhq/wrtc) */
     wrtc?: WebRTCPolyfill;
 }
-/**
- * Options for joining a topic
- */
-export interface JoinOptions {
-    /** Filter function to select specific sessions */
-    filter?: (session: {
-        code: string;
-        peerId: string;
-    }) => boolean;
-    /** Selection strategy for choosing a session */
-    select?: 'first' | 'newest' | 'oldest' | 'random';
-}
 /**
  * Connection role - whether this peer is creating or answering
  */
@@ -199,7 +136,7 @@ export type ConnectionRole = 'offerer' | 'answerer';
  */
 export interface RondevuConnectionParams {
     id: string;
-    topic: string;
+    topic?: string;
     role: ConnectionRole;
     pc: RTCPeerConnection;
     localPeerId: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xtr-dev/rondevu-client",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "TypeScript client for Rondevu peer signaling and discovery server",
   "type": "module",
   "main": "dist/index.js",