openrtc 2.4.0 → 2.5.1

package/dist/runtime/index.d.ts

@@ -1,15 +1,15 @@
-import { a as PeerReconciliationStats } from '../assembly-By3UBQsE.js';
-export { D as ConnectionActor, d as ConnectionActorError, e as ConnectionActorErrorKind, f as ConnectionActorKey, g as ConnectionActorOptions, h as ConnectionActorState, i as ConnectionActors, j as ConnectionClose, k as ConnectionDial, l as LogicalChannel, P as PolicySnapshot, m as PreferredTransport, n as RUNTIME_POLICY, R as RuntimeClient, o as connectionActorKey, p as connectionActorKeyString, q as getRuntimePolicy } from '../assembly-By3UBQsE.js';
+import { a as PeerReconciliationStats } from '../assembly-DvfsYFCL.js';
+export { D as ConnectionActor, d as ConnectionActorError, e as ConnectionActorErrorKind, f as ConnectionActorKey, g as ConnectionActorOptions, h as ConnectionActorState, i as ConnectionActors, j as ConnectionClose, k as ConnectionDial, l as LogicalChannel, P as PolicySnapshot, m as PreferredTransport, n as RUNTIME_POLICY, R as RuntimeClient, o as connectionActorKey, p as connectionActorKeyString, q as getRuntimePolicy } from '../assembly-DvfsYFCL.js';
 import { Client as Client$1 } from '../coreClient.js';
-import { c as Avenue } from '../types-BArEthJr.js';
-import { au as SignalingOptions, K as ISignalingBackend, N as RuntimeIdentity, O as RoomMember, V as SignalingEnvelope, Y as SignalingSession, Q as Device, X as DesiredPeerProjection, a9 as BackendConnectionState, ar as AppLimits, G as GrantScope, f as Connection, av as JoinRoomOptions, aw as ChannelMetadata, al as CryptoStreams, ax as RoomCreationMode, F as ClientOptions, ak as PayloadCrypto, z as DiscoveryMode, ay as ProtocolCapabilityMap, az as ScanningLoopOptions, aA as ScanningLoopHandle, aB as RuntimeBootstrapOptions, aC as RuntimeBootstrapResult, aD as ApplicationPayloadReadinessOptions, aE as ManagedApplicationRouteOptions, aF as PeerState, aG as PeerScope, aH as PeerHealth, aI as ChannelDescriptor, aJ as JoinRequest, a7 as NativeConnectParams, a8 as NativeConnectResult, as as ConnectionTarget, w as RawConnection } from '../Connection-DZ5eP5hL.js';
-export { aK as AutoConnectPolicy, ae as BrowserProtocolStore, C as ChannelDescriptor, aL as ChannelFraming, p as ConnectionEvent, n as ConnectionState, aM as ConnectionStatus, r as DeviceConnectOptions, aN as DevicePresence, v as DeviceProfile, D as DeviceStatus, I as IncomingStream, ah as IrohDocEntry, ag as IrohMutationReceipt, J as JoinRoomOptions, L as LocalDeviceInfo, M as ManagedOptions, q as ManagedSession, af as NamespaceDescriptor, aO as PayloadRouteOptions, e as PeerConnectOptions, aP as PeerLifecycleStatus, h as PeerReadiness, aQ as PeerSessionSnapshot, k as PeerStreamOptions, a5 as PortableMediaChunk, a6 as PortableMediaControl, a3 as PortableMediaPublicationStart, a2 as PortableMediaPublish, a4 as PortableMediaSample, at as PresenceLoopOptions, aR as PresencePolicy, o as ReadinessOptions, aS as RuntimeAuthContext, ap as RuntimeAuthIdentity, y as RuntimeClientOptions, l as RuntimeDevice, i as RuntimePeerHealth, aT as RuntimePeerScope, d as RuntimePeerState, x as RuntimeRoomMember, aq as RuntimeSession, S as ScopedChannelOptions, m as ScopedLogicalChannel, aU as SessionKind, aV as SessionPlatform } from '../Connection-DZ5eP5hL.js';
-import { R as RuntimeCapabilities } from '../capabilities-B2mHv_H7.js';
-export { B as BROWSER_CAPABILITIES, a as CapabilityHost, C as CapabilityProfile, N as NATIVE_CAPABILITIES, b as NativeRuntimeStatus, c as RuntimeAdapterKind, T as TransportStatus, d as browserCapabilities, e as capabilityProfile, f as cloneCapabilities, s as statusCapabilities } from '../capabilities-B2mHv_H7.js';
+import { c as Avenue } from '../types-Cyc-mPjk.js';
+import { aB as SignalingOptions, U as ISignalingBackend, V as RuntimeIdentity, W as RoomMember, _ as SignalingEnvelope, a1 as SignalingSession, X as Device, a0 as DesiredPeerProjection, ae as BackendConnectionState, ay as AppLimits, G as GrantScope, j as Connection, aC as JoinRoomOptions, aD as ChannelMetadata, as as CryptoStreams, aE as RoomCreationMode, Q as ClientOptions, ar as PayloadCrypto, K as DiscoveryMode, aF as ProtocolCapabilityMap, aG as ScanningLoopOptions, aH as ScanningLoopHandle, aI as RuntimeBootstrapOptions, aJ as RuntimeBootstrapResult, aK as ApplicationPayloadReadinessOptions, aL as ManagedApplicationRouteOptions, aM as PeerState, aN as PeerScope, aO as PeerHealth, aP as ChannelDescriptor, aQ as JoinRequest, ac as NativeConnectParams, ad as NativeConnectResult, az as ConnectionTarget, A as RawConnection } from '../Connection-CTpuImO-.js';
+export { aR as AutoConnectPolicy, aj as BrowserProtocolStore, C as ChannelDescriptor, aS as ChannelFraming, t as ConnectionEvent, r as ConnectionState, aT as ConnectionStatus, v as DeviceConnectOptions, aU as DevicePresence, z as DeviceProfile, D as DeviceStatus, I as IncomingStream, am as IrohDocEntry, al as IrohMutationReceipt, J as JoinRoomOptions, L as LocalDeviceInfo, M as ManagedOptions, u as ManagedSession, ak as NamespaceDescriptor, aV as PayloadRouteOptions, i as PeerConnectOptions, aW as PeerLifecycleStatus, l as PeerReadiness, aX as PeerSessionSnapshot, o as PeerStreamOptions, aa as PortableMediaChunk, ab as PortableMediaControl, a8 as PortableMediaPublicationStart, a7 as PortableMediaPublish, a9 as PortableMediaSample, aA as PresenceLoopOptions, aY as PresencePolicy, s as ReadinessOptions, aZ as RuntimeAuthContext, aw as RuntimeAuthIdentity, H as RuntimeClientOptions, p as RuntimeDevice, m as RuntimePeerHealth, a_ as RuntimePeerScope, h as RuntimePeerState, B as RuntimeRoomMember, ax as RuntimeSession, S as ScopedChannelOptions, q as ScopedLogicalChannel, a$ as SessionKind, b0 as SessionPlatform } from '../Connection-CTpuImO-.js';
+import { R as RuntimeCapabilities } from '../capabilities-CmzzxSvW.js';
+export { B as BROWSER_CAPABILITIES, a as CapabilityHost, b as CapabilityMaturity, C as CapabilityProfile, N as NATIVE_CAPABILITIES, c as NativeRuntimeStatus, P as ProductCapabilityMaturity, d as RuntimeAdapterKind, T as TransportStatus, e as browserCapabilities, f as capabilityProfile, g as cloneCapabilities, s as statusCapabilities } from '../capabilities-CmzzxSvW.js';
 export { DeviceActiveOptions, isDeviceActive, isDeviceConnectable, isDeviceRoutable } from './device-status.js';
