openrtc 1.0.26 → 2.0.0-rc.0

package/dist/{assembly-CscFVHYK.d.ts → types-BDc7AZYI.d.ts}

@@ -1,7 +1,7 @@
+import { H as GrantScope, q as ISignalingBackend, Y as ConnectDeviceHooks, Z as ConnectDeviceOptions, _ as ConnectDeviceResult, u as ManagedConnectionRecord, m as PeerSessionSnapshot, v as ResolvedPeerIdentity, $ as AppLimits, N as NativeConnectParams, z as NativeConnectResult, E as ExplicitFileDataSendParams } from './types-BVJr065k.js';
 import { A as AuthContext } from './IEngineBridge-BbsT8hof.js';
-import { G as GrantScope, I as ISignalingBackend, b as ConnectDeviceHooks, c as ConnectDeviceOptions, C as ConnectDeviceResult, M as ManagedConnectionRecord, P as PeerSessionSnapshot, R as ResolvedPeerIdentity, Y as AppLimits, p as NativeConnectParams, q as NativeConnectResult, E as ExplicitFileDataSendParams } from './types-zT2QwuCv.js';
-import { h as RuntimePeerState, s as RuntimeConnectionStateSnapshot, j as RuntimePeerReadinessSnapshot, i as RuntimePeerConnectOptions, C as Connection, n as RuntimeIncomingStream, R as RuntimeClientOptions, H as RuntimeAuthIdentity, f as RuntimeLocalDeviceInfo, g as RuntimeLocalDeviceProfile, c as RuntimeDevice, a as RuntimeManagedSessionOptions, b as RuntimeManagedSession, d as RuntimeDeviceStatusSnapshot, e as RuntimeDeviceConnectOptions, X as RuntimeSession, q as RuntimeJoinRoomOptions, r as RuntimeRoomMember, K as RuntimeConnectionTarget, o as RuntimeScopedChannelOptions, p as RuntimeScopedLogicalChannel, m as RuntimePeerStreamOptions, v as RuntimeRawConnection, l as RuntimeChannelDescriptor, V as RuntimePresenceLoopOptions, k as RuntimePeerHealth, t as RuntimeApplicationPayloadReadinessOptions, u as RuntimeConnectionEvent } from './types-BJU2GoVb.js';
-import { R as RuntimeCapabilities, a as RuntimeCapabilityProfile } from './capabilities-CaqXOIUU.js';
+import { a as RuntimePeerState, b as RuntimeConnectionStateSnapshot, c as RuntimePeerReadinessSnapshot, d as RuntimePeerConnectOptions, C as Connection, e as RuntimeIncomingStream, R as RuntimeClientOptions, f as RuntimeAuthIdentity, g as RuntimeLocalDeviceInfo, h as RuntimeLocalDeviceProfile, i as RuntimeDevice, j as RuntimeManagedSessionOptions, k as RuntimeManagedSession, l as RuntimeDeviceStatusSnapshot, m as RuntimeDeviceConnectOptions, n as RuntimeSession, o as RuntimeJoinRoomOptions, p as RuntimeRoomMember, q as RuntimeConnectionTarget, r as RuntimeScopedChannelOptions, s as RuntimeScopedLogicalChannel, t as RuntimePeerStreamOptions, u as RuntimeRawConnection, v as RuntimeChannelDescriptor, w as RuntimePresenceLoopOptions, x as RuntimePeerHealth, y as RuntimeApplicationPayloadReadinessOptions, z as RuntimeConnectionEvent } from './types-BUXwspL0.js';
+import { R as RuntimeCapabilities, a as RuntimeCapabilityProfile } from './capabilities-YSskrE8H.js';
 
 /**
  * Coalesced peer reconciliation scheduler and full reconcile orchestration.
@@ -75,30 +75,6 @@ interface Session {
     /** Tear down all subscriptions and disconnect scope-tagged connections. */
     dispose(): void;
 }
-declare class ScopedSession implements Session {
-    readonly scope: string;
-    private _disposed;
-    private readonly runtime;
-    private readonly allowAllPeers;
-    private readonly allowedPeerIds;
-    private readonly cleanups;
-    constructor(runtime: RuntimeClient, options: SessionOptions);
-    get disposed(): boolean;
-    /** Returns true when this session should receive events for this peer. */
-    private matchesPeer;
-    private matchesConnectionState;
-    private matchesStream;
-    watchPeerStates(callback: (peers: RuntimePeerState[]) => void): () => void;
-    onConnectionStateChange(callback: (state: RuntimeConnectionStateSnapshot) => void): (() => void) | Promise<() => void>;
-    listConnectedPeers(): RuntimePeerState[];
-    getPeerReadiness(peerId: string): Promise<RuntimePeerReadinessSnapshot>;
-    connectPeer(options: RuntimePeerConnectOptions): Promise<Connection>;
-    disconnectPeer(peerId: string): Promise<void>;
-    onIncomingStream(callback: (stream: RuntimeIncomingStream) => void): () => void;
-    dispose(): void;
-    private releaseScopedPeersOnDispose;
-    private assertNotDisposed;
-}
 
 /**
  * Phase 4 of the OpenRTC auth + connection remediation plan
@@ -320,6 +296,7 @@ declare class RuntimeClient {
     private managedSessionOptions;
     private managedSessionTransition;
     private managedSessionStartInFlight;
+    private terminalShutdown;
     private readonly managedReconciliationTasks;
     private managedReconciliationTimer;
     private readonly managedReconciliationFollowupTimers;
@@ -617,6 +594,14 @@ declare class RuntimeClient {
     connect(): Promise<void>;
     /** Disconnect from the runtime (alias for stop()) */
     disconnect(): void;
