openrtc 0.1.0

package/dist/core/PlutoRTC.d.ts

@@ -0,0 +1,13 @@
+import type { Device, SignalingSession } from './types';
+import type { AuthContext, IEngineBridge } from './IEngineBridge';
+export declare class PlutoRTC {
+    private readonly transport;
+    constructor(transport: IEngineBridge);
+    setAuthContext(context: AuthContext | null): Promise<void>;
+    searchDevices(excludeNodeId?: string): Promise<Device[]>;
+    onDevicesChange(callback: (devices: Device[]) => void, excludeNodeId?: string): () => void;
+    subscribeSessions(localDeviceId: string, callback: (session: SignalingSession) => void): Promise<() => void>;
+    updatePresence(localNodeId: string, ticket: string, isOnline?: boolean, ttlMs?: number, metadata?: string): Promise<void>;
+    setOffline(localNodeId: string): Promise<void>;
+    forceReconnectSnapshot(): void;
+}

package/dist/core/PlutoRTC.js

@@ -0,0 +1,26 @@
+export class PlutoRTC {
+    constructor(transport) {
+        this.transport = transport;
+    }
+    async setAuthContext(context) {
+        await this.transport.setAuthContext(context);
+    }
+    async searchDevices(excludeNodeId) {
+        return this.transport.searchDevices(excludeNodeId);
+    }
+    onDevicesChange(callback, excludeNodeId) {
+        return this.transport.onDevicesChange(callback, excludeNodeId);
+    }
+    async subscribeSessions(localDeviceId, callback) {
+        return this.transport.subscribeSessions(localDeviceId, callback);
+    }
+    async updatePresence(localNodeId, ticket, isOnline = true, ttlMs = 300000, metadata) {
+        await this.transport.updatePresence(localNodeId, ticket, isOnline, ttlMs, metadata);
+    }
+    async setOffline(localNodeId) {
+        await this.transport.setOffline(localNodeId);
+    }
+    forceReconnectSnapshot() {
+        this.transport.forceReconnectSnapshot();
+    }
+}

package/dist/core/Room.d.ts

@@ -0,0 +1,47 @@
+import { Signaling } from './Signaling';
+import { Connection } from './Connection';
+import { Client } from './Client';
+import { JoinRoomOptions, RoomMember } from './types';
+import { RtdbPresence } from './bridges/RtdbPresence';
+export 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 (or joins the special 'demo' room if specified)
+     */
+    createRoom(): 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;
+}

package/dist/core/Room.js

