openrtc 0.1.0 → 0.1.2

package/README.md

@@ -70,11 +70,10 @@ full ALPN plugin layer.
 ### Root Package
 - `OpenRTC()`
 - `OpenRTC.native()`
-- `Client` (re-export alias)
-- `RuntimeClient`
 
 ### Runtime Secondary Entrypoint
 - `openrtc/runtime`
+- `RuntimeClient`
 - `createWasmClient()` and `createIpcClient(..., bridge)` (legacy compatibility)
 - `IpcRuntimeAdapter`
 - `WasmRuntimeAdapter`

package/dist/{core/types.d.ts → DelegatingRuntimeAdapter-CW8d78dZ.d.ts}

@@ -1,5 +1,4 @@
-export type PlanTier = 'free' | 'starter' | 'pro' | 'internal';
-export interface AppLimits {
+interface AppLimits {
     /** Max devices per authenticated user. -1 = unlimited. */
     devicesPerUser: number;
     /** Max total rooms the developer app can have open at once. -1 = unlimited. */
@@ -9,40 +8,50 @@ export interface AppLimits {
     /** Max active devices across all provisioned personal spaces for this app. -1 = unlimited. */
     maxPersonalDevices: number;
 }
-export declare const DEFAULT_FREE_LIMITS: AppLimits;
-export declare const DEFAULT_MOQ_RELAY_URL = "https://relay.cloudflare.mediaoverquic.com";
-export declare const DEFAULT_ICE_SERVERS: {
-    urls: string;
-}[];
-export interface PlutoRTCConfiguration extends RTCConfiguration {
+interface PlutoRTCConfiguration extends RTCConfiguration {
     iceServers?: RTCIceServer[];
     privacyMode?: boolean;
     useTurn?: boolean;
 }
-export declare const DEFAULT_WEBRTC_CONFIG: PlutoRTCConfiguration;
-export interface PlutoMoQConfiguration {
+interface PlutoMoQConfiguration {
     relayUrl?: string;
 }
-export declare const DEFAULT_MOQ_CONFIG: PlutoMoQConfiguration;
-export interface PlutoIrohConfiguration {
+interface PlutoIrohConfiguration {
     relayOnly?: boolean;
     persistenceMode?: 'persistent' | 'ephemeral';
 }
-export type DiscoveryMode = 'personal' | 'user-scoped';
-export type AuthMode = 'external' | 'anonymous' | 'required';
-export type SignalingMode = 'hosted' | 'ticket-only';
-export type RoomCreationMode = 'client-open' | 'client-auth' | 'server-only';
-export type EndpointKind = 'device' | 'ephemeral';
-export type PeerLifecycleStatus = 'disconnected' | 'connecting' | 'connected' | 'failed' | 'closed';
-export type PeerHealth = 'unknown' | 'healthy' | 'suspect' | 'stale';
-export type PeerScope = 'persistent' | 'session' | string;
-export type ChannelOwnership = 'shared' | 'exclusive';
-export type ChannelPeerModel = 'device-first' | 'node-first' | 'anonymous-ticket';
-export type ChannelRoutingMode = 'stream-envelope' | 'session-default';
-export type ChannelReadinessMode = 'settled-peer' | 'transport-only';
-export type ChannelPromotionPolicy = 'eligible' | 'never';
-export type ChannelSignalingPolicy = 'hosted' | 'ticket-only';
-export interface ChannelDescriptor {
+interface TurnCredentials {
+    iceServers?: RTCIceServer[];
+}
+type TurnCredentialsProvider = () => Promise<TurnCredentials | null | undefined>;
+type DiscoveryMode = 'personal' | 'user-scoped';
+type AuthMode = 'external' | 'anonymous' | 'required';
+type SignalingMode = 'hosted' | 'ticket-only';
+type RoomCreationMode = 'client-open' | 'client-auth' | 'server-only';
+type EndpointKind = 'device' | 'ephemeral';
+type PeerLifecycleStatus = 'disconnected' | 'connecting' | 'connected' | 'failed' | 'closed';
+type PeerHealth = 'unknown' | 'healthy' | 'suspect' | 'stale';
+/**
+ * Lifecycle label attached to a projected peer while the runtime tracks local ownership.
+ *
+ * This is not an admission grant. Use `GrantScope` for ticket/token authorization labels
+ * such as `"share"`, `"friend"`, or `"user-device"`.
+ */
+type PeerScope = 'persistent' | 'session' | string;
+/**
+ * Admission-grant label embedded in restricted compound tickets and session tokens.
+ *
+ * `GrantScope` controls authorization and bulk revoke behavior in the Rust admission layer.
+ * It is distinct from `PeerScope`, which only labels local peer lifecycle ownership.
+ */
+type GrantScope = string;
+type ChannelOwnership = 'shared' | 'exclusive';
+type ChannelPeerModel = 'device-first' | 'node-first' | 'anonymous-ticket';
+type ChannelRoutingMode = 'stream-envelope' | 'session-default';
+type ChannelReadinessMode = 'settled-peer' | 'transport-only';
+type ChannelPromotionPolicy = 'eligible' | 'never';
+type ChannelSignalingPolicy = 'hosted' | 'ticket-only';
+interface ChannelDescriptor {
     id: string;
     kind: 'system' | 'auth' | 'share' | 'transfer' | 'sync' | string;
     ownership: ChannelOwnership;
@@ -53,16 +62,16 @@ export interface ChannelDescriptor {
     signalingPolicy?: ChannelSignalingPolicy;
     description?: string;
 }
-export type ProtocolName = 'iroh' | 'webrtc' | 'websocket' | 'webtransport' | 'moq';
-export type ProtocolMaturity = 'stable' | 'experimental' | 'unsupported';
-export interface ProtocolCapability {
+type ProtocolName = 'iroh' | 'iroh-quic' | 'iroh-relay' | 'webrtc' | 'moq';
+type ProtocolMaturity = 'stable' | 'experimental' | 'unsupported';
+interface ProtocolCapability {
     protocol: ProtocolName;
     maturity: ProtocolMaturity;
     available: boolean;
     reason?: string;
 }
-export type ProtocolCapabilityMap = Record<ProtocolName, ProtocolCapability>;
-export interface ClientOptions {
+type ProtocolCapabilityMap = Record<ProtocolName, ProtocolCapability>;
+interface ClientOptions {
     /**
      * API key issued from the Pluto developer dashboard (https://api.openrtc.app/developer).
      * The runtime derives its app namespace from this key.
@@ -105,6 +114,15 @@ export interface ClientOptions {
     nodeIdPersistence?: 'persistent' | 'ephemeral';
     secretKey?: string;
     strictMode?: boolean;
+    /**
+     * Optional application-provided TURN credential loader.
+     *
+     * OpenRTC never needs long-lived TURN secrets in the client. When strict/privacy
+     * WebRTC needs relay candidates, provide a backend-backed loader that returns
+     * short-lived RTCIceServer entries. Leave unset for the production default of
+     * no paid TURN usage.
+     */
+    turnCredentialsProvider?: TurnCredentialsProvider;
     localDeviceId?: string;
     onDevices?: (devices: Device[]) => void;
     onAutoConnect?: (devices: Device[]) => void;
@@ -117,19 +135,11 @@ export interface ClientOptions {
     transportPriority?: ProtocolName[];
     disableIrohFallback?: boolean;
 }
-export interface Device {
-    /**
-     * @deprecated Internal namespace metadata. Public integrations should not depend on `appTag`.
-     */
-    appTag?: string;
+interface Device {
     deviceId: string;
     deviceName: string;
     online: boolean;
     ticket: string;
-    /**
-     * @deprecated Legacy/internal namespace metadata. Public integrations should not depend on `tag`.
-     */
-    tag?: string;
     kind?: EndpointKind | string;
     nodeId?: string;
     platformType?: string;
@@ -148,8 +158,9 @@ export interface Device {
     createdAt?: any;
     updatedAt?: any;
     metadata?: string;
+    excludedPeers?: string[];
 }
-export interface PeerState {
+interface PeerState {
     peerId: string;
     deviceId?: string;
     deviceIdHint?: string;
@@ -165,12 +176,16 @@ export interface PeerState {
     transportState?: string;
     protocolState?: string;
     routable?: boolean;
+    activeTransportStableId?: number | null;
+    transportGeneration?: number;
+    activeTransport?: ProtocolName;
+    parallelTransport?: ProtocolName | null;
     promotionEligible?: boolean;
     scopes: PeerScope[];
     lastSeenAt?: number;
     error?: string;
 }
-export interface BackendConnectionState {
+interface BackendConnectionState {
     connectionId: string;
     deviceId?: string | null;
     deviceIdHint?: string | null;
@@ -179,6 +194,8 @@ export interface BackendConnectionState {
     transportState?: string;
     protocolState?: string;
     routable?: boolean;
+    activeTransport?: ProtocolName;
+    parallelTransport?: ProtocolName | null;
     readinessState?: string;
     readinessReason?: string;
     transportGeneration?: number;
@@ -195,32 +212,40 @@ export interface BackendConnectionState {
     createdAt?: number;
     updatedAt?: number;
 }
-export interface NativeConnectResult {
+interface NativeConnectResult {
     connectionId: string;
     deviceId?: string | null;
     deviceIdHint?: string | null;
     remoteNodeId?: string | null;
     state: string;
 }
-export interface BackendPeerBiStream {
+interface BackendPeerBiStream {
     readable: ReadableStream<Uint8Array>;
     writable: WritableStream<Uint8Array>;
 }
-export interface BackendPeerUniStream {
+interface BackendPeerUniStream {
     writable: WritableStream<Uint8Array>;
 }
-export interface IncomingStreamChannelMetadata {
+interface IncomingStreamChannelMetadata {
     channelId: string;
     metadata?: Record<string, unknown> | null;
 }
-export interface LocalDeviceInfo {
+interface LocalDeviceInfo {
     deviceId: string;
     deviceName: string;
     platformType?: string;
     capabilities?: Device['capabilities'];
     lastSeenAt?: string;
 }
-export interface RoomMember {
+interface NativeManagedSessionStartResult {
+    localNodeId: string | null;
+    ticket?: string | null;
+    ticketScope?: string | null;
+    presenceStarted: boolean;
+    autoConnectStarted: boolean;
+    localDevice?: LocalDeviceInfo | null;
+}
+interface RoomMember {
     nodeId: string;
     userId: string;
     ticket: string;
@@ -228,10 +253,10 @@ export interface RoomMember {
     lastSeenAt: number;
     expiresAt?: number;
 }
-export interface JoinRoomOptions {
+interface JoinRoomOptions {
     bootstrapPeers?: boolean;
 }
-export interface SignalingEnvelope {
+interface SignalingEnvelope {
     name?: string;
     senderId: string;
     targetId: string;
@@ -240,7 +265,7 @@ export interface SignalingEnvelope {
     replyPayload?: string;
     timestamp?: number;
 }
-export interface SignalingSession {
+interface SignalingSession {
     connectionId: string;
     initiator?: string;
     target?: string;
@@ -258,14 +283,15 @@ export interface SignalingSession {
     targetEndpointAddr?: string;
     intent?: string;
     /**
-     * @deprecated Internal namespace metadata. Public integrations should not depend on `appTag`.
+        * @deprecated Internal namespace metadata. Public integrations should not depend on `appTag`.
+        * Removal target: v0.2.0.
      */
     appTag?: string;
     createdAt?: number;
     expiresAt?: number;
     state: string;
 }
-export interface ScanningLoopOptions {
+interface ScanningLoopOptions {
     localDeviceId: string;
     autoConnect?: boolean;
     autoConnectDebounceMs?: number;
@@ -286,10 +312,10 @@ export interface ScanningLoopOptions {
     }>;
     onIncomingSessionAccepted?: (session: SignalingSession) => Promise<void> | void;
 }
-export interface ScanningLoopHandle {
+interface ScanningLoopHandle {
     stop: () => void;
 }
-export interface ConnectDeviceHooks {
+interface ConnectDeviceHooks {
     getConnectionState?: (deviceId: string) => Promise<string | undefined> | string | undefined;
     forceDisconnect?: (deviceId: string) => Promise<void>;
     refreshState?: () => Promise<void>;
@@ -306,19 +332,19 @@ export interface ConnectDeviceHooks {
     onConnected?: (device: Device) => Promise<void> | void;
     onRetry?: (device: Device, attempt: number, delayMs: number) => void;
 }
-export interface ConnectDeviceOptions {
+interface ConnectDeviceOptions {
     localDeviceId: string;
     targetUserId?: string;
     maxRetries?: number;
     initialBackoffMs?: number;
 }
-export interface ConnectDeviceResult {
+interface ConnectDeviceResult {
     success: boolean;
     skipped?: 'already-connecting' | 'missing-local-device-id';
     error?: string;
     attempts: number;
 }
-export interface ManagedDeviceConnectOptions {
+interface ManagedDeviceConnectOptions {
     localDeviceId: string;
     targetUserId?: string;
     maxRetries?: number;
@@ -326,7 +352,7 @@ export interface ManagedDeviceConnectOptions {
     onRetry?: (device: Device, attempt: number, delayMs: number) => void;
     onConnected?: (device: Device) => void | Promise<void>;
 }
-export interface DeviceStatusSnapshot extends Device {
+interface DeviceStatusSnapshot extends Device {
     connectionStatus: PeerLifecycleStatus | 'online';
     settledReady?: boolean;
     readinessState?: string;
@@ -339,8 +365,10 @@ export interface DeviceStatusSnapshot extends Device {
     deviceIdHint?: string;
     activeTransportStableId?: number | null;
     transportGeneration?: number;
+    activeTransport?: ProtocolName;
+    parallelTransport?: ProtocolName | null;
 }
-export interface ManagedConnectionRecord {
+interface ManagedConnectionRecord {
     connectionId: string;
     nodeId?: string | null;
     deviceId?: string | null;
@@ -361,34 +389,13 @@ export interface ManagedConnectionRecord {
     createdAtMs: number;
     updatedAtMs: number;
 }
-export type ManagedConnectionHealthStatus = 'healthy' | 'awaitingReplacement' | 'dead';
-export interface ManagedConnectionHealthSnapshot {
-    connectionId: string;
-    deviceId?: string | null;
-    deviceIdHint?: string | null;
-    nodeId?: string | null;
-    activeTransportStableId?: number | null;
-    transportGeneration: number;
-    status: ManagedConnectionHealthStatus;
-    settledReady?: boolean;
-    readinessState?: string;
-    replacementPending?: boolean;
-    lastLifecycleTransitionAtMs?: number;
-    readinessReason?: string;
-    transitionCount?: number;
-    connectingTransitionCount?: number;
-    replacementCount?: number;
-    retireCount?: number;
-    lastDisconnectReason?: string | null;
-    lastReconnectReason?: string | null;
-}
-export interface ResolvedPeerIdentity {
+interface ResolvedPeerIdentity {
     peerId?: string | null;
     deviceId?: string | null;
     deviceIdHint?: string | null;
     nodeId?: string | null;
 }
-export interface PeerSessionSnapshot {
+interface PeerSessionSnapshot {
     peerId: string;
     deviceId?: string | null;
     deviceIdHint?: string | null;
@@ -401,6 +408,8 @@ export interface PeerSessionSnapshot {
     readinessState?: string;
     activeTransportStableId?: number | null;
     transportGeneration?: number;
+    activeTransport?: ProtocolName;
+    parallelTransport?: ProtocolName | null;
     replacementPending?: boolean;
     lastLifecycleTransitionAtMs?: number;
     readinessReason?: string;
@@ -414,7 +423,7 @@ export interface PeerSessionSnapshot {
     lastSeenAtMs: number;
     error?: string | null;
 }
-export interface RuntimeBootstrapOptions {
+interface RuntimeBootstrapOptions {
     platform: 'native' | 'web';
     initializeWeb?: () => Promise<void>;
     isNativeReady?: () => Promise<boolean>;
@@ -427,18 +436,18 @@ export interface RuntimeBootstrapOptions {
     nativeInitEventTimeoutMs?: number;
     initializeClient?: boolean;
 }
-export interface RuntimeBootstrapResult {
+interface RuntimeBootstrapResult {
     ready: boolean;
     mode: 'native' | 'web';
 }
-export interface RuntimeIdentity {
+interface RuntimeIdentity {
     id: string;
     email?: string | null;
     displayName?: string | null;
     isAnonymous?: boolean;
     getToken?: (forceRefresh?: boolean) => Promise<string | null>;
 }
-export type DeviceEvent = {
+type DeviceEvent = {
     type: 'added';
     device: Device;
 } | {
@@ -448,7 +457,7 @@ export type DeviceEvent = {
     type: 'removed';
     deviceId: string;
 };
-export type SessionEvent = {
+type SessionEvent = {
     type: 'added';
     session: SignalingSession;
 } | {
@@ -458,7 +467,7 @@ export type SessionEvent = {
     type: 'removed';
     sessionId: string;
 };
-export interface ExplicitFileDataSendParams {
+interface ExplicitFileDataSendParams {
     connectionId?: string;
     connection?: {
         send: (message: unknown) => Promise<void>;
@@ -470,7 +479,7 @@ export interface ExplicitFileDataSendParams {
     transferId: string;
     channelId?: string;
 }
-export interface ISignalingBackend {
+interface ISignalingBackend {
     currentUser: RuntimeIdentity | null;
     signInAnonymously(): Promise<void>;
     signInWithPluto?(): Promise<void>;
@@ -512,6 +521,17 @@ export interface ISignalingBackend {
     getLocalDeviceId?(): Promise<string | null>;
     getLocalDeviceInfo?(): Promise<LocalDeviceInfo | null>;
     updateLocalDeviceName?(deviceName: string): Promise<LocalDeviceInfo | null>;
+    startManagedSessionNative?(options: {
+        userId: string;
+        deviceName?: string;
+        localDeviceId?: string | null;
+        metadata?: string;
+        autoConnect?: boolean;
+        presence?: boolean;
+    }): Promise<NativeManagedSessionStartResult>;
+    reconcileNativeManagedSession?(options?: {
+        reason?: string;
+    }): Promise<unknown>;
     getManagedNodeId?(options?: {
         initializeIfMissing?: boolean;
     }): Promise<string | null>;
@@ -522,6 +542,14 @@ export interface ISignalingBackend {
         deviceId?: string | null;
         endpointTicket: string;
     }): Promise<NativeConnectResult>;
+    /**
+     * Optional backchannel so a backend (e.g. WasmBridge) can access the core
+     * Client after Client.setSignalingBackend() has been called. This lets the
+     * backend trigger Client.connect() for peers it dials directly (e.g. via
+     * the WASM auto-connect path) so the TS Connection/upgrade state machine
+     * stays in lockstep with the Rust transport.
+     */
+    setCoreClient?(client: unknown): void;
     disconnectDevice?(deviceId: string): Promise<void>;
     setAutoConnectExcluded?(deviceId: string, excluded: boolean): Promise<void>;
     isConnected(nodeId: string): Promise<boolean>;
@@ -532,7 +560,7 @@ export interface ISignalingBackend {
     getTransferHistory?(limit?: number): Promise<Array<[string, unknown]>>;
     deleteTransferJob?(jobId: string): Promise<void>;
 }
-export interface SignalingOptions {
+interface SignalingOptions {
     apiKey?: string;
     allowAnonymousHostedDefaults?: boolean;
     authMode?: AuthMode;
@@ -540,20 +568,172 @@ export interface SignalingOptions {
     storagePrefix?: string;
     nodeIdPersistence?: 'persistent' | 'ephemeral';
 }
-export interface TransportContext {
+interface TransportContext {
     sendMoQ: (data: Uint8Array) => Promise<void>;
     priorities: ProtocolName[];
     disableIrohFallback: boolean;
     isMoQReady: () => boolean;
+    runtimeFlow?: 'default' | 'ticket-only';
+    readerCloseStrategy?: 'cancel' | 'release-lock';
 }
-export interface ConnectionOptions {
+interface ConnectionOptions {
     reliable?: boolean;
     rtcConfig?: RTCConfiguration;
     transportContext?: TransportContext;
+    onTransportStatusChange?: (status: {
+        activeTransport: ProtocolName;
+        parallelTransport?: ProtocolName | null;
+    }) => void;
 }
-export interface JoinRequest {
+interface JoinRequest {
     id: string;
     userId: string;
     ticket: string;
     state: 'pending' | 'accepted' | 'rejected';
 }
+
+type AuthContext = {
+    userId: string;
+    token?: string | null;
+    refreshToken?: string | null;
+    customToken?: string | null;
+    tokenProvider?: (forceRefresh?: boolean) => Promise<string | null>;
+    expiresAtMs?: number | null;
+};
+
+type RuntimeAdapterKind = 'browser-wasm' | 'native-ipc' | 'tauri-ipc' | 'unknown';
+interface RuntimeCapabilities {
+    adapter: RuntimeAdapterKind;
+    signaling: {
+        firestore: boolean;
+        nativeIpc: boolean;
+        rtdbPresence: boolean;
+    };
+    transport: {
+        irohQuic: boolean;
+        webRtcUpgrade: boolean;
+        nativeWebRtc: boolean;
+        wasm: boolean;
+    };
+    lifecycle: {
+        managedSession: boolean;
+        autoConnect: boolean;
+        manualDisconnect: boolean;
+        connectionStateEvents: boolean;
+        peerSessions: boolean;
+    };
+    transfers: {
+        explicitFilePath: boolean;
+        explicitFileData: boolean;
+        history: boolean;
+    };
+    fallback: {
+        wasm: boolean;
+    };
+}
+declare const BROWSER_WASM_RUNTIME_CAPABILITIES: RuntimeCapabilities;
+declare const NATIVE_IPC_RUNTIME_CAPABILITIES: RuntimeCapabilities;
+declare function cloneRuntimeCapabilities(capabilities: RuntimeCapabilities): RuntimeCapabilities;
+
+interface WasmBridgeOptions {
+    apiKey?: string;
+    discoveryMode?: DiscoveryMode;
+    spaceKey?: string;
+    authMode?: AuthMode;
+    signalingMode?: SignalingMode;
+    projectId?: string;
+    storagePrefix?: string;
+    nodeIdPersistence?: 'persistent' | 'ephemeral';
+    deviceName?: string;
+    turnCredentialsProvider?: () => Promise<{
+        iceServers?: RTCIceServer[];
+    } | null | undefined>;
+}
+
+declare abstract class DelegatingRuntimeAdapter implements ISignalingBackend {
+    protected readonly backend: ISignalingBackend;
+    protected constructor(backend: ISignalingBackend);
+    get currentUser(): RuntimeIdentity | null;
+    setAuthContext(context: AuthContext | null): Promise<void> | void;
+    signInAnonymously(): Promise<void>;
+    signInWithPluto(): Promise<void>;
+    signOut(): Promise<void>;
+    stopAuthScopedActivity(): Promise<void>;
+    getTurnCredentials(): Promise<any>;
+    updatePresence(localNodeId: string, ticketStr: string, isOnline: boolean, ttlMs: number, metadata?: string): Promise<void>;
+    setOffline(localNodeId: string): Promise<void>;
+    cleanupStaleDevices(): Promise<void>;
+    searchDevices(excludeNodeId?: string): Promise<Device[]>;
+    listDevicesWithStatus(): Promise<DeviceStatusSnapshot[]>;
+    getPeerSession(id: string): Promise<PeerSessionSnapshot | null>;
+    listPeerSessions(): Promise<PeerSessionSnapshot[]>;
+    waitForSettledPeer(id: string, timeoutMs?: number): Promise<PeerSessionSnapshot | null>;
+    resolvePeerIdentity(id: string): Promise<ResolvedPeerIdentity>;
+    resolvePeerConnectionRecords(id: string): Promise<ManagedConnectionRecord[]>;
+    updateDevice(deviceId: string, updates: {
+        deviceName?: string;
+        capabilities?: Device['capabilities'];
+        metadata?: string;
+    }): Promise<void>;
+    deleteDevice(deviceId: string): Promise<void>;
+    onDevicesChange(callback: (devices: Device[]) => void, excludeNodeId?: string): () => void;
+    onAuthChange(callback: (user: RuntimeIdentity | null) => void): () => void;
+    checkForSSOToken(): Promise<void>;
+    waitForAuth(): Promise<void>;
+    sendMessage(targetId: string, payload: string, state?: string, replyPayload?: string): Promise<string>;
+    pollMessages(targetId: string): Promise<SignalingEnvelope[]>;
+    subscribeDevices(userId: string): Promise<ReadableStream<DeviceEvent[]>>;
+    startAutoConnect(userId: string, localDeviceId: string): void;
+    startPresenceLoop(userId: string, localNodeId: string, deviceName: string, ticket: string, metadata?: string): void;
+    createSession(session: SignalingSession): Promise<void>;
+    updateSession(sessionId: string, updateData: any): Promise<void>;
+    subscribeSessions(localDeviceId: string): Promise<ReadableStream<SessionEvent[]>>;
+    forceReconnectSnapshot(): void;
+    getLocalDeviceId(): Promise<string | null>;
+    getLocalDeviceInfo(): Promise<LocalDeviceInfo | null>;
+    updateLocalDeviceName(deviceName: string): Promise<LocalDeviceInfo | null>;
+    startManagedSessionNative(options: {
+        userId: string;
+        deviceName?: string;
+        localDeviceId?: string | null;
+        metadata?: string;
+        autoConnect?: boolean;
+        presence?: boolean;
+    }): Promise<NativeManagedSessionStartResult>;
+    getManagedNodeId(options?: {
+        initializeIfMissing?: boolean;
+    }): Promise<string | null>;
+    startPresenceLoopOnce(userId: string, localNodeId: string, deviceName: string, ticket: string, metadata?: string): Promise<void>;
+    startAutoConnectOnce(userId: string, localDeviceId: string): Promise<void>;
+    getEndpointTicket(): Promise<string>;
+    getEndpointTicketWithToken(scope: GrantScope, maxConnections: number): Promise<string | null>;
+    registerSessionToken(token: string, scope: GrantScope, maxConnections: number): Promise<void>;
+    revokeSessionTokensByScope(scope: GrantScope): Promise<string[]>;
+    openPeerBi(id: string, timeoutMs?: number): Promise<BackendPeerBiStream>;
+    openPeerBiTransportOnly(id: string, timeoutMs?: number): Promise<BackendPeerBiStream>;
+    openPeerUni(id: string, timeoutMs?: number): Promise<BackendPeerUniStream>;
+    connectToDevice(params: {
+        deviceId?: string | null;
+        endpointTicket: string;
+    }): Promise<NativeConnectResult>;
+    disconnectDevice(deviceId: string): Promise<void>;
+    isConnected(nodeId: string): Promise<boolean>;
+    getConnectionStates(): Promise<BackendConnectionState[]>;
+    onConnectionStateChange(callback: (state: BackendConnectionState) => void): Promise<() => void> | (() => void);
+    sendExplicitFilePath(connectionId: string, filePath: string, transferId?: string): Promise<string>;
+    sendExplicitFileData(params: ExplicitFileDataSendParams): Promise<void>;
+    getTransferHistory(limit?: number): Promise<Array<[string, unknown]>>;
+    deleteTransferJob(jobId: string): Promise<void>;
+    getRuntimeCapabilities(): RuntimeCapabilities;
+    onIncomingNativeMessage(callback: (connectionId: string, remoteNodeId: string | null, message: any) => void): Promise<() => void>;
+    unwrap(): ISignalingBackend;
+    /**
+     * Forward setCoreClient() to the inner backend if it implements it. This
+     * lets the core Client inject a reference into backends (e.g. WasmBridge)
+     * that need to escalate transport-level dials into full Client.connect()
+     * handshakes.
+     */
+    setCoreClient(client: unknown): void;
+}
+
+export { type AuthContext as A, type BackendConnectionState as B, type ConnectDeviceResult as C, DelegatingRuntimeAdapter as D, type ExplicitFileDataSendParams as E, type RoomCreationMode as F, type GrantScope as G, type ScanningLoopOptions as H, type IncomingStreamChannelMetadata as I, type JoinRoomOptions as J, type ScanningLoopHandle as K, type LocalDeviceInfo as L, type ManagedDeviceConnectOptions as M, type NativeConnectResult as N, type RuntimeBootstrapOptions as O, type PeerSessionSnapshot as P, type RuntimeBootstrapResult as Q, type ResolvedPeerIdentity as R, type SignalingMode as S, type JoinRequest as T, BROWSER_WASM_RUNTIME_CAPABILITIES as U, NATIVE_IPC_RUNTIME_CAPABILITIES as V, type WasmBridgeOptions as W, cloneRuntimeCapabilities as X, type ConnectDeviceHooks as a, type ConnectDeviceOptions as b, type RuntimeCapabilities as c, type AppLimits as d, type AuthMode as e, type DiscoveryMode as f, type ProtocolCapability as g, type ProtocolCapabilityMap as h, type ProtocolName as i, type RuntimeAdapterKind as j, type ClientOptions as k, type ChannelDescriptor as l, type Device as m, type SignalingSession as n, type RuntimeIdentity as o, type DeviceStatusSnapshot as p, type PeerState as q, type PeerHealth as r, type RoomMember as s, type PeerScope as t, type PeerLifecycleStatus as u, type ConnectionOptions as v, type ISignalingBackend as w, type ManagedConnectionRecord as x, type SignalingOptions as y, type SignalingEnvelope as z };

package/dist/IpcRuntimeAdapter-CT-W0Mtp.d.ts

@@ -0,0 +1,24 @@
+import { W as WasmBridgeOptions, k as ClientOptions, D as DelegatingRuntimeAdapter } from './DelegatingRuntimeAdapter-CW8d78dZ.js';
+
+type PlutoIpcUnlisten = () => void | Promise<void>;
+interface PlutoIpcBridge {
+    invoke<T = unknown>(command: string, args?: Record<string, unknown>): Promise<T>;
+    listen<T = unknown>(event: string, handler: (payload: T) => void): Promise<PlutoIpcUnlisten>;
+    isAvailable?(): boolean | Promise<boolean>;
+}
+
+interface NativeIpcBridgeOptions extends WasmBridgeOptions {
+    allowWasmFallback?: boolean;
+    ipcBridge?: PlutoIpcBridge;
+    transports?: ClientOptions['transports'];
+    strictMode?: boolean;
+}
+
+interface IpcRuntimeAdapterOptions extends NativeIpcBridgeOptions {
+    bridge: PlutoIpcBridge;
+}
+declare class IpcRuntimeAdapter extends DelegatingRuntimeAdapter {
+    constructor(options: IpcRuntimeAdapterOptions);
+}
+
+export { IpcRuntimeAdapter as I, type NativeIpcBridgeOptions as N, type PlutoIpcBridge as P, type IpcRuntimeAdapterOptions as a, type PlutoIpcUnlisten as b };