openrtc 0.1.0

package/dist/runtime/DelegatingRuntimeAdapter.js

@@ -0,0 +1,250 @@
+export class DelegatingRuntimeAdapter {
+    constructor(backend) {
+        this.backend = backend;
+    }
+    get currentUser() {
+        return this.backend.currentUser;
+    }
+    setAuthContext(context) {
+        const backend = this.backend;
+        return backend.setAuthContext?.(context);
+    }
+    async signInAnonymously() {
+        return this.backend.signInAnonymously();
+    }
+    async signInWithPluto() {
+        if (typeof this.backend.signInWithPluto !== 'function') {
+            throw new Error('Selected runtime adapter does not support Pluto SSO.');
+        }
+        return this.backend.signInWithPluto();
+    }
+    async signOut() {
+        return this.backend.signOut();
+    }
+    async stopAuthScopedActivity() {
+        if (typeof this.backend.stopAuthScopedActivity === 'function') {
+            await this.backend.stopAuthScopedActivity();
+        }
+    }
+    async getTurnCredentials() {
+        return this.backend.getTurnCredentials();
+    }
+    async updatePresence(localNodeId, ticketStr, isOnline, ttlMs, metadata) {
+        return this.backend.updatePresence(localNodeId, ticketStr, isOnline, ttlMs, metadata);
+    }
+    async setOffline(localNodeId) {
+        return this.backend.setOffline(localNodeId);
+    }
+    async cleanupStaleDevices() {
+        return this.backend.cleanupStaleDevices();
+    }
+    async searchDevices(excludeNodeId) {
+        return this.backend.searchDevices(excludeNodeId);
+    }
+    async listDevicesWithStatus() {
+        if (typeof this.backend.listDevicesWithStatus !== 'function') {
+            throw new Error('Selected runtime adapter does not support listDevicesWithStatus().');
+        }
+        return this.backend.listDevicesWithStatus();
+    }
+    async getPeerSession(id) {
+        if (typeof this.backend.getPeerSession !== 'function') {
+            return null;
+        }
+        return this.backend.getPeerSession(id);
+    }
+    async listPeerSessions() {
+        if (typeof this.backend.listPeerSessions !== 'function') {
+            return [];
+        }
+        return this.backend.listPeerSessions();
+    }
+    async waitForSettledPeer(id, timeoutMs) {
+        if (typeof this.backend.waitForSettledPeer !== 'function') {
+            return null;
+        }
+        return this.backend.waitForSettledPeer(id, timeoutMs);
+    }
+    async resolvePeerIdentity(id) {
+        if (typeof this.backend.resolvePeerIdentity !== 'function') {
+            return {
+                peerId: null,
+                deviceId: null,
+                deviceIdHint: null,
+                nodeId: null,
+            };
+        }
+        return this.backend.resolvePeerIdentity(id);
+    }
+    async resolvePeerConnectionRecords(id) {
+        if (typeof this.backend.resolvePeerConnectionRecords !== 'function') {
+            return [];
+        }
+        return this.backend.resolvePeerConnectionRecords(id);
+    }
+    async updateDevice(deviceId, updates) {
+        return this.backend.updateDevice(deviceId, updates);
+    }
+    async deleteDevice(deviceId) {
+        return this.backend.deleteDevice(deviceId);
+    }
+    onDevicesChange(callback, excludeNodeId) {
+        return this.backend.onDevicesChange(callback, excludeNodeId);
+    }
+    onAuthChange(callback) {
+        return this.backend.onAuthChange(callback);
+    }
+    async checkForSSOToken() {
+        return this.backend.checkForSSOToken();
+    }
+    async waitForAuth() {
+        return this.backend.waitForAuth();
+    }
+    async sendMessage(targetId, payload, state, replyPayload) {
+        return this.backend.sendMessage(targetId, payload, state, replyPayload);
+    }
+    async pollMessages(targetId) {
+        return this.backend.pollMessages(targetId);
+    }
+    async subscribeDevices(userId) {
+        return this.backend.subscribeDevices(userId);
+    }
+    startAutoConnect(userId, localDeviceId) {
+        this.backend.startAutoConnect(userId, localDeviceId);
+    }
+    startPresenceLoop(userId, localNodeId, deviceName, ticket, metadata) {
+        this.backend.startPresenceLoop(userId, localNodeId, deviceName, ticket, metadata);
+    }
+    async createSession(session) {
+        return this.backend.createSession(session);
+    }
+    async updateSession(sessionId, updateData) {
+        return this.backend.updateSession(sessionId, updateData);
+    }
+    async subscribeSessions(localDeviceId) {
+        return this.backend.subscribeSessions(localDeviceId);
+    }
+    forceReconnectSnapshot() {
+        this.backend.forceReconnectSnapshot();
+    }
+    async getLocalDeviceId() {
+        if (typeof this.backend.getLocalDeviceId !== 'function') {
+            return null;
+        }
+        return this.backend.getLocalDeviceId();
+    }
+    async getLocalDeviceInfo() {
+        if (typeof this.backend.getLocalDeviceInfo !== 'function') {
+            return null;
+        }
+        return this.backend.getLocalDeviceInfo();
+    }
+    async updateLocalDeviceName(deviceName) {
+        if (typeof this.backend.updateLocalDeviceName !== 'function') {
+            return null;
+        }
+        return this.backend.updateLocalDeviceName(deviceName);
+    }
+    async getManagedNodeId(options) {
+        if (typeof this.backend.getManagedNodeId !== 'function') {
+            return null;
+        }
+        return this.backend.getManagedNodeId(options);
+    }
+    async getEndpointTicket() {
+        if (typeof this.backend.getEndpointTicket !== 'function') {
+            throw new Error('Selected runtime adapter does not support getEndpointTicket().');
+        }
+        return this.backend.getEndpointTicket();
+    }
+    async getEndpointTicketWithToken(scope, maxConnections) {
+        const b = this.backend;
+        if (typeof b.getEndpointTicketWithToken !== 'function')
+            return null;
+        return b.getEndpointTicketWithToken(scope, maxConnections);
+    }
+    async registerSessionToken(token, scope, maxConnections) {
+        const b = this.backend;
+        if (typeof b.registerSessionToken === 'function') {
+            await b.registerSessionToken(token, scope, maxConnections);
+        }
+    }
+    async revokeSessionTokensByScope(scope) {
+        const b = this.backend;
+        if (typeof b.revokeSessionTokensByScope !== 'function')
+            return [];
+        return b.revokeSessionTokensByScope(scope);
+    }
+    async openPeerBi(id, timeoutMs) {
+        if (typeof this.backend.openPeerBi !== 'function') {
+            throw new Error('Selected runtime adapter does not support openPeerBi().');
+        }
+        return this.backend.openPeerBi(id, timeoutMs);
+    }
+    async openPeerUni(id, timeoutMs) {
+        if (typeof this.backend.openPeerUni !== 'function') {
+            throw new Error('Selected runtime adapter does not support openPeerUni().');
+        }
+        return this.backend.openPeerUni(id, timeoutMs);
+    }
+    async connectToDevice(params) {
+        if (typeof this.backend.connectToDevice !== 'function') {
+            throw new Error('Selected runtime adapter does not support connectToDevice().');
+        }
+        return this.backend.connectToDevice(params);
+    }
+    async disconnectDevice(deviceId) {
+        if (typeof this.backend.disconnectDevice !== 'function') {
+            throw new Error('Selected runtime adapter does not support disconnectDevice().');
+        }
+        return this.backend.disconnectDevice(deviceId);
+    }
+    async isConnected(nodeId) {
+        return this.backend.isConnected(nodeId);
+    }
+    async getConnectionStates() {
+        if (typeof this.backend.getConnectionStates !== 'function') {
+            return [];
+        }
+        return this.backend.getConnectionStates();
+    }
+    onConnectionStateChange(callback) {
+        if (typeof this.backend.onConnectionStateChange !== 'function') {
+            return () => { };
+        }
+        return this.backend.onConnectionStateChange(callback);
+    }
+    async sendExplicitFilePath(connectionId, filePath, transferId) {
+        if (typeof this.backend.sendExplicitFilePath !== 'function') {
+            throw new Error('Selected runtime adapter does not support sendExplicitFilePath().');
+        }
+        return this.backend.sendExplicitFilePath(connectionId, filePath, transferId);
+    }
+    async sendExplicitFileData(params) {
+        if (typeof this.backend.sendExplicitFileData !== 'function') {
+            throw new Error('Selected runtime adapter does not support sendExplicitFileData().');
+        }
+        return this.backend.sendExplicitFileData(params);
+    }
+    async getTransferHistory(limit) {
+        if (typeof this.backend.getTransferHistory !== 'function') {
+            return [];
+        }
+        return this.backend.getTransferHistory(limit);
+    }
+    async deleteTransferJob(jobId) {
+        if (typeof this.backend.deleteTransferJob !== 'function') {
+            return;
+        }
+        return this.backend.deleteTransferJob(jobId);
+    }
+    async onIncomingNativeMessage(callback) {
+        const b = this.backend;
+        if (typeof b.onIncomingNativeMessage !== 'function')
+            return () => { };
+        return b.onIncomingNativeMessage(callback);
+    }
+    unwrap() {
+        return this.backend;
+    }
+}

