openrtc 0.1.0

package/dist/auth/internal.d.ts

@@ -0,0 +1 @@
+export { registerDesktopAuthRelay } from './host';

package/dist/auth/internal.js

@@ -0,0 +1 @@
+export { registerDesktopAuthRelay } from './host';

package/dist/compat/index.d.ts

@@ -0,0 +1,20 @@
+export * from '../core/Client';
+export * from '../core/PlutoRTC';
+export * from '../core/IEngineBridge';
+export * from '../core/Connection';
+export * from '../core/Signaling';
+export * from '../core/Room';
+export * from '../core/types';
+export * from '../core/transports/TransportFactory';
+export * from '../transports/WebTransport';
+export * from '../transports/TauriTransport';
+export * from '../core/bridges/TauriBridge';
+export * from '../core/bridges/WasmBridge';
+export * from '../api/PlutoWebSocket';
+export * from '../api/PlutoWebTransport';
+export * from '../api/PlutoPeerConnection';
+export * from '../moq/MoQSession';
+export * from '../moq/MoQPublisher';
+export * from '../moq/MoQSubscriber';
+export * from '../moq/MoQMediaTransport';
+export { BufferReader, StreamBuffer, BufferWriter, Mutex } from '../moq/common';

package/dist/compat/index.js

@@ -0,0 +1,20 @@
+export * from '../core/Client';
+export * from '../core/PlutoRTC';
+export * from '../core/IEngineBridge';
+export * from '../core/Connection';
+export * from '../core/Signaling';
+export * from '../core/Room';
+export * from '../core/types';
+export * from '../core/transports/TransportFactory';
+export * from '../transports/WebTransport';
+export * from '../transports/TauriTransport';
+export * from '../core/bridges/TauriBridge';
+export * from '../core/bridges/WasmBridge';
+export * from '../api/PlutoWebSocket';
+export * from '../api/PlutoWebTransport';
+export * from '../api/PlutoPeerConnection';
+export * from '../moq/MoQSession';
+export * from '../moq/MoQPublisher';
+export * from '../moq/MoQSubscriber';
+export * from '../moq/MoQMediaTransport';
+export { BufferReader, StreamBuffer, BufferWriter, Mutex } from '../moq/common';

package/dist/core/Client.d.ts

