openrtc 1.0.3 → 1.0.5

package/README.md

@@ -147,6 +147,11 @@ product policy remain consumer-owned.
 - `OpenRTC()`
 - `OpenRTC.native()`
 
+### Native-only Entrypoint
+- `openrtc/native`
+- `createNativeOpenRTC(options, bridge)`
+- excludes the browser WASM adapter and binary from Tauri webview bundles
+
 ### Runtime Secondary Entrypoint
 - `openrtc/runtime`
 - `RuntimeClient`
@@ -162,14 +167,17 @@ product policy remain consumer-owned.
 - Rust plugin crate: `openrtc-tauri-plugin`
 - `openrtc/runtime/tauri` remains as a deprecated compatibility shim for one release cycle
 
-For Tauri desktop/mobile apps, use `OpenRTC.native(options)` with the
-`openrtc-tauri` bridge and register `openrtc-tauri-plugin` in the Rust Tauri
+For Tauri desktop/mobile apps, use `createNativeOpenRTC(options, bridge)` from
+`openrtc/native` with the `openrtc-tauri` bridge and register
+`openrtc-tauri-plugin` in the Rust Tauri
 builder. Do not copy product-owned RTC command files into new apps. The plugin
 owns the native IPC command set and delegates lifecycle, discovery, presence,
 auto-connect, and connection state to one `openrtc::client::Client`. Do not use
-`OpenRTC(options)` inside a Tauri shell unless you intentionally want the
+`OpenRTC(options)` or the compatibility `OpenRTC.native(options)` entry inside a
+Tauri shell unless you intentionally want the
 browser/WASM runtime for a prototype; that path bypasses the native Rust runtime
-and can hide native lifecycle/presence issues from tests.
+or retains browser-runtime bundle reachability and can hide native
+lifecycle/presence issues from tests.
 
 Mobile hosts should forward connectivity-restored callbacks through
 `client.advanced.notifyNetworkChange(reason)`. The Tauri plugin passes this hint

package/dist/{DelegatingRuntimeAdapter-D2_dgabz.d.ts → DelegatingRuntimeAdapter-DlC0TZB0.d.ts}

@@ -1,105 +1,6 @@
-import { D as DiscoveryMode, A as AuthMode, S as SignalingMode, E as ExplicitFileDataSendParams, I as ISignalingBackend, R as RuntimeIdentity, a as Device, b as DeviceStatusSnapshot, P as PeerSessionSnapshot, c as ResolvedPeerIdentity, M as ManagedConnectionRecord, d as SignalingEnvelope, e as DeviceEvent, f as SignalingSession, g as SessionEvent, L as LocalDeviceInfo, N as NativeManagedSessionStartResult, G as GrantScope, B as BackendPeerBiStream, h as BackendPeerUniStream, i as NativeConnectParams, j as NativeConnectResult, k as BackendConnectionState } from './types-ByZyADCn.js';
+import { D as DiscoveryMode, A as AuthMode, S as SignalingMode, E as ExplicitFileDataSendParams, I as ISignalingBackend, c as RuntimeIdentity, d as Device, e as DeviceStatusSnapshot, P as PeerSessionSnapshot, R as ResolvedPeerIdentity, M as ManagedConnectionRecord, f as SignalingEnvelope, g as DeviceEvent, h as SignalingSession, i as SessionEvent, L as LocalDeviceInfo, N as NativeManagedSessionStartResult, G as GrantScope, B as BackendPeerBiStream, j as BackendPeerUniStream, k as NativeConnectParams, l as NativeConnectResult, m as BackendConnectionState } from './types-BCkKK8dy.js';
 import { A as AuthContext } from './IEngineBridge-C7OT2CRv.js';
