openrtc 0.1.3 → 0.2.1

package/dist/runtime/index.js

@@ -1 +1 @@
-export{f as DriveGrantActorError,i as DriveGrantActorHandle,j as DriveGrantActorRegistry,k as RuntimeClient,b as RuntimeConnectionController,f as ScopedConnectionActorError,i as ScopedConnectionActorHandle,j as ScopedConnectionActorRegistry,e as clog,d as correlationForDriveGrantScope,m as createIpcClient,l as createWasmClient,g as driveGrantConnectionKey,h as driveGrantConnectionKeyToString,c as renderCorrelationFields,g as scopedConnectionKey,h as scopedConnectionKeyToString}from'../chunk-26POO5PL.js';export{a as WasmRuntimeAdapter}from'../chunk-D54VGRRH.js';export{b as TauriRuntimeAdapter,a as createTauriIpcBridge}from'../chunk-UVASANPG.js';export{b as IpcRuntimeAdapter}from'../chunk-DIQYFAGL.js';export{r as BROWSER_WASM_RUNTIME_CAPABILITIES,s as NATIVE_IPC_RUNTIME_CAPABILITIES,p as OPENRTC_RUNTIME_POLICY,t as cloneRuntimeCapabilities,q as getRuntimePolicy,i as logOpenRtcTeardownTrace}from'../chunk-PZ25OCVG.js';import'../chunk-4MH42GUI.js';
+export{y as RuntimeClient,h as RuntimeConnectionController,l as ScopedConnectionActorError,o as ScopedConnectionActorHandle,p as ScopedConnectionActorRegistry,k as clog,w as concatRuntimeBytes,j as correlationForDriveGrantScope,A as createIpcClient,v as createRuntimeJsonFrameDecoder,r as createRuntimeU32BEFrameDecoder,z as createWasmClient,t as decodeRuntimeJsonPayload,u as encodeRuntimeJsonFrame,s as encodeRuntimeJsonPayload,q as encodeRuntimeU32BEFrame,B as isRuntimeDeviceActive,D as isRuntimeDeviceConnectable,C as isRuntimeDeviceRoutable,x as readRuntimeU32BE,i as renderCorrelationFields,m as scopedConnectionKey,n as scopedConnectionKeyToString}from'../chunk-UPO23UMZ.js';export{a as WasmRuntimeAdapter}from'../chunk-IUHUYHNZ.js';export{b as TauriRuntimeAdapter,a as createTauriIpcBridge}from'../chunk-7DN33VUQ.js';export{h as IpcRuntimeAdapter,e as classifyNativeIpcFailure,f as isNativeIpcCommandUnavailable}from'../chunk-UBEE42VU.js';export{s as BROWSER_WASM_RUNTIME_CAPABILITIES,t as NATIVE_IPC_RUNTIME_CAPABILITIES,q as OPENRTC_RUNTIME_POLICY,u as cloneRuntimeCapabilities,r as getRuntimePolicy,i as logOpenRtcTeardownTrace,c as openRtcDebug,b as openRtcDebugEnabled,d as openRtcDebugInfo,e as openRtcDebugLog,v as runtimeCapabilitiesFromNativeStatus,w as runtimeCapabilityProfile}from'../chunk-WNJE3MJF.js';import'../chunk-FQETZQPW.js';import'../chunk-BLOEZIFJ.js';

package/dist/runtime/tauri.d.ts

@@ -1,7 +1,6 @@
-import { N as NativeIpcBridgeOptions, I as IpcRuntimeAdapter, P as PlutoIpcBridge } from '../IpcRuntimeAdapter-CT-W0Mtp.js';
-import '../DelegatingRuntimeAdapter-CW8d78dZ.js';
-
-type TauriBridgeOptions = NativeIpcBridgeOptions;
+import { I as IpcRuntimeAdapter, N as NativeIpcBridgeOptions, P as PlutoIpcBridge } from '../IpcRuntimeAdapter-U5AEH0jn.js';
+import '../types-D0fRvUbN.js';
+import '../DelegatingRuntimeAdapter-BxOcVIx_.js';
 
 /**
  * @deprecated Native Tauri support now lives in the first-party `openrtc-tauri` package.
@@ -13,8 +12,8 @@ declare function createTauriIpcBridge(): PlutoIpcBridge;
  * Removal target: OpenRTC 0.2.0. This shim remains for one compatibility cycle.
  */
 declare class TauriRuntimeAdapter extends IpcRuntimeAdapter {
-    constructor(options: TauriBridgeOptions);
+    constructor(options: NativeIpcBridgeOptions);
 }
