openrtc 0.1.0

package/dist/core/bridges/NativeIpcBridge.js

@@ -0,0 +1,1472 @@
+import { WasmBridge } from './WasmBridge';
+import { normalizeDeviceStatusSnapshotRecord, normalizeManagedConnectionRecord, normalizePeerSessionSnapshotRecord, normalizeResolvedPeerIdentity, } from './BridgeCodecs';
+import { isTauriEnvironment } from '../../utils/runtime';
+import { getAuthHost } from '../../auth/host';
+import { assertValidIpcBridge, createCompatTauriIpcBridge, } from '../../runtime/ipc';
+import { openRtcDebug, openRtcDebugInfo } from '../../utils/debug';
+function fingerprintForLogs(value) {
+    if (!value) {
+        return null;
+    }
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < value.length; i += 1) {
+        hash ^= value.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return `fp-${(hash >>> 0).toString(16).padStart(8, '0')}`;
+}
+export class NativeIpcBridge {
+    constructor(options) {
+        /**
+         * NativeIpcBridge is a host adapter for native IPC.
+         *
+         * Allowed:
+         * - lightweight IPC readiness checks
+         * - native auth relay
+         * - typed command/event forwarding
+         *
+         * Not allowed:
+         * - becoming a second lifecycle engine
+         * - owning peer identity policy
+         * - teaching product code to depend on native-specific fallbacks
+         *
+         * Source of truth:
+         * - Rust core owns connection lifecycle and device identity
+         * - RuntimeClient owns host-facing orchestration
+         */
+        this.subscriptionNonce = 0;
+        this.lastSyncedAuthToken = null;
+        this.cachedLocalDeviceId = null;
+        this.cachedLocalDeviceName = null;
+        this.tauriCoreAvailability = null;
+        this.tauriCoreAvailabilityValue = null;
+        this.tauriCoreAvailabilityCheckedAtMs = 0;
+        this.authSyncInFlight = null;
+        this.lastNativeAuthSyncAtMs = 0;
+        this.hasLoggedMissingAuthForDevices = false;
+        this.nativeRtdbPresenceScope = null;
+        this.nativeRtdbTicketVersion = 0;
+        this.lastNativePresenceTicket = null;
+        this.fallback = new WasmBridge(options);
+        this.app = this.fallback.app;
+        this.auth = this.fallback.auth;
+        this.appTag = this.fallback.appTag;
+        this.options = this.fallback.getResolvedOptions();
+        this.allowWasmFallback = options.allowWasmFallback ?? false;
+        this.ipcBridge = assertValidIpcBridge(options.ipcBridge ?? createCompatTauriIpcBridge(), 'NativeIpcBridge');
+    }
+    get currentUser() {
+        return this.fallback.currentUser;
+    }
+    get tag() {
+        return this.fallback.tag;
+    }
+    setWasmClient(client) {
+        this.fallback.setWasmClient(client);
+    }
+    onAuthChange(callback) {
+        return this.fallback.onAuthChange(callback);
+    }
+    checkForSSOToken() {
+        return this.fallback.checkForSSOToken();
+    }
+    waitForAuth() {
+        return this.fallback.waitForAuth();
+    }
+    signInAnonymously() {
+        return this.fallback.signInAnonymously();
+    }
+    getTurnCredentials() {
+        return this.fallback.getTurnCredentials();
+    }
+    cleanupStaleDevices() {
+        return this.fallback.cleanupStaleDevices();
+    }
+    sendMessage(targetId, payload, state, replyPayload) {
+        return this.fallback.sendMessage(targetId, payload, state, replyPayload);
+    }
+    pollMessages(targetId) {
+        return this.fallback.pollMessages(targetId);
+    }
+    createSession(session) {
+        return this.fallback.createSession(session);
+    }
+    updateSession(sessionId, updateData) {
+        return this.fallback.updateSession(sessionId, updateData);
+    }
+    openPeerBi(id, timeoutMs) {
+        return this.fallback.openPeerBi(id, timeoutMs);
+    }
+    openPeerUni(id, timeoutMs) {
+        return this.fallback.openPeerUni(id, timeoutMs);
+    }
+    isConnected(nodeId) {
+        return this.fallback.isConnected(nodeId);
+    }
+    getAuthContext() {
+        return this.fallback.getAuthContext();
+    }
+    getCurrentUserId() {
+        return this.fallback.getCurrentUserIdForScope();
+    }
+    resolveWebLogicalDeviceId() {
+        return this.fallback.getResolvedWebLogicalDeviceId();
+    }
+    normalizeDevice(raw, fallbackId) {
+        return this.fallback.normalizeDeviceRecord(raw, fallbackId);
+    }
+    matchesTag(device) {
+        return this.fallback.matchesDiscoveryTag(device);
+    }
+    buildNativeRtdbScope(userIdHint) {
+        const mode = this.options.discoveryMode ?? 'personal';
+        if (mode === 'personal') {
+            return null;
+        }
+        const userId = userIdHint ?? this.getCurrentUserId();
+        if (!userId) {
+            return null;
+        }
+        return {
+            kind: 'user-scoped',
+            appTag: this.appTag,
+            userId,
+        };
+    }
+    async syncNativeRtdbPresenceTicket(ticket) {
+        const scope = this.buildNativeRtdbScope();
+        const localDeviceId = await this.resolveLocalDeviceId();
+        if (!scope || !localDeviceId) {
+            return;
+        }
+        const rtdbPresence = this.fallback.rtdbPresence;
+        if (!rtdbPresence || !this.nativeRtdbPresenceScope) {
+            await this.fallback.registerRtdbPresence(scope, localDeviceId, this.nativeRtdbTicketVersion);
+            this.nativeRtdbPresenceScope = scope;
+            this.lastNativePresenceTicket = ticket;
+            openRtcDebugInfo('[NativeIpcBridge][RTDB] registered native presence ticket state', {
+                deviceId: localDeviceId,
+                ticketVersion: this.nativeRtdbTicketVersion,
+                ticketFingerprint: fingerprintForLogs(ticket),
+            });
+            return;
+        }
+        const ticketChanged = this.lastNativePresenceTicket !== ticket;
+        const scopeChanged = this.nativeRtdbPresenceScope.kind !== scope.kind ||
+            (scope.kind === 'user-scoped' &&
+                this.nativeRtdbPresenceScope.kind === 'user-scoped' &&
+                (this.nativeRtdbPresenceScope.appTag !== scope.appTag ||
+                    this.nativeRtdbPresenceScope.userId !== scope.userId));
+        if (scopeChanged) {
+            await this.fallback.registerRtdbPresence(scope, localDeviceId, this.nativeRtdbTicketVersion);
+            this.nativeRtdbPresenceScope = scope;
+        }
+        if (ticketChanged) {
+            this.nativeRtdbTicketVersion += 1;
+            await this.fallback.rtdbPresence?.bumpTicketVersion(scope, localDeviceId, this.nativeRtdbTicketVersion);
+            openRtcDebugInfo('[NativeIpcBridge][RTDB] bumped native ticketVersion after managed ticket change', {
+                deviceId: localDeviceId,
+                ticketVersion: this.nativeRtdbTicketVersion,
+                ticketFingerprint: fingerprintForLogs(ticket),
+            });
+        }
+        this.nativeRtdbPresenceScope = scope;
+        this.lastNativePresenceTicket = ticket;
+    }
+    async markNativeRtdbOffline() {
+        if (!this.nativeRtdbPresenceScope) {
+            return;
+        }
+        const localDeviceId = await this.resolveLocalDeviceId();
+        if (!localDeviceId) {
+            return;
+        }
+        try {
+            await this.fallback.rtdbPresence?.markOffline(this.nativeRtdbPresenceScope, localDeviceId, this.nativeRtdbTicketVersion);
+            openRtcDebugInfo('[NativeIpcBridge][RTDB] marked native presence offline', {
+                deviceId: localDeviceId,
+                ticketVersion: this.nativeRtdbTicketVersion,
+            });
+        }
+        catch (error) {
+            console.warn('[NativeIpcBridge][RTDB] failed to mark native presence offline:', error);
+        }
+        finally {
+            this.nativeRtdbPresenceScope = null;
+            this.nativeRtdbTicketVersion = 0;
+            this.lastNativePresenceTicket = null;
+        }
+    }
+    isTauriEnv() {
+        return isTauriEnvironment();
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    nextConnectionEventRetryDelayMs(attempt) {
+        const backoff = NativeIpcBridge.CONNECTION_EVENT_RETRY_MIN_DELAY_MS * Math.pow(2, Math.max(0, attempt - 1));
+        return Math.min(NativeIpcBridge.CONNECTION_EVENT_RETRY_MAX_DELAY_MS, backoff);
+    }
+    async clearNativeAuthRelay(reason) {
+        if (!(await this.canUseTauriIpc())) {
+            return;
+        }
+        try {
+            await this.invokeIpc('desktop_set_pluto_auth_token', {
+                authToken: null,
+                refreshToken: null,
+            });
+            this.lastSyncedAuthToken = null;
+            this.lastNativeAuthSyncAtMs = 0;
+            openRtcDebugInfo(`[NativeIpcBridge] cleared native auth relay (${reason})`);
+        }
+        catch (error) {
+            console.warn(`[NativeIpcBridge] failed clearing native auth relay (${reason}):`, error);
+        }
+    }
+    async canUseTauriIpc() {
+        if (this.ipcBridge) {
+            if (typeof this.ipcBridge.isAvailable === 'function') {
+                return !!(await this.ipcBridge.isAvailable());
+            }
+            return true;
+        }
+        if (typeof window === 'undefined') {
+            return false;
+        }
+        if (this.tauriCoreAvailabilityValue === true) {
+            return true;
+        }
+        // Do not permanently cache "false". Tauri globals/IPC can appear slightly after boot.
+        if (this.tauriCoreAvailabilityValue === false &&
+            Date.now() - this.tauriCoreAvailabilityCheckedAtMs <
+                NativeIpcBridge.TAURI_IPC_NEGATIVE_CACHE_MS) {
+            return false;
+        }
+        if (!this.tauriCoreAvailability) {
+            this.tauriCoreAvailability = (async () => {
+                try {
+                    // Fast path: canonical Tauri globals are present.
+                    if (this.isTauriEnv()) {
+                        this.tauriCoreAvailabilityValue = true;
+                        this.tauriCoreAvailabilityCheckedAtMs = Date.now();
+                        return true;
+                    }
+                    // Fallback path: some runtimes may not expose globals consistently.
+                    // Probe IPC directly and treat command-level failures as "IPC exists".
+                    try {
+                        await this.invokeIpc('rtc_native_status');
+                        openRtcDebugInfo('[NativeIpcBridge] Resolved Tauri IPC via rtc_native_status probe');
+                        this.tauriCoreAvailabilityValue = true;
+                        this.tauriCoreAvailabilityCheckedAtMs = Date.now();
+                        return true;
+                    }
+                    catch (error) {
+                        const message = String(error?.message ?? error ?? '');
+                        const missingRuntime = message.includes('__TAURI_INTERNALS__') ||
+                            message.includes('Cannot read properties of undefined') ||
+                            message.includes('window is not defined');
+                        if (!missingRuntime) {
+                            openRtcDebugInfo('[NativeIpcBridge] Tauri IPC probe reached native layer (command-level error acceptable)');
+                            this.tauriCoreAvailabilityValue = true;
+                            this.tauriCoreAvailabilityCheckedAtMs = Date.now();
+                            return true;
+                        }
+                        this.tauriCoreAvailabilityValue = false;
+                        this.tauriCoreAvailabilityCheckedAtMs = Date.now();
+                        return false;
+                    }
+                }
+                catch {
+                    this.tauriCoreAvailabilityValue = false;
+                    this.tauriCoreAvailabilityCheckedAtMs = Date.now();
+                    return false;
+                }
+            })().finally(() => {
+                this.tauriCoreAvailability = null;
+            });
+        }
+        return this.tauriCoreAvailability;
+    }
+    async invokeIpc(command, args) {
+        return this.ipcBridge.invoke(command, args);
+    }
+    async listenIpc(event, handler) {
+        return this.ipcBridge.listen(event, (payload) => {
+            handler({ payload });
+        });
+    }
+    async shouldUseTauriSignaling() {
+        const available = await this.canUseTauriIpc();
+        if (available) {
+            return true;
+        }
+        if (this.allowWasmFallback) {
+            return false;
+        }
+        throw new Error('[pluto-rtc] Tauri runtime adapter requires native IPC, but it is unavailable.');
+    }
+    async signInWithPluto() {
+        if (!(await this.canUseTauriIpc())) {
+            await this.fallback.signInWithPluto();
+            return;
+        }
+        const result = await this.invokeIpc('rtc_sign_in_with_pluto');
+        const customToken = typeof result?.customToken === 'string' ? result.customToken.trim() : '';
+        if (!customToken) {
+            throw new Error('[pluto-rtc] Native Pluto SSO did not return a custom token.');
+        }
+        await getAuthHost().signInWithCustomTokenValue(customToken);
+        await this.ensureNativeAuth('pluto-sso', { requireToken: true, maxWaitMs: 10000 });
+    }
+    async setAuthContext(context) {
+        await this.fallback.setAuthContext(context);
+        if (!context?.token) {
+            await this.markNativeRtdbOffline();
+            await this.clearNativeAuthRelay('setAuthContext');
+        }
+    }
+    async signOut() {
+        await this.fallback.signOut();
+        await this.markNativeRtdbOffline();
+        await this.clearNativeAuthRelay('signOut');
+    }
+    async stopAuthScopedActivity(options) {
+        const userId = options?.userId ?? this.currentUser?.id ?? null;
+        if (await this.shouldUseTauriSignaling()) {
+            try {
+                await Promise.allSettled([
+                    this.revokeSessionTokensByScope('user-device'),
+                    this.invokeIpc('stop_rtc_presence_loop'),
+                    this.invokeIpc('stop_rtc_auto_connect'),
+                    userId ? this.invokeIpc('set_rtc_offline', { userId }) : Promise.resolve(),
+                ]);
+            }
+            catch (error) {
+                console.warn('[NativeIpcBridge] Failed to stop native auth-scoped RTC activity:', error);
+            }
+        }
+        await this.markNativeRtdbOffline();
+        await this.fallback.stopAuthScopedActivity({ userId });
+    }
+    async ensureNativeAuthOnce(reason, requireToken) {
+        if (!(await this.canUseTauriIpc()))
+            return true;
+        if (this.authSyncInFlight) {
+            return this.authSyncInFlight;
+        }
+        const syncPromise = (async () => {
+            try {
+                if (!this.currentUser) {
+                    console.warn(`[NativeIpcBridge] auth sync skipped (${reason}): no current user`);
+                    return !requireToken;
+                }
+                const shouldForceRefresh = (Date.now() - this.lastNativeAuthSyncAtMs) >= (8 * 60 * 1000);
+                const token = this.currentUser?.getToken
+                    ? await this.currentUser.getToken(shouldForceRefresh)
+                    : null;
+                const authContext = this.getAuthContext();
+                const refreshToken = authContext?.refreshToken ??
+                    (this.auth?.currentUser?.refreshToken ?? null);
+                if (!token) {
+                    console.warn(`[NativeIpcBridge] auth sync skipped (${reason}): missing token for user ${this.currentUser?.id}`);
+                    return !requireToken;
+                }
+                if (token === this.lastSyncedAuthToken) {
+                    return true;
+                }
+                const relayResult = await Promise.allSettled([
+                    this.invokeIpc('desktop_set_pluto_auth_token', { authToken: token, refreshToken }),
+                ]);
+                if (relayResult[0]?.status === 'rejected') {
+                    console.warn(`[NativeIpcBridge] desktop auth relay failed (${reason}):`, relayResult[0].reason);
+                    return false;
+                }
+                this.lastSyncedAuthToken = token;
+                this.lastNativeAuthSyncAtMs = Date.now();
+                openRtcDebugInfo(`[NativeIpcBridge] auth token relayed to native runtime (${reason}) user_id=${this.currentUser?.id}`);
+                return true;
+            }
+            catch (error) {
+                console.error('[NativeIpcBridge] auth sync failed:', error);
+                return false;
+            }
+        })();
+        this.authSyncInFlight = syncPromise;
+        try {
+            return await syncPromise;
+        }
+        finally {
+            if (this.authSyncInFlight === syncPromise) {
+                this.authSyncInFlight = null;
+            }
+        }
+    }
+    async ensureNativeAuth(reason = 'runtime', options) {
+        if (!(await this.canUseTauriIpc()))
+            return true;
+        const requireToken = options?.requireToken ?? false;
+        const maxWaitMs = options?.maxWaitMs ?? (requireToken ? NativeIpcBridge.AUTH_REQUIRED_WAIT_MS : 0);
+        const pollMs = options?.pollMs ?? 250;
+        const deadlineMs = Date.now() + Math.max(0, maxWaitMs);
+        while (true) {
+            const ready = await this.ensureNativeAuthOnce(reason, requireToken);
+            if (ready) {
+                return true;
+            }
+            if (!requireToken || Date.now() >= deadlineMs) {
+                return false;
+            }
+            await this.sleep(pollMs);
+        }
+    }
+    async resolveLocalDeviceId() {
+        if (this.cachedLocalDeviceId)
+            return this.cachedLocalDeviceId;
+        if (await this.canUseTauriIpc()) {
+            try {
+                const info = await this.invokeIpc('get_rtc_local_device_info');
+                const nativeDeviceId = typeof info?.device_id === 'string' ? info.device_id : '';
+                const nativeDeviceName = typeof info?.device_name === 'string' ? info.device_name.trim() : '';
+                if (nativeDeviceId) {
+                    this.cachedLocalDeviceId = nativeDeviceId;
+                    if (nativeDeviceName) {
+                        this.cachedLocalDeviceName = nativeDeviceName;
+                    }
+                    return nativeDeviceId;
+                }
+            }
+            catch (error) {
+                console.warn('[NativeIpcBridge] get_rtc_local_device_info failed:', error);
+            }
+        }
+        const fallbackDeviceId = this.resolveWebLogicalDeviceId();
+        this.cachedLocalDeviceId = fallbackDeviceId;
+        return fallbackDeviceId;
+    }
+    async resolveLocalDeviceName() {
+        if (this.cachedLocalDeviceName) {
+            return this.cachedLocalDeviceName;
+        }
+        if (await this.canUseTauriIpc()) {
+            try {
+                const info = await this.invokeIpc('get_rtc_local_device_info');
+                const nativeDeviceName = typeof info?.device_name === 'string' ? info.device_name.trim() : '';
+                if (nativeDeviceName) {
+                    const resolvedName = this.normalizeNativeDeviceName(nativeDeviceName);
+                    this.cachedLocalDeviceName = resolvedName;
+                    return resolvedName;
+                }
+            }
+            catch (error) {
+                console.warn('[NativeIpcBridge] get_rtc_local_device_info failed:', error);
+            }
+        }
+        return this.defaultDeviceNameFallback();
+    }
+    normalizeNativeDeviceName(rawName) {
+        const trimmedName = rawName.trim();
+        if (!trimmedName) {
+            return this.defaultDeviceNameFallback();
+        }
+        if (trimmedName === 'Desktop Device') {
+            const fallbackName = this.defaultDeviceNameFallback();
+            if (fallbackName !== 'Desktop Device') {
+                return fallbackName;
+            }
+        }
+        return trimmedName;
+    }
+    defaultDeviceNameFallback() {
+        if (typeof window === 'undefined' || typeof navigator === 'undefined') {
+            return 'Desktop Device';
+        }
+        const userAgent = navigator.userAgent || '';
+        if (/iPhone|iPad|iPod/i.test(userAgent)) {
+            return 'iPhone';
+        }
+        if (/Android/i.test(userAgent)) {
+            return 'Android';
+        }
+        return 'Desktop Device';
+    }
+    withPresenceMetadata(metadata, deviceId) {
+        try {
+            const data = metadata ? JSON.parse(metadata) : {};
+            return JSON.stringify({ ...data, deviceId, plutoVersion: '0.1.0-desktop' });
+        }
+        catch {
+            return JSON.stringify({ deviceId, plutoVersion: '0.1.0-desktop', rawMetadata: metadata });
+        }
+    }
+    // ── ISignalingBackend overrides ──────────────────────────────────────
+    async searchDevices(excludeNodeId) {
+        if (await this.shouldUseTauriSignaling()) {
+            const authReady = await this.ensureNativeAuth('searchDevices', {
+                requireToken: true,
+                maxWaitMs: NativeIpcBridge.AUTH_REQUIRED_WAIT_MS,
+            });
+            if (!authReady) {
+                throw new Error('Native auth token unavailable for searchDevices');
+            }
+            const result = await this.invokeIpc('search_rtc_devices', {
+                userId: this.currentUser?.id,
+            });
+            if (Array.isArray(result?.devices)) {
+                let devices = result.devices.map((d) => this.normalizeDevice(d));
+                if (excludeNodeId) {
+                    devices = devices.filter((d) => d.ticket !== excludeNodeId &&
+                        d.deviceId !== excludeNodeId &&
+                        d.nodeId !== excludeNodeId);
+                }
+                return devices;
+            }
+            if (typeof result?.message === 'string') {
+                throw new Error(String(result.message));
+            }
+            throw new Error('Unexpected response for search_rtc_devices');
+        }
+        return this.fallback.searchDevices(excludeNodeId);
+    }
+    async listDevicesWithStatus() {
+        if (await this.shouldUseTauriSignaling()) {
+            const authReady = await this.ensureNativeAuth('listDevicesWithStatus', {
+                requireToken: true,
+                maxWaitMs: NativeIpcBridge.AUTH_REQUIRED_WAIT_MS,
+            });
+            if (!authReady) {
+                throw new Error('Native auth token unavailable for listDevicesWithStatus');
+            }
+            const result = await this.invokeIpc('search_rtc_devices_with_status', {
+                userId: this.currentUser?.id,
+            });
+            if (Array.isArray(result?.devices)) {
+                const devices = result.devices
+                    .map((device) => normalizeDeviceStatusSnapshotRecord(device))
+                    .filter((device) => this.matchesTag(device));
+                openRtcDebug('[NativeIpcBridge] listDevicesWithStatus result', {
+                    count: devices.length,
+                    devices: devices.map((device) => ({
+                        deviceId: device.deviceId,
+                        deviceName: device.deviceName,
+                        online: !!device.online,
+                        connectionStatus: device.connectionStatus,
+                        settledReady: !!device.settledReady,
+                        peerHealth: device.peerHealth,
+                        scopes: device.scopes,
+                        connectionId: device.connectionId ?? null,
+                        deviceIdHint: device.deviceIdHint ?? null,
+                        nodeId: device.nodeId ?? null,
+                    })),
+                });
+                return devices;
+            }
+            if (typeof result?.message === 'string') {
+                throw new Error(String(result.message));
+            }
+            throw new Error('Unexpected response for search_rtc_devices_with_status');
+        }
+        return this.fallback.listDevicesWithStatus();
+    }
+    async getPeerSession(id) {
+        if (await this.shouldUseTauriSignaling()) {
+            const snapshot = await this.invokeIpc('get_rtc_peer_session', { id });
+            if (!snapshot || typeof snapshot !== 'object') {
+                return null;
+            }
+            return normalizePeerSessionSnapshotRecord(snapshot);
+        }
+        return this.fallback.getPeerSession(id);
+    }
+    async listPeerSessions() {
+        if (await this.shouldUseTauriSignaling()) {
+            const snapshots = await this.invokeIpc('list_rtc_peer_sessions');
+            return (Array.isArray(snapshots) ? snapshots : []).map((snapshot) => normalizePeerSessionSnapshotRecord(snapshot));
+        }
+        return this.fallback.listPeerSessions();
+    }
+    async waitForSettledPeer(id, timeoutMs) {
+        if (await this.shouldUseTauriSignaling()) {
+            const snapshot = await this.invokeIpc('wait_for_rtc_settled_peer', { id, timeoutMs });
+            if (!snapshot || typeof snapshot !== 'object') {
+                return null;
+            }
+            return normalizePeerSessionSnapshotRecord(snapshot);
+        }
+        return this.fallback.waitForSettledPeer(id, timeoutMs);
+    }
+    async resolvePeerConnectionRecords(id) {
+        if (await this.shouldUseTauriSignaling()) {
+            const records = await this.invokeIpc('resolve_rtc_peer_connection_records', { id });
+            return (Array.isArray(records) ? records : []).map((record) => normalizeManagedConnectionRecord(record));
+        }
+        return this.fallback.resolvePeerConnectionRecords(id);
+    }
+    async resolvePeerIdentity(id) {
+        if (await this.shouldUseTauriSignaling()) {
+            const snapshot = await this.invokeIpc('resolve_rtc_peer_identity', { id });
+            return normalizeResolvedPeerIdentity(snapshot);
+        }
+        return this.fallback.resolvePeerIdentity(id);
+    }
+    async setOffline(localNodeId) {
+        if (await this.shouldUseTauriSignaling()) {
+            try {
+                const authReady = await this.ensureNativeAuth('setOffline', {
+                    requireToken: true,
+                    maxWaitMs: NativeIpcBridge.AUTH_REQUIRED_WAIT_MS,
+                });
+                if (!authReady) {
+                    throw new Error('Native auth token unavailable for setOffline');
+                }
+                const userId = this.getCurrentUserId();
+                await this.invokeIpc('set_rtc_offline', { userId });
+                await this.markNativeRtdbOffline();
+                return;
+            }
+            catch (error) {
+                console.warn('[NativeIpcBridge] set_rtc_offline failed:', error);
+            }
+        }
+        return this.fallback.setOffline(localNodeId);
+    }
+    async updateDevice(deviceId, updates) {
+        const useNative = await this.shouldUseTauriSignaling();
+        if (useNative) {
+            const authReady = await this.ensureNativeAuth('updateDevice', {
+                requireToken: true,
+                maxWaitMs: NativeIpcBridge.AUTH_REQUIRED_WAIT_MS,
+            });
+            if (!authReady) {
+                throw new Error('Native auth token unavailable for updateDevice');
+            }
+            const userId = this.getCurrentUserId();
+            if (!userId) {
+                throw new Error('updateDevice requires authenticated user scope');
+            }
+            try {
+                await this.invokeIpc('update_rtc_device', {
+                    userId,
+                    deviceId,
+                    deviceName: updates.deviceName ?? null,
+                    capabilities: updates.capabilities ?? null,
+                    metadata: updates.metadata ?? null,
+                });
+                return;
+            }
+            catch (error) {
+                console.warn('[NativeIpcBridge] update_rtc_device failed:', error);
+                throw error instanceof Error ? error : new Error(String(error));
+            }
+        }
+        return this.fallback.updateDevice(deviceId, updates);
+    }
+    async deleteDevice(deviceId) {
+        const useNative = await this.shouldUseTauriSignaling();
+        if (useNative) {
+            const authReady = await this.ensureNativeAuth('deleteDevice', {
+                requireToken: true,
+                maxWaitMs: NativeIpcBridge.AUTH_REQUIRED_WAIT_MS,
+            });
+            if (!authReady) {
+                throw new Error('Native auth token unavailable for deleteDevice');
+            }
+            const userId = this.getCurrentUserId();
+            if (!userId) {
+                throw new Error('deleteDevice requires authenticated user scope');
+            }
+            try {
+                await this.invokeIpc('delete_rtc_device', { userId, deviceId });
+                return;
+            }
+            catch (error) {
+                console.warn('[NativeIpcBridge] delete_rtc_device failed:', error);
+                throw error instanceof Error ? error : new Error(String(error));
+            }
+        }
+        return this.fallback.deleteDevice(deviceId);
+    }
+    async getLocalDeviceInfo() {
+        if (!(await this.canUseTauriIpc())) {
+            const deviceId = await this.getLocalDeviceId?.();
+            if (!deviceId) {
+                return null;
+            }
+            return {
+                deviceId,
+                deviceName: this.defaultDeviceNameFallback(),
+                platformType: 'web',
+            };
+        }
+        try {
+            const info = await this.invokeIpc('get_rtc_local_device_info');
+            const deviceId = typeof info?.device_id === 'string' ? info.device_id.trim() : '';
+            if (!deviceId) {
+                return null;
+            }
+            return {
+                deviceId,
+                deviceName: this.normalizeNativeDeviceName(typeof info?.device_name === 'string' ? info.device_name : ''),
+                platformType: typeof info?.platform_type === 'string' ? info.platform_type : 'desktop',
+                capabilities: info?.capabilities ?? undefined,
+                lastSeenAt: typeof info?.last_seen_at === 'string' ? info.last_seen_at : undefined,
+            };
+        }
+        catch (error) {
+            console.warn('[NativeIpcBridge] getLocalDeviceInfo failed:', error);
+            return null;
+        }
+    }
+    async updateLocalDeviceName(deviceName) {
+        if (!(await this.canUseTauriIpc())) {
+            return null;
+        }
+        try {
+            const info = await this.invokeIpc('update_rtc_local_device_name', { deviceName });
+            const deviceId = typeof info?.device_id === 'string' ? info.device_id.trim() : '';
+            if (!deviceId) {
+                return null;
+            }
+            this.cachedLocalDeviceName = this.normalizeNativeDeviceName(deviceName);
+            return {
+                deviceId,
+                deviceName: this.cachedLocalDeviceName,
+                platformType: typeof info?.platform_type === 'string' ? info.platform_type : 'desktop',
+                capabilities: info?.capabilities ?? undefined,
+                lastSeenAt: typeof info?.last_seen_at === 'string' ? info.last_seen_at : undefined,
+            };
+        }
+        catch (error) {
+            console.warn('[NativeIpcBridge] updateLocalDeviceName failed:', error);
+            return null;
+        }
+    }
+    async getManagedNodeId(options) {
+        const initializeIfMissing = options?.initializeIfMissing ?? true;
+        if (!(await this.canUseTauriIpc())) {
+            return null;
+        }
+        try {
+            const existing = await this.invokeIpc('get_iroh_node_id');
+            if (existing || !initializeIfMissing) {
+                return existing;
+            }
+            return this.invokeIpc('start_iroh_node');
+        }
+        catch (error) {
+            console.warn('[NativeIpcBridge] getManagedNodeId failed:', error);
+            if (!initializeIfMissing) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async getEndpointTicket() {
+        if (!(await this.canUseTauriIpc())) {
+            throw new Error('[pluto-rtc] getEndpointTicket requires native IPC in Tauri runtime.');
+        }
+        return this.invokeIpc('get_iroh_endpoint_ticket');
+    }
+    async connectToDevice(params) {
+        if (!(await this.canUseTauriIpc())) {
+            throw new Error('[pluto-rtc] connectToDevice requires native IPC in Tauri runtime.');
+        }
+        if (this.options.authMode !== 'anonymous') {
+            await this.ensureNativeAuth('connectToDevice', {
+                requireToken: true,
+                maxWaitMs: NativeIpcBridge.AUTH_REQUIRED_WAIT_MS,
+            });
+        }
+        else {
+            openRtcDebugInfo('[NativeIpcBridge] connectToDevice using anonymous native ticket path');
+        }
+        return this.invokeIpc('connect_to_device', {
+            deviceId: params.deviceId ?? null,
+            endpointTicket: params.endpointTicket,
+        });
+    }
+    // -----------------------------------------------------------------------
+    // Session token IPC — syncs token operations with the native Rust backend
+    // -----------------------------------------------------------------------
+    async registerSessionToken(token, grantScope, maxConnections) {
+        if (!(await this.canUseTauriIpc()))
+            return;
+        await this.invokeIpc('register_session_token', { token, scope: grantScope, maxConnections });
+    }
+    async getEndpointTicketWithToken(grantScope, maxConnections) {
+        if (!(await this.canUseTauriIpc()))
+            return null;
+        try {
+            return await this.invokeIpc('get_endpoint_ticket_with_token', { scope: grantScope, maxConnections });
+        }
+        catch {
+            return null;
+        }
+    }
+    async validateSessionToken(token, connectionId) {
+        if (!(await this.canUseTauriIpc()))
+            return null;
+        try {
+            return await this.invokeIpc('validate_session_token', {
+                token,
+                connectionId: connectionId ?? null,
+            });
+        }
+        catch {
+            return null;
+        }
+    }
+    async revokeSessionTokensByScope(grantScope) {
+        if (!(await this.canUseTauriIpc()))
+            return [];
+        try {
+            return await this.invokeIpc('revoke_session_tokens_by_scope', { scope: grantScope });
+        }
+        catch {
+            return [];
+        }
+    }
+    async disconnectDevice(deviceId) {
+        if (!(await this.canUseTauriIpc())) {
+            throw new Error('[pluto-rtc] disconnectDevice requires native IPC in Tauri runtime.');
+        }
+        await this.invokeIpc('disconnect_device', { deviceId });
+    }
+    async setAutoConnectExcluded(deviceId, excluded) {
+        if (!(await this.canUseTauriIpc())) {
+            return;
+        }
+        await this.invokeIpc('set_auto_connect_excluded', { deviceId, excluded });
+    }
+    onDevicesChange(callback, excludeNodeId) {
+        let cancelled = false;
+        const devicesById = new Map();
+        let reader = null;
+        let emittedEmptySnapshot = false;
+        const emit = () => {
+            let devices = Array.from(devicesById.values());
+            if (excludeNodeId) {
+                devices = devices.filter(d => d.ticket !== excludeNodeId &&
+                    d.deviceId !== excludeNodeId &&
+                    d.nodeId !== excludeNodeId);
+            }
+            callback(devices);
+        };
+        const bootstrap = async () => {
+            if (!(await this.shouldUseTauriSignaling())) {
+                console.warn('[NativeIpcBridge] onDevicesChange falling back to wasm signaling (Tauri IPC unavailable)');
+                cleanup = this.fallback.onDevicesChange(callback, excludeNodeId);
+                return;
+            }
+            while (!cancelled) {
+                try {
+                    const authWindowMs = 15000;
+                    const authDeadlineMs = Date.now() + authWindowMs;
+                    let userId = this.getCurrentUserId();
+                    while (!cancelled && !userId && Date.now() < authDeadlineMs) {
+                        if (!this.hasLoggedMissingAuthForDevices) {
+                            this.hasLoggedMissingAuthForDevices = true;
+                            openRtcDebugInfo('[NativeIpcBridge] onDevicesChange waiting for authenticated user before subscription');
+                        }
+                        userId = this.getCurrentUserId();
+                        if (userId)
+                            break;
+                        await this.sleep(250);
+                    }
+                    if (!userId) {
+                        if (!cancelled && !emittedEmptySnapshot) {
+                            console.warn('[NativeIpcBridge] onDevicesChange could not resolve authenticated user; keeping subscription in retry mode');
+                            callback([]);
+                            emittedEmptySnapshot = true;
+                        }
+                        await this.sleep(1000);
+                        continue;
+                    }
+                    const authReady = await this.ensureNativeAuth('onDevicesChange', {
+                        requireToken: true,
+                        maxWaitMs: Math.max(0, authDeadlineMs - Date.now()),
+                    });
+                    if (!authReady) {
+                        if (!cancelled && !emittedEmptySnapshot) {
+                            console.warn('[NativeIpcBridge] onDevicesChange timed out waiting for auth token; keeping subscription in retry mode');
+                            callback([]);
+                            emittedEmptySnapshot = true;
+                        }
+                        await this.sleep(1000);
+                        continue;
+                    }
+                    this.hasLoggedMissingAuthForDevices = false;
+                    emittedEmptySnapshot = false;
+                    openRtcDebugInfo(`[NativeIpcBridge] onDevicesChange starting subscription user_id=${userId}`);
+                    const initialDevices = await this.searchDevices(excludeNodeId);
+                    devicesById.clear();
+                    for (const device of initialDevices)
+                        devicesById.set(device.deviceId, device);
+                    emit();
+                    const stream = await this.subscribeDevices(userId);
+                    reader = stream.getReader();
+                    while (!cancelled) {
+                        const { done, value } = await reader.read();
+                        if (done || !value)
+                            break;
+                        for (const event of value) {
+                            if (event.type === 'removed') {
+                                devicesById.delete(event.deviceId);
+                                continue;
+                            }
+                            const normalized = this.normalizeDevice(event.device);
+                            if (!normalized.deviceId)
+                                continue;
+                            if (!this.matchesTag(normalized)) {
+                                devicesById.delete(normalized.deviceId);
+                                continue;
+                            }
+                            devicesById.set(normalized.deviceId, normalized);
+                        }
+                        emit();
+                    }
+                }
+                catch (error) {
+                    if (!cancelled) {
+                        console.error('[NativeIpcBridge] onDevicesChange stream failed; retrying subscription:', error);
+                        await this.sleep(1000);
+                    }
+                }
+                finally {
+                    if (reader) {
+                        try {
+                            await reader.cancel();
+                        }
+                        catch {
+                            // no-op
+                        }
+                        reader = null;
+                    }
+                }
+            }
+        };
+        let cleanup = () => {
+            cancelled = true;
+            if (reader) {
+                void reader.cancel();
+                reader = null;
+            }
+        };
+        void bootstrap();
+        return () => cleanup();
+    }
+    async subscribeDevices(userId) {
+        if (await this.shouldUseTauriSignaling()) {
+            const authReady = await this.ensureNativeAuth('subscribeDevices', {
+                requireToken: true,
+                maxWaitMs: NativeIpcBridge.AUTH_REQUIRED_WAIT_MS,
+            });
+            if (!authReady) {
+                throw new Error('Native auth token unavailable for subscribeDevices');
+            }
+            const requestId = `sub-${Math.random().toString(36).substring(2, 11)}`;
+            let unlisten = null;
+            let stopSubscription = null;
+            let closed = false;
+            const closeSubscription = async () => {
+                if (closed) {
+                    return;
+                }
+                closed = true;
+                if (unlisten) {
+                    await Promise.resolve(unlisten());
+                    unlisten = null;
+                }
+                if (stopSubscription) {
+                    try {
+                        await stopSubscription();
+                    }
+                    catch {
+                        // no-op
+                    }
+                    stopSubscription = null;
+                }
+            };
+            return new ReadableStream({
+                start: async (controller) => {
+                    openRtcDebugInfo(`[NativeIpcBridge] subscribeDevices request start user_id=${userId} request_id=${requestId}`);
+                    unlisten = await this.listenIpc('rtc-device-events', (event) => {
+                        if (closed) {
+                            return;
+                        }
+                        const payload = event.payload;
+                        if (payload.requestId === requestId) {
+                            if (payload.type === 'deviceEvents') {
+                                const count = Array.isArray(payload.events) ? payload.events.length : 0;
+                                openRtcDebug(`[NativeIpcBridge] subscribeDevices event batch request_id=${requestId} count=${count}`);
+                                try {
+                                    controller.enqueue(payload.events);
+                                }
+                                catch {
+                                    void closeSubscription();
+                                }
+                            }
+                            else if (payload.type === 'error') {
+                                console.warn(`[NativeIpcBridge] subscribeDevices stream error request_id=${requestId}: ${payload.message}`);
+                                if (!closed) {
+                                    try {
+                                        controller.error(payload.message);
+                                    }
+                                    catch {
+                                        // no-op
+                                    }
+                                    void closeSubscription();
+                                }
+                            }
+                        }
+                    });
+                    stopSubscription = async () => {
+                        await this.invokeIpc('stop_rtc_subscription', { requestId });
+                    };
+                    try {
+                        await this.invokeIpc('start_rtc_device_subscription', { requestId, userId });
+                    }
+                    catch (error) {
+                        try {
+                            controller.error(error);
+                        }
+                        catch {
+                            // no-op
+                        }
+                        await closeSubscription();
+                    }
+                },
+                cancel: async () => {
+                    openRtcDebugInfo(`[NativeIpcBridge] subscribeDevices request stop request_id=${requestId}`);
+                    await closeSubscription();
+                }
+            });
+        }
+        return this.fallback.subscribeDevices(userId);
+    }
+    async subscribeSessions(localDeviceId) {
+        if (await this.shouldUseTauriSignaling()) {
+            const authReady = await this.ensureNativeAuth('subscribeSessions', {
+                requireToken: true,
+                maxWaitMs: NativeIpcBridge.AUTH_REQUIRED_WAIT_MS,
+            });
+            if (!authReady) {
+                throw new Error('Native auth token unavailable for subscribeSessions');
+            }
+            const requestId = `sub-${Math.random().toString(36).substring(2, 11)}`;
+            const effectiveLocalDeviceId = (await this.resolveLocalDeviceId()) || localDeviceId;
+            let unlistenSession = null;
+            let stopSubscription = null;
+            let closed = false;
+            const closeSubscription = async () => {
+                if (closed) {
+                    return;
+                }
+                closed = true;
+                if (unlistenSession) {
+                    await Promise.resolve(unlistenSession());
+                    unlistenSession = null;
+                }
+                if (stopSubscription) {
+                    try {
+                        await stopSubscription();
+                    }
+                    catch {
+                        // no-op
+                    }
+                    stopSubscription = null;
+                }
+            };
+            return new ReadableStream({
+                start: async (controller) => {
+                    unlistenSession = await this.listenIpc('rtc-session-events', (event) => {
+                        if (closed) {
+                            return;
+                        }
+                        const payload = event.payload;
+                        if (payload.requestId === requestId) {
+                            if (payload.type === 'sessionEvents') {
+                                try {
+                                    controller.enqueue(payload.events);
+                                }
+                                catch {
+                                    void closeSubscription();
+                                }
+                            }
+                            else if (payload.type === 'error') {
+                                if (!closed) {
+                                    try {
+                                        controller.error(payload.message);
+                                    }
+                                    catch {
+                                        // no-op
+                                    }
+                                    void closeSubscription();
+                                }
+                            }
+                        }
+                    });
+                    stopSubscription = async () => {
+                        await this.invokeIpc('stop_rtc_subscription', { requestId });
+                    };
+                    try {
+                        await this.invokeIpc('start_rtc_session_subscription', {
+                            requestId,
+                            localDeviceId: effectiveLocalDeviceId,
+                        });
+                    }
+                    catch (error) {
+                        try {
+                            controller.error(error);
+                        }
+                        catch {
+                            // no-op
+                        }
+                        await closeSubscription();
+                    }
+                },
+                cancel: async () => {
+                    await closeSubscription();
+                }
+            });
+        }
+        return this.fallback.subscribeSessions(localDeviceId);
+    }
+    async getLocalDeviceId() {
+        return this.resolveLocalDeviceId();
+    }
+    async updatePresence(localNodeId, ticketStr, isOnline = true, ttlMs = 300000, metadata) {
+        if (await this.shouldUseTauriSignaling()) {
+            try {
+                const authReady = await this.ensureNativeAuth('updatePresence', {
+                    requireToken: true,
+                    maxWaitMs: NativeIpcBridge.AUTH_REQUIRED_WAIT_MS,
+                });
+                if (!authReady) {
+                    throw new Error('Native auth token unavailable for updatePresence');
+                }
+                const userId = this.getCurrentUserId();
+                const localDeviceId = await this.resolveLocalDeviceId();
+                const localDeviceName = await this.resolveLocalDeviceName();
+                await this.invokeIpc('update_rtc_presence', {
+                    userId,
+                    deviceName: localDeviceName,
+                    ticket: ticketStr,
+                    metadata: this.withPresenceMetadata(metadata, localDeviceId),
+                });
+                await this.syncNativeRtdbPresenceTicket(ticketStr);
+                return;
+            }
+            catch (error) {
+                console.warn('[NativeIpcBridge] update_rtc_presence failed:', error);
+            }
+        }
+        return this.fallback.updatePresence(localNodeId, ticketStr, isOnline, ttlMs, metadata);
+    }
+    startAutoConnect(userId, localDeviceId) {
+        void (async () => {
+            try {
+                if (!(await this.shouldUseTauriSignaling())) {
+                    console.error('[NativeIpcBridge] startAutoConnect requires native Rust signaling; IPC unavailable');
+                    return;
+                }
+                const effectiveLocalDeviceId = (await this.resolveLocalDeviceId()) || localDeviceId;
+                await this.startAutoConnectOnce(userId, effectiveLocalDeviceId);
+            }
+            catch (error) {
+                console.warn('[NativeIpcBridge] startAutoConnect failed:', error);
+            }
+        })();
+    }
+    forceReconnectSnapshot() {
+        void (async () => {
+            if (!(await this.shouldUseTauriSignaling())) {
+                console.error('[NativeIpcBridge] forceReconnectSnapshot requires native Rust signaling; IPC unavailable');
+                return;
+            }
+            try {
+                await this.invokeIpc('force_rtc_reconnect_snapshot');
+            }
+            catch (error) {
+                console.warn('[NativeIpcBridge] force_rtc_reconnect_snapshot failed:', error);
+            }
+        })();
+    }
+    startPresenceLoop(userId, localNodeId, deviceName, ticket, metadata) {
+        void (async () => {
+            try {
+                if (!(await this.shouldUseTauriSignaling())) {
+                    console.warn('[NativeIpcBridge] startPresenceLoop falling back to wasm signaling (Tauri IPC unavailable)');
+                    this.fallback.startPresenceLoop(userId, localNodeId, deviceName, ticket, metadata);
+                    return;
+                }
+                const localDeviceId = await this.resolveLocalDeviceId();
+                const resolvedDeviceName = this.shouldUseResolvedDeviceName(deviceName)
+                    ? await this.resolveLocalDeviceName()
+                    : deviceName.trim();
+                const metadataWithDevice = this.withPresenceMetadata(metadata, localDeviceId);
+                await this.startPresenceLoopOnce(userId, localNodeId, resolvedDeviceName, ticket, metadataWithDevice);
+                await this.syncNativeRtdbPresenceTicket(ticket);
+            }
+            catch (error) {
+                console.warn('[NativeIpcBridge] startPresenceLoop failed:', error);
+            }
+        })();
+    }
+    async startAutoConnectOnce(userId, localDeviceId) {
+        // One-shot native forwarder only. Retry/dedup policy belongs in RuntimeClient
+        // or the Rust core, not inside the bridge compatibility layer.
+        if (!(await this.shouldUseTauriSignaling())) {
+            throw new Error('[pluto-rtc] Native IPC unavailable for startAutoConnectOnce().');
+        }
+        const authReady = await this.ensureNativeAuth('startAutoConnect', {
+            requireToken: true,
+            maxWaitMs: NativeIpcBridge.AUTH_REQUIRED_WAIT_MS,
+        });
+        if (!authReady) {
+            throw new Error('Native auth token unavailable for startAutoConnect');
+        }
+        await this.invokeIpc('start_rtc_auto_connect', {
+            userId,
+            localDeviceId,
+        });
+    }
+    async startPresenceLoopOnce(userId, localNodeId, deviceName, ticket, metadata) {
+        // One-shot native forwarder only. Retry/dedup policy belongs in RuntimeClient
+        // or the Rust core, not inside the bridge compatibility layer.
+        if (!(await this.shouldUseTauriSignaling())) {
+            throw new Error('[pluto-rtc] Native IPC unavailable for startPresenceLoopOnce().');
+        }
+        const authReady = await this.ensureNativeAuth('startPresenceLoop', {
+            requireToken: true,
+            maxWaitMs: NativeIpcBridge.AUTH_REQUIRED_WAIT_MS,
+        });
+        if (!authReady) {
+            throw new Error('Native auth token unavailable for startPresenceLoop');
+        }
+        await this.invokeIpc('start_rtc_presence_loop', {
+            userId,
+            localNodeId,
+            deviceName,
+            ticket,
+            metadata,
+            apiKey: this.options.apiKey ?? null,
+        });
+    }
+    shouldUseResolvedDeviceName(deviceName) {
+        const normalized = deviceName.trim();
+        return normalized.length === 0 || normalized === 'Unknown Device' || normalized === 'Desktop Device';
+    }
+    async sendExplicitFilePath(connectionId, filePath, transferId = '') {
+        openRtcDebugInfo('[NativeIpcBridge] sendExplicitFilePath start', {
+            connectionId,
+            filePath,
+            transferId: transferId || null,
+            authMode: this.options.authMode,
+        });
+        if (await this.canUseTauriIpc()) {
+            if (this.options.authMode !== 'anonymous') {
+                await this.ensureNativeAuth('sendExplicitFilePath');
+            }
+            else {
+                openRtcDebugInfo('[NativeIpcBridge] sendExplicitFilePath using anonymous native path');
+            }
+            const result = await this.invokeIpc('send_file', {
+                connectionId,
+                filePath,
+                transferId,
+            });
+            openRtcDebugInfo('[NativeIpcBridge] sendExplicitFilePath completed', {
+                connectionId,
+                transferId: transferId || null,
+                result,
+            });
+            return result;
+        }
+        return this.fallback.sendExplicitFilePath(connectionId, filePath, transferId);
+    }
+    async sendExplicitFileData(params) {
+        openRtcDebugInfo('[NativeIpcBridge] sendExplicitFileData start', {
+            connectionId: params.connectionId ?? null,
+            connectionRemoteNodeId: params.connection?.remoteNodeId ?? null,
+            remoteNodeId: params.remoteNodeId ?? null,
+            transferId: params.transferId ?? null,
+            fileName: params.file.name,
+            fileSize: params.file.size,
+            authMode: this.options.authMode,
+        });
+        if (await this.canUseTauriIpc()) {
+            if (this.options.authMode !== 'anonymous') {
+                await this.ensureNativeAuth('sendExplicitFileData');
+            }
+            else {
+                openRtcDebugInfo('[NativeIpcBridge] sendExplicitFileData using anonymous native path');
+            }
+            const connectionId = params.connectionId ||
+                params.connection?.deviceId ||
+                params.connection?.remoteNodeId ||
+                params.remoteNodeId ||
+                '';
+            if (!connectionId) {
+                throw new Error('sendExplicitFileData requires a settled peer identifier in native runtime');
+            }
+            const bytes = new Uint8Array(await params.file.arrayBuffer());
+            await this.invokeIpc('send_file_data', {
+                connectionId,
+                filename: params.file.name,
+                data: Array.from(bytes),
+                transferId: params.transferId,
+            });
+            openRtcDebugInfo('[NativeIpcBridge] sendExplicitFileData completed', {
+                connectionId,
+                transferId: params.transferId ?? null,
+                fileName: params.file.name,
+                fileSize: params.file.size,
+            });
+            return;
+        }
+        return this.fallback.sendExplicitFileData(params);
+    }
+    async getConnectionStates() {
+        if (await this.canUseTauriIpc()) {
+            try {
+                if (this.options.authMode !== 'anonymous') {
+                    await this.ensureNativeAuth('getConnectionStates');
+                }
+                const states = await this.invokeIpc('list_rtc_connection_states');
+                return Array.isArray(states) ? states : [];
+            }
+            catch (error) {
+                console.warn('[NativeIpcBridge] Failed to fetch native connection states:', error);
+                return [];
+            }
+        }
+        return [];
+    }
+    async onConnectionStateChange(callback) {
+        let stopped = false;
+        let unsubscribeInner = null;
+        const startedAt = Date.now();
+        let attempt = 0;
+        const stopSubscription = () => {
+            const unlisten = unsubscribeInner;
+            if (unlisten) {
+                void Promise.resolve(unlisten());
+            }
+        };
+        while (!stopped && Date.now() - startedAt <= NativeIpcBridge.CONNECTION_EVENT_SUBSCRIBE_WINDOW_MS) {
+            attempt += 1;
+            if (!(await this.canUseTauriIpc())) {
+                await this.sleep(this.nextConnectionEventRetryDelayMs(attempt));
+                continue;
+            }
+            unsubscribeInner = await this.listenIpc('connection-state-changed', (event) => {
+                if (!event?.payload) {
+                    return;
+                }
+                openRtcDebug('[NativeIpcBridge] connection-state-changed trigger', {
+                    connectionId: event.payload.connectionId,
+                    deviceId: event.payload.deviceId ?? null,
+                    deviceIdHint: event.payload.deviceIdHint ?? null,
+                    remoteNodeId: event.payload.remoteNodeId ?? null,
+                    state: event.payload.state,
+                    transportState: event.payload.transportState ?? null,
+                    protocolState: event.payload.protocolState ?? null,
+                    routable: event.payload.routable ?? null,
+                });
+                void this.getConnectionStates()
+                    .then((states) => {
+                    states.forEach((state) => callback(state));
+                })
+                    .catch((error) => {
+                    console.warn('[NativeIpcBridge] Failed to refresh Rust-owned connection states after trigger:', error);
+                });
+            });
+            try {
+                const states = await this.getConnectionStates();
+                if (states.length > 0) {
+                    openRtcDebug('[NativeIpcBridge] replaying current native connection states', states.map((state) => ({
+                        connectionId: state.connectionId,
+                        deviceId: state.deviceId ?? null,
+                        deviceIdHint: state.deviceIdHint ?? null,
+                        remoteNodeId: state.remoteNodeId ?? null,
+                        state: state.state,
+                        transportState: state.transportState ?? null,
+                        protocolState: state.protocolState ?? null,
+                        routable: state.routable ?? null,
+                    })));
+                }
+                states.forEach((state) => callback(state));
+            }
+            catch (error) {
+                console.warn('[NativeIpcBridge] Failed to replay native connection states after event subscription:', error);
+            }
+            return () => {
+                stopped = true;
+                stopSubscription();
+            };
+        }
+        return () => {
+            stopped = true;
+            stopSubscription();
+        };
+    }
+    /**
+     * Subscribe to raw messages forwarded from native iroh connections.
+     * The Rust backend emits `iroh://message` Tauri events for messages that
+     * arrive on the main stream of an incoming connection. This lets the TS
+     * Client.handleMessage() run token validation on native-side connections.
+     *
+     * Payload: { connectionId: string, streamId: string, data: number[] }
+     * The `data` array is the raw frame bytes; for TS-originated messages it is
+     * [4-byte-len BE][1-byte-type][JSON payload].
+     */
+    async onIncomingNativeMessage(callback) {
+        if (!(await this.canUseTauriIpc())) {
+            return () => { };
+        }
+        const unlisten = await this.listenIpc('iroh://message', (event) => {
+            if (!event?.payload?.data)
+                return;
+            // Only process messages from the main stream; data-channel streams
+            // are handled separately and should not go through handleMessage.
+            if (event.payload.streamId !== 'main')
+                return;
+            try {
+                const bytes = new Uint8Array(event.payload.data);
+                // After read_framed_message strips the 4-byte length prefix, the
+                // data is: [1-byte-type=0x00][JSON payload].
+                // Minimum: 2 bytes (type + at least one byte of JSON).
+                if (bytes.length < 2)
+                    return;
+                const typeId = bytes[0];
+                if (typeId !== 0)
+                    return; // Only process user messages (type=0)
+                const jsonBytes = bytes.slice(1);
+                const json = new TextDecoder().decode(jsonBytes);
+                const msg = JSON.parse(json);
+                callback(event.payload.connectionId, event.payload.remoteNodeId ?? null, msg);
+            }
+            catch {
+                // Malformed or non-JSON message — ignore
+            }
+        });
+        return typeof unlisten === 'function' ? unlisten : () => { };
+    }
+    async getTransferHistory(limit = 50) {
+        if (await this.canUseTauriIpc()) {
+            return this.invokeIpc('get_transfer_history', { limit });
+        }
+        return [];
+    }
+    async deleteTransferJob(jobId) {
+        if (await this.canUseTauriIpc()) {
+            await this.invokeIpc('delete_transfer_job', { jobId });
+        }
+    }
+}
+NativeIpcBridge.AUTH_REQUIRED_WAIT_MS = 15000;
+NativeIpcBridge.CONNECTION_EVENT_SUBSCRIBE_WINDOW_MS = 15000;
+NativeIpcBridge.CONNECTION_EVENT_RETRY_MIN_DELAY_MS = 250;
+NativeIpcBridge.CONNECTION_EVENT_RETRY_MAX_DELAY_MS = 1000;
+NativeIpcBridge.TAURI_IPC_NEGATIVE_CACHE_MS = 2000;