openrtc 2.0.0-rc.9 → 2.0.1

package/dist/runtime/index.d.ts

@@ -1,18 +1,17 @@
-import { d as OpenRTCClient, P as PeerReconciliationStats } from '../OpenRTCShared-BswnbjpG.js';
-export { e as OPENRTC_RUNTIME_POLICY, R as RuntimeClient, f as RuntimePolicySnapshot, D as ScopedConnectionActorError, g as ScopedConnectionActorErrorKind, h as ScopedConnectionActorHandle, i as ScopedConnectionActorHandleOptions, j as ScopedConnectionActorRegistry, k as ScopedConnectionActorState, l as ScopedConnectionClose, m as ScopedConnectionDial, n as ScopedConnectionKey, o as ScopedLogicalChannelHandle, p as ScopedPreferredTransport, q as getRuntimePolicy, r as scopedConnectionKey, s as scopedConnectionKeyToString } from '../OpenRTCShared-BswnbjpG.js';
-import { f as OpenRTCCapabilityHandle } from '../types-byWIP-WI.js';
-import { C as Connection, r as RuntimeConnectionTarget, v as RuntimeRawConnection } from '../types-D0pqNSOf.js';
-export { A as ChannelDescriptor, B as ConnectionEvent, D as ConnectionTarget, E as DeviceProfile, I as IncomingStream, P as PeerConnectOptions, F as PeerReadiness, G as PeerStreamOptions, H as PresenceLoopOptions, J as RawConnection, y as RuntimeApplicationPayloadReadinessOptions, K as RuntimeApplicationPayloadRouteOptions, L as RuntimeAuthContext, g as RuntimeAuthIdentity, M as RuntimeAutoConnectPolicy, R as RuntimeChannelDescriptor, a as RuntimeClientOptions, z as RuntimeConnectionEvent, c as RuntimeConnectionStateSnapshot, j as RuntimeDevice, n as RuntimeDeviceConnectOptions, N as RuntimeDevicePresenceStatus, O as RuntimeDeviceStatus, m as RuntimeDeviceStatusSnapshot, f as RuntimeIncomingStream, p as RuntimeJoinRoomOptions, h as RuntimeLocalDeviceInfo, i as RuntimeLocalDeviceProfile, Q as RuntimeLogicalChannelFraming, l as RuntimeManagedSession, S as RuntimeManagedSessionKind, k as RuntimeManagedSessionOptions, T as RuntimeManagedSessionPlatform, e as RuntimePeerConnectOptions, x as RuntimePeerHealth, U as RuntimePeerLifecycleStatus, d as RuntimePeerReadinessSnapshot, V as RuntimePeerScope, W as RuntimePeerSessionSnapshot, b as RuntimePeerState, u as RuntimePeerStreamOptions, w as RuntimePresenceLoopOptions, X as RuntimePresencePolicy, q as RuntimeRoomMember, s as RuntimeScopedChannelOptions, t as RuntimeScopedLogicalChannel, o as RuntimeSession, Y as RuntimeUiConnectionStatus, Z as ScopedChannelOptions, _ as ScopedLogicalChannel, $ as Session, a0 as SessionOptions } from '../types-D0pqNSOf.js';
+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 * as Draft14 from '@moq/net';
-import { $ as SignalingOptions, I as ISignalingBackend, R as RuntimeIdentity, a as RoomMember, e as SignalingEnvelope, h as SignalingSession, b as Device, g as DesiredPeerProjection, m as BackendConnectionState, _ as AppLimits, G as GrantScope, J as JoinRoomOptions, x as IncomingStreamChannelMetadata, Q as ApplicationCryptoStreamTools, a0 as RoomCreationMode, C as ClientOptions, o as ApplicationPayloadCrypto, D as DiscoveryMode, O as ProtocolCapabilityMap, a1 as ScanningLoopOptions, a2 as ScanningLoopHandle, a3 as RuntimeBootstrapOptions, a4 as RuntimeBootstrapResult, p as ApplicationPayloadReadinessOptions, a5 as ManagedApplicationRouteOptions, t as PeerState, u as PeerScope, v as PeerHealth, w as ChannelDescriptor, a6 as JoinRequest, k as NativeConnectParams, l as NativeConnectResult, a7 as SpaceTokenProvider } from '../types-BHePJWbM.js';
-import { R as RuntimeCapabilities } from '../capabilities-YSskrE8H.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-YSskrE8H.js';
+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, T as TauriRuntimeAdapter, b as TauriRuntimeAdapterOptions, c as createTauriIpcBridge } from '../tauri-BgLgJoQA.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 '../IEngineBridge-BbsT8hof.js';
-import '../ITransport-BsPcaov7.js';
-import '../DelegatingRuntimeAdapter-BLNigcS4.js';
+import '../DelegatingRuntimeAdapter-fgz5OPQx.js';
 
 declare class Signaling {
     private readonly appTag;
@@ -31,6 +30,10 @@ declare class Signaling {
     signInWithPluto(): Promise<void>;
     signOut(): Promise<void>;
     stopAuthScopedActivity(): Promise<void>;
+    setCoordinationHostAvailability(input: {
+        available: boolean;
+        reason: string;
+    }): void;
     getRuntimeCapabilities(): RuntimeCapabilities | undefined;
     getTurnCredentials(): Promise<any>;
     updatePresence(localNodeId: string, ticketStr: string, isOnline?: boolean, ttlMs?: number, metadata?: string): Promise<void>;
@@ -109,6 +112,12 @@ interface TransportInterface {
 interface MoQSessionOptions {
     onSubscriptionTerminated?: (namespace: string, name: string, error: unknown) => void;
 }
+interface MoQDatagramDuplex {
+    readonly maxDatagramSize?: number;
+    readonly readable: ReadableStream<Uint8Array>;
+    readonly writable: WritableStream<Uint8Array>;
+    close(): void;
+}
 /**
  * Draft-14 MoQT adapter. The OpenRTC controller owns reconnect and lifecycle;
  * this class owns only one negotiated relay session and its protocol handles.
@@ -127,6 +136,12 @@ declare class MoQSession {
     private readonly setupPromise;
     constructor(transport: TransportInterface, onObject?: (ns: string, name: string, obj: Uint8Array, meta: unknown) => void, role?: number, relayUrl?: URL, options?: MoQSessionOptions);
     requireConnection(): Draft14.Connection.Established;
+    /**
+     * Open the patched Draft 14 object-datagram surface used only by the Iroh
+     * packet carrier. Existing application-data publishing remains on subgroup
+     * streams and never shares readiness with this duplex.
+     */
+    openDatagramDuplex(publishNamespace: string, subscribeNamespace: string, trackName: string): Promise<MoQDatagramDuplex>;
     init(): Promise<void>;
     waitForSetup(): Promise<void>;
     onClose(callback: (reason?: unknown) => void): () => void;
@@ -368,7 +383,7 @@ declare class Client {
     buildCompoundTicketWithToken(irohTicket: string, grantScope: GrantScope, maxConnections?: number): string;
     setManagedPresenceTicket(ticket: string | null): void;
     clearManagedPresenceTicket(): void;
-    registerSessionToken(token: string, grantScope: GrantScope, maxConnections: number): void;
+    registerSessionToken(token: string, grantScope: GrantScope, maxConnections: number, expiresAtMs?: number): void;
     revokeSessionToken(token: string): void;
     revokeTokensByScope(grantScope: GrantScope): Promise<string[]>;
     clearSessionTokens(): Promise<void>;
@@ -525,52 +540,4 @@ declare function createRuntimeJsonFrameDecoder<T = unknown>(onValue: RuntimeJson
 declare function concatRuntimeBytes(a: ByteArrayLike, b: ByteArrayLike): ByteArray;
 declare function readRuntimeU32BE(bytes: ByteArrayLike, offset: number): number;
 
-type MintSpaceTokenRequest = {
-    spaceKey: string;
-    memberId?: string;
-    ttl?: number;
-    sandboxAppId?: string;
-};
-type MintSpaceTokenResponse = {
-    token: string;
-    expiresAt: number;
-    tokenLifetimeSeconds: number;
-    namespaceId: string;
-    spaceAppTag: string;
-};
-/**
- * Mint a namespace-scoped Firebase custom token from your backend using the
- * OpenRTC `POST /v1/spaces/tokens` endpoint. Never call this from browser code
- * with a secret key — proxy through your server.
- */
-type EnableSpaceAuthResponse = {
-    success: true;
-    space: {
-        namespaceId: string;
-        requireScopedAuth: boolean;
-        status: 'active' | 'revoked';
-    };
-};
-/**
- * Opt a provisioned space into scoped-auth mode (required for all spaces).
- * Call from your backend with sk_live_... only.
- */
-declare function enableSpaceAuth(endpointUrl: string, secretKey: string, namespaceId: string): Promise<EnableSpaceAuthResponse>;
-declare function mintSpaceToken(endpointUrl: string, secretKey: string, request: MintSpaceTokenRequest): Promise<MintSpaceTokenResponse>;
-/**
- * Browser-safe space auth for static sites. Calls the rate-limited
- * `v1SpacePublicTokens` endpoint (pk_live_ + spaceKey only).
- */
-declare function createPublicSpaceTokenProvider(options: {
-    apiKey: string;
-    space?: string;
-    spaceKey?: string;
-    endpointUrl?: string;
-    memberIdStorageKey?: string;
-    sandboxAppId?: string;
-}): SpaceTokenProvider;
-declare function sandboxSpaceKey(spaceKey: string, sandboxAppId?: string): string;
-declare const spaceToken: typeof createPublicSpaceTokenProvider;
-declare const createSpaceTokenProvider: typeof createPublicSpaceTokenProvider;
-
-export { Connection, type CorrelationFields, type EnableSpaceAuthResponse, type MintSpaceTokenRequest, type MintSpaceTokenResponse, type OpenRTCCapabilityRuntime, RuntimeCapabilities, RuntimeConnectionController, RuntimeConnectionTarget, type RuntimeJsonFrameDecoderOptions, type RuntimeJsonFrameHandler, RuntimeRawConnection, type RuntimeU32BEFrameHandler, clog, concatRuntimeBytes, correlationForDriveGrantScope, createPublicSpaceTokenProvider, createRuntimeJsonFrameDecoder, createRuntimeU32BEFrameDecoder, createSpaceTokenProvider, decodeRuntimeJsonPayload, enableSpaceAuth, encodeRuntimeJsonFrame, encodeRuntimeJsonPayload, encodeRuntimeU32BEFrame, logOpenRtcTeardownTrace, mintSpaceToken, openRtcDebug, openRtcDebugEnabled, openRtcDebugInfo, openRtcDebugLog, readRuntimeU32BE, renderCorrelationFields, runtimeForCapability as runtimeFromCapability, sandboxSpaceKey, spaceToken };
+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 };

package/dist/runtime/index.js

@@ -1,2 +1 @@
-export{b as TauriRuntimeAdapter,a as createTauriIpcBridge}from'../chunk-O3D7S5MD.js';export{b as runtimeFromCapability}from'../chunk-23XC6TGK.js';export{b as Connection,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-NCL672QJ.js';export{f as IpcRuntimeAdapter}from'../chunk-A7AMB23L.js';import'../chunk-C6PAXO3N.js';import'../chunk-7Z6N46RB.js';export{q as BROWSER_WASM_RUNTIME_CAPABILITIES,r as NATIVE_IPC_RUNTIME_CAPABILITIES,o as OPENRTC_RUNTIME_POLICY,s as cloneRuntimeCapabilities,p as getRuntimePolicy,g as logOpenRtcTeardownTrace,t as runtimeCapabilitiesForBrowserHost,u as runtimeCapabilitiesFromNativeStatus,v as runtimeCapabilityProfile}from'../chunk-JIVVHBCB.js';export{b as openRtcDebug,a as openRtcDebugEnabled,c as openRtcDebugInfo,d as openRtcDebugLog}from'../chunk-VK6KX433.js';import'../chunk-NT5YHZQH.js';export{a as classifyNativeIpcFailure,b as isNativeIpcCommandUnavailable}from'../chunk-K37WVIZL.js';import'../chunk-BXFXPIXO.js';import {b}from'../chunk-N26S7V4N.js';import'../chunk-NB4H5TP3.js';import'../chunk-RD3JEGGF.js';import'../chunk-C7YN5MSV.js';export{a as isRuntimeDeviceActive,c as isRuntimeDeviceConnectable,b as isRuntimeDeviceRoutable}from'../chunk-CK6WQV7J.js';var j="https://api.openrtc.app";function c(e){if(typeof globalThis.crypto?.randomUUID!="function")throw new Error(`Secure request identity is unavailable for ${e}.`);return `${e}:${globalThis.crypto.randomUUID()}`}async function z(e,t,n){let o=e.replace(/\/$/,""),r=await fetch(`${o}/v1/spaces/${encodeURIComponent(n)}/scoped-auth`,{method:"POST",headers:{Authorization:`Bearer ${t}`,"Content-Type":"application/json","X-OpenRTC-Idempotency-Key":c("enable-space-auth")},body:"{}"}),a=await r.json().catch(()=>({}));if(!r.ok){let s=typeof a?.error=="string"?a.error:`enableSpaceAuth failed (${r.status})`;throw new Error(s)}return a}async function q(e,t,n){let o=await fetch(e,{method:"POST",headers:{Authorization:`Bearer ${t}`,"Content-Type":"application/json","X-OpenRTC-Idempotency-Key":c("mint-space-token")},body:JSON.stringify(n)}),r=await o.json().catch(()=>({}));if(!o.ok){let a=typeof r?.error=="string"?r.error:`mintSpaceToken failed (${o.status})`;throw new Error(a)}if(typeof r?.token!="string"||!r.token.trim())throw new Error("mintSpaceToken response missing token");return r}function d(e){let t=e.apiKey.trim(),n=(e.spaceKey??e.space??"").trim(),o=g(e.sandboxAppId),r=(e.endpointUrl??j).replace(/\/$/,""),a=e.memberIdStorageKey??`openrtc:space-member:${n}${o?`:sandbox:${o}`:""}`;return async()=>{if(!t||!n)throw new Error("spaceToken requires apiKey and space");let s=null;typeof sessionStorage<"u"?(s=sessionStorage.getItem(a),s||(s=globalThis.crypto?.randomUUID?.()??`member-${Date.now()}`,sessionStorage.setItem(a,s))):s=`member-${Date.now()}`;let m=await b().getAppCheckToken(),i=await fetch(`${r}/v1SpacePublicTokens`,{method:"POST",headers:{"Content-Type":"application/json","X-OpenRTC-Idempotency-Key":c("mint-public-space-token"),...m?{"X-Firebase-AppCheck":m}:{}},body:JSON.stringify({apiKey:t,spaceKey:n,memberId:s,...o?{sandboxAppId:o}:{}})}),{text:u,payload:p}=await B(i);if(!i.ok){let f=typeof p?.error=="string"?p.error:u.trim()?u.trim().slice(0,240):`public space token mint failed (${i.status})`;throw new Error(f)}let l=typeof p?.token=="string"?p.token.trim():"";if(!l)throw new Error("public space token response missing token");return {customToken:l}}}function M(e){if(!e.trim())return {};try{let t=JSON.parse(e);return t&&typeof t=="object"?t:{}}catch{return {}}}async function B(e){let t=e.text;if(typeof t=="function"){let o=await t.call(e).catch(()=>"");return {text:o,payload:M(o)}}let n=await e.json().catch(()=>({}));return {text:JSON.stringify(n),payload:n&&typeof n=="object"?n:{}}}function g(e){let t=e?.trim().toLowerCase()??"";if(!t)return "";if(!/^[a-z0-9][a-z0-9-]{0,47}$/.test(t))throw new Error("sandboxAppId must be 1-48 lowercase letters, numbers, or dashes.");return t}function J(e,t){let n=e.trim(),o=g(t);return o?`${n}::sandbox::${o}`:n}var L=d,H=d;
-export{d as createPublicSpaceTokenProvider,H as createSpaceTokenProvider,z as enableSpaceAuth,q as mintSpaceToken,J as sandboxSpaceKey,L as spaceToken};
+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';

package/dist/testing.d.ts

@@ -1,30 +1,133 @@
-import { d as OpenRTCClient } from './OpenRTCShared-BswnbjpG.js';
+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 { a as RuntimeClientOptions } from './types-D0pqNSOf.js';
-import { O as OpenRTCOptions, a as OpenRTCClient$1 } from './types-byWIP-WI.js';
-import './types-BHePJWbM.js';
-import './IEngineBridge-BbsT8hof.js';
-import './capabilities-YSskrE8H.js';
-import './ITransport-BsPcaov7.js';
+import './OpenRTCShared.js';
+import './assembly-CLdwe5T-.js';
+import './types-l3m3GrOe.js';
+import './capabilities-BUe5YldR.js';
+
+interface OpenRTCDeviceProof {
+    publicKeyJwk: JsonWebKey;
+    signature: string;
+    nonce: string;
+    issuedAt: number;
+}
+interface OpenRTCDeviceKey {
+    readonly publicKeyJwk: JsonWebKey;
+    readonly thumbprint: string;
+    proof(challenge: (nonce: string, issuedAt: number) => string): Promise<OpenRTCDeviceProof>;
+}
+interface OpenRTCDeviceKeyProvider {
+    getOrCreate(appTag: string): Promise<OpenRTCDeviceKey>;
+    delete?(appTag: string): Promise<void>;
+    /**
+     * Optional platform-secure record storage. Native hosts use this for the
+     * device certificate that is bound to the private key; browsers retain
+     * their same-origin localStorage implementation.
+     */
+    readSecureRecord?(appTag: string, key: string): Promise<string | null>;
+    writeSecureRecord?(appTag: string, key: string, value: string): Promise<void>;
+    deleteSecureRecord?(appTag: string, key: string): Promise<void>;
+}
 
 interface OpenRTCV2Endpoints {
     controlPlane: string;
     gateway: string;
 }
 
+interface CredentialSource {
+    type: 'capability' | 'device-certificate';
+    token: string;
+    avenue: CoordinationGatewayGrantRequest['avenue'];
+    expiresAtMs: number;
+    renew?: () => Promise<CredentialSource>;
+    /**
+     * Re-establishes an authenticated device certificate only after the
+     * control plane explicitly reports a stale generation. This is separate
+     * from time-based renewal so revocation cannot create a refresh loop.
+     */
+    recoverRejectedCertificate?: () => Promise<CredentialSource>;
+}
+interface CachedDeviceCertificate {
+    token: string;
+    expiresAtMs: number;
+    principalId?: string;
+    signingPublicJwk: JsonWebKey & {
+        kid?: string;
+    };
+}
+interface AuthenticatedDeviceCertificate extends CachedDeviceCertificate {
+    principalId: string;
+    enrolled: boolean;
+}
+interface OpenRTCV2ControlPlaneEvents {
+    beforeLogicalOperation?: (operation: string) => void;
+    onLogicalOperation?: (operation: string) => void;
+    onAuthEpochChanged?: (auth: OpenRTCAuthProvider) => void;
+}
+declare class OpenRTCV2ControlPlane {
+    readonly apiKey: string;
+    private readonly endpoints;
+    private readonly keyProvider;
+    private readonly attestation?;
+    private readonly events;
+    private readonly botVerification?;
+    readonly appTag: string;
+    private keyPromise;
+    private readonly authEpochs;
+    constructor(apiKey: string, endpoints: OpenRTCV2Endpoints, keyProvider: OpenRTCDeviceKeyProvider, attestation?: OpenRTCAttestationProvider | undefined, events?: OpenRTCV2ControlPlaneEvents, botVerification?: OpenRTCBotVerificationProvider | undefined);
+    private record;
+    private before;
+    private authEpoch;
+    dispose(): void;
+    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<{
+        source: CredentialSource;
+        principalId: string;
+        enrolled: boolean;
+    }>;
+    private resolveAuthenticatedDevice;
+    private deviceCertificateResult;
+    private enrollAuthenticatedDevice;
+    listEnrolledDevices(auth: OpenRTCAuthProvider, deviceId: string): Promise<Array<{
+        deviceId: string;
+        name?: string;
+        platform?: string;
+        enrolledAtMs: number | null;
+        lastGrantAtMs: number | null;
+        current: boolean;
+    }>>;
+    revokeDevice(auth: OpenRTCAuthProvider, currentDeviceId: string, targetDeviceId: string): Promise<void>;
+    revokeAllDevices(auth: OpenRTCAuthProvider, 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'>;
+        /**
+         * Keeps the transport/admission credential relay synchronized
+         * when a capability or device certificate is renewed in place.
+         * The callback runs only after the replacement source has
+         * successfully produced a gateway grant.
+         */
+        onSourceRenewed?: (source: {
+            token: string;
+            expiresAtMs: number;
+        }) => Promise<void> | void;
+    }): (request: CoordinationGatewayGrantRequest) => Promise<CoordinationGatewayGrant>;
+}
+
+/** 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?: {
     deviceId?: string;
     irohTestRelayUrl?: string;
-}): OpenRTCClient$1;
+}): OpenRTCClient;
 /** Native equivalent for emulator and harness lanes; never import in product code. */
-declare function createTestingNativeOpenRTC(options: OpenRTCOptions, endpoints: OpenRTCV2Endpoints, bridge: PlutoIpcBridge): OpenRTCClient$1;
-/**
- * Rollback-harness constructor. This is intentionally confined to the
- * `openrtc/testing` export because it enables plaintext loopback coordination
- * for local emulators and also carries the time-bounded v1 runtime.
- */
-declare const createTestingLegacyOpenRTC: ((options: RuntimeClientOptions) => Promise<OpenRTCClient>) & {
-    native: (options: RuntimeClientOptions, bridge?: PlutoIpcBridge) => OpenRTCClient;
-};
+declare function createTestingNativeOpenRTC(options: OpenRTCOptions, endpoints: OpenRTCV2Endpoints, bridge: PlutoIpcBridge): OpenRTCClient;
 
-export { createTestingLegacyOpenRTC, createTestingNativeOpenRTC, createTestingOpenRTC };
+export { createTestingNativeOpenRTC, createTestingOpenRTC, createTestingOpenRTCControlPlane };

package/dist/testing.js

@@ -1 +1 @@
-import {a as a$1}from'./chunk-KWXAZUAZ.js';import {c}from'./chunk-23XC6TGK.js';import {a}from'./chunk-DZCZLRM5.js';import'./chunk-2QHDEGVX.js';import'./chunk-D45U2NXV.js';import'./chunk-EUNCYGJD.js';import'./chunk-IAIGT5G3.js';import'./chunk-N4SX7C3W.js';import'./chunk-NCL672QJ.js';import'./chunk-A7AMB23L.js';import'./chunk-C6PAXO3N.js';import'./chunk-7Z6N46RB.js';import'./chunk-JIVVHBCB.js';import'./chunk-VK6KX433.js';import'./chunk-NT5YHZQH.js';import'./chunk-K37WVIZL.js';import'./chunk-BXFXPIXO.js';import'./chunk-N26S7V4N.js';import'./chunk-NB4H5TP3.js';import'./chunk-RD3JEGGF.js';import'./chunk-C7YN5MSV.js';function m(e,t,n={}){return c(e,{endpoints:t,testingAllowInsecureLoopback:true,platform:"web",...n.deviceId?{deviceIdProvider:async()=>n.deviceId}:{},...n.irohTestRelayUrl?{irohTestRelayUrl:n.irohTestRelayUrl}:{},runtimeFactory:async i=>{let{createWasmClient:o}=await import('./factories-TLUZAXUG.js');return o(i)}})}function d(e,t,n){return c(e,{endpoints:t,testingAllowInsecureLoopback:true,platform:"native",deviceKeyProvider:a$1(n),deviceIdProvider:async()=>{let i=await n.invoke("get_rtc_local_device_info");return String(i?.deviceId??"")},runtimeFactory:async i=>{let{createIpcClient:o}=await import('./ipcFactory-QOAZVE56.js');return o(i,n)}})}function p(e){let t=e.coordinationGateway;return {...e,...t?{coordinationGateway:{...t,testingAllowInsecureLoopback:true}}:{}}}var C=Object.assign(e=>a(p(e)),{native:(e,t)=>a.native(p(e),t)});export{C as createTestingLegacyOpenRTC,d as createTestingNativeOpenRTC,m as createTestingOpenRTC};
+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};

package/dist/transport/index.d.ts

@@ -1,6 +1,5 @@
-import { r as ProtocolName, H as RouteDescriptor, K as ProtocolCapability, O as ProtocolCapabilityMap, o as ApplicationPayloadCrypto, Q as ApplicationCryptoStreamTools } from '../types-BHePJWbM.js';
-export { U as ApplicationCryptoBiStream, V as RouteFamily, W as RouteImplementationKind } from '../types-BHePJWbM.js';
-import { I as ITransport } from '../ITransport-BsPcaov7.js';
+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';
 
 declare const TRANSPORT_LABELS: readonly ProtocolName[];
 declare function normalizeTransportLabel(value: unknown): ProtocolName | undefined;

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-7Z6N46RB.js';export{e as TRANSPORT_LABELS,o as createApplicationCryptoStreamTools,n as createSharedSecretApplicationCrypto,m as isApplicationEncryptedPayload,h as isDirectIrohTransportLabel,l as isIndependentTransportLabel,g as isIrohBaseTransportLabel,i as isOptionalTransportLabel,j as isWebRtcTransportLabel,f as normalizeTransportLabel}from'../chunk-VK6KX433.js';import'../chunk-NB4H5TP3.js';export{a as ROUTE_DESCRIPTORS,e as getRouteDescriptor,f as listRouteDescriptors}from'../chunk-C7YN5MSV.js';
+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';

package/dist/{types-byWIP-WI.d.ts → types-DhmY9hBy.d.ts}

@@ -1,5 +1,6 @@
-import { O as OpenRTCPeerNamespace, a as OpenRTCChannelNamespace, b as OpenRTCDiagnosticsNamespace, c as OpenRTCDeviceNamespace } from './OpenRTCShared-BswnbjpG.js';
-import { R as RuntimeChannelDescriptor } from './types-D0pqNSOf.js';
+import { OpenRTCPeerNamespace, OpenRTCChannelNamespace, OpenRTCDiagnosticsNamespace, OpenRTCDeviceNamespace } from './OpenRTCShared.js';
+import { R as RuntimeChannelDescriptor } from './types-l3m3GrOe.js';
+import { P as PlutoIrohConfiguration, a as PlutoRTCConfiguration, b as PlutoMoQConfiguration, T as TransportOptimization, c as ProtocolName } from './ITransport-UNOXiRJD.js';
 
 interface OpenRTCAuthProvider {
     /** Registered provider ID from the developer app capability manifest. */
@@ -10,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: {
@@ -25,6 +25,13 @@ interface OpenRTCAuthProvider {
          * enrollment/renewal assertion, never for hourly gateway refreshes.
          */
         deviceId: string;
+        /**
+         * Present only after OpenRTC receives the exact structured response
+         * indicating that this installation ID is enrolled with another
+         * public key. Consumer backends should require recent interactive
+         * authentication before authorizing the replacement.
+         */
+        recoveryReason?: 'device-key-rotation';
     }): Promise<string | null>;
     /**
      * Optional identity-epoch observer. Notify only when the signed-in
@@ -45,6 +52,19 @@ interface OpenRTCEnrolledDevice {
     lastGrantAtMs: number | null;
     current: boolean;
 }
+/**
+ * Public, non-secret presentation metadata for one enrolled installation.
+ * 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 {
+    /** 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`. */
+    platform?: string;
+    /** Optional application-owned public presence metadata, bounded to 4 KiB. */
+    metadata?: string;
+}
 interface OpenRTCAttestationProvider {
     readonly kind: 'firebase-app-check' | 'apple-app-attest' | 'play-integrity' | `custom:${string}`;
     /**
@@ -83,10 +103,10 @@ interface OpenRTCUsageWarning extends OpenRTCUsageUpdate {
     kind: 'warning' | 'session-limit';
 }
 interface OpenRTCTransportPreferences {
-    iroh?: boolean;
-    webrtc?: boolean;
+    iroh?: boolean | PlutoIrohConfiguration;
+    webrtc?: boolean | PlutoRTCConfiguration;
     relay?: boolean;
-    moq?: boolean;
+    moq?: boolean | PlutoMoQConfiguration;
     ble?: boolean;
     /**
      * Advanced privacy mode. `relay-only` suppresses direct Iroh addresses,
@@ -94,13 +114,16 @@ interface OpenRTCTransportPreferences {
      * developer manifest's relay opt-in.
      */
     privacy?: 'direct' | 'relay-only';
+    /** Optimize eligible routes for stability/cost or measured latency. */
+    optimizeFor?: TransportOptimization;
     /**
      * 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')[];
+    /** Exact route order. Unsupported routes are skipped, never treated as failures. */
+    priority?: readonly ProtocolName[];
 }
 interface OpenRTCOptions {
     apiKey: string;
@@ -119,6 +142,30 @@ interface OpenRTCOptions {
 }
 type OpenRTCAccessMode = 'capability' | 'authenticated';
 type OpenRTCLatestStateMode = 'reliable' | 'latest-state';
+interface OpenRTCConnection {
+    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> {
+    send(message: T): Promise<void>;
+    sendTo(peerId: string, message: T): Promise<void>;
+    onMessage(callback: (event: {
+        peerId: string;
+        message: T;
+    }) => void): () => void;
+}
+interface OpenRTCState<T> {
+    /** Replace the locally published value. Delivery is best-effort and coalesced. */
+    set(value: T): void;
+    /** A null value means the peer disconnected. */
+    watch(callback: (event: {
+        peerId: string;
+        value: T | null;
+    }) => void): () => void;
+}
 interface OpenRTCCapabilityHandle {
     readonly kind: 'devices' | 'space' | 'room' | 'ticket';
     readonly id: string;
@@ -126,6 +173,10 @@ interface OpenRTCCapabilityHandle {
     readonly channels: OpenRTCChannelNamespace;
     readonly diagnostics: OpenRTCDiagnosticsNamespace;
     readonly closed: boolean;
+    state<T>(name: string): OpenRTCState<T>;
+    channel<T>(name: string): OpenRTCChannel<T>;
+    /** Observe current and future connections without taking lifecycle ownership. */
+    onConnection(callback: (connection: OpenRTCConnection) => void): () => void;
     close(): Promise<void>;
 }
 interface OpenRTCDevicesHandle extends OpenRTCCapabilityHandle {
@@ -150,20 +201,20 @@ interface OpenRTCRoomHandle extends OpenRTCCapabilityHandle {
 }
 interface OpenRTCTicketHandle extends OpenRTCCapabilityHandle {
     readonly kind: 'ticket';
+    /**
+     * Opaque, install-bound OpenRTC capability credential. This is not a
+     * transferable invitation or recipient redemption token. Do not display,
+     * log, persist, or send it to another installation.
+     * @deprecated This credential exposure is retained only for RC source
+     * compatibility and will not be part of the stable invitation workflow.
+     */
     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;
-    };
+    profile?: OpenRTCDeviceProfile;
     maxPeers?: number;
     /** Requires the app manifest's advanced-fanout opt-in. */
     advancedFanout?: boolean;
@@ -205,6 +256,11 @@ interface OpenRTCUsageNamespace {
 }
 interface OpenRTCClient {
     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>;
         listEnrolled(options?: {
             auth?: OpenRTCAuthProvider;
@@ -231,4 +287,4 @@ interface OpenRTCClient {
     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, OpenRTCChannelCatalog as g, OpenRTCDevicesHandle as h, OpenRTCDevicesStartOptions as i, OpenRTCEnrolledDevice as j, OpenRTCLatestStateMode as k, OpenRTCRoomHandle as l, OpenRTCRoomJoinOptions as m, OpenRTCSpaceHandle as n, OpenRTCSpaceJoinOptions as o, OpenRTCTicketHandle as p, OpenRTCTicketIssueOptions as q, OpenRTCTransportPreferences as r, OpenRTCUsageNamespace as s, OpenRTCUsageUpdate as t, OpenRTCUsageWarning as u };
+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 };

package/dist/{types-D0pqNSOf.d.ts → types-l3m3GrOe.d.ts}

@@ -1,6 +1,4 @@
-import { A as AuthContext } from './IEngineBridge-BbsT8hof.js';
-import { n as ConnectionOptions, o as ApplicationPayloadCrypto, p as ApplicationPayloadReadinessOptions, q as ApplicationPayloadRouteOptions, r as ProtocolName, s as ApplicationPayloadSendOptions, T as TransportLatencySnapshot, t as PeerState, u as PeerScope, v as PeerHealth, w as ChannelDescriptor$1, x as IncomingStreamChannelMetadata, b as Device, m as BackendConnectionState, L as LocalDeviceInfo, c as DeviceStatusSnapshot, y as ManagedDeviceConnectOptions, C as ClientOptions, h as SignalingSession, R as RuntimeIdentity, J as JoinRoomOptions, a as RoomMember, z as DevicePresenceStatus, F as PeerLifecycleStatus, P as PeerSessionSnapshot } from './types-BHePJWbM.js';
-import { I as ITransport } from './ITransport-BsPcaov7.js';
+import { x as ConnectionOptions, y as ApplicationPayloadCrypto, z as ApplicationPayloadReadinessOptions, F as ApplicationPayloadRouteOptions, c as ProtocolName, H as ApplicationPayloadSendOptions, J as ITransport, K as TransportLatencySnapshot, O as PeerState, Q as PeerScope, U as PeerHealth, V as ChannelDescriptor$1, W as IncomingStreamChannelMetadata, D as Device, v as BackendConnectionState, L as LocalDeviceInfo, n as DeviceStatusSnapshot, X as ManagedDeviceConnectOptions, g as ClientOptions, t as SignalingSession, l as RuntimeIdentity, Y as JoinRoomOptions, k as RoomMember, Z as DevicePresenceStatus, _ as PeerLifecycleStatus, d as PeerSessionSnapshot } from './ITransport-UNOXiRJD.js';
 
 type ConnectionHealth = 'unknown' | 'healthy' | 'suspect' | 'stale';
 
@@ -401,6 +399,22 @@ declare class Connection {
     private normalizeNegotiationId;
 }
 
+type AuthContext = {
+    userId: string;
+    token?: string | null;
+    refreshToken?: string | null;
+    customToken?: string | null;
+    tokenProvider?: (forceRefresh?: boolean) => Promise<string | null>;
+    /**
+     * Supplies the platform attestation token required by the configured
+     * control plane. Firebase-backed hosted deployments use App Check today;
+     * keeping acquisition on the auth context prevents coordination code from
+     * owning a second Firebase app or assuming one global project.
+     */
+    appCheckTokenProvider?: (forceRefresh?: boolean) => Promise<string | null>;
+    expiresAtMs?: number | null;
+};
+
 /**
  * App-facing options intentionally hide transport node identifiers from callbacks.
  */
@@ -439,6 +453,59 @@ interface RuntimeConnectionTarget {
     ticket: string;
     timeoutMs?: number;
 }
+/**
+ * Durable browser storage used by the optional upstream Iroh docs, blobs, and
+ * gossip protocols. Implementations normally map these atomic operations to
+ * IndexedDB; OpenRTC deliberately does not own a second browser database.
+ */
+interface IrohBrowserProtocolStore {
+    loadIdentity(): Promise<{
+        defaultAuthor: Uint8Array;
+    } | null>;
+    exportSnapshot(): Promise<{
+        authors: unknown[];
+        namespaces: unknown[];
+        entries: unknown[];
+    }>;
+    importAuthor(authorId: string, author: Uint8Array): Promise<void>;
+    importNamespace(capability: unknown): Promise<void>;
+    deleteNamespace(namespaceId: string): Promise<void>;
+    applyEntryTransaction(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>;
+    readBlobOutboardNode(contentHash: string, nodeId: string): Promise<Uint8Array | null>;
+    writeBlobOutboardNode(contentHash: string, nodeId: string, pair: Uint8Array): Promise<void>;
+    markBlobBaoReady(contentHash: string): Promise<void>;
+    writeBlobStagingChunk(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>;
+    beginBlobImport(contentHash: string, size: number, chunkBytes: number): Promise<void>;
+    writeBlobChunk(contentHash: string, size: number, chunkBytes: number, chunkIndex: number, bytes: Uint8Array): Promise<void>;
+    finalizeBlobImport(contentHash: string, size: number, chunkBytes: number): Promise<void>;
+    flush(): Promise<void>;
+}
+interface IrohNamespaceDescriptor {
+    namespaceId: string;
+    capabilityKind: 'read' | 'write';
+    capability: Uint8Array;
+}
+interface IrohMutationReceipt {
+    contentHash: string;
+    operationId: string;
+}
+interface IrohDocEntry {
+    namespaceId: string;
+    authorId: string;
+    key: Uint8Array;
+    timestamp: number;
+    contentHash: string;
+    contentLength: number;
+}
 interface RuntimePeerConnectOptions {
     deviceId?: string;
     ticket?: string;
@@ -595,4 +662,4 @@ type SessionOptions = RuntimeManagedSessionOptions;
 type Session = RuntimeManagedSession;
 type ChannelDescriptor = RuntimeChannelDescriptor;
 
-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 RuntimeChannelDescriptor 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 RuntimeClientOptions as a, type SessionOptions as a0, type RuntimePeerState as b, type RuntimeConnectionStateSnapshot as c, type RuntimePeerReadinessSnapshot as d, type RuntimePeerConnectOptions as e, type RuntimeIncomingStream as f, type RuntimeAuthIdentity as g, type RuntimeLocalDeviceInfo as h, type RuntimeLocalDeviceProfile as i, type RuntimeDevice as j, type RuntimeManagedSessionOptions as k, type RuntimeManagedSession as l, type RuntimeDeviceStatusSnapshot as m, type RuntimeDeviceConnectOptions as n, type RuntimeSession as o, type RuntimeJoinRoomOptions as p, type RuntimeRoomMember as q, type RuntimeConnectionTarget as r, type RuntimeScopedChannelOptions as s, type RuntimeScopedLogicalChannel as t, type RuntimePeerStreamOptions as u, type RuntimeRawConnection as v, type RuntimePresenceLoopOptions as w, type RuntimePeerHealth as x, type RuntimeApplicationPayloadReadinessOptions as y, type RuntimeConnectionEvent as z };
+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 };