@@ -0,0 +1,376 @@
+import { getAuthHost } from '../auth/host';
+import { BrowserFirestoreRooms } from './bridges/BrowserFirestoreRooms';
+export class RoomManager {
+    constructor(client, signaling) {
+        // Phase 2: RTDB replaces the 5-minute Firestore heartbeat interval.
+        // heartbeatStops is kept for graceful cleanup but now holds RTDB unregister
+        // callbacks rather than setInterval handles.
+        this.heartbeatStops = new Map();
+        this.browserRooms = null;
+        this.rtdbPresence = null;
+        this.client = client;
+        this.signaling = signaling;
+    }
+    getBrowserRooms() {
+        if (!this.browserRooms) {
+            this.browserRooms = new BrowserFirestoreRooms({
+                app: getAuthHost().getApp(),
+                getRoomBackendTag: () => this.client.getRoomBackendTag(),
+            });
+        }
+        // Phase 2: wire RTDB presence into the room watcher if available.
+        if (this.rtdbPresence && this.browserRooms) {
+            this.browserRooms.setRtdbPresence(this.rtdbPresence);
+        }
+        return this.browserRooms;
+    }
+    /**
+     * Phase 2: called by the runtime after RTDB presence is initialised
+     * (same RtdbPresence instance used for device presence in Phase 1).
+     */
+    setRtdbPresence(rtdbPresence) {
+        this.rtdbPresence = rtdbPresence;
+        // If browserRooms already exists, wire it in immediately.
+        if (this.browserRooms) {
+            this.browserRooms.setRtdbPresence(rtdbPresence);
+        }
+    }
+    usesDirectRoomBackend() {
+        return this.client.usesDirectRoomBackend();
+    }
+    get roomBackendTag() {
+        return this.client.getRoomBackendTag();
+    }
+    get appTag() {
+        return this.signaling.tag;
+    }
+    async invokeRoomCallable(name, payload) {
+        const { getFunctions, httpsCallable } = await import('firebase/functions');
+        const functions = getFunctions(getAuthHost().getApp());
+        const callable = httpsCallable(functions, name);
+        const result = await callable(payload);
+        return result.data;
+    }
+    isAlreadyExistsError(error) {
+        if (!error || typeof error !== 'object') {
+            return false;
+        }
+        const maybeCode = 'code' in error && typeof error.code === 'string' ? error.code : '';
+        const maybeMessage = 'message' in error && typeof error.message === 'string' ? error.message : '';
+        return maybeCode.includes('already-exists') || maybeMessage.toLowerCase().includes('already exists');
+    }
+    async getMembersInternal(roomId, myNodeId) {
+        if (!this.client.wasmClient)
+            throw new Error('WASM Client not loaded');
+        const memberId = myNodeId ?? await this.client.getNodeId();
+        const membersStr = await this.client.wasmClient.get_members(roomId, memberId, this.roomBackendTag);
+        return this.parseMemberDocuments(membersStr);
+    }
+    parseMemberDocuments(membersStr) {
+        const parsed = JSON.parse(membersStr);
+        return parsed.map((doc) => this.parseRoomMemberDocument(doc));
+    }
+    parseRoomMemberDocument(doc) {
+        const fields = doc.fields;
+        return {
+            nodeId: fields.nodeId?.stringValue || doc.name.split('/').pop(),
+            userId: fields.userId?.stringValue,
+            ticket: fields.ticket?.stringValue,
+            joinedAt: fields.joinedAt?.integerValue ? parseInt(fields.joinedAt.integerValue) : undefined,
+            lastSeenAt: fields.lastSeenAt?.integerValue ? parseInt(fields.lastSeenAt.integerValue) : undefined,
+            expiresAt: fields.expiresAt?.integerValue ? parseInt(fields.expiresAt.integerValue) : undefined,
+        };
+    }
+    /**
+     * Creates a new room (or joins the special 'demo' room if specified)
+     */
+    async createRoom() {
+        await this.client.ensureAuthenticated('room-op');
+        if (!this.client.wasmClient)
+            throw new Error("WASM Client not loaded");
+        const myTicket = await this.client.getTicket();
+        const myNodeId = await this.client.getNodeId();
+        const userId = this.signaling.currentUser?.id ?? myNodeId ?? 'anonymous';
+        if (!this.usesDirectRoomBackend()) {
+            await this.client.refreshHostedAppSettings();
+            if (this.client.roomCreationMode === 'server-only') {
+                throw new Error('This app uses server-only room creation. Create the room on your backend with your sk_live_... key, then call joinRoom(roomId) on the client.');
+            }
+            let roomId = '';
+            let created = false;
+            for (let i = 0; i < 3; i += 1) {
+                const bytes = new Uint8Array(6);
+                crypto.getRandomValues(bytes);
+                roomId = Array.from(bytes, b => b.toString(36).padStart(2, '0')).join('').substring(0, 6).toUpperCase();
+                try {
+                    await this.invokeRoomCallable('createClientRoom', {
+                        appTag: this.appTag,
+                        roomId,
+                        nodeId: myNodeId,
+                        ticket: myTicket,
+                    });
+                    created = true;
+                    break;
+                }
+                catch (error) {
+                    if (this.isAlreadyExistsError(error)) {
+                        continue;
+                    }
+                    throw error;
+                }
+            }
+            if (!created) {
+                throw new Error('Failed to create room after multiple attempts (ID collisions).');
+            }
+            await this.registerRtdbRoomMember(roomId, myNodeId);
+            return roomId;
+        }
+        // Generate 6-char random ID
+        // Try up to 3 times to account for collisions
+        let roomId = '';
+        let created = false;
+        for (let i = 0; i < 3; i++) {
+            const bytes = new Uint8Array(6);
+            crypto.getRandomValues(bytes);
+            roomId = Array.from(bytes, b => b.toString(36).padStart(2, '0')).join('').substring(0, 6).toUpperCase();
+            const maxMembers = this.client.appLimits.maxMembersPerRoom > 0
+                ? this.client.appLimits.maxMembersPerRoom
+                : undefined;
+            created = await this.client.wasmClient.create_room(roomId, userId, myTicket, myNodeId, this.roomBackendTag, maxMembers);
+            if (created) {
+                console.log(`Room created: ${roomId}`);
+                break;
+            }
+            else {
+                console.log(`Collision for roomId ${roomId}, retrying...`);
+            }
+        }
+        if (!created) {
+            throw new Error("Failed to create room after multiple attempts (ID collisions).");
+        }
+        await this.registerRtdbRoomMember(roomId, myNodeId);
+        return roomId;
+    }
+    /**
+     * Joins a room by ID.
+     */
+    async joinRoom(roomId, options = {}) {
+        await this.client.ensureAuthenticated('room-op');
+        if (!this.client.wasmClient)
+            throw new Error("WASM Client not loaded");
+        if (typeof roomId !== 'string' || roomId.length === 0 || roomId.length > 64) {
+            throw new Error('roomId must be a non-empty string of at most 64 characters');
+        }
+        if (roomId !== 'demo' && !/^[a-zA-Z0-9_-]+$/.test(roomId)) {
+            throw new Error('roomId must contain only alphanumeric characters, hyphens, or underscores');
+        }
+        const myTicket = await this.client.getTicket();
+        const myNodeId = await this.client.getNodeId();
+        const userId = this.signaling.currentUser?.id ?? myNodeId ?? 'anonymous';
+        const normalizedId = roomId.toUpperCase();
+        const targetRoomId = roomId === 'demo' ? 'demo' : roomId;
+        console.log('[RoomManager] joinRoom request', {
+            roomId,
+            normalizedId,
+            targetRoomId,
+            tag: this.roomBackendTag,
+            userId,
+            myNodeId,
+            hasTicket: !!myTicket,
+            ticketLength: myTicket?.length || 0,
+        });
+        try {
+            if (this.usesDirectRoomBackend()) {
+                await this.client.wasmClient.join_room(targetRoomId, userId, myTicket, myNodeId, this.roomBackendTag);
+            }
+            else {
+                await this.client.refreshHostedAppSettings();
+                await this.invokeRoomCallable('joinClientRoom', {
+                    appTag: this.appTag,
+                    roomId: targetRoomId,
+                    nodeId: myNodeId,
+                    ticket: myTicket,
+                });
+            }
+            console.log(`Joined room: ${targetRoomId}`);
+        }
+        catch (e) {
+            console.error("Join Room failed: ", e);
+            throw e;
+        }
+        // BOOTSTRAP: Connect to existing members
+        const members = await this.getMembersInternal(targetRoomId, myNodeId);
+        const connections = [];
+        if (options.bootstrapPeers !== false) {
+            const connectionPromises = members.map(async (member) => {
+                // Check expiration
+                let isExpired = false;
+                const now = Date.now();
+                if (member.expiresAt) {
+                    if (member.expiresAt < now)
+                        isExpired = true;
+                }
+                else {
+                    const lastSeen = member.lastSeenAt || member.joinedAt || 0;
+                    if (now - lastSeen > 5 * 60 * 1000)
+                        isExpired = true;
+                }
+                if (isExpired)
+                    return null;
+                if (member.ticket) {
+                    try {
+                        console.log(`Bootstrapping: Connecting to peer ${member.nodeId}...`);
+                        // Use 5s timeout for bootstrapping
+                        const conn = await this.client.connect(member.ticket, 5000);
+                        conn.send({ type: 'chat', text: `Use ${userId} joined the room.` });
+                        return conn;
+                    }
+                    catch (e) {
+                        console.warn(`Failed to connect to peer ${member.nodeId}:`, e);
+                        return null;
+                    }
+                }
+                return null;
+            });
+            const results = await Promise.allSettled(connectionPromises);
+            results.forEach(result => {
+                if (result.status === 'fulfilled' && result.value) {
+                    connections.push(result.value);
+                }
+            });
+        }
+        // Phase 2: Register RTDB presence (replaces 5-minute Firestore heartbeat).
+        await this.registerRtdbRoomMember(targetRoomId, myNodeId);
+        return connections;
+    }
+    async leaveRoom(roomId) {
+        if (!this.usesDirectRoomBackend()) {
+            await this.client.ensureAuthenticated('room-op');
+        }
+        const myNodeId = await this.client.getNodeId();
+        if (!myNodeId)
+            return;
+        console.log(`Leaving room ${roomId}...`);
+        // Phase 2: mark offline in RTDB immediately on graceful leave.
+        await this.markRtdbRoomMemberOffline(roomId, myNodeId);
+        this.stopHeartbeat(roomId);
+        const targetRoomId = roomId === 'demo' ? 'demo' : roomId;
+        try {
+            if (this.usesDirectRoomBackend()) {
+                await this.client.wasmClient.leave_room(targetRoomId, myNodeId, this.roomBackendTag);
+            }
+            else {
+                await this.invokeRoomCallable('leaveClientRoom', {
+                    appTag: this.appTag,
+                    roomId: targetRoomId,
+                    nodeId: myNodeId,
+                });
+            }
+            console.log(`Left room: ${targetRoomId}`);
+        }
+        catch (e) {
+            console.warn("Leave room failed:", e);
+            throw e;
+        }
+    }
+    async getRoomMembers(roomId) {
+        await this.client.ensureAuthenticated('room-op');
+        const targetRoomId = roomId === 'demo' ? 'demo' : roomId;
+        return this.getMembersInternal(targetRoomId);
+    }
+    watchRoom(roomId, callback) {
+        let cancelled = false;
+        let stopWatching = null;
+        void (async () => {
+            try {
+                await this.client.ensureAuthenticated('room-op');
+                if (cancelled) {
+                    return;
+                }
+                const targetRoomId = roomId === 'demo' ? 'demo' : roomId;
+                const myNodeId = await this.client.getNodeId();
+                if (cancelled) {
+                    return;
+                }
+                stopWatching = this.getBrowserRooms().watchMembers(targetRoomId, myNodeId, callback);
+                if (cancelled) {
+                    stopWatching();
+                    stopWatching = null;
+                }
+            }
+            catch (error) {
+                if (!cancelled) {
+                    console.warn('[RoomManager] watchRoom listener failed:', error);
+                }
+            }
+        })();
+        return () => {
+            cancelled = true;
+            stopWatching?.();
+            stopWatching = null;
+        };
+    }
+    // --- Phase 2: RTDB room member presence ---
+    /**
+     * 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.
+     */
+    async registerRtdbRoomMember(roomId, memberId) {
+        this.stopHeartbeat(roomId);
+        if (this.rtdbPresence) {
+            const appTag = this.roomBackendTag;
+            try {
+                await this.rtdbPresence.registerRoomMember(appTag, roomId, memberId);
+            }
+            catch (err) {
+                console.warn('[RoomManager] RTDB room member register failed:', err);
+                // Fall through — room join already succeeded in Firestore.
+            }
+            // Store a no-op stop handle (actual cleanup happens in markRtdbRoomMemberOffline).
+            this.heartbeatStops.set(roomId, () => {
+                void this.markRtdbRoomMemberOffline(roomId, memberId);
+            });
+        }
+        else {
+            // Fallback: legacy 5-minute Firestore heartbeat.
+            this.startLegacyHeartbeat(roomId, memberId);
+        }
+    }
+    async markRtdbRoomMemberOffline(roomId, memberId) {
+        if (!this.rtdbPresence)
+            return;
+        const appTag = this.roomBackendTag;
+        try {
+            await this.rtdbPresence.markRoomMemberOffline(appTag, roomId, memberId);
+        }
+        catch (err) {
+            console.warn('[RoomManager] RTDB markRoomMemberOffline failed:', err);
+        }
+    }
+    // --- Legacy fallback heartbeat (used when RTDB is not available) ---
+    startLegacyHeartbeat(roomId, memberId) {
+        const interval = setInterval(() => {
+            if (this.client.wasmClient) {
+                this.client.wasmClient.heartbeat_tick(roomId, memberId, this.roomBackendTag).catch(console.error);
+            }
+        }, 300000); // 5 minutes — liveness/expiry only; real-time member awareness via listener
+        this.heartbeatStops.set(roomId, () => clearInterval(interval));
+    }
+    stopHeartbeat(roomId) {
+        if (typeof roomId === 'string') {
+            const stop = this.heartbeatStops.get(roomId);
+            if (stop) {
+                stop();
+                this.heartbeatStops.delete(roomId);
+                console.log(`Heartbeat stopped for room ${roomId}.`);
+            }
+            return;
+        }
+        for (const [activeRoomId, stop] of this.heartbeatStops.entries()) {
+            stop();
+            console.log(`Heartbeat stopped for room ${activeRoomId}.`);
+        }
+        this.heartbeatStops.clear();
+    }
+}