@@ -0,0 +1,352 @@
+import { Connection } from './Connection';
+import { Signaling } from './Signaling';
+import { RoomManager } from './Room';
+import { MoQSession } from '../moq/MoQSession';
+import { MoQPublisher } from '../moq/MoQPublisher';
+import { MoQSubscriber } from '../moq/MoQSubscriber';
+export interface BiStream {
+    send: WritableStream<Uint8Array>;
+    recv: ReadableStream<Uint8Array>;
+    endpoint_id: string;
+}
+export interface IncomingStream {
+    type: 'bi' | 'uni';
+    stream: BiStream | ReadableStream<Uint8Array>;
+    endpointId: string;
+}
+type IncomingProtocolHint = 'control' | 'explicit' | 'native-main' | 'unknown';
+type IncomingStreamListenerEvent = {
+    type: 'bi' | 'uni';
+    stream: any;
+    remoteNodeId: string;
+    protocolHint?: IncomingProtocolHint;
+    channel?: import('./types').IncomingStreamChannelMetadata | null;
+    invalid?: boolean;
+};
+import { type AppLimits, ClientOptions, JoinRequest, ScanningLoopOptions, ScanningLoopHandle, Device, ConnectDeviceHooks, ConnectDeviceOptions, ConnectDeviceResult, ChannelDescriptor, RuntimeBootstrapOptions, RuntimeBootstrapResult, DiscoveryMode, PeerHealth, PeerScope, PeerState, RoomCreationMode } from './types';
+export declare class Client {
+    private static readonly CHANNEL_ENVELOPE_MAGIC;
+    private static readonly CHANNEL_ENVELOPE_VERSION;
+    private static readonly CHANNEL_ENVELOPE_HEADER_BYTES;
+    private static readonly EXPLICIT_PROTOCOL_BYTE;
+    private static readonly NATIVE_MAIN_PROTOCOL_BYTE;
+    private static readonly NATIVE_MAIN_LABEL;
+    private static readonly NATIVE_MAIN_MAX_LABEL_BYTES;
+    private static readonly NATIVE_MAIN_PROTOCOL_VERSION;
+    private static readonly CONNECTION_STATE_CHANGED_EVENT;
+    private static readonly INCOMING_STREAM_RETRY_MIN_DELAY_MS;
+    private static readonly INCOMING_STREAM_RETRY_MAX_DELAY_MS;
+    private static readonly DEFAULT_PEER_CHANNEL_ID;
+    private static readonly SHARE_FILE_CHANNEL_ID;
+    private static readonly SHARE_CONTROL_CHANNEL_ID;
+    private static readonly incomingStreamHubs;
+    signaling: Signaling;
+    rooms: RoomManager;
+    private wasmLoaded;
+    wasmClient: any;
+    private initPromise;
+    node: any;
+    private connections;
+    private connectionListeners;
+    private disconnectionListeners;
+    private messageListeners;
+    private roomRequestListeners;
+    private streamListeners;
+    private readonly channelStreamListeners;
+    private readonly registeredChannels;
+    private announcedConnections;
+    private readonly peerLifecycle;
+    private readonly knownDevicesById;
+    private readonly knownDeviceIdsByNodeId;
+    private readonly connectionTrustStates;
+    private readonly connectionChannelIds;
+    private managedPresenceGrant;
+    /** Token extracted from a compound ticket during connect(), keyed by remote node ID. */
+    private readonly pendingTokenByNodeId;
+    private localNodeId;
+    private listening;
+    private listenLoopTask;
+    private options;
+    appLimits: AppLimits;
+    private pendingConnection;
+    private authSyncUnsubscribe;
+    private backendConnectionStateUnsubscribe;
+    private authRefreshInterval;
+    private deviceId;
+    private lastWasmAuthSyncUserId;
+    private lastWasmAuthSyncToken;
+    private static readonly CONNECTION_STABLE_WINDOW_MS;
+    private static readonly CONNECTION_STABLE_TIMEOUT_MS;
+    private static readonly CONNECTION_STABLE_POLL_MS;
+    private presenceInterval;
+    private hostedAppSettingsLoaded;
+    private effectiveRoomBackendTag;
+    private _moqSession;
+    private _moqState;
+    private moqReadyListeners;
+    private moqFailedListeners;
+    private moqObjectListeners;
+    roomCreationMode: RoomCreationMode;
+    constructor(options: ClientOptions);
+    private sleep;
+    get apiKey(): string | undefined;
+    get discoveryMode(): DiscoveryMode;
+    private usesTicketOnlySignalingMode;
+    usesDirectRoomBackend(): boolean;
+    getRoomBackendTag(): string;
+    refreshHostedAppSettings(force?: boolean): Promise<void>;
+    setSignalingBackend(backend: import('./types').ISignalingBackend): void;
+    get currentUser(): import("./types").RuntimeIdentity | null;
+    onAuthChange(callback: (user: any) => void): () => void;
+    signInAnonymously(): Promise<void>;
+    signInWithPluto(): Promise<void>;
+    signOut(): Promise<void>;
+    getSignalingTelemetry(): {
+        transport: string;
+        wasmLoaded: boolean;
+    };
+    getProtocolCapabilities(): import("./types").ProtocolCapabilityMap;
+    getRuntimeStatus(): Promise<{
+        runtime: 'tauri' | 'browser' | 'unknown';
+        wasmLoaded: boolean;
+        localNodeId?: string;
+        userId?: string;
+    }>;
+    private ensureWasmRuntimeForP2P;
+    private ensureSignalingReadyForDiscovery;
+    private requiresManagedTransportTrust;
+    private getRegisteredChannel;
+    private isChannelPromotionEligible;
+    private getConnectionChannelId;
+    private resolvePromotionEligibility;
+    private assignConnectionChannel;
+    private rememberKnownDevice;
+    private getKnownDevice;
+    private refreshKnownDeviceCache;
+    private initializeConnectionTrust;
+    private getConnectionTrustState;
+    private getConnectionTrustProjection;
+    private applyConnectionTrustProjection;
+    private buildLocalTransportTrustPayload;
+    private sendTransportHandshake;
+    private verifyRemoteTransportTrust;
+    private enforceConnectionTrustFailure;
+    private markConnectionTrustVerified;
+    searchDevices(): Promise<Device[]>;
+    updateDevice(deviceId: string, updates: {
+        deviceName?: string;
+        capabilities?: Device['capabilities'];
+        metadata?: string;
+    }): Promise<void>;
+    deleteDevice(deviceId: string): Promise<void>;
+    onDevicesChange(callback: any): () => void;
+    subscribeSessions(localDeviceId: string, callback: (session: import('./types').SignalingSession) => void): Promise<() => void>;
+    startScanningLoop(options: ScanningLoopOptions): Promise<ScanningLoopHandle>;
+    connectDeviceWithRetry(device: Device, hooks: ConnectDeviceHooks, options: ConnectDeviceOptions): Promise<ConnectDeviceResult>;
+    bootstrapRuntime(options: RuntimeBootstrapOptions): Promise<RuntimeBootstrapResult>;
+    updateTransportConfig(transports: ClientOptions['transports']): void;
+    /**
+     * Bootstraps the WASM module and Rust signaling.
+     * Must be called before connect or createRoom.
+     */
+    init(): Promise<void>;
+    ensureAuthenticated(reason: 'init' | 'room-op' | 'discovery'): Promise<void>;
+    private installAuthTokenSync;
+    private syncAuthTokenToWasm;
+    get moqState(): "connecting" | "failed" | "none" | "ready";
+    get moq(): {
+        session: MoQSession;
+        publisher: MoQPublisher;
+        subscriber: MoQSubscriber;
+    } | null;
+    onMoQReady(cb: () => void): void;
+    onMoQFailed(cb: () => void): void;
+    onMoQObject(callback: (ns: string, name: string, obj: Uint8Array, meta: any) => void): void;
+    private initMoQ;
+    connect(ticket: string, timeoutMs?: number, expectedDeviceId?: string | null, channelId?: string): Promise<Connection>;
+    /**
+     * Low-level dial helper.
+     * Ensures the ticket is connected and returns only connection identity metadata.
+     */
+    connectRaw(ticket: string, timeoutMs?: number): Promise<{
+        connectionId: string;
+        localNodeId: string;
+        remoteNodeId: string;
+    }>;
+    /**
+     * Start core-managed auto-connect for the authenticated user.
+     * This is intentionally low-level: callers decide when to start/stop and
+     * what higher-level protocol to run on top of the resulting connection.
+     */
+    startAutoConnect(localDeviceId?: string): Promise<void>;
+    openBi(peerId: string): Promise<{
+        readable: ReadableStream<Uint8Array>;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    openUni(peerId: string): Promise<WritableStream<Uint8Array>>;
+    getConnections(): Connection[];
+    watchPeerStates(callback: (peers: PeerState[]) => void): () => void;
+    getPeerState(id: string): PeerState | undefined;
+    listConnectedPeers(): PeerState[];
+    isPeerPromotionEligible(identifiers: {
+        connectionId?: string | null;
+        deviceId?: string | null;
+        deviceIdHint?: string | null;
+        nodeId?: string | null;
+    }): boolean;
+    addPeerScope(id: string, scope?: PeerScope): PeerState | undefined;
+    releasePeerScope(id: string, scope?: PeerScope): PeerState | undefined;
+    getPeerScopes(id: string): PeerScope[];
+    isSamePeer(a: string, b: string): boolean;
+    refreshPeerSnapshot(): Promise<PeerState[]>;
+    connectPeer(options: {
+        deviceId?: string;
+        ticket?: string;
+        scope?: PeerScope;
+        channelId?: string;
+    }): Promise<Connection>;
+    disconnectPeer(id: string, scope?: PeerScope): Promise<void>;
+    forceDisconnectPeer(id: string): Promise<void>;
+    getPeerHealth(id: string): Promise<PeerHealth>;
+    private mapRustPeerStatus;
+    private mapRustPeerHealth;
+    getTicket(): Promise<string>;
+    getNodeId(): Promise<string>;
+    getNodeIdFromTicket(ticket: string): Promise<string | null>;
+    /**
+     * Generate a random session token, register it, and return a compound
+     * ticket string with the token suffix appended.
+     *
+     * @param scope      Logical label (e.g. "share"). Used for bulk-revoke.
+     * @param maxConnections  0 = unlimited.
+     */
+    getEndpointTicketWithToken(grantScope: string, maxConnections?: number): Promise<string>;
+    /**
+     * Build a compound ticket from an externally-provided iroh ticket string.
+     * Generates a session token, registers it with the Rust wasm client when available,
+     * and appends the token
+     * payload as a base64url suffix separated by `.`.
+     *
+     * Used by RuntimeClient.getTicketWithToken() on native desktop where the
+     * iroh ticket comes from the Rust backend (via Tauri IPC) rather than the
+     * WASM node running in the webview.
+     */
+    buildCompoundTicketWithToken(irohTicket: string, grantScope: string, maxConnections?: number): string;
+    setManagedPresenceTicket(ticket: string | null): void;
+    clearManagedPresenceTicket(): void;
+    /** Register an externally-generated session token with the Rust wasm client. */
+    registerSessionToken(token: string, grantScope: string, maxConnections: number): void;
+    /** Revoke a specific session token. */
+    revokeSessionToken(token: string): void;
+    /** Revoke all tokens that match the given scope. */
+    revokeTokensByScope(grantScope: string): Promise<string[]>;
+    private static generateSessionToken;
+    private static encodeSessionTokenPayload;
+    private static buildCompoundTicketWithPayload;
+    clearSessionTokens(): Promise<void>;
+    private resolvePresenceTicket;
+    private refreshManagedPresenceTicketIfNeeded;
+    private validateIncomingSessionToken;
+    /**
+     * Start the signaling-backed presence loop owned by the Rust core.
+     * A ticket can be provided explicitly, otherwise the current endpoint ticket is used.
+     */
+    startPresenceLoop(options?: {
+        deviceName?: string;
+        ticket?: string;
+        metadata?: string;
+    }): Promise<void>;
+    /**
+     * Mark local presence offline in the signaling backend.
+     */
+    setOffline(): Promise<void>;
+    /**
+     * Check raw connectivity against a remote node id.
+     */
+    isConnected(nodeId: string): Promise<boolean>;
+    /**
+     * Disconnect a remote node from the local connection manager.
+     */
+    disconnectNode(nodeId: string): Promise<void>;
+    getLocalDeviceId(): Promise<string | null>;
+    /**
+     * Route a raw message received on a native iroh connection through token
+     * validation. Called by RuntimeClient when NativeIpcBridge fires an
+     * `iroh://message` event for an incoming native connection.
+     *
+     * If we have a TS Connection object for this peer (e.g. the client also
+     * called connect()), route through handleMessage. Otherwise, for connections
+     * that were accepted purely by the Rust protocol handler, perform token
+     * validation directly.
+     *
+     * @returns true if the connection should be rejected (caller should disconnect)
+     */
+    acceptNativeMessage(connectionId: string | null, remoteNodeId: string | null, msg: any): Promise<boolean>;
+    startListening(): Promise<void>;
+    stopListening(): void;
+    private getSharedIncomingStreamHub;
+    private nextIncomingStreamRetryDelayMs;
+    /**
+     * Force an immediate presence update and reconnect snapshot.
+     */
+    forceReconnectSnapshot(): void;
+    private updatePresenceInternal;
+    private listenLoop;
+    private prependChunkToReadable;
+    private cancelUnhandledIncomingUniStream;
+    private prependBytesToReader;
+    private concatBytes;
+    private encodeChannelEnvelope;
+    wrapChannelWritable(writable: WritableStream<Uint8Array>, channelId: string, metadata?: Record<string, unknown> | null): WritableStream<Uint8Array>;
+    private extractIncomingChannelEnvelope;
+    private isBiStreamLike;
+    private materializeIncomingBiStream;
+    private rebuildBiIncomingStream;
+    private classifyBiIncomingStream;
+    private detectNativeMainStream;
+    private resolveLocalHandshakePayload;
+    private getDeterministicConnectionId;
+    private getNativeMainConnectionId;
+    private hasRustPeerLifecycleProjection;
+    private shouldProjectNativeMainLifecycle;
+    private emitNativeMainConnectionState;
+    private applyBackendConnectionState;
+    private encodeNativeMainFrame;
+    private writeNativeMainMessage;
+    private handleNativeHandshakeRequest;
+    private handleNativeSessionTokenRequest;
+    private handleNativeMainStream;
+    private isCoreConnectionHealthy;
+    private waitForStableConnection;
+    private announceConnectionWhenStable;
+    private normalizeIncomingStreamEvent;
+    private hasIncomingChannelListener;
+    private hasAnyIncomingChannelListeners;
+    private dispatchIncomingChannelListeners;
+    private dispatchIncomingGenericListeners;
+    private handleUnhandledIncomingStreamEvent;
+    private handleIncomingStream;
+    private registerConnection;
+    private syncConnectionPeerLifecycle;
+    private getPeerCandidates;
+    updatePresence(isOnline?: boolean, ttlMs?: number, metadata?: string, ticketOverride?: string): Promise<void>;
+    onConnection(callback: (conn: Connection) => void): () => void;
+    onDisconnection(callback: (conn: Connection) => void): () => void;
+    onMessage(callback: (conn: Connection, msg: any) => void): () => void;
+    onIncomingStream(callback: (stream: IncomingStreamListenerEvent) => boolean | void): () => void;
+    registerChannel(descriptor: ChannelDescriptor): void;
+    unregisterChannel(channelId: string): void;
+    listChannels(): ChannelDescriptor[];
+    onIncomingChannelStream(channelId: string, callback: (stream: IncomingStreamListenerEvent) => boolean | void): () => void;
+    onRoomJoinRequest(callback: (request: JoinRequest) => void): () => void;
+    private createMoQDataTracks;
+    /**
+     * Send data via MoQ.
+     * @param peerId Target Node ID (for 1:1) or null (for Broadcast)
+     * @param data Payload
+     */
+    sendMoQData(peerId: string | null, data: Uint8Array): Promise<void>;
+    private handleMessage;
+    private getRTCConfig;
+}
+export {};