openrtc 2.4.0 → 2.5.2

package/README.md

@@ -100,6 +100,95 @@ 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');
+```
+
+`maxPeers` counts everyone in the room, including the service. Node defaults to
+eight; set a value from 1 through 50 explicitly when needed. Your app's approved
+limit and available credits still apply, so a larger request can be denied.
+Browser and standalone Rust grant requests may omit the value to use app policy.
+These limits are not a promise of 50 simultaneous server connections or a
+replacement for the remaining authority acceptance tests.
+
+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.
+`connection.peerId` is the admitted remote endpoint ID, not an app account or
+durable device ID. Room access alone does not grant those identities. Keep
+`stateDirectory` across process restarts to retain the host's private keys.
+Await `service.close()` before reusing that directory; it waits for the host
+process to finish, not just acknowledge shutdown.
+JSON and string messages use the same room-scoped envelope as browser
+`Connection.send`; `onMessage` receives the application value, not the envelope.
+Messages explicitly addressed to another room are discarded. Node byte payloads
+(`Uint8Array`/`ArrayBuffer`) retain the lower-level native byte contract; use
+JSON values for portable browser/Node application messages.
+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. Its `RoomAuthority::compose_client(builder)` method binds the
+dedicated service-room client to the existing Rust peer-session owner before
+endpoint initialization. Native hosts publish a room-scoped compound ticket;
+attaching the signaling backend alone is not service startup.
+
+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 +255,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/NativeManagedBroadcastHost-WCQ6TPUU.js

@@ -0,0 +1 @@
+import {b as b$1,a}from'./chunk-LLZT3MR6.js';import'./chunk-JPBW67B3.js';var p=64,w=50;function l(n,e){if(n instanceof Uint8Array)return n.slice();if(n instanceof ArrayBuffer)return new Uint8Array(n.slice(0));if(Array.isArray(n)&&n.every(r=>Number.isInteger(r)&&r>=0&&r<=255))return Uint8Array.from(n);throw new Error(`[OpenRTC] ${e} returned invalid binary data.`)}var u=class{constructor(e,r,t,i,o){this.bridge=e;this.handleId=r;this.onFailure=o;this.incoming=null;this.incomingWriters=new Map;this.sources=new Map;this.timer=null;this.closed=false;let s=i[0]??"",c={beginOpenRtcMediaPublication:async a=>{let d=await this.bridge.invoke("begin_openrtc_broadcast_publication",{handleId:this.handleId,sourceSlot:s,publicationId:a.publicationId||null,kind:a.kind,codec:a.codec,clockRate:a.clockRate,codedWidth:a.codedWidth??null,codedHeight:a.codedHeight??null,channels:a.channels??null});return {...d,control:l(d.control??[],"broadcast publication")}},encodeOpenRtcMediaSample:async a=>{if(!this.bridge.invokeRaw)throw new Error("[OpenRTC] Native broadcast requires binary IPC.");return await this.bridge.invokeRaw("publish_openrtc_broadcast_sample",a.payload,{"x-openrtc-broadcast-handle-id":this.handleId,"x-openrtc-publication-id":a.publicationId,"x-openrtc-timestamp-us":String(a.timestampUs),"x-openrtc-duration-us":String(a.durationUs),"x-openrtc-keyframe":String(a.keyframe),"x-openrtc-discardable":String(a.discardable)}),new Uint8Array},pauseOpenRtcMediaPublication:async a=>{await this.bridge.invoke("pause_openrtc_broadcast_publication",{handleId:this.handleId,publicationId:a});},retireOpenRtcMediaPublication:async a=>{await this.bridge.invoke("retire_openrtc_broadcast_publication",{handleId:this.handleId,publicationId:a});},retireOpenRtcMediaReceiver:async(a,d)=>{await this.bridge.invoke("retire_openrtc_broadcast_receiver",{handleId:this.handleId,publicationId:a,mediaGeneration:d});},decodeOpenRtcMediaControl:a=>this.decodeControl(a),decodeOpenRtcMediaChunk:a=>this.decodeChunk(a)},v={createBidirectionalStream:async()=>({protocol:"openrtc-media/1",readable:new ReadableStream({start(a){a.close();}}),writable:new WritableStream})};if(this.media=new b$1(v,c,(a,d)=>(this.incoming=d,()=>{this.incoming=null;})),["owner","publisher","processor"].includes(t)&&!s)throw new Error("[OpenRTC] Broadcast publisher grant has no source slot.");this.scheduleReceive(0);}addTrack(e,r){return this.media.addTrack(e,r)}removeTrack(e){return this.media.removeTrack(e)}onTrack(e){return this.media.onTrack(r=>e({...r,source:{id:this.sources.get(r.receiver.id)??"unknown"}}))}senders(){return this.media.senders()}receivers(){return this.media.receivers()}async close(){this.closed||(this.closed=true,this.timer&&clearTimeout(this.timer),this.timer=null,await Promise.all([...this.incomingWriters.values()].map(({writer:e})=>e.close().catch(()=>{}))),this.incomingWriters.clear(),this.sources.clear(),await this.media.close());}scheduleReceive(e){this.closed||(this.timer=setTimeout(()=>{this.receive();},e));}async receive(){if(!this.closed)try{let e=await this.bridge.invoke("receive_openrtc_broadcast_media",{handleId:this.handleId,max:p});for(let r of e)await this.accept(r);this.scheduleReceive(e.length===p?0:w);}catch(e){this.closed||this.onFailure(e);}}async accept(e){let r=e.publicationId;if(this.sources.set(r,e.sourceSlot),e.control){let i=this.incomingWriters.get(r);if(e.controlType==="stop"){i?.generation===e.mediaGeneration&&(this.incomingWriters.delete(r),await i.writer.close().catch(()=>{})),this.sources.delete(r);return}if(e.controlType!=="publish"||i&&i.generation>=e.mediaGeneration)return;i&&await i.writer.close().catch(()=>{});let o=new TransformStream,s=o.writable.getWriter();this.incomingWriters.set(r,{generation:e.mediaGeneration,writer:s}),this.incoming?.({peerId:e.sourceSlot,protocol:"openrtc-media/1",readable:o.readable,writable:new WritableStream}),await s.write(a(l(e.control,"broadcast control")));return}if(!e.media)return;let t=this.incomingWriters.get(r);!t||t.generation!==e.mediaGeneration||await t.writer.write(a(l(e.media,"broadcast media")));}async decodeControl(e){if(!this.bridge.invokeRaw)throw new Error("[OpenRTC] Native broadcast requires binary IPC.");return this.bridge.invokeRaw("decode_openrtc_media_control",e,{})}async decodeChunk(e){if(!this.bridge.invokeRaw)throw new Error("[OpenRTC] Native broadcast requires binary IPC.");let r=l(await this.bridge.invokeRaw("decode_openrtc_media_chunk",e,{}),"decode_openrtc_media_chunk");if(r.byteLength<4)throw new Error("[OpenRTC] Native media metadata is truncated.");let i=4+new DataView(r.buffer,r.byteOffset,4).getUint32(0,false);if(i>r.byteLength)throw new Error("[OpenRTC] Native media metadata is invalid.");return {...JSON.parse(new TextDecoder().decode(r.subarray(4,i))),payload:r.slice(i)}}},b=class{constructor(e,r){this.bridge=e;this.context=r;this.sessions=new Set;this.publishers=new Set;}open(e){return this.openNative(e)}async create(e){let r=e.auth??this.context.defaultAuth;if(!r)throw new Error("Managed broadcast creation requires authenticated control-plane access.");let t=await this.context.manage({action:"create",deviceId:await this.context.deviceId(),auth:r,create:e});if(!t)throw new Error("Managed broadcast creation returned no grant.");return t}async preparePublisher(){let e=await this.bridge.invoke("prepare_openrtc_broadcast_publisher"),r=l(e.verificationKey,"broadcast publisher");if(!e.handle||r.byteLength!==32)throw e.handle&&await this.bridge.invoke("release_openrtc_broadcast_publisher",{handle:e.handle}).catch(()=>{}),new Error("[OpenRTC] Native broadcast publisher is invalid.");let t=false,i={verificationKey:r,open:o=>{if(t)throw new Error("[OpenRTC] Broadcast publisher is closed.");return this.openNative(o,e.handle)},close:async()=>{t||(t=true,this.publishers.delete(i),await this.bridge.invoke("release_openrtc_broadcast_publisher",{handle:e.handle}));}};return this.publishers.add(i),i}renew(e,r){return this.manage("renew",r,{grant:e})}invite(e,r,t){return this.manage("invite",t,{grant:e,invitation:r})}accept(e,r){return this.manage("accept",r,{invite:e})}async revoke(e,r,t){await this.manage("revoke",t,{grant:e,invite:r});}async leave(e,r){await this.manage("leave",r,{grant:e});}async closeGrant(e,r){await this.manage("close",r,{grant:e});}async close(){await Promise.all([...this.sessions].map(e=>e.close())),await Promise.all([...this.publishers].map(e=>e.close()));}async manage(e,r,t){let i=r??this.context.defaultAuth;if(!i)throw new Error(`Managed broadcast ${e} requires authenticated control-plane access.`);return this.context.manage({action:e,deviceId:await this.context.deviceId(),auth:i,...t})}async openNative(e,r){let t=await this.bridge.invoke("open_openrtc_broadcast",{grantToken:e,issuerPublicKey:null,publisherSignerHandle:r??null,nowMs:Date.now()}),i=t.state,o=false,s=new u(this.bridge,t.handleId,t.role,t.sourceSlots??[],()=>{i="failed";}),c={id:t.id,role:t.role,get state(){return i},media:s,getStats:()=>this.bridge.invoke("get_openrtc_broadcast_stats",{handleId:t.handleId}),close:async()=>{o||(o=true,i="closed",await s.close(),await this.bridge.invoke("close_openrtc_broadcast",{handleId:t.handleId}),this.sessions.delete(c));}};return this.sessions.add(c),c}};export{b as NativeManagedBroadcastHost};

package/dist/WasmBridge-LWMCETW4.js

@@ -0,0 +1 @@
+export{b as WasmBridge,a as loadBrowserWasmRuntimeModule}from'./chunk-PLIWPC45.js';import'./chunk-AYHD4X2R.js';import'./chunk-AAZPQQXX.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-LOFcpH3S.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.
@@ -313,6 +313,7 @@ declare class RuntimeClient {
     private resolveManagedSessionUserId;
     private resolveManagedAutoConnectEnabled;
     private resolveManagedPresenceEnabled;
+    private resolveManagedTicketScope;
     private getEffectiveRuntimeUserId;
     private fetchAndApplyAppLimits;
     private resolvePeerStreamTarget;
@@ -466,7 +467,7 @@ declare class RuntimeClient {
         preserveBackendSession?: boolean;
     }): Promise<void>;
     private stopManagedSessionInternal;
-    private rotateManagedUserDeviceGrant;
+    private rotateManagedGrant;
     listDevices(): Promise<RuntimeDevice[]>;
     listDeviceStatus(): Promise<DeviceStatus[]>;
     updateDevice(deviceId: string, updates: {
@@ -618,7 +619,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 };

package/dist/chunk-6Q2LAXM4.js

@@ -0,0 +1 @@
+import {t}from'./chunk-AAZPQQXX.js';var a=class{constructor(e){this.backend=e;}get currentUser(){return this.backend.currentUser}setAuthContext(e){return this.backend.setAuthContext?.(e)}async signInAnonymously(){return this.backend.signInAnonymously()}async signInWithPluto(){if(typeof this.backend.signInWithPluto!="function")throw new Error("Selected runtime adapter does not support Pluto SSO.");return this.backend.signInWithPluto()}async signOut(){return this.backend.signOut()}async stopAuthActivity(){typeof this.backend.stopAuthActivity=="function"&&await this.backend.stopAuthActivity();}usesCoordinationGateway(){return this.backend.usesCoordinationGateway?.()===true}async joinCoordinationRoom(e,t,n){if(!this.backend.joinCoordinationRoom)throw new Error("Selected runtime adapter does not support coordination rooms.");await this.backend.joinCoordinationRoom(e,t,n);}async leaveCoordinationRoom(e){if(!this.backend.leaveCoordinationRoom)throw new Error("Selected runtime adapter does not support coordination rooms.");await this.backend.leaveCoordinationRoom(e);}async getCoordinationRoomMembers(e){if(!this.backend.getCoordinationRoomMembers)throw new Error("Selected runtime adapter does not support coordination rooms.");return this.backend.getCoordinationRoomMembers(e)}watchCoordinationRoomMembers(e,t){if(!this.backend.watchCoordinationRoomMembers)throw new Error("Selected runtime adapter does not support coordination rooms.");return this.backend.watchCoordinationRoomMembers(e,t)}async getTurnCredentials(){return this.backend.getTurnCredentials()}async updatePresence(e,t,n,i,r){return this.backend.updatePresence(e,t,n,i,r)}async refreshLivePresence(e,t,n){if(typeof this.backend.refreshLivePresence!="function")throw new Error("Selected runtime adapter does not support refreshLivePresence().");return this.backend.refreshLivePresence(e,t,n)}async setOffline(e){return this.backend.setOffline(e)}async cleanupStaleDevices(){return this.backend.cleanupStaleDevices()}async searchDevices(e){return this.backend.searchDevices(e)}async listDeviceStatus(){if(typeof this.backend.listDeviceStatus!="function")throw new Error("Selected runtime adapter does not support listDeviceStatus().");return this.backend.listDeviceStatus()}async getPeerSession(e){return typeof this.backend.getPeerSession!="function"?null:this.backend.getPeerSession(e)}async listPeerSessions(){return typeof this.backend.listPeerSessions!="function"?[]:this.backend.listPeerSessions()}async waitForSettledPeer(e,t){return typeof this.backend.waitForSettledPeer!="function"?null:this.backend.waitForSettledPeer(e,t)}async resolvePeerIdentity(e){return typeof this.backend.resolvePeerIdentity!="function"?{peerId:null,deviceId:null,deviceIdHint:null,nodeId:null}:this.backend.resolvePeerIdentity(e)}async resolvePeerRecords(e){return typeof this.backend.resolvePeerRecords!="function"?[]:this.backend.resolvePeerRecords(e)}async updateDevice(e,t){return this.backend.updateDevice(e,t)}async deleteDevice(e){return this.backend.deleteDevice(e)}onDevicesChange(e,t){return this.backend.onDevicesChange(e,t)}onAuthChange(e){return this.backend.onAuthChange(e)}async checkForSSOToken(){return this.backend.checkForSSOToken()}async waitForAuth(){return this.backend.waitForAuth()}async sendMessage(e,t,n,i){return this.backend.sendMessage(e,t,n,i)}async pollMessages(e){return this.backend.pollMessages(e)}watchFriendDevices(e,t){let n=this.backend;return n.watchFriendDevices?n.watchFriendDevices(e,t):()=>{}}async updateFriendTicket(e){let t=this.backend;t.updateFriendTicket&&await t.updateFriendTicket(e);}async subscribeDevices(e){return this.backend.subscribeDevices(e)}startAutoConnect(e,t){this.backend.startAutoConnect(e,t);}async submitDesiredPeerProjection(e,t){if(typeof this.backend.submitDesiredPeerProjection!="function")throw new Error("Selected runtime adapter does not support desired-peer projections.");await this.backend.submitDesiredPeerProjection(e,t);}async startPresenceLoop(e,t,n,i,r){await this.backend.startPresenceLoop(e,t,n,i,r);}async createSession(e){return this.backend.createSession(e)}async updateSession(e,t){return this.backend.updateSession(e,t)}async subscribeSessions(e){return this.backend.subscribeSessions(e)}forceReconnect(){this.backend.forceReconnect();}async getLocalDeviceId(){return typeof this.backend.getLocalDeviceId!="function"?null:this.backend.getLocalDeviceId()}async getLocalDeviceInfo(){return typeof this.backend.getLocalDeviceInfo!="function"?null:this.backend.getLocalDeviceInfo()}async updateDeviceName(e){return typeof this.backend.updateDeviceName!="function"?null:this.backend.updateDeviceName(e)}async startNativeSession(e){let t=this.backend;if(typeof t.startNativeSession!="function")throw new Error("Selected runtime adapter does not support startNativeSession().");return t.startNativeSession(e)}async notifyNetworkChange(e){return typeof this.backend.notifyNetworkChange!="function"?null:this.backend.notifyNetworkChange(e)}async setTransportPriority(e){if(typeof this.backend.setTransportPriority!="function")throw new Error("Selected runtime adapter does not support setTransportPriority().");await this.backend.setTransportPriority(e);}async getManagedNodeId(e){if(console.info("[DelegatingRuntimeAdapter][getManagedNodeId] enter",{hasMethod:typeof this.backend.getManagedNodeId=="function",backendCtor:this.backend.constructor?.name??null}),typeof this.backend.getManagedNodeId!="function")return null;let t=await this.backend.getManagedNodeId(e);return console.info("[DelegatingRuntimeAdapter][getManagedNodeId] resolved",{result:t}),t}async startPresence(e,t,n,i,r){let o=this.backend;if(typeof o.startPresence!="function")throw new Error("Selected runtime adapter does not support startPresence().");return o.startPresence(e,t,n,i,r)}async startAutoConnectOnce(e,t){let n=this.backend;if(typeof n.startAutoConnectOnce!="function")throw new Error("Selected runtime adapter does not support startAutoConnectOnce().");return n.startAutoConnectOnce(e,t)}async getEndpointTicket(){if(typeof this.backend.getEndpointTicket!="function")throw new Error("Selected runtime adapter does not support getEndpointTicket().");return this.backend.getEndpointTicket()}async getTicketWithToken(e,t){let n=this.backend;return typeof n.getTicketWithToken!="function"?null:n.getTicketWithToken(e,t)}async registerSessionToken(e,t,n,i){let r=this.backend;typeof r.registerSessionToken=="function"&&await r.registerSessionToken(e,t,n,i);}async revokeTokens(e){let t=this.backend;return typeof t.revokeTokens!="function"?[]:t.revokeTokens(e)}async openPeerBi(e,t){if(typeof this.backend.openPeerBi!="function")throw new Error("Selected runtime adapter does not support openPeerBi().");return this.backend.openPeerBi(e,t)}async incoming_streams(){let e=this.backend;if(typeof e.incoming_streams!="function")throw new Error("Selected runtime adapter does not support incoming_streams().");return e.incoming_streams()}async incoming_projected_streams(){let e=this.backend;if(typeof e.incoming_projected_streams!="function")throw new Error("Selected runtime adapter does not support incoming_projected_streams().");return e.incoming_projected_streams()}projectedIncomingStreamSource(){let e=this.backend;return typeof e.projectedIncomingStreamSource!="function"?{incoming_streams:()=>this.incoming_projected_streams(),isCurrentTransport:(t,n)=>this.isCurrentTransport(t,n)}:e.projectedIncomingStreamSource()}async isCurrentTransport(e,t){let n=this.backend;return typeof n.isCurrentTransport=="function"?n.isCurrentTransport(e,t):typeof n.is_current_transport_stable_id!="function"?false:n.is_current_transport_stable_id(e,t)}async openPeerBiRaw(e,t){let n=this.backend;if(typeof n.openPeerBiRaw=="function")return n.openPeerBiRaw(e,t);throw new Error("Selected runtime adapter does not support the restricted transport-only diagnostic stream.")}async openPeerUni(e,t){if(typeof this.backend.openPeerUni!="function")throw new Error("Selected runtime adapter does not support openPeerUni().");return this.backend.openPeerUni(e,t)}async beginOpenRtcMediaPublication(e){if(typeof this.backend.beginOpenRtcMediaPublication!="function")throw new Error("Selected runtime adapter does not support media publications.");return this.backend.beginOpenRtcMediaPublication(e)}async encodeOpenRtcMediaSample(e){if(typeof this.backend.encodeOpenRtcMediaSample!="function")throw new Error("Selected runtime adapter does not support media samples.");return this.backend.encodeOpenRtcMediaSample(e)}async pauseOpenRtcMediaPublication(e){if(typeof this.backend.pauseOpenRtcMediaPublication!="function")throw new Error("Selected runtime adapter does not support media publications.");await this.backend.pauseOpenRtcMediaPublication(e);}async retireOpenRtcMediaPublication(e){if(typeof this.backend.retireOpenRtcMediaPublication!="function")throw new Error("Selected runtime adapter does not support media publications.");await this.backend.retireOpenRtcMediaPublication(e);}async retireOpenRtcMediaReceiver(e,t){if(typeof this.backend.retireOpenRtcMediaReceiver!="function")throw new Error("Selected runtime adapter does not support media receivers.");await this.backend.retireOpenRtcMediaReceiver(e,t);}async decodeOpenRtcMediaChunk(e){if(typeof this.backend.decodeOpenRtcMediaChunk!="function")throw new Error("Selected runtime adapter does not support the media protocol.");return this.backend.decodeOpenRtcMediaChunk(e)}async decodeOpenRtcMediaControl(e){if(typeof this.backend.decodeOpenRtcMediaControl!="function")throw new Error("Selected runtime adapter does not support the media protocol.");return this.backend.decodeOpenRtcMediaControl(e)}async connectToDevice(e){if(typeof this.backend.connectToDevice!="function")throw new Error("Selected runtime adapter does not support connectToDevice().");return this.backend.connectToDevice(e)}async disconnectDevice(e){if(typeof this.backend.disconnectDevice!="function")throw new Error("Selected runtime adapter does not support disconnectDevice().");return this.backend.disconnectDevice(e)}async excludeAutoConnect(e,t){if(typeof this.backend.excludeAutoConnect!="function")throw new Error("Selected runtime adapter does not support excludeAutoConnect().");return this.backend.excludeAutoConnect(e,t)}async isConnected(e){return this.backend.isConnected(e)}async getConnectionStates(){return typeof this.backend.getConnectionStates!="function"?[]:this.backend.getConnectionStates()}onStateChange(e){return typeof this.backend.onStateChange!="function"?()=>{}:this.backend.onStateChange(e)}async sendExplicitFilePath(e,t,n){if(typeof this.backend.sendExplicitFilePath!="function")throw new Error("Selected runtime adapter does not support sendExplicitFilePath().");return this.backend.sendExplicitFilePath(e,t,n)}async sendExplicitFileData(e){if(typeof this.backend.sendExplicitFileData!="function")throw new Error("Selected runtime adapter does not support sendExplicitFileData().");return this.backend.sendExplicitFileData(e)}async getTransferHistory(e){return typeof this.backend.getTransferHistory!="function"?[]:this.backend.getTransferHistory(e)}async deleteTransferJob(e){if(typeof this.backend.deleteTransferJob=="function")return this.backend.deleteTransferJob(e)}async sendPeerMessage(e,t){if(typeof this.backend.sendPeerMessage!="function")throw new Error("Selected runtime adapter does not support native peer messages.");await this.backend.sendPeerMessage(e,t);}onPeerMessage(e){return typeof this.backend.onPeerMessage!="function"?()=>{}:this.backend.onPeerMessage(e)}capabilities(){let e=this.backend;return typeof e.capabilities=="function"?e.capabilities():t()}async onIncomingNativeMessage(e){let t=this.backend;return typeof t.onIncomingNativeMessage!="function"?()=>{}:t.onIncomingNativeMessage(e)}unwrap(){return this.backend}setCoreClient(e){let t=this.backend;typeof t.setCoreClient=="function"&&t.setCoreClient(e);}};export{a};