openrtc 2.0.0-rc.2 → 2.0.0-rc.21

package/dist/{OpenRTCShared-ZQPu5LqL.d.ts → types-DE4iPkMB.d.ts}

@@ -1,8 +1,18 @@
-import { H as GrantScope, q as ISignalingBackend, Y as ConnectDeviceHooks, Z as ConnectDeviceOptions, _ as ConnectDeviceResult, u as ManagedConnectionRecord, m as PeerSessionSnapshot, v as ResolvedPeerIdentity, $ as AppLimits, N as NativeConnectParams, z as NativeConnectResult, E as ExplicitFileDataSendParams } from './types-BVJr065k.js';
+import { G as GrantScope, I as ISignalingBackend, X as ConnectDeviceHooks, Y as ConnectDeviceOptions, Z as ConnectDeviceResult, M as ManagedConnectionRecord, P as PeerSessionSnapshot, d as ResolvedPeerIdentity, _ as AppLimits, k as NativeConnectParams, l as NativeConnectResult, E as ExplicitFileDataSendParams } from './types-BwmoJU2O.js';
 import { A as AuthContext } from './IEngineBridge-BbsT8hof.js';
-import { b as RuntimePeerState, c as RuntimeConnectionStateSnapshot, d as RuntimePeerReadinessSnapshot, e as RuntimePeerConnectOptions, C as Connection, f as RuntimeIncomingStream, a as RuntimeClientOptions, g as RuntimeAuthIdentity, h as RuntimeLocalDeviceInfo, i as RuntimeLocalDeviceProfile, j as RuntimeDevice, k as RuntimeManagedSessionOptions, l as RuntimeManagedSession, m as RuntimeDeviceStatusSnapshot, n as RuntimeDeviceConnectOptions, o as RuntimeSession, p as RuntimeJoinRoomOptions, q as RuntimeRoomMember, r as RuntimeConnectionTarget, s as RuntimeScopedChannelOptions, t as RuntimeScopedLogicalChannel, u as RuntimePeerStreamOptions, v as RuntimeRawConnection, R as RuntimeChannelDescriptor, w as RuntimePresenceLoopOptions, x as RuntimePeerHealth, y as RuntimeApplicationPayloadReadinessOptions, z as RuntimeConnectionEvent } from './types-DkgaCyqS.js';
+import { R as RuntimePeerState, a as RuntimeConnectionStateSnapshot, b as RuntimePeerReadinessSnapshot, c as RuntimePeerConnectOptions, C as Connection, d as RuntimeIncomingStream, e as RuntimeClientOptions, f as RuntimeAuthIdentity, g as RuntimeLocalDeviceInfo, h as RuntimeLocalDeviceProfile, i as RuntimeDevice, j as RuntimeManagedSessionOptions, k as RuntimeManagedSession, l as RuntimeDeviceStatusSnapshot, m as RuntimeDeviceConnectOptions, n as RuntimeSession, o as RuntimeJoinRoomOptions, p as RuntimeRoomMember, q as RuntimeConnectionTarget, r as RuntimeScopedChannelOptions, s as RuntimeScopedLogicalChannel, t as RuntimePeerStreamOptions, u as RuntimeRawConnection, v as RuntimeChannelDescriptor, w as RuntimePresenceLoopOptions, x as RuntimePeerHealth, y as RuntimeApplicationPayloadReadinessOptions, z as RuntimeConnectionEvent } from './types-oGGnaSW2.js';
 import { R as RuntimeCapabilities, a as RuntimeCapabilityProfile } from './capabilities-YSskrE8H.js';
 
