openrtc 1.0.26 → 2.0.0-rc.0

package/dist/factories-O5575ECL.js

@@ -0,0 +1 @@
+export{b as createIpcClient,a as createWasmClient}from'./chunk-XE43HAXV.js';import'./chunk-CEMN2JKR.js';import'./chunk-4K2QPYGT.js';import'./chunk-7Z6N46RB.js';import'./chunk-K37WVIZL.js';import'./chunk-BXFXPIXO.js';import'./chunk-A3IAG6EL.js';import'./chunk-YBXGNKM7.js';import'./chunk-VK6KX433.js';import'./chunk-NT5YHZQH.js';import'./chunk-N26S7V4N.js';import'./chunk-NB4H5TP3.js';import'./chunk-RD3JEGGF.js';import'./chunk-C7YN5MSV.js';

package/dist/index.d.ts

@@ -1,31 +1,19 @@
-import { R as RuntimeClientOptions, I as ITransport } 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, u as RuntimeConnectionEvent, s as RuntimeConnectionStateSnapshot, K as RuntimeConnectionTarget, 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, v as RuntimeRawConnection, r as RuntimeRoomMember, o as RuntimeScopedChannelOptions, p as RuntimeScopedLogicalChannel, X as RuntimeSession, Y as RuntimeUiConnectionStatus, Z as ScopedChannelOptions, _ as ScopedLogicalChannel } from './types-BJU2GoVb.js';
 import { P as PlutoIpcBridge } from './ipc-CflAVodw.js';
-import { O as OpenRTCClient } from './spaceTokens-CiwcKKr2.js';
-export { E as EnableSpaceAuthResponse, M as MintSpaceTokenRequest, a as MintSpaceTokenResponse, b as OpenRTCChannelConnectOptions, c as OpenRTCDeviceNamespace, d as OpenRTCDeviceSessionOptions, e as OpenRTCRoomNamespace, f as OpenRTCTicketNamespace, g as createPublicSpaceTokenProvider, h as createSpaceTokenProvider, i as enableSpaceAuth, m as mintSpaceToken, s as sandboxSpaceKey, j as spaceToken } from './spaceTokens-CiwcKKr2.js';
-import { w as ProtocolName, V as ProtocolCapability, W as ProtocolCapabilityMap, t as ApplicationPayloadCrypto, X as ApplicationCryptoStreamTools } from './types-zT2QwuCv.js';
-export { Y as AppLimits, Z as ApplicationCryptoBiStream, u as ApplicationPayloadReadinessOptions, v as ApplicationPayloadRouteOptions, x as ApplicationPayloadSendOptions, A as AuthMode, Q as DevicePresenceStatus, D as DiscoveryMode, G as GrantScope, _ as ProtocolBaseName, $ as ProtocolImplementationKind, a0 as ProtocolLocality, a1 as RouteDescriptor, a2 as RouteFamily, a3 as RouteImplementationKind, d as SignalingMode, S as SpaceAuthMode, a as SpaceTokenProvider } from './types-zT2QwuCv.js';
-export { ROUTE_DESCRIPTORS, TRANSPORT_LABELS, getRouteDescriptor, isDirectIrohTransportLabel, isIndependentTransportLabel, isIrohBaseTransportLabel, isOptionalTransportLabel, isWebRtcTransportLabel, listRouteDescriptors, normalizeTransportLabel } from './transport/index.js';
-export { isRuntimeDeviceActive, isRuntimeDeviceConnectable, isRuntimeDeviceRoutable } from './runtime/device-status.js';
-export { R as RuntimeJsonFrameHandler, a as RuntimeU32BEFrameHandler, c as createRuntimeJsonFrameDecoder, b as createRuntimeU32BEFrameDecoder, d as decodeRuntimeJsonPayload, e as encodeRuntimeJsonFrame, f as encodeRuntimeJsonPayload, g as encodeRuntimeU32BEFrame } from './framing-zRvEKOld.js';
-export { O as OPENRTC_RUNTIME_POLICY, a as RuntimePolicySnapshot, S as ScopedSession, c as Session, d as SessionOptions, g as getRuntimePolicy } from './assembly-CscFVHYK.js';
-export { b as RuntimeAdapterKind, R as RuntimeCapabilities } from './capabilities-CaqXOIUU.js';
+import { O as OpenRTCOptions, a as OpenRTCClient } from './types-BDc7AZYI.js';
+export { c as OpenRTCAttestationProvider, d as OpenRTCAuthProvider, f as OpenRTCCapabilityHandle, h as OpenRTCDevicesHandle, i as OpenRTCDevicesStartOptions, k as OpenRTCRoomHandle, l as OpenRTCRoomJoinOptions, m as OpenRTCSpaceHandle, n as OpenRTCSpaceJoinOptions, o as OpenRTCTicketHandle, p as OpenRTCTicketIssueOptions, q as OpenRTCTransportPreferences, s as OpenRTCUsageUpdate, t as OpenRTCUsageWarning } from './types-BDc7AZYI.js';
+import './types-BVJr065k.js';
 import './IEngineBridge-BbsT8hof.js';
