@oxy.so/core 1.0.0

package/dist/cjs/session/socketLoader.js

@@ -0,0 +1,55 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSocketIO = getSocketIO;
+const logger_1 = require("../logger");
+let cachedFactory = null;
+let loadAttempted = false;
+async function getSocketIO() {
+    if (cachedFactory)
+        return cachedFactory;
+    if (loadAttempted)
+        return null;
+    loadAttempted = true;
+    try {
+        const mod = (await Promise.resolve().then(() => __importStar(require('socket.io-client'))));
+        cachedFactory = mod.io ?? mod.default ?? null;
+        return cachedFactory;
+    }
+    catch (error) {
+        logger_1.logger.warn('[SessionClient] socket.io-client import failed; realtime session sync disabled', { component: 'SessionClient' }, error);
+        return null;
+    }
+}

package/dist/cjs/shared/utils/colorUtils.js

@@ -0,0 +1,153 @@
+"use strict";
+/**
+ * Color Utility Functions
+ *
+ * Consolidated color manipulation utilities used across the OxyServices ecosystem.
+ * These functions work in any JavaScript environment (browser, Node.js, React Native).
+ *
+ * @module shared/utils/colorUtils
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContrastTextColor = exports.isLightColor = exports.withOpacity = exports.rgbToHex = exports.hexToRgb = exports.lightenColor = exports.darkenColor = void 0;
+/**
+ * Darkens a hex color by a specified factor.
+ *
+ * @param color - Hex color string (with or without #)
+ * @param factor - Amount to darken (0-1). Default: 0.6
+ * @returns Darkened hex color string with # prefix
+ *
+ * @example
+ * ```ts
+ * darkenColor('#FF0000', 0.5); // Returns a darker red
+ * darkenColor('FF0000', 0.3);  // Also works without #
+ * ```
+ */
+const darkenColor = (color, factor = 0.6) => {
+    const hex = color.replace('#', '');
+    const r = Number.parseInt(hex.substring(0, 2), 16);
+    const g = Number.parseInt(hex.substring(2, 4), 16);
+    const b = Number.parseInt(hex.substring(4, 6), 16);
+    const newR = Math.max(0, Math.round(r * (1 - factor)));
+    const newG = Math.max(0, Math.round(g * (1 - factor)));
+    const newB = Math.max(0, Math.round(b * (1 - factor)));
+    return `#${newR.toString(16).padStart(2, '0')}${newG.toString(16).padStart(2, '0')}${newB.toString(16).padStart(2, '0')}`;
+};
+exports.darkenColor = darkenColor;
+/**
+ * Lightens a hex color by a specified factor.
+ *
+ * @param color - Hex color string (with or without #)
+ * @param factor - Amount to lighten (0-1). Default: 0.3
+ * @returns Lightened hex color string with # prefix
+ *
+ * @example
+ * ```ts
+ * lightenColor('#0000FF', 0.5); // Returns a lighter blue
+ * ```
+ */
+const lightenColor = (color, factor = 0.3) => {
+    const hex = color.replace('#', '');
+    const r = Number.parseInt(hex.substring(0, 2), 16);
+    const g = Number.parseInt(hex.substring(2, 4), 16);
+    const b = Number.parseInt(hex.substring(4, 6), 16);
+    const newR = Math.min(255, Math.round(r + (255 - r) * factor));
+    const newG = Math.min(255, Math.round(g + (255 - g) * factor));
+    const newB = Math.min(255, Math.round(b + (255 - b) * factor));
+    return `#${newR.toString(16).padStart(2, '0')}${newG.toString(16).padStart(2, '0')}${newB.toString(16).padStart(2, '0')}`;
+};
+exports.lightenColor = lightenColor;
+/**
+ * Converts a hex color to RGB values.
+ *
+ * @param hex - Hex color string (with or without #)
+ * @returns Object with r, g, b values (0-255)
+ *
+ * @example
+ * ```ts
+ * hexToRgb('#FF5733'); // { r: 255, g: 87, b: 51 }
+ * ```
+ */
+const hexToRgb = (hex) => {
+    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+    return result
+        ? {
+            r: Number.parseInt(result[1], 16),
+            g: Number.parseInt(result[2], 16),
+            b: Number.parseInt(result[3], 16),
+        }
+        : null;
+};
+exports.hexToRgb = hexToRgb;
+/**
+ * Converts RGB values to a hex color string.
+ *
+ * @param r - Red value (0-255)
+ * @param g - Green value (0-255)
+ * @param b - Blue value (0-255)
+ * @returns Hex color string with # prefix
+ *
+ * @example
+ * ```ts
+ * rgbToHex(255, 87, 51); // '#ff5733'
+ * ```
+ */
+const rgbToHex = (r, g, b) => {
+    return `#${((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1)}`;
+};
+exports.rgbToHex = rgbToHex;
+/**
+ * Adjusts the opacity of a hex color, returning an rgba string.
+ *
+ * @param hex - Hex color string
+ * @param opacity - Opacity value (0-1)
+ * @returns RGBA color string
+ *
+ * @example
+ * ```ts
+ * withOpacity('#FF0000', 0.5); // 'rgba(255, 0, 0, 0.5)'
+ * ```
+ */
+const withOpacity = (hex, opacity) => {
+    const rgb = (0, exports.hexToRgb)(hex);
+    if (!rgb)
+        return hex;
+    return `rgba(${rgb.r}, ${rgb.g}, ${rgb.b}, ${opacity})`;
+};
+exports.withOpacity = withOpacity;
+/**
+ * Checks if a color is considered "light" (for determining text contrast).
+ *
+ * @param hex - Hex color string
+ * @returns true if the color is light, false if dark
+ *
+ * @example
+ * ```ts
+ * isLightColor('#FFFFFF'); // true
+ * isLightColor('#000000'); // false
+ * ```
+ */
+const isLightColor = (hex) => {
+    const rgb = (0, exports.hexToRgb)(hex);
+    if (!rgb)
+        return true;
+    // Using relative luminance formula
+    const luminance = (0.299 * rgb.r + 0.587 * rgb.g + 0.114 * rgb.b) / 255;
+    return luminance > 0.5;
+};
+exports.isLightColor = isLightColor;
+/**
+ * Gets a contrasting text color (black or white) for a given background color.
+ *
+ * @param backgroundColor - Hex color string of the background
+ * @returns '#000000' for light backgrounds, '#ffffff' for dark backgrounds
+ *
+ * @example
+ * ```ts
+ * getContrastTextColor('#FFFF00'); // '#000000' (black text on yellow)
+ * getContrastTextColor('#000080'); // '#ffffff' (white text on navy)
+ * ```
+ */
+const getContrastTextColor = (backgroundColor) => {
+    return (0, exports.isLightColor)(backgroundColor) ? '#000000' : '#ffffff';
+};
+exports.getContrastTextColor = getContrastTextColor;

