openrtc 0.1.0 → 0.1.2

package/dist/index.d.ts

@@ -1,3 +1,160 @@
-export { OpenRTC, type OpenRTCClient } from './OpenRTC';
-export { RuntimeClient } from './runtime/RuntimeClient';
-export { RuntimeClient as Client } from './runtime/RuntimeClient';
+import { C as ConnectDeviceResult, a as ConnectDeviceHooks, b as ConnectDeviceOptions, P as PeerSessionSnapshot, R as ResolvedPeerIdentity, c as RuntimeCapabilities, A as AuthContext } from './DelegatingRuntimeAdapter-CW8d78dZ.js';
+export { d as AppLimits, e as AuthMode, f as DiscoveryMode, G as GrantScope, g as ProtocolCapability, h as ProtocolCapabilityMap, i as ProtocolName, j as RuntimeAdapterKind, S as SignalingMode } from './DelegatingRuntimeAdapter-CW8d78dZ.js';
+import { R as RuntimeClientOptions, a as RuntimeClient, b as RuntimeDevice, c as RuntimeDeviceStatusSnapshot, d as RuntimeDeviceConnectOptions, e as RuntimeLocalDeviceInfo, f as RuntimeLocalDeviceProfile, g as RuntimePeerState, h as RuntimePeerConnectOptions, C as Connection, i as RuntimePeerReadinessSnapshot, j as RuntimePeerHealth, k as RuntimeChannelDescriptor, l as RuntimePeerStreamOptions, m as RuntimeIncomingStream, n as RuntimePolicySnapshot, o as RuntimeConnectionStateSnapshot, p as RuntimeConnectionEvent, P as PlutoRuntimeAssembly, q as RuntimeRawConnection } from './factories-0TxDPMeu.js';
+export { r as ChannelDescriptor, s as ConnectionEvent, t as ConnectionTarget, D as DeviceProfile, I as IncomingStream, O as OPENRTC_RUNTIME_POLICY, u as PeerConnectOptions, v as PeerReadiness, w as PeerStreamOptions, x as PresenceLoopOptions, y as RawConnection, z as RuntimeAuthContext, A as RuntimeAuthIdentity, B as RuntimeAutoConnectPolicy, E as RuntimeConnectionTarget, F as RuntimeDeviceStatus, G as RuntimeJoinRoomOptions, H as RuntimeManagedSession, J as RuntimeManagedSessionKind, K as RuntimeManagedSessionOptions, L as RuntimeManagedSessionPlatform, M as RuntimePeerLifecycleStatus, N as RuntimePeerScope, Q as RuntimePeerSessionSnapshot, S as RuntimePresenceLoopOptions, T as RuntimePresencePolicy, U as RuntimeRoomMember, V as RuntimeSession, W as RuntimeUiConnectionStatus, X as ScopedSession, Y as Session, Z as SessionOptions, _ as getRuntimePolicy } from './factories-0TxDPMeu.js';
+import { P as PlutoIpcBridge } from './IpcRuntimeAdapter-CT-W0Mtp.js';
+import './runtime/WasmRuntimeAdapter.js';
+
+interface OpenRTCDeviceNamespace {
+    list(): Promise<RuntimeDevice[]>;
+    listWithStatus(): Promise<RuntimeDeviceStatusSnapshot[]>;
+    watch(callback: (devices: RuntimeDevice[]) => void): () => void;
+    watchWithStatus(callback: (devices: RuntimeDeviceStatusSnapshot[]) => void): () => void;
+    connect(device: string | RuntimeDevice, options?: RuntimeDeviceConnectOptions): Promise<ConnectDeviceResult>;
+    connectWithRetry(device: string | RuntimeDevice, hooks: ConnectDeviceHooks, options: ConnectDeviceOptions): Promise<ConnectDeviceResult>;
+    disconnect(deviceId: string): Promise<void>;
+    update(deviceId: string, updates: {
+        deviceName?: string;
+        capabilities?: RuntimeDevice['capabilities'];
+        metadata?: string;
+    }): Promise<void>;
+    delete(deviceId: string): Promise<void>;
+    localId(): Promise<string | null>;
+    localInfo(): Promise<RuntimeLocalDeviceInfo | null>;
+    localProfile(options?: {
+        deviceName?: string;
+        localDeviceId?: string | null;
+        platform?: 'native' | 'web';
+        userId?: string | null;
+    }): Promise<RuntimeLocalDeviceProfile>;
+    updateLocalName(deviceName: string): Promise<RuntimeLocalDeviceInfo | null>;
+}
+interface OpenRTCPeerNamespace {
+    watch(callback: (peers: RuntimePeerState[]) => void): () => void;
+    get(id: string): RuntimePeerState | undefined;
+    listConnected(): RuntimePeerState[];
+    connect(options: RuntimePeerConnectOptions): Promise<Connection>;
+    disconnect(id: string, scope?: string): Promise<void>;
+    forceDisconnect(id: string): Promise<void>;
+    session(id: string): Promise<PeerSessionSnapshot | null>;
+    sessions(): Promise<PeerSessionSnapshot[]>;
+    waitConnected(id: string, timeoutMs?: number): Promise<PeerSessionSnapshot | null>;
+    readiness(id: string, timeoutMs?: number): Promise<RuntimePeerReadinessSnapshot>;
+    health(id: string): Promise<RuntimePeerHealth>;
+    identity(id: string): Promise<ResolvedPeerIdentity>;
+    addScope(id: string, scope?: string): RuntimePeerState | undefined;
+    releaseScope(id: string, scope?: string): RuntimePeerState | undefined;
+    scopes(id: string): string[];
+    refresh(): Promise<RuntimePeerState[]>;
+}
+interface OpenRTCChannelNamespace {
+    register(descriptor: RuntimeChannelDescriptor): void;
+    unregister(channelId: string): void;
+    list(): RuntimeChannelDescriptor[];
+    openBi(id: string, channelId: string, options?: Omit<RuntimePeerStreamOptions, 'channelId'>): Promise<{
+        connection: Connection;
+        readable: ReadableStream<Uint8Array>;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    openUni(id: string, channelId: string, options?: Omit<RuntimePeerStreamOptions, 'channelId'>): Promise<{
+        connection: Connection;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    onIncoming(callback: (stream: RuntimeIncomingStream) => boolean | void): () => void;
+    onIncomingChannel(channelId: string, callback: (stream: RuntimeIncomingStream & {
+        channel: NonNullable<RuntimeIncomingStream['channel']>;
+    }) => boolean | void): () => void;
+}
+interface OpenRTCDiagnosticsNamespace {
+    status(): Promise<{
+        runtime: 'tauri' | 'browser' | 'unknown';
+        wasmLoaded: boolean;
+        localNodeId?: string;
+        userId?: string;
+    }>;
+    policy(): RuntimePolicySnapshot;
+    capabilities(): RuntimeCapabilities;
+    connectionStates(): Promise<RuntimeConnectionStateSnapshot[]>;
+    onConnectionStateChange(callback: (state: RuntimeConnectionStateSnapshot) => void): Promise<() => void> | (() => void);
+    connections(): Connection[];
+    onConnection(callback: (connection: Connection) => void): () => void;
+    onDisconnection(callback: (connection: Connection) => void): () => void;
+    onConnectionEvent(callback: (event: RuntimeConnectionEvent) => void): () => void;
+    forceReconnectSnapshot(): void;
+}
+interface OpenRTCAdvancedNamespace {
+    readonly runtime: RuntimeClient;
+    readonly assembly: PlutoRuntimeAssembly;
+    nodeId(): Promise<string>;
+    nodeIdFromTicket(ticket: string): Promise<string | null>;
+    endpointTicket(): Promise<string>;
+    connectRaw(target: {
+        ticket: string;
+        timeoutMs?: number;
+    }): Promise<RuntimeRawConnection>;
+    openBi(nodeId: string): Promise<{
+        readable: ReadableStream<Uint8Array>;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    openUni(nodeId: string): Promise<WritableStream<Uint8Array>>;
+    isConnected(nodeId: string): Promise<boolean>;
+    disconnectNode(nodeId: string): Promise<void>;
+    setAutoConnectExcluded(deviceId: string, excluded: boolean): Promise<void>;
+}
+/**
+ * OpenRTCClient extends RuntimeClient with auth helpers that were
+ * previously only available on PlutoRuntimeAssembly.
+ *
+ * This is the unified type returned by OpenRTC() and OpenRTC.native().
+ */
+interface OpenRTCClient extends RuntimeClient {
+    readonly devices: OpenRTCDeviceNamespace;
+    readonly peers: OpenRTCPeerNamespace;
+    readonly channels: OpenRTCChannelNamespace;
+    readonly diagnostics: OpenRTCDiagnosticsNamespace;
+    readonly advanced: OpenRTCAdvancedNamespace;
+    /** @deprecated Use setAuth() instead */
+    setAuthContext(context: AuthContext | null): Promise<void>;
+    /** Set auth context for the runtime */
+    setAuth(context: AuthContext | null): Promise<void>;
+    /** Sync Pluto-hosted auth to the runtime */
+    syncPlutoAuth(options?: {
+        userId?: string | null;
+        forceRefresh?: boolean;
+    }): Promise<void>;
+    /** Bind Pluto auth host to auto-sync on token changes */
+    bindPlutoAuthHost(): () => void;
+    /** Sign in via Pluto SSO */
+    signIn(): Promise<void>;
+    /** Sign out and clear auth context */
+    signOut(): Promise<void>;
+    /**
+     * Access to the underlying PlutoRuntimeAssembly for backward compatibility.
+     * @deprecated Access methods directly on the client instead.
+     */
+    readonly runtime: RuntimeClient;
+    /**
+     * Access to the underlying PlutoRuntimeAssembly for backward compatibility.
+     * @internal
+     */
+    readonly _assembly: PlutoRuntimeAssembly;
+}
+/**
+ * Create an OpenRTC client for browser/WASM environments.
+ *
+ * @example
+ * ```typescript
+ * import { OpenRTC } from 'openrtc';
+ * const client = OpenRTC({ apiKey: 'pk_live_...' });
+ * await client.connect();
+ * ```
+ */
+declare function OpenRTC(options: RuntimeClientOptions): OpenRTCClient;
+declare namespace OpenRTC {
+    var native: (options: RuntimeClientOptions, bridge?: PlutoIpcBridge) => OpenRTCClient;
+}
+
+type UpgradeState = 'none' | 'upgrading' | 'upgraded' | 'failed';
+type OutboundMessage = string | object | ArrayBuffer | Uint8Array;
+
+export { OpenRTC, type OpenRTCClient, RuntimeClientOptions as OpenRTCOptions, type OutboundMessage, RuntimeCapabilities, RuntimeChannelDescriptor, RuntimeClientOptions, RuntimeConnectionEvent, RuntimeConnectionStateSnapshot, RuntimeDevice, RuntimeDeviceConnectOptions, RuntimeDeviceStatusSnapshot, RuntimeIncomingStream, RuntimeLocalDeviceInfo, RuntimeLocalDeviceProfile, RuntimePeerConnectOptions, RuntimePeerHealth, RuntimePeerReadinessSnapshot, RuntimePeerState, RuntimePeerStreamOptions, RuntimePolicySnapshot, RuntimeRawConnection, type UpgradeState };

package/dist/index.js

@@ -1,3 +1 @@
-export { OpenRTC } from './OpenRTC';
-export { RuntimeClient } from './runtime/RuntimeClient';
-export { RuntimeClient as Client } from './runtime/RuntimeClient';
+import {l,m as m$1}from'./chunk-CQAKCS2S.js';export{a as ScopedSession}from'./chunk-CQAKCS2S.js';import'./chunk-D54VGRRH.js';import {a}from'./chunk-DIQYFAGL.js';export{p as OPENRTC_RUNTIME_POLICY,q as getRuntimePolicy}from'./chunk-PZ25OCVG.js';import'./chunk-4MH42GUI.js';function m(t){let n={...t};if("auth"in t&&!t.authMode){let o=t.auth;n.authMode=o==="none"?"anonymous":o;}if("identity"in t&&!t.nodeIdPersistence){let o=t.identity;n.nodeIdPersistence=o==="temporary"?"ephemeral":o;}return "namespace"in t&&!t.storagePrefix&&(n.storagePrefix=t.namespace),"privacy"in t&&t.strictMode===void 0&&(n.strictMode=!!t.privacy),n}function d(t){let n=t.runtime,o=Object.create(n),s=async e=>{if(typeof e!="string")return e;let r=(await n.listDevices()).find(h=>h.deviceId===e);if(!r)throw new Error(`OpenRTC device '${e}' is not currently discoverable.`);return r},c=async e=>({...e,localDeviceId:e?.localDeviceId??await n.getLocalDeviceId()??""}),g={list:()=>n.listDevices(),listWithStatus:()=>n.listDevicesWithStatus(),watch:e=>n.watchDevices(e),watchWithStatus:e=>n.watchDevicesWithStatus(e),connect:async(e,i)=>n.connectDevice(await s(e),await c(i)),connectWithRetry:async(e,i,r)=>n.connectDeviceWithRetry(await s(e),i,r),disconnect:e=>n.disconnectDevice(e),update:(e,i)=>n.updateDevice(e,i),delete:e=>n.deleteDevice(e),localId:()=>n.getLocalDeviceId(),localInfo:()=>n.getLocalDeviceInfo(),localProfile:e=>n.getLocalDeviceProfile(e),updateLocalName:e=>n.updateLocalDeviceName(e)},v={watch:e=>n.watchPeerStates(e),get:e=>n.getPeerState(e),listConnected:()=>n.listConnectedPeers(),connect:e=>n.connectPeer(e),disconnect:(e,i)=>n.disconnectPeer(e,i),forceDisconnect:e=>n.forceDisconnectPeer(e),session:e=>n.getPeerSession(e),sessions:()=>n.listPeerSessions(),waitConnected:(e,i)=>n.waitForConnectedPeer(e,i),readiness:(e,i)=>n.getPeerReadiness(e,i),health:e=>n.getPeerHealth(e),identity:e=>n.resolvePeerIdentity(e),addScope:(e,i)=>n.addPeerScope(e,i),releaseScope:(e,i)=>n.releasePeerScope(e,i),scopes:e=>n.getPeerScopes(e),refresh:()=>n.refreshPeerSnapshot()},C={register:e=>n.registerChannel(e),unregister:e=>n.unregisterChannel(e),list:()=>n.listChannels(),openBi:(e,i,r)=>n.openPeerBi(e,{...r,channelId:i}),openUni:(e,i,r)=>n.openPeerUni(e,{...r,channelId:i}),onIncoming:e=>n.onIncomingStream(e),onIncomingChannel:(e,i)=>n.onIncomingChannelStream(e,r=>{if(r.channel)return i(r)})},R={status:()=>n.getRuntimeStatus(),policy:()=>n.getRuntimePolicy(),capabilities:()=>n.getRuntimeCapabilities(),connectionStates:()=>n.getConnectionStates(),onConnectionStateChange:e=>n.onConnectionStateChange(e),connections:()=>n.getConnections(),onConnection:e=>n.onConnection(e),onDisconnection:e=>n.onDisconnection(e),onConnectionEvent:e=>n.onConnectionEvent(e),forceReconnectSnapshot:()=>n.forceReconnectSnapshot()},P={runtime:n,assembly:t,nodeId:()=>n.getNodeId(),nodeIdFromTicket:e=>n.getNodeIdFromTicket(e),endpointTicket:()=>n.getEndpointTicket(),connectRaw:e=>n.connectRaw(e),openBi:e=>n.openBi(e),openUni:e=>n.openUni(e),isConnected:e=>n.isConnected(e),disconnectNode:e=>n.disconnectNode(e),setAutoConnectExcluded:(e,i)=>n.setAutoConnectExcluded(e,i)};return Object.defineProperties(o,{devices:{get:()=>g,enumerable:true},peers:{get:()=>v,enumerable:true},channels:{get:()=>C,enumerable:true},diagnostics:{get:()=>R,enumerable:true},advanced:{get:()=>P,enumerable:true},setAuth:{value:e=>t.setAuthContext(e),enumerable:true,writable:true,configurable:true},setAuthContext:{value:e=>t.setAuthContext(e),enumerable:true,writable:true,configurable:true},syncPlutoAuth:{value:e=>t.syncPlutoAuth(e),enumerable:true,writable:true,configurable:true},bindPlutoAuthHost:{value:()=>t.bindPlutoAuthHost(),enumerable:true,writable:true,configurable:true},signIn:{value:()=>t.signInWithPluto(),enumerable:true,writable:true,configurable:true},signOut:{value:()=>t.signOut(),enumerable:true,writable:true,configurable:true},runtime:{get:()=>n,enumerable:false},_assembly:{get:()=>t,enumerable:false}}),o}function p(t){let n=m(t),o=l(n);return d(o)}p.native=function(t,n){let o=m(t),s=n??a(),c=m$1(o,s);return d(c)};export{p as OpenRTC};

package/dist/runtime/WasmRuntimeAdapter.d.ts

@@ -1,6 +1,8 @@
-import { type WasmBridgeOptions } from '../core/bridges/WasmBridge';
-import { DelegatingRuntimeAdapter } from './DelegatingRuntimeAdapter';
-export declare class WasmRuntimeAdapter extends DelegatingRuntimeAdapter {
+import { D as DelegatingRuntimeAdapter, W as WasmBridgeOptions } from '../DelegatingRuntimeAdapter-CW8d78dZ.js';
+
+declare class WasmRuntimeAdapter extends DelegatingRuntimeAdapter {
     constructor(options: WasmBridgeOptions);
     setWasmClient(client: unknown): void;
 }
+
+export { WasmRuntimeAdapter };

package/dist/runtime/WasmRuntimeAdapter.js

@@ -1,11 +1 @@
-import { WasmBridge } from '../core/bridges/WasmBridge';
-import { DelegatingRuntimeAdapter } from './DelegatingRuntimeAdapter';
-export class WasmRuntimeAdapter extends DelegatingRuntimeAdapter {
-    constructor(options) {
-        super(new WasmBridge(options));
-    }
-    setWasmClient(client) {
-        const backend = this.unwrap();
-        backend.setWasmClient(client);
-    }
-}
+export{a as WasmRuntimeAdapter}from'../chunk-D54VGRRH.js';import'../chunk-PZ25OCVG.js';import'../chunk-4MH42GUI.js';