openrtc 0.1.0

package/dist/runtime/TauriRuntimeAdapter.d.ts

@@ -0,0 +1 @@
+export { TauriRuntimeAdapter, createTauriIpcBridge, type TauriRuntimeAdapterOptions, } from './tauri';

package/dist/runtime/TauriRuntimeAdapter.js

@@ -0,0 +1 @@
+export { TauriRuntimeAdapter, createTauriIpcBridge, } from './tauri';

package/dist/runtime/WasmRuntimeAdapter.d.ts

@@ -0,0 +1,6 @@
+import { type WasmBridgeOptions } from '../core/bridges/WasmBridge';
+import { DelegatingRuntimeAdapter } from './DelegatingRuntimeAdapter';
+export declare class WasmRuntimeAdapter extends DelegatingRuntimeAdapter {
+    constructor(options: WasmBridgeOptions);
+    setWasmClient(client: unknown): void;
+}

package/dist/runtime/WasmRuntimeAdapter.js

@@ -0,0 +1,11 @@
+import { WasmBridge } from '../core/bridges/WasmBridge';
+import { DelegatingRuntimeAdapter } from './DelegatingRuntimeAdapter';
+export class WasmRuntimeAdapter extends DelegatingRuntimeAdapter {
+    constructor(options) {
+        super(new WasmBridge(options));
+    }
+    setWasmClient(client) {
+        const backend = this.unwrap();
+        backend.setWasmClient(client);
+    }
+}

package/dist/runtime/factories.d.ts

@@ -0,0 +1,24 @@
+import type { AuthContext } from '../core/IEngineBridge';
+import { type ClientOptions, type ISignalingBackend } from '../core/types';
+import { RuntimeClient } from './RuntimeClient';
+import { IpcRuntimeAdapter } from './IpcRuntimeAdapter';
+import { WasmRuntimeAdapter } from './WasmRuntimeAdapter';
+import type { PlutoIpcBridge } from './ipc';
+type RuntimeAdapterWithAuth = ISignalingBackend & {
+    setAuthContext?: (context: AuthContext | null) => Promise<void> | void;
+};
+export type RuntimeFactoryOptions = ClientOptions;
+export interface PlutoRuntimeAssembly<TBackend extends RuntimeAdapterWithAuth = RuntimeAdapterWithAuth> {
+    runtime: RuntimeClient;
+    setAuthContext(context: AuthContext | null): Promise<void>;
+    syncPlutoAuth(options?: {
+        userId?: string | null;
+        forceRefresh?: boolean;
+    }): Promise<void>;
+    bindPlutoAuthHost(): () => void;
+    signInWithPluto(): Promise<void>;
+    signOut(): Promise<void>;
+}
+export declare function createWasmClient(options: RuntimeFactoryOptions): PlutoRuntimeAssembly<WasmRuntimeAdapter>;
+export declare function createIpcClient(options: RuntimeFactoryOptions, bridge: PlutoIpcBridge): PlutoRuntimeAssembly<IpcRuntimeAdapter>;
+export {};

package/dist/runtime/factories.js

