y-openrtc 0.1.2 → 2.0.0-rc.0

package/README.md

@@ -12,11 +12,17 @@ pnpm add y-openrtc yjs
 
 ```ts
 import * as Y from 'yjs';
+import { OpenRTC } from 'openrtc';
 import { OpenrtcProvider } from 'y-openrtc';
 
+const rtc = OpenRTC({ apiKey: '<your public OpenRTC API key>' });
+const room = await rtc.rooms.join('my-room', {
+  access: 'capability',
+  membership: 'ephemeral',
+});
 const doc = new Y.Doc();
 const provider = new OpenrtcProvider('my-room', doc, {
-  apiKey: '<your public OpenRTC API key>',
+  room,
 });
 ```
 
@@ -27,40 +33,32 @@ import * as Y from 'yjs';
 import { OpenRTC } from 'openrtc';
 import { OpenrtcProvider } from 'y-openrtc';
 
-const client = OpenRTC({
-  apiKey: '<your public OpenRTC API key>',
+const room = await rtc.rooms.join('private-room', {
+  access: 'authenticated',
+  auth,
 });
 
 const doc = new Y.Doc();
 const provider = new OpenrtcProvider('my-room', doc, {
-  runtime: client,
+  room,
 });
 ```
 
 ## Transport and strict-mode options
 
-`OpenrtcProvider` forwards OpenRTC transport options when it creates its own runtime:
+Configure advanced transports on the OpenRTC client, then pass the activated room:
 
 ```ts
-const provider = new OpenrtcProvider('private-room', doc, {
+const rtc = OpenRTC({
   apiKey: '<your public OpenRTC API key>',
-  strictMode: true,
   transports: {
     iroh: true,
-    webrtc: {
-      privacyMode: true,
-      useTurn: true,
-    },
+    webrtc: true,
     moq: true,
   },
-  turnCredentialsProvider: async () => ({
-    iceServers: [{
-      urls: ['turn:turn.example.com:3478?transport=udp'],
-      username: 'short-lived-user',
-      credential: 'short-lived-credential',
-    }],
-  }),
 });
+const room = await rtc.rooms.join('private-room', { access: 'capability' });
+const provider = new OpenrtcProvider('private-room', doc, { room });
 ```
 
 Keep TURN credentials server-generated and short lived. Do not commit `.env` files or long-lived secrets.
@@ -69,6 +67,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/index.d.ts

@@ -1,3 +1,4 @@
 export { OpenrtcProvider, } from './provider.js';
 export { roomNameToOpenrtcRoomId } from './roomName.js';
-export type { OpenrtcAuthMode, OpenrtcProviderEvents, OpenrtcProviderOptions, OpenrtcTransports, PeersEventPayload, StatusEventPayload, SyncedEventPayload, } from './types.js';
+export type { OpenrtcProviderEvents, OpenrtcProviderOptions, OpenrtcTransports, PeersEventPayload, StatusEventPayload, SyncedEventPayload, } from './types.js';
+export { runtimeFromRoom } from './roomRuntime.js';

package/dist/index.js

@@ -1,2 +1,3 @@
 export { OpenrtcProvider, } from './provider.js';
 export { roomNameToOpenrtcRoomId } from './roomName.js';
+export { runtimeFromRoom } from './roomRuntime.js';

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,
@@ -262,9 +264,6 @@ export class OpenrtcProvider {
     async connectInternal() {
         const lease = acquireRuntimeLease({
             ...this.options,
-            authMode: this.options.authMode ?? 'anonymous',
-            allowAnonymousHostedDefaults: this.options.allowAnonymousHostedDefaults ?? !this.options.apiKey,
-            space: this.options.space ?? this.options.spaceKey ?? (!this.options.apiKey ? this.roomName : undefined),
         });
         this.runtimeLease = lease;
         const runtime = await lease.ensureReady();
@@ -282,7 +281,6 @@ export class OpenrtcProvider {
                 return;
             }
             this.attachConnection(connection);
-            void this.reconcilePeers();
         });
         if (typeof runtime.onConnectionStateChange === 'function') {
             const stopRuntimeConnectionStates = runtime.onConnectionStateChange((state) => {
@@ -350,7 +348,6 @@ export class OpenrtcProvider {
             this.requestReconcile();
         });
         this.refreshKnownRuntimeConnections();
-        this.startRuntimeConnectionRefresh();
         this.broadcastInitialBcState();
         this.requestReconcile();
         this.updateSyncedState();
@@ -508,7 +505,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 +536,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 +562,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 +591,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 +603,6 @@ export class OpenrtcProvider {
             }
             this.emitPeers([], [nodeId]);
             this.updateSyncedState();
-            this.requestReconcile();
         });
         this.sendInitialSync(connection, record);
     }
@@ -642,6 +632,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 +728,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/roomRuntime.d.ts

@@ -0,0 +1,4 @@
+import type { OpenRTCRoomHandle } from 'openrtc';
+import type { RuntimeClient } from 'openrtc/runtime';
+/** One-handle adapter; cast is isolated here so provider code cannot see legacy construction. */
+export declare function runtimeFromRoom(room: OpenRTCRoomHandle): RuntimeClient;

package/dist/roomRuntime.js

@@ -0,0 +1,63 @@
+function normalized(value) {
+    return value.trim().toUpperCase();
+}
+function assertRoom(room, requested) {
+    if (normalized(room.id) !== normalized(requested)) {
+        throw new Error(`Activated OpenRTC room '${room.id}' cannot join '${requested}'.`);
+    }
+}
+/** One-handle adapter; cast is isolated here so provider code cannot see legacy construction. */
+export function runtimeFromRoom(room) {
+    const connections = () => room.diagnostics.connections();
+    const adapter = {
+        initialize: async () => undefined,
+        start: async () => undefined,
+        shutdown: async () => room.close(),
+        getNodeId: async () => {
+            const status = await room.diagnostics.status();
+            if (!status.localNodeId)
+                throw new Error('The activated OpenRTC room has no local peer identity.');
+            return status.localNodeId;
+        },
+        createRoom: async (roomId = room.id) => {
+            assertRoom(room, roomId);
+            return normalized(room.id);
+        },
+        joinRoom: async (roomId) => {
+            assertRoom(room, roomId);
+            return connections();
+        },
+        leaveRoom: async (roomId) => {
+            assertRoom(room, roomId);
+            await room.leave();
+        },
+        watchRoom: (roomId, callback) => {
+            assertRoom(room, roomId);
+            return room.peers.watch((peers) => callback(peers.map((peer) => ({
+                nodeId: peer.nodeId ?? peer.id,
+                userId: peer.userId,
+                ticket: peer.ticket,
+                joinedAt: Date.now(),
+                lastSeenAt: Date.now(),
+            }))));
+        },
+        onConnection: (callback) => {
+            const seen = new Set();
+            const publish = () => {
+                for (const connection of connections()) {
+                    const id = connection.id ?? connection.remoteNodeId;
+                    if (!id || seen.has(id))
+                        continue;
+                    seen.add(id);
+                    callback(connection);
+                }
+            };
+            publish();
+            return room.peers.watch(publish);
+        },
+        onConnectionStateChange: room.diagnostics.onConnectionStateChange,
+        getConnections: connections,
+        connectByTicket: ({ ticket, timeoutMs }) => room.peers.connect({ ticket, timeoutMs }),
+    };
+    return adapter;
+}

package/dist/runtimePool.js

@@ -1,33 +1,5 @@
-import { OpenRTC } from 'openrtc';
-const ownedRuntimes = new Map();
+import { runtimeFromRoom } from './roomRuntime.js';
 const runtimeStartPromises = new WeakMap();
-function stableStringify(value) {
-    if (value === null || typeof value !== 'object') {
-        return JSON.stringify(value);
-    }
-    if (Array.isArray(value)) {
-        return `[${value.map((item) => stableStringify(item)).join(',')}]`;
-    }
-    const entries = Object.entries(value)
-        .filter(([, current]) => current !== undefined)
-        .sort(([left], [right]) => left.localeCompare(right));
-    return `{${entries.map(([key, current]) => `${JSON.stringify(key)}:${stableStringify(current)}`).join(',')}}`;
-}
-function runtimePoolKey(options) {
-    const space = options.spaceKey ?? options.space;
-    return stableStringify({
-        apiKey: options.apiKey,
-        authMode: options.authMode,
-        allowAnonymousHostedDefaults: options.allowAnonymousHostedDefaults,
-        space,
-        hasSpaceTokenProvider: typeof options.spaceTokenProvider === 'function',
-        storagePrefix: options.storagePrefix,
-        nodeIdPersistence: options.nodeIdPersistence,
-        transports: options.transports,
-        strictMode: options.strictMode,
-        hasTurnCredentialsProvider: typeof options.turnCredentialsProvider === 'function',
-    });
-}
 async function ensureRuntimeReady(runtime) {
     let startPromise = runtimeStartPromises.get(runtime);
     if (!startPromise) {
@@ -41,53 +13,15 @@ async function ensureRuntimeReady(runtime) {
     return runtime;
 }
 export function acquireRuntimeLease(options) {
-    if (options.runtime) {
-        const runtime = options.runtime;
-        return {
-            runtime,
-            owned: false,
-            ensureReady: () => ensureRuntimeReady(runtime),
-            release: async () => undefined,
-        };
-    }
-    const key = runtimePoolKey(options);
-    const space = options.spaceKey ?? options.space;
-    let entry = ownedRuntimes.get(key);
-    if (!entry) {
-        entry = {
-            runtime: OpenRTC({
-                apiKey: options.apiKey,
-                authMode: options.authMode,
-                allowAnonymousHostedDefaults: options.allowAnonymousHostedDefaults,
-                space,
-                spaceTokenProvider: options.spaceTokenProvider,
-                storagePrefix: options.storagePrefix,
-                nodeIdPersistence: options.nodeIdPersistence,
-                transports: options.transports,
-                strictMode: options.strictMode,
-                turnCredentialsProvider: options.turnCredentialsProvider,
-            }),
-            refs: 0,
-        };
-        ownedRuntimes.set(key, entry);
+    const runtime = options.runtime
+        ?? (options.room ? runtimeFromRoom(options.room) : null);
+    if (!runtime) {
+        throw new Error('y-openrtc requires an activated OpenRTC 2.0 room handle or an explicit openrtc/runtime client.');
     }
-    entry.refs += 1;
     return {
-        runtime: entry.runtime,
-        owned: true,
-        ensureReady: () => ensureRuntimeReady(entry.runtime),
-        release: async () => {
-            const current = ownedRuntimes.get(key);
-            if (!current) {
-                return;
-            }
-            current.refs -= 1;
-            if (current.refs > 0) {
-                return;
-            }
-            ownedRuntimes.delete(key);
-            runtimeStartPromises.delete(current.runtime);
-            current.runtime.stop();
-        },
+        runtime,
+        owned: false,
+        ensureReady: () => ensureRuntimeReady(runtime),
+        release: async () => undefined,
     };
 }

package/dist/types.d.ts

@@ -1,29 +1,15 @@
-import type { OpenRTC } from 'openrtc';
+import type { OpenRTCOptions, OpenRTCRoomHandle } from 'openrtc';
 import type { RuntimeClient } from 'openrtc/runtime';
 import type { Awareness } from 'y-protocols/awareness';
-type OpenrtcClientOptions = Parameters<typeof OpenRTC>[0];
-export type OpenrtcTransports = OpenrtcClientOptions['transports'];
-export type OpenrtcAuthMode = OpenrtcClientOptions['authMode'];
-export type OpenrtcTurnCredentialsProvider = NonNullable<OpenrtcClientOptions>['turnCredentialsProvider'];
-export type OpenrtcAllowAnonymousHostedDefaults = NonNullable<OpenrtcClientOptions>['allowAnonymousHostedDefaults'];
-export type OpenrtcSpaceTokenProvider = NonNullable<OpenrtcClientOptions>['spaceTokenProvider'];
+export type OpenrtcTransports = OpenRTCOptions['transports'];
 export interface OpenrtcProviderOptions {
-    apiKey?: string;
     runtime?: RuntimeClient;
-    authMode?: OpenrtcAuthMode;
-    allowAnonymousHostedDefaults?: OpenrtcAllowAnonymousHostedDefaults;
-    space?: string;
-    spaceKey?: string;
-    spaceTokenProvider?: OpenrtcSpaceTokenProvider;
+    /** Preferred 2.0 path: one already-activated collaborative room. */
+    room?: OpenRTCRoomHandle;
     awareness?: Awareness;
     password?: string | null;
     maxConns?: number;
     filterBcConns?: boolean;
-    storagePrefix?: string;
-    nodeIdPersistence?: 'persistent' | 'ephemeral';
-    transports?: OpenrtcTransports;
-    strictMode?: boolean;
-    turnCredentialsProvider?: OpenrtcTurnCredentialsProvider;
     roomIdOverride?: string;
     /**
      * Ordered room ids to try when the preferred room is unavailable. This is
@@ -64,4 +50,3 @@ export interface OpenrtcProviderEvents {
     synced: SyncedEventPayload;
     peers: PeersEventPayload;
 }
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "y-openrtc",
-  "version": "0.1.2",
+  "version": "2.0.0-rc.0",
   "private": false,
   "type": "module",
   "sideEffects": false,
@@ -37,13 +37,13 @@
     "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:deterministic": "vitest run tests/TetrisSync.test.ts tests/TetrisPeerDiagnostic.test.ts tests/OpenrtcProvider.test.ts tests/RoomRuntime.test.ts tests/PublicPackageGuard.test.ts tests/crypto.test.ts",
     "test:watch": "vitest",
     "test:live": "vitest run tests/OpenrtcProvider.live.test.ts"
   },
   "dependencies": {
     "lib0": "^0.2.114",
-    "openrtc": "^0.2.0",
+    "openrtc": "2.0.0-rc.0",
     "y-protocols": "^1.0.6"
   },
   "peerDependencies": {