openrtc 2.0.0 → 2.1.0

package/dist/{types-DVNSd5B9.d.ts → types-D67HlF0p.d.ts}

@@ -1,4 +1,4 @@
-import { v as ConnectionOptions, w as ApplicationPayloadCrypto, x as ApplicationPayloadReadinessOptions, y as ApplicationPayloadRouteOptions, c as ProtocolName, z as ApplicationPayloadSendOptions, F as ITransport, H as TransportLatencySnapshot, J as PeerState, K as PeerScope, O as PeerHealth, Q as ChannelDescriptor$1, U as IncomingStreamChannelMetadata, D as Device, t as BackendConnectionState, L as LocalDeviceInfo, l as DeviceStatusSnapshot, V as ManagedDeviceConnectOptions, g as ClientOptions, r as SignalingSession, j as RuntimeIdentity, W as JoinRoomOptions, i as RoomMember, X as DevicePresenceStatus, Y as PeerLifecycleStatus, d as PeerSessionSnapshot } from './ITransport-WV6gGMnX.js';
+import { y as ConnectionOptions, z as PayloadCrypto, F as ApplicationPayloadReadinessOptions, H as ApplicationPayloadRouteOptions, c as ProtocolName, J as ApplicationPayloadSendOptions, K as ITransport, O as LatencySnapshot, Q as PeerState, T as PeerScope, U as PeerHealth, V as ChannelDescriptor$1, W as ChannelMetadata, D as Device, w as BackendConnectionState, L as LocalDeviceInfo$1, o as DeviceStatusSnapshot, X as ManagedDeviceConnectOptions, h as ClientOptions, u as SignalingSession, m as RuntimeIdentity, Y as JoinRoomOptions$1, l as RoomMember, Z as DevicePresenceStatus, _ as PeerLifecycleStatus$1, d as PeerSessionSnapshot$1 } from './ITransport-yaruAmx3.js';
 
 type ConnectionHealth = 'unknown' | 'healthy' | 'suspect' | 'stale';
 
