@xtr-dev/rondevu-client 0.10.2 → 0.12.0

package/README.md

@@ -17,10 +17,12 @@ TypeScript/JavaScript client for Rondevu, providing easy-to-use WebRTC connectio
 
 - **High-Level Wrappers**: ServiceHost and ServiceClient eliminate WebRTC boilerplate
 - **Username-Based Discovery**: Connect to peers by username, not complex offer/answer exchange
+- **Semver-Compatible Matching**: Requesting chat@1.0.0 matches any compatible 1.x.x version
+- **Privacy-First Design**: Services are hidden by default - no enumeration possible
 - **Automatic Reconnection**: Built-in retry logic with exponential backoff
 - **Message Queuing**: Messages sent while disconnected are queued and flushed on reconnect
 - **Cryptographic Username Claiming**: Secure ownership with Ed25519 signatures
-- **Service Publishing**: Package-style naming (chat.app@1.0.0)
+- **Service Publishing**: Package-style naming (chat.app@1.0.0) with multiple simultaneous offers
 - **TypeScript**: Full type safety and autocomplete
 - **Configurable Polling**: Exponential backoff with jitter to reduce server load
 
@@ -373,7 +375,7 @@ await conn.queueMessage('This will be sent when connected', {
 
 ## Migration from v0.9.x
 
-v0.11.0 introduces high-level wrappers and RESTful API changes:
+v0.11.0+ introduces high-level wrappers, RESTful API changes, and semver-compatible discovery:
 
 **API Changes:**
 - Server endpoints restructured (`/usernames/*` → `/users/*`)
@@ -381,6 +383,10 @@ v0.11.0 introduces high-level wrappers and RESTful API changes:
 - Message queue fully implemented
 - Configurable polling with exponential backoff
 - Removed deprecated `cleanup()` methods (use `dispose()`)
+- **v0.11.0+**: Services use `offers` array instead of single `sdp`
+- **v0.11.0+**: Semver-compatible service discovery (chat@1.0.0 matches 1.x.x)
+- **v0.11.0+**: All services are hidden - no listing endpoint
+- **v0.11.0+**: Services support multiple simultaneous offers for connection pooling
 
 **Migration Guide:**
 

package/dist/api.d.ts

@@ -25,20 +25,29 @@ export interface Offer {
     expiresAt: number;
     answererPeerId?: string;
 }
+export interface OfferRequest {
+    sdp: string;
+}
 export interface ServiceRequest {
     username: string;
     serviceFqn: string;
-    sdp: string;
+    offers: OfferRequest[];
     ttl?: number;
     isPublic?: boolean;
     metadata?: Record<string, any>;
     signature: string;
     message: string;
 }
+export interface ServiceOffer {
+    offerId: string;
+    sdp: string;
+    createdAt: number;
+    expiresAt: number;
+}
 export interface Service {
     serviceId: string;
     uuid: string;
-    offerId: string;
+    offers: ServiceOffer[];
     username: string;
     serviceFqn: string;
     isPublic: boolean;
@@ -90,27 +99,35 @@ export declare class RondevuAPI {
      */
     getOffer(offerId: string): Promise<Offer>;
     /**
-     * Answer an offer
+     * Answer a service
      */
-    answerOffer(offerId: string, sdp: string, secret?: string): Promise<void>;
+    answerService(serviceUuid: string, sdp: string): Promise<{
+        offerId: string;
+    }>;
     /**
-     * Get answer for an offer (offerer polls this)
+     * Get answer for a service (offerer polls this)
      */
-    getAnswer(offerId: string): Promise<{
+    getServiceAnswer(serviceUuid: string): Promise<{
         sdp: string;
+        offerId: string;
     } | null>;
     /**
      * Search offers by topic
      */
     searchOffers(topic: string): Promise<Offer[]>;
     /**
-     * Add ICE candidates to an offer
+     * Add ICE candidates to a service
      */
-    addIceCandidates(offerId: string, candidates: RTCIceCandidateInit[]): Promise<void>;
+    addServiceIceCandidates(serviceUuid: string, candidates: RTCIceCandidateInit[], offerId?: string): Promise<{
+        offerId: string;
+    }>;
     /**
-     * Get ICE candidates for an offer (with polling support)
+     * Get ICE candidates for a service (with polling support)
      */
-    getIceCandidates(offerId: string, since?: number): Promise<IceCandidate[]>;
+    getServiceIceCandidates(serviceUuid: string, since?: number, offerId?: string): Promise<{
+        candidates: IceCandidate[];
+        offerId: string;
+    }>;
     /**
      * Publish a service
      */

package/dist/api.js

@@ -131,27 +131,28 @@ export class RondevuAPI {
         return await response.json();
     }
     /**
-     * Answer an offer
+     * Answer a service
      */
-    async answerOffer(offerId, sdp, secret) {
-        const response = await fetch(`${this.baseUrl}/offers/${offerId}/answer`, {
+    async answerService(serviceUuid, sdp) {
+        const response = await fetch(`${this.baseUrl}/services/${serviceUuid}/answer`, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
                 ...this.getAuthHeader(),
             },
-            body: JSON.stringify({ sdp, secret }),
+            body: JSON.stringify({ sdp }),
         });
         if (!response.ok) {
             const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(`Failed to answer offer: ${error.error || response.statusText}`);
+            throw new Error(`Failed to answer service: ${error.error || response.statusText}`);
         }
+        return await response.json();
     }
     /**
-     * Get answer for an offer (offerer polls this)
+     * Get answer for a service (offerer polls this)
      */
-    async getAnswer(offerId) {
-        const response = await fetch(`${this.baseUrl}/offers/${offerId}/answer`, {
+    async getServiceAnswer(serviceUuid) {
+        const response = await fetch(`${this.baseUrl}/services/${serviceUuid}/answer`, {
             headers: this.getAuthHeader(),
         });
         if (!response.ok) {
@@ -163,7 +164,7 @@ export class RondevuAPI {
             throw new Error(`Failed to get answer: ${error.error || response.statusText}`);
         }
         const data = await response.json();
-        return { sdp: data.sdp };
+        return { sdp: data.sdp, offerId: data.offerId };
     }
     /**
      * Search offers by topic
@@ -182,33 +183,42 @@ export class RondevuAPI {
     // ICE Candidates
     // ============================================
     /**
-     * Add ICE candidates to an offer
+     * Add ICE candidates to a service
      */
-    async addIceCandidates(offerId, candidates) {
-        const response = await fetch(`${this.baseUrl}/offers/${offerId}/ice-candidates`, {
+    async addServiceIceCandidates(serviceUuid, candidates, offerId) {
+        const response = await fetch(`${this.baseUrl}/services/${serviceUuid}/ice-candidates`, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
                 ...this.getAuthHeader(),
             },
-            body: JSON.stringify({ candidates }),
+            body: JSON.stringify({ candidates, offerId }),
         });
         if (!response.ok) {
             const error = await response.json().catch(() => ({ error: 'Unknown error' }));
             throw new Error(`Failed to add ICE candidates: ${error.error || response.statusText}`);
         }
+        return await response.json();
     }
     /**
-     * Get ICE candidates for an offer (with polling support)
+     * Get ICE candidates for a service (with polling support)
      */
-    async getIceCandidates(offerId, since = 0) {
-        const response = await fetch(`${this.baseUrl}/offers/${offerId}/ice-candidates?since=${since}`, { headers: this.getAuthHeader() });
+    async getServiceIceCandidates(serviceUuid, since = 0, offerId) {
+        const url = new URL(`${this.baseUrl}/services/${serviceUuid}/ice-candidates`);
+        url.searchParams.set('since', since.toString());
+        if (offerId) {
+            url.searchParams.set('offerId', offerId);
+        }
+        const response = await fetch(url.toString(), { headers: this.getAuthHeader() });
         if (!response.ok) {
             const error = await response.json().catch(() => ({ error: 'Unknown error' }));
             throw new Error(`Failed to get ICE candidates: ${error.error || response.statusText}`);
         }
         const data = await response.json();
-        return data.candidates || [];
+        return {
+            candidates: data.candidates || [],
+            offerId: data.offerId
+        };
     }
     // ============================================
     // Services

package/dist/rondevu-service.d.ts

@@ -7,7 +7,9 @@ export interface RondevuServiceOptions {
 }
 export interface PublishServiceOptions {
     serviceFqn: string;
-    sdp: string;
+    offers: Array<{
+        sdp: string;
+    }>;
     ttl?: number;
     isPublic?: boolean;
     metadata?: Record<string, any>;
@@ -36,7 +38,7 @@ export interface PublishServiceOptions {
  * // Publish a service
  * const publishedService = await service.publishService({
  *   serviceFqn: 'chat.app@1.0.0',
- *   sdp: offerSdp,
+ *   offers: [{ sdp: offerSdp }],
  *   ttl: 300000,
  *   isPublic: true,
  * })

package/dist/rondevu-service.js

@@ -23,7 +23,7 @@ import { RondevuAPI } from './api.js';
  * // Publish a service
  * const publishedService = await service.publishService({
  *   serviceFqn: 'chat.app@1.0.0',
- *   sdp: offerSdp,
+ *   offers: [{ sdp: offerSdp }],
  *   ttl: 300000,
  *   isPublic: true,
  * })
@@ -86,7 +86,7 @@ export class RondevuService {
         if (!this.usernameClaimed) {
             throw new Error('Username not claimed. Call claimUsername() first or the server will reject the service.');
         }
-        const { serviceFqn, sdp, ttl, isPublic, metadata } = options;
+        const { serviceFqn, offers, ttl, isPublic, metadata } = options;
         // Generate signature for service publication
         const message = `publish:${this.username}:${serviceFqn}:${Date.now()}`;
         const signature = await RondevuAPI.signMessage(message, this.keypair.privateKey);
@@ -94,7 +94,7 @@ export class RondevuService {
         const serviceRequest = {
             username: this.username,
             serviceFqn,
-            sdp,
+            offers,
             signature,
             message,
             ttl,

package/dist/rondevu-signaler.js

@@ -62,11 +62,15 @@ export class RondevuSignaler {
         // Publish service with the offer SDP
         const publishedService = await this.rondevu.publishService({
             serviceFqn: this.service,
-            sdp: offer.sdp,
+            offers: [{ sdp: offer.sdp }],
             ttl: 300000, // 5 minutes
             isPublic: true,
         });
-        this.offerId = publishedService.offerId;
+        // Get the first offer from the published service
+        if (!publishedService.offers || publishedService.offers.length === 0) {
+            throw new Error('No offers returned from service publication');
+        }
+        this.offerId = publishedService.offers[0].offerId;
         this.serviceUuid = publishedService.uuid;
         // Start polling for answer
         this.startAnswerPolling();
@@ -81,11 +85,12 @@ export class RondevuSignaler {
         if (!answer.sdp) {
             throw new Error('Answer SDP is required');
         }
-        if (!this.offerId) {
-            throw new Error('No offer ID available. Must receive offer first.');
+        if (!this.serviceUuid) {
+            throw new Error('No service UUID available. Must receive offer first.');
         }
-        // Send answer to the offer
-        await this.rondevu.getAPI().answerOffer(this.offerId, answer.sdp);
+        // Send answer to the service
+        const result = await this.rondevu.getAPI().answerService(this.serviceUuid, answer.sdp);
+        this.offerId = result.offerId;
         // Start polling for ICE candidates
         this.startIcePolling();
     }
@@ -125,8 +130,8 @@ export class RondevuSignaler {
      * Send an ICE candidate to the remote peer
      */
     async addIceCandidate(candidate) {
-        if (!this.offerId) {
-            console.warn('Cannot send ICE candidate: no offer ID');
+        if (!this.serviceUuid) {
+            console.warn('Cannot send ICE candidate: no service UUID');
             return;
         }
         const candidateData = candidate.toJSON();
@@ -135,7 +140,11 @@ export class RondevuSignaler {
             return;
         }
         try {
-            await this.rondevu.getAPI().addIceCandidates(this.offerId, [candidateData]);
+            const result = await this.rondevu.getAPI().addServiceIceCandidates(this.serviceUuid, [candidateData], this.offerId || undefined);
+            // Store offerId if we didn't have it yet
+            if (!this.offerId) {
+                this.offerId = result.offerId;
+            }
         }
         catch (err) {
             console.error('Failed to send ICE candidate:', err);
@@ -173,12 +182,19 @@ export class RondevuSignaler {
             }
             // Get the first available service (already has full details from searchServices)
             const service = services[0];
-            this.offerId = service.offerId;
+            // Get the first available offer from the service
+            if (!service.offers || service.offers.length === 0) {
+                console.warn(`No offers available for service ${this.host}/${this.service}`);
+                this.isPolling = false;
+                return;
+            }
+            const firstOffer = service.offers[0];
+            this.offerId = firstOffer.offerId;
             this.serviceUuid = service.uuid;
             // Notify offer listeners
             const offer = {
                 type: 'offer',
-                sdp: service.sdp,
+                sdp: firstOffer.sdp,
             };
             this.offerListeners.forEach(listener => {
                 try {
@@ -198,19 +214,23 @@ export class RondevuSignaler {
      * Start polling for answer (offerer side) with exponential backoff
      */
     startAnswerPolling() {
-        if (this.answerPollingTimeout || !this.offerId) {
+        if (this.answerPollingTimeout || !this.serviceUuid) {
             return;
         }
         let interval = this.pollingConfig.initialInterval;
         let retries = 0;
         const poll = async () => {
-            if (!this.offerId) {
+            if (!this.serviceUuid) {
                 this.stopAnswerPolling();
                 return;
             }
             try {
-                const answer = await this.rondevu.getAPI().getAnswer(this.offerId);
+                const answer = await this.rondevu.getAPI().getServiceAnswer(this.serviceUuid);
                 if (answer && answer.sdp) {
+                    // Store offerId if we didn't have it yet
+                    if (!this.offerId) {
+                        this.offerId = answer.offerId;
+                    }
                     // Got answer - notify listeners and stop polling
                     const answerDesc = {
                         type: 'answer',
@@ -269,21 +289,25 @@ export class RondevuSignaler {
      * Start polling for ICE candidates with adaptive backoff
      */
     startIcePolling() {
-        if (this.icePollingTimeout || !this.offerId) {
+        if (this.icePollingTimeout || !this.serviceUuid) {
             return;
         }
         let interval = this.pollingConfig.initialInterval;
         const poll = async () => {
-            if (!this.offerId) {
+            if (!this.serviceUuid) {
                 this.stopIcePolling();
                 return;
             }
             try {
-                const candidates = await this.rondevu
+                const result = await this.rondevu
                     .getAPI()
-                    .getIceCandidates(this.offerId, this.lastIceTimestamp);
+                    .getServiceIceCandidates(this.serviceUuid, this.lastIceTimestamp, this.offerId || undefined);
+                // Store offerId if we didn't have it yet
+                if (!this.offerId) {
+                    this.offerId = result.offerId;
+                }
                 let foundCandidates = false;
-                for (const item of candidates) {
+                for (const item of result.candidates) {
                     if (item.candidate && item.candidate.candidate && item.candidate.candidate !== '') {
                         foundCandidates = true;
                         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xtr-dev/rondevu-client",
-  "version": "0.10.2",
+  "version": "0.12.0",
   "description": "TypeScript client for Rondevu with durable WebRTC connections, automatic reconnection, and message queuing",
   "type": "module",
   "main": "dist/index.js",