@@ -0,0 +1,66 @@
+import { getAuthHost } from '../auth/host';
+import { withPlutoHostedDefaults } from '../presets/plutoHosted';
+import { RuntimeClient } from './RuntimeClient';
+import { IpcRuntimeAdapter } from './IpcRuntimeAdapter';
+import { WasmRuntimeAdapter } from './WasmRuntimeAdapter';
+function createAssembly(options, backend) {
+    const runtime = new RuntimeClient(options, backend);
+    const assembly = {
+        runtime,
+        async setAuthContext(context) {
+            if (typeof backend.setAuthContext !== 'function') {
+                throw new Error('Selected runtime adapter does not support auth context injection.');
+            }
+            await backend.setAuthContext(context);
+        },
+        async syncPlutoAuth(syncOptions) {
+            const authHost = getAuthHost();
+            const currentUser = authHost.getCurrentUser();
+            const explicitUserId = typeof syncOptions?.userId === 'string' ? syncOptions.userId.trim() : '';
+            const userId = explicitUserId || currentUser?.uid || null;
+            if (!userId) {
+                await assembly.setAuthContext(null);
+                return;
+            }
+            const token = await authHost.getIdToken({
+                forceRefresh: syncOptions?.forceRefresh ?? false,
+            }).catch(() => null);
+            const refreshToken = (authHost.getCurrentUser()?.refreshToken) ?? null;
+            const expiresAtMs = (authHost.getCurrentUser()?.stsTokenManager?.expirationTime) ?? null;
+            await assembly.setAuthContext({
+                userId,
+                token,
+                refreshToken,
+                tokenProvider: async (forceRefresh) => authHost.getIdToken({ forceRefresh: forceRefresh ?? true }),
+                expiresAtMs,
+            });
+        },
+        bindPlutoAuthHost() {
+            const authHost = getAuthHost();
+            void assembly.syncPlutoAuth({
+                userId: authHost.getCurrentUser()?.uid ?? null,
+                forceRefresh: false,
+            });
+            return authHost.onIdTokenChanged((user) => {
+                void assembly.syncPlutoAuth({
+                    userId: user?.uid ?? null,
+                    forceRefresh: false,
+                });
+            });
+        },
+        signInWithPluto: () => runtime.signInWithPluto(),
+        signOut: () => runtime.signOut(),
+    };
+    return assembly;
+}
+export function createWasmClient(options) {
+    const normalizedOptions = withPlutoHostedDefaults(options);
+    return createAssembly(normalizedOptions, new WasmRuntimeAdapter(normalizedOptions));
+}
+export function createIpcClient(options, bridge) {
+    const normalizedOptions = withPlutoHostedDefaults(options);
+    return createAssembly(normalizedOptions, new IpcRuntimeAdapter({
+        ...normalizedOptions,
+        bridge,
+    }));
+}

package/dist/runtime/index.d.ts

@@ -0,0 +1,6 @@
+export { RuntimeClient } from './RuntimeClient';
+export * from './types';
+export * from './factories';
+export * from './IpcRuntimeAdapter';
+export * from './WasmRuntimeAdapter';
+export type { PlutoIpcBridge, PlutoIpcUnlisten, PlutoIpcBridge as NativeBridge } from './ipc';

package/dist/runtime/index.js

@@ -0,0 +1,5 @@
+export { RuntimeClient } from './RuntimeClient';
+export * from './types';
+export * from './factories';
+export * from './IpcRuntimeAdapter';
+export * from './WasmRuntimeAdapter';

package/dist/runtime/ipc.d.ts

@@ -0,0 +1,8 @@
+export type PlutoIpcUnlisten = () => void | Promise<void>;
+export interface PlutoIpcBridge {
+    invoke<T = unknown>(command: string, args?: Record<string, unknown>): Promise<T>;
+    listen<T = unknown>(event: string, handler: (payload: T) => void): Promise<PlutoIpcUnlisten>;
+    isAvailable?(): boolean | Promise<boolean>;
+}
+export declare function assertValidIpcBridge(bridge: PlutoIpcBridge | null | undefined, context?: string): PlutoIpcBridge;
+export declare function createCompatTauriIpcBridge(): PlutoIpcBridge;

package/dist/runtime/ipc.js

@@ -0,0 +1,65 @@
+export function assertValidIpcBridge(bridge, context = 'native runtime') {
+    if (!bridge || typeof bridge !== 'object') {
+        throw new Error(`[openrtc] ${context} requires a valid IPC bridge object.`);
+    }
+    if (typeof bridge.invoke !== 'function') {
+        throw new Error(`[openrtc] ${context} IPC bridge is missing invoke(command, args).`);
+    }
+    if (typeof bridge.listen !== 'function') {
+        throw new Error(`[openrtc] ${context} IPC bridge is missing listen(event, handler).`);
+    }
+    return bridge;
+}
+let tauriAdapterModulePromise = null;
+async function loadTauriAdapterModule() {
+    if (!tauriAdapterModulePromise) {
+        tauriAdapterModulePromise = (async () => {
+            const packageSpecifier = 'openrtc-tauri';
+            const workspaceSpecifier = '../../../tauri/src/runtime/ipc';
+            try {
+                return await import(/* @vite-ignore */ packageSpecifier);
+            }
+            catch (packageError) {
+                try {
+                    return await import(/* @vite-ignore */ workspaceSpecifier);
+                }
+                catch (workspaceError) {
+                    const error = new Error('[openrtc] Native support now lives in the first-party `openrtc-tauri` package. ' +
+                        'Install `openrtc-tauri` (and `@tauri-apps/api`) or pass an explicit IPC bridge to OpenRTC.native(...).');
+                    error.cause = {
+                        packageError,
+                        workspaceError,
+                    };
+                    throw error;
+                }
+            }
+        })();
+    }
+    return tauriAdapterModulePromise;
+}
+export function createCompatTauriIpcBridge() {
+    let delegatePromise = null;
+    const getDelegate = async () => {
+        if (!delegatePromise) {
+            delegatePromise = loadTauriAdapterModule().then((mod) => assertValidIpcBridge(mod.createTauriIpcBridge(), 'openrtc-tauri'));
+        }
+        return delegatePromise;
+    };
+    return {
+        async invoke(command, args) {
+            return (await getDelegate()).invoke(command, args);
+        },
+        async listen(event, handler) {
+            return (await getDelegate()).listen(event, handler);
+        },
+        async isAvailable() {
+            try {
+                const bridge = await getDelegate();
+                return typeof bridge.isAvailable === 'function' ? !!(await bridge.isAvailable()) : true;
+            }
+            catch {
+                return false;
+            }
+        },
+    };
+}

