@webacy-xyz/sdk-core 1.0.1

package/dist/esm/errors/base.js

@@ -0,0 +1,72 @@
+/**
+ * Base error class for all Webacy SDK errors
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await client.addresses.analyze(address, { chain: Chain.ETH });
+ * } catch (error) {
+ *   if (error instanceof WebacyError) {
+ *     console.error(`Error: ${error.message}`);
+ *     console.error(`Code: ${error.code}`);
+ *     if (error.endpoint) {
+ *       console.error(`Endpoint: ${error.endpoint}`);
+ *     }
+ *     if (error.requestId) {
+ *       console.error(`Request ID: ${error.requestId} (include this when contacting support)`);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export class WebacyError extends Error {
+    /** HTTP status code if applicable */
+    status;
+    /** Error code for programmatic handling */
+    code;
+    /** Original error if wrapped */
+    cause;
+    /** Request ID for support inquiries */
+    requestId;
+    /** API endpoint that failed (for debugging) */
+    endpoint;
+    constructor(message, options) {
+        super(message);
+        this.name = 'WebacyError';
+        this.status = options.status;
+        this.code = options.code;
+        this.cause = options.cause;
+        this.requestId = options.requestId;
+        this.endpoint = options.endpoint;
+        // Maintain proper stack trace
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+    /**
+     * Check if this error is retryable
+     */
+    isRetryable() {
+        return false;
+    }
+    /**
+     * Convert to JSON for logging
+     */
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            code: this.code,
+            status: this.status,
+            requestId: this.requestId,
+            endpoint: this.endpoint,
+        };
+    }
+    /**
+     * Get a user-friendly description of how to resolve this error
+     */
+    getRecoverySuggestion() {
+        return undefined;
+    }
+}
+//# sourceMappingURL=base.js.map

package/dist/esm/errors/base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.js","sourceRoot":"","sources":["../../../src/errors/base.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,OAAO,WAAY,SAAQ,KAAK;IACpC,qCAAqC;IACrB,MAAM,CAAU;IAEhC,2CAA2C;IAC3B,IAAI,CAAS;IAE7B,gCAAgC;IAChB,KAAK,CAAS;IAE9B,uCAAuC;IACvB,SAAS,CAAU;IAEnC,+CAA+C;IAC/B,QAAQ,CAAU;IAElC,YACE,OAAe,EACf,OAMC;QAED,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,aAAa,CAAC;QAC1B,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;QAC7B,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;QACzB,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC;QAC3B,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC;QACnC,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;QAEjC,8BAA8B;QAC9B,IAAI,KAAK,CAAC,iBAAiB,EAAE,CAAC;YAC5B,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QAClD,CAAC;IACH,CAAC;IAED;;OAEG;IACH,WAAW;QACT,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO;YACL,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,QAAQ,EAAE,IAAI,CAAC,QAAQ;SACxB,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,qBAAqB;QACnB,OAAO,SAAS,CAAC;IACnB,CAAC;CACF"}

package/dist/esm/errors/index.js

@@ -0,0 +1,7 @@
+export { WebacyError } from './base.js';
+export { AuthenticationError } from './authentication.js';
+export { RateLimitError } from './rate-limit.js';
+export { ValidationError } from './validation.js';
+export { NotFoundError } from './not-found.js';
+export { NetworkError } from './network.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/errors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/errors/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AACrC,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC"}

package/dist/esm/errors/network.js

