@zudojs/http 0.1.0 → 1.0.0

package/dist/httpCacheControl/httpCacheControl.freshness.js

@@ -0,0 +1,124 @@
+/**
+ * Cache freshness calculations.
+ *
+ * @module httpCacheControl/freshness
+ */
+import { parseCacheControl } from "./core/httpCacheControl.parse.js";
+/**
+ * Calculates the freshness of a cached response.
+ *
+ * `s-maxage` is preferred over `max-age`, and `Expires` is used when neither
+ * is present. `no-cache` and `no-store` force the response stale — a response
+ * the origin marked must-revalidate-before-reuse must never be reported
+ * fresh.
+ *
+ * @param responseHeaders - The cached response's headers.
+ * @param responseDate - The response's `Date`, if already parsed.
+ * @returns The freshness calculation.
+ */
+export function calculateFreshness(responseHeaders, responseDate) {
+    const cacheControl = responseHeaders["cache-control"];
+    const directives = parseCacheControl(cacheControl);
+    const date = responseDate ?? new Date(responseHeaders["date"] ?? Date.now());
+    /*
+     * RFC 9111 section 5.1: Age is a non-negative delta-seconds. A negative or
+     * suffixed value would otherwise inflate freshness without bound, which
+     * pins a poisoned response in cache far past the origin's TTL.
+     */
+    const rawAge = (responseHeaders["age"] ?? "").trim();
+    const age = /^\d+$/.test(rawAge) ? Number(rawAge) : 0;
+    const expiresHeader = responseHeaders["expires"];
+    const expires = expiresHeader ? parseExpires(expiresHeader) : undefined;
+    const effectiveMaxAge = resolveMaxAge(directives, expires, date);
+    const remaining = Math.max(0, effectiveMaxAge - age);
+    const stale = remaining <= 0 ||
+        directives.noCache === true ||
+        directives.noStore === true;
+    return {
+        maxAge: effectiveMaxAge,
+        expires,
+        date,
+        age,
+        stale,
+        remaining,
+    };
+}
+/**
+ * Parses an `Expires` header, treating an unparseable value as expired.
+ *
+ * @param value - The raw `Expires` value.
+ * @returns The parsed date, or the epoch when it cannot be parsed.
+ */
+function parseExpires(value) {
+    const parsed = new Date(value);
+    return Number.isNaN(parsed.getTime()) ? new Date(0) : parsed;
+}
+/**
+ * Resolves the freshness lifetime in seconds.
+ *
+ * @param directives - The parsed Cache-Control directives.
+ * @param expires - The parsed `Expires` header, if present.
+ * @param date - The response's `Date`.
+ * @returns The freshness lifetime in seconds.
+ */
+function resolveMaxAge(directives, expires, date) {
+    if (directives.sMaxAge !== undefined) {
+        return directives.sMaxAge;
+    }
+    if (directives.maxAge !== undefined) {
+        return directives.maxAge;
+    }
+    if (expires) {
+        return Math.max(0, Math.floor((expires.getTime() - date.getTime()) / 1_000));
+    }
+    return 0;
+}
+/**
+ * Determines if a cached response is still fresh.
+ */
+export function isFresh(responseHeaders, requestHeaders) {
+    const freshness = calculateFreshness(responseHeaders);
+    if (freshness.stale) {
+        return false;
+    }
+    if (requestHeaders) {
+        const reqCacheControl = requestHeaders["cache-control"];
+        const reqDirectives = parseCacheControl(reqCacheControl);
+        if (reqDirectives.maxAge !== undefined &&
+            freshness.age >= reqDirectives.maxAge) {
+            return false;
+        }
+        if (reqDirectives.minFresh !== undefined) {
+            const remaining = freshness.remaining;
+            if (remaining < reqDirectives.minFresh) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+/**
+ * Gets the remaining freshness in seconds.
+ */
+export function getRemainingFreshness(responseHeaders) {
+    const freshness = calculateFreshness(responseHeaders);
+    return freshness.remaining;
+}
+/**
+ * Determines if a stale response can be served while revalidating.
+ */
+export function canServeStaleWhileRevalidate(responseHeaders) {
+    const cacheControl = responseHeaders["cache-control"];
+    const directives = parseCacheControl(cacheControl);
+    return (directives.staleWhileRevalidate !== undefined &&
+        directives.staleWhileRevalidate > 0);
+}
+/**
+ * Determines if a stale response can be served on error.
+ */
+export function canServeStaleIfError(responseHeaders) {
+    const cacheControl = responseHeaders["cache-control"];
+    const directives = parseCacheControl(cacheControl);
+    return directives.staleIfError !== undefined && directives.staleIfError > 0;
+}
+//# sourceMappingURL=httpCacheControl.freshness.js.map

package/dist/httpCacheControl/httpCacheControl.requestHelper.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Request-related cache control helpers.
+ *
+ * @module httpCacheControl/requestHelpers
+ */
+import type { CacheControlDirectives } from "./core/httpCacheControl.type.js";
+/**
+ * Checks if a specific cache directive is present.
+ *
+ * Valued directives (`maxAge`, `sMaxAge`, `staleWhileRevalidate`,
+ * `noCacheHeaders`, …) are stored as numbers or arrays, not `true`, so a
+ * strict equality against `true` answered "no" for every one of them.
+ *
+ * @param directives - The parsed directives.
+ * @param directive - The directive to look for.
+ * @returns `true` if the directive was present in the header.
+ */
+export declare function hasCacheDirective(directives: CacheControlDirectives, directive: keyof CacheControlDirectives): boolean;
+/**
+ * Gets the value of a specific cache directive.
+ */
+export declare function getCacheDirective(directives: CacheControlDirectives, directive: keyof CacheControlDirectives): string | number | boolean | readonly string[] | undefined;
+/**
+ * Determines if a request requires cache revalidation.
+ */
+export declare function requestRequiresRevalidation(header: string | undefined): boolean;
+/**
+ * Determines if a request only uses cached responses.
+ */
+export declare function requestOnlyIfCached(header: string | undefined): boolean;
+/**
+ * Gets the maximum stale age from request directives.
+ */
+export declare function getMaximumStaleAge(header: string | undefined): number | undefined;
+/**
+ * Gets the minimum freshness required from request directives.
+ */
+export declare function getMinimumFreshness(header: string | undefined): number | undefined;
+//# sourceMappingURL=httpCacheControl.requestHelper.d.ts.map

package/dist/httpCacheControl/httpCacheControl.requestHelper.js

@@ -0,0 +1,56 @@
+/**
+ * Request-related cache control helpers.
+ *
+ * @module httpCacheControl/requestHelpers
+ */
+import { parseCacheControl } from "./core/httpCacheControl.parse.js";
+/**
+ * Checks if a specific cache directive is present.
+ *
+ * Valued directives (`maxAge`, `sMaxAge`, `staleWhileRevalidate`,
+ * `noCacheHeaders`, …) are stored as numbers or arrays, not `true`, so a
+ * strict equality against `true` answered "no" for every one of them.
+ *
+ * @param directives - The parsed directives.
+ * @param directive - The directive to look for.
+ * @returns `true` if the directive was present in the header.
+ */
+export function hasCacheDirective(directives, directive) {
+    const value = directives[directive];
+    return value !== undefined && value !== false;
+}
+/**
+ * Gets the value of a specific cache directive.
+ */
+export function getCacheDirective(directives, directive) {
+    return directives[directive];
+}
+/**
+ * Determines if a request requires cache revalidation.
+ */
+export function requestRequiresRevalidation(header) {
+    const directives = parseCacheControl(header);
+    return directives.noCache === true || directives.mustRevalidate === true;
+}
+/**
+ * Determines if a request only uses cached responses.
+ */
+export function requestOnlyIfCached(header) {
+    const directives = parseCacheControl(header);
+    return directives.onlyIfCached === true;
+}
+/**
+ * Gets the maximum stale age from request directives.
+ */
+export function getMaximumStaleAge(header) {
+    const directives = parseCacheControl(header);
+    return directives.maxStale;
+}
+/**
+ * Gets the minimum freshness required from request directives.
+ */
+export function getMinimumFreshness(header) {
+    const directives = parseCacheControl(header);
+    return directives.minFresh;
+}
+//# sourceMappingURL=httpCacheControl.requestHelper.js.map

package/dist/httpCacheControl/httpCacheControl.responseHelper.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Response-related cache control helpers.
+ *
+ * @module httpCacheControl/responseHelpers
+ */
+/**
+ * Determines if a response is storable by a **shared** cache.
+ *
+ * RFC 9111 section 3.5: a response to an `Authorization`-bearing request may
+ * only be stored when it carries `must-revalidate`, `public` or `s-maxage`.
+ * `private` is not sufficient — it is the directive meaning *"do not store
+ * this in a shared cache"*, so accepting it authorised the canonical
+ * shared-cache authentication bypass.
+ *
+ * @param responseHeaders - The response headers.
+ * @param requestHeaders - The originating request's headers.
+ * @returns `true` if the response may be stored.
+ */
+export declare function isResponseStorable(responseHeaders: Readonly<Record<string, string>>, requestHeaders?: Readonly<Record<string, string>>): boolean;
+/**
+ * Determines if a response is explicitly public.
+ */
+export declare function isResponsePublic(responseHeaders: Readonly<Record<string, string>>): boolean;
+/**
+ * Determines if a response is explicitly private.
+ */
+export declare function isResponsePrivate(responseHeaders: Readonly<Record<string, string>>): boolean;
+/**
+ * Determines if a response is immutable.
+ */
+export declare function isImmutable(responseHeaders: Readonly<Record<string, string>>): boolean;
+/**
+ * Determines if a response allows transformation.
+ */
+export declare function allowsTransformation(responseHeaders: Readonly<Record<string, string>>): boolean;
+/**
+ * Gets the effective max-age for a response.
+ */
+export declare function getEffectiveMaxAge(responseHeaders: Readonly<Record<string, string>>): number;
+//# sourceMappingURL=httpCacheControl.responseHelper.d.ts.map

package/dist/httpCacheControl/httpCacheControl.responseHelper.js

@@ -0,0 +1,87 @@
+/**
+ * Response-related cache control helpers.
+ *
+ * @module httpCacheControl/responseHelpers
+ */
+import { parseCacheControl } from "./core/httpCacheControl.parse.js";
+/**
+ * Determines if a response is storable by a **shared** cache.
+ *
+ * RFC 9111 section 3.5: a response to an `Authorization`-bearing request may
+ * only be stored when it carries `must-revalidate`, `public` or `s-maxage`.
+ * `private` is not sufficient — it is the directive meaning *"do not store
+ * this in a shared cache"*, so accepting it authorised the canonical
+ * shared-cache authentication bypass.
+ *
+ * @param responseHeaders - The response headers.
+ * @param requestHeaders - The originating request's headers.
+ * @returns `true` if the response may be stored.
+ */
+export function isResponseStorable(responseHeaders, requestHeaders) {
+    const directives = parseCacheControl(responseHeaders["cache-control"]);
+    if (directives.noStore) {
+        return false;
+    }
+    if (parseCacheControl(requestHeaders?.["cache-control"]).noStore) {
+        return false;
+    }
+    const authHeader = requestHeaders?.["authorization"];
+    if (authHeader &&
+        !(directives.public === true ||
+            directives.mustRevalidate === true ||
+            directives.sMaxAge !== undefined)) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Determines if a response is explicitly public.
+ */
+export function isResponsePublic(responseHeaders) {
+    const cacheControl = responseHeaders["cache-control"];
+    const directives = parseCacheControl(cacheControl);
+    return directives.public === true;
+}
+/**
+ * Determines if a response is explicitly private.
+ */
+export function isResponsePrivate(responseHeaders) {
+    const cacheControl = responseHeaders["cache-control"];
+    const directives = parseCacheControl(cacheControl);
+    return directives.private === true;
+}
+/**
+ * Determines if a response is immutable.
+ */
+export function isImmutable(responseHeaders) {
+    const cacheControl = responseHeaders["cache-control"];
+    const directives = parseCacheControl(cacheControl);
+    return directives.immutable === true;
+}
+/**
+ * Determines if a response allows transformation.
+ */
+export function allowsTransformation(responseHeaders) {
+    const cacheControl = responseHeaders["cache-control"];
+    const directives = parseCacheControl(cacheControl);
+    return directives.noTransform !== true;
+}
+/**
+ * Gets the effective max-age for a response.
+ */
+export function getEffectiveMaxAge(responseHeaders) {
+    const cacheControl = responseHeaders["cache-control"];
+    const directives = parseCacheControl(cacheControl);
+    if (directives.maxAge !== undefined) {
+        return directives.maxAge;
+    }
+    const expires = responseHeaders["expires"];
+    if (expires) {
+        const expiresDate = new Date(expires);
+        const now = new Date();
+        const diff = Math.floor((expiresDate.getTime() - now.getTime()) / 1000);
+        return Math.max(0, diff);
+    }
+    return 0;
+}
+//# sourceMappingURL=httpCacheControl.responseHelper.js.map

package/dist/httpClient/httpClient.abort.d.ts

@@ -0,0 +1,7 @@
+/**
+ * HTTP client abort signal combining.
+ *
+ * @module httpClient/abort
+ */
+export declare function combineAbortSignals(first?: AbortSignal, second?: AbortSignal): AbortSignal | undefined;
+//# sourceMappingURL=httpClient.abort.d.ts.map

package/dist/httpClient/httpClient.abort.js

@@ -0,0 +1,34 @@
+/**
+ * HTTP client abort signal combining.
+ *
+ * @module httpClient/abort
+ */
+export function combineAbortSignals(first, second) {
+    if (!first) {
+        return second;
+    }
+    if (!second) {
+        return first;
+    }
+    if (typeof AbortSignal !== "undefined" && "any" in AbortSignal) {
+        return AbortSignal.any([first, second]);
+    }
+    const controller = new AbortController();
+    const abort = (event) => {
+        controller.abort(event.target.reason);
+    };
+    if (first.aborted) {
+        controller.abort(first.reason);
+    }
+    else {
+        first.addEventListener("abort", abort, { once: true });
+    }
+    if (second.aborted) {
+        controller.abort(second.reason);
+    }
+    else {
+        second.addEventListener("abort", abort, { once: true });
+    }
+    return controller.signal;
+}
+//# sourceMappingURL=httpClient.abort.js.map

package/dist/httpClient/httpClient.body.d.ts

@@ -0,0 +1,8 @@
+/**
+ * HTTP client request body normalization.
+ *
+ * @module httpClient/body
+ */
+import type { HttpClientBody } from "./httpClient.type.js";
+export declare function normalizeRequestBody(body: HttpClientBody, headers: Headers, method: string): BodyInit | undefined;
+//# sourceMappingURL=httpClient.body.d.ts.map

package/dist/httpClient/httpClient.body.js

@@ -0,0 +1,53 @@
+/**
+ * HTTP client request body normalization.
+ *
+ * @module httpClient/body
+ */
+import { HttpClientError } from "./httpClient.error.js";
+export function normalizeRequestBody(body, headers, method) {
+    if (body === undefined || body === null) {
+        return undefined;
+    }
+    if (method === "GET" || method === "HEAD") {
+        throw new HttpClientError(`${method} requests cannot contain a request body.`, {
+            code: "HTTP_CLIENT_INVALID_BODY",
+        });
+    }
+    if (isBodyInit(body)) {
+        return body;
+    }
+    if (typeof body === "object") {
+        if (!headers.has("content-type")) {
+            headers.set("content-type", "application/json; charset=utf-8");
+        }
+        return JSON.stringify(body);
+    }
+    return String(body);
+}
+function isBodyInit(value) {
+    if (typeof value === "string") {
+        return true;
+    }
+    if (typeof Blob !== "undefined" && value instanceof Blob) {
+        return true;
+    }
+    if (typeof FormData !== "undefined" && value instanceof FormData) {
+        return true;
+    }
+    if (typeof URLSearchParams !== "undefined" &&
+        value instanceof URLSearchParams) {
+        return true;
+    }
+    if (typeof ArrayBuffer !== "undefined" && value instanceof ArrayBuffer) {
+        return true;
+    }
+    if (typeof Uint8Array !== "undefined" && value instanceof Uint8Array) {
+        return true;
+    }
+    if (typeof ReadableStream !== "undefined" &&
+        value instanceof ReadableStream) {
+        return true;
+    }
+    return false;
+}
+//# sourceMappingURL=httpClient.body.js.map

package/dist/httpClient/httpClient.client.d.ts

@@ -0,0 +1,24 @@
+/**
+ * HTTP client core class.
+ *
+ * @module httpClient/client
+ */
+import type { HttpClientRequestConfig, HttpRetryOptions, HttpClientOptions, HttpClientResponse, HttpRequestInterceptor, HttpResponseInterceptor, HttpErrorInterceptor } from "./httpClient.type.js";
+export declare class HttpClient {
+    readonly baseUrl: string | undefined;
+    private readonly defaultHeaders;
+    readonly defaultTimeout: number | undefined;
+    readonly defaultRetry: HttpRetryOptions | undefined;
+    readonly defaults: Omit<RequestInit, "headers">;
+    readonly fetchImpl: typeof globalThis.fetch;
+    private readonly requestInterceptors;
+    private readonly responseInterceptors;
+    private readonly errorInterceptors;
+    constructor(options?: HttpClientOptions);
+    request<T = unknown>(url: string | URL, config?: HttpClientRequestConfig): Promise<HttpClientResponse<T>>;
+    addRequestInterceptor(interceptor: HttpRequestInterceptor): () => void;
+    addResponseInterceptor(interceptor: HttpResponseInterceptor): () => void;
+    addErrorInterceptor(interceptor: HttpErrorInterceptor): () => void;
+    private execute;
+}
+//# sourceMappingURL=httpClient.client.d.ts.map

package/dist/httpClient/httpClient.client.js

@@ -0,0 +1,84 @@
+/**
+ * HTTP client core class.
+ *
+ * @module httpClient/client
+ */
+import { normalizeBaseUrl, validateTimeout, isHttpClientResponse, HttpClientResponseMarker, } from "./httpClient.helpers.js";
+import { normalizeRetryOptions } from "./httpClient.retry.js";
+import { normalizeClientError } from "./httpClient.errorNormalizer.js";
+import { createContext } from "./httpClient.context.js";
+import { executeWithRetry } from "./httpClient.executor.js";
+import { addRequestInterceptor, addResponseInterceptor, addErrorInterceptor, } from "./httpClient.interceptors.js";
+export class HttpClient {
+    baseUrl;
+    defaultHeaders;
+    defaultTimeout;
+    defaultRetry;
+    defaults;
+    fetchImpl;
+    requestInterceptors;
+    responseInterceptors;
+    errorInterceptors;
+    constructor(options = {}) {
+        this.baseUrl = normalizeBaseUrl(options.baseUrl);
+        this.defaultHeaders = new Headers(options.headers);
+        this.defaultTimeout = validateTimeout(options.timeout);
+        this.defaultRetry = normalizeRetryOptions(options.retry);
+        this.defaults = {
+            credentials: options.credentials,
+            mode: options.mode,
+            cache: options.cache,
+            redirect: options.redirect,
+            referrer: options.referrer,
+            referrerPolicy: options.referrerPolicy,
+            integrity: options.integrity,
+            keepalive: options.keepalive,
+        };
+        this.fetchImpl = options.fetch ?? globalThis.fetch.bind(globalThis);
+        this.requestInterceptors = [...(options.interceptors?.request ?? [])];
+        this.responseInterceptors = [...(options.interceptors?.response ?? [])];
+        this.errorInterceptors = [...(options.interceptors?.error ?? [])];
+    }
+    request(url, config = {}) {
+        return this.execute(url, config);
+    }
+    /* Interceptors */
+    addRequestInterceptor(interceptor) {
+        return addRequestInterceptor(this.requestInterceptors, interceptor);
+    }
+    addResponseInterceptor(interceptor) {
+        return addResponseInterceptor(this.responseInterceptors, interceptor);
+    }
+    addErrorInterceptor(interceptor) {
+        return addErrorInterceptor(this.errorInterceptors, interceptor);
+    }
+    /* Execution */
+    async execute(url, config) {
+        let context = createContext(url, config, this.baseUrl, this.defaultHeaders, this.defaults);
+        try {
+            for (const interceptor of this.requestInterceptors) {
+                context = await interceptor(context);
+            }
+            const response = await executeWithRetry(context, this);
+            let transformed = response;
+            for (const interceptor of this.responseInterceptors) {
+                transformed = await interceptor(transformed);
+            }
+            return transformed;
+        }
+        catch (error) {
+            const normalized = normalizeClientError(error, context.request);
+            for (const interceptor of this.errorInterceptors) {
+                const result = await interceptor(normalized);
+                if (result instanceof HttpClientResponseMarker) {
+                    return result.value;
+                }
+                if (isHttpClientResponse(result)) {
+                    return result;
+                }
+            }
+            throw normalized;
+        }
+    }
+}
+//# sourceMappingURL=httpClient.client.js.map

package/dist/httpClient/httpClient.context.d.ts

@@ -0,0 +1,8 @@
+/**
+ * HTTP client request context creation.
+ *
+ * @module httpClient/context
+ */
+import type { HttpClientRequestConfig, HttpClientRequestContext } from "./httpClient.type.js";
+export declare function createContext(url: string | URL, config: HttpClientRequestConfig, baseUrl: string | undefined, defaultHeaders: Headers, defaults?: Omit<RequestInit, "headers">): HttpClientRequestContext;
+//# sourceMappingURL=httpClient.context.d.ts.map

package/dist/httpClient/httpClient.context.js

@@ -0,0 +1,42 @@
+/**
+ * HTTP client request context creation.
+ *
+ * @module httpClient/context
+ */
+import { createFetchRequest } from "../httpAdapter/httpFetch.adapter.js";
+import { buildClientUrl } from "./httpClient.url.js";
+import { mergeHeaders } from "./httpClient.headers.js";
+import { normalizeRequestBody } from "./httpClient.body.js";
+export function createContext(url, config, baseUrl, defaultHeaders, defaults = {}) {
+    const method = (config.method ?? "GET").toUpperCase();
+    const target = buildClientUrl(url, baseUrl, config.query);
+    const headers = mergeHeaders(defaultHeaders, config.headers);
+    const body = normalizeRequestBody(config.body, headers, method);
+    /*
+     * Client-level defaults are applied first and the per-request config
+     * overrides them. Previously `defaults` was built in the constructor and
+     * read nowhere, so `redirect: "manual"`, `credentials: "omit"` and an
+     * `integrity` pin were all silently dropped.
+     */
+    const request = createFetchRequest({
+        url: typeof target === "string" ? target : target.toString(),
+        method,
+        headers: Object.fromEntries(headers.entries()),
+        body,
+    }, {
+        credentials: config.credentials ?? defaults.credentials,
+        mode: config.mode ?? defaults.mode,
+        cache: config.cache ?? defaults.cache,
+        redirect: config.redirect ?? defaults.redirect,
+        referrer: config.referrer ?? defaults.referrer,
+        referrerPolicy: config.referrerPolicy ?? defaults.referrerPolicy,
+        integrity: config.integrity ?? defaults.integrity,
+        keepalive: config.keepalive ?? defaults.keepalive,
+    });
+    return {
+        url: target.toString(),
+        config: { ...config, method },
+        request,
+    };
+}
+//# sourceMappingURL=httpClient.context.js.map

package/dist/httpClient/httpClient.errorNormalizer.d.ts

@@ -0,0 +1,8 @@
+/**
+ * HTTP client error normalization.
+ *
+ * @module httpClient/errorNormalizer
+ */
+import { HttpClientError } from "./httpClient.error.js";
+export declare function normalizeClientError(error: unknown, request?: Request): HttpClientError;
+//# sourceMappingURL=httpClient.errorNormalizer.d.ts.map

package/dist/httpClient/httpClient.errorNormalizer.js

@@ -0,0 +1,32 @@
+/**
+ * HTTP client error normalization.
+ *
+ * @module httpClient/errorNormalizer
+ */
+import { HttpClientError, HttpClientTimeoutError, HttpClientAbortError, HttpClientNetworkError, } from "./httpClient.error.js";
+export function normalizeClientError(error, request) {
+    if (error instanceof HttpClientError) {
+        return error;
+    }
+    /*
+     * Classify by the error itself first. Checking `signal.aborted` up front
+     * meant a genuine DNS or TLS failure that happened to race a concurrent
+     * timeout was reported as an abort, hiding the real cause.
+     */
+    if (error instanceof DOMException && error.name === "AbortError") {
+        const reason = request?.signal.reason;
+        if (reason instanceof HttpClientTimeoutError) {
+            return reason;
+        }
+        return new HttpClientAbortError(request, reason ?? error);
+    }
+    if (error instanceof TypeError) {
+        return new HttpClientNetworkError(error.message || "HTTP request failed due to a network error.", request, error);
+    }
+    return new HttpClientError(error instanceof Error ? error.message : "HTTP request failed.", {
+        code: "HTTP_CLIENT_ERROR",
+        request,
+        cause: error,
+    });
+}
+//# sourceMappingURL=httpClient.errorNormalizer.js.map

package/dist/httpClient/httpClient.executor.d.ts

@@ -0,0 +1,14 @@
+/**
+ * HTTP client execution with retry.
+ *
+ * @module httpClient/executor
+ */
+import type { HttpClientRequestContext, HttpClientResponse } from "./httpClient.type.js";
+interface HttpClientLike {
+    readonly fetchImpl: typeof globalThis.fetch;
+    readonly defaultRetry: import("./httpClient.type.js").HttpRetryOptions | undefined;
+    readonly defaultTimeout: number | undefined;
+}
+export declare function executeWithRetry(context: HttpClientRequestContext, client: HttpClientLike): Promise<HttpClientResponse>;
+export {};
+//# sourceMappingURL=httpClient.executor.d.ts.map