openrtc 2.0.0-rc.2 → 2.0.0-rc.4

package/dist/DelegatingRuntimeAdapter-BLNigcS4.d.ts

@@ -0,0 +1,134 @@
+import { D as DiscoveryMode, A as AuthMode, S as SignalingMode, C as ClientOptions, E as ExplicitFileDataSendParams, I as ISignalingBackend, R as RuntimeIdentity, a as RoomMember, b as Device, c as DeviceStatusSnapshot, P as PeerSessionSnapshot, d as ResolvedPeerIdentity, M as ManagedConnectionRecord, e as SignalingEnvelope, f as DeviceEvent, g as DesiredPeerProjection, h as SignalingSession, i as SessionEvent, L as LocalDeviceInfo, N as NativeManagedSessionStartResult, G as GrantScope, B as BackendPeerBiStream, j as BackendPeerUniStream, k as NativeConnectParams, l as NativeConnectResult, m as BackendConnectionState } from './types-BHePJWbM.js';
+import { A as AuthContext } from './IEngineBridge-BbsT8hof.js';
+import { R as RuntimeCapabilities } from './capabilities-YSskrE8H.js';
+
+interface WasmBridgeOptions {
+    apiKey?: string;
+    discoveryMode?: DiscoveryMode;
+    space?: string;
+    spaceKey?: string;
+    authMode?: AuthMode;
+    signalingMode?: SignalingMode;
+    projectId?: string;
+    coordinationGateway?: ClientOptions['coordinationGateway'];
+    coordinationAvenueOverride?: ClientOptions['coordinationAvenueOverride'];
+    platformAttestationTokenProvider?: ClientOptions['platformAttestationTokenProvider'];
+    /** Internal host hint used by the provider-neutral gateway projection. */
+    coordinationPlatformType?: 'web' | 'desktop' | 'mobile';
+    storagePrefix?: string;
+    deviceIdPersistence?: 'persistent' | 'ephemeral';
+    endpointIdPersistence?: 'persistent' | 'ephemeral';
+    nodeIdPersistence?: 'persistent' | 'ephemeral';
+    localDeviceId?: string;
+    deviceName?: string;
+    turnCredentialsProvider?: () => Promise<{
+        iceServers?: RTCIceServer[];
+    } | null | undefined>;
+    applicationCrypto?: ExplicitFileDataSendParams['applicationCrypto'];
+    spaceAuth?: 'scoped-token';
+}
+
+declare abstract class DelegatingRuntimeAdapter implements ISignalingBackend {
+    protected readonly backend: ISignalingBackend;
+    protected constructor(backend: ISignalingBackend);
+    get currentUser(): RuntimeIdentity | null;
+    setAuthContext(context: AuthContext | null): Promise<void> | void;
+    signInAnonymously(): Promise<void>;
+    signInWithPluto(): Promise<void>;
+    signOut(): Promise<void>;
+    stopAuthScopedActivity(): Promise<void>;
+    usesCoordinationGateway(): boolean;
+    joinCoordinationRoom(roomId: string, nodeId: string, ticket: string): Promise<void>;
+    leaveCoordinationRoom(roomId: string): Promise<void>;
+    getCoordinationRoomMembers(roomId: string): Promise<RoomMember[]>;
+    watchCoordinationRoomMembers(roomId: string, callback: (members: RoomMember[]) => void): () => void;
+    getTurnCredentials(): Promise<any>;
+    updatePresence(localNodeId: string, ticketStr: string, isOnline: boolean, ttlMs: number, metadata?: string): Promise<void>;
+    refreshLivePresence(localNodeId: string, ticketStr: string, metadata?: string): Promise<void>;
+    setOffline(localNodeId: string): Promise<void>;
+    cleanupStaleDevices(): Promise<void>;
+    searchDevices(excludeNodeId?: string): Promise<Device[]>;
+    listDevicesWithStatus(): Promise<DeviceStatusSnapshot[]>;
+    getPeerSession(id: string): Promise<PeerSessionSnapshot | null>;
+    listPeerSessions(): Promise<PeerSessionSnapshot[]>;
+    waitForSettledPeer(id: string, timeoutMs?: number): Promise<PeerSessionSnapshot | null>;
+    resolvePeerIdentity(id: string): Promise<ResolvedPeerIdentity>;
+    resolvePeerConnectionRecords(id: string): Promise<ManagedConnectionRecord[]>;
+    updateDevice(deviceId: string, updates: {
+        deviceName?: string;
+        capabilities?: Device['capabilities'];
+        metadata?: string;
+    }): Promise<void>;
+    deleteDevice(deviceId: string): Promise<void>;
+    onDevicesChange(callback: (devices: Device[]) => void, excludeNodeId?: string): () => void;
+    onAuthChange(callback: (user: RuntimeIdentity | null) => void): () => void;
+    checkForSSOToken(): Promise<void>;
+    waitForAuth(): Promise<void>;
+    sendMessage(targetId: string, payload: string, state?: string, replyPayload?: string): Promise<string>;
+    pollMessages(targetId: string): Promise<SignalingEnvelope[]>;
+    watchFriendDevices(friendUserIds: string[], callback: (friendDevices: Map<string, Device[]>) => void): () => void;
+    updateFriendTicket(friendTicket: string | null): Promise<void>;
+    subscribeDevices(userId: string): Promise<ReadableStream<DeviceEvent[]>>;
+    startAutoConnect(userId: string, localDeviceId: string): void;
+    submitDesiredPeerProjection(revision: number, peers: DesiredPeerProjection[]): Promise<void>;
+    startPresenceLoop(userId: string, localNodeId: string, deviceName: string, ticket: string, metadata?: string): void;
+    createSession(session: SignalingSession): Promise<void>;
+    updateSession(sessionId: string, updateData: any): Promise<void>;
+    subscribeSessions(localDeviceId: string): Promise<ReadableStream<SessionEvent[]>>;
+    forceReconnectSnapshot(): void;
+    getLocalDeviceId(): Promise<string | null>;
+    getLocalDeviceInfo(): Promise<LocalDeviceInfo | null>;
+    updateLocalDeviceName(deviceName: string): Promise<LocalDeviceInfo | null>;
+    startManagedSessionNative(options: {
+        userId: string;
+        deviceName?: string;
+        localDeviceId?: string | null;
+        metadata?: string;
+        autoConnect?: boolean;
+        presence?: boolean;
+    }): Promise<NativeManagedSessionStartResult>;
+    notifyNetworkChange(options?: {
+        reason?: string;
+    }): Promise<unknown>;
+    getManagedNodeId(options?: {
+        initializeIfMissing?: boolean;
+    }): Promise<string | null>;
+    startPresenceLoopOnce(userId: string, localNodeId: string, deviceName: string, ticket: string, metadata?: string): Promise<void>;
+    startAutoConnectOnce(userId: string, localDeviceId: string): Promise<void>;
+    getEndpointTicket(): Promise<string>;
+    getEndpointTicketWithToken(scope: GrantScope, maxConnections: number): Promise<string | null>;
+    registerSessionToken(token: string, scope: GrantScope, maxConnections: number): Promise<void>;
+    revokeSessionTokensByScope(scope: GrantScope): Promise<string[]>;
+    openPeerBi(id: string, timeoutMs?: number): Promise<BackendPeerBiStream>;
+    incoming_streams(): Promise<ReadableStream<unknown>>;
+    is_current_transport_stable_id(endpointId: string, transportStableId: bigint): Promise<boolean>;
+    openPeerNativeBi(id: string, label: string, timeoutMs?: number): Promise<BackendPeerBiStream>;
+    openPeerBiTransportOnly(id: string, timeoutMs?: number): Promise<BackendPeerBiStream>;
+    openPeerUni(id: string, timeoutMs?: number): Promise<BackendPeerUniStream>;
+    connectToDevice(params: NativeConnectParams): Promise<NativeConnectResult>;
+    disconnectDevice(deviceId: string): Promise<void>;
+    setAutoConnectExcluded(deviceId: string, excluded: boolean): Promise<void>;
+    isConnected(nodeId: string): Promise<boolean>;
+    getConnectionStates(): Promise<BackendConnectionState[]>;
+    onConnectionStateChange(callback: (state: BackendConnectionState) => void): Promise<() => void> | (() => void);
+    /** @deprecated Use named channels or `openrtc-file-transfer`. */
+    sendExplicitFilePath(connectionId: string, filePath: string, transferId?: string): Promise<string>;
+    /** @deprecated Use named channels or `openrtc-file-transfer`. */
+    sendExplicitFileData(params: ExplicitFileDataSendParams): Promise<void>;
+    /** @deprecated Transfer history belongs to the consumer application. */
+    getTransferHistory(limit?: number): Promise<Array<[string, unknown]>>;
+    /** @deprecated Transfer history belongs to the consumer application. */
+    deleteTransferJob(jobId: string): Promise<void>;
+    getRuntimeCapabilities(): RuntimeCapabilities;
+    onIncomingNativeMessage(callback: (connectionId: string, remoteNodeId: string | null, message: any) => void): Promise<() => void>;
+    unwrap(): ISignalingBackend;
+    /**
+     * Forward setCoreClient() to the inner backend if it implements it. This
+     * lets the core Client inject a reference into backends (e.g. WasmBridge)
+     * that need to escalate transport-level dials into full Client.connect()
+     * handshakes.
+     */
+    setCoreClient(client: unknown): void;
+}
+
+export { DelegatingRuntimeAdapter as D, type WasmBridgeOptions as W };

