openrtc 2.0.1 → 2.2.0

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

@@ -1,7 +1,7 @@
-import { h as RuntimeDevice, o as RuntimeDeviceStatusSnapshot } from '../types-l3m3GrOe.js';
-import '../ITransport-UNOXiRJD.js';
+import { e as RuntimeDevice, D as DeviceStatus } from '../types-D67HlF0p.js';
+import '../ITransport-yaruAmx3.js';
 
-interface RuntimeDeviceActiveOptions {
+interface DeviceActiveOptions {
     now?: number;
     /**
      * Optional local freshness window for durable roster rows. Leave undefined
@@ -10,15 +10,15 @@ interface RuntimeDeviceActiveOptions {
     staleAfterMs?: number;
 }
 type RuntimeDeviceActivityStatus = Pick<Partial<RuntimeDevice>, 'online' | 'lastSeenAt' | 'updatedAt' | 'createdAt' | 'expiresAt'>;
-type RuntimeDeviceRouteStatus = Pick<Partial<RuntimeDeviceStatusSnapshot>, 'settledReady' | 'readinessState' | 'connectionStatus'>;
-type RuntimeDevicePresenceStatus = Pick<RuntimeDevice, 'online' | 'ticket'> & Pick<Partial<RuntimeDeviceStatusSnapshot>, 'connectable' | 'presenceStatus' | 'online' | 'ticket'>;
+type RuntimeDeviceRouteStatus = Pick<Partial<DeviceStatus>, 'settledReady' | 'readinessState' | 'connectionStatus'>;
+type DevicePresence = Pick<RuntimeDevice, 'online' | 'ticket'> & Pick<Partial<DeviceStatus>, 'connectable' | 'presenceStatus' | 'online' | 'ticket'>;
 /**
  * True when a runtime device row is currently live enough to display or
  * consider for app-level routing. This is deliberately separate from
- * `isRuntimeDeviceConnectable`: a peer can be active/present before it has a
+ * `isDeviceConnectable`: a peer can be active/present before it has a
  * usable ticket, and a stale durable row should not keep app UIs alive.
  */
-declare function isRuntimeDeviceActive(device: RuntimeDeviceActivityStatus, options?: RuntimeDeviceActiveOptions): boolean;
+declare function isDeviceActive(device: RuntimeDeviceActivityStatus, options?: DeviceActiveOptions): boolean;
 /**
  * True once OpenRTC has a routable peer projection for normal app payloads.
  *
@@ -27,11 +27,11 @@ declare function isRuntimeDeviceActive(device: RuntimeDeviceActivityStatus, opti
  * are not proof that an application-level protocol has exchanged its own
  * ready/capability message over the mesh.
  */
-declare function isRuntimeDeviceRoutable(device: RuntimeDeviceRouteStatus): boolean;
+declare function isDeviceRoutable(device: RuntimeDeviceRouteStatus): boolean;
 /**
  * True when the discovery row currently has enough fresh presence to attempt
  * a dial. This is a discovery gate, not a connected/readiness gate.
  */
-declare function isRuntimeDeviceConnectable(device: RuntimeDevicePresenceStatus): boolean;
+declare function isDeviceConnectable(device: DevicePresence): boolean;
 
-export { type RuntimeDeviceActiveOptions, isRuntimeDeviceActive, isRuntimeDeviceConnectable, isRuntimeDeviceRoutable };
+export { type DeviceActiveOptions, isDeviceActive, isDeviceConnectable, isDeviceRoutable };

package/dist/runtime/device-status.js

@@ -1 +1 @@
-export{a as isRuntimeDeviceActive,c as isRuntimeDeviceConnectable,b as isRuntimeDeviceRoutable}from'../chunk-CK6WQV7J.js';
+export{a as isDeviceActive,c as isDeviceConnectable,b as isDeviceRoutable}from'../chunk-CK6WQV7J.js';

package/dist/runtime/factories.d.ts

@@ -1,10 +1,10 @@
-import { c as RuntimeFactoryOptions, b as PlutoRuntimeAssembly } from '../assembly-CLdwe5T-.js';
-import { I as IpcRuntimeAdapter } from '../IpcRuntimeAdapter-CI3vCzk0.js';
-import { W as WasmBridge } from '../DelegatingRuntimeAdapter-fgz5OPQx.js';
-import { P as PlutoIpcBridge } from '../ipc-CflAVodw.js';
-import '../types-l3m3GrOe.js';
-import '../ITransport-UNOXiRJD.js';
-import '../capabilities-BUe5YldR.js';
+import { c as RuntimeFactoryOptions, b as PlutoRuntimeAssembly } from '../assembly-BTzwQuwI.js';
+import { I as IpcRuntimeAdapter } from '../IpcRuntimeAdapter-DDKeQ6UC.js';
+import { W as WasmBridge } from '../DelegatingRuntimeAdapter-BkLR3TNN.js';
+import { P as PlutoIpcBridge } from '../ipc-CPnNwv6f.js';
+import '../types-D67HlF0p.js';
+import '../ITransport-yaruAmx3.js';
+import '../capabilities-BwzPe51I.js';
 
 /**
  * @deprecated Legacy assembly helper. Use `OpenRTC()` for app code.
@@ -13,7 +13,7 @@ import '../capabilities-BUe5YldR.js';
 declare function createWasmClient(options: RuntimeFactoryOptions): Promise<PlutoRuntimeAssembly<WasmBridge>>;
 /**
  * @deprecated Legacy assembly helper. Native applications should use
- * `createNativeOpenRTC` from `openrtc/native`.
+ * `OpenRTC.native` from `openrtc`.
  * Removal target: OpenRTC 0.2.0.
  */
 declare function createIpcClient(options: RuntimeFactoryOptions, bridge: PlutoIpcBridge): PlutoRuntimeAssembly<IpcRuntimeAdapter>;

package/dist/runtime/factories.js

@@ -1 +1 @@
-import {a as a$2}from'../chunk-HIXXBEWX.js';import {u,a as a$3}from'../chunk-5OTF7W2N.js';import'../chunk-LRT5GEGH.js';import'../chunk-Z2WVSXPW.js';import'../chunk-DUY34MGT.js';import'../chunk-Y35AKFCM.js';import'../chunk-ZQF5KSOK.js';import'../chunk-AG2F6MOB.js';import'../chunk-CWGKLGJZ.js';import {a as a$1}from'../chunk-KJTJLLJE.js';import'../chunk-45WBH7E3.js';import'../chunk-NRXEG5GQ.js';var s=false;function a(){s||(s=true,a$3(async()=>{let t=await import('../openrtc-JUV7TOTL.js');return {initWasm:t.default,WasmClient:t.WasmClient,start:t.start}}));}async function d(t){a();let e=a$1(t),{WasmBridge:i}=await import('../WasmBridge-P5646IVR.js');return a$2(e,new i(e))}function y(t,e){let i=a$1(t);return a$2(i,new u({...i,bridge:e}))}export{y as createIpcClient,d as createWasmClient};
+import {a as a$2}from'../chunk-GND6UW37.js';import {t,a as a$3}from'../chunk-UGZJJQPM.js';import'../chunk-HUG5AX7R.js';import'../chunk-DUY34MGT.js';import'../chunk-F4BJ72HN.js';import'../chunk-OUFHVLDQ.js';import'../chunk-AJQVMVYW.js';import {a as a$1}from'../chunk-NXM5ZGHD.js';import'../chunk-NRXEG5GQ.js';import'../chunk-FKEKINIM.js';import'../chunk-SUWCBTBQ.js';import'../chunk-LN4ALFT6.js';var n=false;function a(){n||(n=true,a$3(async()=>{let t=await import('../openrtc-INQDCF23.js');return {initWasm:t.default,WasmClient:t.WasmClient,start:t.start}}));}async function d(t){a();let e=a$1(t),{WasmBridge:i}=await import('../WasmBridge-DVQ2YPRB.js');return a$2(e,new i(e))}function y(t$1,e){let i=a$1(t$1);return a$2(i,new t({...i,bridge:e}))}export{y as createIpcClient,d as createWasmClient};

package/dist/runtime/index.d.ts

@@ -1,17 +1,17 @@
-import { P as PeerReconciliationStats } from '../assembly-CLdwe5T-.js';
-export { O as OPENRTC_RUNTIME_POLICY, a as RuntimeClient, R as RuntimePolicySnapshot, D as ScopedConnectionActorError, d as ScopedConnectionActorErrorKind, e as ScopedConnectionActorHandle, f as ScopedConnectionActorHandleOptions, g as ScopedConnectionActorRegistry, h as ScopedConnectionActorState, i as ScopedConnectionClose, j as ScopedConnectionDial, k as ScopedConnectionKey, l as ScopedLogicalChannelHandle, m as ScopedPreferredTransport, n as getRuntimePolicy, o as scopedConnectionKey, p as scopedConnectionKeyToString } from '../assembly-CLdwe5T-.js';
-import { OpenRTCClient } from '../OpenRTCShared.js';
-import { f as OpenRTCCapabilityHandle } from '../types-DhmY9hBy.js';
-import { C as Connection, D as RuntimeConnectionTarget, s as RuntimeRawConnection } from '../types-l3m3GrOe.js';
-export { F as ChannelDescriptor, G as ConnectionEvent, H as ConnectionTarget, J as DeviceProfile, K as IncomingStream, I as IrohBrowserProtocolStore, y as IrohDocEntry, x as IrohMutationReceipt, w as IrohNamespaceDescriptor, P as PeerConnectOptions, L as PeerReadiness, M as PeerStreamOptions, N as PresenceLoopOptions, O as RawConnection, k as RuntimeApplicationPayloadReadinessOptions, Q as RuntimeApplicationPayloadRouteOptions, S as RuntimeAuthContext, z as RuntimeAuthIdentity, T as RuntimeAutoConnectPolicy, R as RuntimeChannelDescriptor, v as RuntimeClientOptions, l as RuntimeConnectionEvent, j as RuntimeConnectionStateSnapshot, h as RuntimeDevice, p as RuntimeDeviceConnectOptions, U as RuntimeDevicePresenceStatus, V as RuntimeDeviceStatus, o as RuntimeDeviceStatusSnapshot, f as RuntimeIncomingStream, t as RuntimeJoinRoomOptions, q as RuntimeLocalDeviceInfo, r as RuntimeLocalDeviceProfile, W as RuntimeLogicalChannelFraming, n as RuntimeManagedSession, X as RuntimeManagedSessionKind, m as RuntimeManagedSessionOptions, Y as RuntimeManagedSessionPlatform, b as RuntimePeerConnectOptions, d as RuntimePeerHealth, Z as RuntimePeerLifecycleStatus, c as RuntimePeerReadinessSnapshot, _ as RuntimePeerScope, $ as RuntimePeerSessionSnapshot, a as RuntimePeerState, e as RuntimePeerStreamOptions, E as RuntimePresenceLoopOptions, a0 as RuntimePresencePolicy, u as RuntimeRoomMember, g as RuntimeScopedChannelOptions, i as RuntimeScopedLogicalChannel, B as RuntimeSession, a1 as RuntimeUiConnectionStatus, a2 as ScopedChannelOptions, a3 as ScopedLogicalChannel, a4 as Session, a5 as SessionOptions } from '../types-l3m3GrOe.js';
+import { a as PeerReconciliationStats } from '../assembly-BTzwQuwI.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-BTzwQuwI.js';
+import { Client as Client$1 } from '../coreClient.js';
+import { b as Avenue } from '../types-C4TIUgOJ.js';
 import * as Draft14 from '@moq/net';
-import { a7 as SignalingOptions, I as ISignalingBackend, l as RuntimeIdentity, k as RoomMember, m as SignalingEnvelope, t as SignalingSession, D as Device, q as DesiredPeerProjection, v as BackendConnectionState, a6 as AppLimits, G as GrantScope, Y as JoinRoomOptions, W as IncomingStreamChannelMetadata, a2 as ApplicationCryptoStreamTools, a8 as RoomCreationMode, g as ClientOptions, y as ApplicationPayloadCrypto, j as DiscoveryMode, a1 as ProtocolCapabilityMap, a9 as ScanningLoopOptions, aa as ScanningLoopHandle, ab as RuntimeBootstrapOptions, ac as RuntimeBootstrapResult, z as ApplicationPayloadReadinessOptions, ad as ManagedApplicationRouteOptions, O as PeerState, Q as PeerScope, U as PeerHealth, V as ChannelDescriptor, ae as JoinRequest, N as NativeConnectParams, s as NativeConnectResult } from '../ITransport-UNOXiRJD.js';
-import { R as RuntimeCapabilities } from '../capabilities-BUe5YldR.js';
-export { B as BROWSER_WASM_RUNTIME_CAPABILITIES, b as BrowserRuntimeCapabilityHost, N as NATIVE_IPC_RUNTIME_CAPABILITIES, c as NativeRuntimeStatusSnapshot, d as NativeRuntimeTransportFeatureStatus, e as RuntimeAdapterKind, a as RuntimeCapabilityProfile, f as cloneRuntimeCapabilities, r as runtimeCapabilitiesForBrowserHost, g as runtimeCapabilitiesFromNativeStatus, h as runtimeCapabilityProfile } from '../capabilities-BUe5YldR.js';
-export { RuntimeDeviceActiveOptions, isRuntimeDeviceActive, isRuntimeDeviceConnectable, isRuntimeDeviceRoutable } from './device-status.js';
-export { I as IpcRuntimeAdapter, a as IpcRuntimeAdapterOptions } from '../IpcRuntimeAdapter-CI3vCzk0.js';
-export { P as NativeBridge, N as NativeIpcFailureKind, P as PlutoIpcBridge, a as PlutoIpcUnlisten, c as classifyNativeIpcFailure, i as isNativeIpcCommandUnavailable } from '../ipc-CflAVodw.js';
-import '../DelegatingRuntimeAdapter-fgz5OPQx.js';
+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-yaruAmx3.js';
+import { a as Connection, t as ConnectionTarget, m as RawConnection } from '../types-D67HlF0p.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-D67HlF0p.js';
+import { R as RuntimeCapabilities } from '../capabilities-BwzPe51I.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-BwzPe51I.js';
+export { DeviceActiveOptions, isDeviceActive, isDeviceConnectable, isDeviceRoutable } from './device-status.js';
+export { a as IpcAdapterOptions, I as IpcRuntimeAdapter } from '../IpcRuntimeAdapter-DDKeQ6UC.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-BkLR3TNN.js';
 
 declare class Signaling {
     private readonly appTag;
@@ -29,12 +29,12 @@ declare class Signaling {
     signInAnonymously(): Promise<void>;
     signInWithPluto(): Promise<void>;
     signOut(): Promise<void>;
-    stopAuthScopedActivity(): Promise<void>;
+    stopAuthActivity(): Promise<void>;
     setCoordinationHostAvailability(input: {
         available: boolean;
         reason: string;
     }): void;
-    getRuntimeCapabilities(): RuntimeCapabilities | undefined;
+    capabilities(): RuntimeCapabilities | undefined;
     getTurnCredentials(): Promise<any>;
     updatePresence(localNodeId: string, ticketStr: string, isOnline?: boolean, ttlMs?: number, metadata?: string): Promise<void>;
     setOffline(localNodeId: string): Promise<void>;
@@ -55,21 +55,21 @@ declare class Signaling {
     submitDesiredPeerProjection(revision: number, peers: DesiredPeerProjection[]): Promise<void>;
     notifyDisconnectRequested(remoteNodeId: string): void;
     startPresenceLoop(userId: string, localNodeId: string, deviceName: string, ticket: string, metadata?: string): void;
-    forceReconnectSnapshot(): void;
+    forceReconnect(): void;
     isConnected(nodeId: string): Promise<boolean>;
     getConnectionStates(): Promise<BackendConnectionState[]>;
-    onConnectionStateChange(callback: (state: BackendConnectionState) => void): (() => void) | Promise<() => void>;
+    onStateChange(callback: (state: BackendConnectionState) => void): (() => void) | Promise<() => void>;
     supportsRustPeerLifecycleProjection(): boolean;
     setWasmClient(client: any): void;
 }
 
-type OpenRTCCapabilityRuntime = OpenRTCClient;
+type CapabilityRuntime = Client$1;
 /**
  * Low-level escape hatch used only by `openrtc/runtime`. Product code should
  * prefer the capability namespaces. Keeping this registry here prevents a
  * runtime pointer from leaking onto the provider-neutral root surface.
  */
-declare function runtimeForCapability(handle: OpenRTCCapabilityHandle): OpenRTCCapabilityRuntime;
+declare function runtimeForCapability(handle: Avenue): CapabilityRuntime;
 
 interface MoQSubscriberOptions {
     maxPendingSubscriptions?: number;
@@ -247,16 +247,16 @@ declare class RoomManager {
     stopHeartbeat(_roomId?: string): void;
 }
 
-type IncomingProtocolHint = 'control' | 'explicit' | 'native-main' | 'unknown';
-type IncomingStreamListenerEvent = {
+type ProtocolHint = 'control' | 'explicit' | 'native-main' | 'unknown';
+type IncomingStreamEvent = {
     type: 'bi' | 'uni';
     stream: any;
     remoteNodeId: string;
     transportStableId?: number;
     traceId?: string;
-    protocolHint?: IncomingProtocolHint;
-    channel?: IncomingStreamChannelMetadata | null;
-    applicationCrypto?: ApplicationCryptoStreamTools;
+    protocolHint?: ProtocolHint;
+    channel?: ChannelMetadata | null;
+    applicationCrypto?: CryptoStreams;
     invalid?: boolean;
 };
 
@@ -277,10 +277,10 @@ declare class Client {
     get node(): any;
     set node(node: any);
     attachIncomingStreamSource(source: unknown, localNodeId: string): void;
-    getApplicationCrypto(connection?: Connection): ApplicationPayloadCrypto | undefined;
-    resolveApplicationCryptoForPeer(peerId?: string, connection?: Connection): ApplicationPayloadCrypto | undefined;
+    getApplicationCrypto(connection?: Connection): PayloadCrypto | undefined;
+    resolveApplicationCryptoForPeer(peerId?: string, connection?: Connection): PayloadCrypto | undefined;
     releaseApplicationKeyAgreementReply(connectionId: string, action: 'response' | 'ack', claimId: string): void;
-    waitForApplicationCryptoForPeer(peerId?: string, timeoutMs?: number): Promise<ApplicationPayloadCrypto | undefined>;
+    waitForApplicationCryptoForPeer(peerId?: string, timeoutMs?: number): Promise<PayloadCrypto | undefined>;
     destroy(): void;
     dispose(): void;
     get apiKey(): string | undefined;
@@ -298,7 +298,7 @@ declare class Client {
         wasmLoaded: boolean;
         peerReconciliation: Readonly<PeerReconciliationStats>;
     };
-    getPeerReconciliationStats(): Readonly<PeerReconciliationStats>;
+    reconciliationStats(): Readonly<PeerReconciliationStats>;
     getProtocolCapabilities(): ProtocolCapabilityMap;
     getRuntimeStatus(): Promise<{
         runtime: 'tauri' | 'browser' | 'unknown';
@@ -346,7 +346,7 @@ declare class Client {
     }>;
     openUni(peerId: string): Promise<WritableStream<Uint8Array>>;
     getConnections(): Connection[];
-    getApplicationReadyConnections(options?: ApplicationPayloadReadinessOptions): Connection[];
+    readyConnections(options?: ApplicationPayloadReadinessOptions): Connection[];
     getConnectionForPeer(connectionId?: string, remoteNodeId?: string): Connection | null;
     hasApplicationRouteForPeer(connectionId?: string, remoteNodeId?: string): boolean;
     ensureManagedApplicationRoute(options: ManagedApplicationRouteOptions): Promise<Connection>;
@@ -370,7 +370,7 @@ declare class Client {
         scope?: PeerScope;
         channelId?: string;
         timeoutMs?: number;
-        respectManualDisconnect?: boolean;
+        keepManualDisconnect?: boolean;
     }): Promise<Connection>;
     clearManualDisconnectProjection(id: string): void;
     disconnectPeer(id: string, scope?: PeerScope): Promise<void>;
@@ -379,7 +379,7 @@ declare class Client {
     getTicket(): Promise<string>;
     getNodeId(): Promise<string>;
     getNodeIdFromTicket(ticket: string): Promise<string | null>;
-    getEndpointTicketWithToken(grantScope: GrantScope, maxConnections?: number): Promise<string>;
+    getTicketWithToken(grantScope: GrantScope, maxConnections?: number): Promise<string>;
     buildCompoundTicketWithToken(irohTicket: string, grantScope: GrantScope, maxConnections?: number): string;
     setManagedPresenceTicket(ticket: string | null): void;
     clearManagedPresenceTicket(): void;
@@ -401,17 +401,17 @@ declare class Client {
         startPresence?: boolean;
     }): Promise<void>;
     stopListening(): void;
-    forceReconnectSnapshot(): void;
+    forceReconnect(): void;
     wrapChannelWritable(writable: WritableStream<Uint8Array>, channelId: string, metadata?: Record<string, unknown> | null): WritableStream<Uint8Array>;
     updatePresence(isOnline?: boolean, ttlMs?: number, metadata?: string, ticketOverride?: string): Promise<void>;
     onConnection(callback: (conn: Connection) => void): () => void;
     onDisconnection(callback: (conn: Connection) => void): () => void;
     onMessage(callback: (conn: Connection, msg: any) => void): () => void;
-    onIncomingStream(callback: (stream: IncomingStreamListenerEvent) => boolean | void): () => void;
+    onIncomingStream(callback: (stream: IncomingStreamEvent) => boolean | void): () => void;
     registerChannel(descriptor: ChannelDescriptor): void;
     unregisterChannel(channelId: string): void;
     listChannels(): ChannelDescriptor[];
-    onIncomingChannelStream(channelId: string, callback: (stream: IncomingStreamListenerEvent) => boolean | void): () => void;
+    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?: {
@@ -426,13 +426,13 @@ declare class Client {
  * readiness, and channel orchestration remain in their existing managers until
  * those boundaries can be tightened independently.
  */
-declare class RuntimeConnectionController {
+declare class ConnectionController {
     private readonly client;
     private readonly backend;
     private readonly onLifecycleMutation;
     constructor(client: Client, backend: ISignalingBackend | null, onLifecycleMutation?: () => void);
     connectToDevice(params: NativeConnectParams): Promise<NativeConnectResult>;
-    connectRaw(target: RuntimeConnectionTarget): Promise<RuntimeRawConnection>;
+    connectRaw(target: ConnectionTarget): Promise<RawConnection>;
     openBi(nodeId: string): Promise<{
         readable: ReadableStream<Uint8Array>;
         writable: WritableStream<Uint8Array>;
@@ -441,7 +441,7 @@ declare class RuntimeConnectionController {
     isConnected(nodeId: string): Promise<boolean>;
     disconnectNode(nodeId: string): Promise<void>;
     disconnectDevice(deviceId: string): Promise<void>;
-    setAutoConnectExcluded(deviceId: string, excluded: boolean): Promise<void>;
+    excludeAutoConnect(deviceId: string, excluded: boolean): Promise<void>;
     disconnectPeer(id: string, scope?: string): Promise<void>;
     forceDisconnectPeer(id: string): Promise<void>;
     private clearManualDisconnectProjection;
@@ -484,9 +484,9 @@ interface CorrelationFields {
  * the Phase 0 parser's primary regex set). Empty fields are dropped.
  * Exposed for tests.
  */
-declare function renderCorrelationFields(fields: CorrelationFields): string;
+declare function renderCorrelation(fields: CorrelationFields): string;
 /** @deprecated Use correlationForScope() */
-declare function correlationForDriveGrantScope(scope: string, extra?: CorrelationFields): CorrelationFields;
+declare function grantCorrelation(scope: string, extra?: CorrelationFields): CorrelationFields;
 /**
  * Phase 7 structured-log call. Emits a single `console.log` line of the
  * form `<tag> <fields> <message>` — the exact shape the Phase 0
@@ -505,7 +505,7 @@ declare function clog(tag: string, fields: CorrelationFields, message?: string,
  *   Stack lines are tagged `[OpenRTC][teardown-trace:stack]`.
  * Native / Tauri: run with `PLUTO_RTC_TEARDOWN_TRACE=1` to log matching Rust iroh disconnect lines to stderr.
  */
-declare function logOpenRtcTeardownTrace(kind: string, details?: Record<string, unknown>): void;
+declare function logTeardownTrace(kind: string, details?: Record<string, unknown>): void;
 
 declare function openRtcDebugEnabled(): boolean;
 declare function openRtcDebug(message: string, data?: unknown): void;
@@ -526,18 +526,18 @@ declare function openRtcDebugLog(message: string, data?: unknown): void;
 type ByteArray = Uint8Array<ArrayBuffer>;
 type ByteArrayLike = Uint8Array<ArrayBufferLike>;
 
-type RuntimeU32BEFrameHandler = (payload: ByteArray) => void;
-type RuntimeJsonFrameHandler<T = unknown> = (value: T, payload: ByteArray) => void;
-interface RuntimeJsonFrameDecoderOptions {
+type U32FrameHandler = (payload: ByteArray) => void;
+type JsonFrameHandler<T = unknown> = (value: T, payload: ByteArray) => void;
+interface JsonDecoderOptions {
     onInvalidJson?: (error: unknown, payload: ByteArray) => void;
 }
-declare function encodeRuntimeU32BEFrame(payload: ByteArrayLike): ByteArray;
-declare function createRuntimeU32BEFrameDecoder(onFrame: RuntimeU32BEFrameHandler): (chunk: ByteArrayLike) => void;
-declare function encodeRuntimeJsonPayload(value: unknown): ByteArray;
-declare function decodeRuntimeJsonPayload<T = unknown>(payload: ByteArrayLike): T;
-declare function encodeRuntimeJsonFrame(value: unknown): ByteArray;
-declare function createRuntimeJsonFrameDecoder<T = unknown>(onValue: RuntimeJsonFrameHandler<T>, options?: RuntimeJsonFrameDecoderOptions): (chunk: ByteArrayLike) => void;
+declare function encodeU32Frame(payload: ByteArrayLike): ByteArray;
+declare function createU32Decoder(onFrame: U32FrameHandler): (chunk: ByteArrayLike) => void;
+declare function encodeJsonPayload(value: unknown): ByteArray;
+declare function decodeJsonPayload<T = unknown>(payload: ByteArrayLike): T;
+declare function encodeJsonFrame(value: unknown): ByteArray;
+declare function createJsonDecoder<T = unknown>(onValue: JsonFrameHandler<T>, options?: JsonDecoderOptions): (chunk: ByteArrayLike) => void;
 declare function concatRuntimeBytes(a: ByteArrayLike, b: ByteArrayLike): ByteArray;
 declare function readRuntimeU32BE(bytes: ByteArrayLike, offset: number): number;
 
-export { Connection, type CorrelationFields, type OpenRTCCapabilityRuntime, RuntimeCapabilities, RuntimeConnectionController, RuntimeConnectionTarget, type RuntimeJsonFrameDecoderOptions, type RuntimeJsonFrameHandler, RuntimeRawConnection, type RuntimeU32BEFrameHandler, clog, concatRuntimeBytes, correlationForDriveGrantScope, createRuntimeJsonFrameDecoder, createRuntimeU32BEFrameDecoder, decodeRuntimeJsonPayload, encodeRuntimeJsonFrame, encodeRuntimeJsonPayload, encodeRuntimeU32BEFrame, logOpenRtcTeardownTrace, openRtcDebug, openRtcDebugEnabled, openRtcDebugInfo, openRtcDebugLog, readRuntimeU32BE, renderCorrelationFields, runtimeForCapability as runtimeFromCapability };
+export { type CapabilityRuntime, ConnectionController, ConnectionTarget, type CorrelationFields, type JsonDecoderOptions, type JsonFrameHandler, RawConnection, RuntimeCapabilities, type U32FrameHandler, clog, concatRuntimeBytes, createJsonDecoder, createU32Decoder, decodeJsonPayload, encodeJsonFrame, encodeJsonPayload, encodeU32Frame, grantCorrelation, logTeardownTrace, openRtcDebug, openRtcDebugEnabled, openRtcDebugInfo, openRtcDebugLog, readRuntimeU32BE, renderCorrelation, runtimeForCapability as runtimeFromCapability };

package/dist/runtime/index.js

@@ -1 +1 @@
-export{a as runtimeFromCapability}from'../chunk-QCPSLUKO.js';import'../chunk-XPL7PUBW.js';export{a as isRuntimeDeviceActive,c as isRuntimeDeviceConnectable,b as isRuntimeDeviceRoutable}from'../chunk-CK6WQV7J.js';export{b as Connection,u as IpcRuntimeAdapter,t as RuntimeClient,c as RuntimeConnectionController,g as ScopedConnectionActorError,j as ScopedConnectionActorHandle,k as ScopedConnectionActorRegistry,f as clog,r as concatRuntimeBytes,e as correlationForDriveGrantScope,q as createRuntimeJsonFrameDecoder,m as createRuntimeU32BEFrameDecoder,o as decodeRuntimeJsonPayload,p as encodeRuntimeJsonFrame,n as encodeRuntimeJsonPayload,l as encodeRuntimeU32BEFrame,s as readRuntimeU32BE,d as renderCorrelationFields,h as scopedConnectionKey,i as scopedConnectionKeyToString}from'../chunk-5OTF7W2N.js';import'../chunk-LRT5GEGH.js';export{a as classifyNativeIpcFailure,b as isNativeIpcCommandUnavailable}from'../chunk-Z2WVSXPW.js';import'../chunk-DUY34MGT.js';import'../chunk-Y35AKFCM.js';export{s as BROWSER_WASM_RUNTIME_CAPABILITIES,t as NATIVE_IPC_RUNTIME_CAPABILITIES,q as OPENRTC_RUNTIME_POLICY,u as cloneRuntimeCapabilities,r as getRuntimePolicy,i as logOpenRtcTeardownTrace,v as runtimeCapabilitiesForBrowserHost,w as runtimeCapabilitiesFromNativeStatus,x as runtimeCapabilityProfile}from'../chunk-ZQF5KSOK.js';export{b as openRtcDebug,a as openRtcDebugEnabled,c as openRtcDebugInfo,d as openRtcDebugLog}from'../chunk-AG2F6MOB.js';import'../chunk-CWGKLGJZ.js';import'../chunk-KJTJLLJE.js';import'../chunk-45WBH7E3.js';import'../chunk-NRXEG5GQ.js';
+export{a as runtimeFromCapability}from'../chunk-2IRNZN3N.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-UGZJJQPM.js';export{a as classifyIpcFailure,b as isIpcUnavailable}from'../chunk-HUG5AX7R.js';import'../chunk-DUY34MGT.js';import'../chunk-F4BJ72HN.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-OUFHVLDQ.js';import'../chunk-AJQVMVYW.js';import'../chunk-NXM5ZGHD.js';import'../chunk-NRXEG5GQ.js';import'../chunk-FKEKINIM.js';export{b as openRtcDebug,a as openRtcDebugEnabled,c as openRtcDebugInfo,d as openRtcDebugLog}from'../chunk-SUWCBTBQ.js';import'../chunk-LN4ALFT6.js';

package/dist/testing.d.ts

@@ -1,24 +1,24 @@
-import { h as CoordinationGatewayGrantRequest, i as CoordinationGatewayGrant } from './ITransport-UNOXiRJD.js';
-import { c as OpenRTCAttestationProvider, d as OpenRTCAuthProvider, e as OpenRTCBotVerificationProvider, j as OpenRTCDeviceProfile, O as OpenRTCOptions, a as OpenRTCClient } from './types-DhmY9hBy.js';
-import { P as PlutoIpcBridge } from './ipc-CflAVodw.js';
-import './OpenRTCShared.js';
-import './assembly-CLdwe5T-.js';
-import './types-l3m3GrOe.js';
-import './capabilities-BUe5YldR.js';
+import { i as CoordinationGatewayGrantRequest, j as CoordinationGatewayGrant } from './ITransport-yaruAmx3.js';
+import { A as AttestationProvider, a as AuthProvider, B as BotVerificationProvider, e as DeviceProfile, O as Options, C as Client } from './types-C4TIUgOJ.js';
+import { P as PlutoIpcBridge } from './ipc-CPnNwv6f.js';
+import './coreClient.js';
+import './assembly-BTzwQuwI.js';
+import './types-D67HlF0p.js';
+import './capabilities-BwzPe51I.js';
 
-interface OpenRTCDeviceProof {
+interface DeviceProof {
     publicKeyJwk: JsonWebKey;
     signature: string;
     nonce: string;
     issuedAt: number;
 }
-interface OpenRTCDeviceKey {
+interface DeviceKey {
     readonly publicKeyJwk: JsonWebKey;
     readonly thumbprint: string;
-    proof(challenge: (nonce: string, issuedAt: number) => string): Promise<OpenRTCDeviceProof>;
+    proof(challenge: (nonce: string, issuedAt: number) => string): Promise<DeviceProof>;
 }
-interface OpenRTCDeviceKeyProvider {
-    getOrCreate(appTag: string): Promise<OpenRTCDeviceKey>;
+interface DeviceKeyProvider {
+    getOrCreate(appTag: string): Promise<DeviceKey>;
     delete?(appTag: string): Promise<void>;
     /**
      * Optional platform-secure record storage. Native hosts use this for the
@@ -30,7 +30,7 @@ interface OpenRTCDeviceKeyProvider {
     deleteSecureRecord?(appTag: string, key: string): Promise<void>;
 }
 
-interface OpenRTCV2Endpoints {
+interface Endpoints {
     controlPlane: string;
     gateway: string;
 }
@@ -60,12 +60,12 @@ interface AuthenticatedDeviceCertificate extends CachedDeviceCertificate {
     principalId: string;
     enrolled: boolean;
 }
-interface OpenRTCV2ControlPlaneEvents {
+interface ControlPlaneEvents {
     beforeLogicalOperation?: (operation: string) => void;
     onLogicalOperation?: (operation: string) => void;
-    onAuthEpochChanged?: (auth: OpenRTCAuthProvider) => void;
+    onAuthEpochChanged?: (auth: AuthProvider) => void;
 }
-declare class OpenRTCV2ControlPlane {
+declare class ControlPlane {
     readonly apiKey: string;
     private readonly endpoints;
     private readonly keyProvider;
@@ -75,7 +75,7 @@ declare class OpenRTCV2ControlPlane {
     readonly appTag: string;
     private keyPromise;
     private readonly authEpochs;
-    constructor(apiKey: string, endpoints: OpenRTCV2Endpoints, keyProvider: OpenRTCDeviceKeyProvider, attestation?: OpenRTCAttestationProvider | undefined, events?: OpenRTCV2ControlPlaneEvents, botVerification?: OpenRTCBotVerificationProvider | undefined);
+    constructor(apiKey: string, endpoints: Endpoints, keyProvider: DeviceKeyProvider, attestation?: AttestationProvider | undefined, events?: ControlPlaneEvents, botVerification?: BotVerificationProvider | undefined);
     private record;
     private before;
     private authEpoch;
@@ -83,7 +83,7 @@ declare class OpenRTCV2ControlPlane {
     private key;
     private post;
     capability(kind: 'space' | 'room' | 'ticket', id: string, maxPeers?: number, advancedFanout?: boolean): Promise<CredentialSource>;
-    deviceCertificate(auth: OpenRTCAuthProvider, deviceId: string, avenue?: CoordinationGatewayGrantRequest['avenue'], profile?: OpenRTCDeviceProfile, rejected?: AuthenticatedDeviceCertificate): Promise<{
+    deviceCertificate(auth: AuthProvider, deviceId: string, avenue?: CoordinationGatewayGrantRequest['avenue'], profile?: DeviceProfile, rejected?: AuthenticatedDeviceCertificate): Promise<{
         source: CredentialSource;
         principalId: string;
         enrolled: boolean;
@@ -91,7 +91,7 @@ declare class OpenRTCV2ControlPlane {
     private resolveAuthenticatedDevice;
     private deviceCertificateResult;
     private enrollAuthenticatedDevice;
-    listEnrolledDevices(auth: OpenRTCAuthProvider, deviceId: string): Promise<Array<{
+    listEnrolledDevices(auth: AuthProvider, deviceId: string): Promise<Array<{
         deviceId: string;
         name?: string;
         platform?: string;
@@ -99,15 +99,15 @@ declare class OpenRTCV2ControlPlane {
         lastGrantAtMs: number | null;
         current: boolean;
     }>>;
-    revokeDevice(auth: OpenRTCAuthProvider, currentDeviceId: string, targetDeviceId: string): Promise<void>;
-    revokeAllDevices(auth: OpenRTCAuthProvider, currentDeviceId: string, exceptCurrent: boolean): Promise<void>;
+    revokeDevice(auth: AuthProvider, currentDeviceId: string, targetDeviceId: string): Promise<void>;
+    revokeAllDevices(auth: AuthProvider, currentDeviceId: string, exceptCurrent: boolean): Promise<void>;
     private deleteDeviceKey;
     private deviceManagement;
     durableRoomMembership(source: CredentialSource, roomId: string, action: 'join' | 'leave'): Promise<void>;
     grantProvider(source: CredentialSource, input?: {
         maxPeers?: number;
         features?: Record<string, boolean>;
-        deviceProfile?: Pick<OpenRTCDeviceProfile, 'name' | 'platform'>;
+        deviceProfile?: Pick<DeviceProfile, 'name' | 'platform'>;
         /**
          * Keeps the transport/admission credential relay synchronized
          * when a capability or device certificate is renewed in place.
@@ -122,12 +122,13 @@ declare class OpenRTCV2ControlPlane {
 }
 
 /** Focused control-plane factory for live harnesses that do not need a transport runtime. */
-declare function createTestingOpenRTCControlPlane(apiKey: string, endpoints: OpenRTCV2Endpoints, keyNamespace: string): OpenRTCV2ControlPlane;
-declare function createTestingOpenRTC(options: OpenRTCOptions, endpoints: OpenRTCV2Endpoints, testing?: {
+declare function controlPlane(apiKey: string, endpoints: Endpoints, keyNamespace: string): ControlPlane;
+declare function OpenRTC(options: Options, endpoints: Endpoints, testing?: {
     deviceId?: string;
     irohTestRelayUrl?: string;
-}): OpenRTCClient;
-/** Native equivalent for emulator and harness lanes; never import in product code. */
-declare function createTestingNativeOpenRTC(options: OpenRTCOptions, endpoints: OpenRTCV2Endpoints, bridge: PlutoIpcBridge): OpenRTCClient;
+}): Client;
+declare namespace OpenRTC {
+    var native: (options: Options, endpoints: Endpoints, bridge: PlutoIpcBridge) => Client;
+}
 
-export { createTestingNativeOpenRTC, createTestingOpenRTC, createTestingOpenRTCControlPlane };
+export { OpenRTC, controlPlane };

package/dist/testing.js

@@ -1 +1 @@
-import {a}from'./chunk-IKZ33R7R.js';import {a as a$1}from'./chunk-7FPG3MFF.js';import {b as b$1}from'./chunk-VBUDERMM.js';import {b}from'./chunk-QCPSLUKO.js';import'./chunk-XPL7PUBW.js';import'./chunk-DUY34MGT.js';import'./chunk-NRXEG5GQ.js';function l(n){let r=e=>`${e}:${n}`;return {getOrCreate:e=>b$1.getOrCreate(r(e)),delete:async e=>{await b$1.delete?.(r(e));},readSecureRecord:(e,t)=>b$1.readSecureRecord?.(r(e),t)??Promise.resolve(null),writeSecureRecord:(e,t,i)=>b$1.writeSecureRecord?.(r(e),t,i)??Promise.resolve(),deleteSecureRecord:(e,t)=>b$1.deleteSecureRecord?.(r(e),t)??Promise.resolve()}}function C(n,r,e){return new a(n,r,l(e))}function R(n,r,e={}){return b(n,{endpoints:r,testingAllowInsecureLoopback:true,platform:"web",...e.deviceId?{deviceIdProvider:async()=>e.deviceId}:{},...e.irohTestRelayUrl?{irohTestRelayUrl:e.irohTestRelayUrl}:{},runtimeFactory:async t=>{let{createWasmClient:i}=await import('./runtime/factories.js');return i(t)}})}function m(n,r,e){return b(n,{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:i}=await import('./ipcFactory-JTMNUTZI.js');return i(t,e)}})}export{m as createTestingNativeOpenRTC,R as createTestingOpenRTC,C as createTestingOpenRTCControlPlane};
+import {a}from'./chunk-DI5VSZ2T.js';import {a as a$1}from'./chunk-BOS554IK.js';import {c}from'./chunk-4MLJXEVV.js';import {b}from'./chunk-2IRNZN3N.js';import'./chunk-ZA44REGI.js';import'./chunk-DUY34MGT.js';import'./chunk-NRXEG5GQ.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-DQFK65VE.js');return n(t,e)}})};export{s as OpenRTC,y as controlPlane};

package/dist/transport/index.d.ts

@@ -1,13 +1,13 @@
-import { c as ProtocolName, $ as RouteDescriptor, J as ITransport, a0 as ProtocolCapability, a1 as ProtocolCapabilityMap, y as ApplicationPayloadCrypto, a2 as ApplicationCryptoStreamTools } from '../ITransport-UNOXiRJD.js';
-export { a3 as ApplicationCryptoBiStream, a4 as RouteFamily, a5 as RouteImplementationKind } from '../ITransport-UNOXiRJD.js';
+import { c as ProtocolName, $ as RouteDescriptor, K as ITransport, a0 as ProtocolCapability, a1 as ProtocolCapabilityMap, z as PayloadCrypto, a2 as CryptoStreams } from '../ITransport-yaruAmx3.js';
+export { a3 as CryptoBiStream, a4 as RouteFamily, a5 as RouteKind } from '../ITransport-yaruAmx3.js';
 
 declare const TRANSPORT_LABELS: readonly ProtocolName[];
-declare function normalizeTransportLabel(value: unknown): ProtocolName | undefined;
-declare function isIrohBaseTransportLabel(value: unknown): boolean;
-declare function isDirectIrohTransportLabel(value: unknown): boolean;
-declare function isOptionalTransportLabel(value: unknown): boolean;
-declare function isWebRtcTransportLabel(value: unknown): boolean;
-declare function isIndependentTransportLabel(value: unknown): boolean;
+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;
@@ -19,37 +19,37 @@ declare class TransportFactory {
     static createTransport(name: ProtocolName): ITransport;
     static getProtocolCapability(name: ProtocolName): ProtocolCapability;
     static getProtocolCapabilities(): ProtocolCapabilityMap;
-    static getPreferredProtocolOrder(options?: {
+    static preferredProtocols(options?: {
         runtime?: 'browser' | 'native' | 'any';
         includePathLabels?: boolean;
     }): ProtocolName[];
     static assertProtocolAvailable(name: ProtocolName): void;
 }
-declare function getPreferredProtocolOrder(options?: Parameters<typeof TransportFactory.getPreferredProtocolOrder>[0]): ProtocolName[];
+declare function preferredProtocols(options?: Parameters<typeof TransportFactory.preferredProtocols>[0]): ProtocolName[];
 
-declare function isApplicationEncryptedPayload(payload: Uint8Array): boolean;
-declare function createSharedSecretApplicationCrypto(key: Uint8Array, options?: {
+declare function isEncryptedPayload(payload: Uint8Array): boolean;
+declare function createSharedCrypto(key: Uint8Array, options?: {
     requireEncrypted?: boolean;
     randomBytes?: (byteLength: number) => Uint8Array;
     replayProtection?: boolean;
-}): ApplicationPayloadCrypto;
-declare function createApplicationCryptoStreamTools(crypto: ApplicationPayloadCrypto, options?: {
+}): PayloadCrypto;
+declare function createCryptoStreams(crypto: PayloadCrypto, options?: {
     typeId?: number;
     maxFrameBytes?: number;
-}): ApplicationCryptoStreamTools;
+}): CryptoStreams;
 
-declare const KEY_AGREEMENT_PUBLIC_KEY_BYTES = 32;
-declare const KEY_AGREEMENT_ALGORITHM = "openrtc:x25519-hkdf:v1";
-interface ApplicationKeyAgreementPayload {
-    algorithm: typeof KEY_AGREEMENT_ALGORITHM;
+declare const PUBLIC_KEY_BYTES = 32;
+declare const KEY_ALGORITHM = "openrtc:x25519-hkdf:v1";
+interface KeyAgreementPayload {
+    algorithm: typeof KEY_ALGORITHM;
     publicKey: string;
 }
-interface EphemeralKeyAgreement {
+interface KeyAgreement {
     publicKey: Uint8Array;
     secretKey: Uint8Array;
 }
-declare function generateEphemeralKeyAgreement(randomBytes?: (byteLength: number) => Uint8Array): EphemeralKeyAgreement;
-declare function deriveApplicationCryptoKey(localSecretKey: Uint8Array, remotePublicKey: Uint8Array, localNodeId: string, remoteNodeId: string): Uint8Array;
-declare function encodeApplicationKeyAgreementPayload(publicKey: Uint8Array): ApplicationKeyAgreementPayload;
+declare function createKeyAgreement(randomBytes?: (byteLength: number) => Uint8Array): KeyAgreement;
+declare function deriveCryptoKey(localSecretKey: Uint8Array, remotePublicKey: Uint8Array, localNodeId: string, remoteNodeId: string): Uint8Array;
+declare function encodeKeyAgreement(publicKey: Uint8Array): KeyAgreementPayload;
 
-export { ApplicationCryptoStreamTools, type ApplicationKeyAgreementPayload, ApplicationPayloadCrypto, KEY_AGREEMENT_ALGORITHM, KEY_AGREEMENT_PUBLIC_KEY_BYTES, ProtocolName, ROUTE_DESCRIPTORS, RouteDescriptor, TRANSPORT_LABELS, createApplicationCryptoStreamTools, createSharedSecretApplicationCrypto, deriveApplicationCryptoKey, encodeApplicationKeyAgreementPayload, generateEphemeralKeyAgreement, getPreferredProtocolOrder, getRouteDescriptor, isApplicationEncryptedPayload, isDirectIrohTransportLabel, isIndependentTransportLabel, isIrohBaseTransportLabel, isOptionalTransportLabel, isWebRtcTransportLabel, listRouteDescriptors, normalizeTransportLabel };
+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 };

package/dist/transport/index.js

@@ -1 +1 @@
-export{e as KEY_AGREEMENT_ALGORITHM,d as KEY_AGREEMENT_PUBLIC_KEY_BYTES,g as deriveApplicationCryptoKey,i as encodeApplicationKeyAgreementPayload,f as generateEphemeralKeyAgreement,c as getPreferredProtocolOrder}from'../chunk-LRT5GEGH.js';export{o as TRANSPORT_LABELS,z as createApplicationCryptoStreamTools,y as createSharedSecretApplicationCrypto,x as isApplicationEncryptedPayload,r as isDirectIrohTransportLabel,w as isIndependentTransportLabel,q as isIrohBaseTransportLabel,s as isOptionalTransportLabel,t as isWebRtcTransportLabel,p as normalizeTransportLabel}from'../chunk-AG2F6MOB.js';export{a as ROUTE_DESCRIPTORS,e as getRouteDescriptor,f as listRouteDescriptors}from'../chunk-45WBH7E3.js';
+export{e as KEY_ALGORITHM,d as PUBLIC_KEY_BYTES,f as createKeyAgreement,g as deriveCryptoKey,i as encodeKeyAgreement,c as preferredProtocols}from'../chunk-FKEKINIM.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-SUWCBTBQ.js';export{a as ROUTE_DESCRIPTORS,e as getRouteDescriptor,f as listRouteDescriptors}from'../chunk-LN4ALFT6.js';