openrtc 2.0.0-rc.2 → 2.0.0-rc.20

package/dist/runtime/index.d.ts

@@ -1,19 +1,13 @@
-import { R as RuntimeFactoryOptions, P as PlutoRuntimeAssembly, d as OpenRTCClient, e as PeerReconciliationStats } from '../OpenRTCShared-ZQPu5LqL.js';
-export { f as OPENRTC_RUNTIME_POLICY, g as RuntimeClient, h as RuntimePolicySnapshot, D as ScopedConnectionActorError, i as ScopedConnectionActorErrorKind, j as ScopedConnectionActorHandle, k as ScopedConnectionActorHandleOptions, l as ScopedConnectionActorRegistry, m as ScopedConnectionActorState, n as ScopedConnectionClose, o as ScopedConnectionDial, p as ScopedConnectionKey, q as ScopedLogicalChannelHandle, r as ScopedPreferredTransport, s as getRuntimePolicy, t as scopedConnectionKey, u as scopedConnectionKeyToString } from '../OpenRTCShared-ZQPu5LqL.js';
-import { f as OpenRTCCapabilityHandle } from '../types-DNl4KHHY.js';
-import { C as Connection, r as RuntimeConnectionTarget, v as RuntimeRawConnection } from '../types-DkgaCyqS.js';
-export { A as ChannelDescriptor, B as ConnectionEvent, D as ConnectionTarget, E as DeviceProfile, I as IncomingStream, P as PeerConnectOptions, F as PeerReadiness, G as PeerStreamOptions, H as PresenceLoopOptions, J as RawConnection, y as RuntimeApplicationPayloadReadinessOptions, K as RuntimeApplicationPayloadRouteOptions, L as RuntimeAuthContext, g as RuntimeAuthIdentity, M as RuntimeAutoConnectPolicy, R as RuntimeChannelDescriptor, a as RuntimeClientOptions, z as RuntimeConnectionEvent, c as RuntimeConnectionStateSnapshot, j as RuntimeDevice, n as RuntimeDeviceConnectOptions, N as RuntimeDevicePresenceStatus, O as RuntimeDeviceStatus, m as RuntimeDeviceStatusSnapshot, f as RuntimeIncomingStream, p as RuntimeJoinRoomOptions, h as RuntimeLocalDeviceInfo, i as RuntimeLocalDeviceProfile, Q as RuntimeLogicalChannelFraming, l as RuntimeManagedSession, S as RuntimeManagedSessionKind, k as RuntimeManagedSessionOptions, T as RuntimeManagedSessionPlatform, e as RuntimePeerConnectOptions, x as RuntimePeerHealth, U as RuntimePeerLifecycleStatus, d as RuntimePeerReadinessSnapshot, V as RuntimePeerScope, W as RuntimePeerSessionSnapshot, b as RuntimePeerState, u as RuntimePeerStreamOptions, w as RuntimePresenceLoopOptions, X as RuntimePresencePolicy, q as RuntimeRoomMember, s as RuntimeScopedChannelOptions, t as RuntimeScopedLogicalChannel, o as RuntimeSession, Y as RuntimeUiConnectionStatus, Z as ScopedChannelOptions, _ as ScopedLogicalChannel, $ as Session, a0 as SessionOptions } from '../types-DkgaCyqS.js';
+import { P as PlutoIpcBridge, y as OpenRTCClient, f as OpenRTCCapabilityHandle, z as PeerReconciliationStats } from '../types-DE4iPkMB.js';
+export { N as NativeIpcFailureKind, A as OPENRTC_RUNTIME_POLICY, B as PlutoIpcUnlisten, R as RuntimeClient, C as RuntimePolicySnapshot, D as ScopedConnectionActorError, E as ScopedConnectionActorErrorKind, F as ScopedConnectionActorHandle, G as ScopedConnectionActorHandleOptions, H as ScopedConnectionActorRegistry, I as ScopedConnectionActorState, J as ScopedConnectionClose, K as ScopedConnectionDial, L as ScopedConnectionKey, M as ScopedLogicalChannelHandle, Q as ScopedPreferredTransport, w as classifyNativeIpcFailure, S as getRuntimePolicy, x as isNativeIpcCommandUnavailable, T as scopedConnectionKey, U as scopedConnectionKeyToString } from '../types-DE4iPkMB.js';
+import { C as Connection, q as RuntimeConnectionTarget, u as RuntimeRawConnection } from '../types-oGGnaSW2.js';
+export { A as ChannelDescriptor, B as ConnectionEvent, D as ConnectionTarget, E as DeviceProfile, I as IncomingStream, P as PeerConnectOptions, F as PeerReadiness, G as PeerStreamOptions, H as PresenceLoopOptions, J as RawConnection, y as RuntimeApplicationPayloadReadinessOptions, K as RuntimeApplicationPayloadRouteOptions, L as RuntimeAuthContext, f as RuntimeAuthIdentity, M as RuntimeAutoConnectPolicy, v as RuntimeChannelDescriptor, e as RuntimeClientOptions, z as RuntimeConnectionEvent, a as RuntimeConnectionStateSnapshot, i as RuntimeDevice, m as RuntimeDeviceConnectOptions, N as RuntimeDevicePresenceStatus, O as RuntimeDeviceStatus, l as RuntimeDeviceStatusSnapshot, d as RuntimeIncomingStream, o as RuntimeJoinRoomOptions, g as RuntimeLocalDeviceInfo, h as RuntimeLocalDeviceProfile, Q as RuntimeLogicalChannelFraming, k as RuntimeManagedSession, S as RuntimeManagedSessionKind, j as RuntimeManagedSessionOptions, T as RuntimeManagedSessionPlatform, c as RuntimePeerConnectOptions, x as RuntimePeerHealth, U as RuntimePeerLifecycleStatus, b as RuntimePeerReadinessSnapshot, V as RuntimePeerScope, W as RuntimePeerSessionSnapshot, R as RuntimePeerState, t as RuntimePeerStreamOptions, w as RuntimePresenceLoopOptions, X as RuntimePresencePolicy, p as RuntimeRoomMember, r as RuntimeScopedChannelOptions, s as RuntimeScopedLogicalChannel, n as RuntimeSession, Y as RuntimeUiConnectionStatus, Z as ScopedChannelOptions, _ as ScopedLogicalChannel, $ as Session, a0 as SessionOptions } from '../types-oGGnaSW2.js';
 import * as Draft14 from '@moq/net';
