@repost/client 0.2.0 → 0.4.0

package/dist/esm/node-BAJt_qhB.mjs

@@ -0,0 +1,839 @@
+import { e as errorCode$1, c as classifyNetworkFailure } from './index-DRD5FBax.mjs';
+import { gunzip } from 'node:zlib';
+import { buildConnector, Pool } from 'undici';
+import { connect, isIP } from 'node:net';
+import { connect as connect$1 } from 'node:tls';
+import { connect as connect$2, constants } from 'node:http2';
+import './version-Dp5vd2nu.mjs';
+import './observer-Dns2X4wE.mjs';
+
+/** Builds the exact ordered fields used by the Node H1/H2 dispatcher. */
+function frameRequest(request) {
+    const url = new URL(request.url);
+    const authority = explicitAuthority(request.url);
+    const headers = [
+        "host", authority,
+        "content-length", String(request.bodyBytes.byteLength),
+    ];
+    for (const [name, value] of request.headers)
+        headers.push(name, value);
+    return {
+        origin: `${url.protocol}//${authority}`,
+        path: `${url.pathname}${url.search}`,
+        headers,
+    };
+}
+function explicitAuthority(value) {
+    const start = value.indexOf("://");
+    const authorityStart = start < 0 ? 0 : start + 3;
+    const tail = value.slice(authorityStart);
+    const authorityEnd = tail.search(/[/?#]/u);
+    return tail.slice(0, authorityEnd < 0 ? undefined : authorityEnd);
+}
+
+const COMPRESSED_LIMIT = 1048576;
+const DECOMPRESSED_LIMIT = 1048576;
+const ERROR_INSPECTION_LIMIT = 65536;
+const EXPANSION_RATIO_LIMIT = 100;
+const HEADER_FIELD_LIMIT = 100;
+const HEADER_BYTES_LIMIT = 65536;
+const HEADER_NAME_LIMIT = 256;
+const HEADER_VALUE_LIMIT = 8192;
+const encoder = new TextEncoder();
+const asciiOnlyHeaders = new Set(["content-encoding", "content-length", "content-type", "retry-after", "location"]);
+const framingHeaders = new Set(["connection", "date", "keep-alive", "transfer-encoding"]);
+async function readResponse(status, rawHeaders, chunks, compressedBytes, transportTruncated, compressedLimit = COMPRESSED_LIMIT) {
+    const headerSnapshot = snapshotHeaders(rawHeaders);
+    const common = {
+        kind: "response",
+        status,
+        headers: headerSnapshot.headers,
+        compressedBytes,
+        responseHeaderFields: headerSnapshot.fields,
+        responseHeaderBytes: headerSnapshot.bytes,
+    };
+    const success = status >= 200 && status <= 299;
+    if (headerSnapshot.protocolInvalid || headerSnapshot.limitExceeded) {
+        return {
+            ...common,
+            bodyBytes: new Uint8Array(),
+            compressedBytes: 0,
+            decompressedBytes: 0,
+            truncated: transportTruncated,
+            headerLimitExceeded: true,
+            ...(headerSnapshot.protocolInvalid ? { protocolError: true } : {}),
+            ...(headerSnapshot.limitExceeded ? { limitExceeded: success, nonRetryable: !success } : {}),
+        };
+    }
+    const outputLimit = success ? DECOMPRESSED_LIMIT : ERROR_INSPECTION_LIMIT;
+    const encoding = contentEncoding(headerSnapshot.headers);
+    if (encoding === null) {
+        return { ...common, bodyBytes: new Uint8Array(), compressedBytes: 0, decompressedBytes: 0, truncated: false, protocolError: true };
+    }
+    const declaredLength = singleHeader(headerSnapshot.headers, "content-length");
+    if (success && declaredLength !== null && (!/^(?:0|[1-9][0-9]*)$/u.test(declaredLength) || Number(declaredLength) > compressedLimit)) {
+        return { ...common, bodyBytes: new Uint8Array(), decompressedBytes: 0, truncated: transportTruncated, limitExceeded: true };
+    }
+    if (transportTruncated || compressedBytes > compressedLimit) {
+        if (encoding === "identity") {
+            const overLimit = compressedBytes > compressedLimit;
+            return {
+                ...common,
+                bodyBytes: concatenate(chunks, Math.min(outputLimit, compressedLimit)),
+                decompressedBytes: compressedBytes,
+                truncated: overLimit ? false : transportTruncated,
+                ...(success && overLimit ? { limitExceeded: true } : {}),
+                ...(success && transportTruncated && !overLimit ? { protocolError: true } : {}),
+                ...(!success && overLimit ? { nonRetryable: true } : {}),
+            };
+        }
+        return {
+            ...common,
+            bodyBytes: new Uint8Array(),
+            decompressedBytes: 0,
+            truncated: transportTruncated,
+            protocolError: true,
+        };
+    }
+    const compressed = concatenate(chunks, compressedLimit);
+    if (encoding === "identity") {
+        const truncated = compressed.length > outputLimit;
+        const bodyBytes = truncated ? compressed.slice(0, outputLimit) : compressed;
+        return { ...common, bodyBytes, decompressedBytes: compressed.length, truncated, limitExceeded: success && truncated };
+    }
+    try {
+        const decoded = new Uint8Array(await new Promise((resolve, reject) => {
+            gunzip(compressed, { maxOutputLength: outputLimit + 1 }, (error, value) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(value);
+            });
+        }));
+        const ratioExceeded = compressed.length === 0 ? decoded.length > 0 : decoded.length > compressed.length * EXPANSION_RATIO_LIMIT;
+        const truncated = decoded.length > outputLimit;
+        const bodyBytes = decoded.slice(0, Math.min(decoded.length, outputLimit));
+        return {
+            ...common,
+            bodyBytes,
+            decompressedBytes: decoded.length,
+            truncated,
+            ...(ratioExceeded ? { protocolError: true } : { limitExceeded: success && truncated }),
+        };
+    }
+    catch (error) {
+        const limit = errorCode(error) === "ERR_BUFFER_TOO_LARGE";
+        return {
+            ...common,
+            bodyBytes: new Uint8Array(),
+            decompressedBytes: limit ? outputLimit + 1 : 0,
+            truncated: limit,
+            ...(limit ? { limitExceeded: success } : { protocolError: true }),
+        };
+    }
+}
+function snapshotHeaders(raw) {
+    const headers = {};
+    let fields = 0;
+    let bytes = 0;
+    let protocolInvalid = raw.length % 2 !== 0;
+    let limitExceeded = false;
+    for (let index = 0; index + 1 < raw.length; index += 2) {
+        const name = Buffer.from(raw[index]).toString("latin1").toLowerCase();
+        const value = Buffer.from(raw[index + 1]).toString("latin1");
+        if (framingHeaders.has(name))
+            continue;
+        fields += 1;
+        const nameBytes = encoder.encode(name).length;
+        const valueBytes = encoder.encode(value).length;
+        bytes = saturatingAdd(bytes, nameBytes + 2 + valueBytes + 2);
+        if (fields > HEADER_FIELD_LIMIT || bytes > HEADER_BYTES_LIMIT || nameBytes > HEADER_NAME_LIMIT || valueBytes > HEADER_VALUE_LIMIT)
+            limitExceeded = true;
+        if (nameBytes < 1
+            || !/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u.test(name)
+            || /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/u.test(value)
+            || (asciiOnlyHeaders.has(name) && /[^\u0000-\u007f]/u.test(value)))
+            protocolInvalid = true;
+        if (protocolInvalid || limitExceeded)
+            continue;
+        (headers[name] ?? (headers[name] = [])).push(value);
+    }
+    return { headers, fields, bytes, protocolInvalid, limitExceeded };
+}
+function contentEncoding(headers) {
+    const values = headers["content-encoding"] ?? [];
+    if (values.length === 0)
+        return "identity";
+    if (values.length !== 1)
+        return null;
+    const value = values[0]?.trim().toLowerCase();
+    return value === "identity" || value === "gzip" ? value : null;
+}
+function singleHeader(headers, name) {
+    const values = headers[name] ?? [];
+    return values.length === 1 ? values[0] ?? null : null;
+}
+function concatenate(chunks, limit) {
+    const length = Math.min(limit + 1, chunks.reduce((total, chunk) => saturatingAdd(total, chunk.length), 0));
+    const bytes = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+        const part = chunk.subarray(0, length - offset);
+        bytes.set(part, offset);
+        offset += part.length;
+        if (offset === length)
+            break;
+    }
+    return bytes;
+}
+function saturatingAdd(left, right) {
+    return left > Number.MAX_SAFE_INTEGER - right ? Number.MAX_SAFE_INTEGER : left + right;
+}
+function errorCode(error) {
+    return error && typeof error === "object" && typeof error.code === "string"
+        ? error.code
+        : "";
+}
+
+const HEADER_LIMIT = 65536;
+async function connectThroughProxy(proxy, target, tls, allowH2, timeoutMs) {
+    const authority = `${target.hostname}:${target.port}`;
+    let authorization;
+    if (proxy.credentialsProvider) {
+        let credentials;
+        try {
+            credentials = await proxy.credentialsProvider();
+        }
+        catch (cause) {
+            throw proxyError("REPOST_PROXY_CREDENTIAL_PROVIDER", cause);
+        }
+        authorization = `Basic ${Buffer.from(`${credentials.username}:${credentials.password}`, "utf8").toString("base64")}`;
+    }
+    const tunnel = await connectTunnel(proxy.url, authority, authorization, timeoutMs);
+    if (tunnel.status === 407) {
+        tunnel.socket.destroy();
+        throw proxyError("REPOST_PROXY_AUTH_REQUIRED");
+    }
+    if (tunnel.status !== 200) {
+        tunnel.socket.destroy();
+        throw proxyError("REPOST_PROXY_CONNECT_FAILED");
+    }
+    if (target.protocol !== "https:")
+        return tunnel.socket;
+    return secureTunnel(tunnel.socket, target, tls, allowH2, timeoutMs);
+}
+async function connectTunnel(proxyValue, authority, authorization, timeoutMs) {
+    const proxy = new URL(proxyValue);
+    if (proxy.protocol !== "http:" || proxy.username || proxy.password || proxy.pathname !== "/") {
+        throw proxyError("REPOST_PROXY_CONNECT_FAILED");
+    }
+    const socket = connect({ host: proxy.hostname, port: Number(proxy.port || 80) });
+    await socketReady(socket, timeoutMs);
+    socket.write(`CONNECT ${authority} HTTP/1.1\r\n`
+        + `host: ${authority}\r\n`
+        + (authorization ? `proxy-authorization: ${authorization}\r\n` : "")
+        + "\r\n", "latin1");
+    let response = Buffer.alloc(0);
+    while (response.indexOf("\r\n\r\n") < 0) {
+        const chunk = await nextChunk(socket, timeoutMs);
+        response = Buffer.concat([response, chunk], Math.min(HEADER_LIMIT + 1, response.length + chunk.length));
+        if (response.length > HEADER_LIMIT)
+            throw proxyError("REPOST_PROXY_CONNECT_FAILED");
+    }
+    const boundary = response.indexOf("\r\n\r\n");
+    const status = Number(/^HTTP\/1\.1 ([0-9]{3})/u.exec(response.subarray(0, boundary).toString("latin1"))?.[1]);
+    if (!Number.isInteger(status))
+        throw proxyError("REPOST_PROXY_CONNECT_FAILED");
+    const remainder = response.subarray(boundary + 4);
+    if (remainder.length > 0)
+        socket.unshift(remainder);
+    return { socket, status };
+}
+function secureTunnel(socket, target, tls, allowH2, timeoutMs) {
+    const options = {
+        socket,
+        servername: target.servername ?? target.hostname,
+        ALPNProtocols: allowH2 ? ["h2", "http/1.1"] : ["http/1.1"],
+        ca: tls?.caCertificates ? [...tls.caCertificates] : undefined,
+        minVersion: tls?.minVersion ?? "TLSv1.2",
+        maxVersion: tls?.maxVersion,
+        ciphers: tls?.ciphers?.join(":"),
+        cert: tls?.clientCertificate?.certificate,
+        key: tls?.clientCertificate?.key,
+        passphrase: tls?.clientCertificate?.passphrase,
+    };
+    const secure = connect$1(options);
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => secure.destroy(proxyError("UND_ERR_CONNECT_TIMEOUT")), timeoutMs);
+        secure.once("secureConnect", () => { clearTimeout(timer); resolve(secure); });
+        secure.once("error", (error) => { clearTimeout(timer); reject(error); });
+    });
+}
+function socketReady(socket, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => socket.destroy(proxyError("UND_ERR_CONNECT_TIMEOUT")), timeoutMs);
+        socket.once("connect", () => { clearTimeout(timer); resolve(); });
+        socket.once("error", (error) => { clearTimeout(timer); reject(error); });
+    });
+}
+function nextChunk(socket, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const cleanup = () => { clearTimeout(timer); socket.off("error", onError); socket.off("data", onData); socket.off("end", onEnd); };
+        const timer = setTimeout(() => {
+            cleanup();
+            socket.destroy();
+            reject(proxyError("UND_ERR_CONNECT_TIMEOUT"));
+        }, timeoutMs);
+        const onData = (chunk) => { cleanup(); socket.pause(); resolve(chunk); };
+        const onError = (error) => { cleanup(); reject(error); };
+        const onEnd = () => { cleanup(); reject(proxyError("REPOST_PROXY_CONNECT_FAILED")); };
+        socket.once("data", onData);
+        socket.once("error", onError);
+        socket.once("end", onEnd);
+        socket.resume();
+    });
+}
+function proxyError(code, cause) {
+    const error = new Error("proxy connection failed");
+    error.code = code;
+    error.cause = cause;
+    return error;
+}
+
+function createH2Pool(origin, firstSocket, socketFactory) {
+    let initial = firstSocket;
+    let sessionPromise = null;
+    const session = () => {
+        if (sessionPromise)
+            return sessionPromise;
+        sessionPromise = (async () => {
+            const socket = initial ?? await socketFactory();
+            initial = null;
+            const client = connect$2(origin, { createConnection: () => socket });
+            client.once("goaway", () => { if (sessionPromise)
+                sessionPromise = null; });
+            client.once("close", () => { sessionPromise = null; });
+            await new Promise((resolve, reject) => {
+                client.once("connect", resolve);
+                client.once("error", reject);
+            });
+            return client;
+        })();
+        return sessionPromise;
+    };
+    return {
+        async dispatch(request) {
+            const client = await session();
+            return dispatchH2(client, origin, request);
+        },
+        async close() {
+            const client = sessionPromise ? await sessionPromise.catch(() => null) : null;
+            client?.close();
+        },
+    };
+}
+function dispatchH2(client, origin, request) {
+    return new Promise((resolve, reject) => {
+        const authority = headerValue(request.headers, "host");
+        const headers = {
+            ":method": "POST",
+            ":scheme": new URL(origin).protocol.slice(0, -1),
+            ":authority": authority,
+            ":path": request.path,
+        };
+        for (let index = 0; index + 1 < request.headers.length; index += 2) {
+            const name = request.headers[index] ?? "";
+            if (name !== "host")
+                headers[name] = request.headers[index + 1] ?? "";
+        }
+        let stream;
+        try {
+            stream = client.request(headers, { endStream: false });
+        }
+        catch (error) {
+            reject(error);
+            return;
+        }
+        let status = 0;
+        let rawHeaders = [];
+        const chunks = [];
+        let compressedBytes = 0;
+        let retainedBytes = 0;
+        let truncated = false;
+        let settled = false;
+        const cleanup = () => {
+            request.signal.removeEventListener("abort", abort);
+            client.removeListener("goaway", refusedByGoaway);
+        };
+        const finish = (response) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            resolve(response);
+        };
+        const fail = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(normalizeH2Error(error));
+        };
+        const abort = () => stream.close(constants.NGHTTP2_CANCEL);
+        const refusedByGoaway = (_errorCode, lastStreamId) => {
+            if (typeof stream.id === "number" && stream.id > lastStreamId) {
+                fail(Object.assign(new Error("HTTP/2 stream refused by GOAWAY"), { code: "REPOST_H2_REFUSED" }));
+            }
+        };
+        request.signal.addEventListener("abort", abort, { once: true });
+        client.on("goaway", refusedByGoaway);
+        stream.once("response", (responseHeaders) => {
+            status = Number(responseHeaders[":status"] ?? 0);
+            rawHeaders = h2Headers(responseHeaders);
+            const declared = rawHeaderValue$1(rawHeaders, "content-length");
+            if (declared !== null && /^(?:0|[1-9][0-9]*)$/u.test(declared) && Number(declared) > request.maxResponseBytes) {
+                truncated = true;
+                stream.close(constants.NGHTTP2_CANCEL);
+                finish({ status, rawHeaders, chunks, compressedBytes, truncated });
+            }
+        });
+        stream.on("data", (chunk) => {
+            compressedBytes += chunk.length;
+            const room = request.maxResponseBytes - retainedBytes;
+            if (room > 0) {
+                const retained = new Uint8Array(chunk.subarray(0, room));
+                chunks.push(retained);
+                retainedBytes += retained.length;
+            }
+            if (compressedBytes > request.maxResponseBytes) {
+                truncated = true;
+                stream.close(constants.NGHTTP2_CANCEL);
+                finish({ status, rawHeaders, chunks, compressedBytes, truncated });
+            }
+        });
+        stream.once("end", () => {
+            if (status === 0)
+                fail(Object.assign(new Error("HTTP/2 stream ended before response"), { code: "ECONNRESET" }));
+            else
+                finish({ status, rawHeaders, chunks, compressedBytes, truncated });
+        });
+        stream.once("error", fail);
+        stream.once("aborted", () => fail(Object.assign(new Error("HTTP/2 stream reset"), { code: "ECONNRESET" })));
+        if (request.signal.aborted) {
+            abort();
+            return;
+        }
+        stream.end(request.body, () => {
+            if (stream.rstCode === 0)
+                request.onBodySent();
+        });
+    });
+}
+function h2Headers(headers) {
+    return Object.entries(headers).flatMap(([name, values]) => {
+        if (name.startsWith(":") || values === undefined)
+            return [];
+        return (Array.isArray(values) ? values : [String(values)]).flatMap((value) => [Buffer.from(name, "ascii"), Buffer.from(value, "utf8")]);
+    });
+}
+function headerValue(headers, name) {
+    for (let index = 0; index + 1 < headers.length; index += 2)
+        if (headers[index] === name)
+            return headers[index + 1] ?? "";
+    return "";
+}
+function rawHeaderValue$1(raw, name) {
+    for (let index = 0; index + 1 < raw.length; index += 2) {
+        if (Buffer.from(raw[index]).toString("ascii").toLowerCase() === name)
+            return Buffer.from(raw[index + 1]).toString("utf8");
+    }
+    return null;
+}
+function normalizeH2Error(error) {
+    if (error && typeof error === "object" && error.code === "ERR_HTTP2_STREAM_ERROR") {
+        error.code = "ECONNRESET";
+    }
+    return error;
+}
+
+async function openOriginSocket(origin, options) {
+    const url = new URL(origin);
+    const hostname = url.hostname.replace(/^\[|\]$/gu, "");
+    const port = url.port || (url.protocol === "https:" ? "443" : "80");
+    if (options.proxy) {
+        return connectThroughProxy(options.proxy, { hostname, port, protocol: url.protocol, servername: hostname }, options.tls, options.allowH2, options.connectTimeout);
+    }
+    const resolved = options.dnsResolver ? await resolveAddress(options.dnsResolver, hostname) : null;
+    const host = resolved?.address ?? hostname;
+    if (url.protocol === "http:") {
+        return awaitConnected(connect({ host, port: Number(port), family: resolved?.family }), options.connectTimeout);
+    }
+    const tlsOptions = {
+        host,
+        port: Number(port),
+        servername: isIP(hostname) === 0 ? hostname : undefined,
+        ALPNProtocols: options.allowH2 ? ["h2", "http/1.1"] : ["http/1.1"],
+        ca: options.tls?.caCertificates ? [...options.tls.caCertificates] : undefined,
+        minVersion: options.tls?.minVersion ?? "TLSv1.2",
+        maxVersion: options.tls?.maxVersion,
+        ciphers: options.tls?.ciphers?.join(":"),
+        cert: options.tls?.clientCertificate?.certificate,
+        key: options.tls?.clientCertificate?.key,
+        passphrase: options.tls?.clientCertificate?.passphrase,
+    };
+    return awaitSecure(connect$1(tlsOptions), options.connectTimeout);
+}
+async function resolveAddress(resolver, hostname) {
+    try {
+        const addresses = await resolver(hostname);
+        const address = addresses[0];
+        if (!address || (address.family !== 4 && address.family !== 6))
+            throw new Error("empty DNS result");
+        return address;
+    }
+    catch (cause) {
+        const error = new Error("DNS resolver failed");
+        error.code = "REPOST_DNS_RESOLVER";
+        error.cause = cause;
+        throw error;
+    }
+}
+function awaitConnected(socket, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => socket.destroy(timeoutError()), timeoutMs);
+        socket.once("connect", () => { clearTimeout(timer); resolve(socket); });
+        socket.once("error", (error) => { clearTimeout(timer); reject(error); });
+    });
+}
+function awaitSecure(socket, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => socket.destroy(timeoutError()), timeoutMs);
+        socket.once("secureConnect", () => { clearTimeout(timer); resolve(socket); });
+        socket.once("error", (error) => { clearTimeout(timer); reject(error); });
+    });
+}
+function timeoutError() {
+    const error = new Error("connection timed out");
+    error.code = "UND_ERR_CONNECT_TIMEOUT";
+    return error;
+}
+
+/** The sole Undici compatibility boundary for the SDK. */
+function createUndiciPool(origin, options) {
+    if (!options.allowH2 || !origin.startsWith("https://"))
+        return createHttp1Pool(origin, options);
+    let lanePromise = null;
+    const lane = () => {
+        lanePromise ?? (lanePromise = (async () => {
+            const socket = await openOriginSocket(origin, options);
+            if ("alpnProtocol" in socket && socket.alpnProtocol === "h2") {
+                return createH2Pool(origin, socket, async () => {
+                    const next = await openOriginSocket(origin, options);
+                    if (!("alpnProtocol" in next) || next.alpnProtocol !== "h2") {
+                        next.destroy();
+                        throw Object.assign(new Error("HTTP/2 negotiation failed"), { code: "ERR_TLS_ALPN_NEGOTIATION" });
+                    }
+                    return next;
+                });
+            }
+            return createHttp1Pool(origin, { ...options, allowH2: false }, socket);
+        })());
+        return lanePromise;
+    };
+    return {
+        async dispatch(request) { return (await lane()).dispatch(request); },
+        async close() { if (lanePromise)
+            await (await lanePromise).close(); },
+    };
+}
+function createHttp1Pool(origin, options, initialSocket) {
+    const bodyCommits = new WeakMap();
+    const lookup = options.dnsResolver
+        ? (hostname, lookupOptions, callback) => {
+            options.dnsResolver?.(hostname).then((addresses) => callback(null, lookupOptions.all ? addresses : addresses[0]?.address ?? "", addresses[0]?.family), (error) => callback(dnsResolverError(error), "", 0));
+        }
+        : undefined;
+    const connector = buildConnector({
+        allowH2: options.allowH2,
+        timeout: options.connectTimeout,
+        lookup,
+        ca: options.tls?.caCertificates ? [...options.tls.caCertificates] : undefined,
+        minVersion: options.tls?.minVersion ?? "TLSv1.2",
+        maxVersion: options.tls?.maxVersion,
+        ciphers: options.tls?.ciphers?.join(":"),
+        cert: options.tls?.clientCertificate?.certificate,
+        key: options.tls?.clientCertificate?.key,
+        passphrase: options.tls?.clientCertificate?.passphrase,
+    });
+    const connect = (connectOptions, callback) => {
+        if (initialSocket) {
+            const socket = initialSocket;
+            initialSocket = undefined;
+            if (!("alpnProtocol" in socket) || socket.alpnProtocol !== "h2")
+                installExactH1Framing(socket, bodyCommits);
+            queueMicrotask(() => callback(null, socket));
+            return;
+        }
+        if (options.proxy) {
+            connectThroughProxy(options.proxy, connectOptions, options.tls, options.allowH2, options.connectTimeout).then((socket) => {
+                if (!("alpnProtocol" in socket) || socket.alpnProtocol !== "h2")
+                    installExactH1Framing(socket, bodyCommits);
+                callback(null, socket);
+            }, (error) => callback(error, null));
+            return;
+        }
+        connector(connectOptions, (error, socket) => {
+            if (error) {
+                callback(error, null);
+                return;
+            }
+            if (!("alpnProtocol" in socket) || socket.alpnProtocol !== "h2")
+                installExactH1Framing(socket, bodyCommits);
+            callback(null, socket);
+        });
+    };
+    const pool = new Pool(origin, {
+        connections: options.connections,
+        clientTtl: options.clientTtl,
+        keepAliveTimeout: options.keepAliveTimeout,
+        keepAliveMaxTimeout: options.keepAliveTimeout,
+        allowH2: options.allowH2,
+        pipelining: 1,
+        strictContentLength: true,
+        maxHeaderSize: 131072,
+        connect,
+    });
+    return {
+        dispatch(request) {
+            return new Promise((resolve, reject) => {
+                let bodySent = false;
+                const bodyKey = request.body.buffer;
+                const bodyCommit = { deferred: false, commit: request.onBodySent };
+                bodyCommits.set(bodyKey, bodyCommit);
+                let status = 0;
+                let rawHeaders = [];
+                const chunks = [];
+                let compressedBytes = 0;
+                let retainedBytes = 0;
+                let truncated = false;
+                let abortDispatch;
+                const limitError = new Error("response body limit exceeded");
+                const abortRequest = () => abortDispatch?.(request.signal.reason instanceof Error ? request.signal.reason : new Error("request aborted"));
+                request.signal.addEventListener("abort", abortRequest, { once: true });
+                pool.dispatch({
+                    path: request.path,
+                    method: "POST",
+                    headers: request.headers,
+                    body: request.body,
+                    idempotent: true,
+                    blocking: false,
+                    headersTimeout: request.headersTimeout,
+                    bodyTimeout: request.bodyTimeout,
+                }, {
+                    onConnect(abort) {
+                        abortDispatch = abort;
+                        if (request.signal.aborted)
+                            abortRequest();
+                    },
+                    onBodySent() {
+                        if (bodySent)
+                            return;
+                        bodySent = true;
+                        if (!bodyCommit.deferred) {
+                            bodyCommits.delete(bodyKey);
+                            request.onBodySent();
+                        }
+                    },
+                    onHeaders(statusCode, headers) {
+                        status = statusCode;
+                        rawHeaders = headers.map((value) => new Uint8Array(value));
+                        const declared = rawHeaderValue(rawHeaders, "content-length");
+                        if (declared !== null && /^(?:0|[1-9][0-9]*)$/u.test(declared) && Number(declared) > request.maxResponseBytes) {
+                            truncated = true;
+                            abortDispatch?.(limitError);
+                        }
+                        return true;
+                    },
+                    onData(chunk) {
+                        compressedBytes += chunk.length;
+                        const room = request.maxResponseBytes - retainedBytes;
+                        if (room > 0) {
+                            const retained = new Uint8Array(chunk.subarray(0, room));
+                            chunks.push(retained);
+                            retainedBytes += retained.length;
+                        }
+                        if (compressedBytes > request.maxResponseBytes) {
+                            truncated = true;
+                            abortDispatch?.(limitError);
+                        }
+                        return true;
+                    },
+                    onComplete() {
+                        request.signal.removeEventListener("abort", abortRequest);
+                        bodyCommits.delete(bodyKey);
+                        resolve({ status, rawHeaders, chunks, compressedBytes, truncated });
+                    },
+                    onError(error) {
+                        request.signal.removeEventListener("abort", abortRequest);
+                        bodyCommits.delete(bodyKey);
+                        if (error === limitError)
+                            resolve({ status, rawHeaders, chunks, compressedBytes, truncated: true });
+                        else if (status !== 0)
+                            resolve({
+                                status,
+                                rawHeaders,
+                                chunks,
+                                compressedBytes,
+                                truncated: status < 200 || status >= 300,
+                            });
+                        else
+                            reject(error);
+                    },
+                });
+            });
+        },
+        close: () => pool.close(),
+    };
+}
+function dnsResolverError(cause) {
+    const error = new Error("DNS resolver failed");
+    error.code = "REPOST_DNS_RESOLVER";
+    error.cause = cause;
+    return error;
+}
+function rawHeaderValue(raw, target) {
+    let value = null;
+    for (let index = 0; index + 1 < raw.length; index += 2) {
+        if (Buffer.from(raw[index]).toString("latin1").toLowerCase() !== target)
+            continue;
+        if (value !== null)
+            return null;
+        value = Buffer.from(raw[index + 1]).toString("latin1");
+    }
+    return value;
+}
+function installExactH1Framing(socket, bodyCommits) {
+    const write = socket.write.bind(socket);
+    let writeChain = Promise.resolve();
+    socket.write = ((chunk, encoding, callback) => {
+        if (typeof chunk === "string" && chunk.startsWith("POST ") && chunk.includes(" HTTP/1.1\r\n")) {
+            chunk = normalizeH1Header(chunk);
+            writeChain = writeChain.then(() => new Promise((resolve) => {
+                if (socket.destroyed)
+                    return resolve();
+                write(chunk, encoding, (error) => { callback?.(error); resolve(); });
+            }));
+            return true;
+        }
+        if (chunk instanceof Uint8Array && chunk.byteLength > 0) {
+            const bodyCommit = bodyCommits.get(chunk.buffer);
+            if (bodyCommit) {
+                bodyCommit.deferred = true;
+                writeChain = writeChain
+                    .then(() => peerResetOpportunity())
+                    .then(() => new Promise((resolve) => {
+                    if (socket.destroyed)
+                        return resolve();
+                    write(chunk, encoding, (error) => {
+                        bodyCommits.delete(chunk.buffer);
+                        if (!error)
+                            bodyCommit.commit();
+                        callback?.(error);
+                        resolve();
+                    });
+                }));
+                return true;
+            }
+        }
+        return write(chunk, encoding, callback);
+    });
+}
+function peerResetOpportunity() {
+    // Let a peer that rejected the headers close before any body byte is queued.
+    // This keeps a header-only reset classified as uncommitted.
+    return new Promise((resolve) => setTimeout(resolve, 5));
+}
+function normalizeH1Header(header) {
+    const withoutConnection = header.replace(/^connection: (?:keep-alive|close)\r\n/mu, "");
+    const contentLength = /^content-length: [0-9]+\r\n/mu.exec(withoutConnection)?.[0];
+    if (!contentLength)
+        return withoutConnection;
+    const withoutLength = withoutConnection.replace(contentLength, "");
+    return withoutLength.replace(/^(host: [^\r\n]+\r\n)/mu, `$1${contentLength}`);
+}
+
+const RESPONSE_LIMIT_BYTES = 1048576;
+function createNodeTransport(options = {}) {
+    const compressedLimit = options.responseCompressedLimitBytes ?? RESPONSE_LIMIT_BYTES;
+    const pools = new Map();
+    const poolFor = (origin, request) => {
+        let pool = pools.get(origin);
+        if (!pool) {
+            pool = createUndiciPool(origin, {
+                connections: options.maxConnectionsPerOrigin ?? 32,
+                clientTtl: options.connectionLifetimeMs ?? 300000,
+                keepAliveTimeout: options.connectionIdleTimeoutMs ?? 120000,
+                allowH2: options.http2 ?? true,
+                connectTimeout: request.connectTimeoutMs,
+                tls: options.tls,
+                dnsResolver: options.dnsResolver,
+                proxy: options.proxy,
+            });
+            pools.set(origin, pool);
+        }
+        return pool;
+    };
+    return {
+        async send(request) {
+            const framed = frameRequest(request);
+            const pool = poolFor(framed.origin, request);
+            try {
+                const response = await dispatch(pool, framed.path, framed.headers, request, compressedLimit);
+                return await readResponse(response.status, response.rawHeaders, response.chunks, response.compressedBytes, response.truncated, compressedLimit);
+            }
+            catch (error) {
+                return classifyFailure(error, request.commitTracker.committed);
+            }
+        },
+        async close() {
+            await Promise.all([...pools.values()].map((pool) => pool.close()));
+            pools.clear();
+        },
+    };
+}
+function dispatch(pool, path, headers, request, compressedLimit) {
+    return pool.dispatch({
+        path,
+        headers,
+        body: request.bodyBytes,
+        headersTimeout: request.attemptTimeoutMs,
+        bodyTimeout: request.attemptTimeoutMs,
+        signal: request.signal,
+        onBodySent: () => request.commitTracker.markCommitted(),
+        maxResponseBytes: compressedLimit + 1,
+    });
+}
+function classifyFailure(error, committed) {
+    if (errorCode$1(error) === "REPOST_H2_REFUSED") {
+        return { kind: "failure", code: "IO", reason: "CONNECTION_RESET", committed: false };
+    }
+    const classified = classifyNetworkFailure(error, committed);
+    if (classified)
+        return classified;
+    if (errorCode$1(error) === "ECONNRESET" || errorCode$1(error) === "ERR_HTTP2_STREAM_ERROR") {
+        return { kind: "failure", code: "IO", reason: "CONNECTION_RESET", committed };
+    }
+    if (errorCode$1(error) === "UND_ERR_INFO" && error instanceof Error && error.message.startsWith("HTTP/2:")) {
+        return { kind: "failure", code: "IO", reason: "CONNECTION_RESET", committed };
+    }
+    return {
+        kind: "failure",
+        code: "IO",
+        reason: "UNKNOWN",
+        committed,
+        causeCategory: "HTTP_RUNTIME",
+    };
+}
+
+export { createNodeTransport };
+//# sourceMappingURL=node-BAJt_qhB.mjs.map