@@ -0,0 +1,41 @@
+import { WebacyError } from './base.js';
+/**
+ * Thrown when a network error occurs
+ *
+ * This includes timeouts, connection failures, and other transport-level errors.
+ * The SDK automatically retries network errors with exponential backoff.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await client.addresses.analyze(address, { chain: Chain.ETH });
+ * } catch (error) {
+ *   if (error instanceof NetworkError) {
+ *     console.error('Network error:', error.message);
+ *     if (error.cause) {
+ *       console.error('Cause:', error.cause.message);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export class NetworkError extends WebacyError {
+    constructor(message = 'Network request failed', options = {}) {
+        super(message, {
+            code: 'NETWORK_ERROR',
+            cause: options.cause,
+            endpoint: options.endpoint,
+        });
+        this.name = 'NetworkError';
+    }
+    isRetryable() {
+        return true;
+    }
+    getRecoverySuggestion() {
+        if (this.message.toLowerCase().includes('timed out')) {
+            return 'The request timed out. Try increasing the timeout option or check your network connection.';
+        }
+        return 'Check your network connection and try again. If the problem persists, the Webacy API may be temporarily unavailable.';
+    }
+}
+//# sourceMappingURL=network.js.map

package/dist/esm/errors/network.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"network.js","sourceRoot":"","sources":["../../../src/errors/network.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAErC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,OAAO,YAAa,SAAQ,WAAW;IAC3C,YACE,OAAO,GAAG,wBAAwB,EAClC,UAAgD,EAAE;QAElD,KAAK,CAAC,OAAO,EAAE;YACb,IAAI,EAAE,eAAe;YACrB,KAAK,EAAE,OAAO,CAAC,KAAK;YACpB,QAAQ,EAAE,OAAO,CAAC,QAAQ;SAC3B,CAAC,CAAC;QACH,IAAI,CAAC,IAAI,GAAG,cAAc,CAAC;IAC7B,CAAC;IAEQ,WAAW;QAClB,OAAO,IAAI,CAAC;IACd,CAAC;IAEQ,qBAAqB;QAC5B,IAAI,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC;YACrD,OAAO,4FAA4F,CAAC;QACtG,CAAC;QACD,OAAO,sHAAsH,CAAC;IAChI,CAAC;CACF"}

package/dist/esm/errors/not-found.js

@@ -0,0 +1,34 @@
+import { WebacyError } from './base.js';
+/**
+ * Thrown when a resource is not found
+ *
+ * This typically means the address or resource doesn't exist on the specified chain,
+ * or hasn't been indexed yet.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await client.addresses.analyze(address, { chain: Chain.ETH });
+ * } catch (error) {
+ *   if (error instanceof NotFoundError) {
+ *     console.error('Resource not found:', error.message);
+ *     // The address may not exist or may not have any activity
+ *   }
+ * }
+ * ```
+ */
+export class NotFoundError extends WebacyError {
+    constructor(message = 'Resource not found', options = {}) {
+        super(message, {
+            status: 404,
+            code: 'NOT_FOUND_ERROR',
+            requestId: options.requestId,
+            endpoint: options.endpoint,
+        });
+        this.name = 'NotFoundError';
+    }
+    getRecoverySuggestion() {
+        return 'Verify the address exists and has activity on the specified chain. For new addresses, data may take a few minutes to become available.';
+    }
+}
+//# sourceMappingURL=not-found.js.map

package/dist/esm/errors/not-found.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"not-found.js","sourceRoot":"","sources":["../../../src/errors/not-found.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAErC;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,OAAO,aAAc,SAAQ,WAAW;IAC5C,YACE,OAAO,GAAG,oBAAoB,EAC9B,UAAqD,EAAE;QAEvD,KAAK,CAAC,OAAO,EAAE;YACb,MAAM,EAAE,GAAG;YACX,IAAI,EAAE,iBAAiB;YACvB,SAAS,EAAE,OAAO,CAAC,SAAS;YAC5B,QAAQ,EAAE,OAAO,CAAC,QAAQ;SAC3B,CAAC,CAAC;QACH,IAAI,CAAC,IAAI,GAAG,eAAe,CAAC;IAC9B,CAAC;IAEQ,qBAAqB;QAC5B,OAAO,wIAAwI,CAAC;IAClJ,CAAC;CACF"}

package/dist/esm/errors/rate-limit.js