-import { a0 as SignalingOptions, q as ISignalingBackend, R as RuntimeIdentity, j as RoomMember, r as SignalingEnvelope, S as SignalingSession, D as Device, x as DesiredPeerProjection, B as BackendConnectionState, $ as AppLimits, H as GrantScope, J as JoinRoomOptions, I as IncomingStreamChannelMetadata, U as ApplicationCryptoStreamTools, a1 as RoomCreationMode, i as ClientOptions, A as ApplicationPayloadCrypto, n as DiscoveryMode, Q as ProtocolCapabilityMap, a2 as ScanningLoopOptions, a3 as ScanningLoopHandle, a4 as RuntimeBootstrapOptions, a5 as RuntimeBootstrapResult, a as ApplicationPayloadReadinessOptions, a6 as ManagedApplicationRouteOptions, d as PeerState, e as PeerScope, f as PeerHealth, g as ChannelDescriptor, a7 as JoinRequest, N as NativeConnectParams, z as NativeConnectResult, a8 as SpaceTokenProvider } from '../types-BVJr065k.js';
+import { $ as SignalingOptions, I as ISignalingBackend, R as RuntimeIdentity, a as RoomMember, e as SignalingEnvelope, h as SignalingSession, b as Device, g as DesiredPeerProjection, m as BackendConnectionState, C as ClientOptions, _ as AppLimits, G as GrantScope, J as JoinRoomOptions, x as IncomingStreamChannelMetadata, Q as ApplicationCryptoStreamTools, a0 as RoomCreationMode, o as ApplicationPayloadCrypto, D as DiscoveryMode, O as ProtocolCapabilityMap, a1 as ScanningLoopOptions, a2 as ScanningLoopHandle, a3 as RuntimeBootstrapOptions, a4 as RuntimeBootstrapResult, p as ApplicationPayloadReadinessOptions, a5 as ManagedApplicationRouteOptions, t as PeerState, u as PeerScope, v as PeerHealth, w as ChannelDescriptor, a6 as JoinRequest, k as NativeConnectParams, l as NativeConnectResult } from '../types-BwmoJU2O.js';
 import { R as RuntimeCapabilities } from '../capabilities-YSskrE8H.js';
 export { B as BROWSER_WASM_RUNTIME_CAPABILITIES, b as BrowserRuntimeCapabilityHost, N as NATIVE_IPC_RUNTIME_CAPABILITIES, c as NativeRuntimeStatusSnapshot, d as NativeRuntimeTransportFeatureStatus, e as RuntimeAdapterKind, a as RuntimeCapabilityProfile, f as cloneRuntimeCapabilities, r as runtimeCapabilitiesForBrowserHost, g as runtimeCapabilitiesFromNativeStatus, h as runtimeCapabilityProfile } from '../capabilities-YSskrE8H.js';
 export { RuntimeDeviceActiveOptions, isRuntimeDeviceActive, isRuntimeDeviceConnectable, isRuntimeDeviceRoutable } from './device-status.js';