package/dist/runtime/ipcContract.d.ts

@@ -0,0 +1,46 @@
+export interface NativeRtcIpcCommandMap {
+    nativeStatus: string;
+    signInWithPluto: string;
+    setAuthToken: string;
+    stopPresenceLoop: string;
+    stopAutoConnect: string;
+    setOffline: string;
+    searchDevices: string;
+    searchDevicesWithStatus: string;
+    getPeerSession: string;
+    listPeerSessions: string;
+    waitForSettledPeer: string;
+    resolvePeerConnectionRecords: string;
+    resolvePeerIdentity: string;
+    updateDevice: string;
+    deleteDevice: string;
+    getLocalDeviceInfo: string;
+    updateLocalDeviceName: string;
+    getManagedNodeId: string;
+    startManagedNode: string;
+    getEndpointTicket: string;
+    connectToDevice: string;
+    disconnectDevice: string;
+    setAutoConnectExcluded: string;
+    startDeviceSubscription: string;
+    startSessionSubscription: string;
+    stopSubscription: string;
+    updatePresence: string;
+    startAutoConnect: string;
+    forceReconnectSnapshot: string;
+    startPresenceLoop: string;
+    sendFile: string;
+    sendFileData: string;
+    listConnectionStates: string;
+    getTransferHistory: string;
+    deleteTransferJob: string;
+}
+export interface NativeRtcIpcEventMap {
+    deviceEvents: string;
+    sessionEvents: string;
+    connectionStateChanged: string;
+}
+export interface NativeRtcIpcContract {
+    commands: NativeRtcIpcCommandMap;
+    events: NativeRtcIpcEventMap;
+}

package/dist/runtime/ipcContract.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/tauri.d.ts

@@ -0,0 +1,16 @@
+import type { TauriBridgeOptions } from '../core/bridges/TauriBridge';
+import { IpcRuntimeAdapter } from './IpcRuntimeAdapter';
+import { type PlutoIpcBridge } from './ipc';
+/**
+ * @deprecated Native Tauri support now lives in the first-party `openrtc-tauri` package.
+ * This shim remains for one compatibility cycle.
+ */
+export declare function createTauriIpcBridge(): PlutoIpcBridge;
+/**
+ * @deprecated Native Tauri support now lives in the first-party `openrtc-tauri` package.
+ * This shim remains for one compatibility cycle.
+ */
+export declare class TauriRuntimeAdapter extends IpcRuntimeAdapter {
+    constructor(options: TauriBridgeOptions);
+}
+export type TauriRuntimeAdapterOptions = TauriBridgeOptions;

package/dist/runtime/tauri.js

@@ -0,0 +1,22 @@
+import { IpcRuntimeAdapter } from './IpcRuntimeAdapter';
+import { createCompatTauriIpcBridge } from './ipc';
+/**
+ * @deprecated Native Tauri support now lives in the first-party `openrtc-tauri` package.
+ * This shim remains for one compatibility cycle.
+ */
+export function createTauriIpcBridge() {
+    return createCompatTauriIpcBridge();
+}
+/**
+ * @deprecated Native Tauri support now lives in the first-party `openrtc-tauri` package.
+ * This shim remains for one compatibility cycle.
+ */
+export class TauriRuntimeAdapter extends IpcRuntimeAdapter {
+    constructor(options) {
+        super({
+            ...options,
+            bridge: createCompatTauriIpcBridge(),
+            allowWasmFallback: options.allowWasmFallback ?? false,
+        });
+    }
+}

