tunnelfetch 1.0.0

package/types/client/cookies.d.ts

@@ -0,0 +1,159 @@
+/**
+ * Parse a cookie date per RFC 6265 s5.1.1 — NOT Date.parse. Date.parse accepts formats the
+ * RFC rejects, rejects formats the RFC accepts (two-digit years, odd delimiters), and differs
+ * between engines; cookies from 1990s-era servers still use every shape the RFC grandfathers.
+ *
+ * The algorithm: split into tokens on "delimiters", then find — in any order, first match per
+ * category wins — a time (hh:mm:ss), a day (1-2 digits), a month (3-letter name), and a year
+ * (2-4 digits). Each token may carry trailing non-digit junk after the match.
+ *
+ * @param {string} s
+ * @returns {number|null} epoch milliseconds UTC, or null if the string is not a cookie date.
+ */
+export function parseCookieDate(s: string): number | null;
+/**
+ * RFC 6265 s5.1.4: the default path is the request path up to (not including) its last '/'.
+ * @param {string} requestPath
+ * @returns {string}
+ */
+export function defaultPath(requestPath: string): string;
+/**
+ * RFC 6265 s5.1.4 path-match.
+ * @param {string} requestPath
+ * @param {string} cookiePath
+ * @returns {boolean}
+ */
+export function pathMatches(requestPath: string, cookiePath: string): boolean;
+/**
+ * RFC 6265 s5.1.3 domain-match: exact, or host ends with '.' + domain.
+ * @param {string} host
+ * @param {string} cookieDomain
+ * @returns {boolean}
+ */
+export function domainMatches(host: string, cookieDomain: string): boolean;
+/**
+ * A stored cookie, as entries() exposes it. Records are live jar state, not copies.
+ * @typedef {object} Cookie
+ * @property {string} name
+ * @property {string} value quotes already stripped
+ * @property {string} domain lowercased; the Domain attribute, or the request host
+ * @property {boolean} hostOnly true when no Domain attribute applied — exact-host match only
+ * @property {string} path
+ * @property {boolean} secure
+ * @property {boolean} httpOnly
+ * @property {string | null} sameSite lowercased attribute value, stored verbatim — servers send
+ *   values outside strict/lax/none and this jar does not enforce SameSite anyway
+ * @property {number} expiry epoch ms; Infinity for a session cookie
+ * @property {number} creation epoch ms from the injected clock, kept across overwrites (s5.3)
+ * @property {number} seq creation-order tiebreak for the frozen-clock runtime
+ */
+/**
+ * @typedef {object} CookieJarOptions
+ * @property {() => number} [now] injectable clock returning epoch ms. On the target runtime
+ *   Date.now() freezes for a whole execution slice, so expiry must be testable via this knob.
+ * @property {number} [maxCookies] global cap, default 3000
+ * @property {number} [maxPerDomain] per-domain cap, default 50
+ */
+export class CookieJar {
+    /**
+     * @param {CookieJarOptions} [options]
+     *   The caps exist because this jar lives inside a long-lived Worker isolate: an unbounded
+     *   jar fed by a hostile or merely enthusiastic server is a slow memory leak, so overflow
+     *   evicts the oldest cookies instead of growing.
+     */
+    constructor({ now, maxCookies, maxPerDomain }?: CookieJarOptions);
+    _now: () => number;
+    _maxCookies: number;
+    _maxPerDomain: number;
+    /** @type {Map<string, Cookie>} key "domain|path|name" -> cookie record */
+    _cookies: Map<string, Cookie>;
+    _rejected: number;
+    /** Count of Set-Cookie values ignored per RFC rules — the observability hook. */
+    get rejected(): number;
+    get size(): number;
+    /**
+     * Ingest the Set-Cookie values of one response. Never throws on a bad cookie — rejection is
+     * silent per RFC 6265, counted in `rejected`.
+     * @param {string|URL} url the request URL the response belongs to
+     * @param {string[]} setCookieValues one array entry per Set-Cookie header
+     * @returns {void}
+     */
+    setFromResponse(url: string | URL, setCookieValues: string[]): void;
+    /**
+     * @param {string} host
+     * @param {boolean} requestSecure
+     * @param {string} requestPath
+     * @param {string} setCookie
+     * @returns {boolean} stored or deliberately deleted (true) vs ignored (false)
+     */
+    _setOne(host: string, requestSecure: boolean, requestPath: string, setCookie: string): boolean;
+    /**
+     * Evict expired cookies first, then the oldest by creation, per-domain then globally.
+     * @param {string} domain
+     */
+    _enforceCaps(domain: string): void;
+    /**
+     * The Cookie header value for a request, or null if no cookie matches.
+     * @param {string|URL} url
+     * @returns {string | null}
+     */
+    headerFor(url: string | URL): string | null;
+    /**
+     * Everything currently stored, for tests and debugging. Records are live; do not mutate.
+     * @returns {Cookie[]}
+     */
+    entries(): Cookie[];
+}
+/**
+ * A stored cookie, as entries() exposes it. Records are live jar state, not copies.
+ */
+export type Cookie = {
+    name: string;
+    /**
+     * quotes already stripped
+     */
+    value: string;
+    /**
+     * lowercased; the Domain attribute, or the request host
+     */
+    domain: string;
+    /**
+     * true when no Domain attribute applied — exact-host match only
+     */
+    hostOnly: boolean;
+    path: string;
+    secure: boolean;
+    httpOnly: boolean;
+    /**
+     * lowercased attribute value, stored verbatim — servers send
+     * values outside strict/lax/none and this jar does not enforce SameSite anyway
+     */
+    sameSite: string | null;
+    /**
+     * epoch ms; Infinity for a session cookie
+     */
+    expiry: number;
+    /**
+     * epoch ms from the injected clock, kept across overwrites (s5.3)
+     */
+    creation: number;
+    /**
+     * creation-order tiebreak for the frozen-clock runtime
+     */
+    seq: number;
+};
+export type CookieJarOptions = {
+    /**
+     * injectable clock returning epoch ms. On the target runtime
+     * Date.now() freezes for a whole execution slice, so expiry must be testable via this knob.
+     */
+    now?: (() => number) | undefined;
+    /**
+     * global cap, default 3000
+     */
+    maxCookies?: number | undefined;
+    /**
+     * per-domain cap, default 50
+     */
+    maxPerDomain?: number | undefined;
+};

