openrtc 2.3.0 → 2.4.0

package/dist/DelegatingRuntimeAdapter-4cgiIWMN.d.ts

@@ -0,0 +1,150 @@
+import { z as DiscoveryMode, B as AuthMode, E as SignalingMode, F as ClientOptions, H as ExplicitFileDataSendParams, K as ISignalingBackend, N as RuntimeIdentity, A as AuthContext, O as RoomMember, Q as Device, T as DeviceStatusSnapshot, g as PeerSessionSnapshot, j as ResolvedPeerIdentity, U as ManagedConnectionRecord, V as SignalingEnvelope, W as DeviceEvent, X as DesiredPeerProjection, Y as SignalingSession, Z as SessionEvent, _ as LocalDeviceInfo, $ as NativeManagedSessionStartResult, c as ProtocolName, G as GrantScope, a0 as BackendPeerBiStream, a1 as BackendPeerUniStream, a2 as PortableMediaPublish, a3 as PortableMediaPublicationStart, a4 as PortableMediaSample, a5 as PortableMediaChunk, a6 as PortableMediaControl, a7 as NativeConnectParams, a8 as NativeConnectResult, a9 as BackendConnectionState, aa as NativePeerDataEvent } from './Connection-DZ5eP5hL.js';
+import { R as RuntimeCapabilities } from './capabilities-B2mHv_H7.js';
+
+/** Host-neutral configuration shared by browser/WASM and native/IPC adapters. */
+interface RuntimeBridgeOptions {
+    apiKey?: string;
+    discoveryMode?: DiscoveryMode;
+    space?: string;
+    spaceKey?: string;
+    authMode?: AuthMode;
+    signalingMode?: SignalingMode;
+    projectId?: string;
+    coordinationGateway?: ClientOptions['coordinationGateway'];
+    coordinationAvenueOverride?: ClientOptions['coordinationAvenueOverride'];
+    coordinationRoomGossipFanout?: ClientOptions['coordinationRoomGossipFanout'];
+    attestationTokenProvider?: ClientOptions['attestationTokenProvider'];
+    /** Internal host hint used by the provider-neutral gateway projection. */
+    coordinationPlatformType?: string;
+    storagePrefix?: string;
+    deviceIdPersistence?: 'persistent' | 'ephemeral';
+    endpointIdPersistence?: 'persistent' | 'ephemeral';
+    nodeIdPersistence?: 'persistent' | 'ephemeral';
+    localDeviceId?: string;
+    deviceName?: string;
+    turnCredentialsProvider?: () => Promise<{
+        iceServers?: RTCIceServer[];
+    } | null | undefined>;
+    applicationCrypto?: ExplicitFileDataSendParams['applicationCrypto'];
+    spaceTokenProvider?: ClientOptions['spaceTokenProvider'];
+    spaceAuth?: 'scoped-token';
+}
+
+declare abstract class DelegatingRuntimeAdapter implements ISignalingBackend {
+    protected readonly backend: ISignalingBackend;
+    protected constructor(backend: ISignalingBackend);
+    get currentUser(): RuntimeIdentity | null;
+    setAuthContext(context: AuthContext | null): Promise<void> | void;
+    signInAnonymously(): Promise<void>;
+    signInWithPluto(): Promise<void>;
+    signOut(): Promise<void>;
+    stopAuthActivity(): Promise<void>;
+    usesCoordinationGateway(): boolean;
+    joinCoordinationRoom(roomId: string, nodeId: string, ticket: string): Promise<void>;
+    leaveCoordinationRoom(roomId: string): Promise<void>;
+    getCoordinationRoomMembers(roomId: string): Promise<RoomMember[]>;
+    watchCoordinationRoomMembers(roomId: string, callback: (members: RoomMember[]) => void): () => void;
+    getTurnCredentials(): Promise<any>;
+    updatePresence(localNodeId: string, ticketStr: string, isOnline: boolean, ttlMs: number, metadata?: string): Promise<void>;
+    refreshLivePresence(localNodeId: string, ticketStr: string, metadata?: string): Promise<void>;
+    setOffline(localNodeId: string): Promise<void>;
+    cleanupStaleDevices(): Promise<void>;
+    searchDevices(excludeNodeId?: string): Promise<Device[]>;
+    listDeviceStatus(): Promise<DeviceStatusSnapshot[]>;
+    getPeerSession(id: string): Promise<PeerSessionSnapshot | null>;
+    listPeerSessions(): Promise<PeerSessionSnapshot[]>;
+    waitForSettledPeer(id: string, timeoutMs?: number): Promise<PeerSessionSnapshot | null>;
+    resolvePeerIdentity(id: string): Promise<ResolvedPeerIdentity>;
+    resolvePeerRecords(id: string): Promise<ManagedConnectionRecord[]>;
+    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;
+    onAuthChange(callback: (user: RuntimeIdentity | null) => void): () => void;
+    checkForSSOToken(): Promise<void>;
+    waitForAuth(): Promise<void>;
+    sendMessage(targetId: string, payload: string, state?: string, replyPayload?: string): Promise<string>;
+    pollMessages(targetId: string): Promise<SignalingEnvelope[]>;
+    watchFriendDevices(friendUserIds: string[], callback: (friendDevices: Map<string, Device[]>) => void): () => void;
+    updateFriendTicket(friendTicket: string | null): Promise<void>;
+    subscribeDevices(userId: string): Promise<ReadableStream<DeviceEvent[]>>;
+    startAutoConnect(userId: string, localDeviceId: string): void;
+    submitDesiredPeerProjection(revision: number, peers: DesiredPeerProjection[]): Promise<void>;
+    startPresenceLoop(userId: string, localNodeId: string, deviceName: string, ticket: string, metadata?: string): void;
+    createSession(session: SignalingSession): Promise<void>;
+    updateSession(sessionId: string, updateData: any): Promise<void>;
+    subscribeSessions(localDeviceId: string): Promise<ReadableStream<SessionEvent[]>>;
+    forceReconnect(): void;
+    getLocalDeviceId(): Promise<string | null>;
+    getLocalDeviceInfo(): Promise<LocalDeviceInfo | null>;
+    updateDeviceName(deviceName: string): Promise<LocalDeviceInfo | null>;
+    startNativeSession(options: {
+        userId: string;
+        deviceName?: string;
+        localDeviceId?: string | null;
+        metadata?: string;
+        autoConnect?: boolean;
+        presence?: boolean;
+    }): Promise<NativeManagedSessionStartResult>;
+    notifyNetworkChange(options?: {
+        reason?: string;
+    }): Promise<unknown>;
+    setTransportPriority(priority: ProtocolName[]): Promise<void>;
+    getManagedNodeId(options?: {
+        initializeIfMissing?: boolean;
+    }): Promise<string | null>;
+    startPresence(userId: string, localNodeId: string, deviceName: string, ticket: string, metadata?: string): Promise<void>;
+    startAutoConnectOnce(userId: string, localDeviceId: string): Promise<void>;
+    getEndpointTicket(): Promise<string>;
+    getTicketWithToken(scope: GrantScope, maxConnections: number): Promise<string | null>;
+    registerSessionToken(token: string, scope: GrantScope, maxConnections: number, expiresAtMs?: number): Promise<void>;
+    revokeTokens(scope: GrantScope): Promise<string[]>;
+    openPeerBi(id: string, timeoutMs?: number): Promise<BackendPeerBiStream>;
+    incoming_streams(): Promise<ReadableStream<unknown>>;
+    incoming_projected_streams(): Promise<ReadableStream<unknown>>;
+    projectedIncomingStreamSource(): {
+        incoming_streams: () => Promise<ReadableStream<unknown>>;
+        isCurrentTransport?: (endpointId: string, transportStableId: bigint) => Promise<boolean>;
+    };
+    isCurrentTransport(endpointId: string, transportStableId: bigint): Promise<boolean>;
+    openPeerBiRaw(id: string, timeoutMs?: number): Promise<BackendPeerBiStream>;
+    openPeerUni(id: string, timeoutMs?: number): Promise<BackendPeerUniStream>;
+    beginOpenRtcMediaPublication(input: Omit<PortableMediaPublish, 'mediaGeneration'>): Promise<PortableMediaPublicationStart>;
+    encodeOpenRtcMediaSample(input: PortableMediaSample): Promise<Uint8Array>;
+    pauseOpenRtcMediaPublication(publicationId: string): Promise<void>;
+    retireOpenRtcMediaPublication(publicationId: string): Promise<void>;
+    retireOpenRtcMediaReceiver(publicationId: string, mediaGeneration: number): Promise<void>;
+    decodeOpenRtcMediaChunk(encoded: Uint8Array): Promise<PortableMediaChunk>;
+    decodeOpenRtcMediaControl(encoded: Uint8Array): Promise<PortableMediaControl>;
+    connectToDevice(params: NativeConnectParams): Promise<NativeConnectResult>;
+    disconnectDevice(deviceId: string): Promise<void>;
+    excludeAutoConnect(deviceId: string, excluded: boolean): Promise<void>;
+    isConnected(nodeId: string): Promise<boolean>;
+    getConnectionStates(): Promise<BackendConnectionState[]>;
+    onStateChange(callback: (state: BackendConnectionState) => void): Promise<() => void> | (() => void);
+    /** @deprecated Use named channels or `openrtc-file-transfer`. */
+    sendExplicitFilePath(connectionId: string, filePath: string, transferId?: string): Promise<string>;
+    /** @deprecated Use named channels or `openrtc-file-transfer`. */
+    sendExplicitFileData(params: ExplicitFileDataSendParams): Promise<void>;
+    /** @deprecated Transfer history belongs to the consumer application. */
+    getTransferHistory(limit?: number): Promise<Array<[string, unknown]>>;
+    /** @deprecated Transfer history belongs to the consumer application. */
+    deleteTransferJob(jobId: string): Promise<void>;
+    sendPeerMessage(id: string, payload: Uint8Array): Promise<void>;
+    onPeerMessage(callback: (event: NativePeerDataEvent) => void): Promise<() => void> | (() => void);
+    capabilities(): RuntimeCapabilities;
+    onIncomingNativeMessage(callback: (connectionId: string, remoteNodeId: string | null, message: any) => void): Promise<() => void>;
+    unwrap(): ISignalingBackend;
+    /**
+     * Forward setCoreClient() to the inner backend if it implements it. This
+     * lets the core Client inject a reference into backends (e.g. WasmBridge)
+     * that need to escalate transport-level dials into full Client.connect()
+     * handshakes.
+     */
+    setCoreClient(client: unknown): void;
+}
+
+export { DelegatingRuntimeAdapter as D, type RuntimeBridgeOptions as R };

