@xtr-dev/rondevu-client 0.20.1 → 0.21.3

package/dist/core/rondevu.js

@@ -1,129 +1,44 @@
 import { RondevuAPI } from '../api/client.js';
+import { BrowserWebRTCAdapter } from '../webrtc/browser.js';
 import { EventEmitter } from 'eventemitter3';
-import { AnswererConnection } from '../connections/answerer.js';
 import { OfferPool } from './offer-pool.js';
-// ICE server presets
-export const ICE_SERVER_PRESETS = {
-    'ipv4-turn': [
-        { urls: 'stun:57.129.61.67:3478' },
-        {
-            urls: [
-                'turn:57.129.61.67:3478?transport=tcp',
-                'turn:57.129.61.67:3478?transport=udp',
-            ],
-            username: 'webrtcuser',
-            credential: 'supersecretpassword'
-        }
-    ],
-    'hostname-turns': [
-        { urls: 'stun:turn.share.fish:3478' },
-        {
-            urls: [
-                'turns:turn.share.fish:5349?transport=tcp',
-                'turns:turn.share.fish:5349?transport=udp',
-                'turn:turn.share.fish:3478?transport=tcp',
-                'turn:turn.share.fish:3478?transport=udp',
-            ],
-            username: 'webrtcuser',
-            credential: 'supersecretpassword'
-        }
-    ],
-    'google-stun': [
-        { urls: 'stun:stun.l.google.com:19302' },
-        { urls: 'stun:stun1.l.google.com:19302' }
-    ],
-    'relay-only': [
-        { urls: 'stun:57.129.61.67:3478' },
-        {
-            urls: [
-                'turn:57.129.61.67:3478?transport=tcp',
-                'turn:57.129.61.67:3478?transport=udp',
-            ],
-            username: 'webrtcuser',
-            credential: 'supersecretpassword',
-            // @ts-expect-error - iceTransportPolicy is valid but not in RTCIceServer type
-            iceTransportPolicy: 'relay'
-        }
-    ]
-};
-/**
- * Base error class for Rondevu errors
- */
-export class RondevuError extends Error {
-    constructor(message, context) {
-        super(message);
-        this.context = context;
-        this.name = 'RondevuError';
-        Object.setPrototypeOf(this, RondevuError.prototype);
-    }
-}
-/**
- * Network-related errors (API calls, connectivity)
- */
-export class NetworkError extends RondevuError {
-    constructor(message, context) {
-        super(message, context);
-        this.name = 'NetworkError';
-        Object.setPrototypeOf(this, NetworkError.prototype);
-    }
-}
-/**
- * Validation errors (invalid input, malformed data)
- */
-export class ValidationError extends RondevuError {
-    constructor(message, context) {
-        super(message, context);
-        this.name = 'ValidationError';
-        Object.setPrototypeOf(this, ValidationError.prototype);
-    }
-}
-/**
- * WebRTC connection errors (peer connection failures, ICE issues)
- */
-export class ConnectionError extends RondevuError {
-    constructor(message, context) {
-        super(message, context);
-        this.name = 'ConnectionError';
-        Object.setPrototypeOf(this, ConnectionError.prototype);
-    }
-}
+import { Peer } from './peer.js';
+import { getIceConfiguration } from './ice-config.js';
+import { PollingManager } from './polling-manager.js';
+// Re-export ICE config for backward compatibility
+export { ICE_SERVER_PRESETS } from './ice-config.js';
 /**
  * Rondevu - Complete WebRTC signaling client with durable connections
  *
- * v1.0.0 introduces breaking changes:
- * - connectToService() now returns AnswererConnection instead of ConnectionContext
- * - Automatic reconnection and message buffering built-in
- * - Connection objects expose .send() method instead of raw DataChannel
- * - Rich event system for connection lifecycle (connected, disconnected, reconnecting, etc.)
+ * Uses a tags-based discovery system where offers have 1+ tags for matching.
  *
  * @example
  * ```typescript
  * // Create and initialize Rondevu instance with preset ICE servers
  * const rondevu = await Rondevu.connect({
  *   apiUrl: 'https://signal.example.com',
- *   username: 'alice',
  *   iceServers: 'ipv4-turn'  // Use preset: 'ipv4-turn', 'hostname-turns', 'google-stun', or 'relay-only'
  * })
  *
- * // Publish a service with automatic offer management
- * await rondevu.publishService({
- *   service: 'chat:2.0.0',
+ * // Create offers with tags for discovery
+ * await rondevu.offer({
+ *   tags: ['chat', 'video'],
  *   maxOffers: 5  // Maintain up to 5 concurrent offers
  * })
  *
  * // Start accepting connections (auto-fills offers and polls)
  * await rondevu.startFilling()
  *
- * // Listen for connections (v1.0.0 API)
+ * // Listen for connections
  * rondevu.on('connection:opened', (offerId, connection) => {
  *   connection.on('connected', () => console.log('Connected!'))
  *   connection.on('message', (data) => console.log('Received:', data))
  *   connection.send('Hello!')
  * })
  *
- * // Connect to a service (v1.0.0 - returns AnswererConnection)
- * const connection = await rondevu.connectToService({
- *   serviceFqn: 'chat:2.0.0@bob'
+ * // Connect by discovering offers with matching tags
+ * const connection = await rondevu.connect({
+ *   tags: ['chat']
  * })
  *
  * connection.on('connected', () => {
@@ -141,27 +56,35 @@ export class ConnectionError extends RondevuError {
  * ```
  */
 export class Rondevu extends EventEmitter {
-    constructor(apiUrl, username, keypair, api, iceServers, cryptoAdapter, batchingOptions, debugEnabled = false, rtcPeerConnection, rtcIceCandidate) {
+    constructor(apiUrl, credential, api, iceServers, iceTransportPolicy, webrtcAdapter, cryptoAdapter, debugEnabled = false) {
         super();
-        this.usernameClaimed = false;
-        // Service management
-        this.currentService = null;
+        // Publishing state
+        this.currentTags = null;
         this.offerPool = null;
         this.apiUrl = apiUrl;
-        this.username = username;
-        this.keypair = keypair;
+        this.credential = credential;
         this.api = api;
         this.iceServers = iceServers;
+        this.iceTransportPolicy = iceTransportPolicy;
+        this.webrtcAdapter = webrtcAdapter;
         this.cryptoAdapter = cryptoAdapter;
-        this.batchingOptions = batchingOptions;
         this.debugEnabled = debugEnabled;
-        this.rtcPeerConnection = rtcPeerConnection;
-        this.rtcIceCandidate = rtcIceCandidate;
+        // Initialize centralized polling manager
+        this.pollingManager = new PollingManager({
+            api: this.api,
+            debugEnabled: this.debugEnabled,
+        });
+        // Forward polling events to Rondevu instance
+        this.pollingManager.on('poll:answer', data => {
+            this.emit('poll:answer', data);
+        });
+        this.pollingManager.on('poll:ice', data => {
+            this.emit('poll:ice', data);
+        });
         this.debug('Instance created:', {
-            username: this.username,
-            publicKey: this.keypair.publicKey,
+            name: this.credential.name,
             hasIceServers: iceServers.length > 0,
-            batchingEnabled: batchingOptions !== false
+            iceTransportPolicy: iceTransportPolicy || 'all',
         });
     }
     /**
@@ -177,84 +100,76 @@ export class Rondevu extends EventEmitter {
      *
      * @example
      * ```typescript
+     * const rondevu = await Rondevu.connect({})  // Uses default API URL
+     * // or
      * const rondevu = await Rondevu.connect({
-     *   apiUrl: 'https://api.ronde.vu',
-     *   username: 'alice'
+     *   apiUrl: 'https://custom.api.com'
      * })
      * ```
      */
-    static async connect(options) {
-        const username = options.username || Rondevu.generateAnonymousUsername();
-        // Apply WebRTC polyfills to global scope if provided (Node.js environments)
-        if (options.rtcPeerConnection) {
-            globalThis.RTCPeerConnection = options.rtcPeerConnection;
-        }
-        if (options.rtcIceCandidate) {
-            globalThis.RTCIceCandidate = options.rtcIceCandidate;
-        }
-        // Handle preset string or custom array
-        let iceServers;
-        if (typeof options.iceServers === 'string') {
-            iceServers = ICE_SERVER_PRESETS[options.iceServers];
-        }
-        else {
-            iceServers = options.iceServers || [
-                { urls: 'stun:stun.l.google.com:19302' }
-            ];
-        }
+    static async connect(options = {}) {
+        const apiUrl = options.apiUrl || Rondevu.DEFAULT_API_URL;
+        // Use provided WebRTC adapter or default to browser adapter
+        const webrtcAdapter = options.webrtcAdapter || new BrowserWebRTCAdapter();
+        // Handle preset string or custom array, extracting iceTransportPolicy if present
+        const iceConfig = getIceConfiguration(options.iceServers);
         if (options.debug) {
             console.log('[Rondevu] Connecting:', {
-                username,
-                hasKeypair: !!options.keypair,
-                iceServers: iceServers.length,
-                batchingEnabled: options.batching !== false
+                apiUrl,
+                hasCredential: !!options.credential,
+                iceServers: iceConfig.iceServers?.length ?? 0,
+                iceTransportPolicy: iceConfig.iceTransportPolicy || 'all',
             });
         }
-        // Generate keypair if not provided
-        let keypair = options.keypair;
-        if (!keypair) {
+        // Generate credential if not provided
+        let credential = options.credential;
+        if (!credential) {
             if (options.debug)
-                console.log('[Rondevu] Generating new keypair...');
-            keypair = await RondevuAPI.generateKeypair(options.cryptoAdapter);
+                console.log('[Rondevu] Generating new credentials...');
+            credential = await RondevuAPI.generateCredentials(apiUrl, {
+                name: options.username, // Will claim this username if provided
+            });
             if (options.debug)
-                console.log('[Rondevu] Generated keypair, publicKey:', keypair.publicKey);
+                console.log('[Rondevu] Generated credentials, name:', credential.name);
         }
         else {
             if (options.debug)
-                console.log('[Rondevu] Using existing keypair, publicKey:', keypair.publicKey);
+                console.log('[Rondevu] Using existing credential, name:', credential.name);
         }
         // Create API instance
-        const api = new RondevuAPI(options.apiUrl, username, keypair, options.cryptoAdapter, options.batching);
+        const api = new RondevuAPI(apiUrl, credential, options.cryptoAdapter);
         if (options.debug)
             console.log('[Rondevu] Created API instance');
-        return new Rondevu(options.apiUrl, username, keypair, api, iceServers, options.cryptoAdapter, options.batching, options.debug || false, options.rtcPeerConnection, options.rtcIceCandidate);
+        return new Rondevu(apiUrl, credential, api, iceConfig.iceServers || [], iceConfig.iceTransportPolicy, webrtcAdapter, options.cryptoAdapter, options.debug || false);
     }
+    // ============================================
+    // Credential Access
+    // ============================================
     /**
-     * Generate an anonymous username with timestamp and random component
+     * Get the current credential name
      */
-    static generateAnonymousUsername() {
-        const timestamp = Date.now().toString(36);
-        const random = Array.from(crypto.getRandomValues(new Uint8Array(3)))
-            .map(b => b.toString(16).padStart(2, '0')).join('');
-        return `anon-${timestamp}-${random}`;
+    getName() {
+        return this.credential.name;
     }
-    // ============================================
-    // Username Management
-    // ============================================
     /**
-     * Check if username has been claimed (checks with server)
+     * Get the full credential (name + secret)
+     * Use this to persist credentials for future sessions
+     *
+     * ⚠️ SECURITY WARNING:
+     * - The secret grants full access to this identity
+     * - Store credentials securely (encrypted storage, never in logs)
+     * - Never expose credentials in URLs, console output, or error messages
+     * - Treat the secret like a password or API key
      */
-    async isUsernameClaimed() {
-        try {
-            const claimed = await this.api.isUsernameClaimed();
-            // Update internal flag to match server state
-            this.usernameClaimed = claimed;
-            return claimed;
-        }
-        catch (err) {
-            console.error('Failed to check username claim status:', err);
-            return false;
-        }
+    getCredential() {
+        return { ...this.credential };
+    }
+    /**
+     * Get the WebRTC adapter for creating peer connections
+     * Used internally by offer pool and connections
+     */
+    getWebRTCAdapter() {
+        return this.webrtcAdapter;
     }
     // ============================================
     // Service Publishing
@@ -270,37 +185,39 @@ export class Rondevu extends EventEmitter {
         return { dc, offer };
     }
     /**
-     * Publish a service with automatic offer management
-     * Call startFilling() to begin accepting connections
+     * Create offers with tags for discovery (offerer/host side)
+     * Auto-starts filling by default. Use the returned object to cancel.
      *
      * @example
      * ```typescript
-     * await rondevu.publishService({
-     *   service: 'chat:2.0.0',
-     *   maxOffers: 5,
-     *   connectionConfig: {
-     *     reconnectEnabled: true,
-     *     bufferEnabled: true
-     *   }
+     * // Auto-start (default)
+     * const offer = await rondevu.offer({
+     *   tags: ['chat', 'video'],
+     *   maxOffers: 5
      * })
+     * // Later: offer.cancel() to stop
+     *
+     * // Manual start
+     * await rondevu.offer({ tags: ['chat'], maxOffers: 5, autoStart: false })
      * await rondevu.startFilling()
      * ```
      */
-    async publishService(options) {
-        const { service, maxOffers, offerFactory, ttl, connectionConfig } = options;
-        this.currentService = service;
+    async offer(options) {
+        const { tags, maxOffers, offerFactory, ttl, connectionConfig, autoStart = true } = options;
+        this.currentTags = tags;
         this.connectionConfig = connectionConfig;
-        // Auto-append username to service
-        const serviceFqn = `${service}@${this.username}`;
-        this.debug(`Publishing service: ${service} with maxOffers: ${maxOffers}`);
-        // Create OfferPool (but don't start it yet - call startFilling() to begin)
+        this.debug(`Creating offers with tags: ${tags.join(', ')} with maxOffers: ${maxOffers}`);
+        // Create OfferPool
         this.offerPool = new OfferPool({
             api: this.api,
-            serviceFqn,
+            tags,
+            ownerUsername: this.credential.name,
             maxOffers,
             offerFactory: offerFactory || this.defaultOfferFactory.bind(this),
             ttl: ttl || Rondevu.DEFAULT_TTL_MS,
             iceServers: this.iceServers,
+            iceTransportPolicy: this.iceTransportPolicy,
+            webrtcAdapter: this.webrtcAdapter,
             connectionConfig,
             debugEnabled: this.debugEnabled,
         });
@@ -308,23 +225,39 @@ export class Rondevu extends EventEmitter {
         this.offerPool.on('connection:opened', (offerId, connection) => {
             this.emit('connection:opened', offerId, connection);
         });
-        this.offerPool.on('offer:created', (offerId, serviceFqn) => {
-            this.emit('offer:created', offerId, serviceFqn);
+        this.offerPool.on('offer:created', (offerId, tags) => {
+            this.emit('offer:created', offerId, tags);
         });
         this.offerPool.on('connection:rotated', (oldOfferId, newOfferId, connection) => {
             this.emit('connection:rotated', oldOfferId, newOfferId, connection);
         });
-        this.usernameClaimed = true;
+        // Subscribe to polling events and forward to OfferPool
+        this.on('poll:answer', data => {
+            this.offerPool?.handlePollAnswer(data);
+        });
+        this.on('poll:ice', data => {
+            this.offerPool?.handlePollIce(data);
+        });
+        // Auto-start if enabled (default)
+        if (autoStart) {
+            await this.startFilling();
+        }
+        // Return handle for cancellation
+        return {
+            cancel: () => this.stopFilling(),
+        };
     }
     /**
      * Start filling offers and polling for answers/ICE
-     * Call this after publishService() to begin accepting connections
+     * Call this after offer() to begin accepting connections
      */
     async startFilling() {
         if (!this.offerPool) {
-            throw new Error('No service published. Call publishService() first.');
+            throw new Error('No offers created. Call offer() first.');
         }
         this.debug('Starting offer filling and polling');
+        // Start the centralized polling manager
+        this.pollingManager.start();
         await this.offerPool.start();
     }
     /**
@@ -333,8 +266,31 @@ export class Rondevu extends EventEmitter {
      */
     stopFilling() {
         this.debug('Stopping offer filling and polling');
+        // Stop the centralized polling manager
+        this.pollingManager.stop();
         this.offerPool?.stop();
     }
+    /**
+     * Start the centralized polling manager
+     * Use this when you need polling without offers (e.g., answerer connections)
+     */
+    startPolling() {
+        this.debug('Starting polling manager');
+        this.pollingManager.start();
+    }
+    /**
+     * Stop the centralized polling manager
+     */
+    stopPolling() {
+        this.debug('Stopping polling manager');
+        this.pollingManager.stop();
+    }
+    /**
+     * Check if polling is active
+     */
+    isPolling() {
+        return this.pollingManager.isRunning();
+    }
     /**
      * Get the count of active offers
      * @returns Number of active offers
@@ -359,148 +315,112 @@ export class Rondevu extends EventEmitter {
         this.offerPool?.disconnectAll();
     }
     /**
-     * Get the current service status
-     * @returns Object with service state information
+     * Get the current publishing status
+     * @returns Object with publishing state information
      */
-    getServiceStatus() {
+    getPublishStatus() {
         return {
-            active: this.currentService !== null,
-            offerCount: this.offerPool?.getOfferCount() ?? 0
+            active: this.currentTags !== null,
+            offerCount: this.offerPool?.getOfferCount() ?? 0,
+            tags: this.currentTags,
         };
     }
     /**
-     * Resolve the full service FQN from various input options
-     * Supports direct FQN, service+username, or service discovery
-     */
-    async resolveServiceFqn(options) {
-        const { serviceFqn, service, username } = options;
-        if (serviceFqn) {
-            return serviceFqn;
-        }
-        else if (service && username) {
-            return `${service}@${username}`;
-        }
-        else if (service) {
-            // Discovery mode - get random service
-            this.debug(`Discovering service: ${service}`);
-            const discovered = await this.findService(service);
-            return discovered.serviceFqn;
-        }
-        else {
-            throw new Error('Either serviceFqn or service must be provided');
-        }
-    }
-    /**
-     * Connect to a service (answerer side) - v1.0.0 API
-     * Returns an AnswererConnection with automatic reconnection and buffering
-     *
-     * BREAKING CHANGE: This now returns AnswererConnection instead of ConnectionContext
+     * Create a peer connection with simplified DX
+     * Returns a Peer object with clean state management and events
      *
      * @example
      * ```typescript
+     * // Connect to any peer matching tags
+     * const peer = await rondevu.peer({ tags: ['chat'] })
+     *
      * // Connect to specific user
-     * const connection = await rondevu.connectToService({
-     *   serviceFqn: 'chat:2.0.0@alice',
-     *   connectionConfig: {
-     *     reconnectEnabled: true,
-     *     bufferEnabled: true
-     *   }
+     * const peer = await rondevu.peer({
+     *   username: 'alice',
+     *   tags: ['chat']
      * })
      *
-     * connection.on('connected', () => {
-     *   console.log('Connected!')
-     *   connection.send('Hello!')
+     * peer.on('open', () => {
+     *   console.log('Connected to', peer.peerUsername)
+     *   peer.send('Hello!')
      * })
      *
-     * connection.on('message', (data) => {
+     * peer.on('message', (data) => {
      *   console.log('Received:', data)
      * })
      *
-     * connection.on('reconnecting', (attempt) => {
-     *   console.log(`Reconnecting, attempt ${attempt}`)
+     * peer.on('state', (state, prevState) => {
+     *   console.log(`State: ${prevState} → ${state}`)
      * })
      *
-     * // Discover random service
-     * const connection = await rondevu.connectToService({
-     *   service: 'chat:2.0.0'
-     * })
+     * // Access underlying RTCPeerConnection
+     * if (peer.peerConnection) {
+     *   console.log('ICE state:', peer.peerConnection.iceConnectionState)
+     * }
      * ```
      */
-    async connectToService(options) {
-        const { rtcConfig, connectionConfig } = options;
-        // Validate inputs
-        if (options.serviceFqn !== undefined && typeof options.serviceFqn === 'string' && !options.serviceFqn.trim()) {
-            throw new Error('serviceFqn cannot be empty');
-        }
-        if (options.service !== undefined && typeof options.service === 'string' && !options.service.trim()) {
-            throw new Error('service cannot be empty');
-        }
-        if (options.username !== undefined && typeof options.username === 'string' && !options.username.trim()) {
-            throw new Error('username cannot be empty');
-        }
-        // Determine the full service FQN
-        const fqn = await this.resolveServiceFqn(options);
-        this.debug(`Connecting to service: ${fqn}`);
-        // Get service offer
-        const serviceData = await this.api.getService(fqn);
-        this.debug(`Found service from @${serviceData.username}`);
-        // Create RTCConfiguration
-        const rtcConfiguration = rtcConfig || {
-            iceServers: this.iceServers
-        };
-        // Create AnswererConnection
-        const connection = new AnswererConnection({
+    async peer(options) {
+        const peer = new Peer({
+            ...options,
             api: this.api,
-            serviceFqn: serviceData.serviceFqn,
-            offerId: serviceData.offerId,
-            offerSdp: serviceData.sdp,
-            rtcConfig: rtcConfiguration,
-            config: {
-                ...connectionConfig,
-                debug: this.debugEnabled,
-            },
+            iceServers: this.iceServers,
+            iceTransportPolicy: this.iceTransportPolicy,
+            webrtcAdapter: this.webrtcAdapter,
+            debug: this.debugEnabled,
         });
-        // Initialize the connection
-        await connection.initialize();
-        return connection;
+        await peer.initialize();
+        // Subscribe to poll:ice events for this peer's connection
+        const peerOfferId = peer.offerId;
+        const peerConnection = peer.getConnection();
+        if (peerConnection) {
+            const pollIceHandler = (data) => {
+                if (data.offerId === peerOfferId) {
+                    peerConnection.handleRemoteIceCandidates(data.candidates);
+                }
+            };
+            this.on('poll:ice', pollIceHandler);
+            // Clean up handler when connection closes
+            peerConnection.on('closed', () => {
+                this.off('poll:ice', pollIceHandler);
+            });
+        }
+        // Start polling if not already running
+        if (!this.pollingManager.isRunning()) {
+            this.debug('Starting polling for peer connection');
+            this.pollingManager.start();
+        }
+        return peer;
     }
     // ============================================
-    // Service Discovery
+    // Discovery
     // ============================================
     /**
-     * Find a service - unified discovery method
+     * Discover offers by tags
      *
-     * @param serviceFqn - Service identifier (e.g., 'chat:1.0.0' or 'chat:1.0.0@alice')
-     * @param options - Discovery options
+     * @param tags - Tags to search for (OR logic - matches any tag)
+     * @param options - Discovery options (pagination)
      *
      * @example
      * ```typescript
-     * // Direct lookup (has username)
-     * const service = await rondevu.findService('chat:1.0.0@alice')
-     *
-     * // Random discovery (no username)
-     * const service = await rondevu.findService('chat:1.0.0')
+     * // Discover offers matching any of the tags
+     * const result = await rondevu.discover(['chat', 'video'])
      *
      * // Paginated discovery
-     * const result = await rondevu.findService('chat:1.0.0', {
-     *   mode: 'paginated',
+     * const result = await rondevu.discover(['chat'], {
      *   limit: 20,
      *   offset: 0
      * })
+     *
+     * // Access offers
+     * for (const offer of result.offers) {
+     *   console.log(offer.username, offer.tags)
+     * }
      * ```
      */
-    async findService(serviceFqn, options) {
-        const { mode, limit = 10, offset = 0 } = options || {};
-        // Auto-detect mode if not specified
-        const hasUsername = serviceFqn.includes('@');
-        const effectiveMode = mode || (hasUsername ? 'direct' : 'random');
-        if (effectiveMode === 'paginated') {
-            return await this.api.getService(serviceFqn, { limit, offset });
-        }
-        else {
-            // Both 'direct' and 'random' use the same API call
-            return await this.api.getService(serviceFqn);
-        }
+    async discover(tags, options) {
+        const { limit = 10, offset = 0 } = options || {};
+        // Always pass limit to ensure we get DiscoverResponse (paginated mode)
+        return (await this.api.discover({ tags, limit, offset }));
     }
     // ============================================
     // WebRTC Signaling
@@ -508,15 +428,15 @@ export class Rondevu extends EventEmitter {
     /**
      * Post answer SDP to specific offer
      */
-    async postOfferAnswer(serviceFqn, offerId, sdp) {
-        await this.api.answerOffer(serviceFqn, offerId, sdp);
+    async postOfferAnswer(offerId, sdp) {
+        await this.api.answerOffer(offerId, sdp);
         return { success: true, offerId };
     }
     /**
      * Get answer SDP (offerer polls this)
      */
-    async getOfferAnswer(serviceFqn, offerId) {
-        return await this.api.getOfferAnswer(serviceFqn, offerId);
+    async getOfferAnswer(offerId) {
+        return await this.api.getOfferAnswer(offerId);
     }
     /**
      * Combined polling for answers and ICE candidates
@@ -528,73 +448,26 @@ export class Rondevu extends EventEmitter {
     /**
      * Add ICE candidates to specific offer
      */
-    async addOfferIceCandidates(serviceFqn, offerId, candidates) {
-        return await this.api.addOfferIceCandidates(serviceFqn, offerId, candidates);
+    async addOfferIceCandidates(offerId, candidates) {
+        return await this.api.addOfferIceCandidates(offerId, candidates);
     }
     /**
      * Get ICE candidates for specific offer (with polling support)
      */
-    async getOfferIceCandidates(serviceFqn, offerId, since = 0) {
-        return await this.api.getOfferIceCandidates(serviceFqn, offerId, since);
+    async getOfferIceCandidates(offerId, since = 0) {
+        return await this.api.getOfferIceCandidates(offerId, since);
     }
     // ============================================
     // Utility Methods
     // ============================================
-    /**
-     * Get the current keypair (for backup/storage)
-     */
-    getKeypair() {
-        return this.keypair;
-    }
-    /**
-     * Get the username
-     */
-    getUsername() {
-        return this.username;
-    }
-    /**
-     * Get the public key
-     */
-    getPublicKey() {
-        return this.keypair.publicKey;
-    }
     /**
      * Get active connections (for offerer side)
      */
     getActiveConnections() {
         return this.offerPool?.getActiveConnections() ?? new Map();
     }
-    /**
-     * Get all active offers (legacy compatibility)
-     * @deprecated Use getActiveConnections() instead
-     */
-    getActiveOffers() {
-        const offers = [];
-        const connections = this.offerPool?.getActiveConnections() ?? new Map();
-        for (const [offerId, connection] of connections.entries()) {
-            const pc = connection.getPeerConnection();
-            const dc = connection.getDataChannel();
-            if (pc) {
-                offers.push({
-                    offerId,
-                    serviceFqn: this.currentService ? `${this.currentService}@${this.username}` : '',
-                    pc,
-                    dc: dc || undefined,
-                    answered: connection.getState() === 'connected',
-                    createdAt: Date.now(),
-                });
-            }
-        }
-        return offers;
-    }
-    /**
-     * Access to underlying API for advanced operations
-     * @deprecated Use direct methods on Rondevu instance instead
-     */
-    getAPIPublic() {
-        return this.api;
-    }
 }
 // Constants
+Rondevu.DEFAULT_API_URL = 'https://api.ronde.vu';
 Rondevu.DEFAULT_TTL_MS = 300000; // 5 minutes
 Rondevu.POLLING_INTERVAL_MS = 1000; // 1 second