openrtc 0.1.3 → 0.2.1

package/dist/runtime/index.d.ts

@@ -1,9 +1,10 @@
-import { C as Connection, E as RuntimeConnectionTarget, q as RuntimeRawConnection } from '../factories-0TxDPMeu.js';
-export { r as ChannelDescriptor, s as ConnectionEvent, t as ConnectionTarget, D as DeviceProfile, $ as DriveGrantActorError, a0 as DriveGrantActorErrorKind, a1 as DriveGrantActorHandle, a2 as DriveGrantActorHandleOptions, a3 as DriveGrantActorRegistry, a4 as DriveGrantClose, a5 as DriveGrantConnectionKey, a6 as DriveGrantDial, a7 as DriveGrantLogicalChannelHandle, a8 as DriveGrantWebRtcState, I as IncomingStream, O as OPENRTC_RUNTIME_POLICY, u as PeerConnectOptions, v as PeerReadiness, w as PeerStreamOptions, P as PlutoRuntimeAssembly, x as PresenceLoopOptions, y as RawConnection, z as RuntimeAuthContext, A as RuntimeAuthIdentity, B as RuntimeAutoConnectPolicy, k as RuntimeChannelDescriptor, a as RuntimeClient, R as RuntimeClientOptions, p as RuntimeConnectionEvent, o as RuntimeConnectionStateSnapshot, b as RuntimeDevice, d as RuntimeDeviceConnectOptions, F as RuntimeDeviceStatus, c as RuntimeDeviceStatusSnapshot, a9 as RuntimeFactoryOptions, m as RuntimeIncomingStream, G as RuntimeJoinRoomOptions, e as RuntimeLocalDeviceInfo, f as RuntimeLocalDeviceProfile, H as RuntimeManagedSession, J as RuntimeManagedSessionKind, K as RuntimeManagedSessionOptions, L as RuntimeManagedSessionPlatform, h as RuntimePeerConnectOptions, j as RuntimePeerHealth, M as RuntimePeerLifecycleStatus, i as RuntimePeerReadinessSnapshot, N as RuntimePeerScope, Q as RuntimePeerSessionSnapshot, g as RuntimePeerState, l as RuntimePeerStreamOptions, n as RuntimePolicySnapshot, S as RuntimePresenceLoopOptions, T as RuntimePresencePolicy, U as RuntimeRoomMember, V as RuntimeSession, W as RuntimeUiConnectionStatus, $ as ScopedConnectionActorError, a0 as ScopedConnectionActorErrorKind, a1 as ScopedConnectionActorHandle, a2 as ScopedConnectionActorHandleOptions, a3 as ScopedConnectionActorRegistry, a4 as ScopedConnectionClose, a6 as ScopedConnectionDial, a5 as ScopedConnectionKey, a7 as ScopedLogicalChannelHandle, a8 as ScopedWebRtcState, aa as Session, ab as SessionOptions, ac as createIpcClient, ad as createWasmClient, ae as driveGrantConnectionKey, af as driveGrantConnectionKeyToString, _ as getRuntimePolicy, ae as scopedConnectionKey, af as scopedConnectionKeyToString } from '../factories-0TxDPMeu.js';
-import { y as SignalingOptions, w as ISignalingBackend, o as RuntimeIdentity, z as SignalingEnvelope, n as SignalingSession, m as Device, B as BackendConnectionState, J as JoinRoomOptions, s as RoomMember, d as AppLimits, F as RoomCreationMode, k as ClientOptions, f as DiscoveryMode, h as ProtocolCapabilityMap, H as ScanningLoopOptions, K as ScanningLoopHandle, a as ConnectDeviceHooks, b as ConnectDeviceOptions, C as ConnectDeviceResult, O as RuntimeBootstrapOptions, Q as RuntimeBootstrapResult, q as PeerState, t as PeerScope, r as PeerHealth, G as GrantScope, I as IncomingStreamChannelMetadata, l as ChannelDescriptor, T as JoinRequest, N as NativeConnectResult } from '../DelegatingRuntimeAdapter-CW8d78dZ.js';
-export { U as BROWSER_WASM_RUNTIME_CAPABILITIES, V as NATIVE_IPC_RUNTIME_CAPABILITIES, j as RuntimeAdapterKind, c as RuntimeCapabilities, X as cloneRuntimeCapabilities } from '../DelegatingRuntimeAdapter-CW8d78dZ.js';
+import { C as Connection, P as PeerReconciliationStats, Q as RuntimeConnectionTarget, y as RuntimeRawConnection } from '../framing-lxzHEuSr.js';
+export { z as ChannelDescriptor, A as ConnectionEvent, B as ConnectionTarget, D as DeviceProfile, E as IncomingStream, O as OPENRTC_RUNTIME_POLICY, F as PeerConnectOptions, G as PeerReadiness, H as PeerStreamOptions, x as PlutoRuntimeAssembly, J as PresenceLoopOptions, K as RawConnection, v as RuntimeApplicationPayloadReadinessOptions, L as RuntimeAuthContext, M as RuntimeAuthIdentity, N as RuntimeAutoConnectPolicy, m as RuntimeChannelDescriptor, a as RuntimeClient, R as RuntimeClientOptions, w as RuntimeConnectionEvent, u as RuntimeConnectionStateSnapshot, d as RuntimeDevice, aj as RuntimeDeviceActiveOptions, f as RuntimeDeviceConnectOptions, S as RuntimeDevicePresenceStatus, T as RuntimeDeviceStatus, e as RuntimeDeviceStatusSnapshot, ak as RuntimeFactoryOptions, o as RuntimeIncomingStream, r as RuntimeJoinRoomOptions, al as RuntimeJsonFrameDecoderOptions, U as RuntimeJsonFrameHandler, g as RuntimeLocalDeviceInfo, h as RuntimeLocalDeviceProfile, V as RuntimeLogicalChannelFraming, c as RuntimeManagedSession, W as RuntimeManagedSessionKind, b as RuntimeManagedSessionOptions, X as RuntimeManagedSessionPlatform, j as RuntimePeerConnectOptions, l as RuntimePeerHealth, Y as RuntimePeerLifecycleStatus, k as RuntimePeerReadinessSnapshot, Z as RuntimePeerScope, _ as RuntimePeerSessionSnapshot, i as RuntimePeerState, n as RuntimePeerStreamOptions, t as RuntimePolicySnapshot, $ as RuntimePresenceLoopOptions, a0 as RuntimePresencePolicy, s as RuntimeRoomMember, p as RuntimeScopedChannelOptions, q as RuntimeScopedLogicalChannel, a1 as RuntimeSession, a2 as RuntimeU32BEFrameHandler, a3 as RuntimeUiConnectionStatus, a4 as ScopedChannelOptions, am as ScopedConnectionActorError, an as ScopedConnectionActorErrorKind, ao as ScopedConnectionActorHandle, ap as ScopedConnectionActorHandleOptions, aq as ScopedConnectionActorRegistry, ar as ScopedConnectionActorState, as as ScopedConnectionClose, at as ScopedConnectionDial, au as ScopedConnectionKey, a5 as ScopedLogicalChannel, av as ScopedLogicalChannelHandle, aw as ScopedPreferredTransport, ax as Session, ay as SessionOptions, az as concatRuntimeBytes, aA as createIpcClient, a9 as createRuntimeJsonFrameDecoder, aa as createRuntimeU32BEFrameDecoder, aB as createWasmClient, ab as decodeRuntimeJsonPayload, ac as encodeRuntimeJsonFrame, ad as encodeRuntimeJsonPayload, ae as encodeRuntimeU32BEFrame, af as getRuntimePolicy, ag as isRuntimeDeviceActive, ah as isRuntimeDeviceConnectable, ai as isRuntimeDeviceRoutable, aC as readRuntimeU32BE, aD as scopedConnectionKey, aE as scopedConnectionKeyToString } from '../framing-lxzHEuSr.js';
+import { K as SignalingOptions, I as ISignalingBackend, R as RuntimeIdentity, d as SignalingEnvelope, f as SignalingSession, a as Device, j as BackendConnectionState, t as AppLimits, O as JoinRoomOptions, Q as RoomMember, T as IncomingStreamChannelMetadata, r as ApplicationCryptoStreamTools, U as RoomCreationMode, C as ClientOptions, q as ApplicationPayloadCrypto, D as DiscoveryMode, p as ProtocolCapabilityMap, V as ScanningLoopOptions, W as ScanningLoopHandle, l as ConnectDeviceHooks, m as ConnectDeviceOptions, k as ConnectDeviceResult, X as RuntimeBootstrapOptions, Y as RuntimeBootstrapResult, v as ApplicationPayloadReadinessOptions, Z as PeerState, _ as PeerScope, $ as PeerHealth, G as GrantScope, a0 as ChannelDescriptor, a1 as JoinRequest, i as NativeConnectResult } from '../types-D0fRvUbN.js';
 import { FirebaseApp } from 'firebase/app';
