openrtc 0.1.2 → 0.2.0

package/dist/runtime/index.js

@@ -1 +1 @@
-export{f as DriveGrantActorError,i as DriveGrantActorHandle,j as DriveGrantActorRegistry,k as RuntimeClient,b as RuntimeConnectionController,f as ScopedConnectionActorError,i as ScopedConnectionActorHandle,j as ScopedConnectionActorRegistry,e as clog,d as correlationForDriveGrantScope,m as createIpcClient,l as createWasmClient,g as driveGrantConnectionKey,h as driveGrantConnectionKeyToString,c as renderCorrelationFields,g as scopedConnectionKey,h as scopedConnectionKeyToString}from'../chunk-CQAKCS2S.js';export{a as WasmRuntimeAdapter}from'../chunk-D54VGRRH.js';export{b as TauriRuntimeAdapter,a as createTauriIpcBridge}from'../chunk-UVASANPG.js';export{b as IpcRuntimeAdapter}from'../chunk-DIQYFAGL.js';export{r as BROWSER_WASM_RUNTIME_CAPABILITIES,s as NATIVE_IPC_RUNTIME_CAPABILITIES,p as OPENRTC_RUNTIME_POLICY,t as cloneRuntimeCapabilities,q as getRuntimePolicy,i as logOpenRtcTeardownTrace}from'../chunk-PZ25OCVG.js';import'../chunk-4MH42GUI.js';
+export{q as RuntimeClient,h as RuntimeConnectionController,l as ScopedConnectionActorError,o as ScopedConnectionActorHandle,p as ScopedConnectionActorRegistry,k as clog,j as correlationForDriveGrantScope,s as createIpcClient,r as createWasmClient,i as renderCorrelationFields,m as scopedConnectionKey,n as scopedConnectionKeyToString}from'../chunk-MFT6SOZ6.js';export{a as WasmRuntimeAdapter}from'../chunk-VARALO7G.js';export{b as TauriRuntimeAdapter,a as createTauriIpcBridge}from'../chunk-SGZWR63E.js';export{c as IpcRuntimeAdapter}from'../chunk-WOHFM6DI.js';export{s as BROWSER_WASM_RUNTIME_CAPABILITIES,t as NATIVE_IPC_RUNTIME_CAPABILITIES,q as OPENRTC_RUNTIME_POLICY,u as cloneRuntimeCapabilities,r as getRuntimePolicy,i as logOpenRtcTeardownTrace,c as openRtcDebug,b as openRtcDebugEnabled,d as openRtcDebugInfo,e as openRtcDebugLog,v as runtimeCapabilityProfile}from'../chunk-JXGKO7SX.js';import'../chunk-YHJOXD46.js';import'../chunk-3VTF5RKW.js';

package/dist/runtime/tauri.d.ts

@@ -1,7 +1,6 @@
-import { N as NativeIpcBridgeOptions, I as IpcRuntimeAdapter, P as PlutoIpcBridge } from '../IpcRuntimeAdapter-CT-W0Mtp.js';
-import '../DelegatingRuntimeAdapter-CW8d78dZ.js';
-
-type TauriBridgeOptions = NativeIpcBridgeOptions;
+import { I as IpcRuntimeAdapter, N as NativeIpcBridgeOptions, P as PlutoIpcBridge } from '../IpcRuntimeAdapter-CtckyMol.js';
+import '../types-DyCGvj9l.js';
+import '../DelegatingRuntimeAdapter-CjHzBEBA.js';
 
 /**
  * @deprecated Native Tauri support now lives in the first-party `openrtc-tauri` package.
@@ -13,8 +12,8 @@ declare function createTauriIpcBridge(): PlutoIpcBridge;
  * Removal target: OpenRTC 0.2.0. This shim remains for one compatibility cycle.
  */
 declare class TauriRuntimeAdapter extends IpcRuntimeAdapter {
-    constructor(options: TauriBridgeOptions);
+    constructor(options: NativeIpcBridgeOptions);
 }
-type TauriRuntimeAdapterOptions = TauriBridgeOptions;
+type TauriRuntimeAdapterOptions = NativeIpcBridgeOptions;
 
 export { TauriRuntimeAdapter, type TauriRuntimeAdapterOptions, createTauriIpcBridge };

