@xtr-dev/rondevu-client 0.18.10 → 0.20.1

package/dist/{rondevu.d.ts → core/rondevu.d.ts}

@@ -1,6 +1,9 @@
-import { RondevuAPI, Keypair, IceCandidate, BatcherOptions } from './api.js';
-import { CryptoAdapter } from './crypto-adapter.js';
+import { RondevuAPI, Keypair, IceCandidate, BatcherOptions } from '../api/client.js';
+import { CryptoAdapter } from '../crypto/adapter.js';
 import { EventEmitter } from 'eventemitter3';
+import { OffererConnection } from '../connections/offerer.js';
+import { AnswererConnection } from '../connections/answerer.js';
+import { ConnectionConfig } from '../connections/config.js';
 export type IceServerPreset = 'ipv4-turn' | 'hostname-turns' | 'google-stun' | 'relay-only';
 export declare const ICE_SERVER_PRESETS: Record<IceServerPreset, RTCIceServer[]>;
 export interface RondevuOptions {
@@ -32,6 +35,7 @@ export interface PublishServiceOptions {
     maxOffers: number;
     offerFactory?: OfferFactory;
     ttl?: number;
+    connectionConfig?: Partial<ConnectionConfig>;
 }
 export interface ConnectionContext {
     pc: RTCPeerConnection;
@@ -44,8 +48,8 @@ export interface ConnectToServiceOptions {
     serviceFqn?: string;
     service?: string;
     username?: string;
-    onConnection?: (context: ConnectionContext) => void | Promise<void>;
     rtcConfig?: RTCConfiguration;
+    connectionConfig?: Partial<ConnectionConfig>;
 }
 export interface ActiveOffer {
     offerId: string;
@@ -101,14 +105,13 @@ export declare class ConnectionError extends RondevuError {
     constructor(message: string, context?: Record<string, any>);
 }
 /**
- * Rondevu - Complete WebRTC signaling client
+ * Rondevu - Complete WebRTC signaling client with durable connections
  *
- * Provides a unified API for:
- * - Implicit username claiming (auto-claimed on first authenticated request)
- * - Service publishing with automatic signature generation
- * - Service discovery (direct, random, paginated)
- * - WebRTC signaling (offer/answer exchange, ICE relay)
- * - Keypair management
+ * 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.)
  *
  * @example
  * ```typescript
@@ -119,39 +122,39 @@ export declare class ConnectionError extends RondevuError {
  *   iceServers: 'ipv4-turn'  // Use preset: 'ipv4-turn', 'hostname-turns', 'google-stun', or 'relay-only'
  * })
  *
- * // Or use custom ICE servers
- * const rondevu2 = await Rondevu.connect({
- *   apiUrl: 'https://signal.example.com',
- *   username: 'bob',
- *   iceServers: [
- *     { urls: 'stun:stun.l.google.com:19302' },
- *     { urls: 'turn:turn.example.com:3478', username: 'user', credential: 'pass' }
- *   ]
- * })
- *
  * // Publish a service with automatic offer management
  * await rondevu.publishService({
  *   service: 'chat:2.0.0',
- *   maxOffers: 5,  // Maintain up to 5 concurrent offers
- *   offerFactory: async (pc) => {
- *     // pc is created by Rondevu with ICE handlers already attached
- *     const dc = pc.createDataChannel('chat')
- *     const offer = await pc.createOffer()
- *     await pc.setLocalDescription(offer)
- *     return { dc, offer }
- *   }
+ *   maxOffers: 5  // Maintain up to 5 concurrent offers
  * })
  *
  * // Start accepting connections (auto-fills offers and polls)
  * await rondevu.startFilling()
  *
- * // Access active connections
- * for (const offer of rondevu.getActiveOffers()) {
- *   offer.dc?.addEventListener('message', (e) => console.log(e.data))
- * }
+ * // Listen for connections (v1.0.0 API)
+ * 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'
+ * })
+ *
+ * connection.on('connected', () => {
+ *   console.log('Connected!')
+ *   connection.send('Hello!')
+ * })
+ *
+ * connection.on('message', (data) => {
+ *   console.log('Received:', data)
+ * })
  *
- * // Stop when done
- * rondevu.stopFilling()
+ * connection.on('reconnecting', (attempt) => {
+ *   console.log(`Reconnecting, attempt ${attempt}`)
+ * })
  * ```
  */
 export declare class Rondevu extends EventEmitter {
@@ -169,14 +172,8 @@ export declare class Rondevu extends EventEmitter {
     private rtcPeerConnection?;
     private rtcIceCandidate?;
     private currentService;
-    private maxOffers;
-    private offerFactory;
-    private ttl;
-    private activeOffers;
-    private filling;
-    private pollingInterval;
-    private lastPollTimestamp;
-    private isPolling;
+    private connectionConfig?;
+    private offerPool;
     private constructor();
     /**
      * Internal debug logging - only logs if debug mode is enabled
@@ -215,32 +212,16 @@ export declare class Rondevu extends EventEmitter {
      * ```typescript
      * await rondevu.publishService({
      *   service: 'chat:2.0.0',
-     *   maxOffers: 5
+     *   maxOffers: 5,
+     *   connectionConfig: {
+     *     reconnectEnabled: true,
+     *     bufferEnabled: true
+     *   }
      * })
      * await rondevu.startFilling()
      * ```
      */
     publishService(options: PublishServiceOptions): Promise<void>;
-    /**
-     * Set up ICE candidate handler to send candidates to the server
-     *
-     * Note: This is used by connectToService() where the offerId is already known.
-     * For createOffer(), we use inline ICE handling with early candidate queuing
-     * since the offerId isn't available until after the factory completes.
-     */
-    private setupIceCandidateHandler;
-    /**
-     * Create a single offer and publish it to the server
-     */
-    private createOffer;
-    /**
-     * Fill offers to reach maxOffers count
-     */
-    private fillOffers;
-    /**
-     * Poll for answers and ICE candidates (internal use for automatic offer management)
-     */
-    private pollInternal;
     /**
      * Start filling offers and polling for answers/ICE
      * Call this after publishService() to begin accepting connections
@@ -259,14 +240,14 @@ export declare class Rondevu extends EventEmitter {
     /**
      * Check if an offer is currently connected
      * @param offerId - The offer ID to check
-     * @returns True if the offer exists and has been answered
+     * @returns True if the offer exists and is connected
      */
     isConnected(offerId: string): boolean;
     /**
      * Disconnect all active offers
      * Similar to stopFilling() but doesn't stop the polling/filling process
      */
-    disconnectAll(): Promise<void>;
+    disconnectAll(): void;
     /**
      * Get the current service status
      * @returns Object with service state information
@@ -274,8 +255,6 @@ export declare class Rondevu extends EventEmitter {
     getServiceStatus(): {
         active: boolean;
         offerCount: number;
-        maxOffers: number;
-        filling: boolean;
     };
     /**
      * Resolve the full service FQN from various input options
@@ -283,41 +262,45 @@ export declare class Rondevu extends EventEmitter {
      */
     private resolveServiceFqn;
     /**
-     * Start polling for remote ICE candidates
-     * Returns the polling interval ID
-     */
-    private startIcePolling;
-    /**
-     * Automatically connect to a service (answerer side)
-     * Handles the entire connection flow: discovery, WebRTC setup, answer exchange, ICE candidates
+     * 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
      *
      * @example
      * ```typescript
      * // Connect to specific user
      * const connection = await rondevu.connectToService({
      *   serviceFqn: 'chat:2.0.0@alice',
-     *   onConnection: ({ dc, peerUsername }) => {
-     *     console.log('Connected to', peerUsername)
-     *     dc.addEventListener('message', (e) => console.log(e.data))
-     *     dc.addEventListener('open', () => dc.send('Hello!'))
+     *   connectionConfig: {
+     *     reconnectEnabled: true,
+     *     bufferEnabled: true
      *   }
      * })
      *
+     * connection.on('connected', () => {
+     *   console.log('Connected!')
+     *   connection.send('Hello!')
+     * })
+     *
+     * connection.on('message', (data) => {
+     *   console.log('Received:', data)
+     * })
+     *
+     * connection.on('reconnecting', (attempt) => {
+     *   console.log(`Reconnecting, attempt ${attempt}`)
+     * })
+     *
      * // Discover random service
      * const connection = await rondevu.connectToService({
-     *   service: 'chat:2.0.0',
-     *   onConnection: ({ dc, peerUsername }) => {
-     *     console.log('Connected to', peerUsername)
-     *   }
+     *   service: 'chat:2.0.0'
      * })
      * ```
      */
-    connectToService(options: ConnectToServiceOptions): Promise<ConnectionContext>;
+    connectToService(options: ConnectToServiceOptions): Promise<AnswererConnection>;
     /**
      * Find a service - unified discovery method
      *
-     * Replaces getService(), discoverService(), and discoverServices() with a single method.
-     *
      * @param serviceFqn - Service identifier (e.g., 'chat:1.0.0' or 'chat:1.0.0@alice')
      * @param options - Discovery options
      *
@@ -399,6 +382,15 @@ export declare class Rondevu extends EventEmitter {
      * Get the public key
      */
     getPublicKey(): string;
+    /**
+     * Get active connections (for offerer side)
+     */
+    getActiveConnections(): Map<string, OffererConnection>;
+    /**
+     * Get all active offers (legacy compatibility)
+     * @deprecated Use getActiveConnections() instead
+     */
+    getActiveOffers(): ActiveOffer[];
     /**
      * Access to underlying API for advanced operations
      * @deprecated Use direct methods on Rondevu instance instead