openrtc 2.4.0 → 2.5.1

package/README.md

@@ -100,6 +100,75 @@ const team = await rtc.rooms.join('team', {
 Every long-lived capability has `close()`; spaces and rooms also have
 `leave()`. One handle activates exactly one avenue.
 
+## Developer service nodes
+
+`openrtc/service-node` exposes a preview WebSocket-server-like application
+surface for browser/WASM. Browser code supplies a callback
+that obtains a short-lived authority grant from the developer backend; it must
+never receive a developer `sk_*` key. Trusted Node/server code can mint that
+grant with `openrtc/server`.
+
+```ts
+import { ServiceNode } from 'openrtc/service-node';
+
+const service = new ServiceNode({
+  client: rtc,
+  apiKey,
+  serviceId: 'world-simulation',
+  generation: 1,
+  shardIds: ['zone-a'],
+  deviceId: await rtc.devices.localId(),
+  deviceSigner,
+  assignmentSigner,
+  grantIssuer: (request) => fetch('/api/openrtc/authority-grant', {
+    method: 'POST',
+    body: JSON.stringify(request),
+  }).then((response) => response.json()),
+});
+
+service.onConnection(({ connection }) => console.log(connection.id));
+await service.listen('world-42');
+```
+
+Trusted Node.js authorities use the dedicated Rust host through `openrtc/node`;
+no application IPC bridge or native addon is required:
+
+```ts
+import { ServiceNode } from 'openrtc/node';
+
+const service = new ServiceNode({
+  apiKey: process.env.OPENRTC_API_KEY!,
+  secretKey: process.env.OPENRTC_SECRET_KEY!,
+  serviceId: 'world-simulation',
+  generation: 1,
+  shardIds: ['zone-a'],
+  deviceId: 'world-simulation-1',
+  stateDirectory: '/var/lib/world-simulation/openrtc', // private and persistent
+});
+
+service.onConnection(({ connection }) => {
+  connection.onMessage((message) => console.log(connection.peerId, message));
+});
+await service.listen('world-42');
+```
+
+The released package must contain the signed native artifact for the current
+`process.platform`/`process.arch`; a missing artifact fails closed. A reviewed
+source checkout can instead opt into `buildFromSource: true` with an absolute
+`sourceRoot`. The developer secret is sent only over the child's stdin, and
+the Node layer only demultiplexes bounded application messages and authority
+assignments. The Rust peer-session actor remains the sole lifecycle owner.
+This preview Node facade intentionally owns one room and exposes only
+message-oriented `send`/`onMessage`/`onClose` plus assignment publication; it
+does not yet claim the browser facade's streams, media, or full Room
+namespaces. Browser resolution of `openrtc/node` fails closed; browser code
+uses WASM plus delegated grants through `openrtc/service-node`. Native Rust
+uses `ControlPlane::join_authority_room` directly and does not require
+JavaScript.
+
+The authority surface remains preview-only until signed prebuilt artifacts and
+source-bound browser, Node, and native Rust authority E2E lanes pass.
+
 ## Optional trust adapters
 
 Attestation is evaluated at device enrollment, key rotation, recovery, or risk
@@ -166,8 +235,11 @@ overrides live only in `openrtc/testing`.
 
 Relay, durable membership, managed attestation, MoQ, and BLE require both
 portal enablement and explicit runtime opt-in. Avenues default to 8 peers.
-Reviewed non-room avenues may request 9-12 peers. Reviewed rooms may request up
-to 99 peers with `advancedFanout: true`; OpenRTC then maintains a symmetric
-four-neighbor overlay and forwards named-channel messages with bounded hops and
-duplicate suppression. `state()` is intentionally unavailable in sparse rooms;
-use a named channel with application-owned latest-state revisions.
+Reviewed non-room avenues may request 9-12 peers. Rooms default to
+`architecture: 'auto'` and `payload: 'reliable'`. Small rooms use a direct
+mesh. A room may declare `payload: 'latest-state'` so auto can use the reviewed
+four-neighbor sparse graph through 50 members. Reliable rooms above the safe
+mesh limit require
+the explicitly enabled, content-blind managed path. `advancedFanout: true` is a
+one-release alias for fixed sparse latest-state delivery. `state()` remains
+unavailable in sparse rooms; use a named channel with application revisions.

package/dist/BrowserManagedBroadcastHost-ARCP5MGJ.js

@@ -0,0 +1 @@
+import {b,a as a$2}from'./chunk-BGWJHPBC.js';import {a}from'./chunk-AYHD4X2R.js';import {b as b$1,a as a$1}from'./chunk-LLZT3MR6.js';import'./chunk-JPBW67B3.js';var y=class{constructor(e){this.deps=e;this.active=null;this.commands=Promise.resolve();}apply(e){let t=this.commands.then(()=>this.applyOrdered(e));return this.commands=t.catch(()=>{}),t}dispose(){this.retire();}async applyOrdered(e){if(e.type==="open"){await this.open(e);return}if(this.isCurrent(e)){if(e.type==="publish"){if(!this.active||!["owner","publisher","processor"].includes(this.active.role))throw new Error("broadcast role cannot publish");let t=await this.duplex(e.sourceSlot,true),r=this.active.writers.get(e.sourceSlot);r||(r=t.writable.getWriter(),this.active.writers.set(e.sourceSlot,r)),await b(r.write(e.object),2e3,"broadcast object write");return}if(e.type==="subscribe"){if(!this.active||!["owner","subscriber","processor"].includes(this.active.role))throw new Error("broadcast role cannot subscribe");await Promise.all(e.sourceSlots.map(async t=>{let r=await this.duplex(t,false),a=this.active;this.readObjects(a,t,r.readable).catch(async()=>{if(!(this.active!==a||a.closed))try{await this.deps.observe({type:"failed",broadcastGeneration:a.broadcastGeneration,grantGeneration:a.grantGeneration,retryable:!1,code:"relay-object-rejected"});}catch{}});}));return}this.retire(),await this.deps.observe({type:"closed",broadcastGeneration:e.broadcastGeneration,grantGeneration:e.grantGeneration,code:e.reason});}}async open(e){this.retire();try{let t=this.deps.openSession?await this.deps.openSession(e.relay.relayUrl,e.relay.token):await A(e.relay.relayUrl,e.relay.token),r={broadcastGeneration:e.broadcastGeneration,grantGeneration:e.grantGeneration,role:e.role,namespace:e.relay.namespace,session:t,duplexes:new Map,writers:new Map,closed:!1};if(this.active=r,t.onClose(()=>{this.active!==r||r.closed||this.deps.observe({type:"failed",broadcastGeneration:r.broadcastGeneration,grantGeneration:r.grantGeneration,retryable:!0,code:"relay-session-closed"});}),await b(t.init(),1e4,"broadcast MoQ Draft 14 setup"),await b(t.waitForSetup(),5e3,"broadcast MoQ Draft 14 setup"),this.active!==r)return;await this.deps.observe({type:"opened",broadcastGeneration:r.broadcastGeneration,grantGeneration:r.grantGeneration});}catch{this.matches(e)&&(this.retire(),await this.deps.observe({type:"failed",broadcastGeneration:e.broadcastGeneration,grantGeneration:e.grantGeneration,retryable:true,code:"relay-open-failed"}));}}async duplex(e,t){let r=this.active;if(!r)throw new Error("broadcast session is unavailable");let a=`${t?"pub":"sub"}:${e}`,o=r.duplexes.get(a);if(o)return o;let n=`${r.namespace}/source/${e}`,l=`${r.namespace}/control/${r.grantGeneration}/${e}`,c=await b(r.session.openObjectStreamDuplex(t?n:l,t?l:n,"openrtc-broadcast-1"),12e3,"broadcast MoQ Draft 14 object stream");if(this.active!==r)throw c.close(),new Error("broadcast generation retired during setup");return r.duplexes.set(a,c),c}async readObjects(e,t,r){let a=r.getReader();try{for(;this.active===e;){let o=await a.read();if(o.done)break;await this.deps.onObject({broadcastGeneration:e.broadcastGeneration,grantGeneration:e.grantGeneration,sourceSlot:t,object:o.value})&&await this.deps.observe({type:"usage",broadcastGeneration:e.broadcastGeneration,grantGeneration:e.grantGeneration,deliveredBytes:o.value.byteLength});}}finally{a.releaseLock();}}isCurrent(e){return this.matches(e)&&this.active?.closed===false}matches(e){return this.active?.broadcastGeneration===e.broadcastGeneration&&this.active.grantGeneration===e.grantGeneration}retire(){let e=this.active;if(this.active=null,!!e){e.closed=true;for(let t of e.writers.values())try{t.releaseLock();}catch{}for(let t of e.duplexes.values())try{t.close();}catch{}e.session.close();}}};async function A(m,e){let t=new URL(m);if(t.protocol!=="https:"||t.search||t.hash||!/^[A-Za-z0-9._-]{16,16384}$/.test(e))throw new Error("broadcast relay access is invalid");let r=new URL(t.toString());r.pathname=`${r.pathname.replace(/\/+$/,"")}/${encodeURIComponent(e)}`;let a=new WebTransport(r.toString());return await b(a.ready,15e3,"broadcast relay connection"),new a$2(a,t)}var g=class{constructor(e,t,r,a,o){this.wasm=e;this.handleId=t;this.drain=o;this.incoming=null;this.incomingWriters=new Map;this.sources=new Map;this.closed=false;let n=a[0]??"",l={beginOpenRtcMediaPublication:async s=>{let d=this.wasm.__beginOpenRtcBroadcastPublication(this.handleId,n,s.publicationId||void 0,s.kind,s.codec,s.clockRate,s.codedWidth,s.codedHeight,s.channels);return await this.drain(),{...d,control:new Uint8Array(d.control??[])}},encodeOpenRtcMediaSample:async s=>(this.wasm.__publishOpenRtcBroadcastSample(this.handleId,s.publicationId,s.timestampUs,s.durationUs,s.keyframe,s.discardable,s.payload),await this.drain(),new Uint8Array),pauseOpenRtcMediaPublication:async s=>{this.wasm.__pauseOpenRtcBroadcastPublication(this.handleId,s);},retireOpenRtcMediaPublication:async s=>{this.wasm.__retireOpenRtcBroadcastPublication(this.handleId,s);},retireOpenRtcMediaReceiver:async(s,d)=>{this.wasm.__retireOpenRtcMediaReceiver(s,d);},decodeOpenRtcMediaControl:async s=>this.wasm.__decodeOpenRtcMediaControl(s),decodeOpenRtcMediaChunk:async s=>{let d=this.wasm.__decodeOpenRtcMediaChunk(s);return {...d,payload:new Uint8Array(d.payload)}}},c={createBidirectionalStream:async()=>({protocol:"openrtc-media/1",readable:new ReadableStream({start(s){s.close();}}),writable:new WritableStream})};if(this.media=new b$1(c,l,(s,d)=>(this.incoming=d,()=>{this.incoming=null;})),["owner","publisher","processor"].includes(r)&&!n)throw new Error("[OpenRTC] Broadcast publisher grant has no source slot.")}addTrack(e,t){return this.media.addTrack(e,t)}removeTrack(e){return this.media.removeTrack(e)}onTrack(e){return this.media.onTrack(t=>e({...t,source:{id:this.sources.get(t.receiver.id)??"unknown"}}))}senders(){return this.media.senders()}receivers(){return this.media.receivers()}async accept(e,t){if(this.closed)return  false;let r=this.wasm.__acceptOpenRtcBroadcastObject(this.handleId,e,t);if(!r)return  false;let a=r.publicationId;if(this.sources.set(a,r.sourceSlot),r.control){let n=this.incomingWriters.get(a);if(r.controlType==="stop")return n?.generation===r.mediaGeneration&&(this.incomingWriters.delete(a),await n.writer.close().catch(()=>{})),this.sources.delete(a),true;if(r.controlType!=="publish"||n&&n.generation>=r.mediaGeneration)return  true;n&&await n.writer.close().catch(()=>{});let l=new TransformStream,c=l.writable.getWriter();return this.incomingWriters.set(a,{generation:r.mediaGeneration,writer:c}),this.incoming?.({peerId:r.sourceSlot,protocol:"openrtc-media/1",readable:l.readable,writable:new WritableStream}),await c.write(a$1(new Uint8Array(r.control))),true}if(!r.media)return  true;let o=this.incomingWriters.get(a);return !o||o.generation!==r.mediaGeneration||await o.writer.write(a$1(new Uint8Array(r.media))),true}async close(){this.closed||(this.closed=true,await Promise.all([...this.incomingWriters.values()].map(({writer:e})=>e.close().catch(()=>{}))),this.incomingWriters.clear(),this.sources.clear(),await this.media.close());}};var M=class{constructor(e){this.deps=e;this.wasmPromise=null;this.sessions=new Set;this.publishers=new Set;}async open(e){return this.openResolved(e)}async create(e){let t=e.auth??this.deps.defaultAuth;if(!t||!this.deps.manage||!this.deps.deviceId)throw new Error("Managed broadcast creation requires authenticated control-plane access.");let r=await this.deps.manage({action:"create",deviceId:await this.deps.deviceId(),auth:t,create:e});if(!r)throw new Error("Managed broadcast creation returned no grant.");return r}async renew(e,t){let r=await this.manageGrant("renew",e,t);if(!r)throw new Error("Managed broadcast renewal returned no grant.");return r}async invite(e,t,r){let a=await this.manage("invite",r,{grant:e,invitation:t});if(!a)throw new Error("Managed broadcast invitation returned no token.");return a}async accept(e,t){let r=await this.manage("accept",t,{invite:e});if(!r)throw new Error("Managed broadcast invitation acceptance returned no grant.");return r}async revoke(e,t,r){await this.manage("revoke",r,{grant:e,invite:t});}async leave(e,t){await this.manageGrant("leave",e,t);}async closeGrant(e,t){await this.manageGrant("close",e,t);}async preparePublisher(){let e=await this.wasm(),t=a.create(e);this.publishers.add(t);let r=false;return {verificationKey:t.verificationKey.slice(),open:a=>{if(r)throw new Error("broadcast publisher signer is closed");return this.openResolved(a,t)},close:async()=>{r||(r=true,t.close(),this.publishers.delete(t));}}}async close(){await Promise.all([...this.sessions].map(e=>e.close()));for(let e of this.publishers)e.close();this.publishers.clear();}wasm(){return this.wasmPromise??(this.wasmPromise=this.deps.loadWasm())}async manageGrant(e,t,r){return this.manage(e,r,{grant:t})}async manage(e,t,r){let a=t??this.deps.defaultAuth;if(!a||!this.deps.manage||!this.deps.deviceId)throw new Error(`Managed broadcast ${e} requires authenticated control-plane access.`);return this.deps.manage({action:e,deviceId:await this.deps.deviceId(),auth:a,...r})}async openResolved(e,t){let[r,a]=await Promise.all([this.wasm(),this.deps.resolve(e,t?.verificationKey)]),o=Date.now(),n;if(t)n=await t.open(a,o);else {let i=r.__prepareOpenRtcBroadcastGrant(a.token,a.issuerPublicKey,o),v=await a.signBindingChallenge(i.signingBytes);n=r.__openOpenRtcBroadcast(a.token,a.issuerPublicKey,i.handle,v,void 0,o);}let l={...a.relay},c=n.state,s=false,d=false,h=false,u=null,f=new y({openSession:this.deps.openSession,observe:async i=>{if(!s){i.type==="opened"&&(c="live"),i.type==="failed"&&(c="retrying"),i.type==="closed"&&(c="closed");try{r.__observeOpenRtcBroadcastAdapter(n.handleId,i);}finally{await w();}}},onObject:async i=>s||!u?false:u.accept(i.sourceSlot,i.object)}),w=async()=>{if(!s){if(d){h=true;return}d=true;try{do{h=!1;let i=r.__takeOpenRtcBroadcastActions(n.handleId,32);for(let v of i)await f.apply(this.adapterAction(v,l));i.length===32&&(h=!0);}while(h)}finally{d=false;}}};u=new g(r,n.handleId,n.role,n.sourceSlots??[],w);let b={id:n.id,role:n.role,get state(){return c},media:u,getStats:async()=>({...r.__getOpenRtcBroadcastStats(n.handleId)}),close:async()=>{s||(s=true,f.dispose(),await u?.close(),r.__closeOpenRtcBroadcast(n.handleId),this.sessions.delete(b));}};this.sessions.add(b);try{return await w(),b}catch(i){throw await b.close(),i}}adapterAction(e,t){let r={broadcastGeneration:e.broadcastGeneration,grantGeneration:e.grantGeneration};if(e.type==="open"&&e.role)return {type:"open",role:e.role,relay:t,...r};if(e.type==="publish"&&e.sourceSlot&&e.object)return {type:"publish",sourceSlot:e.sourceSlot,object:e.object,discardable:e.discardable===true,control:e.control===true,...r};if(e.type==="subscribe"&&e.sourceSlots)return {type:"subscribe",sourceSlots:e.sourceSlots,...r};if(e.type==="close"&&e.reason)return {type:"close",reason:e.reason,...r};throw new Error("Rust returned an invalid broadcast adapter action")}};export{M as BrowserManagedBroadcastHost};

package/dist/{Connection-DZ5eP5hL.d.ts → Connection-CTpuImO-.d.ts}

@@ -17,7 +17,7 @@ type AuthContext = {
 /**
  * App-facing options intentionally hide transport node identifiers from callbacks.
  */
-type RuntimeClientOptions = Omit<ClientOptions, 'onDevices' | 'onAutoConnect' | 'onIncomingSession' | 'coordinationAvenueOverride' | 'coordinationRoomGossipFanout' | 'coordinationPlatformType'> & {
+type RuntimeClientOptions = Omit<ClientOptions, 'onDevices' | 'onAutoConnect' | 'onIncomingSession' | 'coordinationAvenueOverride' | 'coordinationRoomGossipFanout' | 'coordinationRoomArchitecture' | 'coordinationDevicePublicKeyX' | 'coordinationDeviceSign' | 'coordinationPlatformType'> & {
     onDevices?: (devices: RuntimeDevice[]) => void;
     onAutoConnect?: (devices: RuntimeDevice[]) => void;
     onIncomingSession?: (session: RuntimeSession) => Promise<void>;
@@ -294,6 +294,79 @@ interface ManagedSession {
     stop: () => Promise<void>;
 }
 
+/**
+ * Provider-neutral hot coordination contract.
+ *
+ * Implementations deliver authenticated roster, presence, and signaling facts.
+ * They do not decide peer identity, admission, transport dialing, retries,
+ * replacement, or settlement; those remain Rust/OpenRTC lifecycle concerns.
+ */
+interface CoordinationSignalingStore {
+    updatePresence(localNodeId: string, ticket: string, online: boolean, ttlMs: number, metadata?: string, deviceNameOverride?: string): Promise<void>;
+    setOffline(localNodeId: string): Promise<void>;
+    updateDevice(deviceId: string, updates: {
+        deviceName?: string;
+        capabilities?: Device['capabilities'];
+        metadata?: string;
+        excludedPeers?: string[];
+    }): Promise<void>;
+    /**
+     * Publish the complete session-scoped peer-exclusion set for this runtime.
+     *
+     * The coordination provider owns delivery and persistence. Rust/WASM owns
+     * the local desired-peer decision and consumes remote exclusion snapshots.
+     */
+    setExcludedPeers?(excludedPeers: string[]): Promise<void>;
+    deleteDevice(deviceId: string): Promise<void>;
+    cleanupStaleDevices(): Promise<void>;
+    searchDevices(excludeNodeId?: string): Promise<Device[]>;
+    listDevices(excludeNodeId?: string): Promise<Device[]>;
+    subscribeDevices(): Promise<ReadableStream<DeviceEvent[]>>;
+    onDevicesChange(callback: (devices: Device[]) => void, excludeNodeId?: string): () => void;
+    onRoomArchitectureChange?(callback: (snapshot: RoomArchitectureSnapshot) => void): () => void;
+    onRoomAuthorityAssignmentChange?(callback: (assignment: RoomAuthorityAssignment | null) => void): () => void;
+    publishAuthorityAssignment?(input: {
+        assignment: {
+            policyVersion: 'room-authority-assignment-v1';
+            serviceId: string;
+            generation: number;
+            revision: number;
+            subjectDeviceId: string;
+            shardId: string;
+            priorityDeviceIds: string[];
+            relevantEntityIds: string[];
+            issuedAtMs: number;
+            expiresAtMs: number;
+        };
+        signature: string;
+    }): Promise<void>;
+    publishManagedRoomMessage?(input: {
+        messageId: string;
+        channel: string;
+        priority: 0 | 1 | 2 | 3;
+        zoneId?: string;
+        payload: Uint8Array;
+    }): Promise<void>;
+    onManagedRoomMessage?(callback: (message: ManagedRoomMessage) => void): () => void;
+    createSession(session: SignalingSession): Promise<void>;
+    updateSession(sessionId: string, updateData: Record<string, unknown>): Promise<void>;
+    subscribeSessions(localDeviceId: string): Promise<ReadableStream<SessionEvent[]>>;
+    sendMessage(targetId: string, payload: string, state?: string, replyPayload?: string): Promise<string>;
+    pollMessages(targetId: string): Promise<SignalingEnvelope[]>;
+    watchFriendDevices(friendUserIds: string[], callback: (devices: Map<string, Device[]>) => void): () => void;
+    updateFriendTicket(friendTicket: string | null): Promise<void>;
+    handleScopeChange(): Promise<void>;
+    setHostAvailability?(input: {
+        available: boolean;
+        reason: string;
+    }): void;
+    stopAuthActivity(): void;
+    usesCoordinationGateway?(): boolean;
+    joinCoordinationRoom?(roomId: string, nodeId: string, ticket: string): Promise<void>;
+    leaveCoordinationRoom?(roomId: string): Promise<void>;
+    getCoordinationRoomMembers?(roomId: string): Promise<RoomMember[]>;
+    watchCoordinationRoomMembers?(roomId: string, callback: (members: RoomMember[]) => void): () => void;
+}
 interface CoordinationGatewayOptions {
     /**
      * Provider-neutral coordination gateway endpoint.
@@ -644,6 +717,8 @@ interface Device {
     connectable?: boolean;
     kind?: EndpointKind | string;
     nodeId?: string;
+    /** Gateway-verified public half of the non-exportable device signing key. */
+    devicePublicKeyJwk?: JsonWebKey;
     platformType?: string;
     capabilities?: {
         canHost?: boolean;
@@ -665,6 +740,8 @@ interface Device {
     transports?: ProtocolName[];
 }
 interface PeerState {
+    /** Rust's current-record terminal verdict; absent on older runtimes. */
+    logicalSessionTerminal?: boolean;
     peerId: string;
     deviceId?: string;
     deviceIdHint?: string;
@@ -709,6 +786,7 @@ interface PeerState {
     errorPlane?: string;
 }
 interface BackendConnectionState {
+    logicalSessionTerminal?: boolean;
     connectionId: string;
     deviceId?: string | null;
     deviceIdHint?: string | null;
@@ -977,6 +1055,7 @@ interface ResolvedPeerIdentity {
     nodeId?: string | null;
 }
 interface PeerSessionSnapshot {
+    logicalSessionTerminal?: boolean;
     peerId: string;
     deviceId?: string | null;
     deviceIdHint?: string | null;
@@ -1082,6 +1161,53 @@ interface DesiredPeerProjection {
     online?: boolean;
     sessionId?: string | null;
     excludedPeers?: string[];
+    devicePublicKeyJwk?: JsonWebKey;
+    topologyRole?: 'active' | 'backup';
+    topologyRevision?: number;
+}
+/**
+ * Room-wide routing intent. Physical Iroh carrier selection remains private.
+ * `managed` is reserved but unavailable in 2.5; selecting it fails explicitly.
+ */
+type RoomArchitectureMode = 'auto' | 'mesh' | 'sparse' | 'managed' | 'authority';
+type EffectiveRoomArchitecture = Exclude<RoomArchitectureMode, 'auto'>;
+type RoomArchitectureReason = 'size' | 'traffic' | 'latency' | 'cost' | 'capacity' | 'manual' | 'recovery';
+/**
+ * Customer-safe room policy projection delivered by the authenticated gateway.
+ * Provider rates, margins, reserves, and invoice allocation stay server-side.
+ */
+interface RoomArchitectureSnapshot {
+    requested: RoomArchitectureMode;
+    effective: EffectiveRoomArchitecture;
+    epoch: number;
+    phase: 'settled' | 'preparing';
+    reason: RoomArchitectureReason;
+    heldCreditsUsd: number;
+    quoteExpiresAtMs: number;
+}
+/**
+ * Read-only application-interest projection signed by the room's registered
+ * authority and admitted by the gateway. It suggests what the application
+ * should render or simulate; it never grants transport or room permissions.
+ */
+interface RoomAuthorityAssignment {
+    serviceId: string;
+    generation: number;
+    revision: number;
+    shardId: string;
+    priorityDeviceIds: readonly string[];
+    relevantEntityIds: readonly string[];
+    issuedAtMs: number;
+    expiresAtMs: number;
+}
+/** Internal decrypted delivery from the Rust-owned managed-room group. */
+interface ManagedRoomMessage {
+    senderId: string;
+    messageId: string;
+    channel: string;
+    priority: 0 | 1 | 2 | 3;
+    zoneId?: string;
+    payload: Uint8Array;
 }
 /** Browser-only Rust/WASM module supplied by the browser signaling adapter. */
 interface BrowserWasmRuntimeModule {
@@ -1124,6 +1250,31 @@ interface ISignalingBackend {
     }): Promise<void>;
     deleteDevice(deviceId: string): Promise<void>;
     onDevicesChange(callback: (devices: Device[]) => void, excludeNodeId?: string): () => void;
+    onRoomArchitectureChange?(callback: (snapshot: RoomArchitectureSnapshot) => void): () => void;
+    onRoomAuthorityAssignmentChange?(callback: (assignment: RoomAuthorityAssignment | null) => void): () => void;
+    publishAuthorityAssignment?(input: {
+        assignment: {
+            policyVersion: 'room-authority-assignment-v1';
+            serviceId: string;
+            generation: number;
+            revision: number;
+            subjectDeviceId: string;
+            shardId: string;
+            priorityDeviceIds: string[];
+            relevantEntityIds: string[];
+            issuedAtMs: number;
+            expiresAtMs: number;
+        };
+        signature: string;
+    }): Promise<void>;
+    publishManagedRoomMessage?(input: {
+        messageId: string;
+        channel: string;
+        priority: 0 | 1 | 2 | 3;
+        zoneId?: string;
+        payload: Uint8Array;
+    }): Promise<void>;
+    onManagedRoomMessage?(callback: (message: ManagedRoomMessage) => void): () => void;
     onAuthChange(callback: (user: RuntimeIdentity | null) => void): () => void;
     checkForSSOToken(): Promise<void>;
     waitForAuth(): Promise<void>;
@@ -1135,7 +1286,7 @@ interface ISignalingBackend {
     submitDesiredPeerProjection?(revision: number, peers: DesiredPeerProjection[]): Promise<void>;
     notifyDisconnectRequested?(remoteNodeId: string): void;
     startPresence?(userId: string, localNodeId: string, deviceName: string, ticket: string, metadata?: string): Promise<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>;
     createSession(session: SignalingSession): Promise<void>;
     updateSession(sessionId: string, updateData: any): Promise<void>;
     subscribeSessions(localDeviceId: string): Promise<ReadableStream<SessionEvent[]>>;
@@ -1188,6 +1339,19 @@ interface ISignalingBackend {
     onStateChange?(callback: (state: BackendConnectionState) => void): Promise<() => void> | (() => void);
     /** Native-only protected logical message surface; browser uses its WASM connection. */
     sendPeerMessage?(id: string, payload: Uint8Array): Promise<void>;
+    encodeSparseFanoutMessage?(capability: string, payload: Uint8Array): Promise<Uint8Array>;
+    acceptSparseFanoutMessage?(capability: string, sourcePeerId: string, payload: Uint8Array): Promise<{
+        payload: Uint8Array;
+        authorDeviceId: string;
+        authorPeerId: string;
+        topologyRevision: number;
+        hop: number;
+        forwardPeerIds: string[];
+        forwardPeerLimit: number;
+        forwardQueueCapacity: number;
+        forward?: Uint8Array;
+    }>;
+    recordSparseFanoutForwardQueueDrop?(capability: string, count: number): Promise<void>;
     /** Native-only generation-fenced logical message projection. */
     onPeerMessage?(callback: (event: NativePeerDataEvent) => void): Promise<() => void> | (() => void);
     /** @deprecated Implement file protocols over named channels, or use `openrtc-file-transfer`. */
@@ -1383,7 +1547,7 @@ declare class Connection {
         transportState?: string | null;
         transportGeneration?: number | null;
         transportStableId?: number | null;
-    }): void;
+    }): boolean;
     getTransportDiagnostics(): Promise<any>;
     send(message: Message, options?: ApplicationPayloadSendOptions): Promise<void>;
     lastPayloadTransport(): ProtocolName | null;
@@ -1433,4 +1597,4 @@ declare class Connection {
     private close;
 }
 
-export { type NativeManagedSessionStartResult as $, type AuthContext as A, type AuthMode as B, type ChannelDescriptor$1 as C, type DeviceStatus as D, type SignalingMode as E, type ClientOptions as F, type GrantScope as G, type ExplicitFileDataSendParams as H, type IncomingStream as I, type JoinRoomOptions$1 as J, type ISignalingBackend as K, type LocalDeviceInfo$1 as L, type ManagedOptions as M, type RuntimeIdentity as N, type RoomMember as O, type PlutoIrohConfiguration as P, type Device as Q, type RouteOptimization as R, type ScopedChannelOptions as S, type DeviceStatusSnapshot as T, type ManagedConnectionRecord as U, type SignalingEnvelope as V, type DeviceEvent as W, type DesiredPeerProjection as X, type SignalingSession as Y, type SessionEvent as Z, type LocalDeviceInfo as _, type PlutoRTCConfiguration as a, type BackendPeerBiStream as a0, type BackendPeerUniStream as a1, type PortableMediaPublish as a2, type PortableMediaPublicationStart as a3, type PortableMediaSample as a4, type PortableMediaChunk as a5, type PortableMediaControl as a6, type NativeConnectParams as a7, type NativeConnectResult as a8, type BackendConnectionState as a9, type ScanningLoopHandle as aA, type RuntimeBootstrapOptions as aB, type RuntimeBootstrapResult as aC, type ApplicationPayloadReadinessOptions as aD, type ManagedApplicationRouteOptions as aE, type PeerState as aF, type PeerScope as aG, type PeerHealth as aH, type ChannelDescriptor as aI, type JoinRequest as aJ, type AutoConnectPolicy as aK, type ChannelFraming as aL, type ConnectionStatus as aM, type DevicePresence as aN, type PayloadRouteOptions as aO, type PeerLifecycleStatus$1 as aP, type PeerSessionSnapshot$1 as aQ, type PresencePolicy as aR, type RuntimeAuthContext as aS, type RuntimePeerScope as aT, type SessionKind as aU, type SessionPlatform as aV, type NativePeerDataEvent as aa, type CoordinationGatewayGrantRequest as ab, type CoordinationGatewayGrant as ac, type BrowserWasmRuntimeModule as ad, type BrowserProtocolStore as ae, type NamespaceDescriptor as af, type IrohMutationReceipt as ag, type IrohDocEntry as ah, type CoreClientBridgeHost as ai, type RouteDescriptor as aj, type PayloadCrypto as ak, type CryptoStreams as al, type CryptoBiStream as am, type RouteFamily as an, type RouteKind as ao, type RuntimeAuthIdentity as ap, type RuntimeSession as aq, type AppLimits as ar, type ConnectionTarget as as, type PresenceLoopOptions as at, type SignalingOptions as au, type JoinRoomOptions as av, type ChannelMetadata as aw, type RoomCreationMode as ax, type ProtocolCapabilityMap as ay, type ScanningLoopOptions as az, type PlutoMoQConfiguration as b, type ProtocolName as c, type RuntimePeerState as d, type PeerConnectOptions as e, Connection as f, type PeerSessionSnapshot as g, type PeerReadiness as h, type RuntimePeerHealth as i, type ResolvedPeerIdentity as j, type PeerStreamOptions as k, type RuntimeDevice as l, type ScopedLogicalChannel as m, type ConnectionState as n, type ReadinessOptions as o, type ConnectionEvent as p, type ManagedSession as q, type DeviceConnectOptions as r, type ConnectDeviceResult as s, type ConnectDeviceHooks as t, type ConnectDeviceOptions as u, type DeviceProfile as v, type RawConnection as w, type RuntimeRoomMember as x, type RuntimeClientOptions as y, type DiscoveryMode as z };
+export { type DeviceEvent as $, type RawConnection as A, type RuntimeRoomMember as B, type ChannelDescriptor$1 as C, type DeviceStatus as D, type EffectiveRoomArchitecture as E, type AuthContext as F, type GrantScope as G, type RuntimeClientOptions as H, type IncomingStream as I, type JoinRoomOptions$1 as J, type DiscoveryMode as K, type LocalDeviceInfo$1 as L, type ManagedOptions as M, type AuthMode as N, type SignalingMode as O, type PlutoIrohConfiguration as P, type ClientOptions as Q, type RoomArchitectureMode as R, type ScopedChannelOptions as S, type ExplicitFileDataSendParams as T, type ISignalingBackend as U, type RuntimeIdentity as V, type RoomMember as W, type Device as X, type DeviceStatusSnapshot as Y, type ManagedConnectionRecord as Z, type SignalingEnvelope as _, type RoomArchitectureReason as a, type SessionKind as a$, type DesiredPeerProjection as a0, type SignalingSession as a1, type SessionEvent as a2, type LocalDeviceInfo as a3, type NativeManagedSessionStartResult as a4, type BackendPeerBiStream as a5, type BackendPeerUniStream as a6, type PortableMediaPublish as a7, type PortableMediaPublicationStart as a8, type PortableMediaSample as a9, type PresenceLoopOptions as aA, type SignalingOptions as aB, type JoinRoomOptions as aC, type ChannelMetadata as aD, type RoomCreationMode as aE, type ProtocolCapabilityMap as aF, type ScanningLoopOptions as aG, type ScanningLoopHandle as aH, type RuntimeBootstrapOptions as aI, type RuntimeBootstrapResult as aJ, type ApplicationPayloadReadinessOptions as aK, type ManagedApplicationRouteOptions as aL, type PeerState as aM, type PeerScope as aN, type PeerHealth as aO, type ChannelDescriptor as aP, type JoinRequest as aQ, type AutoConnectPolicy as aR, type ChannelFraming as aS, type ConnectionStatus as aT, type DevicePresence as aU, type PayloadRouteOptions as aV, type PeerLifecycleStatus$1 as aW, type PeerSessionSnapshot$1 as aX, type PresencePolicy as aY, type RuntimeAuthContext as aZ, type RuntimePeerScope as a_, type PortableMediaChunk as aa, type PortableMediaControl as ab, type NativeConnectParams as ac, type NativeConnectResult as ad, type BackendConnectionState as ae, type NativePeerDataEvent as af, type CoordinationGatewayGrantRequest as ag, type CoordinationGatewayGrant as ah, type BrowserWasmRuntimeModule as ai, type BrowserProtocolStore as aj, type NamespaceDescriptor as ak, type IrohMutationReceipt as al, type IrohDocEntry as am, type CoordinationSignalingStore as an, type ManagedRoomMessage as ao, type CoreClientBridgeHost as ap, type RouteDescriptor as aq, type PayloadCrypto as ar, type CryptoStreams as as, type CryptoBiStream as at, type RouteFamily as au, type RouteKind as av, type RuntimeAuthIdentity as aw, type RuntimeSession as ax, type AppLimits as ay, type ConnectionTarget as az, type RoomArchitectureSnapshot as b, type SessionPlatform as b0, type RoomAuthorityAssignment as c, type PlutoRTCConfiguration as d, type PlutoMoQConfiguration as e, type RouteOptimization as f, type ProtocolName as g, type RuntimePeerState as h, type PeerConnectOptions as i, Connection as j, type PeerSessionSnapshot as k, type PeerReadiness as l, type RuntimePeerHealth as m, type ResolvedPeerIdentity as n, type PeerStreamOptions as o, type RuntimeDevice as p, type ScopedLogicalChannel as q, type ConnectionState as r, type ReadinessOptions as s, type ConnectionEvent as t, type ManagedSession as u, type DeviceConnectOptions as v, type ConnectDeviceResult as w, type ConnectDeviceHooks as x, type ConnectDeviceOptions as y, type DeviceProfile as z };

package/dist/{DelegatingRuntimeAdapter-4cgiIWMN.d.ts → DelegatingRuntimeAdapter-D67Ozqo3.d.ts}

@@ -1,5 +1,5 @@
-import { z as DiscoveryMode, B as AuthMode, E as SignalingMode, F as ClientOptions, H as ExplicitFileDataSendParams, K as ISignalingBackend, N as RuntimeIdentity, A as AuthContext, O as RoomMember, Q as Device, T as DeviceStatusSnapshot, g as PeerSessionSnapshot, j as ResolvedPeerIdentity, U as ManagedConnectionRecord, V as SignalingEnvelope, W as DeviceEvent, X as DesiredPeerProjection, Y as SignalingSession, Z as SessionEvent, _ as LocalDeviceInfo, $ as NativeManagedSessionStartResult, c as ProtocolName, G as GrantScope, a0 as BackendPeerBiStream, a1 as BackendPeerUniStream, a2 as PortableMediaPublish, a3 as PortableMediaPublicationStart, a4 as PortableMediaSample, a5 as PortableMediaChunk, a6 as PortableMediaControl, a7 as NativeConnectParams, a8 as NativeConnectResult, a9 as BackendConnectionState, aa as NativePeerDataEvent } from './Connection-DZ5eP5hL.js';
-import { R as RuntimeCapabilities } from './capabilities-B2mHv_H7.js';
+import { K as DiscoveryMode, N as AuthMode, O as SignalingMode, Q as ClientOptions, T as ExplicitFileDataSendParams, U as ISignalingBackend, V as RuntimeIdentity, F as AuthContext, W as RoomMember, X as Device, Y as DeviceStatusSnapshot, k as PeerSessionSnapshot, n as ResolvedPeerIdentity, Z as ManagedConnectionRecord, _ as SignalingEnvelope, $ as DeviceEvent, a0 as DesiredPeerProjection, a1 as SignalingSession, a2 as SessionEvent, a3 as LocalDeviceInfo, a4 as NativeManagedSessionStartResult, g as ProtocolName, G as GrantScope, a5 as BackendPeerBiStream, a6 as BackendPeerUniStream, a7 as PortableMediaPublish, a8 as PortableMediaPublicationStart, a9 as PortableMediaSample, aa as PortableMediaChunk, ab as PortableMediaControl, ac as NativeConnectParams, ad as NativeConnectResult, ae as BackendConnectionState, af as NativePeerDataEvent } from './Connection-CTpuImO-.js';
+import { R as RuntimeCapabilities } from './capabilities-CmzzxSvW.js';
 
 /** Host-neutral configuration shared by browser/WASM and native/IPC adapters. */
 interface RuntimeBridgeOptions {
@@ -13,6 +13,10 @@ interface RuntimeBridgeOptions {
     coordinationGateway?: ClientOptions['coordinationGateway'];
     coordinationAvenueOverride?: ClientOptions['coordinationAvenueOverride'];
     coordinationRoomGossipFanout?: ClientOptions['coordinationRoomGossipFanout'];
+    coordinationRoomArchitecture?: ClientOptions['coordinationRoomArchitecture'];
+    coordinationDevicePublicKeyX?: ClientOptions['coordinationDevicePublicKeyX'];
+    coordinationDeviceSign?: ClientOptions['coordinationDeviceSign'];
+    initialAutoConnectExcludedDeviceIds?: ClientOptions['initialAutoConnectExcludedDeviceIds'];
     attestationTokenProvider?: ClientOptions['attestationTokenProvider'];
     /** Internal host hint used by the provider-neutral gateway projection. */
     coordinationPlatformType?: string;
@@ -73,7 +77,7 @@ declare abstract class DelegatingRuntimeAdapter implements ISignalingBackend {
     subscribeDevices(userId: string): Promise<ReadableStream<DeviceEvent[]>>;
     startAutoConnect(userId: string, localDeviceId: string): void;
     submitDesiredPeerProjection(revision: number, peers: DesiredPeerProjection[]): Promise<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>;
     createSession(session: SignalingSession): Promise<void>;
     updateSession(sessionId: string, updateData: any): Promise<void>;
     subscribeSessions(localDeviceId: string): Promise<ReadableStream<SessionEvent[]>>;

package/dist/{IpcRuntimeAdapter-Dduaxscj.d.ts → IpcRuntimeAdapter-Ddx0MtSI.d.ts}

@@ -1,6 +1,6 @@
-import { R as RuntimeBridgeOptions, D as DelegatingRuntimeAdapter } from './DelegatingRuntimeAdapter-4cgiIWMN.js';
+import { R as RuntimeBridgeOptions, D as DelegatingRuntimeAdapter } from './DelegatingRuntimeAdapter-D67Ozqo3.js';
 import { P as PlutoIpcBridge } from './ipc-DgzKqHH3.js';
-import { a9 as BackendConnectionState, aa as NativePeerDataEvent } from './Connection-DZ5eP5hL.js';
+import { ae as BackendConnectionState, af as NativePeerDataEvent } from './Connection-CTpuImO-.js';
 
 interface NativeIpcBridgeOptions extends RuntimeBridgeOptions {
     ipcBridge?: PlutoIpcBridge;
@@ -21,6 +21,12 @@ interface NativeIpcBridgeOptions extends RuntimeBridgeOptions {
 interface NativeProjectionHost {
     incoming_projected_streams(): Promise<ReadableStream<NativeRootProjectionEvent>>;
     isCurrentTransport(endpointId: string, transportStableId: bigint): Promise<boolean>;
+    /**
+     * Drop the process-owned Tauri projection Channel. Required because an
+     * errored ReadableStream does not run its cancel algorithm, so listen-loop
+     * or pump faults would otherwise leave Rust claiming the sole owner slot.
+     */
+    releaseNativeProjectionSubscription?(): Promise<void>;
 }
 interface NativeProjectedStreamSource {
     readonly __openrtcNativeCapabilityProjection: true;

package/dist/WasmBridge-ZXBCXBBM.js

@@ -0,0 +1 @@
+export{b as WasmBridge,a as loadBrowserWasmRuntimeModule}from'./chunk-EIJNERKZ.js';import'./chunk-AYHD4X2R.js';import'./chunk-GTHSRQ7Y.js';import'./chunk-XTYALGJN.js';import'./chunk-OT7IPLZE.js';import'./chunk-OWKAJPOI.js';import'./chunk-CCCYE3XN.js';import'./chunk-N6LGTNUI.js';import'./chunk-JPBW67B3.js';import'./chunk-2GX6GB6L.js';

package/dist/{assembly-By3UBQsE.d.ts → assembly-DvfsYFCL.d.ts}

@@ -1,5 +1,5 @@
-import { d as RuntimePeerState, n as ConnectionState, h as PeerReadiness, e as PeerConnectOptions, f as Connection, I as IncomingStream, G as GrantScope, y as RuntimeClientOptions, K as ISignalingBackend, ap as RuntimeAuthIdentity, A as AuthContext, c as ProtocolName, L as LocalDeviceInfo, v as DeviceProfile, ae as BrowserProtocolStore, af as NamespaceDescriptor, ag as IrohMutationReceipt, ah as IrohDocEntry, l as RuntimeDevice, M as ManagedOptions, q as ManagedSession, D as DeviceStatus, t as ConnectDeviceHooks, u as ConnectDeviceOptions, s as ConnectDeviceResult, r as DeviceConnectOptions, U as ManagedConnectionRecord, g as PeerSessionSnapshot, j as ResolvedPeerIdentity, aq as RuntimeSession, ar as AppLimits, J as JoinRoomOptions, x as RuntimeRoomMember, as as ConnectionTarget, S as ScopedChannelOptions, m as ScopedLogicalChannel, k as PeerStreamOptions, a7 as NativeConnectParams, a8 as NativeConnectResult, w as RawConnection, C as ChannelDescriptor, H as ExplicitFileDataSendParams, at as PresenceLoopOptions, i as RuntimePeerHealth, o as ReadinessOptions, p as ConnectionEvent } from './Connection-DZ5eP5hL.js';
-import { R as RuntimeCapabilities, C as CapabilityProfile } from './capabilities-B2mHv_H7.js';
+import { h as RuntimePeerState, r as ConnectionState, l as PeerReadiness, i as PeerConnectOptions, j as Connection, I as IncomingStream, G as GrantScope, H as RuntimeClientOptions, U as ISignalingBackend, aw as RuntimeAuthIdentity, F as AuthContext, g as ProtocolName, L as LocalDeviceInfo, z as DeviceProfile, aj as BrowserProtocolStore, ak as NamespaceDescriptor, al as IrohMutationReceipt, am as IrohDocEntry, p as RuntimeDevice, M as ManagedOptions, u as ManagedSession, D as DeviceStatus, x as ConnectDeviceHooks, y as ConnectDeviceOptions, w as ConnectDeviceResult, v as DeviceConnectOptions, Z as ManagedConnectionRecord, k as PeerSessionSnapshot, n as ResolvedPeerIdentity, ax as RuntimeSession, ay as AppLimits, J as JoinRoomOptions, B as RuntimeRoomMember, az as ConnectionTarget, S as ScopedChannelOptions, q as ScopedLogicalChannel, o as PeerStreamOptions, ac as NativeConnectParams, ad as NativeConnectResult, A as RawConnection, C as ChannelDescriptor, T as ExplicitFileDataSendParams, aA as PresenceLoopOptions, b as RoomArchitectureSnapshot, c as RoomAuthorityAssignment, m as RuntimePeerHealth, s as ReadinessOptions, t as ConnectionEvent } from './Connection-CTpuImO-.js';
+import { R as RuntimeCapabilities, C as CapabilityProfile } from './capabilities-CmzzxSvW.js';
 
 /**
  * Coalesced peer reconciliation scheduler and full reconcile orchestration.
@@ -618,7 +618,12 @@ declare class RuntimeClient {
     startAutoConnect(localDeviceId?: string): Promise<void>;
     isConnected(nodeId: string): Promise<boolean>;
     disconnectNode(nodeId: string): Promise<void>;
+    recordSparseFanoutForwardQueueDrop(capability: string, count: number): Promise<void>;
     disconnectDevice(deviceId: string): Promise<void>;
+    /** Observe the gateway-owned room policy without taking topology ownership. */
+    onRoomArchitectureChange(callback: (snapshot: RoomArchitectureSnapshot) => void): () => void;
+    /** Observe signed authority interest without taking routing ownership. */
+    onRoomAuthorityAssignmentChange(callback: (assignment: RoomAuthorityAssignment | null) => void): () => void;
     excludeAutoConnect(deviceId: string, excluded: boolean): Promise<void>;
     disconnectPeer(id: string, scope?: string): Promise<void>;
     forceDisconnectPeer(id: string): Promise<void>;

package/dist/{capabilities-B2mHv_H7.d.ts → capabilities-CmzzxSvW.d.ts}

@@ -1,8 +1,17 @@
-import { c as ProtocolName, R as RouteOptimization } from './Connection-DZ5eP5hL.js';
+import { g as ProtocolName, f as RouteOptimization } from './Connection-CTpuImO-.js';
 
 type RuntimeAdapterKind = 'browser-wasm' | 'native-ipc' | 'tauri-ipc' | 'unknown';
+type CapabilityMaturity = 'stable' | 'preview' | 'support-only' | 'unavailable';
+interface ProductCapabilityMaturity {
+    boundedRooms: CapabilityMaturity;
+    serviceNodes: CapabilityMaturity;
+    offlineEdge: CapabilityMaturity;
+    broadcast: CapabilityMaturity;
+}
 interface RuntimeCapabilities {
     adapter: RuntimeAdapterKind;
+    /** Product support facts reported by the runtime owner. */
+    productMaturity?: ProductCapabilityMaturity;
     signaling: {
         coordinationGateway: boolean;
         nativeIpc: boolean;
@@ -40,6 +49,7 @@ interface RuntimeCapabilities {
 }
 interface CapabilityProfile {
     environment: 'web' | 'native' | 'unknown';
+    productMaturity?: ProductCapabilityMaturity;
     transports: {
         quic: boolean;
         irohRelay: boolean;
@@ -63,6 +73,7 @@ interface NativeRuntimeStatus {
     ready?: boolean;
     nodeId?: string | null;
     node_id?: string | null;
+    productMaturity?: Partial<ProductCapabilityMaturity>;
     transport?: {
         irohQuic?: TransportStatus;
         irohLan?: TransportStatus;
@@ -98,4 +109,4 @@ declare function browserCapabilities(host?: CapabilityHost | null | undefined):
 declare function statusCapabilities(status: NativeRuntimeStatus | null | undefined, allowWasmFallback?: boolean): RuntimeCapabilities;
 declare function capabilityProfile(capabilities: RuntimeCapabilities): CapabilityProfile;
 
-export { BROWSER_CAPABILITIES as B, type CapabilityProfile as C, NATIVE_CAPABILITIES as N, type RuntimeCapabilities as R, type TransportStatus as T, type CapabilityHost as a, type NativeRuntimeStatus as b, type RuntimeAdapterKind as c, browserCapabilities as d, capabilityProfile as e, cloneCapabilities as f, statusCapabilities as s };
+export { BROWSER_CAPABILITIES as B, type CapabilityProfile as C, NATIVE_CAPABILITIES as N, type ProductCapabilityMaturity as P, type RuntimeCapabilities as R, type TransportStatus as T, type CapabilityHost as a, type CapabilityMaturity as b, type NativeRuntimeStatus as c, type RuntimeAdapterKind as d, browserCapabilities as e, capabilityProfile as f, cloneCapabilities as g, statusCapabilities as s };