@@ -86,13 +86,12 @@ declare class Connection {
     private webRtcDisconnectedGraceTimer;
     private preferredWebRtcRole;
     constructor(id: string, localNodeId: string, remoteNodeId: string, writer: WritableStreamDefaultWriter<Uint8Array>, reader: ReadableStreamDefaultReader<Uint8Array>, options?: ConnectionOptions);
-    setApplicationCrypto(applicationCrypto: ApplicationPayloadCrypto | undefined): void;
-    markApplicationKeyAgreementObserved(): number;
-    getApplicationKeyAgreementObservationEpoch(): number;
+    setApplicationCrypto(applicationCrypto: PayloadCrypto | undefined): void;
+    getKeyAgreementEpoch(): number;
     requireApplicationCrypto(): void;
     isApplicationCryptoRequired(): boolean;
-    isReadyForApplicationPayload(options?: ApplicationPayloadReadinessOptions): boolean;
-    getApplicationPayloadTransports(options?: ApplicationPayloadRouteOptions): ProtocolName[];
+    isPayloadReady(options?: ApplicationPayloadReadinessOptions): boolean;
+    payloadTransports(options?: ApplicationPayloadRouteOptions): ProtocolName[];
     private isTransportAvailableForApplicationPayload;
     private resolveApplicationCryptoWaiters;
     private rejectApplicationCryptoWaiters;
@@ -102,17 +101,6 @@ declare class Connection {
      * No-op when WebRTC is not configured or an upgrade already started.
      */
     requestWebRTCUpgrade(reason?: string): void;
-    /**
-     * Records that the current native base transport has completed session
-     * admission and can now accept optional-route signaling.
-     *
-     * A replacement Iroh transport is projected before its token exchange has
-     * necessarily completed. If a WebRTC attempt starts during that interval,
-     * its renegotiate/SDP frames are intentionally rejected. Admission is the
-     * authoritative event that makes one fresh attempt safe. The generation
-     * fence prevents duplicate token approvals from creating a retry storm.
-     */
-    handleNativeSessionAdmissionAvailable(reason?: string): void;
     /**
      * Whether the current WebRTC route is provably alive: an open data channel
      * plus either a recent heartbeat round trip or a freshly opened channel. An
@@ -141,15 +129,6 @@ declare class Connection {
     }): void;
     private beginWebRtcRecovery;
     getUpgradeState(): UpgradeState;
-    /**
-     * Generation fence for asynchronous native-main signaling.
-     *
-     * WebRTC callbacks and control-stream opens can complete after their
-     * transport has been replaced. A late SDP/candidate/renegotiate frame from
-     * that retired generation must not be allowed to replace the current
-     * negotiation on the peer.
-     */
-    isCurrentWebRtcNegotiationSignal(envelope: any): boolean;
     updateRTCConfig(rtcConfig: ConnectionOptions['rtcConfig']): void;
     onUpgradeStateChange(callback: (state: UpgradeState) => void): void;
     /**
@@ -204,7 +183,7 @@ declare class Connection {
      */
     sendOnTransport(transport: ProtocolName, message: string | object | ArrayBuffer | Uint8Array): Promise<void>;
     /** Last transport that accepted an application payload from this connection. */
-    getLastApplicationPayloadTransport(): ProtocolName | null;
+    lastPayloadTransport(): ProtocolName | null;
     /**
      * Send plaintext control traffic that is required to bootstrap application
      * key agreement. This is intentionally separate from public app-data sends.
@@ -338,7 +317,7 @@ declare class Connection {
         parallelTransport: ProtocolName | null;
     };
     /** Passive RTT samples owned by the active transport heartbeats. */
-    getTransportLatencySnapshot(): TransportLatencySnapshot;
+    getLatencySnapshot(): LatencySnapshot;
     private resolveParallelTransport;
     setNativeSignalSender(sender: (envelope: any) => Promise<void>): void;
     /**
@@ -356,14 +335,6 @@ declare class Connection {
      * accidentally routes control through the native sender.
      */
     sendNativeControlEnvelope(envelope: any): Promise<boolean>;
-    /**
-     * Promote a connection to the native-main control plane: switch its
-     * control-frame mode to `native-main` and attach the native signal sender.
-     * Used when native-main evidence arrives for a connection that bootstrapped
-     * on a typed stream, so subsequent control traffic flows over the durable
-     * native-main route even if the bootstrap stream later closes.
-     */
-    promoteToNativeMainControlRoute(sender: (envelope: any) => Promise<void>): void;
     private hasRequiredApplicationCrypto;
     private clearWebRtcApplicationRouteReady;
     private isCurrentWebRtcTransportApplicationRouteReady;
@@ -418,7 +389,7 @@ type AuthContext = {
 /**
  * App-facing options intentionally hide transport node identifiers from callbacks.
  */
-type RuntimeClientOptions = Omit<ClientOptions, 'onDevices' | 'onAutoConnect' | 'onIncomingSession'> & {
+type RuntimeClientOptions = Omit<ClientOptions, 'onDevices' | 'onAutoConnect' | 'onIncomingSession' | 'coordinationAvenueOverride' | 'coordinationRoomGossipFanout' | 'coordinationPlatformType'> & {
     onDevices?: (devices: RuntimeDevice[]) => void;
     onAutoConnect?: (devices: RuntimeDevice[]) => void;
     onIncomingSession?: (session: RuntimeSession) => Promise<void>;
@@ -438,18 +409,18 @@ type RuntimeAuthContext = AuthContext;
  */
 type RuntimePeerState = Omit<PeerState, 'nodeId'>;
 type RuntimePeerHealth = PeerHealth;
-type RuntimePeerLifecycleStatus = PeerLifecycleStatus;
+type PeerLifecycleStatus = PeerLifecycleStatus$1;
 type RuntimePeerScope = PeerScope;
 /**
  * App-facing peer session snapshot model. Runtime transport identifiers stay internal.
  */
-type RuntimePeerSessionSnapshot = Omit<PeerSessionSnapshot, 'nodeId'>;
-type RuntimeLocalDeviceInfo = LocalDeviceInfo;
+type PeerSessionSnapshot = Omit<PeerSessionSnapshot$1, 'nodeId'>;
+type LocalDeviceInfo = LocalDeviceInfo$1;
 type RuntimeRoomMember = RoomMember;
-type RuntimeDeviceConnectOptions = ManagedDeviceConnectOptions;
-type RuntimeJoinRoomOptions = JoinRoomOptions;
-type RuntimeChannelDescriptor = ChannelDescriptor$1;
-interface RuntimeConnectionTarget {
+type DeviceConnectOptions = ManagedDeviceConnectOptions;
+type JoinRoomOptions = JoinRoomOptions$1;
+type ChannelDescriptor = ChannelDescriptor$1;
+interface ConnectionTarget {
     ticket: string;
     timeoutMs?: number;
 }
@@ -458,7 +429,7 @@ interface RuntimeConnectionTarget {
  * gossip protocols. Implementations normally map these atomic operations to
  * IndexedDB; OpenRTC deliberately does not own a second browser database.
  */
-interface IrohBrowserProtocolStore {
+interface BrowserProtocolStore {
     loadIdentity(): Promise<{
         defaultAuthor: Uint8Array;
     } | null>;
@@ -470,17 +441,17 @@ interface IrohBrowserProtocolStore {
     importAuthor(authorId: string, author: Uint8Array): Promise<void>;
     importNamespace(capability: unknown): Promise<void>;
     deleteNamespace(namespaceId: string): Promise<void>;
-    applyEntryTransaction(mutation: unknown): Promise<void>;
+    applyEntry(mutation: unknown): Promise<void>;
     acknowledgeOutbox(operationId: string): Promise<void>;
     listBlobManifests(): Promise<unknown[]>;
     getBlobResumeState(contentHash: string): Promise<unknown | null>;
     readBlobRange(contentHash: string, offset: number, length: number): Promise<Uint8Array | null>;
     writeBlobRange(contentHash: string, size: number, chunkBytes: number, offset: number, bytes: Uint8Array): Promise<void>;
-    finalizeBlobIfComplete(contentHash: string): Promise<boolean>;
+    finalizeBlob(contentHash: string): Promise<boolean>;
     readBlobOutboardNode(contentHash: string, nodeId: string): Promise<Uint8Array | null>;
-    writeBlobOutboardNode(contentHash: string, nodeId: string, pair: Uint8Array): Promise<void>;
+    writeOutboard(contentHash: string, nodeId: string, pair: Uint8Array): Promise<void>;
     markBlobBaoReady(contentHash: string): Promise<void>;
-    writeBlobStagingChunk(sessionId: string, chunkIndex: number, bytes: Uint8Array): Promise<void>;
+    writeStagingChunk(sessionId: string, chunkIndex: number, bytes: Uint8Array): Promise<void>;
     finalizeBlobStaging(sessionId: string, contentHash: string, size: number, chunkBytes: number): Promise<void>;
     abortBlobStaging(sessionId: string): Promise<void>;
     deleteBlob(contentHash: string, force: boolean): Promise<boolean>;
@@ -489,7 +460,7 @@ interface IrohBrowserProtocolStore {
     finalizeBlobImport(contentHash: string, size: number, chunkBytes: number): Promise<void>;
     flush(): Promise<void>;
 }
-interface IrohNamespaceDescriptor {
+interface NamespaceDescriptor {
     namespaceId: string;
     capabilityKind: 'read' | 'write';
     capability: Uint8Array;
@@ -506,7 +477,7 @@ interface IrohDocEntry {
     contentHash: string;
     contentLength: number;
 }
-interface RuntimePeerConnectOptions {
+interface PeerConnectOptions {
     deviceId?: string;
     ticket?: string;
     scope?: RuntimePeerScope;
@@ -518,16 +489,16 @@ interface RuntimePeerConnectOptions {
      * manual-disconnect projection for this app session. User-initiated manual
      * reconnects should leave this unset and clear the exclusion explicitly.
      */
-    respectManualDisconnect?: boolean;
+    keepManualDisconnect?: boolean;
 }
-interface RuntimePeerStreamOptions {
+interface PeerStreamOptions {
     ticket?: string;
     scope?: RuntimePeerScope;
     channelId?: string;
     timeoutMs?: number;
 }
-type RuntimeLogicalChannelFraming = 'raw' | 'u32be';
-interface RuntimeScopedChannelOptions {
+type ChannelFraming = 'raw' | 'u32be';
+interface ScopedChannelOptions {
     peerId?: string;
     peerNodeId?: string;
     deviceId?: string | null;
@@ -535,7 +506,7 @@ interface RuntimeScopedChannelOptions {
     scope: RuntimePeerScope;
     channelId: string;
     timeoutMs?: number;
-    respectManualDisconnect?: boolean;
+    keepManualDisconnect?: boolean;
     /**
      * Reuse an application-ready route owned by an active capability and fail
      * if none exists. Protocol packages use this to open a named channel
@@ -548,9 +519,9 @@ interface RuntimeScopedChannelOptions {
      * apps do not need to choose raw transport APIs.
      */
     nativeLabel?: boolean;
-    framing?: RuntimeLogicalChannelFraming;
+    framing?: ChannelFraming;
 }
-interface RuntimeScopedLogicalChannel {
+interface ScopedLogicalChannel {
     channelId: string;
     peerId: string;
     connection: Connection;
@@ -564,7 +535,7 @@ interface RuntimeScopedLogicalChannel {
         hasSendOnWebRTC?: boolean;
         hasWebRTCTransport?: boolean;
         lastSendTransport?: ProtocolName | 'stream' | null;
-        framing: RuntimeLogicalChannelFraming;
+        framing: ChannelFraming;
         nativeLabel: boolean;
         delivery: 'reliable' | 'latest-state';
     };
@@ -572,46 +543,45 @@ interface RuntimeScopedLogicalChannel {
 /**
  * App-facing device status snapshot model. Runtime transport identifiers stay internal.
  */
-type RuntimeDeviceStatusSnapshot = Omit<DeviceStatusSnapshot, 'nodeId'>;
-type RuntimeDeviceStatus = RuntimeDeviceStatusSnapshot;
-type RuntimeDevicePresenceStatus = DevicePresenceStatus;
-type RuntimeIncomingStream = {
+type DeviceStatus = Omit<DeviceStatusSnapshot, 'nodeId'>;
+type DevicePresence = DevicePresenceStatus;
+type IncomingStream = {
     type: 'bi' | 'uni';
     stream: any;
     remoteNodeId: string;
     protocolHint?: 'control' | 'explicit' | 'native-main' | 'unknown';
-    channel?: IncomingStreamChannelMetadata | null;
+    channel?: ChannelMetadata | null;
 };
-type RuntimeConnectionEvent = {
+type ConnectionEvent = {
     type: 'connected' | 'disconnected';
     connectionId: string;
     localNodeId: string;
     remoteNodeId: string;
     transport: ProtocolName;
 };
-type RuntimeRawConnection = {
+type RawConnection = {
     connectionId: string;
     localNodeId: string;
     remoteNodeId: string;
 };
-type RuntimePresenceLoopOptions = {
+type PresenceLoopOptions = {
     deviceName?: string;
     ticket?: string;
     metadata?: string;
 };
-type RuntimeManagedSessionPlatform = 'native' | 'web';
-type RuntimeManagedSessionKind = 'app-user-device' | 'share-anonymous' | 'drive-grant-guest' | 'scoped-guest' | (string & {});
-type RuntimeAutoConnectPolicy = 'enabled' | 'disabled' | 'scoped-only';
-type RuntimePresencePolicy = 'online' | 'disabled';
-type RuntimeConnectionStateSnapshot = BackendConnectionState;
-type RuntimeApplicationPayloadReadinessOptions = ApplicationPayloadReadinessOptions;
-type RuntimeApplicationPayloadRouteOptions = ApplicationPayloadRouteOptions;
-type RuntimeUiConnectionStatus = 'connecting' | 'connected' | 'disconnected' | 'failed';
-interface RuntimePeerReadinessSnapshot {
+type SessionPlatform = 'native' | 'web';
+type SessionKind = 'app-user-device' | 'share-anonymous' | 'drive-grant-guest' | 'scoped-guest' | (string & {});
+type AutoConnectPolicy = 'enabled' | 'disabled' | 'scoped-only';
+type PresencePolicy = 'online' | 'disabled';
+type ConnectionState = BackendConnectionState;
+type ReadinessOptions = ApplicationPayloadReadinessOptions;
+type PayloadRouteOptions = ApplicationPayloadRouteOptions;
+type ConnectionStatus = 'connecting' | 'connected' | 'disconnected' | 'failed';
+interface PeerReadiness {
     requestedId: string;
     connected: boolean;
     settledReady: boolean;
-    status: RuntimeUiConnectionStatus;
+    status: ConnectionStatus;
     health: RuntimePeerHealth | 'unknown';
     deviceId?: string | null;
     deviceIdHint?: string | null;
@@ -620,21 +590,21 @@ interface RuntimePeerReadinessSnapshot {
     readinessReason?: string;
     scopes: string[];
 }
-interface RuntimeLocalDeviceProfile {
+interface DeviceProfile {
     deviceId: string | null;
     deviceName: string;
     platformType: string;
     userId: string | null;
-    capabilities: NonNullable<RuntimeLocalDeviceInfo['capabilities']>;
+    capabilities: NonNullable<LocalDeviceInfo['capabilities']>;
     lastSeenAt: string;
     localNodeId?: string | null;
 }
-interface RuntimeManagedSessionOptions {
-    platform: RuntimeManagedSessionPlatform;
-    sessionKind?: RuntimeManagedSessionKind;
+interface ManagedOptions {
+    platform: SessionPlatform;
+    sessionKind?: SessionKind;
     scope?: string | null;
-    autoConnectPolicy?: RuntimeAutoConnectPolicy;
-    presencePolicy?: RuntimePresencePolicy;
+    autoConnectPolicy?: AutoConnectPolicy;
+    presencePolicy?: PresencePolicy;
     userId?: string | null;
     deviceName?: string;
     localDeviceId?: string | null;
@@ -642,24 +612,10 @@ interface RuntimeManagedSessionOptions {
     autoConnect?: boolean;
     presence?: boolean;
 }
-interface RuntimeManagedSession {
-    mode: RuntimeManagedSessionPlatform;
-    device: RuntimeLocalDeviceProfile;
+interface ManagedSession {
+    mode: SessionPlatform;
+    device: DeviceProfile;
     stop: () => Promise<void>;
 }
-type ConnectionTarget = RuntimeConnectionTarget;
-type PeerConnectOptions = RuntimePeerConnectOptions;
-type PeerStreamOptions = RuntimePeerStreamOptions;
-type ScopedChannelOptions = RuntimeScopedChannelOptions;
-type ScopedLogicalChannel = RuntimeScopedLogicalChannel;
-type IncomingStream = RuntimeIncomingStream;
-type ConnectionEvent = RuntimeConnectionEvent;
-type RawConnection = RuntimeRawConnection;
-type PresenceLoopOptions = RuntimePresenceLoopOptions;
-type PeerReadiness = RuntimePeerReadinessSnapshot;
-type DeviceProfile = RuntimeLocalDeviceProfile;
-type SessionOptions = RuntimeManagedSessionOptions;
-type Session = RuntimeManagedSession;
-type ChannelDescriptor = RuntimeChannelDescriptor;
 
-export { type RuntimePeerSessionSnapshot as $, type AuthContext as A, type RuntimeSession as B, Connection as C, type RuntimeConnectionTarget as D, type RuntimePresenceLoopOptions as E, type ChannelDescriptor as F, type ConnectionEvent as G, type ConnectionTarget as H, type IrohBrowserProtocolStore as I, type DeviceProfile as J, type IncomingStream as K, type PeerReadiness as L, type PeerStreamOptions as M, type PresenceLoopOptions as N, type RawConnection as O, type PeerConnectOptions as P, type RuntimeApplicationPayloadRouteOptions as Q, type RuntimeChannelDescriptor as R, type RuntimeAuthContext as S, type RuntimeAutoConnectPolicy as T, type RuntimeDevicePresenceStatus as U, type RuntimeDeviceStatus as V, type RuntimeLogicalChannelFraming as W, type RuntimeManagedSessionKind as X, type RuntimeManagedSessionPlatform as Y, type RuntimePeerLifecycleStatus as Z, type RuntimePeerScope as _, type RuntimePeerState as a, type RuntimePresencePolicy as a0, type RuntimeUiConnectionStatus as a1, type ScopedChannelOptions as a2, type ScopedLogicalChannel as a3, type Session as a4, type SessionOptions as a5, type RuntimePeerConnectOptions as b, type RuntimePeerReadinessSnapshot as c, type RuntimePeerHealth as d, type RuntimePeerStreamOptions as e, type RuntimeIncomingStream as f, type RuntimeScopedChannelOptions as g, type RuntimeDevice as h, type RuntimeScopedLogicalChannel as i, type RuntimeConnectionStateSnapshot as j, type RuntimeApplicationPayloadReadinessOptions as k, type RuntimeConnectionEvent as l, type RuntimeManagedSessionOptions as m, type RuntimeManagedSession as n, type RuntimeDeviceStatusSnapshot as o, type RuntimeDeviceConnectOptions as p, type RuntimeLocalDeviceInfo as q, type RuntimeLocalDeviceProfile as r, type RuntimeRawConnection as s, type RuntimeJoinRoomOptions as t, type RuntimeRoomMember as u, type RuntimeClientOptions as v, type IrohNamespaceDescriptor as w, type IrohMutationReceipt as x, type IrohDocEntry as y, type RuntimeAuthIdentity as z };
+export { type AuthContext as A, type BrowserProtocolStore as B, type ChannelDescriptor as C, type DeviceStatus as D, type PeerLifecycleStatus as E, type PeerSessionSnapshot as F, type PresencePolicy as G, type RuntimeAuthContext as H, type IncomingStream as I, type JoinRoomOptions as J, type RuntimePeerScope as K, type LocalDeviceInfo as L, type ManagedOptions as M, type NamespaceDescriptor as N, type SessionKind as O, type PeerConnectOptions as P, type SessionPlatform as Q, type RuntimePeerState as R, type ScopedChannelOptions as S, Connection as a, type PeerReadiness as b, type RuntimePeerHealth as c, type PeerStreamOptions as d, type RuntimeDevice as e, type ScopedLogicalChannel as f, type ConnectionState as g, type ReadinessOptions as h, type ConnectionEvent as i, type ManagedSession as j, type DeviceConnectOptions as k, type DeviceProfile as l, type RawConnection as m, type RuntimeRoomMember as n, type RuntimeClientOptions as o, type IrohMutationReceipt as p, type IrohDocEntry as q, type RuntimeAuthIdentity as r, type RuntimeSession as s, type ConnectionTarget as t, type PresenceLoopOptions as u, type AutoConnectPolicy as v, type ChannelFraming as w, type ConnectionStatus as x, type DevicePresence as y, type PayloadRouteOptions as z };

package/dist/{types-Di034GVQ.d.ts → types-DCdYg7za.d.ts}

@@ -1,8 +1,8 @@
-import { OpenRTCPeerNamespace, OpenRTCChannelNamespace, OpenRTCDiagnosticsNamespace, OpenRTCDeviceNamespace } from './OpenRTCShared.js';
-import { R as RuntimeChannelDescriptor } from './types-DVNSd5B9.js';
-import { P as PlutoIrohConfiguration, a as PlutoRTCConfiguration, b as PlutoMoQConfiguration, T as TransportOptimization, c as ProtocolName } from './ITransport-WV6gGMnX.js';
+import { PeerNamespace, ChannelNamespace, DiagnosticsNamespace, DeviceNamespace } from './coreClient.js';
+import { C as ChannelDescriptor } from './types-D67HlF0p.js';
+import { P as PlutoIrohConfiguration, a as PlutoRTCConfiguration, b as PlutoMoQConfiguration, R as RouteOptimization, c as ProtocolName } from './ITransport-yaruAmx3.js';
 
-interface OpenRTCAuthProvider {
+interface AuthProvider {
     /** Registered provider ID from the developer app capability manifest. */
     readonly providerId?: string;
     /**
@@ -11,9 +11,8 @@ interface OpenRTCAuthProvider {
      * an ordinary access-token refresh. OpenRTC hashes this value together
      * with the app and installation-key thumbprint before persisting a lookup.
      *
-     * Optional during the 2.0 RC compatibility window. Providers that omit it
-     * use the assertion-first flow and remain correct, but cannot skip the
-     * assertion exchange on a cold process start.
+     * Optional because assertion-only providers remain valid, though they
+     * cannot skip the assertion exchange on a cold process start.
      */
     getSessionKey?(): Promise<string | null>;
     getAssertion(input: {
@@ -45,7 +44,7 @@ interface OpenRTCAuthProvider {
         sessionKey: string | null;
     }) => void): () => void;
 }
-interface OpenRTCEnrolledDevice {
+interface EnrolledDevice {
     deviceId: string;
     name?: string;
     platform?: string;
@@ -58,7 +57,7 @@ interface OpenRTCEnrolledDevice {
  * OpenRTC derives a useful browser default when these fields are omitted;
  * native hosts should pass the OS/device information reported by their host.
  */
-interface OpenRTCDeviceProfile {
+interface DeviceProfile {
     /** Human-readable label such as `Bryant's iPhone` or `Chrome on Android`. */
     name?: string;
     /** Raw OS/runtime label such as `ios`, `android`, `macos`, or `web`. */
@@ -66,7 +65,7 @@ interface OpenRTCDeviceProfile {
     /** Optional application-owned public presence metadata, bounded to 4 KiB. */
     metadata?: string;
 }
-interface OpenRTCAttestationProvider {
+interface AttestationProvider {
     readonly kind: 'firebase-app-check' | 'apple-app-attest' | 'play-integrity' | `custom:${string}`;
     /**
      * Describes what the provider actually signs. Reusable app-integrity
@@ -88,22 +87,22 @@ interface OpenRTCAttestationProvider {
  * load a CAPTCHA dependency; the host supplies a fresh token only when its
  * developer manifest requires anonymous capability verification.
  */
-interface OpenRTCBotVerificationProvider {
+interface BotVerificationProvider {
     getToken(input: {
         action: 'openrtc_capability';
         apiKey: string;
     }): Promise<string>;
 }
-interface OpenRTCUsageUpdate {
+interface UsageUpdate {
     sessionCreditsUsd: number;
     operation: string;
     estimated: boolean;
 }
-interface OpenRTCUsageWarning extends OpenRTCUsageUpdate {
+interface UsageWarning extends UsageUpdate {
     thresholdCreditsUsd: number;
     kind: 'warning' | 'session-limit';
 }
-interface OpenRTCTransportPreferences {
+interface Transports {
     iroh?: boolean | PlutoIrohConfiguration;
     webrtc?: boolean | PlutoRTCConfiguration;
     relay?: boolean;
@@ -116,7 +115,7 @@ interface OpenRTCTransportPreferences {
      */
     privacy?: 'direct' | 'relay-only';
     /** Optimize eligible routes for stability/cost or measured latency. */
-    optimizeFor?: TransportOptimization;
+    optimizeFor?: RouteOptimization;
     /**
      * Advanced native integration for hosts whose Rust process owns the
      * application protocol registry (for example, a Tauri file-transfer host).
@@ -126,31 +125,31 @@ interface OpenRTCTransportPreferences {
     /** Exact route order. Unsupported routes are skipped, never treated as failures. */
     priority?: readonly ProtocolName[];
 }
-interface OpenRTCOptions {
+interface Options {
     apiKey: string;
-    auth?: OpenRTCAuthProvider;
+    auth?: AuthProvider;
     trust?: {
-        attestation?: OpenRTCAttestationProvider;
-        botVerification?: OpenRTCBotVerificationProvider;
+        attestation?: AttestationProvider;
+        botVerification?: BotVerificationProvider;
     };
     usage?: {
         warnAtSessionCreditsUsd?: number;
         maxSessionCreditsUsd?: number;
-        onUsage?: (event: OpenRTCUsageUpdate) => void;
-        onWarning?: (warning: OpenRTCUsageWarning) => void;
+        onUsage?: (event: UsageUpdate) => void;
+        onWarning?: (warning: UsageWarning) => void;
     };
-    transports?: OpenRTCTransportPreferences;
+    transports?: Transports;
 }
-type OpenRTCAccessMode = 'capability' | 'authenticated';
-type OpenRTCLatestStateMode = 'reliable' | 'latest-state';
-interface OpenRTCConnection {
+type AccessMode = 'capability' | 'authenticated';
+type Delivery = 'reliable' | 'latest-state';
+interface Connection {
     readonly id: string;
     readonly peerId: string;
     send(message: unknown): Promise<void>;
     onMessage<T = unknown>(callback: (message: T) => void): () => void;
     onClose(callback: () => void): () => void;
 }
-interface OpenRTCChannel<T> {
+interface Channel<T> {
     send(message: T): Promise<void>;
     sendTo(peerId: string, message: T): Promise<void>;
     onMessage(callback: (event: {
@@ -158,7 +157,7 @@ interface OpenRTCChannel<T> {
         message: T;
     }) => void): () => void;
 }
-interface OpenRTCState<T> {
+interface State<T> {
     /** Replace the locally published value. Delivery is best-effort and coalesced. */
     set(value: T): void;
     /** A null value means the peer disconnected. */
@@ -167,40 +166,40 @@ interface OpenRTCState<T> {
         value: T | null;
     }) => void): () => void;
 }
-interface OpenRTCCapabilityHandle {
+interface Avenue {
     readonly kind: 'devices' | 'space' | 'room' | 'ticket';
     readonly id: string;
-    readonly peers: OpenRTCPeerNamespace;
-    readonly channels: OpenRTCChannelNamespace;
-    readonly diagnostics: OpenRTCDiagnosticsNamespace;
+    readonly peers: PeerNamespace;
+    readonly channels: ChannelNamespace;
+    readonly diagnostics: DiagnosticsNamespace;
     readonly closed: boolean;
-    state<T>(name: string): OpenRTCState<T>;
-    channel<T>(name: string): OpenRTCChannel<T>;
+    state<T>(name: string): State<T>;
+    channel<T>(name: string): Channel<T>;
     /** Observe current and future connections without taking lifecycle ownership. */
-    onConnection(callback: (connection: OpenRTCConnection) => void): () => void;
+    onConnection(callback: (connection: Connection) => void): () => void;
     close(): Promise<void>;
 }
-interface OpenRTCDevicesHandle extends OpenRTCCapabilityHandle {
+interface Devices extends Avenue {
     readonly kind: 'devices';
-    localId(): ReturnType<OpenRTCDeviceNamespace['localId']>;
-    localInfo(): ReturnType<OpenRTCDeviceNamespace['localInfo']>;
-    list(): ReturnType<OpenRTCDeviceNamespace['list']>;
-    listWithStatus(): ReturnType<OpenRTCDeviceNamespace['listWithStatus']>;
-    watch: OpenRTCDeviceNamespace['watch'];
-    connect: OpenRTCDeviceNamespace['connect'];
-    disconnect: OpenRTCDeviceNamespace['disconnect'];
+    localId(): ReturnType<DeviceNamespace['localId']>;
+    localInfo(): ReturnType<DeviceNamespace['localInfo']>;
+    list(): ReturnType<DeviceNamespace['list']>;
+    listWithStatus(): ReturnType<DeviceNamespace['listWithStatus']>;
+    watch: DeviceNamespace['watch'];
+    connect: DeviceNamespace['connect'];
+    disconnect: DeviceNamespace['disconnect'];
 }
-interface OpenRTCSpaceHandle extends OpenRTCCapabilityHandle {
+interface Space extends Avenue {
     readonly kind: 'space';
-    readonly delivery: OpenRTCLatestStateMode;
+    readonly delivery: Delivery;
     leave(): Promise<void>;
 }
-interface OpenRTCRoomHandle extends OpenRTCCapabilityHandle {
+interface Room extends Avenue {
     readonly kind: 'room';
     readonly membership: 'ephemeral' | 'durable';
     leave(): Promise<void>;
 }
-interface OpenRTCTicketHandle extends OpenRTCCapabilityHandle {
+interface Ticket extends Avenue {
     readonly kind: 'ticket';
     /**
      * Opaque, install-bound OpenRTC capability credential. This is not a
@@ -211,41 +210,44 @@ interface OpenRTCTicketHandle extends OpenRTCCapabilityHandle {
      */
     readonly token: string;
 }
-interface OpenRTCDevicesStartOptions {
-    auth?: OpenRTCAuthProvider;
+interface DeviceOptions {
+    auth?: AuthProvider;
     autoConnect?: 'none' | 'online';
     /** Optional local profile; it does not alter the durable device identity. */
-    profile?: OpenRTCDeviceProfile;
+    profile?: DeviceProfile;
     maxPeers?: number;
     /** Requires the app manifest's advanced-fanout opt-in. */
     advancedFanout?: boolean;
 }
-interface OpenRTCSpaceJoinOptions {
+interface SpaceOptions {
     access?: 'capability';
     identity?: 'ephemeral';
-    payload?: OpenRTCLatestStateMode;
+    payload?: Delivery;
     maxPeers?: number;
     /** Requires the app manifest's advanced-fanout opt-in. */
     advancedFanout?: boolean;
 }
-interface OpenRTCRoomJoinOptions {
-    access?: OpenRTCAccessMode;
+interface RoomOptions {
+    access?: AccessMode;
     membership?: 'ephemeral' | 'durable';
-    auth?: OpenRTCAuthProvider;
+    auth?: AuthProvider;
     maxPeers?: number;
-    /** Requires the app manifest's advanced-fanout opt-in. */
+    /**
+     * Requires the app manifest's reviewed advanced-fanout opt-in. Rooms then
+     * use a four-neighbor sparse overlay with bounded named-channel gossip.
+     */
     advancedFanout?: boolean;
 }
-interface OpenRTCTicketIssueOptions {
+interface TicketOptions {
     maxPeers?: number;
     /** Requires the app manifest's advanced-fanout opt-in. */
     advancedFanout?: boolean;
 }
-interface OpenRTCChannelCatalog {
-    register(descriptor: RuntimeChannelDescriptor): () => void;
-    list(): readonly RuntimeChannelDescriptor[];
+interface Channels {
+    register(descriptor: ChannelDescriptor): () => void;
+    list(): readonly ChannelDescriptor[];
 }
-interface OpenRTCUsageNamespace {
+interface Usage {
     estimate(input: {
         operation: string;
         units?: number;
@@ -255,37 +257,37 @@ interface OpenRTCUsageNamespace {
     };
     readonly sessionCreditsUsd: number;
 }
-interface OpenRTCClient {
+interface Client {
     readonly devices: {
         /**
          * Returns this installation's durable, app-scoped device ID without
          * starting a capability or performing network work.
          */
         localId(): Promise<string>;
-        start(options?: OpenRTCDevicesStartOptions): Promise<OpenRTCDevicesHandle>;
+        start(options?: DeviceOptions): Promise<Devices>;
         listEnrolled(options?: {
-            auth?: OpenRTCAuthProvider;
-        }): Promise<OpenRTCEnrolledDevice[]>;
+            auth?: AuthProvider;
+        }): Promise<EnrolledDevice[]>;
         revoke(deviceId: string, options?: {
-            auth?: OpenRTCAuthProvider;
+            auth?: AuthProvider;
         }): Promise<void>;
         revokeAll(options?: {
-            auth?: OpenRTCAuthProvider;
+            auth?: AuthProvider;
             exceptCurrent?: boolean;
         }): Promise<void>;
     };
     readonly spaces: {
-        join(id: string, options?: OpenRTCSpaceJoinOptions): Promise<OpenRTCSpaceHandle>;
+        join(id: string, options?: SpaceOptions): Promise<Space>;
     };
     readonly rooms: {
-        join(id: string, options?: OpenRTCRoomJoinOptions): Promise<OpenRTCRoomHandle>;
+        join(id: string, options?: RoomOptions): Promise<Room>;
     };
     readonly tickets: {
-        issue(id: string, options?: OpenRTCTicketIssueOptions): Promise<OpenRTCTicketHandle>;
+        issue(id: string, options?: TicketOptions): Promise<Ticket>;
     };
-    readonly channels: OpenRTCChannelCatalog;
-    readonly usage: OpenRTCUsageNamespace;
+    readonly channels: Channels;
+    readonly usage: Usage;
     close(): Promise<void>;
 }
 
-export type { OpenRTCOptions as O, OpenRTCClient as a, OpenRTCAccessMode as b, OpenRTCAttestationProvider as c, OpenRTCAuthProvider as d, OpenRTCBotVerificationProvider as e, OpenRTCCapabilityHandle as f, OpenRTCChannel as g, OpenRTCChannelCatalog as h, OpenRTCConnection as i, OpenRTCDeviceProfile as j, OpenRTCDevicesHandle as k, OpenRTCDevicesStartOptions as l, OpenRTCEnrolledDevice as m, OpenRTCLatestStateMode as n, OpenRTCRoomHandle as o, OpenRTCRoomJoinOptions as p, OpenRTCSpaceHandle as q, OpenRTCSpaceJoinOptions as r, OpenRTCState as s, OpenRTCTicketHandle as t, OpenRTCTicketIssueOptions as u, OpenRTCTransportPreferences as v, OpenRTCUsageNamespace as w, OpenRTCUsageUpdate as x, OpenRTCUsageWarning as y };
+export type { AttestationProvider as A, BotVerificationProvider as B, Client as C, DeviceOptions as D, EnrolledDevice as E, Options as O, Room as R, Space as S, Ticket as T, UsageUpdate as U, AuthProvider as a, Avenue as b, Channel as c, Connection as d, DeviceProfile as e, Devices as f, RoomOptions as g, SpaceOptions as h, State as i, TicketOptions as j, Transports as k, UsageWarning as l };