openrtc 2.3.0 → 2.4.0

package/dist/{ITransport-CjxCQ6q7.d.ts → Connection-DZ5eP5hL.d.ts}

@@ -1,3 +1,299 @@
+type AuthContext = {
+    userId: string;
+    token?: string | null;
+    refreshToken?: string | null;
+    customToken?: string | null;
+    tokenProvider?: (forceRefresh?: boolean) => Promise<string | null>;
+    /**
+     * Supplies the platform attestation token required by the configured
+     * control plane. Firebase-backed hosted deployments use App Check today;
+     * keeping acquisition on the auth context prevents coordination code from
+     * owning a second Firebase app or assuming one global project.
+     */
+    appCheckTokenProvider?: (forceRefresh?: boolean) => Promise<string | null>;
+    expiresAtMs?: number | null;
+};
+
+/**
+ * App-facing options intentionally hide transport node identifiers from callbacks.
+ */
+type RuntimeClientOptions = Omit<ClientOptions, 'onDevices' | 'onAutoConnect' | 'onIncomingSession' | 'coordinationAvenueOverride' | 'coordinationRoomGossipFanout' | 'coordinationPlatformType'> & {
+    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 PeerLifecycleStatus$1 = PeerLifecycleStatus;
+type RuntimePeerScope = PeerScope;
+/**
+ * App-facing peer session snapshot model. Runtime transport identifiers stay internal.
+ */
+type PeerSessionSnapshot$1 = Omit<PeerSessionSnapshot, 'nodeId'>;
+type LocalDeviceInfo$1 = LocalDeviceInfo;
+type RuntimeRoomMember = RoomMember;
+type DeviceConnectOptions = ManagedDeviceConnectOptions;
+type JoinRoomOptions$1 = JoinRoomOptions;
+type ChannelDescriptor$1 = ChannelDescriptor;
+interface ConnectionTarget {
+    ticket: string;
+    timeoutMs?: number;
+}
+/**
+ * Durable browser storage used by the optional upstream Iroh docs, blobs, and
+ * gossip protocols. Implementations normally map these atomic operations to
+ * IndexedDB; OpenRTC deliberately does not own a second browser database.
+ */
+interface BrowserProtocolStore {
+    loadIdentity(): Promise<{
+        defaultAuthor: Uint8Array;
+    } | null>;
+    exportSnapshot(): Promise<{
+        authors: unknown[];
+        namespaces: unknown[];
+        entries: unknown[];
+    }>;
+    importAuthor(authorId: string, author: Uint8Array): Promise<void>;
+    importNamespace(capability: unknown): Promise<void>;
+    deleteNamespace(namespaceId: string): Promise<void>;
+    applyEntry(mutation: unknown): Promise<void>;
+    acknowledgeOutbox(operationId: string): Promise<void>;
+    listBlobManifests(): Promise<unknown[]>;
+    getBlobResumeState(contentHash: string): Promise<unknown | null>;
+    readBlobRange(contentHash: string, offset: number, length: number): Promise<Uint8Array | null>;
+    writeBlobRange(contentHash: string, size: number, chunkBytes: number, offset: number, bytes: Uint8Array): Promise<void>;
+    finalizeBlob(contentHash: string): Promise<boolean>;
+    readBlobOutboardNode(contentHash: string, nodeId: string): Promise<Uint8Array | null>;
+    writeOutboard(contentHash: string, nodeId: string, pair: Uint8Array): Promise<void>;
+    markBlobBaoReady(contentHash: string): Promise<void>;
+    writeStagingChunk(sessionId: string, chunkIndex: number, bytes: Uint8Array): Promise<void>;
+    finalizeBlobStaging(sessionId: string, contentHash: string, size: number, chunkBytes: number): Promise<void>;
+    abortBlobStaging(sessionId: string): Promise<void>;
+    deleteBlob(contentHash: string, force: boolean): Promise<boolean>;
+    beginBlobImport(contentHash: string, size: number, chunkBytes: number): Promise<void>;
+    writeBlobChunk(contentHash: string, size: number, chunkBytes: number, chunkIndex: number, bytes: Uint8Array): Promise<void>;
+    finalizeBlobImport(contentHash: string, size: number, chunkBytes: number): Promise<void>;
+    flush(): Promise<void>;
+}
+interface NamespaceDescriptor {
+    namespaceId: string;
+    capabilityKind: 'read' | 'write';
+    capability: Uint8Array;
+}
+interface IrohMutationReceipt {
+    contentHash: string;
+    operationId: string;
+}
+interface IrohDocEntry {
+    namespaceId: string;
+    authorId: string;
+    key: Uint8Array;
+    timestamp: number;
+    contentHash: string;
+    contentLength: number;
+}
+interface PeerConnectOptions {
+    deviceId?: string;
+    ticket?: string;
+    scope?: RuntimePeerScope;
+    channelId?: string;
+    /** Total wall-clock budget for dial, admission, and peer settlement. */
+    timeoutMs?: number;
+    /**
+     * 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.
+     */
+    keepManualDisconnect?: boolean;
+}
+interface PeerStreamOptions {
+    ticket?: string;
+    scope?: RuntimePeerScope;
+    channelId?: string;
+    /** Internal channel metadata written inside the protected stream envelope. */
+    channelMetadata?: Record<string, unknown> | null;
+    timeoutMs?: number;
+}
+interface PortableMediaChunk {
+    publicationId: string;
+    mediaGeneration: number;
+    sequence: number;
+    timestampUs: number;
+    durationUs: number;
+    kind: 'audio' | 'video' | 'screen' | 'data';
+    codec: 'opus' | 'h264' | 'vp8' | 'vp9' | 'av1' | 'pcm' | 'opaque';
+    keyframe: boolean;
+    discardable: boolean;
+    payload: Uint8Array;
+}
+interface PortableMediaPublish {
+    publicationId: string;
+    mediaGeneration: number;
+    kind: 'audio' | 'video';
+    codec: PortableMediaChunk['codec'];
+    clockRate: number;
+    codedWidth?: number;
+    codedHeight?: number;
+    channels?: number;
+}
+interface PortableMediaPublicationStart {
+    publicationId: string;
+    mediaGeneration: number;
+    control: Uint8Array;
+}
+interface PortableMediaSample {
+    publicationId: string;
+    timestampUs: number;
+    durationUs: number;
+    keyframe: boolean;
+    discardable: boolean;
+    payload: Uint8Array;
+}
+type PortableMediaControl = {
+    type: 'publish';
+    publicationId: string;
+    mediaGeneration: number;
+    kind: PortableMediaPublish['kind'];
+    codec: PortableMediaPublish['codec'];
+    clockRate: number;
+    codedWidth?: number;
+    codedHeight?: number;
+    channels?: number;
+} | {
+    type: 'set-enabled' | 'request-keyframe' | 'stop';
+    publicationId: string;
+    mediaGeneration: number;
+    [key: string]: unknown;
+};
+type ChannelFraming = 'raw' | 'u32be';
+interface ScopedChannelOptions {
+    peerId?: string;
+    peerNodeId?: string;
+    deviceId?: string | null;
+    ticket?: string;
+    scope: RuntimePeerScope;
+    channelId: string;
+    timeoutMs?: number;
+    keepManualDisconnect?: boolean;
+    /**
+     * Reuse an application-ready route owned by an active capability and fail
+     * if none exists. Protocol packages use this to open a named channel
+     * without gaining authority to dial, repair, or add an admission avenue.
+     */
+    existingRouteOnly?: boolean;
+    framing?: ChannelFraming;
+}
+interface ScopedLogicalChannel {
+    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[];
+        hasSendOnWebRTC?: boolean;
+        hasWebRTCTransport?: boolean;
+        lastSendTransport?: ProtocolName | 'stream' | null;
+        framing: ChannelFraming;
+        delivery: 'reliable' | 'latest-state';
+    };
+}
+/**
+ * App-facing device status snapshot model. Runtime transport identifiers stay internal.
+ */
+type DeviceStatus = Omit<DeviceStatusSnapshot, 'nodeId'>;
+type DevicePresence = DevicePresenceStatus;
+type IncomingStream = {
+    type: 'bi' | 'uni';
+    stream: any;
+    /** Native Rust logical connection identity used for internal demux. */
+    connectionId?: string;
+    remoteNodeId: string;
+    protocolHint?: 'control' | 'explicit' | 'native-main' | 'unknown';
+    channel?: ChannelMetadata | null;
+};
+type ConnectionEvent = {
+    type: 'connected' | 'disconnected';
+    connectionId: string;
+    localNodeId: string;
+    remoteNodeId: string;
+    transport: ProtocolName;
+};
+type RawConnection = {
+    connectionId: string;
+    localNodeId: string;
+    remoteNodeId: string;
+};
+type PresenceLoopOptions = {
+    deviceName?: string;
+    ticket?: string;
+    metadata?: string;
+};
+type SessionPlatform = 'native' | 'web';
+type SessionKind = 'app-user-device' | 'share-anonymous' | 'drive-grant-guest' | 'scoped-guest' | (string & {});
+type AutoConnectPolicy = 'enabled' | 'disabled' | 'scoped-only';
+type PresencePolicy = 'online' | 'disabled';
+type ConnectionState = BackendConnectionState;
+type ReadinessOptions = ApplicationPayloadReadinessOptions;
+type PayloadRouteOptions = ApplicationPayloadRouteOptions;
+type ConnectionStatus = 'connecting' | 'connected' | 'disconnected' | 'failed';
+interface PeerReadiness {
+    requestedId: string;
+    connected: boolean;
+    settledReady: boolean;
+    status: ConnectionStatus;
+    health: RuntimePeerHealth | 'unknown';
+    deviceId?: string | null;
+    deviceIdHint?: string | null;
+    activeConnectionId?: string | null;
+    readinessState?: string;
+    readinessReason?: string;
+    scopes: string[];
+}
+interface DeviceProfile {
+    deviceId: string | null;
+    deviceName: string;
+    platformType: string;
+    userId: string | null;
+    capabilities: NonNullable<LocalDeviceInfo$1['capabilities']>;
+    lastSeenAt: string;
+    localNodeId?: string | null;
+}
+interface ManagedOptions {
+    platform: SessionPlatform;
+    sessionKind?: SessionKind;
+    scope?: string | null;
+    autoConnectPolicy?: AutoConnectPolicy;
+    presencePolicy?: PresencePolicy;
+    userId?: string | null;
+    deviceName?: string;
+    localDeviceId?: string | null;
+    metadata?: string;
+    autoConnect?: boolean;
+    presence?: boolean;
+}
+interface ManagedSession {
+    mode: SessionPlatform;
+    device: DeviceProfile;
+    stop: () => Promise<void>;
+}
+
 interface CoordinationGatewayOptions {
     /**
      * Provider-neutral coordination gateway endpoint.
@@ -117,10 +413,9 @@ type EndpointKind = 'device' | 'ephemeral';
 type PeerLifecycleStatus = 'disconnected' | 'connecting' | 'connected' | 'failed' | 'closed';
 type PeerHealth = 'unknown' | 'healthy' | 'suspect' | 'stale';
 type DevicePresenceStatus = 'online' | 'idle' | 'offline';
-type PeerLifecycleStage = 'discovered' | 'dialing' | 'base-connected' | 'admitted' | 'protocol-ready' | 'upgrading' | 'webrtc-ready' | 'degraded' | 'reconnecting' | 'closed';
+type PeerLifecycleStage = 'discovered' | 'dialing' | 'base-connected' | 'admitted' | 'protocol-ready' | 'degraded' | 'reconnecting' | 'closed';
 type PeerBaseTransportState = 'unknown' | 'connecting' | 'connected' | 'degraded' | 'closed';
 type PeerAdmissionState = 'unknown' | 'pending' | 'admitted' | 'rejected' | 'expired';
-type PeerWebRtcState = 'unknown' | 'disabled' | 'connecting' | 'transport-open' | 'route-probing' | 'ready' | 'failed' | 'closed';
 /**
  * Lifecycle label attached to a projected peer while the runtime tracks local ownership.
  *
@@ -154,13 +449,13 @@ interface ChannelDescriptor {
     delivery?: 'reliable' | 'latest-state';
     description?: string;
 }
-type ProtocolName = 'iroh' | 'iroh-quic' | 'iroh-relay' | 'iroh-lan' | 'iroh-webrtc' | 'iroh-moq' | 'ble' | 'webrtc' | 'webrtc-lan' | 'webrtc-turn' | 'moq';
+type ProtocolName = 'iroh' | 'iroh-quic' | 'iroh-relay' | 'iroh-lan' | 'ble' | 'webrtc' | 'moq';
 type ProtocolMaturity = 'stable' | 'experimental' | 'unsupported';
 type TransportPrivacy = 'direct' | 'relay-only';
 type RouteOptimization = 'balanced' | 'lowest-latency';
 type ProtocolBaseName = 'iroh' | 'webrtc' | 'moq';
-type RouteFamily = 'iroh-path' | 'iroh-physical' | 'optional-route';
-type RouteKind = 'core' | 'host-installed' | 'carrier-adapter' | 'route-adapter' | 'path-label';
+type RouteFamily = 'iroh-path' | 'iroh-physical';
+type RouteKind = 'core' | 'host-installed' | 'carrier-adapter' | 'path-label';
 /**
  * Public compatibility type. `native` and `plugin` are legacy capability
  * labels; generated route descriptors use `RouteKind`.
@@ -177,7 +472,6 @@ interface RouteDescriptor {
     defaultRank: number;
     browser: boolean;
     native: boolean;
-    independent: boolean;
 }
 interface ProtocolCapability {
     /** Canonical descriptor id; additive to the legacy capability shape. */
@@ -190,16 +484,14 @@ interface ProtocolCapability {
     implementation: ProtocolImplementationKind;
     locality: ProtocolLocality;
     maturity: ProtocolMaturity;
-    /** Canonical descriptor rank; additive to the legacy capability shape. */
-    defaultRank?: number;
+    /** Canonical descriptor rank and the sole public ordering metadata. */
+    defaultRank: number;
+    /** @deprecated Read-only 2.x compatibility alias; removed in 3.0.0. */
+    preferredRank: number;
     /** Canonical implementation taxonomy; `implementation` retains legacy values. */
     routeImplementation?: RouteKind;
-    /** Compatibility alias for `defaultRank`. */
-    preferredRank: number;
     browser: boolean;
     native: boolean;
-    /** Canonical descriptor flag; additive to the legacy capability shape. */
-    independent?: boolean;
     configured?: boolean;
     available: boolean;
     reason?: string;
@@ -293,15 +585,6 @@ interface ClientOptions {
     nodeIdPersistence?: 'persistent' | 'ephemeral';
     secretKey?: string;
     strictMode?: boolean;
-    /**
-     * Selects the sole consumer of admitted native application streams.
-     *
-     * `runtime` (default) routes named OpenRTC channels through the TypeScript
-     * runtime. `host` is for native products that install one process-level
-     * Rust protocol dispatcher. A native host must never enable both consumers:
-     * the underlying stream queue is ordered and each raw stream has one owner.
-     */
-    nativeStreamConsumer?: 'runtime' | 'host';
     /**
      * Optional application-provided TURN credential loader.
      *
@@ -316,7 +599,10 @@ interface ClientOptions {
     onAutoConnect?: (devices: Device[]) => void;
     onIncomingSession?: (session: SignalingSession) => Promise<void>;
     transports?: {
-        /** Allow Iroh, TURN, and MoQ relay routes. Defaults to true. */
+        /**
+         * Consumer relay intent. Authenticated Iroh-relay and managed-TURN
+         * availability are separate runtime facts.
+         */
         relay?: boolean;
         iroh?: boolean | PlutoIrohConfiguration;
         webrtc?: boolean | PlutoRTCConfiguration;
@@ -401,7 +687,6 @@ interface PeerState {
     settledReady?: boolean;
     readinessState?: string;
     readinessReason?: string;
-    webrtcState?: PeerWebRtcState;
     routable?: boolean;
     transportStableId?: number | null;
     transportGeneration?: number;
@@ -454,6 +739,16 @@ interface BackendConnectionState {
     createdAt?: number;
     updatedAt?: number;
 }
+/** Generation-fenced application message emitted by the native Rust owner. */
+interface NativePeerDataEvent {
+    connectionId: string;
+    remoteNodeId?: string | null;
+    transport: ProtocolName;
+    transportStableId: number;
+    transportGeneration: number;
+    routeGeneration: number;
+    payload: number[];
+}
 interface NativeConnectResult {
     connectionId: string;
     deviceId?: string | null;
@@ -646,13 +941,9 @@ interface DeviceStatusSnapshot extends Device {
 }
 interface LatencySnapshot {
     webrtc?: number | null;
-    webrtcLan?: number | null;
-    webrtcTurn?: number | null;
     iroh?: number | null;
     irohLan?: number | null;
     irohRelay?: number | null;
-    irohWebrtc?: number | null;
-    irohMoq?: number | null;
     ble?: number | null;
     moq?: number | null;
 }
@@ -768,13 +1059,6 @@ interface ExplicitFileDataSendParams {
         deviceId?: string;
         remoteNodeId?: string;
         requireApplicationCrypto?: boolean;
-        getUpgradeState?: () => string;
-        isWebRtcApplicationRouteReady?: () => boolean;
-        sendOnWebRTC?: (data: Uint8Array) => Promise<void>;
-        getWebRTCTransport?: () => {
-            getBufferedAmount?: () => number;
-            waitForDrain?: (lowWaterMark: number) => Promise<void>;
-        } | null;
     };
     remoteNodeId?: string;
     file: File;
@@ -799,8 +1083,15 @@ interface DesiredPeerProjection {
     sessionId?: string | null;
     excludedPeers?: string[];
 }
+/** Browser-only Rust/WASM module supplied by the browser signaling adapter. */
+interface BrowserWasmRuntimeModule {
+    initWasm(moduleOrPath?: unknown): Promise<unknown>;
+    WasmClient: new (apiKey: string) => any;
+    start(): void;
+}
 interface ISignalingBackend {
     currentUser: RuntimeIdentity | null;
+    loadBrowserWasmRuntime?(): Promise<BrowserWasmRuntimeModule>;
     signInAnonymously(): Promise<void>;
     signInWithPluto?(): Promise<void>;
     signOut(): Promise<void>;
@@ -866,13 +1157,20 @@ interface ISignalingBackend {
     notifyNetworkChange?(options?: {
         reason?: string;
     }): Promise<unknown>;
+    setTransportPriority?(priority: ProtocolName[]): Promise<void>;
     getManagedNodeId?(options?: {
         initializeIfMissing?: boolean;
     }): Promise<string | null>;
     getEndpointTicket?(): Promise<string>;
     openPeerBi?(id: string, timeoutMs?: number): Promise<BackendPeerBiStream>;
-    openPeerNativeBi?(id: string, label: string, timeoutMs?: number): Promise<BackendPeerBiStream>;
     openPeerUni?(id: string, timeoutMs?: number): Promise<BackendPeerUniStream>;
+    beginOpenRtcMediaPublication?(input: Omit<PortableMediaPublish, 'mediaGeneration'>): PortableMediaPublicationStart | Promise<PortableMediaPublicationStart>;
+    encodeOpenRtcMediaSample?(input: PortableMediaSample): Uint8Array | Promise<Uint8Array>;
+    pauseOpenRtcMediaPublication?(publicationId: string): void | Promise<void>;
+    retireOpenRtcMediaPublication?(publicationId: string): void | Promise<void>;
+    retireOpenRtcMediaReceiver?(publicationId: string, mediaGeneration: number): void | Promise<void>;
+    decodeOpenRtcMediaChunk?(encoded: Uint8Array): PortableMediaChunk | Promise<PortableMediaChunk>;
+    decodeOpenRtcMediaControl?(encoded: Uint8Array): PortableMediaControl | Promise<PortableMediaControl>;
     connectToDevice?(params: {
         deviceId?: string | null;
         endpointTicket: string;
@@ -888,6 +1186,10 @@ interface ISignalingBackend {
     isConnected(nodeId: string): Promise<boolean>;
     getConnectionStates?(): Promise<BackendConnectionState[]>;
     onStateChange?(callback: (state: BackendConnectionState) => void): Promise<() => void> | (() => void);
+    /** Native-only protected logical message surface; browser uses its WASM connection. */
+    sendPeerMessage?(id: string, payload: Uint8Array): Promise<void>;
+    /** Native-only generation-fenced logical message projection. */
+    onPeerMessage?(callback: (event: NativePeerDataEvent) => void): Promise<() => void> | (() => void);
     /** @deprecated Implement file protocols over named channels, or use `openrtc-file-transfer`. */
     sendExplicitFilePath?(connectionId: string, filePath: string, transferId?: string): Promise<string>;
     /** @deprecated Implement file protocols over named channels, or use `openrtc-file-transfer`. */
@@ -898,15 +1200,7 @@ interface ISignalingBackend {
     deleteTransferJob?(jobId: string): Promise<void>;
 }
 interface CoreClientBridgeHost {
-    connect(ticket: string, timeoutMs?: number, expectedDeviceId?: string | null, channelId?: string, options?: {
-        admissionAlreadyPresented?: boolean;
-        approvedScope?: string | null;
-    }): Promise<{
-        id?: string | null;
-        remoteNodeId?: string | null;
-        deviceId?: string | null;
-    } | unknown>;
-    ensureManagedApplicationRoute?(options: ManagedApplicationRouteOptions): Promise<{
+    ensureManagedApplicationRoute(options: ManagedApplicationRouteOptions): Promise<{
         id?: string | null;
         remoteNodeId?: string | null;
         deviceId?: string | null;
@@ -932,9 +1226,6 @@ interface SignalingOptions {
     nodeIdPersistence?: 'persistent' | 'ephemeral';
 }
 interface TransportContext {
-    sendMoQ: (data: Uint8Array, options?: {
-        alreadyProtected?: boolean;
-    }) => Promise<void>;
     /**
      * Send one plaintext typed frame over a fresh runtime-owned Iroh application
      * stream. The runtime applies the negotiated application-crypto stream
@@ -949,11 +1240,6 @@ interface TransportContext {
      */
     rankRoutes?: (candidates: ProtocolName[]) => ProtocolName[];
     disableIrohFallback: boolean;
-    isMoQReady: () => boolean;
-    isMoQDataReady?: () => boolean;
-    isMoQApplicationRouteProven?: () => boolean;
-    requestMoQApplicationRouteProof?: () => void;
-    clearMoQApplicationRouteProof?: () => void;
     requestIrohCarrier?: () => void;
     runtimeFlow?: 'default' | 'ticket-only';
     readerCloseStrategy?: 'cancel' | 'release-lock';
@@ -1004,19 +1290,8 @@ interface ApplicationPayloadRouteOptions extends ApplicationPayloadReadinessOpti
 }
 interface ApplicationPayloadSendOptions extends ApplicationPayloadRouteOptions {
 }
-interface ApplicationRouteReadyObservation {
-    connectionId: string;
-    remoteNodeId: string;
-    activeTransport: ProtocolName;
-    parallelTransport?: ProtocolName | null;
-    reason: 'webrtc-route-ready' | 'webrtc-heartbeat-healthy' | 'webrtc-application-send' | 'base-transport-loss-preserved';
-    transportStableId?: number;
-    transportGeneration?: number;
-    routeGeneration?: number;
-}
 interface ConnectionOptions {
     reliable?: boolean;
-    rtcConfig?: PlutoRTCConfiguration;
     transportContext?: TransportContext;
     applicationCrypto?: PayloadCrypto;
     /**
@@ -1042,23 +1317,6 @@ interface ConnectionOptions {
         transportGeneration?: number;
         routeGeneration?: number;
     }) => boolean | void | Promise<boolean | void>;
-    /**
-     * Fired when a connection-owned application route has proven it can carry
-     * app traffic. Consumers should use this as a lifecycle signal for the same
-     * connection record, not as an independent projection source.
-     */
-    onApplicationRouteReady?: (event: ApplicationRouteReadyObservation) => void;
-    /**
-     * Fired when the WebRTC data plane has proven a ping/pong round trip but the
-     * mandatory application crypto route is not installed yet. Connection owns
-     * transport proof; Client owns the application-route handshake recovery.
-     */
-    onApplicationRouteMissing?: (event: {
-        connectionId: string;
-        remoteNodeId: string;
-        reason: 'webrtc-heartbeat-before-crypto';
-        negotiationId?: string | null;
-    }) => void;
 }
 interface JoinRequest {
     id: string;
@@ -1067,19 +1325,112 @@ interface JoinRequest {
     state: 'pending' | 'accepted' | 'rejected';
 }
 
-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 Message = string | object | ArrayBuffer | Uint8Array;
+/**
+ * One logical admitted peer connection.
+ *
+ * This class owns application framing and callbacks on the logical Iroh stream
+ * supplied by Rust. WebRTC and MoQ are packet carriers below that stream; this
+ * class never constructs, negotiates, retries, or retains either carrier.
+ * Authority inventory: `canonical-iroh-carriers` and
+ * `logical-peer-streams-and-datagrams`.
+ */
+declare class Connection {
+    private static readonly decoder;
+    private static readonly encoder;
+    private static readonly MAX_PENDING_MESSAGES;
+    private static readonly MAX_PENDING_ENCRYPTED_PAYLOADS;
+    private static readonly DEFAULT_APPLICATION_CRYPTO_WAIT_MS;
+    private writer;
+    private reader;
+    private options;
+    private receiveBuffer;
+    private writeMutex;
+    private closed;
+    private nativeSignalSender;
+    private applicationKeyAgreementObservationEpoch;
+    private lastApplicationPayloadTransport;
+    private lastTransportStatusFingerprint;
+    private lastBaseTransportGeneration;
+    private lastBaseTransportStableId;
+    private remoteDedicatedCarrierControl;
+    private remoteDedicatedCarrierControlReady;
+    private readonly listeners;
+    private readonly closeListeners;
+    private readonly irohHealthListeners;
+    private readonly pendingMessages;
+    private pendingEncryptedApplicationPayloads;
+    private readonly applicationCryptoWaiters;
+    readonly id: string;
+    readonly remoteNodeId: string;
+    /** @deprecated Use the admitted peer/device projection for device identity. */
+    readonly deviceId: string;
+    readonly localNodeId: string;
+    constructor(id: string, localNodeId: string, remoteNodeId: string, writer: WritableStreamDefaultWriter<Uint8Array>, reader: ReadableStreamDefaultReader<Uint8Array>, options?: ConnectionOptions);
+    get isClosed(): boolean;
+    get transportType(): ProtocolName;
+    setApplicationCrypto(applicationCrypto: PayloadCrypto | undefined): void;
+    getKeyAgreementEpoch(): number;
+    requireApplicationCrypto(): void;
+    isApplicationCryptoRequired(): boolean;
+    isPayloadReady(options?: ApplicationPayloadReadinessOptions): boolean;
+    payloadTransports(options?: ApplicationPayloadRouteOptions): ProtocolName[];
+    requestTransportRecovery(_reason: string): void;
+    handleAppForeground(): void;
+    handleBaseTransportAvailable(_source: string, proof: {
+        transportState?: string | null;
+        transportGeneration?: number | null;
+        transportStableId?: number | null;
+    }): void;
+    getTransportDiagnostics(): Promise<any>;
+    send(message: Message, options?: ApplicationPayloadSendOptions): Promise<void>;
+    lastPayloadTransport(): ProtocolName | null;
+    sendControl(message: Message): Promise<void>;
+    sendRawIrohFrame(frame: Uint8Array): Promise<void>;
+    getAvailableTransports(): ProtocolName[];
+    disconnect(): Promise<void>;
+    handleSessionAdmissionRejected(reason: string): void;
+    onMessage(callback: (message: any) => void): void;
+    onDisconnect(callback: () => void): void;
+    injectData(chunk: Uint8Array): void;
+    receiveFrameBody(body: Uint8Array): void;
+    receiveMessage(message: unknown): void;
+    receiveDataPayload(messageData: Uint8Array): void;
+    onWebRtcHeartbeatHealth(_callback: (health: ConnectionHealth) => void): void;
+    onIrohHeartbeatHealth(callback: (health: ConnectionHealth) => void): void;
+    reportTransportStatusIfChanged(): void;
+    getTransportStatus(): {
+        activeTransport: ProtocolName;
+        parallelTransport: ProtocolName | null;
+    };
+    getLatencySnapshot(): LatencySnapshot;
+    setNativeSignalSender(sender: (envelope: any) => Promise<void>): void;
+    getControlFrameMode(): NonNullable<ConnectionOptions['controlFrameMode']>;
+    sendNativeControlEnvelope(envelope: unknown): Promise<boolean>;
+    /** @deprecated Direct WebRTC/MoQ signal sessions were removed. */
+    receiveInternalSignal(_content: unknown): void;
+    private hasRequiredApplicationCrypto;
+    private hasBaseApplicationRoute;
+    private waitForRequiredApplicationCrypto;
+    private resolveApplicationCryptoWaiters;
+    private rejectApplicationCryptoWaiters;
+    private encodePayload;
+    private buildFrame;
+    private sendTyped;
+    private writeFrame;
+    private openApplicationPayload;
+    private openUntypedApplicationPayload;
+    private isPlaintextBootstrapPayload;
+    private queueEncryptedApplicationPayload;
+    private flushPendingEncryptedApplicationPayloads;
+    private readLoop;
+    private handleData;
+    private static isUntypedDataFrame;
+    private processDataPayload;
+    private emitMessage;
+    private close;
 }
 
-export type { RouteDescriptor as $, AuthMode as A, BackendPeerBiStream as B, ConnectDeviceResult as C, Device as D, ExplicitFileDataSendParams as E, ApplicationPayloadReadinessOptions as F, GrantScope as G, ApplicationPayloadRouteOptions as H, ISignalingBackend as I, ApplicationPayloadSendOptions as J, ITransport as K, LocalDeviceInfo as L, ManagedConnectionRecord as M, NativeConnectParams as N, LatencySnapshot as O, PlutoIrohConfiguration as P, PeerState as Q, RouteOptimization as R, SignalingMode as S, PeerScope as T, PeerHealth as U, ChannelDescriptor as V, ChannelMetadata as W, ManagedDeviceConnectOptions as X, JoinRoomOptions as Y, DevicePresenceStatus as Z, PeerLifecycleStatus as _, PlutoRTCConfiguration as a, ProtocolCapability as a0, ProtocolCapabilityMap as a1, CryptoStreams as a2, CryptoBiStream as a3, RouteFamily as a4, RouteKind as a5, AppLimits as a6, SignalingOptions as a7, RoomCreationMode as a8, ScanningLoopOptions as a9, ScanningLoopHandle as aa, RuntimeBootstrapOptions as ab, RuntimeBootstrapResult as ac, ManagedApplicationRouteOptions as ad, JoinRequest as ae, PlutoMoQConfiguration as b, ProtocolName as c, PeerSessionSnapshot as d, ResolvedPeerIdentity as e, ConnectDeviceHooks as f, ConnectDeviceOptions as g, ClientOptions as h, CoordinationGatewayGrantRequest as i, CoordinationGatewayGrant as j, DiscoveryMode as k, RoomMember as l, RuntimeIdentity as m, SignalingEnvelope as n, DeviceStatusSnapshot as o, BackendPeerUniStream as p, DeviceEvent as q, DesiredPeerProjection as r, CoreClientBridgeHost as s, NativeConnectResult as t, SignalingSession as u, SessionEvent as v, BackendConnectionState as w, NativeManagedSessionStartResult as x, ConnectionOptions as y, PayloadCrypto as z };
+export { type NativeManagedSessionStartResult as $, type AuthContext as A, type AuthMode as B, type ChannelDescriptor$1 as C, type DeviceStatus as D, type SignalingMode as E, type ClientOptions as F, type GrantScope as G, type ExplicitFileDataSendParams as H, type IncomingStream as I, type JoinRoomOptions$1 as J, type ISignalingBackend as K, type LocalDeviceInfo$1 as L, type ManagedOptions as M, type RuntimeIdentity as N, type RoomMember as O, type PlutoIrohConfiguration as P, type Device as Q, type RouteOptimization as R, type ScopedChannelOptions as S, type DeviceStatusSnapshot as T, type ManagedConnectionRecord as U, type SignalingEnvelope as V, type DeviceEvent as W, type DesiredPeerProjection as X, type SignalingSession as Y, type SessionEvent as Z, type LocalDeviceInfo as _, type PlutoRTCConfiguration as a, type BackendPeerBiStream as a0, type BackendPeerUniStream as a1, type PortableMediaPublish as a2, type PortableMediaPublicationStart as a3, type PortableMediaSample as a4, type PortableMediaChunk as a5, type PortableMediaControl as a6, type NativeConnectParams as a7, type NativeConnectResult as a8, type BackendConnectionState as a9, type ScanningLoopHandle as aA, type RuntimeBootstrapOptions as aB, type RuntimeBootstrapResult as aC, type ApplicationPayloadReadinessOptions as aD, type ManagedApplicationRouteOptions as aE, type PeerState as aF, type PeerScope as aG, type PeerHealth as aH, type ChannelDescriptor as aI, type JoinRequest as aJ, type AutoConnectPolicy as aK, type ChannelFraming as aL, type ConnectionStatus as aM, type DevicePresence as aN, type PayloadRouteOptions as aO, type PeerLifecycleStatus$1 as aP, type PeerSessionSnapshot$1 as aQ, type PresencePolicy as aR, type RuntimeAuthContext as aS, type RuntimePeerScope as aT, type SessionKind as aU, type SessionPlatform as aV, type NativePeerDataEvent as aa, type CoordinationGatewayGrantRequest as ab, type CoordinationGatewayGrant as ac, type BrowserWasmRuntimeModule as ad, type BrowserProtocolStore as ae, type NamespaceDescriptor as af, type IrohMutationReceipt as ag, type IrohDocEntry as ah, type CoreClientBridgeHost as ai, type RouteDescriptor as aj, type PayloadCrypto as ak, type CryptoStreams as al, type CryptoBiStream as am, type RouteFamily as an, type RouteKind as ao, type RuntimeAuthIdentity as ap, type RuntimeSession as aq, type AppLimits as ar, type ConnectionTarget as as, type PresenceLoopOptions as at, type SignalingOptions as au, type JoinRoomOptions as av, type ChannelMetadata as aw, type RoomCreationMode as ax, type ProtocolCapabilityMap as ay, type ScanningLoopOptions as az, type PlutoMoQConfiguration as b, type ProtocolName as c, type RuntimePeerState as d, type PeerConnectOptions as e, Connection as f, type PeerSessionSnapshot as g, type PeerReadiness as h, type RuntimePeerHealth as i, type ResolvedPeerIdentity as j, type PeerStreamOptions as k, type RuntimeDevice as l, type ScopedLogicalChannel as m, type ConnectionState as n, type ReadinessOptions as o, type ConnectionEvent as p, type ManagedSession as q, type DeviceConnectOptions as r, type ConnectDeviceResult as s, type ConnectDeviceHooks as t, type ConnectDeviceOptions as u, type DeviceProfile as v, type RawConnection as w, type RuntimeRoomMember as x, type RuntimeClientOptions as y, type DiscoveryMode as z };