package/dist/runtime/types.d.ts

@@ -0,0 +1,110 @@
+import type { AuthContext } from '../core/IEngineBridge';
+import type { BackendConnectionState, ChannelDescriptor as CoreChannelDescriptor, ClientOptions, DeviceStatusSnapshot, Device, IncomingStreamChannelMetadata, LocalDeviceInfo, ManagedDeviceConnectOptions, PeerSessionSnapshot, PeerHealth, PeerLifecycleStatus, PeerScope, PeerState, RoomMember, RuntimeIdentity, SignalingSession, JoinRoomOptions } from '../core/types';
+export type RuntimeClientOptions = ClientOptions;
+export type RuntimeDevice = Device;
+export type RuntimeSession = SignalingSession;
+export type RuntimeAuthIdentity = RuntimeIdentity;
+export type RuntimeAuthContext = AuthContext;
+export type RuntimePeerState = PeerState;
+export type RuntimePeerHealth = PeerHealth;
+export type RuntimePeerLifecycleStatus = PeerLifecycleStatus;
+export type RuntimePeerScope = PeerScope;
+export type RuntimePeerSessionSnapshot = PeerSessionSnapshot;
+export type RuntimeLocalDeviceInfo = LocalDeviceInfo;
+export type RuntimeRoomMember = RoomMember;
+export type RuntimeDeviceConnectOptions = ManagedDeviceConnectOptions;
+export type RuntimeJoinRoomOptions = JoinRoomOptions;
+export type RuntimeChannelDescriptor = CoreChannelDescriptor;
+export interface RuntimeConnectionTarget {
+    ticket: string;
+    timeoutMs?: number;
+}
+export interface RuntimePeerConnectOptions {
+    deviceId?: string;
+    ticket?: string;
+    scope?: RuntimePeerScope;
+    channelId?: string;
+}
+export interface RuntimePeerStreamOptions {
+    ticket?: string;
+    scope?: RuntimePeerScope;
+    channelId?: string;
+    timeoutMs?: number;
+}
+export type RuntimeDeviceStatusSnapshot = DeviceStatusSnapshot;
+export type RuntimeDeviceStatus = RuntimeDeviceStatusSnapshot;
+export type RuntimeIncomingStream = {
+    type: 'bi' | 'uni';
+    stream: any;
+    remoteNodeId: string;
+    protocolHint?: 'control' | 'explicit' | 'native-main' | 'unknown';
+    channel?: IncomingStreamChannelMetadata | null;
+};
+export type RuntimeConnectionEvent = {
+    type: 'connected' | 'disconnected';
+    connectionId: string;
+    localNodeId: string;
+    remoteNodeId: string;
+    transport: 'iroh' | 'webrtc' | 'moq';
+};
+export type RuntimeRawConnection = {
+    connectionId: string;
+    localNodeId: string;
+    remoteNodeId: string;
+};
+export type RuntimePresenceLoopOptions = {
+    deviceName?: string;
+    ticket?: string;
+    metadata?: string;
+};
+export type RuntimeManagedSessionPlatform = 'native' | 'web';
+export type RuntimeConnectionStateSnapshot = BackendConnectionState;
+export type RuntimeUiConnectionStatus = 'connecting' | 'connected' | 'disconnected' | 'failed';
+export interface RuntimePeerReadinessSnapshot {
+    requestedId: string;
+    connected: boolean;
+    settledReady: boolean;
+    status: RuntimeUiConnectionStatus;
+    health: RuntimePeerHealth | 'unknown';
+    deviceId?: string | null;
+    deviceIdHint?: string | null;
+    activeConnectionId?: string | null;
+    readinessState?: string;
+    readinessReason?: string;
+    scopes: string[];
+}
+export interface RuntimeLocalDeviceProfile {
+    deviceId: string | null;
+    deviceName: string;
+    platformType: string;
+    userId: string | null;
+    capabilities: NonNullable<RuntimeLocalDeviceInfo['capabilities']>;
+    lastSeenAt: string;
+    localNodeId?: string | null;
+}
+export interface RuntimeManagedSessionOptions {
+    platform: RuntimeManagedSessionPlatform;
+    userId?: string | null;
+    deviceName?: string;
+    localDeviceId?: string | null;
+    metadata?: string;
+    autoConnect?: boolean;
+    presence?: boolean;
+}
+export interface RuntimeManagedSession {
+    mode: RuntimeManagedSessionPlatform;
+    device: RuntimeLocalDeviceProfile;
+    stop: () => Promise<void>;
+}
+export type ConnectionTarget = RuntimeConnectionTarget;
+export type PeerConnectOptions = RuntimePeerConnectOptions;
+export type PeerStreamOptions = RuntimePeerStreamOptions;
+export type IncomingStream = RuntimeIncomingStream;
+export type ConnectionEvent = RuntimeConnectionEvent;
+export type RawConnection = RuntimeRawConnection;
+export type PresenceLoopOptions = RuntimePresenceLoopOptions;
+export type PeerReadiness = RuntimePeerReadinessSnapshot;
+export type DeviceProfile = RuntimeLocalDeviceProfile;
+export type SessionOptions = RuntimeManagedSessionOptions;
+export type Session = RuntimeManagedSession;
+export type ChannelDescriptor = RuntimeChannelDescriptor;

