y-openrtc 1.0.0 → 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.

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.js

@@ -264,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();

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": "1.0.0",
+  "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": "^1.0.0",
+    "openrtc": "2.0.0-rc.0",
     "y-protocols": "^1.0.6"
   },
   "peerDependencies": {