openrtc 0.2.0 → 1.0.0

package/dist/{factories-CwZiIRg1.d.ts → framing-BUtu0oZK.d.ts}

@@ -1,337 +1,10 @@
-import { A as AuthContext, R as RuntimeCapabilities, a as RuntimeCapabilityProfile } from './DelegatingRuntimeAdapter-CjHzBEBA.js';
-import { J as ConnectionOptions, q as ApplicationPayloadCrypto, v as ApplicationPayloadReadinessOptions, w as ApplicationPayloadRouteOptions, n as ProtocolName, x as ApplicationPayloadSendOptions, K as ChannelDescriptor$1, L as LocalDeviceInfo, O as IncomingStreamChannelMetadata, C as ClientOptions, a as Device, f as SignalingSession, R as RuntimeIdentity, b as DeviceStatusSnapshot, Q as ManagedDeviceConnectOptions, T as PeerState, U as PeerHealth, V as JoinRoomOptions, W as RoomMember, X as PeerScope, j as BackendConnectionState, Y 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-DyCGvj9l.js';
-import { P as PlutoIpcBridge, I as IpcRuntimeAdapter } from './IpcRuntimeAdapter-CtckyMol.js';
+import { A as AuthContext } from './IEngineBridge-C7OT2CRv.js';
+import { G as GrantScope, I as ISignalingBackend, m as ConnectDeviceHooks, n as ConnectDeviceOptions, l as ConnectDeviceResult, M as ManagedConnectionRecord, P as PeerSessionSnapshot, c as ResolvedPeerIdentity, u as AppLimits, i as NativeConnectParams, j as NativeConnectResult, E as ExplicitFileDataSendParams } from './types-CzIpGV9x.js';
+import { h as RuntimePeerState, s as RuntimeConnectionStateSnapshot, j as RuntimePeerReadinessSnapshot, i as RuntimePeerConnectOptions, C as Connection, n as RuntimeIncomingStream, R as RuntimeClientOptions, H as RuntimeAuthIdentity, f as RuntimeLocalDeviceInfo, g as RuntimeLocalDeviceProfile, c as RuntimeDevice, a as RuntimeManagedSessionOptions, b as RuntimeManagedSession, d as RuntimeDeviceStatusSnapshot, e as RuntimeDeviceConnectOptions, X as RuntimeSession, q as RuntimeJoinRoomOptions, r as RuntimeRoomMember, K as RuntimeConnectionTarget, o as RuntimeScopedChannelOptions, p as RuntimeScopedLogicalChannel, m as RuntimePeerStreamOptions, v as RuntimeRawConnection, l as RuntimeChannelDescriptor, V as RuntimePresenceLoopOptions, k as RuntimePeerHealth, t as RuntimeApplicationPayloadReadinessOptions, u as RuntimeConnectionEvent } from './device-status-nkXepu97.js';
+import { R as RuntimeCapabilities, a as RuntimeCapabilityProfile } from './DelegatingRuntimeAdapter-By7pziBs.js';
+import { P as PlutoIpcBridge, I as IpcRuntimeAdapter } from './IpcRuntimeAdapter-DymXAsNU.js';
 import { WasmRuntimeAdapter } from './runtime/WasmRuntimeAdapter.js';
 
-interface ITransport {
-    readonly name: string;
-    readonly isReady: boolean;
-    init(localNodeId: string, remoteNodeId: string, options: any): Promise<void>;
-    send(data: Uint8Array): Promise<void>;
-    close(): void;
-    onMessage(callback: (data: Uint8Array) => void): void;
-    onStateChange(callback: (state: 'connecting' | 'connected' | 'failed' | 'disconnected') => void): void;
-    handleSignalingMessage?(msg: any): void;
-    getSignalingHandler?(): (msg: any) => Promise<void>;
-    getNativeTransport?(): any;
-    getNegotiationId?(): string | null;
-    getDataChannelReadyState?(): string | null;
-}
-
-type ConnectionHealth = 'unknown' | 'healthy' | 'suspect' | 'stale';
-
-type UpgradeState = 'none' | 'upgrading' | 'upgraded' | 'failed';
-declare class Connection {
-    private static readonly textDecoder;
-    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;
-    private writer;
-    private reader;
-    private _isClosed;
-    get isClosed(): boolean;
-    private receiveBuffer;
-    readonly id: string;
-    readonly remoteNodeId: string;
-    /** @deprecated Compatibility alias for legacy consumers. This is the remote node id, not a device id. */
-    readonly deviceId: string;
-    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;
-    }): void;
-    private static readonly FOREGROUND_PROBE_TIMEOUT_MS;
-    handleAppForeground(): void;
-    private beginWebRtcRecovery;
-    getUpgradeState(): UpgradeState;
-    updateRTCConfig(rtcConfig: ConnectionOptions['rtcConfig']): void;
-    onUpgradeStateChange(callback: (state: UpgradeState) => void): void;
-    /**
-     * Best-effort transport diagnostics for developer tooling.
-     *
-     * - `usesRelay=true` means the selected WebRTC candidate pair includes a relay candidate.
-     * - `usesRelay=false` means we found a selected pair and it is direct.
-     * - `usesRelay=null` means there is not enough data yet.
-     */
-    getTransportDiagnostics(): Promise<{
-        activeTransport: ProtocolName;
-        parallelTransport: ProtocolName | null;
-        usesRelay: boolean | null;
-        relaySource: string | null;
-        webrtc: {
-            iceConnectionState: string | null;
-            iceGatheringState: string | null;
-            localCandidateType: string | null;
-            remoteCandidateType: string | null;
-            localProtocol: string | null;
-            remoteProtocol: string | null;
-            candidateTypeSummary: string | null;
-        } | null;
-    }>;
-    private lastWebRtcLocalCandidateType;
-    private lastWebRtcRemoteCandidateType;
-    get transportType(): ProtocolName;
-    private _peerMoQReady;
-    get peerMoQReady(): boolean;
-    set peerMoQReady(value: boolean);
-    private _remoteSupportsWebRTC;
-    get remoteSupportsWebRTC(): boolean;
-    set remoteSupportsWebRTC(value: boolean);
-    private mediaListeners;
-    /**
-     * Send a message to the other peer.
-     * Messages can be strings or objects (JSON stringified).
-     */
-    send(message: string | object | ArrayBuffer | Uint8Array, options?: ApplicationPayloadSendOptions): Promise<void>;
-    /**
-     * Send media data (video/audio header + payload)
-     * Internal use for now.
-     */
-    sendMedia(type: 'audio' | 'video', data: Uint8Array): Promise<void>;
-    /**
-     * Send a data message on a specific transport without fallback.
-     * 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>;
-    /**
-     * 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
-     */
-    disconnect(): Promise<void>;
-    /**
-     * Listen for incoming messages
-     */
-    onMessage(callback: (message: any) => void): void;
-    /**
-     * Listen for incoming media
-     */
-    onMedia(callback: (type: 'audio' | 'video', data: Uint8Array) => void): void;
-    /**
-     * Listen for disconnection
-     */
-    onDisconnect(callback: () => void): void;
-    private close;
-    private preserveWebRtcConnectionAfterBaseTransportLoss;
-    private readLoop;
-    injectData(chunk: Uint8Array): void;
-    private handleData;
-    private tryHandlePlaintextNativeSignal;
-    private static isUntypedDataFrame;
-    private processDataPayload;
-    private isLikelyTextPayload;
-    private emitMedia;
-    private emitMessage;
-    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;
-    private hasRecoverableBasePath;
-    private isWebRtcDataChannelOpen;
-    private clearWebRtcDisconnectedGraceTimer;
-    private transportStillLikelyAlive;
-    private handleUnhealthyWebRtcTransportStateWithGrace;
-    private attemptUpgrade;
-    private setUpgradeState;
-    private handleUpgradeFailure;
-    private scheduleUpgradeReDrive;
-    private clearUpgradeReDriveTimer;
-    private shouldRetryUpgrade;
-    private scheduleUpgradeRetry;
-    private clearUpgradeRetryTimer;
-    private startUpgradeAttemptTimeout;
-    private clearUpgradeAttemptTimeoutTimer;
-    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 sendInternalSignal;
-    receiveInternalSignal(content: any): void;
-    private handleInternalSignal;
-    private createNegotiationId;
-    private getDeterministicWebRtcRole;
-    private normalizeNegotiationId;
-}
-
 /**
  * Coalesced peer reconciliation scheduler and full reconcile orchestration.
  *
@@ -348,186 +21,6 @@ type PeerReconciliationStats = {
     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 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
@@ -776,8 +269,7 @@ interface RuntimePolicySnapshot {
     };
     nativeIpc: {
         authRequiredWaitMs: number;
-        managedSessionIpcTimeoutMs: number;
-        managedSessionIpcMaxAttempts: number;
+        defaultBoundedCommandTimeoutMs: number;
         connectionEventSubscribeWindowMs: number;
         connectionEventRetryMinDelayMs: number;
         connectionEventRetryMaxDelayMs: number;
@@ -852,6 +344,7 @@ declare class RuntimeClient {
     private fetchAndApplyAppLimits;
     private resolvePeerStreamTarget;
     private compatPeerConnectionFromTarget;
+    private isTransportOnlyStreamChannel;
     private nextNativeStartRetryDelayMs;
     private hasManagedSession;
     private usesNativeIpcBackend;
@@ -860,10 +353,10 @@ declare class RuntimeClient {
     private stopManagedReconciliation;
     private notifyManagedReconciliation;
     reconcileNativeManagedSession(reason?: string): Promise<void>;
+    notifyNetworkChange(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>;
@@ -1060,10 +553,8 @@ declare class RuntimeClient {
         connection: Connection;
         writable: WritableStream<Uint8Array>;
     }>;
-    connectToDevice(params: {
-        deviceId?: string | null;
-        endpointTicket: string;
-    }): Promise<NativeConnectResult>;
+    private waitForBrowserApplicationCrypto;
+    connectToDevice(params: NativeConnectParams): Promise<NativeConnectResult>;
     connectRaw(target: RuntimeConnectionTarget): Promise<RuntimeRawConnection>;
     openBi(nodeId: string): Promise<{
         readable: ReadableStream<Uint8Array>;
@@ -1075,9 +566,13 @@ declare class RuntimeClient {
     unregisterChannel(channelId: string): void;
     listChannels(): RuntimeChannelDescriptor[];
     onIncomingChannelStream(channelId: string, callback: (stream: RuntimeIncomingStream) => boolean | void): () => void;
+    /** @deprecated Use named channels or the optional `openrtc-file-transfer` package. */
     sendExplicitFilePath(connectionId: string, filePath: string, transferId?: string): Promise<string>;
