openrtc 2.3.1 → 2.5.1

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

@@ -1,3 +1,372 @@
+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' | 'coordinationRoomArchitecture' | 'coordinationDevicePublicKeyX' | 'coordinationDeviceSign' | '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>;
+}
+
+/**
+ * Provider-neutral hot coordination contract.
+ *
+ * Implementations deliver authenticated roster, presence, and signaling facts.
+ * They do not decide peer identity, admission, transport dialing, retries,
+ * replacement, or settlement; those remain Rust/OpenRTC lifecycle concerns.
+ */
+interface CoordinationSignalingStore {
+    updatePresence(localNodeId: string, ticket: string, online: boolean, ttlMs: number, metadata?: string, deviceNameOverride?: string): Promise<void>;
+    setOffline(localNodeId: string): Promise<void>;
+    updateDevice(deviceId: string, updates: {
+        deviceName?: string;
+        capabilities?: Device['capabilities'];
+        metadata?: string;
+        excludedPeers?: string[];
+    }): Promise<void>;
+    /**
+     * Publish the complete session-scoped peer-exclusion set for this runtime.
+     *
+     * The coordination provider owns delivery and persistence. Rust/WASM owns
+     * the local desired-peer decision and consumes remote exclusion snapshots.
+     */
+    setExcludedPeers?(excludedPeers: string[]): Promise<void>;
+    deleteDevice(deviceId: string): Promise<void>;
+    cleanupStaleDevices(): Promise<void>;
+    searchDevices(excludeNodeId?: string): Promise<Device[]>;
+    listDevices(excludeNodeId?: string): Promise<Device[]>;
+    subscribeDevices(): Promise<ReadableStream<DeviceEvent[]>>;
+    onDevicesChange(callback: (devices: Device[]) => void, excludeNodeId?: string): () => void;
+    onRoomArchitectureChange?(callback: (snapshot: RoomArchitectureSnapshot) => void): () => void;
+    onRoomAuthorityAssignmentChange?(callback: (assignment: RoomAuthorityAssignment | null) => void): () => void;
+    publishAuthorityAssignment?(input: {
+        assignment: {
+            policyVersion: 'room-authority-assignment-v1';
+            serviceId: string;
+            generation: number;
+            revision: number;
+            subjectDeviceId: string;
+            shardId: string;
+            priorityDeviceIds: string[];
+            relevantEntityIds: string[];
+            issuedAtMs: number;
+            expiresAtMs: number;
+        };
+        signature: string;
+    }): Promise<void>;
+    publishManagedRoomMessage?(input: {
+        messageId: string;
+        channel: string;
+        priority: 0 | 1 | 2 | 3;
+        zoneId?: string;
+        payload: Uint8Array;
+    }): Promise<void>;
+    onManagedRoomMessage?(callback: (message: ManagedRoomMessage) => void): () => void;
+    createSession(session: SignalingSession): Promise<void>;
+    updateSession(sessionId: string, updateData: Record<string, unknown>): Promise<void>;
+    subscribeSessions(localDeviceId: string): Promise<ReadableStream<SessionEvent[]>>;
+    sendMessage(targetId: string, payload: string, state?: string, replyPayload?: string): Promise<string>;
+    pollMessages(targetId: string): Promise<SignalingEnvelope[]>;
+    watchFriendDevices(friendUserIds: string[], callback: (devices: Map<string, Device[]>) => void): () => void;
+    updateFriendTicket(friendTicket: string | null): Promise<void>;
+    handleScopeChange(): Promise<void>;
+    setHostAvailability?(input: {
+        available: boolean;
+        reason: string;
+    }): void;
+    stopAuthActivity(): void;
+    usesCoordinationGateway?(): boolean;
+    joinCoordinationRoom?(roomId: string, nodeId: string, ticket: string): Promise<void>;
+    leaveCoordinationRoom?(roomId: string): Promise<void>;
+    getCoordinationRoomMembers?(roomId: string): Promise<RoomMember[]>;
+    watchCoordinationRoomMembers?(roomId: string, callback: (members: RoomMember[]) => void): () => void;
+}
 interface CoordinationGatewayOptions {
     /**
      * Provider-neutral coordination gateway endpoint.
@@ -117,10 +486,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 +522,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 +545,6 @@ interface RouteDescriptor {
     defaultRank: number;
     browser: boolean;
     native: boolean;
-    independent: boolean;
 }
 interface ProtocolCapability {
     /** Canonical descriptor id; additive to the legacy capability shape. */
@@ -190,16 +557,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 +658,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 +672,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;
@@ -358,6 +717,8 @@ interface Device {
     connectable?: boolean;
     kind?: EndpointKind | string;
     nodeId?: string;
+    /** Gateway-verified public half of the non-exportable device signing key. */
+    devicePublicKeyJwk?: JsonWebKey;
     platformType?: string;
     capabilities?: {
         canHost?: boolean;
@@ -379,6 +740,8 @@ interface Device {
     transports?: ProtocolName[];
 }
 interface PeerState {
+    /** Rust's current-record terminal verdict; absent on older runtimes. */
+    logicalSessionTerminal?: boolean;
     peerId: string;
     deviceId?: string;
     deviceIdHint?: string;
@@ -401,7 +764,6 @@ interface PeerState {
     settledReady?: boolean;
     readinessState?: string;
     readinessReason?: string;
-    webrtcState?: PeerWebRtcState;
     routable?: boolean;
     transportStableId?: number | null;
     transportGeneration?: number;
@@ -424,6 +786,7 @@ interface PeerState {
     errorPlane?: string;
 }
 interface BackendConnectionState {
+    logicalSessionTerminal?: boolean;
     connectionId: string;
     deviceId?: string | null;
     deviceIdHint?: string | null;
@@ -454,6 +817,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 +1019,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;
 }
@@ -686,6 +1055,7 @@ interface ResolvedPeerIdentity {
     nodeId?: string | null;
 }
 interface PeerSessionSnapshot {
+    logicalSessionTerminal?: boolean;
     peerId: string;
     deviceId?: string | null;
     deviceIdHint?: string | null;
@@ -768,13 +1138,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;
@@ -798,9 +1161,63 @@ interface DesiredPeerProjection {
     online?: boolean;
     sessionId?: string | null;
     excludedPeers?: string[];
+    devicePublicKeyJwk?: JsonWebKey;
+    topologyRole?: 'active' | 'backup';
+    topologyRevision?: number;
+}
+/**
+ * Room-wide routing intent. Physical Iroh carrier selection remains private.
+ * `managed` is reserved but unavailable in 2.5; selecting it fails explicitly.
+ */
+type RoomArchitectureMode = 'auto' | 'mesh' | 'sparse' | 'managed' | 'authority';
+type EffectiveRoomArchitecture = Exclude<RoomArchitectureMode, 'auto'>;
+type RoomArchitectureReason = 'size' | 'traffic' | 'latency' | 'cost' | 'capacity' | 'manual' | 'recovery';
+/**
+ * Customer-safe room policy projection delivered by the authenticated gateway.
+ * Provider rates, margins, reserves, and invoice allocation stay server-side.
+ */
+interface RoomArchitectureSnapshot {
+    requested: RoomArchitectureMode;
+    effective: EffectiveRoomArchitecture;
+    epoch: number;
+    phase: 'settled' | 'preparing';
+    reason: RoomArchitectureReason;
+    heldCreditsUsd: number;
+    quoteExpiresAtMs: number;
+}
+/**
+ * Read-only application-interest projection signed by the room's registered
+ * authority and admitted by the gateway. It suggests what the application
+ * should render or simulate; it never grants transport or room permissions.
+ */
+interface RoomAuthorityAssignment {
+    serviceId: string;
+    generation: number;
+    revision: number;
+    shardId: string;
+    priorityDeviceIds: readonly string[];
+    relevantEntityIds: readonly string[];
+    issuedAtMs: number;
+    expiresAtMs: number;
+}
+/** Internal decrypted delivery from the Rust-owned managed-room group. */
+interface ManagedRoomMessage {
+    senderId: string;
+    messageId: string;
+    channel: string;
+    priority: 0 | 1 | 2 | 3;
+    zoneId?: string;
+    payload: Uint8Array;
+}
+/** 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>;
@@ -833,6 +1250,31 @@ interface ISignalingBackend {
     }): Promise<void>;
     deleteDevice(deviceId: string): Promise<void>;
     onDevicesChange(callback: (devices: Device[]) => void, excludeNodeId?: string): () => void;
+    onRoomArchitectureChange?(callback: (snapshot: RoomArchitectureSnapshot) => void): () => void;
+    onRoomAuthorityAssignmentChange?(callback: (assignment: RoomAuthorityAssignment | null) => void): () => void;
+    publishAuthorityAssignment?(input: {
+        assignment: {
+            policyVersion: 'room-authority-assignment-v1';
+            serviceId: string;
+            generation: number;
+            revision: number;
+            subjectDeviceId: string;
+            shardId: string;
+            priorityDeviceIds: string[];
+            relevantEntityIds: string[];
+            issuedAtMs: number;
+            expiresAtMs: number;
+        };
+        signature: string;
+    }): Promise<void>;
+    publishManagedRoomMessage?(input: {
+        messageId: string;
+        channel: string;
+        priority: 0 | 1 | 2 | 3;
+        zoneId?: string;
+        payload: Uint8Array;
+    }): Promise<void>;
+    onManagedRoomMessage?(callback: (message: ManagedRoomMessage) => void): () => void;
     onAuthChange(callback: (user: RuntimeIdentity | null) => void): () => void;
     checkForSSOToken(): Promise<void>;
     waitForAuth(): Promise<void>;
@@ -844,7 +1286,7 @@ interface ISignalingBackend {
     submitDesiredPeerProjection?(revision: number, peers: DesiredPeerProjection[]): Promise<void>;
     notifyDisconnectRequested?(remoteNodeId: string): void;
     startPresence?(userId: string, localNodeId: string, deviceName: string, ticket: string, metadata?: string): Promise<void>;
-    startPresenceLoop(userId: string, localNodeId: string, deviceName: string, ticket: string, metadata?: string): void;
+    startPresenceLoop(userId: string, localNodeId: string, deviceName: string, ticket: string, metadata?: string): Promise<void>;
     createSession(session: SignalingSession): Promise<void>;
     updateSession(sessionId: string, updateData: any): Promise<void>;
     subscribeSessions(localDeviceId: string): Promise<ReadableStream<SessionEvent[]>>;
@@ -866,13 +1308,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 +1337,23 @@ 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>;
+    encodeSparseFanoutMessage?(capability: string, payload: Uint8Array): Promise<Uint8Array>;
+    acceptSparseFanoutMessage?(capability: string, sourcePeerId: string, payload: Uint8Array): Promise<{
+        payload: Uint8Array;
+        authorDeviceId: string;
+        authorPeerId: string;
+        topologyRevision: number;
+        hop: number;
+        forwardPeerIds: string[];
+        forwardPeerLimit: number;
+        forwardQueueCapacity: number;
+        forward?: Uint8Array;
+    }>;
+    recordSparseFanoutForwardQueueDrop?(capability: string, count: number): 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 +1364,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 +1390,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 +1404,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 +1454,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 +1481,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 +1489,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;
+    }): boolean;
+    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 DeviceEvent as $, type RawConnection as A, type RuntimeRoomMember as B, type ChannelDescriptor$1 as C, type DeviceStatus as D, type EffectiveRoomArchitecture as E, type AuthContext as F, type GrantScope as G, type RuntimeClientOptions as H, type IncomingStream as I, type JoinRoomOptions$1 as J, type DiscoveryMode as K, type LocalDeviceInfo$1 as L, type ManagedOptions as M, type AuthMode as N, type SignalingMode as O, type PlutoIrohConfiguration as P, type ClientOptions as Q, type RoomArchitectureMode as R, type ScopedChannelOptions as S, type ExplicitFileDataSendParams as T, type ISignalingBackend as U, type RuntimeIdentity as V, type RoomMember as W, type Device as X, type DeviceStatusSnapshot as Y, type ManagedConnectionRecord as Z, type SignalingEnvelope as _, type RoomArchitectureReason as a, type SessionKind as a$, type DesiredPeerProjection as a0, type SignalingSession as a1, type SessionEvent as a2, type LocalDeviceInfo as a3, type NativeManagedSessionStartResult as a4, type BackendPeerBiStream as a5, type BackendPeerUniStream as a6, type PortableMediaPublish as a7, type PortableMediaPublicationStart as a8, type PortableMediaSample as a9, type PresenceLoopOptions as aA, type SignalingOptions as aB, type JoinRoomOptions as aC, type ChannelMetadata as aD, type RoomCreationMode as aE, type ProtocolCapabilityMap as aF, type ScanningLoopOptions as aG, type ScanningLoopHandle as aH, type RuntimeBootstrapOptions as aI, type RuntimeBootstrapResult as aJ, type ApplicationPayloadReadinessOptions as aK, type ManagedApplicationRouteOptions as aL, type PeerState as aM, type PeerScope as aN, type PeerHealth as aO, type ChannelDescriptor as aP, type JoinRequest as aQ, type AutoConnectPolicy as aR, type ChannelFraming as aS, type ConnectionStatus as aT, type DevicePresence as aU, type PayloadRouteOptions as aV, type PeerLifecycleStatus$1 as aW, type PeerSessionSnapshot$1 as aX, type PresencePolicy as aY, type RuntimeAuthContext as aZ, type RuntimePeerScope as a_, type PortableMediaChunk as aa, type PortableMediaControl as ab, type NativeConnectParams as ac, type NativeConnectResult as ad, type BackendConnectionState as ae, type NativePeerDataEvent as af, type CoordinationGatewayGrantRequest as ag, type CoordinationGatewayGrant as ah, type BrowserWasmRuntimeModule as ai, type BrowserProtocolStore as aj, type NamespaceDescriptor as ak, type IrohMutationReceipt as al, type IrohDocEntry as am, type CoordinationSignalingStore as an, type ManagedRoomMessage as ao, type CoreClientBridgeHost as ap, type RouteDescriptor as aq, type PayloadCrypto as ar, type CryptoStreams as as, type CryptoBiStream as at, type RouteFamily as au, type RouteKind as av, type RuntimeAuthIdentity as aw, type RuntimeSession as ax, type AppLimits as ay, type ConnectionTarget as az, type RoomArchitectureSnapshot as b, type SessionPlatform as b0, type RoomAuthorityAssignment as c, type PlutoRTCConfiguration as d, type PlutoMoQConfiguration as e, type RouteOptimization as f, type ProtocolName as g, type RuntimePeerState as h, type PeerConnectOptions as i, Connection as j, type PeerSessionSnapshot as k, type PeerReadiness as l, type RuntimePeerHealth as m, type ResolvedPeerIdentity as n, type PeerStreamOptions as o, type RuntimeDevice as p, type ScopedLogicalChannel as q, type ConnectionState as r, type ReadinessOptions as s, type ConnectionEvent as t, type ManagedSession as u, type DeviceConnectOptions as v, type ConnectDeviceResult as w, type ConnectDeviceHooks as x, type ConnectDeviceOptions as y, type DeviceProfile as z };