openrtc 2.3.0 → 2.4.0

package/dist/runtime/index.d.ts

@@ -1,17 +1,15 @@
-import { a as PeerReconciliationStats } from '../assembly-Bmi65-tK.js';
-export { D as ConnectionActor, d as ConnectionActorError, e as ConnectionActorErrorKind, f as ConnectionActorKey, g as ConnectionActorOptions, h as ConnectionActorState, i as ConnectionActors, j as ConnectionClose, k as ConnectionDial, l as LogicalChannel, P as PolicySnapshot, m as PreferredTransport, n as RUNTIME_POLICY, R as RuntimeClient, o as connectionActorKey, p as connectionActorKeyString, q as getRuntimePolicy } from '../assembly-Bmi65-tK.js';
+import { a as PeerReconciliationStats } from '../assembly-By3UBQsE.js';
+export { D as ConnectionActor, d as ConnectionActorError, e as ConnectionActorErrorKind, f as ConnectionActorKey, g as ConnectionActorOptions, h as ConnectionActorState, i as ConnectionActors, j as ConnectionClose, k as ConnectionDial, l as LogicalChannel, P as PolicySnapshot, m as PreferredTransport, n as RUNTIME_POLICY, R as RuntimeClient, o as connectionActorKey, p as connectionActorKeyString, q as getRuntimePolicy } from '../assembly-By3UBQsE.js';
 import { Client as Client$1 } from '../coreClient.js';
-import { b as Avenue } from '../types--jQzenZR.js';
-import * as Draft14 from '@moq/net';
-import { a7 as SignalingOptions, I as ISignalingBackend, m as RuntimeIdentity, l as RoomMember, n as SignalingEnvelope, u as SignalingSession, D as Device, r as DesiredPeerProjection, w as BackendConnectionState, a6 as AppLimits, G as GrantScope, Y as JoinRoomOptions, W as ChannelMetadata, a2 as CryptoStreams, a8 as RoomCreationMode, h as ClientOptions, z as PayloadCrypto, k as DiscoveryMode, a1 as ProtocolCapabilityMap, a9 as ScanningLoopOptions, aa as ScanningLoopHandle, ab as RuntimeBootstrapOptions, ac as RuntimeBootstrapResult, F as ApplicationPayloadReadinessOptions, ad as ManagedApplicationRouteOptions, Q as PeerState, T as PeerScope, U as PeerHealth, V as ChannelDescriptor, ae as JoinRequest, N as NativeConnectParams, t as NativeConnectResult } from '../ITransport-CjxCQ6q7.js';
-import { a as Connection, t as ConnectionTarget, m as RawConnection } from '../types-DDhMQkK8.js';
-export { v as AutoConnectPolicy, B as BrowserProtocolStore, C as ChannelDescriptor, w as ChannelFraming, i as ConnectionEvent, g as ConnectionState, x as ConnectionStatus, k as DeviceConnectOptions, y as DevicePresence, l as DeviceProfile, D as DeviceStatus, I as IncomingStream, q as IrohDocEntry, p as IrohMutationReceipt, J as JoinRoomOptions, L as LocalDeviceInfo, M as ManagedOptions, j as ManagedSession, N as NamespaceDescriptor, z as PayloadRouteOptions, P as PeerConnectOptions, E as PeerLifecycleStatus, b as PeerReadiness, F as PeerSessionSnapshot, d as PeerStreamOptions, u as PresenceLoopOptions, G as PresencePolicy, h as ReadinessOptions, H as RuntimeAuthContext, r as RuntimeAuthIdentity, o as RuntimeClientOptions, e as RuntimeDevice, c as RuntimePeerHealth, K as RuntimePeerScope, R as RuntimePeerState, n as RuntimeRoomMember, s as RuntimeSession, S as ScopedChannelOptions, f as ScopedLogicalChannel, O as SessionKind, Q as SessionPlatform } from '../types-DDhMQkK8.js';
-import { R as RuntimeCapabilities } from '../capabilities-BPuynml5.js';
-export { B as BROWSER_CAPABILITIES, a as CapabilityHost, C as CapabilityProfile, N as NATIVE_CAPABILITIES, b as NativeRuntimeStatus, c as RuntimeAdapterKind, T as TransportStatus, d as browserCapabilities, e as capabilityProfile, f as cloneCapabilities, s as statusCapabilities } from '../capabilities-BPuynml5.js';
+import { c as Avenue } from '../types-BArEthJr.js';
+import { au as SignalingOptions, K as ISignalingBackend, N as RuntimeIdentity, O as RoomMember, V as SignalingEnvelope, Y as SignalingSession, Q as Device, X as DesiredPeerProjection, a9 as BackendConnectionState, ar as AppLimits, G as GrantScope, f as Connection, av as JoinRoomOptions, aw as ChannelMetadata, al as CryptoStreams, ax as RoomCreationMode, F as ClientOptions, ak as PayloadCrypto, z as DiscoveryMode, ay as ProtocolCapabilityMap, az as ScanningLoopOptions, aA as ScanningLoopHandle, aB as RuntimeBootstrapOptions, aC as RuntimeBootstrapResult, aD as ApplicationPayloadReadinessOptions, aE as ManagedApplicationRouteOptions, aF as PeerState, aG as PeerScope, aH as PeerHealth, aI as ChannelDescriptor, aJ as JoinRequest, a7 as NativeConnectParams, a8 as NativeConnectResult, as as ConnectionTarget, w as RawConnection } from '../Connection-DZ5eP5hL.js';
+export { aK as AutoConnectPolicy, ae as BrowserProtocolStore, C as ChannelDescriptor, aL as ChannelFraming, p as ConnectionEvent, n as ConnectionState, aM as ConnectionStatus, r as DeviceConnectOptions, aN as DevicePresence, v as DeviceProfile, D as DeviceStatus, I as IncomingStream, ah as IrohDocEntry, ag as IrohMutationReceipt, J as JoinRoomOptions, L as LocalDeviceInfo, M as ManagedOptions, q as ManagedSession, af as NamespaceDescriptor, aO as PayloadRouteOptions, e as PeerConnectOptions, aP as PeerLifecycleStatus, h as PeerReadiness, aQ as PeerSessionSnapshot, k as PeerStreamOptions, a5 as PortableMediaChunk, a6 as PortableMediaControl, a3 as PortableMediaPublicationStart, a2 as PortableMediaPublish, a4 as PortableMediaSample, at as PresenceLoopOptions, aR as PresencePolicy, o as ReadinessOptions, aS as RuntimeAuthContext, ap as RuntimeAuthIdentity, y as RuntimeClientOptions, l as RuntimeDevice, i as RuntimePeerHealth, aT as RuntimePeerScope, d as RuntimePeerState, x as RuntimeRoomMember, aq as RuntimeSession, S as ScopedChannelOptions, m as ScopedLogicalChannel, aU as SessionKind, aV as SessionPlatform } from '../Connection-DZ5eP5hL.js';
+import { R as RuntimeCapabilities } from '../capabilities-B2mHv_H7.js';
+export { B as BROWSER_CAPABILITIES, a as CapabilityHost, C as CapabilityProfile, N as NATIVE_CAPABILITIES, b as NativeRuntimeStatus, c as RuntimeAdapterKind, T as TransportStatus, d as browserCapabilities, e as capabilityProfile, f as cloneCapabilities, s as statusCapabilities } from '../capabilities-B2mHv_H7.js';
 export { DeviceActiveOptions, isDeviceActive, isDeviceConnectable, isDeviceRoutable } from './device-status.js';
