openrtc 2.0.0-rc.3 → 2.0.0-rc.30

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-DqfHkjLy.d.ts → DelegatingRuntimeAdapter-BFZDC604.d.ts}

@@ -1,6 +1,6 @@
-import { D as Device, n as DiscoveryMode, o as AuthMode, p as SignalingMode, i as ClientOptions, E as ExplicitFileDataSendParams, q as ISignalingBackend, j as RoomMember, R as RuntimeIdentity, r as SignalingEnvelope, h as DeviceStatusSnapshot, m as PeerSessionSnapshot, s as BackendPeerBiStream, t as BackendPeerUniStream, u as ManagedConnectionRecord, v as ResolvedPeerIdentity, w as DeviceEvent, x as DesiredPeerProjection, y as CoreClientBridgeHost, N as NativeConnectParams, z as NativeConnectResult, S as SignalingSession, F as SessionEvent, B as BackendConnectionState, L as LocalDeviceInfo, G as NativeManagedSessionStartResult, H as GrantScope } from './types-BVJr065k.js';
-import { R as RuntimeCapabilities } from './capabilities-YSskrE8H.js';
-import { A as AuthContext } from './IEngineBridge-BbsT8hof.js';
+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;
@@ -25,7 +25,7 @@ interface WasmBridgeOptions {
     coordinationAvenueOverride?: ClientOptions['coordinationAvenueOverride'];
     platformAttestationTokenProvider?: ClientOptions['platformAttestationTokenProvider'];
     /** Internal host hint used by the provider-neutral gateway projection. */
-    coordinationPlatformType?: 'web' | 'desktop' | 'mobile';
+    coordinationPlatformType?: string;
     storagePrefix?: string;
     deviceIdPersistence?: 'persistent' | 'ephemeral';
     endpointIdPersistence?: 'persistent' | 'ephemeral';
@@ -79,7 +79,7 @@ declare class WasmBridge implements ISignalingBackend {
         coordinationGateway?: ClientOptions['coordinationGateway'];
         coordinationAvenueOverride?: ClientOptions['coordinationAvenueOverride'];
         platformAttestationTokenProvider?: ClientOptions['platformAttestationTokenProvider'];
-        coordinationPlatformType?: 'web' | 'desktop' | 'mobile';
+        coordinationPlatformType?: string;
         storagePrefix?: string;
         deviceIdPersistence?: 'persistent' | 'ephemeral';
         endpointIdPersistence?: 'persistent' | 'ephemeral';
@@ -96,6 +96,7 @@ declare class WasmBridge implements ISignalingBackend {
     };
     private spaceNamespaceIdPromise;
     private cachedSpaceNamespaceId;
+    private coordinationHostAvailability;
     private authListeners;
     private persistenceReady;
     wasmClient: any;
@@ -124,6 +125,7 @@ declare class WasmBridge implements ISignalingBackend {
     private authScopedRuntimeGeneration;
     private coreClient;
     private readonly applicationRouteEscalations;
+    private applicationRouteEscalationAttemptKeys;
     private applicationRouteEscalationUnsubscribe;
     private applicationRouteEscalationSubscriptionGeneration;
     private applicationRouteEscalationSubscriptionEpoch;
@@ -139,8 +141,13 @@ declare class WasmBridge implements ISignalingBackend {
     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>;
@@ -150,7 +157,7 @@ declare class WasmBridge implements ISignalingBackend {
     }): () => void;
     setCoordinationLocalDeviceId(deviceId: string): void;
     /** Internal native-host hint for provider-neutral roster presentation. */
-    setCoordinationPlatformType(platformType: 'desktop' | 'mobile'): void;
+    setCoordinationPlatformType(platformType: string): void;
     setCoordinationExcludedPeers(excludedPeers: string[]): Promise<void>;
     joinCoordinationRoom(roomId: string, nodeId: string, ticket: string): Promise<void>;
     leaveCoordinationRoom(roomId: string): Promise<void>;
@@ -183,6 +190,23 @@ declare class WasmBridge implements ISignalingBackend {
         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;
@@ -336,7 +360,7 @@ declare abstract class DelegatingRuntimeAdapter implements ISignalingBackend {
     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>;
+    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>>;
@@ -370,4 +394,4 @@ declare abstract class DelegatingRuntimeAdapter implements ISignalingBackend {
     setCoreClient(client: unknown): void;
 }
 
-export { DelegatingRuntimeAdapter as D, type WasmBridgeOptions as W, WasmBridge as a };
+export { DelegatingRuntimeAdapter as D, WasmBridge as W, type WasmBridgeOptions as a };

package/dist/{types-BVJr065k.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 { AppLimits as $, ApplicationPayloadCrypto as A, BackendConnectionState as B, ConnectionOptions as C, Device as D, ExplicitFileDataSendParams as E, SessionEvent as F, NativeManagedSessionStartResult as G, GrantScope as H, IncomingStreamChannelMetadata as I, JoinRoomOptions as J, RouteDescriptor as K, LocalDeviceInfo as L, ManagedDeviceConnectOptions as M, NativeConnectParams as N, ProtocolCapability as O, ProtocolName as P, ProtocolCapabilityMap as Q, RuntimeIdentity as R, SignalingSession as S, TransportLatencySnapshot as T, ApplicationCryptoStreamTools as U, ApplicationCryptoBiStream as V, RouteFamily as W, RouteImplementationKind as X, ConnectDeviceHooks as Y, ConnectDeviceOptions as Z, ConnectDeviceResult as _, ApplicationPayloadReadinessOptions as a, SignalingOptions as a0, RoomCreationMode as a1, ScanningLoopOptions as a2, ScanningLoopHandle as a3, RuntimeBootstrapOptions as a4, RuntimeBootstrapResult as a5, ManagedApplicationRouteOptions as a6, JoinRequest as a7, SpaceTokenProvider as a8, ApplicationPayloadRouteOptions as b, ApplicationPayloadSendOptions as c, PeerState as d, PeerScope as e, PeerHealth as f, ChannelDescriptor as g, DeviceStatusSnapshot as h, ClientOptions as i, RoomMember as j, DevicePresenceStatus as k, PeerLifecycleStatus as l, PeerSessionSnapshot as m, DiscoveryMode as n, AuthMode as o, SignalingMode as p, ISignalingBackend as q, SignalingEnvelope as r, BackendPeerBiStream as s, BackendPeerUniStream as t, ManagedConnectionRecord as u, ResolvedPeerIdentity as v, DeviceEvent as w, DesiredPeerProjection as x, CoreClientBridgeHost as y, NativeConnectResult 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 };

package/dist/OpenRTCShared.d.ts

@@ -0,0 +1,250 @@
+import { R as RuntimePolicySnapshot, P as PeerReconciliationStats, a as RuntimeClient, b as PlutoRuntimeAssembly } from './assembly-q0jRRpsc.js';
+import { d as PeerSessionSnapshot, R as ResolvedPeerIdentity, C as ConnectDeviceResult, e as ConnectDeviceHooks, f as ConnectDeviceOptions, G as GrantScope } from './ITransport-WV6gGMnX.js';
+import { a as RuntimePeerState, b as RuntimePeerConnectOptions, C as Connection, c as RuntimePeerReadinessSnapshot, d as RuntimePeerHealth, R as RuntimeChannelDescriptor, e as RuntimePeerStreamOptions, f as RuntimeIncomingStream, g as RuntimeScopedChannelOptions, h as RuntimeDevice, i as RuntimeScopedLogicalChannel, j as RuntimeConnectionStateSnapshot, k as RuntimeApplicationPayloadReadinessOptions, l as RuntimeConnectionEvent, m as RuntimeManagedSessionOptions, n as RuntimeManagedSession, o as RuntimeDeviceStatusSnapshot, p as RuntimeDeviceConnectOptions, q as RuntimeLocalDeviceInfo, r as RuntimeLocalDeviceProfile, s as RuntimeRawConnection, t as RuntimeJoinRoomOptions, u as RuntimeRoomMember, A as AuthContext, v as RuntimeClientOptions } from './types-DVNSd5B9.js';
+import { R as RuntimeCapabilities, a as RuntimeCapabilityProfile } from './capabilities-BfZi4Cd7.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;
+}
+declare function resolveOptions(options: RuntimeClientOptions): RuntimeClientOptions;
+declare function wrapAssembly(assembly: PlutoRuntimeAssembly, defaultManagedSessionPlatform: RuntimeManagedSessionOptions['platform']): OpenRTCClient;
+
+export { type OpenRTCAdvancedNamespace, type OpenRTCChannelConnectOptions, type OpenRTCChannelNamespace, type OpenRTCClient, type OpenRTCDeviceNamespace, type OpenRTCDeviceSessionOptions, type OpenRTCDiagnosticsNamespace, type OpenRTCPeerNamespace, type OpenRTCRoomNamespace, type OpenRTCTicketNamespace, resolveOptions, wrapAssembly };

package/dist/OpenRTCShared.js

@@ -0,0 +1 @@
+import {n}from'./chunk-KJTJLLJE.js';import'./chunk-45WBH7E3.js';import'./chunk-NRXEG5GQ.js';function O(i){let s=n({...i});if("auth"in i&&!i.authMode){let n=i.auth;s.authMode=n==="none"?"anonymous":n;}if("identity"in i){let n=i.identity,r=n==="temporary"?"ephemeral":n;!i.deviceIdPersistence&&!i.nodeIdPersistence&&(s.deviceIdPersistence=r),!i.endpointIdPersistence&&!i.nodeIdPersistence&&(s.endpointIdPersistence=r);}return "namespace"in i&&!i.storagePrefix&&(s.storagePrefix=i.namespace),"privacy"in i&&i.strictMode===void 0&&(s.strictMode=!!i.privacy),s}function I(i,s){let n=i.runtime,r=Object.create(n),l=async e=>{if(typeof e!="string")return e;let o=(await n.listDevices()).find(c=>c.deviceId===e);if(!o)throw new Error(`OpenRTC device '${e}' is not currently discoverable.`);return o},u=async e=>({...e,localDeviceId:e?.localDeviceId??await n.getLocalDeviceId()??""}),R=async e=>{let{device:t,scope:o,...c}=e,a=c.deviceId??(typeof t=="string"?t:t?.deviceId)??null,m=c.ticket??(typeof t=="string"?void 0:t?.ticket);a&&!m&&(m=(await l(a).catch(()=>null))?.ticket);let d={...c,scope:o??"session"};return a&&(d.deviceId=a),m&&(d.ticket=m),d},g={list:()=>n.listDevices(),startSession:(e={})=>n.startManagedSession({...e,platform:e.platform??s}),stopSession:e=>n.stopManagedSession(e),listWithStatus:()=>n.listDevicesWithStatus(),watch:e=>n.watchDevices(e),watchWithStatus:e=>n.watchDevicesWithStatus(e),connect:async(e,t)=>n.connectDevice(await l(e),await u(t)),connectWithRetry:async(e,t,o)=>n.connectDeviceWithRetry(await l(e),t,o),disconnect:e=>n.disconnectDevice(e),update:(e,t)=>n.updateDevice(e,t),delete:e=>n.deleteDevice(e),localId:()=>n.getLocalDeviceId(),localInfo:()=>n.getLocalDeviceInfo(),localProfile:e=>n.getLocalDeviceProfile(e),updateLocalName:e=>n.updateLocalDeviceName(e)},v={watch:e=>n.watchPeerStates(e),watchLifecycle:e=>n.watchPeerLifecycle(e),get:e=>n.getPeerState(e),listConnected:()=>n.listConnectedPeers(),connect:e=>n.connectPeer(e),disconnect:(e,t)=>n.disconnectPeer(e,t),forceDisconnect:e=>n.forceDisconnectPeer(e),session:e=>n.getPeerSession(e),sessions:()=>n.listPeerSessions(),waitConnected:(e,t)=>n.waitForConnectedPeer(e,t),readiness:(e,t)=>n.getPeerReadiness(e,t),health:e=>n.getPeerHealth(e),identity:e=>n.resolvePeerIdentity(e),addScope:(e,t)=>n.addPeerScope(e,t),releaseScope:(e,t)=>n.releasePeerScope(e,t),scopes:e=>n.getPeerScopes(e),refresh:()=>n.refreshPeerSnapshot()},C={register:e=>n.registerChannel(e),unregister:e=>n.unregisterChannel(e),list:()=>n.listChannels(),openBi:(e,t,o)=>n.openPeerBi(e,{...o,channelId:t}),openUni:(e,t,o)=>n.openPeerUni(e,{...o,channelId:t}),onIncoming:e=>n.onIncomingStream(e),onIncomingChannel:(e,t)=>n.onIncomingChannelStream(e,o=>{if(o.channel)return t(o)}),connect:async e=>n.connectScopedChannel(await R(e)),connectScoped:e=>n.connectScopedChannel(e)},P={create:e=>n.createRoom(e),join:(e,t)=>n.joinRoom(e,t),leave:e=>n.leaveRoom(e),watch:(e,t)=>n.watchRoom(e,t),members:e=>n.getRoomMembers(e)},h={raw:()=>n.getInvite(),share:e=>n.getTicketWithToken("share",e?.maxConnections??1),grant:(e,t)=>n.getTicketWithToken(e,t?.maxConnections??0),revoke:e=>n.revokeTokensByScope(e)},S={status:()=>n.getRuntimeStatus(),policy:()=>n.getRuntimePolicy(),capabilities:()=>n.getRuntimeCapabilities(),capabilityProfile:()=>n.getCapabilityProfile(),connectionStates:()=>n.getConnectionStates(),onConnectionStateChange:e=>n.onConnectionStateChange(e),connections:()=>n.getConnections(),applicationReadyConnections:e=>n.getApplicationReadyConnections(e),onConnection:e=>n.onConnection(e),onDisconnection:e=>n.onDisconnection(e),onConnectionEvent:e=>n.onConnectionEvent(e),forceReconnectSnapshot:()=>n.forceReconnectSnapshot(),peerReconciliation:()=>n.getPeerReconciliationStats()},b={runtime:n,assembly:i,nodeId:()=>n.getNodeId(),nodeIdFromTicket:e=>n.getNodeIdFromTicket(e),endpointTicket:()=>n.getEndpointTicket(),connectRaw:e=>n.connectRaw(e),openBi:e=>n.openBi(e),openUni:e=>n.openUni(e),isConnected:e=>n.isConnected(e),disconnectNode:e=>n.disconnectNode(e),setAutoConnectExcluded:(e,t)=>n.setAutoConnectExcluded(e,t),notifyNetworkChange:e=>n.notifyNetworkChange(e)};return Object.defineProperties(r,{devices:{get:()=>g,enumerable:true},peers:{get:()=>v,enumerable:true},channels:{get:()=>C,enumerable:true},rooms:{get:()=>P,enumerable:true},tickets:{get:()=>h,enumerable:true},diagnostics:{get:()=>S,enumerable:true},advanced:{get:()=>b,enumerable:true},setAuth:{value:e=>i.setAuthContext(e),enumerable:true,writable:true,configurable:true},setAuthContext:{value:e=>i.setAuthContext(e),enumerable:true,writable:true,configurable:true},syncPlutoAuth:{value:e=>i.syncPlutoAuth(e),enumerable:true,writable:true,configurable:true},bindPlutoAuthHost:{value:()=>i.bindPlutoAuthHost(),enumerable:true,writable:true,configurable:true},signIn:{value:()=>i.signInWithPluto(),enumerable:true,writable:true,configurable:true},signOut:{value:()=>i.signOut(),enumerable:true,writable:true,configurable:true},runtime:{get:()=>n,enumerable:false},_assembly:{get:()=>i,enumerable:false}}),r}export{O as resolveOptions,I as wrapAssembly};

package/dist/WasmBridge-5GYKXPXK.js

@@ -0,0 +1 @@
+export{y as WasmBridge}from'./chunk-VOCOZ57Q.js';import'./chunk-AG2F6MOB.js';import'./chunk-CWGKLGJZ.js';import'./chunk-KJTJLLJE.js';import'./chunk-45WBH7E3.js';import'./chunk-NRXEG5GQ.js';