@private.me/xbind 1.3.5 → 3.0.0

package/dist-standalone/retry-strategies.d.ts

@@ -0,0 +1,382 @@
+/**
+ * @module retry-strategies
+ * Configurable retry strategies for enhanced reliability.
+ *
+ * Provides flexible retry policies with exponential backoff, jitter, circuit breakers,
+ * and error-specific retry logic. Designed for production-grade fault tolerance.
+ *
+ * @example
+ * ```typescript
+ * import { RetryStrategy, CircuitBreaker } from '@private.me/xbind/retry-strategies';
+ *
+ * // Exponential backoff with circuit breaker
+ * const strategy = RetryStrategy.exponentialBackoff({
+ *   maxAttempts: 5,
+ *   initialDelayMs: 1000,
+ *   maxDelayMs: 30000,
+ *   multiplier: 2,
+ *   jitter: true
+ * });
+ *
+ * const circuitBreaker = new CircuitBreaker({
+ *   failureThreshold: 5,
+ *   resetTimeoutMs: 60000
+ * });
+ * ```
+ */
+import type { Result } from '@private.me/shared';
+import type { TransportError } from './transport.js';
+/**
+ * Retry context provides information about the current retry attempt.
+ */
+export interface RetryContext {
+    /** Current attempt number (0-indexed) */
+    readonly attempt: number;
+    /** Error from the previous attempt */
+    readonly error: TransportError;
+    /** Timestamp of the first attempt */
+    readonly startTime: number;
+    /** Total elapsed time since first attempt (ms) */
+    readonly elapsedMs: number;
+    /** Additional metadata */
+    readonly metadata?: Record<string, unknown>;
+}
+/**
+ * Result of a retry decision.
+ */
+export interface RetryDecision {
+    /** Whether to retry the operation */
+    readonly shouldRetry: boolean;
+    /** Delay before next retry (ms), if shouldRetry is true */
+    readonly delayMs?: number;
+    /** Reason for the decision (for logging/debugging) */
+    readonly reason?: string;
+}
+/**
+ * Configuration for exponential backoff retry strategy.
+ */
+export interface ExponentialBackoffConfig {
+    /** Maximum number of retry attempts (default: 3) */
+    maxAttempts?: number;
+    /** Initial delay in milliseconds (default: 1000) */
+    initialDelayMs?: number;
+    /** Maximum delay cap in milliseconds (default: 30000) */
+    maxDelayMs?: number;
+    /** Backoff multiplier (default: 2) */
+    multiplier?: number;
+    /** Enable jitter randomization (default: true) */
+    jitter?: boolean;
+    /** Maximum jitter percentage (0-1, default: 0.2 = ±20%) */
+    jitterFactor?: number;
+    /** Only retry on specific errors (default: all errors) */
+    retryableErrors?: ReadonlyArray<TransportError>;
+}
+/**
+ * Configuration for linear backoff retry strategy.
+ */
+export interface LinearBackoffConfig {
+    /** Maximum number of retry attempts (default: 3) */
+    maxAttempts?: number;
+    /** Fixed delay increment in milliseconds (default: 1000) */
+    delayIncrementMs?: number;
+    /** Initial delay in milliseconds (default: 1000) */
+    initialDelayMs?: number;
+    /** Maximum delay cap in milliseconds (default: 30000) */
+    maxDelayMs?: number;
+    /** Enable jitter randomization (default: true) */
+    jitter?: boolean;
+    /** Maximum jitter percentage (0-1, default: 0.1 = ±10%) */
+    jitterFactor?: number;
+    /** Only retry on specific errors (default: all errors) */
+    retryableErrors?: ReadonlyArray<TransportError>;
+}
+/**
+ * Configuration for fixed delay retry strategy.
+ */
+export interface FixedDelayConfig {
+    /** Maximum number of retry attempts (default: 3) */
+    maxAttempts?: number;
+    /** Fixed delay in milliseconds (default: 1000) */
+    delayMs?: number;
+    /** Enable jitter randomization (default: false) */
+    jitter?: boolean;
+    /** Maximum jitter percentage (0-1, default: 0.1 = ±10%) */
+    jitterFactor?: number;
+    /** Only retry on specific errors (default: all errors) */
+    retryableErrors?: ReadonlyArray<TransportError>;
+}
+/**
+ * Configuration for circuit breaker.
+ */
+export interface CircuitBreakerConfig {
+    /** Number of consecutive failures before opening circuit (default: 5) */
+    failureThreshold?: number;
+    /** Time to wait before attempting to close circuit (ms, default: 60000) */
+    resetTimeoutMs?: number;
+    /** Number of successful requests needed to close circuit (default: 2) */
+    successThreshold?: number;
+    /** Time window for counting failures (ms, default: 60000) */
+    windowMs?: number;
+}
+/**
+ * Circuit breaker states.
+ */
+export type CircuitState = 'CLOSED' | 'OPEN' | 'HALF_OPEN';
+/**
+ * Statistics for circuit breaker monitoring.
+ */
+export interface CircuitBreakerStats {
+    /** Current circuit state */
+    readonly state: CircuitState;
+    /** Number of consecutive failures */
+    readonly consecutiveFailures: number;
+    /** Number of consecutive successes in HALF_OPEN state */
+    readonly consecutiveSuccesses: number;
+    /** Timestamp when circuit was opened (if open) */
+    readonly openedAt?: number;
+    /** Total requests attempted */
+    readonly totalRequests: number;
+    /** Total failures */
+    readonly totalFailures: number;
+    /** Total successes */
+    readonly totalSuccesses: number;
+}
+/**
+ * Core retry strategy interface.
+ *
+ * Implementations determine retry behavior based on context.
+ */
+export interface IRetryStrategy {
+    /**
+     * Decide whether to retry the operation.
+     *
+     * @param context - Current retry context
+     * @returns Retry decision with delay
+     */
+    shouldRetry(context: RetryContext): RetryDecision;
+    /**
+     * Get strategy name for logging.
+     */
+    readonly name: string;
+}
+/**
+ * Exponential backoff retry strategy.
+ *
+ * Delay formula: min(initialDelay * multiplier^attempt, maxDelay) ± jitter
+ *
+ * Best for: Network requests, API calls, database operations.
+ * Avoids overwhelming failing services with exponentially increasing delays.
+ */
+export declare class ExponentialBackoffStrategy implements IRetryStrategy {
+    readonly name = "ExponentialBackoff";
+    private readonly maxAttempts;
+    private readonly initialDelayMs;
+    private readonly maxDelayMs;
+    private readonly multiplier;
+    private readonly jitter;
+    private readonly jitterFactor;
+    private readonly retryableErrors;
+    constructor(config?: ExponentialBackoffConfig);
+    shouldRetry(context: RetryContext): RetryDecision;
+    private applyJitter;
+}
+/**
+ * Linear backoff retry strategy.
+ *
+ * Delay formula: min(initialDelay + attempt * increment, maxDelay) ± jitter
+ *
+ * Best for: Rate-limited APIs, gradual load recovery.
+ * More predictable than exponential, suitable when service recovery is linear.
+ */
+export declare class LinearBackoffStrategy implements IRetryStrategy {
+    readonly name = "LinearBackoff";
+    private readonly maxAttempts;
+    private readonly delayIncrementMs;
+    private readonly initialDelayMs;
+    private readonly maxDelayMs;
+    private readonly jitter;
+    private readonly jitterFactor;
+    private readonly retryableErrors;
+    constructor(config?: LinearBackoffConfig);
+    shouldRetry(context: RetryContext): RetryDecision;
+    private applyJitter;
+}
+/**
+ * Fixed delay retry strategy.
+ *
+ * Delay formula: delayMs ± jitter (constant for all attempts)
+ *
+ * Best for: Simple retry scenarios, testing.
+ * Predictable timing, no backoff complexity.
+ */
+export declare class FixedDelayStrategy implements IRetryStrategy {
+    readonly name = "FixedDelay";
+    private readonly maxAttempts;
+    private readonly delayMs;
+    private readonly jitter;
+    private readonly jitterFactor;
+    private readonly retryableErrors;
+    constructor(config?: FixedDelayConfig);
+    shouldRetry(context: RetryContext): RetryDecision;
+    private applyJitter;
+}
+/**
+ * No retry strategy (fail immediately).
+ *
+ * Best for: Operations that must succeed on first try, testing.
+ */
+export declare class NoRetryStrategy implements IRetryStrategy {
+    readonly name = "NoRetry";
+    shouldRetry(_context: RetryContext): RetryDecision;
+}
+/**
+ * Circuit breaker for preventing cascading failures.
+ *
+ * States:
+ * - CLOSED: Normal operation, requests pass through
+ * - OPEN: Circuit tripped, requests fail immediately
+ * - HALF_OPEN: Testing recovery, limited requests allowed
+ *
+ * Best practices:
+ * - Use with retry strategies for comprehensive fault tolerance
+ * - Monitor circuit state changes for alerting
+ * - Tune thresholds based on service characteristics
+ *
+ * @example
+ * ```typescript
+ * const breaker = new CircuitBreaker({
+ *   failureThreshold: 5,
+ *   resetTimeoutMs: 60000,
+ *   successThreshold: 2
+ * });
+ *
+ * // Check before operation
+ * if (breaker.allowRequest()) {
+ *   const result = await operation();
+ *   if (result.ok) {
+ *     breaker.recordSuccess();
+ *   } else {
+ *     breaker.recordFailure();
+ *   }
+ * }
+ * ```
+ */
+export declare class CircuitBreaker {
+    private state;
+    private consecutiveFailures;
+    private consecutiveSuccesses;
+    private openedAt?;
+    private totalRequests;
+    private totalFailures;
+    private totalSuccesses;
+    private failureTimestamps;
+    private readonly failureThreshold;
+    private readonly resetTimeoutMs;
+    private readonly successThreshold;
+    private readonly windowMs;
+    constructor(config?: CircuitBreakerConfig);
+    /**
+     * Check if request should be allowed through circuit.
+     *
+     * @returns True if request should proceed, false if circuit is open
+     */
+    allowRequest(): boolean;
+    /**
+     * Record a successful operation.
+     */
+    recordSuccess(): void;
+    /**
+     * Record a failed operation.
+     */
+    recordFailure(): void;
+    /**
+     * Get current circuit breaker statistics.
+     */
+    getStats(): CircuitBreakerStats;
+    /**
+     * Reset circuit breaker to initial state.
+     */
+    reset(): void;
+    /**
+     * Force circuit to open (for testing or manual intervention).
+     */
+    forceOpen(): void;
+    /**
+     * Force circuit to close (for testing or manual recovery).
+     */
+    forceClose(): void;
+}
+/**
+ * Factory for creating retry strategies with common configurations.
+ */
+export declare class RetryStrategy {
+    /**
+     * Create exponential backoff strategy.
+     *
+     * @param config - Configuration options
+     * @returns Exponential backoff strategy
+     */
+    static exponentialBackoff(config?: ExponentialBackoffConfig): IRetryStrategy;
+    /**
+     * Create linear backoff strategy.
+     *
+     * @param config - Configuration options
+     * @returns Linear backoff strategy
+     */
+    static linearBackoff(config?: LinearBackoffConfig): IRetryStrategy;
+    /**
+     * Create fixed delay strategy.
+     *
+     * @param config - Configuration options
+     * @returns Fixed delay strategy
+     */
+    static fixedDelay(config?: FixedDelayConfig): IRetryStrategy;
+    /**
+     * Create no retry strategy (fail immediately).
+     *
+     * @returns No retry strategy
+     */
+    static noRetry(): IRetryStrategy;
+    /**
+     * Create aggressive retry strategy for critical operations.
+     *
+     * Config: 5 attempts, 500ms initial, max 10s, exponential backoff.
+     *
+     * @returns Aggressive retry strategy
+     */
+    static aggressive(): IRetryStrategy;
+    /**
+     * Create conservative retry strategy for non-critical operations.
+     *
+     * Config: 2 attempts, 2s initial, max 5s, linear backoff.
+     *
+     * @returns Conservative retry strategy
+     */
+    static conservative(): IRetryStrategy;
+    /**
+     * Create default retry strategy (balanced).
+     *
+     * Config: 3 attempts, 1s initial, max 30s, exponential backoff.
+     *
+     * @returns Default retry strategy
+     */
+    static default(): IRetryStrategy;
+}
+/**
+ * Execute an operation with retry strategy and optional circuit breaker.
+ *
+ * @param operation - Async operation to execute
+ * @param strategy - Retry strategy to use
+ * @param circuitBreaker - Optional circuit breaker
+ * @returns Result of the operation
+ *
+ * @example
+ * ```typescript
+ * const result = await executeWithRetry(
+ *   async () => transport.send(envelope, did),
+ *   RetryStrategy.exponentialBackoff(),
+ *   circuitBreaker
+ * );
+ * ```
+ */
+export declare function executeWithRetry<T>(operation: () => Promise<Result<T, TransportError>>, strategy: IRetryStrategy, circuitBreaker?: CircuitBreaker): Promise<Result<T, TransportError>>;