+type PlutoIpcUnlisten = () => void | Promise<void>;
+interface PlutoIpcBridge {
+    invoke<T = unknown>(command: string, args?: Record<string, unknown>): Promise<T>;
+    listen<T = unknown>(event: string, handler: (payload: T) => void): Promise<PlutoIpcUnlisten>;
+    isAvailable?(): boolean | Promise<boolean>;
+}
+type NativeIpcFailureKind = 'command-unavailable' | 'runtime-unavailable' | 'timeout' | 'unknown';
+declare function classifyNativeIpcFailure(error: unknown): NativeIpcFailureKind;
+declare function isNativeIpcCommandUnavailable(error: unknown): boolean;
+
 /**
  * Coalesced peer reconciliation scheduler and full reconcile orchestration.
  *
@@ -230,7 +240,6 @@ interface RuntimePolicySnapshot {
         nativeStartRetryWindowMs: number;
         nativeStartRetryMinDelayMs: number;
         nativeStartRetryMaxDelayMs: number;
-        reconciliationIntervalMs: number;
         deviceStatusRefreshDebounceMs: number;
     };
     browserAutoConnect: {
@@ -281,7 +290,6 @@ declare class RuntimeClient {
     private static readonly NATIVE_START_RETRY_WINDOW_MS;
     private static readonly NATIVE_START_RETRY_MIN_DELAY_MS;
     private static readonly NATIVE_START_RETRY_MAX_DELAY_MS;
-    private static readonly MANAGED_RECONCILIATION_INTERVAL_MS;
     private static readonly DEVICE_STATUS_REFRESH_DEBOUNCE_MS;
     private static readonly MANAGED_USER_DEVICE_SCOPE;
     static readonly MANAGED_FRIEND_SCOPE: GrantScope;
@@ -298,7 +306,6 @@ declare class RuntimeClient {
     private managedSessionStartInFlight;
     private terminalShutdown;
     private readonly managedReconciliationTasks;
-    private managedReconciliationTimer;
     private readonly managedReconciliationFollowupTimers;
     /**
      * The one per-`{scope, peerNodeId}` observer-side dial coalescer. It is
@@ -378,6 +385,19 @@ declare class RuntimeClient {
      * @param maxConnections 0 = unlimited.
      */
     getTicketWithToken(grantScope: GrantScope, maxConnections?: number): Promise<string>;
+    /**
+     * Register a product-issued admission token with the active runtime.
+     *
+     * Product code supplies the durable authorization decision, while OpenRTC
+     * remains the sole owner of the native/WASM admission registry. Restricted
+     * grants should always include their server-issued expiry.
+     */
+    registerAdmissionToken(input: {
+        token: string;
+        scope: GrantScope;
+        maxConnections?: number;
+        expiresAtMs?: number;
+    }): Promise<void>;
     /** Revoke all session tokens that match the given scope. */
     revokeTokensByScope(grantScope: GrantScope): Promise<string[]>;
     private revokeTokensByScopeInternal;