package/dist/IpcRuntimeAdapter-Dduaxscj.d.ts

@@ -0,0 +1,80 @@
+import { R as RuntimeBridgeOptions, D as DelegatingRuntimeAdapter } from './DelegatingRuntimeAdapter-4cgiIWMN.js';
+import { P as PlutoIpcBridge } from './ipc-DgzKqHH3.js';
+import { a9 as BackendConnectionState, aa as NativePeerDataEvent } from './Connection-DZ5eP5hL.js';
+
+interface NativeIpcBridgeOptions extends RuntimeBridgeOptions {
+    ipcBridge?: PlutoIpcBridge;
+}
+
+/**
+ * Root-client owner for the one native WebView projection.
+ *
+ * Owner: one `OpenRTC.native(...)` root client.
+ * Consumers: capability runtimes registered by that root.
+ * Introduced: 2026-08-26; capability-scoped fan-out: 2026-08-27.
+ *
+ * Rust authenticates, classifies, generation-fences, and tags every projected
+ * descriptor with its authoritative capability key. This broker owns only the
+ * one physical Tauri Channel and bounded fan-out to the matching capability.
+ * It never dials, retries, admits, selects carriers, or invents a scope.
+ */
+interface NativeProjectionHost {
+    incoming_projected_streams(): Promise<ReadableStream<NativeRootProjectionEvent>>;
+    isCurrentTransport(endpointId: string, transportStableId: bigint): Promise<boolean>;
+}
+interface NativeProjectedStreamSource {
+    readonly __openrtcNativeCapabilityProjection: true;
+    readonly capabilityKey: string;
+    incoming_streams(): Promise<ReadableStream<unknown>>;
+    onStateChange(callback: (state: BackendConnectionState) => void): () => void;
+    onPeerMessage(callback: (event: NativePeerDataEvent) => void): () => void;
+    isCurrentTransport(endpointId: string, transportStableId: bigint): Promise<boolean>;
+}
+type NativeRootProjectionEvent = {
+    kind: 'connection-state';
+    capabilityKeys: readonly string[];
+    payload: BackendConnectionState;
+} | {
+    kind: 'peer-data';
+    capabilityKeys: readonly string[];
+    payload: NativePeerDataEvent;
+} | {
+    kind: 'stream';
+    capabilityKeys: readonly string[];
+    payload: unknown;
+};
+declare class NativeProjectionBroker {
+    private host;
+    private readonly consumers;
+    private hostReader;
+    private hostPump;
+    private closed;
+    register(capabilityKey: string, host: NativeProjectionHost): NativeProjectedStreamSource;
+    unregister(capabilityKey: string): void;
+    private subscribeState;
+    private subscribePeerData;
+    private requireConsumer;
+    private currentHost;
+    private incomingStreams;
+    private ensureHostPump;
+    private pumpHost;
+    private hasActiveConsumers;
+    private cancelHostReaderIfIdle;
+    private cancelHostReader;
+    close(): Promise<void>;
+}
+
+interface IpcAdapterOptions extends NativeIpcBridgeOptions {
+    bridge: PlutoIpcBridge;
+    projectionBroker: NativeProjectionBroker;
+}
+declare class IpcRuntimeAdapter extends DelegatingRuntimeAdapter {
+    private readonly projectionBroker;
+    private readonly capabilityKey;
+    private readonly projectedSource;
+    constructor(options: IpcAdapterOptions);
+    projectedIncomingStreamSource(): NativeProjectedStreamSource;
+    releaseNativeCapability(): Promise<void>;
+}
+
+export { IpcRuntimeAdapter as I, NativeProjectionBroker as N, type IpcAdapterOptions as a };