-import { I as IpcRuntimeAdapter } from '../tauri-Cz9n17g8.js';
-export { a as IpcRuntimeAdapterOptions, T as TauriRuntimeAdapter, b as TauriRuntimeAdapterOptions, c as createTauriIpcBridge } from '../tauri-Cz9n17g8.js';
-import { a as WasmBridge } from '../DelegatingRuntimeAdapter-DqfHkjLy.js';
-import { P as PlutoIpcBridge } from '../ipc-CflAVodw.js';
-export { N as NativeIpcFailureKind, a as PlutoIpcUnlisten, c as classifyNativeIpcFailure, i as isNativeIpcCommandUnavailable } from '../ipc-CflAVodw.js';
-export { WasmRuntimeAdapter } from './WasmRuntimeAdapter.js';
+import { W as WasmBridgeOptions, D as DelegatingRuntimeAdapter } from '../DelegatingRuntimeAdapter-7Y3gss5D.js';
 import '../IEngineBridge-BbsT8hof.js';
 import '../ITransport-BsPcaov7.js';
 
@@ -63,17 +57,19 @@ declare class Signaling {
     setWasmClient(client: any): void;
 }
 
-/**
- * @deprecated Legacy assembly helper. Use `OpenRTC()` for app code.
- * Removal target: OpenRTC 0.2.0.
- */
-declare function createWasmClient(options: RuntimeFactoryOptions): Promise<PlutoRuntimeAssembly<WasmBridge>>;
-/**
- * @deprecated Legacy assembly helper. Native applications should use
- * `createNativeOpenRTC` from `openrtc/native`.
- * Removal target: OpenRTC 0.2.0.
- */
-declare function createIpcClient(options: RuntimeFactoryOptions, bridge: PlutoIpcBridge): PlutoRuntimeAssembly<IpcRuntimeAdapter>;
+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);
+}
 
 type OpenRTCCapabilityRuntime = OpenRTCClient;
 /**
@@ -383,7 +379,7 @@ declare class Client {
     buildCompoundTicketWithToken(irohTicket: string, grantScope: GrantScope, maxConnections?: number): string;
     setManagedPresenceTicket(ticket: string | null): void;
     clearManagedPresenceTicket(): void;
-    registerSessionToken(token: string, grantScope: GrantScope, maxConnections: number): void;
+    registerSessionToken(token: string, grantScope: GrantScope, maxConnections: number, expiresAtMs?: number): void;
     revokeSessionToken(token: string): void;
     revokeTokensByScope(grantScope: GrantScope): Promise<string[]>;
     clearSessionTokens(): Promise<void>;
@@ -540,52 +536,4 @@ declare function createRuntimeJsonFrameDecoder<T = unknown>(onValue: RuntimeJson
 declare function concatRuntimeBytes(a: ByteArrayLike, b: ByteArrayLike): ByteArray;
 declare function readRuntimeU32BE(bytes: ByteArrayLike, offset: number): number;
 
-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 { Connection, type CorrelationFields, type EnableSpaceAuthResponse, IpcRuntimeAdapter, type MintSpaceTokenRequest, type MintSpaceTokenResponse, PlutoIpcBridge as NativeBridge, type OpenRTCCapabilityRuntime, PlutoIpcBridge, PlutoRuntimeAssembly, RuntimeCapabilities, RuntimeConnectionController, RuntimeConnectionTarget, RuntimeFactoryOptions, type RuntimeJsonFrameDecoderOptions, type RuntimeJsonFrameHandler, RuntimeRawConnection, type RuntimeU32BEFrameHandler, clog, concatRuntimeBytes, correlationForDriveGrantScope, createIpcClient, createPublicSpaceTokenProvider, createRuntimeJsonFrameDecoder, createRuntimeU32BEFrameDecoder, createSpaceTokenProvider, createWasmClient, decodeRuntimeJsonPayload, enableSpaceAuth, encodeRuntimeJsonFrame, encodeRuntimeJsonPayload, encodeRuntimeU32BEFrame, logOpenRtcTeardownTrace, mintSpaceToken, openRtcDebug, openRtcDebugEnabled, openRtcDebugInfo, openRtcDebugLog, readRuntimeU32BE, renderCorrelationFields, runtimeForCapability as runtimeFromCapability, sandboxSpaceKey, spaceToken };
+export { Connection, type CorrelationFields, IpcRuntimeAdapter, type IpcRuntimeAdapterOptions, PlutoIpcBridge as NativeBridge, type OpenRTCCapabilityRuntime, PlutoIpcBridge, RuntimeCapabilities, RuntimeConnectionController, RuntimeConnectionTarget, type RuntimeJsonFrameDecoderOptions, type RuntimeJsonFrameHandler, RuntimeRawConnection, type RuntimeU32BEFrameHandler, clog, concatRuntimeBytes, correlationForDriveGrantScope, createRuntimeJsonFrameDecoder, createRuntimeU32BEFrameDecoder, decodeRuntimeJsonPayload, encodeRuntimeJsonFrame, encodeRuntimeJsonPayload, encodeRuntimeU32BEFrame, logOpenRtcTeardownTrace, openRtcDebug, openRtcDebugEnabled, openRtcDebugInfo, openRtcDebugLog, readRuntimeU32BE, renderCorrelationFields, runtimeForCapability as runtimeFromCapability };

package/dist/runtime/index.js

@@ -1,2 +1 @@
-export{a as WasmRuntimeAdapter}from'../chunk-GW7P3D54.js';export{b as TauriRuntimeAdapter,a as createTauriIpcBridge}from'../chunk-5LRLWIT5.js';export{b as runtimeFromCapability}from'../chunk-PODAMIL6.js';export{b as createIpcClient,a as createWasmClient}from'../chunk-YQWQDTQ3.js';export{b as Connection,t as RuntimeClient,c as RuntimeConnectionController,g as ScopedConnectionActorError,j as ScopedConnectionActorHandle,k as ScopedConnectionActorRegistry,f as clog,r as concatRuntimeBytes,e as correlationForDriveGrantScope,q as createRuntimeJsonFrameDecoder,m as createRuntimeU32BEFrameDecoder,o as decodeRuntimeJsonPayload,p as encodeRuntimeJsonFrame,n as encodeRuntimeJsonPayload,l as encodeRuntimeU32BEFrame,s as readRuntimeU32BE,d as renderCorrelationFields,h as scopedConnectionKey,i as scopedConnectionKeyToString}from'../chunk-3USHQ7QW.js';export{f as IpcRuntimeAdapter}from'../chunk-F2XGNLXL.js';import'../chunk-A3IAG6EL.js';import'../chunk-7Z6N46RB.js';export{q as BROWSER_WASM_RUNTIME_CAPABILITIES,r as NATIVE_IPC_RUNTIME_CAPABILITIES,o as OPENRTC_RUNTIME_POLICY,s as cloneRuntimeCapabilities,p as getRuntimePolicy,g as logOpenRtcTeardownTrace,t as runtimeCapabilitiesForBrowserHost,u as runtimeCapabilitiesFromNativeStatus,v as runtimeCapabilityProfile}from'../chunk-YBXGNKM7.js';export{b as openRtcDebug,a as openRtcDebugEnabled,c as openRtcDebugInfo,d as openRtcDebugLog}from'../chunk-VK6KX433.js';import'../chunk-NT5YHZQH.js';export{a as classifyNativeIpcFailure,b as isNativeIpcCommandUnavailable}from'../chunk-K37WVIZL.js';import'../chunk-BXFXPIXO.js';import {b}from'../chunk-N26S7V4N.js';import'../chunk-NB4H5TP3.js';import'../chunk-RD3JEGGF.js';import'../chunk-C7YN5MSV.js';export{a as isRuntimeDeviceActive,c as isRuntimeDeviceConnectable,b as isRuntimeDeviceRoutable}from'../chunk-CK6WQV7J.js';var j="https://api.openrtc.app";function c(e){if(typeof globalThis.crypto?.randomUUID!="function")throw new Error(`Secure request identity is unavailable for ${e}.`);return `${e}:${globalThis.crypto.randomUUID()}`}async function z(e,t,n){let o=e.replace(/\/$/,""),r=await fetch(`${o}/v1/spaces/${encodeURIComponent(n)}/scoped-auth`,{method:"POST",headers:{Authorization:`Bearer ${t}`,"Content-Type":"application/json","X-OpenRTC-Idempotency-Key":c("enable-space-auth")},body:"{}"}),a=await r.json().catch(()=>({}));if(!r.ok){let s=typeof a?.error=="string"?a.error:`enableSpaceAuth failed (${r.status})`;throw new Error(s)}return a}async function q(e,t,n){let o=await fetch(e,{method:"POST",headers:{Authorization:`Bearer ${t}`,"Content-Type":"application/json","X-OpenRTC-Idempotency-Key":c("mint-space-token")},body:JSON.stringify(n)}),r=await o.json().catch(()=>({}));if(!o.ok){let a=typeof r?.error=="string"?r.error:`mintSpaceToken failed (${o.status})`;throw new Error(a)}if(typeof r?.token!="string"||!r.token.trim())throw new Error("mintSpaceToken response missing token");return r}function d(e){let t=e.apiKey.trim(),n=(e.spaceKey??e.space??"").trim(),o=g(e.sandboxAppId),r=(e.endpointUrl??j).replace(/\/$/,""),a=e.memberIdStorageKey??`openrtc:space-member:${n}${o?`:sandbox:${o}`:""}`;return async()=>{if(!t||!n)throw new Error("spaceToken requires apiKey and space");let s=null;typeof sessionStorage<"u"?(s=sessionStorage.getItem(a),s||(s=globalThis.crypto?.randomUUID?.()??`member-${Date.now()}`,sessionStorage.setItem(a,s))):s=`member-${Date.now()}`;let m=await b().getAppCheckToken(),i=await fetch(`${r}/v1SpacePublicTokens`,{method:"POST",headers:{"Content-Type":"application/json","X-OpenRTC-Idempotency-Key":c("mint-public-space-token"),...m?{"X-Firebase-AppCheck":m}:{}},body:JSON.stringify({apiKey:t,spaceKey:n,memberId:s,...o?{sandboxAppId:o}:{}})}),{text:u,payload:p}=await B(i);if(!i.ok){let f=typeof p?.error=="string"?p.error:u.trim()?u.trim().slice(0,240):`public space token mint failed (${i.status})`;throw new Error(f)}let l=typeof p?.token=="string"?p.token.trim():"";if(!l)throw new Error("public space token response missing token");return {customToken:l}}}function M(e){if(!e.trim())return {};try{let t=JSON.parse(e);return t&&typeof t=="object"?t:{}}catch{return {}}}async function B(e){let t=e.text;if(typeof t=="function"){let o=await t.call(e).catch(()=>"");return {text:o,payload:M(o)}}let n=await e.json().catch(()=>({}));return {text:JSON.stringify(n),payload:n&&typeof n=="object"?n:{}}}function g(e){let t=e?.trim().toLowerCase()??"";if(!t)return "";if(!/^[a-z0-9][a-z0-9-]{0,47}$/.test(t))throw new Error("sandboxAppId must be 1-48 lowercase letters, numbers, or dashes.");return t}function J(e,t){let n=e.trim(),o=g(t);return o?`${n}::sandbox::${o}`:n}var L=d,H=d;
-export{d as createPublicSpaceTokenProvider,H as createSpaceTokenProvider,z as enableSpaceAuth,q as mintSpaceToken,J as sandboxSpaceKey,L as spaceToken};
+export{b as Connection,u as IpcRuntimeAdapter,t as RuntimeClient,c as RuntimeConnectionController,g as ScopedConnectionActorError,j as ScopedConnectionActorHandle,k as ScopedConnectionActorRegistry,f as clog,r as concatRuntimeBytes,e as correlationForDriveGrantScope,q as createRuntimeJsonFrameDecoder,m as createRuntimeU32BEFrameDecoder,o as decodeRuntimeJsonPayload,p as encodeRuntimeJsonFrame,n as encodeRuntimeJsonPayload,l as encodeRuntimeU32BEFrame,s as readRuntimeU32BE,d as renderCorrelationFields,h as scopedConnectionKey,i as scopedConnectionKeyToString}from'../chunk-KEPDY3LB.js';export{a as classifyNativeIpcFailure,b as isNativeIpcCommandUnavailable}from'../chunk-Z2WVSXPW.js';export{b as runtimeFromCapability}from'../chunk-NW25RLPN.js';export{a as isRuntimeDeviceActive,c as isRuntimeDeviceConnectable,b as isRuntimeDeviceRoutable}from'../chunk-CK6WQV7J.js';import'../chunk-NCMT4MKM.js';export{s as BROWSER_WASM_RUNTIME_CAPABILITIES,t as NATIVE_IPC_RUNTIME_CAPABILITIES,q as OPENRTC_RUNTIME_POLICY,u as cloneRuntimeCapabilities,r as getRuntimePolicy,i as logOpenRtcTeardownTrace,v as runtimeCapabilitiesForBrowserHost,w as runtimeCapabilitiesFromNativeStatus,x as runtimeCapabilityProfile}from'../chunk-FQH6O3SU.js';import'../chunk-NT5YHZQH.js';import'../chunk-RRMBD5OL.js';export{b as openRtcDebug,a as openRtcDebugEnabled,c as openRtcDebugInfo,d as openRtcDebugLog}from'../chunk-PQK5SJ47.js';import'../chunk-QHSM5NFZ.js';import'../chunk-C7YN5MSV.js';

package/dist/testing.d.ts

@@ -1,11 +1,9 @@
-import { d as OpenRTCClient } from './OpenRTCShared-ZQPu5LqL.js';
-import { P as PlutoIpcBridge } from './ipc-CflAVodw.js';
-import { a as RuntimeClientOptions } from './types-DkgaCyqS.js';
-import { O as OpenRTCOptions, a as OpenRTCClient$1 } from './types-DNl4KHHY.js';
-import './types-BVJr065k.js';
+import { O as OpenRTCOptions, P as PlutoIpcBridge, a as OpenRTCClient } from './types-DE4iPkMB.js';
+import './types-BwmoJU2O.js';
 import './IEngineBridge-BbsT8hof.js';
-import './capabilities-YSskrE8H.js';
+import './types-oGGnaSW2.js';
 import './ITransport-BsPcaov7.js';
+import './capabilities-YSskrE8H.js';
 
 interface OpenRTCV2Endpoints {
     controlPlane: string;
@@ -15,16 +13,8 @@ interface OpenRTCV2Endpoints {
 declare function createTestingOpenRTC(options: OpenRTCOptions, endpoints: OpenRTCV2Endpoints, testing?: {
     deviceId?: string;
     irohTestRelayUrl?: string;
-}): OpenRTCClient$1;
+}): OpenRTCClient;
 /** Native equivalent for emulator and harness lanes; never import in product code. */