@@ -675,7 +695,6 @@ declare class RuntimeClient {
 type RuntimeAdapterWithAuth = ISignalingBackend & {
     setAuthContext?: (context: AuthContext | null) => Promise<void> | void;
 };
-type RuntimeFactoryOptions = RuntimeClientOptions;
 interface PlutoRuntimeAssembly<TBackend extends RuntimeAdapterWithAuth = RuntimeAdapterWithAuth> {
     runtime: RuntimeClient;
     identity: any;
@@ -857,7 +876,7 @@ interface OpenRTCAdvancedNamespace {
  *
  * This is the unified type returned by OpenRTC() and OpenRTC.native().
  */
-interface OpenRTCClient extends RuntimeClient {
+interface OpenRTCClient$1 extends RuntimeClient {
     readonly devices: OpenRTCDeviceNamespace;
     readonly peers: OpenRTCPeerNamespace;
     readonly channels: OpenRTCChannelNamespace;
@@ -942,4 +961,245 @@ interface OpenRTCClient extends RuntimeClient {
     readonly _assembly: PlutoRuntimeAssembly;
 }
 
-export { DriveGrantActorError as D, type OpenRTCPeerNamespace as O, type PlutoRuntimeAssembly as P, type RuntimeFactoryOptions as R, type OpenRTCChannelNamespace as a, type OpenRTCDiagnosticsNamespace as b, type OpenRTCDeviceNamespace as c, type OpenRTCClient as d, type PeerReconciliationStats as e, OPENRTC_RUNTIME_POLICY as f, RuntimeClient as g, type RuntimePolicySnapshot as h, type DriveGrantActorErrorKind as i, DriveGrantActorHandle as j, type DriveGrantActorHandleOptions as k, DriveGrantActorRegistry as l, type DriveGrantActorState as m, type DriveGrantClose as n, type DriveGrantDial as o, type DriveGrantConnectionKey as p, type DriveGrantLogicalChannelHandle as q, type DriveGrantPreferredTransport as r, getRuntimePolicy as s, driveGrantConnectionKey as t, driveGrantConnectionKeyToString as u };
+interface OpenRTCAuthProvider {
+    /** Registered provider ID from the developer app capability manifest. */
+    readonly providerId?: string;
+    /**
+     * Stable, non-secret, local-only identifier for the currently signed-in
+     * principal. It changes on login, logout, or account switch, but never for
+     * an ordinary access-token refresh. OpenRTC hashes this value together
+     * with the app and installation-key thumbprint before persisting a lookup.
+     *
+     * Optional during the 2.0 RC compatibility window. Providers that omit it
+     * use the assertion-first flow and remain correct, but cannot skip the
+     * assertion exchange on a cold process start.
+     */
+    getSessionKey?(): Promise<string | null>;
+    getAssertion(input: {
+        audience: 'https://api.openrtc.app/v2/assertions/exchange';
+        forceRefresh: boolean;
+        /**
+         * Stable OpenRTC installation ID being enrolled. Consumer backends
+         * may bind product admission (for example a paid device allowance) to
+         * this value in the signed assertion. It is supplied only for an
+         * enrollment/renewal assertion, never for hourly gateway refreshes.
+         */
+        deviceId: string;
+    }): Promise<string | null>;
+    /**
+     * Optional identity-epoch observer. Notify only when the signed-in
+     * principal/session changes (login, logout, account switch, or explicit
+     * revocation). Do not notify for ordinary OAuth/Firebase access-token
+     * refreshes: OpenRTC refreshes its own avenue grant in place.
+     */
+    subscribe?(listener: (event: {
+        type: 'principal-changed';
+        sessionKey: string | null;
+    }) => void): () => void;
+}
+interface OpenRTCEnrolledDevice {
+    deviceId: string;
+    name?: string;
+    platform?: string;
+    enrolledAtMs: number | null;
+    lastGrantAtMs: number | null;
+    current: boolean;
+}
+/**
+ * Public, non-secret presentation metadata for one enrolled installation.
+ * OpenRTC derives a useful browser default when these fields are omitted;
+ * native hosts should pass the OS/device information reported by their host.
+ */
+interface OpenRTCDeviceProfile {
+    /** Human-readable label such as `Bryant's iPhone` or `Chrome on Android`. */
+    name?: string;
+    /** Raw OS/runtime label such as `ios`, `android`, `macos`, or `web`. */
+    platform?: string;
+    /** Optional application-owned public presence metadata, bounded to 4 KiB. */
+    metadata?: string;
+}
+interface OpenRTCAttestationProvider {
+    readonly kind: 'firebase-app-check' | 'apple-app-attest' | 'play-integrity' | `custom:${string}`;
+    /**
+     * Describes what the provider actually signs. Reusable app-integrity
+     * tokens (for example Firebase App Check) do not become request-bound just
+     * because OpenRTC supplies an enrollment challenge. The server derives and
+     * enforces the authoritative binding from the registered provider kind;
+     * this field keeps host integrations and diagnostics honest.
+     */
+    readonly evidenceBinding: 'app-session' | 'request-challenge';
+    getEvidence(input: {
+        challenge: string;
+        apiKey: string;
+    }): Promise<{
+        token: string;
+    }>;
+}
+/**
+ * Optional consumer-owned bot challenge. Core OpenRTC does not render a UI or
+ * load a CAPTCHA dependency; the host supplies a fresh token only when its
+ * developer manifest requires anonymous capability verification.
+ */
+interface OpenRTCBotVerificationProvider {
+    getToken(input: {
+        action: 'openrtc_capability';
+        apiKey: string;
+    }): Promise<string>;
+}
+interface OpenRTCUsageUpdate {
+    sessionCreditsUsd: number;
+    operation: string;
+    estimated: boolean;
+}
+interface OpenRTCUsageWarning extends OpenRTCUsageUpdate {
+    thresholdCreditsUsd: number;
+    kind: 'warning' | 'session-limit';
+}
+interface OpenRTCTransportPreferences {
+    iroh?: boolean;
+    webrtc?: boolean;
+    relay?: boolean;
+    moq?: boolean;
+    ble?: boolean;
+    /**
+     * Advanced privacy mode. `relay-only` suppresses direct Iroh addresses,
+     * local discovery, and host/srflx WebRTC candidates. It also requires the
+     * developer manifest's relay opt-in.
+     */
+    privacy?: 'direct' | 'relay-only';
+    /**
+     * Advanced native integration for hosts whose Rust process owns the
+     * application protocol registry (for example, a Tauri file-transfer host).
+     * Normal SDK consumers should leave this disabled.
+     */
+    nativeHostProtocols?: boolean;
+    priority?: readonly ('iroh' | 'webrtc' | 'moq' | 'ble')[];
+}
+interface OpenRTCOptions {
+    apiKey: string;
+    auth?: OpenRTCAuthProvider;
+    trust?: {
+        attestation?: OpenRTCAttestationProvider;
+        botVerification?: OpenRTCBotVerificationProvider;
+    };
+    usage?: {
+        warnAtSessionCreditsUsd?: number;
+        maxSessionCreditsUsd?: number;
+        onUsage?: (event: OpenRTCUsageUpdate) => void;
+        onWarning?: (warning: OpenRTCUsageWarning) => void;
+    };
+    transports?: OpenRTCTransportPreferences;
+}
+type OpenRTCAccessMode = 'capability' | 'authenticated';
+type OpenRTCLatestStateMode = 'reliable' | 'latest-state';
+interface OpenRTCCapabilityHandle {
+    readonly kind: 'devices' | 'space' | 'room' | 'ticket';
+    readonly id: string;
+    readonly peers: OpenRTCPeerNamespace;
+    readonly channels: OpenRTCChannelNamespace;
+    readonly diagnostics: OpenRTCDiagnosticsNamespace;
+    readonly closed: boolean;
+    close(): Promise<void>;
+}
+interface OpenRTCDevicesHandle extends OpenRTCCapabilityHandle {
+    readonly kind: 'devices';
+    localId(): ReturnType<OpenRTCDeviceNamespace['localId']>;
+    localInfo(): ReturnType<OpenRTCDeviceNamespace['localInfo']>;
+    list(): ReturnType<OpenRTCDeviceNamespace['list']>;
+    listWithStatus(): ReturnType<OpenRTCDeviceNamespace['listWithStatus']>;
+    watch: OpenRTCDeviceNamespace['watch'];
+    connect: OpenRTCDeviceNamespace['connect'];
+    disconnect: OpenRTCDeviceNamespace['disconnect'];
+}
+interface OpenRTCSpaceHandle extends OpenRTCCapabilityHandle {
+    readonly kind: 'space';
+    readonly delivery: OpenRTCLatestStateMode;
+    leave(): Promise<void>;
+}
+interface OpenRTCRoomHandle extends OpenRTCCapabilityHandle {
+    readonly kind: 'room';
+    readonly membership: 'ephemeral' | 'durable';
+    leave(): Promise<void>;
+}
+interface OpenRTCTicketHandle extends OpenRTCCapabilityHandle {
+    readonly kind: 'ticket';
+    readonly token: string;
+}
+interface OpenRTCDevicesStartOptions {
+    auth?: OpenRTCAuthProvider;
+    autoConnect?: 'none' | 'online';
+    /** Optional local profile; it does not alter the durable device identity. */
+    profile?: OpenRTCDeviceProfile;
+    maxPeers?: number;
+    /** Requires the app manifest's advanced-fanout opt-in. */
+    advancedFanout?: boolean;
+}
+interface OpenRTCSpaceJoinOptions {
+    access?: 'capability';
+    identity?: 'ephemeral';
+    payload?: OpenRTCLatestStateMode;
+    maxPeers?: number;
+    /** Requires the app manifest's advanced-fanout opt-in. */
+    advancedFanout?: boolean;
+}
+interface OpenRTCRoomJoinOptions {
+    access?: OpenRTCAccessMode;
+    membership?: 'ephemeral' | 'durable';
+    auth?: OpenRTCAuthProvider;
+    maxPeers?: number;
+    /** Requires the app manifest's advanced-fanout opt-in. */
+    advancedFanout?: boolean;
+}
+interface OpenRTCTicketIssueOptions {
+    maxPeers?: number;
+    /** Requires the app manifest's advanced-fanout opt-in. */
+    advancedFanout?: boolean;
+}
+interface OpenRTCChannelCatalog {
+    register(descriptor: RuntimeChannelDescriptor): () => void;
+    list(): readonly RuntimeChannelDescriptor[];
+}
+interface OpenRTCUsageNamespace {
+    estimate(input: {
+        operation: string;
+        units?: number;
+    }): {
+        creditsUsd: number;
+        estimated: true;
+    };
+    readonly sessionCreditsUsd: number;
+}
+interface OpenRTCClient {
+    readonly devices: {
+        /**
+         * Returns this installation's durable, app-scoped device ID without
+         * starting a capability or performing network work.
+         */
+        localId(): Promise<string>;
+        start(options?: OpenRTCDevicesStartOptions): Promise<OpenRTCDevicesHandle>;
+        listEnrolled(options?: {
+            auth?: OpenRTCAuthProvider;
+        }): Promise<OpenRTCEnrolledDevice[]>;
+        revoke(deviceId: string, options?: {
+            auth?: OpenRTCAuthProvider;
+        }): Promise<void>;
+        revokeAll(options?: {
+            auth?: OpenRTCAuthProvider;
+            exceptCurrent?: boolean;
+        }): Promise<void>;
+    };
+    readonly spaces: {
+        join(id: string, options?: OpenRTCSpaceJoinOptions): Promise<OpenRTCSpaceHandle>;
+    };
+    readonly rooms: {
+        join(id: string, options?: OpenRTCRoomJoinOptions): Promise<OpenRTCRoomHandle>;
+    };
+    readonly tickets: {
+        issue(id: string, options?: OpenRTCTicketIssueOptions): Promise<OpenRTCTicketHandle>;
+    };
+    readonly channels: OpenRTCChannelCatalog;
+    readonly usage: OpenRTCUsageNamespace;
+    close(): Promise<void>;
+}
+
+export { OPENRTC_RUNTIME_POLICY as A, type PlutoIpcUnlisten as B, type RuntimePolicySnapshot as C, DriveGrantActorError as D, type DriveGrantActorErrorKind as E, DriveGrantActorHandle as F, type DriveGrantActorHandleOptions as G, DriveGrantActorRegistry as H, type DriveGrantActorState as I, type DriveGrantClose as J, type DriveGrantDial as K, type DriveGrantConnectionKey as L, type DriveGrantLogicalChannelHandle as M, type NativeIpcFailureKind as N, type OpenRTCOptions as O, type PlutoIpcBridge as P, type DriveGrantPreferredTransport as Q, RuntimeClient as R, getRuntimePolicy as S, driveGrantConnectionKey as T, driveGrantConnectionKeyToString as U, type OpenRTCClient as a, type OpenRTCAccessMode as b, type OpenRTCAttestationProvider as c, type OpenRTCAuthProvider as d, type OpenRTCBotVerificationProvider as e, type OpenRTCCapabilityHandle as f, type OpenRTCChannelCatalog as g, type OpenRTCDeviceProfile as h, type OpenRTCDevicesHandle as i, type OpenRTCDevicesStartOptions as j, type OpenRTCEnrolledDevice as k, type OpenRTCLatestStateMode as l, type OpenRTCRoomHandle as m, type OpenRTCRoomJoinOptions as n, type OpenRTCSpaceHandle as o, type OpenRTCSpaceJoinOptions as p, type OpenRTCTicketHandle as q, type OpenRTCTicketIssueOptions as r, type OpenRTCTransportPreferences as s, type OpenRTCUsageNamespace as t, type OpenRTCUsageUpdate as u, type OpenRTCUsageWarning as v, classifyNativeIpcFailure as w, isNativeIpcCommandUnavailable as x, type OpenRTCClient$1 as y, type PeerReconciliationStats as z };

package/dist/{types-DkgaCyqS.d.ts → types-oGGnaSW2.d.ts}

@@ -1,5 +1,5 @@
 import { A as AuthContext } from './IEngineBridge-BbsT8hof.js';
-import { C as ConnectionOptions, A as ApplicationPayloadCrypto, a as ApplicationPayloadReadinessOptions, b as ApplicationPayloadRouteOptions, P as ProtocolName, c as ApplicationPayloadSendOptions, T as TransportLatencySnapshot, d as PeerState, e as PeerScope, f as PeerHealth, g as ChannelDescriptor$1, I as IncomingStreamChannelMetadata, D as Device, B as BackendConnectionState, L as LocalDeviceInfo, h as DeviceStatusSnapshot, M as ManagedDeviceConnectOptions, i as ClientOptions, S as SignalingSession, R as RuntimeIdentity, J as JoinRoomOptions, j as RoomMember, k as DevicePresenceStatus, l as PeerLifecycleStatus, m as PeerSessionSnapshot } from './types-BVJr065k.js';
+import { n as ConnectionOptions, o as ApplicationPayloadCrypto, p as ApplicationPayloadReadinessOptions, q as ApplicationPayloadRouteOptions, r as ProtocolName, s as ApplicationPayloadSendOptions, T as TransportLatencySnapshot, t as PeerState, u as PeerScope, v as PeerHealth, w as ChannelDescriptor$1, x as IncomingStreamChannelMetadata, b as Device, m as BackendConnectionState, L as LocalDeviceInfo, c as DeviceStatusSnapshot, y as ManagedDeviceConnectOptions, C as ClientOptions, h as SignalingSession, R as RuntimeIdentity, J as JoinRoomOptions, a as RoomMember, z as DevicePresenceStatus, F as PeerLifecycleStatus, P as PeerSessionSnapshot } from './types-BwmoJU2O.js';
 import { I as ITransport } from './ITransport-BsPcaov7.js';
 
 type ConnectionHealth = 'unknown' | 'healthy' | 'suspect' | 'stale';
@@ -595,4 +595,4 @@ type SessionOptions = RuntimeManagedSessionOptions;
 type Session = RuntimeManagedSession;
 type ChannelDescriptor = RuntimeChannelDescriptor;
 
-export { type Session as $, type ChannelDescriptor as A, type ConnectionEvent as B, Connection as C, type ConnectionTarget as D, type DeviceProfile as E, type PeerReadiness as F, type PeerStreamOptions as G, type PresenceLoopOptions as H, type IncomingStream as I, type RawConnection as J, type RuntimeApplicationPayloadRouteOptions as K, type RuntimeAuthContext as L, type RuntimeAutoConnectPolicy as M, type RuntimeDevicePresenceStatus as N, type RuntimeDeviceStatus as O, type PeerConnectOptions as P, type RuntimeLogicalChannelFraming as Q, type RuntimeChannelDescriptor as R, type RuntimeManagedSessionKind as S, type RuntimeManagedSessionPlatform as T, type RuntimePeerLifecycleStatus as U, type RuntimePeerScope as V, type RuntimePeerSessionSnapshot as W, type RuntimePresencePolicy as X, type RuntimeUiConnectionStatus as Y, type ScopedChannelOptions as Z, type ScopedLogicalChannel as _, type RuntimeClientOptions as a, type SessionOptions as a0, type RuntimePeerState as b, type RuntimeConnectionStateSnapshot as c, type RuntimePeerReadinessSnapshot as d, type RuntimePeerConnectOptions as e, type RuntimeIncomingStream as f, type RuntimeAuthIdentity as g, type RuntimeLocalDeviceInfo as h, type RuntimeLocalDeviceProfile as i, type RuntimeDevice as j, type RuntimeManagedSessionOptions as k, type RuntimeManagedSession as l, type RuntimeDeviceStatusSnapshot as m, type RuntimeDeviceConnectOptions as n, type RuntimeSession as o, type RuntimeJoinRoomOptions as p, type RuntimeRoomMember as q, type RuntimeConnectionTarget as r, type RuntimeScopedChannelOptions as s, type RuntimeScopedLogicalChannel as t, type RuntimePeerStreamOptions as u, type RuntimeRawConnection as v, type RuntimePresenceLoopOptions as w, type RuntimePeerHealth as x, type RuntimeApplicationPayloadReadinessOptions as y, type RuntimeConnectionEvent as z };
+export { type Session as $, type ChannelDescriptor as A, type ConnectionEvent as B, Connection as C, type ConnectionTarget as D, type DeviceProfile as E, type PeerReadiness as F, type PeerStreamOptions as G, type PresenceLoopOptions as H, type IncomingStream as I, type RawConnection as J, type RuntimeApplicationPayloadRouteOptions as K, type RuntimeAuthContext as L, type RuntimeAutoConnectPolicy as M, type RuntimeDevicePresenceStatus as N, type RuntimeDeviceStatus as O, type PeerConnectOptions as P, type RuntimeLogicalChannelFraming as Q, type RuntimePeerState as R, type RuntimeManagedSessionKind as S, type RuntimeManagedSessionPlatform as T, type RuntimePeerLifecycleStatus as U, type RuntimePeerScope as V, type RuntimePeerSessionSnapshot as W, type RuntimePresencePolicy as X, type RuntimeUiConnectionStatus as Y, type ScopedChannelOptions as Z, type ScopedLogicalChannel as _, type RuntimeConnectionStateSnapshot as a, type SessionOptions as a0, type RuntimePeerReadinessSnapshot as b, type RuntimePeerConnectOptions as c, type RuntimeIncomingStream as d, type RuntimeClientOptions as e, type RuntimeAuthIdentity as f, type RuntimeLocalDeviceInfo as g, type RuntimeLocalDeviceProfile as h, type RuntimeDevice as i, type RuntimeManagedSessionOptions as j, type RuntimeManagedSession as k, type RuntimeDeviceStatusSnapshot as l, type RuntimeDeviceConnectOptions as m, type RuntimeSession as n, type RuntimeJoinRoomOptions as o, type RuntimeRoomMember as p, type RuntimeConnectionTarget as q, type RuntimeScopedChannelOptions as r, type RuntimeScopedLogicalChannel as s, type RuntimePeerStreamOptions as t, type RuntimeRawConnection as u, type RuntimeChannelDescriptor as v, type RuntimePresenceLoopOptions as w, type RuntimePeerHealth as x, type RuntimeApplicationPayloadReadinessOptions as y, type RuntimeConnectionEvent as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openrtc",
-  "version": "2.0.0-rc.2",
+  "version": "2.0.0-rc.21",
   "private": false,
   "type": "module",
   "sideEffects": false,
@@ -43,18 +43,10 @@
       "types": "./dist/testing.d.ts",
       "import": "./dist/testing.js"
     },
-    "./auth": {
-      "types": "./dist/auth/index.d.ts",
-      "import": "./dist/auth/index.js"
-    },
     "./runtime": {
       "types": "./dist/runtime/index.d.ts",
       "import": "./dist/runtime/index.js"
     },
-    "./runtime/legacy": {
-      "types": "./dist/runtime/legacy.d.ts",
-      "import": "./dist/runtime/legacy.js"
-    },
     "./runtime/device-status": {
       "types": "./dist/runtime/device-status.d.ts",
       "import": "./dist/runtime/device-status.js"
@@ -63,18 +55,10 @@
       "types": "./dist/runtime/WasmRuntimeAdapter.d.ts",
       "import": "./dist/runtime/WasmRuntimeAdapter.js"
     },
-    "./runtime/tauri": {
-      "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"
-    },
     "./package.json": "./package.json"
   },
   "scripts": {
@@ -107,14 +91,6 @@
     "@noble/hashes": "^1.8.0",
     "tweetnacl": "^1.0.3"
   },
-  "peerDependencies": {
-    "firebase": "^9.0.0 || ^10.0.0 || ^11.0.0 || ^12.0.0"
-  },
-  "peerDependenciesMeta": {
-    "firebase": {
-      "optional": true
-    }
-  },
   "devDependencies": {
     "@types/node": "^20.0.0",
     "@vitest/coverage-v8": "^4.0.18",