openrtc 2.3.1 → 2.5.1

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-DvfsYFCL.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-GHAJW6SZ.js';import'./chunk-Z54XUIKZ.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,155 @@
+import { C as Client, X as Room, r as Connection } from './types-Cyc-mPjk.js';
+import './coreClient.js';
+import './assembly-DvfsYFCL.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;
+    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-GHAJW6SZ.js';import'./chunk-Z54XUIKZ.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

@@ -0,0 +1,11 @@
+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-DvfsYFCL.js';
+import '../Connection-CTpuImO-.js';
+import '../capabilities-CmzzxSvW.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-VFDCIEP6.js';import {a}from'../chunk-VTYVIKTM.js';import'../chunk-NDR2ANQB.js';import {f}from'../chunk-Z54XUIKZ.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 f(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-PRAJ7JP7.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 { 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-Bmi65-tK.js';
-import './types-DDhMQkK8.js';
-import './capabilities-BPuynml5.js';
+import './assembly-DvfsYFCL.js';
+import './capabilities-CmzzxSvW.js';
 
 interface DeviceProof {
     publicKeyJwk: JsonWebKey;
@@ -15,32 +14,31 @@ 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 {
     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 +58,8 @@ interface CachedDeviceCertificate {
 interface AuthenticatedDeviceCertificate extends CachedDeviceCertificate {
     principalId: string;
     enrolled: boolean;
-    relay: boolean;
+    irohRelay: boolean;
+    managedTurn: boolean;
 }
 interface ControlPlaneEvents {
     beforeLogicalOperation?: (operation: string) => void;
@@ -83,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;
@@ -109,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
@@ -132,8 +162,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-BFN3AVHA.js';import {c}from'./chunk-NDR2ANQB.js';import {f}from'./chunk-Z54XUIKZ.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 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 f(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 { 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;
 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';