-declare function createTestingNativeOpenRTC(options: OpenRTCOptions, endpoints: OpenRTCV2Endpoints, bridge: PlutoIpcBridge): OpenRTCClient$1;
-/**
- * Rollback-harness constructor. This is intentionally confined to the
- * `openrtc/testing` export because it enables plaintext loopback coordination
- * for local emulators and also carries the time-bounded v1 runtime.
- */
-declare const createTestingLegacyOpenRTC: ((options: RuntimeClientOptions) => Promise<OpenRTCClient>) & {
-    native: (options: RuntimeClientOptions, bridge?: PlutoIpcBridge) => OpenRTCClient;
-};
+declare function createTestingNativeOpenRTC(options: OpenRTCOptions, endpoints: OpenRTCV2Endpoints, bridge: PlutoIpcBridge): OpenRTCClient;
 
-export { createTestingLegacyOpenRTC, createTestingNativeOpenRTC, createTestingOpenRTC };
+export { createTestingNativeOpenRTC, createTestingOpenRTC };

package/dist/testing.js

@@ -1 +1 @@
-import {a as a$1}from'./chunk-UEYM6WTT.js';import {c}from'./chunk-PODAMIL6.js';import {a}from'./chunk-IEQTFQ3Q.js';import'./chunk-2QHDEGVX.js';import'./chunk-6TAVJ46R.js';import'./chunk-N4SX7C3W.js';import'./chunk-YQWQDTQ3.js';import'./chunk-3USHQ7QW.js';import'./chunk-F2XGNLXL.js';import'./chunk-A3IAG6EL.js';import'./chunk-7Z6N46RB.js';import'./chunk-YBXGNKM7.js';import'./chunk-VK6KX433.js';import'./chunk-NT5YHZQH.js';import'./chunk-K37WVIZL.js';import'./chunk-BXFXPIXO.js';import'./chunk-N26S7V4N.js';import'./chunk-NB4H5TP3.js';import'./chunk-RD3JEGGF.js';import'./chunk-C7YN5MSV.js';function m(e,t,n={}){return c(e,{endpoints:t,testingAllowInsecureLoopback:true,platform:"web",...n.deviceId?{deviceIdProvider:async()=>n.deviceId}:{},...n.irohTestRelayUrl?{irohTestRelayUrl:n.irohTestRelayUrl}:{},runtimeFactory:async i=>{let{createWasmClient:o}=await import('./factories-SIVMTIHJ.js');return o(i)}})}function d(e,t,n){return c(e,{endpoints:t,testingAllowInsecureLoopback:true,platform:"native",deviceKeyProvider:a$1(n),deviceIdProvider:async()=>{let i=await n.invoke("get_rtc_local_device_info");return String(i?.deviceId??"")},runtimeFactory:async i=>{let{createIpcClient:o}=await import('./ipcFactory-QY44OIKA.js');return o(i,n)}})}function p(e){let t=e.coordinationGateway;return {...e,...t?{coordinationGateway:{...t,testingAllowInsecureLoopback:true}}:{}}}var C=Object.assign(e=>a(p(e)),{native:(e,t)=>a.native(p(e),t)});export{C as createTestingLegacyOpenRTC,d as createTestingNativeOpenRTC,m as createTestingOpenRTC};
+import {a}from'./chunk-R2QM2IDY.js';import {c}from'./chunk-NW25RLPN.js';function l(r,n,e={}){return c(r,{endpoints:n,testingAllowInsecureLoopback:true,platform:"web",...e.deviceId?{deviceIdProvider:async()=>e.deviceId}:{},...e.irohTestRelayUrl?{irohTestRelayUrl:e.irohTestRelayUrl}:{},runtimeFactory:async t=>{let{createWasmClient:i}=await import('./factories-NLQVWWJE.js');return i(t)}})}function s(r,n,e){return c(r,{endpoints:n,testingAllowInsecureLoopback:true,platform:"native",deviceKeyProvider:a(e),deviceIdProvider:async()=>{let t=await e.invoke("get_rtc_local_device_info");return String(t?.deviceId??"")},runtimeFactory:async t=>{let{createIpcClient:i}=await import('./ipcFactory-SMUMTEMH.js');return i(t,e)}})}export{s as createTestingNativeOpenRTC,l as createTestingOpenRTC};

