openrtc 0.1.0 → 0.1.2

package/dist/factories-0TxDPMeu.d.ts

@@ -0,0 +1,1041 @@
+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 { 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;
+    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 WEBRTC_DISCONNECTED_GRACE_MS;
+    private static readonly MAX_PENDING_MESSAGES;
+    /**
+     * 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 listeners;
+    private pendingMessages;
+    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 nativeSignalSender;
+    private webrtcTransport;
+    private upgradeState;
+    private upgradeRequested;
+    private upgradeAttemptActive;
+    private upgradeRetryCount;
+    private upgradeRetryTimer;
+    private upgradeAttemptTimeoutTimer;
+    private lastReportedTransportStatus;
+    private upgradeTerminalFailure;
+    private pendingSignals;
+    private activeNegotiationId;
+    private webrtcHeartbeat;
+    private webRtcHeartbeatProbeInFlight;
+    private webRtcHeartbeatConsecutiveProbeFailures;
+    private irohHealthListeners;
+    private webrtcHealthListeners;
+    private lastWebRtcHeartbeatOkAt;
+    private lastWebRtcDataChannelOpenAt;
+    private lastForegroundAt;
+    private webRtcDisconnectedGraceTimer;
+    private preferredWebRtcRole;
+    constructor(id: string, localNodeId: string, remoteNodeId: string, writer: WritableStreamDefaultWriter<Uint8Array>, reader: ReadableStreamDefaultReader<Uint8Array>, options?: ConnectionOptions);
+    /**
+     * 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;
+    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;
+    }>;
+    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): 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>;
+    /**
+     * 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.
+     */
+    getAvailableTransports(): ProtocolName[];
+    onWebRTCBinaryMessage(handler: (data: Uint8Array) => boolean): void;
+    getWebRTCTransport(): ITransport | null;
+    sendOnWebRTC(data: Uint8Array): Promise<void>;
+    private encodePayload;
+    private buildFrame;
+    private sendOverIroh;
+    private sendUsingTransport;
+    private sendTypedOnTransport;
+    private sendTyped;
+    /**
+     * 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 static isUntypedDataFrame;
+    private processDataPayload;
+    private isLikelyTextPayload;
+    private emitMedia;
+    private emitMessage;
+    receiveMessage(msg: any): void;
+    receiveDataPayload(messageData: Uint8Array): void;
+    private trackListeners;
+    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 handleDisconnectedTransportStateWithGrace;
+    private attemptUpgrade;
+    private setUpgradeState;
+    private handleUpgradeFailure;
+    private shouldRetryUpgrade;
+    private scheduleUpgradeRetry;
+    private clearUpgradeRetryTimer;
+    private startUpgradeAttemptTimeout;
+    private clearUpgradeAttemptTimeoutTimer;
+    private teardownWebRTCTransport;
+    private startWebRtcHeartbeat;
+    private stopWebRtcHeartbeat;
+    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;
+    private resolveParallelTransport;
+    setNativeSignalSender(sender: (envelope: any) => Promise<void>): void;
+    private sendInternalSignal;
+    receiveInternalSignal(content: any): void;
+    private handleInternalSignal;
+    private createNegotiationId;
+    private getDeterministicWebRtcRole;
+    private normalizeNegotiationId;
+}
+
+interface SessionOptions {
+    /**
+     * Logical purpose of this session. Used as a peer-scope tag on all
+     * outbound connections. Incoming events are filtered to peers carrying
+     * this scope (or all peers when `allowAllPeers` is true).
+     */
+    scope: string;
+    /**
+     * When true, watchPeerStates / onConnectionStateChange deliver events for
+     * ALL peers, not just those scoped to this session. Useful for the default
+     * 'user-device' session that legitimately needs the full peer picture.
+     * Default: false.
+     */
+    allowAllPeers?: boolean;
+    /**
+     * Additional peer IDs (node IDs, device IDs, connection IDs) that this
+     * session is permitted to observe, independent of their scope tags.
+     * Useful for magic-link sessions that know the host's node ID from the
+     * ticket before a connection exists.
+     */
+    allowPeers?: ReadonlyArray<string>;
+}
+/** Disposable scope-filtered view over a shared RuntimeClient. */
+interface Session {
+    readonly scope: string;
+    readonly disposed: boolean;
+    /**
+     * Subscribe to peer-state snapshots filtered to this session's scope.
+     * The callback fires once immediately with the current filtered snapshot,
+     * then again whenever relevant peer state changes.
+     */
+    watchPeerStates(callback: (peers: RuntimePeerState[]) => void): () => void;
+    /**
+     * Subscribe to connection-state events filtered to this session's scope.
+     * Returns the unsubscribe function (may be async for WASM bridge compat).
+     */
+    onConnectionStateChange(callback: (state: RuntimeConnectionStateSnapshot) => void): (() => void) | Promise<() => void>;
+    /** Async snapshot of peers matching this session's scope. */
+    listConnectedPeers(): RuntimePeerState[];
+    /** Peer readiness for a specific peer ID (scope-filtered). */
+    getPeerReadiness(peerId: string): Promise<RuntimePeerReadinessSnapshot>;
+    /**
+     * Connect to a peer via ticket or device ID, tagging the connection with
+     * this session's scope.
+     */
+    connectPeer(options: RuntimePeerConnectOptions): Promise<Connection>;
+    /** Disconnect a peer within this session's scope only. */
+    disconnectPeer(peerId: string): Promise<void>;
+    /**
+     * Subscribe to incoming streams from peers whose scope matches this
+     * session. Streams from other scopes are not delivered.
+     */
+    onIncomingStream(callback: (stream: RuntimeIncomingStream) => void): () => void;
+    /** Tear down all subscriptions and disconnect scope-tagged connections. */
+    dispose(): void;
+}
+declare class ScopedSession implements Session {
+    readonly scope: string;
+    private _disposed;
+    private readonly runtime;
+    private readonly allowAllPeers;
+    private readonly allowedPeerIds;
+    private readonly cleanups;
+    constructor(runtime: RuntimeClient, options: SessionOptions);
+    get disposed(): boolean;
+    /** Returns true when this session should receive events for this peer. */
+    private matchesPeer;
+    private matchesConnectionState;
+    private matchesStream;
+    watchPeerStates(callback: (peers: RuntimePeerState[]) => void): () => void;
+    onConnectionStateChange(callback: (state: RuntimeConnectionStateSnapshot) => void): (() => void) | Promise<() => void>;
+    listConnectedPeers(): RuntimePeerState[];
+    getPeerReadiness(peerId: string): Promise<RuntimePeerReadinessSnapshot>;
+    connectPeer(options: RuntimePeerConnectOptions): Promise<Connection>;
+    disconnectPeer(peerId: string): Promise<void>;
+    onIncomingStream(callback: (stream: RuntimeIncomingStream) => void): () => void;
+    dispose(): void;
+    private assertNotDisposed;
+}
+
+/**
+ * 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`.
+ *
+ * ## 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:
+ *
+ *   - `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'`.
+ *
+ * ## Coalescing semantics
+ *
+ * `ensureReady()` is the canonical "is the connection up?" call:
+ *
+ *   - If the underlying dial is in flight, all callers await the same
+ *     promise.
+ *   - If the underlying dial succeeded, callers resolve immediately.
+ *   - If the underlying dial failed, the handle stays "not ready" and the
+ *     next caller may try again.
+ *   - If `shutdown()` was called, every caller (current + future) rejects
+ *     with `ActorError.Shutdown`.
+ *
+ * The only state machine transitions are:
+ *
+ *   `idle` --(ensureReady)--> `dialing` --(success)--> `ready`
+ *                                  |   --(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.
+ */
+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';
+interface DriveGrantConnectionKey {
+    scope: string;
+    peerNodeId: string;
+}
+declare function driveGrantConnectionKey(scope: string, peerNodeId: string): DriveGrantConnectionKey;
+declare function driveGrantConnectionKeyToString(key: DriveGrantConnectionKey): string;
+/**
+ * The dial function the handle calls when no connection has yet
+ * resolved. Must be idempotent: returning when a healthy transport
+ * exists, throwing only on transient failure (caller retries) or
+ * permanent failure (caller surfaces).
+ */
+type DriveGrantDial = (key: DriveGrantConnectionKey) => Promise<void>;
+/**
+ * Optional teardown hook invoked on `shutdown()`. Default is a no-op.
+ */
+type DriveGrantClose = (key: DriveGrantConnectionKey) => Promise<void>;
+interface DriveGrantActorHandleOptions {
+    key: DriveGrantConnectionKey;
+    dial: DriveGrantDial;
+    close?: DriveGrantClose;
+}
+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;
+    /**
+     * Phase 7 correlation context. Always populated with
+     * `sessionKind=drive-grant-guest`, `scope`, `peerNodeId`, and
+     * (when the scope encodes one) `grantId`.
+     */
+    private correlation;
+    /**
+     * Coalesce-and-dial. N concurrent callers resolve via a single
+     * underlying dial. After the first success this is a fast no-op until
+     * `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
+     * drive-view frames arriving on a bi-stream with label `"drive-view"`,
+     * so logical channels are implicitly multiplexed by the underlying
+     * QUIC stream layer.
+     */
+    openLogicalChannel(label: string): Promise<DriveGrantLogicalChannelHandle>;
+    /**
+     * Test/Phase-4 helper: returns the label without invoking the
+     * unimplemented wire format, so observers can prove their request
+     * shape round-trips today.
+     */
+    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(): Promise<void>;
+}
+/**
+ * Registry that hands out one shared `DriveGrantActorHandle` per
+ * `DriveGrantConnectionKey`. `getOrSpawn` is idempotent.
+ */
+declare class DriveGrantActorRegistry {
+    private actors;
+    private readonly factory;
+    constructor(factory: (key: DriveGrantConnectionKey) => DriveGrantActorHandle);
+    getOrSpawn(key: DriveGrantConnectionKey, factoryOverride?: (key: DriveGrantConnectionKey) => DriveGrantActorHandle): DriveGrantActorHandle;
+    get(key: DriveGrantConnectionKey): DriveGrantActorHandle | null;
+    /** Tear down every actor; clears the registry. */
+    shutdownAll(): Promise<void>;
+    size(): number;
+}
+
+interface RuntimePolicySnapshot {
+    managedSession: {
+        nativeStartRetryWindowMs: number;
+        nativeStartRetryMinDelayMs: number;
+        nativeStartRetryMaxDelayMs: number;
+        reconciliationIntervalMs: number;
+        deviceStatusRefreshDebounceMs: number;
+    };
+    browserAutoConnect: {
+        scanDebounceMs: number;
+        retryCooldownMs: number;
+        settleGuardMs: number;
+        retryMaxMs: number;
+        nonInitiatorBaseGraceMs: number;
+        nonInitiatorMaxGraceMs: number;
+    };
+    nativeIpc: {
+        authRequiredWaitMs: number;
+        managedSessionIpcTimeoutMs: number;
+        managedSessionIpcMaxAttempts: number;
+        connectionEventSubscribeWindowMs: number;
+        connectionEventRetryMinDelayMs: number;
+        connectionEventRetryMaxDelayMs: number;
+        tauriIpcNegativeCacheMs: number;
+    };
+    browserIdentity: {
+        ephemeralDeviceIdTtlMs: number;
+    };
+}
+declare const OPENRTC_RUNTIME_POLICY: RuntimePolicySnapshot;
+declare function getRuntimePolicy(): RuntimePolicySnapshot;
+
+/**
+ * RuntimeClient is the primary application-facing API.
+ * It owns host/runtime orchestration on top of the Rust core and should be the
+ * only high-level surface consumed by product code. App code should not rebuild
+ * lifecycle, discovery, or transfer-readiness policy above this layer.
+ *
+ * Allowed:
+ * - app-facing session startup/shutdown
+ * - typed device, peer, room, and transfer APIs
+ * - thin host/runtime coordination
+ *
+ * Not allowed:
+ * - teaching app code to depend on `advanced.unwrap*()`
+ * - treating `nodeId` as high-level peer identity
+ * - reimplementing Rust-owned lifecycle policy in product code
+ *
+ * Source of truth:
+ * - Rust core owns transport lifecycle, connection health, and native signaling surfaces
+ * - Browser discovery/presence/signaling are host-owned by the scoped TypeScript Firebase adapters
+ * - RuntimeClient should converge toward thin wrappers over those runtime/backing surfaces
+ */
+declare class RuntimeClient {
+    private static readonly NATIVE_START_RETRY_WINDOW_MS;
+    private static readonly NATIVE_START_RETRY_MIN_DELAY_MS;
+    private static readonly NATIVE_START_RETRY_MAX_DELAY_MS;
+    private static readonly MANAGED_RECONCILIATION_INTERVAL_MS;
+    private static readonly DEVICE_STATUS_REFRESH_DEBOUNCE_MS;
+    private static readonly MANAGED_USER_DEVICE_SCOPE;
+    static readonly MANAGED_FRIEND_SCOPE: GrantScope;
+    private readonly client;
+    private readonly backend;
+    private readonly deviceManager;
+    private readonly peerManager;
+    private readonly connectionController;
+    private managedSessionKey;
+    private managedSessionUserId;
+    private managedSessionOptions;
+    private managedSessionTransition;
+    private managedSessionStartInFlight;
+    private readonly managedReconciliationTasks;
+    /**
+     * Phase 4: per-`{scope, peerNodeId}` scoped-connection actor registry.
+     * Lazily created; `null` until an observer first calls `getDriveGrantActor`
+     * (legacy name) or `getScopedConnectionActor` (generic alias).
+     *
+     * Note: persistent same-account auto-connect (`app-user-device`) and
+     * anonymous share flows (`share-anonymous`) do not use this coalescer.
+     */
+    private driveGrantActorRegistry;
+    private static describeTicketForLogs;
+    private serializeManagedSessionOperation;
+    constructor(options: RuntimeClientOptions, backend?: ISignalingBackend | null);
+    get identity(): RuntimeAuthIdentity | null;
+    private resolveManagedSessionUserId;
+    private resolveManagedAutoConnectEnabled;
+    private resolveManagedPresenceEnabled;
+    private getEffectiveRuntimeUserId;
+    private sleep;
+    private fetchAndApplyAppLimits;
+    private resolvePeerStreamTarget;
+    private compatPeerConnectionFromTarget;
+    private nextNativeStartRetryDelayMs;
+    private hasManagedSession;
+    private usesNativeIpcBackend;
+    private startManagedReconciliation;
+    private notifyManagedReconciliation;
+    reconcileNativeManagedSession(reason?: string): Promise<void>;
+    private connectionStateSnapshotKey;
+    private runNativeStartLoop;
+    private isUnsupportedRuntimeAdapterError;
+    onIdentityChange(callback: (identity: RuntimeAuthIdentity | null) => void): () => void;
+    signInAnonymously(): Promise<void>;
+    signInWithPluto(): Promise<void>;
+    setAuthContext(context: AuthContext | null): Promise<void>;
+    signOut(): Promise<void>;
+    initialize(): Promise<void>;
+    getRuntimeStatus(): Promise<{
+        runtime: 'tauri' | 'browser' | 'unknown';
+        wasmLoaded: boolean;
+        localNodeId?: string;
+        userId?: string;
+    }>;
+    getRuntimePolicy(): RuntimePolicySnapshot;
+    getRuntimeCapabilities(): RuntimeCapabilities;
+    start(options?: {
+        clearSessionTokens?: boolean;
+    }): Promise<void>;
+    stop(): void;
+    getNodeId(): Promise<string>;
+    getNodeIdFromTicket(ticket: string): Promise<string | null>;
+    getLocalDeviceId(): Promise<string | null>;
+    getLocalDeviceInfo(): Promise<RuntimeLocalDeviceInfo | null>;
+    getLocalDeviceProfile(options?: {
+        deviceName?: string;
+        localDeviceId?: string | null;
+        platform?: 'native' | 'web';
+        userId?: string | null;
+    }): Promise<RuntimeLocalDeviceProfile>;
+    updateLocalDeviceName(deviceName: string): Promise<RuntimeLocalDeviceInfo | null>;
+    getManagedNodeId(options?: {
+        initializeIfMissing?: boolean;
+    }): Promise<string | null>;
+    getTicket(): Promise<string>;
+    /**
+     * Generate a session-scoped endpoint ticket with an embedded random token.
+     * The token gates incoming connections: only clients that present the token
+     * in their handshake are accepted while the registry is non-empty.
+     *
+     * @param grantScope     Admission-grant label for bulk revoke (e.g. "share").
+     *                       This is distinct from `PeerScope`, which only labels peer lifecycle.
+     * @param maxConnections 0 = unlimited.
+     */
+    getTicketWithToken(grantScope: GrantScope, maxConnections?: number): Promise<string>;
+    /** Revoke all session tokens that match the given scope. */
+    revokeTokensByScope(grantScope: GrantScope): Promise<string[]>;
+    private revokeTokensByScopeInternal;
+    /** Revoke a single session token by its raw value. */
+    revokeSessionToken(token: string): void;
+    /**
+     * Watch devices belonging to friend users via the browser Firestore
+     * signaling backend. Sets up one listener per friend UID.
+     *
+     * Only works when the signaling backend supports `watchFriendDevices`.
+     * For native backends, friend device discovery should be handled
+     * at the application layer (e.g., FriendDeviceContext).
+     *
+     * @param friendUserIds - Array of friend user IDs to watch
+     * @param callback - Called with the merged map of friend devices
+     * @returns Cleanup function
+     */
+    watchFriendDevices(friendUserIds: string[], callback: (friendDevices: Map<string, RuntimeDevice[]>) => void): () => void;
+    /**
+     * Get a compound ticket with a friend-scoped grant token.
+     * Friends connecting with this ticket are admitted with `friend` scope.
+     */
+    getFriendTicket(maxConnections?: number): Promise<string>;
+    /**
+     * Revoke all friend-scoped tokens and disconnect affected connections.
+     */
+    revokeFriendTokens(): Promise<string[]>;
+    /**
+     * Update the friend ticket on the current device's presence doc.
+     * Call this after minting a friend ticket so that friends watching
+     * the device doc can see and use the friend-scoped ticket.
+     */
+    updateFriendTicket(friendTicket: string | null): Promise<void>;
+    getEndpointTicket(): Promise<string>;
+    startManagedSession(options: RuntimeManagedSessionOptions): Promise<RuntimeManagedSession>;
+    stopManagedSession(options?: {
+        preserveBackendSession?: boolean;
+    }): Promise<void>;
+    private stopManagedSessionInternal;
+    private rotateManagedUserDeviceGrant;
+    listDevices(): Promise<RuntimeDevice[]>;
+    listDevicesWithStatus(): Promise<RuntimeDeviceStatusSnapshot[]>;
+    updateDevice(deviceId: string, updates: {
+        deviceName?: string;
+        capabilities?: RuntimeDevice['capabilities'];
+        metadata?: string;
+    }): Promise<void>;
+    deleteDevice(deviceId: string): Promise<void>;
+    watchDevices(callback: (devices: RuntimeDevice[]) => void): () => void;
+    watchDevicesWithStatus(callback: (devices: RuntimeDeviceStatusSnapshot[]) => void): () => void;
+    connectDeviceWithRetry(device: RuntimeDevice, hooks: ConnectDeviceHooks, options: ConnectDeviceOptions): Promise<ConnectDeviceResult>;
+    /**
+     * Runtime-owned device connect flow used by product code.
+     * Rust owns the actual managed dial policy. This wrapper only:
+     * - validates the app-facing device/ticket input
+     * - forwards the request to the active runtime adapter
+     * - refreshes peer state and invokes optional app callbacks
+     */
+    connectDevice(device: RuntimeDevice, options: RuntimeDeviceConnectOptions): Promise<ConnectDeviceResult>;
+    watchPeerStates(callback: (peers: RuntimePeerState[]) => void): () => void;
+    getPeerState(id: string): RuntimePeerState | undefined;
+    resolvePeerConnectionRecords(id: string): Promise<ManagedConnectionRecord[]>;
+    getPeerSession(id: string): Promise<PeerSessionSnapshot | null>;
+    listPeerSessions(): Promise<PeerSessionSnapshot[]>;
+    waitForConnectedPeer(id: string, timeoutMs?: number): Promise<PeerSessionSnapshot | null>;
+    getPeerReadiness(id: string, timeoutMs?: number): Promise<RuntimePeerReadinessSnapshot>;
+    resolvePeerIdentity(id: string): Promise<ResolvedPeerIdentity>;
+    resolveIncomingStreamPeer(remoteNodeId: string): Promise<ResolvedPeerIdentity>;
+    listConnectedPeers(): RuntimePeerState[];
+    addPeerScope(id: string, scope?: string): RuntimePeerState | undefined;
+    releasePeerScope(id: string, scope?: string): RuntimePeerState | undefined;
+    getPeerScopes(id: string): string[];
+    isSamePeer(a: string, b: string): boolean;
+    refreshPeerSnapshot(): Promise<RuntimePeerState[]>;
+    subscribeSessions(localDeviceId: string, callback: (session: RuntimeSession) => void): Promise<() => void>;
+    getAppLimits(): AppLimits;
+    createRoom(roomId?: string): Promise<string>;
+    joinRoom(roomId: string, options?: RuntimeJoinRoomOptions): Promise<Connection[]>;
+    leaveRoom(roomId: string): Promise<void>;
+    getRoomMembers(roomId: string): Promise<RuntimeRoomMember[]>;
+    watchRoom(roomId: string, callback: (members: RuntimeRoomMember[]) => void): () => void;
+    /** @deprecated Use connect() (no-arg) for lifecycle, or connectTo() for peer connections */
+    connectByTicket(target: RuntimeConnectionTarget): Promise<Connection>;
+    connectPeer(options: RuntimePeerConnectOptions): Promise<Connection>;
+    /**
+     * 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
+     * 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`.
+     *
+     * 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).
+     */
+    getDriveGrantActor(key: DriveGrantConnectionKey | {
+        scope: string;
+        peerNodeId: string;
+    }, options?: {
+        /**
+         * Compound ticket to dial when the actor's `dial` runs. Used by
+         * the default dial that calls `connectPeer` for callers that
+         * don't supply a custom `dial`.
+         */
+        ticket?: string;
+        timeoutMs?: number;
+        channelId?: string;
+        /**
+         * Phase 4 escape hatch: callers that need to capture the
+         * resolved `Connection` (e.g. `DriveViewClient` wires its
+         * 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
+         * 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`. */
+    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>;
+    }>;
+    /** Like openPeerBi but skips the settled_ready requirement — usable for latency probes. */
+    openPeerBiTransportOnly(id: string, options?: RuntimePeerStreamOptions): Promise<{
+        connection: Connection;
+        readable: ReadableStream<Uint8Array>;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    openPeerUni(id: string, options?: RuntimePeerStreamOptions): Promise<{
+        connection: Connection;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    connectToDevice(params: {
+        deviceId?: string | null;
+        endpointTicket: string;
+    }): Promise<NativeConnectResult>;
+    connectRaw(target: RuntimeConnectionTarget): Promise<RuntimeRawConnection>;
+    openBi(nodeId: string): Promise<{
+        readable: ReadableStream<Uint8Array>;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    openUni(nodeId: string): Promise<WritableStream<Uint8Array>>;
+    onIncomingStream(callback: (stream: RuntimeIncomingStream) => boolean | void): () => void;
+    registerChannel(descriptor: RuntimeChannelDescriptor): void;
+    unregisterChannel(channelId: string): void;
+    listChannels(): RuntimeChannelDescriptor[];
+    onIncomingChannelStream(channelId: string, callback: (stream: RuntimeIncomingStream) => boolean | 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>;
+    startPresenceLoop(options?: RuntimePresenceLoopOptions): Promise<void>;
+    updatePresence(options?: {
+        isOnline?: boolean;
+        ttlMs?: number;
+        metadata?: string;
+        ticket?: string;
+    }): Promise<void>;
+    setOffline(): Promise<void>;
+    cleanupStaleDevices(): Promise<void>;
+    startAutoConnect(localDeviceId?: string): Promise<void>;
+    isConnected(nodeId: string): Promise<boolean>;
+    disconnectNode(nodeId: string): Promise<void>;
+    disconnectDevice(deviceId: string): Promise<void>;
+    setAutoConnectExcluded(deviceId: string, excluded: boolean): Promise<void>;
+    disconnectPeer(id: string, scope?: string): Promise<void>;
+    forceDisconnectPeer(id: string): Promise<void>;
+    getPeerHealth(id: string): Promise<RuntimePeerHealth>;
+    getConnectionStates(): Promise<RuntimeConnectionStateSnapshot[]>;
+    onConnectionStateChange(callback: (state: RuntimeConnectionStateSnapshot) => void): Promise<() => void> | (() => void);
+    getConnections(): Connection[];
+    onConnection(callback: (connection: Connection) => void): () => void;
+    onDisconnection(callback: (connection: Connection) => void): () => void;
+    onConnectionEvent(callback: (event: RuntimeConnectionEvent) => void): () => void;
+    forceReconnectSnapshot(): void;
+    /** Single-call lifecycle: combines initialize() + start() */
+    connect(): Promise<void>;
+    /** Disconnect from the runtime (alias for stop()) */
+    disconnect(): void;
+    /** Alias for onIdentityChange */
+    onAuthChange(callback: (identity: RuntimeAuthIdentity | null) => void): () => void;
+    /** Alias for setAuthContext */
+    setAuth(context: AuthContext | null): Promise<void>;
+    /** Alias for signInWithPluto */
+    signIn(): Promise<void>;
+    /** Alias for listDevices */
+    getDevices(): Promise<RuntimeDevice[]>;
+    /** Device subscription with optional status enrichment */
+    onDevices(callback: (devices: RuntimeDevice[]) => void): () => void;
+    onDevices(callback: (devices: RuntimeDeviceStatusSnapshot[]) => void, options: {
+        status: true;
+    }): () => void;
+    /** Alias for getTicket — returns an invite/ticket string */
+    getInvite(): Promise<string>;
+    /** Connect to a peer by device ID or options */
+    connectTo(options: RuntimePeerConnectOptions): Promise<Connection>;
+    /** Alias for waitForConnectedPeer */
+    waitFor(id: string, timeoutMs?: number): Promise<PeerSessionSnapshot | null>;
+    /** Open a stream to a peer (default: bidirectional) */
+    openStream(id: string, options?: RuntimePeerStreamOptions & {
+        direction?: 'bi' | 'send';
+    }): Promise<{
+        connection: Connection;
+        readable?: ReadableStream<Uint8Array>;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    openChannelStream(channelId: string, id: string, options?: RuntimePeerStreamOptions & {
+        direction?: 'bi' | 'send';
+    }): Promise<{
+        connection: Connection;
+        readable?: ReadableStream<Uint8Array>;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    /** Alias for onIncomingStream */
+    onStream(callback: (stream: RuntimeIncomingStream) => boolean | void): () => void;
+    onChannelStream(channelId: string, callback: (stream: RuntimeIncomingStream) => boolean | void): () => void;
+    /** Alias for watchRoom */
+    onRoomChange(roomId: string, callback: (members: RuntimeRoomMember[]) => void): () => void;
+    /**
+     * Create a scope-filtered session backed by this runtime.
+     *
+     * The session filters all peer-state and connection-state emissions to
+     * peers whose scope tags include `options.scope`, and tags outbound
+     * connections with the same scope for the remote side's ACL layer.
+     *
+     * Disposing the session removes only its own subscriptions and
+     * scope-tagged connections — other sessions on this runtime are unaffected.
+     *
+     * @example
+     * // Guest magic-link viewer — sees only the ticket endpoint, never device peers
+     * const session = runtime.createSession({ scope: 'magic-link', allowPeers: [ticketNodeId] });
+     * session.watchPeerStates(peers => { ... });
+     * // On unmount:
+     * session.dispose();
+     */
+    createSession(options: SessionOptions): Session;
+}
+
+type RuntimeAdapterWithAuth = ISignalingBackend & {
+    setAuthContext?: (context: AuthContext | null) => Promise<void> | void;
+};
+type RuntimeFactoryOptions = RuntimeClientOptions;
+interface PlutoRuntimeAssembly<TBackend extends RuntimeAdapterWithAuth = RuntimeAdapterWithAuth> {
+    runtime: RuntimeClient;
+    identity: any;
+    setAuthContext(context: AuthContext | null): Promise<void>;
+    syncPlutoAuth(options?: {
+        userId?: string | null;
+        forceRefresh?: boolean;
+    }): Promise<void>;
+    bindPlutoAuthHost(): () => void;
+    signInWithPluto(): Promise<void>;
+    signOut(): Promise<void>;
+    stopManagedSession(): Promise<void>;
+    startManagedSession(options: any): Promise<any>;
+    onAuthChange(callback: (identity: any) => void): () => void;
+    getManagedNodeId(options?: {
+        initializeIfMissing?: boolean;
+    }): Promise<string | null>;
+    getRuntimeStatus(): Promise<any>;
+    listDevicesWithStatus(): Promise<any>;
+    watchDevicesWithStatus(callback: (devices: any[]) => void): () => void;
+    connectDevice(device: any, options: any): Promise<any>;
+    setAutoConnectExcluded(deviceId: string, excluded: boolean): Promise<void>;
+}
+/**
+ * @deprecated Legacy assembly helper. Use `OpenRTC()` for app code.
+ * Removal target: OpenRTC 0.2.0. This remains available from `openrtc/runtime`
+ * only for advanced integrations that still need `PlutoRuntimeAssembly`.
+ */
+declare function createWasmClient(options: RuntimeFactoryOptions): PlutoRuntimeAssembly<WasmRuntimeAdapter>;
+/**
+ * @deprecated Legacy assembly helper. Use `OpenRTC.native()` for app code.
+ * Removal target: OpenRTC 0.2.0. This remains available from `openrtc/runtime`
+ * only for advanced integrations that still need `PlutoRuntimeAssembly`.
+ */
+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 };