+import './types-BUXwspL0.js';
+import './ITransport-BsPcaov7.js';
+import './capabilities-YSskrE8H.js';
 
 /**
- * OpenRTC developer-facing browser entrypoint and compatibility native factory.
- *
- * Native-only applications should import `createNativeOpenRTC` from
- * `openrtc/native` so their webview bundle does not carry the browser WASM
- * runtime.
- */
-
-/**
- * Create an OpenRTC client for browser/WASM environments.
+ * Create a lazy OpenRTC 2.0 browser client. Construction validates only local
+ * input and performs no network, storage, auth, timer, WASM, or transport work.
  */
-declare function OpenRTC(options: RuntimeClientOptions): OpenRTCClient;
+declare function OpenRTC(options: OpenRTCOptions): OpenRTCClient;
 declare namespace OpenRTC {
-    var native: (options: RuntimeClientOptions, bridge?: PlutoIpcBridge) => OpenRTCClient;
+    var native: (options: OpenRTCOptions, bridge?: PlutoIpcBridge) => OpenRTCClient;
 }
 
 /**
@@ -104,46 +92,4 @@ declare function openRtcError(code: OpenRtcErrorCode, message: string, options:
  */
 declare function classifyOpenRtcFailure(error: unknown): OpenRtcError;
 
-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;
-
-type UpgradeState = 'none' | 'upgrading' | 'upgraded' | 'failed';
-type OutboundMessage = string | object | ArrayBuffer | Uint8Array;
-
-export { ApplicationCryptoStreamTools, type ApplicationKeyAgreementPayload, ApplicationPayloadCrypto, KEY_AGREEMENT_ALGORITHM, KEY_AGREEMENT_PUBLIC_KEY_BYTES, OPENRTC_ERROR_CODES, OpenRTC, OpenRTCClient, RuntimeClientOptions as OpenRTCOptions, OpenRtcError, type OpenRtcErrorCode, type OpenRtcErrorOptions, type OpenRtcErrorPlane, type OpenRtcErrorProjection, type OutboundMessage, ProtocolCapability, ProtocolCapabilityMap, ProtocolName, RuntimeClientOptions, type UpgradeState, classifyOpenRtcFailure, createApplicationCryptoStreamTools, createSharedSecretApplicationCrypto, deriveApplicationCryptoKey, encodeApplicationKeyAgreementPayload, generateEphemeralKeyAgreement, getPreferredProtocolOrder, isApplicationEncryptedPayload, openRtcError, projectOpenRtcErrorFields };
+export { OPENRTC_ERROR_CODES, OpenRTC, OpenRTCClient, OpenRTCOptions, OpenRtcError, type OpenRtcErrorCode, type OpenRtcErrorOptions, type OpenRtcErrorPlane, type OpenRtcErrorProjection, classifyOpenRtcFailure, openRtcError, projectOpenRtcErrorFields };

package/dist/index.js

