openrtc 1.0.4 → 1.0.6

package/dist/runtime/tauri.js

@@ -1 +1 @@
-export{b as TauriRuntimeAdapter,a as createTauriIpcBridge}from'../chunk-RRCARL4S.js';import'../chunk-L6OUJ6YN.js';import'../chunk-MESPJTUA.js';import'../chunk-34LATQZZ.js';import'../chunk-QT2ASNI3.js';import'../chunk-C7YN5MSV.js';
+export{b as TauriRuntimeAdapter,a as createTauriIpcBridge}from'../chunk-N6UBUNGC.js';import'../chunk-DI5IPRPM.js';import'../chunk-YTUWXCRO.js';import'../chunk-QT2ASNI3.js';import'../chunk-HVTYSEU7.js';import'../chunk-C7YN5MSV.js';

package/dist/spaceTokens-3sbs1mUF.d.ts

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

package/dist/tauri-BVSxK0jq.d.ts

@@ -0,0 +1,33 @@
+import { n as ClientOptions } from './types-BCkKK8dy.js';
+import { W as WasmBridgeOptions, D as DelegatingRuntimeAdapter } from './DelegatingRuntimeAdapter-DlC0TZB0.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);
+}
+
+/**
+ * @deprecated Native Tauri support now lives in the first-party `openrtc-tauri` package.
+ * Removal target: OpenRTC 0.2.0. This shim remains for one compatibility cycle.
+ */
+declare function createTauriIpcBridge(): PlutoIpcBridge;
+/**
+ * @deprecated Native Tauri support now lives in the first-party `openrtc-tauri` package.
+ * Removal target: OpenRTC 0.2.0. This shim remains for one compatibility cycle.
+ */
+declare class TauriRuntimeAdapter extends IpcRuntimeAdapter {
+    constructor(options: NativeIpcBridgeOptions);
+}
+type TauriRuntimeAdapterOptions = NativeIpcBridgeOptions;
+
+export { IpcRuntimeAdapter as I, TauriRuntimeAdapter as T, type IpcRuntimeAdapterOptions as a, type TauriRuntimeAdapterOptions as b, createTauriIpcBridge as c };

package/dist/tauri-WEvOC_Z6.d.ts

@@ -0,0 +1,33 @@
+import { p as ClientOptions } from './types-ZDsZknDI.js';
+import { W as WasmBridgeOptions, D as DelegatingRuntimeAdapter } from './DelegatingRuntimeAdapter-lFDUNBy9.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);
+}
+
+/**
+ * @deprecated Native Tauri support now lives in the first-party `openrtc-tauri` package.
+ * Removal target: OpenRTC 0.2.0. This shim remains for one compatibility cycle.
+ */
+declare function createTauriIpcBridge(): PlutoIpcBridge;
+/**
+ * @deprecated Native Tauri support now lives in the first-party `openrtc-tauri` package.
+ * Removal target: OpenRTC 0.2.0. This shim remains for one compatibility cycle.
+ */
+declare class TauriRuntimeAdapter extends IpcRuntimeAdapter {
+    constructor(options: NativeIpcBridgeOptions);
+}
+type TauriRuntimeAdapterOptions = NativeIpcBridgeOptions;
+
+export { IpcRuntimeAdapter as I, TauriRuntimeAdapter as T, type IpcRuntimeAdapterOptions as a, type TauriRuntimeAdapterOptions as b, createTauriIpcBridge as c };

package/dist/transport/index.d.ts

@@ -1,5 +1,5 @@
-import { K as RouteDescriptor, o as ProtocolName } from '../types-ByZyADCn.js';
-export { O as RouteFamily, Q as RouteImplementationKind } from '../types-ByZyADCn.js';
+import { a0 as RouteDescriptor, u as ProtocolName } from '../types-ZDsZknDI.js';
+export { a1 as RouteFamily, a2 as RouteImplementationKind } from '../types-ZDsZknDI.js';
 
 declare const ROUTE_DESCRIPTORS: readonly RouteDescriptor[];
 declare function getRouteDescriptor(id: ProtocolName): RouteDescriptor;

package/dist/{types-ByZyADCn.d.ts → types-BCkKK8dy.d.ts}

@@ -934,4 +934,4 @@ interface JoinRequest {
     state: 'pending' | 'accepted' | 'rejected';
 }
 
