openrtc 0.1.0 → 0.1.2

package/dist/runtime/index.d.ts

@@ -1,6 +1,796 @@
-export { RuntimeClient } from './RuntimeClient';
-export * from './types';
-export * from './factories';
-export * from './IpcRuntimeAdapter';
-export * from './WasmRuntimeAdapter';
-export type { PlutoIpcBridge, PlutoIpcUnlisten, PlutoIpcBridge as NativeBridge } from './ipc';
+import { C as Connection, E as RuntimeConnectionTarget, q as RuntimeRawConnection } from '../factories-0TxDPMeu.js';
+export { r as ChannelDescriptor, s as ConnectionEvent, t as ConnectionTarget, D as DeviceProfile, $ as DriveGrantActorError, a0 as DriveGrantActorErrorKind, a1 as DriveGrantActorHandle, a2 as DriveGrantActorHandleOptions, a3 as DriveGrantActorRegistry, a4 as DriveGrantClose, a5 as DriveGrantConnectionKey, a6 as DriveGrantDial, a7 as DriveGrantLogicalChannelHandle, a8 as DriveGrantWebRtcState, I as IncomingStream, O as OPENRTC_RUNTIME_POLICY, u as PeerConnectOptions, v as PeerReadiness, w as PeerStreamOptions, P as PlutoRuntimeAssembly, x as PresenceLoopOptions, y as RawConnection, z as RuntimeAuthContext, A as RuntimeAuthIdentity, B as RuntimeAutoConnectPolicy, k as RuntimeChannelDescriptor, a as RuntimeClient, R as RuntimeClientOptions, p as RuntimeConnectionEvent, o as RuntimeConnectionStateSnapshot, b as RuntimeDevice, d as RuntimeDeviceConnectOptions, F as RuntimeDeviceStatus, c as RuntimeDeviceStatusSnapshot, a9 as RuntimeFactoryOptions, m as RuntimeIncomingStream, G as RuntimeJoinRoomOptions, e as RuntimeLocalDeviceInfo, f as RuntimeLocalDeviceProfile, H as RuntimeManagedSession, J as RuntimeManagedSessionKind, K as RuntimeManagedSessionOptions, L as RuntimeManagedSessionPlatform, h as RuntimePeerConnectOptions, j as RuntimePeerHealth, M as RuntimePeerLifecycleStatus, i as RuntimePeerReadinessSnapshot, N as RuntimePeerScope, Q as RuntimePeerSessionSnapshot, g as RuntimePeerState, l as RuntimePeerStreamOptions, n as RuntimePolicySnapshot, S as RuntimePresenceLoopOptions, T as RuntimePresencePolicy, U as RuntimeRoomMember, V as RuntimeSession, W as RuntimeUiConnectionStatus, $ as ScopedConnectionActorError, a0 as ScopedConnectionActorErrorKind, a1 as ScopedConnectionActorHandle, a2 as ScopedConnectionActorHandleOptions, a3 as ScopedConnectionActorRegistry, a4 as ScopedConnectionClose, a6 as ScopedConnectionDial, a5 as ScopedConnectionKey, a7 as ScopedLogicalChannelHandle, a8 as ScopedWebRtcState, aa as Session, ab as SessionOptions, ac as createIpcClient, ad as createWasmClient, ae as driveGrantConnectionKey, af as driveGrantConnectionKeyToString, _ as getRuntimePolicy, ae as scopedConnectionKey, af as scopedConnectionKeyToString } from '../factories-0TxDPMeu.js';
+import { y as SignalingOptions, w as ISignalingBackend, o as RuntimeIdentity, z as SignalingEnvelope, n as SignalingSession, m as Device, B as BackendConnectionState, J as JoinRoomOptions, s as RoomMember, d as AppLimits, F as RoomCreationMode, k as ClientOptions, f as DiscoveryMode, h as ProtocolCapabilityMap, H as ScanningLoopOptions, K as ScanningLoopHandle, a as ConnectDeviceHooks, b as ConnectDeviceOptions, C as ConnectDeviceResult, O as RuntimeBootstrapOptions, Q as RuntimeBootstrapResult, q as PeerState, t as PeerScope, r as PeerHealth, G as GrantScope, I as IncomingStreamChannelMetadata, l as ChannelDescriptor, T as JoinRequest, N as NativeConnectResult } from '../DelegatingRuntimeAdapter-CW8d78dZ.js';
+export { U as BROWSER_WASM_RUNTIME_CAPABILITIES, V as NATIVE_IPC_RUNTIME_CAPABILITIES, j as RuntimeAdapterKind, c as RuntimeCapabilities, X as cloneRuntimeCapabilities } from '../DelegatingRuntimeAdapter-CW8d78dZ.js';
+import { FirebaseApp } from 'firebase/app';
+export { I as IpcRuntimeAdapter, a as IpcRuntimeAdapterOptions, P as NativeBridge, P as PlutoIpcBridge, b as PlutoIpcUnlisten } from '../IpcRuntimeAdapter-CT-W0Mtp.js';
+export { WasmRuntimeAdapter } from './WasmRuntimeAdapter.js';
+export { TauriRuntimeAdapter, TauriRuntimeAdapterOptions, createTauriIpcBridge } from './tauri.js';
+
+/**
+ * RtdbPresence — Phase 1 RTDB-backed device presence.
+ *
+ * Replaces the 60-second Firestore heartbeat loop with Firebase Realtime
+ * Database `onDisconnect` hooks. When a client disconnects (tab close,
+ * crash, network loss), the RTDB server automatically writes the offline
+ * state — no cleanup polling needed.
+ *
+ * RTDB paths mirror the Firestore device collection paths:
+ *
+ *   personal/spaceKey  → presence/spaces/{namespaceId}/devices/{deviceId}
+ *   user-scoped        → presence/{appTag}/users/{userId}/devices/{deviceId}
+ *
+ * Ticket version invalidation:
+ *   Each presence node stores a `ticketVersion` integer. WasmBridge bumps it
+ *   whenever it writes a new Firestore ticket (network change, reconnect).
+ *   Subscribers compare the received ticketVersion against their cached value;
+ *   if it differs they re-fetch the full device doc from Firestore. This means
+ *   other clients never hold a stale connection ticket for more than one RTDB
+ *   heartbeat interval (~1 s), eliminating the P2P-failure→Firestore fallback.
+ */
+
+interface RtdbDevicePresence {
+    online: boolean;
+    ticketVersion: number;
+}
+type RtdbPresenceMap = Record<string, RtdbDevicePresence>;
+type DiscoveryPresenceScope = {
+    kind: 'user-scoped';
+    appTag: string;
+    userId: string;
+} | {
+    kind: 'personal';
+    namespaceId: string;
+};
+interface RtdbMemberPresence {
+    online: boolean;
+}
+type RtdbRoomPresenceMap = Record<string, RtdbMemberPresence>;
+declare class RtdbPresence {
+    private readonly db;
+    constructor(app: FirebaseApp);
+    /**
+     * Register this device as online in RTDB and set an onDisconnect handler
+     * so the server marks it offline automatically on connection loss.
+     *
+     * Should be called once per session, after a Firestore ticket has been
+     * written. Does not replace the Firestore device doc — that remains the
+     * source of truth for the connection ticket and metadata.
+     */
+    registerDevice(scope: DiscoveryPresenceScope, deviceId: string, ticketVersion?: number): Promise<void>;
+    /**
+     * Bump the ticketVersion for a device. Call this whenever a new Firestore
+     * ticket is written (e.g. on network change / node restart). Subscribers
+     * will see the version change and re-fetch the Firestore doc.
+     */
+    bumpTicketVersion(scope: DiscoveryPresenceScope, deviceId: string, newVersion: number): Promise<void>;
+    /**
+     * Explicitly mark a device offline (graceful disconnect / sign-out).
+     * The onDisconnect handler would eventually fire anyway, but calling this
+     * immediately on graceful shutdown gives instant feedback to other clients.
+     */
+    markOffline(scope: DiscoveryPresenceScope, deviceId: string, ticketVersion?: number): Promise<void>;
+    /**
+     * Register a room member as online and set an onDisconnect handler.
+     * Called immediately after the Firestore member doc is written (join).
+     */
+    registerRoomMember(appTag: string, roomId: string, memberId: string): Promise<void>;
+    /**
+     * Explicitly mark a room member offline (graceful leave).
+     * The onDisconnect would fire eventually, but calling this immediately
+     * gives instant feedback to other members in the room.
+     */
+    markRoomMemberOffline(appTag: string, roomId: string, memberId: string): Promise<void>;
+    /**
+     * Subscribe to all member presence states in a room.
+     * Returns an unsubscribe function. The callback receives a map of
+     * memberId → { online } whenever any member's liveness changes.
+     *
+     * Consumers (BrowserFirestoreRooms) overlay this onto the Firestore
+     * member roster to show which members are currently alive vs. ghost entries.
+     */
+    onRoomPresenceChange(appTag: string, roomId: string, callback: (presenceMap: RtdbRoomPresenceMap) => void): () => void;
+    /**
+     * Subscribe to all device presence states in a discovery scope.
+     *
+     * Returns an unsubscribe function. The callback receives the full map of
+     * deviceId → { online, ticketVersion } whenever any device's presence
+     * changes. This replaces the `onSnapshot` on the Firestore device
+     * collection for the online/offline boolean overlay.
+     *
+     * The Firestore device collection remains as the source of truth for
+     * connection tickets and metadata; RTDB is only used for the live
+     * online boolean and ticket invalidation signal.
+     */
+    onPresenceChange(scope: DiscoveryPresenceScope, callback: (presenceMap: RtdbPresenceMap) => void): () => void;
+}
+
+declare class Signaling {
+    private readonly appTag;
+    private backend;
+    constructor(options: SignalingOptions, backend: ISignalingBackend);
+    get tag(): string;
+    waitForAuth(): Promise<void>;
+    get currentUser(): RuntimeIdentity | null;
+    onAuthChange(callback: (user: RuntimeIdentity | null) => void): () => void;
+    signInAnonymously(): Promise<void>;
+    signInWithPluto(): Promise<void>;
+    signOut(): Promise<void>;
+    stopAuthScopedActivity(): Promise<void>;
+    getTurnCredentials(): Promise<any>;
+    updatePresence(localNodeId: string, ticketStr: string, isOnline?: boolean, ttlMs?: number, metadata?: string): Promise<void>;
+    setOffline(localNodeId: string): Promise<void>;
+    cleanupStaleDevices(): Promise<void>;
+    sendMessage(targetId: string, payload: string, state?: string, replyPayload?: string): Promise<string>;
+    pollMessages(targetId: string): Promise<SignalingEnvelope[]>;
+    subscribeSessions(localDeviceId: string, callback: (session: SignalingSession) => void): Promise<() => void>;
+    getLocalDeviceId(): Promise<string | null>;
+    searchDevices(excludeNodeId?: string): Promise<Device[]>;
+    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;
+    startAutoConnect(userId: string, localDeviceId: string): void;
+    notifyDisconnectRequested(remoteNodeId: string): void;
+    startPresenceLoop(userId: string, localNodeId: string, deviceName: string, ticket: string, metadata?: string): void;
+    forceReconnectSnapshot(): void;
+    isConnected(nodeId: string): Promise<boolean>;
+    getConnectionStates(): Promise<BackendConnectionState[]>;
+    onConnectionStateChange(callback: (state: BackendConnectionState) => void): (() => void) | Promise<() => void>;
+    supportsRustPeerLifecycleProjection(): boolean;
+    setWasmClient(client: any): void;
+}
+
+declare class RoomManager {
+    private signaling;
+    private client;
+    private readonly heartbeatStops;
+    private browserRooms;
+    private rtdbPresence;
+    constructor(client: Client, signaling: Signaling);
+    private getBrowserRooms;
+    /**
+     * Phase 2: called by the runtime after RTDB presence is initialised
+     * (same RtdbPresence instance used for device presence in Phase 1).
+     */
+    setRtdbPresence(rtdbPresence: RtdbPresence): void;
+    private usesDirectRoomBackend;
+    private get roomBackendTag();
+    private get appTag();
+    private invokeRoomCallable;
+    private isAlreadyExistsError;
+    private getMembersInternal;
+    private parseMemberDocuments;
+    private parseRoomMemberDocument;
+    /**
+     * Creates a new room. When `requestedRoomId` is provided, the backend will
+     * try to create that exact room ID instead of generating a random one.
+     */
+    createRoom(requestedRoomId?: string): Promise<string>;
+    /**
+     * Joins a room by ID.
+     */
+    joinRoom(roomId: string, options?: JoinRoomOptions): Promise<Connection[]>;
+    leaveRoom(roomId: string): Promise<void>;
+    getRoomMembers(roomId: string): Promise<RoomMember[]>;
+    watchRoom(roomId: string, callback: (members: RoomMember[]) => void): () => void;
+    /**
+     * Register this device as an online room member in RTDB and store a
+     * cleanup callback in heartbeatStops (keyed by roomId) so that
+     * stopHeartbeat() / leaveRoom() can trigger graceful offline marking.
+     */
+    private registerRtdbRoomMember;
+    private markRtdbRoomMemberOffline;
+    private startLegacyHeartbeat;
+    stopHeartbeat(roomId?: string): void;
+}
+
+declare class MoQPublisher {
+    private session;
+    private tracks;
+    private activePublishers;
+    constructor(session: MoQSession);
+    private pendingAnnounces;
+    announce(namespace: string): Promise<void>;
+    onAnnounceResult(namespace: string, error?: {
+        code: number;
+        reason: string;
+    }): void;
+    onSubscribe(msg: any): void;
+    onUnsubscribe(subscribeId: number): void;
+    createTrack(namespace: string, name: string): Promise<any>;
+}
+
+declare class MoQSubscriber {
+    private session;
+    private onObject;
+    constructor(session: MoQSession, onObject: (ns: string, name: string, obj: Uint8Array, meta: any) => void);
+    private aliasMap;
+    private nextAlias;
+    private nextSubscribeId;
+    private pendingSubscriptions;
+    private deliveryState;
+    private activeSubscriptions;
+    subscribe(namespace: string, name: string): Promise<void>;
+    onSubscribeOk(subscribeId: number): void;
+    onSubscribeError(subscribeId: number, code: number): Promise<void>;
+    onSubscribeDone(subscribeId: number, code: number, reason: string): void;
+    private wakeDelivery;
+    private runDeliveryLoop;
+    handleIncomingUniStream(stream: ReadableStream<Uint8Array>): Promise<void>;
+}
+
+interface TransportInterface {
+    createBidirectionalStream(): Promise<{
+        readable: ReadableStream<Uint8Array>;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    createUnidirectionalStream(): Promise<WritableStream<Uint8Array>>;
+    incomingBidirectionalStreams: ReadableStream<any>;
+    incomingUnidirectionalStreams: ReadableStream<ReadableStream<Uint8Array>>;
+    close(): void;
+    ready: Promise<void>;
+}
+declare class MoQSession {
+    transport: TransportInterface;
+    private controlStreamWriter;
+    private controlStreamReader;
+    private uniStreamReader;
+    private closeListeners;
+    private closed;
+    private closeEmitted;
+    private resourcesClosed;
+    private role;
+    setupComplete: boolean;
+    private setupResolve;
+    private setupPromise;
+    maxSubscribeId: number;
+    private streamBuffer;
+    publisher: MoQPublisher;
+    subscriber: MoQSubscriber;
+    constructor(transport: TransportInterface, onObject?: (ns: string, name: string, obj: Uint8Array, meta: any) => void, role?: number);
+    /** Wait for handshake to complete before sending ANNOUNCE/SUBSCRIBE */
+    waitForSetup(): Promise<void>;
+    init(): Promise<void>;
+    onClose(callback: (reason?: unknown) => void): () => void;
+    close(): void;
+    private cleanupResources;
+    private emitClose;
+    private readUniStreams;
+    sendControlMessage(msg: any): Promise<void>;
+    private readLoop;
+    private processBuffer;
+    private handleControlMessage;
+}
+
+type IncomingProtocolHint = 'control' | 'explicit' | 'native-main' | 'unknown';
+type IncomingStreamListenerEvent = {
+    type: 'bi' | 'uni';
+    stream: any;
+    remoteNodeId: string;
+    traceId?: string;
+    protocolHint?: IncomingProtocolHint;
+    channel?: IncomingStreamChannelMetadata | null;
+    invalid?: boolean;
+};
+
+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_MAX_FRAME_BYTES;
+    private static readonly NATIVE_MAIN_PROTOCOL_VERSION;
+    private static readonly CONNECTION_STATE_CHANGED_EVENT;
+    private static readonly NATIVE_MAIN_MESSAGE_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 peerLifecycleClient;
+    private readonly knownDevicesById;
+    private readonly knownDeviceIdsByNodeId;
+    private readonly connectionTrustStates;
+    private readonly connectionChannelIds;
+    private readonly pendingSessionTokenTrustApprovals;
+    /** Tracks the last rejection timestamp per remote node to debounce repeated stale-token retries. */
+    private readonly sessionTokenRejectionCooldowns;
+    /** Tracks the last trust-failure timestamp per remote node to suppress rapid connection-rebuild storms. */
+    private readonly trustFailureCooldowns;
+    /** Nodes that have passed at least one session-token approval — exempt from trust-failure cooldown. */
+    private readonly sessionTokenApprovedNodes;
+    /** Connection IDs that have been explicitly approved via session-token admission. */
+    private readonly sessionTokenApprovedConnectionIds;
+    /** Most recent inbound native-main BiStream writer per remote node (desktop -> web). */
+    private readonly inboundNativeMainWriters;
+    /** Per-node write mutex for inbound native-main writers. */
+    private readonly inboundNativeMainWriteMutex;
+    /** Lifecycle metadata for inbound native-main writers to debug stale-writer routing. */
+    private readonly inboundNativeMainWriterMeta;
+    /** Per-node cooldown to bypass missing/stale inbound writer probes. */
+    private readonly inboundNativeMainBypassUntilMs;
+    private inboundNativeMainWriterSeq;
+    private managedPresenceGrant;
+    /** Token extracted from a compound ticket during connect(), keyed by remote node ID. */
+    private readonly pendingTokenByNodeId;
+    private readonly pendingNativeMainConnections;
+    private readonly webrtcIncomingExplicitTransfers;
+    private localNodeId;
+    private listening;
+    private listenLoopTask;
+    private options;
+    private readonly runtimeSafetyProfile;
+    appLimits: AppLimits;
+    private pendingConnection;
+    private incomingTraceSequence;
+    private browserBackgrounded;
+    private authSyncUnsubscribe;
+    private backendConnectionStateUnsubscribe;
+    private authRefreshInterval;
+    private deviceId;
+    private lastWasmAuthSyncUserId;
+    private lastWasmAuthSyncToken;
+    private loggedNativeDiscoveryWasmSkip;
+    private static readonly CONNECTION_STABLE_WINDOW_MS;
+    private static readonly CONNECTION_STABLE_TIMEOUT_MS;
+    private static readonly CONNECTION_STABLE_POLL_MS;
+    private static readonly SESSION_TOKEN_TRUST_APPROVAL_TTL_MS;
+    private static readonly SESSION_TOKEN_UNKNOWN_RETRY_ATTEMPTS;
+    private static readonly SESSION_TOKEN_UNKNOWN_RETRY_DELAY_MS;
+    /** How long to suppress new Connection objects for a node after a trust failure (ms). */
+    private static readonly TRUST_FAILURE_COOLDOWN_MS;
+    private static readonly INBOUND_WRITER_RETRY_COOLDOWN_MS;
+    private static readonly MOQ_RECONNECT_INITIAL_DELAY_MS;
+    private static readonly MOQ_RECONNECT_MAX_DELAY_MS;
+    private presenceInterval;
+    private hostedAppSettingsLoaded;
+    private effectiveRoomBackendTag;
+    private _moqSession;
+    private _moqState;
+    private moqReadyListeners;
+    private moqFailedListeners;
+    private moqObjectListeners;
+    private moqReconnectTimer;
+    private moqReconnectAttempts;
+    private readonly moqPeerSubscriptions;
+    roomCreationMode: RoomCreationMode;
+    constructor(options: ClientOptions);
+    private sleep;
+    private installAppLifecycleListeners;
+    private handleAppBackgroundState;
+    private reconcileConnectionsAfterForeground;
+    get apiKey(): string | undefined;
+    get discoveryMode(): DiscoveryMode;
+    private usesTicketOnlySignalingMode;
+    usesDirectRoomBackend(): boolean;
+    getRoomBackendTag(): string;
+    refreshHostedAppSettings(force?: boolean): Promise<void>;
+    setSignalingBackend(backend: ISignalingBackend): void;
+    get currentUser(): RuntimeIdentity | null;
+    onAuthChange(callback: (user: any) => void): () => void;
+    signInAnonymously(): Promise<void>;
+    signInWithPluto(): Promise<void>;
+    signOut(): Promise<void>;
+    getSignalingTelemetry(): {
+        transport: string;
+        wasmLoaded: boolean;
+    };
+    getProtocolCapabilities(): ProtocolCapabilityMap;
+    getRuntimeStatus(): Promise<{
+        runtime: 'tauri' | 'browser' | 'unknown';
+        wasmLoaded: boolean;
+        localNodeId?: string;
+        userId?: string;
+    }>;
+    private ensureWasmRuntimeForP2P;
+    private usesNativeIpcRuntimeWithoutWasmFallback;
+    private nativeWasmInitForbiddenError;
+    private ensureSignalingReadyForDiscovery;
+    private requiresManagedTransportTrust;
+    private getRegisteredChannel;
+    private isChannelPromotionEligible;
+    private isTransportOnlyChannel;
+    private getConnectionChannelId;
+    private isTransportOnlyConnectionId;
+    private resolvePromotionEligibility;
+    private assignConnectionChannel;
+    private rememberKnownDevice;
+    private getKnownDevice;
+    private refreshKnownDeviceCache;
+    private initializeConnectionTrust;
+    private consumePendingSessionTokenTrustApproval;
+    private applySessionTokenTrustApproval;
+    private getConnectionTrustState;
+    private getConnectionTrustProjection;
+    private applyConnectionTrustProjection;
+    private getConnectionTransportProjectionState;
+    private buildLocalTransportTrustPayload;
+    private sendTransportHandshake;
+    private broadcastTransportCapabilityUpdate;
+    private verifyRemoteTransportTrust;
+    private enforceConnectionTrustFailure;
+    private markConnectionTrustVerified;
+    private bindConnectionDeviceIdInRust;
+    private retireSupersededConnections;
+    searchDevices(): Promise<Device[]>;
+    updateDevice(deviceId: string, updates: {
+        deviceName?: string;
+        capabilities?: Device['capabilities'];
+        metadata?: string;
+    }): Promise<void>;
+    deleteDevice(deviceId: string): Promise<void>;
+    cleanupStaleDevices(): Promise<void>;
+    onDevicesChange(callback: any): () => void;
+    subscribeSessions(localDeviceId: string, callback: (session: 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;
+    private getTurnCredentialsForTransportConfig;
+    /**
+     * 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(): "none" | "failed" | "connecting" | "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 clearMoQReconnectTimer;
+    private closeMoQSession;
+    private handleMoQSessionClosed;
+    private scheduleMoQReconnect;
+    private enableMoQForConnection;
+    private subscribeMoQPeer;
+    private resubscribeMoQPeers;
+    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[];
+    getConnectionForPeer(connectionId?: string, remoteNodeId?: string): Connection | null;
+    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>;
+    clearManualDisconnectProjection(id: string): void;
+    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 grantScope Admission-grant label (e.g. "share"). Used for bulk revoke in Rust.
+     *                   This is distinct from `PeerScope`, which only tracks local peer lifecycle.
+     * @param maxConnections  0 = unlimited.
+     */
+    getEndpointTicketWithToken(grantScope: GrantScope, 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: GrantScope, 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: GrantScope, maxConnections: number): void;
+    /** Revoke a specific session token. */
+    revokeSessionToken(token: string): void;
+    /** Revoke all tokens that match the given scope. */
+    revokeTokensByScope(grantScope: GrantScope): Promise<string[]>;
+    private static generateSessionToken;
+    private static encodeSessionTokenPayload;
+    private static buildCompoundTicketWithPayload;
+    clearSessionTokens(): Promise<void>;
+    private resolvePresenceTicket;
+    private refreshManagedPresenceTicketIfNeeded;
+    private validateIncomingSessionToken;
+    private validateIncomingSessionTokenWithRetry;
+    /**
+     * 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;
+    private getRuntimeSafetyProfile;
+    private shouldVerboseIncomingDiagnostics;
+    private shouldUseTransportOnlyChannelConnection;
+    private createTransportOnlyChannelConnection;
+    private shouldInspectIncomingChannelEnvelope;
+    private createTransportContext;
+    private hasTransportOnlyConnectionForRemoteNode;
+    private shouldSkipIncomingBiProbeForRemoteNode;
+    private disconnectNodeTransport;
+    private nextIncomingTraceId;
+    private logIncomingDiagnostic;
+    private awaitConnectEventReady;
+    private safeReleaseReaderLock;
+    /**
+     * 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 findManualDisconnectProjectionForNativeNode;
+    private hasKnownConnectionForRemoteNode;
+    private inferTicketFlowBiProtocolHint;
+    private hasRustPeerLifecycleProjection;
+    private shouldProjectNativeMainLifecycle;
+    private emitNativeMainConnectionState;
+    private applyBackendConnectionState;
+    private encodeNativeMainFrame;
+    private dispatchNativeMainMessage;
+    private writeNativeMainMessage;
+    private handleNativeHandshakeRequest;
+    private handleNativeSessionTokenRequest;
+    private isNativeSignalEnvelope;
+    private buildNativeMainPayload;
+    private buildFramedMessage;
+    private buildNativeMainLabelHeader;
+    private writeNativeMainLabelHeaderOnBiStream;
+    private registerInboundNativeMainWriter;
+    private clearInboundNativeMainWriter;
+    private sendNativeSignalViaInboundControlStream;
+    private sendNativeSignalViaDedicatedStream;
+    private sendNativeSignalEnvelope;
+    private ensureIncomingConnectionForRemoteNode;
+    private handleNativeMainStream;
+    private tryExtractNativeMainPayload;
+    private isCoreConnectionHealthy;
+    private waitForStableConnection;
+    private announceConnectionWhenStable;
+    private normalizeIncomingStreamEvent;
+    private hasIncomingChannelListener;
+    private hasAnyIncomingChannelListeners;
+    private dispatchIncomingChannelListeners;
+    private dispatchIncomingGenericListeners;
+    private shouldTreatIncomingStreamAsTransportOnly;
+    private handleUnhandledIncomingStreamEvent;
+    private isHandshakeMessage;
+    private handleIncomingStream;
+    private maybeHandleWebRTCExplicitFileEnvelope;
+    private reassembleWebRTCExplicitPayload;
+    private dispatchSyntheticExplicitIncomingStream;
+    private registerConnection;
+    private reportConnectionTransportStatus;
+    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 isWebRTCTransportEnabled;
+    private getRTCConfig;
+}
+
+/**
+ * Owns low-level transport commands for RuntimeClient.
+ *
+ * This intentionally stays narrow: managed sessions, device discovery, peer
+ * readiness, and channel orchestration remain in their existing managers until
+ * those boundaries can be tightened independently.
+ */
+declare class RuntimeConnectionController {
+    private readonly client;
+    private readonly backend;
+    constructor(client: Client, backend: ISignalingBackend | null);
+    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>>;
+    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>;
+    private clearManualDisconnectProjection;
+}
+
+/**
+ * Phase 7 TS-side correlation logger. Mirror of
+ * `openrtc/crates/openrtc/src/client/correlation.rs`. Emits `console.log` lines in
+ * the exact `key=value` shape the Phase 0 parser
+ * (`tests/helpers/correlationLog.ts`) recognises.
+ *
+ * The TS half exists so observer-side state transitions (scoped-actor
+ * coalescing, upgrade observation, channel opens, shutdown) emit the same
+ * correlation chain the Rust core does — making cross-language log scans
+ * grep-friendly.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * import { clog } from '@/openrtc/packages/openrtc/src/runtime/correlationLog';
+ * clog('[scoped-actor][dial]',
+ *      { sessionKind: 'scoped-guest', scope: 'scoped:abc', peerNodeId: 'node-A' },
+ *      'ready_first');
+ * ```
+ *
+ * Empty/undefined fields are omitted so log lines stay short.
+ */
+interface CorrelationFields {
+    sessionKind?: string;
+    grantId?: string;
+    scope?: string;
+    peerNodeId?: string;
+    connectionId?: string;
+    transportEpoch?: string | number;
+    channel?: string;
+    tokenFp?: string;
+}
+/**
+ * Renders `fields` to `key=value key=value` (snake_case keys to match
+ * the Phase 0 parser's primary regex set). Empty fields are dropped.
+ * Exposed for tests.
+ */
+declare function renderCorrelationFields(fields: CorrelationFields): string;
+/** @deprecated Use correlationForScope() */
+declare function correlationForDriveGrantScope(scope: string, extra?: CorrelationFields): CorrelationFields;
+/**
+ * Phase 7 structured-log call. Emits a single `console.log` line of the
+ * form `<tag> <fields> <message>` — the exact shape the Phase 0
+ * `correlationLog.ts` parser already understands.
+ *
+ * Tag is typically a bracket-prefix like `[drive-grant-actor][dial]`.
+ * Fields are rendered as `snake_case=value`. Pass an empty object for
+ * the fields if a context isn't applicable yet.
+ */
+declare function clog(tag: string, fields: CorrelationFields, message?: string, ...extra: unknown[]): void;
+
+/**
+ * Consistent logging for session teardown / revoke paths (user-device, share, etc.).
+ *
+ * Browser: set `localStorage.setItem('OPENRTC_TEARDOWN_TRACE', '1')`, reload, reproduce.
+ *   Stack lines are tagged `[OpenRTC][teardown-trace:stack]`.
+ * Native / Tauri: run with `PLUTO_RTC_TEARDOWN_TRACE=1` to log matching Rust iroh disconnect lines to stderr.
+ */
+declare function logOpenRtcTeardownTrace(kind: string, details?: Record<string, unknown>): void;
+
+export { type CorrelationFields, RuntimeConnectionController, RuntimeConnectionTarget, RuntimeRawConnection, clog, correlationForDriveGrantScope, logOpenRtcTeardownTrace, renderCorrelationFields };