openrtc 2.3.1 → 2.5.1

package/dist/runtime/factories.d.ts

@@ -1,10 +1,354 @@
-import { c as RuntimeFactoryOptions, b as PlutoRuntimeAssembly } from '../assembly-Bmi65-tK.js';
-import { I as IpcRuntimeAdapter } from '../IpcRuntimeAdapter-CE0va9Tr.js';
-import { W as WasmBridge } from '../DelegatingRuntimeAdapter-DE4LTGAJ.js';
-import { P as PlutoIpcBridge } from '../ipc-CPnNwv6f.js';
-import '../types-DDhMQkK8.js';
-import '../ITransport-CjxCQ6q7.js';
-import '../capabilities-BPuynml5.js';
+import { c as RuntimeFactoryOptions, b as PlutoRuntimeAssembly } from '../assembly-DvfsYFCL.js';
+import { N as NativeProjectionBroker, I as IpcRuntimeAdapter } from '../IpcRuntimeAdapter-Ddx0MtSI.js';
+import { X as Device, U as ISignalingBackend, K as DiscoveryMode, N as AuthMode, O as SignalingMode, Q as ClientOptions, T as ExplicitFileDataSendParams, ai as BrowserWasmRuntimeModule, a3 as LocalDeviceInfo, W as RoomMember, aj as BrowserProtocolStore, ak as NamespaceDescriptor, al as IrohMutationReceipt, am as IrohDocEntry, V as RuntimeIdentity, _ as SignalingEnvelope, Y as DeviceStatusSnapshot, k as PeerSessionSnapshot, a5 as BackendPeerBiStream, a6 as BackendPeerUniStream, a7 as PortableMediaPublish, a8 as PortableMediaPublicationStart, a9 as PortableMediaSample, aa as PortableMediaChunk, ab as PortableMediaControl, Z as ManagedConnectionRecord, n as ResolvedPeerIdentity, b as RoomArchitectureSnapshot, c as RoomAuthorityAssignment, an as CoordinationSignalingStore, ao as ManagedRoomMessage, $ as DeviceEvent, a0 as DesiredPeerProjection, ap as CoreClientBridgeHost, ac as NativeConnectParams, ad as NativeConnectResult, a1 as SignalingSession, a2 as SessionEvent, ae as BackendConnectionState } from '../Connection-CTpuImO-.js';
+import { R as RuntimeCapabilities } from '../capabilities-CmzzxSvW.js';
+import { R as RuntimeBridgeOptions } from '../DelegatingRuntimeAdapter-D67Ozqo3.js';
+import { P as PlutoIpcBridge } from '../ipc-DgzKqHH3.js';
+
+interface NativeTrustToken {
+    token: string;
+    expiresAtMs: number;
+}
+
+/** Internal-only gateway record before normalization; includes namespace fields omitted from the public Device type. */
+type RawDeviceDoc = Device & {
+    appTag?: string;
+    tag?: string;
+};
+
+/** Public verification material plus an opaque Rust/WASM signer handle. */
+interface WasmPublisherSignerDescriptor {
+    handle: string;
+    publicKey: Uint8Array;
+}
+interface ResolvedWasmBroadcastGrant {
+    token: string;
+    issuerPublicKey: Uint8Array;
+    signBindingChallenge(message: Uint8Array): Promise<Uint8Array>;
+}
+interface BrowserBroadcastWasmBindings {
+    __createOpenRtcBroadcastPublisherSigner(): WasmPublisherSignerDescriptor;
+    __prepareOpenRtcBroadcastGrant(token: string, issuerPublicKey: Uint8Array, nowMs: number): {
+        handle: string;
+        signingBytes: Uint8Array;
+        expiresAtMs: number;
+    };
+    __openOpenRtcBroadcast(token: string, issuerPublicKey: Uint8Array, bindingChallengeHandle: string, bindingSignature: Uint8Array, publisherSignerHandle: string | undefined, nowMs: number): unknown;
+    __releaseOpenRtcBroadcastPublisherSigner(handle: string): boolean;
+}
+/**
+ * Private browser publisher boundary used by the managed broadcast host.
+ *
+ * Rust/WASM owns the signing key. JavaScript receives only a public key and an
+ * opaque handle, has no sign operation, and cannot export private key bytes.
+ * The shared Rust core canonicalizes and verifies every signed media group.
+ */
+declare class BrowserBroadcastWasmPublisher {
+    private readonly wasm;
+    readonly verificationKey: Uint8Array;
+    private handle;
+    private constructor();
+    static create(wasm: BrowserBroadcastWasmBindings): BrowserBroadcastWasmPublisher;
+    /** Open a publisher grant previously bound to `verificationKey`. */
+    open(grant: ResolvedWasmBroadcastGrant, nowMs?: number): Promise<unknown>;
+    close(): void;
+}
+
+type WasmBridgeOptions = RuntimeBridgeOptions;
+/**
+ * WasmBridge is the browser host wrapper over the Rust/WASM runtime.
+ *
+ * Allowed:
+ * - normalize JS/WASM binding shapes
+ * - forward auth, discovery, signaling, and lifecycle calls into Rust
+ * - expose typed browser-facing results
+ *
+ * Not allowed:
+ * - become a second lifecycle engine
+ * - invent peer identity or connect policy that is not backed by Rust
+ * - normalize app-specific payload protocols into runtime behavior
+ *
+ * Source of truth:
+ * - Rust/WASM owns transport/runtime connection state and lifecycle primitives
+ * - The selected coordination provider owns browser delivery projections
+ * - RuntimeClient owns app-facing orchestration across those surfaces
+ */
+declare class WasmBridge implements ISignalingBackend {
+    private static readonly EXPLICIT_FILE_PROTOCOL_TYPE;
+    private static readonly EXPLICIT_FILE_CHUNK_SIZE_BYTES;
+    private static readonly MAX_EXPLICIT_TRANSFER_HEADER_BYTES;
+    private static readonly FALLBACK_EXPLICIT_FILE_NAME;
+    private static readonly MAX_EXPLICIT_FILE_NAME_CHARS;
+    private static readonly FALLBACK_EXPLICIT_MIME_TYPE;
+    private static readonly MAX_EXPLICIT_MIME_TYPE_CHARS;
+    app: any | null;
+    auth: any | null;
+    private readonly appTag;
+    protected options: {
+        appTag: string;
+        apiKey?: string;
+        discoveryMode?: DiscoveryMode;
+        space?: string;
+        spaceKey?: string;
+        authMode: AuthMode;
+        signalingMode?: SignalingMode;
+        projectId: string;
+        coordinationGateway?: ClientOptions['coordinationGateway'];
+        coordinationAvenueOverride?: ClientOptions['coordinationAvenueOverride'];
+        coordinationRoomGossipFanout?: ClientOptions['coordinationRoomGossipFanout'];
+        coordinationRoomArchitecture?: ClientOptions['coordinationRoomArchitecture'];
+        coordinationDevicePublicKeyX?: ClientOptions['coordinationDevicePublicKeyX'];
+        coordinationDeviceSign?: ClientOptions['coordinationDeviceSign'];
+        initialAutoConnectExcludedDeviceIds?: ClientOptions['initialAutoConnectExcludedDeviceIds'];
+        attestationTokenProvider?: ClientOptions['attestationTokenProvider'];
+        coordinationPlatformType?: string;
+        storagePrefix?: string;
+        deviceIdPersistence?: 'persistent' | 'ephemeral';
+        endpointIdPersistence?: 'persistent' | 'ephemeral';
+        nodeIdPersistence?: 'persistent' | 'ephemeral';
+        localDeviceId?: string;
+        deviceName?: string;
+        strictMode?: boolean;
+        turnCredentialsProvider?: () => Promise<{
+            iceServers?: RTCIceServer[];
+        } | null | undefined>;
+        applicationCrypto?: ExplicitFileDataSendParams['applicationCrypto'];
+        spaceTokenProvider?: ClientOptions['spaceTokenProvider'];
+        spaceAuth?: 'scoped-token';
+    };
+    private spaceNamespaceIdPromise;
+    private cachedSpaceNamespaceId;
+    private authListeners;
+    private persistenceReady;
+    wasmClient: any;
+    private readonly createdAtMs;
+    private missingWasmWarnings;
+    private readonly wasmReadyWarningDelayMs;
+    private readonly coordinationHost;
+    /** Test seam only; production gateway ownership remains in coordinationHost. */
+    private browserCoordinationSignaling;
+    private effectiveRoomArchitecture;
+    private lastObservedFirebaseUserId;
+    private sessionReaders;
+    protected authContext: {
+        userId: string;
+        token?: string | null;
+        refreshToken?: string | null;
+        customToken?: string | null;
+        tokenProvider?: (forceRefresh?: boolean) => Promise<string | null>;
+        appCheckTokenProvider?: (forceRefresh?: boolean) => Promise<string | null>;
+        expiresAtMs?: number | null;
+    } | null;
+    private injectedBrowserAuthSessionActive;
+    private readonly presenceManager;
+    private hasSyncedAuthToWasmClient;
+    private lastWasmAuthUserId;
+    private lastWasmAuthToken;
+    private lastDeliveredConnectionStates;
+    private authScopedRuntimeGeneration;
+    private coreClient;
+    private readonly applicationRouteEscalations;
+    private applicationRouteEscalationAttemptKeys;
+    private applicationRouteEscalationUnsubscribe;
+    private routeSubscriptionGeneration;
+    private applicationRouteEscalationSubscriptionEpoch;
+    constructor(options: WasmBridgeOptions);
+    loadBrowserWasmRuntime(): Promise<BrowserWasmRuntimeModule>;
+    get tag(): string;
+    capabilities(): RuntimeCapabilities;
+    private static readonly WEB_DEVICE_ID_STORAGE_PREFIX;
+    private static readonly EPHEMERAL_DEVICE_ID_TTL_MS;
+    private getDeviceIdentityStorageKey;
+    private getDeviceIdPersistenceMode;
+    private isTicketOnlyMode;
+    private usesProviderNeutralGrant;
+    private createRandomDeviceId;
+    protected resolveWebLogicalDeviceId(): string;
+    private getDefaultBrowserDeviceName;
+    getLocalDeviceInfo(): Promise<LocalDeviceInfo>;
+    private getCoordinationSignaling;
+    usesCoordinationGateway(): boolean;
+    setCoordinationHostAvailability(input: {
+        available: boolean;
+        reason: string;
+    }): void;
+    /** Restore the existing gateway delivery subscription after a native host resumes. */
+    reconnectCoordinationAfterHostResume(): Promise<void>;
+    getCoordinationNativeTrustToken(forceRefresh?: boolean): Promise<NativeTrustToken>;
+    invalidateCoordinationNativeTrustToken(): void;
+    subscribeCoordinationNativeTrustToken(listener: (token: NativeTrustToken | null) => void, options?: {
+        emitCurrent?: boolean;
+    }): () => void;
+    setCoordinationLocalDeviceId(deviceId: string): void;
+    /** Internal native-host hint for provider-neutral roster presentation. */
+    setCoordinationPlatformType(platformType: string): void;
+    setCoordinationExcludedPeers(excludedPeers: string[]): Promise<void>;
+    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;
+    private withWebPresenceMetadata;
+    setAuthContext(context: {
+        userId: string;
+        token?: string | null;
+        refreshToken?: string | null;
+        customToken?: string | null;
+        tokenProvider?: (forceRefresh?: boolean) => Promise<string | null>;
+        appCheckTokenProvider?: (forceRefresh?: boolean) => Promise<string | null>;
+        expiresAtMs?: number | null;
+    } | null): Promise<void>;
+    private ensureBrowserPlatformAuth;
+    private syncWasmAuthToken;
+    private toRuntimeIdentity;
+    protected getCurrentUserId(): string | null;
+    getCurrentUserIdForScope(): string | null;
+    getAuthContext(): Readonly<typeof this.authContext> | null;
+    protected isSpaceMode(): boolean;
+    getResolvedOptions(): Readonly<typeof this.options>;
+    protected getDiscoveryScopeId(): string | null;
+    protected matchesTag(device: Pick<RawDeviceDoc, 'tag' | 'appTag'>): boolean;
+    matchesLegacyOrCurrentTag(device: Pick<RawDeviceDoc, 'tag' | 'appTag'>): boolean;
+    private stopSessionSubscriptions;
+    private stopRuntimeAuthScopedLoops;
+    stopAuthActivity(options?: {
+        userId?: string | null;
+    }): Promise<void>;
+    setWasmClient(client: any): void;
+    /** Private managed-broadcast edge. Rust/WASM retains the private signer. */
+    createBroadcastPublisher(): Promise<BrowserBroadcastWasmPublisher>;
+    initializePersistentIrohProtocols(store: BrowserProtocolStore): Promise<void>;
+    createPersistentIrohNamespace(generation: number, shareRevision: number): Promise<NamespaceDescriptor>;
+    importPersistentIrohTicket(ticket: string, generation: number, shareRevision: number): Promise<string>;
+    sharePersistentIrohNamespace(namespaceId: string, writable: boolean): Promise<string>;
+    removePersistentIrohNamespace(namespaceId: string, generation: number, shareRevision: number): Promise<void>;
+    putPersistentIrohBytes(namespaceId: string, key: Uint8Array, value: Uint8Array): Promise<IrohMutationReceipt>;
+    setPersistentIrohHash(namespaceId: string, key: Uint8Array, contentHash: string, contentLength: number): Promise<string>;
+    deletePersistentIrohPrefix(namespaceId: string, prefix: Uint8Array): Promise<{
+        removed: number;
+        operationId: string;
+    }>;
+    queryPersistentIrohNamespace(namespaceId: string, keyPrefix: Uint8Array): Promise<IrohDocEntry[]>;
+    hydratePersistentIrohBlob(contentHash: string): Promise<void>;
+    acknowledgePersistentIrohOutbox(operationId: string): Promise<void>;
+    flushPersistentIrohProtocols(): Promise<void>;
+    shutdownPersistentIrohProtocols(): Promise<void>;
+    private requirePersistentProtocolHost;
+    private warnMissingWasmOnce;
+    private waitForWasmClient;
+    protected normalizeDevice(raw: Record<string, any>, fallbackId?: string): Device;
+    normalizeDeviceRecord(raw: Record<string, any>, fallbackId?: string): Device;
+    getResolvedWebLogicalDeviceId(): string;
+    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>;
+    private normalizeDeviceStatusSnapshot;
+    private normalizePeerSessionSnapshot;
+    private toBackendConnectionStateFromPeerSession;
+    private normalizeStateSnapshot;
+    private stabilizeConnectionState;
+    private sameConnectionState;
+    private deliverConnectionState;
+    private get browserPresenceLoopState();
+    private set browserPresenceLoopState(value);
+    get currentUser(): RuntimeIdentity | null;
+    onAuthChange(callback: (user: RuntimeIdentity | null) => void): () => void;
+    checkForSSOToken(): Promise<void>;
+    waitForAuth(): Promise<void>;
+    signInAnonymously(): Promise<void>;
+    signInWithPluto(): Promise<void>;
+    signOut(): Promise<void>;
+    getTurnCredentials(): Promise<any>;
+    updatePresence(localNodeId: string, ticketStr: string, isOnline?: boolean, ttlMs?: number, metadata?: string, deviceNameOverride?: string): Promise<void>;
+    refreshLivePresence(localNodeId: string, ticketStr: string, 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>;
+    deleteDevice(deviceId: string): Promise<void>;
+    cleanupStaleDevices(): Promise<void>;
+    sendMessage(targetId: string, payload: string, state?: string, replyPayload?: string): Promise<string>;
+    pollMessages(targetId: string): Promise<SignalingEnvelope[]>;
+    searchDevices(excludeNodeId?: string): Promise<Device[]>;
+    listDeviceStatus(): Promise<DeviceStatusSnapshot[]>;
+    getPeerSession(id: string): Promise<PeerSessionSnapshot | null>;
+    listPeerSessions(): Promise<PeerSessionSnapshot[]>;
+    waitForSettledPeer(id: string, timeoutMs?: number): Promise<PeerSessionSnapshot | null>;
+    openPeerBi(id: string, timeoutMs?: number): Promise<BackendPeerBiStream>;
+    openPeerBiRaw(id: string, timeoutMs?: number): Promise<BackendPeerBiStream>;
+    openPeerUni(id: string, timeoutMs?: number): Promise<BackendPeerUniStream>;
+    beginOpenRtcMediaPublication(input: Omit<PortableMediaPublish, 'mediaGeneration'>): PortableMediaPublicationStart;
+    encodeOpenRtcMediaSample(input: PortableMediaSample): Uint8Array;
+    pauseOpenRtcMediaPublication(publicationId: string): void;
+    retireOpenRtcMediaPublication(publicationId: string): void;
+    retireOpenRtcMediaReceiver(publicationId: string, mediaGeneration: number): void;
+    decodeOpenRtcMediaChunk(encoded: Uint8Array): PortableMediaChunk;
+    decodeOpenRtcMediaControl(encoded: Uint8Array): PortableMediaControl;
+    sendPeerDatagram(id: string, payload: Uint8Array, maxAgeMs?: number): Promise<boolean>;
+    receivePeerDatagram(id: string): Promise<Uint8Array>;
+    peerDatagramMaxSize(): number;
+    createPeerDatagramPolicy(): unknown;
+    resolvePeerRecords(id: string): Promise<ManagedConnectionRecord[]>;
+    resolvePeerIdentity(id: string): Promise<ResolvedPeerIdentity>;
+    onDevicesChange(callback: (devices: Device[]) => void, excludeNodeId?: string): () => void;
+    onRoomArchitectureChange(callback: (snapshot: RoomArchitectureSnapshot) => void): () => void;
+    onRoomAuthorityAssignmentChange(callback: (assignment: RoomAuthorityAssignment | null) => void): () => void;
+    publishAuthorityAssignment(input: Parameters<NonNullable<CoordinationSignalingStore['publishAuthorityAssignment']>>[0]): 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;
+    subscribeDevices(userId: string): Promise<ReadableStream<DeviceEvent[]>>;
+    startAutoConnect(userId: string, localDeviceId: string): Promise<void>;
+    startAutoConnectOnce(userId: string, localDeviceId: string): Promise<void>;
+    notifyDisconnectRequested(remoteNodeId: string): void;
+    excludeAutoConnect(deviceId: string, excluded: boolean): Promise<void>;
+    disconnectDevice(deviceId: string): Promise<void>;
+    submitDesiredPeerProjection(revision: number, peers: DesiredPeerProjection[]): Promise<void>;
+    setCoreClient(client: CoreClientBridgeHost | null): void;
+    private startApplicationRouteEscalationSubscription;
+    private stopApplicationRouteEscalationSubscription;
+    private retryManagedApplicationRouteEscalations;
+    private escalateManagedApplicationRoute;
+    connectToDevice(params: NativeConnectParams): Promise<NativeConnectResult>;
+    forceReconnect(): void;
+    startPresenceLoop(userId: string, localNodeId: string, deviceName: string, ticket: string, metadata?: string): Promise<void>;
+    private ensureSpaceNamespaceIdPromise;
+    createSession(session: SignalingSession): Promise<void>;
+    updateSession(sessionId: string, updateData: any): Promise<void>;
+    subscribeSessions(localDeviceId: string): Promise<ReadableStream<SessionEvent[]>>;
+    getLocalDeviceId(): Promise<string | null>;
+    isConnected(node_id: string): Promise<boolean>;
+    getConnectionStates(): Promise<BackendConnectionState[]>;
+    onStateChange(callback: (state: BackendConnectionState) => void): Promise<() => void> | (() => void);
+    sendExplicitFilePath(connectionId: string, filePath: string, transferId?: string): Promise<string>;
+    private sanitizeExplicitFileName;
+    private sanitizeExplicitMimeType;
+    private assertExplicitTransferHeaderSize;
+    private createWebRTCExplicitTransferId;
+    private createWebRTCExplicitTransferFrame;
+    sendExplicitFileData(params: ExplicitFileDataSendParams): Promise<void>;
+    getTransferHistory(limit?: number): Promise<Array<[string, unknown]>>;
+    deleteTransferJob(jobId: string): Promise<void>;
+    watchFriendDevices(friendUserIds: string[], callback: (friendDevices: Map<string, any[]>) => void): () => void;
+    updateFriendTicket(friendTicket: string | null): Promise<void>;
+}
 
 /**
  * @deprecated Legacy assembly helper. Use `OpenRTC()` for app code.
@@ -16,6 +360,6 @@ declare function createWasmClient(options: RuntimeFactoryOptions): Promise<Pluto
  * `OpenRTC.native` from `openrtc`.
  * Removal target: OpenRTC 0.2.0.
  */
-declare function createIpcClient(options: RuntimeFactoryOptions, bridge: PlutoIpcBridge): PlutoRuntimeAssembly<IpcRuntimeAdapter>;
+declare function createIpcClient(options: RuntimeFactoryOptions, bridge: PlutoIpcBridge, projectionBroker?: NativeProjectionBroker): PlutoRuntimeAssembly<IpcRuntimeAdapter>;
 
 export { PlutoRuntimeAssembly, RuntimeFactoryOptions, createIpcClient, createWasmClient };

package/dist/runtime/factories.js

@@ -1 +1 @@
-import {a as a$2}from'../chunk-KRJECX7X.js';import {t,a as a$3}from'../chunk-XAL4T6TB.js';import'../chunk-HUG5AX7R.js';import'../chunk-DUY34MGT.js';import'../chunk-R35AWMNY.js';import'../chunk-Z2IS6NH2.js';import'../chunk-AJQVMVYW.js';import {a as a$1}from'../chunk-WA434EWD.js';import'../chunk-HEAJ7ZUR.js';import'../chunk-7BJKDBLP.js';import'../chunk-2L6ULC32.js';import'../chunk-2SUSPEC4.js';var n=false;function a(){n||(n=true,a$3(async()=>{let t=await import('../openrtc-MWLNTJI7.js');return {initWasm:t.default,WasmClient:t.WasmClient,start:t.start}}));}async function d(t){a();let e=a$1(t),{WasmBridge:i}=await import('../WasmBridge-75F6GKHG.js');return a$2(e,new i(e))}function y(t$1,e){let i=a$1(t$1);return a$2(i,new t({...i,bridge:e}))}export{y as createIpcClient,d as createWasmClient};
+import {a as a$2}from'../chunk-Z4KJHIV5.js';import {s}from'../chunk-2K47N3QP.js';import'../chunk-BGWJHPBC.js';import'../chunk-FEF3DPPB.js';import'../chunk-GTHSRQ7Y.js';import {a as a$1}from'../chunk-XTYALGJN.js';import'../chunk-TYZS5LXQ.js';import'../chunk-OT7IPLZE.js';import'../chunk-OWKAJPOI.js';import {a}from'../chunk-VTYVIKTM.js';import'../chunk-72NEEJQG.js';import'../chunk-DUY34MGT.js';import'../chunk-CCCYE3XN.js';import'../chunk-N6LGTNUI.js';import'../chunk-JPBW67B3.js';import'../chunk-2GX6GB6L.js';async function l(e){let t=a$1(e),{WasmBridge:o}=await import('../WasmBridge-ZXBCXBBM.js');return a$2(t,new o(t))}function y(e,t,o=new a){let m=a$1(e);return a$2(m,new s({...m,bridge:t,projectionBroker:o}))}export{y as createIpcClient,l as createWasmClient};

package/dist/runtime/index.d.ts

@@ -1,17 +1,15 @@
-import { a as PeerReconciliationStats } from '../assembly-Bmi65-tK.js';
-export { D as ConnectionActor, d as ConnectionActorError, e as ConnectionActorErrorKind, f as ConnectionActorKey, g as ConnectionActorOptions, h as ConnectionActorState, i as ConnectionActors, j as ConnectionClose, k as ConnectionDial, l as LogicalChannel, P as PolicySnapshot, m as PreferredTransport, n as RUNTIME_POLICY, R as RuntimeClient, o as connectionActorKey, p as connectionActorKeyString, q as getRuntimePolicy } from '../assembly-Bmi65-tK.js';
+import { a as PeerReconciliationStats } from '../assembly-DvfsYFCL.js';
+export { D as ConnectionActor, d as ConnectionActorError, e as ConnectionActorErrorKind, f as ConnectionActorKey, g as ConnectionActorOptions, h as ConnectionActorState, i as ConnectionActors, j as ConnectionClose, k as ConnectionDial, l as LogicalChannel, P as PolicySnapshot, m as PreferredTransport, n as RUNTIME_POLICY, R as RuntimeClient, o as connectionActorKey, p as connectionActorKeyString, q as getRuntimePolicy } from '../assembly-DvfsYFCL.js';
 import { Client as Client$1 } from '../coreClient.js';
-import { b as Avenue } from '../types--jQzenZR.js';
-import * as Draft14 from '@moq/net';
-import { a7 as SignalingOptions, I as ISignalingBackend, m as RuntimeIdentity, l as RoomMember, n as SignalingEnvelope, u as SignalingSession, D as Device, r as DesiredPeerProjection, w as BackendConnectionState, a6 as AppLimits, G as GrantScope, Y as JoinRoomOptions, W as ChannelMetadata, a2 as CryptoStreams, a8 as RoomCreationMode, h as ClientOptions, z as PayloadCrypto, k as DiscoveryMode, a1 as ProtocolCapabilityMap, a9 as ScanningLoopOptions, aa as ScanningLoopHandle, ab as RuntimeBootstrapOptions, ac as RuntimeBootstrapResult, F as ApplicationPayloadReadinessOptions, ad as ManagedApplicationRouteOptions, Q as PeerState, T as PeerScope, U as PeerHealth, V as ChannelDescriptor, ae as JoinRequest, N as NativeConnectParams, t as NativeConnectResult } from '../ITransport-CjxCQ6q7.js';
-import { a as Connection, t as ConnectionTarget, m as RawConnection } from '../types-DDhMQkK8.js';
-export { v as AutoConnectPolicy, B as BrowserProtocolStore, C as ChannelDescriptor, w as ChannelFraming, i as ConnectionEvent, g as ConnectionState, x as ConnectionStatus, k as DeviceConnectOptions, y as DevicePresence, l as DeviceProfile, D as DeviceStatus, I as IncomingStream, q as IrohDocEntry, p as IrohMutationReceipt, J as JoinRoomOptions, L as LocalDeviceInfo, M as ManagedOptions, j as ManagedSession, N as NamespaceDescriptor, z as PayloadRouteOptions, P as PeerConnectOptions, E as PeerLifecycleStatus, b as PeerReadiness, F as PeerSessionSnapshot, d as PeerStreamOptions, u as PresenceLoopOptions, G as PresencePolicy, h as ReadinessOptions, H as RuntimeAuthContext, r as RuntimeAuthIdentity, o as RuntimeClientOptions, e as RuntimeDevice, c as RuntimePeerHealth, K as RuntimePeerScope, R as RuntimePeerState, n as RuntimeRoomMember, s as RuntimeSession, S as ScopedChannelOptions, f as ScopedLogicalChannel, O as SessionKind, Q as SessionPlatform } from '../types-DDhMQkK8.js';
-import { R as RuntimeCapabilities } from '../capabilities-BPuynml5.js';
-export { B as BROWSER_CAPABILITIES, a as CapabilityHost, C as CapabilityProfile, N as NATIVE_CAPABILITIES, b as NativeRuntimeStatus, c as RuntimeAdapterKind, T as TransportStatus, d as browserCapabilities, e as capabilityProfile, f as cloneCapabilities, s as statusCapabilities } from '../capabilities-BPuynml5.js';
+import { c as Avenue } from '../types-Cyc-mPjk.js';
+import { aB as SignalingOptions, U as ISignalingBackend, V as RuntimeIdentity, W as RoomMember, _ as SignalingEnvelope, a1 as SignalingSession, X as Device, a0 as DesiredPeerProjection, ae as BackendConnectionState, ay as AppLimits, G as GrantScope, j as Connection, aC as JoinRoomOptions, aD as ChannelMetadata, as as CryptoStreams, aE as RoomCreationMode, Q as ClientOptions, ar as PayloadCrypto, K as DiscoveryMode, aF as ProtocolCapabilityMap, aG as ScanningLoopOptions, aH as ScanningLoopHandle, aI as RuntimeBootstrapOptions, aJ as RuntimeBootstrapResult, aK as ApplicationPayloadReadinessOptions, aL as ManagedApplicationRouteOptions, aM as PeerState, aN as PeerScope, aO as PeerHealth, aP as ChannelDescriptor, aQ as JoinRequest, ac as NativeConnectParams, ad as NativeConnectResult, az as ConnectionTarget, A as RawConnection } from '../Connection-CTpuImO-.js';
+export { aR as AutoConnectPolicy, aj as BrowserProtocolStore, C as ChannelDescriptor, aS as ChannelFraming, t as ConnectionEvent, r as ConnectionState, aT as ConnectionStatus, v as DeviceConnectOptions, aU as DevicePresence, z as DeviceProfile, D as DeviceStatus, I as IncomingStream, am as IrohDocEntry, al as IrohMutationReceipt, J as JoinRoomOptions, L as LocalDeviceInfo, M as ManagedOptions, u as ManagedSession, ak as NamespaceDescriptor, aV as PayloadRouteOptions, i as PeerConnectOptions, aW as PeerLifecycleStatus, l as PeerReadiness, aX as PeerSessionSnapshot, o as PeerStreamOptions, aa as PortableMediaChunk, ab as PortableMediaControl, a8 as PortableMediaPublicationStart, a7 as PortableMediaPublish, a9 as PortableMediaSample, aA as PresenceLoopOptions, aY as PresencePolicy, s as ReadinessOptions, aZ as RuntimeAuthContext, aw as RuntimeAuthIdentity, H as RuntimeClientOptions, p as RuntimeDevice, m as RuntimePeerHealth, a_ as RuntimePeerScope, h as RuntimePeerState, B as RuntimeRoomMember, ax as RuntimeSession, S as ScopedChannelOptions, q as ScopedLogicalChannel, a$ as SessionKind, b0 as SessionPlatform } from '../Connection-CTpuImO-.js';
+import { R as RuntimeCapabilities } from '../capabilities-CmzzxSvW.js';
+export { B as BROWSER_CAPABILITIES, a as CapabilityHost, b as CapabilityMaturity, C as CapabilityProfile, N as NATIVE_CAPABILITIES, c as NativeRuntimeStatus, P as ProductCapabilityMaturity, d as RuntimeAdapterKind, T as TransportStatus, e as browserCapabilities, f as capabilityProfile, g as cloneCapabilities, s as statusCapabilities } from '../capabilities-CmzzxSvW.js';
 export { DeviceActiveOptions, isDeviceActive, isDeviceConnectable, isDeviceRoutable } from './device-status.js';
-export { a as IpcAdapterOptions, I as IpcRuntimeAdapter } from '../IpcRuntimeAdapter-CE0va9Tr.js';
-export { P as NativeBridge, N as NativeIpcFailureKind, P as PlutoIpcBridge, a as PlutoIpcUnlisten, c as classifyIpcFailure, i as isIpcUnavailable } from '../ipc-CPnNwv6f.js';
-import '../DelegatingRuntimeAdapter-DE4LTGAJ.js';
+export { a as IpcAdapterOptions, I as IpcRuntimeAdapter } from '../IpcRuntimeAdapter-Ddx0MtSI.js';
+export { P as NativeBridge, N as NativeIpcFailureKind, P as PlutoIpcBridge, a as PlutoIpcUnlisten, c as classifyIpcFailure, i as isIpcUnavailable } from '../ipc-DgzKqHH3.js';
+import '../DelegatingRuntimeAdapter-D67Ozqo3.js';
 
 declare class Signaling {
     private readonly appTag;
@@ -54,7 +52,7 @@ declare class Signaling {
     startAutoConnect(userId: string, localDeviceId: string): void;
     submitDesiredPeerProjection(revision: number, peers: DesiredPeerProjection[]): Promise<void>;
     notifyDisconnectRequested(remoteNodeId: string): void;
-    startPresenceLoop(userId: string, localNodeId: string, deviceName: string, ticket: string, metadata?: string): void;
+    startPresenceLoop(userId: string, localNodeId: string, deviceName: string, ticket: string, metadata?: string): Promise<void>;
     forceReconnect(): void;
     isConnected(nodeId: string): Promise<boolean>;
     getConnectionStates(): Promise<BackendConnectionState[]>;
@@ -71,142 +69,6 @@ type CapabilityRuntime = Client$1;
  */
 declare function runtimeForCapability(handle: Avenue): CapabilityRuntime;
 
-interface MoQSubscriberOptions {
-    maxPendingSubscriptions?: number;
-    maxSubscribeRetries?: number;
-    subscribeRetryDelayMs?: number;
-    maxBufferedGroupsPerTrack?: number;
-    maxBufferedFramesPerGroup?: number;
-    maxBufferedBytesPerTrack?: number;
-    maxObjectPayloadBytes?: number;
-    onSubscriptionTerminated?: (namespace: string, name: string, error: unknown) => void;
-}
-/** Draft-14 subscriber facade; session reconnect remains owned by MoQController. */
-declare class MoQSubscriber {
-    private readonly session;
-    private readonly onObject;
-    private readonly subscriptions;
-    private readonly maxSubscriptions;
-    private readonly maxSubscribeRetries;
-    private readonly subscribeRetryDelayMs;
-    private readonly maxObjectPayloadBytes;
-    private readonly onSubscriptionTerminated?;
-    private closed;
-    constructor(session: MoQSession, onObject: (trackNamespace: string, trackName: string, object: Uint8Array, metadata: unknown) => void, options?: MoQSubscriberOptions);
-    subscribe(namespace: string, name: string): Promise<void>;
-    close(): void;
-    private consume;
-}
-
-interface TransportInterface {
-    createBidirectionalStream(): Promise<{
-        readable: ReadableStream<Uint8Array>;
-        writable: WritableStream<Uint8Array>;
-    }>;
-    createUnidirectionalStream(): Promise<WritableStream<Uint8Array>>;
-    incomingBidirectionalStreams: ReadableStream<unknown>;
-    incomingUnidirectionalStreams: ReadableStream<ReadableStream<Uint8Array>>;
-    close(): void;
-    ready: Promise<void>;
-}
-interface MoQSessionOptions {
-    onSubscriptionTerminated?: (namespace: string, name: string, error: unknown) => void;
-}
-interface MoQDatagramDuplex {
-    readonly maxDatagramSize?: number;
-    readonly readable: ReadableStream<Uint8Array>;
-    readonly writable: WritableStream<Uint8Array>;
-    close(): void;
-}
-/**
- * Draft-14 MoQT adapter. The OpenRTC controller owns reconnect and lifecycle;
- * this class owns only one negotiated relay session and its protocol handles.
- */
-declare class MoQSession {
-    readonly transport: TransportInterface;
-    private readonly relayUrl;
-    readonly publisher: MoQPublisher;
-    readonly subscriber: MoQSubscriber;
-    setupComplete: boolean;
-    private connection;
-    private closeListeners;
-    private closed;
-    private closeEmitted;
-    private setupResolve;
-    private readonly setupPromise;
-    constructor(transport: TransportInterface, onObject?: (ns: string, name: string, obj: Uint8Array, meta: unknown) => void, role?: number, relayUrl?: URL, options?: MoQSessionOptions);
-    requireConnection(): Draft14.Connection.Established;
-    /**
-     * Open the patched Draft 14 object-datagram surface used only by the Iroh
-     * packet carrier. Existing application-data publishing remains on subgroup
-     * streams and never shares readiness with this duplex.
-     */
-    openDatagramDuplex(publishNamespace: string, subscribeNamespace: string, trackName: string): Promise<MoQDatagramDuplex>;
-    init(): Promise<void>;
-    waitForSetup(): Promise<void>;
-    onClose(callback: (reason?: unknown) => void): () => void;
-    close(): void;
-    private emitClose;
-}
-
-interface MoQPublisherOptions {
-    maxPendingAnnounces?: number;
-    announceTimeoutMs?: number;
-    maxSubscribedTracks?: number;
-    maxActivePublishers?: number;
-    maxTrackIdChars?: number;
-    /**
-     * Reject an application object before it reaches a relay track. This must
-     * match the receiver-side default so browser and native clients apply the
-     * same hard egress boundary.
-     */
-    maxObjectPayloadBytes?: number;
-}
-interface TrackPublisher {
-    close(): void;
-    push(data: Uint8Array, init: {
-        isKey: boolean;
-        timestamp: number;
-        closeAfterPush?: boolean;
-    }): Promise<void>;
-}
-/** Draft-14 publisher facade preserving OpenRTC's existing data-track API. */
-declare class MoQPublisher {
-    private readonly session;
-    private readonly namespaces;
-    private readonly activePublishers;
-    private readonly maxNamespaces;
-    private readonly maxSubscribedTracks;
-    private readonly maxActivePublishers;
-    private readonly maxTrackIdChars;
-    private readonly maxObjectPayloadBytes;
-    private closed;
-    constructor(session: MoQSession, options?: MoQPublisherOptions);
-    announce(namespace: string): Promise<void>;
-    hasNamespace(namespace: string): boolean;
-    hasTrackSubscriber(namespace: string, name: string): boolean;
-    createTrack(namespace: string, name: string): Promise<TrackPublisher>;
-    close(): void;
-    private acceptTrackRequests;
-    private totalSubscriberCount;
-    private resolveTrackId;
-}
-
-/**
- * Browser MoQ session controller.
- *
- * Owns the WebTransport-backed MoQ relay session, reconnect state, peer
- * subscriptions, and direct MoQ data helpers. `Client` remains the facade so
- * existing SDK calls and test spies keep working while MoQ stops contributing
- * more lifecycle state to the god object.
- */
-
-type MoQBundle = {
-    session: MoQSession;
-    publisher: MoQPublisher;
-    subscriber: MoQSubscriber;
-};
-
 interface RoomClientHost {
     wasmClient: any;
     roomCreationMode: 'client-open' | 'client-auth' | 'server-only';
@@ -251,11 +113,14 @@ type ProtocolHint = 'control' | 'explicit' | 'native-main' | 'unknown';
 type IncomingStreamEvent = {
     type: 'bi' | 'uni';
     stream: any;
+    connectionId?: string;
     remoteNodeId: string;
     transportStableId?: number;
     traceId?: string;
     protocolHint?: ProtocolHint;
     channel?: ChannelMetadata | null;
+    applicationAuthorized?: boolean;
+    admissionCandidate?: boolean;
     applicationCrypto?: CryptoStreams;
     invalid?: boolean;
 };
@@ -318,18 +183,11 @@ declare class Client {
     subscribeSessions(localDeviceId: string, callback: (session: SignalingSession) => void | Promise<void>): Promise<() => void>;
     startScanningLoop(options: ScanningLoopOptions): Promise<ScanningLoopHandle>;
     bootstrapRuntime(options: RuntimeBootstrapOptions): Promise<RuntimeBootstrapResult>;
-    updateTransportConfig(transports: ClientOptions['transports']): void;
+    updateTransportConfig(transports: ClientOptions['transports']): Promise<void>;
     init(): Promise<void>;
     ensureAuthenticated(reason: 'init' | 'room-op' | 'discovery'): Promise<void>;
     refreshRuntimeAuthToken(reason?: 'runtime-start' | 'managed-session'): Promise<void>;
-    get moqState(): string;
-    get moq(): MoQBundle | null;
-    onMoQReady(cb: () => void): () => void;
-    onMoQFailed(cb: () => void): () => void;
     refreshTransportCapabilities(reason?: string): Promise<void>;
-    onMoQObject(callback: (ns: string, name: string, obj: Uint8Array, meta: any) => void): () => void;
-    subscribeMoQPeer(connection: Connection): void;
-    subscribeMoQPeerNode(peerId: string, subscriptionKey?: string): void;
     connect(ticket: string, timeoutMs?: number, expectedDeviceId?: string | null, channelId?: string, options?: {
         admissionAlreadyPresented?: boolean;
         approvedScope?: string | null;
@@ -413,10 +271,6 @@ declare class Client {
     listChannels(): ChannelDescriptor[];
     onChannelStream(channelId: string, callback: (stream: IncomingStreamEvent) => boolean | void): () => void;
     onRoomJoinRequest(callback: (request: JoinRequest) => void): () => void;
-    isMoQDataReady(peerId: string | null): boolean;
-    sendMoQData(peerId: string | null, data: Uint8Array, options?: {
-        alreadyProtected?: boolean;
-    }): Promise<void>;
 }
 
 /**

package/dist/runtime/index.js

@@ -1 +1 @@
-export{a as runtimeFromCapability}from'../chunk-UILOGUOU.js';import'../chunk-ZA44REGI.js';export{a as isDeviceActive,c as isDeviceConnectable,b as isDeviceRoutable}from'../chunk-CK6WQV7J.js';export{i as ConnectionActor,f as ConnectionActorError,j as ConnectionActors,b as ConnectionController,t as IpcRuntimeAdapter,s as RuntimeClient,e as clog,q as concatRuntimeBytes,g as connectionActorKey,h as connectionActorKeyString,p as createJsonDecoder,l as createU32Decoder,n as decodeJsonPayload,o as encodeJsonFrame,m as encodeJsonPayload,k as encodeU32Frame,d as grantCorrelation,r as readRuntimeU32BE,c as renderCorrelation}from'../chunk-XAL4T6TB.js';export{a as classifyIpcFailure,b as isIpcUnavailable}from'../chunk-HUG5AX7R.js';import'../chunk-DUY34MGT.js';import'../chunk-R35AWMNY.js';export{s as BROWSER_CAPABILITIES,t as NATIVE_CAPABILITIES,q as RUNTIME_POLICY,v as browserCapabilities,x as capabilityProfile,u as cloneCapabilities,r as getRuntimePolicy,i as logTeardownTrace,w as statusCapabilities}from'../chunk-Z2IS6NH2.js';import'../chunk-AJQVMVYW.js';import'../chunk-WA434EWD.js';import'../chunk-HEAJ7ZUR.js';import'../chunk-7BJKDBLP.js';export{b as openRtcDebug,a as openRtcDebugEnabled,c as openRtcDebugInfo,d as openRtcDebugLog}from'../chunk-2L6ULC32.js';import'../chunk-2SUSPEC4.js';
+export{a as isDeviceActive,c as isDeviceConnectable,b as isDeviceRoutable}from'../chunk-CK6WQV7J.js';export{h as ConnectionActor,e as ConnectionActorError,i as ConnectionActors,a as ConnectionController,s as IpcRuntimeAdapter,r as RuntimeClient,d as clog,p as concatRuntimeBytes,f as connectionActorKey,g as connectionActorKeyString,o as createJsonDecoder,k as createU32Decoder,m as decodeJsonPayload,n as encodeJsonFrame,l as encodeJsonPayload,j as encodeU32Frame,c as grantCorrelation,q as readRuntimeU32BE,b as renderCorrelation}from'../chunk-2K47N3QP.js';import'../chunk-BGWJHPBC.js';import'../chunk-FEF3DPPB.js';export{q as BROWSER_CAPABILITIES,r as NATIVE_CAPABILITIES,o as RUNTIME_POLICY,t as browserCapabilities,v as capabilityProfile,s as cloneCapabilities,p as getRuntimePolicy,h as logTeardownTrace,d as openRtcDebug,c as openRtcDebugEnabled,e as openRtcDebugInfo,f as openRtcDebugLog,u as statusCapabilities}from'../chunk-GTHSRQ7Y.js';import'../chunk-XTYALGJN.js';import'../chunk-TYZS5LXQ.js';import'../chunk-OT7IPLZE.js';import'../chunk-OWKAJPOI.js';export{a as classifyIpcFailure,b as isIpcUnavailable}from'../chunk-72NEEJQG.js';export{a as runtimeFromCapability}from'../chunk-Z54XUIKZ.js';import'../chunk-ZA44REGI.js';import'../chunk-LLZT3MR6.js';import'../chunk-DUY34MGT.js';import'../chunk-CCCYE3XN.js';import'../chunk-N6LGTNUI.js';import'../chunk-JPBW67B3.js';import'../chunk-2GX6GB6L.js';

package/dist/server-browser.d.ts

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

package/dist/server-browser.js

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