-export type { RuntimeBootstrapOptions as $, AuthMode as A, BackendPeerBiStream as B, ClientOptions as C, DiscoveryMode as D, ExplicitFileDataSendParams as E, ProtocolBaseName as F, GrantScope as G, ProtocolImplementationKind as H, ISignalingBackend as I, ProtocolLocality as J, RouteDescriptor as K, LocalDeviceInfo as L, ManagedConnectionRecord as M, NativeManagedSessionStartResult as N, RouteFamily as O, PeerSessionSnapshot as P, RouteImplementationKind as Q, RuntimeIdentity as R, SignalingMode as S, SpaceAuthMode as T, SignalingOptions as U, JoinRoomOptions as V, RoomMember as W, IncomingStreamChannelMetadata as X, RoomCreationMode as Y, ScanningLoopOptions as Z, ScanningLoopHandle as _, Device as a, RuntimeBootstrapResult as a0, ManagedApplicationRouteOptions as a1, PeerState as a2, PeerScope as a3, PeerHealth as a4, ChannelDescriptor as a5, JoinRequest as a6, ConnectionOptions as a7, TransportLatencySnapshot as a8, ManagedDeviceConnectOptions as a9, PeerLifecycleStatus as aa, DeviceStatusSnapshot as b, ResolvedPeerIdentity as c, SignalingEnvelope as d, DeviceEvent as e, SignalingSession as f, SessionEvent as g, BackendPeerUniStream as h, NativeConnectParams as i, NativeConnectResult as j, BackendConnectionState as k, ConnectDeviceResult as l, ConnectDeviceHooks as m, ConnectDeviceOptions as n, ProtocolName as o, ProtocolCapability as p, ProtocolCapabilityMap as q, ApplicationPayloadCrypto as r, ApplicationCryptoStreamTools as s, SpaceTokenProvider as t, AppLimits as u, ApplicationCryptoBiStream as v, ApplicationPayloadReadinessOptions as w, ApplicationPayloadRouteOptions as x, ApplicationPayloadSendOptions as y, DevicePresenceStatus as z };
+export type { RouteDescriptor as $, AuthMode as A, BackendPeerBiStream as B, ConnectDeviceResult as C, DiscoveryMode as D, ExplicitFileDataSendParams as E, PeerScope as F, GrantScope as G, DevicePresenceStatus as H, ISignalingBackend as I, JoinRoomOptions as J, PeerLifecycleStatus as K, LocalDeviceInfo as L, ManagedConnectionRecord as M, NativeManagedSessionStartResult as N, ProtocolCapability as O, PeerSessionSnapshot as P, ProtocolCapabilityMap as Q, ResolvedPeerIdentity as R, SignalingMode as S, TransportLatencySnapshot as T, ApplicationCryptoStreamTools as U, SpaceTokenProvider as V, AppLimits as W, ApplicationCryptoBiStream as X, ProtocolBaseName as Y, ProtocolImplementationKind as Z, ProtocolLocality as _, ConnectDeviceHooks as a, RouteFamily as a0, RouteImplementationKind as a1, SpaceAuthMode as a2, SignalingOptions as a3, RoomCreationMode as a4, ScanningLoopOptions as a5, ScanningLoopHandle as a6, RuntimeBootstrapOptions as a7, RuntimeBootstrapResult as a8, ManagedApplicationRouteOptions as a9, JoinRequest as aa, ConnectDeviceOptions as b, RuntimeIdentity as c, Device as d, DeviceStatusSnapshot as e, SignalingEnvelope as f, DeviceEvent as g, SignalingSession as h, SessionEvent as i, BackendPeerUniStream as j, NativeConnectParams as k, NativeConnectResult as l, BackendConnectionState as m, ClientOptions as n, ConnectionOptions as o, ApplicationPayloadCrypto as p, ApplicationPayloadReadinessOptions as q, ApplicationPayloadRouteOptions as r, ProtocolName as s, ApplicationPayloadSendOptions as t, ChannelDescriptor as u, IncomingStreamChannelMetadata as v, ManagedDeviceConnectOptions as w, PeerState as x, PeerHealth as y, RoomMember as z };

package/dist/{device-status-CR27Ak7c.d.ts → types-N9s66nF8.d.ts}

@@ -1,5 +1,5 @@
 import { A as AuthContext } from './IEngineBridge-C7OT2CRv.js';