-type TauriRuntimeAdapterOptions = TauriBridgeOptions;
+type TauriRuntimeAdapterOptions = NativeIpcBridgeOptions;
 
 export { TauriRuntimeAdapter, type TauriRuntimeAdapterOptions, createTauriIpcBridge };

package/dist/runtime/tauri.js

@@ -1 +1 @@
-export{b as TauriRuntimeAdapter,a as createTauriIpcBridge}from'../chunk-UVASANPG.js';import'../chunk-DIQYFAGL.js';import'../chunk-PZ25OCVG.js';import'../chunk-4MH42GUI.js';
+export{b as TauriRuntimeAdapter,a as createTauriIpcBridge}from'../chunk-7DN33VUQ.js';import'../chunk-UBEE42VU.js';import'../chunk-WNJE3MJF.js';import'../chunk-FQETZQPW.js';import'../chunk-BLOEZIFJ.js';

package/dist/transport/index.d.ts

@@ -0,0 +1,11 @@
+import { n as ProtocolName } from '../types-D0fRvUbN.js';
+
+declare const TRANSPORT_LABELS: readonly ProtocolName[];
+declare function normalizeTransportLabel(value: unknown): ProtocolName | undefined;
+declare function isIrohBaseTransportLabel(value: unknown): boolean;
+declare function isDirectIrohTransportLabel(value: unknown): boolean;
+declare function isOptionalTransportLabel(value: unknown): boolean;
+declare function isWebRtcTransportLabel(value: unknown): boolean;
+declare function isIndependentTransportLabel(value: unknown): boolean;
+
+export { ProtocolName, TRANSPORT_LABELS, isDirectIrohTransportLabel, isIndependentTransportLabel, isIrohBaseTransportLabel, isOptionalTransportLabel, isWebRtcTransportLabel, normalizeTransportLabel };

package/dist/transport/index.js

@@ -0,0 +1 @@
+export{a as TRANSPORT_LABELS,d as isDirectIrohTransportLabel,g as isIndependentTransportLabel,c as isIrohBaseTransportLabel,e as isOptionalTransportLabel,f as isWebRtcTransportLabel,b as normalizeTransportLabel}from'../chunk-BLOEZIFJ.js';

package/dist/{DelegatingRuntimeAdapter-CW8d78dZ.d.ts → types-D0fRvUbN.d.ts}

@@ -5,32 +5,59 @@ interface AppLimits {
     maxRooms: number;
     /** Max members per room. -1 = unlimited. */
     maxMembersPerRoom: number;
-    /** Max active devices across all provisioned personal spaces for this app. -1 = unlimited. */
+    /** Max active devices across all provisioned spaces for this app. -1 = unlimited. */
     maxPersonalDevices: number;
 }
 interface PlutoRTCConfiguration extends RTCConfiguration {
     iceServers?: RTCIceServer[];
     privacyMode?: boolean;
     useTurn?: boolean;
+    /** Prefer host/srflx ICE candidates and upgrade aggressively on LAN. */
+    lanMode?: boolean;
+}
+interface LocalPeerSnapshot {
+    nodeId: string;
+    discoveredAtMs: number;
+    localReachable: boolean;
 }
 interface PlutoMoQConfiguration {
     relayUrl?: string;
 }
 interface PlutoIrohConfiguration {
     relayOnly?: boolean;
+    relayTransportPolicy?: 'auto' | 'quicRequired' | 'websocketRequired';
     persistenceMode?: 'persistent' | 'ephemeral';
+    /** Enable native iroh mDNS LAN discovery (native runtimes only). */
+    localDiscovery?: boolean;
+    /** When false, listen for LAN peers without advertising this endpoint. */
+    localDiscoveryMode?: 'active' | 'passive';
+}
+interface PlutoBleConfiguration {
+    /** Enable native BLE discovery + transport (native runtimes only). */
+    enabled?: boolean;
+    /** Timeout for a single BLE connection attempt. */
+    connectTimeoutMs?: number;
+    /** Preferred retry budget for native BLE connection establishment. */
+    retryAttempts?: number;
+    /** Backoff between BLE retry attempts. */
+    retryBackoffMs?: number;
 }
 interface TurnCredentials {
     iceServers?: RTCIceServer[];
 }
 type TurnCredentialsProvider = () => Promise<TurnCredentials | null | undefined>;