-export { I as IpcRuntimeAdapter, a as IpcRuntimeAdapterOptions, P as NativeBridge, P as PlutoIpcBridge, b as PlutoIpcUnlisten } from '../IpcRuntimeAdapter-CT-W0Mtp.js';
+import { R as RuntimeCapabilities } from '../DelegatingRuntimeAdapter-BxOcVIx_.js';
+export { B as BROWSER_WASM_RUNTIME_CAPABILITIES, N as NATIVE_IPC_RUNTIME_CAPABILITIES, c as NativeRuntimeStatusSnapshot, d as NativeRuntimeTransportFeatureStatus, b as RuntimeAdapterKind, a as RuntimeCapabilityProfile, e as cloneRuntimeCapabilities, r as runtimeCapabilitiesFromNativeStatus, f as runtimeCapabilityProfile } from '../DelegatingRuntimeAdapter-BxOcVIx_.js';
+export { I as IpcRuntimeAdapter, a as IpcRuntimeAdapterOptions, P as NativeBridge, b as NativeIpcFailureKind, P as PlutoIpcBridge, c as PlutoIpcUnlisten, d as classifyNativeIpcFailure, i as isNativeIpcCommandUnavailable } from '../IpcRuntimeAdapter-U5AEH0jn.js';
 export { WasmRuntimeAdapter } from './WasmRuntimeAdapter.js';
 export { TauriRuntimeAdapter, TauriRuntimeAdapterOptions, createTauriIpcBridge } from './tauri.js';
 
@@ -13,13 +14,19 @@ export { TauriRuntimeAdapter, TauriRuntimeAdapterOptions, createTauriIpcBridge }
  * Replaces the 60-second Firestore heartbeat loop with Firebase Realtime
  * Database `onDisconnect` hooks. When a client disconnects (tab close,
  * crash, network loss), the RTDB server automatically writes the offline
- * state — no cleanup polling needed.
+ * state. A shared `.info/connected` listener republishes desired online state
+ * after WebSocket reconnects, and server cleanup compacts old offline nodes.
  *
  * RTDB paths mirror the Firestore device collection paths:
  *
- *   personal/spaceKey  → presence/spaces/{namespaceId}/devices/{deviceId}
+ *   space/spaceKey     → presence/spaces/{namespaceId}/devices/{deviceId}
  *   user-scoped        → presence/{appTag}/users/{userId}/devices/{deviceId}
  *
+ * Space RTDB paths require scoped Firebase auth
+ * (`namespaceId` or `space::{namespaceId}` appTag claim). The browser bridge
+ * skips space RTDB until such auth is available and uses Firestore as the
+ * compatibility fallback.
+ *
  * Ticket version invalidation:
  *   Each presence node stores a `ticketVersion` integer. WasmBridge bumps it
  *   whenever it writes a new Firestore ticket (network change, reconnect).