+    /**
+     * Await the provider-neutral terminal lifecycle before destroying this
+     * runtime instance. Consumers that may create a replacement runtime in the
+     * same page should use this instead of composing setOffline(), stop(), and
+     * destroy() themselves: the active adapter owns presence, coordination
+     * sockets, session readers, and scoped connection actors.
+     */
+    shutdown(): Promise<void>;
     /**
      * Terminal teardown of the runtime instance. Unlike stop()/disconnect()
      * (which only stop the listen loop and are used during normal operation),
@@ -715,4 +700,437 @@ interface PlutoRuntimeAssembly<TBackend extends RuntimeAdapterWithAuth = Runtime
     setAutoConnectExcluded(deviceId: string, excluded: boolean): Promise<void>;
 }
 
-export { DriveGrantActorError as D, OPENRTC_RUNTIME_POLICY as O, type PeerReconciliationStats as P, RuntimeClient as R, ScopedSession as S, type RuntimePolicySnapshot as a, type PlutoRuntimeAssembly as b, type Session as c, type SessionOptions as d, type RuntimeFactoryOptions as e, type DriveGrantActorErrorKind as f, getRuntimePolicy as g, DriveGrantActorHandle as h, type DriveGrantActorHandleOptions as i, DriveGrantActorRegistry as j, type DriveGrantActorState as k, type DriveGrantClose as l, type DriveGrantDial as m, type DriveGrantConnectionKey as n, type DriveGrantLogicalChannelHandle as o, type DriveGrantPreferredTransport as p, driveGrantConnectionKey as q, driveGrantConnectionKeyToString as r };
+type OpenRTCChannelConnectOptions = Omit<RuntimeScopedChannelOptions, 'scope' | 'deviceId' | 'ticket'> & {
+    /**
+     * Device selected from `client.devices.*`. Passing the device object lets
+     * OpenRTC reuse its current ticket for native and ticket-gated routes.
+     */
+    device?: string | RuntimeDevice;
+    deviceId?: string | null;
+    ticket?: string;
+    /**
+     * Logical channel lifecycle scope. Most app channels should use the default
+     * `session`; pass a custom scope only when you intentionally manage peer
+     * lifecycle separately from the channel.
+     */
+    scope?: RuntimeScopedChannelOptions['scope'];
+};
+type OpenRTCDeviceSessionOptions = Omit<RuntimeManagedSessionOptions, 'platform'> & {
+    /**
+     * Runtime host for the managed user-device session. Normal apps can omit
+     * this: `OpenRTC(...)` defaults to `web`, and `OpenRTC.native(...)` defaults
+     * to `native`.
+     */
+    platform?: RuntimeManagedSessionOptions['platform'];
+};
+interface OpenRTCDeviceNamespace {
+    startSession(options?: OpenRTCDeviceSessionOptions): Promise<RuntimeManagedSession>;
+    stopSession(options?: {
+        preserveBackendSession?: boolean;
+    }): Promise<void>;
+    list(): Promise<RuntimeDevice[]>;
+    listWithStatus(): Promise<RuntimeDeviceStatusSnapshot[]>;
+    watch(callback: (devices: RuntimeDevice[]) => void): () => void;
+    watchWithStatus(callback: (devices: RuntimeDeviceStatusSnapshot[]) => void): () => void;
+    connect(device: string | RuntimeDevice, options?: RuntimeDeviceConnectOptions): Promise<ConnectDeviceResult>;
+    /**
+     * @deprecated Use `devices.connect()`. Retry and route recovery are owned by
+     * OpenRTC; legacy consumer-provided connection hooks are ignored.
+     */
+    connectWithRetry(device: string | RuntimeDevice, hooks: ConnectDeviceHooks, options: ConnectDeviceOptions): Promise<ConnectDeviceResult>;
+    disconnect(deviceId: string): Promise<void>;
+    update(deviceId: string, updates: {
+        deviceName?: string;
+        capabilities?: RuntimeDevice['capabilities'];
+        metadata?: string;
+    }): Promise<void>;
+    delete(deviceId: string): Promise<void>;
+    localId(): Promise<string | null>;
+    localInfo(): Promise<RuntimeLocalDeviceInfo | null>;
+    localProfile(options?: {
+        deviceName?: string;
+        localDeviceId?: string | null;
+        platform?: 'native' | 'web';
+        userId?: string | null;
+    }): Promise<RuntimeLocalDeviceProfile>;
+    updateLocalName(deviceName: string): Promise<RuntimeLocalDeviceInfo | null>;
+}
+interface OpenRTCPeerNamespace {
+    watch(callback: (peers: RuntimePeerState[]) => void): () => void;
+    watchLifecycle(callback: (peers: RuntimePeerState[]) => void): () => void;
+    get(id: string): RuntimePeerState | undefined;
+    listConnected(): RuntimePeerState[];
+    connect(options: RuntimePeerConnectOptions): Promise<Connection>;
+    disconnect(id: string, scope?: string): Promise<void>;
+    forceDisconnect(id: string): Promise<void>;
+    session(id: string): Promise<PeerSessionSnapshot | null>;
+    sessions(): Promise<PeerSessionSnapshot[]>;
+    waitConnected(id: string, timeoutMs?: number): Promise<PeerSessionSnapshot | null>;
+    readiness(id: string, timeoutMs?: number): Promise<RuntimePeerReadinessSnapshot>;
+    health(id: string): Promise<RuntimePeerHealth>;
+    identity(id: string): Promise<ResolvedPeerIdentity>;
+    addScope(id: string, scope?: string): RuntimePeerState | undefined;
+    releaseScope(id: string, scope?: string): RuntimePeerState | undefined;
+    scopes(id: string): string[];
+    refresh(): Promise<RuntimePeerState[]>;
+}
+interface OpenRTCChannelNamespace {
+    register(descriptor: RuntimeChannelDescriptor): void;
+    unregister(channelId: string): void;
+    list(): RuntimeChannelDescriptor[];
+    openBi(id: string, channelId: string, options?: Omit<RuntimePeerStreamOptions, 'channelId'>): Promise<{
+        connection: Connection;
+        readable: ReadableStream<Uint8Array>;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    openUni(id: string, channelId: string, options?: Omit<RuntimePeerStreamOptions, 'channelId'>): Promise<{
+        connection: Connection;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    onIncoming(callback: (stream: RuntimeIncomingStream) => boolean | void): () => void;
+    onIncomingChannel(channelId: string, callback: (stream: RuntimeIncomingStream & {
+        channel: NonNullable<RuntimeIncomingStream['channel']>;
+    }) => boolean | void): () => void;
+    connect(options: OpenRTCChannelConnectOptions): Promise<RuntimeScopedLogicalChannel>;
+    connectScoped(options: RuntimeScopedChannelOptions): Promise<RuntimeScopedLogicalChannel>;
+}
+interface OpenRTCRoomNamespace {
+    create(roomId?: string): Promise<string>;
+    join(roomId: string, options?: RuntimeJoinRoomOptions): Promise<Connection[]>;
+    leave(roomId: string): Promise<void>;
+    watch(roomId: string, callback: (members: RuntimeRoomMember[]) => void): () => void;
+    members(roomId: string): Promise<RuntimeRoomMember[]>;
+}
+interface OpenRTCTicketNamespace {
+    raw(): Promise<string>;
+    share(options?: {
+        maxConnections?: number;
+    }): Promise<string>;
+    grant(scope: GrantScope, options?: {
+        maxConnections?: number;
+    }): Promise<string>;
+    revoke(scope: GrantScope): Promise<string[]>;
+}
+interface OpenRTCDiagnosticsNamespace {
+    status(): Promise<{
+        runtime: 'tauri' | 'browser' | 'unknown';
+        wasmLoaded: boolean;
+        localNodeId?: string;
+        userId?: string;
+    }>;
+    policy(): RuntimePolicySnapshot;
+    capabilities(): RuntimeCapabilities;
+    capabilityProfile(): RuntimeCapabilityProfile;
+    connectionStates(): Promise<RuntimeConnectionStateSnapshot[]>;
+    onConnectionStateChange(callback: (state: RuntimeConnectionStateSnapshot) => void): Promise<() => void> | (() => void);
+    connections(): Connection[];
+    applicationReadyConnections(options?: RuntimeApplicationPayloadReadinessOptions): Connection[];
+    onConnection(callback: (connection: Connection) => void): () => void;
+    onDisconnection(callback: (connection: Connection) => void): () => void;
+    onConnectionEvent(callback: (event: RuntimeConnectionEvent) => void): () => void;
+    forceReconnectSnapshot(): void;
+    peerReconciliation(): Readonly<PeerReconciliationStats>;
+}
+interface OpenRTCAdvancedNamespace {
+    readonly runtime: RuntimeClient;
+    readonly assembly: PlutoRuntimeAssembly;
+    nodeId(): Promise<string>;
+    nodeIdFromTicket(ticket: string): Promise<string | null>;
+    endpointTicket(): Promise<string>;
+    connectRaw(target: {
+        ticket: string;
+        timeoutMs?: number;
+    }): Promise<RuntimeRawConnection>;
+    openBi(nodeId: string): Promise<{
+        readable: ReadableStream<Uint8Array>;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    openUni(nodeId: string): Promise<WritableStream<Uint8Array>>;
+    isConnected(nodeId: string): Promise<boolean>;
+    disconnectNode(nodeId: string): Promise<void>;
+    setAutoConnectExcluded(deviceId: string, excluded: boolean): Promise<void>;
+    notifyNetworkChange(reason?: string): Promise<void>;
+}
+/**
+ * OpenRTCClient extends RuntimeClient with auth helpers that were
+ * previously only available on PlutoRuntimeAssembly.
+ *
+ * This is the unified type returned by OpenRTC() and OpenRTC.native().
+ */
+interface OpenRTCClient$1 extends RuntimeClient {
+    readonly devices: OpenRTCDeviceNamespace;
+    readonly peers: OpenRTCPeerNamespace;
+    readonly channels: OpenRTCChannelNamespace;
+    readonly rooms: OpenRTCRoomNamespace;
+    readonly tickets: OpenRTCTicketNamespace;
+    readonly diagnostics: OpenRTCDiagnosticsNamespace;
+    readonly advanced: OpenRTCAdvancedNamespace;
+    /** @deprecated Use setAuth() instead */
+    setAuthContext(context: AuthContext | null): Promise<void>;
+    /** Set auth context for the runtime */
+    setAuth(context: AuthContext | null): Promise<void>;
+    /** Sync Pluto-hosted auth to the runtime */
+    syncPlutoAuth(options?: {
+        userId?: string | null;
+        forceRefresh?: boolean;
+    }): Promise<void>;
+    /** Bind Pluto auth host to auto-sync on token changes */
+    bindPlutoAuthHost(): () => void;
+    /** Sign in via Pluto SSO */
+    signIn(): Promise<void>;
+    /** Sign out and clear auth context */
+    signOut(): Promise<void>;
+    /**
+     * @deprecated Use `client.devices.startSession(...)` for the public
+     * user-device avenue lifecycle. This top-level method remains for
+     * RuntimeClient compatibility and advanced integrations.
+     */
+    startManagedSession(options: RuntimeManagedSessionOptions): Promise<RuntimeManagedSession>;
+    /**
+     * @deprecated Use `client.devices.stopSession(...)` for the public
+     * user-device avenue lifecycle.
+     */
+    stopManagedSession(options?: {
+        preserveBackendSession?: boolean;
+    }): Promise<void>;
+    /** @deprecated Use `client.rooms.create(...)`. */
+    createRoom(roomId?: string): Promise<string>;
+    /** @deprecated Use `client.rooms.join(...)`. */
+    joinRoom(roomId: string, options?: RuntimeJoinRoomOptions): Promise<Connection[]>;
+    /** @deprecated Use `client.rooms.leave(...)`. */
+    leaveRoom(roomId: string): Promise<void>;
+    /** @deprecated Use `client.rooms.watch(...)`. */
+    watchRoom(roomId: string, callback: (members: RuntimeRoomMember[]) => void): () => void;
+    /** @deprecated Use `client.rooms.members(...)`. */
+    getRoomMembers(roomId: string): Promise<RuntimeRoomMember[]>;
+    /** @deprecated Use `client.tickets.raw(...)`. */
+    getInvite(): Promise<string>;
+    /** @deprecated Use `client.tickets.raw(...)`. */
+    getTicket(): Promise<string>;
+    /** @deprecated Use `client.tickets.share(...)` or `client.tickets.grant(...)`. */
+    getTicketWithToken(scope: GrantScope, maxConnections?: number): Promise<string>;
+    /** @deprecated Use `client.tickets.revoke(...)`. */
+    revokeTokensByScope(scope: GrantScope): Promise<string[]>;
+    /** @deprecated Use `client.peers.connect(...)`. */
+    connectPeer(options: RuntimePeerConnectOptions): Promise<Connection>;
+    /** @deprecated Use `client.peers.connect(...)`. */
+    connectTo(options: RuntimePeerConnectOptions): Promise<Connection>;
+    /** @deprecated Use `client.peers.waitConnected(...)`. */
+    waitForConnectedPeer(id: string, timeoutMs?: number): Promise<PeerSessionSnapshot | null>;
+    /** @deprecated Use `client.channels.connect(...)`; use `client.channels.connectScoped(...)` only for custom lifecycle scopes. */
+    connectScopedChannel(options: RuntimeScopedChannelOptions): Promise<RuntimeScopedLogicalChannel>;
+    /** @deprecated Use `client.channels.openBi(...)`. */
+    openPeerBi(id: string, options?: RuntimePeerStreamOptions): Promise<{
+        connection: Connection;
+        readable: ReadableStream<Uint8Array>;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    /** @deprecated Use `client.channels.openUni(...)`. */
+    openPeerUni(id: string, options?: RuntimePeerStreamOptions): Promise<{
+        connection: Connection;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    /**
+     * Access to the underlying PlutoRuntimeAssembly for backward compatibility.
+     * @deprecated Access methods directly on the client instead.
+     */
+    readonly runtime: RuntimeClient;
+    /**
+     * Access to the underlying PlutoRuntimeAssembly for backward compatibility.
+     * @internal
+     */
+    readonly _assembly: PlutoRuntimeAssembly;
+}
+
+interface OpenRTCAuthProvider {
+    /** Registered provider ID from the developer app capability manifest. */
+    readonly providerId?: string;
+    getAssertion(input: {
+        audience: 'https://api.openrtc.app/v2/assertions/exchange';
+        forceRefresh: boolean;
+    }): Promise<string | null>;
+    /**
+     * Optional identity-epoch observer. Notify only when the signed-in
+     * principal/session changes (login, logout, account switch, or explicit
+     * revocation). Do not notify for ordinary OAuth/Firebase access-token
+     * refreshes: OpenRTC refreshes its own avenue grant in place.
+     */
+    subscribe?(listener: () => void): () => void;
+}
+interface OpenRTCAttestationProvider {
+    readonly kind: 'firebase-app-check' | 'apple-app-attest' | 'play-integrity' | `custom:${string}`;
+    /**
+     * Describes what the provider actually signs. Reusable app-integrity
+     * tokens (for example Firebase App Check) do not become request-bound just
+     * because OpenRTC supplies an enrollment challenge. The server derives and
+     * enforces the authoritative binding from the registered provider kind;
+     * this field keeps host integrations and diagnostics honest.
+     */
+    readonly evidenceBinding: 'app-session' | 'request-challenge';
+    getEvidence(input: {
+        challenge: string;
+        apiKey: string;
+    }): Promise<{
+        token: string;
+    }>;
+}
+/**
+ * Optional consumer-owned bot challenge. Core OpenRTC does not render a UI or
+ * load a CAPTCHA dependency; the host supplies a fresh token only when its
+ * developer manifest requires anonymous capability verification.
+ */
+interface OpenRTCBotVerificationProvider {
+    getToken(input: {
+        action: 'openrtc_capability';
+        apiKey: string;
+    }): Promise<string>;
+}
+interface OpenRTCUsageUpdate {
+    sessionCreditsUsd: number;
+    operation: string;
+    estimated: boolean;
+}
+interface OpenRTCUsageWarning extends OpenRTCUsageUpdate {
+    thresholdCreditsUsd: number;
+    kind: 'warning' | 'session-limit';
+}
+interface OpenRTCTransportPreferences {
+    iroh?: boolean;
+    webrtc?: boolean;
+    relay?: boolean;
+    moq?: boolean;
+    ble?: boolean;
+    /**
+     * Advanced privacy mode. `relay-only` suppresses direct Iroh addresses,
+     * local discovery, and host/srflx WebRTC candidates. It also requires the
+     * developer manifest's relay opt-in.
+     */
+    privacy?: 'direct' | 'relay-only';
+    /**
+     * Advanced native integration for hosts whose Rust process owns the
+     * application protocol registry (for example, a Tauri file-transfer host).
+     * Normal SDK consumers should leave this disabled.
+     */
+    nativeHostProtocols?: boolean;
+    priority?: readonly ('iroh' | 'webrtc' | 'moq' | 'ble')[];
+}
+interface OpenRTCOptions {
+    apiKey: string;
+    auth?: OpenRTCAuthProvider;
+    trust?: {
+        attestation?: OpenRTCAttestationProvider;
+        botVerification?: OpenRTCBotVerificationProvider;
+    };
+    usage?: {
+        warnAtSessionCreditsUsd?: number;
+        maxSessionCreditsUsd?: number;
+        onUsage?: (event: OpenRTCUsageUpdate) => void;
+        onWarning?: (warning: OpenRTCUsageWarning) => void;
+    };
+    transports?: OpenRTCTransportPreferences;
+}
+type OpenRTCAccessMode = 'capability' | 'authenticated';
+type OpenRTCLatestStateMode = 'reliable' | 'latest-state';
+interface OpenRTCCapabilityHandle {
+    readonly kind: 'devices' | 'space' | 'room' | 'ticket';
+    readonly id: string;
+    readonly peers: OpenRTCPeerNamespace;
+    readonly channels: OpenRTCChannelNamespace;
+    readonly diagnostics: OpenRTCDiagnosticsNamespace;
+    readonly closed: boolean;
+    close(): Promise<void>;
+}
+interface OpenRTCDevicesHandle extends OpenRTCCapabilityHandle {
+    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'];
+}
+interface OpenRTCSpaceHandle extends OpenRTCCapabilityHandle {
+    readonly kind: 'space';
+    readonly delivery: OpenRTCLatestStateMode;
+    leave(): Promise<void>;
+}
+interface OpenRTCRoomHandle extends OpenRTCCapabilityHandle {
+    readonly kind: 'room';
+    readonly membership: 'ephemeral' | 'durable';
+    leave(): Promise<void>;
+}
+interface OpenRTCTicketHandle extends OpenRTCCapabilityHandle {
+    readonly kind: 'ticket';
+    readonly token: string;
+}
+interface OpenRTCDevicesStartOptions {
+    auth?: OpenRTCAuthProvider;
+    autoConnect?: 'none' | 'online';
+    /** Optional local profile; it does not alter the durable device identity. */
+    profile?: {
+        name?: string;
+        /**
+         * Optional application-owned public presence metadata. It is bounded
+         * to 4 KiB and folded into the initial connection/presence operation.
+         */
+        metadata?: string;
+    };
+    maxPeers?: number;
+    /** Requires the app manifest's advanced-fanout opt-in. */
+    advancedFanout?: boolean;
+}
+interface OpenRTCSpaceJoinOptions {
+    access?: 'capability';
+    identity?: 'ephemeral';
+    payload?: OpenRTCLatestStateMode;
+    maxPeers?: number;
+    /** Requires the app manifest's advanced-fanout opt-in. */
+    advancedFanout?: boolean;
+}
+interface OpenRTCRoomJoinOptions {
+    access?: OpenRTCAccessMode;
+    membership?: 'ephemeral' | 'durable';
+    auth?: OpenRTCAuthProvider;
+    maxPeers?: number;
+    /** Requires the app manifest's advanced-fanout opt-in. */
+    advancedFanout?: boolean;
+}
+interface OpenRTCTicketIssueOptions {
+    maxPeers?: number;
+    /** Requires the app manifest's advanced-fanout opt-in. */
+    advancedFanout?: boolean;
+}
+interface OpenRTCChannelCatalog {
+    register(descriptor: RuntimeChannelDescriptor): () => void;
+    list(): readonly RuntimeChannelDescriptor[];
+}
+interface OpenRTCUsageNamespace {
+    estimate(input: {
+        operation: string;
+        units?: number;
+    }): {
+        creditsUsd: number;
+        estimated: true;
+    };
+    readonly sessionCreditsUsd: number;
+}
+interface OpenRTCClient {
+    readonly devices: {
+        start(options?: OpenRTCDevicesStartOptions): Promise<OpenRTCDevicesHandle>;
+    };
+    readonly spaces: {
+        join(id: string, options?: OpenRTCSpaceJoinOptions): Promise<OpenRTCSpaceHandle>;
+    };
+    readonly rooms: {
+        join(id: string, options?: OpenRTCRoomJoinOptions): Promise<OpenRTCRoomHandle>;
+    };
+    readonly tickets: {
+        issue(id: string, options?: OpenRTCTicketIssueOptions): Promise<OpenRTCTicketHandle>;
+    };
+    readonly channels: OpenRTCChannelCatalog;
+    readonly usage: OpenRTCUsageNamespace;
+    close(): Promise<void>;
+}
+
+export { DriveGrantActorHandle as A, type DriveGrantActorHandleOptions as B, DriveGrantActorRegistry as C, DriveGrantActorError as D, type DriveGrantActorState as E, type DriveGrantClose as F, type DriveGrantDial as G, type DriveGrantConnectionKey as H, type DriveGrantLogicalChannelHandle as I, type DriveGrantPreferredTransport as J, getRuntimePolicy as K, driveGrantConnectionKey as L, driveGrantConnectionKeyToString as M, type OpenRTCOptions as O, type PlutoRuntimeAssembly as P, type RuntimeFactoryOptions as R, type OpenRTCClient as a, type OpenRTCAccessMode as b, type OpenRTCAttestationProvider as c, type OpenRTCAuthProvider as d, type OpenRTCBotVerificationProvider as e, type OpenRTCCapabilityHandle as f, type OpenRTCChannelCatalog as g, type OpenRTCDevicesHandle as h, type OpenRTCDevicesStartOptions as i, type OpenRTCLatestStateMode as j, type OpenRTCRoomHandle as k, type OpenRTCRoomJoinOptions as l, type OpenRTCSpaceHandle as m, type OpenRTCSpaceJoinOptions as n, type OpenRTCTicketHandle as o, type OpenRTCTicketIssueOptions as p, type OpenRTCTransportPreferences as q, type OpenRTCUsageNamespace as r, type OpenRTCUsageUpdate as s, type OpenRTCUsageWarning as t, type OpenRTCClient$1 as u, type PeerReconciliationStats as v, OPENRTC_RUNTIME_POLICY as w, RuntimeClient as x, type RuntimePolicySnapshot as y, type DriveGrantActorErrorKind as z };

package/dist/{types-BJU2GoVb.d.ts → types-BUXwspL0.d.ts}

@@ -1,20 +1,6 @@
 import { A as AuthContext } from './IEngineBridge-BbsT8hof.js';
-import { s as ConnectionOptions, t as ApplicationPayloadCrypto, u as ApplicationPayloadReadinessOptions, v as ApplicationPayloadRouteOptions, w as ProtocolName, x as ApplicationPayloadSendOptions, T as TransportLatencySnapshot, y as ChannelDescriptor$1, L as LocalDeviceInfo, z as IncomingStreamChannelMetadata, e as ClientOptions, h as Device, m as SignalingSession, f as RuntimeIdentity, i as DeviceStatusSnapshot, F as ManagedDeviceConnectOptions, H as PeerState, J as PeerHealth, K as JoinRoomOptions, g as RoomMember, O as PeerScope, r as BackendConnectionState, Q as DevicePresenceStatus, U as PeerLifecycleStatus, P as PeerSessionSnapshot } from './types-zT2QwuCv.js';
-
-interface ITransport {
-    readonly name: string;
-    readonly isReady: boolean;
-    init(localNodeId: string, remoteNodeId: string, options: any): Promise<void>;
-    send(data: Uint8Array): Promise<void>;
-    close(): void;
-    onMessage(callback: (data: Uint8Array) => void): void;
-    onStateChange(callback: (state: 'connecting' | 'connected' | 'failed' | 'disconnected') => void): void;
-    handleSignalingMessage?(msg: any): void;
-    getSignalingHandler?(): (msg: any) => Promise<void>;
-    getNativeTransport?(): any;
-    getNegotiationId?(): string | null;
-    getDataChannelReadyState?(): string | null;
-}
+import { C as ConnectionOptions, A as ApplicationPayloadCrypto, a as ApplicationPayloadReadinessOptions, b as ApplicationPayloadRouteOptions, P as ProtocolName, c as ApplicationPayloadSendOptions, T as TransportLatencySnapshot, d as PeerState, e as PeerScope, f as PeerHealth, g as ChannelDescriptor$1, I as IncomingStreamChannelMetadata, D as Device, B as BackendConnectionState, L as LocalDeviceInfo, h as DeviceStatusSnapshot, M as ManagedDeviceConnectOptions, i as ClientOptions, S as SignalingSession, R as RuntimeIdentity, J as JoinRoomOptions, j as RoomMember, k as DevicePresenceStatus, l as PeerLifecycleStatus, m as PeerSessionSnapshot } from './types-BVJr065k.js';
+import { I as ITransport } from './ITransport-BsPcaov7.js';
 
 type ConnectionHealth = 'unknown' | 'healthy' | 'suspect' | 'stale';
 
@@ -483,6 +469,12 @@ interface RuntimeScopedChannelOptions {
     channelId: string;
     timeoutMs?: number;
     respectManualDisconnect?: 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
+     * without gaining authority to dial, repair, or add an admission avenue.
+     */
+    existingRouteOnly?: boolean;
     /**
      * Native product protocols such as Plutonium drive-view expect a plaintext
      * stream label before payload frames. OpenRTC owns that handshake here so
@@ -507,6 +499,7 @@ interface RuntimeScopedLogicalChannel {
         lastSendTransport?: ProtocolName | 'stream' | null;
         framing: RuntimeLogicalChannelFraming;
         nativeLabel: boolean;
+        delivery: 'reliable' | 'latest-state';
     };
 }
 /**
@@ -545,6 +538,7 @@ 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 {
     requestedId: string;
@@ -601,4 +595,4 @@ type SessionOptions = RuntimeManagedSessionOptions;
 type Session = RuntimeManagedSession;
 type ChannelDescriptor = RuntimeChannelDescriptor;
 
-export { type Session as $, type PeerReadiness as A, type PeerStreamOptions as B, Connection as C, type DeviceProfile as D, type PresenceLoopOptions as E, type RawConnection as F, type RuntimeAuthContext as G, type RuntimeAuthIdentity as H, type ITransport as I, type RuntimeAutoConnectPolicy as J, type RuntimeConnectionTarget as K, type RuntimeDevicePresenceStatus as L, type RuntimeDeviceStatus as M, type RuntimeLogicalChannelFraming as N, type RuntimeManagedSessionKind as O, type PeerConnectOptions as P, type RuntimeManagedSessionPlatform as Q, type RuntimeClientOptions as R, type RuntimePeerLifecycleStatus as S, type RuntimePeerScope as T, type RuntimePeerSessionSnapshot as U, type RuntimePresenceLoopOptions as V, type RuntimePresencePolicy as W, type RuntimeSession as X, type RuntimeUiConnectionStatus as Y, type ScopedChannelOptions as Z, type ScopedLogicalChannel as _, type RuntimeManagedSessionOptions as a, type SessionOptions as a0, type RuntimeManagedSession as b, type RuntimeDevice as c, type RuntimeDeviceStatusSnapshot as d, type RuntimeDeviceConnectOptions as e, type RuntimeLocalDeviceInfo as f, type RuntimeLocalDeviceProfile as g, type RuntimePeerState as h, type RuntimePeerConnectOptions as i, type RuntimePeerReadinessSnapshot as j, type RuntimePeerHealth as k, type RuntimeChannelDescriptor as l, type RuntimePeerStreamOptions as m, type RuntimeIncomingStream as n, type RuntimeScopedChannelOptions as o, type RuntimeScopedLogicalChannel as p, type RuntimeJoinRoomOptions as q, type RuntimeRoomMember as r, type RuntimeConnectionStateSnapshot as s, type RuntimeApplicationPayloadReadinessOptions as t, type RuntimeConnectionEvent as u, type RuntimeRawConnection as v, type ChannelDescriptor as w, type ConnectionEvent as x, type ConnectionTarget as y, type IncomingStream as z };
+export { type Session as $, type ChannelDescriptor as A, type ConnectionEvent as B, Connection as C, type ConnectionTarget as D, type DeviceProfile as E, type PeerReadiness as F, type PeerStreamOptions as G, type PresenceLoopOptions as H, type IncomingStream as I, type RawConnection as J, type RuntimeApplicationPayloadRouteOptions as K, type RuntimeAuthContext as L, type RuntimeAutoConnectPolicy as M, type RuntimeDevicePresenceStatus as N, type RuntimeDeviceStatus as O, type PeerConnectOptions as P, type RuntimeLogicalChannelFraming as Q, type RuntimeClientOptions as R, type RuntimeManagedSessionKind as S, type RuntimeManagedSessionPlatform as T, type RuntimePeerLifecycleStatus as U, type RuntimePeerScope as V, type RuntimePeerSessionSnapshot as W, type RuntimePresencePolicy as X, type RuntimeUiConnectionStatus as Y, type ScopedChannelOptions as Z, type ScopedLogicalChannel as _, type RuntimePeerState as a, type SessionOptions as a0, type RuntimeConnectionStateSnapshot as b, type RuntimePeerReadinessSnapshot as c, type RuntimePeerConnectOptions as d, type RuntimeIncomingStream as e, type RuntimeAuthIdentity as f, type RuntimeLocalDeviceInfo as g, type RuntimeLocalDeviceProfile as h, type RuntimeDevice as i, type RuntimeManagedSessionOptions as j, type RuntimeManagedSession as k, type RuntimeDeviceStatusSnapshot as l, type RuntimeDeviceConnectOptions as m, type RuntimeSession as n, type RuntimeJoinRoomOptions as o, type RuntimeRoomMember as p, type RuntimeConnectionTarget as q, type RuntimeScopedChannelOptions as r, type RuntimeScopedLogicalChannel as s, type RuntimePeerStreamOptions as t, type RuntimeRawConnection as u, type RuntimeChannelDescriptor as v, type RuntimePresenceLoopOptions as w, type RuntimePeerHealth as x, type RuntimeApplicationPayloadReadinessOptions as y, type RuntimeConnectionEvent as z };

package/dist/{types-zT2QwuCv.d.ts → types-BVJr065k.d.ts}

@@ -17,6 +17,14 @@ interface CoordinationGatewayOptions {
      * verify the matching identity tenant and token audience.
      */
     environment: 'staging' | 'production';
+    /**
+     * Test-runtime authority for an insecure loopback gateway. The public v2
+     * constructor never sets this flag; `openrtc/testing` owns it for local
+     * emulator harnesses. Non-loopback HTTP/WS endpoints still fail closed.
+     *
+     * @internal
+     */
+    testingAllowInsecureLoopback?: boolean;
     /**
      * Opaque native trust token loader.
      *
@@ -29,6 +37,33 @@ interface CoordinationGatewayOptions {
         token: string;
         expiresAtMs: number;
     } | null | undefined>;
+    /**
+     * OpenRTC 2.0's provider-neutral grant source. This is installed by the
+     * public capability client, never supplied as a public endpoint or token
+     * hook by application code.
+     *
+     * @internal
+     */
+    grantProvider?: (input: CoordinationGatewayGrantRequest) => Promise<CoordinationGatewayGrant>;
+}
+interface CoordinationGatewayGrantRequest {
+    avenue: {
+        kind: 'user' | 'space' | 'room' | 'session';
+        id: string;
+    };
+    deviceId: string;
+    runtimeInstanceId: string;
+    ticketFingerprint: string;
+    purpose: 'presence' | 'device-control';
+    refreshGrant?: string;
+}
+interface CoordinationGatewayGrant {
+    protocolVersion: 1 | 2;
+    gatewayUrl: string;
+    routeKey: string;
+    token: string;
+    expiresAtMs: number;
+    avenue: CoordinationGatewayGrantRequest['avenue'];
 }
 
 interface AppLimits {
@@ -131,6 +166,8 @@ interface ChannelDescriptor {
     readiness: ChannelReadinessMode;
     promotionPolicy?: ChannelPromotionPolicy;
     signalingPolicy?: ChannelSignalingPolicy;
+    /** Drop queued superseded payloads while retaining reliable delivery for the newest state. */
+    delivery?: 'reliable' | 'latest-state';
     description?: string;
 }
 type ProtocolName = 'iroh' | 'iroh-quic' | 'iroh-relay' | 'iroh-lan' | 'ble' | 'webrtc' | 'webrtc-lan' | 'webrtc-turn' | 'moq';
@@ -182,8 +219,6 @@ interface ProtocolCapability {
     reason?: string;
 }
 type ProtocolCapabilityMap = Record<ProtocolName, ProtocolCapability>;
-/** Space discovery always uses namespace-scoped Firebase tokens. */
-type SpaceAuthMode = 'scoped-token';
 type SpaceTokenProvider = () => Promise<{
     customToken: string;
     uid?: string;
@@ -242,6 +277,11 @@ interface ClientOptions {
      * Hosted production clients receive the managed production default.
      */
     coordinationGateway?: CoordinationGatewayOptions;
+    /** @internal One capability maps to exactly one gateway avenue. */
+    coordinationAvenueOverride?: {
+        kind: 'user' | 'space' | 'room' | 'session';
+        id: string;
+    };
     /**
      * Supplies the provider-neutral platform-attestation token used by the
      * configured coordination control plane.
@@ -1040,4 +1080,4 @@ interface JoinRequest {
     state: 'pending' | 'accepted' | 'rejected';
 }
 
-export type { ProtocolImplementationKind as $, AuthMode as A, BackendPeerBiStream as B, ConnectDeviceResult as C, DiscoveryMode as D, ExplicitFileDataSendParams as E, ManagedDeviceConnectOptions as F, GrantScope as G, PeerState as H, ISignalingBackend as I, PeerHealth as J, JoinRoomOptions as K, LocalDeviceInfo as L, ManagedConnectionRecord as M, NativeManagedSessionStartResult as N, PeerScope as O, PeerSessionSnapshot as P, DevicePresenceStatus as Q, ResolvedPeerIdentity as R, SpaceAuthMode as S, TransportLatencySnapshot as T, PeerLifecycleStatus as U, ProtocolCapability as V, ProtocolCapabilityMap as W, ApplicationCryptoStreamTools as X, AppLimits as Y, ApplicationCryptoBiStream as Z, ProtocolBaseName as _, SpaceTokenProvider as a, ProtocolLocality as a0, RouteDescriptor as a1, RouteFamily as a2, RouteImplementationKind as a3, SignalingOptions as a4, RoomCreationMode as a5, ScanningLoopOptions as a6, ScanningLoopHandle as a7, RuntimeBootstrapOptions as a8, RuntimeBootstrapResult as a9, ManagedApplicationRouteOptions as aa, JoinRequest as ab, ConnectDeviceHooks as b, ConnectDeviceOptions as c, SignalingMode as d, ClientOptions as e, RuntimeIdentity as f, RoomMember as g, Device as h, DeviceStatusSnapshot as i, SignalingEnvelope as j, DeviceEvent as k, DesiredPeerProjection as l, SignalingSession as m, SessionEvent as n, BackendPeerUniStream as o, NativeConnectParams as p, NativeConnectResult as q, BackendConnectionState as r, ConnectionOptions as s, ApplicationPayloadCrypto as t, ApplicationPayloadReadinessOptions as u, ApplicationPayloadRouteOptions as v, ProtocolName as w, ApplicationPayloadSendOptions as x, ChannelDescriptor as y, IncomingStreamChannelMetadata as z };
+export type { AppLimits as $, ApplicationPayloadCrypto as A, BackendConnectionState as B, ConnectionOptions as C, Device as D, ExplicitFileDataSendParams as E, SessionEvent as F, NativeManagedSessionStartResult as G, GrantScope as H, IncomingStreamChannelMetadata as I, JoinRoomOptions as J, RouteDescriptor as K, LocalDeviceInfo as L, ManagedDeviceConnectOptions as M, NativeConnectParams as N, ProtocolCapability as O, ProtocolName as P, ProtocolCapabilityMap as Q, RuntimeIdentity as R, SignalingSession as S, TransportLatencySnapshot as T, ApplicationCryptoStreamTools as U, ApplicationCryptoBiStream as V, RouteFamily as W, RouteImplementationKind as X, ConnectDeviceHooks as Y, ConnectDeviceOptions as Z, ConnectDeviceResult as _, ApplicationPayloadReadinessOptions as a, SignalingOptions as a0, RoomCreationMode as a1, ScanningLoopOptions as a2, ScanningLoopHandle as a3, RuntimeBootstrapOptions as a4, RuntimeBootstrapResult as a5, ManagedApplicationRouteOptions as a6, JoinRequest as a7, SpaceTokenProvider as a8, ApplicationPayloadRouteOptions as b, ApplicationPayloadSendOptions as c, PeerState as d, PeerScope as e, PeerHealth as f, ChannelDescriptor as g, DeviceStatusSnapshot as h, ClientOptions as i, RoomMember as j, DevicePresenceStatus as k, PeerLifecycleStatus as l, PeerSessionSnapshot as m, DiscoveryMode as n, AuthMode as o, SignalingMode as p, ISignalingBackend as q, SignalingEnvelope as r, BackendPeerBiStream as s, BackendPeerUniStream as t, ManagedConnectionRecord as u, ResolvedPeerIdentity as v, DeviceEvent as w, DesiredPeerProjection as x, CoreClientBridgeHost as y, NativeConnectResult as z };