-
-type RuntimeAdapterKind = 'browser-wasm' | 'native-ipc' | 'tauri-ipc' | 'unknown';
-interface RuntimeCapabilities {
-    adapter: RuntimeAdapterKind;
-    signaling: {
-        firestore: boolean;
-        nativeIpc: boolean;
-        rtdbPresence: boolean;
-    };
-    transport: {
-        irohQuic: boolean;
-        irohLan: boolean;
-        webRtcUpgrade: boolean;
-        webRtcLan: boolean;
-        nativeWebRtc: boolean;
-        moq: boolean;
-        ble: boolean;
-        wasm: boolean;
-    };
-    nativeProtocols: {
-        productAlpn: boolean;
-        irohDocs: boolean;
-        irohBlobs: boolean;
-        irohGossip: boolean;
-    };
-    lifecycle: {
-        managedSession: boolean;
-        autoConnect: boolean;
-        manualDisconnect: boolean;
-        connectionStateEvents: boolean;
-        peerSessions: boolean;
-    };
-    transfers: {
-        explicitFilePath: boolean;
-        explicitFileData: boolean;
-        history: boolean;
-    };
-    fallback: {
-        wasm: boolean;
-    };
-}
-interface RuntimeCapabilityProfile {
-    environment: 'web' | 'native' | 'unknown';
-    transports: {
-        quic: boolean;
-        irohRelay: boolean;
-        irohLan: boolean;
-        webRtc: boolean;
-        webRtcLan: boolean;
-        moq: boolean;
-        ble: boolean;
-    };
-    lifecycle: RuntimeCapabilities['lifecycle'];
-    storage: {
-        localFileSystem: boolean;
-        transferHistory: boolean;
-    };
-    nativeProtocols: RuntimeCapabilities['nativeProtocols'];
-}
-interface NativeRuntimeTransportFeatureStatus {
-    compiled?: boolean;
-    enabled?: boolean;
-}
-interface NativeRuntimeStatusSnapshot {
-    ready?: boolean;
-    nodeId?: string | null;
-    node_id?: string | null;
-    transport?: {
-        irohQuic?: NativeRuntimeTransportFeatureStatus;
-        irohLan?: NativeRuntimeTransportFeatureStatus;
-        webRtc?: NativeRuntimeTransportFeatureStatus;
-        webRtcLan?: NativeRuntimeTransportFeatureStatus;
-        moq?: NativeRuntimeTransportFeatureStatus;
-        ble?: NativeRuntimeTransportFeatureStatus;
-        irohRelayOnly?: boolean;
-        irohRelayTransportPolicy?: string | null;
-    };
-}
-declare const BROWSER_WASM_RUNTIME_CAPABILITIES: RuntimeCapabilities;
-/**
- * The small host surface that browser WebRTC capability reporting needs.
- *
- * This is deliberately a feature check only: capability reporting must not
- * create a peer connection, probe ICE, or influence route ownership.
- */
-interface BrowserRuntimeCapabilityHost {
-    RTCPeerConnection?: unknown;
-}
-declare const NATIVE_IPC_RUNTIME_CAPABILITIES: RuntimeCapabilities;
-declare function cloneRuntimeCapabilities(capabilities: RuntimeCapabilities): RuntimeCapabilities;
-/**
- * Returns browser/WASM capabilities for a concrete JavaScript host.
- *
- * The static browser baseline describes package support. WebRTC additionally
- * requires the browser primitive to exist at runtime. Passing the host keeps
- * the resolver deterministic in SSR and test environments.
- */
-declare function runtimeCapabilitiesForBrowserHost(host?: BrowserRuntimeCapabilityHost | null | undefined): RuntimeCapabilities;
-declare function runtimeCapabilitiesFromNativeStatus(status: NativeRuntimeStatusSnapshot | null | undefined, allowWasmFallback?: boolean): RuntimeCapabilities;
-declare function runtimeCapabilityProfile(capabilities: RuntimeCapabilities): RuntimeCapabilityProfile;
+import { R as RuntimeCapabilities } from './capabilities-C4Dqs_pB.js';
 
 interface WasmBridgeOptions {
     apiKey?: string;
@@ -216,4 +117,4 @@ declare abstract class DelegatingRuntimeAdapter implements ISignalingBackend {
     setCoreClient(client: unknown): void;
 }
 
-export { BROWSER_WASM_RUNTIME_CAPABILITIES as B, DelegatingRuntimeAdapter as D, NATIVE_IPC_RUNTIME_CAPABILITIES as N, type RuntimeCapabilities as R, type WasmBridgeOptions as W, type RuntimeCapabilityProfile as a, type RuntimeAdapterKind as b, type BrowserRuntimeCapabilityHost as c, type NativeRuntimeStatusSnapshot as d, type NativeRuntimeTransportFeatureStatus as e, cloneRuntimeCapabilities as f, runtimeCapabilitiesFromNativeStatus as g, runtimeCapabilityProfile as h, runtimeCapabilitiesForBrowserHost as r };
+export { DelegatingRuntimeAdapter as D, type WasmBridgeOptions as W };

package/dist/OpenRTCShared-BvTf2gFH.d.ts

@@ -0,0 +1,249 @@
+import { R as RuntimeClient, a as RuntimePolicySnapshot, P as PeerReconciliationStats, b as PlutoRuntimeAssembly } from './assembly-BH-ZekkH.js';
+import { C as ConnectDeviceResult, a as ConnectDeviceHooks, b as ConnectDeviceOptions, P as PeerSessionSnapshot, R as ResolvedPeerIdentity, G as GrantScope } from './types-BCkKK8dy.js';
+import { A as AuthContext } from './IEngineBridge-C7OT2CRv.js';
+import { a as RuntimeManagedSessionOptions, b as RuntimeManagedSession, c as RuntimeDevice, d as RuntimeDeviceStatusSnapshot, e as RuntimeDeviceConnectOptions, f as RuntimeLocalDeviceInfo, g as RuntimeLocalDeviceProfile, h as RuntimePeerState, i as RuntimePeerConnectOptions, C as Connection, j as RuntimePeerReadinessSnapshot, k as RuntimePeerHealth, l as RuntimeChannelDescriptor, m as RuntimePeerStreamOptions, n as RuntimeIncomingStream, o as RuntimeScopedChannelOptions, p as RuntimeScopedLogicalChannel, q as RuntimeJoinRoomOptions, r as RuntimeRoomMember, s as RuntimeConnectionStateSnapshot, t as RuntimeApplicationPayloadReadinessOptions, u as RuntimeConnectionEvent, v as RuntimeRawConnection } from './types-QMj23Nvm.js';
+import { R as RuntimeCapabilities, a as RuntimeCapabilityProfile } from './capabilities-C4Dqs_pB.js';
+
+type OpenRTCChannelConnectOptions = Omit<RuntimeScopedChannelOptions, 'scope' | 'deviceId' | 'ticket'> & {
+    /**
+     * Device selected from `client.devices.*`. Passing the device object lets
+     * OpenRTC reuse its current ticket for native and ticket-gated routes.
+     */
+    device?: string | RuntimeDevice;
+    deviceId?: string | null;
+    ticket?: string;
+    /**
+     * Logical channel lifecycle scope. Most app channels should use the default
+     * `session`; pass a custom scope only when you intentionally manage peer
+     * lifecycle separately from the channel.
+     */
+    scope?: RuntimeScopedChannelOptions['scope'];
+};
+type OpenRTCDeviceSessionOptions = Omit<RuntimeManagedSessionOptions, 'platform'> & {
+    /**
+     * Runtime host for the managed user-device session. Normal apps can omit
+     * this: `OpenRTC(...)` defaults to `web`, and `OpenRTC.native(...)` defaults
+     * to `native`.
+     */
+    platform?: RuntimeManagedSessionOptions['platform'];
+};
+interface OpenRTCDeviceNamespace {
+    startSession(options?: OpenRTCDeviceSessionOptions): Promise<RuntimeManagedSession>;
+    stopSession(options?: {
+        preserveBackendSession?: boolean;
+    }): Promise<void>;
+    list(): Promise<RuntimeDevice[]>;
+    listWithStatus(): Promise<RuntimeDeviceStatusSnapshot[]>;
+    watch(callback: (devices: RuntimeDevice[]) => void): () => void;
+    watchWithStatus(callback: (devices: RuntimeDeviceStatusSnapshot[]) => void): () => void;
+    connect(device: string | RuntimeDevice, options?: RuntimeDeviceConnectOptions): Promise<ConnectDeviceResult>;
+    /**
+     * @deprecated Use `devices.connect()`. Retry and route recovery are owned by
+     * OpenRTC; legacy consumer-provided connection hooks are ignored.
+     */
+    connectWithRetry(device: string | RuntimeDevice, hooks: ConnectDeviceHooks, options: ConnectDeviceOptions): Promise<ConnectDeviceResult>;
+    disconnect(deviceId: string): Promise<void>;
+    update(deviceId: string, updates: {
+        deviceName?: string;
+        capabilities?: RuntimeDevice['capabilities'];
+        metadata?: string;
+    }): Promise<void>;
+    delete(deviceId: string): Promise<void>;
+    localId(): Promise<string | null>;
+    localInfo(): Promise<RuntimeLocalDeviceInfo | null>;
+    localProfile(options?: {
+        deviceName?: string;
+        localDeviceId?: string | null;
+        platform?: 'native' | 'web';
+        userId?: string | null;
+    }): Promise<RuntimeLocalDeviceProfile>;
+    updateLocalName(deviceName: string): Promise<RuntimeLocalDeviceInfo | null>;
+}
+interface OpenRTCPeerNamespace {
+    watch(callback: (peers: RuntimePeerState[]) => void): () => void;
+    watchLifecycle(callback: (peers: RuntimePeerState[]) => void): () => void;
+    get(id: string): RuntimePeerState | undefined;
+    listConnected(): RuntimePeerState[];
+    connect(options: RuntimePeerConnectOptions): Promise<Connection>;
+    disconnect(id: string, scope?: string): Promise<void>;
+    forceDisconnect(id: string): Promise<void>;
+    session(id: string): Promise<PeerSessionSnapshot | null>;
+    sessions(): Promise<PeerSessionSnapshot[]>;
+    waitConnected(id: string, timeoutMs?: number): Promise<PeerSessionSnapshot | null>;
+    readiness(id: string, timeoutMs?: number): Promise<RuntimePeerReadinessSnapshot>;
+    health(id: string): Promise<RuntimePeerHealth>;
+    identity(id: string): Promise<ResolvedPeerIdentity>;
+    addScope(id: string, scope?: string): RuntimePeerState | undefined;
+    releaseScope(id: string, scope?: string): RuntimePeerState | undefined;
+    scopes(id: string): string[];
+    refresh(): Promise<RuntimePeerState[]>;
+}
+interface OpenRTCChannelNamespace {
+    register(descriptor: RuntimeChannelDescriptor): void;
+    unregister(channelId: string): void;
+    list(): RuntimeChannelDescriptor[];
+    openBi(id: string, channelId: string, options?: Omit<RuntimePeerStreamOptions, 'channelId'>): Promise<{
+        connection: Connection;
+        readable: ReadableStream<Uint8Array>;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    openUni(id: string, channelId: string, options?: Omit<RuntimePeerStreamOptions, 'channelId'>): Promise<{
+        connection: Connection;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    onIncoming(callback: (stream: RuntimeIncomingStream) => boolean | void): () => void;
+    onIncomingChannel(channelId: string, callback: (stream: RuntimeIncomingStream & {
+        channel: NonNullable<RuntimeIncomingStream['channel']>;
+    }) => boolean | void): () => void;
+    connect(options: OpenRTCChannelConnectOptions): Promise<RuntimeScopedLogicalChannel>;
+    connectScoped(options: RuntimeScopedChannelOptions): Promise<RuntimeScopedLogicalChannel>;
+}
+interface OpenRTCRoomNamespace {
+    create(roomId?: string): Promise<string>;
+    join(roomId: string, options?: RuntimeJoinRoomOptions): Promise<Connection[]>;
+    leave(roomId: string): Promise<void>;
+    watch(roomId: string, callback: (members: RuntimeRoomMember[]) => void): () => void;
+    members(roomId: string): Promise<RuntimeRoomMember[]>;
+}
+interface OpenRTCTicketNamespace {
+    raw(): Promise<string>;
+    share(options?: {
+        maxConnections?: number;
+    }): Promise<string>;
+    grant(scope: GrantScope, options?: {
+        maxConnections?: number;
+    }): Promise<string>;
+    revoke(scope: GrantScope): Promise<string[]>;
+}
+interface OpenRTCDiagnosticsNamespace {
+    status(): Promise<{
+        runtime: 'tauri' | 'browser' | 'unknown';
+        wasmLoaded: boolean;
+        localNodeId?: string;
+        userId?: string;
+    }>;
+    policy(): RuntimePolicySnapshot;
+    capabilities(): RuntimeCapabilities;
+    capabilityProfile(): RuntimeCapabilityProfile;
+    connectionStates(): Promise<RuntimeConnectionStateSnapshot[]>;
+    onConnectionStateChange(callback: (state: RuntimeConnectionStateSnapshot) => void): Promise<() => void> | (() => void);
+    connections(): Connection[];
+    applicationReadyConnections(options?: RuntimeApplicationPayloadReadinessOptions): Connection[];
+    onConnection(callback: (connection: Connection) => void): () => void;
+    onDisconnection(callback: (connection: Connection) => void): () => void;
+    onConnectionEvent(callback: (event: RuntimeConnectionEvent) => void): () => void;
+    forceReconnectSnapshot(): void;
+    peerReconciliation(): Readonly<PeerReconciliationStats>;
+}
+interface OpenRTCAdvancedNamespace {
+    readonly runtime: RuntimeClient;
+    readonly assembly: PlutoRuntimeAssembly;
+    nodeId(): Promise<string>;
+    nodeIdFromTicket(ticket: string): Promise<string | null>;
+    endpointTicket(): Promise<string>;
+    connectRaw(target: {
+        ticket: string;
+        timeoutMs?: number;
+    }): Promise<RuntimeRawConnection>;
+    openBi(nodeId: string): Promise<{
+        readable: ReadableStream<Uint8Array>;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    openUni(nodeId: string): Promise<WritableStream<Uint8Array>>;
+    isConnected(nodeId: string): Promise<boolean>;
+    disconnectNode(nodeId: string): Promise<void>;
+    setAutoConnectExcluded(deviceId: string, excluded: boolean): Promise<void>;
+    notifyNetworkChange(reason?: string): Promise<void>;
+}
+/**
+ * OpenRTCClient extends RuntimeClient with auth helpers that were
+ * previously only available on PlutoRuntimeAssembly.
+ *
+ * This is the unified type returned by OpenRTC() and OpenRTC.native().
+ */
+interface OpenRTCClient extends RuntimeClient {
+    readonly devices: OpenRTCDeviceNamespace;
+    readonly peers: OpenRTCPeerNamespace;
+    readonly channels: OpenRTCChannelNamespace;
+    readonly rooms: OpenRTCRoomNamespace;
+    readonly tickets: OpenRTCTicketNamespace;
+    readonly diagnostics: OpenRTCDiagnosticsNamespace;
+    readonly advanced: OpenRTCAdvancedNamespace;
+    /** @deprecated Use setAuth() instead */
+    setAuthContext(context: AuthContext | null): Promise<void>;
+    /** Set auth context for the runtime */
+    setAuth(context: AuthContext | null): Promise<void>;
+    /** Sync Pluto-hosted auth to the runtime */
+    syncPlutoAuth(options?: {
+        userId?: string | null;
+        forceRefresh?: boolean;
+    }): Promise<void>;
+    /** Bind Pluto auth host to auto-sync on token changes */
+    bindPlutoAuthHost(): () => void;
+    /** Sign in via Pluto SSO */
+    signIn(): Promise<void>;
+    /** Sign out and clear auth context */
+    signOut(): Promise<void>;
+    /**
+     * @deprecated Use `client.devices.startSession(...)` for the public
+     * user-device avenue lifecycle. This top-level method remains for
+     * RuntimeClient compatibility and advanced integrations.
+     */
+    startManagedSession(options: RuntimeManagedSessionOptions): Promise<RuntimeManagedSession>;
+    /**
+     * @deprecated Use `client.devices.stopSession(...)` for the public
+     * user-device avenue lifecycle.
+     */
+    stopManagedSession(options?: {
+        preserveBackendSession?: boolean;
+    }): Promise<void>;
+    /** @deprecated Use `client.rooms.create(...)`. */
+    createRoom(roomId?: string): Promise<string>;
+    /** @deprecated Use `client.rooms.join(...)`. */
+    joinRoom(roomId: string, options?: RuntimeJoinRoomOptions): Promise<Connection[]>;
+    /** @deprecated Use `client.rooms.leave(...)`. */
+    leaveRoom(roomId: string): Promise<void>;
+    /** @deprecated Use `client.rooms.watch(...)`. */
+    watchRoom(roomId: string, callback: (members: RuntimeRoomMember[]) => void): () => void;
+    /** @deprecated Use `client.rooms.members(...)`. */
+    getRoomMembers(roomId: string): Promise<RuntimeRoomMember[]>;
+    /** @deprecated Use `client.tickets.raw(...)`. */
+    getInvite(): Promise<string>;
+    /** @deprecated Use `client.tickets.raw(...)`. */
+    getTicket(): Promise<string>;
+    /** @deprecated Use `client.tickets.share(...)` or `client.tickets.grant(...)`. */
+    getTicketWithToken(scope: GrantScope, maxConnections?: number): Promise<string>;
+    /** @deprecated Use `client.tickets.revoke(...)`. */
+    revokeTokensByScope(scope: GrantScope): Promise<string[]>;
+    /** @deprecated Use `client.peers.connect(...)`. */
+    connectPeer(options: RuntimePeerConnectOptions): Promise<Connection>;
+    /** @deprecated Use `client.peers.connect(...)`. */
+    connectTo(options: RuntimePeerConnectOptions): Promise<Connection>;
+    /** @deprecated Use `client.peers.waitConnected(...)`. */
+    waitForConnectedPeer(id: string, timeoutMs?: number): Promise<PeerSessionSnapshot | null>;
+    /** @deprecated Use `client.channels.connect(...)`; use `client.channels.connectScoped(...)` only for custom lifecycle scopes. */
+    connectScopedChannel(options: RuntimeScopedChannelOptions): Promise<RuntimeScopedLogicalChannel>;
+    /** @deprecated Use `client.channels.openBi(...)`. */
+    openPeerBi(id: string, options?: RuntimePeerStreamOptions): Promise<{
+        connection: Connection;
+        readable: ReadableStream<Uint8Array>;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    /** @deprecated Use `client.channels.openUni(...)`. */
+    openPeerUni(id: string, options?: RuntimePeerStreamOptions): Promise<{
+        connection: Connection;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    /**
+     * Access to the underlying PlutoRuntimeAssembly for backward compatibility.
+     * @deprecated Access methods directly on the client instead.
+     */
+    readonly runtime: RuntimeClient;
+    /**
+     * Access to the underlying PlutoRuntimeAssembly for backward compatibility.
+     * @internal
+     */
+    readonly _assembly: PlutoRuntimeAssembly;
+}
+
+export type { OpenRTCClient as O, OpenRTCChannelConnectOptions as a, OpenRTCDeviceNamespace as b, OpenRTCDeviceSessionOptions as c, OpenRTCRoomNamespace as d, OpenRTCTicketNamespace as e };

package/dist/{framing-rPdckqn5.d.ts → assembly-BH-ZekkH.d.ts}

@@ -1,9 +1,7 @@
 import { A as AuthContext } from './IEngineBridge-C7OT2CRv.js';
-import { G as GrantScope, I as ISignalingBackend, m as ConnectDeviceHooks, n as ConnectDeviceOptions, l as ConnectDeviceResult, M as ManagedConnectionRecord, P as PeerSessionSnapshot, c as ResolvedPeerIdentity, u as AppLimits, i as NativeConnectParams, j as NativeConnectResult, E as ExplicitFileDataSendParams } from './types-ByZyADCn.js';
-import { h as RuntimePeerState, s as RuntimeConnectionStateSnapshot, j as RuntimePeerReadinessSnapshot, i as RuntimePeerConnectOptions, C as Connection, n as RuntimeIncomingStream, R as RuntimeClientOptions, H as RuntimeAuthIdentity, f as RuntimeLocalDeviceInfo, g as RuntimeLocalDeviceProfile, c as RuntimeDevice, a as RuntimeManagedSessionOptions, b as RuntimeManagedSession, d as RuntimeDeviceStatusSnapshot, e as RuntimeDeviceConnectOptions, X as RuntimeSession, q as RuntimeJoinRoomOptions, r as RuntimeRoomMember, K as RuntimeConnectionTarget, o as RuntimeScopedChannelOptions, p as RuntimeScopedLogicalChannel, m as RuntimePeerStreamOptions, v as RuntimeRawConnection, l as RuntimeChannelDescriptor, V as RuntimePresenceLoopOptions, k as RuntimePeerHealth, t as RuntimeApplicationPayloadReadinessOptions, u as RuntimeConnectionEvent } from './device-status-CR27Ak7c.js';
-import { R as RuntimeCapabilities, a as RuntimeCapabilityProfile } from './DelegatingRuntimeAdapter-D2_dgabz.js';
-import { P as PlutoIpcBridge, I as IpcRuntimeAdapter } from './IpcRuntimeAdapter-B8rkqNrq.js';
-import { WasmRuntimeAdapter } from './runtime/WasmRuntimeAdapter.js';
+import { G as GrantScope, I as ISignalingBackend, a as ConnectDeviceHooks, b as ConnectDeviceOptions, C as ConnectDeviceResult, M as ManagedConnectionRecord, P as PeerSessionSnapshot, R as ResolvedPeerIdentity, W as AppLimits, k as NativeConnectParams, l as NativeConnectResult, E as ExplicitFileDataSendParams } from './types-BCkKK8dy.js';
+import { h as RuntimePeerState, s as RuntimeConnectionStateSnapshot, j as RuntimePeerReadinessSnapshot, i as RuntimePeerConnectOptions, C as Connection, n as RuntimeIncomingStream, R as RuntimeClientOptions, H as RuntimeAuthIdentity, f as RuntimeLocalDeviceInfo, g as RuntimeLocalDeviceProfile, c as RuntimeDevice, a as RuntimeManagedSessionOptions, b as RuntimeManagedSession, d as RuntimeDeviceStatusSnapshot, e as RuntimeDeviceConnectOptions, X as RuntimeSession, q as RuntimeJoinRoomOptions, r as RuntimeRoomMember, K as RuntimeConnectionTarget, o as RuntimeScopedChannelOptions, p as RuntimeScopedLogicalChannel, m as RuntimePeerStreamOptions, v as RuntimeRawConnection, l as RuntimeChannelDescriptor, V as RuntimePresenceLoopOptions, k as RuntimePeerHealth, t as RuntimeApplicationPayloadReadinessOptions, u as RuntimeConnectionEvent } from './types-QMj23Nvm.js';
+import { R as RuntimeCapabilities, a as RuntimeCapabilityProfile } from './capabilities-C4Dqs_pB.js';
 
 /**
  * Coalesced peer reconciliation scheduler and full reconcile orchestration.
@@ -716,45 +714,5 @@ interface PlutoRuntimeAssembly<TBackend extends RuntimeAdapterWithAuth = Runtime
     connectDevice(device: any, options: any): Promise<any>;
     setAutoConnectExcluded(deviceId: string, excluded: boolean): Promise<void>;
 }
-/**
- * @deprecated Legacy assembly helper. Use `OpenRTC()` for app code.
- * Removal target: OpenRTC 0.2.0. This remains available from `openrtc/runtime`
- * only for advanced integrations that still need `PlutoRuntimeAssembly`.
- */
-declare function createWasmClient(options: RuntimeFactoryOptions): PlutoRuntimeAssembly<WasmRuntimeAdapter>;
-/**
- * @deprecated Legacy assembly helper. Use `OpenRTC.native()` for app code.
- * Removal target: OpenRTC 0.2.0. This remains available from `openrtc/runtime`
- * only for advanced integrations that still need `PlutoRuntimeAssembly`.
- */
-declare function createIpcClient(options: RuntimeFactoryOptions, bridge: PlutoIpcBridge): PlutoRuntimeAssembly<IpcRuntimeAdapter>;
-
-/**
- * Pure byte / stream / timing helpers.
- *
- * Extracted from the `Client` god object (see
- * `docs/plans/client-ts-decomposition.md` Phase 1). These functions are
- * deliberately pure — no `Client` state, no `this`, no logging side effects — so
- * the same helper is reused everywhere instead of being re-implemented inline
- * (e.g. `concatBytes` previously existed both here and in `applicationCrypto.ts`,
- * and three near-identical exponential-backoff helpers existed across the class).
- */
-
-type ByteArray = Uint8Array<ArrayBuffer>;
-type ByteArrayLike = Uint8Array<ArrayBufferLike>;
-
-type RuntimeU32BEFrameHandler = (payload: ByteArray) => void;
-type RuntimeJsonFrameHandler<T = unknown> = (value: T, payload: ByteArray) => void;
-interface RuntimeJsonFrameDecoderOptions {
-    onInvalidJson?: (error: unknown, payload: ByteArray) => void;
-}
-declare function encodeRuntimeU32BEFrame(payload: ByteArrayLike): ByteArray;
-declare function createRuntimeU32BEFrameDecoder(onFrame: RuntimeU32BEFrameHandler): (chunk: ByteArrayLike) => void;
-declare function encodeRuntimeJsonPayload(value: unknown): ByteArray;
-declare function decodeRuntimeJsonPayload<T = unknown>(payload: ByteArrayLike): T;
-declare function encodeRuntimeJsonFrame(value: unknown): ByteArray;
-declare function createRuntimeJsonFrameDecoder<T = unknown>(onValue: RuntimeJsonFrameHandler<T>, options?: RuntimeJsonFrameDecoderOptions): (chunk: ByteArrayLike) => void;
-declare function concatRuntimeBytes(a: ByteArrayLike, b: ByteArrayLike): ByteArray;
-declare function readRuntimeU32BE(bytes: ByteArrayLike, offset: number): number;
 
-export { createIpcClient as A, createWasmClient as B, readRuntimeU32BE as C, DriveGrantActorError as D, driveGrantConnectionKey as E, driveGrantConnectionKeyToString as F, OPENRTC_RUNTIME_POLICY as O, type PeerReconciliationStats as P, RuntimeClient as R, ScopedSession as S, type RuntimePolicySnapshot as a, type PlutoRuntimeAssembly as b, type RuntimeJsonFrameHandler as c, type RuntimeU32BEFrameHandler as d, type Session as e, type SessionOptions as f, createRuntimeJsonFrameDecoder as g, createRuntimeU32BEFrameDecoder as h, decodeRuntimeJsonPayload as i, encodeRuntimeJsonFrame as j, encodeRuntimeJsonPayload as k, encodeRuntimeU32BEFrame as l, getRuntimePolicy as m, type RuntimeFactoryOptions as n, type RuntimeJsonFrameDecoderOptions as o, type DriveGrantActorErrorKind as p, DriveGrantActorHandle as q, type DriveGrantActorHandleOptions as r, DriveGrantActorRegistry as s, type DriveGrantActorState as t, type DriveGrantClose as u, type DriveGrantDial as v, type DriveGrantConnectionKey as w, type DriveGrantLogicalChannelHandle as x, type DriveGrantPreferredTransport as y, concatRuntimeBytes as z };
+export { DriveGrantActorError as D, OPENRTC_RUNTIME_POLICY as O, type PeerReconciliationStats as P, RuntimeClient as R, ScopedSession as S, type RuntimePolicySnapshot as a, type PlutoRuntimeAssembly as b, type Session as c, type SessionOptions as d, type RuntimeFactoryOptions as e, type DriveGrantActorErrorKind as f, getRuntimePolicy as g, DriveGrantActorHandle as h, type DriveGrantActorHandleOptions as i, DriveGrantActorRegistry as j, type DriveGrantActorState as k, type DriveGrantClose as l, type DriveGrantDial as m, type DriveGrantConnectionKey as n, type DriveGrantLogicalChannelHandle as o, type DriveGrantPreferredTransport as p, driveGrantConnectionKey as q, driveGrantConnectionKeyToString as r };

package/dist/auth/index.js

@@ -1 +1 @@
-export{H as authHost,G as getAuthHost,F as registerDesktopAuthRelay}from'../chunk-34LATQZZ.js';import'../chunk-C7YN5MSV.js';
+export{H as authHost,G as getAuthHost,F as registerDesktopAuthRelay}from'../chunk-HVTYSEU7.js';import'../chunk-C7YN5MSV.js';

package/dist/auth/internal.js

@@ -1 +1 @@
-export{F as registerDesktopAuthRelay}from'../chunk-34LATQZZ.js';import'../chunk-C7YN5MSV.js';
+export{F as registerDesktopAuthRelay}from'../chunk-HVTYSEU7.js';import'../chunk-C7YN5MSV.js';

package/dist/capabilities-C4Dqs_pB.d.ts

@@ -0,0 +1,101 @@
+type RuntimeAdapterKind = 'browser-wasm' | 'native-ipc' | 'tauri-ipc' | 'unknown';
+interface RuntimeCapabilities {
+    adapter: RuntimeAdapterKind;
+    signaling: {
+        firestore: boolean;
+        nativeIpc: boolean;
+        rtdbPresence: boolean;
+    };
+    transport: {
+        irohQuic: boolean;
+        irohLan: boolean;
+        webRtcUpgrade: boolean;
+        webRtcLan: boolean;
+        nativeWebRtc: boolean;
+        moq: boolean;
+        ble: boolean;
+        wasm: boolean;
+    };
+    nativeProtocols: {
+        productAlpn: boolean;
+        irohDocs: boolean;
+        irohBlobs: boolean;
+        irohGossip: boolean;
+    };
+    lifecycle: {
+        managedSession: boolean;
+        autoConnect: boolean;
+        manualDisconnect: boolean;
+        connectionStateEvents: boolean;
+        peerSessions: boolean;
+    };
+    transfers: {
+        explicitFilePath: boolean;
+        explicitFileData: boolean;
+        history: boolean;
+    };
+    fallback: {
+        wasm: boolean;
+    };
+}
+interface RuntimeCapabilityProfile {
+    environment: 'web' | 'native' | 'unknown';
+    transports: {
+        quic: boolean;
+        irohRelay: boolean;
+        irohLan: boolean;
+        webRtc: boolean;
+        webRtcLan: boolean;
+        moq: boolean;
+        ble: boolean;
+    };
+    lifecycle: RuntimeCapabilities['lifecycle'];
+    storage: {
+        localFileSystem: boolean;
+        transferHistory: boolean;
+    };
+    nativeProtocols: RuntimeCapabilities['nativeProtocols'];
+}
+interface NativeRuntimeTransportFeatureStatus {
+    compiled?: boolean;
+    enabled?: boolean;
+}
+interface NativeRuntimeStatusSnapshot {
+    ready?: boolean;
+    nodeId?: string | null;
+    node_id?: string | null;
+    transport?: {
+        irohQuic?: NativeRuntimeTransportFeatureStatus;
+        irohLan?: NativeRuntimeTransportFeatureStatus;
+        webRtc?: NativeRuntimeTransportFeatureStatus;
+        webRtcLan?: NativeRuntimeTransportFeatureStatus;
+        moq?: NativeRuntimeTransportFeatureStatus;
+        ble?: NativeRuntimeTransportFeatureStatus;
+        irohRelayOnly?: boolean;
+        irohRelayTransportPolicy?: string | null;
+    };
+}
+declare const BROWSER_WASM_RUNTIME_CAPABILITIES: RuntimeCapabilities;
+/**
+ * The small host surface that browser WebRTC capability reporting needs.
+ *
+ * This is deliberately a feature check only: capability reporting must not
+ * create a peer connection, probe ICE, or influence route ownership.
+ */
+interface BrowserRuntimeCapabilityHost {
+    RTCPeerConnection?: unknown;
+}
+declare const NATIVE_IPC_RUNTIME_CAPABILITIES: RuntimeCapabilities;
+declare function cloneRuntimeCapabilities(capabilities: RuntimeCapabilities): RuntimeCapabilities;
+/**
+ * Returns browser/WASM capabilities for a concrete JavaScript host.
+ *
+ * The static browser baseline describes package support. WebRTC additionally
+ * requires the browser primitive to exist at runtime. Passing the host keeps
+ * the resolver deterministic in SSR and test environments.
+ */
+declare function runtimeCapabilitiesForBrowserHost(host?: BrowserRuntimeCapabilityHost | null | undefined): RuntimeCapabilities;
+declare function runtimeCapabilitiesFromNativeStatus(status: NativeRuntimeStatusSnapshot | null | undefined, allowWasmFallback?: boolean): RuntimeCapabilities;
+declare function runtimeCapabilityProfile(capabilities: RuntimeCapabilities): RuntimeCapabilityProfile;
+
+export { BROWSER_WASM_RUNTIME_CAPABILITIES as B, NATIVE_IPC_RUNTIME_CAPABILITIES as N, type RuntimeCapabilities as R, type RuntimeCapabilityProfile as a, type RuntimeAdapterKind as b, type BrowserRuntimeCapabilityHost as c, type NativeRuntimeStatusSnapshot as d, type NativeRuntimeTransportFeatureStatus as e, cloneRuntimeCapabilities as f, runtimeCapabilitiesFromNativeStatus as g, runtimeCapabilityProfile as h, runtimeCapabilitiesForBrowserHost as r };