package/dist/runtime/tauri.js

@@ -1 +1 @@
-export{b as TauriRuntimeAdapter,a as createTauriIpcBridge}from'../chunk-UVASANPG.js';import'../chunk-DIQYFAGL.js';import'../chunk-PZ25OCVG.js';import'../chunk-4MH42GUI.js';
+export{b as TauriRuntimeAdapter,a as createTauriIpcBridge}from'../chunk-SGZWR63E.js';import'../chunk-WOHFM6DI.js';import'../chunk-JXGKO7SX.js';import'../chunk-YHJOXD46.js';import'../chunk-3VTF5RKW.js';

package/dist/transport/index.d.ts

@@ -0,0 +1,11 @@
+import { n as ProtocolName } from '../types-DyCGvj9l.js';
+
+declare const TRANSPORT_LABELS: readonly ProtocolName[];
+declare function normalizeTransportLabel(value: unknown): ProtocolName | undefined;
+declare function isIrohBaseTransportLabel(value: unknown): boolean;
+declare function isDirectIrohTransportLabel(value: unknown): boolean;
+declare function isOptionalTransportLabel(value: unknown): boolean;
+declare function isWebRtcTransportLabel(value: unknown): boolean;
+declare function isIndependentTransportLabel(value: unknown): boolean;
+
+export { ProtocolName, TRANSPORT_LABELS, isDirectIrohTransportLabel, isIndependentTransportLabel, isIrohBaseTransportLabel, isOptionalTransportLabel, isWebRtcTransportLabel, normalizeTransportLabel };

package/dist/transport/index.js

@@ -0,0 +1 @@
+export{a as TRANSPORT_LABELS,d as isDirectIrohTransportLabel,g as isIndependentTransportLabel,c as isIrohBaseTransportLabel,e as isOptionalTransportLabel,f as isWebRtcTransportLabel,b as normalizeTransportLabel}from'../chunk-3VTF5RKW.js';

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

@@ -5,32 +5,58 @@ interface AppLimits {
     maxRooms: number;
     /** Max members per room. -1 = unlimited. */
     maxMembersPerRoom: number;
-    /** Max active devices across all provisioned personal spaces for this app. -1 = unlimited. */
+    /** Max active devices across all provisioned spaces for this app. -1 = unlimited. */
     maxPersonalDevices: number;
 }
 interface PlutoRTCConfiguration extends RTCConfiguration {
     iceServers?: RTCIceServer[];
     privacyMode?: boolean;
     useTurn?: boolean;
+    /** Prefer host/srflx ICE candidates and upgrade aggressively on LAN. */
+    lanMode?: boolean;
+}
+interface LocalPeerSnapshot {
+    nodeId: string;
+    discoveredAtMs: number;
+    localReachable: boolean;
 }
 interface PlutoMoQConfiguration {
     relayUrl?: string;
 }
 interface PlutoIrohConfiguration {
     relayOnly?: boolean;
+    relayTransportPolicy?: 'auto' | 'quicRequired' | 'websocketRequired';
     persistenceMode?: 'persistent' | 'ephemeral';
+    /** Enable native iroh mDNS LAN discovery (native runtimes only). */
+    localDiscovery?: boolean;
+    /** When false, listen for LAN peers without advertising this endpoint. */
+    localDiscoveryMode?: 'active' | 'passive';
+}
+interface PlutoBleConfiguration {
+    /** Enable native BLE discovery + transport (native runtimes only). */
+    enabled?: boolean;
+    /** Timeout for a single BLE connection attempt. */
+    connectTimeoutMs?: number;
+    /** Preferred retry budget for native BLE connection establishment. */
+    retryAttempts?: number;
+    /** Backoff between BLE retry attempts. */
+    retryBackoffMs?: number;
 }
 interface TurnCredentials {
     iceServers?: RTCIceServer[];
 }
 type TurnCredentialsProvider = () => Promise<TurnCredentials | null | undefined>;