package/dist/runtime/IpcRuntimeAdapter.d.ts

@@ -0,0 +1,9 @@
+import { type NativeIpcBridgeOptions } from '../core/bridges/NativeIpcBridge';
+import { DelegatingRuntimeAdapter } from './DelegatingRuntimeAdapter';
+import { type PlutoIpcBridge } from './ipc';
+export interface IpcRuntimeAdapterOptions extends NativeIpcBridgeOptions {
+    bridge: PlutoIpcBridge;
+}
+export declare class IpcRuntimeAdapter extends DelegatingRuntimeAdapter {
+    constructor(options: IpcRuntimeAdapterOptions);
+}

package/dist/runtime/IpcRuntimeAdapter.js

@@ -0,0 +1,13 @@
+import { NativeIpcBridge } from '../core/bridges/NativeIpcBridge';
+import { DelegatingRuntimeAdapter } from './DelegatingRuntimeAdapter';
+import { assertValidIpcBridge } from './ipc';
+export class IpcRuntimeAdapter extends DelegatingRuntimeAdapter {
+    constructor(options) {
+        const bridge = assertValidIpcBridge(options.bridge, 'IpcRuntimeAdapter');
+        super(new NativeIpcBridge({
+            ...options,
+            ipcBridge: bridge,
+            allowWasmFallback: options.allowWasmFallback ?? false,
+        }));
+    }
+}