@@ -32,6 +39,10 @@ export { TauriRuntimeAdapter, TauriRuntimeAdapterOptions, createTauriIpcBridge }
 interface RtdbDevicePresence {
     online: boolean;
     ticketVersion: number;
+    ticket?: string;
+    nodeId?: string;
+    deviceName?: string;
+    metadata?: string;
 }
 type RtdbPresenceMap = Record<string, RtdbDevicePresence>;
 type DiscoveryPresenceScope = {
@@ -39,16 +50,30 @@ type DiscoveryPresenceScope = {
     appTag: string;
     userId: string;
 } | {
-    kind: 'personal';
+    kind: 'space';
     namespaceId: string;
 };
+interface RtdbPresenceRosterFields {
+    ticket?: string;
+    nodeId?: string;
+    deviceName?: string;
+    metadata?: string;
+}
 interface RtdbMemberPresence {
     online: boolean;
 }
 type RtdbRoomPresenceMap = Record<string, RtdbMemberPresence>;
 declare class RtdbPresence {
     private readonly db;
+    private readonly desiredOnlineNodes;
+    private connected;
+    private connectedUnsubscribe;
     constructor(app: FirebaseApp);
+    private ensureReconnectWatch;
+    private publishDesiredOnline;
+    private registerOnlineNode;
+    private markNodeOffline;
+    private subscribeIncremental;
     /**
      * Register this device as online in RTDB and set an onDisconnect handler
      * so the server marks it offline automatically on connection loss.
@@ -57,13 +82,13 @@ declare class RtdbPresence {
      * written. Does not replace the Firestore device doc — that remains the
      * source of truth for the connection ticket and metadata.
      */
-    registerDevice(scope: DiscoveryPresenceScope, deviceId: string, ticketVersion?: number): Promise<void>;
+    registerDevice(scope: DiscoveryPresenceScope, deviceId: string, ticketVersion?: number, fields?: RtdbPresenceRosterFields): Promise<void>;
     /**
      * Bump the ticketVersion for a device. Call this whenever a new Firestore
      * ticket is written (e.g. on network change / node restart). Subscribers
      * will see the version change and re-fetch the Firestore doc.
      */
-    bumpTicketVersion(scope: DiscoveryPresenceScope, deviceId: string, newVersion: number): Promise<void>;
+    bumpTicketVersion(scope: DiscoveryPresenceScope, deviceId: string, newVersion: number, fields?: RtdbPresenceRosterFields): Promise<void>;
     /**
      * Explicitly mark a device offline (graceful disconnect / sign-out).
      * The onDisconnect handler would eventually fire anyway, but calling this
@@ -72,7 +97,7 @@ declare class RtdbPresence {
     markOffline(scope: DiscoveryPresenceScope, deviceId: string, ticketVersion?: number): Promise<void>;
     /**
      * Register a room member as online and set an onDisconnect handler.
-     * Called immediately after the Firestore member doc is written (join).
+     * Managed/user-scoped room writes require roomPresenceAcl writer grants.
      */
     registerRoomMember(appTag: string, roomId: string, memberId: string): Promise<void>;
     /**
@@ -94,15 +119,13 @@ declare class RtdbPresence {
      * Subscribe to all device presence states in a discovery scope.
      *
      * Returns an unsubscribe function. The callback receives the full map of
-     * deviceId → { online, ticketVersion } whenever any device's presence
-     * changes. This replaces the `onSnapshot` on the Firestore device
-     * collection for the online/offline boolean overlay.
-     *
-     * The Firestore device collection remains as the source of truth for
-     * connection tickets and metadata; RTDB is only used for the live
-     * online boolean and ticket invalidation signal.
+     * deviceId -> { online, ticketVersion, ...roster fields } whenever any
+     * device's presence changes. Firestore remains the durable roster; RTDB
+     * carries enough fields to keep discovery usable during short Firestore
+     * offline windows.
      */
     onPresenceChange(scope: DiscoveryPresenceScope, callback: (presenceMap: RtdbPresenceMap) => void): () => void;
+    readPresenceMap(scope: DiscoveryPresenceScope): Promise<RtdbPresenceMap>;
 }
 
 declare class Signaling {
@@ -112,18 +135,20 @@ declare class Signaling {
     get tag(): string;
     waitForAuth(): Promise<void>;
     get currentUser(): RuntimeIdentity | null;
+    getRtdbPresence(): RtdbPresence | null;
     onAuthChange(callback: (user: RuntimeIdentity | null) => void): () => void;
     signInAnonymously(): Promise<void>;
     signInWithPluto(): Promise<void>;
     signOut(): Promise<void>;
     stopAuthScopedActivity(): Promise<void>;
+    getRuntimeCapabilities(): RuntimeCapabilities | undefined;
     getTurnCredentials(): Promise<any>;
     updatePresence(localNodeId: string, ticketStr: string, isOnline?: boolean, ttlMs?: number, metadata?: string): Promise<void>;
     setOffline(localNodeId: string): Promise<void>;
     cleanupStaleDevices(): Promise<void>;
     sendMessage(targetId: string, payload: string, state?: string, replyPayload?: string): Promise<string>;
     pollMessages(targetId: string): Promise<SignalingEnvelope[]>;
-    subscribeSessions(localDeviceId: string, callback: (session: SignalingSession) => void): Promise<() => void>;
+    subscribeSessions(localDeviceId: string, callback: (session: SignalingSession) => void | Promise<void>): Promise<() => void>;
     getLocalDeviceId(): Promise<string | null>;
     searchDevices(excludeNodeId?: string): Promise<Device[]>;
     updateDevice(deviceId: string, updates: {
@@ -144,70 +169,26 @@ declare class Signaling {
     setWasmClient(client: any): void;
 }
 
-declare class RoomManager {
-    private signaling;
-    private client;
-    private readonly heartbeatStops;
-    private browserRooms;
-    private rtdbPresence;
-    constructor(client: Client, signaling: Signaling);
-    private getBrowserRooms;
-    /**
-     * Phase 2: called by the runtime after RTDB presence is initialised
-     * (same RtdbPresence instance used for device presence in Phase 1).
-     */
-    setRtdbPresence(rtdbPresence: RtdbPresence): void;
-    private usesDirectRoomBackend;
-    private get roomBackendTag();
-    private get appTag();
-    private invokeRoomCallable;
-    private isAlreadyExistsError;
-    private getMembersInternal;
-    private parseMemberDocuments;
-    private parseRoomMemberDocument;
-    /**
-     * Creates a new room. When `requestedRoomId` is provided, the backend will
-     * try to create that exact room ID instead of generating a random one.
-     */
-    createRoom(requestedRoomId?: string): Promise<string>;
-    /**
-     * Joins a room by ID.
-     */
-    joinRoom(roomId: string, options?: JoinRoomOptions): Promise<Connection[]>;
-    leaveRoom(roomId: string): Promise<void>;
-    getRoomMembers(roomId: string): Promise<RoomMember[]>;
-    watchRoom(roomId: string, callback: (members: RoomMember[]) => void): () => void;
-    /**
-     * Register this device as an online room member in RTDB and store a
-     * cleanup callback in heartbeatStops (keyed by roomId) so that
-     * stopHeartbeat() / leaveRoom() can trigger graceful offline marking.
-     */
-    private registerRtdbRoomMember;
-    private markRtdbRoomMemberOffline;
-    private startLegacyHeartbeat;
-    stopHeartbeat(roomId?: string): void;
+interface MoQSubscriberOptions {
+    maxPendingSubscriptions?: number;
+    maxSubscribeRetries?: number;
+    subscribeRetryDelayMs?: number;
+    maxBufferedGroupsPerTrack?: number;
+    maxBufferedFramesPerGroup?: number;
+    maxBufferedBytesPerTrack?: number;
+    maxObjectPayloadBytes?: number;
 }
-
-declare class MoQPublisher {
-    private session;
-    private tracks;
-    private activePublishers;
-    constructor(session: MoQSession);
-    private pendingAnnounces;
-    announce(namespace: string): Promise<void>;
-    onAnnounceResult(namespace: string, error?: {
-        code: number;
-        reason: string;
-    }): void;
-    onSubscribe(msg: any): void;
-    onUnsubscribe(subscribeId: number): void;
-    createTrack(namespace: string, name: string): Promise<any>;
-}
-
 declare class MoQSubscriber {
     private session;
+    private readonly maxPendingSubscriptions;
+    private readonly maxSubscribeRetries;
+    private readonly subscribeRetryDelayMs;
+    private readonly maxBufferedGroupsPerTrack;
+    private readonly maxBufferedFramesPerGroup;
+    private readonly maxBufferedBytesPerTrack;
+    private readonly maxObjectPayloadBytes;
     private onObject;
-    constructor(session: MoQSession, onObject: (ns: string, name: string, obj: Uint8Array, meta: any) => void);
+    constructor(session: MoQSession, onObject: (ns: string, name: string, obj: Uint8Array, meta: any) => void, options?: MoQSubscriberOptions);
     private aliasMap;
     private nextAlias;
     private nextSubscribeId;
@@ -266,6 +247,109 @@ declare class MoQSession {
     private handleControlMessage;
 }
 
+interface MoQPublisherOptions {
+    maxPendingAnnounces?: number;
+    announceTimeoutMs?: number;
+    maxSubscribedTracks?: number;
+    maxActivePublishers?: number;
+    maxTrackIdChars?: number;
+}
+declare class MoQPublisher {
+    private session;
+    private tracks;
+    private activePublishers;
+    private readonly maxPendingAnnounces;
+    private readonly announceTimeoutMs;
+    private readonly maxSubscribedTracks;
+    private readonly maxActivePublishers;
+    private readonly maxTrackIdChars;
+    constructor(session: MoQSession, options?: MoQPublisherOptions);
+    private pendingAnnounces;
+    announce(namespace: string): Promise<void>;
+    onAnnounceResult(namespace: string, error?: {
+        code: number;
+        reason: string;
+    }): void;
+    onSubscribe(msg: any): void;
+    onUnsubscribe(subscribeId: number): void;
+    hasTrackSubscriber(namespace: string, name: string): boolean;
+    createTrack(namespace: string, name: string): Promise<any>;
+    private resolveTrackId;
+}
+
+/**
+ * Browser MoQ session controller.
+ *
+ * Owns the WebTransport-backed MoQ relay session, reconnect state, peer
+ * subscriptions, and direct MoQ data helpers. `Client` remains the facade so
+ * existing SDK calls and test spies keep working while MoQ stops contributing
+ * more lifecycle state to the god object.
+ */
+
+type MoQBundle = {
+    session: MoQSession;
+    publisher: MoQPublisher;
+    subscriber: MoQSubscriber;
+};
+
+interface RoomClientHost {
+    wasmClient: any;
+    roomCreationMode: 'client-open' | 'client-auth' | 'server-only';
+    appLimits: AppLimits;
+    ensureAuthenticated(reason: 'room-op'): Promise<void>;
+    getTicket(): Promise<string>;
+    getNodeId(): Promise<string>;
+    connect(ticket: string, timeoutMs?: number): Promise<Connection>;
+    refreshHostedAppSettings(force?: boolean): Promise<void>;
+    usesDirectRoomBackend(): boolean;
+    getRoomBackendTag(): string;
+}
+declare class RoomManager {
+    private signaling;
+    private client;
+    private readonly heartbeatStops;
+    private browserRooms;
+    private rtdbPresence;
+    constructor(client: RoomClientHost, signaling: Signaling);
+    private getBrowserRooms;
+    /**
+     * Phase 2: called by the runtime after RTDB presence is initialised
+     * (same RtdbPresence instance used for device presence in Phase 1).
+     */
+    setRtdbPresence(rtdbPresence: RtdbPresence): void;
+    private syncRtdbPresenceFromSignaling;
+    private usesDirectRoomBackend;
+    private get roomBackendTag();
+    private resolveRoomUserId;
+    private get appTag();
+    private invokeRoomCallable;
+    private isAlreadyExistsError;
+    private normalizeRoomId;
+    private getMembersInternal;
+    private parseMemberDocuments;
+    private parseRoomMemberDocument;
+    /**
+     * Creates a new room. When `requestedRoomId` is provided, the backend will
+     * try to create that exact room ID instead of generating a random one.
+     */
+    createRoom(requestedRoomId?: string): Promise<string>;
+    /**
+     * Joins a room by ID.
+     */
+    joinRoom(roomId: string, options?: JoinRoomOptions): Promise<Connection[]>;
+    leaveRoom(roomId: string): Promise<void>;
+    getRoomMembers(roomId: string): Promise<RoomMember[]>;
+    watchRoom(roomId: string, callback: (members: RoomMember[]) => void): () => void;
+    /**
+     * Register this device as an online room member in RTDB and store a
+     * cleanup callback in heartbeatStops (keyed by roomId) so that
+     * stopHeartbeat() / leaveRoom() can trigger graceful offline marking.
+     */
+    private registerRtdbRoomMember;
+    private markRtdbRoomMemberOffline;
+    stopHeartbeat(roomId?: string): void;
+}
+
 type IncomingProtocolHint = 'control' | 'explicit' | 'native-main' | 'unknown';
 type IncomingStreamListenerEvent = {
     type: 'bi' | 'uni';
@@ -274,131 +358,49 @@ type IncomingStreamListenerEvent = {
     traceId?: string;
     protocolHint?: IncomingProtocolHint;
     channel?: IncomingStreamChannelMetadata | null;
+    applicationCrypto?: ApplicationCryptoStreamTools;
     invalid?: boolean;
 };
 
 declare class Client {
-    private static readonly CHANNEL_ENVELOPE_MAGIC;
-    private static readonly CHANNEL_ENVELOPE_VERSION;
-    private static readonly CHANNEL_ENVELOPE_HEADER_BYTES;
-    private static readonly EXPLICIT_PROTOCOL_BYTE;
-    private static readonly NATIVE_MAIN_PROTOCOL_BYTE;
-    private static readonly NATIVE_MAIN_LABEL;
-    private static readonly NATIVE_MAIN_MAX_LABEL_BYTES;
-    private static readonly NATIVE_MAIN_MAX_FRAME_BYTES;
-    private static readonly NATIVE_MAIN_PROTOCOL_VERSION;
-    private static readonly CONNECTION_STATE_CHANGED_EVENT;
-    private static readonly NATIVE_MAIN_MESSAGE_EVENT;
-    private static readonly INCOMING_STREAM_RETRY_MIN_DELAY_MS;
-    private static readonly INCOMING_STREAM_RETRY_MAX_DELAY_MS;
-    private static readonly DEFAULT_PEER_CHANNEL_ID;
-    private static readonly SHARE_FILE_CHANNEL_ID;
-    private static readonly SHARE_CONTROL_CHANNEL_ID;
-    private static readonly incomingStreamHubs;
     signaling: Signaling;
     rooms: RoomManager;
-    private wasmLoaded;
-    wasmClient: any;
-    private initPromise;
-    node: any;
-    private connections;
-    private connectionListeners;
-    private disconnectionListeners;
-    private messageListeners;
-    private roomRequestListeners;
-    private streamListeners;
-    private readonly channelStreamListeners;
-    private readonly registeredChannels;
-    private announcedConnections;
-    private readonly peerLifecycle;
-    private readonly peerLifecycleClient;
-    private readonly knownDevicesById;
-    private readonly knownDeviceIdsByNodeId;
-    private readonly connectionTrustStates;
-    private readonly connectionChannelIds;
-    private readonly pendingSessionTokenTrustApprovals;
-    /** Tracks the last rejection timestamp per remote node to debounce repeated stale-token retries. */
-    private readonly sessionTokenRejectionCooldowns;
-    /** Tracks the last trust-failure timestamp per remote node to suppress rapid connection-rebuild storms. */
-    private readonly trustFailureCooldowns;
-    /** Nodes that have passed at least one session-token approval — exempt from trust-failure cooldown. */
-    private readonly sessionTokenApprovedNodes;
-    /** Connection IDs that have been explicitly approved via session-token admission. */
-    private readonly sessionTokenApprovedConnectionIds;
-    /** Most recent inbound native-main BiStream writer per remote node (desktop -> web). */
-    private readonly inboundNativeMainWriters;
-    /** Per-node write mutex for inbound native-main writers. */
-    private readonly inboundNativeMainWriteMutex;
-    /** Lifecycle metadata for inbound native-main writers to debug stale-writer routing. */
-    private readonly inboundNativeMainWriterMeta;
-    /** Per-node cooldown to bypass missing/stale inbound writer probes. */
-    private readonly inboundNativeMainBypassUntilMs;
-    private inboundNativeMainWriterSeq;
-    private managedPresenceGrant;
-    /** Token extracted from a compound ticket during connect(), keyed by remote node ID. */
-    private readonly pendingTokenByNodeId;
-    private readonly pendingNativeMainConnections;
-    private readonly webrtcIncomingExplicitTransfers;
-    private localNodeId;
-    private listening;
-    private listenLoopTask;
+    private _services?;
     private options;
     private readonly runtimeSafetyProfile;
     appLimits: AppLimits;
-    private pendingConnection;
-    private incomingTraceSequence;
-    private browserBackgrounded;
-    private authSyncUnsubscribe;
-    private backendConnectionStateUnsubscribe;
-    private authRefreshInterval;
-    private deviceId;
-    private lastWasmAuthSyncUserId;
-    private lastWasmAuthSyncToken;
-    private loggedNativeDiscoveryWasmSkip;
-    private static readonly CONNECTION_STABLE_WINDOW_MS;
-    private static readonly CONNECTION_STABLE_TIMEOUT_MS;
-    private static readonly CONNECTION_STABLE_POLL_MS;
-    private static readonly SESSION_TOKEN_TRUST_APPROVAL_TTL_MS;
-    private static readonly SESSION_TOKEN_UNKNOWN_RETRY_ATTEMPTS;
-    private static readonly SESSION_TOKEN_UNKNOWN_RETRY_DELAY_MS;
-    /** How long to suppress new Connection objects for a node after a trust failure (ms). */
-    private static readonly TRUST_FAILURE_COOLDOWN_MS;
-    private static readonly INBOUND_WRITER_RETRY_COOLDOWN_MS;
-    private static readonly MOQ_RECONNECT_INITIAL_DELAY_MS;
-    private static readonly MOQ_RECONNECT_MAX_DELAY_MS;
-    private presenceInterval;
-    private hostedAppSettingsLoaded;
     private effectiveRoomBackendTag;
-    private _moqSession;
-    private _moqState;
-    private moqReadyListeners;
-    private moqFailedListeners;
-    private moqObjectListeners;
-    private moqReconnectTimer;
-    private moqReconnectAttempts;
-    private readonly moqPeerSubscriptions;
     roomCreationMode: RoomCreationMode;
     constructor(options: ClientOptions);
-    private sleep;
-    private installAppLifecycleListeners;
-    private handleAppBackgroundState;
-    private reconcileConnectionsAfterForeground;
+    private get services();
+    private createServiceGraph;
+    get wasmClient(): any;
+    set wasmClient(client: any);
+    get node(): any;
+    set node(node: any);
+    attachIncomingStreamSource(source: unknown, localNodeId: string): void;
+    getApplicationCrypto(connection?: Connection): ApplicationPayloadCrypto | undefined;
+    resolveApplicationCryptoForPeer(peerId?: string, connection?: Connection): ApplicationPayloadCrypto | undefined;
+    waitForApplicationCryptoForPeer(peerId?: string, timeoutMs?: number): Promise<ApplicationPayloadCrypto | undefined>;
+    destroy(): void;
+    dispose(): void;
     get apiKey(): string | undefined;
     get discoveryMode(): DiscoveryMode;
-    private usesTicketOnlySignalingMode;
     usesDirectRoomBackend(): boolean;
     getRoomBackendTag(): string;
     refreshHostedAppSettings(force?: boolean): Promise<void>;
     setSignalingBackend(backend: ISignalingBackend): void;
-    get currentUser(): RuntimeIdentity | null;
+    get currentUser(): any;
     onAuthChange(callback: (user: any) => void): () => void;
-    signInAnonymously(): Promise<void>;
-    signInWithPluto(): Promise<void>;
-    signOut(): Promise<void>;
+    signInAnonymously(): Promise<unknown>;
+    signInWithPluto(): Promise<unknown>;
+    signOut(): Promise<unknown>;
     getSignalingTelemetry(): {
         transport: string;
         wasmLoaded: boolean;
+        peerReconciliation: Readonly<PeerReconciliationStats>;
     };
+    getPeerReconciliationStats(): Readonly<PeerReconciliationStats>;
     getProtocolCapabilities(): ProtocolCapabilityMap;
     getRuntimeStatus(): Promise<{
         runtime: 'tauri' | 'browser' | 'unknown';
@@ -406,36 +408,6 @@ declare class Client {
         localNodeId?: string;
         userId?: string;
     }>;
-    private ensureWasmRuntimeForP2P;
-    private usesNativeIpcRuntimeWithoutWasmFallback;
-    private nativeWasmInitForbiddenError;
-    private ensureSignalingReadyForDiscovery;
-    private requiresManagedTransportTrust;
-    private getRegisteredChannel;
-    private isChannelPromotionEligible;
-    private isTransportOnlyChannel;
-    private getConnectionChannelId;
-    private isTransportOnlyConnectionId;
-    private resolvePromotionEligibility;
-    private assignConnectionChannel;
-    private rememberKnownDevice;
-    private getKnownDevice;
-    private refreshKnownDeviceCache;
-    private initializeConnectionTrust;
-    private consumePendingSessionTokenTrustApproval;
-    private applySessionTokenTrustApproval;
-    private getConnectionTrustState;
-    private getConnectionTrustProjection;
-    private applyConnectionTrustProjection;
-    private getConnectionTransportProjectionState;
-    private buildLocalTransportTrustPayload;
-    private sendTransportHandshake;
-    private broadcastTransportCapabilityUpdate;
-    private verifyRemoteTransportTrust;
-    private enforceConnectionTrustFailure;
-    private markConnectionTrustVerified;
-    private bindConnectionDeviceIdInRust;
-    private retireSupersededConnections;
     searchDevices(): Promise<Device[]>;
     updateDevice(deviceId: string, updates: {
         deviceName?: string;
@@ -444,53 +416,31 @@ declare class Client {
     }): Promise<void>;
     deleteDevice(deviceId: string): Promise<void>;
     cleanupStaleDevices(): Promise<void>;
-    onDevicesChange(callback: any): () => void;
-    subscribeSessions(localDeviceId: string, callback: (session: SignalingSession) => void): Promise<() => void>;
+    onDevicesChange(callback: (devices: Device[]) => void): () => void;
+    subscribeSessions(localDeviceId: string, callback: (session: SignalingSession) => void | Promise<void>): Promise<() => void>;
     startScanningLoop(options: ScanningLoopOptions): Promise<ScanningLoopHandle>;
     connectDeviceWithRetry(device: Device, hooks: ConnectDeviceHooks, options: ConnectDeviceOptions): Promise<ConnectDeviceResult>;
     bootstrapRuntime(options: RuntimeBootstrapOptions): Promise<RuntimeBootstrapResult>;
     updateTransportConfig(transports: ClientOptions['transports']): void;
-    private getTurnCredentialsForTransportConfig;
-    /**
-     * Bootstraps the WASM module and Rust signaling.
-     * Must be called before connect or createRoom.
-     */
     init(): Promise<void>;
     ensureAuthenticated(reason: 'init' | 'room-op' | 'discovery'): Promise<void>;
-    private installAuthTokenSync;
-    private syncAuthTokenToWasm;
-    get moqState(): "none" | "failed" | "connecting" | "ready";
-    get moq(): {
-        session: MoQSession;
-        publisher: MoQPublisher;
-        subscriber: MoQSubscriber;
-    } | null;
-    onMoQReady(cb: () => void): void;
-    onMoQFailed(cb: () => void): void;
-    onMoQObject(callback: (ns: string, name: string, obj: Uint8Array, meta: any) => void): void;
-    private clearMoQReconnectTimer;
-    private closeMoQSession;
-    private handleMoQSessionClosed;
-    private scheduleMoQReconnect;
-    private enableMoQForConnection;
-    private subscribeMoQPeer;
-    private resubscribeMoQPeers;
-    private initMoQ;
-    connect(ticket: string, timeoutMs?: number, expectedDeviceId?: string | null, channelId?: string): Promise<Connection>;
-    /**
-     * Low-level dial helper.
-     * Ensures the ticket is connected and returns only connection identity metadata.
-     */
+    refreshRuntimeAuthToken(reason?: 'runtime-start' | 'managed-session'): Promise<void>;
+    get moqState(): string;
+    get moq(): MoQBundle | null;
+    onMoQReady(cb: () => void): () => void;
+    onMoQFailed(cb: () => void): () => void;
+    onMoQObject(callback: (ns: string, name: string, obj: Uint8Array, meta: any) => void): () => void;
+    subscribeMoQPeer(connection: Connection): void;
+    subscribeMoQPeerNode(peerId: string, subscriptionKey?: string): void;
+    connect(ticket: string, timeoutMs?: number, expectedDeviceId?: string | null, channelId?: string, options?: {
+        admissionAlreadyPresented?: boolean;
+        approvedScope?: string | null;
+    }): Promise<Connection>;
     connectRaw(ticket: string, timeoutMs?: number): Promise<{
         connectionId: string;
         localNodeId: string;
         remoteNodeId: string;
     }>;
-    /**
-     * Start core-managed auto-connect for the authenticated user.
-     * This is intentionally low-level: callers decide when to start/stop and
-     * what higher-level protocol to run on top of the resulting connection.
-     */
     startAutoConnect(localDeviceId?: string): Promise<void>;
     openBi(peerId: string): Promise<{
         readable: ReadableStream<Uint8Array>;
@@ -498,7 +448,9 @@ declare class Client {
     }>;
     openUni(peerId: string): Promise<WritableStream<Uint8Array>>;
     getConnections(): Connection[];
+    getApplicationReadyConnections(options?: ApplicationPayloadReadinessOptions): Connection[];
     getConnectionForPeer(connectionId?: string, remoteNodeId?: string): Connection | null;
+    hasApplicationRouteForPeer(connectionId?: string, remoteNodeId?: string): boolean;
     watchPeerStates(callback: (peers: PeerState[]) => void): () => void;
     getPeerState(id: string): PeerState | undefined;
     listConnectedPeers(): PeerState[];
@@ -518,169 +470,39 @@ declare class Client {
         ticket?: string;
         scope?: PeerScope;
         channelId?: string;
+        respectManualDisconnect?: boolean;
     }): Promise<Connection>;
     clearManualDisconnectProjection(id: string): void;
     disconnectPeer(id: string, scope?: PeerScope): Promise<void>;
     forceDisconnectPeer(id: string): Promise<void>;
     getPeerHealth(id: string): Promise<PeerHealth>;
-    private mapRustPeerStatus;
-    private mapRustPeerHealth;
     getTicket(): Promise<string>;
     getNodeId(): Promise<string>;
     getNodeIdFromTicket(ticket: string): Promise<string | null>;
-    /**
-     * Generate a random session token, register it, and return a compound
-     * ticket string with the token suffix appended.
-     *
-     * @param grantScope Admission-grant label (e.g. "share"). Used for bulk revoke in Rust.
-     *                   This is distinct from `PeerScope`, which only tracks local peer lifecycle.
-     * @param maxConnections  0 = unlimited.
-     */
     getEndpointTicketWithToken(grantScope: GrantScope, maxConnections?: number): Promise<string>;
-    /**
-     * Build a compound ticket from an externally-provided iroh ticket string.
-     * Generates a session token, registers it with the Rust wasm client when available,
-     * and appends the token
-     * payload as a base64url suffix separated by `.`.
-     *
-     * Used by RuntimeClient.getTicketWithToken() on native desktop where the
-     * iroh ticket comes from the Rust backend (via Tauri IPC) rather than the
-     * WASM node running in the webview.
-     */
     buildCompoundTicketWithToken(irohTicket: string, grantScope: GrantScope, maxConnections?: number): string;
     setManagedPresenceTicket(ticket: string | null): void;
     clearManagedPresenceTicket(): void;
-    /** Register an externally-generated session token with the Rust wasm client. */
     registerSessionToken(token: string, grantScope: GrantScope, maxConnections: number): void;
-    /** Revoke a specific session token. */
     revokeSessionToken(token: string): void;
-    /** Revoke all tokens that match the given scope. */
     revokeTokensByScope(grantScope: GrantScope): Promise<string[]>;
-    private static generateSessionToken;
-    private static encodeSessionTokenPayload;
-    private static buildCompoundTicketWithPayload;
     clearSessionTokens(): Promise<void>;
-    private resolvePresenceTicket;
-    private refreshManagedPresenceTicketIfNeeded;
-    private validateIncomingSessionToken;
-    private validateIncomingSessionTokenWithRetry;
-    /**
-     * Start the signaling-backed presence loop owned by the Rust core.
-     * A ticket can be provided explicitly, otherwise the current endpoint ticket is used.
-     */
     startPresenceLoop(options?: {
         deviceName?: string;
         ticket?: string;
         metadata?: string;
     }): Promise<void>;
-    /**
-     * Mark local presence offline in the signaling backend.
-     */
     setOffline(): Promise<void>;
-    /**
-     * Check raw connectivity against a remote node id.
-     */
     isConnected(nodeId: string): Promise<boolean>;
-    /**
-     * Disconnect a remote node from the local connection manager.
-     */
     disconnectNode(nodeId: string): Promise<void>;
     getLocalDeviceId(): Promise<string | null>;
-    /**
-     * Route a raw message received on a native iroh connection through token
-     * validation. Called by RuntimeClient when NativeIpcBridge fires an
-     * `iroh://message` event for an incoming native connection.
-     *
-     * If we have a TS Connection object for this peer (e.g. the client also
-     * called connect()), route through handleMessage. Otherwise, for connections
-     * that were accepted purely by the Rust protocol handler, perform token
-     * validation directly.
-     *
-     * @returns true if the connection should be rejected (caller should disconnect)
-     */
     acceptNativeMessage(connectionId: string | null, remoteNodeId: string | null, msg: any): Promise<boolean>;
-    startListening(): Promise<void>;
+    startListening(options?: {
+        startPresence?: boolean;
+    }): Promise<void>;
     stopListening(): void;
-    private getSharedIncomingStreamHub;
-    private nextIncomingStreamRetryDelayMs;
-    private getRuntimeSafetyProfile;
-    private shouldVerboseIncomingDiagnostics;
-    private shouldUseTransportOnlyChannelConnection;
-    private createTransportOnlyChannelConnection;
-    private shouldInspectIncomingChannelEnvelope;
-    private createTransportContext;
-    private hasTransportOnlyConnectionForRemoteNode;
-    private shouldSkipIncomingBiProbeForRemoteNode;
-    private disconnectNodeTransport;
-    private nextIncomingTraceId;
-    private logIncomingDiagnostic;
-    private awaitConnectEventReady;
-    private safeReleaseReaderLock;
-    /**
-     * Force an immediate presence update and reconnect snapshot.
-     */
     forceReconnectSnapshot(): void;
-    private updatePresenceInternal;
-    private listenLoop;
-    private prependChunkToReadable;
-    private cancelUnhandledIncomingUniStream;
-    private prependBytesToReader;
-    private concatBytes;
-    private encodeChannelEnvelope;
     wrapChannelWritable(writable: WritableStream<Uint8Array>, channelId: string, metadata?: Record<string, unknown> | null): WritableStream<Uint8Array>;
-    private extractIncomingChannelEnvelope;
-    private isBiStreamLike;
-    private materializeIncomingBiStream;
-    private rebuildBiIncomingStream;
-    private classifyBiIncomingStream;
-    private detectNativeMainStream;
-    private resolveLocalHandshakePayload;
-    private getDeterministicConnectionId;
-    private getNativeMainConnectionId;
-    private findManualDisconnectProjectionForNativeNode;
-    private hasKnownConnectionForRemoteNode;
-    private inferTicketFlowBiProtocolHint;
-    private hasRustPeerLifecycleProjection;
-    private shouldProjectNativeMainLifecycle;
-    private emitNativeMainConnectionState;
-    private applyBackendConnectionState;
-    private encodeNativeMainFrame;
-    private dispatchNativeMainMessage;
-    private writeNativeMainMessage;
-    private handleNativeHandshakeRequest;
-    private handleNativeSessionTokenRequest;
-    private isNativeSignalEnvelope;
-    private buildNativeMainPayload;
-    private buildFramedMessage;
-    private buildNativeMainLabelHeader;
-    private writeNativeMainLabelHeaderOnBiStream;
-    private registerInboundNativeMainWriter;
-    private clearInboundNativeMainWriter;
-    private sendNativeSignalViaInboundControlStream;
-    private sendNativeSignalViaDedicatedStream;
-    private sendNativeSignalEnvelope;
-    private ensureIncomingConnectionForRemoteNode;
-    private handleNativeMainStream;
-    private tryExtractNativeMainPayload;
-    private isCoreConnectionHealthy;
-    private waitForStableConnection;
-    private announceConnectionWhenStable;
-    private normalizeIncomingStreamEvent;
-    private hasIncomingChannelListener;
-    private hasAnyIncomingChannelListeners;
-    private dispatchIncomingChannelListeners;
-    private dispatchIncomingGenericListeners;
-    private shouldTreatIncomingStreamAsTransportOnly;
-    private handleUnhandledIncomingStreamEvent;
-    private isHandshakeMessage;
-    private handleIncomingStream;
-    private maybeHandleWebRTCExplicitFileEnvelope;
-    private reassembleWebRTCExplicitPayload;
-    private dispatchSyntheticExplicitIncomingStream;
-    private registerConnection;
-    private reportConnectionTransportStatus;
-    private syncConnectionPeerLifecycle;
-    private getPeerCandidates;
     updatePresence(isOnline?: boolean, ttlMs?: number, metadata?: string, ticketOverride?: string): Promise<void>;
     onConnection(callback: (conn: Connection) => void): () => void;
     onDisconnection(callback: (conn: Connection) => void): () => void;
@@ -691,16 +513,10 @@ declare class Client {
     listChannels(): ChannelDescriptor[];
     onIncomingChannelStream(channelId: string, callback: (stream: IncomingStreamListenerEvent) => boolean | void): () => void;
     onRoomJoinRequest(callback: (request: JoinRequest) => void): () => void;
-    private createMoQDataTracks;
-    /**
-     * Send data via MoQ.
-     * @param peerId Target Node ID (for 1:1) or null (for Broadcast)
-     * @param data Payload
-     */
-    sendMoQData(peerId: string | null, data: Uint8Array): Promise<void>;
-    private handleMessage;
-    private isWebRTCTransportEnabled;
-    private getRTCConfig;
+    isMoQDataReady(peerId: string | null): boolean;
+    sendMoQData(peerId: string | null, data: Uint8Array, options?: {
+        alreadyProtected?: boolean;
+    }): Promise<void>;
 }
 
 /**
@@ -793,4 +609,9 @@ declare function clog(tag: string, fields: CorrelationFields, message?: string,
  */
 declare function logOpenRtcTeardownTrace(kind: string, details?: Record<string, unknown>): void;
 
-export { type CorrelationFields, RuntimeConnectionController, RuntimeConnectionTarget, RuntimeRawConnection, clog, correlationForDriveGrantScope, logOpenRtcTeardownTrace, renderCorrelationFields };
+declare function openRtcDebugEnabled(): boolean;
+declare function openRtcDebug(message: string, data?: unknown): void;
+declare function openRtcDebugInfo(message: string, data?: unknown): void;
+declare function openRtcDebugLog(message: string, data?: unknown): void;
+
+export { type CorrelationFields, RuntimeCapabilities, RuntimeConnectionController, RuntimeConnectionTarget, RuntimeRawConnection, clog, correlationForDriveGrantScope, logOpenRtcTeardownTrace, openRtcDebug, openRtcDebugEnabled, openRtcDebugInfo, openRtcDebugLog, renderCorrelationFields };