@adaptic/utils 0.0.1005 → 0.0.1006

package/dist/index.mjs

@@ -2175,6 +2175,419 @@ function validateAlphaVantageApiKey(apiKey) {
     }
 }
 
+const DEFAULT_RETRY_CONFIG = {
+    maxRetries: 3,
+    baseDelayMs: 1000,
+    maxDelayMs: 30000,
+    retryableStatusCodes: [429, 500, 502, 503, 504],
+    retryOnNetworkError: true,
+};
+/**
+ * Node.js / undici / system error codes that represent transient network
+ * conditions. Present on `error.code` for net/http/dns/undici errors.
+ */
+const RETRYABLE_ERROR_CODES = new Set([
+    "ETIMEDOUT",
+    "ESOCKETTIMEDOUT",
+    "ECONNRESET",
+    "ECONNREFUSED",
+    "EHOSTUNREACH",
+    "ENETUNREACH",
+    "EAI_AGAIN",
+    "EPIPE",
+    "ECONNABORTED",
+    "ENOTFOUND",
+    "UND_ERR_CONNECT_TIMEOUT",
+    "UND_ERR_HEADERS_TIMEOUT",
+    "UND_ERR_BODY_TIMEOUT",
+    "UND_ERR_SOCKET",
+    "UND_ERR_CLOSED",
+    "UND_ERR_REQ_CONTENT_LENGTH_MISMATCH",
+]);
+/**
+ * Error constructor names / `error.name` values that indicate transient
+ * abort / timeout conditions.
+ */
+const RETRYABLE_ERROR_NAMES = new Set([
+    "AbortError",
+    "TimeoutError",
+    "FetchError",
+    "RequestTimeoutError",
+    "ConnectTimeoutError",
+    "HeadersTimeoutError",
+    "BodyTimeoutError",
+]);
+/**
+ * Message-pattern fallback for libraries that discard error codes/names but
+ * preserve text (e.g., some Apollo/axios wrappers).
+ */
+const RETRYABLE_MESSAGE_PATTERNS = [
+    /aborted/i,
+    /timeout/i,
+    /timed out/i,
+    /network error/i,
+    /socket hang up/i,
+    /connection (reset|refused|closed)/i,
+    /ECONNRESET/,
+    /ETIMEDOUT/,
+    /ECONNREFUSED/,
+    /EAI_AGAIN/,
+    /UND_ERR_/,
+];
+/**
+ * Walks the `error.cause` chain (capped to avoid cycles) and tests whether
+ * any link along the chain looks like a transient network error. Modern APIs
+ * (undici, fetch, Apollo Client 3.8+) wrap the root network failure as a
+ * `.cause`, so the surface `Error` may report a generic message while the
+ * actionable signal lives one or more levels deeper.
+ *
+ * Exported for use by downstream consumers (engine services, per-call catch
+ * blocks, application-level loggers) that need to demote recoverable
+ * transient errors from ERROR to WARN. Aligns the whole stack on a single
+ * canonical classifier so MassiveAPI, AlpacaAPI, and application-layer
+ * retry handlers all treat the same network blips identically.
+ */
+function isTransientNetworkError(error) {
+    const MAX_CAUSE_DEPTH = 6;
+    let current = error;
+    for (let depth = 0; depth < MAX_CAUSE_DEPTH && current; depth++) {
+        if (current instanceof Error || typeof current === "object") {
+            const err = current;
+            if (typeof err.name === "string" && RETRYABLE_ERROR_NAMES.has(err.name)) {
+                return true;
+            }
+            if (typeof err.code === "string" && RETRYABLE_ERROR_CODES.has(err.code)) {
+                return true;
+            }
+            if (typeof err.message === "string") {
+                for (const pattern of RETRYABLE_MESSAGE_PATTERNS) {
+                    if (pattern.test(err.message)) {
+                        return true;
+                    }
+                }
+            }
+            current = err.cause;
+        }
+        else {
+            break;
+        }
+    }
+    return false;
+}
+/**
+ * Analyzes an error and determines if it's retryable.
+ * @param error - The error to analyze
+ * @param response - Optional Response object for HTTP errors
+ * @param config - Retry configuration
+ * @returns Structured error details
+ */
+function analyzeError(error, response, config) {
+    // Handle Response objects with error status codes
+    if (response && !response.ok) {
+        const status = response.status;
+        // Rate limit errors - always retryable
+        if (status === 429) {
+            const retryAfterHeader = response.headers.get("Retry-After");
+            const retryAfter = retryAfterHeader
+                ? parseInt(retryAfterHeader, 10) * 1000
+                : undefined;
+            return {
+                type: "RATE_LIMIT",
+                reason: "Rate limit exceeded",
+                status,
+                retryAfter,
+                isRetryable: true,
+            };
+        }
+        // Authentication errors - never retry
+        if (status === 401 || status === 403) {
+            return {
+                type: "AUTH_ERROR",
+                reason: status === 401
+                    ? "Authentication failed - invalid credentials"
+                    : "Access forbidden - insufficient permissions",
+                status,
+                isRetryable: false,
+            };
+        }
+        // Server errors - check if in retryable list
+        if (status >= 500 && status < 600) {
+            return {
+                type: "SERVER_ERROR",
+                reason: `Server error (${status})`,
+                status,
+                isRetryable: config.retryableStatusCodes.includes(status),
+            };
+        }
+        // Other client errors - never retry
+        if (status >= 400 && status < 500) {
+            return {
+                type: "CLIENT_ERROR",
+                reason: `Client error (${status})`,
+                status,
+                isRetryable: false,
+            };
+        }
+    }
+    // Handle network errors (TypeError from fetch API)
+    if (error instanceof TypeError && error.message.includes("fetch")) {
+        return {
+            type: "NETWORK_ERROR",
+            reason: "Network connectivity issue",
+            status: null,
+            isRetryable: config.retryOnNetworkError,
+        };
+    }
+    // Handle transient network conditions: AbortError, TimeoutError,
+    // Node/undici error codes (ETIMEDOUT, ECONNRESET, UND_ERR_*), and
+    // wrapped failures exposed via error.cause. This catches the broad class
+    // of infrastructure flakes that the TypeError-only check above misses.
+    if (isTransientNetworkError(error)) {
+        const reason = error instanceof Error ? error.message : "Transient network error";
+        return {
+            type: "NETWORK_ERROR",
+            reason,
+            status: null,
+            isRetryable: config.retryOnNetworkError,
+        };
+    }
+    // Handle error objects with messages
+    if (error instanceof Error) {
+        // Parse error messages that might contain status information
+        if (error.message.includes("429") || error.message.includes("RATE_LIMIT")) {
+            const match = error.message.match(/RATE_LIMIT: 429:(\d+)/);
+            const retryAfter = match ? parseInt(match[1], 10) : undefined;
+            return {
+                type: "RATE_LIMIT",
+                reason: "Rate limit exceeded",
+                status: 429,
+                retryAfter,
+                isRetryable: true,
+            };
+        }
+        if (error.message.includes("401") ||
+            error.message.includes("403") ||
+            error.message.includes("AUTH_ERROR")) {
+            const status = error.message.includes("401") ? 401 : 403;
+            return {
+                type: "AUTH_ERROR",
+                reason: `Authentication error (${status})`,
+                status,
+                isRetryable: false,
+            };
+        }
+        if (error.message.includes("SERVER_ERROR") ||
+            error.message.match(/50[0-9]/)) {
+            const statusMatch = error.message.match(/50[0-9]/);
+            const status = statusMatch ? parseInt(statusMatch[0], 10) : 500;
+            return {
+                type: "SERVER_ERROR",
+                reason: `Server error (${status})`,
+                status,
+                isRetryable: config.retryableStatusCodes.includes(status),
+            };
+        }
+        if (error.message.includes("network") ||
+            error.message.includes("NETWORK_ERROR")) {
+            return {
+                type: "NETWORK_ERROR",
+                reason: error.message,
+                status: null,
+                isRetryable: config.retryOnNetworkError,
+            };
+        }
+    }
+    // Unknown error - not retryable by default for safety
+    return {
+        type: "UNKNOWN",
+        reason: error instanceof Error ? error.message : String(error),
+        status: null,
+        isRetryable: false,
+    };
+}
+/**
+ * Calculates the delay before the next retry attempt using exponential backoff with jitter.
+ * @param attempt - Current attempt number (1-indexed)
+ * @param baseDelay - Base delay in milliseconds
+ * @param maxDelay - Maximum delay in milliseconds
+ * @returns Delay in milliseconds
+ */
+function calculateBackoff(attempt, baseDelay, maxDelay) {
+    // Exponential backoff: baseDelay * 2^(attempt-1)
+    const exponentialDelay = baseDelay * Math.pow(2, attempt - 1);
+    // Cap at maxDelay
+    const cappedDelay = Math.min(exponentialDelay, maxDelay);
+    // Add jitter (random value between 0% and 25% of the delay)
+    const jitter = Math.random() * cappedDelay * 0.25;
+    return Math.floor(cappedDelay + jitter);
+}
+/**
+ * Wraps an async function with retry logic and exponential backoff.
+ *
+ * This utility handles transient errors in external API calls by automatically retrying
+ * failed requests with intelligent backoff strategies. It respects rate limit headers,
+ * fails fast on non-retryable errors, and provides detailed logging.
+ *
+ * @template T - The return type of the wrapped function
+ * @param fn - The async function to wrap with retry logic
+ * @param config - Retry configuration (merged with defaults)
+ * @param label - A descriptive label for logging (e.g., 'Massive.fetchTickerInfo')
+ * @returns A promise that resolves to the function's return value
+ * @throws The last error encountered if all retries are exhausted
+ *
+ * @example
+ * ```typescript
+ * // Basic usage with defaults
+ * const data = await withRetry(
+ *   async () => fetch('https://api.example.com/data'),
+ *   {},
+ *   'ExampleAPI.fetchData'
+ * );
+ *
+ * // Custom configuration for rate-limited API
+ * const result = await withRetry(
+ *   async () => alphaVantageAPI.getQuote(symbol),
+ *   {
+ *     maxRetries: 5,
+ *     baseDelayMs: 5000,
+ *     maxDelayMs: 60000,
+ *     onRetry: (attempt, error) => {
+ *       getLogger().info(`Retry ${attempt} after error:`, error);
+ *     }
+ *   },
+ *   'AlphaVantage.getQuote'
+ * );
+ * ```
+ */
+async function withRetry(fn, config = {}, label = "unknown") {
+    const fullConfig = { ...DEFAULT_RETRY_CONFIG, ...config };
+    let lastError;
+    for (let attempt = 1; attempt <= fullConfig.maxRetries; attempt++) {
+        try {
+            const result = await fn();
+            // If we succeeded after retries, log it
+            if (attempt > 1) {
+                getLogger().info(`[${label}] Succeeded on attempt ${attempt}/${fullConfig.maxRetries}`);
+            }
+            return result;
+        }
+        catch (error) {
+            lastError = error;
+            // If this is the last attempt, throw the error.
+            // Transient network classes (undici/fetch timeouts, ECONNRESET,
+            // AbortError, etc.) are self-healing at the upstream retry layer —
+            // the caller re-invokes on the next refresh/poll tick. Logging them
+            // at ERROR produces alert noise that does not represent actionable
+            // failures. Demote the transient class to WARN with a recovery hint;
+            // reserve ERROR for non-transient final failures (auth, schema,
+            // contract violations, unknown classes).
+            if (attempt === fullConfig.maxRetries) {
+                const isTransient = isTransientNetworkError(error);
+                const logMeta = {
+                    error: error instanceof Error ? error.message : String(error),
+                    attempts: fullConfig.maxRetries,
+                    timestamp: new Date().toISOString(),
+                    ...(isTransient
+                        ? {
+                            transient: true,
+                            recoveryHint: "Upstream caller should retry on next cycle",
+                        }
+                        : {}),
+                };
+                if (isTransient) {
+                    getLogger().warn(`[${label}] Failed after ${fullConfig.maxRetries} attempts (transient)`, logMeta);
+                }
+                else {
+                    getLogger().error(`[${label}] Failed after ${fullConfig.maxRetries} attempts`, logMeta);
+                }
+                throw error;
+            }
+            // Analyze the error to determine if we should retry
+            const response = error instanceof Response ? error : null;
+            const errorDetails = analyzeError(error, response, fullConfig);
+            // If error is not retryable, fail immediately
+            if (!errorDetails.isRetryable) {
+                getLogger().error(`[${label}] Non-retryable error (${errorDetails.type})`, {
+                    reason: errorDetails.reason,
+                    status: errorDetails.status,
+                    timestamp: new Date().toISOString(),
+                });
+                throw error;
+            }
+            // Calculate delay for next retry
+            let delayMs;
+            if (errorDetails.type === "RATE_LIMIT" && errorDetails.retryAfter) {
+                // Use Retry-After header if available
+                delayMs = errorDetails.retryAfter;
+            }
+            else if (errorDetails.type === "RATE_LIMIT") {
+                // For rate limits without Retry-After, use a longer minimum delay
+                delayMs = Math.max(calculateBackoff(attempt, fullConfig.baseDelayMs, fullConfig.maxDelayMs), 5000);
+            }
+            else {
+                // Standard exponential backoff with jitter
+                delayMs = calculateBackoff(attempt, fullConfig.baseDelayMs, fullConfig.maxDelayMs);
+            }
+            // Log the retry attempt
+            getLogger().warn(`[${label}] Attempt ${attempt}/${fullConfig.maxRetries} failed: ${errorDetails.reason}. Retrying in ${delayMs}ms...`, {
+                attemptNumber: attempt,
+                totalRetries: fullConfig.maxRetries,
+                errorType: errorDetails.type,
+                httpStatus: errorDetails.status,
+                retryDelay: delayMs,
+                timestamp: new Date().toISOString(),
+            });
+            // Call the optional retry callback
+            if (fullConfig.onRetry) {
+                fullConfig.onRetry(attempt, error);
+            }
+            // Wait before retrying
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+    }
+    // This should never be reached due to the throw in the last attempt,
+    // but TypeScript needs this to satisfy the return type
+    throw lastError;
+}
+/**
+ * API-specific retry configurations for different external services.
+ * These configurations are tuned based on each API's rate limits and characteristics.
+ */
+const API_RETRY_CONFIGS = {
+    /** Massive.com API - 5 requests/second rate limit */
+    MASSIVE: {
+        maxRetries: 3,
+        baseDelayMs: 1000,
+        maxDelayMs: 30000,
+        retryableStatusCodes: [429, 500, 502, 503, 504],
+        retryOnNetworkError: true,
+    },
+    /** Alpha Vantage API - 5 requests/minute rate limit (more strict) */
+    ALPHA_VANTAGE: {
+        maxRetries: 5,
+        baseDelayMs: 5000,
+        maxDelayMs: 60000,
+        retryableStatusCodes: [429, 500, 502, 503, 504],
+        retryOnNetworkError: true,
+    },
+    /** Alpaca API - generally reliable, shorter retry window */
+    ALPACA: {
+        maxRetries: 3,
+        baseDelayMs: 1000,
+        maxDelayMs: 30000,
+        retryableStatusCodes: [429, 500, 502, 503, 504],
+        retryOnNetworkError: true,
+    },
+    /** Generic crypto API configuration */
+    CRYPTO: {
+        maxRetries: 3,
+        baseDelayMs: 1000,
+        maxDelayMs: 30000,
+        retryableStatusCodes: [429, 500, 502, 503, 504],
+        retryOnNetworkError: true,
+    },
+};
+
 /**
  * Structured error type hierarchy for all API integrations
  *
@@ -2719,6 +3132,32 @@ const rateLimiters = {
     }),
 };
 
+/**
+ * Bounded retry for TRANSIENT network faults on Alpaca market-data reads.
+ *
+ * 2026-07-30: the engine logged 637 `TypeError: fetch failed` / `read
+ * ECONNRESET` errors against `/v2/stocks/bars` in a single session (~4 per
+ * minute). Every OTHER Alpaca/Massive client in this package already routes
+ * transient faults through {@link isTransientNetworkError} — this client was
+ * the one that never adopted it, so a single reset socket killed the whole
+ * read. Those failures surface in the engine's market-tape prompt context and
+ * its intraday direction/path resolvers, so the decision model judged with a
+ * blind tape: raw confidence collapsed from a 0.677 median to a degenerate
+ * ~0.504 band, the entire distribution fell below the 0.55 admission floor,
+ * and live participation went to near zero.
+ *
+ * `ECONNRESET` on a keep-alive pool is the classic idle-socket race — the
+ * server closes a pooled connection while the client dispatches onto it. It
+ * is transient by construction and safe to retry on an idempotent GET.
+ */
+const TRANSIENT_NETWORK_RETRY_ATTEMPTS = 3;
+/** Base backoff (ms); doubled per attempt with full jitter. */
+const TRANSIENT_NETWORK_RETRY_BASE_MS = 120;
+/** Full-jitter backoff so concurrent fan-out retries do not resonate. */
+function transientRetryDelayMs(attempt) {
+    const ceiling = TRANSIENT_NETWORK_RETRY_BASE_MS * 2 ** attempt;
+    return Math.floor(Math.random() * ceiling);
+}
 const log$l = (message, options = { type: "info" }) => {
     log$m(message, { ...options, source: "AlpacaMarketDataAPI" });
 };
@@ -3229,11 +3668,42 @@ class AlpacaMarketDataAPI extends EventEmitter {
             // can't overrun Alpaca's server-side rate limit. Prior to this, parallel
             // historical-bar fan-out produced ~125 server-side 429s per minute.
             await rateLimiters.alpaca.acquire();
-            const response = await fetch(url.toString(), {
-                method,
-                headers: this.headers,
-                signal: createTimeoutSignal(DEFAULT_TIMEOUTS.ALPACA_API),
-            });
+            // Retry ONLY transient connection faults, and only on GET (every
+            // market-data read here is idempotent). A non-2xx response is a real
+            // answer from Alpaca and is never retried — that path still throws on
+            // the first attempt exactly as before.
+            let response;
+            let lastNetworkError;
+            for (let attempt = 0; attempt < TRANSIENT_NETWORK_RETRY_ATTEMPTS; attempt += 1) {
+                try {
+                    response = await fetch(url.toString(), {
+                        method,
+                        headers: this.headers,
+                        signal: createTimeoutSignal(DEFAULT_TIMEOUTS.ALPACA_API),
+                    });
+                    break;
+                }
+                catch (networkErr) {
+                    lastNetworkError = networkErr;
+                    const retryable = method === "GET" &&
+                        isTransientNetworkError(networkErr) &&
+                        attempt < TRANSIENT_NETWORK_RETRY_ATTEMPTS - 1;
+                    if (!retryable) {
+                        throw networkErr;
+                    }
+                    const delayMs = transientRetryDelayMs(attempt);
+                    log$l(`Transient network fault on ${endpoint} (attempt ${attempt + 1}/${TRANSIENT_NETWORK_RETRY_ATTEMPTS}); retrying in ${delayMs}ms`, { type: "warn" });
+                    await new Promise((resolve) => setTimeout(resolve, delayMs));
+                    // Re-acquire the rate-limit token so a retry storm cannot overrun
+                    // Alpaca's server-side limit.
+                    await rateLimiters.alpaca.acquire();
+                }
+            }
+            if (!response) {
+                throw lastNetworkError instanceof Error
+                    ? lastNetworkError
+                    : new Error(`Market Data API request failed for ${endpoint}`);
+            }
             if (!response.ok) {
                 const errorText = await response.text();
                 log$l(`Market Data API error (${response.status}): ${errorText}`, {
@@ -3965,419 +4435,6 @@ class AlpacaMarketDataAPI extends EventEmitter {
 // Export the singleton instance
 const marketDataAPI = AlpacaMarketDataAPI.getInstance();
 
-const DEFAULT_RETRY_CONFIG = {
-    maxRetries: 3,
-    baseDelayMs: 1000,
-    maxDelayMs: 30000,
-    retryableStatusCodes: [429, 500, 502, 503, 504],
-    retryOnNetworkError: true,
-};
-/**
- * Node.js / undici / system error codes that represent transient network
- * conditions. Present on `error.code` for net/http/dns/undici errors.
- */
-const RETRYABLE_ERROR_CODES = new Set([
-    "ETIMEDOUT",
-    "ESOCKETTIMEDOUT",
-    "ECONNRESET",
-    "ECONNREFUSED",
-    "EHOSTUNREACH",
-    "ENETUNREACH",
-    "EAI_AGAIN",
-    "EPIPE",
-    "ECONNABORTED",
-    "ENOTFOUND",
-    "UND_ERR_CONNECT_TIMEOUT",
-    "UND_ERR_HEADERS_TIMEOUT",
-    "UND_ERR_BODY_TIMEOUT",
-    "UND_ERR_SOCKET",
-    "UND_ERR_CLOSED",
-    "UND_ERR_REQ_CONTENT_LENGTH_MISMATCH",
-]);
-/**
- * Error constructor names / `error.name` values that indicate transient
- * abort / timeout conditions.
- */
-const RETRYABLE_ERROR_NAMES = new Set([
-    "AbortError",
-    "TimeoutError",
-    "FetchError",
-    "RequestTimeoutError",
-    "ConnectTimeoutError",
-    "HeadersTimeoutError",
-    "BodyTimeoutError",
-]);
-/**
- * Message-pattern fallback for libraries that discard error codes/names but
- * preserve text (e.g., some Apollo/axios wrappers).
- */
-const RETRYABLE_MESSAGE_PATTERNS = [
-    /aborted/i,
-    /timeout/i,
-    /timed out/i,
-    /network error/i,
-    /socket hang up/i,
-    /connection (reset|refused|closed)/i,
-    /ECONNRESET/,
-    /ETIMEDOUT/,
-    /ECONNREFUSED/,
-    /EAI_AGAIN/,
-    /UND_ERR_/,
-];
-/**
- * Walks the `error.cause` chain (capped to avoid cycles) and tests whether
- * any link along the chain looks like a transient network error. Modern APIs
- * (undici, fetch, Apollo Client 3.8+) wrap the root network failure as a
- * `.cause`, so the surface `Error` may report a generic message while the
- * actionable signal lives one or more levels deeper.
- *
- * Exported for use by downstream consumers (engine services, per-call catch
- * blocks, application-level loggers) that need to demote recoverable
- * transient errors from ERROR to WARN. Aligns the whole stack on a single
- * canonical classifier so MassiveAPI, AlpacaAPI, and application-layer
- * retry handlers all treat the same network blips identically.
- */
-function isTransientNetworkError(error) {
-    const MAX_CAUSE_DEPTH = 6;
-    let current = error;
-    for (let depth = 0; depth < MAX_CAUSE_DEPTH && current; depth++) {
-        if (current instanceof Error || typeof current === "object") {
-            const err = current;
-            if (typeof err.name === "string" && RETRYABLE_ERROR_NAMES.has(err.name)) {
-                return true;
-            }
-            if (typeof err.code === "string" && RETRYABLE_ERROR_CODES.has(err.code)) {
-                return true;
-            }
-            if (typeof err.message === "string") {
-                for (const pattern of RETRYABLE_MESSAGE_PATTERNS) {
-                    if (pattern.test(err.message)) {
-                        return true;
-                    }
-                }
-            }
-            current = err.cause;
-        }
-        else {
-            break;
-        }
-    }
-    return false;
-}
-/**
- * Analyzes an error and determines if it's retryable.
- * @param error - The error to analyze
- * @param response - Optional Response object for HTTP errors
- * @param config - Retry configuration
- * @returns Structured error details
- */
-function analyzeError(error, response, config) {
-    // Handle Response objects with error status codes
-    if (response && !response.ok) {
-        const status = response.status;
-        // Rate limit errors - always retryable
-        if (status === 429) {
-            const retryAfterHeader = response.headers.get("Retry-After");
-            const retryAfter = retryAfterHeader
-                ? parseInt(retryAfterHeader, 10) * 1000
-                : undefined;
-            return {
-                type: "RATE_LIMIT",
-                reason: "Rate limit exceeded",
-                status,
-                retryAfter,
-                isRetryable: true,
-            };
-        }
-        // Authentication errors - never retry
-        if (status === 401 || status === 403) {
-            return {
-                type: "AUTH_ERROR",
-                reason: status === 401
-                    ? "Authentication failed - invalid credentials"
-                    : "Access forbidden - insufficient permissions",
-                status,
-                isRetryable: false,
-            };
-        }
-        // Server errors - check if in retryable list
-        if (status >= 500 && status < 600) {
-            return {
-                type: "SERVER_ERROR",
-                reason: `Server error (${status})`,
-                status,
-                isRetryable: config.retryableStatusCodes.includes(status),
-            };
-        }
-        // Other client errors - never retry
-        if (status >= 400 && status < 500) {
-            return {
-                type: "CLIENT_ERROR",
-                reason: `Client error (${status})`,
-                status,
-                isRetryable: false,
-            };
-        }
-    }
-    // Handle network errors (TypeError from fetch API)
-    if (error instanceof TypeError && error.message.includes("fetch")) {
-        return {
-            type: "NETWORK_ERROR",
-            reason: "Network connectivity issue",
-            status: null,
-            isRetryable: config.retryOnNetworkError,
-        };
-    }
-    // Handle transient network conditions: AbortError, TimeoutError,
-    // Node/undici error codes (ETIMEDOUT, ECONNRESET, UND_ERR_*), and
-    // wrapped failures exposed via error.cause. This catches the broad class
-    // of infrastructure flakes that the TypeError-only check above misses.
-    if (isTransientNetworkError(error)) {
-        const reason = error instanceof Error ? error.message : "Transient network error";
-        return {
-            type: "NETWORK_ERROR",
-            reason,
-            status: null,
-            isRetryable: config.retryOnNetworkError,
-        };
-    }
-    // Handle error objects with messages
-    if (error instanceof Error) {
-        // Parse error messages that might contain status information
-        if (error.message.includes("429") || error.message.includes("RATE_LIMIT")) {
-            const match = error.message.match(/RATE_LIMIT: 429:(\d+)/);
-            const retryAfter = match ? parseInt(match[1], 10) : undefined;
-            return {
-                type: "RATE_LIMIT",
-                reason: "Rate limit exceeded",
-                status: 429,
-                retryAfter,
-                isRetryable: true,
-            };
-        }
-        if (error.message.includes("401") ||
-            error.message.includes("403") ||
-            error.message.includes("AUTH_ERROR")) {
-            const status = error.message.includes("401") ? 401 : 403;
-            return {
-                type: "AUTH_ERROR",
-                reason: `Authentication error (${status})`,
-                status,
-                isRetryable: false,
-            };
-        }
-        if (error.message.includes("SERVER_ERROR") ||
-            error.message.match(/50[0-9]/)) {
-            const statusMatch = error.message.match(/50[0-9]/);
-            const status = statusMatch ? parseInt(statusMatch[0], 10) : 500;
-            return {
-                type: "SERVER_ERROR",
-                reason: `Server error (${status})`,
-                status,
-                isRetryable: config.retryableStatusCodes.includes(status),
-            };
-        }
-        if (error.message.includes("network") ||
-            error.message.includes("NETWORK_ERROR")) {
-            return {
-                type: "NETWORK_ERROR",
-                reason: error.message,
-                status: null,
-                isRetryable: config.retryOnNetworkError,
-            };
-        }
-    }
-    // Unknown error - not retryable by default for safety
-    return {
-        type: "UNKNOWN",
-        reason: error instanceof Error ? error.message : String(error),
-        status: null,
-        isRetryable: false,
-    };
-}
-/**
- * Calculates the delay before the next retry attempt using exponential backoff with jitter.
- * @param attempt - Current attempt number (1-indexed)
- * @param baseDelay - Base delay in milliseconds
- * @param maxDelay - Maximum delay in milliseconds
- * @returns Delay in milliseconds
- */
-function calculateBackoff(attempt, baseDelay, maxDelay) {
-    // Exponential backoff: baseDelay * 2^(attempt-1)
-    const exponentialDelay = baseDelay * Math.pow(2, attempt - 1);
-    // Cap at maxDelay
-    const cappedDelay = Math.min(exponentialDelay, maxDelay);
-    // Add jitter (random value between 0% and 25% of the delay)
-    const jitter = Math.random() * cappedDelay * 0.25;
-    return Math.floor(cappedDelay + jitter);
-}
-/**
- * Wraps an async function with retry logic and exponential backoff.
- *
- * This utility handles transient errors in external API calls by automatically retrying
- * failed requests with intelligent backoff strategies. It respects rate limit headers,
- * fails fast on non-retryable errors, and provides detailed logging.
- *
- * @template T - The return type of the wrapped function
- * @param fn - The async function to wrap with retry logic
- * @param config - Retry configuration (merged with defaults)
- * @param label - A descriptive label for logging (e.g., 'Massive.fetchTickerInfo')
- * @returns A promise that resolves to the function's return value
- * @throws The last error encountered if all retries are exhausted
- *
- * @example
- * ```typescript
- * // Basic usage with defaults
- * const data = await withRetry(
- *   async () => fetch('https://api.example.com/data'),
- *   {},
- *   'ExampleAPI.fetchData'
- * );
- *
- * // Custom configuration for rate-limited API
- * const result = await withRetry(
- *   async () => alphaVantageAPI.getQuote(symbol),
- *   {
- *     maxRetries: 5,
- *     baseDelayMs: 5000,
- *     maxDelayMs: 60000,
- *     onRetry: (attempt, error) => {
- *       getLogger().info(`Retry ${attempt} after error:`, error);
- *     }
- *   },
- *   'AlphaVantage.getQuote'
- * );
- * ```
- */
-async function withRetry(fn, config = {}, label = "unknown") {
-    const fullConfig = { ...DEFAULT_RETRY_CONFIG, ...config };
-    let lastError;
-    for (let attempt = 1; attempt <= fullConfig.maxRetries; attempt++) {
-        try {
-            const result = await fn();
-            // If we succeeded after retries, log it
-            if (attempt > 1) {
-                getLogger().info(`[${label}] Succeeded on attempt ${attempt}/${fullConfig.maxRetries}`);
-            }
-            return result;
-        }
-        catch (error) {
-            lastError = error;
-            // If this is the last attempt, throw the error.
-            // Transient network classes (undici/fetch timeouts, ECONNRESET,
-            // AbortError, etc.) are self-healing at the upstream retry layer —
-            // the caller re-invokes on the next refresh/poll tick. Logging them
-            // at ERROR produces alert noise that does not represent actionable
-            // failures. Demote the transient class to WARN with a recovery hint;
-            // reserve ERROR for non-transient final failures (auth, schema,
-            // contract violations, unknown classes).
-            if (attempt === fullConfig.maxRetries) {
-                const isTransient = isTransientNetworkError(error);
-                const logMeta = {
-                    error: error instanceof Error ? error.message : String(error),
-                    attempts: fullConfig.maxRetries,
-                    timestamp: new Date().toISOString(),
-                    ...(isTransient
-                        ? {
-                            transient: true,
-                            recoveryHint: "Upstream caller should retry on next cycle",
-                        }
-                        : {}),
-                };
-                if (isTransient) {
-                    getLogger().warn(`[${label}] Failed after ${fullConfig.maxRetries} attempts (transient)`, logMeta);
-                }
-                else {
-                    getLogger().error(`[${label}] Failed after ${fullConfig.maxRetries} attempts`, logMeta);
-                }
-                throw error;
-            }
-            // Analyze the error to determine if we should retry
-            const response = error instanceof Response ? error : null;
-            const errorDetails = analyzeError(error, response, fullConfig);
-            // If error is not retryable, fail immediately
-            if (!errorDetails.isRetryable) {
-                getLogger().error(`[${label}] Non-retryable error (${errorDetails.type})`, {
-                    reason: errorDetails.reason,
-                    status: errorDetails.status,
-                    timestamp: new Date().toISOString(),
-                });
-                throw error;
-            }
-            // Calculate delay for next retry
-            let delayMs;
-            if (errorDetails.type === "RATE_LIMIT" && errorDetails.retryAfter) {
-                // Use Retry-After header if available
-                delayMs = errorDetails.retryAfter;
-            }
-            else if (errorDetails.type === "RATE_LIMIT") {
-                // For rate limits without Retry-After, use a longer minimum delay
-                delayMs = Math.max(calculateBackoff(attempt, fullConfig.baseDelayMs, fullConfig.maxDelayMs), 5000);
-            }
-            else {
-                // Standard exponential backoff with jitter
-                delayMs = calculateBackoff(attempt, fullConfig.baseDelayMs, fullConfig.maxDelayMs);
-            }
-            // Log the retry attempt
-            getLogger().warn(`[${label}] Attempt ${attempt}/${fullConfig.maxRetries} failed: ${errorDetails.reason}. Retrying in ${delayMs}ms...`, {
-                attemptNumber: attempt,
-                totalRetries: fullConfig.maxRetries,
-                errorType: errorDetails.type,
-                httpStatus: errorDetails.status,
-                retryDelay: delayMs,
-                timestamp: new Date().toISOString(),
-            });
-            // Call the optional retry callback
-            if (fullConfig.onRetry) {
-                fullConfig.onRetry(attempt, error);
-            }
-            // Wait before retrying
-            await new Promise((resolve) => setTimeout(resolve, delayMs));
-        }
-    }
-    // This should never be reached due to the throw in the last attempt,
-    // but TypeScript needs this to satisfy the return type
-    throw lastError;
-}
-/**
- * API-specific retry configurations for different external services.
- * These configurations are tuned based on each API's rate limits and characteristics.
- */
-const API_RETRY_CONFIGS = {
-    /** Massive.com API - 5 requests/second rate limit */
-    MASSIVE: {
-        maxRetries: 3,
-        baseDelayMs: 1000,
-        maxDelayMs: 30000,
-        retryableStatusCodes: [429, 500, 502, 503, 504],
-        retryOnNetworkError: true,
-    },
-    /** Alpha Vantage API - 5 requests/minute rate limit (more strict) */
-    ALPHA_VANTAGE: {
-        maxRetries: 5,
-        baseDelayMs: 5000,
-        maxDelayMs: 60000,
-        retryableStatusCodes: [429, 500, 502, 503, 504],
-        retryOnNetworkError: true,
-    },
-    /** Alpaca API - generally reliable, shorter retry window */
-    ALPACA: {
-        maxRetries: 3,
-        baseDelayMs: 1000,
-        maxDelayMs: 30000,
-        retryableStatusCodes: [429, 500, 502, 503, 504],
-        retryOnNetworkError: true,
-    },
-    /** Generic crypto API configuration */
-    CRYPTO: {
-        maxRetries: 3,
-        baseDelayMs: 1000,
-        maxDelayMs: 30000,
-        retryableStatusCodes: [429, 500, 502, 503, 504],
-        retryOnNetworkError: true,
-    },
-};
-
 const limitPriceSlippagePercent100 = 0.1; // 0.1%
 /**
  * Alpaca's maximum page size for GET /orders — also our explicit default.
@@ -14561,17 +14618,17 @@ var hasRequiredBrowser;
 function requireBrowser () {
 	if (hasRequiredBrowser) return browser.exports;
 	hasRequiredBrowser = 1;
-	(function (module, exports) {
+	(function (module, exports$1) {
 		/**
 		 * This is the web browser implementation of `debug()`.
 		 */
 
-		exports.formatArgs = formatArgs;
-		exports.save = save;
-		exports.load = load;
-		exports.useColors = useColors;
-		exports.storage = localstorage();
-		exports.destroy = (() => {
+		exports$1.formatArgs = formatArgs;
+		exports$1.save = save;
+		exports$1.load = load;
+		exports$1.useColors = useColors;
+		exports$1.storage = localstorage();
+		exports$1.destroy = (() => {
 			let warned = false;
 
 			return () => {
@@ -14586,7 +14643,7 @@ function requireBrowser () {
 		 * Colors.
 		 */
 
-		exports.colors = [
+		exports$1.colors = [
 			'#0000CC',
 			'#0000FF',
 			'#0033CC',
@@ -14751,7 +14808,7 @@ function requireBrowser () {
 		 *
 		 * @api public
 		 */
-		exports.log = console.debug || console.log || (() => {});
+		exports$1.log = console.debug || console.log || (() => {});
 
 		/**
 		 * Save `namespaces`.
@@ -14762,9 +14819,9 @@ function requireBrowser () {
 		function save(namespaces) {
 			try {
 				if (namespaces) {
-					exports.storage.setItem('debug', namespaces);
+					exports$1.storage.setItem('debug', namespaces);
 				} else {
-					exports.storage.removeItem('debug');
+					exports$1.storage.removeItem('debug');
 				}
 			} catch (error) {
 				// Swallow
@@ -14781,7 +14838,7 @@ function requireBrowser () {
 		function load() {
 			let r;
 			try {
-				r = exports.storage.getItem('debug') || exports.storage.getItem('DEBUG') ;
+				r = exports$1.storage.getItem('debug') || exports$1.storage.getItem('DEBUG') ;
 			} catch (error) {
 				// Swallow
 				// XXX (@Qix-) should we be logging these?
@@ -14817,7 +14874,7 @@ function requireBrowser () {
 			}
 		}
 
-		module.exports = requireCommon()(exports);
+		module.exports = requireCommon()(exports$1);
 
 		const {formatters} = module.exports;
 
@@ -15006,7 +15063,7 @@ var hasRequiredNode$1;
 function requireNode$1 () {
 	if (hasRequiredNode$1) return node$1.exports;
 	hasRequiredNode$1 = 1;
-	(function (module, exports) {
+	(function (module, exports$1) {
 		const tty = require$$1$1;
 		const util = require$$1$2;
 
@@ -15014,13 +15071,13 @@ function requireNode$1 () {
 		 * This is the Node.js implementation of `debug()`.
 		 */
 
-		exports.init = init;
-		exports.log = log;
-		exports.formatArgs = formatArgs;
-		exports.save = save;
-		exports.load = load;
-		exports.useColors = useColors;
-		exports.destroy = util.deprecate(
+		exports$1.init = init;
+		exports$1.log = log;
+		exports$1.formatArgs = formatArgs;
+		exports$1.save = save;
+		exports$1.load = load;
+		exports$1.useColors = useColors;
+		exports$1.destroy = util.deprecate(
 			() => {},
 			'Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.'
 		);
@@ -15029,7 +15086,7 @@ function requireNode$1 () {
 		 * Colors.
 		 */
 
-		exports.colors = [6, 2, 3, 4, 5, 1];
+		exports$1.colors = [6, 2, 3, 4, 5, 1];
 
 		try {
 			// Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json)
@@ -15037,7 +15094,7 @@ function requireNode$1 () {
 			const supportsColor = requireSupportsColor();
 
 			if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
-				exports.colors = [
+				exports$1.colors = [
 					20,
 					21,
 					26,
@@ -15126,7 +15183,7 @@ function requireNode$1 () {
 		 *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
 		 */
 
-		exports.inspectOpts = Object.keys(process.env).filter(key => {
+		exports$1.inspectOpts = Object.keys(process.env).filter(key => {
 			return /^debug_/i.test(key);
 		}).reduce((obj, key) => {
 			// Camel-case
@@ -15158,8 +15215,8 @@ function requireNode$1 () {
 		 */
 
 		function useColors() {
-			return 'colors' in exports.inspectOpts ?
-				Boolean(exports.inspectOpts.colors) :
+			return 'colors' in exports$1.inspectOpts ?
+				Boolean(exports$1.inspectOpts.colors) :
 				tty.isatty(process.stderr.fd);
 		}
 
@@ -15185,7 +15242,7 @@ function requireNode$1 () {
 		}
 
 		function getDate() {
-			if (exports.inspectOpts.hideDate) {
+			if (exports$1.inspectOpts.hideDate) {
 				return '';
 			}
 			return new Date().toISOString() + ' ';
@@ -15196,7 +15253,7 @@ function requireNode$1 () {
 		 */
 
 		function log(...args) {
-			return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + '\n');
+			return process.stderr.write(util.formatWithOptions(exports$1.inspectOpts, ...args) + '\n');
 		}
 
 		/**
@@ -15236,13 +15293,13 @@ function requireNode$1 () {
 		function init(debug) {
 			debug.inspectOpts = {};
 
-			const keys = Object.keys(exports.inspectOpts);
+			const keys = Object.keys(exports$1.inspectOpts);
 			for (let i = 0; i < keys.length; i++) {
-				debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+				debug.inspectOpts[keys[i]] = exports$1.inspectOpts[keys[i]];
 			}
 		}
 
-		module.exports = requireCommon()(exports);
+		module.exports = requireCommon()(exports$1);
 
 		const {formatters} = module.exports;
 
@@ -15816,7 +15873,7 @@ function requireFollowRedirects () {
 	// Wraps the key/value object of protocols with redirect functionality
 	function wrap(protocols) {
 	  // Default settings
-	  var exports = {
+	  var exports$1 = {
 	    maxRedirects: 21,
 	    maxBodyLength: 10 * 1024 * 1024,
 	  };
@@ -15826,7 +15883,7 @@ function requireFollowRedirects () {
 	  Object.keys(protocols).forEach(function (scheme) {
 	    var protocol = scheme + ":";
 	    var nativeProtocol = nativeProtocols[protocol] = protocols[scheme];
-	    var wrappedProtocol = exports[scheme] = Object.create(nativeProtocol);
+	    var wrappedProtocol = exports$1[scheme] = Object.create(nativeProtocol);
 
 	    // Executes a request, following redirects
 	    function request(input, options, callback) {
@@ -15849,8 +15906,8 @@ function requireFollowRedirects () {
 
 	      // Set defaults
 	      options = Object.assign({
-	        maxRedirects: exports.maxRedirects,
-	        maxBodyLength: exports.maxBodyLength,
+	        maxRedirects: exports$1.maxRedirects,
+	        maxBodyLength: exports$1.maxBodyLength,
 	      }, input, options);
 	      options.nativeProtocols = nativeProtocols;
 	      if (!isString(options.host) && !isString(options.hostname)) {
@@ -15875,7 +15932,7 @@ function requireFollowRedirects () {
 	      get: { value: get, configurable: true, enumerable: true, writable: true },
 	    });
 	  });
-	  return exports;
+	  return exports$1;
 	}
 
 	function noop() { /* empty */ }
@@ -17481,7 +17538,7 @@ var hasRequiredLodash;
 function requireLodash () {
 	if (hasRequiredLodash) return lodash$1.exports;
 	hasRequiredLodash = 1;
-	(function (module, exports) {
+	(function (module, exports$1) {
 (function() {
 
 		  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
@@ -17912,7 +17969,7 @@ function requireLodash () {
 		  var root = freeGlobal || freeSelf || Function('return this')();
 
 		  /** Detect free variable `exports`. */
-		  var freeExports = exports && !exports.nodeType && exports;
+		  var freeExports = exports$1 && !exports$1.nodeType && exports$1;
 
 		  /** Detect free variable `module`. */
 		  var freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module;
@@ -35742,12 +35799,12 @@ var hasRequiredIsBuffer;
 function requireIsBuffer () {
 	if (hasRequiredIsBuffer) return isBuffer.exports;
 	hasRequiredIsBuffer = 1;
-	(function (module, exports) {
+	(function (module, exports$1) {
 		var root = require_root(),
 		    stubFalse = requireStubFalse();
 
 		/** Detect free variable `exports`. */
-		var freeExports = exports && !exports.nodeType && exports;
+		var freeExports = exports$1 && !exports$1.nodeType && exports$1;
 
 		/** Detect free variable `module`. */
 		var freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module;
@@ -35967,11 +36024,11 @@ var hasRequired_nodeUtil;
 function require_nodeUtil () {
 	if (hasRequired_nodeUtil) return _nodeUtil.exports;
 	hasRequired_nodeUtil = 1;
-	(function (module, exports) {
+	(function (module, exports$1) {
 		var freeGlobal = require_freeGlobal();
 
 		/** Detect free variable `exports`. */
-		var freeExports = exports && !exports.nodeType && exports;
+		var freeExports = exports$1 && !exports$1.nodeType && exports$1;
 
 		/** Detect free variable `module`. */
 		var freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module;
@@ -44893,7 +44950,7 @@ var hasRequiredSafeBuffer;
 function requireSafeBuffer () {
 	if (hasRequiredSafeBuffer) return safeBuffer.exports;
 	hasRequiredSafeBuffer = 1;
-	(function (module, exports) {
+	(function (module, exports$1) {
 		/* eslint-disable node/no-deprecated-api */
 		var buffer = require$$0$5;
 		var Buffer = buffer.Buffer;
@@ -44908,8 +44965,8 @@ function requireSafeBuffer () {
 		  module.exports = buffer;
 		} else {
 		  // Copy properties from require('buffer')
-		  copyProps(buffer, exports);
-		  exports.Buffer = SafeBuffer;
+		  copyProps(buffer, exports$1);
+		  exports$1.Buffer = SafeBuffer;
 		}
 
 		function SafeBuffer (arg, encodingOrOffset, length) {
@@ -48107,22 +48164,22 @@ var hasRequiredReadable;
 function requireReadable () {
 	if (hasRequiredReadable) return readable.exports;
 	hasRequiredReadable = 1;
-	(function (module, exports) {
+	(function (module, exports$1) {
 		var Stream = require$$0$3;
 		if (process.env.READABLE_STREAM === 'disable' && Stream) {
 		  module.exports = Stream.Readable;
 		  Object.assign(module.exports, Stream);
 		  module.exports.Stream = Stream;
 		} else {
-		  exports = module.exports = require_stream_readable();
-		  exports.Stream = Stream || exports;
-		  exports.Readable = exports;
-		  exports.Writable = require_stream_writable();
-		  exports.Duplex = require_stream_duplex();
-		  exports.Transform = require_stream_transform();
-		  exports.PassThrough = require_stream_passthrough();
-		  exports.finished = requireEndOfStream();
-		  exports.pipeline = requirePipeline();
+		  exports$1 = module.exports = require_stream_readable();
+		  exports$1.Stream = Stream || exports$1;
+		  exports$1.Readable = exports$1;
+		  exports$1.Writable = require_stream_writable();
+		  exports$1.Duplex = require_stream_duplex();
+		  exports$1.Transform = require_stream_transform();
+		  exports$1.PassThrough = require_stream_passthrough();
+		  exports$1.finished = requireEndOfStream();
+		  exports$1.pipeline = requirePipeline();
 		} 
 	} (readable, readable.exports));
 	return readable.exports;
@@ -49557,12 +49614,12 @@ var hasRequiredWebsocket;
 function requireWebsocket () {
 	if (hasRequiredWebsocket) return websocket$1;
 	hasRequiredWebsocket = 1;
-	(function (exports) {
+	(function (exports$1) {
 		var __importDefault = (websocket$1 && websocket$1.__importDefault) || function (mod) {
 		    return (mod && mod.__esModule) ? mod : { "default": mod };
 		};
-		Object.defineProperty(exports, "__esModule", { value: true });
-		exports.AlpacaWebsocket = exports.ERROR = exports.CONN_ERROR = exports.EVENT = exports.STATE = void 0;
+		Object.defineProperty(exports$1, "__esModule", { value: true });
+		exports$1.AlpacaWebsocket = exports$1.ERROR = exports$1.CONN_ERROR = exports$1.EVENT = exports$1.STATE = void 0;
 		const events_1 = __importDefault(require$$0$4);
 		const ws_1 = __importDefault(requireWs());
 		const msgpack5_1 = __importDefault(requireMsgpack5());
@@ -49576,7 +49633,7 @@ function requireWebsocket () {
 		    STATE["DISCONNECTED"] = "disconnected";
 		    STATE["WAITING_TO_CONNECT"] = "waiting to connect";
 		    STATE["WAITING_TO_RECONNECT"] = "waiting to reconnect";
-		})(STATE || (exports.STATE = STATE = {}));
+		})(STATE || (exports$1.STATE = STATE = {}));
 		// Client events
 		var EVENT;
 		(function (EVENT) {
@@ -49595,9 +49652,9 @@ function requireWebsocket () {
 		    EVENT["CORRECTIONS"] = "corrections";
 		    EVENT["ORDERBOOKS"] = "orderbooks";
 		    EVENT["NEWS"] = "news";
-		})(EVENT || (exports.EVENT = EVENT = {}));
+		})(EVENT || (exports$1.EVENT = EVENT = {}));
 		// Connection errors by code
-		exports.CONN_ERROR = new Map([
+		exports$1.CONN_ERROR = new Map([
 		    [400, "invalid syntax"],
 		    [401, "not authenticated"],
 		    [402, "auth failed"],
@@ -49616,7 +49673,7 @@ function requireWebsocket () {
 		    ERROR["MISSING_SECERT_KEY"] = "missing secret key";
 		    ERROR["MISSING_API_KEY"] = "missing api key";
 		    ERROR["UNEXPECTED_MESSAGE"] = "unexpected message";
-		})(ERROR || (exports.ERROR = ERROR = {}));
+		})(ERROR || (exports$1.ERROR = ERROR = {}));
 		class AlpacaWebsocket extends events_1.default.EventEmitter {
 		    constructor(options) {
 		        super();
@@ -49773,7 +49830,7 @@ function requireWebsocket () {
 		                this.updateSubscriptions(data[0]);
 		                break;
 		            case "error":
-		                this.emit(EVENT.CLIENT_ERROR, exports.CONN_ERROR.get(data[0].code));
+		                this.emit(EVENT.CLIENT_ERROR, exports$1.CONN_ERROR.get(data[0].code));
 		                break;
 		            default:
 		                this.dataHandler(data);
@@ -49802,7 +49859,7 @@ function requireWebsocket () {
 		        }
 		    }
 		}
-		exports.AlpacaWebsocket = AlpacaWebsocket; 
+		exports$1.AlpacaWebsocket = AlpacaWebsocket; 
 	} (websocket$1));
 	return websocket$1;
 }
@@ -50436,8 +50493,8 @@ var hasRequiredWebsockets;
 function requireWebsockets () {
 	if (hasRequiredWebsockets) return websockets;
 	hasRequiredWebsockets = 1;
-	(function (exports) {
-		Object.defineProperty(exports, "__esModule", { value: true });
+	(function (exports$1) {
+		Object.defineProperty(exports$1, "__esModule", { value: true });
 		const events = require$$0$4;
 		const WebSocket = requireWs();
 		const entity = requireEntity();
@@ -50452,7 +50509,7 @@ function requireWebsockets () {
 		    STATE.DISCONNECTED = "disconnected";
 		    STATE.WAITING_TO_CONNECT = "waiting to connect";
 		    STATE.WAITING_TO_RECONNECT = "waiting to reconnect";
-		})((STATE = exports.STATE || (exports.STATE = {})));
+		})((STATE = exports$1.STATE || (exports$1.STATE = {})));
 		// Client events
 		var EVENT;
 		(function (EVENT) {
@@ -50466,7 +50523,7 @@ function requireWebsockets () {
 		    EVENT.STOCK_QUOTES = "stock_quotes";
 		    EVENT.STOCK_AGG_SEC = "stock_agg_sec";
 		    EVENT.STOCK_AGG_MIN = "stock_agg_min";
-		})((EVENT = exports.EVENT || (exports.EVENT = {})));
+		})((EVENT = exports$1.EVENT || (exports$1.EVENT = {})));
 		// Connection errors Each of these will also emit EVENT.ERROR
 		var ERROR;
 		(function (ERROR) {
@@ -50475,7 +50532,7 @@ function requireWebsockets () {
 		    ERROR.MISSING_API_KEY = "missing api key";
 		    ERROR.MISSING_SECRET_KEY = "missing secret key";
 		    ERROR.UNKNOWN = "unknown error";
-		})((ERROR = exports.ERROR || (exports.ERROR = {})));
+		})((ERROR = exports$1.ERROR || (exports$1.ERROR = {})));
 		/**
 		 * AlpacaStreamClient manages a connection to Alpaca's websocket api
 		 */
@@ -50788,7 +50845,7 @@ function requireWebsockets () {
 		        }
 		    }
 		}
-		exports.AlpacaStreamClient = AlpacaStreamClient; 
+		exports$1.AlpacaStreamClient = AlpacaStreamClient; 
 	} (websockets));
 	return websockets;
 }
@@ -51040,13 +51097,13 @@ var hasRequiredDist;
 function requireDist () {
 	if (hasRequiredDist) return dist$1.exports;
 	hasRequiredDist = 1;
-	(function (module, exports) {
+	(function (module, exports$1) {
 		var __importDefault = (dist && dist.__importDefault) || function (mod) {
 		    return (mod && mod.__esModule) ? mod : { "default": mod };
 		};
-		Object.defineProperty(exports, "__esModule", { value: true });
+		Object.defineProperty(exports$1, "__esModule", { value: true });
 		const alpaca_trade_api_1 = __importDefault(requireAlpacaTradeApi());
-		exports.default = alpaca_trade_api_1.default;
+		exports$1.default = alpaca_trade_api_1.default;
 		module.exports = alpaca_trade_api_1.default; 
 	} (dist$1, dist$1.exports));
 	return dist$1.exports;