package/dist-standalone/retry-strategies.js

@@ -0,0 +1 @@
+import{err}from"./_deps/shared/index.js";export class ExponentialBackoffStrategy{name="ExponentialBackoff";maxAttempts;initialDelayMs;maxDelayMs;multiplier;jitter;jitterFactor;retryableErrors;constructor(t={}){this.maxAttempts=t.maxAttempts??3,this.initialDelayMs=t.initialDelayMs??1e3,this.maxDelayMs=t.maxDelayMs??3e4,this.multiplier=t.multiplier??2,this.jitter=t.jitter??!0,this.jitterFactor=t.jitterFactor??.2,this.retryableErrors=t.retryableErrors?new Set(t.retryableErrors):new Set(["SEND_FAILED","NETWORK_ERROR","RECIPIENT_UNREACHABLE","TIMEOUT"])}shouldRetry(t){if(t.attempt>=this.maxAttempts)return{shouldRetry:!1,reason:`Maximum attempts (${this.maxAttempts}) exceeded`};if(!this.retryableErrors.has(t.error))return{shouldRetry:!1,reason:`Error type '${t.error}' is not retryable`};const e=this.initialDelayMs*Math.pow(this.multiplier,t.attempt),s=Math.min(e,this.maxDelayMs),r=this.jitter?this.applyJitter(s):s;return{shouldRetry:!0,delayMs:Math.round(r),reason:`Attempt ${t.attempt+1}/${this.maxAttempts}`}}applyJitter(t){const e=new Uint32Array(1);crypto.getRandomValues(e);return t+(2*(e[0]/4294967295)-1)*(t*this.jitterFactor)}}export class LinearBackoffStrategy{name="LinearBackoff";maxAttempts;delayIncrementMs;initialDelayMs;maxDelayMs;jitter;jitterFactor;retryableErrors;constructor(t={}){this.maxAttempts=t.maxAttempts??3,this.delayIncrementMs=t.delayIncrementMs??1e3,this.initialDelayMs=t.initialDelayMs??1e3,this.maxDelayMs=t.maxDelayMs??3e4,this.jitter=t.jitter??!0,this.jitterFactor=t.jitterFactor??.1,this.retryableErrors=t.retryableErrors?new Set(t.retryableErrors):new Set(["SEND_FAILED","NETWORK_ERROR","RECIPIENT_UNREACHABLE","TIMEOUT"])}shouldRetry(t){if(t.attempt>=this.maxAttempts)return{shouldRetry:!1,reason:`Maximum attempts (${this.maxAttempts}) exceeded`};if(!this.retryableErrors.has(t.error))return{shouldRetry:!1,reason:`Error type '${t.error}' is not retryable`};const e=this.initialDelayMs+t.attempt*this.delayIncrementMs,s=Math.min(e,this.maxDelayMs),r=this.jitter?this.applyJitter(s):s;return{shouldRetry:!0,delayMs:Math.round(r),reason:`Attempt ${t.attempt+1}/${this.maxAttempts}`}}applyJitter(t){const e=new Uint32Array(1);crypto.getRandomValues(e);return t+(2*(e[0]/4294967295)-1)*(t*this.jitterFactor)}}export class FixedDelayStrategy{name="FixedDelay";maxAttempts;delayMs;jitter;jitterFactor;retryableErrors;constructor(t={}){this.maxAttempts=t.maxAttempts??3,this.delayMs=t.delayMs??1e3,this.jitter=t.jitter??!1,this.jitterFactor=t.jitterFactor??.1,this.retryableErrors=t.retryableErrors?new Set(t.retryableErrors):new Set(["SEND_FAILED","NETWORK_ERROR","RECIPIENT_UNREACHABLE","TIMEOUT"])}shouldRetry(t){if(t.attempt>=this.maxAttempts)return{shouldRetry:!1,reason:`Maximum attempts (${this.maxAttempts}) exceeded`};if(!this.retryableErrors.has(t.error))return{shouldRetry:!1,reason:`Error type '${t.error}' is not retryable`};const e=this.jitter?this.applyJitter(this.delayMs):this.delayMs;return{shouldRetry:!0,delayMs:Math.round(e),reason:`Attempt ${t.attempt+1}/${this.maxAttempts}`}}applyJitter(t){const e=new Uint32Array(1);crypto.getRandomValues(e);return t+(2*(e[0]/4294967295)-1)*(t*this.jitterFactor)}}export class NoRetryStrategy{name="NoRetry";shouldRetry(t){return{shouldRetry:!1,reason:"No retry policy - fail immediately"}}}export class CircuitBreaker{state="CLOSED";consecutiveFailures=0;consecutiveSuccesses=0;openedAt;totalRequests=0;totalFailures=0;totalSuccesses=0;failureTimestamps=[];failureThreshold;resetTimeoutMs;successThreshold;windowMs;constructor(t={}){this.failureThreshold=t.failureThreshold??5,this.resetTimeoutMs=t.resetTimeoutMs??6e4,this.successThreshold=t.successThreshold??2,this.windowMs=t.windowMs??6e4}allowRequest(){const t=Date.now();return this.failureTimestamps=this.failureTimestamps.filter(e=>t-e<this.windowMs),"CLOSED"===this.state||("OPEN"!==this.state||!!(this.openedAt&&t-this.openedAt>=this.resetTimeoutMs)&&(this.state="HALF_OPEN",this.consecutiveSuccesses=0,!0))}recordSuccess(){this.totalRequests++,this.totalSuccesses++,this.consecutiveFailures=0,"HALF_OPEN"===this.state&&(this.consecutiveSuccesses++,this.consecutiveSuccesses>=this.successThreshold&&(this.state="CLOSED",this.consecutiveSuccesses=0,this.openedAt=void 0))}recordFailure(){this.totalRequests++,this.totalFailures++,this.consecutiveFailures++,this.consecutiveSuccesses=0;const t=Date.now();if(this.failureTimestamps.push(t),"CLOSED"===this.state||"HALF_OPEN"===this.state){this.failureTimestamps.filter(e=>t-e<this.windowMs).length>=this.failureThreshold&&(this.state="OPEN",this.openedAt=t)}}getStats(){return{state:this.state,consecutiveFailures:this.consecutiveFailures,consecutiveSuccesses:this.consecutiveSuccesses,openedAt:this.openedAt,totalRequests:this.totalRequests,totalFailures:this.totalFailures,totalSuccesses:this.totalSuccesses}}reset(){this.state="CLOSED",this.consecutiveFailures=0,this.consecutiveSuccesses=0,this.openedAt=void 0,this.totalRequests=0,this.totalFailures=0,this.totalSuccesses=0,this.failureTimestamps=[]}forceOpen(){this.state="OPEN",this.openedAt=Date.now()}forceClose(){this.state="CLOSED",this.consecutiveFailures=0,this.consecutiveSuccesses=0,this.openedAt=void 0}}export class RetryStrategy{static exponentialBackoff(t){return new ExponentialBackoffStrategy(t)}static linearBackoff(t){return new LinearBackoffStrategy(t)}static fixedDelay(t){return new FixedDelayStrategy(t)}static noRetry(){return new NoRetryStrategy}static aggressive(){return new ExponentialBackoffStrategy({maxAttempts:5,initialDelayMs:500,maxDelayMs:1e4,multiplier:2,jitter:!0})}static conservative(){return new LinearBackoffStrategy({maxAttempts:2,initialDelayMs:2e3,delayIncrementMs:1e3,maxDelayMs:5e3,jitter:!0})}static default(){return new ExponentialBackoffStrategy({maxAttempts:3,initialDelayMs:1e3,maxDelayMs:3e4,multiplier:2,jitter:!0})}}export async function executeWithRetry(t,e,s){const r=Date.now();let i=0,a="NETWORK_ERROR";for(;;){if(s&&!s.allowRequest())return err("SEND_FAILED");const o=await t();if(o.ok)return s?.recordSuccess(),o;a=o.error,s?.recordFailure();const l={attempt:i,error:a,startTime:r,elapsedMs:Date.now()-r},n=e.shouldRetry(l);if(!n.shouldRetry)return err(a);n.delayMs&&n.delayMs>0&&await sleep(n.delayMs),i++}}function sleep(t){return new Promise(e=>setTimeout(e,t))}