package/dist/{OpenRTCShared-ZQPu5LqL.d.ts → OpenRTCShared-BswnbjpG.d.ts}

@@ -1,6 +1,6 @@
-import { H as GrantScope, q as ISignalingBackend, Y as ConnectDeviceHooks, Z as ConnectDeviceOptions, _ as ConnectDeviceResult, u as ManagedConnectionRecord, m as PeerSessionSnapshot, v as ResolvedPeerIdentity, $ as AppLimits, N as NativeConnectParams, z as NativeConnectResult, E as ExplicitFileDataSendParams } from './types-BVJr065k.js';
+import { G as GrantScope, I as ISignalingBackend, X as ConnectDeviceHooks, Y as ConnectDeviceOptions, Z as ConnectDeviceResult, M as ManagedConnectionRecord, P as PeerSessionSnapshot, d as ResolvedPeerIdentity, _ as AppLimits, k as NativeConnectParams, l as NativeConnectResult, E as ExplicitFileDataSendParams } from './types-BHePJWbM.js';
 import { A as AuthContext } from './IEngineBridge-BbsT8hof.js';
-import { b as RuntimePeerState, c as RuntimeConnectionStateSnapshot, d as RuntimePeerReadinessSnapshot, e as RuntimePeerConnectOptions, C as Connection, f as RuntimeIncomingStream, a as RuntimeClientOptions, g as RuntimeAuthIdentity, h as RuntimeLocalDeviceInfo, i as RuntimeLocalDeviceProfile, j as RuntimeDevice, k as RuntimeManagedSessionOptions, l as RuntimeManagedSession, m as RuntimeDeviceStatusSnapshot, n as RuntimeDeviceConnectOptions, o as RuntimeSession, p as RuntimeJoinRoomOptions, q as RuntimeRoomMember, r as RuntimeConnectionTarget, s as RuntimeScopedChannelOptions, t as RuntimeScopedLogicalChannel, u as RuntimePeerStreamOptions, v as RuntimeRawConnection, R as RuntimeChannelDescriptor, w as RuntimePresenceLoopOptions, x as RuntimePeerHealth, y as RuntimeApplicationPayloadReadinessOptions, z as RuntimeConnectionEvent } from './types-DkgaCyqS.js';
+import { b as RuntimePeerState, c as RuntimeConnectionStateSnapshot, d as RuntimePeerReadinessSnapshot, e as RuntimePeerConnectOptions, C as Connection, f as RuntimeIncomingStream, a as RuntimeClientOptions, g as RuntimeAuthIdentity, h as RuntimeLocalDeviceInfo, i as RuntimeLocalDeviceProfile, j as RuntimeDevice, k as RuntimeManagedSessionOptions, l as RuntimeManagedSession, m as RuntimeDeviceStatusSnapshot, n as RuntimeDeviceConnectOptions, o as RuntimeSession, p as RuntimeJoinRoomOptions, q as RuntimeRoomMember, r as RuntimeConnectionTarget, s as RuntimeScopedChannelOptions, t as RuntimeScopedLogicalChannel, u as RuntimePeerStreamOptions, v as RuntimeRawConnection, R as RuntimeChannelDescriptor, w as RuntimePresenceLoopOptions, x as RuntimePeerHealth, y as RuntimeApplicationPayloadReadinessOptions, z as RuntimeConnectionEvent } from './types-D0pqNSOf.js';
 import { R as RuntimeCapabilities, a as RuntimeCapabilityProfile } from './capabilities-YSskrE8H.js';
 
 /**
@@ -675,7 +675,6 @@ declare class RuntimeClient {
 type RuntimeAdapterWithAuth = ISignalingBackend & {
     setAuthContext?: (context: AuthContext | null) => Promise<void> | void;
 };
-type RuntimeFactoryOptions = RuntimeClientOptions;
 interface PlutoRuntimeAssembly<TBackend extends RuntimeAdapterWithAuth = RuntimeAdapterWithAuth> {
     runtime: RuntimeClient;
     identity: any;
@@ -942,4 +941,4 @@ interface OpenRTCClient extends RuntimeClient {
     readonly _assembly: PlutoRuntimeAssembly;
 }
 
-export { DriveGrantActorError as D, type OpenRTCPeerNamespace as O, type PlutoRuntimeAssembly as P, type RuntimeFactoryOptions as R, type OpenRTCChannelNamespace as a, type OpenRTCDiagnosticsNamespace as b, type OpenRTCDeviceNamespace as c, type OpenRTCClient as d, type PeerReconciliationStats as e, OPENRTC_RUNTIME_POLICY as f, RuntimeClient as g, type RuntimePolicySnapshot as h, type DriveGrantActorErrorKind as i, DriveGrantActorHandle as j, type DriveGrantActorHandleOptions as k, DriveGrantActorRegistry as l, type DriveGrantActorState as m, type DriveGrantClose as n, type DriveGrantDial as o, type DriveGrantConnectionKey as p, type DriveGrantLogicalChannelHandle as q, type DriveGrantPreferredTransport as r, getRuntimePolicy as s, driveGrantConnectionKey as t, driveGrantConnectionKeyToString as u };
+export { DriveGrantActorError as D, type OpenRTCPeerNamespace as O, type PeerReconciliationStats as P, RuntimeClient as R, type OpenRTCChannelNamespace as a, type OpenRTCDiagnosticsNamespace as b, type OpenRTCDeviceNamespace as c, type OpenRTCClient as d, OPENRTC_RUNTIME_POLICY as e, type RuntimePolicySnapshot as f, type DriveGrantActorErrorKind as g, DriveGrantActorHandle as h, type DriveGrantActorHandleOptions as i, DriveGrantActorRegistry as j, type DriveGrantActorState as k, type DriveGrantClose as l, type DriveGrantDial as m, type DriveGrantConnectionKey as n, type DriveGrantLogicalChannelHandle as o, type DriveGrantPreferredTransport as p, getRuntimePolicy as q, driveGrantConnectionKey as r, driveGrantConnectionKeyToString as s };

package/dist/chunk-6OLYXEOG.js

@@ -0,0 +1 @@
+import {a as a$1}from'./chunk-GHGHBGHY.js';import {a as a$2}from'./chunk-XPEDISSU.js';import {f}from'./chunk-F2XGNLXL.js';import {c}from'./chunk-RD3JEGGF.js';var s=false;function a(){s||(s=true,a$2(async()=>{let t=await import('./openrtc-UU4BBJLG.js');return {initWasm:t.default,WasmClient:t.WasmClient,start:t.start}}));}async function d(t){a();let e=c(t),{WasmBridge:i}=await import('./WasmBridge-2A22U7RU.js');return a$1(e,new i(e))}function y(t,e){let i=c(t);return a$1(i,new f({...i,bridge:e}))}export{d as a,y as b};

package/dist/chunk-GHGHBGHY.js

@@ -0,0 +1 @@
+import {t}from'./chunk-XPEDISSU.js';import {b}from'./chunk-N26S7V4N.js';function v(i,d){let t$1=new t(i,d),a=i.spaceKey??i.space,l=(i.discoveryMode===void 0||i.discoveryMode==="space")&&typeof i.apiKey=="string"&&i.apiKey.trim().length>0&&typeof a=="string"&&a.trim().length>0,s={runtime:t$1,async setAuthContext(e){await t$1.setAuthContext(e);},async syncPlutoAuth(e){if(l)return;let n=b(),c=n.getCurrentUser(),r=(typeof e?.userId=="string"?e.userId.trim():"")||c?.uid||null;if(!r){await s.setAuthContext(null);return}let h=await n.getIdToken({forceRefresh:e?.forceRefresh??false}).catch(()=>null),m=n.getCurrentUser()?.refreshToken??null,g=n.getCurrentUser()?.stsTokenManager?.expirationTime??null;await s.setAuthContext({userId:r,token:h,refreshToken:m,tokenProvider:async y=>n.getIdToken({forceRefresh:y??false}),expiresAtMs:g});},bindPlutoAuthHost(){let e=b();return s.syncPlutoAuth({userId:e.getCurrentUser()?.uid??null,forceRefresh:false}),e.onIdTokenChanged(n=>{s.syncPlutoAuth({userId:n?.uid??null,forceRefresh:false});})},signInWithPluto:()=>t$1.signInWithPluto(),signOut:()=>t$1.signOut(),stopManagedSession:()=>t$1.stopManagedSession(),startManagedSession:e=>t$1.startManagedSession(e),onAuthChange:e=>t$1.onIdentityChange(e),getManagedNodeId:e=>t$1.getManagedNodeId(e),getRuntimeStatus:()=>t$1.getRuntimeStatus(),listDevicesWithStatus:()=>t$1.listDevicesWithStatus(),watchDevicesWithStatus:e=>t$1.watchDevicesWithStatus(e),connectDevice:(e,n)=>t$1.connectDevice(e,n),setAutoConnectExcluded:(e,n)=>t$1.setAutoConnectExcluded(e,n)};return Object.defineProperty(s,"identity",{get:()=>t$1.identity,enumerable:true}),s}export{v as a};

package/dist/chunk-HXMHYSZF.js

@@ -0,0 +1 @@
+import {a}from'./chunk-GHGHBGHY.js';import {f}from'./chunk-F2XGNLXL.js';import {c}from'./chunk-RD3JEGGF.js';function s(i,r){let t=c(i);return a(t,new f({...t,bridge:r}))}export{s as a};

package/dist/{chunk-IEQTFQ3Q.js → chunk-PRBVSCKN.js}

@@ -1 +1 @@
-import {b as b$1,a as a$2}from'./chunk-2QHDEGVX.js';import {a as a$3}from'./chunk-6TAVJ46R.js';import {b}from'./chunk-N4SX7C3W.js';import {a as a$1}from'./chunk-YQWQDTQ3.js';import {d}from'./chunk-K37WVIZL.js';import {a}from'./chunk-N26S7V4N.js';async function c(t){return a(b),b$1(await a$1(a$2(t)),"web")}c.native=function(t,a$1=d()){return a(b),b$1(a$3(a$2(t),a$1),"native")};export{c as a};
+import {b as b$1,a as a$2}from'./chunk-2QHDEGVX.js';import {a as a$1}from'./chunk-6OLYXEOG.js';import {a as a$3}from'./chunk-HXMHYSZF.js';import {b}from'./chunk-N4SX7C3W.js';import {d}from'./chunk-K37WVIZL.js';import {a}from'./chunk-N26S7V4N.js';async function c(t){return a(b),b$1(await a$1(a$2(t)),"web")}c.native=function(t,a$1=d()){return a(b),b$1(a$3(a$2(t),a$1),"native")};export{c as a};