openrtc 0.1.3 → 0.2.1

package/dist/{factories-0TxDPMeu.d.ts → framing-lxzHEuSr.d.ts}

@@ -1,145 +1,8 @@
-import { l as ChannelDescriptor$1, i as ProtocolName, L as LocalDeviceInfo, I as IncomingStreamChannelMetadata, k as ClientOptions, m as Device, n as SignalingSession, o as RuntimeIdentity, p as DeviceStatusSnapshot, M as ManagedDeviceConnectOptions, q as PeerState, r as PeerHealth, J as JoinRoomOptions, s as RoomMember, t as PeerScope, B as BackendConnectionState, A as AuthContext, u as PeerLifecycleStatus, P as PeerSessionSnapshot, v as ConnectionOptions, G as GrantScope, w as ISignalingBackend, c as RuntimeCapabilities, a as ConnectDeviceHooks, b as ConnectDeviceOptions, C as ConnectDeviceResult, x as ManagedConnectionRecord, R as ResolvedPeerIdentity, d as AppLimits, N as NativeConnectResult, E as ExplicitFileDataSendParams } from './DelegatingRuntimeAdapter-CW8d78dZ.js';
-import { P as PlutoIpcBridge, I as IpcRuntimeAdapter } from './IpcRuntimeAdapter-CT-W0Mtp.js';
+import { A as AuthContext, R as RuntimeCapabilities, a as RuntimeCapabilityProfile } from './DelegatingRuntimeAdapter-BxOcVIx_.js';
+import { a2 as ConnectionOptions, q as ApplicationPayloadCrypto, v as ApplicationPayloadReadinessOptions, w as ApplicationPayloadRouteOptions, n as ProtocolName, x as ApplicationPayloadSendOptions, a0 as ChannelDescriptor$1, L as LocalDeviceInfo, T as IncomingStreamChannelMetadata, C as ClientOptions, a as Device, f as SignalingSession, R as RuntimeIdentity, b as DeviceStatusSnapshot, a3 as ManagedDeviceConnectOptions, Z as PeerState, $ as PeerHealth, O as JoinRoomOptions, Q as RoomMember, _ as PeerScope, j as BackendConnectionState, y as DevicePresenceStatus, a4 as PeerLifecycleStatus, P as PeerSessionSnapshot, G as GrantScope, I as ISignalingBackend, l as ConnectDeviceHooks, m as ConnectDeviceOptions, k as ConnectDeviceResult, M as ManagedConnectionRecord, c as ResolvedPeerIdentity, t as AppLimits, i as NativeConnectResult, E as ExplicitFileDataSendParams } from './types-D0fRvUbN.js';
+import { P as PlutoIpcBridge, I as IpcRuntimeAdapter } from './IpcRuntimeAdapter-U5AEH0jn.js';
 import { WasmRuntimeAdapter } from './runtime/WasmRuntimeAdapter.js';
 