-export { a as IpcAdapterOptions, I as IpcRuntimeAdapter } from '../IpcRuntimeAdapter-CE0va9Tr.js';
-export { P as NativeBridge, N as NativeIpcFailureKind, P as PlutoIpcBridge, a as PlutoIpcUnlisten, c as classifyIpcFailure, i as isIpcUnavailable } from '../ipc-CPnNwv6f.js';
-import '../DelegatingRuntimeAdapter-DE4LTGAJ.js';
+export { a as IpcAdapterOptions, I as IpcRuntimeAdapter } from '../IpcRuntimeAdapter-Dduaxscj.js';
+export { P as NativeBridge, N as NativeIpcFailureKind, P as PlutoIpcBridge, a as PlutoIpcUnlisten, c as classifyIpcFailure, i as isIpcUnavailable } from '../ipc-DgzKqHH3.js';
+import '../DelegatingRuntimeAdapter-4cgiIWMN.js';
 
 declare class Signaling {
     private readonly appTag;
@@ -71,142 +69,6 @@ type CapabilityRuntime = Client$1;
  */
 declare function runtimeForCapability(handle: Avenue): CapabilityRuntime;
 
-interface MoQSubscriberOptions {
-    maxPendingSubscriptions?: number;
-    maxSubscribeRetries?: number;
-    subscribeRetryDelayMs?: number;
-    maxBufferedGroupsPerTrack?: number;
-    maxBufferedFramesPerGroup?: number;
-    maxBufferedBytesPerTrack?: number;
-    maxObjectPayloadBytes?: number;
-    onSubscriptionTerminated?: (namespace: string, name: string, error: unknown) => void;
-}
-/** Draft-14 subscriber facade; session reconnect remains owned by MoQController. */
-declare class MoQSubscriber {
-    private readonly session;
-    private readonly onObject;
-    private readonly subscriptions;
-    private readonly maxSubscriptions;
-    private readonly maxSubscribeRetries;
-    private readonly subscribeRetryDelayMs;
-    private readonly maxObjectPayloadBytes;
-    private readonly onSubscriptionTerminated?;
-    private closed;
-    constructor(session: MoQSession, onObject: (trackNamespace: string, trackName: string, object: Uint8Array, metadata: unknown) => void, options?: MoQSubscriberOptions);
-    subscribe(namespace: string, name: string): Promise<void>;
-    close(): void;
-    private consume;
-}
-
-interface TransportInterface {
-    createBidirectionalStream(): Promise<{
-        readable: ReadableStream<Uint8Array>;
-        writable: WritableStream<Uint8Array>;
-    }>;
-    createUnidirectionalStream(): Promise<WritableStream<Uint8Array>>;
-    incomingBidirectionalStreams: ReadableStream<unknown>;
-    incomingUnidirectionalStreams: ReadableStream<ReadableStream<Uint8Array>>;
-    close(): void;
-    ready: Promise<void>;
-}
-interface MoQSessionOptions {
-    onSubscriptionTerminated?: (namespace: string, name: string, error: unknown) => void;
-}
-interface MoQDatagramDuplex {
-    readonly maxDatagramSize?: number;
-    readonly readable: ReadableStream<Uint8Array>;
-    readonly writable: WritableStream<Uint8Array>;
-    close(): void;
-}
-/**
- * Draft-14 MoQT adapter. The OpenRTC controller owns reconnect and lifecycle;
- * this class owns only one negotiated relay session and its protocol handles.
- */
-declare class MoQSession {
-    readonly transport: TransportInterface;
-    private readonly relayUrl;
-    readonly publisher: MoQPublisher;
-    readonly subscriber: MoQSubscriber;
-    setupComplete: boolean;
-    private connection;
-    private closeListeners;
-    private closed;
-    private closeEmitted;
-    private setupResolve;
-    private readonly setupPromise;
-    constructor(transport: TransportInterface, onObject?: (ns: string, name: string, obj: Uint8Array, meta: unknown) => void, role?: number, relayUrl?: URL, options?: MoQSessionOptions);
-    requireConnection(): Draft14.Connection.Established;
-    /**
-     * Open the patched Draft 14 object-datagram surface used only by the Iroh
-     * packet carrier. Existing application-data publishing remains on subgroup
-     * streams and never shares readiness with this duplex.
-     */
-    openDatagramDuplex(publishNamespace: string, subscribeNamespace: string, trackName: string): Promise<MoQDatagramDuplex>;
-    init(): Promise<void>;
-    waitForSetup(): Promise<void>;
-    onClose(callback: (reason?: unknown) => void): () => void;
-    close(): void;
-    private emitClose;
-}
-
-interface MoQPublisherOptions {
-    maxPendingAnnounces?: number;
-    announceTimeoutMs?: number;
-    maxSubscribedTracks?: number;
-    maxActivePublishers?: number;
-    maxTrackIdChars?: number;
-    /**
-     * Reject an application object before it reaches a relay track. This must
-     * match the receiver-side default so browser and native clients apply the
-     * same hard egress boundary.
-     */
-    maxObjectPayloadBytes?: number;
-}
-interface TrackPublisher {
-    close(): void;
-    push(data: Uint8Array, init: {
-        isKey: boolean;
-        timestamp: number;
-        closeAfterPush?: boolean;
-    }): Promise<void>;
-}
-/** Draft-14 publisher facade preserving OpenRTC's existing data-track API. */
-declare class MoQPublisher {
-    private readonly session;
-    private readonly namespaces;
-    private readonly activePublishers;
-    private readonly maxNamespaces;
-    private readonly maxSubscribedTracks;
-    private readonly maxActivePublishers;
-    private readonly maxTrackIdChars;
-    private readonly maxObjectPayloadBytes;
-    private closed;
-    constructor(session: MoQSession, options?: MoQPublisherOptions);
-    announce(namespace: string): Promise<void>;
-    hasNamespace(namespace: string): boolean;
-    hasTrackSubscriber(namespace: string, name: string): boolean;
-    createTrack(namespace: string, name: string): Promise<TrackPublisher>;
-    close(): void;
-    private acceptTrackRequests;
-    private totalSubscriberCount;
-    private resolveTrackId;
-}
-
-/**
- * Browser MoQ session controller.
- *
- * Owns the WebTransport-backed MoQ relay session, reconnect state, peer
- * subscriptions, and direct MoQ data helpers. `Client` remains the facade so
- * existing SDK calls and test spies keep working while MoQ stops contributing
- * more lifecycle state to the god object.
- */
-
-type MoQBundle = {
-    session: MoQSession;
-    publisher: MoQPublisher;
-    subscriber: MoQSubscriber;
-};
-
 interface RoomClientHost {
     wasmClient: any;
     roomCreationMode: 'client-open' | 'client-auth' | 'server-only';
@@ -251,11 +113,13 @@ type ProtocolHint = 'control' | 'explicit' | 'native-main' | 'unknown';
 type IncomingStreamEvent = {
     type: 'bi' | 'uni';
     stream: any;
+    connectionId?: string;
     remoteNodeId: string;
     transportStableId?: number;
     traceId?: string;
     protocolHint?: ProtocolHint;
     channel?: ChannelMetadata | null;
+    applicationAuthorized?: boolean;
     applicationCrypto?: CryptoStreams;
     invalid?: boolean;
 };
@@ -318,18 +182,11 @@ declare class Client {
     subscribeSessions(localDeviceId: string, callback: (session: SignalingSession) => void | Promise<void>): Promise<() => void>;
     startScanningLoop(options: ScanningLoopOptions): Promise<ScanningLoopHandle>;
     bootstrapRuntime(options: RuntimeBootstrapOptions): Promise<RuntimeBootstrapResult>;
-    updateTransportConfig(transports: ClientOptions['transports']): void;
+    updateTransportConfig(transports: ClientOptions['transports']): Promise<void>;
     init(): Promise<void>;
     ensureAuthenticated(reason: 'init' | 'room-op' | 'discovery'): Promise<void>;
     refreshRuntimeAuthToken(reason?: 'runtime-start' | 'managed-session'): Promise<void>;
-    get moqState(): string;
-    get moq(): MoQBundle | null;
-    onMoQReady(cb: () => void): () => void;
-    onMoQFailed(cb: () => void): () => void;
     refreshTransportCapabilities(reason?: string): Promise<void>;
-    onMoQObject(callback: (ns: string, name: string, obj: Uint8Array, meta: any) => void): () => void;
-    subscribeMoQPeer(connection: Connection): void;
-    subscribeMoQPeerNode(peerId: string, subscriptionKey?: string): void;
     connect(ticket: string, timeoutMs?: number, expectedDeviceId?: string | null, channelId?: string, options?: {
         admissionAlreadyPresented?: boolean;
         approvedScope?: string | null;
@@ -413,10 +270,6 @@ declare class Client {
     listChannels(): ChannelDescriptor[];
     onChannelStream(channelId: string, callback: (stream: IncomingStreamEvent) => boolean | void): () => void;
     onRoomJoinRequest(callback: (request: JoinRequest) => void): () => void;
-    isMoQDataReady(peerId: string | null): boolean;
-    sendMoQData(peerId: string | null, data: Uint8Array, options?: {
-        alreadyProtected?: boolean;
-    }): Promise<void>;
 }
 
 /**

package/dist/runtime/index.js

@@ -1 +1 @@
-export{a as runtimeFromCapability}from'../chunk-UILOGUOU.js';import'../chunk-ZA44REGI.js';export{a as isDeviceActive,c as isDeviceConnectable,b as isDeviceRoutable}from'../chunk-CK6WQV7J.js';export{i as ConnectionActor,f as ConnectionActorError,j as ConnectionActors,b as ConnectionController,t as IpcRuntimeAdapter,s as RuntimeClient,e as clog,q as concatRuntimeBytes,g as connectionActorKey,h as connectionActorKeyString,p as createJsonDecoder,l as createU32Decoder,n as decodeJsonPayload,o as encodeJsonFrame,m as encodeJsonPayload,k as encodeU32Frame,d as grantCorrelation,r as readRuntimeU32BE,c as renderCorrelation}from'../chunk-XAL4T6TB.js';export{a as classifyIpcFailure,b as isIpcUnavailable}from'../chunk-HUG5AX7R.js';import'../chunk-DUY34MGT.js';import'../chunk-R35AWMNY.js';export{s as BROWSER_CAPABILITIES,t as NATIVE_CAPABILITIES,q as RUNTIME_POLICY,v as browserCapabilities,x as capabilityProfile,u as cloneCapabilities,r as getRuntimePolicy,i as logTeardownTrace,w as statusCapabilities}from'../chunk-Z2IS6NH2.js';import'../chunk-AJQVMVYW.js';import'../chunk-WA434EWD.js';import'../chunk-HEAJ7ZUR.js';import'../chunk-7BJKDBLP.js';export{b as openRtcDebug,a as openRtcDebugEnabled,c as openRtcDebugInfo,d as openRtcDebugLog}from'../chunk-2L6ULC32.js';import'../chunk-2SUSPEC4.js';
+export{a as runtimeFromCapability}from'../chunk-2LATKLCC.js';import'../chunk-ZA44REGI.js';export{a as isDeviceActive,c as isDeviceConnectable,b as isDeviceRoutable}from'../chunk-CK6WQV7J.js';export{h as ConnectionActor,e as ConnectionActorError,i as ConnectionActors,a as ConnectionController,s as IpcRuntimeAdapter,r as RuntimeClient,d as clog,p as concatRuntimeBytes,f as connectionActorKey,g as connectionActorKeyString,o as createJsonDecoder,k as createU32Decoder,m as decodeJsonPayload,n as encodeJsonFrame,l as encodeJsonPayload,j as encodeU32Frame,c as grantCorrelation,q as readRuntimeU32BE,b as renderCorrelation}from'../chunk-6OFAKLDB.js';import'../chunk-XEHBTMJQ.js';export{B as BROWSER_CAPABILITIES,C as NATIVE_CAPABILITIES,z as RUNTIME_POLICY,E as browserCapabilities,G as capabilityProfile,D as cloneCapabilities,A as getRuntimePolicy,m as logTeardownTrace,c as openRtcDebug,b as openRtcDebugEnabled,d as openRtcDebugInfo,e as openRtcDebugLog,F as statusCapabilities}from'../chunk-GNW63SM6.js';import'../chunk-TYZS5LXQ.js';import'../chunk-OT7IPLZE.js';import'../chunk-AJQVMVYW.js';export{a as classifyIpcFailure,b as isIpcUnavailable}from'../chunk-72NEEJQG.js';import'../chunk-WB66633N.js';import'../chunk-JPBW67B3.js';import'../chunk-MI3ZMVPK.js';import'../chunk-OWKAJPOI.js';import'../chunk-2GX6GB6L.js';

package/dist/testing/native.d.ts

@@ -0,0 +1,11 @@
+import { O as Options, C as Client } from '../types-BArEthJr.js';
+import { E as Endpoints } from '../protocol-BSBjMb7p.js';
+import { P as PlutoIpcBridge } from '../ipc-DgzKqHH3.js';
+import '../coreClient.js';
+import '../assembly-By3UBQsE.js';
+import '../Connection-DZ5eP5hL.js';
+import '../capabilities-B2mHv_H7.js';
+
+declare function OpenRTC(options: Options, endpoints: Endpoints, bridge: PlutoIpcBridge): Client;
+
+export { OpenRTC };

package/dist/testing/native.js

@@ -0,0 +1 @@
+import {a as a$1}from'../chunk-BOS554IK.js';import'../chunk-4MLJXEVV.js';import {b}from'../chunk-2LATKLCC.js';import'../chunk-ZA44REGI.js';import {a}from'../chunk-P2SHJMS3.js';import'../chunk-WB66633N.js';import'../chunk-JPBW67B3.js';import'../chunk-2GX6GB6L.js';function v(c,p,e){let o=new a;return b(c,{endpoints:p,testingAllowInsecureLoopback:true,platform:"native",close:()=>o.close(),deviceKeyProvider:a$1(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-4PCGKZIN.js');return a(t,e,o)}})}export{v as OpenRTC};

package/dist/testing.d.ts

@@ -1,10 +1,9 @@
-import { i as CoordinationGatewayGrantRequest, j as CoordinationGatewayGrant } from './ITransport-CjxCQ6q7.js';
-import { A as AttestationProvider, a as AuthProvider, B as BotVerificationProvider, e as DeviceProfile, O as Options, C as Client } from './types--jQzenZR.js';
-import { P as PlutoIpcBridge } from './ipc-CPnNwv6f.js';
+import { ab as CoordinationGatewayGrantRequest, ac as CoordinationGatewayGrant } from './Connection-DZ5eP5hL.js';
+import { a as AttestationProvider, b as AuthProvider, B as BotVerificationProvider, h as DeviceProfile, O as Options, C as Client } from './types-BArEthJr.js';
+import { E as Endpoints } from './protocol-BSBjMb7p.js';
 import './coreClient.js';
-import './assembly-Bmi65-tK.js';
-import './types-DDhMQkK8.js';
-import './capabilities-BPuynml5.js';
+import './assembly-By3UBQsE.js';
+import './capabilities-B2mHv_H7.js';
 
 interface DeviceProof {
     publicKeyJwk: JsonWebKey;
@@ -21,26 +20,23 @@ interface DeviceKeyProvider {
     getOrCreate(appTag: string): Promise<DeviceKey>;
     delete?(appTag: string): Promise<void>;
     /**
-     * Optional platform-secure record storage. Native hosts use this for the
-     * device certificate that is bound to the private key; browsers retain
-     * their same-origin localStorage implementation.
+     * Optional host-private record storage. Native hosts use this for the
+     * device certificate bound to their non-exported signing key; the host
+     * chooses a prompt-free implementation. Browsers retain their same-origin
+     * storage implementation.
      */
     readSecureRecord?(appTag: string, key: string): Promise<string | null>;
     writeSecureRecord?(appTag: string, key: string, value: string): Promise<void>;
     deleteSecureRecord?(appTag: string, key: string): Promise<void>;
 }
 
-interface Endpoints {
-    controlPlane: string;
-    gateway: string;
-}
-
 interface CredentialSource {
     type: 'capability' | 'device-certificate';
     token: string;
     avenue: CoordinationGatewayGrantRequest['avenue'];
     expiresAtMs: number;
-    relay: boolean;
+    irohRelay: boolean;
+    managedTurn: boolean;
     renew?: () => Promise<CredentialSource>;
     /**
      * Re-establishes an authenticated device certificate only after the
@@ -60,7 +56,8 @@ interface CachedDeviceCertificate {
 interface AuthenticatedDeviceCertificate extends CachedDeviceCertificate {
     principalId: string;
     enrolled: boolean;
-    relay: boolean;
+    irohRelay: boolean;
+    managedTurn: boolean;
 }
 interface ControlPlaneEvents {
     beforeLogicalOperation?: (operation: string) => void;
@@ -132,8 +129,5 @@ declare function OpenRTC(options: Options, endpoints: Endpoints, testing?: {
     deviceId?: string;
     irohTestRelayUrl?: string;
 }): Client;
-declare namespace OpenRTC {
-    var native: (options: Options, endpoints: Endpoints, bridge: PlutoIpcBridge) => Client;
-}
 
 export { OpenRTC, controlPlane };

package/dist/testing.js

@@ -1 +1 @@
-import {a}from'./chunk-Q6KXVTSH.js';import {a as a$1}from'./chunk-BOS554IK.js';import {c}from'./chunk-4MLJXEVV.js';import {b}from'./chunk-UILOGUOU.js';import'./chunk-ZA44REGI.js';import'./chunk-DUY34MGT.js';import'./chunk-HEAJ7ZUR.js';function d(o){let r=e=>`${e}:${o}`;return {getOrCreate:e=>c.getOrCreate(r(e)),delete:async e=>{await c.delete?.(r(e));},readSecureRecord:(e,t)=>c.readSecureRecord?.(r(e),t)??Promise.resolve(null),writeSecureRecord:(e,t,n)=>c.writeSecureRecord?.(r(e),t,n)??Promise.resolve(),deleteSecureRecord:(e,t)=>c.deleteSecureRecord?.(r(e),t)??Promise.resolve()}}function y(o,r,e){return new a(o,r,d(e))}function s(o,r,e={}){return b(o,{endpoints:r,testingAllowInsecureLoopback:true,platform:"web",...e.deviceId?{deviceIdProvider:async()=>e.deviceId}:{},...e.irohTestRelayUrl?{irohTestRelayUrl:e.irohTestRelayUrl}:{},runtimeFactory:async t=>{let{createWasmClient:n}=await import('./runtime/factories.js');return n(t)}})}s.native=function(o,r,e){return b(o,{endpoints:r,testingAllowInsecureLoopback:true,platform:"native",deviceKeyProvider:a$1(e),deviceIdProvider:async()=>{let t=await e.invoke("get_rtc_local_device_info");return String(t?.deviceId??"")},runtimeFactory:async t=>{let{createIpcClient:n}=await import('./ipcFactory-32R47AVK.js');return n(t,e)}})};export{s as OpenRTC,y as controlPlane};
+import {a}from'./chunk-BCGCJGIV.js';import {c}from'./chunk-4MLJXEVV.js';import {b}from'./chunk-2LATKLCC.js';import'./chunk-ZA44REGI.js';import'./chunk-WB66633N.js';import'./chunk-JPBW67B3.js';import'./chunk-2GX6GB6L.js';function s(i){let r=e=>`${e}:${i}`;return {getOrCreate:e=>c.getOrCreate(r(e)),delete:async e=>{await c.delete?.(r(e));},readSecureRecord:(e,o)=>c.readSecureRecord?.(r(e),o)??Promise.resolve(null),writeSecureRecord:(e,o,n)=>c.writeSecureRecord?.(r(e),o,n)??Promise.resolve(),deleteSecureRecord:(e,o)=>c.deleteSecureRecord?.(r(e),o)??Promise.resolve()}}function m(i,r,e){return new a(i,r,s(e))}function u(i,r,e={}){return b(i,{endpoints:r,testingAllowInsecureLoopback:true,platform:"web",...e.deviceId?{deviceIdProvider:async()=>e.deviceId}:{},...e.irohTestRelayUrl?{irohTestRelayUrl:e.irohTestRelayUrl}:{},runtimeFactory:async o=>{let{createWasmClient:n}=await import('./runtime/factories.js');return n(o)}})}export{u as OpenRTC,m as controlPlane};

package/dist/transport/index.d.ts

@@ -1,31 +1,20 @@
-import { c as ProtocolName, $ as RouteDescriptor, K as ITransport, a0 as ProtocolCapability, a1 as ProtocolCapabilityMap, z as PayloadCrypto, a2 as CryptoStreams } from '../ITransport-CjxCQ6q7.js';
-export { a3 as CryptoBiStream, a4 as RouteFamily, a5 as RouteKind } from '../ITransport-CjxCQ6q7.js';
+import { c as ProtocolName, aj as RouteDescriptor, ak as PayloadCrypto, al as CryptoStreams } from '../Connection-DZ5eP5hL.js';
+export { am as CryptoBiStream, an as RouteFamily, ao as RouteKind } from '../Connection-DZ5eP5hL.js';
 
 declare const TRANSPORT_LABELS: readonly ProtocolName[];
 declare function normalizeTransport(value: unknown): ProtocolName | undefined;
 declare function isBaseIroh(value: unknown): boolean;
 declare function isDirectIroh(value: unknown): boolean;
-declare function isOptionalTransport(value: unknown): boolean;
 declare function isWebRtc(value: unknown): boolean;
-declare function isIndependent(value: unknown): boolean;
 
 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 preferredProtocols(options?: {
-        runtime?: 'browser' | 'native' | 'any';
-        includePathLabels?: boolean;
-    }): ProtocolName[];
-    static assertProtocolAvailable(name: ProtocolName): void;
-}
-declare function preferredProtocols(options?: Parameters<typeof TransportFactory.preferredProtocols>[0]): ProtocolName[];
+declare function preferredProtocols(options?: {
+    runtime?: 'browser' | 'native' | 'any';
+    includePathLabels?: boolean;
+}): ProtocolName[];
 
 declare function isEncryptedPayload(payload: Uint8Array): boolean;
 declare function createSharedCrypto(key: Uint8Array, options?: {
@@ -52,4 +41,4 @@ declare function createKeyAgreement(randomBytes?: (byteLength: number) => Uint8A
 declare function deriveCryptoKey(localSecretKey: Uint8Array, remotePublicKey: Uint8Array, localNodeId: string, remoteNodeId: string): Uint8Array;
 declare function encodeKeyAgreement(publicKey: Uint8Array): KeyAgreementPayload;
 
-export { CryptoStreams, KEY_ALGORITHM, type KeyAgreementPayload, PUBLIC_KEY_BYTES, PayloadCrypto, ProtocolName, ROUTE_DESCRIPTORS, RouteDescriptor, TRANSPORT_LABELS, createCryptoStreams, createKeyAgreement, createSharedCrypto, deriveCryptoKey, encodeKeyAgreement, getRouteDescriptor, isBaseIroh, isDirectIroh, isEncryptedPayload, isIndependent, isOptionalTransport, isWebRtc, listRouteDescriptors, normalizeTransport, preferredProtocols };
+export { CryptoStreams, KEY_ALGORITHM, type KeyAgreementPayload, PUBLIC_KEY_BYTES, PayloadCrypto, ProtocolName, ROUTE_DESCRIPTORS, RouteDescriptor, TRANSPORT_LABELS, createCryptoStreams, createKeyAgreement, createSharedCrypto, deriveCryptoKey, encodeKeyAgreement, getRouteDescriptor, isBaseIroh, isDirectIroh, isEncryptedPayload, isWebRtc, listRouteDescriptors, normalizeTransport, preferredProtocols };

package/dist/transport/index.js

@@ -1 +1 @@
-export{e as KEY_ALGORITHM,d as PUBLIC_KEY_BYTES,f as createKeyAgreement,g as deriveCryptoKey,i as encodeKeyAgreement,c as preferredProtocols}from'../chunk-7BJKDBLP.js';export{o as TRANSPORT_LABELS,z as createCryptoStreams,y as createSharedCrypto,q as isBaseIroh,r as isDirectIroh,x as isEncryptedPayload,w as isIndependent,s as isOptionalTransport,t as isWebRtc,p as normalizeTransport}from'../chunk-2L6ULC32.js';export{a as ROUTE_DESCRIPTORS,e as getRouteDescriptor,f as listRouteDescriptors}from'../chunk-2SUSPEC4.js';
+export{g as KEY_ALGORITHM,f as PUBLIC_KEY_BYTES,c as createCryptoStreams,h as createKeyAgreement,b as createSharedCrypto,i as deriveCryptoKey,j as encodeKeyAgreement,a as isEncryptedPayload,e as preferredProtocols}from'../chunk-TYZS5LXQ.js';export{k as TRANSPORT_LABELS,m as isBaseIroh,n as isDirectIroh,o as isWebRtc,l as normalizeTransport}from'../chunk-OT7IPLZE.js';export{b as ROUTE_DESCRIPTORS,e as getRouteDescriptor,f as listRouteDescriptors}from'../chunk-OWKAJPOI.js';

package/dist/{types--jQzenZR.d.ts → types-BArEthJr.d.ts}

@@ -1,6 +1,5 @@
 import { PeerNamespace, ChannelNamespace, DiagnosticsNamespace, DeviceNamespace } from './coreClient.js';
-import { C as ChannelDescriptor } from './types-DDhMQkK8.js';
-import { P as PlutoIrohConfiguration, a as PlutoRTCConfiguration, b as PlutoMoQConfiguration, R as RouteOptimization, c as ProtocolName } from './ITransport-CjxCQ6q7.js';
+import { C as ChannelDescriptor, P as PlutoIrohConfiguration, a as PlutoRTCConfiguration, b as PlutoMoQConfiguration, R as RouteOptimization, c as ProtocolName } from './Connection-DZ5eP5hL.js';
 
 interface AuthProvider {
     /** Registered provider ID from the developer app capability manifest. */
@@ -105,7 +104,11 @@ interface UsageWarning extends UsageUpdate {
 interface Transports {
     iroh?: boolean | PlutoIrohConfiguration;
     webrtc?: boolean | PlutoRTCConfiguration;
-    /** Allow managed relay fallback. Defaults to true; set false for direct-only P2P. */
+    /**
+     * Allow relay mechanisms. Defaults to true; set false for direct-only P2P.
+     * The authenticated runtime tracks Iroh relay and managed TURN readiness
+     * independently; this option is intent, not proof that either is deployed.
+     */
     relay?: boolean;
     moq?: boolean | PlutoMoQConfiguration;
     ble?: boolean;
@@ -117,12 +120,6 @@ interface Transports {
     privacy?: 'direct' | 'relay-only';
     /** Optimize eligible routes for stability/cost or measured latency. */
     optimizeFor?: RouteOptimization;
-    /**
-     * 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;
     /** Exact route order. Unsupported routes are skipped, never treated as failures. */
     priority?: readonly ProtocolName[];
 }
@@ -143,9 +140,176 @@ interface Options {
 }
 type AccessMode = 'capability' | 'authenticated';
 type Delivery = 'reliable' | 'latest-state';
+interface PeerStreamOptions {
+    /** Registered application protocol used by the single incoming classifier. */
+    protocol: string;
+    timeoutMs?: number;
+}
+interface PeerBidirectionalStream {
+    readonly protocol: string;
+    readonly readable: ReadableStream<Uint8Array>;
+    readonly writable: WritableStream<Uint8Array>;
+}
+interface IncomingPeerBidirectionalStream extends PeerBidirectionalStream {
+    readonly peerId: string;
+}
+interface IncomingPeerUnidirectionalStream {
+    readonly peerId: string;
+    readonly protocol: string;
+    readonly readable: ReadableStream<Uint8Array>;
+}
+interface PeerDatagramDuplexStream {
+    readonly maxDatagramSize: number;
+    /** Drop received datagrams older than this many milliseconds; `null` disables expiry. */
+    incomingMaxAge: number | null;
+    /** Drop queued outgoing datagrams older than this many milliseconds; `null` disables expiry. */
+    outgoingMaxAge: number | null;
+    /** Bounded application receive queue. */
+    incomingMaxBufferedDatagrams: number;
+    /** Bounded application send queue. */
+    outgoingMaxBufferedDatagrams: number;
+    readonly readable: ReadableStream<Uint8Array>;
+    readonly writable: WritableStream<Uint8Array>;
+    getStats(): PeerDatagramStats;
+}
+interface PeerDatagramStats {
+    received: number;
+    sent: number;
+    bytesReceived: number;
+    bytesSent: number;
+    droppedIncoming: number;
+    droppedOutgoing: number;
+    expiredIncoming: number;
+    expiredOutgoing: number;
+    sendFailures: number;
+    incomingBufferedDatagrams: number;
+    outgoingBufferedDatagrams: number;
+}
+interface PeerStreamTransport {
+    createBidirectionalStream(options: PeerStreamOptions): Promise<PeerBidirectionalStream>;
+    createUnidirectionalStream(options: PeerStreamOptions): Promise<WritableStream<Uint8Array>>;
+    readonly incomingBidirectionalStreams: ReadableStream<IncomingPeerBidirectionalStream>;
+    readonly incomingUnidirectionalStreams: ReadableStream<IncomingPeerUnidirectionalStream>;
+    readonly datagrams: PeerDatagramDuplexStream;
+}
+type MediaKind = 'audio' | 'video';
+interface MediaTrackOptions {
+    streams?: readonly MediaStream[];
+    /** Browser codec preference. Web Audio edges default to PCM; other browser audio defaults to Opus. */
+    codec?: string;
+    bitrate?: number;
+}
+/** Bounded local monotonic-clock samples; this is not cross-peer latency. */
+interface MediaLatencySummary {
+    samples: number;
+    p50Ms: number;
+    p95Ms: number;
+    p99Ms: number;
+    maxMs: number;
+}
+interface MediaSenderStats {
+    publicationId: string;
+    mediaGeneration: number;
+    accepted: number;
+    /** Encoded chunks currently waiting on the protected logical stream. */
+    queued: number;
+    /** Encoded payload bytes currently waiting on the protected logical stream. */
+    queuedBytes: number;
+    /** Age of the oldest currently queued encoded payload. */
+    queuedAgeMs: number;
+    transmitted: number;
+    dropped: number;
+    bytes: number;
+    maxQueued: number;
+    maxQueuedBytes: number;
+    maxQueuedAgeMs: number;
+    /** Most recent asynchronous encoder or protected-stream failure, if any. */
+    lastError?: string;
+    encodeLatency: MediaLatencySummary;
+    protectedWriteLatency: MediaLatencySummary;
+}
+interface MediaReceiverStats {
+    publicationId: string;
+    mediaGeneration: number;
+    received: number;
+    decoded: number;
+    rendered: number;
+    dropped: number;
+    integrityFailures: number;
+    malformedFrames: number;
+    replayDrops: number;
+    /** Successful resumptions on a video keyframe after corruption or loss. */
+    videoRecoveries: number;
+    /** Whether dependent video is currently being discarded until a keyframe. */
+    awaitingKeyframe: boolean;
+    /** Longest local receive-side wait for a recovery keyframe. */
+    maxVideoRecoveryMs: number;
+    bytes: number;
+    decoderQueued: number;
+    maxDecoderQueued: number;
+    renderQueued: number;
+    maxRenderQueued: number;
+    receiveToDecodeLatency: MediaLatencySummary;
+    renderWriteLatency: MediaLatencySummary;
+}
+interface MediaIncomingDemuxStats {
+    /** Whether this connection's protected peer-stream channel listener is installed. */
+    registered: boolean;
+    /** Existing public peers known to this capability router. */
+    peers: number;
+    /** Rust logical connection identities bound to those peers. */
+    boundConnections: number;
+    /** Protected streams offered to this capability router. */
+    observed: number;
+    /** Streams claimed by an existing public peer and protocol handler. */
+    accepted: number;
+    /** Streams this capability correctly left for another capability router. */
+    declined: number;
+    /** Most recent identifier-free ownership decision. */
+    lastResolution: 'none' | 'connection' | 'remote-peer' | 'peer-alias' | 'unbound-connection';
+}
+interface MediaStats {
+    senders: readonly MediaSenderStats[];
+    receivers: readonly MediaReceiverStats[];
+    /** Bounded receiver setup/runtime failures for streams that never produced a receiver. */
+    incomingFailures: readonly string[];
+    /** Number of protected publication streams delivered by protocol dispatch. */
+    incomingProtocolStreams: number;
+    /** Transport-agnostic protected-stream ownership diagnostics. */
+    incomingDemux: MediaIncomingDemuxStats;
+}
+interface MediaSender {
+    readonly id: string;
+    readonly track: MediaStreamTrack | null;
+    replaceTrack(track: MediaStreamTrack | null): Promise<void>;
+    setEnabled(enabled: boolean): Promise<void>;
+    stop(): Promise<void>;
+    getStats(): Promise<MediaSenderStats>;
+}
+interface MediaReceiver {
+    readonly id: string;
+    readonly track: MediaStreamTrack;
+    getStats(): Promise<MediaReceiverStats>;
+}
+interface MediaTrackEvent {
+    readonly track: MediaStreamTrack;
+    readonly receiver: MediaReceiver;
+    readonly streams: readonly MediaStream[];
+}
+interface MediaConnection {
+    addTrack(track: MediaStreamTrack, options?: MediaTrackOptions): Promise<MediaSender>;
+    removeTrack(sender: MediaSender): Promise<void>;
+    onTrack(callback: (event: MediaTrackEvent) => void): () => void;
+    senders(): readonly MediaSender[];
+    receivers(): readonly MediaReceiver[];
+    getStats(): Promise<MediaStats>;
+}
 interface Connection {
+    /** Stable logical peer identity. It does not change when Rust replaces a physical connection or carrier. */
     readonly id: string;
     readonly peerId: string;
+    readonly streams: PeerStreamTransport;
+    readonly media: MediaConnection;
     send(message: unknown): Promise<void>;
     onMessage<T = unknown>(callback: (message: T) => void): () => void;
     onClose(callback: () => void): () => void;
@@ -232,6 +396,8 @@ interface SpaceOptions {
 interface RoomOptions {
     access?: AccessMode;
     membership?: 'ephemeral' | 'durable';
+    /** Use a new memory-only identity for this anonymous room client run. */
+    identity?: 'session';
     auth?: AuthProvider;
     maxPeers?: number;
     /**
@@ -241,6 +407,8 @@ interface RoomOptions {
     advancedFanout?: boolean;
 }
 interface TicketOptions {
+    /** Use a new memory-only identity for this ticket client run. */
+    identity?: 'session';
     maxPeers?: number;
     /** Requires the app manifest's advanced-fanout opt-in. */
     advancedFanout?: boolean;
@@ -292,4 +460,4 @@ interface Client {
     close(): Promise<void>;
 }
 
-export type { AttestationProvider as A, BotVerificationProvider as B, Client as C, DeviceOptions as D, EnrolledDevice as E, Options as O, Room as R, Space as S, Ticket as T, UsageUpdate as U, AuthProvider as a, Avenue as b, Channel as c, Connection as d, DeviceProfile as e, Devices as f, RoomOptions as g, SpaceOptions as h, State as i, TicketOptions as j, Transports as k, UsageWarning as l };
+export type { AccessMode as A, BotVerificationProvider as B, Client as C, Delivery as D, EnrolledDevice as E, State as F, TicketOptions as G, Transports as H, IncomingPeerBidirectionalStream as I, UsageUpdate as J, UsageWarning as K, MediaConnection as M, Options as O, PeerBidirectionalStream as P, Room as R, Space as S, Ticket as T, Usage as U, AttestationProvider as a, AuthProvider as b, Avenue as c, Channel as d, Channels as e, Connection as f, DeviceOptions as g, DeviceProfile as h, Devices as i, IncomingPeerUnidirectionalStream as j, MediaIncomingDemuxStats as k, MediaKind as l, MediaLatencySummary as m, MediaReceiver as n, MediaReceiverStats as o, MediaSender as p, MediaSenderStats as q, MediaStats as r, MediaTrackEvent as s, MediaTrackOptions as t, PeerDatagramDuplexStream as u, PeerDatagramStats as v, PeerStreamOptions as w, PeerStreamTransport as x, RoomOptions as y, SpaceOptions as z };