@affectively/dash 5.4.0 → 5.4.5

package/dist/middleware/errorHandler.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Dash Error Handling Middleware
+ * Provides retry logic, rate limiting, and error recovery for Dash operations
+ */
+export interface RetryConfig {
+    maxRetries: number;
+    baseDelay: number;
+    maxDelay: number;
+    backoffFactor: number;
+}
+export interface RateLimitConfig {
+    maxRequests: number;
+    windowMs: number;
+    skipSuccessfulRequests: boolean;
+}
+export interface ErrorHandlerConfig {
+    retry?: RetryConfig;
+    rateLimit?: RateLimitConfig;
+    onError?: (error: Error, context: string) => void;
+    onRetry?: (attempt: number, error: Error) => void;
+}
+export declare class DashErrorHandler {
+    private config;
+    private requestCounts;
+    constructor(config?: ErrorHandlerConfig);
+    /**
+     * Execute operation with retry logic
+     */
+    executeWithRetry<T>(operation: () => Promise<T>, context?: string): Promise<T>;
+    /**
+     * Check if operation should be rate limited
+     */
+    checkRateLimit(key?: string): boolean;
+    /**
+     * Record a request for rate limiting
+     */
+    recordRequest(key?: string): void;
+    /**
+     * Execute operation with rate limiting and retry logic
+     */
+    execute<T>(operation: () => Promise<T>, context?: string, rateLimitKey?: string): Promise<T>;
+    private delay;
+    /**
+     * Reset rate limit counters
+     */
+    resetRateLimit(key?: string): void;
+    /**
+     * Get current rate limit status
+     */
+    getRateLimitStatus(key?: string): {
+        current: number;
+        limit: number;
+        remaining: number;
+        resetTime: number;
+    };
+}
+export declare const defaultErrorHandler: DashErrorHandler;
+export declare function withRetry<T>(operation: () => Promise<T>, config?: RetryConfig): Promise<T>;
+export declare function withRateLimit<T>(operation: () => Promise<T>, rateLimitKey: string, config?: RateLimitConfig): Promise<T>;
+export declare function withErrorHandling<T>(operation: () => Promise<T>, config?: ErrorHandlerConfig, rateLimitKey?: string): Promise<T>;

package/dist/{src/sync → sync}/AeonDurableSync.d.ts

@@ -1,24 +1,23 @@
-/**
- * AeonDurableSync - Durable telemetry runtime for sync operations
- *
- * Records transport selection, discovery events, and sync protocol messages
- * using Aeon's OfflineOperationQueue, SyncProtocol, and ReplicationManager.
- *
- * Operates in-memory by default. Persistence requires @affectively/aeon/persistence
- * (available in a future release).
- */
+import { type DashStorageBackend, type DashStorageAdapterOptions } from '@affectively/aeon/persistence';
 type TransportType = 'websocket' | 'webtransport' | null;
 export interface AeonDurableSyncConfig {
     enabled?: boolean;
     roomName: string;
     persistenceKeyPrefix?: string;
+    storageBackend?: DashStorageBackend;
+    storageOptions?: DashStorageAdapterOptions;
 }
 export declare class AeonDurableSyncRuntime {
+    private readonly adapter;
     private readonly queue;
     private readonly protocol;
     private readonly replication;
     constructor(config: AeonDurableSyncConfig);
     initialize(): Promise<void>;
+    /**
+     * Flush all pending writes to the storage backend.
+     */
+    flushSync(): Promise<void>;
     recordTransportSelection(roomName: string, transport: TransportType, relay: string | null): void;
     recordDiscovery(roomName: string, relays: string[]): void;
     getPendingOperations(): number;