@@ -1 +1 @@
-import {a,b}from'./chunk-BW6OKBHV.js';export{e as createPublicSpaceTokenProvider,h as createSpaceTokenProvider,c as enableSpaceAuth,d as mintSpaceToken,f as sandboxSpaceKey,g as spaceToken}from'./chunk-BW6OKBHV.js';import {a as a$1,b as b$1}from'./chunk-QBAVJDN2.js';export{d as KEY_AGREEMENT_ALGORITHM,c as KEY_AGREEMENT_PUBLIC_KEY_BYTES,h as ScopedSession,w as createRuntimeJsonFrameDecoder,s as createRuntimeU32BEFrameDecoder,u as decodeRuntimeJsonPayload,f as deriveApplicationCryptoKey,g as encodeApplicationKeyAgreementPayload,v as encodeRuntimeJsonFrame,t as encodeRuntimeJsonPayload,r as encodeRuntimeU32BEFrame,e as generateEphemeralKeyAgreement,b as getPreferredProtocolOrder}from'./chunk-DXJZDB7Q.js';export{a as isRuntimeDeviceActive,c as isRuntimeDeviceConnectable,b as isRuntimeDeviceRoutable}from'./chunk-CK6WQV7J.js';import'./chunk-2W2YWRIZ.js';import {g}from'./chunk-PPGIC6DR.js';export{o as OPENRTC_ERROR_CODES,A as OPENRTC_RUNTIME_POLICY,p as OpenRtcError,s as classifyOpenRtcFailure,m as createApplicationCryptoStreamTools,l as createSharedSecretApplicationCrypto,B as getRuntimePolicy,k as isApplicationEncryptedPayload,r as openRtcError,q as projectOpenRtcErrorFields}from'./chunk-D4JYPV6F.js';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';import'./chunk-OCSZA6PK.js';export{a as ROUTE_DESCRIPTORS,e as getRouteDescriptor,f as listRouteDescriptors}from'./chunk-C7YN5MSV.js';function c(e){let t=a(e),o=a$1(t);return b(o,"web")}c.native=function(e,t){let o=a(e),s=t??g(),m=b$1(o,s);return b(m,"native")};export{c as OpenRTC};
+import {a}from'./chunk-UEYM6WTT.js';import {c}from'./chunk-PODAMIL6.js';import {d}from'./chunk-K37WVIZL.js';export{a as OPENRTC_ERROR_CODES,b as OpenRtcError,e as classifyOpenRtcFailure,d as openRtcError,c as projectOpenRtcErrorFields}from'./chunk-NT5YHZQH.js';function i(p){return c(p,{platform:"web",runtimeFactory:async e=>{let{createWasmClient:t}=await import('./factories-O5575ECL.js');return t(e)}})}i.native=function(p,e=d()){return c(p,{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:a}=await import('./ipcFactory-FBNUVH7V.js');return a(t,e)}})};export{i as OpenRTC};

package/dist/ipcFactory-FBNUVH7V.js

@@ -0,0 +1 @@
+export{a as createIpcClient}from'./chunk-YGJ6OAPR.js';import'./chunk-CEMN2JKR.js';import'./chunk-4K2QPYGT.js';import'./chunk-7Z6N46RB.js';import'./chunk-K37WVIZL.js';import'./chunk-BXFXPIXO.js';import'./chunk-A3IAG6EL.js';import'./chunk-YBXGNKM7.js';import'./chunk-VK6KX433.js';import'./chunk-NT5YHZQH.js';import'./chunk-N26S7V4N.js';import'./chunk-NB4H5TP3.js';import'./chunk-RD3JEGGF.js';import'./chunk-C7YN5MSV.js';

package/dist/native.d.ts

@@ -1,21 +1,15 @@
-import { R as RuntimeClientOptions } from './types-BJU2GoVb.js';
 import { P as PlutoIpcBridge } from './ipc-CflAVodw.js';
 export { c as classifyNativeIpcFailure, i as isNativeIpcCommandUnavailable } from './ipc-CflAVodw.js';
-import { O as OpenRTCClient } from './spaceTokens-CiwcKKr2.js';
-export { E as EnableSpaceAuthResponse, M as MintSpaceTokenRequest, a as MintSpaceTokenResponse, b as OpenRTCChannelConnectOptions, c as OpenRTCDeviceNamespace, d as OpenRTCDeviceSessionOptions, e as OpenRTCRoomNamespace, f as OpenRTCTicketNamespace, g as createPublicSpaceTokenProvider, h as createSpaceTokenProvider, i as enableSpaceAuth, m as mintSpaceToken, s as sandboxSpaceKey, j as spaceToken } from './spaceTokens-CiwcKKr2.js';
-export { S as SpaceAuthMode, a as SpaceTokenProvider } from './types-zT2QwuCv.js';
+import { O as OpenRTCOptions, a as OpenRTCClient } from './types-BDc7AZYI.js';
+export { b as OpenRTCAccessMode, c as OpenRTCAttestationProvider, d as OpenRTCAuthProvider, e as OpenRTCBotVerificationProvider, f as OpenRTCCapabilityHandle, g as OpenRTCChannelCatalog, h as OpenRTCDevicesHandle, i as OpenRTCDevicesStartOptions, j as OpenRTCLatestStateMode, k as OpenRTCRoomHandle, l as OpenRTCRoomJoinOptions, m as OpenRTCSpaceHandle, n as OpenRTCSpaceJoinOptions, o as OpenRTCTicketHandle, p as OpenRTCTicketIssueOptions, q as OpenRTCTransportPreferences, r as OpenRTCUsageNamespace, s as OpenRTCUsageUpdate, t as OpenRTCUsageWarning } from './types-BDc7AZYI.js';
+import './types-BVJr065k.js';
 import './IEngineBridge-BbsT8hof.js';
