y-openrtc 0.1.2 → 1.0.0

package/README.md

@@ -69,6 +69,8 @@ Keep TURN credentials server-generated and short lived. Do not commit `.env` fil
 
 - `signaling` and `peerOpts` are accepted for compatibility, but ignored.
 - OpenRTC remains the source of truth for room membership and peer transport.
+- Runtime connection events and room-membership changes drive peer attachment;
+  the provider does not poll or own base-connection retries.
 - Same-tab sync still prefers `BroadcastChannel` when available.
 - `password` encrypts provider payloads end-to-end on top of OpenRTC.
 

package/dist/provider.d.ts

@@ -34,7 +34,6 @@ export declare class OpenrtcProvider {
     private localObserversAttached;
     private connectPromise;
     private reconcileTimer;
-    private runtimeRefreshTimer;
     private readonly diagnostics;
     constructor(roomName: string, doc: Y.Doc, options?: OpenrtcProviderOptions);
     get connected(): boolean;
@@ -66,12 +65,12 @@ export declare class OpenrtcProvider {
     private hasBcNodeId;
     private isRelevantConnection;
     private refreshKnownRuntimeConnections;
-    private startRuntimeConnectionRefresh;
     private resyncPeer;
     private sendInitialSync;
     private attachConnection;
     private sendToConnection;
     private sendControlToConnection;
+    private sendControlBestEffort;
     private sendBroadcastPayload;
     private broadcastProviderPayload;
     private broadcastInitialBcState;

package/dist/provider.js

@@ -68,6 +68,9 @@ function isRoomFullError(error) {
 function isTransientStartupError(error) {
     return /relay-only endpoint ticket unavailable|failed to fetch|network|timed out/i.test(errorText(error));
 }
+function isClosedConnectionSendError(error) {
+    return /connection is closed|closed connection|not open|writer is closed|application crypto is required but the connection is closed/i.test(errorText(error));
+}
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -93,7 +96,6 @@ export class OpenrtcProvider {
         this.localObserversAttached = false;
         this.connectPromise = null;
         this.reconcileTimer = null;
-        this.runtimeRefreshTimer = null;
         this.diagnostics = {
             openrtcSent: 0,
             openrtcReceived: 0,
@@ -282,7 +284,6 @@ export class OpenrtcProvider {
                 return;
             }
             this.attachConnection(connection);
-            void this.reconcilePeers();
         });
         if (typeof runtime.onConnectionStateChange === 'function') {
             const stopRuntimeConnectionStates = runtime.onConnectionStateChange((state) => {
@@ -350,7 +351,6 @@ export class OpenrtcProvider {
             this.requestReconcile();
         });
         this.refreshKnownRuntimeConnections();
-        this.startRuntimeConnectionRefresh();
         this.broadcastInitialBcState();
         this.requestReconcile();
         this.updateSyncedState();
@@ -508,7 +508,6 @@ export class OpenrtcProvider {
             }
             catch (error) {
                 console.warn(`[y-openrtc] failed to connect to room peer ${member.nodeId}:`, error);
-                this.requestReconcile();
             }
             finally {
                 this.pendingNodeIds.delete(member.nodeId);
@@ -540,31 +539,22 @@ export class OpenrtcProvider {
             }
         }
     }
-    startRuntimeConnectionRefresh() {
-        if (this.runtimeRefreshTimer) {
-            return;
-        }
-        this.runtimeRefreshTimer = setInterval(() => {
-            this.refreshKnownRuntimeConnections();
-            this.requestReconcile();
-        }, 1000);
-    }
     resyncPeer(remoteNodeId) {
         const record = this.openrtcConnections.get(remoteNodeId);
         if (!record) {
             return;
         }
         record.synced = false;
-        void this.sendControlToConnection(record.connection, encodeSyncStep1(this.doc));
-        void this.sendControlToConnection(record.connection, encodeAwarenessQuery());
+        this.sendControlBestEffort(record.connection, encodeSyncStep1(this.doc));
+        this.sendControlBestEffort(record.connection, encodeAwarenessQuery());
         this.updateSyncedState();
     }
     sendInitialSync(connection, record) {
-        void this.sendControlToConnection(connection, encodeSyncStep1(this.doc));
-        void this.sendControlToConnection(connection, encodeAwarenessQuery());
+        this.sendControlBestEffort(connection, encodeSyncStep1(this.doc));
+        this.sendControlBestEffort(connection, encodeAwarenessQuery());
         const awarenessStates = Array.from(this.awareness.getStates().keys());
         if (awarenessStates.length > 0) {
-            void this.sendControlToConnection(connection, encodeAwarenessUpdate(this.awareness, awarenessStates));
+            this.sendControlBestEffort(connection, encodeAwarenessUpdate(this.awareness, awarenessStates));
         }
         for (const delayMs of [250, 1000, 3000]) {
             setTimeout(() => {
@@ -575,8 +565,8 @@ export class OpenrtcProvider {
                     || this.openrtcConnections.get(connection.remoteNodeId)?.connection.id !== connection.id) {
                     return;
                 }
-                void this.sendControlToConnection(connection, encodeSyncStep1(this.doc));
-                void this.sendControlToConnection(connection, encodeAwarenessQuery());
+                this.sendControlBestEffort(connection, encodeSyncStep1(this.doc));
+                this.sendControlBestEffort(connection, encodeAwarenessQuery());
             }, delayMs);
         }
     }
@@ -604,7 +594,11 @@ export class OpenrtcProvider {
                 return;
             }
             this.diagnostics.openrtcReceived += 1;
-            void this.handleIncomingPayload(normalizeBinaryPayload(message), { type: 'openrtc', nodeId, connectionId: connection.id }, (reply) => this.sendControlToConnection(connection, reply), record);
+            void this.handleIncomingPayload(normalizeBinaryPayload(message), { type: 'openrtc', nodeId, connectionId: connection.id }, (reply) => this.sendControlToConnection(connection, reply), record).catch((error) => {
+                if (!isClosedConnectionSendError(error)) {
+                    console.warn('[y-openrtc] incoming payload handler failed', error);
+                }
+            });
         });
         connection.onDisconnect(() => {
             if (!this.openrtcConnections.delete(nodeId)) {
@@ -612,7 +606,6 @@ export class OpenrtcProvider {
             }
             this.emitPeers([], [nodeId]);
             this.updateSyncedState();
-            this.requestReconcile();
         });
         this.sendInitialSync(connection, record);
     }
@@ -642,6 +635,13 @@ export class OpenrtcProvider {
         }
         await connection.send(encrypted);
     }
+    sendControlBestEffort(connection, payload) {
+        void this.sendControlToConnection(connection, payload).catch((error) => {
+            if (!isClosedConnectionSendError(error)) {
+                console.warn('[y-openrtc] control send failed', error);
+            }
+        });
+    }
     async sendBroadcastPayload(payload) {
         const encrypted = await encryptFrame(payload, await this.keyPromise);
         this.diagnostics.broadcastSent += 1;
@@ -731,10 +731,6 @@ export class OpenrtcProvider {
             clearTimeout(this.reconcileTimer);
             this.reconcileTimer = null;
         }
-        if (this.runtimeRefreshTimer) {
-            clearInterval(this.runtimeRefreshTimer);
-            this.runtimeRefreshTimer = null;
-        }
         this.broadcastTransport?.disconnect();
         this.broadcastTransport = null;
         this.roomMembers.clear();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "y-openrtc",
-  "version": "0.1.2",
+  "version": "1.0.0",
   "private": false,
   "type": "module",
   "sideEffects": false,
@@ -43,7 +43,7 @@
   },
   "dependencies": {
     "lib0": "^0.2.114",
-    "openrtc": "^0.2.0",
+    "openrtc": "^1.0.0",
     "y-protocols": "^1.0.6"
   },
   "peerDependencies": {