package/dist/WasmBridge-3W2HHADU.js

@@ -0,0 +1 @@
+export{a as WasmBridge}from'./chunk-YYI6AY6W.js';import'./chunk-GNW63SM6.js';import'./chunk-OT7IPLZE.js';import'./chunk-AJQVMVYW.js';import'./chunk-JPBW67B3.js';import'./chunk-MI3ZMVPK.js';import'./chunk-OWKAJPOI.js';import'./chunk-2GX6GB6L.js';

package/dist/{assembly-Bmi65-tK.d.ts → assembly-By3UBQsE.d.ts}

@@ -1,6 +1,5 @@
-import { R as RuntimePeerState, g as ConnectionState, b as PeerReadiness, P as PeerConnectOptions, a as Connection, I as IncomingStream, o as RuntimeClientOptions, r as RuntimeAuthIdentity, A as AuthContext, L as LocalDeviceInfo, l as DeviceProfile, B as BrowserProtocolStore, N as NamespaceDescriptor, p as IrohMutationReceipt, q as IrohDocEntry, e as RuntimeDevice, M as ManagedOptions, j as ManagedSession, D as DeviceStatus, k as DeviceConnectOptions, s as RuntimeSession, J as JoinRoomOptions, n as RuntimeRoomMember, t as ConnectionTarget, S as ScopedChannelOptions, f as ScopedLogicalChannel, d as PeerStreamOptions, m as RawConnection, C as ChannelDescriptor, u as PresenceLoopOptions, c as RuntimePeerHealth, h as ReadinessOptions, i as ConnectionEvent } from './types-DDhMQkK8.js';
-import { G as GrantScope, I as ISignalingBackend, f as ConnectDeviceHooks, g as ConnectDeviceOptions, C as ConnectDeviceResult, M as ManagedConnectionRecord, d as PeerSessionSnapshot, e as ResolvedPeerIdentity, a6 as AppLimits, N as NativeConnectParams, t as NativeConnectResult, E as ExplicitFileDataSendParams } from './ITransport-CjxCQ6q7.js';
-import { R as RuntimeCapabilities, C as CapabilityProfile } from './capabilities-BPuynml5.js';
+import { d as RuntimePeerState, n as ConnectionState, h as PeerReadiness, e as PeerConnectOptions, f as Connection, I as IncomingStream, G as GrantScope, y as RuntimeClientOptions, K as ISignalingBackend, ap as RuntimeAuthIdentity, A as AuthContext, c as ProtocolName, L as LocalDeviceInfo, v as DeviceProfile, ae as BrowserProtocolStore, af as NamespaceDescriptor, ag as IrohMutationReceipt, ah as IrohDocEntry, l as RuntimeDevice, M as ManagedOptions, q as ManagedSession, D as DeviceStatus, t as ConnectDeviceHooks, u as ConnectDeviceOptions, s as ConnectDeviceResult, r as DeviceConnectOptions, U as ManagedConnectionRecord, g as PeerSessionSnapshot, j as ResolvedPeerIdentity, aq as RuntimeSession, ar as AppLimits, J as JoinRoomOptions, x as RuntimeRoomMember, as as ConnectionTarget, S as ScopedChannelOptions, m as ScopedLogicalChannel, k as PeerStreamOptions, a7 as NativeConnectParams, a8 as NativeConnectResult, w as RawConnection, C as ChannelDescriptor, H as ExplicitFileDataSendParams, at as PresenceLoopOptions, i as RuntimePeerHealth, o as ReadinessOptions, p as ConnectionEvent } from './Connection-DZ5eP5hL.js';
+import { R as RuntimeCapabilities, C as CapabilityProfile } from './capabilities-B2mHv_H7.js';
 
 /**
  * Coalesced peer reconciliation scheduler and full reconcile orchestration.
@@ -121,10 +120,10 @@ interface Session {
  *                                  |   --(failure)--> `idle`
  *   `<any>` --(shutdown)--> `closed`
  *
- * WebRTC upgrade/readiness is intentionally absent from this actor. The
- * runtime `Connection`/peer lifecycle owns transport promotion. Actor callers
- * may observe that lifecycle separately, but this handle must not become a
- * second WebRTC-ready emitter.
+ * Physical-carrier readiness is intentionally absent from this actor. The
+ * Rust runtime peer lifecycle owns carrier promotion. Actor callers may
+ * observe that lifecycle separately, but this handle must not become a second
+ * carrier-ready emitter.
  *
  * The Rust actor has a similar shape but is inactive scaffolding in the current
  * workspace. Treat the two implementations as migration debt, not redundant
@@ -213,6 +212,12 @@ declare class DriveGrantActorRegistry {
     constructor(factory: (key: DriveGrantConnectionKey) => DriveGrantActorHandle);
     getOrSpawn(key: DriveGrantConnectionKey, factoryOverride?: (key: DriveGrantConnectionKey) => DriveGrantActorHandle): DriveGrantActorHandle;
     get(key: DriveGrantConnectionKey): DriveGrantActorHandle | null;
+    /**
+     * Remove and close `handle` only while it is still the registered actor for
+     * `key`. The identity fence prevents a late failed dial from retiring a
+     * newer observer handle that has already replaced it.
+     */
+    retireIfCurrent(key: DriveGrantConnectionKey, handle: DriveGrantActorHandle): Promise<boolean>;
     /** Tear down every actor; clears the registry. */
     shutdownAll(): Promise<void>;
     size(): number;