-import { a7 as ConnectionOptions, r as ApplicationPayloadCrypto, w as ApplicationPayloadReadinessOptions, x as ApplicationPayloadRouteOptions, o as ProtocolName, y as ApplicationPayloadSendOptions, a8 as TransportLatencySnapshot, a5 as ChannelDescriptor$1, L as LocalDeviceInfo, X as IncomingStreamChannelMetadata, C as ClientOptions, a as Device, f as SignalingSession, R as RuntimeIdentity, b as DeviceStatusSnapshot, a9 as ManagedDeviceConnectOptions, a2 as PeerState, a4 as PeerHealth, V as JoinRoomOptions, W as RoomMember, a3 as PeerScope, k as BackendConnectionState, z as DevicePresenceStatus, aa as PeerLifecycleStatus, P as PeerSessionSnapshot } from './types-ByZyADCn.js';
+import { q as ConnectionOptions, r as ApplicationPayloadCrypto, s as ApplicationPayloadReadinessOptions, t as ApplicationPayloadRouteOptions, u as ProtocolName, v as ApplicationPayloadSendOptions, T as TransportLatencySnapshot, w as ChannelDescriptor$1, L as LocalDeviceInfo, x as IncomingStreamChannelMetadata, p as ClientOptions, f as Device, j as SignalingSession, e as RuntimeIdentity, g as DeviceStatusSnapshot, y as ManagedDeviceConnectOptions, z as PeerState, F as PeerHealth, J as JoinRoomOptions, H as RoomMember, K as PeerScope, o as BackendConnectionState, O as DevicePresenceStatus, Q as PeerLifecycleStatus, P as PeerSessionSnapshot } from './types-ZDsZknDI.js';
 
 interface ITransport {
     readonly name: string;
@@ -483,7 +483,7 @@ interface RuntimeScopedLogicalChannel {
  */
 type RuntimeDeviceStatusSnapshot = Omit<DeviceStatusSnapshot, 'nodeId'>;
 type RuntimeDeviceStatus = RuntimeDeviceStatusSnapshot;
-type RuntimeDevicePresenceStatus$1 = DevicePresenceStatus;
+type RuntimeDevicePresenceStatus = DevicePresenceStatus;
 type RuntimeIncomingStream = {
     type: 'bi' | 'uni';
     stream: any;
@@ -570,37 +570,4 @@ type SessionOptions = RuntimeManagedSessionOptions;
 type Session = RuntimeManagedSession;
 type ChannelDescriptor = RuntimeChannelDescriptor;
 
-interface RuntimeDeviceActiveOptions {
-    now?: number;
-    /**
-     * Optional local freshness window for durable roster rows. Leave undefined
-     * when the caller only wants to honor explicit online/expiresAt state.
-     */
-    staleAfterMs?: number;
-}
-type RuntimeDeviceActivityStatus = Pick<Partial<RuntimeDevice>, 'online' | 'lastSeenAt' | 'updatedAt' | 'createdAt' | 'expiresAt'>;
-type RuntimeDeviceRouteStatus = Pick<Partial<RuntimeDeviceStatusSnapshot>, 'settledReady' | 'readinessState' | 'connectionStatus'>;
-type RuntimeDevicePresenceStatus = Pick<RuntimeDevice, 'online' | 'ticket'> & Pick<Partial<RuntimeDeviceStatusSnapshot>, 'connectable' | 'presenceStatus' | 'online' | 'ticket'>;
-/**
- * True when a runtime device row is currently live enough to display or
- * consider for app-level routing. This is deliberately separate from
- * `isRuntimeDeviceConnectable`: a peer can be active/present before it has a
- * usable ticket, and a stale durable row should not keep app UIs alive.
- */
-declare function isRuntimeDeviceActive(device: RuntimeDeviceActivityStatus, options?: RuntimeDeviceActiveOptions): boolean;
-/**
- * True once OpenRTC has a routable peer projection for normal app payloads.
- *
- * This intentionally does not inspect discovery metadata or device
- * capabilities. Those fields describe the remote endpoint roster entry; they
- * are not proof that an application-level protocol has exchanged its own
- * ready/capability message over the mesh.
- */
-declare function isRuntimeDeviceRoutable(device: RuntimeDeviceRouteStatus): boolean;
-/**
- * True when the discovery row currently has enough fresh presence to attempt
- * a dial. This is a discovery gate, not a connected/readiness gate.
- */
-declare function isRuntimeDeviceConnectable(device: RuntimeDevicePresenceStatus): boolean;
-
-export { isRuntimeDeviceActive as $, type PeerReadiness as A, type PeerStreamOptions as B, Connection as C, type DeviceProfile as D, type PresenceLoopOptions as E, type RawConnection as F, type RuntimeAuthContext as G, type RuntimeAuthIdentity as H, type ITransport as I, type RuntimeAutoConnectPolicy as J, type RuntimeConnectionTarget as K, type RuntimeDevicePresenceStatus$1 as L, type RuntimeDeviceStatus as M, type RuntimeLogicalChannelFraming as N, type RuntimeManagedSessionKind as O, type PeerConnectOptions as P, type RuntimeManagedSessionPlatform as Q, type RuntimeClientOptions as R, type RuntimePeerLifecycleStatus as S, type RuntimePeerScope as T, type RuntimePeerSessionSnapshot as U, type RuntimePresenceLoopOptions as V, type RuntimePresencePolicy as W, type RuntimeSession as X, type RuntimeUiConnectionStatus as Y, type ScopedChannelOptions as Z, type ScopedLogicalChannel as _, type RuntimeManagedSessionOptions as a, isRuntimeDeviceConnectable as a0, isRuntimeDeviceRoutable as a1, type RuntimeDeviceActiveOptions as a2, type Session as a3, type SessionOptions as a4, type RuntimeManagedSession as b, type RuntimeDevice as c, type RuntimeDeviceStatusSnapshot as d, type RuntimeDeviceConnectOptions as e, type RuntimeLocalDeviceInfo as f, type RuntimeLocalDeviceProfile as g, type RuntimePeerState as h, type RuntimePeerConnectOptions as i, type RuntimePeerReadinessSnapshot as j, type RuntimePeerHealth as k, type RuntimeChannelDescriptor as l, type RuntimePeerStreamOptions as m, type RuntimeIncomingStream as n, type RuntimeScopedChannelOptions as o, type RuntimeScopedLogicalChannel as p, type RuntimeJoinRoomOptions as q, type RuntimeRoomMember as r, type RuntimeConnectionStateSnapshot as s, type RuntimeApplicationPayloadReadinessOptions as t, type RuntimeConnectionEvent as u, type RuntimeRawConnection as v, type ChannelDescriptor as w, type ConnectionEvent as x, type ConnectionTarget as y, type IncomingStream as z };
+export { type Session as $, type PeerReadiness as A, type PeerStreamOptions as B, Connection as C, type DeviceProfile as D, type PresenceLoopOptions as E, type RawConnection as F, type RuntimeAuthContext as G, type RuntimeAuthIdentity as H, type ITransport as I, type RuntimeAutoConnectPolicy as J, type RuntimeConnectionTarget as K, type RuntimeDevicePresenceStatus as L, type RuntimeDeviceStatus as M, type RuntimeLogicalChannelFraming as N, type RuntimeManagedSessionKind as O, type PeerConnectOptions as P, type RuntimeManagedSessionPlatform as Q, type RuntimeClientOptions as R, type RuntimePeerLifecycleStatus as S, type RuntimePeerScope as T, type RuntimePeerSessionSnapshot as U, type RuntimePresenceLoopOptions as V, type RuntimePresencePolicy as W, type RuntimeSession as X, type RuntimeUiConnectionStatus as Y, type ScopedChannelOptions as Z, type ScopedLogicalChannel as _, type RuntimeManagedSessionOptions as a, type SessionOptions as a0, type RuntimeManagedSession as b, type RuntimeDevice as c, type RuntimeDeviceStatusSnapshot as d, type RuntimeDeviceConnectOptions as e, type RuntimeLocalDeviceInfo as f, type RuntimeLocalDeviceProfile as g, type RuntimePeerState as h, type RuntimePeerConnectOptions as i, type RuntimePeerReadinessSnapshot as j, type RuntimePeerHealth as k, type RuntimeChannelDescriptor as l, type RuntimePeerStreamOptions as m, type RuntimeIncomingStream as n, type RuntimeScopedChannelOptions as o, type RuntimeScopedLogicalChannel as p, type RuntimeJoinRoomOptions as q, type RuntimeRoomMember as r, type RuntimeConnectionStateSnapshot as s, type RuntimeApplicationPayloadReadinessOptions as t, type RuntimeConnectionEvent as u, type RuntimeRawConnection as v, type ChannelDescriptor as w, type ConnectionEvent as x, type ConnectionTarget as y, type IncomingStream as z };