-type DiscoveryMode = 'personal' | 'user-scoped';
+type DiscoveryMode = 'space' | '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';
+type PeerLifecycleStage = 'discovered' | 'dialing' | 'base-connected' | 'admitted' | 'protocol-ready' | 'upgrading' | 'webrtc-ready' | 'degraded' | 'reconnecting' | 'closed';
+type PeerBaseTransportState = 'unknown' | 'connecting' | 'connected' | 'degraded' | 'closed';
+type PeerAdmissionState = 'unknown' | 'pending' | 'admitted' | 'rejected' | 'expired';
+type PeerWebRtcState = 'unknown' | 'disabled' | 'connecting' | 'transport-open' | 'route-probing' | 'ready' | 'failed' | 'closed';
 /**
  * Lifecycle label attached to a projected peer while the runtime tracks local ownership.
  *
@@ -62,15 +88,30 @@ interface ChannelDescriptor {
     signalingPolicy?: ChannelSignalingPolicy;
     description?: string;
 }
-type ProtocolName = 'iroh' | 'iroh-quic' | 'iroh-relay' | 'webrtc' | 'moq';
+type ProtocolName = 'iroh' | 'iroh-quic' | 'iroh-relay' | 'iroh-lan' | 'ble' | 'webrtc' | 'webrtc-lan' | 'moq';
 type ProtocolMaturity = 'stable' | 'experimental' | 'unsupported';
+type ProtocolBaseName = 'iroh' | 'webrtc' | 'moq';
+type ProtocolImplementationKind = 'plugin' | 'native' | 'path-label';
+type ProtocolLocality = 'nearby' | 'direct-internet' | 'relay' | 'mixed';
 interface ProtocolCapability {
     protocol: ProtocolName;
+    baseProtocol: ProtocolBaseName;
+    implementation: ProtocolImplementationKind;
+    locality: ProtocolLocality;
     maturity: ProtocolMaturity;
+    preferredRank: number;
+    browser: boolean;
+    native: boolean;
     available: boolean;
     reason?: string;
 }
 type ProtocolCapabilityMap = Record<ProtocolName, ProtocolCapability>;
+/** Space discovery always uses namespace-scoped Firebase tokens. */
+type SpaceAuthMode = 'scoped-token';
+type SpaceTokenProvider = () => Promise<{
+    customToken: string;
+    uid?: string;
+} | null | undefined>;
 interface ClientOptions {
     /**
      * API key issued from the Pluto developer dashboard (https://api.openrtc.app/developer).
@@ -78,26 +119,23 @@ interface ClientOptions {
      */
     apiKey?: string;
     /**
-     * Explicitly opt in to the legacy shared hosted fallback when no apiKey is provided.
-     *
-     * This should only be used for controlled demos/tests. Production integrations
-     * should always provide an API key.
-     */
-    allowAnonymousHostedDefaults?: boolean;
-    /**
-     * Discovery mode for this app. Defaults to 'personal'.
-     * - 'personal': No user accounts. Devices share a spaceKey to discover each other.
+     * Discovery mode for this app. Defaults to 'space'.
+     * - 'space': Devices share a space and authenticate with scoped Firebase tokens.
      * - 'user-scoped': Developer mints tokens for their users. Devices scoped per user.
      *
      * Set in the developer dashboard. The server validates this against the app's plan.
      */
     discoveryMode?: DiscoveryMode;
     /**
-     * Space key for 'personal' discovery mode. Acts as a shared secret that scopes
-     * device discovery without requiring user authentication. Devices with the same
-     * spaceKey + apiKey will see each other.
+     * Shared space name for 'space' discovery mode. This is the beginner-facing
+     * name for `spaceKey`; if both are set, `spaceKey` wins.
+     */
+    space?: string;
+    /**
+     * Space key for 'space' discovery mode. The SDK derives a namespace from
+     * apiKey + spaceKey, then authenticates with spaceTokenProvider.
      *
-     * Only used when discoveryMode is 'personal'. Ignored for managed modes.
+     * Only used when discoveryMode is 'space'. Ignored for managed modes.
      */
     spaceKey?: string;
     /**
@@ -106,6 +144,11 @@ interface ClientOptions {
      */
     sessionToken?: string;
     authMode?: AuthMode;
+    /**
+     * Allows first-party demos to use hosted defaults when an API key is omitted.
+     * Product apps should pass an API key.
+     */
+    allowAnonymousHostedDefaults?: boolean;
     signalingMode?: SignalingMode;
     projectId?: string;
     storagePrefix?: string;
@@ -130,10 +173,38 @@ interface ClientOptions {
     transports?: {
         iroh?: boolean | PlutoIrohConfiguration;
         webrtc?: boolean | PlutoRTCConfiguration;
+        ble?: boolean | PlutoBleConfiguration;
         moq?: boolean | PlutoMoQConfiguration;
     };
     transportPriority?: ProtocolName[];
+    /** Subscribe to native LAN peer discovery events. */
+    onLocalPeer?: (peer: LocalPeerSnapshot) => void;
     disableIrohFallback?: boolean;
+    /**
+     * Optional application-layer payload envelope. When configured, OpenRTC
+     * protects public message/media payload bytes before they are handed to
+     * iroh, WebRTC, or MoQ and opens them before app callbacks fire.
+     */
+    applicationCrypto?: ApplicationPayloadCrypto;
+    /**
+     * When manual `applicationCrypto` is not set, peers must negotiate an
+     * ephemeral X25519 ECDH key during transport handshake. Disabling is not
+     * supported in secure deployments.
+     */
+    automaticApplicationKeyAgreement?: boolean;
+    /**
+     * @internal Overrides orphan drift grace windows for tests and diagnostics.
+     */
+    orphanReconciliationGrace?: {
+        tsConnectionMs?: number;
+        rustRecordMs?: number;
+    };
+    /**
+     * Mints a namespace-scoped Firebase custom token for space discovery.
+     * Required when `discoveryMode` is `space` and `space`/`spaceKey` is set.
+     * Use `spaceToken` for browser demos.
+     */
+    spaceTokenProvider?: SpaceTokenProvider;
 }
 interface Device {
     deviceId: string;
@@ -159,6 +230,8 @@ interface Device {
     updatedAt?: any;
     metadata?: string;
     excludedPeers?: string[];
+    availableTransports?: ProtocolName[];
+    transports?: ProtocolName[];
 }
 interface PeerState {
     peerId: string;
@@ -173,13 +246,22 @@ interface PeerState {
     platformType?: string;
     status: PeerLifecycleStatus;
     health: PeerHealth;
+    lifecycleStage?: PeerLifecycleStage;
+    generation?: number;
+    baseTransportState?: PeerBaseTransportState;
+    admissionState?: PeerAdmissionState;
     transportState?: string;
     protocolState?: string;
+    webrtcState?: PeerWebRtcState;
     routable?: boolean;
     activeTransportStableId?: number | null;
     transportGeneration?: number;
     activeTransport?: ProtocolName;
+    fallbackTransport?: ProtocolName | null;
     parallelTransport?: ProtocolName | null;
+    manualDisconnect?: boolean;
+    lastAuthoritativeEventAt?: number;
+    lastTransientEventAt?: number;
     promotionEligible?: boolean;
     scopes: PeerScope[];
     lastSeenAt?: number;
@@ -218,6 +300,7 @@ interface NativeConnectResult {
     deviceIdHint?: string | null;
     remoteNodeId?: string | null;
     state: string;
+    approvedScope?: string | null;
 }
 interface BackendPeerBiStream {
     readable: ReadableStream<Uint8Array>;
@@ -260,6 +343,8 @@ interface SignalingEnvelope {
     name?: string;
     senderId: string;
     targetId: string;
+    senderUserId?: string;
+    targetUserId?: string;
     state?: string;
     payload: string;
     replyPayload?: string;
@@ -367,6 +452,7 @@ interface DeviceStatusSnapshot extends Device {
     transportGeneration?: number;
     activeTransport?: ProtocolName;
     parallelTransport?: ProtocolName | null;
+    availableTransports?: ProtocolName[];
 }
 interface ManagedConnectionRecord {
     connectionId: string;
@@ -473,11 +559,21 @@ interface ExplicitFileDataSendParams {
         send: (message: unknown) => Promise<void>;
         deviceId?: string;
         remoteNodeId?: string;
+        requireApplicationCrypto?: boolean;
+        getUpgradeState?: () => string;
+        isWebRtcApplicationRouteReady?: () => boolean;
+        sendOnWebRTC?: (data: Uint8Array) => Promise<void>;
+        getWebRTCTransport?: () => {
+            getBufferedAmount?: () => number;
+            waitForDrain?: (lowWaterMark: number) => Promise<void>;
+        } | null;
     };
     remoteNodeId?: string;
     file: File;
     transferId: string;
     channelId?: string;
+    applicationCrypto?: ApplicationPayloadCrypto;
+    requireApplicationCrypto?: boolean;
 }
 interface ISignalingBackend {
     currentUser: RuntimeIdentity | null;
@@ -537,19 +633,18 @@ interface ISignalingBackend {
     }): Promise<string | null>;
     getEndpointTicket?(): Promise<string>;
     openPeerBi?(id: string, timeoutMs?: number): Promise<BackendPeerBiStream>;
+    openPeerNativeBi?(id: string, label: string, timeoutMs?: number): Promise<BackendPeerBiStream>;
     openPeerUni?(id: string, timeoutMs?: number): Promise<BackendPeerUniStream>;
     connectToDevice?(params: {
         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.
+     * Optional backchannel so a backend (e.g. WasmBridge) can access the narrow
+     * facade surface needed to escalate runtime transport dials into registered
+     * TS connections.
      */
-    setCoreClient?(client: unknown): void;
+    setCoreClient?(client: CoreClientBridgeHost | null): void;
     disconnectDevice?(deviceId: string): Promise<void>;
     setAutoConnectExcluded?(deviceId: string, excluded: boolean): Promise<void>;
     isConnected(nodeId: string): Promise<boolean>;
@@ -560,30 +655,109 @@ interface ISignalingBackend {
     getTransferHistory?(limit?: number): Promise<Array<[string, unknown]>>;
     deleteTransferJob?(jobId: string): Promise<void>;
 }
+interface CoreClientBridgeHost {
+    connect(ticket: string, timeoutMs?: number, expectedDeviceId?: string | null, channelId?: string, options?: {
+        admissionAlreadyPresented?: boolean;
+        approvedScope?: string | null;
+    }): Promise<{
+        remoteNodeId?: string | null;
+        deviceId?: string | null;
+    } | unknown>;
+    waitForApplicationCryptoForPeer?(peerId?: string, timeoutMs?: number): Promise<unknown>;
+    hasApplicationRouteForPeer?(connectionId?: string, remoteNodeId?: string): boolean;
+}
 interface SignalingOptions {
     apiKey?: string;
-    allowAnonymousHostedDefaults?: boolean;
     authMode?: AuthMode;
     projectId?: string;
     storagePrefix?: string;
     nodeIdPersistence?: 'persistent' | 'ephemeral';
 }
 interface TransportContext {
-    sendMoQ: (data: Uint8Array) => Promise<void>;
+    sendMoQ: (data: Uint8Array, options?: {
+        alreadyProtected?: boolean;
+    }) => Promise<void>;
     priorities: ProtocolName[];
     disableIrohFallback: boolean;
     isMoQReady: () => boolean;
     runtimeFlow?: 'default' | 'ticket-only';
     readerCloseStrategy?: 'cancel' | 'release-lock';
 }
+interface ApplicationPayloadCrypto {
+    /**
+     * When true, incoming application payloads that are not encrypted by this
+     * envelope are dropped before app callbacks fire.
+     */
+    requireEncrypted?: boolean;
+    protectPayload: (typeId: number, payload: Uint8Array) => Uint8Array;
+    openPayload: (expectedTypeId: number, payload: Uint8Array) => Uint8Array | null;
+}
+interface ApplicationCryptoBiStream {
+    send: WritableStream<Uint8Array>;
+    recv: ReadableStream<Uint8Array>;
+    endpoint_id?: string;
+}
+interface ApplicationCryptoStreamTools {
+    readonly typeId: number;
+    protectFrame: (payload: Uint8Array) => Uint8Array;
+    openFrame: (payload: Uint8Array) => Uint8Array | null;
+    createOutboundTransform: () => TransformStream<Uint8Array, Uint8Array>;
+    createInboundTransform: () => TransformStream<Uint8Array, Uint8Array>;
+    wrapReadable: (readable: ReadableStream<Uint8Array>) => ReadableStream<Uint8Array>;
+    wrapWritable: (writable: WritableStream<Uint8Array>) => WritableStream<Uint8Array>;
+    wrapBiStream: <T extends ApplicationCryptoBiStream>(stream: T) => T;
+}
+interface ApplicationPayloadReadinessOptions {
+    /**
+     * When provided, a connection is considered ready only once its active
+     * application route is one of these transports.
+     */
+    preferredTransports?: ProtocolName[];
+    /**
+     * If a preferred upgraded route cannot be established, allow the connection's
+     * proven application route to carry payloads instead of remaining pending.
+     */
+    allowFallbackAfterPreferredTransportFailure?: boolean;
+}
+interface ApplicationPayloadRouteOptions extends ApplicationPayloadReadinessOptions {
+    /**
+     * Include the parallel/fallback transport in diagnostic route listings.
+     * Normal app payload probes should leave this disabled so they measure the
+     * route OpenRTC would actually prefer for application data.
+     */
+    includeFallbackTransports?: boolean;
+}
+interface ApplicationPayloadSendOptions extends ApplicationPayloadRouteOptions {
+}
 interface ConnectionOptions {
     reliable?: boolean;
-    rtcConfig?: RTCConfiguration;
+    rtcConfig?: PlutoRTCConfiguration;
     transportContext?: TransportContext;
+    applicationCrypto?: ApplicationPayloadCrypto;
+    /** Framing used by the underlying iroh control stream. */
+    controlFrameMode?: 'typed' | 'native-main';
+    /**
+     * When true, public application payload sends wait for applicationCrypto to
+     * be installed and fail closed if key negotiation never completes.
+     * Internal handshake/control frames are sent through a separate control path.
+     */
+    requireApplicationCrypto?: boolean;
+    applicationCryptoWaitMs?: number;
     onTransportStatusChange?: (status: {
         activeTransport: ProtocolName;
         parallelTransport?: ProtocolName | null;
     }) => void;
+    /**
+     * Fired when the WebRTC data plane has proven a ping/pong round trip but the
+     * mandatory application crypto route is not installed yet. Connection owns
+     * transport proof; Client owns the application-route handshake recovery.
+     */
+    onApplicationRouteMissing?: (event: {
+        connectionId: string;
+        remoteNodeId: string;
+        reason: 'webrtc-heartbeat-before-crypto';
+        negotiationId?: string | null;
+    }) => void;
 }
 interface JoinRequest {
     id: string;
@@ -592,148 +766,4 @@ interface JoinRequest {
     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 };
+export type { ScanningLoopOptions as $, AuthMode as A, BackendPeerBiStream as B, ClientOptions as C, DiscoveryMode as D, ExplicitFileDataSendParams as E, ProtocolLocality as F, GrantScope as G, SpaceAuthMode as H, ISignalingBackend as I, ConnectionOptions as J, ChannelDescriptor as K, LocalDeviceInfo as L, ManagedConnectionRecord as M, NativeManagedSessionStartResult as N, IncomingStreamChannelMetadata as O, PeerSessionSnapshot as P, ManagedDeviceConnectOptions as Q, RuntimeIdentity as R, SignalingMode as S, PeerState as T, PeerHealth as U, JoinRoomOptions as V, RoomMember as W, PeerScope as X, PeerLifecycleStatus as Y, SignalingOptions as Z, RoomCreationMode as _, Device as a, ScanningLoopHandle as a0, RuntimeBootstrapOptions as a1, RuntimeBootstrapResult as a2, JoinRequest as a3, DeviceStatusSnapshot as b, ResolvedPeerIdentity as c, SignalingEnvelope as d, DeviceEvent as e, SignalingSession as f, SessionEvent as g, BackendPeerUniStream as h, NativeConnectResult as i, BackendConnectionState as j, ConnectDeviceResult as k, ConnectDeviceHooks as l, ConnectDeviceOptions as m, ProtocolName as n, ProtocolCapability as o, ProtocolCapabilityMap as p, ApplicationPayloadCrypto as q, ApplicationCryptoStreamTools as r, SpaceTokenProvider as s, AppLimits as t, ApplicationCryptoBiStream as u, ApplicationPayloadReadinessOptions as v, ApplicationPayloadRouteOptions as w, ApplicationPayloadSendOptions as x, ProtocolBaseName as y, ProtocolImplementationKind as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openrtc",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "private": false,
   "type": "module",
   "sideEffects": false,
@@ -27,13 +27,7 @@
     "dist/**/*.js",
     "dist/**/*.d.ts",
     "dist/**/*.wasm",
-    "README.md",
-    "wasm/openrtc.js",
-    "wasm/openrtc.d.ts",
-    "wasm/openrtc_bg.wasm",
-    "wasm/openrtc_bg.wasm.d.ts",
-    "wasm/package.json",
-    "wasm/README.md"
+    "README.md"
   ],
   "exports": {
     ".": {
@@ -56,6 +50,10 @@
       "types": "./dist/runtime/tauri.d.ts",
       "import": "./dist/runtime/tauri.js"
     },
+    "./transport": {
+      "types": "./dist/transport/index.d.ts",
+      "import": "./dist/transport/index.js"
+    },
     "./auth/internal": {
       "types": "./dist/auth/internal.d.ts",
       "import": "./dist/auth/internal.js"
@@ -65,10 +63,11 @@
   "scripts": {
     "build": "tsup",
     "build:types": "tsc --noEmit",
-    "build:wasm": "cd ../../crates/openrtc && wasm-pack build --target web --out-dir ../../packages/openrtc/wasm && rm -rf ../../packages/openrtc/wasm/.gitignore",
+    "build:wasm": "cd ../../crates/openrtc && OPENRTC_REPO_ROOT=$(cd ../.. && pwd) && CARGO_REGISTRY_ROOT=${CARGO_HOME:-$HOME/.cargo} && RUSTUP_TOOLCHAIN=nightly RUSTFLAGS=\"-Zlocation-detail=none --remap-path-prefix=$HOME=/home --remap-path-prefix=$CARGO_REGISTRY_ROOT=/cargo --remap-path-prefix=$OPENRTC_REPO_ROOT=/openrtc\" wasm-pack build --target web --out-dir ../../packages/openrtc/wasm && rm -rf ../../packages/openrtc/wasm/.gitignore",
     "test": "pnpm run test:deterministic",
     "test:deterministic": "OPENRTC_LIVE_TESTS=0 vitest run tests/unit tests/contract",
-    "test:emulator": "OPENRTC_EMULATOR_TESTS=1 OPENRTC_LIVE_TESTS=1 FIREBASE_AUTH_EMULATOR_HOST=127.0.0.1:9100 VITE_USE_EMULATORS=true VITE_OPENRTC_FIRESTORE_EMULATOR_HOST=127.0.0.1:8082 VITE_OPENRTC_RTDB_EMULATOR_HOST=127.0.0.1:9001 vitest run tests/emulator",
+    "test:emulator": "node ../../tests/emulator/run-emulator-suite.mjs",
+    "test:emulator:running": "OPENRTC_EMULATOR_TESTS=1 REQUIRE_OPENRTC_EMULATOR_TESTS=1 OPENRTC_LIVE_TESTS=0 FIREBASE_AUTH_EMULATOR_HOST=127.0.0.1:9100 FIRESTORE_EMULATOR_HOST=127.0.0.1:8082 OPENRTC_FIRESTORE_HOST=127.0.0.1:8082 VITE_USE_EMULATORS=true VITE_OPENRTC_FIRESTORE_EMULATOR_HOST=127.0.0.1:8082 VITE_OPENRTC_RTDB_EMULATOR_HOST=127.0.0.1:9001 vitest run tests/emulator",
     "test:live": "pnpm run build:wasm && pnpm run build && OPENRTC_LIVE_TESTS=1 vitest run tests/live",
     "test:live:emulator": "OPENRTC_LIVE_TESTS=1 FIREBASE_AUTH_EMULATOR_HOST=127.0.0.1:9099 vitest run tests/live",
     "test:watch": "vitest",
@@ -76,6 +75,9 @@
     "prepublishOnly": "npm run build:wasm && npm run build"
   },
   "dependencies": {
+    "@noble/ciphers": "^2.2.0",
+    "@noble/curves": "^1.9.0",
+    "@noble/hashes": "^1.8.0",
     "firebase": "^9.0.0 || ^10.0.0 || ^11.0.0 || ^12.0.0",
     "tweetnacl": "^1.0.3"
   },