package/dist/cjs/shared/utils/errorUtils.js

@@ -0,0 +1,183 @@
+"use strict";
+/**
+ * Error Utility Functions
+ *
+ * Consolidated error handling utilities for the OxyServices ecosystem.
+ * These functions help with common error patterns like checking HTTP status codes.
+ *
+ * @module shared/utils/errorUtils
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRetryableError = exports.isNetworkError = exports.isServerError = exports.isRateLimitError = exports.isNotFoundError = exports.isForbiddenError = exports.isUnauthorizedError = exports.isAlreadyRegisteredError = exports.getErrorMessage = exports.getErrorStatus = exports.HttpStatus = void 0;
+/**
+ * Common HTTP status codes used in error checking.
+ */
+exports.HttpStatus = {
+    BAD_REQUEST: 400,
+    UNAUTHORIZED: 401,
+    FORBIDDEN: 403,
+    NOT_FOUND: 404,
+    CONFLICT: 409,
+    UNPROCESSABLE_ENTITY: 422,
+    TOO_MANY_REQUESTS: 429,
+    INTERNAL_SERVER_ERROR: 500,
+    BAD_GATEWAY: 502,
+    SERVICE_UNAVAILABLE: 503,
+    GATEWAY_TIMEOUT: 504,
+};
+/**
+ * Extracts the HTTP status code from an error object.
+ *
+ * @param error - Any error object
+ * @returns The status code if found, undefined otherwise
+ */
+const getErrorStatus = (error) => {
+    if (!error || typeof error !== 'object')
+        return undefined;
+    const err = error;
+    // Direct status property
+    if (typeof err.status === 'number')
+        return err.status;
+    // Axios-style response.status
+    if (err.response && typeof err.response === 'object') {
+        const response = err.response;
+        if (typeof response.status === 'number')
+            return response.status;
+    }
+    // statusCode property (some libraries use this)
+    if (typeof err.statusCode === 'number')
+        return err.statusCode;
+    return undefined;
+};
+exports.getErrorStatus = getErrorStatus;
+/**
+ * Extracts the error message from an error object.
+ *
+ * @param error - Any error object
+ * @param fallback - Fallback message if none found
+ * @returns The error message
+ */
+const getErrorMessage = (error, fallback = 'An unknown error occurred') => {
+    if (!error)
+        return fallback;
+    if (typeof error === 'string')
+        return error;
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === 'object') {
+        const err = error;
+        if (typeof err.message === 'string')
+            return err.message;
+        if (typeof err.error === 'string')
+            return err.error;
+        // Axios-style response.data.message
+        if (err.response && typeof err.response === 'object') {
+            const response = err.response;
+            if (response.data && typeof response.data === 'object') {
+                const data = response.data;
+                if (typeof data.message === 'string')
+                    return data.message;
+                if (typeof data.error === 'string')
+                    return data.error;
+            }
+        }
+    }
+    return fallback;
+};
+exports.getErrorMessage = getErrorMessage;
+/**
+ * Check if an error indicates the user is already registered (HTTP 409 Conflict).
+ *
+ * The backend should always return HTTP 409 for duplicate registrations.
+ *
+ * @param error - Any error object
+ * @returns true if the error is a 409 Conflict
+ */
+const isAlreadyRegisteredError = (error) => {
+    return (0, exports.getErrorStatus)(error) === exports.HttpStatus.CONFLICT;
+};
+exports.isAlreadyRegisteredError = isAlreadyRegisteredError;
+/**
+ * Check if an error is an authentication error (HTTP 401).
+ *
+ * @param error - Any error object
+ * @returns true if the error is a 401 Unauthorized
+ */
+const isUnauthorizedError = (error) => {
+    return (0, exports.getErrorStatus)(error) === exports.HttpStatus.UNAUTHORIZED;
+};
+exports.isUnauthorizedError = isUnauthorizedError;
+/**
+ * Check if an error is a forbidden error (HTTP 403).
+ *
+ * @param error - Any error object
+ * @returns true if the error is a 403 Forbidden
+ */
+const isForbiddenError = (error) => {
+    return (0, exports.getErrorStatus)(error) === exports.HttpStatus.FORBIDDEN;
+};
+exports.isForbiddenError = isForbiddenError;
+/**
+ * Check if an error is a not found error (HTTP 404).
+ *
+ * @param error - Any error object
+ * @returns true if the error is a 404 Not Found
+ */
+const isNotFoundError = (error) => {
+    return (0, exports.getErrorStatus)(error) === exports.HttpStatus.NOT_FOUND;
+};
+exports.isNotFoundError = isNotFoundError;
+/**
+ * Check if an error is a rate limit error (HTTP 429).
+ *
+ * @param error - Any error object
+ * @returns true if the error is a 429 Too Many Requests
+ */
+const isRateLimitError = (error) => {
+    return (0, exports.getErrorStatus)(error) === exports.HttpStatus.TOO_MANY_REQUESTS;
+};
+exports.isRateLimitError = isRateLimitError;
+/**
+ * Check if an error is a server error (HTTP 5xx).
+ *
+ * @param error - Any error object
+ * @returns true if the error is a 5xx server error
+ */
+const isServerError = (error) => {
+    const status = (0, exports.getErrorStatus)(error);
+    return status !== undefined && status >= 500 && status < 600;
+};
+exports.isServerError = isServerError;
+/**
+ * Check if an error is a network error (no response received).
+ *
+ * @param error - Any error object
+ * @returns true if the error appears to be a network error
+ */
+const isNetworkError = (error) => {
+    if (!error || typeof error !== 'object')
+        return false;
+    const err = error;
+    // Check for common network error indicators
+    if (err.name === 'NetworkError')
+        return true;
+    if (err.code === 'ENOTFOUND' || err.code === 'ECONNREFUSED' || err.code === 'ETIMEDOUT')
+        return true;
+    // Axios-style: has request but no response
+    if (err.request && !err.response)
+        return true;
+    // Message-based detection
+    const message = (0, exports.getErrorMessage)(error, '').toLowerCase();
+    return message.includes('network') || message.includes('connection') || message.includes('timeout');
+};
+exports.isNetworkError = isNetworkError;
+/**
+ * Check if an error is retryable (network errors or 5xx server errors).
+ *
+ * @param error - Any error object
+ * @returns true if the request should be retried
+ */
+const isRetryableError = (error) => {
+    return (0, exports.isNetworkError)(error) || (0, exports.isServerError)(error) || (0, exports.isRateLimitError)(error);
+};
+exports.isRetryableError = isRetryableError;

