y-openrtc 0.1.0

package/dist/roomName.d.ts

@@ -0,0 +1 @@
+export declare function roomNameToOpenrtcRoomId(roomName: string): Promise<string>;

package/dist/roomName.js

@@ -0,0 +1,34 @@
+const encoder = new TextEncoder();
+function toHex(bytes) {
+    return Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+function fallbackHash(text) {
+    let hashA = 2166136261;
+    let hashB = 2166136261;
+    for (let index = 0; index < text.length; index += 1) {
+        const code = text.charCodeAt(index);
+        hashA ^= code;
+        hashA = Math.imul(hashA, 16777619);
+        hashB ^= code + index;
+        hashB = Math.imul(hashB, 16777619);
+    }
+    const hexA = (hashA >>> 0).toString(16).padStart(8, '0');
+    const hexB = (hashB >>> 0).toString(16).padStart(8, '0');
+    return `${hexA}${hexB}`.repeat(3);
+}
+async function sha256Hex(text) {
+    const subtle = globalThis.crypto?.subtle;
+    if (!subtle) {
+        return fallbackHash(text);
+    }
+    const digest = await subtle.digest('SHA-256', encoder.encode(text));
+    return toHex(new Uint8Array(digest));
+}
+export async function roomNameToOpenrtcRoomId(roomName) {
+    const normalized = roomName.trim();
+    if (!normalized) {
+        throw new Error('roomName must be a non-empty string.');
+    }
+    const hex = await sha256Hex(normalized);
+    return `yjs_${hex.slice(0, 48)}`;
+}

package/dist/runtimePool.d.ts

@@ -0,0 +1,9 @@
+import type { RuntimeClient } from 'openrtc/runtime';
+import type { OpenrtcProviderOptions } from './types.js';
+export interface RuntimeLease {
+    runtime: RuntimeClient;
+    owned: boolean;
+    ensureReady(): Promise<RuntimeClient>;
+    release(): Promise<void>;
+}
+export declare function acquireRuntimeLease(options: OpenrtcProviderOptions): RuntimeLease;

package/dist/runtimePool.js

@@ -0,0 +1,93 @@
+import { OpenRTC } from 'openrtc';
+const ownedRuntimes = new Map();
+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) {
+        startPromise = (async () => {
+            await runtime.initialize();
+            await runtime.start();
+        })();
+        runtimeStartPromises.set(runtime, startPromise);
+    }
+    await startPromise;
+    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);
+    }
+    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();
+        },
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,61 @@
+import type { OpenRTC } 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 interface OpenrtcProviderOptions {
+    apiKey?: string;
+    runtime?: RuntimeClient;
+    authMode?: OpenrtcAuthMode;
+    allowAnonymousHostedDefaults?: OpenrtcAllowAnonymousHostedDefaults;
+    space?: string;
+    spaceKey?: string;
+    spaceTokenProvider?: OpenrtcSpaceTokenProvider;
+    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
+     * useful for public demos where stale durable room members can make one
+     * fixed room appear full until backend cleanup catches up.
+     */
+    roomIdCandidates?: string[];
+    signaling?: string[];
+    peerOpts?: Record<string, unknown>;
+    /**
+     * When true, accept incoming P2P connections from any peer regardless of room
+     * membership. Use this with a custom `runtime` that skips room-based discovery
+     * (e.g. ticket-only / direct-connect mode). Off by default.
+     */
+    acceptAllConnections?: boolean;
+}
+export interface StatusEventPayload {
+    connected: boolean;
+}
+export interface SyncedEventPayload {
+    synced: boolean;
+}
+export interface PeersEventPayload {
+    added: string[];
+    removed: string[];
+    openrtcPeers: string[];
+    webrtcPeers: string[];
+    bcPeers: string[];
+}
+export interface OpenrtcProviderEvents {
+    status: StatusEventPayload;
+    synced: SyncedEventPayload;
+    peers: PeersEventPayload;
+}
+export {};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "y-openrtc",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "sideEffects": false,
+  "description": "A Yjs provider that uses OpenRTC for room membership and peer transport.",
+  "keywords": [
+    "yjs",
+    "crdt",
+    "realtime",
+    "openrtc",
+    "collaboration"
+  ],
+  "author": "Bryant Hargreaves",
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://openrtc.app",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bluestarburst/y-openrtc.git"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run tests",
+    "test:watch": "vitest",
+    "test:live": "OPENRTC_LIVE_TESTS=1 vitest run tests/OpenrtcProvider.live.test.ts"
+  },
+  "dependencies": {
+    "lib0": "^0.2.114",
+    "openrtc": "workspace:*",
+    "y-protocols": "^1.0.6"
+  },
+  "peerDependencies": {
+    "yjs": "^13.6.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "happy-dom": "^20.5.0",
+    "typescript": "^5.8.3",
+    "vitest": "^4.0.18",
+    "yjs": "^13.6.27"
+  }
+}