package/dist-standalone/retry-transport.js

@@ -1,98 +1 @@
-/* ── Implementation ── */
-/**
- * Decorator that adds exponential backoff retry logic to any transport adapter.
- *
- * Retry delays follow exponential backoff with jitter:
- * - Formula: 2^attempt * baseDelay + jitter
- * - Jitter: Math.random() * maxJitter * 2 - maxJitter
- * - Default delays: 1s, 2s, 4s (with ±200ms jitter)
- *
- * Use case: Push notification delivery failures requiring automatic retry.
- *
- * @example
- * ```typescript
- * const transport = new RetryTransportAdapter(baseTransport, {
- *   maxRetries: 3,
- *   baseDelayMs: 1000,
- *   maxJitterMs: 200
- * });
- * ```
- */
-export class RetryTransportAdapter {
-    inner;
-    maxRetries;
-    baseDelayMs;
-    maxJitterMs;
-    /**
-     * Create a new RetryTransportAdapter wrapping an existing transport.
-     *
-     * @param inner - The transport adapter to wrap with retry logic
-     * @param options - Retry configuration options
-     */
-    constructor(inner, options = {}) {
-        this.inner = inner;
-        this.maxRetries = options.maxRetries ?? 3;
-        this.baseDelayMs = options.baseDelayMs ?? 1000;
-        this.maxJitterMs = options.maxJitterMs ?? 200;
-    }
-    /**
-     * Send an envelope with exponential backoff retry logic.
-     *
-     * Retries on all error types (SEND_FAILED, NETWORK_ERROR, RECIPIENT_UNREACHABLE, TIMEOUT).
-     * Throws error after all retries are exhausted.
-     *
-     * @param envelope - The envelope to send
-     * @param recipientDid - The recipient's DID
-     * @returns Result with void on success, or TransportError on failure
-     * @throws Error if all retry attempts are exhausted
-     */
-    async send(envelope, recipientDid) {
-        let lastError;
-        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
-            const result = await this.inner.send(envelope, recipientDid);
-            // Success - return immediately
-            if (result.ok) {
-                return result;
-            }
-            // Store error for final throw
-            lastError = result.error;
-            // Don't delay after final attempt
-            if (attempt < this.maxRetries) {
-                // Exponential backoff: 2^attempt * baseDelay + jitter
-                const delay = Math.pow(2, attempt) * this.baseDelayMs;
-                // SAFETY: Using crypto.getRandomValues for OWASP-compliant secure random jitter
-                const jitterArray = new Uint32Array(1);
-                crypto.getRandomValues(jitterArray);
-                const jitter = (jitterArray[0] / 0xffffffff) * this.maxJitterMs * 2 -
-                    this.maxJitterMs;
-                await this.sleep(delay + jitter);
-            }
-        }
-        // All retries exhausted - throw error with clear message
-        throw new Error(`Failed after ${this.maxRetries} retries: ${lastError ?? 'unknown error'}`);
-    }
-    /**
-     * Register a handler for incoming envelopes.
-     * Delegates directly to the inner transport.
-     *
-     * @param handler - The envelope handler function
-     */
-    onReceive(handler) {
-        this.inner.onReceive(handler);
-    }
-    /**
-     * Shut down the transport.
-     * Delegates directly to the inner transport.
-     */
-    dispose() {
-        this.inner.dispose();
-    }
-    /**
-     * Sleep for a specified duration.
-     *
-     * @param ms - Duration in milliseconds
-     */
-    sleep(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-    }
-}
+export class RetryTransportAdapter{inner;maxRetries;baseDelayMs;maxJitterMs;constructor(e,t={}){this.inner=e,this.maxRetries=t.maxRetries??3,this.baseDelayMs=t.baseDelayMs??1e3,this.maxJitterMs=t.maxJitterMs??200}async send(e,t){let s;for(let r=0;r<=this.maxRetries;r++){const i=await this.inner.send(e,t);if(i.ok)return i;if(s=i.error,r<this.maxRetries){const e=Math.pow(2,r)*this.baseDelayMs,t=new Uint32Array(1);crypto.getRandomValues(t);const s=t[0]/4294967295*this.maxJitterMs*2-this.maxJitterMs;await this.sleep(e+s)}}throw new Error(`Failed after ${this.maxRetries} retries: ${s??"unknown error"}`)}onReceive(e){this.inner.onReceive(e)}dispose(){this.inner.dispose()}sleep(e){return new Promise(t=>setTimeout(t,e))}}