openrtc 0.1.0 → 0.1.2

package/dist/runtime/DelegatingRuntimeAdapter.js

@@ -1,250 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,257 +0,0 @@
-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;
-}