openrtc 1.0.27 → 2.0.0-rc.1

package/dist/runtime/index.d.ts

@@ -1,20 +1,21 @@
-import { e as RuntimeFactoryOptions, b as PlutoRuntimeAssembly, P as PeerReconciliationStats } from '../assembly-CscFVHYK.js';
-export { O as OPENRTC_RUNTIME_POLICY, R as RuntimeClient, a as RuntimePolicySnapshot, D as ScopedConnectionActorError, f as ScopedConnectionActorErrorKind, h as ScopedConnectionActorHandle, i as ScopedConnectionActorHandleOptions, j as ScopedConnectionActorRegistry, k as ScopedConnectionActorState, l as ScopedConnectionClose, m as ScopedConnectionDial, n as ScopedConnectionKey, o as ScopedLogicalChannelHandle, p as ScopedPreferredTransport, g as getRuntimePolicy, q as scopedConnectionKey, r as scopedConnectionKeyToString } from '../assembly-CscFVHYK.js';
+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 * as Draft14 from '@moq/net';
-import { a4 as SignalingOptions, I as ISignalingBackend, f as RuntimeIdentity, g as RoomMember, j as SignalingEnvelope, m as SignalingSession, h as Device, l as DesiredPeerProjection, r as BackendConnectionState, Y as AppLimits, G as GrantScope, K as JoinRoomOptions, z as IncomingStreamChannelMetadata, X as ApplicationCryptoStreamTools, a5 as RoomCreationMode, e as ClientOptions, t as ApplicationPayloadCrypto, D as DiscoveryMode, W as ProtocolCapabilityMap, a6 as ScanningLoopOptions, a7 as ScanningLoopHandle, a8 as RuntimeBootstrapOptions, a9 as RuntimeBootstrapResult, u as ApplicationPayloadReadinessOptions, aa as ManagedApplicationRouteOptions, H as PeerState, O as PeerScope, J as PeerHealth, y as ChannelDescriptor, ab as JoinRequest, p as NativeConnectParams, q as NativeConnectResult } from '../types-zT2QwuCv.js';
-import { C as Connection, K as RuntimeConnectionTarget, v as RuntimeRawConnection } from '../types-BJU2GoVb.js';
-export { w as ChannelDescriptor, x as ConnectionEvent, y as ConnectionTarget, D as DeviceProfile, z as IncomingStream, P as PeerConnectOptions, A as PeerReadiness, B as PeerStreamOptions, E as PresenceLoopOptions, F as RawConnection, t as RuntimeApplicationPayloadReadinessOptions, G as RuntimeAuthContext, H as RuntimeAuthIdentity, J as RuntimeAutoConnectPolicy, l as RuntimeChannelDescriptor, R as RuntimeClientOptions, u as RuntimeConnectionEvent, s as RuntimeConnectionStateSnapshot, c as RuntimeDevice, e as RuntimeDeviceConnectOptions, L as RuntimeDevicePresenceStatus, M as RuntimeDeviceStatus, d as RuntimeDeviceStatusSnapshot, n as RuntimeIncomingStream, q as RuntimeJoinRoomOptions, f as RuntimeLocalDeviceInfo, g as RuntimeLocalDeviceProfile, N as RuntimeLogicalChannelFraming, b as RuntimeManagedSession, O as RuntimeManagedSessionKind, a as RuntimeManagedSessionOptions, Q as RuntimeManagedSessionPlatform, i as RuntimePeerConnectOptions, k as RuntimePeerHealth, S as RuntimePeerLifecycleStatus, j as RuntimePeerReadinessSnapshot, T as RuntimePeerScope, U as RuntimePeerSessionSnapshot, h as RuntimePeerState, m as RuntimePeerStreamOptions, V as RuntimePresenceLoopOptions, W as RuntimePresencePolicy, r as RuntimeRoomMember, o as RuntimeScopedChannelOptions, p as RuntimeScopedLogicalChannel, X as RuntimeSession, Y as RuntimeUiConnectionStatus, Z as ScopedChannelOptions, _ as ScopedLogicalChannel, $ as Session, a0 as SessionOptions } from '../types-BJU2GoVb.js';
-import { R as RuntimeCapabilities } from '../capabilities-CaqXOIUU.js';
-export { B as BROWSER_WASM_RUNTIME_CAPABILITIES, c as BrowserRuntimeCapabilityHost, N as NATIVE_IPC_RUNTIME_CAPABILITIES, d as NativeRuntimeStatusSnapshot, e as NativeRuntimeTransportFeatureStatus, b as RuntimeAdapterKind, a as RuntimeCapabilityProfile, f as cloneRuntimeCapabilities, r as runtimeCapabilitiesForBrowserHost, g as runtimeCapabilitiesFromNativeStatus, h as runtimeCapabilityProfile } from '../capabilities-CaqXOIUU.js';
+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 { 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';
-export { h as RuntimeJsonFrameDecoderOptions, R as RuntimeJsonFrameHandler, a as RuntimeU32BEFrameHandler, i as concatRuntimeBytes, c as createRuntimeJsonFrameDecoder, b as createRuntimeU32BEFrameDecoder, d as decodeRuntimeJsonPayload, e as encodeRuntimeJsonFrame, f as encodeRuntimeJsonPayload, g as encodeRuntimeU32BEFrame, r as readRuntimeU32BE } from '../framing-zRvEKOld.js';
-import { I as IpcRuntimeAdapter } from '../tauri-BpsecNrp.js';
-export { a as IpcRuntimeAdapterOptions, T as TauriRuntimeAdapter, b as TauriRuntimeAdapterOptions, c as createTauriIpcBridge } from '../tauri-BpsecNrp.js';
-import { WasmRuntimeAdapter } from './WasmRuntimeAdapter.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 '../IEngineBridge-BbsT8hof.js';
-import '../DelegatingRuntimeAdapter-Cg3jFk1b.js';
+import '../ITransport-BsPcaov7.js';
 
 declare class Signaling {
     private readonly appTag;
@@ -66,7 +67,7 @@ declare class Signaling {
  * @deprecated Legacy assembly helper. Use `OpenRTC()` for app code.
  * Removal target: OpenRTC 0.2.0.
  */
-declare function createWasmClient(options: RuntimeFactoryOptions): PlutoRuntimeAssembly<WasmRuntimeAdapter>;
+declare function createWasmClient(options: RuntimeFactoryOptions): Promise<PlutoRuntimeAssembly<WasmBridge>>;
 /**
  * @deprecated Legacy assembly helper. Native applications should use
  * `createNativeOpenRTC` from `openrtc/native`.
@@ -74,6 +75,14 @@ declare function createWasmClient(options: RuntimeFactoryOptions): PlutoRuntimeA
  */
 declare function createIpcClient(options: RuntimeFactoryOptions, bridge: PlutoIpcBridge): PlutoRuntimeAssembly<IpcRuntimeAdapter>;
 
+type OpenRTCCapabilityRuntime = OpenRTCClient;
+/**
+ * Low-level escape hatch used only by `openrtc/runtime`. Product code should
+ * prefer the capability namespaces. Keeping this registry here prevents a
+ * runtime pointer from leaking onto the provider-neutral root surface.
+ */
+declare function runtimeForCapability(handle: OpenRTCCapabilityHandle): OpenRTCCapabilityRuntime;
+
 interface MoQSubscriberOptions {
     maxPendingSubscriptions?: number;
     maxSubscribeRetries?: number;
@@ -217,7 +226,7 @@ declare class RoomManager {
     private requireCoordinationGateway;
     private get roomBackendTag();
     private resolveRoomUserId;
-    private get appTag();
+    private resolveControlPlaneAppTag;
     private invokeRoomCallable;
     private isAlreadyExistsError;
     private normalizeRoomId;
@@ -503,4 +512,80 @@ declare function openRtcDebug(message: string, data?: unknown): void;
 declare function openRtcDebugInfo(message: string, data?: unknown): void;
 declare function openRtcDebugLog(message: string, data?: unknown): void;
 
-export { type CorrelationFields, IpcRuntimeAdapter, PlutoIpcBridge as NativeBridge, PlutoIpcBridge, PlutoRuntimeAssembly, RuntimeCapabilities, RuntimeConnectionController, RuntimeConnectionTarget, RuntimeFactoryOptions, RuntimeRawConnection, WasmRuntimeAdapter, clog, correlationForDriveGrantScope, createIpcClient, createWasmClient, logOpenRtcTeardownTrace, openRtcDebug, openRtcDebugEnabled, openRtcDebugInfo, openRtcDebugLog, renderCorrelationFields };
+/**
+ * Pure byte / stream / timing helpers.
+ *
+ * Extracted from the `Client` god object (see
+ * `docs/plans/client-ts-decomposition.md` Phase 1). These functions are
+ * deliberately pure — no `Client` state, no `this`, no logging side effects — so
+ * the same helper is reused everywhere instead of being re-implemented inline
+ * (e.g. `concatBytes` previously existed both here and in `applicationCrypto.ts`,
+ * and three near-identical exponential-backoff helpers existed across the class).
+ */
+
+type ByteArray = Uint8Array<ArrayBuffer>;
+type ByteArrayLike = Uint8Array<ArrayBufferLike>;
+
+type RuntimeU32BEFrameHandler = (payload: ByteArray) => void;
+type RuntimeJsonFrameHandler<T = unknown> = (value: T, payload: ByteArray) => void;
+interface RuntimeJsonFrameDecoderOptions {
+    onInvalidJson?: (error: unknown, payload: ByteArray) => void;
+}
+declare function encodeRuntimeU32BEFrame(payload: ByteArrayLike): ByteArray;
+declare function createRuntimeU32BEFrameDecoder(onFrame: RuntimeU32BEFrameHandler): (chunk: ByteArrayLike) => void;
+declare function encodeRuntimeJsonPayload(value: unknown): ByteArray;
+declare function decodeRuntimeJsonPayload<T = unknown>(payload: ByteArrayLike): T;
+declare function encodeRuntimeJsonFrame(value: unknown): ByteArray;
+declare function createRuntimeJsonFrameDecoder<T = unknown>(onValue: RuntimeJsonFrameHandler<T>, options?: RuntimeJsonFrameDecoderOptions): (chunk: ByteArrayLike) => void;
+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 };

package/dist/runtime/index.js

@@ -1 +1,2 @@
-export{b as createIpcClient,a as createWasmClient}from'../chunk-H5VWKP4Q.js';export{z as RuntimeClient,i as RuntimeConnectionController,m as ScopedConnectionActorError,p as ScopedConnectionActorHandle,q as ScopedConnectionActorRegistry,l as clog,x as concatRuntimeBytes,k as correlationForDriveGrantScope,w as createRuntimeJsonFrameDecoder,s as createRuntimeU32BEFrameDecoder,u as decodeRuntimeJsonPayload,v as encodeRuntimeJsonFrame,t as encodeRuntimeJsonPayload,r as encodeRuntimeU32BEFrame,y as readRuntimeU32BE,j as renderCorrelationFields,n as scopedConnectionKey,o as scopedConnectionKeyToString}from'../chunk-HYHVKPQN.js';export{a as isRuntimeDeviceActive,c as isRuntimeDeviceConnectable,b as isRuntimeDeviceRoutable}from'../chunk-CK6WQV7J.js';export{a as WasmRuntimeAdapter}from'../chunk-OMDHDMDJ.js';export{b as TauriRuntimeAdapter,a as createTauriIpcBridge}from'../chunk-EVJYUIBK.js';export{h as IpcRuntimeAdapter,e as classifyNativeIpcFailure,f as isNativeIpcCommandUnavailable}from'../chunk-4IK5EKHY.js';export{C as BROWSER_WASM_RUNTIME_CAPABILITIES,D as NATIVE_IPC_RUNTIME_CAPABILITIES,A as OPENRTC_RUNTIME_POLICY,E as cloneRuntimeCapabilities,B as getRuntimePolicy,n as logOpenRtcTeardownTrace,b as openRtcDebug,a as openRtcDebugEnabled,c as openRtcDebugInfo,d as openRtcDebugLog,F as runtimeCapabilitiesForBrowserHost,G as runtimeCapabilitiesFromNativeStatus,H as runtimeCapabilityProfile}from'../chunk-LAUABWCB.js';import'../chunk-QT2ASNI3.js';import'../chunk-OCSZA6PK.js';import'../chunk-C7YN5MSV.js';
+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};

package/dist/runtime/legacy.d.ts

@@ -0,0 +1,18 @@
+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 '../types-BVJr065k.js';
+import '../IEngineBridge-BbsT8hof.js';
+import '../capabilities-YSskrE8H.js';
+import '../ITransport-BsPcaov7.js';
+
+/**
+ * Rollback-only constructor for the internal diagnostic sandbox. Shipping 2.0
+ * applications must use the root capability API.
+ */
+declare function createLegacyOpenRTC(options: RuntimeClientOptions): Promise<OpenRTCClient>;
+declare namespace createLegacyOpenRTC {
+    var native: (options: RuntimeClientOptions, bridge?: PlutoIpcBridge) => OpenRTCClient;
+}
+
+export { createLegacyOpenRTC };

package/dist/runtime/legacy.js

@@ -0,0 +1 @@
+export{a as createLegacyOpenRTC}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';

package/dist/runtime/tauri.d.ts

@@ -1,6 +1,6 @@
-export { T as TauriRuntimeAdapter, b as TauriRuntimeAdapterOptions, c as createTauriIpcBridge } from '../tauri-BpsecNrp.js';
+export { T as TauriRuntimeAdapter, b as TauriRuntimeAdapterOptions, c as createTauriIpcBridge } from '../tauri-Cz9n17g8.js';
 import '../ipc-CflAVodw.js';
-import '../types-zT2QwuCv.js';
-import '../DelegatingRuntimeAdapter-Cg3jFk1b.js';
+import '../types-BVJr065k.js';
+import '../DelegatingRuntimeAdapter-DqfHkjLy.js';
+import '../capabilities-YSskrE8H.js';
 import '../IEngineBridge-BbsT8hof.js';
-import '../capabilities-CaqXOIUU.js';

package/dist/runtime/tauri.js

@@ -1 +1 @@
-export{b as TauriRuntimeAdapter,a as createTauriIpcBridge}from'../chunk-EVJYUIBK.js';import'../chunk-4IK5EKHY.js';import'../chunk-LAUABWCB.js';import'../chunk-QT2ASNI3.js';import'../chunk-OCSZA6PK.js';import'../chunk-C7YN5MSV.js';
+export{b as TauriRuntimeAdapter,a as createTauriIpcBridge}from'../chunk-5LRLWIT5.js';import'../chunk-F2XGNLXL.js';import'../chunk-A3IAG6EL.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';

package/dist/{tauri-BpsecNrp.d.ts → tauri-Cz9n17g8.d.ts}

@@ -1,5 +1,5 @@
-import { e as ClientOptions } from './types-zT2QwuCv.js';
-import { W as WasmBridgeOptions, D as DelegatingRuntimeAdapter } from './DelegatingRuntimeAdapter-Cg3jFk1b.js';
+import { i as ClientOptions } from './types-BVJr065k.js';
+import { W as WasmBridgeOptions, D as DelegatingRuntimeAdapter } from './DelegatingRuntimeAdapter-DqfHkjLy.js';
 import { P as PlutoIpcBridge } from './ipc-CflAVodw.js';
 
 interface NativeIpcBridgeOptions extends WasmBridgeOptions {

package/dist/testing.d.ts

@@ -0,0 +1,30 @@
+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 './IEngineBridge-BbsT8hof.js';
+import './capabilities-YSskrE8H.js';
+import './ITransport-BsPcaov7.js';
+
+interface OpenRTCV2Endpoints {
+    controlPlane: string;
+    gateway: string;
+}
+
+declare function createTestingOpenRTC(options: OpenRTCOptions, endpoints: OpenRTCV2Endpoints, testing?: {
+    deviceId?: string;
+    irohTestRelayUrl?: string;
+}): OpenRTCClient$1;
+/** 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;
+};
+
+export { createTestingLegacyOpenRTC, createTestingNativeOpenRTC, createTestingOpenRTC };

package/dist/testing.js

@@ -0,0 +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};

package/dist/transport/index.d.ts

@@ -1,9 +1,6 @@
-import { a1 as RouteDescriptor, w as ProtocolName } from '../types-zT2QwuCv.js';
-export { a2 as RouteFamily, a3 as RouteImplementationKind } from '../types-zT2QwuCv.js';
-
-declare const ROUTE_DESCRIPTORS: readonly RouteDescriptor[];
-declare function getRouteDescriptor(id: ProtocolName): RouteDescriptor;
-declare function listRouteDescriptors(): readonly RouteDescriptor[];
+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 { I as ITransport } from '../ITransport-BsPcaov7.js';
 
 declare const TRANSPORT_LABELS: readonly ProtocolName[];
 declare function normalizeTransportLabel(value: unknown): ProtocolName | undefined;
@@ -13,4 +10,47 @@ declare function isOptionalTransportLabel(value: unknown): boolean;
 declare function isWebRtcTransportLabel(value: unknown): boolean;
 declare function isIndependentTransportLabel(value: unknown): boolean;
 
-export { ProtocolName, ROUTE_DESCRIPTORS, RouteDescriptor, TRANSPORT_LABELS, getRouteDescriptor, isDirectIrohTransportLabel, isIndependentTransportLabel, isIrohBaseTransportLabel, isOptionalTransportLabel, isWebRtcTransportLabel, listRouteDescriptors, normalizeTransportLabel };
+declare const ROUTE_DESCRIPTORS: readonly RouteDescriptor[];
+declare function getRouteDescriptor(id: ProtocolName): RouteDescriptor;
+declare function listRouteDescriptors(): readonly RouteDescriptor[];
+
+declare class TransportFactory {
+    private static readonly capabilityMap;
+    /** @deprecated Only WebRTC implements the legacy ITransport construction API. */
+    static createTransport(name: ProtocolName): ITransport;
+    static getProtocolCapability(name: ProtocolName): ProtocolCapability;
+    static getProtocolCapabilities(): ProtocolCapabilityMap;
+    static getPreferredProtocolOrder(options?: {
+        runtime?: 'browser' | 'native' | 'any';
+        includePathLabels?: boolean;
+    }): ProtocolName[];
+    static assertProtocolAvailable(name: ProtocolName): void;
+}
+declare function getPreferredProtocolOrder(options?: Parameters<typeof TransportFactory.getPreferredProtocolOrder>[0]): ProtocolName[];
+
+declare function isApplicationEncryptedPayload(payload: Uint8Array): boolean;
+declare function createSharedSecretApplicationCrypto(key: Uint8Array, options?: {
+    requireEncrypted?: boolean;
+    randomBytes?: (byteLength: number) => Uint8Array;
+    replayProtection?: boolean;
+}): ApplicationPayloadCrypto;
+declare function createApplicationCryptoStreamTools(crypto: ApplicationPayloadCrypto, options?: {
+    typeId?: number;
+    maxFrameBytes?: number;
+}): ApplicationCryptoStreamTools;
+
+declare const KEY_AGREEMENT_PUBLIC_KEY_BYTES = 32;
+declare const KEY_AGREEMENT_ALGORITHM = "openrtc:x25519-hkdf:v1";
+interface ApplicationKeyAgreementPayload {
+    algorithm: typeof KEY_AGREEMENT_ALGORITHM;
+    publicKey: string;
+}
+interface EphemeralKeyAgreement {
+    publicKey: Uint8Array;
+    secretKey: Uint8Array;
+}
+declare function generateEphemeralKeyAgreement(randomBytes?: (byteLength: number) => Uint8Array): EphemeralKeyAgreement;
+declare function deriveApplicationCryptoKey(localSecretKey: Uint8Array, remotePublicKey: Uint8Array, localNodeId: string, remoteNodeId: string): Uint8Array;
+declare function encodeApplicationKeyAgreementPayload(publicKey: Uint8Array): ApplicationKeyAgreementPayload;
+
+export { ApplicationCryptoStreamTools, type ApplicationKeyAgreementPayload, ApplicationPayloadCrypto, KEY_AGREEMENT_ALGORITHM, KEY_AGREEMENT_PUBLIC_KEY_BYTES, ProtocolName, ROUTE_DESCRIPTORS, RouteDescriptor, TRANSPORT_LABELS, createApplicationCryptoStreamTools, createSharedSecretApplicationCrypto, deriveApplicationCryptoKey, encodeApplicationKeyAgreementPayload, generateEphemeralKeyAgreement, getPreferredProtocolOrder, getRouteDescriptor, isApplicationEncryptedPayload, isDirectIrohTransportLabel, isIndependentTransportLabel, isIrohBaseTransportLabel, isOptionalTransportLabel, isWebRtcTransportLabel, listRouteDescriptors, normalizeTransportLabel };

package/dist/transport/index.js

@@ -1 +1 @@
-export{a as TRANSPORT_LABELS,d as isDirectIrohTransportLabel,h as isIndependentTransportLabel,c as isIrohBaseTransportLabel,e as isOptionalTransportLabel,f as isWebRtcTransportLabel,b as normalizeTransportLabel}from'../chunk-QT2ASNI3.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-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';

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

@@ -17,6 +17,14 @@ interface CoordinationGatewayOptions {
      * verify the matching identity tenant and token audience.
      */
     environment: 'staging' | 'production';
+    /**
+     * Test-runtime authority for an insecure loopback gateway. The public v2
+     * constructor never sets this flag; `openrtc/testing` owns it for local
+     * emulator harnesses. Non-loopback HTTP/WS endpoints still fail closed.
+     *
+     * @internal
+     */
+    testingAllowInsecureLoopback?: boolean;
     /**
      * Opaque native trust token loader.
      *
@@ -29,6 +37,33 @@ interface CoordinationGatewayOptions {
         token: string;
         expiresAtMs: number;
     } | null | undefined>;
+    /**
+     * OpenRTC 2.0's provider-neutral grant source. This is installed by the
+     * public capability client, never supplied as a public endpoint or token
+     * hook by application code.
+     *
+     * @internal
+     */
+    grantProvider?: (input: CoordinationGatewayGrantRequest) => Promise<CoordinationGatewayGrant>;
+}
+interface CoordinationGatewayGrantRequest {
+    avenue: {
+        kind: 'user' | 'space' | 'room' | 'session';
+        id: string;
+    };
+    deviceId: string;
+    runtimeInstanceId: string;
+    ticketFingerprint: string;
+    purpose: 'presence' | 'device-control';
+    refreshGrant?: string;
+}
+interface CoordinationGatewayGrant {
+    protocolVersion: 1 | 2;
+    gatewayUrl: string;
+    routeKey: string;
+    token: string;
+    expiresAtMs: number;
+    avenue: CoordinationGatewayGrantRequest['avenue'];
 }
 
 interface AppLimits {
@@ -131,6 +166,8 @@ interface ChannelDescriptor {
     readiness: ChannelReadinessMode;
     promotionPolicy?: ChannelPromotionPolicy;
     signalingPolicy?: ChannelSignalingPolicy;
+    /** Drop queued superseded payloads while retaining reliable delivery for the newest state. */
+    delivery?: 'reliable' | 'latest-state';
     description?: string;
 }
 type ProtocolName = 'iroh' | 'iroh-quic' | 'iroh-relay' | 'iroh-lan' | 'ble' | 'webrtc' | 'webrtc-lan' | 'webrtc-turn' | 'moq';
@@ -182,8 +219,6 @@ interface ProtocolCapability {
     reason?: string;
 }
 type ProtocolCapabilityMap = Record<ProtocolName, ProtocolCapability>;
-/** Space discovery always uses namespace-scoped Firebase tokens. */
-type SpaceAuthMode = 'scoped-token';
 type SpaceTokenProvider = () => Promise<{
     customToken: string;
     uid?: string;
@@ -242,6 +277,11 @@ interface ClientOptions {
      * Hosted production clients receive the managed production default.
      */
     coordinationGateway?: CoordinationGatewayOptions;
+    /** @internal One capability maps to exactly one gateway avenue. */
+    coordinationAvenueOverride?: {
+        kind: 'user' | 'space' | 'room' | 'session';
+        id: string;
+    };
     /**
      * Supplies the provider-neutral platform-attestation token used by the
      * configured coordination control plane.
@@ -1040,4 +1080,4 @@ interface JoinRequest {
     state: 'pending' | 'accepted' | 'rejected';
 }
 
-export type { ProtocolImplementationKind as $, AuthMode as A, BackendPeerBiStream as B, ConnectDeviceResult as C, DiscoveryMode as D, ExplicitFileDataSendParams as E, ManagedDeviceConnectOptions as F, GrantScope as G, PeerState as H, ISignalingBackend as I, PeerHealth as J, JoinRoomOptions as K, LocalDeviceInfo as L, ManagedConnectionRecord as M, NativeManagedSessionStartResult as N, PeerScope as O, PeerSessionSnapshot as P, DevicePresenceStatus as Q, ResolvedPeerIdentity as R, SpaceAuthMode as S, TransportLatencySnapshot as T, PeerLifecycleStatus as U, ProtocolCapability as V, ProtocolCapabilityMap as W, ApplicationCryptoStreamTools as X, AppLimits as Y, ApplicationCryptoBiStream as Z, ProtocolBaseName as _, SpaceTokenProvider as a, ProtocolLocality as a0, RouteDescriptor as a1, RouteFamily as a2, RouteImplementationKind as a3, SignalingOptions as a4, RoomCreationMode as a5, ScanningLoopOptions as a6, ScanningLoopHandle as a7, RuntimeBootstrapOptions as a8, RuntimeBootstrapResult as a9, ManagedApplicationRouteOptions as aa, JoinRequest as ab, ConnectDeviceHooks as b, ConnectDeviceOptions as c, SignalingMode as d, ClientOptions as e, RuntimeIdentity as f, RoomMember as g, Device as h, DeviceStatusSnapshot as i, SignalingEnvelope as j, DeviceEvent as k, DesiredPeerProjection as l, SignalingSession as m, SessionEvent as n, BackendPeerUniStream as o, NativeConnectParams as p, NativeConnectResult as q, BackendConnectionState as r, ConnectionOptions as s, ApplicationPayloadCrypto as t, ApplicationPayloadReadinessOptions as u, ApplicationPayloadRouteOptions as v, ProtocolName as w, ApplicationPayloadSendOptions as x, ChannelDescriptor as y, IncomingStreamChannelMetadata as z };
+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 };

package/dist/types-DNl4KHHY.d.ts

@@ -0,0 +1,195 @@
+import { O as OpenRTCPeerNamespace, a as OpenRTCChannelNamespace, b as OpenRTCDiagnosticsNamespace, c as OpenRTCDeviceNamespace } from './OpenRTCShared-ZQPu5LqL.js';
+import { R as RuntimeChannelDescriptor } from './types-DkgaCyqS.js';
+
+interface OpenRTCAuthProvider {
+    /** Registered provider ID from the developer app capability manifest. */
+    readonly providerId?: string;
+    getAssertion(input: {
+        audience: 'https://api.openrtc.app/v2/assertions/exchange';
+        forceRefresh: boolean;
+    }): 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: () => void): () => void;
+}
+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?: {
+        name?: string;
+        /**
+         * Optional application-owned public presence metadata. It is bounded
+         * to 4 KiB and folded into the initial connection/presence operation.
+         */
+        metadata?: string;
+    };
+    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: {
+        start(options?: OpenRTCDevicesStartOptions): Promise<OpenRTCDevicesHandle>;
+    };
+    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 type { OpenRTCOptions as O, OpenRTCClient as a, OpenRTCAccessMode as b, OpenRTCAttestationProvider as c, OpenRTCAuthProvider as d, OpenRTCBotVerificationProvider as e, OpenRTCCapabilityHandle as f, OpenRTCChannelCatalog as g, OpenRTCDevicesHandle as h, OpenRTCDevicesStartOptions as i, OpenRTCLatestStateMode as j, OpenRTCRoomHandle as k, OpenRTCRoomJoinOptions as l, OpenRTCSpaceHandle as m, OpenRTCSpaceJoinOptions as n, OpenRTCTicketHandle as o, OpenRTCTicketIssueOptions as p, OpenRTCTransportPreferences as q, OpenRTCUsageNamespace as r, OpenRTCUsageUpdate as s, OpenRTCUsageWarning as t };