-/**
- * App-facing options intentionally hide transport node identifiers from callbacks.
- */
-type RuntimeClientOptions = Omit<ClientOptions, 'onDevices' | 'onAutoConnect' | 'onIncomingSession'> & {
-    onDevices?: (devices: RuntimeDevice[]) => void;
-    onAutoConnect?: (devices: RuntimeDevice[]) => void;
-    onIncomingSession?: (session: RuntimeSession) => Promise<void>;
-};
-/**
- * App-facing device model. Runtime transport identifiers stay internal.
- */
-type RuntimeDevice = Omit<Device, 'nodeId'>;
-/**
- * App-facing session model. Node identifiers are runtime-internal metadata.
- */
-type RuntimeSession = Omit<SignalingSession, 'initiatorNodeId' | 'targetNodeId' | 'appTag'>;
-type RuntimeAuthIdentity = RuntimeIdentity;
-type RuntimeAuthContext = AuthContext;
-/**
- * App-facing peer state model. Runtime transport identifiers stay internal.
- */
-type RuntimePeerState = Omit<PeerState, 'nodeId'>;
-type RuntimePeerHealth = PeerHealth;
-type RuntimePeerLifecycleStatus = PeerLifecycleStatus;
-type RuntimePeerScope = PeerScope;
-/**
- * App-facing peer session snapshot model. Runtime transport identifiers stay internal.
- */
-type RuntimePeerSessionSnapshot = Omit<PeerSessionSnapshot, 'nodeId'>;
-type RuntimeLocalDeviceInfo = LocalDeviceInfo;
-type RuntimeRoomMember = RoomMember;
-type RuntimeDeviceConnectOptions = ManagedDeviceConnectOptions;
-type RuntimeJoinRoomOptions = JoinRoomOptions;
-type RuntimeChannelDescriptor = ChannelDescriptor$1;
-interface RuntimeConnectionTarget {
-    ticket: string;
-    timeoutMs?: number;
-}
-interface RuntimePeerConnectOptions {
-    deviceId?: string;
-    ticket?: string;
-    scope?: RuntimePeerScope;
-    channelId?: string;
-}
-interface RuntimePeerStreamOptions {
-    ticket?: string;
-    scope?: RuntimePeerScope;
-    channelId?: string;
-    timeoutMs?: number;
-}
-/**
- * App-facing device status snapshot model. Runtime transport identifiers stay internal.
- */
-type RuntimeDeviceStatusSnapshot = Omit<DeviceStatusSnapshot, 'nodeId'>;
-type RuntimeDeviceStatus = RuntimeDeviceStatusSnapshot;
-type RuntimeIncomingStream = {
-    type: 'bi' | 'uni';
-    stream: any;
-    remoteNodeId: string;
-    protocolHint?: 'control' | 'explicit' | 'native-main' | 'unknown';
-    channel?: IncomingStreamChannelMetadata | null;
-};
-type RuntimeConnectionEvent = {
-    type: 'connected' | 'disconnected';
-    connectionId: string;
-    localNodeId: string;
-    remoteNodeId: string;
-    transport: ProtocolName;
-};
-type RuntimeRawConnection = {
-    connectionId: string;
-    localNodeId: string;
-    remoteNodeId: string;
-};
-type RuntimePresenceLoopOptions = {
-    deviceName?: string;
-    ticket?: string;
-    metadata?: string;
-};
-type RuntimeManagedSessionPlatform = 'native' | 'web';
-type RuntimeManagedSessionKind = 'app-user-device' | 'share-anonymous' | 'drive-grant-guest' | 'scoped-guest' | (string & {});
-type RuntimeAutoConnectPolicy = 'enabled' | 'disabled' | 'scoped-only';
-type RuntimePresencePolicy = 'online' | 'disabled';
-type RuntimeConnectionStateSnapshot = BackendConnectionState;
-type RuntimeUiConnectionStatus = 'connecting' | 'connected' | 'disconnected' | 'failed';
-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[];
-}
-interface RuntimeLocalDeviceProfile {
-    deviceId: string | null;
-    deviceName: string;
-    platformType: string;
-    userId: string | null;
-    capabilities: NonNullable<RuntimeLocalDeviceInfo['capabilities']>;
-    lastSeenAt: string;
-    localNodeId?: string | null;
-}
-interface RuntimeManagedSessionOptions {
-    platform: RuntimeManagedSessionPlatform;
-    sessionKind?: RuntimeManagedSessionKind;
-    scope?: string | null;
-    autoConnectPolicy?: RuntimeAutoConnectPolicy;
-    presencePolicy?: RuntimePresencePolicy;
-    userId?: string | null;
-    deviceName?: string;
-    localDeviceId?: string | null;
-    metadata?: string;
-    autoConnect?: boolean;
-    presence?: boolean;
-}
-interface RuntimeManagedSession {
-    mode: RuntimeManagedSessionPlatform;
-    device: RuntimeLocalDeviceProfile;
-    stop: () => Promise<void>;
-}
-type ConnectionTarget = RuntimeConnectionTarget;
-type PeerConnectOptions = RuntimePeerConnectOptions;
-type PeerStreamOptions = RuntimePeerStreamOptions;
-type IncomingStream = RuntimeIncomingStream;
-type ConnectionEvent = RuntimeConnectionEvent;
-type RawConnection = RuntimeRawConnection;
-type PresenceLoopOptions = RuntimePresenceLoopOptions;
-type PeerReadiness = RuntimePeerReadinessSnapshot;
-type DeviceProfile = RuntimeLocalDeviceProfile;
-type SessionOptions$1 = RuntimeManagedSessionOptions;
-type Session$1 = RuntimeManagedSession;
-type ChannelDescriptor = RuntimeChannelDescriptor;
-
 interface ITransport {
     readonly name: string;
     readonly isReady: boolean;
@@ -163,16 +26,21 @@ declare class Connection {
     private static readonly textEncoder;
     private static readonly UPGRADE_RETRY_DELAY_MS;
     private static readonly MAX_UPGRADE_RETRIES;
+    private static readonly MAX_UPGRADE_REDRIVES;
+    private static readonly UPGRADE_REDRIVE_DELAY_MS;
     private static readonly WEBRTC_DISCONNECTED_GRACE_MS;
     private static readonly MAX_PENDING_MESSAGES;
+    private static readonly DEFAULT_APPLICATION_CRYPTO_WAIT_MS;
     /**
      * Must exceed `WEBRTC_ICE_CONNECT_TIMEOUT_MS` in `WebRTCTransport`: the transport
      * waits that long for ICE + DataChannel before `failed`. A shorter watchdog here
      * tears the PC down early, burns `MAX_UPGRADE_RETRIES`, and stretches upgrades to ~60s+ under load.
      */
     private static readonly WEBRTC_UPGRADE_ATTEMPT_TIMEOUT_MS;
+    private static readonly MAX_PENDING_ENCRYPTED_APPLICATION_PAYLOADS;
     private listeners;
     private pendingMessages;
+    private pendingEncryptedApplicationPayloads;
     private webrtcBinaryHandlers;
     private closeListeners;
     private upgradeStateListeners;
@@ -188,34 +56,61 @@ declare class Connection {
     readonly localNodeId: string;
     private options;
     private writeMutex;
+    private applicationCryptoWaiters;
     private nativeSignalSender;
     private webrtcTransport;
+    private webRtcApplicationRouteReadyTransport;
+    private webRtcApplicationRouteReadyNegotiationId;
     private upgradeState;
     private upgradeRequested;
+    private negotiationSwitchCount;
     private upgradeAttemptActive;
     private upgradeRetryCount;
+    private upgradeReDriveCount;
+    private upgradeReDriveTimer;
     private upgradeRetryTimer;
     private upgradeAttemptTimeoutTimer;
     private lastReportedTransportStatus;
+    private applicationRouteMissingNotified;
     private upgradeTerminalFailure;
     private pendingSignals;
     private activeNegotiationId;
     private webrtcHeartbeat;
     private webRtcHeartbeatProbeInFlight;
+    private webRtcApplicationRouteProbeInFlight;
     private webRtcHeartbeatConsecutiveProbeFailures;
     private irohHealthListeners;
     private webrtcHealthListeners;
     private lastWebRtcHeartbeatOkAt;
     private lastWebRtcDataChannelOpenAt;
+    private static readonly WEBRTC_RENEGOTIATE_LIVENESS_WINDOW_MS;
+    private static readonly MAX_NEGOTIATION_SWITCHES;
     private lastForegroundAt;
     private webRtcDisconnectedGraceTimer;
     private preferredWebRtcRole;
     constructor(id: string, localNodeId: string, remoteNodeId: string, writer: WritableStreamDefaultWriter<Uint8Array>, reader: ReadableStreamDefaultReader<Uint8Array>, options?: ConnectionOptions);
+    setApplicationCrypto(applicationCrypto: ApplicationPayloadCrypto | undefined): void;
+    requireApplicationCrypto(): void;
+    isApplicationCryptoRequired(): boolean;
+    isReadyForApplicationPayload(options?: ApplicationPayloadReadinessOptions): boolean;
+    getApplicationPayloadTransports(options?: ApplicationPayloadRouteOptions): ProtocolName[];
+    private isTransportAvailableForApplicationPayload;
+    private resolveApplicationCryptoWaiters;
+    private rejectApplicationCryptoWaiters;
+    private waitForRequiredApplicationCrypto;
     /**
      * Starts WebRTC upgrade only when peer capability negotiation allows it.
      * No-op when WebRTC is not configured or an upgrade already started.
      */
     requestWebRTCUpgrade(reason?: string): void;
+    /**
+     * Whether the current WebRTC route is provably alive: an open data channel
+     * plus either a recent heartbeat round trip or a freshly opened channel. An
+     * `open` readyState alone is not proof — it lingers for many seconds after the
+     * remote vanishes (e.g. a page reload), so a dead-but-`open` channel reports
+     * not-live and can be replaced rather than trusted.
+     */
+    private isWebRtcRouteHeartbeatLive;
     requestTransportRecovery(reason: string, options?: {
         forceRenegotiate?: boolean;
         replaceExisting?: boolean;
@@ -248,6 +143,8 @@ declare class Connection {
             candidateTypeSummary: string | null;
         } | null;
     }>;
+    private lastWebRtcLocalCandidateType;
+    private lastWebRtcRemoteCandidateType;
     get transportType(): ProtocolName;
     private _peerMoQReady;
     get peerMoQReady(): boolean;
@@ -260,7 +157,7 @@ declare class Connection {
      * Send a message to the other peer.
      * Messages can be strings or objects (JSON stringified).
      */
-    send(message: string | object | ArrayBuffer | Uint8Array): Promise<void>;
+    send(message: string | object | ArrayBuffer | Uint8Array, options?: ApplicationPayloadSendOptions): Promise<void>;
     /**
      * Send media data (video/audio header + payload)
      * Internal use for now.
@@ -271,24 +168,41 @@ declare class Connection {
      * Throws when the requested transport is unavailable.
      */
     sendOnTransport(transport: ProtocolName, message: string | object | ArrayBuffer | Uint8Array): Promise<void>;
+    /**
+     * Send plaintext control traffic that is required to bootstrap application
+     * key agreement. This is intentionally separate from public app-data sends.
+     */
+    sendControl(message: string | object | ArrayBuffer | Uint8Array): Promise<void>;
     /**
      * Write an already-framed payload directly on the underlying iroh control stream.
      * Used by native-main signaling paths that must preserve protocol framing.
      */
     sendRawIrohFrame(frame: Uint8Array): Promise<void>;
     /**
-     * Return currently usable transports for this connection.
+     * Compatibility/diagnostic view of currently usable transports.
+     *
+     * Lifecycle projection and route selection must use getTransportStatus().
+     * This legacy list intentionally remains for older callers and tests that
+     * need a human-readable inventory, but it is not an authority for active
+     * versus fallback transport state.
      */
     getAvailableTransports(): ProtocolName[];
     onWebRTCBinaryMessage(handler: (data: Uint8Array) => boolean): void;
+    private dispatchWebRtcBinaryHandlers;
     getWebRTCTransport(): ITransport | null;
     sendOnWebRTC(data: Uint8Array): Promise<void>;
     private encodePayload;
+    private protectApplicationPayload;
+    private openApplicationPayload;
+    private openUntypedApplicationPayload;
+    private queueEncryptedApplicationPayload;
+    private flushPendingEncryptedApplicationPayloads;
     private buildFrame;
     private sendOverIroh;
     private sendUsingTransport;
     private sendTypedOnTransport;
     private sendTyped;
+    private getSendTransportPriorities;
     /**
      * Disconnect the connection
      */
@@ -310,6 +224,7 @@ declare class Connection {
     private readLoop;
     injectData(chunk: Uint8Array): void;
     private handleData;
+    private tryHandlePlaintextNativeSignal;
     private static isUntypedDataFrame;
     private processDataPayload;
     private isLikelyTextPayload;
@@ -318,6 +233,8 @@ declare class Connection {
     receiveMessage(msg: any): void;
     receiveDataPayload(messageData: Uint8Array): void;
     private trackListeners;
+    private warnedSrtpApplicationCryptoBoundary;
+    private warnSrtpApplicationCryptoBoundary;
     addTrack(track: MediaStreamTrack): RTCRtpSender | null;
     addTransceiver(trackOrKind: MediaStreamTrack | string, init?: RTCRtpTransceiverInit): RTCRtpTransceiver | null;
     onTrack(callback: (event: RTCTrackEvent) => void): void;
@@ -325,10 +242,12 @@ declare class Connection {
     private isWebRtcDataChannelOpen;
     private clearWebRtcDisconnectedGraceTimer;
     private transportStillLikelyAlive;
-    private handleDisconnectedTransportStateWithGrace;
+    private handleUnhealthyWebRtcTransportStateWithGrace;
     private attemptUpgrade;
     private setUpgradeState;
     private handleUpgradeFailure;
+    private scheduleUpgradeReDrive;
+    private clearUpgradeReDriveTimer;
     private shouldRetryUpgrade;
     private scheduleUpgradeRetry;
     private clearUpgradeRetryTimer;
@@ -337,14 +256,75 @@ declare class Connection {
     private teardownWebRTCTransport;
     private startWebRtcHeartbeat;
     private stopWebRtcHeartbeat;
+    private notifyWebRtcApplicationRouteMissing;
+    private startWebRtcApplicationRouteProbe;
     private sendIrohHeartbeatPong;
     /** Register a listener for WebRTC heartbeat health changes. */
     onWebRtcHeartbeatHealth(cb: (health: ConnectionHealth) => void): void;
     /** Register a listener for iroh heartbeat health changes (WASM path). */
     onIrohHeartbeatHealth(cb: (health: ConnectionHealth) => void): void;
     reportTransportStatusIfChanged(): void;
+    /**
+     * Single connection-owned transport snapshot for status reporting,
+     * lifecycle projection, and diagnostics. The active route is application
+     * ready; the parallel route is its usable fallback or candidate.
+     */
+    getTransportStatus(): {
+        activeTransport: ProtocolName;
+        parallelTransport: ProtocolName | null;
+    };
     private resolveParallelTransport;
     setNativeSignalSender(sender: (envelope: any) => Promise<void>): void;
+    /**
+     * Structured connection-lifecycle log. One event per meaningful transition
+     * (upgrade requested/started/failed, route promoted, app route ready, …) with
+     * the connection's current lifecycle snapshot, so the whole connection flow
+     * can be reconstructed from logs. Emits both a human line and a JSON line.
+     */
+    private traceLifecycle;
+    getControlFrameMode(): NonNullable<ConnectionOptions['controlFrameMode']>;
+    /**
+     * Send a control envelope over the native-main signal route. Returns false
+     * (without sending) unless this connection is in `native-main` control-frame
+     * mode and has a native signal sender, so a typed connection never
+     * accidentally routes control through the native sender.
+     */
+    sendNativeControlEnvelope(envelope: any): Promise<boolean>;
+    /**
+     * Promote a connection to the native-main control plane: switch its
+     * control-frame mode to `native-main` and attach the native signal sender.
+     * Used when native-main evidence arrives for a connection that bootstrapped
+     * on a typed stream, so subsequent control traffic flows over the durable
+     * native-main route even if the bootstrap stream later closes.
+     */
+    promoteToNativeMainControlRoute(sender: (envelope: any) => Promise<void>): void;
+    private hasRequiredApplicationCrypto;
+    private clearWebRtcApplicationRouteReady;
+    private isCurrentWebRtcTransportApplicationRouteReady;
+    private isWebRtcApplicationRouteReadyForTransport;
+    /**
+     * Mark the upgraded WebRTC data plane as carrying a proven application route
+     * (data channel open + required crypto present). Idempotent. Promotes the
+     * active transport projection to `webrtc` via reportTransportStatusIfChanged.
+     */
+    private markWebRtcApplicationRouteReady;
+    /**
+     * True only when the WebRTC transport is upgraded AND its application route
+     * is proven (crypto present). The active route must not advertise `webrtc`
+     * until this holds, so a half-open data channel never looks routable.
+     */
+    isWebRtcApplicationRouteReady(): boolean;
+    /**
+     * MoQ has a different data-plane shape than WebRTC: it is a shared relay
+     * session on the Client plus a peer capability/subscription bit on this
+     * Connection. Even so, it follows the same lifecycle invariant as every
+     * custom transport: do not advertise it as the active application route until
+     * the local transport is ready, the peer route is enabled, and the required
+     * application crypto is available. Future MoQ route probes should tighten
+     * this predicate, not bypass it.
+     */
+    isMoQApplicationRouteReady(): boolean;
+    private isMoQDataRouteReady;
     private sendInternalSignal;
     receiveInternalSignal(content: any): void;
     private handleInternalSignal;
@@ -353,6 +333,203 @@ declare class Connection {
     private normalizeNegotiationId;
 }
 
+/**
+ * Coalesced peer reconciliation scheduler and full reconcile orchestration.
+ *
+ * Internal `Client` triggers schedule through `schedulePeerReconciliation()` so
+ * concurrent refresh requests share one in-flight `runPeerReconciliation` pass.
+ */
+
+type PeerReconciliationStats = {
+    scheduled: number;
+    coalesced: number;
+    ran: number;
+    orphanTsConnection: number;
+    orphanRustRecord: number;
+    orphanTsConnectionHealed: number;
+};
+
+/**
+ * App-facing options intentionally hide transport node identifiers from callbacks.
+ */
+type RuntimeClientOptions = Omit<ClientOptions, 'onDevices' | 'onAutoConnect' | 'onIncomingSession'> & {
+    onDevices?: (devices: RuntimeDevice[]) => void;
+    onAutoConnect?: (devices: RuntimeDevice[]) => void;
+    onIncomingSession?: (session: RuntimeSession) => Promise<void>;
+};
+/**
+ * App-facing device model. Runtime transport identifiers stay internal.
+ */
+type RuntimeDevice = Omit<Device, 'nodeId'>;
+/**
+ * App-facing session model. Node identifiers are runtime-internal metadata.
+ */
+type RuntimeSession = Omit<SignalingSession, 'initiatorNodeId' | 'targetNodeId' | 'appTag'>;
+type RuntimeAuthIdentity = RuntimeIdentity;
+type RuntimeAuthContext = AuthContext;
+/**
+ * App-facing peer state model. Runtime transport identifiers stay internal.
+ */
+type RuntimePeerState = Omit<PeerState, 'nodeId'>;
+type RuntimePeerHealth = PeerHealth;
+type RuntimePeerLifecycleStatus = PeerLifecycleStatus;
+type RuntimePeerScope = PeerScope;
+/**
+ * App-facing peer session snapshot model. Runtime transport identifiers stay internal.
+ */
+type RuntimePeerSessionSnapshot = Omit<PeerSessionSnapshot, 'nodeId'>;
+type RuntimeLocalDeviceInfo = LocalDeviceInfo;
+type RuntimeRoomMember = RoomMember;
+type RuntimeDeviceConnectOptions = ManagedDeviceConnectOptions;
+type RuntimeJoinRoomOptions = JoinRoomOptions;
+type RuntimeChannelDescriptor = ChannelDescriptor$1;
+interface RuntimeConnectionTarget {
+    ticket: string;
+    timeoutMs?: number;
+}
+interface RuntimePeerConnectOptions {
+    deviceId?: string;
+    ticket?: string;
+    scope?: RuntimePeerScope;
+    channelId?: string;
+    /**
+     * When true, automatic/observer dials fail fast if the peer has a sticky
+     * manual-disconnect projection for this app session. User-initiated manual
+     * reconnects should leave this unset and clear the exclusion explicitly.
+     */
+    respectManualDisconnect?: boolean;
+}
+interface RuntimePeerStreamOptions {
+    ticket?: string;
+    scope?: RuntimePeerScope;
+    channelId?: string;
+    timeoutMs?: number;
+}
+type RuntimeLogicalChannelFraming = 'raw' | 'u32be';
+interface RuntimeScopedChannelOptions {
+    peerId?: string;
+    peerNodeId?: string;
+    deviceId?: string | null;
+    ticket?: string;
+    scope: RuntimePeerScope;
+    channelId: string;
+    timeoutMs?: number;
+    respectManualDisconnect?: boolean;
+    /**
+     * Native product protocols such as Plutonium drive-view expect a plaintext
+     * stream label before payload frames. OpenRTC owns that handshake here so
+     * apps do not need to choose raw transport APIs.
+     */
+    nativeLabel?: boolean;
+    framing?: RuntimeLogicalChannelFraming;
+}
+interface RuntimeScopedLogicalChannel {
+    channelId: string;
+    peerId: string;
+    connection: Connection;
+    send(payload: Uint8Array): Promise<void>;
+    onMessage(callback: (payload: Uint8Array) => void): () => void;
+    close(): Promise<void>;
+    diagnostics(): {
+        connectionId: string | null;
+        remoteNodeId: string | null;
+        transports: string[];
+        framing: RuntimeLogicalChannelFraming;
+        nativeLabel: boolean;
+    };
+}
+/**
+ * App-facing device status snapshot model. Runtime transport identifiers stay internal.
+ */
+type RuntimeDeviceStatusSnapshot = Omit<DeviceStatusSnapshot, 'nodeId'>;
+type RuntimeDeviceStatus = RuntimeDeviceStatusSnapshot;
+type RuntimeDevicePresenceStatus$1 = DevicePresenceStatus;
+type RuntimeIncomingStream = {
+    type: 'bi' | 'uni';
+    stream: any;
+    remoteNodeId: string;
+    protocolHint?: 'control' | 'explicit' | 'native-main' | 'unknown';
+    channel?: IncomingStreamChannelMetadata | null;
+};
+type RuntimeConnectionEvent = {
+    type: 'connected' | 'disconnected';
+    connectionId: string;
+    localNodeId: string;
+    remoteNodeId: string;
+    transport: ProtocolName;
+};
+type RuntimeRawConnection = {
+    connectionId: string;
+    localNodeId: string;
+    remoteNodeId: string;
+};
+type RuntimePresenceLoopOptions = {
+    deviceName?: string;
+    ticket?: string;
+    metadata?: string;
+};
+type RuntimeManagedSessionPlatform = 'native' | 'web';
+type RuntimeManagedSessionKind = 'app-user-device' | 'share-anonymous' | 'drive-grant-guest' | 'scoped-guest' | (string & {});
+type RuntimeAutoConnectPolicy = 'enabled' | 'disabled' | 'scoped-only';
+type RuntimePresencePolicy = 'online' | 'disabled';
+type RuntimeConnectionStateSnapshot = BackendConnectionState;
+type RuntimeApplicationPayloadReadinessOptions = ApplicationPayloadReadinessOptions;
+type RuntimeUiConnectionStatus = 'connecting' | 'connected' | 'disconnected' | 'failed';
+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[];
+}
+interface RuntimeLocalDeviceProfile {
+    deviceId: string | null;
+    deviceName: string;
+    platformType: string;
+    userId: string | null;
+    capabilities: NonNullable<RuntimeLocalDeviceInfo['capabilities']>;
+    lastSeenAt: string;
+    localNodeId?: string | null;
+}
+interface RuntimeManagedSessionOptions {
+    platform: RuntimeManagedSessionPlatform;
+    sessionKind?: RuntimeManagedSessionKind;
+    scope?: string | null;
+    autoConnectPolicy?: RuntimeAutoConnectPolicy;
+    presencePolicy?: RuntimePresencePolicy;
+    userId?: string | null;
+    deviceName?: string;
+    localDeviceId?: string | null;
+    metadata?: string;
+    autoConnect?: boolean;
+    presence?: boolean;
+}
+interface RuntimeManagedSession {
+    mode: RuntimeManagedSessionPlatform;
+    device: RuntimeLocalDeviceProfile;
+    stop: () => Promise<void>;
+}
+type ConnectionTarget = RuntimeConnectionTarget;
+type PeerConnectOptions = RuntimePeerConnectOptions;
+type PeerStreamOptions = RuntimePeerStreamOptions;
+type ScopedChannelOptions = RuntimeScopedChannelOptions;
+type ScopedLogicalChannel = RuntimeScopedLogicalChannel;
+type IncomingStream = RuntimeIncomingStream;
+type ConnectionEvent = RuntimeConnectionEvent;
+type RawConnection = RuntimeRawConnection;
+type PresenceLoopOptions = RuntimePresenceLoopOptions;
+type PeerReadiness = RuntimePeerReadinessSnapshot;
+type DeviceProfile = RuntimeLocalDeviceProfile;
+type SessionOptions$1 = RuntimeManagedSessionOptions;
+type Session$1 = RuntimeManagedSession;
+type ChannelDescriptor = RuntimeChannelDescriptor;
+
 interface SessionOptions {
     /**
      * Logical purpose of this session. Used as a peer-scope tag on all
@@ -430,6 +607,7 @@ declare class ScopedSession implements Session {
     disconnectPeer(peerId: string): Promise<void>;
     onIncomingStream(callback: (stream: RuntimeIncomingStream) => void): () => void;
     dispose(): void;
+    private releaseScopedPeersOnDispose;
     private assertNotDisposed;
 }
 
@@ -437,29 +615,29 @@ declare class ScopedSession implements Session {
  * Phase 4 of the OpenRTC auth + connection remediation plan
  * (`docs/plans/openrtc-auth-connection-remediation-plan.md`).
  *
- * `DriveGrantActorHandle` is the TS mirror of the Rust
- * `DriveGrantConnectionActor` (see `openrtc/crates/openrtc/src/client/drive_grant_actor.rs`).
- * It is the single observer-facing API for drive-grant guest connections:
- * `DriveViewClient`, `DriveShareRedeemPage`, and friends call this handle
- * instead of dialing/retrying directly. With one handle per
- * `(scope, peerNodeId)` key, multiple requesters that share a connection
- * coalesce their `ensureReady()` calls onto a single underlying dial —
- * removing the lifecycle-replacement race documented in `logs-desktop-A.md`.
+ * `DriveGrantActorHandle` is the historical implementation behind the public
+ * `ScopedConnectionActorHandle` alias. It is a TypeScript observer-side dial
+ * coalescer for scoped protocol routes such as drive-grant guests and
+ * trusted-device drive-view. It mirrors the intended Rust actor shape but is
+ * not backed by the Rust actor today. With one handle per `(scope, peerNodeId)`
+ * key, participating callers coalesce `ensureReady()` onto one underlying
+ * `connectPeer` call. It is not a general peer lifecycle authority.
  *
  * ## Scope
  *
- * Phase 4 lands the handle + `RuntimeClient.getDriveGrantActor` accessor
- * + observer-side rewiring. The actor is **not yet** wired into the
- * underlying Rust dial path — the legacy `connectPeer` codepath continues
- * to run (Phase 7 flips that). What changes today:
+ * The handle is not wired into the underlying Rust dial path; it delegates to
+ * the existing `connectPeer` path. It remains a transitional compatibility
+ * layer until the runtime chooses one actor implementation and wires it
+ * end-to-end. What it does today:
  *
- *   - `DriveViewClient.ensureGrantConnected` calls
- *     `runtimeClient.getDriveGrantActor(scope, peerNodeId).ensureReady()`,
- *     then performs its existing `connectPeer` call inside the
- *     handle-owned `dial` function. Multiple concurrent observers for the
- *     same key thus coalesce to one `connectPeer` call.
- *   - `DeviceContext` for `app-user-device` is bit-for-bit unchanged —
- *     this file only loads when `sessionKind === 'drive-grant-guest'`.
+ *   - `DriveGrantConnectionPipeline` and trusted-device drive-view acquisition call
+ *     `runtimeClient.getScopedConnectionActor(scope, peerNodeId).ensureReady()`,
+ *     then perform their existing `connectPeer` call inside the handle-owned
+ *     `dial` function. Multiple concurrent observers for the same key thus
+ *     coalesce to one `connectPeer` call.
+ *   - `DeviceContext` for the managed `app-user-device` session remains
+ *     separate. It owns app presence/auto-connect and must not call this
+ *     observer coalescer directly.
  *
  * ## Coalescing semantics
  *
@@ -479,16 +657,22 @@ declare class ScopedSession implements Session {
  *                                  |   --(failure)--> `idle`
  *   `<any>` --(shutdown)--> `closed`
  *
- * The Rust actor enforces the same shape; the two are intentionally kept
- * isomorphic so Phase 7 can collapse the TS handle into a thin observer
- * over the Rust actor without changing call sites.
+ * 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.
+ *
+ * The Rust actor has a similar shape but is inactive scaffolding in the current
+ * workspace. Treat the two implementations as migration debt, not redundant
+ * production authorities.
  */
 type DriveGrantActorErrorKind = 'shutdown' | 'dial-failed' | 'not-ready' | 'logical-channel-not-implemented';
 declare class DriveGrantActorError extends Error {
     readonly kind: DriveGrantActorErrorKind;
     constructor(kind: DriveGrantActorErrorKind, message: string);
 }
-type DriveGrantWebRtcState = 'unknown' | 'disabled' | 'connecting' | 'connected' | 'failed';
+type DriveGrantActorState = 'idle' | 'dialing' | 'base-ready' | 'protocol-ready' | 'degraded' | 'closed';
+type DriveGrantPreferredTransport = 'webrtc' | 'base' | 'none';
 interface DriveGrantConnectionKey {
     scope: string;
     peerNodeId: string;
@@ -514,22 +698,23 @@ interface DriveGrantActorHandleOptions {
 interface DriveGrantLogicalChannelHandle {
     label: string;
 }
-type WebRtcListener = (state: DriveGrantWebRtcState) => void;
 declare class DriveGrantActorHandle {
     readonly key: DriveGrantConnectionKey;
     private readonly dial;
     private readonly close;
     private state;
     private inFlight;
-    private webrtcState;
-    private webrtcListeners;
     constructor(options: DriveGrantActorHandleOptions);
     /** Returns true if the actor has resolved a successful dial and is not shut down. */
     isReady(): boolean;
     /** Returns true after `shutdown()` has been called. */
     isClosed(): boolean;
+    getState(): DriveGrantActorState;
+    getPreferredTransport(): DriveGrantPreferredTransport;
+    markProtocolReady(): void;
+    markDegraded(): void;
     /**
-     * Phase 7 correlation context. Always populated with
+     * Correlation context. Always populated with
      * `sessionKind=drive-grant-guest`, `scope`, `peerNodeId`, and
      * (when the scope encodes one) `grantId`.
      */
@@ -540,15 +725,6 @@ declare class DriveGrantActorHandle {
      * `shutdown()` flips state to `closed`.
      */
     ensureReady(): Promise<void>;
-    /** Subscribe to WebRTC adoption state. Returns an unsubscribe fn. */
-    observeWebRtc(listener: WebRtcListener): () => void;
-    /** Current WebRTC state without subscribing. */
-    getWebRtcState(): DriveGrantWebRtcState;
-    /**
-     * Test/Phase-7 hook: lifecycle code that learns of a WebRTC state
-     * transition pushes it via this method so observers see the change.
-     */
-    setWebRtcState(state: DriveGrantWebRtcState): void;
     /**
      * Phase 6: returns a logical channel handle backed by the base iroh
      * transport. The host-side `DriveViewBaseIrohHandler` dispatches
@@ -565,8 +741,7 @@ declare class DriveGrantActorHandle {
     openLogicalChannelTestStub(label: string): Promise<DriveGrantLogicalChannelHandle>;
     /**
      * Idempotent shutdown. Subsequent `ensureReady()` rejects with
-     * `shutdown`; subsequent `shutdown()` is a no-op. Observers receive
-     * a final `'failed'` state so they can wire teardown side-effects.
+     * `shutdown`; subsequent `shutdown()` is a no-op.
      */
     shutdown(): Promise<void>;
 }
@@ -657,15 +832,18 @@ declare class RuntimeClient {
     private managedSessionTransition;
     private managedSessionStartInFlight;
     private readonly managedReconciliationTasks;
+    private managedReconciliationTimer;
+    private readonly managedReconciliationFollowupTimers;
+    private nativeIncomingMessageSubscriptionAttached;
     /**
-     * Phase 4: per-`{scope, peerNodeId}` scoped-connection actor registry.
-     * Lazily created; `null` until an observer first calls `getDriveGrantActor`
-     * (legacy name) or `getScopedConnectionActor` (generic alias).
+     * The one per-`{scope, peerNodeId}` observer-side dial coalescer. It is
+     * intentionally separate from the peer lifecycle read model: it requests a
+     * scoped route through `connectPeer`, while `Client` owns connection state.
      *
-     * Note: persistent same-account auto-connect (`app-user-device`) and
-     * anonymous share flows (`share-anonymous`) do not use this coalescer.
+     * Persistent same-account auto-connect (`app-user-device`) and anonymous
+     * share flows (`share-anonymous`) do not use this grant-guest coalescer.
      */
-    private driveGrantActorRegistry;
+    private scopedConnectionActorRegistry;
     private static describeTicketForLogs;
     private serializeManagedSessionOperation;
     constructor(options: RuntimeClientOptions, backend?: ISignalingBackend | null);
@@ -674,7 +852,6 @@ declare class RuntimeClient {
     private resolveManagedAutoConnectEnabled;
     private resolveManagedPresenceEnabled;
     private getEffectiveRuntimeUserId;
-    private sleep;
     private fetchAndApplyAppLimits;
     private resolvePeerStreamTarget;
     private compatPeerConnectionFromTarget;
@@ -682,11 +859,14 @@ declare class RuntimeClient {
     private hasManagedSession;
     private usesNativeIpcBackend;
     private startManagedReconciliation;
+    private scheduleManagedReconciliationFollowups;
+    private stopManagedReconciliation;
     private notifyManagedReconciliation;
     reconcileNativeManagedSession(reason?: string): Promise<void>;
     private connectionStateSnapshotKey;
     private runNativeStartLoop;
     private isUnsupportedRuntimeAdapterError;
+    private isRecoverableNativeManagedSessionStartError;
     onIdentityChange(callback: (identity: RuntimeAuthIdentity | null) => void): () => void;
     signInAnonymously(): Promise<void>;
     signInWithPluto(): Promise<void>;
@@ -699,8 +879,13 @@ declare class RuntimeClient {
         localNodeId?: string;
         userId?: string;
     }>;
+    getPeerReconciliationStats(): Readonly<PeerReconciliationStats>;
     getRuntimePolicy(): RuntimePolicySnapshot;
     getRuntimeCapabilities(): RuntimeCapabilities;
+    getCapabilityProfile(): RuntimeCapabilityProfile;
+    private attachNativeIncomingMessageSubscription;
+    private attachNativeIncomingStreamSource;
+    private resolveNativeIncomingStreamSource;
     start(options?: {
         clearSessionTokens?: boolean;
     }): Promise<void>;
@@ -790,6 +975,7 @@ declare class RuntimeClient {
      */
     connectDevice(device: RuntimeDevice, options: RuntimeDeviceConnectOptions): Promise<ConnectDeviceResult>;
     watchPeerStates(callback: (peers: RuntimePeerState[]) => void): () => void;
+    watchPeerLifecycle(callback: (peers: RuntimePeerState[]) => void): () => void;
     getPeerState(id: string): RuntimePeerState | undefined;
     resolvePeerConnectionRecords(id: string): Promise<ManagedConnectionRecord[]>;
     getPeerSession(id: string): Promise<PeerSessionSnapshot | null>;
@@ -804,8 +990,9 @@ declare class RuntimeClient {
     getPeerScopes(id: string): string[];
     isSamePeer(a: string, b: string): boolean;
     refreshPeerSnapshot(): Promise<RuntimePeerState[]>;
-    subscribeSessions(localDeviceId: string, callback: (session: RuntimeSession) => void): Promise<() => void>;
+    subscribeSessions(localDeviceId: string, callback: (session: RuntimeSession) => void | Promise<void>): Promise<() => void>;
     getAppLimits(): AppLimits;
+    private syncRoomRtdbPresenceFromBackend;
     createRoom(roomId?: string): Promise<string>;
     joinRoom(roomId: string, options?: RuntimeJoinRoomOptions): Promise<Connection[]>;
     leaveRoom(roomId: string): Promise<void>;
@@ -814,26 +1001,24 @@ declare class RuntimeClient {
     /** @deprecated Use connect() (no-arg) for lifecycle, or connectTo() for peer connections */
     connectByTicket(target: RuntimeConnectionTarget): Promise<Connection>;
     connectPeer(options: RuntimePeerConnectOptions): Promise<Connection>;
+    connectScopedChannel(options: RuntimeScopedChannelOptions): Promise<RuntimeScopedLogicalChannel>;
     /**
-     * Phase 4 of the OpenRTC auth + connection remediation plan:
-     * returns the per-`{scope, peerNodeId}` actor handle that
-     * drive-grant guest observers (DriveViewClient,
-     * DriveShareRedeemPage) coalesce through. The first call for a
-     * given key spawns the handle; subsequent calls return the same
+     * Returns the per-`{scope, peerNodeId}` observer-side coalescer that
+     * participating scoped guest callers (such as DriveViewClient) use. The
+     * first call for a given key spawns the handle; subsequent calls return the same
      * handle so concurrent observers share a single underlying dial.
      *
-     * The handle's `dial` function delegates to this RuntimeClient's
-     * existing `connectPeer` API — the actor is purely an observer
-     * coalescer in Phase 4. Phase 7 collapses this onto the Rust
-     * actor in `Client::drive_grant_actor_registry`.
+     * The handle's `dial` function delegates to this RuntimeClient's existing
+     * `connectPeer` API. It is a compatibility coalescer, not an independent
+     * transport owner, and the Rust registry is not enabled by workspace
+     * production startup.
      *
-     * Calling this from `app-user-device` paths is a programming bug
-     * — the registry is scoped to drive-grant-guest connections by
-     * convention, and same-account auto-connect must not coalesce
-     * onto a single shared dial (each device-pair has its own
-     * lifecycle).
+     * Managed `app-user-device` startup/presence/auto-connect must not call
+     * this observer coalescer directly. Scoped protocol observers may use it
+     * only with a narrow `dial` callback that delegates back through
+     * `connectPeer`; the runtime `Client` remains the peer lifecycle owner.
      */
-    getDriveGrantActor(key: DriveGrantConnectionKey | {
+    getScopedConnectionActor(key: DriveGrantConnectionKey | {
         scope: string;
         peerNodeId: string;
     }, options?: {
@@ -851,37 +1036,26 @@ declare class RuntimeClient {
          * router/disconnect handler to the connection object) can
          * supply their own `dial` here. The actor's coalescer still
          * ensures only one `dial(key)` runs even with N concurrent
-         * `getDriveGrantActor(...).ensureReady()` callers — this just
+         * `getScopedConnectionActor(...).ensureReady()` callers — this just
          * lets the caller decide what "dial" means.
          */
         dial?: (key: DriveGrantConnectionKey) => Promise<void>;
     }): DriveGrantActorHandle;
-    /**
-     * Domain-agnostic alias for `getDriveGrantActor`.
-     *
-     * OpenRTC’s per-`{scope, peerNodeId}` actor is a generic “scoped connection”
-     * coalescer. Plutonium’s drive-grant flows were the first adopter, but other
-     * app protocols (magic-link, user-device, etc.) may also want the same shape.
-     *
-     * Backward-compat: this is a thin wrapper with identical behavior.
-     */
-    getScopedConnectionActor(key: DriveGrantConnectionKey | {
-        scope: string;
-        peerNodeId: string;
-    }, options?: Parameters<RuntimeClient['getDriveGrantActor']>[1]): DriveGrantActorHandle;
-    /** Domain-agnostic alias for `shutdownDriveGrantActors`. */
+    private assertScopedDialAllowed;
+    private scopedDialCandidateIds;
+    private hasManualDisconnectSuppression;
+    /** Shuts down every scoped observer handle during managed-session teardown. */
     shutdownScopedConnectionActors(): Promise<void>;
-    /**
-     * Phase 4: tear down all live drive-grant actors. Called from
-     * managed-session teardown so a refresh between drive-grant guest
-     * routes does not leak observers across navigations.
-     */
-    shutdownDriveGrantActors(): Promise<void>;
     openPeerBi(id: string, options?: RuntimePeerStreamOptions): Promise<{
         connection: Connection;
         readable: ReadableStream<Uint8Array>;
         writable: WritableStream<Uint8Array>;
     }>;
+    openPeerNativeBi(id: string, label: string, options?: RuntimePeerStreamOptions): Promise<{
+        connection: Connection;
+        readable: ReadableStream<Uint8Array>;
+        writable: WritableStream<Uint8Array>;
+    }>;
     /** Like openPeerBi but skips the settled_ready requirement — usable for latency probes. */
     openPeerBiTransportOnly(id: string, options?: RuntimePeerStreamOptions): Promise<{
         connection: Connection;
@@ -929,8 +1103,15 @@ declare class RuntimeClient {
     forceDisconnectPeer(id: string): Promise<void>;
     getPeerHealth(id: string): Promise<RuntimePeerHealth>;
     getConnectionStates(): Promise<RuntimeConnectionStateSnapshot[]>;
+    /**
+     * Subscribe to raw backend connection diagnostics.
+     *
+     * This compatibility surface intentionally does not drive peer lifecycle or
+     * UI readiness; use watchPeerStates() for the reducer-owned lifecycle view.
+     */
     onConnectionStateChange(callback: (state: RuntimeConnectionStateSnapshot) => void): Promise<() => void> | (() => void);
     getConnections(): Connection[];
+    getApplicationReadyConnections(options?: RuntimeApplicationPayloadReadinessOptions): Connection[];
     onConnection(callback: (connection: Connection) => void): () => void;
     onDisconnection(callback: (connection: Connection) => void): () => void;
     onConnectionEvent(callback: (event: RuntimeConnectionEvent) => void): () => void;
@@ -939,6 +1120,17 @@ declare class RuntimeClient {
     connect(): Promise<void>;
     /** Disconnect from the runtime (alias for stop()) */
     disconnect(): void;
+    /**
+     * Terminal teardown of the runtime instance. Unlike stop()/disconnect()
+     * (which only stop the listen loop and are used during normal operation),
+     * destroy() tears down the underlying Client's coordinated dispose path —
+     * document/window listeners, the periodic auth-refresh interval, and signaling
+     * subscriptions (audit V2). Call this only when the runtime singleton is truly
+     * going away (app shutdown, HMR dispose), never on a routine disconnect.
+     */
+    destroy(): void;
+    /** Alias for destroy(); supports callers that expect a `dispose()` contract. */
+    dispose(): void;
     /** Alias for onIdentityChange */
     onAuthChange(callback: (identity: RuntimeAuthIdentity | null) => void): () => void;
     /** Alias for setAuthContext */
@@ -1038,4 +1230,65 @@ declare function createWasmClient(options: RuntimeFactoryOptions): PlutoRuntimeA
  */
 declare function createIpcClient(options: RuntimeFactoryOptions, bridge: PlutoIpcBridge): PlutoRuntimeAssembly<IpcRuntimeAdapter>;
 
-export { DriveGrantActorError as $, type RuntimeAuthIdentity as A, type RuntimeAutoConnectPolicy as B, Connection as C, type DeviceProfile as D, type RuntimeConnectionTarget as E, type RuntimeDeviceStatus as F, type RuntimeJoinRoomOptions as G, type RuntimeManagedSession as H, type IncomingStream as I, type RuntimeManagedSessionKind as J, type RuntimeManagedSessionOptions as K, type RuntimeManagedSessionPlatform as L, type RuntimePeerLifecycleStatus as M, type RuntimePeerScope as N, OPENRTC_RUNTIME_POLICY as O, type PlutoRuntimeAssembly as P, type RuntimePeerSessionSnapshot as Q, type RuntimeClientOptions as R, type RuntimePresenceLoopOptions as S, type RuntimePresencePolicy as T, type RuntimeRoomMember as U, type RuntimeSession as V, type RuntimeUiConnectionStatus as W, ScopedSession as X, type Session as Y, type SessionOptions as Z, getRuntimePolicy as _, RuntimeClient as a, type DriveGrantActorErrorKind as a0, DriveGrantActorHandle as a1, type DriveGrantActorHandleOptions as a2, DriveGrantActorRegistry as a3, type DriveGrantClose as a4, type DriveGrantConnectionKey as a5, type DriveGrantDial as a6, type DriveGrantLogicalChannelHandle as a7, type DriveGrantWebRtcState as a8, type RuntimeFactoryOptions as a9, type Session$1 as aa, type SessionOptions$1 as ab, createIpcClient as ac, createWasmClient as ad, driveGrantConnectionKey as ae, driveGrantConnectionKeyToString as af, type RuntimeDevice as b, type RuntimeDeviceStatusSnapshot as c, type RuntimeDeviceConnectOptions as d, type RuntimeLocalDeviceInfo as e, type RuntimeLocalDeviceProfile as f, type RuntimePeerState as g, type RuntimePeerConnectOptions as h, type RuntimePeerReadinessSnapshot as i, type RuntimePeerHealth as j, type RuntimeChannelDescriptor as k, type RuntimePeerStreamOptions as l, type RuntimeIncomingStream as m, type RuntimePolicySnapshot as n, type RuntimeConnectionStateSnapshot as o, type RuntimeConnectionEvent as p, type RuntimeRawConnection as q, type ChannelDescriptor as r, type ConnectionEvent as s, type ConnectionTarget as t, type PeerConnectOptions as u, type PeerReadiness as v, type PeerStreamOptions as w, type PresenceLoopOptions as x, type RawConnection as y, type RuntimeAuthContext as z };
+interface RuntimeDeviceActiveOptions {
+    now?: number;
+    /**
+     * Optional local freshness window for durable roster rows. Leave undefined
+     * when the caller only wants to honor explicit online/expiresAt state.
+     */
+    staleAfterMs?: number;
+}
+type RuntimeDeviceActivityStatus = Pick<Partial<RuntimeDevice>, 'online' | 'lastSeenAt' | 'updatedAt' | 'createdAt' | 'expiresAt'>;
+type RuntimeDeviceRouteStatus = Pick<Partial<RuntimeDeviceStatusSnapshot>, 'settledReady' | 'readinessState' | 'connectionStatus'>;
+type RuntimeDevicePresenceStatus = Pick<RuntimeDevice, 'online' | 'ticket'> & Pick<Partial<RuntimeDeviceStatusSnapshot>, 'connectable' | 'presenceStatus' | 'online' | 'ticket'>;
+/**
+ * True when a runtime device row is currently live enough to display or
+ * consider for app-level routing. This is deliberately separate from
+ * `isRuntimeDeviceConnectable`: a peer can be active/present before it has a
+ * usable ticket, and a stale durable row should not keep app UIs alive.
+ */
+declare function isRuntimeDeviceActive(device: RuntimeDeviceActivityStatus, options?: RuntimeDeviceActiveOptions): boolean;
+/**
+ * True once OpenRTC has a routable peer projection for normal app payloads.
+ *
+ * This intentionally does not inspect discovery metadata or device
+ * capabilities. Those fields describe the remote endpoint roster entry; they
+ * are not proof that an application-level protocol has exchanged its own
+ * ready/capability message over the mesh.
+ */
+declare function isRuntimeDeviceRoutable(device: RuntimeDeviceRouteStatus): boolean;
+/**
+ * True when the discovery row currently has enough fresh presence to attempt
+ * a dial. This is a discovery gate, not a connected/readiness gate.
+ */
+declare function isRuntimeDeviceConnectable(device: RuntimeDevicePresenceStatus): boolean;
+
+/**
+ * Pure byte / stream / timing helpers.
+ *
+ * Extracted from the `Client` god object (see
+ * `docs/plans/client-ts-decomposition.md` Phase 1). These functions are
+ * deliberately pure — no `Client` state, no `this`, no logging side effects — so
+ * the same helper is reused everywhere instead of being re-implemented inline
+ * (e.g. `concatBytes` previously existed both here and in `applicationCrypto.ts`,
+ * and three near-identical exponential-backoff helpers existed across the class).
+ */
+
+type ByteArray = Uint8Array<ArrayBuffer>;
+type ByteArrayLike = Uint8Array<ArrayBufferLike>;
+
+type RuntimeU32BEFrameHandler = (payload: ByteArray) => void;
+type RuntimeJsonFrameHandler<T = unknown> = (value: T, payload: ByteArray) => void;
+interface RuntimeJsonFrameDecoderOptions {
+    onInvalidJson?: (error: unknown, payload: ByteArray) => void;
+}
+declare function encodeRuntimeU32BEFrame(payload: ByteArrayLike): ByteArray;
+declare function createRuntimeU32BEFrameDecoder(onFrame: RuntimeU32BEFrameHandler): (chunk: ByteArrayLike) => void;
+declare function encodeRuntimeJsonPayload(value: unknown): ByteArray;
+declare function decodeRuntimeJsonPayload<T = unknown>(payload: ByteArrayLike): T;
+declare function encodeRuntimeJsonFrame(value: unknown): ByteArray;
+declare function createRuntimeJsonFrameDecoder<T = unknown>(onValue: RuntimeJsonFrameHandler<T>, options?: RuntimeJsonFrameDecoderOptions): (chunk: ByteArrayLike) => void;
+declare function concatRuntimeBytes(a: ByteArrayLike, b: ByteArrayLike): ByteArray;
+declare function readRuntimeU32BE(bytes: ByteArrayLike, offset: number): number;
+
+export { type RuntimePresenceLoopOptions as $, type ConnectionEvent as A, type ConnectionTarget as B, Connection as C, type DeviceProfile as D, type IncomingStream as E, type PeerConnectOptions as F, type PeerReadiness as G, type PeerStreamOptions as H, type ITransport as I, type PresenceLoopOptions as J, type RawConnection as K, type RuntimeAuthContext as L, type RuntimeAuthIdentity as M, type RuntimeAutoConnectPolicy as N, OPENRTC_RUNTIME_POLICY as O, type PeerReconciliationStats as P, type RuntimeConnectionTarget as Q, type RuntimeClientOptions as R, type RuntimeDevicePresenceStatus$1 as S, type RuntimeDeviceStatus as T, type RuntimeJsonFrameHandler as U, type RuntimeLogicalChannelFraming as V, type RuntimeManagedSessionKind as W, type RuntimeManagedSessionPlatform as X, type RuntimePeerLifecycleStatus as Y, type RuntimePeerScope as Z, type RuntimePeerSessionSnapshot as _, RuntimeClient as a, type RuntimePresencePolicy as a0, type RuntimeSession as a1, type RuntimeU32BEFrameHandler as a2, type RuntimeUiConnectionStatus as a3, type ScopedChannelOptions as a4, type ScopedLogicalChannel as a5, ScopedSession as a6, type Session as a7, type SessionOptions as a8, createRuntimeJsonFrameDecoder as a9, createIpcClient as aA, createWasmClient as aB, readRuntimeU32BE as aC, driveGrantConnectionKey as aD, driveGrantConnectionKeyToString as aE, createRuntimeU32BEFrameDecoder as aa, decodeRuntimeJsonPayload as ab, encodeRuntimeJsonFrame as ac, encodeRuntimeJsonPayload as ad, encodeRuntimeU32BEFrame as ae, getRuntimePolicy as af, isRuntimeDeviceActive as ag, isRuntimeDeviceConnectable as ah, isRuntimeDeviceRoutable as ai, type RuntimeDeviceActiveOptions as aj, type RuntimeFactoryOptions as ak, type RuntimeJsonFrameDecoderOptions as al, DriveGrantActorError as am, type DriveGrantActorErrorKind as an, DriveGrantActorHandle as ao, type DriveGrantActorHandleOptions as ap, DriveGrantActorRegistry as aq, type DriveGrantActorState as ar, type DriveGrantClose as as, type DriveGrantDial as at, type DriveGrantConnectionKey as au, type DriveGrantLogicalChannelHandle as av, type DriveGrantPreferredTransport as aw, type Session$1 as ax, type SessionOptions$1 as ay, concatRuntimeBytes as az, type RuntimeManagedSessionOptions as b, type RuntimeManagedSession as c, type RuntimeDevice as d, type RuntimeDeviceStatusSnapshot as e, type RuntimeDeviceConnectOptions as f, type RuntimeLocalDeviceInfo as g, type RuntimeLocalDeviceProfile as h, type RuntimePeerState as i, type RuntimePeerConnectOptions as j, type RuntimePeerReadinessSnapshot as k, type RuntimePeerHealth as l, type RuntimeChannelDescriptor as m, type RuntimePeerStreamOptions as n, type RuntimeIncomingStream as o, type RuntimeScopedChannelOptions as p, type RuntimeScopedLogicalChannel as q, type RuntimeJoinRoomOptions as r, type RuntimeRoomMember as s, type RuntimePolicySnapshot as t, type RuntimeConnectionStateSnapshot as u, type RuntimeApplicationPayloadReadinessOptions as v, type RuntimeConnectionEvent as w, type PlutoRuntimeAssembly as x, type RuntimeRawConnection as y, type ChannelDescriptor as z };