package/dist/cjs/shared/utils/index.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * Shared Utility Functions
+ *
+ * Re-exports all shared utilities for convenient importing.
+ *
+ * @module shared/utils
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withRetry = exports.delay = exports.shouldAllowRequest = exports.recordSuccess = exports.recordFailure = exports.calculateBackoffInterval = exports.createCircuitBreakerState = exports.DEFAULT_CIRCUIT_BREAKER_CONFIG = exports.isRetryableError = exports.isNetworkError = exports.isServerError = exports.isRateLimitError = exports.isNotFoundError = exports.isForbiddenError = exports.isUnauthorizedError = exports.isAlreadyRegisteredError = exports.getErrorMessage = exports.getErrorStatus = exports.HttpStatus = exports.getSystemColorScheme = exports.systemPrefersDarkMode = exports.getOppositeTheme = exports.normalizeColorScheme = exports.normalizeTheme = exports.getContrastTextColor = exports.isLightColor = exports.withOpacity = exports.rgbToHex = exports.hexToRgb = exports.lightenColor = exports.darkenColor = void 0;
+// Color utilities
+var colorUtils_1 = require("./colorUtils");
+Object.defineProperty(exports, "darkenColor", { enumerable: true, get: function () { return colorUtils_1.darkenColor; } });
+Object.defineProperty(exports, "lightenColor", { enumerable: true, get: function () { return colorUtils_1.lightenColor; } });
+Object.defineProperty(exports, "hexToRgb", { enumerable: true, get: function () { return colorUtils_1.hexToRgb; } });
+Object.defineProperty(exports, "rgbToHex", { enumerable: true, get: function () { return colorUtils_1.rgbToHex; } });
+Object.defineProperty(exports, "withOpacity", { enumerable: true, get: function () { return colorUtils_1.withOpacity; } });
+Object.defineProperty(exports, "isLightColor", { enumerable: true, get: function () { return colorUtils_1.isLightColor; } });
+Object.defineProperty(exports, "getContrastTextColor", { enumerable: true, get: function () { return colorUtils_1.getContrastTextColor; } });
+// Theme utilities
+var themeUtils_1 = require("./themeUtils");
+Object.defineProperty(exports, "normalizeTheme", { enumerable: true, get: function () { return themeUtils_1.normalizeTheme; } });
+Object.defineProperty(exports, "normalizeColorScheme", { enumerable: true, get: function () { return themeUtils_1.normalizeColorScheme; } });
+Object.defineProperty(exports, "getOppositeTheme", { enumerable: true, get: function () { return themeUtils_1.getOppositeTheme; } });
+Object.defineProperty(exports, "systemPrefersDarkMode", { enumerable: true, get: function () { return themeUtils_1.systemPrefersDarkMode; } });
+Object.defineProperty(exports, "getSystemColorScheme", { enumerable: true, get: function () { return themeUtils_1.getSystemColorScheme; } });
+// Error utilities
+var errorUtils_1 = require("./errorUtils");
+Object.defineProperty(exports, "HttpStatus", { enumerable: true, get: function () { return errorUtils_1.HttpStatus; } });
+Object.defineProperty(exports, "getErrorStatus", { enumerable: true, get: function () { return errorUtils_1.getErrorStatus; } });
+Object.defineProperty(exports, "getErrorMessage", { enumerable: true, get: function () { return errorUtils_1.getErrorMessage; } });
+Object.defineProperty(exports, "isAlreadyRegisteredError", { enumerable: true, get: function () { return errorUtils_1.isAlreadyRegisteredError; } });
+Object.defineProperty(exports, "isUnauthorizedError", { enumerable: true, get: function () { return errorUtils_1.isUnauthorizedError; } });
+Object.defineProperty(exports, "isForbiddenError", { enumerable: true, get: function () { return errorUtils_1.isForbiddenError; } });
+Object.defineProperty(exports, "isNotFoundError", { enumerable: true, get: function () { return errorUtils_1.isNotFoundError; } });
+Object.defineProperty(exports, "isRateLimitError", { enumerable: true, get: function () { return errorUtils_1.isRateLimitError; } });
+Object.defineProperty(exports, "isServerError", { enumerable: true, get: function () { return errorUtils_1.isServerError; } });
+Object.defineProperty(exports, "isNetworkError", { enumerable: true, get: function () { return errorUtils_1.isNetworkError; } });
+Object.defineProperty(exports, "isRetryableError", { enumerable: true, get: function () { return errorUtils_1.isRetryableError; } });
+// Network utilities
+var networkUtils_1 = require("./networkUtils");
+Object.defineProperty(exports, "DEFAULT_CIRCUIT_BREAKER_CONFIG", { enumerable: true, get: function () { return networkUtils_1.DEFAULT_CIRCUIT_BREAKER_CONFIG; } });
+Object.defineProperty(exports, "createCircuitBreakerState", { enumerable: true, get: function () { return networkUtils_1.createCircuitBreakerState; } });
+Object.defineProperty(exports, "calculateBackoffInterval", { enumerable: true, get: function () { return networkUtils_1.calculateBackoffInterval; } });
+Object.defineProperty(exports, "recordFailure", { enumerable: true, get: function () { return networkUtils_1.recordFailure; } });
+Object.defineProperty(exports, "recordSuccess", { enumerable: true, get: function () { return networkUtils_1.recordSuccess; } });
+Object.defineProperty(exports, "shouldAllowRequest", { enumerable: true, get: function () { return networkUtils_1.shouldAllowRequest; } });
+Object.defineProperty(exports, "delay", { enumerable: true, get: function () { return networkUtils_1.delay; } });
+Object.defineProperty(exports, "withRetry", { enumerable: true, get: function () { return networkUtils_1.withRetry; } });

