openrtc 2.0.0-rc.8 → 2.0.0

package/README.md

@@ -24,8 +24,6 @@ import { OpenRTC } from 'openrtc';
 
 const rtc = OpenRTC({ apiKey: import.meta.env.VITE_OPENRTC_API_KEY });
 const cursors = await rtc.spaces.join('portfolio-cursors', {
-  access: 'capability',
-  identity: 'ephemeral',
   payload: 'latest-state',
 });
 
@@ -63,9 +61,19 @@ const rtc = OpenRTC({
 const devices = await rtc.devices.start({
   auth,
   autoConnect: 'online',
+  // Optional. Browser clients infer labels such as "Chrome on Android";
+  // native clients should pass the host-reported OS and user-visible name.
+  profile: { name: "Bryant's iPhone", platform: 'ios' },
 });
 ```
 
+`profile` is presentation metadata, not device identity. OpenRTC continues to
+bind enrollment and limits to its stable installation ID and device key. A
+changed profile updates the existing enrollment once; it does not enroll or
+bill a second device. User-assigned hardware names are not exposed by every
+browser or mobile OS, so privacy-safe defaults identify the available
+environment (for example `iPhone`, `Chrome on iPhone`, or `Chrome on Android`).
+
 Consumer apps own login UX, product authorization, IdP registration, and
 platform-attestation setup. OpenRTC owns assertion validation, device binding,
 grant issuance and refresh, revocation, budgets, metering, and abuse controls.
@@ -75,11 +83,7 @@ grant issuance and refresh, revocation, budgets, metering, and abuse controls.
 Rooms default to ephemeral membership:
 
 ```ts
-const room = await rtc.rooms.join('match-123', {
-  access: 'capability',
-  membership: 'ephemeral',
-  maxPeers: 8,
-});
+const room = await rtc.rooms.join('match-123');
 ```
 
 Durable membership is an advanced capability and must be enabled in the
@@ -102,7 +106,7 @@ Attestation is evaluated at device enrollment, key rotation, recovery, or risk
 escalation—not as a connection heartbeat.
 
 ```ts
-import { FirebaseAppCheckAttestationProvider } from '@openrtc/trust-firebase-app-check';
+import { FirebaseAppCheckAttestationProvider } from 'openrtc-trust-firebase-app-check';
 
 const rtc = OpenRTC({
   apiKey,

package/dist/DelegatingRuntimeAdapter-BFZDC604.d.ts

@@ -0,0 +1,397 @@
+import { D as Device, h as DiscoveryMode, A as AuthMode, S as SignalingMode, g as ClientOptions, E as ExplicitFileDataSendParams, I as ISignalingBackend, L as LocalDeviceInfo, i as RoomMember, j as RuntimeIdentity, k as SignalingEnvelope, l as DeviceStatusSnapshot, d as PeerSessionSnapshot, B as BackendPeerBiStream, m as BackendPeerUniStream, M as ManagedConnectionRecord, R as ResolvedPeerIdentity, n as DeviceEvent, o as DesiredPeerProjection, p as CoreClientBridgeHost, N as NativeConnectParams, q as NativeConnectResult, r as SignalingSession, s as SessionEvent, t as BackendConnectionState, u as NativeManagedSessionStartResult, G as GrantScope } from './ITransport-WV6gGMnX.js';
+import { I as IrohBrowserProtocolStore, w as IrohNamespaceDescriptor, x as IrohMutationReceipt, y as IrohDocEntry, A as AuthContext } from './types-DVNSd5B9.js';
+import { R as RuntimeCapabilities } from './capabilities-BfZi4Cd7.js';
+
+interface NativeTrustToken {
+    token: string;
+    expiresAtMs: number;
+}
+
+/** Internal-only gateway record before normalization; includes namespace fields omitted from the public Device type. */
+type RawDeviceDoc = Device & {
+    appTag?: string;
+    tag?: string;
+};
+
+interface WasmBridgeOptions {
+    apiKey?: string;
+    discoveryMode?: DiscoveryMode;
+    space?: string;
+    spaceKey?: string;
+    authMode?: AuthMode;
+    signalingMode?: SignalingMode;
+    projectId?: string;
+    coordinationGateway?: ClientOptions['coordinationGateway'];
+    coordinationAvenueOverride?: ClientOptions['coordinationAvenueOverride'];
+    platformAttestationTokenProvider?: ClientOptions['platformAttestationTokenProvider'];
+    /** Internal host hint used by the provider-neutral gateway projection. */
+    coordinationPlatformType?: string;
+    storagePrefix?: string;
+    deviceIdPersistence?: 'persistent' | 'ephemeral';
+    endpointIdPersistence?: 'persistent' | 'ephemeral';
+    nodeIdPersistence?: 'persistent' | 'ephemeral';
+    localDeviceId?: string;
+    deviceName?: string;
+    turnCredentialsProvider?: () => Promise<{
+        iceServers?: RTCIceServer[];
+    } | null | undefined>;
+    applicationCrypto?: ExplicitFileDataSendParams['applicationCrypto'];
+    spaceAuth?: 'scoped-token';
+}
+/**
+ * WasmBridge is the browser host wrapper over the Rust/WASM runtime.
+ *
+ * Allowed:
+ * - normalize JS/WASM binding shapes
+ * - forward auth, discovery, signaling, and lifecycle calls into Rust
+ * - expose typed browser-facing results
+ *
+ * Not allowed:
+ * - become a second lifecycle engine
+ * - invent peer identity or connect policy that is not backed by Rust
+ * - normalize app-specific payload protocols into runtime behavior
+ *
+ * Source of truth:
+ * - Rust/WASM owns transport/runtime connection state and lifecycle primitives
+ * - The selected coordination provider owns browser delivery projections
+ * - RuntimeClient owns app-facing orchestration across those surfaces
+ */
+declare class WasmBridge implements ISignalingBackend {
+    private static readonly EXPLICIT_FILE_PROTOCOL_TYPE;
+    private static readonly EXPLICIT_FILE_CHUNK_SIZE_BYTES;
+    private static readonly MAX_EXPLICIT_TRANSFER_HEADER_BYTES;
+    private static readonly FALLBACK_EXPLICIT_FILE_NAME;
+    private static readonly MAX_EXPLICIT_FILE_NAME_CHARS;
+    private static readonly FALLBACK_EXPLICIT_MIME_TYPE;
+    private static readonly MAX_EXPLICIT_MIME_TYPE_CHARS;
+    app: any | null;
+    auth: any | null;
+    private readonly appTag;
+    protected options: {
+        appTag: string;
+        apiKey?: string;
+        discoveryMode?: DiscoveryMode;
+        space?: string;
+        spaceKey?: string;
+        authMode: AuthMode;
+        signalingMode?: SignalingMode;
+        projectId: string;
+        coordinationGateway?: ClientOptions['coordinationGateway'];
+        coordinationAvenueOverride?: ClientOptions['coordinationAvenueOverride'];
+        platformAttestationTokenProvider?: ClientOptions['platformAttestationTokenProvider'];
+        coordinationPlatformType?: string;
+        storagePrefix?: string;
+        deviceIdPersistence?: 'persistent' | 'ephemeral';
+        endpointIdPersistence?: 'persistent' | 'ephemeral';
+        nodeIdPersistence?: 'persistent' | 'ephemeral';
+        localDeviceId?: string;
+        deviceName?: string;
+        strictMode?: boolean;
+        turnCredentialsProvider?: () => Promise<{
+            iceServers?: RTCIceServer[];
+        } | null | undefined>;
+        applicationCrypto?: ExplicitFileDataSendParams['applicationCrypto'];
+        spaceTokenProvider?: ClientOptions['spaceTokenProvider'];
+        spaceAuth?: 'scoped-token';
+    };
+    private spaceNamespaceIdPromise;
+    private cachedSpaceNamespaceId;
+    private coordinationHostAvailability;
+    private authListeners;
+    private persistenceReady;
+    wasmClient: any;
+    private readonly createdAtMs;
+    private missingWasmWarnings;
+    private readonly wasmReadyWarningDelayMs;
+    private browserCoordinationSignaling;
+    private readonly nativeTrustTokens;
+    private lastObservedFirebaseUserId;
+    private sessionReaders;
+    protected authContext: {
+        userId: string;
+        token?: string | null;
+        refreshToken?: string | null;
+        customToken?: string | null;
+        tokenProvider?: (forceRefresh?: boolean) => Promise<string | null>;
+        appCheckTokenProvider?: (forceRefresh?: boolean) => Promise<string | null>;
+        expiresAtMs?: number | null;
+    } | null;
+    private injectedBrowserAuthSessionActive;
+    private readonly presenceManager;
+    private hasSyncedAuthToWasmClient;
+    private lastWasmAuthUserId;
+    private lastWasmAuthToken;
+    private lastDeliveredConnectionStates;
+    private authScopedRuntimeGeneration;
+    private coreClient;
+    private readonly applicationRouteEscalations;
+    private applicationRouteEscalationAttemptKeys;
+    private applicationRouteEscalationUnsubscribe;
+    private applicationRouteEscalationSubscriptionGeneration;
+    private applicationRouteEscalationSubscriptionEpoch;
+    constructor(options: WasmBridgeOptions);
+    get tag(): string;
+    getRuntimeCapabilities(): RuntimeCapabilities;
+    private static readonly WEB_DEVICE_ID_STORAGE_PREFIX;
+    private static readonly EPHEMERAL_DEVICE_ID_TTL_MS;
+    private getDeviceIdentityStorageKey;
+    private getDeviceIdPersistenceMode;
+    private isTicketOnlyMode;
+    private usesProviderNeutralGrant;
+    private createRandomDeviceId;
+    protected resolveWebLogicalDeviceId(): string;
+    private getDefaultBrowserDeviceName;
+    getLocalDeviceInfo(): Promise<LocalDeviceInfo>;
+    private getCoordinationSignaling;
+    usesCoordinationGateway(): boolean;
+    setCoordinationHostAvailability(input: {
+        available: boolean;
+        reason: string;
+    }): void;
+    /** Restore the existing gateway delivery subscription after a native host resumes. */
+    reconnectCoordinationAfterHostResume(): Promise<void>;
+    getCoordinationNativeTrustToken(forceRefresh?: boolean): Promise<NativeTrustToken>;
+    invalidateCoordinationNativeTrustToken(): void;
+    subscribeCoordinationNativeTrustToken(listener: (token: NativeTrustToken | null) => void, options?: {
+        emitCurrent?: boolean;
+    }): () => void;
+    setCoordinationLocalDeviceId(deviceId: string): void;
+    /** Internal native-host hint for provider-neutral roster presentation. */
+    setCoordinationPlatformType(platformType: string): void;
+    setCoordinationExcludedPeers(excludedPeers: string[]): Promise<void>;
+    joinCoordinationRoom(roomId: string, nodeId: string, ticket: string): Promise<void>;
+    leaveCoordinationRoom(roomId: string): Promise<void>;
+    getCoordinationRoomMembers(roomId: string): Promise<RoomMember[]>;
+    watchCoordinationRoomMembers(roomId: string, callback: (members: RoomMember[]) => void): () => void;
+    private withWebPresenceMetadata;
+    setAuthContext(context: {
+        userId: string;
+        token?: string | null;
+        refreshToken?: string | null;
+        customToken?: string | null;
+        tokenProvider?: (forceRefresh?: boolean) => Promise<string | null>;
+        appCheckTokenProvider?: (forceRefresh?: boolean) => Promise<string | null>;
+        expiresAtMs?: number | null;
+    } | null): Promise<void>;
+    private ensureBrowserPlatformAuth;
+    private syncWasmAuthToken;
+    private toRuntimeIdentity;
+    protected getCurrentUserId(): string | null;
+    getCurrentUserIdForScope(): string | null;
+    getAuthContext(): Readonly<typeof this.authContext> | null;
+    protected isSpaceMode(): boolean;
+    getResolvedOptions(): Readonly<typeof this.options>;
+    protected getDiscoveryScopeId(): string | null;
+    protected matchesTag(device: Pick<RawDeviceDoc, 'tag' | 'appTag'>): boolean;
+    matchesLegacyOrCurrentTag(device: Pick<RawDeviceDoc, 'tag' | 'appTag'>): boolean;
+    private stopSessionSubscriptions;
+    private stopRuntimeAuthScopedLoops;
+    stopAuthScopedActivity(options?: {
+        userId?: string | null;
+    }): Promise<void>;
+    setWasmClient(client: any): void;
+    initializePersistentIrohProtocols(store: IrohBrowserProtocolStore): Promise<void>;
+    createPersistentIrohNamespace(generation: number, shareRevision: number): Promise<IrohNamespaceDescriptor>;
+    importPersistentIrohTicket(ticket: string, generation: number, shareRevision: number): Promise<string>;
+    sharePersistentIrohNamespace(namespaceId: string, writable: boolean): Promise<string>;
+    removePersistentIrohNamespace(namespaceId: string, generation: number, shareRevision: number): Promise<void>;
+    putPersistentIrohBytes(namespaceId: string, key: Uint8Array, value: Uint8Array): Promise<IrohMutationReceipt>;
+    setPersistentIrohHash(namespaceId: string, key: Uint8Array, contentHash: string, contentLength: number): Promise<string>;
+    deletePersistentIrohPrefix(namespaceId: string, prefix: Uint8Array): Promise<{
+        removed: number;
+        operationId: string;
+    }>;
+    queryPersistentIrohNamespace(namespaceId: string, keyPrefix: Uint8Array): Promise<IrohDocEntry[]>;
+    hydratePersistentIrohBlob(contentHash: string): Promise<void>;
+    acknowledgePersistentIrohOutbox(operationId: string): Promise<void>;
+    flushPersistentIrohProtocols(): Promise<void>;
+    shutdownPersistentIrohProtocols(): Promise<void>;
+    private requirePersistentProtocolHost;
+    private warnMissingWasmOnce;
+    private waitForWasmClient;
+    protected normalizeDevice(raw: Record<string, any>, fallbackId?: string): Device;
+    normalizeDeviceRecord(raw: Record<string, any>, fallbackId?: string): Device;
+    getResolvedWebLogicalDeviceId(): string;
+    private normalizeDeviceStatusSnapshot;
+    private normalizePeerSessionSnapshot;
+    private toBackendConnectionStateFromPeerSession;
+    private normalizeConnectionStateSnapshot;
+    private stabilizeConnectionState;
+    private sameConnectionState;
+    private deliverConnectionState;
+    private get browserPresenceLoopState();
+    private set browserPresenceLoopState(value);
+    get currentUser(): RuntimeIdentity | null;
+    onAuthChange(callback: (user: RuntimeIdentity | null) => void): () => void;
+    checkForSSOToken(): Promise<void>;
+    waitForAuth(): Promise<void>;
+    signInAnonymously(): Promise<void>;
+    signInWithPluto(): Promise<void>;
+    signOut(): Promise<void>;
+    getTurnCredentials(): Promise<any>;
+    updatePresence(localNodeId: string, ticketStr: string, isOnline?: boolean, ttlMs?: number, metadata?: string, deviceNameOverride?: string): Promise<void>;
+    refreshLivePresence(localNodeId: string, ticketStr: string, metadata?: string, deviceNameOverride?: string): Promise<void>;
+    setOffline(localNodeId: string): Promise<void>;
+    updateDevice(deviceId: string, updates: {
+        deviceName?: string;
+        capabilities?: Device['capabilities'];
+        metadata?: string;
+        excludedPeers?: string[];
+    }): Promise<void>;
+    deleteDevice(deviceId: string): Promise<void>;
+    cleanupStaleDevices(): Promise<void>;
+    sendMessage(targetId: string, payload: string, state?: string, replyPayload?: string): Promise<string>;
+    pollMessages(targetId: string): Promise<SignalingEnvelope[]>;
+    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>;
+    openPeerBi(id: string, timeoutMs?: number): Promise<BackendPeerBiStream>;
+    openPeerNativeBi(id: string, label: string, timeoutMs?: number): Promise<BackendPeerBiStream>;
+    openPeerBiTransportOnly(id: string, timeoutMs?: number): Promise<BackendPeerBiStream>;
+    openPeerUni(id: string, timeoutMs?: number): Promise<BackendPeerUniStream>;
+    resolvePeerConnectionRecords(id: string): Promise<ManagedConnectionRecord[]>;
+    resolvePeerIdentity(id: string): Promise<ResolvedPeerIdentity>;
+    onDevicesChange(callback: (devices: Device[]) => void, excludeNodeId?: string): () => void;
+    subscribeDevices(userId: string): Promise<ReadableStream<DeviceEvent[]>>;
+    startAutoConnect(userId: string, localDeviceId: string): Promise<void>;
+    startAutoConnectOnce(userId: string, localDeviceId: string): Promise<void>;
+    notifyDisconnectRequested(remoteNodeId: string): void;
+    setAutoConnectExcluded(deviceId: string, excluded: boolean): Promise<void>;
+    disconnectDevice(deviceId: string): Promise<void>;
+    submitDesiredPeerProjection(revision: number, peers: DesiredPeerProjection[]): Promise<void>;
+    setCoreClient(client: CoreClientBridgeHost | null): void;
+    private startApplicationRouteEscalationSubscription;
+    private stopApplicationRouteEscalationSubscription;
+    private retryManagedApplicationRouteEscalations;
+    private escalateManagedApplicationRoute;
+    connectToDevice(params: NativeConnectParams): Promise<NativeConnectResult>;
+    forceReconnectSnapshot(): void;
+    startPresenceLoop(userId: string, localNodeId: string, deviceName: string, ticket: string, metadata?: string): void;
+    private ensureSpaceNamespaceIdPromise;
+    createSession(session: SignalingSession): Promise<void>;
+    updateSession(sessionId: string, updateData: any): Promise<void>;
+    subscribeSessions(localDeviceId: string): Promise<ReadableStream<SessionEvent[]>>;
+    getLocalDeviceId(): Promise<string | null>;
+    isConnected(node_id: string): Promise<boolean>;
+    private hasConnectedIndependentPeerRoute;
+    getConnectionStates(): Promise<BackendConnectionState[]>;
+    onConnectionStateChange(callback: (state: BackendConnectionState) => void): Promise<() => void> | (() => void);
+    sendExplicitFilePath(connectionId: string, filePath: string, transferId?: string): Promise<string>;
+    private sanitizeExplicitFileName;
+    private sanitizeExplicitMimeType;
+    private assertExplicitTransferHeaderSize;
+    private createWebRTCExplicitTransferId;
+    private createWebRTCExplicitTransferFrame;
+    sendExplicitFileData(params: ExplicitFileDataSendParams): Promise<void>;
+    getTransferHistory(limit?: number): Promise<Array<[string, unknown]>>;
+    deleteTransferJob(jobId: string): Promise<void>;
+    watchFriendDevices(friendUserIds: string[], callback: (friendDevices: Map<string, any[]>) => void): () => void;
+    updateFriendTicket(friendTicket: string | null): Promise<void>;
+}
+
+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>;
+    usesCoordinationGateway(): boolean;
+    joinCoordinationRoom(roomId: string, nodeId: string, ticket: string): Promise<void>;
+    leaveCoordinationRoom(roomId: string): Promise<void>;
+    getCoordinationRoomMembers(roomId: string): Promise<RoomMember[]>;
+    watchCoordinationRoomMembers(roomId: string, callback: (members: RoomMember[]) => void): () => void;
+    getTurnCredentials(): Promise<any>;
+    updatePresence(localNodeId: string, ticketStr: string, isOnline: boolean, ttlMs: number, metadata?: string): Promise<void>;
+    refreshLivePresence(localNodeId: string, ticketStr: string, 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[]>;
+    watchFriendDevices(friendUserIds: string[], callback: (friendDevices: Map<string, Device[]>) => void): () => void;
+    updateFriendTicket(friendTicket: string | null): Promise<void>;
+    subscribeDevices(userId: string): Promise<ReadableStream<DeviceEvent[]>>;
+    startAutoConnect(userId: string, localDeviceId: string): void;
+    submitDesiredPeerProjection(revision: number, peers: DesiredPeerProjection[]): Promise<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>;
+    notifyNetworkChange(options?: {
+        reason?: string;
+    }): Promise<unknown>;
+    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, expiresAtMs?: number): Promise<void>;
+    revokeSessionTokensByScope(scope: GrantScope): Promise<string[]>;
+    openPeerBi(id: string, timeoutMs?: number): Promise<BackendPeerBiStream>;
+    incoming_streams(): Promise<ReadableStream<unknown>>;
+    is_current_transport_stable_id(endpointId: string, transportStableId: bigint): Promise<boolean>;
+    openPeerNativeBi(id: string, label: string, timeoutMs?: number): Promise<BackendPeerBiStream>;
+    openPeerBiTransportOnly(id: string, timeoutMs?: number): Promise<BackendPeerBiStream>;
+    openPeerUni(id: string, timeoutMs?: number): Promise<BackendPeerUniStream>;
+    connectToDevice(params: NativeConnectParams): Promise<NativeConnectResult>;
+    disconnectDevice(deviceId: string): Promise<void>;
+    setAutoConnectExcluded(deviceId: string, excluded: boolean): Promise<void>;
+    isConnected(nodeId: string): Promise<boolean>;
+    getConnectionStates(): Promise<BackendConnectionState[]>;
+    onConnectionStateChange(callback: (state: BackendConnectionState) => void): Promise<() => void> | (() => void);
+    /** @deprecated Use named channels or `openrtc-file-transfer`. */
+    sendExplicitFilePath(connectionId: string, filePath: string, transferId?: string): Promise<string>;
+    /** @deprecated Use named channels or `openrtc-file-transfer`. */
+    sendExplicitFileData(params: ExplicitFileDataSendParams): Promise<void>;
+    /** @deprecated Transfer history belongs to the consumer application. */
+    getTransferHistory(limit?: number): Promise<Array<[string, unknown]>>;
+    /** @deprecated Transfer history belongs to the consumer application. */
+    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 { DelegatingRuntimeAdapter as D, WasmBridge as W, type WasmBridgeOptions as a };

package/dist/{types-BHePJWbM.d.ts → ITransport-WV6gGMnX.d.ts}

@@ -77,6 +77,8 @@ interface AppLimits {
     maxPersonalDevices: number;
 }
 interface PlutoRTCConfiguration extends RTCConfiguration {
+    /** Keep the legacy route, carry Iroh packets, or try the carrier before fallback. */
+    implementation?: TransportImplementation;
     iceServers?: RTCIceServer[];
     /**
      * Populate public STUN defaults when no ICE servers are configured.
@@ -98,6 +100,7 @@ interface PlutoMoQServerCertificateHash {
     value: ArrayBuffer;
 }
 interface PlutoMoQConfiguration {
+    implementation?: TransportImplementation;
     relayUrl?: string;
     /** Relay JWT appended only at WebTransport connection time. Never include it in relayUrl. */
     accessToken?: string;
@@ -170,11 +173,14 @@ interface ChannelDescriptor {
     delivery?: 'reliable' | 'latest-state';
     description?: string;
 }
-type ProtocolName = 'iroh' | 'iroh-quic' | 'iroh-relay' | 'iroh-lan' | 'ble' | 'webrtc' | 'webrtc-lan' | 'webrtc-turn' | 'moq';
+type ProtocolName = 'iroh' | 'iroh-quic' | 'iroh-relay' | 'iroh-lan' | 'iroh-webrtc' | 'iroh-moq' | 'ble' | 'webrtc' | 'webrtc-lan' | 'webrtc-turn' | 'moq';
 type ProtocolMaturity = 'stable' | 'experimental' | 'unsupported';
+type TransportImplementation = 'external' | 'iroh-carrier' | 'auto';
+type TransportPrivacy = 'direct' | 'relay-only';
+type TransportOptimization = 'balanced' | 'lowest-latency';
 type ProtocolBaseName = 'iroh' | 'webrtc' | 'moq';
 type RouteFamily = 'iroh-path' | 'iroh-physical' | 'optional-route';
-type RouteImplementationKind = 'core' | 'host-installed' | 'route-adapter' | 'path-label';
+type RouteImplementationKind = 'core' | 'host-installed' | 'carrier-adapter' | 'route-adapter' | 'path-label';
 /**
  * Public compatibility type. `native` and `plugin` are legacy capability
  * labels; generated route descriptors use `RouteImplementationKind`.
@@ -282,6 +288,8 @@ interface ClientOptions {
         kind: 'user' | 'space' | 'room' | 'session';
         id: string;
     };
+    /** @internal Raw host platform metadata used only for roster presentation. */
+    coordinationPlatformType?: string;
     /**
      * Supplies the provider-neutral platform-attestation token used by the
      * configured coordination control plane.
@@ -339,6 +347,12 @@ interface ClientOptions {
         webrtc?: boolean | PlutoRTCConfiguration;
         ble?: boolean | PlutoBleConfiguration;
         moq?: boolean | PlutoMoQConfiguration;
+        /** Hard route-eligibility policy. Relay-only fails closed. */
+        privacy?: TransportPrivacy;
+        /** Route objective applied after privacy and capability filtering. */
+        optimizeFor?: TransportOptimization;
+        /** Exact-route fallback and tie-break order. Unsupported routes are skipped. */
+        priority?: ProtocolName[];
     };
     transportPriority?: ProtocolName[];
     /** Subscribe to native LAN peer discovery events. */
@@ -421,6 +435,10 @@ interface PeerState {
     admissionState?: PeerAdmissionState;
     transportState?: string;
     protocolState?: string;
+    /** Compatibility projection of the canonical `routable` readiness facet. */
+    settledReady?: boolean;
+    readinessState?: string;
+    readinessReason?: string;
     webrtcState?: PeerWebRtcState;
     routable?: boolean;
     activeTransportStableId?: number | null;
@@ -671,6 +689,8 @@ interface TransportLatencySnapshot {
     iroh?: number | null;
     irohLan?: number | null;
     irohRelay?: number | null;
+    irohWebrtc?: number | null;
+    irohMoq?: number | null;
     ble?: number | null;
     moq?: number | null;
 }
@@ -823,6 +843,10 @@ interface ISignalingBackend {
     signInWithPluto?(): Promise<void>;
     signOut(): Promise<void>;
     stopAuthScopedActivity?(): Promise<void>;
+    setCoordinationHostAvailability?(input: {
+        available: boolean;
+        reason: string;
+    }): void;
     usesCoordinationGateway?(): boolean;
     joinCoordinationRoom?(roomId: string, nodeId: string, ticket: string): Promise<void>;
     leaveCoordinationRoom?(roomId: string): Promise<void>;
@@ -1080,4 +1104,19 @@ interface JoinRequest {
     state: 'pending' | 'accepted' | 'rejected';
 }
 
-export type { SignalingOptions as $, AuthMode as A, BackendPeerBiStream as B, ClientOptions as C, DiscoveryMode as D, ExplicitFileDataSendParams as E, PeerLifecycleStatus as F, GrantScope as G, RouteDescriptor as H, ISignalingBackend as I, JoinRoomOptions as J, ProtocolCapability as K, LocalDeviceInfo as L, ManagedConnectionRecord as M, NativeManagedSessionStartResult as N, ProtocolCapabilityMap as O, PeerSessionSnapshot as P, ApplicationCryptoStreamTools as Q, RuntimeIdentity as R, SignalingMode as S, TransportLatencySnapshot as T, ApplicationCryptoBiStream as U, RouteFamily as V, RouteImplementationKind as W, ConnectDeviceHooks as X, ConnectDeviceOptions as Y, ConnectDeviceResult as Z, AppLimits as _, RoomMember as a, RoomCreationMode as a0, ScanningLoopOptions as a1, ScanningLoopHandle as a2, RuntimeBootstrapOptions as a3, RuntimeBootstrapResult as a4, ManagedApplicationRouteOptions as a5, JoinRequest as a6, SpaceTokenProvider as a7, Device as b, DeviceStatusSnapshot as c, ResolvedPeerIdentity as d, SignalingEnvelope as e, DeviceEvent as f, DesiredPeerProjection as g, SignalingSession as h, SessionEvent as i, BackendPeerUniStream as j, NativeConnectParams as k, NativeConnectResult as l, BackendConnectionState as m, ConnectionOptions as n, ApplicationPayloadCrypto as o, ApplicationPayloadReadinessOptions as p, ApplicationPayloadRouteOptions as q, ProtocolName as r, ApplicationPayloadSendOptions as s, PeerState as t, PeerScope as u, PeerHealth as v, ChannelDescriptor as w, IncomingStreamChannelMetadata as x, ManagedDeviceConnectOptions as y, DevicePresenceStatus as z };
+interface ITransport {
+    readonly name: string;
+    readonly isReady: boolean;
+    init(localNodeId: string, remoteNodeId: string, options: any): Promise<void>;
+    send(data: Uint8Array): Promise<void>;
+    close(): void;
+    onMessage(callback: (data: Uint8Array) => void): void;
+    onStateChange(callback: (state: 'connecting' | 'connected' | 'failed' | 'disconnected') => void): void;
+    handleSignalingMessage?(msg: any): void;
+    getSignalingHandler?(): (msg: any) => Promise<void>;
+    getNativeTransport?(): any;
+    getNegotiationId?(): string | null;
+    getDataChannelReadyState?(): string | null;
+}
+
+export type { ProtocolCapabilityMap as $, AuthMode as A, BackendPeerBiStream as B, ConnectDeviceResult as C, Device as D, ExplicitFileDataSendParams as E, ITransport as F, GrantScope as G, TransportLatencySnapshot as H, ISignalingBackend as I, PeerState as J, PeerScope as K, LocalDeviceInfo as L, ManagedConnectionRecord as M, NativeConnectParams as N, PeerHealth as O, PlutoIrohConfiguration as P, ChannelDescriptor as Q, ResolvedPeerIdentity as R, SignalingMode as S, TransportOptimization as T, IncomingStreamChannelMetadata as U, ManagedDeviceConnectOptions as V, JoinRoomOptions as W, DevicePresenceStatus as X, PeerLifecycleStatus as Y, RouteDescriptor as Z, ProtocolCapability as _, PlutoRTCConfiguration as a, ApplicationCryptoStreamTools as a0, ApplicationCryptoBiStream as a1, RouteFamily as a2, RouteImplementationKind as a3, AppLimits as a4, SignalingOptions as a5, RoomCreationMode as a6, ScanningLoopOptions as a7, ScanningLoopHandle as a8, RuntimeBootstrapOptions as a9, RuntimeBootstrapResult as aa, ManagedApplicationRouteOptions as ab, JoinRequest as ac, PlutoMoQConfiguration as b, ProtocolName as c, PeerSessionSnapshot as d, ConnectDeviceHooks as e, ConnectDeviceOptions as f, ClientOptions as g, DiscoveryMode as h, RoomMember as i, RuntimeIdentity as j, SignalingEnvelope as k, DeviceStatusSnapshot as l, BackendPeerUniStream as m, DeviceEvent as n, DesiredPeerProjection as o, CoreClientBridgeHost as p, NativeConnectResult as q, SignalingSession as r, SessionEvent as s, BackendConnectionState as t, NativeManagedSessionStartResult as u, ConnectionOptions as v, ApplicationPayloadCrypto as w, ApplicationPayloadReadinessOptions as x, ApplicationPayloadRouteOptions as y, ApplicationPayloadSendOptions as z };

package/dist/IpcRuntimeAdapter-CJq3dRBF.d.ts

@@ -0,0 +1,19 @@
+import { g as ClientOptions } from './ITransport-WV6gGMnX.js';
+import { a as WasmBridgeOptions, D as DelegatingRuntimeAdapter } from './DelegatingRuntimeAdapter-BFZDC604.js';
+import { P as PlutoIpcBridge } from './ipc-CflAVodw.js';
+
+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 IpcRuntimeAdapterOptions as a };