y-openrtc 0.1.1 → 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.
 
@@ -79,7 +81,6 @@ The live test at `tests/OpenrtcProvider.live.test.ts` reads package-local env va
 Create `openrtc/packages/y-openrtc/.env.local` with:
 
 ```bash
-OPENRTC_LIVE_TESTS=1
 OPENRTC_Y_OPENRTC_API_KEY=<your public OpenRTC API key>
 ```
 

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;
@@ -49,7 +48,9 @@ export declare class OpenrtcProvider {
     private warnCompatibilityOptions;
     private emitStatus;
     private emitSynced;
+    private currentPeersPayload;
     private emitPeers;
+    private replayEvent;
     private attachLocalObservers;
     private detachLocalObservers;
     private connectInternal;
@@ -64,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,
@@ -129,6 +131,9 @@ export class OpenrtcProvider {
             }
             const clients = added.concat(updated, removed);
             void this.broadcastProviderPayload(encodeAwarenessUpdate(this.awareness, clients));
+            if (added.concat(removed).some((clientId) => clientId !== this.doc.clientID)) {
+                this.emitPeers([], []);
+            }
         };
         this.destroyHandler = () => {
             void this.destroyInternal();
@@ -144,6 +149,7 @@ export class OpenrtcProvider {
         const listeners = this.listeners.get(name) ?? new Set();
         listeners.add(listener);
         this.listeners.set(name, listeners);
+        this.replayEvent(name, listener);
         return listener;
     }
     off(name, listener) {
@@ -154,7 +160,9 @@ export class OpenrtcProvider {
             this.off(name, wrapped);
             listener(payload);
         });
-        this.on(name, wrapped);
+        const listeners = this.listeners.get(name) ?? new Set();
+        listeners.add(wrapped);
+        this.listeners.set(name, listeners);
     }
     emit(name, payload) {
         for (const listener of this.listeners.get(name) ?? []) {
@@ -206,16 +214,37 @@ export class OpenrtcProvider {
         this.synced = nextSynced;
         this.emit('synced', { synced: nextSynced });
     }
-    emitPeers(added, removed) {
-        const payload = {
+    currentPeersPayload(added = [], removed = []) {
+        return {
             added,
             removed,
             openrtcPeers: Array.from(this.openrtcConnections.keys()),
             webrtcPeers: Array.from(this.openrtcConnections.keys()),
             bcPeers: Array.from(this.bcPeers.keys()),
+            awarenessPeers: Array.from(this.awareness.getStates().keys())
+                .filter((clientId) => clientId !== this.doc.clientID),
         };
+    }
+    emitPeers(added, removed) {
+        const payload = this.currentPeersPayload(added, removed);
         this.emit('peers', payload);
     }
+    replayEvent(name, listener) {
+        queueMicrotask(() => {
+            if (this.destroyed || !this.listeners.get(name)?.has(listener)) {
+                return;
+            }
+            if (name === 'status') {
+                listener({ connected: this.connected });
+                return;
+            }
+            if (name === 'synced') {
+                listener({ synced: this.synced });
+                return;
+            }
+            listener(this.currentPeersPayload());
+        });
+    }
     attachLocalObservers() {
         if (this.localObserversAttached) {
             return;
@@ -255,7 +284,6 @@ export class OpenrtcProvider {
                 return;
             }
             this.attachConnection(connection);
-            void this.reconcilePeers();
         });
         if (typeof runtime.onConnectionStateChange === 'function') {
             const stopRuntimeConnectionStates = runtime.onConnectionStateChange((state) => {
@@ -323,7 +351,6 @@ export class OpenrtcProvider {
             this.requestReconcile();
         });
         this.refreshKnownRuntimeConnections();
-        this.startRuntimeConnectionRefresh();
         this.broadcastInitialBcState();
         this.requestReconcile();
         this.updateSyncedState();
@@ -481,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);
@@ -513,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(() => {
@@ -548,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);
         }
     }
@@ -577,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)) {
@@ -585,7 +606,6 @@ export class OpenrtcProvider {
             }
             this.emitPeers([], [nodeId]);
             this.updateSyncedState();
-            this.requestReconcile();
         });
         this.sendInitialSync(connection, record);
     }
@@ -615,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;
@@ -704,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/dist/types.d.ts

@@ -52,6 +52,12 @@ export interface PeersEventPayload {
     openrtcPeers: string[];
     webrtcPeers: string[];
     bcPeers: string[];
+    /**
+     * Remote Yjs awareness client ids currently visible to this provider.
+     * This is the best source for participant counts in collaborative UIs,
+     * because OpenRTC may use a mesh subset or BroadcastChannel for transport.
+     */
+    awarenessPeers: number[];
 }
 export interface OpenrtcProviderEvents {
     status: StatusEventPayload;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "y-openrtc",
-  "version": "0.1.1",
+  "version": "1.0.0",
   "private": false,
   "type": "module",
   "sideEffects": false,
@@ -34,14 +34,16 @@
     "./package.json": "./package.json"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "rm -rf dist && tsc",
+    "prepublishOnly": "pnpm run build",
     "test": "vitest run tests",
+    "test:deterministic": "vitest run tests/TetrisSync.test.ts tests/TetrisPeerDiagnostic.test.ts tests/OpenrtcProvider.test.ts tests/PublicPackageGuard.test.ts tests/crypto.test.ts",
     "test:watch": "vitest",
-    "test:live": "OPENRTC_LIVE_TESTS=1 vitest run tests/OpenrtcProvider.live.test.ts"
+    "test:live": "vitest run tests/OpenrtcProvider.live.test.ts"
   },
   "dependencies": {
     "lib0": "^0.2.114",
-    "openrtc": "workspace:*",
+    "openrtc": "^1.0.0",
     "y-protocols": "^1.0.6"
   },
   "peerDependencies": {