@@ -281,12 +286,14 @@ declare class RuntimeClient {
     private readonly deviceManager;
     private readonly peerManager;
     private readonly connectionController;
-    private readonly nativeStreamConsumer;
+    private readonly nativeConnectionProjection;
+    private nativeProjectionLocalNodeId;
     private managedSessionKey;
     private managedSessionUserId;
     private managedSessionOptions;
     private managedSessionTransition;
     private managedSessionStartInFlight;
+    private browserInitialization;
     private terminalShutdown;
     private readonly managedReconciliationTasks;
     private readonly managedReconciliationFollowupTimers;
@@ -335,10 +342,16 @@ declare class RuntimeClient {
         localNodeId?: string;
         userId?: string;
     }>;
+    /**
+     * Updates application route preference while leaving carrier eligibility,
+     * connection replacement, and settlement with the Rust/WASM peer owner.
+     */
+    setTransportPriority(priority: ProtocolName[]): Promise<void>;
     reconciliationStats(): Readonly<PeerReconciliationStats>;
     getRuntimePolicy(): PolicySnapshot;
     capabilities(): RuntimeCapabilities;
     getCapabilityProfile(): CapabilityProfile;
+    private attachNativeIncomingProjection;
     start(options?: {
         clearSessionTokens?: boolean;
     }): Promise<void>;
@@ -549,21 +562,25 @@ declare class RuntimeClient {
         readable: ReadableStream<Uint8Array>;
         writable: WritableStream<Uint8Array>;
     }>;
-    openPeerNativeBi(id: string, label: string, options?: PeerStreamOptions): Promise<{
-        connection: Connection;
-        readable: ReadableStream<Uint8Array>;
-        writable: WritableStream<Uint8Array>;
-    }>;
-    /** Like openPeerBi but skips the settled_ready requirement — usable for latency probes. */
-    openPeerBiRaw(id: string, options?: PeerStreamOptions): Promise<{
-        connection: Connection;
-        readable: ReadableStream<Uint8Array>;
-        writable: WritableStream<Uint8Array>;
-    }>;
+    /**
+     * Restricted registered-diagnostic path. This is deliberately not part of
+     * the public RuntimeClient surface; openStream reaches it only for a
+     * registry-owned channel whose readiness is explicitly transport-only.
+     */
+    private openPeerBiRaw;
     openPeerUni(id: string, options?: PeerStreamOptions): Promise<{
         connection: Connection;
         writable: WritableStream<Uint8Array>;
     }>;
+    pauseOpenRtcMediaPublication(publicationId: string): Promise<void>;
+    retireOpenRtcMediaPublication(publicationId: string): Promise<void>;
+    retireOpenRtcMediaReceiver(publicationId: string, mediaGeneration: number): Promise<void>;
+    /** Send one protected unreliable datagram; there is no reliable fallback. */
+    sendPeerDatagram(id: string, payload: Uint8Array, maxAgeMs?: number): Promise<boolean>;
+    /** Read one protected unreliable datagram from the current peer generation. */
+    receivePeerDatagram(id: string): Promise<Uint8Array>;
+    peerDatagramMaxSize(): number;
+    createPeerDatagramPolicy(): unknown;
     private waitForBrowserApplicationCrypto;
     connectToDevice(params: NativeConnectParams): Promise<NativeConnectResult>;
     connectRaw(target: ConnectionTarget): Promise<RawConnection>;

package/dist/{capabilities-BPuynml5.d.ts → capabilities-B2mHv_H7.d.ts}

@@ -1,4 +1,4 @@
-import { c as ProtocolName, R as RouteOptimization } from './ITransport-CjxCQ6q7.js';
+import { c as ProtocolName, R as RouteOptimization } from './Connection-DZ5eP5hL.js';
 
 type RuntimeAdapterKind = 'browser-wasm' | 'native-ipc' | 'tauri-ipc' | 'unknown';
 interface RuntimeCapabilities {
@@ -11,9 +11,7 @@ interface RuntimeCapabilities {
     transport: {
         irohQuic: boolean;
         irohLan: boolean;
-        webRtcUpgrade: boolean;
-        webRtcLan: boolean;
-        nativeWebRtc: boolean;
+        webRtc: boolean;
         moq: boolean;
         ble: boolean;
         wasm: boolean;
@@ -47,7 +45,6 @@ interface CapabilityProfile {
         irohRelay: boolean;
         irohLan: boolean;
         webRtc: boolean;
-        webRtcLan: boolean;
         moq: boolean;
         ble: boolean;
     };
@@ -70,7 +67,6 @@ interface NativeRuntimeStatus {
         irohQuic?: TransportStatus;
         irohLan?: TransportStatus;
         webRtc?: TransportStatus;
-        webRtcLan?: TransportStatus;
         moq?: TransportStatus;
         ble?: TransportStatus;
         irohRelayOnly?: boolean;

package/dist/chunk-2GX6GB6L.js

@@ -0,0 +1 @@
+var o=["iroh-relay","moq","iroh"],s=new Set(["iroh","iroh-quic","iroh-relay","iroh-lan","webrtc","moq","ble"]);function y(r){return r?.filter(t=>s.has(t))}function l(r){return (Array.isArray(r.urls)?r.urls:[r.urls]).some(e=>typeof e=="string"&&(e.startsWith("turn:")||e.startsWith("turns:")))}function u(r){let e=(Array.isArray(r.urls)?r.urls:[r.urls]).filter(n=>typeof n=="string"&&!n.startsWith("stun:"));return e.length===0?null:{...r,urls:Array.isArray(r.urls)?e:e[0]}}function a(r){let e=(Array.isArray(r.urls)?r.urls:[r.urls]).filter(n=>{let i=typeof n=="string"?n.trim().toLowerCase():"";return !i.startsWith("turn:")&&!i.startsWith("turns:")});return e.length===0?null:{...r,urls:Array.isArray(r.urls)?e:e[0]}}function c(r){return r?.map(t=>a(t)).filter(t=>t!==null)}function f(r){if(r)return r.map(t=>u(t)).filter(t=>t!==null)}function T(r,t){let e=new Set(["iroh-relay","moq","iroh"]);t&&e.add("webrtc");let n=(r??o).filter(i=>e.has(i));return n.length>0?n:[...o]}function C(r,t){let e=r?.transports?.webrtc;if(e)return e===true?{}:d(r,t)}function d(r,t){let e=r?.transports?.webrtc||void 0;if(e)return r?.transports?.relay===false?{...e,useTurn:false,privacyMode:false,iceTransportPolicy:"all",iceServers:c(e.iceServers)}:r?.strictMode||r?.transports?.privacy==="relay-only"||e.privacyMode?{...e,iceServers:f(e.iceServers),iceTransportPolicy:"relay"}:e.iceTransportPolicy==="relay"&&!(Array.isArray(e.iceServers)&&e.iceServers.some(i=>l(i)))?(t?.("[Client] Overriding relay-only ICE policy to all because no TURN servers are configured"),{...e,iceTransportPolicy:"all"}):e}export{y as a,l as b,f as c,T as d,C as e};