package/dist/runtime/RuntimeClient.d.ts

@@ -0,0 +1,257 @@
+import { Connection } from '../core/Connection';
+import type { AuthContext } from '../core/IEngineBridge';
+import type { AppLimits, ISignalingBackend, NativeConnectResult, ResolvedPeerIdentity } from '../core/types';
+import type { RuntimeAuthIdentity, RuntimeClientOptions, RuntimeConnectionEvent, RuntimeConnectionTarget, RuntimeDeviceConnectOptions, RuntimeDevice, RuntimeDeviceStatusSnapshot, RuntimeIncomingStream, RuntimeLocalDeviceProfile, RuntimeLocalDeviceInfo, RuntimeManagedSession, RuntimeManagedSessionOptions, RuntimePeerReadinessSnapshot, RuntimePeerConnectOptions, RuntimePeerStreamOptions, RuntimePeerHealth, RuntimePeerState, RuntimePresenceLoopOptions, RuntimeRawConnection, RuntimeSession } from './types';
+/**
+ * RuntimeClient is the primary application-facing API.
+ * It owns host/runtime orchestration on top of the Rust core and should be the
+ * only high-level surface consumed by product code. App code should not rebuild
+ * lifecycle, discovery, or transfer-readiness policy above this layer.
+ *
+ * Allowed:
+ * - app-facing session startup/shutdown
+ * - typed device, peer, room, and transfer APIs
+ * - thin host/runtime coordination
+ *
+ * Not allowed:
+ * - teaching app code to depend on `advanced.unwrap*()`
+ * - treating `nodeId` as high-level peer identity
+ * - reimplementing Rust-owned lifecycle policy in product code
+ *
+ * Source of truth:
+ * - Rust core owns discovery, peer identity, presence, and transport lifecycle
+ * - RuntimeClient should converge toward thin wrappers over those core surfaces
+ */
+export declare class RuntimeClient {
+    private static readonly NATIVE_START_RETRY_WINDOW_MS;
+    private static readonly NATIVE_START_RETRY_MIN_DELAY_MS;
+    private static readonly NATIVE_START_RETRY_MAX_DELAY_MS;
+    private static readonly MANAGED_RECONCILIATION_INTERVAL_MS;
+    private static readonly DEVICE_STATUS_REFRESH_DEBOUNCE_MS;
+    private static readonly MANAGED_USER_DEVICE_SCOPE;
+    private static readonly MANAGED_USER_DEVICE_STORAGE_KEY_PREFIX;
+    private readonly client;
+    private readonly backend;
+    private managedSessionKey;
+    private managedSessionUserId;
+    private managedSessionOptions;
+    private readonly apiKey;
+    private readonly storageNamespace;
+    constructor(options: RuntimeClientOptions, backend?: ISignalingBackend | null);
+    get identity(): RuntimeAuthIdentity | null;
+    private sleep;
+    private fetchAndApplyAppLimits;
+    private normalizeUiConnectionStatus;
+    private managedUserDeviceStorageKey;
+    private static encodeManagedCompoundTicket;
+    private decodeManagedUserDeviceGrantFromTicket;
+    private loadPersistedManagedUserDeviceGrant;
+    private persistManagedUserDeviceGrant;
+    private persistManagedUserDeviceGrantFromTicket;
+    private clearPersistedManagedUserDeviceGrant;
+    private resolvePeerStreamTarget;
+    private compatPeerConnectionFromTarget;
+    private deviceStatusSnapshotKey;
+    private buildDeviceStatusLookup;
+    private overlayPeerSessionsOnDeviceSnapshots;
+    private overlayPeerStateOnDeviceSnapshots;
+    private runtimeDeviceToStatusSnapshot;
+    private uniqueLookupIds;
+    private matchSessionByLookupId;
+    private resolvePeerLookupIds;
+    private mergeWatchedDevicesIntoStatusSnapshots;
+    private nextNativeStartRetryDelayMs;
+    private hasManagedSession;
+    private startManagedReconciliation;
+    private connectionStateSnapshotKey;
+    private runNativeStartLoop;
+    onIdentityChange(callback: (identity: RuntimeAuthIdentity | null) => void): () => void;
+    signInAnonymously(): Promise<void>;
+    signInWithPluto(): Promise<void>;
+    setAuthContext(context: AuthContext | null): Promise<void>;
+    signOut(): Promise<void>;
+    initialize(): Promise<void>;
+    getRuntimeStatus(): Promise<{
+        runtime: 'tauri' | 'browser' | 'unknown';
+        wasmLoaded: boolean;
+        localNodeId?: string;
+        userId?: string;
+    }>;
+    start(options?: {
+        clearSessionTokens?: boolean;
+    }): Promise<void>;
+    stop(): void;
+    getNodeId(): Promise<string>;
+    getNodeIdFromTicket(ticket: string): Promise<string | null>;
+    getLocalDeviceId(): Promise<string | null>;
+    getLocalDeviceInfo(): Promise<RuntimeLocalDeviceInfo | null>;
+    getLocalDeviceProfile(options?: {
+        deviceName?: string;
+        localDeviceId?: string | null;
+        platform?: 'native' | 'web';
+        userId?: string | null;
+    }): Promise<RuntimeLocalDeviceProfile>;
+    updateLocalDeviceName(deviceName: string): Promise<RuntimeLocalDeviceInfo | null>;
+    getManagedNodeId(options?: {
+        initializeIfMissing?: boolean;
+    }): Promise<string | null>;
+    getTicket(): Promise<string>;
+    /**
+     * Generate a session-scoped endpoint ticket with an embedded random token.
+     * The token gates incoming connections: only clients that present the token
+     * in their handshake are accepted while the registry is non-empty.
+     *
+     * @param scope          Logical label for bulk-revoke (e.g. "share").
+     * @param maxConnections 0 = unlimited.
+     */
+    getTicketWithToken(grantScope: string, maxConnections?: number): Promise<string>;
+    /** Revoke all session tokens that match the given scope. */
+    revokeTokensByScope(grantScope: string): Promise<string[]>;
+    private revokeTokensByScopeInternal;
+    /** Revoke a single session token by its raw value. */
+    revokeSessionToken(token: string): void;
+    getEndpointTicket(): Promise<string>;
+    startManagedSession(options: RuntimeManagedSessionOptions): Promise<RuntimeManagedSession>;
+    stopManagedSession(options?: {
+        preserveBackendSession?: boolean;
+    }): Promise<void>;
+    private rotateManagedUserDeviceGrant;
+    listDevices(): Promise<RuntimeDevice[]>;
+    listDevicesWithStatus(): Promise<RuntimeDeviceStatusSnapshot[]>;
+    updateDevice(deviceId: string, updates: {
+        deviceName?: string;
+        capabilities?: RuntimeDevice['capabilities'];
+        metadata?: string;
+    }): Promise<void>;
+    deleteDevice(deviceId: string): Promise<void>;
+    watchDevices(callback: (devices: RuntimeDevice[]) => void): () => void;
+    watchDevicesWithStatus(callback: (devices: RuntimeDeviceStatusSnapshot[]) => void): () => void;
+    connectDeviceWithRetry(device: RuntimeDevice, hooks: import('../core/types').ConnectDeviceHooks, options: import('../core/types').ConnectDeviceOptions): Promise<import('../core/types').ConnectDeviceResult>;
+    /**
+     * Runtime-owned device connect flow used by product code.
+     * Rust owns the actual managed dial policy. This wrapper only:
+     * - validates the app-facing device/ticket input
+     * - forwards the request to the active runtime adapter
+     * - refreshes peer state and invokes optional app callbacks
+     */
+    connectDevice(device: RuntimeDevice, options: RuntimeDeviceConnectOptions): Promise<import('../core/types').ConnectDeviceResult>;
+    watchPeerStates(callback: (peers: RuntimePeerState[]) => void): () => void;
+    getPeerState(id: string): RuntimePeerState | undefined;
+    resolvePeerConnectionRecords(id: string): Promise<import('../core/types').ManagedConnectionRecord[]>;
+    getPeerSession(id: string): Promise<import('../core/types').PeerSessionSnapshot | null>;
+    listPeerSessions(): Promise<import('../core/types').PeerSessionSnapshot[]>;
+    waitForConnectedPeer(id: string, timeoutMs?: number): Promise<import('../core/types').PeerSessionSnapshot | null>;
+    getPeerReadiness(id: string, timeoutMs?: number): Promise<RuntimePeerReadinessSnapshot>;
+    resolvePeerIdentity(id: string): Promise<ResolvedPeerIdentity>;
+    resolveIncomingStreamPeer(remoteNodeId: string): Promise<ResolvedPeerIdentity>;
+    listConnectedPeers(): RuntimePeerState[];
+    addPeerScope(id: string, scope?: string): RuntimePeerState | undefined;
+    releasePeerScope(id: string, scope?: string): RuntimePeerState | undefined;
+    getPeerScopes(id: string): string[];
+    isSamePeer(a: string, b: string): boolean;
+    refreshPeerSnapshot(): Promise<RuntimePeerState[]>;
+    subscribeSessions(localDeviceId: string, callback: (session: RuntimeSession) => void): Promise<() => void>;
+    getAppLimits(): AppLimits;
+    createRoom(): Promise<string>;
+    joinRoom(roomId: string, options?: import('./types').RuntimeJoinRoomOptions): Promise<Connection[]>;
+    leaveRoom(roomId: string): Promise<void>;
+    getRoomMembers(roomId: string): Promise<import('./types').RuntimeRoomMember[]>;
+    watchRoom(roomId: string, callback: (members: import('./types').RuntimeRoomMember[]) => void): () => void;
+    /** @deprecated Use connect() (no-arg) for lifecycle, or connectTo() for peer connections */
+    connectByTicket(target: RuntimeConnectionTarget): Promise<Connection>;
+    connectPeer(options: RuntimePeerConnectOptions): Promise<Connection>;
+    openPeerBi(id: string, options?: RuntimePeerStreamOptions): Promise<{
+        connection: Connection;
+        readable: ReadableStream<Uint8Array>;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    openPeerUni(id: string, options?: RuntimePeerStreamOptions): Promise<{
+        connection: Connection;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    connectToDevice(params: {
+        deviceId?: string | null;
+        endpointTicket: string;
+    }): Promise<NativeConnectResult>;
+    connectRaw(target: RuntimeConnectionTarget): Promise<RuntimeRawConnection>;
+    openBi(nodeId: string): Promise<{
+        readable: ReadableStream<Uint8Array>;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    openUni(nodeId: string): Promise<WritableStream<Uint8Array>>;
+    onIncomingStream(callback: (stream: RuntimeIncomingStream) => boolean | void): () => void;
+    registerChannel(descriptor: import('./types').RuntimeChannelDescriptor): void;
+    unregisterChannel(channelId: string): void;
+    listChannels(): import('./types').RuntimeChannelDescriptor[];
+    onIncomingChannelStream(channelId: string, callback: (stream: RuntimeIncomingStream) => boolean | void): () => void;
+    sendExplicitFilePath(connectionId: string, filePath: string, transferId?: string): Promise<string>;
+    sendExplicitFileData(params: import('../core/types').ExplicitFileDataSendParams): Promise<void>;
+    getTransferHistory(limit?: number): Promise<Array<[string, unknown]>>;
+    deleteTransferJob(jobId: string): Promise<void>;
+    startPresenceLoop(options?: RuntimePresenceLoopOptions): Promise<void>;
+    updatePresence(options?: {
+        isOnline?: boolean;
+        ttlMs?: number;
+        metadata?: string;
+        ticket?: string;
+    }): Promise<void>;
+    setOffline(): Promise<void>;
+    startAutoConnect(localDeviceId?: string): Promise<void>;
+    isConnected(nodeId: string): Promise<boolean>;
+    disconnectNode(nodeId: string): Promise<void>;
+    disconnectDevice(deviceId: string): Promise<void>;
+    setAutoConnectExcluded(deviceId: string, excluded: boolean): Promise<void>;
+    disconnectPeer(id: string, scope?: string): Promise<void>;
+    forceDisconnectPeer(id: string): Promise<void>;
+    getPeerHealth(id: string): Promise<RuntimePeerHealth>;
+    getConnectionStates(): Promise<import('./types').RuntimeConnectionStateSnapshot[]>;
+    onConnectionStateChange(callback: (state: import('./types').RuntimeConnectionStateSnapshot) => void): Promise<() => void> | (() => void);
+    getConnections(): Connection[];
+    onConnection(callback: (connection: Connection) => void): () => void;
+    onDisconnection(callback: (connection: Connection) => void): () => void;
+    onConnectionEvent(callback: (event: RuntimeConnectionEvent) => void): () => void;
+    forceReconnectSnapshot(): void;
+    /** Single-call lifecycle: combines initialize() + start() */
+    connect(): Promise<void>;
+    /** Disconnect from the runtime (alias for stop()) */
+    disconnect(): void;
+    /** Alias for onIdentityChange */
+    onAuthChange(callback: (identity: RuntimeAuthIdentity | null) => void): () => void;
+    /** Alias for setAuthContext */
+    setAuth(context: AuthContext | null): Promise<void>;
+    /** Alias for signInWithPluto */
+    signIn(): Promise<void>;
+    /** Alias for listDevices */
+    getDevices(): Promise<RuntimeDevice[]>;
+    /** Device subscription with optional status enrichment */
+    onDevices(callback: (devices: RuntimeDevice[]) => void): () => void;
+    onDevices(callback: (devices: RuntimeDeviceStatusSnapshot[]) => void, options: {
+        status: true;
+    }): () => void;
+    /** Alias for getTicket — returns an invite/ticket string */
+    getInvite(): Promise<string>;
+    /** Connect to a peer by device ID or options */
+    connectTo(options: RuntimePeerConnectOptions): Promise<Connection>;
+    /** Alias for waitForConnectedPeer */
+    waitFor(id: string, timeoutMs?: number): Promise<import('../core/types').PeerSessionSnapshot | null>;
+    /** Open a stream to a peer (default: bidirectional) */
+    openStream(id: string, options?: RuntimePeerStreamOptions & {
+        direction?: 'bi' | 'send';
+    }): Promise<{
+        connection: Connection;
+        readable?: ReadableStream<Uint8Array>;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    openChannelStream(channelId: string, id: string, options?: RuntimePeerStreamOptions & {
+        direction?: 'bi' | 'send';
+    }): Promise<{
+        connection: Connection;
+        readable?: ReadableStream<Uint8Array>;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    /** Alias for onIncomingStream */
+    onStream(callback: (stream: RuntimeIncomingStream) => boolean | void): () => void;
+    onChannelStream(channelId: string, callback: (stream: RuntimeIncomingStream) => boolean | void): () => void;
+    /** Alias for watchRoom */
+    onRoomChange(roomId: string, callback: (members: import('./types').RuntimeRoomMember[]) => void): () => void;
+}