@@ -0,0 +1,49 @@
+import { WebacyError } from './base.js';
+/**
+ * Thrown when rate limit is exceeded
+ *
+ * The SDK automatically retries rate-limited requests with exponential backoff.
+ * If you're seeing this error frequently, consider reducing request frequency
+ * or upgrading your API plan.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await client.addresses.analyze(address, { chain: Chain.ETH });
+ * } catch (error) {
+ *   if (error instanceof RateLimitError) {
+ *     console.error('Rate limited:', error.message);
+ *     if (error.retryAfter) {
+ *       console.log(`Retry after ${error.retryAfter} seconds`);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export class RateLimitError extends WebacyError {
+    /** When the rate limit resets (Unix timestamp) */
+    resetAt;
+    /** Number of seconds until reset */
+    retryAfter;
+    constructor(message = 'Rate limit exceeded', options = {}) {
+        super(message, {
+            status: 429,
+            code: 'RATE_LIMIT_ERROR',
+            requestId: options.requestId,
+            endpoint: options.endpoint,
+        });
+        this.name = 'RateLimitError';
+        this.resetAt = options.resetAt;
+        this.retryAfter = options.retryAfter;
+    }
+    isRetryable() {
+        return true;
+    }
+    getRecoverySuggestion() {
+        if (this.retryAfter) {
+            return `Wait ${this.retryAfter} seconds before retrying. Consider implementing request throttling or upgrading your API plan for higher limits.`;
+        }
+        return 'Wait a moment before retrying. Consider implementing request throttling or upgrading your API plan for higher limits.';
+    }
+}
+//# sourceMappingURL=rate-limit.js.map

package/dist/esm/errors/rate-limit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limit.js","sourceRoot":"","sources":["../../../src/errors/rate-limit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,OAAO,cAAe,SAAQ,WAAW;IAC7C,kDAAkD;IAClC,OAAO,CAAU;IAEjC,oCAAoC;IACpB,UAAU,CAAU;IAEpC,YACE,OAAO,GAAG,qBAAqB,EAC/B,UAA4F,EAAE;QAE9F,KAAK,CAAC,OAAO,EAAE;YACb,MAAM,EAAE,GAAG;YACX,IAAI,EAAE,kBAAkB;YACxB,SAAS,EAAE,OAAO,CAAC,SAAS;YAC5B,QAAQ,EAAE,OAAO,CAAC,QAAQ;SAC3B,CAAC,CAAC;QACH,IAAI,CAAC,IAAI,GAAG,gBAAgB,CAAC;QAC7B,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;QAC/B,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;IACvC,CAAC;IAEQ,WAAW;QAClB,OAAO,IAAI,CAAC;IACd,CAAC;IAEQ,qBAAqB;QAC5B,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,OAAO,QAAQ,IAAI,CAAC,UAAU,kHAAkH,CAAC;QACnJ,CAAC;QACD,OAAO,uHAAuH,CAAC;IACjI,CAAC;CACF"}

package/dist/esm/errors/validation.js

@@ -0,0 +1,45 @@
+import { WebacyError } from './base.js';
+/**
+ * Thrown when request validation fails
+ *
+ * This error occurs when the provided input doesn't meet the API requirements.
+ * Common causes include invalid addresses, unsupported chains, or missing parameters.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await client.addresses.analyze(address, { chain: Chain.ETH });
+ * } catch (error) {
+ *   if (error instanceof ValidationError) {
+ *     console.error('Validation failed:', error.message);
+ *     if (error.errors) {
+ *       for (const [field, messages] of Object.entries(error.errors)) {
+ *         console.error(`  ${field}: ${messages.join(', ')}`);
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export class ValidationError extends WebacyError {
+    /** Field-level validation errors */
+    errors;
+    constructor(message = 'Validation failed', options = {}) {
+        super(message, {
+            status: 400,
+            code: 'VALIDATION_ERROR',
+            requestId: options.requestId,
+            endpoint: options.endpoint,
+        });
+        this.name = 'ValidationError';
+        this.errors = options.errors;
+    }
+    getRecoverySuggestion() {
+        if (this.errors && Object.keys(this.errors).length > 0) {
+            const fields = Object.keys(this.errors).join(', ');
+            return `Check the following fields: ${fields}. Ensure address formats match the specified blockchain and all required parameters are provided.`;
+        }
+        return 'Check your input parameters. Ensure address formats match the specified blockchain (e.g., 0x... for EVM chains, base58 for Solana).';
+    }
+}
+//# sourceMappingURL=validation.js.map