-type DiscoveryMode = 'personal' | 'user-scoped';
+type DiscoveryMode = 'space' | 'user-scoped';
 type AuthMode = 'external' | 'anonymous' | 'required';
 type SignalingMode = 'hosted' | 'ticket-only';
 type RoomCreationMode = 'client-open' | 'client-auth' | 'server-only';
 type EndpointKind = 'device' | 'ephemeral';
 type PeerLifecycleStatus = 'disconnected' | 'connecting' | 'connected' | 'failed' | 'closed';
 type PeerHealth = 'unknown' | 'healthy' | 'suspect' | 'stale';
+type DevicePresenceStatus = 'online' | 'idle' | 'offline';
+type PeerLifecycleStage = 'discovered' | 'dialing' | 'base-connected' | 'admitted' | 'protocol-ready' | 'upgrading' | 'webrtc-ready' | 'degraded' | 'reconnecting' | 'closed';
+type PeerBaseTransportState = 'unknown' | 'connecting' | 'connected' | 'degraded' | 'closed';
+type PeerAdmissionState = 'unknown' | 'pending' | 'admitted' | 'rejected' | 'expired';
+type PeerWebRtcState = 'unknown' | 'disabled' | 'connecting' | 'transport-open' | 'route-probing' | 'ready' | 'failed' | 'closed';
 /**
  * Lifecycle label attached to a projected peer while the runtime tracks local ownership.
  *
@@ -62,15 +89,30 @@ interface ChannelDescriptor {
     signalingPolicy?: ChannelSignalingPolicy;
     description?: string;
 }
-type ProtocolName = 'iroh' | 'iroh-quic' | 'iroh-relay' | 'webrtc' | 'moq';
+type ProtocolName = 'iroh' | 'iroh-quic' | 'iroh-relay' | 'iroh-lan' | 'ble' | 'webrtc' | 'webrtc-lan' | 'moq';
 type ProtocolMaturity = 'stable' | 'experimental' | 'unsupported';
+type ProtocolBaseName = 'iroh' | 'webrtc' | 'moq';
+type ProtocolImplementationKind = 'plugin' | 'native' | 'path-label';
+type ProtocolLocality = 'nearby' | 'direct-internet' | 'relay' | 'mixed';
 interface ProtocolCapability {
     protocol: ProtocolName;
+    baseProtocol: ProtocolBaseName;
+    implementation: ProtocolImplementationKind;
+    locality: ProtocolLocality;
     maturity: ProtocolMaturity;
+    preferredRank: number;
+    browser: boolean;
+    native: boolean;
     available: boolean;
     reason?: string;
 }
 type ProtocolCapabilityMap = Record<ProtocolName, ProtocolCapability>;
+/** Space discovery always uses namespace-scoped Firebase tokens. */
+type SpaceAuthMode = 'scoped-token';
+type SpaceTokenProvider = () => Promise<{
+    customToken: string;
+    uid?: string;
+} | null | undefined>;
 interface ClientOptions {
     /**
      * API key issued from the Pluto developer dashboard (https://api.openrtc.app/developer).
@@ -78,26 +120,30 @@ interface ClientOptions {
      */
     apiKey?: string;
     /**
-     * Explicitly opt in to the legacy shared hosted fallback when no apiKey is provided.
+     * Discovery avenue for this runtime.
      *
-     * This should only be used for controlled demos/tests. Production integrations
-     * should always provide an API key.
-     */
-    allowAnonymousHostedDefaults?: boolean;
-    /**
-     * Discovery mode for this app. Defaults to 'personal'.
-     * - 'personal': No user accounts. Devices share a spaceKey to discover each other.
-     * - 'user-scoped': Developer mints tokens for their users. Devices scoped per user.
+     * Set this explicitly in new apps:
+     * - `space`: a small live shared namespace backed by scoped space tokens.
+     * - `user-scoped`: a signed-in user's durable owned-device roster.
      *
-     * Set in the developer dashboard. The server validates this against the app's plan.
+     * Rooms and ticket/share grants are separate layers. Do not use `space`
+     * as a generic account device list, and do not expect `user-scoped`
+     * discovery to show other users unless a room or explicit grant connects them.
      */
     discoveryMode?: DiscoveryMode;
     /**
-     * Space key for 'personal' discovery mode. Acts as a shared secret that scopes
-     * device discovery without requiring user authentication. Devices with the same
-     * spaceKey + apiKey will see each other.
+     * Shared space name for `space` discovery mode. Use this for lightweight
+     * lobbies, demos, cursors, and other live-only collaboration surfaces.
+     * This is the beginner-facing name for `spaceKey`; if both are set,
+     * `spaceKey` wins.
+     */
+    space?: string;
+    /**
+     * Compatibility name for `space`. The SDK derives a namespace from
+     * apiKey + spaceKey, then authenticates with spaceTokenProvider.
      *
-     * Only used when discoveryMode is 'personal'. Ignored for managed modes.
+     * Prefer `space` in public app code. Only used when discoveryMode is
+     * `space`; ignored for user-scoped discovery.
      */
     spaceKey?: string;
     /**
@@ -106,6 +152,11 @@ interface ClientOptions {
      */
     sessionToken?: string;
     authMode?: AuthMode;
+    /**
+     * Allows first-party demos to use hosted defaults when an API key is omitted.
+     * Product apps should pass an API key.
+     */
+    allowAnonymousHostedDefaults?: boolean;
     signalingMode?: SignalingMode;
     projectId?: string;
     storagePrefix?: string;
@@ -130,16 +181,48 @@ interface ClientOptions {
     transports?: {
         iroh?: boolean | PlutoIrohConfiguration;
         webrtc?: boolean | PlutoRTCConfiguration;
+        ble?: boolean | PlutoBleConfiguration;
         moq?: boolean | PlutoMoQConfiguration;
     };
     transportPriority?: ProtocolName[];
+    /** Subscribe to native LAN peer discovery events. */
+    onLocalPeer?: (peer: LocalPeerSnapshot) => void;
     disableIrohFallback?: boolean;
+    /**
+     * Optional application-layer payload envelope. When configured, OpenRTC
+     * protects public message/media payload bytes before they are handed to
+     * iroh, WebRTC, or MoQ and opens them before app callbacks fire.
+     */
+    applicationCrypto?: ApplicationPayloadCrypto;
+    /**
+     * When manual `applicationCrypto` is not set, peers must negotiate an
+     * ephemeral X25519 ECDH key during transport handshake. Disabling is not
+     * supported in secure deployments.
+     */
+    automaticApplicationKeyAgreement?: boolean;
+    /**
+     * @internal Overrides orphan drift grace windows for tests and diagnostics.
+     */
+    orphanReconciliationGrace?: {
+        tsConnectionMs?: number;
+        rustRecordMs?: number;
+    };
+    /**
+     * Mints a namespace-scoped Firebase custom token for space discovery.
+     * Required when `discoveryMode` is `space` and `space`/`spaceKey` is set.
+     * Use `spaceToken(...)` for browser demos and simple static sites.
+     */
+    spaceTokenProvider?: SpaceTokenProvider;
 }
 interface Device {
     deviceId: string;
     deviceName: string;
     online: boolean;
     ticket: string;
+    presenceStatus?: DevicePresenceStatus;
+    presenceUpdatedAt?: number;
+    presenceExpiresAt?: number;
+    connectable?: boolean;
     kind?: EndpointKind | string;
     nodeId?: string;
     platformType?: string;
@@ -159,6 +242,8 @@ interface Device {
     updatedAt?: any;
     metadata?: string;
     excludedPeers?: string[];
+    availableTransports?: ProtocolName[];
+    transports?: ProtocolName[];
 }
 interface PeerState {
     peerId: string;
@@ -173,13 +258,22 @@ interface PeerState {
     platformType?: string;
     status: PeerLifecycleStatus;
     health: PeerHealth;
+    lifecycleStage?: PeerLifecycleStage;
+    generation?: number;
+    baseTransportState?: PeerBaseTransportState;
+    admissionState?: PeerAdmissionState;
     transportState?: string;
     protocolState?: string;
+    webrtcState?: PeerWebRtcState;
     routable?: boolean;
     activeTransportStableId?: number | null;
     transportGeneration?: number;
     activeTransport?: ProtocolName;
+    fallbackTransport?: ProtocolName | null;
     parallelTransport?: ProtocolName | null;
+    manualDisconnect?: boolean;
+    lastAuthoritativeEventAt?: number;
+    lastTransientEventAt?: number;
     promotionEligible?: boolean;
     scopes: PeerScope[];
     lastSeenAt?: number;
@@ -218,6 +312,7 @@ interface NativeConnectResult {
     deviceIdHint?: string | null;
     remoteNodeId?: string | null;
     state: string;
+    approvedScope?: string | null;
 }
 interface BackendPeerBiStream {
     readable: ReadableStream<Uint8Array>;
@@ -260,6 +355,8 @@ interface SignalingEnvelope {
     name?: string;
     senderId: string;
     targetId: string;
+    senderUserId?: string;
+    targetUserId?: string;
     state?: string;
     payload: string;
     replyPayload?: string;
@@ -353,6 +450,14 @@ interface ManagedDeviceConnectOptions {
     onConnected?: (device: Device) => void | Promise<void>;
 }
 interface DeviceStatusSnapshot extends Device {
+    /**
+     * Presence/liveness for the roster entry. This is separate from
+     * `connectionStatus`, which describes the runtime route to the peer.
+     */
+    presenceStatus: DevicePresenceStatus;
+    presenceUpdatedAt?: number;
+    presenceExpiresAt?: number;
+    connectable: boolean;
     connectionStatus: PeerLifecycleStatus | 'online';
     settledReady?: boolean;
     readinessState?: string;
@@ -367,6 +472,7 @@ interface DeviceStatusSnapshot extends Device {
     transportGeneration?: number;
     activeTransport?: ProtocolName;
     parallelTransport?: ProtocolName | null;
+    availableTransports?: ProtocolName[];
 }
 interface ManagedConnectionRecord {
     connectionId: string;
@@ -473,11 +579,21 @@ interface ExplicitFileDataSendParams {
         send: (message: unknown) => Promise<void>;
         deviceId?: string;
         remoteNodeId?: string;
+        requireApplicationCrypto?: boolean;
+        getUpgradeState?: () => string;
+        isWebRtcApplicationRouteReady?: () => boolean;
+        sendOnWebRTC?: (data: Uint8Array) => Promise<void>;
+        getWebRTCTransport?: () => {
+            getBufferedAmount?: () => number;
+            waitForDrain?: (lowWaterMark: number) => Promise<void>;
+        } | null;
     };
     remoteNodeId?: string;
     file: File;
     transferId: string;
     channelId?: string;
+    applicationCrypto?: ApplicationPayloadCrypto;
+    requireApplicationCrypto?: boolean;
 }
 interface ISignalingBackend {
     currentUser: RuntimeIdentity | null;
@@ -537,19 +653,18 @@ interface ISignalingBackend {
     }): Promise<string | null>;
     getEndpointTicket?(): Promise<string>;
     openPeerBi?(id: string, timeoutMs?: number): Promise<BackendPeerBiStream>;
+    openPeerNativeBi?(id: string, label: string, timeoutMs?: number): Promise<BackendPeerBiStream>;
     openPeerUni?(id: string, timeoutMs?: number): Promise<BackendPeerUniStream>;
     connectToDevice?(params: {
         deviceId?: string | null;
         endpointTicket: string;
     }): Promise<NativeConnectResult>;
     /**
-     * Optional backchannel so a backend (e.g. WasmBridge) can access the core
-     * Client after Client.setSignalingBackend() has been called. This lets the
-     * backend trigger Client.connect() for peers it dials directly (e.g. via
-     * the WASM auto-connect path) so the TS Connection/upgrade state machine
-     * stays in lockstep with the Rust transport.
+     * Optional backchannel so a backend (e.g. WasmBridge) can access the narrow
+     * facade surface needed to escalate runtime transport dials into registered
+     * TS connections.
      */
-    setCoreClient?(client: unknown): void;
+    setCoreClient?(client: CoreClientBridgeHost | null): void;
     disconnectDevice?(deviceId: string): Promise<void>;
     setAutoConnectExcluded?(deviceId: string, excluded: boolean): Promise<void>;
     isConnected(nodeId: string): Promise<boolean>;
@@ -560,30 +675,110 @@ interface ISignalingBackend {
     getTransferHistory?(limit?: number): Promise<Array<[string, unknown]>>;
     deleteTransferJob?(jobId: string): Promise<void>;
 }
+interface CoreClientBridgeHost {
+    connect(ticket: string, timeoutMs?: number, expectedDeviceId?: string | null, channelId?: string, options?: {
+        admissionAlreadyPresented?: boolean;
+        approvedScope?: string | null;
+    }): Promise<{
+        remoteNodeId?: string | null;
+        deviceId?: string | null;
+    } | unknown>;
+    waitForApplicationCryptoForPeer?(peerId?: string, timeoutMs?: number): Promise<unknown>;
+    hasApplicationRouteForPeer?(connectionId?: string, remoteNodeId?: string): boolean;
+}
 interface SignalingOptions {
     apiKey?: string;
-    allowAnonymousHostedDefaults?: boolean;
     authMode?: AuthMode;
     projectId?: string;
     storagePrefix?: string;
     nodeIdPersistence?: 'persistent' | 'ephemeral';
 }
 interface TransportContext {
-    sendMoQ: (data: Uint8Array) => Promise<void>;
+    sendMoQ: (data: Uint8Array, options?: {
+        alreadyProtected?: boolean;
+    }) => Promise<void>;
     priorities: ProtocolName[];
     disableIrohFallback: boolean;
     isMoQReady: () => boolean;
+    isMoQDataReady?: () => boolean;
     runtimeFlow?: 'default' | 'ticket-only';
     readerCloseStrategy?: 'cancel' | 'release-lock';
 }
+interface ApplicationPayloadCrypto {
+    /**
+     * When true, incoming application payloads that are not encrypted by this
+     * envelope are dropped before app callbacks fire.
+     */
+    requireEncrypted?: boolean;
+    protectPayload: (typeId: number, payload: Uint8Array) => Uint8Array;
+    openPayload: (expectedTypeId: number, payload: Uint8Array) => Uint8Array | null;
+}
+interface ApplicationCryptoBiStream {
+    send: WritableStream<Uint8Array>;
+    recv: ReadableStream<Uint8Array>;
+    endpoint_id?: string;
+}
+interface ApplicationCryptoStreamTools {
+    readonly typeId: number;
+    protectFrame: (payload: Uint8Array) => Uint8Array;
+    openFrame: (payload: Uint8Array) => Uint8Array | null;
+    createOutboundTransform: () => TransformStream<Uint8Array, Uint8Array>;
+    createInboundTransform: () => TransformStream<Uint8Array, Uint8Array>;
+    wrapReadable: (readable: ReadableStream<Uint8Array>) => ReadableStream<Uint8Array>;
+    wrapWritable: (writable: WritableStream<Uint8Array>) => WritableStream<Uint8Array>;
+    wrapBiStream: <T extends ApplicationCryptoBiStream>(stream: T) => T;
+}
+interface ApplicationPayloadReadinessOptions {
+    /**
+     * When provided, a connection is considered ready only once its active
+     * application route is one of these transports.
+     */
+    preferredTransports?: ProtocolName[];
+    /**
+     * If a preferred upgraded route cannot be established, allow the connection's
+     * proven application route to carry payloads instead of remaining pending.
+     */
+    allowFallbackAfterPreferredTransportFailure?: boolean;
+}
+interface ApplicationPayloadRouteOptions extends ApplicationPayloadReadinessOptions {
+    /**
+     * Include the parallel/fallback transport in diagnostic route listings.
+     * Normal app payload probes should leave this disabled so they measure the
+     * route OpenRTC would actually prefer for application data.
+     */
+    includeFallbackTransports?: boolean;
+}
+interface ApplicationPayloadSendOptions extends ApplicationPayloadRouteOptions {
+}
 interface ConnectionOptions {
     reliable?: boolean;
-    rtcConfig?: RTCConfiguration;
+    rtcConfig?: PlutoRTCConfiguration;
     transportContext?: TransportContext;
+    applicationCrypto?: ApplicationPayloadCrypto;
+    /** Framing used by the underlying iroh control stream. */
+    controlFrameMode?: 'typed' | 'native-main';
+    /**
+     * When true, public application payload sends wait for applicationCrypto to
+     * be installed and fail closed if key negotiation never completes.
+     * Internal handshake/control frames are sent through a separate control path.
+     */
+    requireApplicationCrypto?: boolean;
+    applicationCryptoWaitMs?: number;
     onTransportStatusChange?: (status: {
         activeTransport: ProtocolName;
         parallelTransport?: ProtocolName | null;
     }) => void;
+    /**
+     * Fired when the WebRTC data plane has proven a ping/pong round trip but the
+     * mandatory application crypto route is not installed yet. Connection owns
+     * transport proof; Client owns the application-route handshake recovery.
+     */
+    onApplicationRouteMissing?: (event: {
+        connectionId: string;
+        remoteNodeId: string;
+        reason: 'webrtc-heartbeat-before-crypto';
+        negotiationId?: string | null;
+    }) => void;
 }
 interface JoinRequest {
     id: string;
@@ -592,148 +787,4 @@ interface JoinRequest {
     state: 'pending' | 'accepted' | 'rejected';
 }
 
-type AuthContext = {
-    userId: string;
-    token?: string | null;
-    refreshToken?: string | null;
-    customToken?: string | null;
-    tokenProvider?: (forceRefresh?: boolean) => Promise<string | null>;
-    expiresAtMs?: number | null;
-};
-
-type RuntimeAdapterKind = 'browser-wasm' | 'native-ipc' | 'tauri-ipc' | 'unknown';
-interface RuntimeCapabilities {
-    adapter: RuntimeAdapterKind;
-    signaling: {
-        firestore: boolean;
-        nativeIpc: boolean;
-        rtdbPresence: boolean;
-    };
-    transport: {
-        irohQuic: boolean;
-        webRtcUpgrade: boolean;
-        nativeWebRtc: boolean;
-        wasm: boolean;
-    };
-    lifecycle: {
-        managedSession: boolean;
-        autoConnect: boolean;
-        manualDisconnect: boolean;
-        connectionStateEvents: boolean;
-        peerSessions: boolean;
-    };
-    transfers: {
-        explicitFilePath: boolean;
-        explicitFileData: boolean;
-        history: boolean;
-    };
-    fallback: {
-        wasm: boolean;
-    };
-}
-declare const BROWSER_WASM_RUNTIME_CAPABILITIES: RuntimeCapabilities;
-declare const NATIVE_IPC_RUNTIME_CAPABILITIES: RuntimeCapabilities;
-declare function cloneRuntimeCapabilities(capabilities: RuntimeCapabilities): RuntimeCapabilities;
-
-interface WasmBridgeOptions {
-    apiKey?: string;
-    discoveryMode?: DiscoveryMode;
-    spaceKey?: string;
-    authMode?: AuthMode;
-    signalingMode?: SignalingMode;
-    projectId?: string;
-    storagePrefix?: string;
-    nodeIdPersistence?: 'persistent' | 'ephemeral';
-    deviceName?: string;
-    turnCredentialsProvider?: () => Promise<{
-        iceServers?: RTCIceServer[];
-    } | null | undefined>;
-}
-
-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>;
-    stopAuthScopedActivity(): Promise<void>;
-    getTurnCredentials(): Promise<any>;
-    updatePresence(localNodeId: string, ticketStr: string, isOnline: boolean, ttlMs: number, metadata?: string): Promise<void>;
-    setOffline(localNodeId: string): Promise<void>;
-    cleanupStaleDevices(): Promise<void>;
-    searchDevices(excludeNodeId?: string): Promise<Device[]>;
-    listDevicesWithStatus(): Promise<DeviceStatusSnapshot[]>;
-    getPeerSession(id: string): Promise<PeerSessionSnapshot | null>;
-    listPeerSessions(): Promise<PeerSessionSnapshot[]>;
-    waitForSettledPeer(id: string, timeoutMs?: number): Promise<PeerSessionSnapshot | null>;
-    resolvePeerIdentity(id: string): Promise<ResolvedPeerIdentity>;
-    resolvePeerConnectionRecords(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[]>;
-    subscribeDevices(userId: string): Promise<ReadableStream<DeviceEvent[]>>;
-    startAutoConnect(userId: string, localDeviceId: string): 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[]>>;
-    forceReconnectSnapshot(): void;
-    getLocalDeviceId(): Promise<string | null>;
-    getLocalDeviceInfo(): Promise<LocalDeviceInfo | null>;
-    updateLocalDeviceName(deviceName: string): Promise<LocalDeviceInfo | null>;
-    startManagedSessionNative(options: {
-        userId: string;
-        deviceName?: string;
-        localDeviceId?: string | null;
-        metadata?: string;
-        autoConnect?: boolean;
-        presence?: boolean;
-    }): Promise<NativeManagedSessionStartResult>;
-    getManagedNodeId(options?: {
-        initializeIfMissing?: boolean;
-    }): Promise<string | null>;
-    startPresenceLoopOnce(userId: string, localNodeId: string, deviceName: string, ticket: string, metadata?: string): Promise<void>;
-    startAutoConnectOnce(userId: string, localDeviceId: string): Promise<void>;
-    getEndpointTicket(): Promise<string>;
-    getEndpointTicketWithToken(scope: GrantScope, maxConnections: number): Promise<string | null>;
-    registerSessionToken(token: string, scope: GrantScope, maxConnections: number): Promise<void>;
-    revokeSessionTokensByScope(scope: GrantScope): Promise<string[]>;
-    openPeerBi(id: string, timeoutMs?: number): Promise<BackendPeerBiStream>;
-    openPeerBiTransportOnly(id: string, timeoutMs?: number): Promise<BackendPeerBiStream>;
-    openPeerUni(id: string, timeoutMs?: number): Promise<BackendPeerUniStream>;
-    connectToDevice(params: {
-        deviceId?: string | null;
-        endpointTicket: string;
-    }): Promise<NativeConnectResult>;
-    disconnectDevice(deviceId: string): Promise<void>;
-    isConnected(nodeId: string): Promise<boolean>;
-    getConnectionStates(): Promise<BackendConnectionState[]>;
-    onConnectionStateChange(callback: (state: BackendConnectionState) => void): Promise<() => void> | (() => void);
-    sendExplicitFilePath(connectionId: string, filePath: string, transferId?: string): Promise<string>;
-    sendExplicitFileData(params: ExplicitFileDataSendParams): Promise<void>;
-    getTransferHistory(limit?: number): Promise<Array<[string, unknown]>>;
-    deleteTransferJob(jobId: string): Promise<void>;
-    getRuntimeCapabilities(): 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 { type AuthContext as A, type BackendConnectionState as B, type ConnectDeviceResult as C, DelegatingRuntimeAdapter as D, type ExplicitFileDataSendParams as E, type RoomCreationMode as F, type GrantScope as G, type ScanningLoopOptions as H, type IncomingStreamChannelMetadata as I, type JoinRoomOptions as J, type ScanningLoopHandle as K, type LocalDeviceInfo as L, type ManagedDeviceConnectOptions as M, type NativeConnectResult as N, type RuntimeBootstrapOptions as O, type PeerSessionSnapshot as P, type RuntimeBootstrapResult as Q, type ResolvedPeerIdentity as R, type SignalingMode as S, type JoinRequest as T, BROWSER_WASM_RUNTIME_CAPABILITIES as U, NATIVE_IPC_RUNTIME_CAPABILITIES as V, type WasmBridgeOptions as W, cloneRuntimeCapabilities as X, type ConnectDeviceHooks as a, type ConnectDeviceOptions as b, type RuntimeCapabilities as c, type AppLimits as d, type AuthMode as e, type DiscoveryMode as f, type ProtocolCapability as g, type ProtocolCapabilityMap as h, type ProtocolName as i, type RuntimeAdapterKind as j, type ClientOptions as k, type ChannelDescriptor as l, type Device as m, type SignalingSession as n, type RuntimeIdentity as o, type DeviceStatusSnapshot as p, type PeerState as q, type PeerHealth as r, type RoomMember as s, type PeerScope as t, type PeerLifecycleStatus as u, type ConnectionOptions as v, type ISignalingBackend as w, type ManagedConnectionRecord as x, type SignalingOptions as y, type SignalingEnvelope as z };
+export type { PeerHealth as $, AuthMode as A, BackendPeerBiStream as B, ClientOptions as C, DiscoveryMode as D, ExplicitFileDataSendParams as E, ProtocolImplementationKind as F, GrantScope as G, ProtocolLocality as H, ISignalingBackend as I, SpaceAuthMode as J, SignalingOptions as K, LocalDeviceInfo as L, ManagedConnectionRecord as M, NativeManagedSessionStartResult as N, JoinRoomOptions as O, PeerSessionSnapshot as P, RoomMember as Q, RuntimeIdentity as R, SignalingMode as S, IncomingStreamChannelMetadata as T, RoomCreationMode as U, ScanningLoopOptions as V, ScanningLoopHandle as W, RuntimeBootstrapOptions as X, RuntimeBootstrapResult as Y, PeerState as Z, PeerScope as _, Device as a, ChannelDescriptor as a0, JoinRequest as a1, ConnectionOptions as a2, ManagedDeviceConnectOptions as a3, PeerLifecycleStatus as a4, DeviceStatusSnapshot as b, ResolvedPeerIdentity as c, SignalingEnvelope as d, DeviceEvent as e, SignalingSession as f, SessionEvent as g, BackendPeerUniStream as h, NativeConnectResult as i, BackendConnectionState as j, ConnectDeviceResult as k, ConnectDeviceHooks as l, ConnectDeviceOptions as m, ProtocolName as n, ProtocolCapability as o, ProtocolCapabilityMap as p, ApplicationPayloadCrypto as q, ApplicationCryptoStreamTools as r, SpaceTokenProvider as s, AppLimits as t, ApplicationCryptoBiStream as u, ApplicationPayloadReadinessOptions as v, ApplicationPayloadRouteOptions as w, ApplicationPayloadSendOptions as x, DevicePresenceStatus as y, ProtocolBaseName as z };