openrtc 0.1.0

package/dist/core/bridges/RtdbPresence.d.ts

@@ -0,0 +1,122 @@
+/**
+ * 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.
+ */
+import type { FirebaseApp } from 'firebase/app';
+export interface RtdbPresenceState {
+    online: boolean;
+    lastSeenAt: object | null;
+    ticketVersion: number;
+}
+export interface RtdbDevicePresence {
+    online: boolean;
+    ticketVersion: number;
+}
+export type RtdbPresenceMap = Record<string, RtdbDevicePresence>;
+export type DiscoveryPresenceScope = {
+    kind: 'user-scoped';
+    appTag: string;
+    userId: string;
+} | {
+    kind: 'personal';
+    namespaceId: string;
+};
+export interface RtdbMemberPresence {
+    online: boolean;
+}
+export type RtdbRoomPresenceMap = Record<string, RtdbMemberPresence>;
+/**
+ * Returns the RTDB presence path for a specific device given a discovery scope.
+ */
+export declare function rtdbDevicePath(scope: DiscoveryPresenceScope, deviceId: string): string;
+/**
+ * Returns the RTDB presence path for all devices in a discovery scope
+ * (the parent node that `onValue` subscribes to).
+ */
+export declare function rtdbScopePath(scope: DiscoveryPresenceScope): string;
+/**
+ * Returns the RTDB path for a single room member's liveness node.
+ *
+ * Room presence lives under a separate namespace:
+ *   presence/{appTag}/rooms/{roomId}/members/{memberId}
+ *
+ * For personal spaces the appTag is "space::{namespaceId}".
+ */
+export declare function rtdbRoomMemberPath(appTag: string, roomId: string, memberId: string): string;
+/** Returns the RTDB path for all members in a room (parent of member nodes). */
+export declare function rtdbRoomMembersPath(appTag: string, roomId: string): string;
+export 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;
+}

package/dist/core/bridges/RtdbPresence.js

