@affectively/dash 5.4.0 → 5.4.5

package/dist/sync/HybridProvider.d.ts

@@ -0,0 +1,124 @@
+/**
+ * HybridProvider - DashRelay v1 transport.
+ *
+ * Uses a real relay socket with strict join-first handshake (`dashrelay-v1`).
+ * On relay outage, falls back to WebRTC peer mode for small rooms, then to
+ * local-authoritative mode until relay connectivity returns.
+ */
+import * as Y from 'yjs';
+import { type AeonDurableSyncConfig } from './AeonDurableSync';
+export interface RelayDiscoveryConfig {
+    url?: string;
+    bootstrap?: string[];
+    announce?: boolean;
+    announceIntervalMs?: number;
+}
+export interface RelayPerformanceConfig {
+    compressionThresholdBytes?: number;
+    batchIntervalMs?: number;
+    maxBatchSize?: number;
+}
+export interface RelayPrivacyConfig {
+    roomKey?: string;
+}
+export interface HybridProviderConfig {
+    websocket?: {
+        url: string;
+    };
+    webtransport?: {
+        url: string;
+    };
+    roomName: string;
+    /** DashRelay API key (format: dr_<64-hex>) - alternative to UCAN auth */
+    apiKey?: string;
+    /** UCAN token for authorization */
+    ucanToken?: string;
+    discovery?: RelayDiscoveryConfig;
+    performance?: RelayPerformanceConfig;
+    privacy?: RelayPrivacyConfig;
+    aeon?: Omit<AeonDurableSyncConfig, 'roomName'>;
+}
+export interface HybridProviderStatus {
+    connected: boolean;
+    roomName: string;
+    transport: 'websocket' | 'webtransport' | null;
+    activeRelay: string | null;
+    discoveryCount: number;
+    isHighFrequencyMode: boolean;
+    fallbackMode: 'relay' | 'webrtc-peer' | 'local-authoritative';
+    performance: Required<RelayPerformanceConfig>;
+    privacy: {
+        enabled: boolean;
+    };
+}
+export declare class HybridProvider {
+    private readonly doc;
+    private config;
+    private readonly _roomName;
+    private _ready;
+    private _destroyed;
+    private _connected;
+    private _joined;
+    private _isHighFrequencyMode;
+    private _transport;
+    private _activeRelay;
+    private _discoveredRelays;
+    private _fallbackMode;
+    private _serverSeq;
+    private _webSocket;
+    private _reconnectTimer;
+    private _reconnectDelayMs;
+    private _applyingRemoteUpdate;
+    private _docUpdateHandler;
+    private _webrtcConnection;
+    private _discoveryTimer;
+    private _discoveryAnnounceBlockedUntilMs;
+    private _discoveryAnnounceFailures;
+    private _discoveryAnnounceInFlight;
+    private _discoveryAnnounceController;
+    private _aeonRuntime;
+    constructor(doc: Y.Doc, config: HybridProviderConfig);
+    private initialize;
+    private getDiscoveryAnnounceIntervalMs;
+    private scheduleDiscoveryAnnounce;
+    private computeDiscoveryAnnounceNextDelayMs;
+    private runDiscoveryAnnounceTick;
+    private fetchDiscoveryPeers;
+    private normalizeRelay;
+    refreshDiscovery(): Promise<void>;
+    private startDiscoveryAnnouncements;
+    private stopDiscoveryAnnouncements;
+    private resolvePreferredRelaySocketUrl;
+    private getJoinAuthToken;
+    private getClientId;
+    private connectRelay;
+    private scheduleRelayReconnect;
+    private clearRelayReconnect;
+    private activateFallback;
+    private deactivateFallback;
+    private applyYjsUpdate;
+    private handleRelayMessage;
+    private sendLocalUpdate;
+    get ready(): Promise<void>;
+    get roomName(): string;
+    getConnectionStatus(): HybridProviderStatus;
+    setRoomKey(roomKey: string | undefined): void;
+    destroy(): Promise<void>;
+    disconnect(): void;
+    enterHighFrequencyMode(): Promise<void>;
+    exitHighFrequencyMode(): void;
+    isHighFrequencyMode(): boolean;
+}
+export declare class SyncConnection {
+    private provider;
+    constructor(options: {
+        doc: Y.Doc;
+        roomName: string;
+        url: string;
+        protocol?: 'websocket' | 'webtransport';
+    });
+    get ready(): Promise<void>;
+    enterHighFrequencyMode(): Promise<void>;
+    disconnect(): void;
+    destroy(): void;
+}