+    /** @deprecated Use named channels or the optional `openrtc-file-transfer` package. */
     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>;
     startPresenceLoop(options?: RuntimePresenceLoopOptions): Promise<void>;
     updatePresence(options?: {
@@ -1086,6 +581,10 @@ declare class RuntimeClient {
         metadata?: string;
         ticket?: string;
     }): Promise<void>;
+    refreshLivePresence(options?: {
+        metadata?: string;
+        ticket?: string;
+    }): Promise<void>;
     setOffline(): Promise<void>;
     cleanupStaleDevices(): Promise<void>;
     startAutoConnect(localDeviceId?: string): Promise<void>;
@@ -1224,4 +723,32 @@ declare function createWasmClient(options: RuntimeFactoryOptions): PlutoRuntimeA
  */
 declare function createIpcClient(options: RuntimeFactoryOptions, bridge: PlutoIpcBridge): PlutoRuntimeAssembly<IpcRuntimeAdapter>;
 
-export { type RuntimeSession as $, type PeerReadiness as A, type PeerStreamOptions as B, Connection as C, type DeviceProfile as D, type PresenceLoopOptions as E, type RawConnection as F, type RuntimeAuthContext as G, type RuntimeAuthIdentity as H, type ITransport as I, type RuntimeAutoConnectPolicy as J, type RuntimeConnectionTarget as K, type RuntimeDeviceStatus as L, type RuntimeJoinRoomOptions as M, type RuntimeLogicalChannelFraming as N, OPENRTC_RUNTIME_POLICY as O, type PeerReconciliationStats as P, type RuntimeManagedSession as Q, type RuntimeClientOptions as R, type RuntimeManagedSessionKind as S, type RuntimeManagedSessionOptions as T, type RuntimeManagedSessionPlatform as U, type RuntimePeerLifecycleStatus as V, type RuntimePeerScope as W, type RuntimePeerSessionSnapshot as X, type RuntimePresenceLoopOptions as Y, type RuntimePresencePolicy as Z, type RuntimeRoomMember as _, RuntimeClient as a, type RuntimeUiConnectionStatus as a0, type ScopedChannelOptions as a1, type ScopedLogicalChannel as a2, ScopedSession as a3, type Session as a4, type SessionOptions as a5, getRuntimePolicy as a6, type RuntimeFactoryOptions as a7, DriveGrantActorError as a8, type DriveGrantActorErrorKind as a9, DriveGrantActorHandle as aa, type DriveGrantActorHandleOptions as ab, DriveGrantActorRegistry as ac, type DriveGrantActorState as ad, type DriveGrantClose as ae, type DriveGrantDial as af, type DriveGrantConnectionKey as ag, type DriveGrantLogicalChannelHandle as ah, type DriveGrantPreferredTransport as ai, type Session$1 as aj, type SessionOptions$1 as ak, createIpcClient as al, createWasmClient as am, driveGrantConnectionKey as an, driveGrantConnectionKeyToString as ao, 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 RuntimeScopedChannelOptions as n, type RuntimeScopedLogicalChannel as o, type RuntimePolicySnapshot as p, type RuntimeConnectionStateSnapshot as q, type RuntimeApplicationPayloadReadinessOptions as r, type RuntimeConnectionEvent as s, type PlutoRuntimeAssembly as t, type RuntimeRawConnection as u, type ChannelDescriptor as v, type ConnectionEvent as w, type ConnectionTarget as x, type IncomingStream as y, type PeerConnectOptions as z };
+/**
+ * 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 { createIpcClient as A, createWasmClient as B, readRuntimeU32BE as C, DriveGrantActorError as D, driveGrantConnectionKey as E, driveGrantConnectionKeyToString as F, OPENRTC_RUNTIME_POLICY as O, type PeerReconciliationStats as P, RuntimeClient as R, ScopedSession as S, type RuntimePolicySnapshot as a, type PlutoRuntimeAssembly as b, type RuntimeJsonFrameHandler as c, type RuntimeU32BEFrameHandler as d, type Session as e, type SessionOptions as f, createRuntimeJsonFrameDecoder as g, createRuntimeU32BEFrameDecoder as h, decodeRuntimeJsonPayload as i, encodeRuntimeJsonFrame as j, encodeRuntimeJsonPayload as k, encodeRuntimeU32BEFrame as l, getRuntimePolicy as m, type RuntimeFactoryOptions as n, type RuntimeJsonFrameDecoderOptions as o, type DriveGrantActorErrorKind as p, DriveGrantActorHandle as q, type DriveGrantActorHandleOptions as r, DriveGrantActorRegistry as s, type DriveGrantActorState as t, type DriveGrantClose as u, type DriveGrantDial as v, type DriveGrantConnectionKey as w, type DriveGrantLogicalChannelHandle as x, type DriveGrantPreferredTransport as y, concatRuntimeBytes as z };