package/types/client/decode.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Undo the response's Content-Encoding.
+ *
+ * @param {ReadableStream<Uint8Array>} stream the raw body
+ * @param {string|null|undefined} contentEncoding the Content-Encoding header value; a
+ *   comma-separated list names codings in the order the SERVER applied them, so decoding
+ *   applies them in reverse.
+ * @returns {ReadableStream<Uint8Array>} decoded bytes
+ */
+export function decodeBody(stream: ReadableStream<Uint8Array>, contentEncoding: string | null | undefined): ReadableStream<Uint8Array>;
+/**
+ * Extract the charset parameter from a Content-Type value, handling quoting and other
+ * parameters: `text/html; boundary=x; charset="ISO-8859-4"` -> 'iso-8859-4'.
+ * @param {string | null | undefined} contentType
+ * @returns {string|null} lowercased charset label, or null when none is declared
+ */
+export function charsetFromContentType(contentType: string | null | undefined): string | null;
+/**
+ * Decide the charset for a response body.
+ *
+ * Precedence: BOM > Content-Type charset parameter > (text/html only) meta prescan > utf-8.
+ * The BOM outranks even an explicit header because it describes the actual bytes, and servers
+ * that recode content routinely forget to update the header; this is WHATWG "decode" order.
+ * The utf-8 default matches Response.text() in fetch — for a client whose callers are code,
+ * matching fetch is worth more than matching the legacy HTML default of windows-1252.
+ *
+ * @param {string|null|undefined} contentType
+ * @param {Uint8Array} [bodyPrefix] the first bytes of the body (>= 1024 to satisfy the prescan)
+ * @returns {string} a charset label for decodeText
+ */
+export function charsetFor(contentType: string | null | undefined, bodyPrefix?: Uint8Array): string;
+/**
+ * Decode bytes with a charset label.
+ *
+ * TextDecoder implements the WHATWG encoding registry, which is the alias table every browser
+ * uses. Note one alias that looks like a bug and is not: `iso-8859-1` (and `latin1`, `ascii`)
+ * maps to windows-1252, per WHATWG — the bytes 0x80-0x9F decode to the punctuation everyone
+ * actually means, not C1 controls. A BOM matching the charset is stripped (TextDecoder default),
+ * which is also what Response.text() does.
+ *
+ * Throws HttpError (HTTP_CHARSET) for a label outside the WHATWG encoding registry.
+ *
+ * @param {Uint8Array} bytes
+ * @param {string} [charset]
+ * @returns {string}
+ */
+export function decodeText(bytes: Uint8Array, charset?: string): string;
+/**
+ * The exact Accept-Encoding value the request layer must send. The target runtime's
+ * DecompressionStream supports ONLY gzip / deflate / deflate-raw (verified empirically);
+ * advertising `br` or `zstd` would invite bytes we can never decode, turning every response
+ * from a brotli-preferring CDN into garbage. Keep this list and decodeBody in lockstep.
+ */
+export const ACCEPT_ENCODING: "gzip, deflate";