package/dist/core/Signaling.d.ts

@@ -0,0 +1,39 @@
+import { ISignalingBackend, Device, SignalingOptions, RuntimeIdentity, BackendConnectionState } from './types';
+export declare class Signaling {
+    appTag: string;
+    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<import("./types").SignalingEnvelope[]>;
+    subscribeSessions(localDeviceId: string, callback: (session: import('./types').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;
+}

package/dist/core/Signaling.js

@@ -0,0 +1,147 @@
+import { resolveAppTag } from './config';
+import { getAuthHost } from '../auth/host';
+export class Signaling {
+    constructor(options, backend) {
+        this.appTag = resolveAppTag(options);
+        this.backend = backend;
+    }
+    get tag() {
+        return this.appTag;
+    }
+    async waitForAuth() {
+        return this.backend.waitForAuth();
+    }
+    get currentUser() {
+        return this.backend.currentUser;
+    }
+    onAuthChange(callback) {
+        return this.backend.onAuthChange(callback);
+    }
+    async signInAnonymously() {
+        await this.backend.signInAnonymously();
+    }
+    async signInWithPluto() {
+        if (typeof this.backend.signInWithPluto === 'function') {
+            await this.backend.signInWithPluto();
+            return;
+        }
+        await getAuthHost().signInWithPluto();
+    }
+    async signOut() {
+        await this.backend.signOut();
+    }
+    async stopAuthScopedActivity() {
+        if (typeof this.backend.stopAuthScopedActivity === 'function') {
+            await this.backend.stopAuthScopedActivity();
+        }
+    }
+    async getTurnCredentials() {
+        return this.backend.getTurnCredentials();
+    }
+    // --- Presence ---
+    async updatePresence(localNodeId, ticketStr, isOnline = true, ttlMs = 5 * 60 * 1000, metadata) {
+        await this.backend.updatePresence(localNodeId, ticketStr, isOnline, ttlMs, metadata);
+    }
+    async setOffline(localNodeId) {
+        await this.backend.setOffline(localNodeId);
+    }
+    async cleanupStaleDevices() {
+        await this.backend.cleanupStaleDevices();
+    }
+    async sendMessage(targetId, payload, state, replyPayload) {
+        return this.backend.sendMessage(targetId, payload, state, replyPayload);
+    }
+    async pollMessages(targetId) {
+        return this.backend.pollMessages(targetId);
+    }
+    async subscribeSessions(localDeviceId, callback) {
+        const stream = await this.backend.subscribeSessions(localDeviceId);
+        const reader = stream.getReader();
+        let isCancelled = false;
+        const poll = async () => {
+            try {
+                while (!isCancelled) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    if (value) {
+                        for (const event of value) {
+                            if ('session' in event && event.session) {
+                                callback(event.session);
+                            }
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                if (!isCancelled)
+                    console.error("[Signaling] Session stream error:", err);
+            }
+        };
+        poll();
+        return () => {
+            isCancelled = true;
+            reader.cancel();
+        };
+    }
+    async getLocalDeviceId() {
+        if (typeof this.backend.getLocalDeviceId !== 'function') {
+            return null;
+        }
+        return this.backend.getLocalDeviceId();
+    }
+    // --- Discovery ---
+    async searchDevices(excludeNodeId) {
+        return this.backend.searchDevices(excludeNodeId);
+    }
+    async updateDevice(deviceId, updates) {
+        await this.backend.updateDevice(deviceId, updates);
+    }
+    async deleteDevice(deviceId) {
+        await this.backend.deleteDevice(deviceId);
+    }
+    onDevicesChange(callback, excludeNodeId) {
+        return this.backend.onDevicesChange(callback, excludeNodeId);
+    }
+    startAutoConnect(userId, localDeviceId) {
+        this.backend.startAutoConnect(userId, localDeviceId);
+    }
+    notifyDisconnectRequested(remoteNodeId) {
+        if (typeof this.backend.notifyDisconnectRequested === 'function') {
+            this.backend.notifyDisconnectRequested(remoteNodeId);
+        }
+    }
+    startPresenceLoop(userId, localNodeId, deviceName, ticket, metadata) {
+        this.backend.startPresenceLoop(userId, localNodeId, deviceName, ticket, metadata);
+    }
+    forceReconnectSnapshot() {
+        this.backend.forceReconnectSnapshot();
+    }
+    async isConnected(nodeId) {
+        return this.backend.isConnected(nodeId);
+    }
+    async getConnectionStates() {
+        if (typeof this.backend.getConnectionStates === 'function') {
+            return this.backend.getConnectionStates();
+        }
+        return [];
+    }
+    onConnectionStateChange(callback) {
+        if (typeof this.backend.onConnectionStateChange === 'function') {
+            return this.backend.onConnectionStateChange(callback);
+        }
+        return () => { };
+    }
+    supportsRustPeerLifecycleProjection() {
+        return typeof this.backend.listPeerSessions === 'function'
+            || typeof this.backend.getPeerSession === 'function'
+            || typeof this.backend.waitForSettledPeer === 'function'
+            || typeof this.backend.getConnectionStates === 'function';
+    }
+    setWasmClient(client) {
+        const backendAny = this.backend;
+        if (backendAny && typeof backendAny.setWasmClient === 'function') {
+            backendAny.setWasmClient(client);
+        }
+    }
+}

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

@@ -0,0 +1,19 @@
+import type { BackendConnectionState, Device, DeviceStatusSnapshot, ManagedConnectionRecord, PeerSessionSnapshot, ResolvedPeerIdentity } from '../types';
+export declare function pickString(raw: Record<string, any>, ...keys: string[]): string | undefined;
+export declare function pickBoolean(raw: Record<string, any>, ...keys: string[]): boolean | undefined;
+export declare function pickNumber(raw: Record<string, any>, ...keys: string[]): number | undefined;
+export declare function isPersonalSpaceMode(options: {
+    discoveryMode?: string;
+    apiKey?: string;
+    spaceKey?: string;
+}): boolean;
+export declare function matchesDiscoveryTag(device: Pick<Device, 'tag' | 'appTag'>, appTag: string, personalMode: boolean): boolean;
+export declare function normalizeDeviceRecord(raw: unknown, fallbackId?: string): Device;
+export declare function normalizeDeviceStatusSnapshotRecord(raw: unknown): DeviceStatusSnapshot;
+export declare function normalizePeerSessionSnapshotRecord(raw: unknown): PeerSessionSnapshot;
+export declare function normalizeManagedConnectionRecord(raw: unknown): ManagedConnectionRecord;
+export declare function normalizeResolvedPeerIdentity(raw: unknown): ResolvedPeerIdentity;
+export declare function mapPeerSessionStatusToBackendState(status: PeerSessionSnapshot['status']): BackendConnectionState['state'];
+export declare function peerSessionToBackendConnectionState(snapshot: PeerSessionSnapshot): BackendConnectionState | null;
+export declare function normalizeConnectionStateSnapshot(raw: unknown): BackendConnectionState | null;
+export declare function sameConnectionState(left: BackendConnectionState | undefined, right: BackendConnectionState): boolean;