openrtc 2.4.0 → 2.5.2

package/dist/runtime/factories.d.ts

@@ -1,8 +1,8 @@
-import { c as RuntimeFactoryOptions, b as PlutoRuntimeAssembly } from '../assembly-By3UBQsE.js';
-import { N as NativeProjectionBroker, I as IpcRuntimeAdapter } from '../IpcRuntimeAdapter-Dduaxscj.js';
-import { Q as Device, K as ISignalingBackend, z as DiscoveryMode, B as AuthMode, E as SignalingMode, F as ClientOptions, H as ExplicitFileDataSendParams, ad as BrowserWasmRuntimeModule, _ as LocalDeviceInfo, O as RoomMember, ae as BrowserProtocolStore, af as NamespaceDescriptor, ag as IrohMutationReceipt, ah as IrohDocEntry, N as RuntimeIdentity, V as SignalingEnvelope, T as DeviceStatusSnapshot, g as PeerSessionSnapshot, a0 as BackendPeerBiStream, a1 as BackendPeerUniStream, a2 as PortableMediaPublish, a3 as PortableMediaPublicationStart, a4 as PortableMediaSample, a5 as PortableMediaChunk, a6 as PortableMediaControl, U as ManagedConnectionRecord, j as ResolvedPeerIdentity, W as DeviceEvent, X as DesiredPeerProjection, ai as CoreClientBridgeHost, a7 as NativeConnectParams, a8 as NativeConnectResult, Y as SignalingSession, Z as SessionEvent, a9 as BackendConnectionState } from '../Connection-DZ5eP5hL.js';
-import { R as RuntimeCapabilities } from '../capabilities-B2mHv_H7.js';
-import { R as RuntimeBridgeOptions } from '../DelegatingRuntimeAdapter-4cgiIWMN.js';
+import { c as RuntimeFactoryOptions, b as PlutoRuntimeAssembly } from '../assembly-LOFcpH3S.js';
+import { N as NativeProjectionBroker, I as IpcRuntimeAdapter } from '../IpcRuntimeAdapter-Ddx0MtSI.js';
+import { X as Device, U as ISignalingBackend, K as DiscoveryMode, N as AuthMode, O as SignalingMode, Q as ClientOptions, T as ExplicitFileDataSendParams, ai as BrowserWasmRuntimeModule, a3 as LocalDeviceInfo, W as RoomMember, aj as BrowserProtocolStore, ak as NamespaceDescriptor, al as IrohMutationReceipt, am as IrohDocEntry, V as RuntimeIdentity, _ as SignalingEnvelope, Y as DeviceStatusSnapshot, k as PeerSessionSnapshot, a5 as BackendPeerBiStream, a6 as BackendPeerUniStream, a7 as PortableMediaPublish, a8 as PortableMediaPublicationStart, a9 as PortableMediaSample, aa as PortableMediaChunk, ab as PortableMediaControl, Z as ManagedConnectionRecord, n as ResolvedPeerIdentity, b as RoomArchitectureSnapshot, c as RoomAuthorityAssignment, an as CoordinationSignalingStore, ao as ManagedRoomMessage, $ as DeviceEvent, a0 as DesiredPeerProjection, ap as CoreClientBridgeHost, ac as NativeConnectParams, ad as NativeConnectResult, a1 as SignalingSession, a2 as SessionEvent, ae as BackendConnectionState } from '../Connection-CTpuImO-.js';
+import { R as RuntimeCapabilities } from '../capabilities-CmzzxSvW.js';
+import { R as RuntimeBridgeOptions } from '../DelegatingRuntimeAdapter-D67Ozqo3.js';
 import { P as PlutoIpcBridge } from '../ipc-DgzKqHH3.js';
 
 interface NativeTrustToken {
@@ -16,6 +16,44 @@ type RawDeviceDoc = Device & {
     tag?: string;
 };
 
+/** Public verification material plus an opaque Rust/WASM signer handle. */
+interface WasmPublisherSignerDescriptor {
+    handle: string;
+    publicKey: Uint8Array;
+}
+interface ResolvedWasmBroadcastGrant {
+    token: string;
+    issuerPublicKey: Uint8Array;
+    signBindingChallenge(message: Uint8Array): Promise<Uint8Array>;
+}
+interface BrowserBroadcastWasmBindings {
+    __createOpenRtcBroadcastPublisherSigner(): WasmPublisherSignerDescriptor;
+    __prepareOpenRtcBroadcastGrant(token: string, issuerPublicKey: Uint8Array, nowMs: number): {
+        handle: string;
+        signingBytes: Uint8Array;
+        expiresAtMs: number;
+    };
+    __openOpenRtcBroadcast(token: string, issuerPublicKey: Uint8Array, bindingChallengeHandle: string, bindingSignature: Uint8Array, publisherSignerHandle: string | undefined, nowMs: number): unknown;
+    __releaseOpenRtcBroadcastPublisherSigner(handle: string): boolean;
+}
+/**
+ * Private browser publisher boundary used by the managed broadcast host.
+ *
+ * Rust/WASM owns the signing key. JavaScript receives only a public key and an
+ * opaque handle, has no sign operation, and cannot export private key bytes.
+ * The shared Rust core canonicalizes and verifies every signed media group.
+ */
+declare class BrowserBroadcastWasmPublisher {
+    private readonly wasm;
+    readonly verificationKey: Uint8Array;
+    private handle;
+    private constructor();
+    static create(wasm: BrowserBroadcastWasmBindings): BrowserBroadcastWasmPublisher;
+    /** Open a publisher grant previously bound to `verificationKey`. */
+    open(grant: ResolvedWasmBroadcastGrant, nowMs?: number): Promise<unknown>;
+    close(): void;
+}
+
 type WasmBridgeOptions = RuntimeBridgeOptions;
 /**
  * WasmBridge is the browser host wrapper over the Rust/WASM runtime.
@@ -58,6 +96,10 @@ declare class WasmBridge implements ISignalingBackend {
         coordinationGateway?: ClientOptions['coordinationGateway'];
         coordinationAvenueOverride?: ClientOptions['coordinationAvenueOverride'];
         coordinationRoomGossipFanout?: ClientOptions['coordinationRoomGossipFanout'];
+        coordinationRoomArchitecture?: ClientOptions['coordinationRoomArchitecture'];
+        coordinationDevicePublicKeyX?: ClientOptions['coordinationDevicePublicKeyX'];
+        coordinationDeviceSign?: ClientOptions['coordinationDeviceSign'];
+        initialAutoConnectExcludedDeviceIds?: ClientOptions['initialAutoConnectExcludedDeviceIds'];
         attestationTokenProvider?: ClientOptions['attestationTokenProvider'];
         coordinationPlatformType?: string;
         storagePrefix?: string;
@@ -85,6 +127,7 @@ declare class WasmBridge implements ISignalingBackend {
     private readonly coordinationHost;
     /** Test seam only; production gateway ownership remains in coordinationHost. */
     private browserCoordinationSignaling;
+    private effectiveRoomArchitecture;
     private lastObservedFirebaseUserId;
     private sessionReaders;
     protected authContext: {
@@ -171,6 +214,8 @@ declare class WasmBridge implements ISignalingBackend {
         userId?: string | null;
     }): Promise<void>;
     setWasmClient(client: any): void;
+    /** Private managed-broadcast edge. Rust/WASM retains the private signer. */
+    createBroadcastPublisher(): Promise<BrowserBroadcastWasmPublisher>;
     initializePersistentIrohProtocols(store: BrowserProtocolStore): Promise<void>;
     createPersistentIrohNamespace(generation: number, shareRevision: number): Promise<NamespaceDescriptor>;
     importPersistentIrohTicket(ticket: string, generation: number, shareRevision: number): Promise<string>;
@@ -193,6 +238,19 @@ declare class WasmBridge implements ISignalingBackend {
     protected normalizeDevice(raw: Record<string, any>, fallbackId?: string): Device;
     normalizeDeviceRecord(raw: Record<string, any>, fallbackId?: string): Device;
     getResolvedWebLogicalDeviceId(): string;
+    encodeSparseFanoutMessage(capability: string, payload: Uint8Array): Promise<Uint8Array>;
+    acceptSparseFanoutMessage(capability: string, sourcePeerId: string, payload: Uint8Array): Promise<{
+        payload: Uint8Array;
+        authorDeviceId: string;
+        authorPeerId: string;
+        topologyRevision: number;
+        hop: number;
+        forwardPeerIds: string[];
+        forwardPeerLimit: number;
+        forwardQueueCapacity: number;
+        forward?: Uint8Array;
+    }>;
+    recordSparseFanoutForwardQueueDrop(capability: string, count: number): Promise<void>;
     private normalizeDeviceStatusSnapshot;
     private normalizePeerSessionSnapshot;
     private toBackendConnectionStateFromPeerSession;
@@ -245,6 +303,17 @@ declare class WasmBridge implements ISignalingBackend {
     resolvePeerRecords(id: string): Promise<ManagedConnectionRecord[]>;
     resolvePeerIdentity(id: string): Promise<ResolvedPeerIdentity>;
     onDevicesChange(callback: (devices: Device[]) => void, excludeNodeId?: string): () => void;
+    onRoomArchitectureChange(callback: (snapshot: RoomArchitectureSnapshot) => void): () => void;
+    onRoomAuthorityAssignmentChange(callback: (assignment: RoomAuthorityAssignment | null) => void): () => void;
+    publishAuthorityAssignment(input: Parameters<NonNullable<CoordinationSignalingStore['publishAuthorityAssignment']>>[0]): Promise<void>;
+    publishManagedRoomMessage(input: {
+        messageId: string;
+        channel: string;
+        priority: 0 | 1 | 2 | 3;
+        zoneId?: string;
+        payload: Uint8Array;
+    }): Promise<void>;
+    onManagedRoomMessage(callback: (message: ManagedRoomMessage) => void): () => void;
     subscribeDevices(userId: string): Promise<ReadableStream<DeviceEvent[]>>;
     startAutoConnect(userId: string, localDeviceId: string): Promise<void>;
     startAutoConnectOnce(userId: string, localDeviceId: string): Promise<void>;
@@ -259,7 +328,7 @@ declare class WasmBridge implements ISignalingBackend {
     private escalateManagedApplicationRoute;
     connectToDevice(params: NativeConnectParams): Promise<NativeConnectResult>;
     forceReconnect(): void;
-    startPresenceLoop(userId: string, localNodeId: string, deviceName: string, ticket: string, metadata?: string): void;
+    startPresenceLoop(userId: string, localNodeId: string, deviceName: string, ticket: string, metadata?: string): Promise<void>;
     private ensureSpaceNamespaceIdPromise;
     createSession(session: SignalingSession): Promise<void>;
     updateSession(sessionId: string, updateData: any): Promise<void>;

package/dist/runtime/factories.js

@@ -1 +1 @@
-import {a as a$2}from'../chunk-5XOLKH66.js';import {a}from'../chunk-P2SHJMS3.js';import {s}from'../chunk-6OFAKLDB.js';import'../chunk-XEHBTMJQ.js';import'../chunk-GNW63SM6.js';import'../chunk-TYZS5LXQ.js';import'../chunk-OT7IPLZE.js';import'../chunk-AJQVMVYW.js';import'../chunk-72NEEJQG.js';import'../chunk-WB66633N.js';import'../chunk-JPBW67B3.js';import {a as a$1}from'../chunk-MI3ZMVPK.js';import'../chunk-OWKAJPOI.js';import'../chunk-2GX6GB6L.js';async function l(e){let t=a$1(e),{WasmBridge:o}=await import('../WasmBridge-3W2HHADU.js');return a$2(t,new o(t))}function y(e,t,o=new a){let m=a$1(e);return a$2(m,new s({...m,bridge:t,projectionBroker:o}))}export{y as createIpcClient,l as createWasmClient};
+import {a as a$2}from'../chunk-EFTDXE6M.js';import {s}from'../chunk-FB5M6GIW.js';import'../chunk-BGWJHPBC.js';import'../chunk-6Q2LAXM4.js';import'../chunk-AAZPQQXX.js';import {a as a$1}from'../chunk-XTYALGJN.js';import'../chunk-TYZS5LXQ.js';import'../chunk-OT7IPLZE.js';import'../chunk-OWKAJPOI.js';import {a}from'../chunk-VTYVIKTM.js';import'../chunk-72NEEJQG.js';import'../chunk-CNAW5BZ3.js';import'../chunk-DUY34MGT.js';import'../chunk-CCCYE3XN.js';import'../chunk-N6LGTNUI.js';import'../chunk-JPBW67B3.js';import'../chunk-2GX6GB6L.js';async function l(e){let t=a$1(e),{WasmBridge:o}=await import('../WasmBridge-LWMCETW4.js');return a$2(t,new o(t))}function y(e,t,o=new a){let m=a$1(e);return a$2(m,new s({...m,bridge:t,projectionBroker:o}))}export{y as createIpcClient,l as createWasmClient};

package/dist/runtime/index.d.ts

@@ -1,15 +1,15 @@
-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 { a as PeerReconciliationStats } from '../assembly-LOFcpH3S.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-LOFcpH3S.js';
 import { Client as Client$1 } from '../coreClient.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';
+import { c as Avenue } from '../types-Cyc-mPjk.js';
+import { aB as SignalingOptions, U as ISignalingBackend, V as RuntimeIdentity, W as RoomMember, _ as SignalingEnvelope, a1 as SignalingSession, X as Device, a0 as DesiredPeerProjection, ae as BackendConnectionState, ay as AppLimits, G as GrantScope, j as Connection, aC as JoinRoomOptions, aD as ChannelMetadata, as as CryptoStreams, aE as RoomCreationMode, Q as ClientOptions, ar as PayloadCrypto, K as DiscoveryMode, aF as ProtocolCapabilityMap, aG as ScanningLoopOptions, aH as ScanningLoopHandle, aI as RuntimeBootstrapOptions, aJ as RuntimeBootstrapResult, aK as ApplicationPayloadReadinessOptions, aL as ManagedApplicationRouteOptions, aM as PeerState, aN as PeerScope, aO as PeerHealth, aP as ChannelDescriptor, aQ as JoinRequest, ac as NativeConnectParams, ad as NativeConnectResult, az as ConnectionTarget, A as RawConnection } from '../Connection-CTpuImO-.js';
+export { aR as AutoConnectPolicy, aj as BrowserProtocolStore, C as ChannelDescriptor, aS as ChannelFraming, t as ConnectionEvent, r as ConnectionState, aT as ConnectionStatus, v as DeviceConnectOptions, aU as DevicePresence, z as DeviceProfile, D as DeviceStatus, I as IncomingStream, am as IrohDocEntry, al as IrohMutationReceipt, J as JoinRoomOptions, L as LocalDeviceInfo, M as ManagedOptions, u as ManagedSession, ak as NamespaceDescriptor, aV as PayloadRouteOptions, i as PeerConnectOptions, aW as PeerLifecycleStatus, l as PeerReadiness, aX as PeerSessionSnapshot, o as PeerStreamOptions, aa as PortableMediaChunk, ab as PortableMediaControl, a8 as PortableMediaPublicationStart, a7 as PortableMediaPublish, a9 as PortableMediaSample, aA as PresenceLoopOptions, aY as PresencePolicy, s as ReadinessOptions, aZ as RuntimeAuthContext, aw as RuntimeAuthIdentity, H as RuntimeClientOptions, p as RuntimeDevice, m as RuntimePeerHealth, a_ as RuntimePeerScope, h as RuntimePeerState, B as RuntimeRoomMember, ax as RuntimeSession, S as ScopedChannelOptions, q as ScopedLogicalChannel, a$ as SessionKind, b0 as SessionPlatform } from '../Connection-CTpuImO-.js';
+import { R as RuntimeCapabilities } from '../capabilities-CmzzxSvW.js';
+export { B as BROWSER_CAPABILITIES, a as CapabilityHost, b as CapabilityMaturity, C as CapabilityProfile, N as NATIVE_CAPABILITIES, c as NativeRuntimeStatus, P as ProductCapabilityMaturity, d as RuntimeAdapterKind, T as TransportStatus, e as browserCapabilities, f as capabilityProfile, g as cloneCapabilities, s as statusCapabilities } from '../capabilities-CmzzxSvW.js';
 export { DeviceActiveOptions, isDeviceActive, isDeviceConnectable, isDeviceRoutable } from './device-status.js';
-export { a as IpcAdapterOptions, I as IpcRuntimeAdapter } from '../IpcRuntimeAdapter-Dduaxscj.js';
+export { a as IpcAdapterOptions, I as IpcRuntimeAdapter } from '../IpcRuntimeAdapter-Ddx0MtSI.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';
+import '../DelegatingRuntimeAdapter-D67Ozqo3.js';
 
 declare class Signaling {
     private readonly appTag;
@@ -52,7 +52,7 @@ declare class Signaling {
     startAutoConnect(userId: string, localDeviceId: string): void;
     submitDesiredPeerProjection(revision: number, peers: DesiredPeerProjection[]): Promise<void>;
     notifyDisconnectRequested(remoteNodeId: string): void;
-    startPresenceLoop(userId: string, localNodeId: string, deviceName: string, ticket: string, metadata?: string): void;
+    startPresenceLoop(userId: string, localNodeId: string, deviceName: string, ticket: string, metadata?: string): Promise<void>;
     forceReconnect(): void;
     isConnected(nodeId: string): Promise<boolean>;
     getConnectionStates(): Promise<BackendConnectionState[]>;
@@ -120,6 +120,7 @@ type IncomingStreamEvent = {
     protocolHint?: ProtocolHint;
     channel?: ChannelMetadata | null;
     applicationAuthorized?: boolean;
+    admissionCandidate?: boolean;
     applicationCrypto?: CryptoStreams;
     invalid?: boolean;
 };

package/dist/runtime/index.js

@@ -1 +1 @@
-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';
+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-FB5M6GIW.js';import'../chunk-BGWJHPBC.js';import'../chunk-6Q2LAXM4.js';export{q as BROWSER_CAPABILITIES,r as NATIVE_CAPABILITIES,o as RUNTIME_POLICY,t as browserCapabilities,v as capabilityProfile,s as cloneCapabilities,p as getRuntimePolicy,h as logTeardownTrace,d as openRtcDebug,c as openRtcDebugEnabled,e as openRtcDebugInfo,f as openRtcDebugLog,u as statusCapabilities}from'../chunk-AAZPQQXX.js';import'../chunk-XTYALGJN.js';import'../chunk-TYZS5LXQ.js';import'../chunk-OT7IPLZE.js';import'../chunk-OWKAJPOI.js';export{a as classifyIpcFailure,b as isIpcUnavailable}from'../chunk-72NEEJQG.js';import'../chunk-CNAW5BZ3.js';export{c as runtimeFromCapability}from'../chunk-TZLNKQNJ.js';import'../chunk-ZA44REGI.js';import'../chunk-LLZT3MR6.js';import'../chunk-DUY34MGT.js';import'../chunk-CCCYE3XN.js';import'../chunk-N6LGTNUI.js';import'../chunk-JPBW67B3.js';import'../chunk-2GX6GB6L.js';

package/dist/server-browser.d.ts

@@ -0,0 +1,14 @@
+export { AuthorityAssignmentInput, AuthorityInterestAssignment, AuthorityServiceGrant, AuthorityServiceGrantRequest, Ed25519Signer } from './service-node.js';
+import './types-Cyc-mPjk.js';
+import './coreClient.js';
+import './assembly-LOFcpH3S.js';
+import './Connection-CTpuImO-.js';
+import './capabilities-CmzzxSvW.js';
+
+/** Browser export for `openrtc/server`; secret-bearing helpers are unavailable. */
+
+declare class AuthorityServiceControlPlane {
+    constructor();
+}
+
+export { AuthorityServiceControlPlane };

package/dist/server-browser.js

@@ -0,0 +1 @@
+var e=class{constructor(){throw new Error("[OpenRTC] openrtc/server is unavailable in browsers; request a delegated grant from your backend.")}};export{e as AuthorityServiceControlPlane};

package/dist/server.d.ts

@@ -0,0 +1,44 @@
+import { Ed25519Signer, AuthorityServiceGrantRequest, AuthorityServiceGrant, AuthorityAssignmentInput, AuthorityInterestAssignment, DelegatedAuthorityGrantRequest } from './service-node.js';
+import './types-Cyc-mPjk.js';
+import './coreClient.js';
+import './assembly-LOFcpH3S.js';
+import './Connection-CTpuImO-.js';
+import './capabilities-CmzzxSvW.js';
+
+/** Secret-bearing Node/server helpers. Do not import this entrypoint in browsers. */
+
+interface AuthorityServiceOptions {
+    apiKey: string;
+    secretKey: string;
+    serviceId: string;
+    generation: number;
+    shardIds: string[];
+    deviceId: string;
+    deviceSigner: Ed25519Signer;
+    assignmentSigner: Ed25519Signer;
+    endpoint?: string;
+    fetch?: typeof globalThis.fetch;
+}
+/** Direct secret-backed grant issuer for a trusted Node/server process. */
+declare class AuthorityServiceControlPlane {
+    private readonly authority;
+    constructor(options: AuthorityServiceOptions);
+    requestGrant(input: AuthorityServiceGrantRequest): Promise<AuthorityServiceGrant>;
+    signAssignment(input: AuthorityAssignmentInput): Promise<{
+        assignment: AuthorityInterestAssignment;
+        signature: string;
+    }>;
+    devicePublicKey(): Promise<{
+        kty: "OKP";
+        crv: "Ed25519";
+        x: string;
+    }>;
+    signDeviceBytes(payload: Uint8Array): Promise<string>;
+    /**
+     * Adapt this trusted issuer to `openrtc/service-node` in Node. Browser
+     * applications must call their own authenticated backend instead.
+     */
+    grantIssuer(): (request: DelegatedAuthorityGrantRequest) => Promise<AuthorityServiceGrant>;
+}
+
+export { AuthorityAssignmentInput, AuthorityInterestAssignment, AuthorityServiceControlPlane, AuthorityServiceGrant, AuthorityServiceGrantRequest, type AuthorityServiceOptions, Ed25519Signer };

package/dist/server.js

@@ -0,0 +1,2 @@
+import {a}from'./chunk-J7NBMQQA.js';import'./chunk-TZLNKQNJ.js';import'./chunk-ZA44REGI.js';import'./chunk-LLZT3MR6.js';import'./chunk-DUY34MGT.js';import'./chunk-CCCYE3XN.js';import'./chunk-N6LGTNUI.js';import'./chunk-JPBW67B3.js';import'./chunk-2GX6GB6L.js';function y(n){let e=new URL(n??"https://api.openrtc.app"),t=e.protocol==="http:"&&["127.0.0.1","localhost","::1"].includes(e.hostname.toLowerCase());if(e.protocol!=="https:"&&!t||e.username||e.password||e.search||e.hash)throw new TypeError("[OpenRTC] authority control-plane endpoint is invalid.");return e.toString().replace(/\/$/,"")}function h(){if(typeof document<"u"||typeof window<"u")throw new Error("[OpenRTC] openrtc/server is unavailable in browsers; use openrtc/service-node with a delegated grant.")}var c=class{constructor(e){h();let t=e.secretKey?.trim()??"";if(!/^sk_(?:live|test)_[A-Za-z0-9_-]+$/.test(t))throw new TypeError("[OpenRTC] secretKey is invalid.");let i=e.fetch??globalThis.fetch;if(typeof i!="function")throw new TypeError("[OpenRTC] a Fetch-compatible implementation is required.");let u=y(e.endpoint);this.authority=new a({apiKey:e.apiKey,serviceId:e.serviceId,generation:e.generation,shardIds:e.shardIds,deviceId:e.deviceId,deviceSigner:e.deviceSigner,assignmentSigner:e.assignmentSigner,grantIssuer:async s=>{let r=await i(`${u}/v2/developer/authority/grants`,{method:"POST",headers:{authorization:`Bearer ${t}`,"content-type":"application/json","x-openrtc-idempotency-key":s.idempotencyKey},body:JSON.stringify(s.body)});if(!r.ok){let o=await r.json().catch(()=>null),d=typeof o?.error=="string"?o.error.slice(0,256):`HTTP ${r.status}`;throw new Error(`[OpenRTC] authority service grant failed: ${d}`)}return r.json()}});}requestGrant(e){return this.authority.requestGrant(e)}signAssignment(e){return this.authority.signAssignment(e)}devicePublicKey(){return this.authority.devicePublicKey()}signDeviceBytes(e){return this.authority.signDeviceBytes(e)}grantIssuer(){return async e=>{let t=e.body;return this.requestGrant({roomId:String(t.avenue?.id??""),runtimeInstanceId:String(t.runtimeInstanceId??""),ticketFingerprint:String(t.ticketFingerprint??""),maxPeers:typeof t.maxPeers=="number"?t.maxPeers:void 0,refreshGrant:typeof t.refreshGrant=="string"?t.refreshGrant:void 0,features:typeof t.features=="object"&&t.features?t.features:void 0})}}};
+export{c as AuthorityServiceControlPlane};

package/dist/service-node.d.ts

@@ -0,0 +1,156 @@
+import { C as Client, X as Room, r as Connection } from './types-Cyc-mPjk.js';
+import './coreClient.js';
+import './assembly-LOFcpH3S.js';
+import './Connection-CTpuImO-.js';
+import './capabilities-CmzzxSvW.js';
+
+/** Browser-safe and Node-host-neutral developer service-node facade. */
+
+interface Ed25519Signer {
+    publicJwk(): JsonWebKey | Promise<JsonWebKey>;
+    sign(payload: Uint8Array): Uint8Array | Promise<Uint8Array>;
+}
+interface AuthorityServiceOptions {
+    apiKey: string;
+    /**
+     * App-backend delegation. Browser code must call a trusted developer
+     * backend here; it must never close over or embed an `sk_*` secret.
+     */
+    grantIssuer: AuthorityGrantIssuer;
+    serviceId: string;
+    generation: number;
+    shardIds: string[];
+    deviceId: string;
+    deviceSigner: Ed25519Signer;
+    assignmentSigner: Ed25519Signer;
+}
+interface DelegatedAuthorityGrantRequest {
+    apiKey: string;
+    idempotencyKey: string;
+    body: Record<string, unknown>;
+}
+type AuthorityGrantIssuer = (request: DelegatedAuthorityGrantRequest) => Promise<unknown>;
+interface AuthorityServiceGrantRequest {
+    roomId: string;
+    runtimeInstanceId: string;
+    ticketFingerprint: string;
+    /** Total room members, including services; 1..50, limited further by app policy. */
+    maxPeers?: number;
+    refreshGrant?: string;
+    features?: Partial<{
+        irohRelay: boolean;
+        managedTurn: boolean;
+        moq: boolean;
+        ble: boolean;
+    }>;
+}
+interface AuthorityServiceGrant {
+    protocolVersion: 2;
+    gatewayUrl: string;
+    routeKey: string;
+    token: string;
+    expiresAtMs: number;
+    avenue: {
+        kind: 'room';
+        id: string;
+    };
+    maxPeers: number;
+    architecture: 'authority';
+    roomAuthority: {
+        serviceId: string;
+        generation: number;
+        shardIds: string[];
+        assignmentPublicKeyJwk: {
+            kty: 'OKP';
+            crv: 'Ed25519';
+            x: string;
+        };
+    };
+}
+interface AuthorityInterestAssignment {
+    policyVersion: 'room-authority-assignment-v1';
+    serviceId: string;
+    generation: number;
+    revision: number;
+    subjectDeviceId: string;
+    shardId: string;
+    priorityDeviceIds: string[];
+    relevantEntityIds: string[];
+    issuedAtMs: number;
+    expiresAtMs: number;
+}
+interface AuthorityAssignmentInput {
+    revision: number;
+    subjectDeviceId: string;
+    shardId: string;
+    priorityDeviceIds?: string[];
+    relevantEntityIds?: string[];
+    ttlMs?: number;
+}
+interface ServiceNodeOptions extends AuthorityServiceOptions {
+    /** Browser uses WASM with delegated grants; `openrtc/node` uses the bundled Rust host. */
+    client: Client;
+    maxPeers?: number;
+    irohRelay?: boolean;
+}
+interface ServiceNodeConnectionEvent {
+    room: ServiceNodeRoom;
+    connection: Connection;
+}
+interface ServiceNodeRoom extends Room {
+    publishAssignment(input: AuthorityAssignmentInput): Promise<AuthorityInterestAssignment>;
+}
+/**
+ * Data-only server boundary for service grant issuance and signed AOI input.
+ * It does not own sockets, retries, topology, or transport selection.
+ */
+declare class DelegatedAuthorityService {
+    private readonly apiKey;
+    private readonly applicationTag;
+    private readonly grantIssuer;
+    private readonly serviceId;
+    private readonly generation;
+    private readonly shardIds;
+    private readonly deviceId;
+    private readonly deviceSigner;
+    private readonly assignmentSigner;
+    constructor(options: AuthorityServiceOptions);
+    requestGrant(input: AuthorityServiceGrantRequest): Promise<AuthorityServiceGrant>;
+    devicePublicKey(): Promise<{
+        kty: 'OKP';
+        crv: 'Ed25519';
+        x: string;
+    }>;
+    assignmentPublicKey(): Promise<{
+        kty: 'OKP';
+        crv: 'Ed25519';
+        x: string;
+    }>;
+    signDeviceBytes(payload: Uint8Array): Promise<string>;
+    signAssignment(input: AuthorityAssignmentInput): Promise<{
+        assignment: AuthorityInterestAssignment;
+        signature: string;
+    }>;
+}
+/**
+ * Familiar application server facade. It handles application events only;
+ * OpenRTC's Rust/WASM owner still controls admission, dialing, retry, routes,
+ * and carrier switching.
+ */
+declare class ServiceNode {
+    private readonly options;
+    private readonly authority;
+    private readonly rooms;
+    private readonly connectionListeners;
+    private readonly connectionCleanups;
+    private closed;
+    constructor(options: ServiceNodeOptions);
+    listen(roomId: string): Promise<ServiceNodeRoom>;
+    onConnection(listener: (event: ServiceNodeConnectionEvent) => void): () => void;
+    close(): Promise<void>;
+    private openRoom;
+    private evictRoom;
+    private attachConnectionListener;
+}
+
+export { type AuthorityAssignmentInput, type AuthorityGrantIssuer, type AuthorityInterestAssignment, type AuthorityServiceGrant, type AuthorityServiceGrantRequest, type AuthorityServiceOptions, type DelegatedAuthorityGrantRequest, DelegatedAuthorityService, type Ed25519Signer, ServiceNode, type ServiceNodeConnectionEvent, type ServiceNodeOptions, type ServiceNodeRoom };

package/dist/service-node.js

@@ -0,0 +1 @@
+export{a as DelegatedAuthorityService,b as ServiceNode}from'./chunk-J7NBMQQA.js';import'./chunk-TZLNKQNJ.js';import'./chunk-ZA44REGI.js';import'./chunk-LLZT3MR6.js';import'./chunk-DUY34MGT.js';import'./chunk-CCCYE3XN.js';import'./chunk-N6LGTNUI.js';import'./chunk-JPBW67B3.js';import'./chunk-2GX6GB6L.js';

package/dist/testing/native.d.ts

@@ -1,10 +1,10 @@
-import { O as Options, C as Client } from '../types-BArEthJr.js';
+import { O as Options, C as Client } from '../types-Cyc-mPjk.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';
+import '../assembly-LOFcpH3S.js';
+import '../Connection-CTpuImO-.js';
+import '../capabilities-CmzzxSvW.js';
 
 declare function OpenRTC(options: Options, endpoints: Endpoints, bridge: PlutoIpcBridge): Client;
 

package/dist/testing/native.js

@@ -1 +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};
+import {a as a$1}from'../chunk-VFDCIEP6.js';import {a}from'../chunk-VTYVIKTM.js';import'../chunk-NDR2ANQB.js';import {i}from'../chunk-TZLNKQNJ.js';import'../chunk-ZA44REGI.js';import'../chunk-LLZT3MR6.js';import'../chunk-DUY34MGT.js';import'../chunk-CCCYE3XN.js';import'../chunk-N6LGTNUI.js';import'../chunk-JPBW67B3.js';import'../chunk-2GX6GB6L.js';function v(c,p,e){let o=new a;return i(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-PDVLUG2W.js');return a(t,e,o)}})}export{v as OpenRTC};

package/dist/testing.d.ts

@@ -1,9 +1,9 @@
-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 { R as RoomArchitectureMode, ag as CoordinationGatewayGrantRequest, ah as CoordinationGatewayGrant } from './Connection-CTpuImO-.js';
+import { a as AttestationProvider, b as AuthProvider, B as BotVerificationProvider, e as BroadcastGrant, d as BroadcastCreateOptions, f as BroadcastInvite, g as BroadcastInviteOptions, D as Delivery, t as DeviceProfile, O as Options, C as Client } from './types-Cyc-mPjk.js';
 import { E as Endpoints } from './protocol-BSBjMb7p.js';
 import './coreClient.js';
-import './assembly-By3UBQsE.js';
-import './capabilities-B2mHv_H7.js';
+import './assembly-LOFcpH3S.js';
+import './capabilities-CmzzxSvW.js';
 
 interface DeviceProof {
     publicKeyJwk: JsonWebKey;
@@ -14,6 +14,8 @@ interface DeviceProof {
 interface DeviceKey {
     readonly publicKeyJwk: JsonWebKey;
     readonly thumbprint: string;
+    /** Signs Rust-canonical protocol bytes without exporting private key material. */
+    sign(message: Uint8Array): Promise<string>;
     proof(challenge: (nonce: string, issuedAt: number) => string): Promise<DeviceProof>;
 }
 interface DeviceKeyProvider {
@@ -80,8 +82,37 @@ declare class ControlPlane {
     private authEpoch;
     dispose(): void;
     private key;
+    /** Public half of the existing platform-issued device signer. */
+    deviceSigningPublicKey(): Promise<JsonWebKey>;
+    signDeviceBytes(message: Uint8Array): Promise<string>;
+    /**
+     * Resolve one opaque grant into a private provider allocation. The public
+     * grant is only a signed, device-bound authorization; relay credentials
+     * are returned solely to the private broadcast mechanics host.
+     */
+    resolveBroadcastAccess(grant: string, publicationVerifyingKey?: Uint8Array): Promise<{
+        token: string;
+        issuerPublicKey: Uint8Array;
+        signBindingChallenge(message: Uint8Array): Promise<Uint8Array>;
+        relay: {
+            relayUrl: string;
+            token: string;
+            namespace: string;
+        };
+    }>;
+    /** Authenticated owner operations. The server performs the atomic hard
+     * reservation before minting a grant or allocating provider capacity. */
+    manageBroadcast(input: {
+        action: 'create' | 'invite' | 'accept' | 'renew' | 'revoke' | 'leave' | 'close';
+        deviceId: string;
+        auth: AuthProvider;
+        grant?: BroadcastGrant;
+        create?: BroadcastCreateOptions;
+        invite?: BroadcastInvite;
+        invitation?: BroadcastInviteOptions;
+    }): Promise<BroadcastGrant | BroadcastInvite | undefined>;
     private post;
-    capability(kind: 'space' | 'room' | 'ticket', id: string, maxPeers?: number, advancedFanout?: boolean): Promise<CredentialSource>;
+    capability(kind: 'space' | 'room' | 'ticket', id: string, maxPeers?: number, advancedFanout?: boolean, architecture?: RoomArchitectureMode, roomDelivery?: Delivery): Promise<CredentialSource>;
     deviceCertificate(auth: AuthProvider, deviceId: string, avenue?: CoordinationGatewayGrantRequest['avenue'], profile?: DeviceProfile, rejected?: AuthenticatedDeviceCertificate): Promise<{
         source: CredentialSource;
         principalId: string;
@@ -106,6 +137,8 @@ declare class ControlPlane {
     grantProvider(source: CredentialSource, input?: {
         maxPeers?: number;
         features?: Record<string, boolean>;
+        architecture?: RoomArchitectureMode;
+        roomDelivery?: Delivery;
         deviceProfile?: Pick<DeviceProfile, 'name' | 'platform'>;
         /**
          * Keeps the transport/admission credential relay synchronized
@@ -128,6 +161,8 @@ declare function controlPlane(apiKey: string, endpoints: Endpoints, keyNamespace
 declare function OpenRTC(options: Options, endpoints: Endpoints, testing?: {
     deviceId?: string;
     irohTestRelayUrl?: string;
+    /** Local expiry fixture only; affects the first ticket before publication. */
+    initialTicketLifetimeMs?: 90_000;
 }): Client;
 
 export { OpenRTC, controlPlane };

package/dist/testing.js

@@ -1 +1 @@
-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};
+import {a}from'./chunk-BFN3AVHA.js';import {a as a$1,d,c}from'./chunk-CNAW5BZ3.js';import {c as c$1}from'./chunk-NDR2ANQB.js';import {i}from'./chunk-TZLNKQNJ.js';import'./chunk-ZA44REGI.js';import'./chunk-LLZT3MR6.js';import'./chunk-DUY34MGT.js';import'./chunk-CCCYE3XN.js';import'./chunk-N6LGTNUI.js';import'./chunk-JPBW67B3.js';import'./chunk-2GX6GB6L.js';function v(o){let t=e=>`${e}:${o}`;return {getOrCreate:e=>c$1.getOrCreate(t(e)),delete:async e=>{await c$1.delete?.(t(e));},readSecureRecord:(e,i)=>c$1.readSecureRecord?.(t(e),i)??Promise.resolve(null),writeSecureRecord:(e,i,c)=>c$1.writeSecureRecord?.(t(e),i,c)??Promise.resolve(),deleteSecureRecord:(e,i)=>c$1.deleteSecureRecord?.(t(e),i)??Promise.resolve()}}function b(o,t,e){return new a(o,t,v(e))}function g(o,t,e={}){if(e.initialTicketLifetimeMs!==void 0){let i=(c,s)=>{let r=new URL(c);return r.protocol===s&&["127.0.0.1","[::1]"].includes(r.hostname)&&Number(r.port)>0&&r.pathname==="/"&&!r.username&&!r.password&&!r.search&&!r.hash};if(e.initialTicketLifetimeMs!==9e4||o.apiKey!=="pk_test_0000000000000000000000000000000000000000"||!i(t.controlPlane,"http:")||!i(t.gateway,"http:")||!e.irohTestRelayUrl||!i(e.irohTestRelayUrl,"https:"))throw new Error("Short initial tickets require the disposable local service lane")}return i(o,{endpoints:t,testingAllowInsecureLoopback:true,platform:"web",...e.deviceId?{deviceIdProvider:async()=>e.deviceId}:{},...e.irohTestRelayUrl?{irohTestRelayUrl:e.irohTestRelayUrl}:{},runtimeFactory:async i=>{let{createWasmClient:c$1}=await import('./runtime/factories.js'),s=await c$1(i);if(e.initialTicketLifetimeMs!==void 0){let r=s.runtime,p=r.getTicketWithToken.bind(r);r.getTicketWithToken=async(l,d$1=0)=>{if(r.getTicketWithToken=p,!l.startsWith("v2:room:"))throw new Error("Short initial ticket requires room scope");let{irohTicket:u,tokenSuffix:m}=a$1(await p(l,d$1)),n=m&&d(u,m);if(!n||!n.t||n.s!==l||n.m!==d$1)throw new Error("Invalid initial service ticket");let h=Date.now()+9e4;return await r.registerToken({token:n.t,scope:l,maxConnections:d$1,expiresAtMs:h}),c(u,n.t,l,d$1,h)};}return s}})}export{g as OpenRTC,b as controlPlane};

package/dist/transport/index.d.ts

@@ -1,5 +1,5 @@
-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';
+import { g as ProtocolName, aq as RouteDescriptor, ar as PayloadCrypto, as as CryptoStreams } from '../Connection-CTpuImO-.js';
+export { at as CryptoBiStream, au as RouteFamily, av as RouteKind } from '../Connection-CTpuImO-.js';
 
 declare const TRANSPORT_LABELS: readonly ProtocolName[];
 declare function normalizeTransport(value: unknown): ProtocolName | undefined;