openrtc 0.1.0

package/dist/core/trust.d.ts

@@ -0,0 +1,23 @@
+export declare const TRANSPORT_TRUST_VERSION = 1;
+export interface TrustedDeviceMetadataRecord {
+    version: number;
+    identityPublicKey: string;
+    identityFingerprint: string;
+}
+export interface LocalTrustedIdentityRecord {
+    publicKey: Uint8Array;
+    secretKey: Uint8Array;
+    fingerprint: string;
+}
+export interface TransportTrustPayload {
+    version: number;
+    deviceId: string;
+    identityFingerprint: string;
+    challenge?: string;
+    signedChallenge?: string;
+}
+export declare function createTransportTrustChallenge(byteLength?: number): string;
+export declare function signTransportTrustChallenge(challenge: string, identitySecretKey: Uint8Array): string;
+export declare function verifyTransportTrustChallenge(challenge: string, signedChallenge: string, identityPublicKey: string): boolean;
+export declare function parseTrustedDeviceMetadata(metadata?: string | null): TrustedDeviceMetadataRecord | null;
+export declare function getLocalTrustedIdentity(): Promise<LocalTrustedIdentityRecord | null>;

package/dist/core/trust.js

@@ -0,0 +1,99 @@
+import * as nacl from 'tweetnacl';
+const TRUSTED_DEVICE_METADATA_KEY = 'trustedDevice';
+const TRUSTED_IDENTITY_STORAGE_KEY = 'plutonium:e2ee:identity:v1';
+export const TRANSPORT_TRUST_VERSION = 1;
+function decodeBase64(value) {
+    const binary = atob(value);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) {
+        bytes[index] = binary.charCodeAt(index);
+    }
+    return bytes;
+}
+function encodeBase64(value) {
+    let binary = '';
+    for (let index = 0; index < value.length; index += 1) {
+        binary += String.fromCharCode(value[index]);
+    }
+    return btoa(binary);
+}
+async function computeFingerprint(publicKey) {
+    const hashBuffer = await crypto.subtle.digest('SHA-256', publicKey);
+    const hashBytes = new Uint8Array(hashBuffer);
+    return Array.from(hashBytes)
+        .map((byte) => byte.toString(16).padStart(2, '0'))
+        .join('');
+}
+export function createTransportTrustChallenge(byteLength = 32) {
+    const challenge = crypto.getRandomValues(new Uint8Array(byteLength));
+    return encodeBase64(challenge);
+}
+export function signTransportTrustChallenge(challenge, identitySecretKey) {
+    const signature = nacl.sign.detached(decodeBase64(challenge), identitySecretKey);
+    return encodeBase64(signature);
+}
+export function verifyTransportTrustChallenge(challenge, signedChallenge, identityPublicKey) {
+    try {
+        return nacl.sign.detached.verify(decodeBase64(challenge), decodeBase64(signedChallenge), decodeBase64(identityPublicKey));
+    }
+    catch {
+        return false;
+    }
+}
+export function parseTrustedDeviceMetadata(metadata) {
+    if (!metadata || !metadata.trim()) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(metadata);
+        const record = parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed[TRUSTED_DEVICE_METADATA_KEY]
+            : null;
+        if (!record || typeof record !== 'object' || Array.isArray(record)) {
+            return null;
+        }
+        const normalized = record;
+        const version = typeof normalized.version === 'number' ? normalized.version : null;
+        const identityPublicKey = typeof normalized.identityPublicKey === 'string' ? normalized.identityPublicKey : null;
+        const identityFingerprint = typeof normalized.identityFingerprint === 'string'
+            ? normalized.identityFingerprint
+            : null;
+        if (!version || !identityPublicKey || !identityFingerprint) {
+            return null;
+        }
+        return {
+            version,
+            identityPublicKey,
+            identityFingerprint,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function getLocalTrustedIdentity() {
+    if (typeof localStorage === 'undefined') {
+        return null;
+    }
+    const raw = localStorage.getItem(TRUSTED_IDENTITY_STORAGE_KEY);
+    if (!raw) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.publicKey !== 'string' || typeof parsed.secretKey !== 'string') {
+            return null;
+        }
+        const publicKey = decodeBase64(parsed.publicKey);
+        const secretKey = decodeBase64(parsed.secretKey);
+        const fingerprint = await computeFingerprint(publicKey);
+        return {
+            publicKey,
+            secretKey,
+            fingerprint,
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/core/types.d.ts

@@ -0,0 +1,559 @@
+export type PlanTier = 'free' | 'starter' | 'pro' | 'internal';
+export interface AppLimits {
+    /** Max devices per authenticated user. -1 = unlimited. */
+    devicesPerUser: number;
+    /** Max total rooms the developer app can have open at once. -1 = unlimited. */
+    maxRooms: number;
+    /** Max members per room. -1 = unlimited. */
+    maxMembersPerRoom: number;
+    /** Max active devices across all provisioned personal spaces for this app. -1 = unlimited. */
+    maxPersonalDevices: number;
+}
+export declare const DEFAULT_FREE_LIMITS: AppLimits;
+export declare const DEFAULT_MOQ_RELAY_URL = "https://relay.cloudflare.mediaoverquic.com";
+export declare const DEFAULT_ICE_SERVERS: {
+    urls: string;
+}[];
+export interface PlutoRTCConfiguration extends RTCConfiguration {
+    iceServers?: RTCIceServer[];
+    privacyMode?: boolean;
+    useTurn?: boolean;
+}
+export declare const DEFAULT_WEBRTC_CONFIG: PlutoRTCConfiguration;
+export interface PlutoMoQConfiguration {
+    relayUrl?: string;
+}
+export declare const DEFAULT_MOQ_CONFIG: PlutoMoQConfiguration;
+export interface PlutoIrohConfiguration {
+    relayOnly?: boolean;
+    persistenceMode?: 'persistent' | 'ephemeral';
+}
+export type DiscoveryMode = 'personal' | 'user-scoped';
+export type AuthMode = 'external' | 'anonymous' | 'required';
+export type SignalingMode = 'hosted' | 'ticket-only';
+export type RoomCreationMode = 'client-open' | 'client-auth' | 'server-only';
+export type EndpointKind = 'device' | 'ephemeral';
+export type PeerLifecycleStatus = 'disconnected' | 'connecting' | 'connected' | 'failed' | 'closed';
+export type PeerHealth = 'unknown' | 'healthy' | 'suspect' | 'stale';
+export type PeerScope = 'persistent' | 'session' | string;
+export type ChannelOwnership = 'shared' | 'exclusive';
+export type ChannelPeerModel = 'device-first' | 'node-first' | 'anonymous-ticket';
+export type ChannelRoutingMode = 'stream-envelope' | 'session-default';
+export type ChannelReadinessMode = 'settled-peer' | 'transport-only';
+export type ChannelPromotionPolicy = 'eligible' | 'never';
+export type ChannelSignalingPolicy = 'hosted' | 'ticket-only';
+export interface ChannelDescriptor {
+    id: string;
+    kind: 'system' | 'auth' | 'share' | 'transfer' | 'sync' | string;
+    ownership: ChannelOwnership;
+    peerModel: ChannelPeerModel;
+    routing: ChannelRoutingMode;
+    readiness: ChannelReadinessMode;
+    promotionPolicy?: ChannelPromotionPolicy;
+    signalingPolicy?: ChannelSignalingPolicy;
+    description?: string;
+}
+export type ProtocolName = 'iroh' | 'webrtc' | 'websocket' | 'webtransport' | 'moq';
+export type ProtocolMaturity = 'stable' | 'experimental' | 'unsupported';
+export interface ProtocolCapability {
+    protocol: ProtocolName;
+    maturity: ProtocolMaturity;
+    available: boolean;
+    reason?: string;
+}
+export type ProtocolCapabilityMap = Record<ProtocolName, ProtocolCapability>;
+export interface ClientOptions {
+    /**
+     * API key issued from the Pluto developer dashboard (https://api.openrtc.app/developer).
+     * The runtime derives its app namespace from this key.
+     */
+    apiKey?: string;
+    /**
+     * Explicitly opt in to the legacy shared hosted fallback when no apiKey is provided.
+     *
+     * This should only be used for controlled demos/tests. Production integrations
+     * should always provide an API key.
+     */
+    allowAnonymousHostedDefaults?: boolean;
+    /**
+     * Discovery mode for this app. Defaults to 'personal'.
+     * - 'personal': No user accounts. Devices share a spaceKey to discover each other.
+     * - 'user-scoped': Developer mints tokens for their users. Devices scoped per user.
+     *
+     * Set in the developer dashboard. The server validates this against the app's plan.
+     */
+    discoveryMode?: DiscoveryMode;
+    /**
+     * Space key for 'personal' discovery mode. Acts as a shared secret that scopes
+     * device discovery without requiring user authentication. Devices with the same
+     * spaceKey + apiKey will see each other.
+     *
+     * Only used when discoveryMode is 'personal'. Ignored for managed modes.
+     */
+    spaceKey?: string;
+    /**
+     * Pre-minted session token from your backend (for managed modes).
+     * Your backend calls PlutoRTC's /v1/tokens endpoint and passes the token here.
+     */
+    sessionToken?: string;
+    authMode?: AuthMode;
+    signalingMode?: SignalingMode;
+    projectId?: string;
+    storagePrefix?: string;
+    deviceTTL?: number;
+    deviceName?: string;
+    nodeIdPersistence?: 'persistent' | 'ephemeral';
+    secretKey?: string;
+    strictMode?: boolean;
+    localDeviceId?: string;
+    onDevices?: (devices: Device[]) => void;
+    onAutoConnect?: (devices: Device[]) => void;
+    onIncomingSession?: (session: SignalingSession) => Promise<void>;
+    transports?: {
+        iroh?: boolean | PlutoIrohConfiguration;
+        webrtc?: boolean | PlutoRTCConfiguration;
+        moq?: boolean | PlutoMoQConfiguration;
+    };
+    transportPriority?: ProtocolName[];
+    disableIrohFallback?: boolean;
+}
+export interface Device {
+    /**
+     * @deprecated Internal namespace metadata. Public integrations should not depend on `appTag`.
+     */
+    appTag?: string;
+    deviceId: string;
+    deviceName: string;
+    online: boolean;
+    ticket: string;
+    /**
+     * @deprecated Legacy/internal namespace metadata. Public integrations should not depend on `tag`.
+     */
+    tag?: string;
+    kind?: EndpointKind | string;
+    nodeId?: string;
+    platformType?: string;
+    capabilities?: {
+        canHost?: boolean;
+        canSync?: boolean;
+        readOnly?: boolean;
+        can_host?: boolean;
+        can_sync?: boolean;
+        read_only?: boolean;
+    };
+    sessionId?: string;
+    userId?: string;
+    lastSeenAt?: any;
+    expiresAt?: any;
+    createdAt?: any;
+    updatedAt?: any;
+    metadata?: string;
+}
+export interface PeerState {
+    peerId: string;
+    deviceId?: string;
+    deviceIdHint?: string;
+    nodeId?: string;
+    connectionId?: string;
+    connectionIds: string[];
+    ticket?: string;
+    online?: boolean;
+    deviceName?: string;
+    platformType?: string;
+    status: PeerLifecycleStatus;
+    health: PeerHealth;
+    transportState?: string;
+    protocolState?: string;
+    routable?: boolean;
+    promotionEligible?: boolean;
+    scopes: PeerScope[];
+    lastSeenAt?: number;
+    error?: string;
+}
+export interface BackendConnectionState {
+    connectionId: string;
+    deviceId?: string | null;
+    deviceIdHint?: string | null;
+    remoteNodeId?: string | null;
+    state: string;
+    transportState?: string;
+    protocolState?: string;
+    routable?: boolean;
+    readinessState?: string;
+    readinessReason?: string;
+    transportGeneration?: number;
+    activeTransportStableId?: number | null;
+    replacementInProgress?: boolean;
+    lastLifecycleTransitionAtMs?: number;
+    transitionCount?: number;
+    connectingTransitionCount?: number;
+    replacementCount?: number;
+    retireCount?: number;
+    lastDisconnectReason?: string | null;
+    lastReconnectReason?: string | null;
+    error?: string;
+    createdAt?: number;
+    updatedAt?: number;
+}
+export interface NativeConnectResult {
+    connectionId: string;
+    deviceId?: string | null;
+    deviceIdHint?: string | null;
+    remoteNodeId?: string | null;
+    state: string;
+}
+export interface BackendPeerBiStream {
+    readable: ReadableStream<Uint8Array>;
+    writable: WritableStream<Uint8Array>;
+}
+export interface BackendPeerUniStream {
+    writable: WritableStream<Uint8Array>;
+}
+export interface IncomingStreamChannelMetadata {
+    channelId: string;
+    metadata?: Record<string, unknown> | null;
+}
+export interface LocalDeviceInfo {
+    deviceId: string;
+    deviceName: string;
+    platformType?: string;
+    capabilities?: Device['capabilities'];
+    lastSeenAt?: string;
+}
+export interface RoomMember {
+    nodeId: string;
+    userId: string;
+    ticket: string;
+    joinedAt: number;
+    lastSeenAt: number;
+    expiresAt?: number;
+}
+export interface JoinRoomOptions {
+    bootstrapPeers?: boolean;
+}
+export interface SignalingEnvelope {
+    name?: string;
+    senderId: string;
+    targetId: string;
+    state?: string;
+    payload: string;
+    replyPayload?: string;
+    timestamp?: number;
+}
+export interface SignalingSession {
+    connectionId: string;
+    initiator?: string;
+    target?: string;
+    initiatorDeviceId: string;
+    targetDeviceId: string;
+    connectionType?: string;
+    offer?: any;
+    offerE2ee?: any;
+    answer?: any;
+    answerE2ee?: any;
+    iceCandidates: any[];
+    initiatorNodeId?: string;
+    targetNodeId?: string;
+    initiatorEndpointAddr?: string;
+    targetEndpointAddr?: string;
+    intent?: string;
+    /**
+     * @deprecated Internal namespace metadata. Public integrations should not depend on `appTag`.
+     */
+    appTag?: string;
+    createdAt?: number;
+    expiresAt?: number;
+    state: string;
+}
+export interface ScanningLoopOptions {
+    localDeviceId: string;
+    autoConnect?: boolean;
+    autoConnectDebounceMs?: number;
+    retryThrottleMs?: number;
+    tieBreaker?: (localDeviceId: string, remoteDeviceId: string) => boolean;
+    shouldSkipDevice?: (device: Device) => boolean;
+    isConnected?: (deviceId: string) => boolean;
+    isConnecting?: (deviceId: string) => boolean;
+    onDevices?: (devices: Device[]) => void;
+    onAutoConnect?: (device: Device) => Promise<void> | void;
+    onIncomingSession?: (session: SignalingSession) => Promise<void> | void;
+    hasProtectedConnectionIntent?: (deviceId: string) => boolean;
+    cleanupStaleConnection?: (deviceId: string) => Promise<void>;
+    allowIncomingNodeId?: (nodeId: string) => Promise<void>;
+    acceptIncomingSession?: (sessionId: string, initiatorDeviceId: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    onIncomingSessionAccepted?: (session: SignalingSession) => Promise<void> | void;
+}
+export interface ScanningLoopHandle {
+    stop: () => void;
+}
+export interface ConnectDeviceHooks {
+    getConnectionState?: (deviceId: string) => Promise<string | undefined> | string | undefined;
+    forceDisconnect?: (deviceId: string) => Promise<void>;
+    refreshState?: () => Promise<void>;
+    directConnect: (device: Device) => Promise<void>;
+    signalConnect: (params: {
+        localDeviceId: string;
+        targetDeviceId: string;
+        targetUserId?: string;
+        device: Device;
+    }) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    onConnected?: (device: Device) => Promise<void> | void;
+    onRetry?: (device: Device, attempt: number, delayMs: number) => void;
+}
+export interface ConnectDeviceOptions {
+    localDeviceId: string;
+    targetUserId?: string;
+    maxRetries?: number;
+    initialBackoffMs?: number;
+}
+export interface ConnectDeviceResult {
+    success: boolean;
+    skipped?: 'already-connecting' | 'missing-local-device-id';
+    error?: string;
+    attempts: number;
+}
+export interface ManagedDeviceConnectOptions {
+    localDeviceId: string;
+    targetUserId?: string;
+    maxRetries?: number;
+    initialBackoffMs?: number;
+    onRetry?: (device: Device, attempt: number, delayMs: number) => void;
+    onConnected?: (device: Device) => void | Promise<void>;
+}
+export interface DeviceStatusSnapshot extends Device {
+    connectionStatus: PeerLifecycleStatus | 'online';
+    settledReady?: boolean;
+    readinessState?: string;
+    readinessReason?: string;
+    peerHealth: PeerHealth;
+    peerId?: string;
+    promotionEligible?: boolean;
+    scopes: PeerScope[];
+    connectionId?: string;
+    deviceIdHint?: string;
+    activeTransportStableId?: number | null;
+    transportGeneration?: number;
+}
+export interface ManagedConnectionRecord {
+    connectionId: string;
+    nodeId?: string | null;
+    deviceId?: string | null;
+    deviceIdHint?: string | null;
+    endpointId?: string | null;
+    transportGeneration: number;
+    transportStableId?: number | null;
+    transportSource?: string | null;
+    lastTransportChangeAtMs: number;
+    state: string;
+    statusReason?: string | null;
+    transitionCount?: number;
+    connectingTransitionCount?: number;
+    replacementCount?: number;
+    retireCount?: number;
+    lastDisconnectReason?: string | null;
+    lastReconnectReason?: string | null;
+    createdAtMs: number;
+    updatedAtMs: number;
+}
+export type ManagedConnectionHealthStatus = 'healthy' | 'awaitingReplacement' | 'dead';
+export interface ManagedConnectionHealthSnapshot {
+    connectionId: string;
+    deviceId?: string | null;
+    deviceIdHint?: string | null;
+    nodeId?: string | null;
+    activeTransportStableId?: number | null;
+    transportGeneration: number;
+    status: ManagedConnectionHealthStatus;
+    settledReady?: boolean;
+    readinessState?: string;
+    replacementPending?: boolean;
+    lastLifecycleTransitionAtMs?: number;
+    readinessReason?: string;
+    transitionCount?: number;
+    connectingTransitionCount?: number;
+    replacementCount?: number;
+    retireCount?: number;
+    lastDisconnectReason?: string | null;
+    lastReconnectReason?: string | null;
+}
+export interface ResolvedPeerIdentity {
+    peerId?: string | null;
+    deviceId?: string | null;
+    deviceIdHint?: string | null;
+    nodeId?: string | null;
+}
+export interface PeerSessionSnapshot {
+    peerId: string;
+    deviceId?: string | null;
+    deviceIdHint?: string | null;
+    nodeId?: string | null;
+    activeConnectionId?: string | null;
+    candidateConnectionIds: string[];
+    status: PeerLifecycleStatus;
+    health: PeerHealth;
+    settledReady?: boolean;
+    readinessState?: string;
+    activeTransportStableId?: number | null;
+    transportGeneration?: number;
+    replacementPending?: boolean;
+    lastLifecycleTransitionAtMs?: number;
+    readinessReason?: string;
+    transitionCount?: number;
+    connectingTransitionCount?: number;
+    replacementCount?: number;
+    retireCount?: number;
+    lastDisconnectReason?: string | null;
+    lastReconnectReason?: string | null;
+    scopes: PeerScope[];
+    lastSeenAtMs: number;
+    error?: string | null;
+}
+export interface RuntimeBootstrapOptions {
+    platform: 'native' | 'web';
+    initializeWeb?: () => Promise<void>;
+    isNativeReady?: () => Promise<boolean>;
+    retryNativeInit?: () => Promise<void>;
+    waitForNativeInitEvent?: (timeoutMs: number) => Promise<boolean>;
+    quickPollAttempts?: number;
+    quickPollIntervalMs?: number;
+    retryPollAttempts?: number;
+    retryPollIntervalMs?: number;
+    nativeInitEventTimeoutMs?: number;
+    initializeClient?: boolean;
+}
+export interface RuntimeBootstrapResult {
+    ready: boolean;
+    mode: 'native' | 'web';
+}
+export interface RuntimeIdentity {
+    id: string;
+    email?: string | null;
+    displayName?: string | null;
+    isAnonymous?: boolean;
+    getToken?: (forceRefresh?: boolean) => Promise<string | null>;
+}
+export type DeviceEvent = {
+    type: 'added';
+    device: Device;
+} | {
+    type: 'modified';
+    device: Device;
+} | {
+    type: 'removed';
+    deviceId: string;
+};
+export type SessionEvent = {
+    type: 'added';
+    session: SignalingSession;
+} | {
+    type: 'modified';
+    session: SignalingSession;
+} | {
+    type: 'removed';
+    sessionId: string;
+};
+export interface ExplicitFileDataSendParams {
+    connectionId?: string;
+    connection?: {
+        send: (message: unknown) => Promise<void>;
+        deviceId?: string;
+        remoteNodeId?: string;
+    };
+    remoteNodeId?: string;
+    file: File;
+    transferId: string;
+    channelId?: string;
+}
+export interface ISignalingBackend {
+    currentUser: RuntimeIdentity | null;
+    signInAnonymously(): Promise<void>;
+    signInWithPluto?(): Promise<void>;
+    signOut(): Promise<void>;
+    stopAuthScopedActivity?(): Promise<void>;
+    getTurnCredentials(): Promise<any>;
+    updatePresence(localNodeId: string, ticketStr: string, isOnline: boolean, ttlMs: number, metadata?: string): Promise<void>;
+    setOffline(localNodeId: string): Promise<void>;
+    cleanupStaleDevices(): Promise<void>;
+    searchDevices(excludeNodeId?: string): Promise<Device[]>;
+    listDevicesWithStatus?(): Promise<DeviceStatusSnapshot[]>;
+    getPeerSession?(id: string): Promise<PeerSessionSnapshot | null>;
+    listPeerSessions?(): Promise<PeerSessionSnapshot[]>;
+    waitForSettledPeer?(id: string, timeoutMs?: number): Promise<PeerSessionSnapshot | null>;
+    resolvePeerIdentity?(id: string): Promise<ResolvedPeerIdentity>;
+    resolvePeerConnectionRecords?(id: string): Promise<ManagedConnectionRecord[]>;
+    updateDevice(deviceId: string, updates: {
+        deviceName?: string;
+        capabilities?: Device['capabilities'];
+        metadata?: string;
+    }): Promise<void>;
+    deleteDevice(deviceId: string): Promise<void>;
+    onDevicesChange(callback: (devices: Device[]) => void, excludeNodeId?: string): () => void;
+    onAuthChange(callback: (user: RuntimeIdentity | null) => void): () => void;
+    checkForSSOToken(): Promise<void>;
+    waitForAuth(): Promise<void>;
+    sendMessage(targetId: string, payload: string, state?: string, replyPayload?: string): Promise<string>;
+    pollMessages(targetId: string): Promise<SignalingEnvelope[]>;
+    subscribeDevices(userId: string): Promise<ReadableStream<DeviceEvent[]>>;
+    startAutoConnectOnce?(userId: string, localDeviceId: string): Promise<void>;
+    startAutoConnect(userId: string, localDeviceId: string): void;
+    notifyDisconnectRequested?(remoteNodeId: string): void;
+    startPresenceLoopOnce?(userId: string, localNodeId: string, deviceName: string, ticket: string, metadata?: string): Promise<void>;
+    startPresenceLoop(userId: string, localNodeId: string, deviceName: string, ticket: string, metadata?: string): void;
+    createSession(session: SignalingSession): Promise<void>;
+    updateSession(sessionId: string, updateData: any): Promise<void>;
+    subscribeSessions(localDeviceId: string): Promise<ReadableStream<SessionEvent[]>>;
+    forceReconnectSnapshot(): void;
+    getLocalDeviceId?(): Promise<string | null>;
+    getLocalDeviceInfo?(): Promise<LocalDeviceInfo | null>;
+    updateLocalDeviceName?(deviceName: string): Promise<LocalDeviceInfo | null>;
+    getManagedNodeId?(options?: {
+        initializeIfMissing?: boolean;
+    }): Promise<string | null>;
+    getEndpointTicket?(): Promise<string>;
+    openPeerBi?(id: string, timeoutMs?: number): Promise<BackendPeerBiStream>;
+    openPeerUni?(id: string, timeoutMs?: number): Promise<BackendPeerUniStream>;
+    connectToDevice?(params: {
+        deviceId?: string | null;
+        endpointTicket: string;
+    }): Promise<NativeConnectResult>;
+    disconnectDevice?(deviceId: string): Promise<void>;
+    setAutoConnectExcluded?(deviceId: string, excluded: boolean): Promise<void>;
+    isConnected(nodeId: string): Promise<boolean>;
+    getConnectionStates?(): Promise<BackendConnectionState[]>;
+    onConnectionStateChange?(callback: (state: BackendConnectionState) => void): Promise<() => void> | (() => void);
+    sendExplicitFilePath?(connectionId: string, filePath: string, transferId?: string): Promise<string>;
+    sendExplicitFileData?(params: ExplicitFileDataSendParams): Promise<void>;
+    getTransferHistory?(limit?: number): Promise<Array<[string, unknown]>>;
+    deleteTransferJob?(jobId: string): Promise<void>;
+}
+export interface SignalingOptions {
+    apiKey?: string;
+    allowAnonymousHostedDefaults?: boolean;
+    authMode?: AuthMode;
+    projectId?: string;
+    storagePrefix?: string;
+    nodeIdPersistence?: 'persistent' | 'ephemeral';
+}
+export interface TransportContext {
+    sendMoQ: (data: Uint8Array) => Promise<void>;
+    priorities: ProtocolName[];
+    disableIrohFallback: boolean;
+    isMoQReady: () => boolean;
+}
+export interface ConnectionOptions {
+    reliable?: boolean;
+    rtcConfig?: RTCConfiguration;
+    transportContext?: TransportContext;
+}
+export interface JoinRequest {
+    id: string;
+    userId: string;
+    ticket: string;
+    state: 'pending' | 'accepted' | 'rejected';
+}

package/dist/core/types.js

@@ -0,0 +1,19 @@
+// --- Billing / Plan Types ---
+export const DEFAULT_FREE_LIMITS = {
+    devicesPerUser: 2,
+    maxRooms: 10,
+    maxMembersPerRoom: 5,
+    maxPersonalDevices: 50, // free: 10 rooms * 5 members = 50
+};
+// --- Constants ---
+export const DEFAULT_MOQ_RELAY_URL = 'https://relay.cloudflare.mediaoverquic.com';
+export const DEFAULT_ICE_SERVERS = [
+    { urls: 'stun:stun.l.google.com:19302' },
+    { urls: 'stun:stun.cloudflare.com:3478' }
+];
+export const DEFAULT_WEBRTC_CONFIG = {
+    iceServers: DEFAULT_ICE_SERVERS
+};
+export const DEFAULT_MOQ_CONFIG = {
+    relayUrl: DEFAULT_MOQ_RELAY_URL
+};