-export { a as IpcAdapterOptions, I as IpcRuntimeAdapter } from '../IpcRuntimeAdapter-Dduaxscj.js';
+export { a as IpcAdapterOptions, I as IpcRuntimeAdapter } from '../IpcRuntimeAdapter-Ddx0MtSI.js';
 export { P as NativeBridge, N as NativeIpcFailureKind, P as PlutoIpcBridge, a as PlutoIpcUnlisten, c as classifyIpcFailure, i as isIpcUnavailable } from '../ipc-DgzKqHH3.js';
-import '../DelegatingRuntimeAdapter-4cgiIWMN.js';
+import '../DelegatingRuntimeAdapter-D67Ozqo3.js';
 
 declare class Signaling {
     private readonly appTag;
@@ -52,7 +52,7 @@ declare class Signaling {
     startAutoConnect(userId: string, localDeviceId: string): void;
     submitDesiredPeerProjection(revision: number, peers: DesiredPeerProjection[]): Promise<void>;
     notifyDisconnectRequested(remoteNodeId: string): void;
-    startPresenceLoop(userId: string, localNodeId: string, deviceName: string, ticket: string, metadata?: string): void;
+    startPresenceLoop(userId: string, localNodeId: string, deviceName: string, ticket: string, metadata?: string): Promise<void>;
     forceReconnect(): void;
     isConnected(nodeId: string): Promise<boolean>;
     getConnectionStates(): Promise<BackendConnectionState[]>;
@@ -120,6 +120,7 @@ type IncomingStreamEvent = {
     protocolHint?: ProtocolHint;
     channel?: ChannelMetadata | null;
     applicationAuthorized?: boolean;
+    admissionCandidate?: boolean;
     applicationCrypto?: CryptoStreams;
     invalid?: boolean;
 };

package/dist/runtime/index.js

@@ -1 +1 @@
-export{a as runtimeFromCapability}from'../chunk-2LATKLCC.js';import'../chunk-ZA44REGI.js';export{a as isDeviceActive,c as isDeviceConnectable,b as isDeviceRoutable}from'../chunk-CK6WQV7J.js';export{h as ConnectionActor,e as ConnectionActorError,i as ConnectionActors,a as ConnectionController,s as IpcRuntimeAdapter,r as RuntimeClient,d as clog,p as concatRuntimeBytes,f as connectionActorKey,g as connectionActorKeyString,o as createJsonDecoder,k as createU32Decoder,m as decodeJsonPayload,n as encodeJsonFrame,l as encodeJsonPayload,j as encodeU32Frame,c as grantCorrelation,q as readRuntimeU32BE,b as renderCorrelation}from'../chunk-6OFAKLDB.js';import'../chunk-XEHBTMJQ.js';export{B as BROWSER_CAPABILITIES,C as NATIVE_CAPABILITIES,z as RUNTIME_POLICY,E as browserCapabilities,G as capabilityProfile,D as cloneCapabilities,A as getRuntimePolicy,m as logTeardownTrace,c as openRtcDebug,b as openRtcDebugEnabled,d as openRtcDebugInfo,e as openRtcDebugLog,F as statusCapabilities}from'../chunk-GNW63SM6.js';import'../chunk-TYZS5LXQ.js';import'../chunk-OT7IPLZE.js';import'../chunk-AJQVMVYW.js';export{a as classifyIpcFailure,b as isIpcUnavailable}from'../chunk-72NEEJQG.js';import'../chunk-WB66633N.js';import'../chunk-JPBW67B3.js';import'../chunk-MI3ZMVPK.js';import'../chunk-OWKAJPOI.js';import'../chunk-2GX6GB6L.js';
+export{a as isDeviceActive,c as isDeviceConnectable,b as isDeviceRoutable}from'../chunk-CK6WQV7J.js';export{h as ConnectionActor,e as ConnectionActorError,i as ConnectionActors,a as ConnectionController,s as IpcRuntimeAdapter,r as RuntimeClient,d as clog,p as concatRuntimeBytes,f as connectionActorKey,g as connectionActorKeyString,o as createJsonDecoder,k as createU32Decoder,m as decodeJsonPayload,n as encodeJsonFrame,l as encodeJsonPayload,j as encodeU32Frame,c as grantCorrelation,q as readRuntimeU32BE,b as renderCorrelation}from'../chunk-2K47N3QP.js';import'../chunk-BGWJHPBC.js';import'../chunk-FEF3DPPB.js';export{q as BROWSER_CAPABILITIES,r as NATIVE_CAPABILITIES,o as RUNTIME_POLICY,t as browserCapabilities,v as capabilityProfile,s as cloneCapabilities,p as getRuntimePolicy,h as logTeardownTrace,d as openRtcDebug,c as openRtcDebugEnabled,e as openRtcDebugInfo,f as openRtcDebugLog,u as statusCapabilities}from'../chunk-GTHSRQ7Y.js';import'../chunk-XTYALGJN.js';import'../chunk-TYZS5LXQ.js';import'../chunk-OT7IPLZE.js';import'../chunk-OWKAJPOI.js';export{a as classifyIpcFailure,b as isIpcUnavailable}from'../chunk-72NEEJQG.js';export{a as runtimeFromCapability}from'../chunk-Z54XUIKZ.js';import'../chunk-ZA44REGI.js';import'../chunk-LLZT3MR6.js';import'../chunk-DUY34MGT.js';import'../chunk-CCCYE3XN.js';import'../chunk-N6LGTNUI.js';import'../chunk-JPBW67B3.js';import'../chunk-2GX6GB6L.js';

package/dist/server-browser.d.ts

@@ -0,0 +1,14 @@
+export { AuthorityAssignmentInput, AuthorityInterestAssignment, AuthorityServiceGrant, AuthorityServiceGrantRequest, Ed25519Signer } from './service-node.js';
+import './types-Cyc-mPjk.js';
+import './coreClient.js';
+import './assembly-DvfsYFCL.js';
+import './Connection-CTpuImO-.js';
+import './capabilities-CmzzxSvW.js';
+
+/** Browser export for `openrtc/server`; secret-bearing helpers are unavailable. */
+
+declare class AuthorityServiceControlPlane {
+    constructor();
+}
+
+export { AuthorityServiceControlPlane };

package/dist/server-browser.js

@@ -0,0 +1 @@
+var e=class{constructor(){throw new Error("[OpenRTC] openrtc/server is unavailable in browsers; request a delegated grant from your backend.")}};export{e as AuthorityServiceControlPlane};

package/dist/server.d.ts

@@ -0,0 +1,44 @@
+import { Ed25519Signer, AuthorityServiceGrantRequest, AuthorityServiceGrant, AuthorityAssignmentInput, AuthorityInterestAssignment, DelegatedAuthorityGrantRequest } from './service-node.js';
+import './types-Cyc-mPjk.js';
+import './coreClient.js';
+import './assembly-DvfsYFCL.js';
+import './Connection-CTpuImO-.js';
+import './capabilities-CmzzxSvW.js';
+
+/** Secret-bearing Node/server helpers. Do not import this entrypoint in browsers. */
+
+interface AuthorityServiceOptions {
+    apiKey: string;
+    secretKey: string;
+    serviceId: string;
+    generation: number;
+    shardIds: string[];
+    deviceId: string;
+    deviceSigner: Ed25519Signer;
+    assignmentSigner: Ed25519Signer;
+    endpoint?: string;
+    fetch?: typeof globalThis.fetch;
+}
+/** Direct secret-backed grant issuer for a trusted Node/server process. */
+declare class AuthorityServiceControlPlane {
+    private readonly authority;
+    constructor(options: AuthorityServiceOptions);
+    requestGrant(input: AuthorityServiceGrantRequest): Promise<AuthorityServiceGrant>;
+    signAssignment(input: AuthorityAssignmentInput): Promise<{
+        assignment: AuthorityInterestAssignment;
+        signature: string;
+    }>;
+    devicePublicKey(): Promise<{
+        kty: "OKP";
+        crv: "Ed25519";
+        x: string;
+    }>;
+    signDeviceBytes(payload: Uint8Array): Promise<string>;
+    /**
+     * Adapt this trusted issuer to `openrtc/service-node` in Node. Browser
+     * applications must call their own authenticated backend instead.
+     */
+    grantIssuer(): (request: DelegatedAuthorityGrantRequest) => Promise<AuthorityServiceGrant>;
+}
+
+export { AuthorityAssignmentInput, AuthorityInterestAssignment, AuthorityServiceControlPlane, AuthorityServiceGrant, AuthorityServiceGrantRequest, type AuthorityServiceOptions, Ed25519Signer };

package/dist/server.js

@@ -0,0 +1,2 @@
+import {a}from'./chunk-GHAJW6SZ.js';import'./chunk-Z54XUIKZ.js';import'./chunk-ZA44REGI.js';import'./chunk-LLZT3MR6.js';import'./chunk-DUY34MGT.js';import'./chunk-CCCYE3XN.js';import'./chunk-N6LGTNUI.js';import'./chunk-JPBW67B3.js';import'./chunk-2GX6GB6L.js';function y(n){let e=new URL(n??"https://api.openrtc.app"),t=e.protocol==="http:"&&["127.0.0.1","localhost","::1"].includes(e.hostname.toLowerCase());if(e.protocol!=="https:"&&!t||e.username||e.password||e.search||e.hash)throw new TypeError("[OpenRTC] authority control-plane endpoint is invalid.");return e.toString().replace(/\/$/,"")}function h(){if(typeof document<"u"||typeof window<"u")throw new Error("[OpenRTC] openrtc/server is unavailable in browsers; use openrtc/service-node with a delegated grant.")}var c=class{constructor(e){h();let t=e.secretKey?.trim()??"";if(!/^sk_(?:live|test)_[A-Za-z0-9_-]+$/.test(t))throw new TypeError("[OpenRTC] secretKey is invalid.");let i=e.fetch??globalThis.fetch;if(typeof i!="function")throw new TypeError("[OpenRTC] a Fetch-compatible implementation is required.");let u=y(e.endpoint);this.authority=new a({apiKey:e.apiKey,serviceId:e.serviceId,generation:e.generation,shardIds:e.shardIds,deviceId:e.deviceId,deviceSigner:e.deviceSigner,assignmentSigner:e.assignmentSigner,grantIssuer:async s=>{let r=await i(`${u}/v2/developer/authority/grants`,{method:"POST",headers:{authorization:`Bearer ${t}`,"content-type":"application/json","x-openrtc-idempotency-key":s.idempotencyKey},body:JSON.stringify(s.body)});if(!r.ok){let o=await r.json().catch(()=>null),d=typeof o?.error=="string"?o.error.slice(0,256):`HTTP ${r.status}`;throw new Error(`[OpenRTC] authority service grant failed: ${d}`)}return r.json()}});}requestGrant(e){return this.authority.requestGrant(e)}signAssignment(e){return this.authority.signAssignment(e)}devicePublicKey(){return this.authority.devicePublicKey()}signDeviceBytes(e){return this.authority.signDeviceBytes(e)}grantIssuer(){return async e=>{let t=e.body;return this.requestGrant({roomId:String(t.avenue?.id??""),runtimeInstanceId:String(t.runtimeInstanceId??""),ticketFingerprint:String(t.ticketFingerprint??""),maxPeers:typeof t.maxPeers=="number"?t.maxPeers:void 0,refreshGrant:typeof t.refreshGrant=="string"?t.refreshGrant:void 0,features:typeof t.features=="object"&&t.features?t.features:void 0})}}};
+export{c as AuthorityServiceControlPlane};

package/dist/service-node.d.ts

@@ -0,0 +1,155 @@
+import { C as Client, X as Room, r as Connection } from './types-Cyc-mPjk.js';
+import './coreClient.js';
+import './assembly-DvfsYFCL.js';
+import './Connection-CTpuImO-.js';
+import './capabilities-CmzzxSvW.js';
+
+/** Browser-safe and Node-host-neutral developer service-node facade. */
+
+interface Ed25519Signer {
+    publicJwk(): JsonWebKey | Promise<JsonWebKey>;
+    sign(payload: Uint8Array): Uint8Array | Promise<Uint8Array>;
+}
+interface AuthorityServiceOptions {
+    apiKey: string;
+    /**
+     * App-backend delegation. Browser code must call a trusted developer
+     * backend here; it must never close over or embed an `sk_*` secret.
+     */
+    grantIssuer: AuthorityGrantIssuer;
+    serviceId: string;
+    generation: number;
+    shardIds: string[];
+    deviceId: string;
+    deviceSigner: Ed25519Signer;
+    assignmentSigner: Ed25519Signer;
+}
+interface DelegatedAuthorityGrantRequest {
+    apiKey: string;
+    idempotencyKey: string;
+    body: Record<string, unknown>;
+}
+type AuthorityGrantIssuer = (request: DelegatedAuthorityGrantRequest) => Promise<unknown>;
+interface AuthorityServiceGrantRequest {
+    roomId: string;
+    runtimeInstanceId: string;
+    ticketFingerprint: string;
+    maxPeers?: number;
+    refreshGrant?: string;
+    features?: Partial<{
+        irohRelay: boolean;
+        managedTurn: boolean;
+        moq: boolean;
+        ble: boolean;
+    }>;
+}
+interface AuthorityServiceGrant {
+    protocolVersion: 2;
+    gatewayUrl: string;
+    routeKey: string;
+    token: string;
+    expiresAtMs: number;
+    avenue: {
+        kind: 'room';
+        id: string;
+    };
+    maxPeers: number;
+    architecture: 'authority';
+    roomAuthority: {
+        serviceId: string;
+        generation: number;
+        shardIds: string[];
+        assignmentPublicKeyJwk: {
+            kty: 'OKP';
+            crv: 'Ed25519';
+            x: string;
+        };
+    };
+}
+interface AuthorityInterestAssignment {
+    policyVersion: 'room-authority-assignment-v1';
+    serviceId: string;
+    generation: number;
+    revision: number;
+    subjectDeviceId: string;
+    shardId: string;
+    priorityDeviceIds: string[];
+    relevantEntityIds: string[];
+    issuedAtMs: number;
+    expiresAtMs: number;
+}
+interface AuthorityAssignmentInput {
+    revision: number;
+    subjectDeviceId: string;
+    shardId: string;
+    priorityDeviceIds?: string[];
+    relevantEntityIds?: string[];
+    ttlMs?: number;
+}
+interface ServiceNodeOptions extends AuthorityServiceOptions {
+    /** Browser uses WASM with delegated grants; `openrtc/node` uses the bundled Rust host. */
+    client: Client;
+    maxPeers?: number;
+    irohRelay?: boolean;
+}
+interface ServiceNodeConnectionEvent {
+    room: ServiceNodeRoom;
+    connection: Connection;
+}
+interface ServiceNodeRoom extends Room {
+    publishAssignment(input: AuthorityAssignmentInput): Promise<AuthorityInterestAssignment>;
+}
+/**
+ * Data-only server boundary for service grant issuance and signed AOI input.
+ * It does not own sockets, retries, topology, or transport selection.
+ */
+declare class DelegatedAuthorityService {
+    private readonly apiKey;
+    private readonly applicationTag;
+    private readonly grantIssuer;
+    private readonly serviceId;
+    private readonly generation;
+    private readonly shardIds;
+    private readonly deviceId;
+    private readonly deviceSigner;
+    private readonly assignmentSigner;
+    constructor(options: AuthorityServiceOptions);
+    requestGrant(input: AuthorityServiceGrantRequest): Promise<AuthorityServiceGrant>;
+    devicePublicKey(): Promise<{
+        kty: 'OKP';
+        crv: 'Ed25519';
+        x: string;
+    }>;
+    assignmentPublicKey(): Promise<{
+        kty: 'OKP';
+        crv: 'Ed25519';
+        x: string;
+    }>;
+    signDeviceBytes(payload: Uint8Array): Promise<string>;
+    signAssignment(input: AuthorityAssignmentInput): Promise<{
+        assignment: AuthorityInterestAssignment;
+        signature: string;
+    }>;
+}
+/**
+ * Familiar application server facade. It handles application events only;
+ * OpenRTC's Rust/WASM owner still controls admission, dialing, retry, routes,
+ * and carrier switching.
+ */
+declare class ServiceNode {
+    private readonly options;
+    private readonly authority;
+    private readonly rooms;
+    private readonly connectionListeners;
+    private readonly connectionCleanups;
+    private closed;
+    constructor(options: ServiceNodeOptions);
+    listen(roomId: string): Promise<ServiceNodeRoom>;
+    onConnection(listener: (event: ServiceNodeConnectionEvent) => void): () => void;
+    close(): Promise<void>;
+    private openRoom;
+    private evictRoom;
+    private attachConnectionListener;
+}
+
+export { type AuthorityAssignmentInput, type AuthorityGrantIssuer, type AuthorityInterestAssignment, type AuthorityServiceGrant, type AuthorityServiceGrantRequest, type AuthorityServiceOptions, type DelegatedAuthorityGrantRequest, DelegatedAuthorityService, type Ed25519Signer, ServiceNode, type ServiceNodeConnectionEvent, type ServiceNodeOptions, type ServiceNodeRoom };

package/dist/service-node.js

@@ -0,0 +1 @@
+export{a as DelegatedAuthorityService,b as ServiceNode}from'./chunk-GHAJW6SZ.js';import'./chunk-Z54XUIKZ.js';import'./chunk-ZA44REGI.js';import'./chunk-LLZT3MR6.js';import'./chunk-DUY34MGT.js';import'./chunk-CCCYE3XN.js';import'./chunk-N6LGTNUI.js';import'./chunk-JPBW67B3.js';import'./chunk-2GX6GB6L.js';

package/dist/testing/native.d.ts

@@ -1,10 +1,10 @@
-import { O as Options, C as Client } from '../types-BArEthJr.js';
+import { O as Options, C as Client } from '../types-Cyc-mPjk.js';
 import { E as Endpoints } from '../protocol-BSBjMb7p.js';
 import { P as PlutoIpcBridge } from '../ipc-DgzKqHH3.js';
 import '../coreClient.js';
-import '../assembly-By3UBQsE.js';
-import '../Connection-DZ5eP5hL.js';
-import '../capabilities-B2mHv_H7.js';
+import '../assembly-DvfsYFCL.js';
+import '../Connection-CTpuImO-.js';
+import '../capabilities-CmzzxSvW.js';
 
 declare function OpenRTC(options: Options, endpoints: Endpoints, bridge: PlutoIpcBridge): Client;
 

package/dist/testing/native.js

@@ -1 +1 @@
-import {a as a$1}from'../chunk-BOS554IK.js';import'../chunk-4MLJXEVV.js';import {b}from'../chunk-2LATKLCC.js';import'../chunk-ZA44REGI.js';import {a}from'../chunk-P2SHJMS3.js';import'../chunk-WB66633N.js';import'../chunk-JPBW67B3.js';import'../chunk-2GX6GB6L.js';function v(c,p,e){let o=new a;return b(c,{endpoints:p,testingAllowInsecureLoopback:true,platform:"native",close:()=>o.close(),deviceKeyProvider:a$1(e),deviceIdProvider:async()=>{let t=await e.invoke("get_rtc_local_device_info");return String(t?.deviceId??"")},runtimeFactory:async t=>{let{createIpcClient:a}=await import('../ipcFactory-4PCGKZIN.js');return a(t,e,o)}})}export{v as OpenRTC};
+import {a as a$1}from'../chunk-VFDCIEP6.js';import {a}from'../chunk-VTYVIKTM.js';import'../chunk-NDR2ANQB.js';import {f}from'../chunk-Z54XUIKZ.js';import'../chunk-ZA44REGI.js';import'../chunk-LLZT3MR6.js';import'../chunk-DUY34MGT.js';import'../chunk-CCCYE3XN.js';import'../chunk-N6LGTNUI.js';import'../chunk-JPBW67B3.js';import'../chunk-2GX6GB6L.js';function v(c,p,e){let o=new a;return f(c,{endpoints:p,testingAllowInsecureLoopback:true,platform:"native",close:()=>o.close(),deviceKeyProvider:a$1(e),deviceIdProvider:async()=>{let t=await e.invoke("get_rtc_local_device_info");return String(t?.deviceId??"")},runtimeFactory:async t=>{let{createIpcClient:a}=await import('../ipcFactory-PRAJ7JP7.js');return a(t,e,o)}})}export{v as OpenRTC};

package/dist/testing.d.ts

@@ -1,9 +1,9 @@
-import { ab as CoordinationGatewayGrantRequest, ac as CoordinationGatewayGrant } from './Connection-DZ5eP5hL.js';
-import { a as AttestationProvider, b as AuthProvider, B as BotVerificationProvider, h as DeviceProfile, O as Options, C as Client } from './types-BArEthJr.js';
+import { R as RoomArchitectureMode, ag as CoordinationGatewayGrantRequest, ah as CoordinationGatewayGrant } from './Connection-CTpuImO-.js';
+import { a as AttestationProvider, b as AuthProvider, B as BotVerificationProvider, e as BroadcastGrant, d as BroadcastCreateOptions, f as BroadcastInvite, g as BroadcastInviteOptions, D as Delivery, t as DeviceProfile, O as Options, C as Client } from './types-Cyc-mPjk.js';
 import { E as Endpoints } from './protocol-BSBjMb7p.js';
 import './coreClient.js';
-import './assembly-By3UBQsE.js';
-import './capabilities-B2mHv_H7.js';
+import './assembly-DvfsYFCL.js';
+import './capabilities-CmzzxSvW.js';
 
 interface DeviceProof {
     publicKeyJwk: JsonWebKey;
@@ -14,6 +14,8 @@ interface DeviceProof {
 interface DeviceKey {
     readonly publicKeyJwk: JsonWebKey;
     readonly thumbprint: string;
+    /** Signs Rust-canonical protocol bytes without exporting private key material. */
+    sign(message: Uint8Array): Promise<string>;
     proof(challenge: (nonce: string, issuedAt: number) => string): Promise<DeviceProof>;
 }
 interface DeviceKeyProvider {
@@ -80,8 +82,37 @@ declare class ControlPlane {
     private authEpoch;
     dispose(): void;
     private key;
+    /** Public half of the existing platform-issued device signer. */
+    deviceSigningPublicKey(): Promise<JsonWebKey>;
+    signDeviceBytes(message: Uint8Array): Promise<string>;
+    /**
+     * Resolve one opaque grant into a private provider allocation. The public
+     * grant is only a signed, device-bound authorization; relay credentials
+     * are returned solely to the private broadcast mechanics host.
+     */
+    resolveBroadcastAccess(grant: string, publicationVerifyingKey?: Uint8Array): Promise<{
+        token: string;
+        issuerPublicKey: Uint8Array;
+        signBindingChallenge(message: Uint8Array): Promise<Uint8Array>;
+        relay: {
+            relayUrl: string;
+            token: string;
+            namespace: string;
+        };
+    }>;
+    /** Authenticated owner operations. The server performs the atomic hard
+     * reservation before minting a grant or allocating provider capacity. */
+    manageBroadcast(input: {
+        action: 'create' | 'invite' | 'accept' | 'renew' | 'revoke' | 'leave' | 'close';
+        deviceId: string;
+        auth: AuthProvider;
+        grant?: BroadcastGrant;
+        create?: BroadcastCreateOptions;
+        invite?: BroadcastInvite;
+        invitation?: BroadcastInviteOptions;
+    }): Promise<BroadcastGrant | BroadcastInvite | undefined>;
     private post;
-    capability(kind: 'space' | 'room' | 'ticket', id: string, maxPeers?: number, advancedFanout?: boolean): Promise<CredentialSource>;
+    capability(kind: 'space' | 'room' | 'ticket', id: string, maxPeers?: number, advancedFanout?: boolean, architecture?: RoomArchitectureMode, roomDelivery?: Delivery): Promise<CredentialSource>;
     deviceCertificate(auth: AuthProvider, deviceId: string, avenue?: CoordinationGatewayGrantRequest['avenue'], profile?: DeviceProfile, rejected?: AuthenticatedDeviceCertificate): Promise<{
         source: CredentialSource;
         principalId: string;
@@ -106,6 +137,8 @@ declare class ControlPlane {
     grantProvider(source: CredentialSource, input?: {
         maxPeers?: number;
         features?: Record<string, boolean>;
+        architecture?: RoomArchitectureMode;
+        roomDelivery?: Delivery;
         deviceProfile?: Pick<DeviceProfile, 'name' | 'platform'>;
         /**
          * Keeps the transport/admission credential relay synchronized

package/dist/testing.js

@@ -1 +1 @@
-import {a}from'./chunk-BCGCJGIV.js';import {c}from'./chunk-4MLJXEVV.js';import {b}from'./chunk-2LATKLCC.js';import'./chunk-ZA44REGI.js';import'./chunk-WB66633N.js';import'./chunk-JPBW67B3.js';import'./chunk-2GX6GB6L.js';function s(i){let r=e=>`${e}:${i}`;return {getOrCreate:e=>c.getOrCreate(r(e)),delete:async e=>{await c.delete?.(r(e));},readSecureRecord:(e,o)=>c.readSecureRecord?.(r(e),o)??Promise.resolve(null),writeSecureRecord:(e,o,n)=>c.writeSecureRecord?.(r(e),o,n)??Promise.resolve(),deleteSecureRecord:(e,o)=>c.deleteSecureRecord?.(r(e),o)??Promise.resolve()}}function m(i,r,e){return new a(i,r,s(e))}function u(i,r,e={}){return b(i,{endpoints:r,testingAllowInsecureLoopback:true,platform:"web",...e.deviceId?{deviceIdProvider:async()=>e.deviceId}:{},...e.irohTestRelayUrl?{irohTestRelayUrl:e.irohTestRelayUrl}:{},runtimeFactory:async o=>{let{createWasmClient:n}=await import('./runtime/factories.js');return n(o)}})}export{u as OpenRTC,m as controlPlane};
+import {a}from'./chunk-BFN3AVHA.js';import {c}from'./chunk-NDR2ANQB.js';import {f}from'./chunk-Z54XUIKZ.js';import'./chunk-ZA44REGI.js';import'./chunk-LLZT3MR6.js';import'./chunk-DUY34MGT.js';import'./chunk-CCCYE3XN.js';import'./chunk-N6LGTNUI.js';import'./chunk-JPBW67B3.js';import'./chunk-2GX6GB6L.js';function s(i){let r=e=>`${e}:${i}`;return {getOrCreate:e=>c.getOrCreate(r(e)),delete:async e=>{await c.delete?.(r(e));},readSecureRecord:(e,o)=>c.readSecureRecord?.(r(e),o)??Promise.resolve(null),writeSecureRecord:(e,o,n)=>c.writeSecureRecord?.(r(e),o,n)??Promise.resolve(),deleteSecureRecord:(e,o)=>c.deleteSecureRecord?.(r(e),o)??Promise.resolve()}}function m(i,r,e){return new a(i,r,s(e))}function u(i,r,e={}){return f(i,{endpoints:r,testingAllowInsecureLoopback:true,platform:"web",...e.deviceId?{deviceIdProvider:async()=>e.deviceId}:{},...e.irohTestRelayUrl?{irohTestRelayUrl:e.irohTestRelayUrl}:{},runtimeFactory:async o=>{let{createWasmClient:n}=await import('./runtime/factories.js');return n(o)}})}export{u as OpenRTC,m as controlPlane};

package/dist/transport/index.d.ts

@@ -1,5 +1,5 @@
-import { c as ProtocolName, aj as RouteDescriptor, ak as PayloadCrypto, al as CryptoStreams } from '../Connection-DZ5eP5hL.js';
-export { am as CryptoBiStream, an as RouteFamily, ao as RouteKind } from '../Connection-DZ5eP5hL.js';
+import { g as ProtocolName, aq as RouteDescriptor, ar as PayloadCrypto, as as CryptoStreams } from '../Connection-CTpuImO-.js';
+export { at as CryptoBiStream, au as RouteFamily, av as RouteKind } from '../Connection-CTpuImO-.js';
 
 declare const TRANSPORT_LABELS: readonly ProtocolName[];
 declare function normalizeTransport(value: unknown): ProtocolName | undefined;

package/dist/{types-BArEthJr.d.ts → types-Cyc-mPjk.d.ts}

@@ -1,5 +1,5 @@
 import { PeerNamespace, ChannelNamespace, DiagnosticsNamespace, DeviceNamespace } from './coreClient.js';
-import { C as ChannelDescriptor, P as PlutoIrohConfiguration, a as PlutoRTCConfiguration, b as PlutoMoQConfiguration, R as RouteOptimization, c as ProtocolName } from './Connection-DZ5eP5hL.js';
+import { R as RoomArchitectureMode, b as RoomArchitectureSnapshot, c as RoomAuthorityAssignment, C as ChannelDescriptor, P as PlutoIrohConfiguration, d as PlutoRTCConfiguration, e as PlutoMoQConfiguration, f as RouteOptimization, g as ProtocolName } from './Connection-CTpuImO-.js';
 
 interface AuthProvider {
     /** Registered provider ID from the developer app capability manifest. */
@@ -317,6 +317,10 @@ interface Connection {
 interface Channel<T> {
     send(message: T): Promise<void>;
     sendTo(peerId: string, message: T): Promise<void>;
+    /**
+     * The event peerId is the authenticated device ID for sparse broadcasts;
+     * direct channels retain the connection peer ID.
+     */
     onMessage(callback: (event: {
         peerId: string;
         message: T;
@@ -362,6 +366,14 @@ interface Space extends Avenue {
 interface Room extends Avenue {
     readonly kind: 'room';
     readonly membership: 'ephemeral' | 'durable';
+    /** Current room-wide architecture chosen by the gateway policy owner. */
+    architecture(): RoomArchitectureSnapshot;
+    /** Emits the current snapshot immediately, then later committed changes. */
+    onArchitectureChanged(callback: (snapshot: RoomArchitectureSnapshot) => void): () => void;
+    /** Current signed application-interest assignment, if authority mode has assigned this client. */
+    authorityAssignment(): RoomAuthorityAssignment | null;
+    /** Emits the current assignment immediately, then later admitted revisions. */
+    onAuthorityAssignmentChanged(callback: (assignment: RoomAuthorityAssignment | null) => void): () => void;
     leave(): Promise<void>;
 }
 interface Ticket extends Avenue {
@@ -378,6 +390,12 @@ interface Ticket extends Avenue {
 interface DeviceOptions {
     auth?: AuthProvider;
     autoConnect?: 'none' | 'online';
+    /**
+     * Durable device IDs that automatic discovery must not connect to.
+     * Load persisted exclusions before calling `devices.start()` so the Rust
+     * owner and the first coordination presence share one atomic policy.
+     */
+    autoConnectExcludedDeviceIds?: readonly string[];
     /** Optional local profile; it does not alter the durable device identity. */
     profile?: DeviceProfile;
     maxPeers?: number;
@@ -400,9 +418,20 @@ interface RoomOptions {
     identity?: 'session';
     auth?: AuthProvider;
     maxPeers?: number;
+    /**
+     * Declares the room's delivery semantics for architecture selection.
+     * Reliable is the safe default. Sparse rooms require latest-state data.
+     */
+    payload?: Delivery;
+    /**
+     * Defaults to auto. A fixed mode is room-wide and may still fail safety or
+     * budget gates. Managed is reserved but unavailable in 2.5.
+     */
+    architecture?: RoomArchitectureMode;
     /**
      * Requires the app manifest's reviewed advanced-fanout opt-in. Rooms then
      * use a four-neighbor sparse overlay with bounded named-channel gossip.
+     * @deprecated Use `architecture: 'sparse'`. Removed in the next major.
      */
     advancedFanout?: boolean;
 }
@@ -425,9 +454,133 @@ interface Usage {
         creditsUsd: number;
         estimated: true;
     };
+    estimateRoom(input: RoomUsageEstimateInput): RoomUsageEstimate;
     readonly sessionCreditsUsd: number;
 }
+interface RoomUsageEstimateInput {
+    /** Managed quotes are unavailable in 2.5 and fail with `room-architecture-unavailable`. */
+    architecture?: RoomArchitectureMode;
+    maxMembers: number;
+    durationSeconds: number;
+    delivery: Delivery;
+    maxPayloadBytes: number;
+    maxMessagesPerSecond: number;
+}
+interface RoomUsageEstimate {
+    architecture: RoomArchitectureMode;
+    effectiveArchitecture: Exclude<RoomArchitectureMode, 'auto'>;
+    creditsUsd: number;
+    estimated: true;
+    expiresAtMs: number;
+    assumptions: readonly string[];
+}
+type OfflineAssurance = 'software' | 'hardware-backed' | 'manufacturer' | 'gateway';
+interface OfflineRuntimeSupport {
+    provisioning: boolean;
+    localMesh: boolean;
+    cloudRequired: false;
+    reason?: string;
+}
+interface OfflineEnrollmentRequest {
+    body: {
+        protocol: 'openrtc-offline-device/1';
+        trustDomain: string;
+        deviceId: string;
+        endpointId: string;
+        proofPublicKey: string;
+        enrollmentNonce: string;
+        requestedRoles: string[];
+        /** Informational request metadata; the fleet issuer certifies the credential assurance. */
+        requestedAssurance: OfflineAssurance;
+        createdAtMs: number;
+    };
+    proofSignature: string;
+}
+interface Offline {
+    support(): Promise<OfflineRuntimeSupport>;
+    /** Native Rust signs this request; private key bytes never enter JavaScript. */
+    createEnrollmentRequest(options: {
+        trustDomain: string;
+        requestedRoles: string[];
+    }): Promise<OfflineEnrollmentRequest>;
+}
+/** Opaque, short-lived, installation-bound broadcast authority. */
+type BroadcastGrant = string & {
+    readonly __openrtcBroadcastGrant: unique symbol;
+};
+/** Single-use bearer invitation. Send it only to the intended recipient. */
+type BroadcastInvite = string & {
+    readonly __openrtcBroadcastInvite: unique symbol;
+};
+type BroadcastRole = 'owner' | 'publisher' | 'subscriber' | 'processor';
+type BroadcastState = 'opening' | 'live' | 'retrying' | 'closed' | 'failed';
+interface BroadcastSource {
+    /** Anonymous slot such as `host-a`; never a device, endpoint, or provider ID. */
+    readonly id: string;
+    readonly alias?: string;
+}
+interface BroadcastTrackEvent extends MediaTrackEvent {
+    readonly source: BroadcastSource;
+}
+interface BroadcastMedia {
+    addTrack(track: MediaStreamTrack, options?: MediaTrackOptions): Promise<MediaSender>;
+    removeTrack(sender: MediaSender): Promise<void>;
+    onTrack(callback: (event: BroadcastTrackEvent) => void): () => void;
+    senders(): readonly MediaSender[];
+    receivers(): readonly MediaReceiver[];
+}
+interface BroadcastStats {
+    queuedMediaBytes: number;
+    droppedMediaObjects: number;
+    publishedBytes: number;
+    deliveredBytes: number;
+    retries: number;
+}
+/** Non-peer relay publication/subscription. It never exposes a carrier or provider handle. */
+interface BroadcastSession {
+    readonly id: string;
+    readonly role: BroadcastRole;
+    readonly state: BroadcastState;
+    readonly media: BroadcastMedia;
+    getStats(): Promise<BroadcastStats>;
+    close(): Promise<void>;
+}
+/**
+ * Runtime-owned publisher identity. Only its public verification key is
+ * exportable; the sign-only private key remains inside native Rust or WASM.
+ */
+interface BroadcastPublisher {
+    readonly verificationKey: Uint8Array;
+    open(grant: BroadcastGrant): Promise<BroadcastSession>;
+    close(): Promise<void>;
+}
+interface BroadcastCreateOptions {
+    /** Rust/WASM/native signer whose public key is bound into the owner grant. */
+    publisher: BroadcastPublisher;
+    auth?: AuthProvider;
+    sourceSlot?: string;
+    maxPublishers: number;
+    maxSubscribers: number;
+    maxBitrateBps: number;
+    maxDurationSeconds: number;
+    maxEgressBytes: number;
+    /** Actual initial owner publication reservation, not the broadcast ceiling. */
+    publisherBitrateBps: number;
+    /** Actual initial owner/viewer egress reservation, not the broadcast ceiling. */
+    reservedEgressBytes: number;
+}
+interface BroadcastInviteOptions {
+    role: 'publisher' | 'subscriber';
+    /** Required for publishers; obtained from that co-host's prepared signer. */
+    publicationVerificationKey?: Uint8Array;
+    /** Required and unique for publishers; omitted for subscribers. */
+    sourceSlot?: string;
+    bitrateBps: number;
+    durationSeconds: number;
+    reservedEgressBytes: number;
+}
 interface Client {
+    readonly offline: Offline;
     readonly devices: {
         /**
          * Returns this installation's durable, app-scoped device ID without
@@ -455,9 +608,43 @@ interface Client {
     readonly tickets: {
         issue(id: string, options?: TicketOptions): Promise<Ticket>;
     };
+    readonly broadcasts: {
+        /** Reserve hard limits and mint a device/key-bound owner grant. */
+        create(options: BroadcastCreateOptions): Promise<BroadcastGrant>;
+        /** The signed grant decides the role; options cannot promote the caller. */
+        open(grant: BroadcastGrant): Promise<BroadcastSession>;
+        /** Familiar viewer alias for `open`; the grant still decides the role. */
+        subscribe(grant: BroadcastGrant): Promise<BroadcastSession>;
+        /** Prepare a runtime-owned signer before requesting a publisher grant. */
+        preparePublisher(): Promise<BroadcastPublisher>;
+        /** Renewal advances the grant generation; it never mutates in place. */
+        renew(grant: BroadcastGrant, options?: {
+            auth?: AuthProvider;
+        }): Promise<BroadcastGrant>;
+        /** Create a single-use role invitation; capacity is reserved on accept. */
+        invite(ownerGrant: BroadcastGrant, options: BroadcastInviteOptions & {
+            auth?: AuthProvider;
+        }): Promise<BroadcastInvite>;
+        /** Bind an invitation to this installation and mint its role grant. */
+        accept(invite: BroadcastInvite, options?: {
+            auth?: AuthProvider;
+        }): Promise<BroadcastGrant>;
+        /** Owner-only targeted revoke; the accepted invitation identifies one role/source. */
+        revoke(ownerGrant: BroadcastGrant, options: {
+            invite: BroadcastInvite;
+            auth?: AuthProvider;
+        }): Promise<void>;
+        /** Retire this installation's own role grant. */
+        leave(grant: BroadcastGrant, options?: {
+            auth?: AuthProvider;
+        }): Promise<void>;
+        close(grant: BroadcastGrant, options?: {
+            auth?: AuthProvider;
+        }): Promise<void>;
+    };
     readonly channels: Channels;
     readonly usage: Usage;
     close(): Promise<void>;
 }
 
-export type { AccessMode as A, BotVerificationProvider as B, Client as C, Delivery as D, EnrolledDevice as E, State as F, TicketOptions as G, Transports as H, IncomingPeerBidirectionalStream as I, UsageUpdate as J, UsageWarning as K, MediaConnection as M, Options as O, PeerBidirectionalStream as P, Room as R, Space as S, Ticket as T, Usage as U, AttestationProvider as a, AuthProvider as b, Avenue as c, Channel as d, Channels as e, Connection as f, DeviceOptions as g, DeviceProfile as h, Devices as i, IncomingPeerUnidirectionalStream as j, MediaIncomingDemuxStats as k, MediaKind as l, MediaLatencySummary as m, MediaReceiver as n, MediaReceiverStats as o, MediaSender as p, MediaSenderStats as q, MediaStats as r, MediaTrackEvent as s, MediaTrackOptions as t, PeerDatagramDuplexStream as u, PeerDatagramStats as v, PeerStreamOptions as w, PeerStreamTransport as x, RoomOptions as y, SpaceOptions as z };
+export type { Space as $, AccessMode as A, BotVerificationProvider as B, Client as C, Delivery as D, EnrolledDevice as E, MediaReceiverStats as F, MediaSender as G, MediaSenderStats as H, IncomingPeerBidirectionalStream as I, MediaStats as J, MediaTrackEvent as K, MediaTrackOptions as L, MediaConnection as M, Offline as N, Options as O, OfflineAssurance as P, OfflineEnrollmentRequest as Q, OfflineRuntimeSupport as R, PeerBidirectionalStream as S, PeerDatagramDuplexStream as T, PeerDatagramStats as U, PeerStreamOptions as V, PeerStreamTransport as W, Room as X, RoomOptions as Y, RoomUsageEstimate as Z, RoomUsageEstimateInput as _, AttestationProvider as a, SpaceOptions as a0, State as a1, Ticket as a2, TicketOptions as a3, Transports as a4, Usage as a5, UsageUpdate as a6, UsageWarning as a7, AuthProvider as b, Avenue as c, BroadcastCreateOptions as d, BroadcastGrant as e, BroadcastInvite as f, BroadcastInviteOptions as g, BroadcastMedia as h, BroadcastPublisher as i, BroadcastRole as j, BroadcastSession as k, BroadcastSource as l, BroadcastState as m, BroadcastStats as n, BroadcastTrackEvent as o, Channel as p, Channels as q, Connection as r, DeviceOptions as s, DeviceProfile as t, Devices as u, IncomingPeerUnidirectionalStream as v, MediaIncomingDemuxStats as w, MediaKind as x, MediaLatencySummary as y, MediaReceiver as z };