package/dist/transport/index.d.ts

@@ -1,5 +1,5 @@
-import { P as ProtocolName, K as RouteDescriptor, O as ProtocolCapability, Q as ProtocolCapabilityMap, A as ApplicationPayloadCrypto, U as ApplicationCryptoStreamTools } from '../types-BVJr065k.js';
-export { V as ApplicationCryptoBiStream, W as RouteFamily, X as RouteImplementationKind } from '../types-BVJr065k.js';
+import { r as ProtocolName, H as RouteDescriptor, K as ProtocolCapability, O as ProtocolCapabilityMap, o as ApplicationPayloadCrypto, Q as ApplicationCryptoStreamTools } from '../types-BwmoJU2O.js';
+export { U as ApplicationCryptoBiStream, V as RouteFamily, W as RouteImplementationKind } from '../types-BwmoJU2O.js';
 import { I as ITransport } from '../ITransport-BsPcaov7.js';
 
 declare const TRANSPORT_LABELS: readonly ProtocolName[];

package/dist/transport/index.js

@@ -1 +1 @@
-export{e as KEY_AGREEMENT_ALGORITHM,d as KEY_AGREEMENT_PUBLIC_KEY_BYTES,g as deriveApplicationCryptoKey,i as encodeApplicationKeyAgreementPayload,f as generateEphemeralKeyAgreement,c as getPreferredProtocolOrder}from'../chunk-7Z6N46RB.js';export{e as TRANSPORT_LABELS,o as createApplicationCryptoStreamTools,n as createSharedSecretApplicationCrypto,m as isApplicationEncryptedPayload,h as isDirectIrohTransportLabel,l as isIndependentTransportLabel,g as isIrohBaseTransportLabel,i as isOptionalTransportLabel,j as isWebRtcTransportLabel,f as normalizeTransportLabel}from'../chunk-VK6KX433.js';import'../chunk-NB4H5TP3.js';export{a as ROUTE_DESCRIPTORS,e as getRouteDescriptor,f as listRouteDescriptors}from'../chunk-C7YN5MSV.js';
+export{e as KEY_AGREEMENT_ALGORITHM,d as KEY_AGREEMENT_PUBLIC_KEY_BYTES,g as deriveApplicationCryptoKey,i as encodeApplicationKeyAgreementPayload,f as generateEphemeralKeyAgreement,c as getPreferredProtocolOrder}from'../chunk-RRMBD5OL.js';export{o as TRANSPORT_LABELS,y as createApplicationCryptoStreamTools,x as createSharedSecretApplicationCrypto,w as isApplicationEncryptedPayload,r as isDirectIrohTransportLabel,v as isIndependentTransportLabel,q as isIrohBaseTransportLabel,s as isOptionalTransportLabel,t as isWebRtcTransportLabel,p as normalizeTransportLabel}from'../chunk-PQK5SJ47.js';export{a as ROUTE_DESCRIPTORS,e as getRouteDescriptor,f as listRouteDescriptors}from'../chunk-C7YN5MSV.js';

package/dist/{types-BVJr065k.d.ts → types-BwmoJU2O.d.ts}

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

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 };