package/dist/runtime/types.js

@@ -0,0 +1 @@
+export {};

package/dist/transports/TauriTransport.d.ts

@@ -0,0 +1,17 @@
+import type { Device, SignalingSession } from '../core/types';
+import type { AuthContext, IEngineBridge } from '../core/IEngineBridge';
+export declare class TauriTransport implements IEngineBridge {
+    private readonly backend;
+    constructor(options: {
+        apiKey?: string;
+        authMode?: 'external' | 'anonymous' | 'required';
+        storagePrefix?: string;
+    });
+    setAuthContext(context: AuthContext | null): 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/transports/TauriTransport.js

@@ -0,0 +1,49 @@
+import { TauriBridge } from '../core/bridges/TauriBridge';
+export class TauriTransport {
+    constructor(options) {
+        this.backend = new TauriBridge({
+            apiKey: options.apiKey,
+            authMode: options.authMode,
+            storagePrefix: options.storagePrefix,
+        });
+    }
+    setAuthContext(context) {
+        this.backend.setAuthContext(context);
+    }
+    async searchDevices(excludeNodeId) {
+        return this.backend.searchDevices(excludeNodeId);
+    }
+    onDevicesChange(callback, excludeNodeId) {
+        return this.backend.onDevicesChange(callback, excludeNodeId);
+    }
+    async subscribeSessions(localDeviceId, callback) {
+        const stream = await this.backend.subscribeSessions(localDeviceId);
+        const reader = stream.getReader();
+        let cancelled = false;
+        void (async () => {
+            while (!cancelled) {
+                const { done, value } = await reader.read();
+                if (done || !value)
+                    break;
+                for (const event of value) {
+                    if ('session' in event && event.session) {
+                        callback(event.session);
+                    }
+                }
+            }
+        })();
+        return () => {
+            cancelled = true;
+            void reader.cancel();
+        };
+    }
+    async updatePresence(localNodeId, ticket, isOnline = true, ttlMs = 300000, metadata) {
+        await this.backend.updatePresence(localNodeId, ticket, isOnline, ttlMs, metadata);
+    }
+    async setOffline(localNodeId) {
+        await this.backend.setOffline(localNodeId);
+    }
+    forceReconnectSnapshot() {
+        this.backend.forceReconnectSnapshot();
+    }
+}

package/dist/transports/WebTransport.d.ts

@@ -0,0 +1,23 @@
+import type { Device, SignalingSession } from '../core/types.js';
+import type { AuthContext, IEngineBridge } from '../core/IEngineBridge.js';
+export declare class WebTransport implements IEngineBridge {
+    private readonly options;
+    private readonly backend;
+    private readonly appTag;
+    private readonly projectId;
+    private wasmClient;
+    constructor(options: {
+        apiKey?: string;
+        authMode?: 'external' | 'anonymous' | 'required';
+        storagePrefix?: string;
+        projectId?: string;
+    });
+    initialize(): Promise<void>;
+    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/transports/WebTransport.js

@@ -0,0 +1,71 @@
+import initWasm, { WasmClient, start } from '../../wasm/openrtc.js';
+import { WasmBridge } from '../core/bridges/WasmBridge.js';
+import { resolveAppTag, resolveProjectId } from '../core/config.js';
+export class WebTransport {
+    constructor(options) {
+        this.options = options;
+        this.wasmClient = null;
+        this.appTag = resolveAppTag(options);
+        this.projectId = resolveProjectId(options);
+        this.backend = new WasmBridge({
+            apiKey: options.apiKey,
+            authMode: options.authMode,
+            projectId: this.projectId,
+            storagePrefix: options.storagePrefix,
+        });
+    }
+    async initialize() {
+        if (this.wasmClient)
+            return;
+        await initWasm();
+        start();
+        this.wasmClient = new WasmClient(this.projectId, this.appTag);
+        this.backend.setWasmClient(this.wasmClient);
+    }
+    async setAuthContext(context) {
+        await this.initialize();
+        this.backend.setAuthContext(context);
+    }
+    async searchDevices(excludeNodeId) {
+        await this.initialize();
+        return this.backend.searchDevices(excludeNodeId);
+    }
+    onDevicesChange(callback, excludeNodeId) {
+        void this.initialize();
+        return this.backend.onDevicesChange(callback, excludeNodeId);
+    }
+    async subscribeSessions(localDeviceId, callback) {
+        await this.initialize();
+        const stream = await this.backend.subscribeSessions(localDeviceId);
+        const reader = stream.getReader();
+        let cancelled = false;
+        void (async () => {
+            while (!cancelled) {
+                const { done, value } = await reader.read();
+                if (done || !value)
+                    break;
+                for (const event of value) {
+                    if ('session' in event && event.session) {
+                        callback(event.session);
+                    }
+                }
+            }
+        })();
+        return () => {
+            cancelled = true;
+            void reader.cancel();
+        };
+    }
+    async updatePresence(localNodeId, ticket, isOnline = true, ttlMs = 300000, metadata) {
+        await this.initialize();
+        await this.backend.updatePresence(localNodeId, ticket, isOnline, ttlMs, metadata);
+    }
+    async setOffline(localNodeId) {
+        await this.initialize();
+        await this.backend.setOffline(localNodeId);
+    }
+    forceReconnectSnapshot() {
+        void this.initialize();
+        this.backend.forceReconnectSnapshot();
+    }
+}

package/dist/utils/debug.d.ts

@@ -0,0 +1,4 @@
+export declare function openRtcDebugEnabled(): boolean;
+export declare function openRtcDebug(message: string, data?: unknown): void;
+export declare function openRtcDebugInfo(message: string, data?: unknown): void;
+export declare function openRtcDebugLog(message: string, data?: unknown): void;

package/dist/utils/debug.js

@@ -0,0 +1,33 @@
+export function openRtcDebugEnabled() {
+    if (typeof globalThis !== 'undefined' && globalThis.__OPENRTC_DEBUG__ === true) {
+        return true;
+    }
+    if (typeof localStorage !== 'undefined') {
+        try {
+            return localStorage.getItem('openrtc:debug') === '1';
+        }
+        catch {
+            return false;
+        }
+    }
+    return false;
+}
+function emit(method, message, data) {
+    if (!openRtcDebugEnabled()) {
+        return;
+    }
+    if (typeof data === 'undefined') {
+        console[method](message);
+        return;
+    }
+    console[method](message, data);
+}
+export function openRtcDebug(message, data) {
+    emit('debug', message, data);
+}
+export function openRtcDebugInfo(message, data) {
+    emit('info', message, data);
+}
+export function openRtcDebugLog(message, data) {
+    emit('log', message, data);
+}

package/dist/utils/runtime.d.ts

@@ -0,0 +1 @@
+export declare function isTauriEnvironment(): boolean;

package/dist/utils/runtime.js

@@ -0,0 +1,10 @@
+export function isTauriEnvironment() {
+    if (typeof window === 'undefined') {
+        return false;
+    }
+    return !!(window.__TAURI_IPC__ ||
+        window.__TAURI_INTERNALS__ ||
+        window.__TAURI__ ||
+        window.location.protocol === 'tauri:' ||
+        window.location.hostname === 'tauri.localhost');
+}