@@ -0,0 +1,201 @@
+/**
+ * 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.
+ */
+import { getDatabase, ref, set, onValue, onDisconnect, serverTimestamp, } from 'firebase/database';
+/**
+ * Returns the RTDB presence path for a specific device given a discovery scope.
+ */
+export function rtdbDevicePath(scope, deviceId) {
+    switch (scope.kind) {
+        case 'user-scoped':
+            return `presence/${scope.appTag}/users/${scope.userId}/devices/${deviceId}`;
+        case 'personal':
+            return `presence/spaces/${scope.namespaceId}/devices/${deviceId}`;
+    }
+}
+/**
+ * Returns the RTDB presence path for all devices in a discovery scope
+ * (the parent node that `onValue` subscribes to).
+ */
+export function rtdbScopePath(scope) {
+    switch (scope.kind) {
+        case 'user-scoped':
+            return `presence/${scope.appTag}/users/${scope.userId}/devices`;
+        case 'personal':
+            return `presence/spaces/${scope.namespaceId}/devices`;
+    }
+}
+/**
+ * Returns the RTDB path for a single room member's liveness node.
+ *
+ * Room presence lives under a separate namespace:
+ *   presence/{appTag}/rooms/{roomId}/members/{memberId}
+ *
+ * For personal spaces the appTag is "space::{namespaceId}".
+ */
+export function rtdbRoomMemberPath(appTag, roomId, memberId) {
+    return `presence/${appTag}/rooms/${roomId}/members/${memberId}`;
+}
+/** Returns the RTDB path for all members in a room (parent of member nodes). */
+export function rtdbRoomMembersPath(appTag, roomId) {
+    return `presence/${appTag}/rooms/${roomId}/members`;
+}
+export class RtdbPresence {
+    constructor(app) {
+        this.db = getDatabase(app);
+    }
+    /**
+     * 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.
+     */
+    async registerDevice(scope, deviceId, ticketVersion = 0) {
+        const deviceRef = ref(this.db, rtdbDevicePath(scope, deviceId));
+        // Register server-side cleanup: if the WebSocket drops, RTDB writes
+        // this offline state automatically.
+        await onDisconnect(deviceRef).set({
+            online: false,
+            lastSeenAt: serverTimestamp(),
+            ticketVersion,
+        });
+        // Now write online state.
+        await set(deviceRef, {
+            online: true,
+            lastSeenAt: serverTimestamp(),
+            ticketVersion,
+        });
+    }
+    /**
+     * 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.
+     */
+    async bumpTicketVersion(scope, deviceId, newVersion) {
+        const deviceRef = ref(this.db, rtdbDevicePath(scope, deviceId));
+        // Update the onDisconnect payload to include the new version too.
+        await onDisconnect(deviceRef).set({
+            online: false,
+            lastSeenAt: serverTimestamp(),
+            ticketVersion: newVersion,
+        });
+        // Partial update — only change the version, keep online: true.
+        const versionRef = ref(this.db, `${rtdbDevicePath(scope, deviceId)}/ticketVersion`);
+        await set(versionRef, newVersion);
+    }
+    /**
+     * 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.
+     */
+    async markOffline(scope, deviceId, ticketVersion = 0) {
+        // Cancel the onDisconnect so we don't write twice.
+        const deviceRef = ref(this.db, rtdbDevicePath(scope, deviceId));
+        await onDisconnect(deviceRef).cancel();
+        await set(deviceRef, {
+            online: false,
+            lastSeenAt: serverTimestamp(),
+            ticketVersion,
+        });
+    }
+    // -------------------------------------------------------------------------
+    // Room member presence (Phase 2)
+    // -------------------------------------------------------------------------
+    /**
+     * Register a room member as online and set an onDisconnect handler.
+     * Called immediately after the Firestore member doc is written (join).
+     */
+    async registerRoomMember(appTag, roomId, memberId) {
+        const memberRef = ref(this.db, rtdbRoomMemberPath(appTag, roomId, memberId));
+        await onDisconnect(memberRef).set({ online: false, lastSeenAt: serverTimestamp() });
+        await set(memberRef, { online: true, lastSeenAt: serverTimestamp() });
+    }
+    /**
+     * 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.
+     */
+    async markRoomMemberOffline(appTag, roomId, memberId) {
+        const memberRef = ref(this.db, rtdbRoomMemberPath(appTag, roomId, memberId));
+        await onDisconnect(memberRef).cancel();
+        await set(memberRef, { online: false, lastSeenAt: serverTimestamp() });
+    }
+    /**
+     * 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, roomId, callback) {
+        const roomRef = ref(this.db, rtdbRoomMembersPath(appTag, roomId));
+        const unsubscribe = onValue(roomRef, (snapshot) => {
+            const raw = snapshot.val() ?? {};
+            const presenceMap = {};
+            for (const [memberId, val] of Object.entries(raw)) {
+                if (val && typeof val === 'object') {
+                    presenceMap[memberId] = {
+                        online: val.online === true,
+                    };
+                }
+            }
+            callback(presenceMap);
+        }, (error) => {
+            console.warn('[RtdbPresence] room presence subscription error:', error);
+        });
+        return unsubscribe;
+    }
+    /**
+     * 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, callback) {
+        const scopeRef = ref(this.db, rtdbScopePath(scope));
+        const unsubscribe = onValue(scopeRef, (snapshot) => {
+            const raw = snapshot.val() ?? {};
+            const presenceMap = {};
+            for (const [deviceId, val] of Object.entries(raw)) {
+                if (val && typeof val === 'object') {
+                    const v = val;
+                    presenceMap[deviceId] = {
+                        online: v.online === true,
+                        ticketVersion: typeof v.ticketVersion === 'number' ? v.ticketVersion : 0,
+                    };
+                }
+            }
+            callback(presenceMap);
+        }, (error) => {
+            console.warn('[RtdbPresence] presence subscription error:', error);
+        });
+        return unsubscribe;
+    }
+}

package/dist/core/bridges/TauriBridge.d.ts

@@ -0,0 +1,8 @@
+import { NativeIpcBridge, type NativeIpcBridgeOptions } from './NativeIpcBridge';
+export type TauriBridgeOptions = NativeIpcBridgeOptions;
+/**
+ * @deprecated Prefer `NativeIpcBridge` or the first-party `openrtc-tauri` adapter package.
+ * This wrapper remains for one compatibility cycle.
+ */
+export declare class TauriBridge extends NativeIpcBridge {
+}

package/dist/core/bridges/TauriBridge.js

@@ -0,0 +1,7 @@
+import { NativeIpcBridge, } from './NativeIpcBridge';
+/**
+ * @deprecated Prefer `NativeIpcBridge` or the first-party `openrtc-tauri` adapter package.
+ * This wrapper remains for one compatibility cycle.
+ */
+export class TauriBridge extends NativeIpcBridge {
+}

package/dist/core/bridges/WasmBridge.d.ts

@@ -0,0 +1,233 @@
+import { FirebaseApp } from 'firebase/app';
+import { Auth } from 'firebase/auth';
+import { RtdbPresence, type DiscoveryPresenceScope } from './RtdbPresence';
+import { AuthMode, BackendConnectionState, Device, DiscoveryMode, DeviceEvent, ExplicitFileDataSendParams, ISignalingBackend, RuntimeIdentity, SignalingMode, SignalingEnvelope, SignalingSession, SessionEvent } from '../types';
+export interface WasmBridgeOptions {
+    apiKey?: string;
+    discoveryMode?: DiscoveryMode;
+    spaceKey?: string;
+    authMode?: AuthMode;
+    signalingMode?: SignalingMode;
+    projectId?: string;
+    storagePrefix?: string;
+    nodeIdPersistence?: 'persistent' | 'ephemeral';
+    deviceName?: string;
+}
+/**
+ * WasmBridge is the browser host wrapper over the Rust/WASM runtime.
+ *
+ * Allowed:
+ * - normalize JS/WASM binding shapes
+ * - forward auth, discovery, signaling, and lifecycle calls into Rust
+ * - expose typed browser-facing results
+ *
+ * Not allowed:
+ * - become a second lifecycle engine
+ * - invent peer identity or connect policy that is not backed by Rust
+ * - normalize app-specific payload protocols into runtime behavior
+ *
+ * Source of truth:
+ * - Rust/WASM owns lifecycle, discovery, signaling, and connection health
+ * - RuntimeClient owns app-facing orchestration
+ */
+export declare class WasmBridge implements ISignalingBackend {
+    private static readonly EXPLICIT_FILE_PROTOCOL_TYPE;
+    private static readonly EXPLICIT_FILE_CHUNK_SIZE_BYTES;
+    private static readonly BROWSER_AUTO_CONNECT_SCAN_DEBOUNCE_MS;
+    private static readonly BROWSER_AUTO_CONNECT_RETRY_COOLDOWN_MS;
+    private static readonly BROWSER_AUTO_CONNECT_SETTLE_GUARD_MS;
+    app: FirebaseApp | null;
+    auth: Auth | null;
+    readonly appTag: string;
+    protected options: {
+        appTag: string;
+        apiKey?: string;
+        discoveryMode?: DiscoveryMode;
+        spaceKey?: string;
+        authMode: AuthMode;
+        signalingMode?: SignalingMode;
+        projectId: string;
+        storagePrefix?: string;
+        nodeIdPersistence?: 'persistent' | 'ephemeral';
+        deviceName?: string;
+    };
+    private authListeners;
+    private persistenceReady;
+    wasmClient: any;
+    private readonly createdAtMs;
+    private missingWasmWarnings;
+    private readonly wasmReadyWarningDelayMs;
+    private browserFirestoreSignaling;
+    private lastObservedFirebaseUserId;
+    private sessionReaders;
+    protected authContext: {
+        userId: string;
+        token?: string | null;
+        refreshToken?: string | null;
+        customToken?: string | null;
+        tokenProvider?: (forceRefresh?: boolean) => Promise<string | null>;
+        expiresAtMs?: number | null;
+    } | null;
+    private injectedBrowserAuthSessionActive;
+    private startedAutoConnectKey;
+    private autoConnectStartsInFlight;
+    private browserAutoConnectUnsubscribe;
+    private readonly browserAutoConnectLastAttemptAt;
+    private readonly browserAutoConnectInFlight;
+    private readonly browserAutoConnectWaitStartedAt;
+    private readonly browserAutoConnectEscalationCount;
+    private readonly browserAutoConnectObservedSignatures;
+    private readonly browserAutoConnectRecoveryTimers;
+    private browserAutoConnectPendingDevices;
+    private browserAutoConnectScanTimer;
+    private browserPresenceLoopInterval;
+    private browserPresenceLoopState;
+    private _rtdbPresence;
+    private rtdbPresenceScope;
+    private rtdbTicketVersion;
+    private rtdbPresenceDisabledForSession;
+    /** Phase 2: expose the RTDB presence instance so RuntimeClient can wire it into RoomManager. */
+    get rtdbPresence(): RtdbPresence | null;
+    private hasSyncedAuthToWasmClient;
+    private lastWasmAuthUserId;
+    private lastWasmAuthToken;
+    private lastDeliveredConnectionStates;
+    constructor(options: WasmBridgeOptions);
+    get tag(): string;
+    private static readonly WEB_DEVICE_ID_STORAGE_PREFIX;
+    private static readonly EPHEMERAL_DEVICE_ID_TTL_MS;
+    private getDeviceIdentityStorageKey;
+    private getNodeIdPersistenceMode;
+    private isTicketOnlyMode;
+    private createRandomDeviceId;
+    protected resolveWebLogicalDeviceId(): string;
+    private getDefaultBrowserDeviceName;
+    private getBrowserFirestoreSignaling;
+    private withWebPresenceMetadata;
+    setAuthContext(context: {
+        userId: string;
+        token?: string | null;
+        refreshToken?: string | null;
+        customToken?: string | null;
+        tokenProvider?: (forceRefresh?: boolean) => Promise<string | null>;
+        expiresAtMs?: number | null;
+    } | null): Promise<void>;
+    private ensureBrowserFirestoreAuth;
+    private syncWasmAuthToken;
+    private toRuntimeIdentity;
+    protected getCurrentUserId(): string | null;
+    getCurrentUserIdForScope(): string | null;
+    getAuthContext(): Readonly<typeof this.authContext> | null;
+    protected isPersonalSpaceMode(): boolean;
+    getResolvedOptions(): Readonly<typeof this.options>;
+    protected usesLegacyBrowserSignalingFallback(): boolean;
+    protected getDiscoveryScopeId(): string | null;
+    protected matchesTag(device: Pick<Device, 'tag' | 'appTag'>): boolean;
+    matchesDiscoveryTag(device: Pick<Device, 'tag' | 'appTag'>): boolean;
+    private stopSessionSubscriptions;
+    private stopRuntimeAuthScopedLoops;
+    private stopBrowserAutoConnect;
+    private clearBrowserAutoConnectDeviceState;
+    private queueBrowserAutoConnectRecoveryForDevice;
+    private triggerBrowserAutoConnectRecovery;
+    private browserAutoConnectLifecycleFresh;
+    private getRustOwnedAutoConnectGate;
+    private browserAutoConnectNonInitiatorGraceMs;
+    private queueBrowserAutoConnectGraceExpiryRecheck;
+    private shouldAttemptBrowserAutoConnectDial;
+    private hasHealthyBrowserAutoConnectSession;
+    private browserAutoConnectSignature;
+    private refreshBrowserAutoConnectDeviceForDial;
+    private scheduleBrowserAutoConnectScan;
+    private processBrowserAutoConnectSnapshot;
+    private stopBrowserPresenceLoop;
+    private disableRtdbPresenceForSession;
+    private startLegacyBrowserPresenceLoop;
+    /**
+     * Phase 1: Register RTDB presence for the current device.
+     *
+     * Initialises an RtdbPresence instance (lazy, one per WasmBridge), wires
+     * it into the BrowserFirestoreSignaling device watcher so RTDB state is
+     * used for the online/offline overlay, and registers this device as online
+     * with an onDisconnect cleanup hook.
+     *
+     * Called by startPresenceLoop (and directly from updatePresence when the
+     * ticket changes after initial registration).
+     */
+    registerRtdbPresence(scope: DiscoveryPresenceScope, deviceId: string, ticketVersion?: number): Promise<void>;
+    stopAuthScopedActivity(options?: {
+        userId?: string | null;
+    }): Promise<void>;
+    setWasmClient(client: any): void;
+    private warnMissingWasmOnce;
+    private waitForWasmClient;
+    protected normalizeDevice(raw: Record<string, any>, fallbackId?: string): Device;
+    normalizeDeviceRecord(raw: Record<string, any>, fallbackId?: string): Device;
+    getResolvedWebLogicalDeviceId(): string;
+    private normalizeDeviceStatusSnapshot;
+    private normalizePeerSessionSnapshot;
+    private toBackendConnectionStateFromPeerSession;
+    private normalizeConnectionStateSnapshot;
+    private normalizeWindowConnectionStateDetail;
+    private stabilizeConnectionState;
+    private sameConnectionState;
+    private deliverConnectionState;
+    private enrichBackendConnectionState;
+    get currentUser(): RuntimeIdentity | null;
+    onAuthChange(callback: (user: RuntimeIdentity | null) => void): () => void;
+    checkForSSOToken(): Promise<void>;
+    waitForAuth(): Promise<void>;
+    signInAnonymously(): Promise<void>;
+    signInWithPluto(): Promise<void>;
+    signOut(): Promise<void>;
+    getTurnCredentials(): Promise<any>;
+    updatePresence(localNodeId: string, ticketStr: string, isOnline?: boolean, ttlMs?: number, metadata?: string, deviceNameOverride?: string): Promise<void>;
+    setOffline(localNodeId: string): Promise<void>;
+    updateDevice(deviceId: string, updates: {
+        deviceName?: string;
+        capabilities?: Device['capabilities'];
+        metadata?: string;
+    }): Promise<void>;
+    deleteDevice(deviceId: string): Promise<void>;
+    cleanupStaleDevices(): Promise<void>;
+    sendMessage(targetId: string, payload: string, state?: string, replyPayload?: string): Promise<string>;
+    pollMessages(targetId: string): Promise<SignalingEnvelope[]>;
+    searchDevices(excludeNodeId?: string): Promise<Device[]>;
+    listDevicesWithStatus(): Promise<import('../types').DeviceStatusSnapshot[]>;
+    private searchDevicesViaWasm;
+    private onDevicesChangeViaWasmPolling;
+    getPeerSession(id: string): Promise<import('../types').PeerSessionSnapshot | null>;
+    listPeerSessions(): Promise<import('../types').PeerSessionSnapshot[]>;
+    waitForSettledPeer(id: string, timeoutMs?: number): Promise<import('../types').PeerSessionSnapshot | null>;
+    openPeerBi(id: string, timeoutMs?: number): Promise<import('../types').BackendPeerBiStream>;
+    openPeerUni(id: string, timeoutMs?: number): Promise<import('../types').BackendPeerUniStream>;
+    resolvePeerConnectionRecords(id: string): Promise<import('../types').ManagedConnectionRecord[]>;
+    resolvePeerIdentity(id: string): Promise<import('../types').ResolvedPeerIdentity>;
+    onDevicesChange(callback: (devices: Device[]) => void, excludeNodeId?: string): () => void;
+    subscribeDevices(userId: string): Promise<ReadableStream<DeviceEvent[]>>;
+    startAutoConnect(userId: string, localDeviceId: string): void;
+    notifyDisconnectRequested(remoteNodeId: string): void;
+    setAutoConnectExcluded(deviceId: string, excluded: boolean): Promise<void>;
+    connectToDevice(params: {
+        deviceId?: string | null;
+        endpointTicket: string;
+    }): Promise<import('../types').NativeConnectResult>;
+    forceReconnectSnapshot(): void;
+    startPresenceLoop(userId: string, localNodeId: string, deviceName: string, ticket: string, metadata?: string): void;
+    /**
+     * Build the RTDB discovery scope from the current auth context and options.
+     * Returns null if scope cannot be determined (e.g. not yet authenticated).
+     */
+    private buildRtdbScope;
+    createSession(session: SignalingSession): Promise<void>;
+    updateSession(sessionId: string, updateData: any): Promise<void>;
+    subscribeSessions(localDeviceId: string): Promise<ReadableStream<SessionEvent[]>>;
+    getLocalDeviceId(): Promise<string | null>;
+    isConnected(node_id: string): Promise<boolean>;
+    getConnectionStates(): Promise<BackendConnectionState[]>;
+    onConnectionStateChange(callback: (state: BackendConnectionState) => void): Promise<() => void> | (() => void);
+    sendExplicitFilePath(connectionId: string, filePath: string, transferId?: string): Promise<string>;
+    sendExplicitFileData(params: ExplicitFileDataSendParams): Promise<void>;
+    getTransferHistory(limit?: number): Promise<Array<[string, unknown]>>;
+    deleteTransferJob(jobId: string): Promise<void>;
+}