-import './assembly-CscFVHYK.js';
-import './capabilities-CaqXOIUU.js';
+import './types-BUXwspL0.js';
+import './ITransport-BsPcaov7.js';
+import './capabilities-YSskrE8H.js';
 
-/**
- * Native-only OpenRTC entrypoint.
- *
- * This entry deliberately imports only the IPC runtime. It is the preferred
- * entry for Tauri webviews because it excludes the browser WASM adapter and
- * binary from the application bundle.
- */
+/** Native-only OpenRTC 2.0 entrypoint. */
 
-declare function createNativeOpenRTC(options: RuntimeClientOptions, bridge: PlutoIpcBridge): OpenRTCClient;
+declare function createNativeOpenRTC(options: OpenRTCOptions, bridge: PlutoIpcBridge): OpenRTCClient;
 
-export { OpenRTCClient, createNativeOpenRTC };
+export { OpenRTCClient, OpenRTCOptions, createNativeOpenRTC };

package/dist/native.js

@@ -1 +1 @@
-import {a,b}from'./chunk-BW6OKBHV.js';export{e as createPublicSpaceTokenProvider,h as createSpaceTokenProvider,c as enableSpaceAuth,d as mintSpaceToken,f as sandboxSpaceKey,g as spaceToken}from'./chunk-BW6OKBHV.js';import {A as A$1}from'./chunk-DXJZDB7Q.js';import {h}from'./chunk-PPGIC6DR.js';export{e as classifyNativeIpcFailure,f as isNativeIpcCommandUnavailable}from'./chunk-PPGIC6DR.js';import'./chunk-D4JYPV6F.js';import'./chunk-QT2ASNI3.js';import {s}from'./chunk-OCSZA6PK.js';import'./chunk-C7YN5MSV.js';function c(t,p){let e=s(t);return A$1(e,new h({...e,bridge:p}))}function A(t,p){let e=c(a(t),p);return b(e,"native")}export{A as createNativeOpenRTC};
+import {a}from'./chunk-UEYM6WTT.js';import {c}from'./chunk-PODAMIL6.js';export{a as classifyNativeIpcFailure,b as isNativeIpcCommandUnavailable}from'./chunk-K37WVIZL.js';function m(n,e){return c(n,{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:o}=await import('./ipcFactory-FBNUVH7V.js');return o(t,e)}})}export{m as createNativeOpenRTC};

package/dist/runtime/WasmRuntimeAdapter.d.ts

@@ -1,7 +1,7 @@
-import { D as DelegatingRuntimeAdapter, W as WasmBridgeOptions } from '../DelegatingRuntimeAdapter-Cg3jFk1b.js';
-import '../types-zT2QwuCv.js';
+import { D as DelegatingRuntimeAdapter, W as WasmBridgeOptions } from '../DelegatingRuntimeAdapter-DqfHkjLy.js';
+import '../types-BVJr065k.js';
+import '../capabilities-YSskrE8H.js';
 import '../IEngineBridge-BbsT8hof.js';