package/types/client/redirect.d.ts

@@ -0,0 +1,96 @@
+/**
+ * @param {number} status
+ * @param {string} [method] accepted for API symmetry; the status alone decides, because even a
+ *   combination we will rewrite (303 + POST) is still a redirect — it just mutates the method.
+ * @returns {boolean}
+ */
+export function shouldRedirect(status: number, method?: string): boolean;
+/**
+ * Resolve a Location header against the current URL, enforcing the scheme allow-list.
+ * Throws HttpError for a missing/unparseable Location or a non-http(s) scheme.
+ * @param {URL} currentUrl
+ * @param {string|null|undefined} location
+ * @returns {URL}
+ */
+export function resolveLocation(currentUrl: URL, location: string | null | undefined): URL;
+/**
+ * A request as the redirect engine consumes it. Bodies stay in whatever form the caller holds
+ * them; this layer only decides whether they survive the hop, never reads them.
+ * @typedef {Uint8Array | string | ReadableStream<Uint8Array> | null} RedirectBody
+ * @typedef {object} RedirectableRequest
+ * @property {string} method
+ * @property {string | URL} url
+ * @property {Headers | Record<string, string>} [headers]
+ * @property {RedirectBody} [body]
+ */
+/**
+ * The follow-up request. `url` and `headers` are always normalised instances; `body` is the
+ * caller's own value passed through, or null when the method rewrite dropped it.
+ * @typedef {object} NextRequest
+ * @property {string} method
+ * @property {URL} url
+ * @property {Headers} headers credential and body-describing headers already stripped per the
+ *   rules above
+ * @property {RedirectBody} body
+ */
+/**
+ * @typedef {object} NextRequestOptions
+ * @property {number} [maxRedirects] default 20
+ * @property {string[]} [history] pass the SAME array across every hop of one logical fetch; it
+ *   is both the loop detector and the hop counter
+ */
+/**
+ * Compute the follow-up request for a redirect response. Throws rather than returning a
+ * failure: LimitError past `maxRedirects`, HttpError for loops and bad Locations, ConfigError
+ * for a non-redirect status or an unreplayable stream body on 307/308.
+ *
+ * @param {RedirectableRequest} current
+ * @param {{ status: number, headers: Headers|Record<string,string> }} response
+ * @param {NextRequestOptions} [options]
+ * @returns {NextRequest}
+ */
+export function nextRequest(current: RedirectableRequest, response: {
+    status: number;
+    headers: Headers | Record<string, string>;
+}, options?: NextRequestOptions): NextRequest;
+export const DEFAULT_MAX_REDIRECTS: 20;
+/**
+ * A request as the redirect engine consumes it. Bodies stay in whatever form the caller holds
+ * them; this layer only decides whether they survive the hop, never reads them.
+ */
+export type RedirectBody = Uint8Array | string | ReadableStream<Uint8Array> | null;
+/**
+ * A request as the redirect engine consumes it. Bodies stay in whatever form the caller holds
+ * them; this layer only decides whether they survive the hop, never reads them.
+ */
+export type RedirectableRequest = {
+    method: string;
+    url: string | URL;
+    headers?: Headers | Record<string, string> | undefined;
+    body?: RedirectBody | undefined;
+};
+/**
+ * The follow-up request. `url` and `headers` are always normalised instances; `body` is the
+ * caller's own value passed through, or null when the method rewrite dropped it.
+ */
+export type NextRequest = {
+    method: string;
+    url: URL;
+    /**
+     * credential and body-describing headers already stripped per the
+     * rules above
+     */
+    headers: Headers;
+    body: RedirectBody;
+};
+export type NextRequestOptions = {
+    /**
+     * default 20
+     */
+    maxRedirects?: number | undefined;
+    /**
+     * pass the SAME array across every hop of one logical fetch; it
+     * is both the loop detector and the hop counter
+     */
+    history?: string[] | undefined;
+};

package/types/client.d.ts