package/dist/esm/errors/validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.js","sourceRoot":"","sources":["../../../src/errors/validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,OAAO,eAAgB,SAAQ,WAAW;IAC9C,oCAAoC;IACpB,MAAM,CAA4B;IAElD,YACE,OAAO,GAAG,mBAAmB,EAC7B,UAAwF,EAAE;QAE1F,KAAK,CAAC,OAAO,EAAE;YACb,MAAM,EAAE,GAAG;YACX,IAAI,EAAE,kBAAkB;YACxB,SAAS,EAAE,OAAO,CAAC,SAAS;YAC5B,QAAQ,EAAE,OAAO,CAAC,QAAQ;SAC3B,CAAC,CAAC;QACH,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC;QAC9B,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAC/B,CAAC;IAEQ,qBAAqB;QAC5B,IAAI,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACvD,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACnD,OAAO,+BAA+B,MAAM,mGAAmG,CAAC;QAClJ,CAAC;QACD,OAAO,qIAAqI,CAAC;IAC/I,CAAC;CACF"}

package/dist/esm/http/client.js

@@ -0,0 +1,389 @@
+import { WebacyError, AuthenticationError, RateLimitError, ValidationError, NotFoundError, NetworkError, } from '../errors/index.js';
+import { DEFAULT_RETRY_CONFIG, calculateRetryDelay, isRetryableStatusCode, sleep, } from './retry.js';
+import { defaultLogger } from '../config.js';
+/**
+ * HTTP client with retry support and interceptors
+ */
+export class HttpClient {
+    baseUrl;
+    defaultHeaders;
+    defaultTimeout;
+    retryConfig;
+    requestInterceptors = [];
+    responseInterceptors = [];
+    errorInterceptors = [];
+    debug;
+    logger;
+    constructor(config) {
+        this.baseUrl = config.baseUrl.replace(/\/$/, ''); // Remove trailing slash
+        this.defaultHeaders = {
+            'Content-Type': 'application/json',
+            Accept: 'application/json',
+            ...config.headers,
+        };
+        this.defaultTimeout = config.timeout ?? 30000;
+        this.retryConfig = { ...DEFAULT_RETRY_CONFIG, ...config.retry };
+        this.debug = config.debug ?? false;
+        this.logger = config.logger ?? defaultLogger;
+    }
+    /**
+     * Check if request logging is enabled
+     */
+    shouldLogRequests() {
+        return this.debug === true || this.debug === 'all' || this.debug === 'requests';
+    }
+    /**
+     * Check if response logging is enabled
+     */
+    shouldLogResponses() {
+        return this.debug === true || this.debug === 'all' || this.debug === 'responses';
+    }
+    /**
+     * Check if error logging is enabled
+     */
+    shouldLogErrors() {
+        return this.debug === true || this.debug === 'all' || this.debug === 'errors';
+    }
+    /**
+     * Log a request
+     */
+    logRequest(method, url, body) {
+        if (this.shouldLogRequests()) {
+            this.logger.debug(`→ ${method} ${url}`, body ? { body: this.sanitizeBody(body) } : undefined);
+        }
+    }
+    /**
+     * Log a response
+     */
+    logResponse(method, url, status, duration) {
+        if (this.shouldLogResponses()) {
+            this.logger.debug(`← ${method} ${url} ${status} (${duration}ms)`);
+        }
+    }
+    /**
+     * Log an error
+     */
+    logError(method, url, error) {
+        if (this.shouldLogErrors()) {
+            this.logger.error(`✗ ${method} ${url} - ${error.code}: ${error.message}`, {
+                code: error.code,
+                status: error.status,
+                requestId: error.requestId,
+            });
+        }
+    }
+    /**
+     * Sanitize request body for logging (remove sensitive data)
+     * Recursively processes nested objects and arrays
+     */
+    sanitizeBody(body) {
+        if (typeof body !== 'object' || body === null) {
+            return body;
+        }
+        // Handle arrays recursively
+        if (Array.isArray(body)) {
+            return body.map((item) => this.sanitizeBody(item));
+        }
+        // Remove potentially sensitive fields from logs
+        const sanitized = {};
+        const sensitiveKeys = [
+            'apikey',
+            'api_key',
+            'secret',
+            'password',
+            'token',
+            'authorization',
+            'auth',
+            'credentials',
+            'bearer',
+        ];
+        for (const [key, value] of Object.entries(body)) {
+            if (sensitiveKeys.includes(key.toLowerCase())) {
+                sanitized[key] = '[REDACTED]';
+            }
+            else if (typeof value === 'object' && value !== null) {
+                sanitized[key] = this.sanitizeBody(value);
+            }
+            else {
+                sanitized[key] = value;
+            }
+        }
+        return sanitized;
+    }
+    /**
+     * Add a request interceptor
+     */
+    addRequestInterceptor(interceptor) {
+        this.requestInterceptors.push(interceptor);
+    }
+    /**
+     * Add a response interceptor
+     */
+    addResponseInterceptor(interceptor) {
+        this.responseInterceptors.push(interceptor);
+    }
+    /**
+     * Add an error interceptor
+     */
+    addErrorInterceptor(interceptor) {
+        this.errorInterceptors.push(interceptor);
+    }
+    /**
+     * Make a GET request
+     */
+    async get(path, config) {
+        return this.request(path, { ...config, method: 'GET' });
+    }
+    /**
+     * Make a POST request
+     */
+    async post(path, body, config) {
+        return this.request(path, { ...config, method: 'POST', body });
+    }
+    /**
+     * Make a PUT request
+     */
+    async put(path, body, config) {
+        return this.request(path, { ...config, method: 'PUT', body });
+    }
+    /**
+     * Make a PATCH request
+     */
+    async patch(path, body, config) {
+        return this.request(path, { ...config, method: 'PATCH', body });
+    }
+    /**
+     * Make a DELETE request
+     */
+    async delete(path, config) {
+        return this.request(path, { ...config, method: 'DELETE' });
+    }
+    /**
+     * Make an HTTP request with retry support
+     */
+    async request(path, config = {}) {
+        const url = `${this.baseUrl}${path.startsWith('/') ? path : `/${path}`}`;
+        // Apply request interceptors
+        let finalConfig = { ...config };
+        for (const interceptor of this.requestInterceptors) {
+            finalConfig = await interceptor(url, finalConfig);
+        }
+        let lastError;
+        let attempt = 0;
+        while (attempt <= this.retryConfig.maxRetries) {
+            try {
+                const response = await this.executeRequest(url, finalConfig);
+                // Apply response interceptors
+                let finalResponse = response;
+                for (const interceptor of this.responseInterceptors) {
+                    finalResponse = (await interceptor(finalResponse));
+                }
+                return finalResponse;
+            }
+            catch (error) {
+                lastError = error instanceof WebacyError ? error : this.wrapError(error);
+                // Apply error interceptors
+                for (const interceptor of this.errorInterceptors) {
+                    lastError = await interceptor(lastError);
+                }
+                // Check if we should retry
+                if (!lastError.isRetryable() || attempt >= this.retryConfig.maxRetries) {
+                    throw lastError;
+                }
+                // Calculate retry delay
+                const retryAfter = lastError instanceof RateLimitError ? lastError.retryAfter : undefined;
+                const delay = calculateRetryDelay(attempt, this.retryConfig, retryAfter);
+                await sleep(delay);
+                attempt++;
+            }
+        }
+        throw lastError ?? new NetworkError('Request failed after all retries');
+    }
+    /**
+     * Execute a single HTTP request
+     */
+    async executeRequest(url, config) {
+        const method = config.method ?? 'GET';
+        const timeout = config.timeout ?? this.defaultTimeout;
+        const controller = new AbortController();
+        let didTimeout = false;
+        const timeoutId = setTimeout(() => {
+            didTimeout = true;
+            controller.abort();
+        }, timeout);
+        const startTime = Date.now();
+        // Log the outgoing request
+        this.logRequest(method, url, config.body);
+        // Combine abort signals if user provided one
+        const signal = config.signal
+            ? this.combineAbortSignals(config.signal, controller.signal)
+            : controller.signal;
+        try {
+            const response = await fetch(url, {
+                method,
+                headers: {
+                    ...this.defaultHeaders,
+                    ...config.headers,
+                },
+                body: config.body ? JSON.stringify(config.body) : undefined,
+                signal,
+            });
+            clearTimeout(timeoutId);
+            const duration = Date.now() - startTime;
+            const requestId = response.headers.get('x-request-id') ?? undefined;
+            // Handle non-OK responses
+            if (!response.ok) {
+                const error = await this.createErrorFromResponse(response, requestId, url);
+                this.logError(method, url, error);
+                throw error;
+            }
+            // Log successful response
+            this.logResponse(method, url, response.status, duration);
+            // Parse response body
+            const contentType = response.headers.get('content-type');
+            let data;
+            if (contentType?.includes('application/json')) {
+                data = (await response.json());
+            }
+            else {
+                data = (await response.text());
+            }
+            return {
+                data,
+                status: response.status,
+                headers: response.headers,
+                requestId,
+            };
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof WebacyError) {
+                throw error;
+            }
+            // Handle fetch errors
+            let networkError;
+            if (error instanceof Error) {
+                if (error.name === 'AbortError') {
+                    // Distinguish between timeout and user-cancelled requests
+                    if (didTimeout) {
+                        networkError = new NetworkError('Request timed out', { cause: error, endpoint: url });
+                    }
+                    else {
+                        networkError = new NetworkError('Request was cancelled by the caller', {
+                            cause: error,
+                            endpoint: url,
+                        });
+                    }
+                }
+                else {
+                    networkError = new NetworkError(error.message, { cause: error, endpoint: url });
+                }
+            }
+            else {
+                networkError = new NetworkError('An unknown error occurred', { endpoint: url });
+            }
+            this.logError(method, url, networkError);
+            throw networkError;
+        }
+    }
+    /**
+     * Create an appropriate error from an HTTP response
+     */
+    async createErrorFromResponse(response, requestId, endpoint) {
+        let errorBody = {};
+        try {
+            errorBody = (await response.json());
+        }
+        catch {
+            // Ignore JSON parse errors
+        }
+        const message = errorBody.message ?? errorBody.error ?? response.statusText;
+        switch (response.status) {
+            case 401:
+            case 403:
+                return new AuthenticationError(message, { requestId, endpoint });
+            case 404:
+                return new NotFoundError(message, { requestId, endpoint });
+            case 429: {
+                const retryAfter = response.headers.get('retry-after');
+                const resetAt = response.headers.get('x-ratelimit-reset');
+                return new RateLimitError(message, {
+                    retryAfter: this.parseRetryAfter(retryAfter),
+                    resetAt: this.parseRetryAfter(resetAt),
+                    requestId,
+                    endpoint,
+                });
+            }
+            case 400:
+                return new ValidationError(message, {
+                    errors: errorBody.errors,
+                    requestId,
+                    endpoint,
+                });
+            default:
+                if (isRetryableStatusCode(response.status, this.retryConfig)) {
+                    return new NetworkError(message, {
+                        cause: new Error(`HTTP ${response.status}`),
+                        endpoint,
+                    });
+                }
+                return new WebacyError(message, {
+                    status: response.status,
+                    code: 'API_ERROR',
+                    requestId,
+                    endpoint,
+                });
+        }
+    }
+    /**
+     * Wrap an unknown error in a WebacyError
+     */
+    wrapError(error) {
+        if (error instanceof WebacyError) {
+            return error;
+        }
+        if (error instanceof Error) {
+            return new NetworkError(error.message, { cause: error });
+        }
+        return new NetworkError('An unknown error occurred');
+    }
+    /**
+     * Parse and validate Retry-After header value
+     *
+     * Handles edge cases:
+     * - NaN from non-numeric strings (e.g., HTTP-date format)
+     * - Negative values
+     * - Extremely large values (capped at 5 minutes)
+     *
+     * @param value - Raw header value
+     * @returns Validated retry delay in seconds, or undefined if invalid
+     */
+    parseRetryAfter(value) {
+        if (!value)
+            return undefined;
+        const parsed = parseInt(value, 10);
+        // Handle NaN (e.g., from HTTP-date format like "Wed, 21 Oct 2015 07:28:00 GMT")
+        // and negative values
+        if (Number.isNaN(parsed) || parsed < 0) {
+            return undefined;
+        }
+        // Cap at 5 minutes to prevent excessive delays from malformed headers
+        const MAX_RETRY_AFTER_SECONDS = 300;
+        return Math.min(parsed, MAX_RETRY_AFTER_SECONDS);
+    }
+    /**
+     * Combine multiple abort signals
+     */
+    combineAbortSignals(...signals) {
+        const controller = new AbortController();
+        for (const signal of signals) {
+            if (signal.aborted) {
+                controller.abort(signal.reason);
+                break;
+            }
+            signal.addEventListener('abort', () => controller.abort(signal.reason), { once: true });
+        }
+        return controller.signal;
+    }
+}
+//# sourceMappingURL=client.js.map