-import '../capabilities-CaqXOIUU.js';
 
 declare class WasmRuntimeAdapter extends DelegatingRuntimeAdapter {
     constructor(options: WasmBridgeOptions);

package/dist/runtime/WasmRuntimeAdapter.js

@@ -1 +1 @@
-export{a as WasmRuntimeAdapter}from'../chunk-2W2YWRIZ.js';import'../chunk-D4JYPV6F.js';import'../chunk-QT2ASNI3.js';import'../chunk-OCSZA6PK.js';import'../chunk-C7YN5MSV.js';
+export{a as WasmRuntimeAdapter}from'../chunk-GW7P3D54.js';import'../chunk-A3IAG6EL.js';import'../chunk-YBXGNKM7.js';import'../chunk-VK6KX433.js';import'../chunk-NT5YHZQH.js';import'../chunk-N26S7V4N.js';import'../chunk-NB4H5TP3.js';import'../chunk-RD3JEGGF.js';import'../chunk-C7YN5MSV.js';

package/dist/runtime/device-status.d.ts

@@ -1,6 +1,7 @@
-import { c as RuntimeDevice, d as RuntimeDeviceStatusSnapshot } from '../types-BJU2GoVb.js';
+import { i as RuntimeDevice, l as RuntimeDeviceStatusSnapshot } from '../types-BUXwspL0.js';
 import '../IEngineBridge-BbsT8hof.js';
-import '../types-zT2QwuCv.js';
+import '../types-BVJr065k.js';
+import '../ITransport-BsPcaov7.js';
 
 interface RuntimeDeviceActiveOptions {
     now?: number;

package/dist/runtime/index.d.ts

@@ -1,20 +1,20 @@
-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 * 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';
-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 { R as RuntimeFactoryOptions, P as PlutoRuntimeAssembly, u as OpenRTCClient, f as OpenRTCCapabilityHandle, v as PeerReconciliationStats } from '../types-BDc7AZYI.js';
+export { w as OPENRTC_RUNTIME_POLICY, x as RuntimeClient, y as RuntimePolicySnapshot, D as ScopedConnectionActorError, z as ScopedConnectionActorErrorKind, A as ScopedConnectionActorHandle, B as ScopedConnectionActorHandleOptions, C as ScopedConnectionActorRegistry, E as ScopedConnectionActorState, F as ScopedConnectionClose, G as ScopedConnectionDial, H as ScopedConnectionKey, I as ScopedLogicalChannelHandle, J as ScopedPreferredTransport, K as getRuntimePolicy, L as scopedConnectionKey, M as scopedConnectionKeyToString } from '../types-BDc7AZYI.js';
+import { R as RuntimeClientOptions, C as Connection, q as RuntimeConnectionTarget, u as RuntimeRawConnection } from '../types-BUXwspL0.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, z as RuntimeConnectionEvent, b as RuntimeConnectionStateSnapshot, i as RuntimeDevice, m as RuntimeDeviceConnectOptions, N as RuntimeDevicePresenceStatus, O as RuntimeDeviceStatus, l as RuntimeDeviceStatusSnapshot, e 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, d as RuntimePeerConnectOptions, x as RuntimePeerHealth, U as RuntimePeerLifecycleStatus, c as RuntimePeerReadinessSnapshot, V as RuntimePeerScope, W as RuntimePeerSessionSnapshot, a 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-BUXwspL0.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';
+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 { 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';
+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 +66,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 +74,23 @@ 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;
+
+/**
+ * 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;
+}
+
 interface MoQSubscriberOptions {
     maxPendingSubscriptions?: number;
     maxSubscribeRetries?: number;
@@ -217,7 +234,7 @@ declare class RoomManager {
     private requireCoordinationGateway;
     private get roomBackendTag();
     private resolveRoomUserId;
-    private get appTag();
+    private resolveControlPlaneAppTag;
     private invokeRoomCallable;
     private isAlreadyExistsError;
     private normalizeRoomId;
@@ -503,4 +520,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, RuntimeClientOptions, RuntimeConnectionController, RuntimeConnectionTarget, RuntimeFactoryOptions, type RuntimeJsonFrameDecoderOptions, type RuntimeJsonFrameHandler, RuntimeRawConnection, type RuntimeU32BEFrameHandler, clog, concatRuntimeBytes, correlationForDriveGrantScope, createIpcClient, createLegacyOpenRTC, 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-QBAVJDN2.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-DXJZDB7Q.js';export{a as isRuntimeDeviceActive,c as isRuntimeDeviceConnectable,b as isRuntimeDeviceRoutable}from'../chunk-CK6WQV7J.js';export{a as WasmRuntimeAdapter}from'../chunk-2W2YWRIZ.js';export{b as TauriRuntimeAdapter,a as createTauriIpcBridge}from'../chunk-DIBUXEEO.js';export{h as IpcRuntimeAdapter,e as classifyNativeIpcFailure,f as isNativeIpcCommandUnavailable}from'../chunk-PPGIC6DR.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-D4JYPV6F.js';import'../chunk-QT2ASNI3.js';import'../chunk-OCSZA6PK.js';import'../chunk-C7YN5MSV.js';
+export{b as TauriRuntimeAdapter,a as createTauriIpcBridge}from'../chunk-DTWEQS3J.js';export{a as createLegacyOpenRTC}from'../chunk-WMRCP3YX.js';import'../chunk-2QHDEGVX.js';export{b as createIpcClient,a as createWasmClient}from'../chunk-XE43HAXV.js';import'../chunk-YGJ6OAPR.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-CEMN2JKR.js';export{f as IpcRuntimeAdapter}from'../chunk-4K2QPYGT.js';import'../chunk-7Z6N46RB.js';export{b as runtimeFromCapability}from'../chunk-PODAMIL6.js';export{a as classifyNativeIpcFailure,b as isNativeIpcCommandUnavailable}from'../chunk-K37WVIZL.js';import'../chunk-N4SX7C3W.js';import'../chunk-BXFXPIXO.js';export{a as isRuntimeDeviceActive,c as isRuntimeDeviceConnectable,b as isRuntimeDeviceRoutable}from'../chunk-CK6WQV7J.js';export{a as WasmRuntimeAdapter}from'../chunk-GW7P3D54.js';import'../chunk-A3IAG6EL.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';import {b}from'../chunk-N26S7V4N.js';import'../chunk-NB4H5TP3.js';import'../chunk-RD3JEGGF.js';import'../chunk-C7YN5MSV.js';var z="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 q(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 p=typeof a?.error=="string"?a.error:`enableSpaceAuth failed (${r.status})`;throw new Error(p)}return a}async function M(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??z).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 p=null;typeof sessionStorage<"u"?(p=sessionStorage.getItem(a),p||(p=globalThis.crypto?.randomUUID?.()??`member-${Date.now()}`,sessionStorage.setItem(a,p))):p=`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:p,...o?{sandboxAppId:o}:{}})}),{text:u,payload:s}=await L(i);if(!i.ok){let f=typeof s?.error=="string"?s.error:u.trim()?u.trim().slice(0,240):`public space token mint failed (${i.status})`;throw new Error(f)}let l=typeof s?.token=="string"?s.token.trim():"";if(!l)throw new Error("public space token response missing token");return {customToken:l}}}function B(e){if(!e.trim())return {};try{let t=JSON.parse(e);return t&&typeof t=="object"?t:{}}catch{return {}}}async function L(e){let t=e.text;if(typeof t=="function"){let o=await t.call(e).catch(()=>"");return {text:o,payload:B(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 H=d,X=d;
+export{d as createPublicSpaceTokenProvider,X as createSpaceTokenProvider,q as enableSpaceAuth,M as mintSpaceToken,J as sandboxSpaceKey,H as spaceToken};

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-DIBUXEEO.js';import'../chunk-PPGIC6DR.js';import'../chunk-D4JYPV6F.js';import'../chunk-QT2ASNI3.js';import'../chunk-OCSZA6PK.js';import'../chunk-C7YN5MSV.js';
+export{b as TauriRuntimeAdapter,a as createTauriIpcBridge}from'../chunk-DTWEQS3J.js';import'../chunk-4K2QPYGT.js';import'../chunk-K37WVIZL.js';import'../chunk-BXFXPIXO.js';import'../chunk-A3IAG6EL.js';import'../chunk-YBXGNKM7.js';import'../chunk-VK6KX433.js';import'../chunk-NT5YHZQH.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,29 @@
+import { u as OpenRTCClient, O as OpenRTCOptions, a as OpenRTCClient$1 } from './types-BDc7AZYI.js';
+import { P as PlutoIpcBridge } from './ipc-CflAVodw.js';
+import { R as RuntimeClientOptions } from './types-BUXwspL0.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 {a}from'./chunk-WMRCP3YX.js';import'./chunk-2QHDEGVX.js';import'./chunk-XE43HAXV.js';import'./chunk-YGJ6OAPR.js';import'./chunk-CEMN2JKR.js';import'./chunk-4K2QPYGT.js';import'./chunk-7Z6N46RB.js';import {c}from'./chunk-PODAMIL6.js';import'./chunk-K37WVIZL.js';import'./chunk-N4SX7C3W.js';import'./chunk-BXFXPIXO.js';import'./chunk-A3IAG6EL.js';import'./chunk-YBXGNKM7.js';import'./chunk-VK6KX433.js';import'./chunk-NT5YHZQH.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-O5575ECL.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-FBNUVH7V.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';