package/dist/cjs/shared/utils/networkUtils.js

@@ -0,0 +1,183 @@
+"use strict";
+/**
+ * Network Utility Functions
+ *
+ * Consolidated network utilities including circuit breaker pattern
+ * and exponential backoff for resilient API calls.
+ *
+ * @module shared/utils/networkUtils
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withRetry = exports.delay = exports.shouldAllowRequest = exports.recordSuccess = exports.recordFailure = exports.calculateBackoffInterval = exports.createCircuitBreakerState = exports.DEFAULT_CIRCUIT_BREAKER_CONFIG = void 0;
+/**
+ * Default circuit breaker configuration.
+ */
+exports.DEFAULT_CIRCUIT_BREAKER_CONFIG = {
+    baseInterval: 10000,
+    maxInterval: 60000,
+    maxFailures: 5,
+    recoveryTimeout: 30000,
+};
+/**
+ * Creates initial circuit breaker state.
+ *
+ * @param config - Optional custom configuration
+ * @returns Initial circuit breaker state
+ *
+ * @example
+ * ```ts
+ * const state = createCircuitBreakerState({ maxFailures: 3 });
+ * ```
+ */
+const createCircuitBreakerState = (config = {}) => {
+    const { baseInterval, maxInterval, maxFailures } = {
+        ...exports.DEFAULT_CIRCUIT_BREAKER_CONFIG,
+        ...config,
+    };
+    return {
+        consecutiveFailures: 0,
+        currentInterval: baseInterval,
+        baseInterval,
+        maxInterval,
+        maxFailures,
+        isOpen: false,
+    };
+};
+exports.createCircuitBreakerState = createCircuitBreakerState;
+/**
+ * Calculates next interval using exponential backoff.
+ *
+ * @param state - Current circuit breaker state
+ * @returns Next interval in milliseconds
+ *
+ * @example
+ * ```ts
+ * const nextInterval = calculateBackoffInterval(state);
+ * await delay(nextInterval);
+ * ```
+ */
+const calculateBackoffInterval = (state) => {
+    const { consecutiveFailures, baseInterval, maxInterval } = state;
+    if (consecutiveFailures === 0)
+        return baseInterval;
+    const backoffMultiplier = Math.min(Math.pow(2, consecutiveFailures - 1), maxInterval / baseInterval);
+    return Math.min(baseInterval * backoffMultiplier, maxInterval);
+};
+exports.calculateBackoffInterval = calculateBackoffInterval;
+/**
+ * Records a failure and updates circuit breaker state.
+ *
+ * @param state - Current circuit breaker state
+ * @returns Updated state after recording failure
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await apiCall();
+ *   state = recordSuccess(state);
+ * } catch (error) {
+ *   state = recordFailure(state);
+ * }
+ * ```
+ */
+const recordFailure = (state) => {
+    const newFailures = state.consecutiveFailures + 1;
+    const newInterval = (0, exports.calculateBackoffInterval)({
+        ...state,
+        consecutiveFailures: newFailures,
+    });
+    const shouldOpenCircuit = newFailures >= state.maxFailures;
+    const finalInterval = shouldOpenCircuit ? state.maxInterval : newInterval;
+    return {
+        ...state,
+        consecutiveFailures: newFailures,
+        currentInterval: finalInterval,
+        isOpen: shouldOpenCircuit,
+        openedAt: shouldOpenCircuit ? Date.now() : state.openedAt,
+    };
+};
+exports.recordFailure = recordFailure;
+/**
+ * Records a success and resets circuit breaker state.
+ *
+ * @param state - Current circuit breaker state
+ * @returns Reset state after successful request
+ */
+const recordSuccess = (state) => {
+    return {
+        ...state,
+        consecutiveFailures: 0,
+        currentInterval: state.baseInterval,
+        isOpen: false,
+        openedAt: undefined,
+    };
+};
+exports.recordSuccess = recordSuccess;
+/**
+ * Checks if the circuit breaker should allow a request.
+ *
+ * When the circuit is open, it will only allow requests after
+ * the recovery timeout has passed (half-open state).
+ *
+ * @param state - Current circuit breaker state
+ * @param recoveryTimeout - Time to wait before allowing recovery attempts
+ * @returns true if request should be allowed
+ */
+const shouldAllowRequest = (state, recoveryTimeout = exports.DEFAULT_CIRCUIT_BREAKER_CONFIG.recoveryTimeout) => {
+    if (!state.isOpen)
+        return true;
+    if (!state.openedAt)
+        return true;
+    const timeSinceOpen = Date.now() - state.openedAt;
+    return timeSinceOpen >= recoveryTimeout;
+};
+exports.shouldAllowRequest = shouldAllowRequest;
+/**
+ * Delays execution for a specified duration.
+ *
+ * @param ms - Milliseconds to delay
+ * @returns Promise that resolves after the delay
+ *
+ * @example
+ * ```ts
+ * await delay(1000); // Wait 1 second
+ * ```
+ */
+const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+exports.delay = delay;
+/**
+ * Executes a function with exponential backoff retry.
+ *
+ * @param fn - Async function to execute
+ * @param options - Retry options
+ * @returns Result of the function
+ * @throws Last error if all retries fail
+ *
+ * @example
+ * ```ts
+ * const result = await withRetry(
+ *   () => fetchData(),
+ *   { maxRetries: 3, baseDelay: 1000 }
+ * );
+ * ```
+ */
+const withRetry = async (fn, options = {}) => {
+    const { maxRetries = 3, baseDelay = 1000, maxDelay = 30000, shouldRetry = () => true, onRetry, } = options;
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt === maxRetries || !shouldRetry(error)) {
+                throw error;
+            }
+            const delayMs = Math.min(baseDelay * Math.pow(2, attempt), maxDelay);
+            onRetry?.(error, attempt + 1);
+            await (0, exports.delay)(delayMs);
+        }
+    }
+    throw lastError;
+};
+exports.withRetry = withRetry;