@@ -0,0 +1,323 @@
+/**
+ * A standalone fetch bound to a configuration, matching httpx's module-level helpers. Creates and
+ * closes a Client per call, so no connection is reused; use `new Client()` when reuse matters.
+ *
+ * @param {ClientOptions} [options]
+ * @returns {FetchLike}
+ */
+export function createFetch(options?: ClientOptions): FetchLike;
+/**
+ * Replace `globalThis.fetch`, for libraries that only accept the global. Returns the undo.
+ * Never called automatically, and never on import.
+ *
+ * @param {ClientOptions} [options]
+ * @returns {() => void} uninstall; idempotent, and a no-op if someone else has since taken the global
+ */
+export function install(options?: ClientOptions): () => void;
+/**
+ * A `fetch`-shaped function. Deliberately the platform's own signature: being assignable to
+ * `typeof fetch` is what lets an SDK accept this in place of the global without adapting.
+ * @typedef {(input: RequestInfo | URL, init?: RequestInit) => Promise<Response>} FetchLike
+ */
+/**
+ * What a Response carries about the connection that produced it, under the non-standard
+ * `tunnelfetch` property.
+ * @typedef {object} ResponseDetail
+ * @property {string} url
+ * @property {boolean} proxied
+ * @property {string | null} proxy the proxy actually used, credentials omitted
+ * @property {import('./tls/connect.js').TlsSessionInfo | null} tls null for cleartext
+ * @property {'1.0' | '1.1' | '2'} httpVersion '2' when ALPN negotiated HTTP/2
+ * @property {'none' | 'content-length' | 'chunked' | 'until-close' | 'h2'} framing 'h2' when the
+ *   body was delimited by an HTTP/2 END_STREAM rather than by any HTTP/1.1 framing rule
+ */
+/**
+ * Limits on what a peer may make us buffer. Each is a fail-closed cap, not a hint.
+ * @typedef {object} Limits
+ * @property {number} [maxHeaderBytes] response head, default 65536
+ * @property {number} [maxProxyReplyBytes] proxy CONNECT reply head, default 32768
+ */
+/**
+ * @typedef {object} ClientOptions
+ * @property {import('./proxy/index.js').ConnectFn} [connect] Socket factory. Required for any
+ *   request the platform's own `fetch` cannot serve — which is every proxied request, and every
+ *   request asking for a trust policy `fetch` cannot express.
+ * @property {string | import('./proxy/index.js').ProxyConfig | null} [proxy] URL string or
+ *   config object; `http:`, `https:`, `socks5:` and `socks5h:`.
+ * @property {import('./trust/index.js').TrustConfig} [trust] certificate policy, httpx's
+ *   `verify=`. Default `{ mode: 'system' }`.
+ * @property {import('./tls/connect.js').TlsOptions} [tls] handshake knobs.
+ * @property {import('./util/deadline.js').DeadlineOptions} [timeouts] connect / handshake /
+ *   headers / idle / total, in ms. The idle gap is the control; total is a backstop.
+ * @property {boolean} [cookies] enable a per-Client cookie jar.
+ * @property {import('./client/cookies.js').CookieJar} [jar] supply a jar directly, e.g. to share
+ *   one across Clients or to persist it.
+ * @property {number} [maxRedirects] default 20.
+ * @property {number} [maxBodyBytes] enforced from Content-Length before a byte is read.
+ * @property {boolean} [decompress] gzip/deflate. Default true. Never `br`; the runtime cannot
+ *   decompress it, so it is never advertised either.
+ * @property {boolean} [keepAlive] default true.
+ * @property {boolean} [http2] offer HTTP/2 via ALPN and speak it when the server selects it.
+ *   Default true. The goal is ACCESS, not speed — some sites treat HTTP/1.1 as a bot signal — and
+ *   on a CPU-billed runtime h2 costs MORE than h1 (HPACK is extra work). Set false to offer only
+ *   `http/1.1`. There is no fallback-and-retry either way: the server's ALPN pick is followed.
+ * @property {boolean} [forceTunnel] never delegate to the platform's fetch, even when it could
+ *   serve the request. Mainly for exercising this stack against origins that do not need it.
+ * @property {FetchLike} [nativeFetch] delegation target; defaults to `globalThis.fetch`.
+ * @property {{ maxPerKey?: number, maxTotal?: number }} [pool] connection pool sizing.
+ * @property {Limits} [limits]
+ * @property {import('./tls/connect.js').TlsDeps} [deps] injectable randomness and key generation.
+ * @property {AbortSignal} [signal] aborts every request this Client makes.
+ * @property {number} [now] epoch ms override, for certificate validity in tests.
+ */
+export class Client {
+    /**
+     * @param {ClientOptions} [options]
+     */
+    constructor(options?: ClientOptions);
+    options: {
+        /**
+         * Socket factory. Required for any
+         * request the platform's own `fetch` cannot serve — which is every proxied request, and every
+         * request asking for a trust policy `fetch` cannot express.
+         */
+        connect?: import("./proxy/index.js").ConnectFn | undefined;
+        /**
+         * URL string or
+         * config object; `http:`, `https:`, `socks5:` and `socks5h:`.
+         */
+        proxy?: string | import("./proxy/index.js").ProxyConfig | null | undefined;
+        /**
+         * certificate policy, httpx's
+         * `verify=`. Default `{ mode: 'system' }`.
+         */
+        trust?: import("./trust/index.js").TrustConfig | undefined;
+        /**
+         * handshake knobs.
+         */
+        tls?: import("./tls/connect.js").TlsOptions | undefined;
+        /**
+         * connect / handshake /
+         * headers / idle / total, in ms. The idle gap is the control; total is a backstop.
+         */
+        timeouts?: import("./util/deadline.js").DeadlineOptions | undefined;
+        /**
+         * enable a per-Client cookie jar.
+         */
+        cookies?: boolean | undefined;
+        /**
+         * supply a jar directly, e.g. to share
+         * one across Clients or to persist it.
+         */
+        jar?: CookieJar | undefined;
+        /**
+         * default 20.
+         */
+        maxRedirects?: number | undefined;
+        /**
+         * enforced from Content-Length before a byte is read.
+         */
+        maxBodyBytes?: number | undefined;
+        /**
+         * gzip/deflate. Default true. Never `br`; the runtime cannot
+         * decompress it, so it is never advertised either.
+         */
+        decompress?: boolean | undefined;
+        /**
+         * default true.
+         */
+        keepAlive?: boolean | undefined;
+        /**
+         * offer HTTP/2 via ALPN and speak it when the server selects it.
+         * Default true. The goal is ACCESS, not speed — some sites treat HTTP/1.1 as a bot signal — and
+         * on a CPU-billed runtime h2 costs MORE than h1 (HPACK is extra work). Set false to offer only
+         * `http/1.1`. There is no fallback-and-retry either way: the server's ALPN pick is followed.
+         */
+        http2?: boolean | undefined;
+        /**
+         * never delegate to the platform's fetch, even when it could
+         * serve the request. Mainly for exercising this stack against origins that do not need it.
+         */
+        forceTunnel?: boolean | undefined;
+        /**
+         * delegation target; defaults to `globalThis.fetch`.
+         */
+        nativeFetch?: FetchLike | undefined;
+        /**
+         * connection pool sizing.
+         */
+        pool?: {
+            maxPerKey?: number;
+            maxTotal?: number;
+        } | undefined;
+        limits?: Limits | undefined;
+        /**
+         * injectable randomness and key generation.
+         */
+        deps?: import("./tls/connect.js").TlsDeps | undefined;
+        /**
+         * aborts every request this Client makes.
+         */
+        signal?: AbortSignal | undefined;
+        /**
+         * epoch ms override, for certificate validity in tests.
+         */
+        now?: number | undefined;
+    };
+    pool: ConnectionPool;
+    /** @type {Map<string, import('./http2/connection.js').Http2Connection>} */
+    _h2: Map<string, import("./http2/connection.js").Http2Connection>;
+    /** @type {Set<import('./http2/connection.js').Http2Connection>} */
+    _h2conns: Set<import("./http2/connection.js").Http2Connection>;
+    jar: CookieJar | null;
+    tickets: TicketStore;
+    _closed: boolean;
+    /**
+     * @param {RequestInfo | URL} input
+     * @param {RequestInit} [init]
+     * @returns {Promise<Response & { tunnelfetch?: ResponseDetail }>}
+     */
+    fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response & {
+        tunnelfetch?: ResponseDetail;
+    }>;
+    /** Release every pooled socket and shared HTTP/2 connection. A Client that is finished must be
+     *  closed or sockets leak for the isolate's lifetime. */
+    close(): Promise<void>;
+}
+/**
+ * A `fetch`-shaped function. Deliberately the platform's own signature: being assignable to
+ * `typeof fetch` is what lets an SDK accept this in place of the global without adapting.
+ */
+export type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+/**
+ * What a Response carries about the connection that produced it, under the non-standard
+ * `tunnelfetch` property.
+ */
+export type ResponseDetail = {
+    url: string;
+    proxied: boolean;
+    /**
+     * the proxy actually used, credentials omitted
+     */
+    proxy: string | null;
+    /**
+     * null for cleartext
+     */
+    tls: import("./tls/connect.js").TlsSessionInfo | null;
+    /**
+     * '2' when ALPN negotiated HTTP/2
+     */
+    httpVersion: "1.0" | "1.1" | "2";
+    /**
+     * 'h2' when the
+     * body was delimited by an HTTP/2 END_STREAM rather than by any HTTP/1.1 framing rule
+     */
+    framing: "none" | "content-length" | "chunked" | "until-close" | "h2";
+};
+/**
+ * Limits on what a peer may make us buffer. Each is a fail-closed cap, not a hint.
+ */
+export type Limits = {
+    /**
+     * response head, default 65536
+     */
+    maxHeaderBytes?: number | undefined;
+    /**
+     * proxy CONNECT reply head, default 32768
+     */
+    maxProxyReplyBytes?: number | undefined;
+};
+export type ClientOptions = {
+    /**
+     * Socket factory. Required for any
+     * request the platform's own `fetch` cannot serve — which is every proxied request, and every
+     * request asking for a trust policy `fetch` cannot express.
+     */
+    connect?: import("./proxy/index.js").ConnectFn | undefined;
+    /**
+     * URL string or
+     * config object; `http:`, `https:`, `socks5:` and `socks5h:`.
+     */
+    proxy?: string | import("./proxy/index.js").ProxyConfig | null | undefined;
+    /**
+     * certificate policy, httpx's
+     * `verify=`. Default `{ mode: 'system' }`.
+     */
+    trust?: import("./trust/index.js").TrustConfig | undefined;
+    /**
+     * handshake knobs.
+     */
+    tls?: import("./tls/connect.js").TlsOptions | undefined;
+    /**
+     * connect / handshake /
+     * headers / idle / total, in ms. The idle gap is the control; total is a backstop.
+     */
+    timeouts?: import("./util/deadline.js").DeadlineOptions | undefined;
+    /**
+     * enable a per-Client cookie jar.
+     */
+    cookies?: boolean | undefined;
+    /**
+     * supply a jar directly, e.g. to share
+     * one across Clients or to persist it.
+     */
+    jar?: CookieJar | undefined;
+    /**
+     * default 20.
+     */
+    maxRedirects?: number | undefined;
+    /**
+     * enforced from Content-Length before a byte is read.
+     */
+    maxBodyBytes?: number | undefined;
+    /**
+     * gzip/deflate. Default true. Never `br`; the runtime cannot
+     * decompress it, so it is never advertised either.
+     */
+    decompress?: boolean | undefined;
+    /**
+     * default true.
+     */
+    keepAlive?: boolean | undefined;
+    /**
+     * offer HTTP/2 via ALPN and speak it when the server selects it.
+     * Default true. The goal is ACCESS, not speed — some sites treat HTTP/1.1 as a bot signal — and
+     * on a CPU-billed runtime h2 costs MORE than h1 (HPACK is extra work). Set false to offer only
+     * `http/1.1`. There is no fallback-and-retry either way: the server's ALPN pick is followed.
+     */
+    http2?: boolean | undefined;
+    /**
+     * never delegate to the platform's fetch, even when it could
+     * serve the request. Mainly for exercising this stack against origins that do not need it.
+     */
+    forceTunnel?: boolean | undefined;
+    /**
+     * delegation target; defaults to `globalThis.fetch`.
+     */
+    nativeFetch?: FetchLike | undefined;
+    /**
+     * connection pool sizing.
+     */
+    pool?: {
+        maxPerKey?: number;
+        maxTotal?: number;
+    } | undefined;
+    limits?: Limits | undefined;
+    /**
+     * injectable randomness and key generation.
+     */
+    deps?: import("./tls/connect.js").TlsDeps | undefined;
+    /**
+     * aborts every request this Client makes.
+     */
+    signal?: AbortSignal | undefined;
+    /**
+     * epoch ms override, for certificate validity in tests.
+     */
+    now?: number | undefined;
+};
+import { CookieJar } from './client/cookies.js';
+import { ConnectionPool } from './pool.js';
+import { TicketStore } from './tls/tickets.js';
+import { utf8 } from './util/bytes.js';
+export { CookieJar, ConnectionPool, utf8 };