openrtc 2.0.0-rc.8 → 2.0.0

package/dist/OpenRTCShared.d.ts

@@ -0,0 +1,250 @@
+import { R as RuntimePolicySnapshot, P as PeerReconciliationStats, a as RuntimeClient, b as PlutoRuntimeAssembly } from './assembly-q0jRRpsc.js';
+import { d as PeerSessionSnapshot, R as ResolvedPeerIdentity, C as ConnectDeviceResult, e as ConnectDeviceHooks, f as ConnectDeviceOptions, G as GrantScope } from './ITransport-WV6gGMnX.js';
+import { a as RuntimePeerState, b as RuntimePeerConnectOptions, C as Connection, c as RuntimePeerReadinessSnapshot, d as RuntimePeerHealth, R as RuntimeChannelDescriptor, e as RuntimePeerStreamOptions, f as RuntimeIncomingStream, g as RuntimeScopedChannelOptions, h as RuntimeDevice, i as RuntimeScopedLogicalChannel, j as RuntimeConnectionStateSnapshot, k as RuntimeApplicationPayloadReadinessOptions, l as RuntimeConnectionEvent, m as RuntimeManagedSessionOptions, n as RuntimeManagedSession, o as RuntimeDeviceStatusSnapshot, p as RuntimeDeviceConnectOptions, q as RuntimeLocalDeviceInfo, r as RuntimeLocalDeviceProfile, s as RuntimeRawConnection, t as RuntimeJoinRoomOptions, u as RuntimeRoomMember, A as AuthContext, v as RuntimeClientOptions } from './types-DVNSd5B9.js';
+import { R as RuntimeCapabilities, a as RuntimeCapabilityProfile } from './capabilities-BfZi4Cd7.js';
+
+type OpenRTCChannelConnectOptions = Omit<RuntimeScopedChannelOptions, 'scope' | 'deviceId' | 'ticket'> & {
+    /**
+     * Device selected from `client.devices.*`. Passing the device object lets
+     * OpenRTC reuse its current ticket for native and ticket-gated routes.
+     */
+    device?: string | RuntimeDevice;
+    deviceId?: string | null;
+    ticket?: string;
+    /**
+     * Logical channel lifecycle scope. Most app channels should use the default
+     * `session`; pass a custom scope only when you intentionally manage peer
+     * lifecycle separately from the channel.
+     */
+    scope?: RuntimeScopedChannelOptions['scope'];
+};
+type OpenRTCDeviceSessionOptions = Omit<RuntimeManagedSessionOptions, 'platform'> & {
+    /**
+     * Runtime host for the managed user-device session. Normal apps can omit
+     * this: `OpenRTC(...)` defaults to `web`, and `OpenRTC.native(...)` defaults
+     * to `native`.
+     */
+    platform?: RuntimeManagedSessionOptions['platform'];
+};
+interface OpenRTCDeviceNamespace {
+    startSession(options?: OpenRTCDeviceSessionOptions): Promise<RuntimeManagedSession>;
+    stopSession(options?: {
+        preserveBackendSession?: boolean;
+    }): Promise<void>;
+    list(): Promise<RuntimeDevice[]>;
+    listWithStatus(): Promise<RuntimeDeviceStatusSnapshot[]>;
+    watch(callback: (devices: RuntimeDevice[]) => void): () => void;
+    watchWithStatus(callback: (devices: RuntimeDeviceStatusSnapshot[]) => void): () => void;
+    connect(device: string | RuntimeDevice, options?: RuntimeDeviceConnectOptions): Promise<ConnectDeviceResult>;
+    /**
+     * @deprecated Use `devices.connect()`. Retry and route recovery are owned by
+     * OpenRTC; legacy consumer-provided connection hooks are ignored.
+     */
+    connectWithRetry(device: string | RuntimeDevice, hooks: ConnectDeviceHooks, options: ConnectDeviceOptions): Promise<ConnectDeviceResult>;
+    disconnect(deviceId: string): Promise<void>;
+    update(deviceId: string, updates: {
+        deviceName?: string;
+        capabilities?: RuntimeDevice['capabilities'];
+        metadata?: string;
+    }): Promise<void>;
+    delete(deviceId: string): Promise<void>;
+    localId(): Promise<string | null>;
+    localInfo(): Promise<RuntimeLocalDeviceInfo | null>;
+    localProfile(options?: {
+        deviceName?: string;
+        localDeviceId?: string | null;
+        platform?: 'native' | 'web';
+        userId?: string | null;
+    }): Promise<RuntimeLocalDeviceProfile>;
+    updateLocalName(deviceName: string): Promise<RuntimeLocalDeviceInfo | null>;
+}
+interface OpenRTCPeerNamespace {
+    watch(callback: (peers: RuntimePeerState[]) => void): () => void;
+    watchLifecycle(callback: (peers: RuntimePeerState[]) => void): () => void;
+    get(id: string): RuntimePeerState | undefined;
+    listConnected(): RuntimePeerState[];
+    connect(options: RuntimePeerConnectOptions): Promise<Connection>;
+    disconnect(id: string, scope?: string): Promise<void>;
+    forceDisconnect(id: string): Promise<void>;
+    session(id: string): Promise<PeerSessionSnapshot | null>;
+    sessions(): Promise<PeerSessionSnapshot[]>;
+    waitConnected(id: string, timeoutMs?: number): Promise<PeerSessionSnapshot | null>;
+    readiness(id: string, timeoutMs?: number): Promise<RuntimePeerReadinessSnapshot>;
+    health(id: string): Promise<RuntimePeerHealth>;
+    identity(id: string): Promise<ResolvedPeerIdentity>;
+    addScope(id: string, scope?: string): RuntimePeerState | undefined;
+    releaseScope(id: string, scope?: string): RuntimePeerState | undefined;
+    scopes(id: string): string[];
+    refresh(): Promise<RuntimePeerState[]>;
+}
+interface OpenRTCChannelNamespace {
+    register(descriptor: RuntimeChannelDescriptor): void;
+    unregister(channelId: string): void;
+    list(): RuntimeChannelDescriptor[];
+    openBi(id: string, channelId: string, options?: Omit<RuntimePeerStreamOptions, 'channelId'>): Promise<{
+        connection: Connection;
+        readable: ReadableStream<Uint8Array>;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    openUni(id: string, channelId: string, options?: Omit<RuntimePeerStreamOptions, 'channelId'>): Promise<{
+        connection: Connection;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    onIncoming(callback: (stream: RuntimeIncomingStream) => boolean | void): () => void;
+    onIncomingChannel(channelId: string, callback: (stream: RuntimeIncomingStream & {
+        channel: NonNullable<RuntimeIncomingStream['channel']>;
+    }) => boolean | void): () => void;
+    connect(options: OpenRTCChannelConnectOptions): Promise<RuntimeScopedLogicalChannel>;
+    connectScoped(options: RuntimeScopedChannelOptions): Promise<RuntimeScopedLogicalChannel>;
+}
+interface OpenRTCRoomNamespace {
+    create(roomId?: string): Promise<string>;
+    join(roomId: string, options?: RuntimeJoinRoomOptions): Promise<Connection[]>;
+    leave(roomId: string): Promise<void>;
+    watch(roomId: string, callback: (members: RuntimeRoomMember[]) => void): () => void;
+    members(roomId: string): Promise<RuntimeRoomMember[]>;
+}
+interface OpenRTCTicketNamespace {
+    raw(): Promise<string>;
+    share(options?: {
+        maxConnections?: number;
+    }): Promise<string>;
+    grant(scope: GrantScope, options?: {
+        maxConnections?: number;
+    }): Promise<string>;
+    revoke(scope: GrantScope): Promise<string[]>;
+}
+interface OpenRTCDiagnosticsNamespace {
+    status(): Promise<{
+        runtime: 'tauri' | 'browser' | 'unknown';
+        wasmLoaded: boolean;
+        localNodeId?: string;
+        userId?: string;
+    }>;
+    policy(): RuntimePolicySnapshot;
+    capabilities(): RuntimeCapabilities;
+    capabilityProfile(): RuntimeCapabilityProfile;
+    connectionStates(): Promise<RuntimeConnectionStateSnapshot[]>;
+    onConnectionStateChange(callback: (state: RuntimeConnectionStateSnapshot) => void): Promise<() => void> | (() => void);
+    connections(): Connection[];
+    applicationReadyConnections(options?: RuntimeApplicationPayloadReadinessOptions): Connection[];
+    onConnection(callback: (connection: Connection) => void): () => void;
+    onDisconnection(callback: (connection: Connection) => void): () => void;
+    onConnectionEvent(callback: (event: RuntimeConnectionEvent) => void): () => void;
+    forceReconnectSnapshot(): void;
+    peerReconciliation(): Readonly<PeerReconciliationStats>;
+}
+interface OpenRTCAdvancedNamespace {
+    readonly runtime: RuntimeClient;
+    readonly assembly: PlutoRuntimeAssembly;
+    nodeId(): Promise<string>;
+    nodeIdFromTicket(ticket: string): Promise<string | null>;
+    endpointTicket(): Promise<string>;
+    connectRaw(target: {
+        ticket: string;
+        timeoutMs?: number;
+    }): Promise<RuntimeRawConnection>;
+    openBi(nodeId: string): Promise<{
+        readable: ReadableStream<Uint8Array>;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    openUni(nodeId: string): Promise<WritableStream<Uint8Array>>;
+    isConnected(nodeId: string): Promise<boolean>;
+    disconnectNode(nodeId: string): Promise<void>;
+    setAutoConnectExcluded(deviceId: string, excluded: boolean): Promise<void>;
+    notifyNetworkChange(reason?: string): Promise<void>;
+}
+/**
+ * OpenRTCClient extends RuntimeClient with auth helpers that were
+ * previously only available on PlutoRuntimeAssembly.
+ *
+ * This is the unified type returned by OpenRTC() and OpenRTC.native().
+ */
+interface OpenRTCClient extends RuntimeClient {
+    readonly devices: OpenRTCDeviceNamespace;
+    readonly peers: OpenRTCPeerNamespace;
+    readonly channels: OpenRTCChannelNamespace;
+    readonly rooms: OpenRTCRoomNamespace;
+    readonly tickets: OpenRTCTicketNamespace;
+    readonly diagnostics: OpenRTCDiagnosticsNamespace;
+    readonly advanced: OpenRTCAdvancedNamespace;
+    /** @deprecated Use setAuth() instead */
+    setAuthContext(context: AuthContext | null): Promise<void>;
+    /** Set auth context for the runtime */
+    setAuth(context: AuthContext | null): Promise<void>;
+    /** Sync Pluto-hosted auth to the runtime */
+    syncPlutoAuth(options?: {
+        userId?: string | null;
+        forceRefresh?: boolean;
+    }): Promise<void>;
+    /** Bind Pluto auth host to auto-sync on token changes */
+    bindPlutoAuthHost(): () => void;
+    /** Sign in via Pluto SSO */
+    signIn(): Promise<void>;
+    /** Sign out and clear auth context */
+    signOut(): Promise<void>;
+    /**
+     * @deprecated Use `client.devices.startSession(...)` for the public
+     * user-device avenue lifecycle. This top-level method remains for
+     * RuntimeClient compatibility and advanced integrations.
+     */
+    startManagedSession(options: RuntimeManagedSessionOptions): Promise<RuntimeManagedSession>;
+    /**
+     * @deprecated Use `client.devices.stopSession(...)` for the public
+     * user-device avenue lifecycle.
+     */
+    stopManagedSession(options?: {
+        preserveBackendSession?: boolean;
+    }): Promise<void>;
+    /** @deprecated Use `client.rooms.create(...)`. */
+    createRoom(roomId?: string): Promise<string>;
+    /** @deprecated Use `client.rooms.join(...)`. */
+    joinRoom(roomId: string, options?: RuntimeJoinRoomOptions): Promise<Connection[]>;
+    /** @deprecated Use `client.rooms.leave(...)`. */
+    leaveRoom(roomId: string): Promise<void>;
+    /** @deprecated Use `client.rooms.watch(...)`. */
+    watchRoom(roomId: string, callback: (members: RuntimeRoomMember[]) => void): () => void;
+    /** @deprecated Use `client.rooms.members(...)`. */
+    getRoomMembers(roomId: string): Promise<RuntimeRoomMember[]>;
+    /** @deprecated Use `client.tickets.raw(...)`. */
+    getInvite(): Promise<string>;
+    /** @deprecated Use `client.tickets.raw(...)`. */
+    getTicket(): Promise<string>;
+    /** @deprecated Use `client.tickets.share(...)` or `client.tickets.grant(...)`. */
+    getTicketWithToken(scope: GrantScope, maxConnections?: number): Promise<string>;
+    /** @deprecated Use `client.tickets.revoke(...)`. */
+    revokeTokensByScope(scope: GrantScope): Promise<string[]>;
+    /** @deprecated Use `client.peers.connect(...)`. */
+    connectPeer(options: RuntimePeerConnectOptions): Promise<Connection>;
+    /** @deprecated Use `client.peers.connect(...)`. */
+    connectTo(options: RuntimePeerConnectOptions): Promise<Connection>;
+    /** @deprecated Use `client.peers.waitConnected(...)`. */
+    waitForConnectedPeer(id: string, timeoutMs?: number): Promise<PeerSessionSnapshot | null>;
+    /** @deprecated Use `client.channels.connect(...)`; use `client.channels.connectScoped(...)` only for custom lifecycle scopes. */
+    connectScopedChannel(options: RuntimeScopedChannelOptions): Promise<RuntimeScopedLogicalChannel>;
+    /** @deprecated Use `client.channels.openBi(...)`. */
+    openPeerBi(id: string, options?: RuntimePeerStreamOptions): Promise<{
+        connection: Connection;
+        readable: ReadableStream<Uint8Array>;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    /** @deprecated Use `client.channels.openUni(...)`. */
+    openPeerUni(id: string, options?: RuntimePeerStreamOptions): Promise<{
+        connection: Connection;
+        writable: WritableStream<Uint8Array>;
+    }>;
+    /**
+     * Access to the underlying PlutoRuntimeAssembly for backward compatibility.
+     * @deprecated Access methods directly on the client instead.
+     */
+    readonly runtime: RuntimeClient;
+    /**
+     * Access to the underlying PlutoRuntimeAssembly for backward compatibility.
+     * @internal
+     */
+    readonly _assembly: PlutoRuntimeAssembly;
+}
+declare function resolveOptions(options: RuntimeClientOptions): RuntimeClientOptions;
+declare function wrapAssembly(assembly: PlutoRuntimeAssembly, defaultManagedSessionPlatform: RuntimeManagedSessionOptions['platform']): OpenRTCClient;
+
+export { type OpenRTCAdvancedNamespace, type OpenRTCChannelConnectOptions, type OpenRTCChannelNamespace, type OpenRTCClient, type OpenRTCDeviceNamespace, type OpenRTCDeviceSessionOptions, type OpenRTCDiagnosticsNamespace, type OpenRTCPeerNamespace, type OpenRTCRoomNamespace, type OpenRTCTicketNamespace, resolveOptions, wrapAssembly };

package/dist/OpenRTCShared.js

@@ -0,0 +1 @@
+import {n}from'./chunk-KJTJLLJE.js';import'./chunk-45WBH7E3.js';import'./chunk-NRXEG5GQ.js';function O(i){let s=n({...i});if("auth"in i&&!i.authMode){let n=i.auth;s.authMode=n==="none"?"anonymous":n;}if("identity"in i){let n=i.identity,r=n==="temporary"?"ephemeral":n;!i.deviceIdPersistence&&!i.nodeIdPersistence&&(s.deviceIdPersistence=r),!i.endpointIdPersistence&&!i.nodeIdPersistence&&(s.endpointIdPersistence=r);}return "namespace"in i&&!i.storagePrefix&&(s.storagePrefix=i.namespace),"privacy"in i&&i.strictMode===void 0&&(s.strictMode=!!i.privacy),s}function I(i,s){let n=i.runtime,r=Object.create(n),l=async e=>{if(typeof e!="string")return e;let o=(await n.listDevices()).find(c=>c.deviceId===e);if(!o)throw new Error(`OpenRTC device '${e}' is not currently discoverable.`);return o},u=async e=>({...e,localDeviceId:e?.localDeviceId??await n.getLocalDeviceId()??""}),R=async e=>{let{device:t,scope:o,...c}=e,a=c.deviceId??(typeof t=="string"?t:t?.deviceId)??null,m=c.ticket??(typeof t=="string"?void 0:t?.ticket);a&&!m&&(m=(await l(a).catch(()=>null))?.ticket);let d={...c,scope:o??"session"};return a&&(d.deviceId=a),m&&(d.ticket=m),d},g={list:()=>n.listDevices(),startSession:(e={})=>n.startManagedSession({...e,platform:e.platform??s}),stopSession:e=>n.stopManagedSession(e),listWithStatus:()=>n.listDevicesWithStatus(),watch:e=>n.watchDevices(e),watchWithStatus:e=>n.watchDevicesWithStatus(e),connect:async(e,t)=>n.connectDevice(await l(e),await u(t)),connectWithRetry:async(e,t,o)=>n.connectDeviceWithRetry(await l(e),t,o),disconnect:e=>n.disconnectDevice(e),update:(e,t)=>n.updateDevice(e,t),delete:e=>n.deleteDevice(e),localId:()=>n.getLocalDeviceId(),localInfo:()=>n.getLocalDeviceInfo(),localProfile:e=>n.getLocalDeviceProfile(e),updateLocalName:e=>n.updateLocalDeviceName(e)},v={watch:e=>n.watchPeerStates(e),watchLifecycle:e=>n.watchPeerLifecycle(e),get:e=>n.getPeerState(e),listConnected:()=>n.listConnectedPeers(),connect:e=>n.connectPeer(e),disconnect:(e,t)=>n.disconnectPeer(e,t),forceDisconnect:e=>n.forceDisconnectPeer(e),session:e=>n.getPeerSession(e),sessions:()=>n.listPeerSessions(),waitConnected:(e,t)=>n.waitForConnectedPeer(e,t),readiness:(e,t)=>n.getPeerReadiness(e,t),health:e=>n.getPeerHealth(e),identity:e=>n.resolvePeerIdentity(e),addScope:(e,t)=>n.addPeerScope(e,t),releaseScope:(e,t)=>n.releasePeerScope(e,t),scopes:e=>n.getPeerScopes(e),refresh:()=>n.refreshPeerSnapshot()},C={register:e=>n.registerChannel(e),unregister:e=>n.unregisterChannel(e),list:()=>n.listChannels(),openBi:(e,t,o)=>n.openPeerBi(e,{...o,channelId:t}),openUni:(e,t,o)=>n.openPeerUni(e,{...o,channelId:t}),onIncoming:e=>n.onIncomingStream(e),onIncomingChannel:(e,t)=>n.onIncomingChannelStream(e,o=>{if(o.channel)return t(o)}),connect:async e=>n.connectScopedChannel(await R(e)),connectScoped:e=>n.connectScopedChannel(e)},P={create:e=>n.createRoom(e),join:(e,t)=>n.joinRoom(e,t),leave:e=>n.leaveRoom(e),watch:(e,t)=>n.watchRoom(e,t),members:e=>n.getRoomMembers(e)},h={raw:()=>n.getInvite(),share:e=>n.getTicketWithToken("share",e?.maxConnections??1),grant:(e,t)=>n.getTicketWithToken(e,t?.maxConnections??0),revoke:e=>n.revokeTokensByScope(e)},S={status:()=>n.getRuntimeStatus(),policy:()=>n.getRuntimePolicy(),capabilities:()=>n.getRuntimeCapabilities(),capabilityProfile:()=>n.getCapabilityProfile(),connectionStates:()=>n.getConnectionStates(),onConnectionStateChange:e=>n.onConnectionStateChange(e),connections:()=>n.getConnections(),applicationReadyConnections:e=>n.getApplicationReadyConnections(e),onConnection:e=>n.onConnection(e),onDisconnection:e=>n.onDisconnection(e),onConnectionEvent:e=>n.onConnectionEvent(e),forceReconnectSnapshot:()=>n.forceReconnectSnapshot(),peerReconciliation:()=>n.getPeerReconciliationStats()},b={runtime:n,assembly:i,nodeId:()=>n.getNodeId(),nodeIdFromTicket:e=>n.getNodeIdFromTicket(e),endpointTicket:()=>n.getEndpointTicket(),connectRaw:e=>n.connectRaw(e),openBi:e=>n.openBi(e),openUni:e=>n.openUni(e),isConnected:e=>n.isConnected(e),disconnectNode:e=>n.disconnectNode(e),setAutoConnectExcluded:(e,t)=>n.setAutoConnectExcluded(e,t),notifyNetworkChange:e=>n.notifyNetworkChange(e)};return Object.defineProperties(r,{devices:{get:()=>g,enumerable:true},peers:{get:()=>v,enumerable:true},channels:{get:()=>C,enumerable:true},rooms:{get:()=>P,enumerable:true},tickets:{get:()=>h,enumerable:true},diagnostics:{get:()=>S,enumerable:true},advanced:{get:()=>b,enumerable:true},setAuth:{value:e=>i.setAuthContext(e),enumerable:true,writable:true,configurable:true},setAuthContext:{value:e=>i.setAuthContext(e),enumerable:true,writable:true,configurable:true},syncPlutoAuth:{value:e=>i.syncPlutoAuth(e),enumerable:true,writable:true,configurable:true},bindPlutoAuthHost:{value:()=>i.bindPlutoAuthHost(),enumerable:true,writable:true,configurable:true},signIn:{value:()=>i.signInWithPluto(),enumerable:true,writable:true,configurable:true},signOut:{value:()=>i.signOut(),enumerable:true,writable:true,configurable:true},runtime:{get:()=>n,enumerable:false},_assembly:{get:()=>i,enumerable:false}}),r}export{O as resolveOptions,I as wrapAssembly};

package/dist/WasmBridge-5GYKXPXK.js

@@ -0,0 +1 @@
+export{y as WasmBridge}from'./chunk-VOCOZ57Q.js';import'./chunk-AG2F6MOB.js';import'./chunk-CWGKLGJZ.js';import'./chunk-KJTJLLJE.js';import'./chunk-45WBH7E3.js';import'./chunk-NRXEG5GQ.js';

package/dist/{OpenRTCShared-BswnbjpG.d.ts → assembly-q0jRRpsc.d.ts}

@@ -1,7 +1,6 @@
-import { G as GrantScope, I as ISignalingBackend, X as ConnectDeviceHooks, Y as ConnectDeviceOptions, Z as ConnectDeviceResult, M as ManagedConnectionRecord, P as PeerSessionSnapshot, d as ResolvedPeerIdentity, _ as AppLimits, k as NativeConnectParams, l as NativeConnectResult, E as ExplicitFileDataSendParams } from './types-BHePJWbM.js';
-import { A as AuthContext } from './IEngineBridge-BbsT8hof.js';
-import { b as RuntimePeerState, c as RuntimeConnectionStateSnapshot, d as RuntimePeerReadinessSnapshot, e as RuntimePeerConnectOptions, C as Connection, f as RuntimeIncomingStream, a as RuntimeClientOptions, g as RuntimeAuthIdentity, h as RuntimeLocalDeviceInfo, i as RuntimeLocalDeviceProfile, j as RuntimeDevice, k as RuntimeManagedSessionOptions, l as RuntimeManagedSession, m as RuntimeDeviceStatusSnapshot, n as RuntimeDeviceConnectOptions, o as RuntimeSession, p as RuntimeJoinRoomOptions, q as RuntimeRoomMember, r as RuntimeConnectionTarget, s as RuntimeScopedChannelOptions, t as RuntimeScopedLogicalChannel, u as RuntimePeerStreamOptions, v as RuntimeRawConnection, R as RuntimeChannelDescriptor, w as RuntimePresenceLoopOptions, x as RuntimePeerHealth, y as RuntimeApplicationPayloadReadinessOptions, z as RuntimeConnectionEvent } from './types-D0pqNSOf.js';
-import { R as RuntimeCapabilities, a as RuntimeCapabilityProfile } from './capabilities-YSskrE8H.js';
+import { a as RuntimePeerState, j as RuntimeConnectionStateSnapshot, c as RuntimePeerReadinessSnapshot, b as RuntimePeerConnectOptions, C as Connection, f as RuntimeIncomingStream, v as RuntimeClientOptions, z as RuntimeAuthIdentity, A as AuthContext, q as RuntimeLocalDeviceInfo, r as RuntimeLocalDeviceProfile, I as IrohBrowserProtocolStore, w as IrohNamespaceDescriptor, x as IrohMutationReceipt, y as IrohDocEntry, h as RuntimeDevice, m as RuntimeManagedSessionOptions, n as RuntimeManagedSession, o as RuntimeDeviceStatusSnapshot, p as RuntimeDeviceConnectOptions, B as RuntimeSession, t as RuntimeJoinRoomOptions, u as RuntimeRoomMember, D as RuntimeConnectionTarget, g as RuntimeScopedChannelOptions, i as RuntimeScopedLogicalChannel, e as RuntimePeerStreamOptions, s as RuntimeRawConnection, R as RuntimeChannelDescriptor, E as RuntimePresenceLoopOptions, d as RuntimePeerHealth, k as RuntimeApplicationPayloadReadinessOptions, l as RuntimeConnectionEvent } from './types-DVNSd5B9.js';
+import { G as GrantScope, I as ISignalingBackend, e as ConnectDeviceHooks, f as ConnectDeviceOptions, C as ConnectDeviceResult, M as ManagedConnectionRecord, d as PeerSessionSnapshot, R as ResolvedPeerIdentity, a4 as AppLimits, N as NativeConnectParams, q as NativeConnectResult, E as ExplicitFileDataSendParams } from './ITransport-WV6gGMnX.js';
+import { R as RuntimeCapabilities, a as RuntimeCapabilityProfile } from './capabilities-BfZi4Cd7.js';
 
 /**
  * Coalesced peer reconciliation scheduler and full reconcile orchestration.
@@ -230,7 +229,6 @@ interface RuntimePolicySnapshot {
         nativeStartRetryWindowMs: number;
         nativeStartRetryMinDelayMs: number;
         nativeStartRetryMaxDelayMs: number;
-        reconciliationIntervalMs: number;
         deviceStatusRefreshDebounceMs: number;
     };
     browserAutoConnect: {
@@ -281,7 +279,6 @@ declare class RuntimeClient {
     private static readonly NATIVE_START_RETRY_WINDOW_MS;
     private static readonly NATIVE_START_RETRY_MIN_DELAY_MS;
     private static readonly NATIVE_START_RETRY_MAX_DELAY_MS;
-    private static readonly MANAGED_RECONCILIATION_INTERVAL_MS;
     private static readonly DEVICE_STATUS_REFRESH_DEBOUNCE_MS;
     private static readonly MANAGED_USER_DEVICE_SCOPE;
     static readonly MANAGED_FRIEND_SCOPE: GrantScope;
@@ -298,7 +295,6 @@ declare class RuntimeClient {
     private managedSessionStartInFlight;
     private terminalShutdown;
     private readonly managedReconciliationTasks;
-    private managedReconciliationTimer;
     private readonly managedReconciliationFollowupTimers;
     /**
      * The one per-`{scope, peerNodeId}` observer-side dial coalescer. It is
@@ -367,6 +363,39 @@ declare class RuntimeClient {
     getManagedNodeId(options?: {
         initializeIfMissing?: boolean;
     }): Promise<string | null>;
+    /**
+     * Enable upstream Iroh docs, blobs, and gossip on this runtime's existing
+     * browser endpoint. The host store supplies durable IndexedDB operations;
+     * no second endpoint, router, presence loop, or reconnect owner is created.
+     */
+    initializeIrohProtocols(store: IrohBrowserProtocolStore): Promise<void>;
+    createIrohNamespace(options?: {
+        generation?: number;
+        shareRevision?: number;
+    }): Promise<IrohNamespaceDescriptor>;
+    importIrohTicket(ticket: string, options?: {
+        generation?: number;
+        shareRevision?: number;
+    }): Promise<string>;
+    shareIrohNamespace(namespaceId: string, options?: {
+        writable?: boolean;
+    }): Promise<string>;
+    removeIrohNamespace(namespaceId: string, options?: {
+        generation?: number;
+        shareRevision?: number;
+    }): Promise<void>;
+    putIrohBytes(namespaceId: string, key: Uint8Array, value: Uint8Array): Promise<IrohMutationReceipt>;
+    setIrohHash(namespaceId: string, key: Uint8Array, contentHash: string, contentLength: number): Promise<string>;
+    deleteIrohPrefix(namespaceId: string, prefix: Uint8Array): Promise<{
+        removed: number;
+        operationId: string;
+    }>;
+    queryIrohNamespace(namespaceId: string, keyPrefix?: Uint8Array<ArrayBuffer>): Promise<IrohDocEntry[]>;
+    hydrateIrohBlob(contentHash: string): Promise<void>;
+    acknowledgeIrohOutbox(operationId: string): Promise<void>;
+    flushIrohProtocols(): Promise<void>;
+    private persistentIrohProtocolBackend;
+    private assertProtocolCounter;
     getTicket(): Promise<string>;
     /**
      * Generate a session-scoped endpoint ticket with an embedded random token.
@@ -378,6 +407,19 @@ declare class RuntimeClient {
      * @param maxConnections 0 = unlimited.
      */
     getTicketWithToken(grantScope: GrantScope, maxConnections?: number): Promise<string>;
+    /**
+     * Register a product-issued admission token with the active runtime.
+     *
+     * Product code supplies the durable authorization decision, while OpenRTC
+     * remains the sole owner of the native/WASM admission registry. Restricted
+     * grants should always include their server-issued expiry.
+     */
+    registerAdmissionToken(input: {
+        token: string;
+        scope: GrantScope;
+        maxConnections?: number;
+        expiresAtMs?: number;
+    }): Promise<void>;
     /** Revoke all session tokens that match the given scope. */
     revokeTokensByScope(grantScope: GrantScope): Promise<string[]>;
     private revokeTokensByScopeInternal;
@@ -675,6 +717,7 @@ declare class RuntimeClient {
 type RuntimeAdapterWithAuth = ISignalingBackend & {
     setAuthContext?: (context: AuthContext | null) => Promise<void> | void;
 };
+type RuntimeFactoryOptions = RuntimeClientOptions;
 interface PlutoRuntimeAssembly<TBackend extends RuntimeAdapterWithAuth = RuntimeAdapterWithAuth> {
     runtime: RuntimeClient;
     identity: any;
@@ -699,246 +742,4 @@ interface PlutoRuntimeAssembly<TBackend extends RuntimeAdapterWithAuth = Runtime
     setAutoConnectExcluded(deviceId: string, excluded: boolean): Promise<void>;
 }
 
-type OpenRTCChannelConnectOptions = Omit<RuntimeScopedChannelOptions, 'scope' | 'deviceId' | 'ticket'> & {
-    /**
-     * Device selected from `client.devices.*`. Passing the device object lets
-     * OpenRTC reuse its current ticket for native and ticket-gated routes.
-     */
-    device?: string | RuntimeDevice;
-    deviceId?: string | null;
-    ticket?: string;
-    /**
-     * Logical channel lifecycle scope. Most app channels should use the default
-     * `session`; pass a custom scope only when you intentionally manage peer
-     * lifecycle separately from the channel.
-     */
-    scope?: RuntimeScopedChannelOptions['scope'];
-};
-type OpenRTCDeviceSessionOptions = Omit<RuntimeManagedSessionOptions, 'platform'> & {
-    /**
-     * Runtime host for the managed user-device session. Normal apps can omit
-     * this: `OpenRTC(...)` defaults to `web`, and `OpenRTC.native(...)` defaults
-     * to `native`.
-     */
-    platform?: RuntimeManagedSessionOptions['platform'];
-};
-interface OpenRTCDeviceNamespace {
-    startSession(options?: OpenRTCDeviceSessionOptions): Promise<RuntimeManagedSession>;
-    stopSession(options?: {
-        preserveBackendSession?: boolean;
-    }): Promise<void>;
-    list(): Promise<RuntimeDevice[]>;
-    listWithStatus(): Promise<RuntimeDeviceStatusSnapshot[]>;
-    watch(callback: (devices: RuntimeDevice[]) => void): () => void;
-    watchWithStatus(callback: (devices: RuntimeDeviceStatusSnapshot[]) => void): () => void;
-    connect(device: string | RuntimeDevice, options?: RuntimeDeviceConnectOptions): Promise<ConnectDeviceResult>;
-    /**
-     * @deprecated Use `devices.connect()`. Retry and route recovery are owned by
-     * OpenRTC; legacy consumer-provided connection hooks are ignored.
-     */
-    connectWithRetry(device: string | RuntimeDevice, hooks: ConnectDeviceHooks, options: ConnectDeviceOptions): Promise<ConnectDeviceResult>;
-    disconnect(deviceId: string): Promise<void>;
-    update(deviceId: string, updates: {
-        deviceName?: string;
-        capabilities?: RuntimeDevice['capabilities'];
-        metadata?: string;
-    }): Promise<void>;
-    delete(deviceId: string): Promise<void>;
-    localId(): Promise<string | null>;
-    localInfo(): Promise<RuntimeLocalDeviceInfo | null>;
-    localProfile(options?: {
-        deviceName?: string;
-        localDeviceId?: string | null;
-        platform?: 'native' | 'web';
-        userId?: string | null;
-    }): Promise<RuntimeLocalDeviceProfile>;
-    updateLocalName(deviceName: string): Promise<RuntimeLocalDeviceInfo | null>;
-}
-interface OpenRTCPeerNamespace {
-    watch(callback: (peers: RuntimePeerState[]) => void): () => void;
-    watchLifecycle(callback: (peers: RuntimePeerState[]) => void): () => void;
-    get(id: string): RuntimePeerState | undefined;
-    listConnected(): RuntimePeerState[];
-    connect(options: RuntimePeerConnectOptions): Promise<Connection>;
-    disconnect(id: string, scope?: string): Promise<void>;
-    forceDisconnect(id: string): Promise<void>;
-    session(id: string): Promise<PeerSessionSnapshot | null>;
-    sessions(): Promise<PeerSessionSnapshot[]>;
-    waitConnected(id: string, timeoutMs?: number): Promise<PeerSessionSnapshot | null>;
-    readiness(id: string, timeoutMs?: number): Promise<RuntimePeerReadinessSnapshot>;
-    health(id: string): Promise<RuntimePeerHealth>;
-    identity(id: string): Promise<ResolvedPeerIdentity>;
-    addScope(id: string, scope?: string): RuntimePeerState | undefined;
-    releaseScope(id: string, scope?: string): RuntimePeerState | undefined;
-    scopes(id: string): string[];
-    refresh(): Promise<RuntimePeerState[]>;
-}
-interface OpenRTCChannelNamespace {
-    register(descriptor: RuntimeChannelDescriptor): void;
-    unregister(channelId: string): void;
-    list(): RuntimeChannelDescriptor[];
-    openBi(id: string, channelId: string, options?: Omit<RuntimePeerStreamOptions, 'channelId'>): Promise<{
-        connection: Connection;
-        readable: ReadableStream<Uint8Array>;
-        writable: WritableStream<Uint8Array>;
-    }>;
-    openUni(id: string, channelId: string, options?: Omit<RuntimePeerStreamOptions, 'channelId'>): Promise<{
-        connection: Connection;
-        writable: WritableStream<Uint8Array>;
-    }>;
-    onIncoming(callback: (stream: RuntimeIncomingStream) => boolean | void): () => void;
-    onIncomingChannel(channelId: string, callback: (stream: RuntimeIncomingStream & {
-        channel: NonNullable<RuntimeIncomingStream['channel']>;
-    }) => boolean | void): () => void;
-    connect(options: OpenRTCChannelConnectOptions): Promise<RuntimeScopedLogicalChannel>;
-    connectScoped(options: RuntimeScopedChannelOptions): Promise<RuntimeScopedLogicalChannel>;
-}
-interface OpenRTCRoomNamespace {
-    create(roomId?: string): Promise<string>;
-    join(roomId: string, options?: RuntimeJoinRoomOptions): Promise<Connection[]>;
-    leave(roomId: string): Promise<void>;
-    watch(roomId: string, callback: (members: RuntimeRoomMember[]) => void): () => void;
-    members(roomId: string): Promise<RuntimeRoomMember[]>;
-}
-interface OpenRTCTicketNamespace {
-    raw(): Promise<string>;
-    share(options?: {
-        maxConnections?: number;
-    }): Promise<string>;
-    grant(scope: GrantScope, options?: {
-        maxConnections?: number;
-    }): Promise<string>;
-    revoke(scope: GrantScope): Promise<string[]>;
-}
-interface OpenRTCDiagnosticsNamespace {
-    status(): Promise<{
-        runtime: 'tauri' | 'browser' | 'unknown';
-        wasmLoaded: boolean;
-        localNodeId?: string;
-        userId?: string;
-    }>;
-    policy(): RuntimePolicySnapshot;
-    capabilities(): RuntimeCapabilities;
-    capabilityProfile(): RuntimeCapabilityProfile;
-    connectionStates(): Promise<RuntimeConnectionStateSnapshot[]>;
-    onConnectionStateChange(callback: (state: RuntimeConnectionStateSnapshot) => void): Promise<() => void> | (() => void);
-    connections(): Connection[];
-    applicationReadyConnections(options?: RuntimeApplicationPayloadReadinessOptions): Connection[];
-    onConnection(callback: (connection: Connection) => void): () => void;
-    onDisconnection(callback: (connection: Connection) => void): () => void;
-    onConnectionEvent(callback: (event: RuntimeConnectionEvent) => void): () => void;
-    forceReconnectSnapshot(): void;
-    peerReconciliation(): Readonly<PeerReconciliationStats>;
-}
-interface OpenRTCAdvancedNamespace {
-    readonly runtime: RuntimeClient;
-    readonly assembly: PlutoRuntimeAssembly;
-    nodeId(): Promise<string>;
-    nodeIdFromTicket(ticket: string): Promise<string | null>;
-    endpointTicket(): Promise<string>;
-    connectRaw(target: {
-        ticket: string;
-        timeoutMs?: number;
-    }): Promise<RuntimeRawConnection>;
-    openBi(nodeId: string): Promise<{
-        readable: ReadableStream<Uint8Array>;
-        writable: WritableStream<Uint8Array>;
-    }>;
-    openUni(nodeId: string): Promise<WritableStream<Uint8Array>>;
-    isConnected(nodeId: string): Promise<boolean>;
-    disconnectNode(nodeId: string): Promise<void>;
-    setAutoConnectExcluded(deviceId: string, excluded: boolean): Promise<void>;
-    notifyNetworkChange(reason?: string): Promise<void>;
-}
-/**
- * OpenRTCClient extends RuntimeClient with auth helpers that were
- * previously only available on PlutoRuntimeAssembly.
- *
- * This is the unified type returned by OpenRTC() and OpenRTC.native().
- */
-interface OpenRTCClient extends RuntimeClient {
-    readonly devices: OpenRTCDeviceNamespace;
-    readonly peers: OpenRTCPeerNamespace;
-    readonly channels: OpenRTCChannelNamespace;
-    readonly rooms: OpenRTCRoomNamespace;
-    readonly tickets: OpenRTCTicketNamespace;
-    readonly diagnostics: OpenRTCDiagnosticsNamespace;
-    readonly advanced: OpenRTCAdvancedNamespace;
-    /** @deprecated Use setAuth() instead */
-    setAuthContext(context: AuthContext | null): Promise<void>;
-    /** Set auth context for the runtime */
-    setAuth(context: AuthContext | null): Promise<void>;
-    /** Sync Pluto-hosted auth to the runtime */
-    syncPlutoAuth(options?: {
-        userId?: string | null;
-        forceRefresh?: boolean;
-    }): Promise<void>;
-    /** Bind Pluto auth host to auto-sync on token changes */
-    bindPlutoAuthHost(): () => void;
-    /** Sign in via Pluto SSO */
-    signIn(): Promise<void>;
-    /** Sign out and clear auth context */
-    signOut(): Promise<void>;
-    /**
-     * @deprecated Use `client.devices.startSession(...)` for the public
-     * user-device avenue lifecycle. This top-level method remains for
-     * RuntimeClient compatibility and advanced integrations.
-     */
-    startManagedSession(options: RuntimeManagedSessionOptions): Promise<RuntimeManagedSession>;
-    /**
-     * @deprecated Use `client.devices.stopSession(...)` for the public
-     * user-device avenue lifecycle.
-     */
-    stopManagedSession(options?: {
-        preserveBackendSession?: boolean;
-    }): Promise<void>;
-    /** @deprecated Use `client.rooms.create(...)`. */
-    createRoom(roomId?: string): Promise<string>;
-    /** @deprecated Use `client.rooms.join(...)`. */
-    joinRoom(roomId: string, options?: RuntimeJoinRoomOptions): Promise<Connection[]>;
-    /** @deprecated Use `client.rooms.leave(...)`. */
-    leaveRoom(roomId: string): Promise<void>;
-    /** @deprecated Use `client.rooms.watch(...)`. */
-    watchRoom(roomId: string, callback: (members: RuntimeRoomMember[]) => void): () => void;
-    /** @deprecated Use `client.rooms.members(...)`. */
-    getRoomMembers(roomId: string): Promise<RuntimeRoomMember[]>;
-    /** @deprecated Use `client.tickets.raw(...)`. */
-    getInvite(): Promise<string>;
-    /** @deprecated Use `client.tickets.raw(...)`. */
-    getTicket(): Promise<string>;
-    /** @deprecated Use `client.tickets.share(...)` or `client.tickets.grant(...)`. */
-    getTicketWithToken(scope: GrantScope, maxConnections?: number): Promise<string>;
-    /** @deprecated Use `client.tickets.revoke(...)`. */
-    revokeTokensByScope(scope: GrantScope): Promise<string[]>;
-    /** @deprecated Use `client.peers.connect(...)`. */
-    connectPeer(options: RuntimePeerConnectOptions): Promise<Connection>;
-    /** @deprecated Use `client.peers.connect(...)`. */
-    connectTo(options: RuntimePeerConnectOptions): Promise<Connection>;
-    /** @deprecated Use `client.peers.waitConnected(...)`. */
-    waitForConnectedPeer(id: string, timeoutMs?: number): Promise<PeerSessionSnapshot | null>;
-    /** @deprecated Use `client.channels.connect(...)`; use `client.channels.connectScoped(...)` only for custom lifecycle scopes. */
-    connectScopedChannel(options: RuntimeScopedChannelOptions): Promise<RuntimeScopedLogicalChannel>;
-    /** @deprecated Use `client.channels.openBi(...)`. */
-    openPeerBi(id: string, options?: RuntimePeerStreamOptions): Promise<{
-        connection: Connection;
-        readable: ReadableStream<Uint8Array>;
-        writable: WritableStream<Uint8Array>;
-    }>;
-    /** @deprecated Use `client.channels.openUni(...)`. */
-    openPeerUni(id: string, options?: RuntimePeerStreamOptions): Promise<{
-        connection: Connection;
-        writable: WritableStream<Uint8Array>;
-    }>;
-    /**
-     * Access to the underlying PlutoRuntimeAssembly for backward compatibility.
-     * @deprecated Access methods directly on the client instead.
-     */
-    readonly runtime: RuntimeClient;
-    /**
-     * Access to the underlying PlutoRuntimeAssembly for backward compatibility.
-     * @internal
-     */
-    readonly _assembly: PlutoRuntimeAssembly;
-}
-
-export { DriveGrantActorError as D, type OpenRTCPeerNamespace as O, type PeerReconciliationStats as P, RuntimeClient as R, type OpenRTCChannelNamespace as a, type OpenRTCDiagnosticsNamespace as b, type OpenRTCDeviceNamespace as c, type OpenRTCClient as d, OPENRTC_RUNTIME_POLICY as e, type RuntimePolicySnapshot as f, type DriveGrantActorErrorKind as g, DriveGrantActorHandle as h, type DriveGrantActorHandleOptions as i, DriveGrantActorRegistry as j, type DriveGrantActorState as k, type DriveGrantClose as l, type DriveGrantDial as m, type DriveGrantConnectionKey as n, type DriveGrantLogicalChannelHandle as o, type DriveGrantPreferredTransport as p, getRuntimePolicy as q, driveGrantConnectionKey as r, driveGrantConnectionKeyToString as s };
+export { DriveGrantActorError as D, OPENRTC_RUNTIME_POLICY as O, type PeerReconciliationStats as P, type RuntimePolicySnapshot as R, RuntimeClient as a, type PlutoRuntimeAssembly as b, type RuntimeFactoryOptions as c, type DriveGrantActorErrorKind as d, DriveGrantActorHandle as e, type DriveGrantActorHandleOptions as f, DriveGrantActorRegistry as g, type DriveGrantActorState as h, type DriveGrantClose as i, type DriveGrantDial as j, type DriveGrantConnectionKey as k, type DriveGrantLogicalChannelHandle as l, type DriveGrantPreferredTransport as m, getRuntimePolicy as n, driveGrantConnectionKey as o, driveGrantConnectionKeyToString as p };

package/dist/{capabilities-YSskrE8H.d.ts → capabilities-BfZi4Cd7.d.ts}

@@ -1,3 +1,5 @@
+import { c as ProtocolName, T as TransportOptimization } from './ITransport-WV6gGMnX.js';
+
 type RuntimeAdapterKind = 'browser-wasm' | 'native-ipc' | 'tauri-ipc' | 'unknown';
 interface RuntimeCapabilities {
     adapter: RuntimeAdapterKind;
@@ -73,6 +75,8 @@ interface NativeRuntimeStatusSnapshot {
         ble?: NativeRuntimeTransportFeatureStatus;
         irohRelayOnly?: boolean;
         irohRelayTransportPolicy?: string | null;
+        routePriority?: ProtocolName[];
+        optimizeFor?: TransportOptimization;
     };
 }
 declare const BROWSER_WASM_RUNTIME_CAPABILITIES: RuntimeCapabilities;

package/dist/chunk-45WBH7E3.js

@@ -0,0 +1 @@
+var t=Object.freeze([Object.freeze({id:"iroh-lan",baseProtocol:"iroh",family:"iroh-path",implementation:"path-label",locality:"nearby",maturity:"stable",defaultRank:0,browser:false,native:true,independentlyInstantiable:false}),Object.freeze({id:"webrtc-lan",baseProtocol:"webrtc",family:"optional-route",implementation:"path-label",locality:"nearby",maturity:"stable",defaultRank:1,browser:true,native:true,independentlyInstantiable:false}),Object.freeze({id:"ble",baseProtocol:"iroh",family:"iroh-physical",implementation:"host-installed",locality:"nearby",maturity:"experimental",defaultRank:2,browser:false,native:true,independentlyInstantiable:false}),Object.freeze({id:"iroh-webrtc",baseProtocol:"iroh",family:"iroh-physical",implementation:"carrier-adapter",locality:"mixed",maturity:"stable",defaultRank:3,browser:true,native:true,independentlyInstantiable:false}),Object.freeze({id:"webrtc",baseProtocol:"webrtc",family:"optional-route",implementation:"route-adapter",locality:"mixed",maturity:"stable",defaultRank:4,browser:true,native:true,independentlyInstantiable:true}),Object.freeze({id:"iroh-moq",baseProtocol:"iroh",family:"iroh-physical",implementation:"carrier-adapter",locality:"relay",maturity:"experimental",defaultRank:5,browser:true,native:true,independentlyInstantiable:false}),Object.freeze({id:"moq",baseProtocol:"moq",family:"optional-route",implementation:"route-adapter",locality:"relay",maturity:"experimental",defaultRank:6,browser:true,native:true,independentlyInstantiable:true}),Object.freeze({id:"iroh",baseProtocol:"iroh",family:"iroh-path",implementation:"core",locality:"mixed",maturity:"stable",defaultRank:7,browser:true,native:true,independentlyInstantiable:false}),Object.freeze({id:"iroh-quic",baseProtocol:"iroh",family:"iroh-path",implementation:"path-label",locality:"direct-internet",maturity:"stable",defaultRank:8,browser:false,native:true,independentlyInstantiable:false}),Object.freeze({id:"iroh-relay",baseProtocol:"iroh",family:"iroh-path",implementation:"path-label",locality:"relay",maturity:"stable",defaultRank:9,browser:true,native:true,independentlyInstantiable:false}),Object.freeze({id:"webrtc-turn",baseProtocol:"webrtc",family:"optional-route",implementation:"path-label",locality:"relay",maturity:"stable",defaultRank:10,browser:true,native:true,independentlyInstantiable:false})]),r=Object.freeze(Object.fromEntries(t.map(e=>[e.id,e]))),o=Object.freeze(["iroh-lan","webrtc-lan","ble","iroh-webrtc","webrtc","iroh-moq","moq","iroh","iroh-quic","iroh-relay","webrtc-turn"]),a=Object.freeze(["iroh-lan","webrtc-lan","ble","iroh-webrtc","webrtc","iroh-moq","moq","iroh"]),i=Object.freeze({iroh:80,"iroh-quic":30,"iroh-relay":70,"iroh-lan":10,ble:25,"iroh-webrtc":27,webrtc:40,"webrtc-lan":20,"webrtc-turn":60,"iroh-moq":55,moq:50});var l=t,n=r,R=o,s=a,m=i;function p(e){return n[e]}function u(){return l}export{l as a,R as b,s as c,m as d,p as e,u as f};

package/dist/chunk-7FPG3MFF.js

@@ -0,0 +1,2 @@
+import {a}from'./chunk-VBUDERMM.js';function p(){let r=crypto.getRandomValues(new Uint8Array(24)),e="";for(let t of r)e+=String.fromCharCode(t);return btoa(e).replace(/\+/g,"-").replace(/\//g,"_").replace(/=+$/,"")}function u(r){if(!r||typeof r!="object")throw new Error("[OpenRTC] Native host returned no device public key.");let e=r;if(e.kty!=="OKP"||e.crv!=="Ed25519"||typeof e.x!="string"||!/^[A-Za-z0-9_-]{43}$/.test(e.x)||e.d!==void 0)throw new Error("[OpenRTC] Native host returned an invalid Ed25519 public key.");return {kty:"OKP",crv:"Ed25519",x:e.x}}function v(r){return {async readSecureRecord(e,t){return r.invoke("openrtc_v2_read_secure_record",{appTag:e,key:t})},async writeSecureRecord(e,t,n){await r.invoke("openrtc_v2_write_secure_record",{appTag:e,key:t,value:n});},async deleteSecureRecord(e,t){await r.invoke("openrtc_v2_delete_secure_record",{appTag:e,key:t});},async delete(e){await r.invoke("openrtc_v2_delete_device_key",{appTag:e});},async getOrCreate(e){let t=u(await r.invoke("openrtc_v2_device_public_key",{appTag:e})),n=await a(t);return {publicKeyJwk:t,thumbprint:n,async proof(s){let o=p(),c=Math.floor(Date.now()/1e3),i=await r.invoke("openrtc_v2_sign_device_proof",{appTag:e,challenge:s(o,c)});if(!/^[A-Za-z0-9_-]{80,128}$/.test(i))throw new Error("[OpenRTC] Native host returned an invalid device proof.");return {publicKeyJwk:t,signature:i,nonce:o,issuedAt:c}}}}}}
+export{v as a};