@npy/fetch 0.1.3 → 0.1.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 matheus fernandes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/_internal/consts.cjs

@@ -0,0 +1,4 @@
+//#region src/_internal/consts.ts
+var CRLF_BYTES = new Uint8Array([13, 10]);
+//#endregion
+exports.CRLF_BYTES = CRLF_BYTES;

package/_internal/consts.d.cts

@@ -0,0 +1,3 @@
+export declare const CRLF_BYTES: Uint8Array<ArrayBuffer>;
+export declare const CRLF_STR = "\r\n";
+export declare const CRLF_LENGTH = 2;

package/_internal/consts.d.ts

@@ -0,0 +1,3 @@
+export declare const CRLF_BYTES: Uint8Array<ArrayBuffer>;
+export declare const CRLF_STR = "\r\n";
+export declare const CRLF_LENGTH = 2;

package/_internal/consts.js

@@ -0,0 +1,4 @@
+//#region src/_internal/consts.ts
+var CRLF_BYTES = new Uint8Array([13, 10]);
+//#endregion
+export { CRLF_BYTES };

package/_internal/decode-stream-error.cjs

@@ -0,0 +1,18 @@
+//#region src/_internal/decode-stream-error.ts
+/**
+* Internal sentinel thrown when a decompression stream fails.
+*
+* Tagged at the source (inside createDecoder) so that error classifiers
+* can use `instanceof` instead of heuristics on error messages or codes.
+* Never exposed in the public API — callers receive ResponseDecodeError.
+*/
+var DecodeStreamError = class extends Error {
+	cause;
+	constructor(cause) {
+		super("Response decode failed", { cause });
+		this.name = "DecodeStreamError";
+		this.cause = cause;
+	}
+};
+//#endregion
+exports.DecodeStreamError = DecodeStreamError;

package/{src/_internal/decode-stream-error.ts → _internal/decode-stream-error.d.cts}

@@ -5,12 +5,7 @@
  * can use `instanceof` instead of heuristics on error messages or codes.
  * Never exposed in the public API — callers receive ResponseDecodeError.
  */
-export class DecodeStreamError extends Error {
+export declare class DecodeStreamError extends Error {
     readonly cause: unknown;
-
-    constructor(cause: unknown) {
-        super("Response decode failed", { cause });
-        this.name = "DecodeStreamError";
-        this.cause = cause;
-    }
+    constructor(cause: unknown);
 }

package/_internal/decode-stream-error.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Internal sentinel thrown when a decompression stream fails.
+ *
+ * Tagged at the source (inside createDecoder) so that error classifiers
+ * can use `instanceof` instead of heuristics on error messages or codes.
+ * Never exposed in the public API — callers receive ResponseDecodeError.
+ */
+export declare class DecodeStreamError extends Error {
+    readonly cause: unknown;
+    constructor(cause: unknown);
+}

package/_internal/decode-stream-error.js

@@ -0,0 +1,18 @@
+//#region src/_internal/decode-stream-error.ts
+/**
+* Internal sentinel thrown when a decompression stream fails.
+*
+* Tagged at the source (inside createDecoder) so that error classifiers
+* can use `instanceof` instead of heuristics on error messages or codes.
+* Never exposed in the public API — callers receive ResponseDecodeError.
+*/
+var DecodeStreamError = class extends Error {
+	cause;
+	constructor(cause) {
+		super("Response decode failed", { cause });
+		this.name = "DecodeStreamError";
+		this.cause = cause;
+	}
+};
+//#endregion
+export { DecodeStreamError };

package/_internal/error-mapping.cjs

@@ -0,0 +1,44 @@
+const require_decode_stream_error = require("./decode-stream-error.cjs");
+const require_errors = require("../errors.cjs");
+//#region src/_internal/error-mapping.ts
+/** Casts or converts the unknown into an Error */
+function unknownToError(err) {
+	if (err instanceof Error) return err;
+	if (typeof err === "string") return new Error(err);
+	return new Error("unknown error", { cause: err });
+}
+function isAbortOrTimeoutError(error) {
+	if (!error || typeof error !== "object") return false;
+	const name = String(error.name ?? "");
+	return name === "AbortError" || name === "TimeoutError";
+}
+function toConnectError(error, { signal, context, timedOut }) {
+	if (error instanceof require_errors.FetchError) return error;
+	if (timedOut || signal?.reason?.name === "TimeoutError") return new require_errors.ConnectTimeoutError(unknownToError(error), context, "Connection timeout");
+	if (signal?.aborted || isAbortOrTimeoutError(error)) return new require_errors.RequestAbortedError(unknownToError(signal?.reason ?? error ?? new DOMException("This operation was aborted", "AbortError")), context, "The request was aborted while connecting");
+	return new require_errors.ConnectionError(unknownToError(error), context, "Connection failed");
+}
+function toSendError(error, { signal, context, phase }) {
+	if (error instanceof require_errors.FetchError) return error;
+	if (signal?.aborted || isAbortOrTimeoutError(error)) return new require_errors.RequestAbortedError(unknownToError(signal?.reason ?? error ?? new DOMException("This operation was aborted", "AbortError")), context, phase === "body" ? "The request was aborted while reading the response body" : "The request was aborted");
+	const cause = unknownToError(error);
+	if (phase === "request") return new require_errors.RequestWriteError(cause, context);
+	if (phase === "response") return new require_errors.ResponseHeaderError(cause, context);
+	if (error instanceof require_decode_stream_error.DecodeStreamError) return new require_errors.ResponseDecodeError(unknownToError(error.cause), context);
+	return new require_errors.ResponseBodyError(cause, context);
+}
+function toWebFetchError(error, signal) {
+	if (signal?.aborted) return signal.reason ?? new DOMException("This operation was aborted", "AbortError");
+	if (error instanceof DOMException || error instanceof TypeError) return error;
+	return new TypeError("fetch failed", { cause: unknownToError(error) });
+}
+function toWebBodyReadError(error, signal) {
+	if (signal?.aborted) return signal.reason ?? new DOMException("This operation was aborted", "AbortError");
+	if (error instanceof DOMException || error instanceof TypeError || error instanceof RangeError) return error;
+	return new TypeError("Failed to read response body", { cause: unknownToError(error) });
+}
+//#endregion
+exports.toConnectError = toConnectError;
+exports.toSendError = toSendError;
+exports.toWebBodyReadError = toWebBodyReadError;
+exports.toWebFetchError = toWebFetchError;

package/_internal/error-mapping.d.cts

@@ -0,0 +1,15 @@
+import { FetchError, FetchErrorContext } from '../errors';
+/** Casts or converts the unknown into an Error */
+export declare function unknownToError(err: unknown): Error;
+export declare function toConnectError(error: unknown, { signal, context, timedOut, }: {
+    signal?: AbortSignal;
+    context?: FetchErrorContext;
+    timedOut?: boolean;
+}): FetchError;
+export declare function toSendError(error: unknown, { signal, context, phase, }: {
+    signal?: AbortSignal;
+    context?: FetchErrorContext;
+    phase: "request" | "response" | "body";
+}): FetchError;
+export declare function toWebFetchError(error: unknown, signal?: AbortSignal): unknown;
+export declare function toWebBodyReadError(error: unknown, signal?: AbortSignal): unknown;

package/_internal/error-mapping.d.ts

@@ -0,0 +1,15 @@
+import { FetchError, FetchErrorContext } from '../errors';
+/** Casts or converts the unknown into an Error */
+export declare function unknownToError(err: unknown): Error;
+export declare function toConnectError(error: unknown, { signal, context, timedOut, }: {
+    signal?: AbortSignal;
+    context?: FetchErrorContext;
+    timedOut?: boolean;
+}): FetchError;
+export declare function toSendError(error: unknown, { signal, context, phase, }: {
+    signal?: AbortSignal;
+    context?: FetchErrorContext;
+    phase: "request" | "response" | "body";
+}): FetchError;
+export declare function toWebFetchError(error: unknown, signal?: AbortSignal): unknown;
+export declare function toWebBodyReadError(error: unknown, signal?: AbortSignal): unknown;

package/_internal/error-mapping.js

@@ -0,0 +1,41 @@
+import { DecodeStreamError } from "./decode-stream-error.js";
+import { ConnectTimeoutError, ConnectionError, FetchError, RequestAbortedError, RequestWriteError, ResponseBodyError, ResponseDecodeError, ResponseHeaderError } from "../errors.js";
+//#region src/_internal/error-mapping.ts
+/** Casts or converts the unknown into an Error */
+function unknownToError(err) {
+	if (err instanceof Error) return err;
+	if (typeof err === "string") return new Error(err);
+	return new Error("unknown error", { cause: err });
+}
+function isAbortOrTimeoutError(error) {
+	if (!error || typeof error !== "object") return false;
+	const name = String(error.name ?? "");
+	return name === "AbortError" || name === "TimeoutError";
+}
+function toConnectError(error, { signal, context, timedOut }) {
+	if (error instanceof FetchError) return error;
+	if (timedOut || signal?.reason?.name === "TimeoutError") return new ConnectTimeoutError(unknownToError(error), context, "Connection timeout");
+	if (signal?.aborted || isAbortOrTimeoutError(error)) return new RequestAbortedError(unknownToError(signal?.reason ?? error ?? new DOMException("This operation was aborted", "AbortError")), context, "The request was aborted while connecting");
+	return new ConnectionError(unknownToError(error), context, "Connection failed");
+}
+function toSendError(error, { signal, context, phase }) {
+	if (error instanceof FetchError) return error;
+	if (signal?.aborted || isAbortOrTimeoutError(error)) return new RequestAbortedError(unknownToError(signal?.reason ?? error ?? new DOMException("This operation was aborted", "AbortError")), context, phase === "body" ? "The request was aborted while reading the response body" : "The request was aborted");
+	const cause = unknownToError(error);
+	if (phase === "request") return new RequestWriteError(cause, context);
+	if (phase === "response") return new ResponseHeaderError(cause, context);
+	if (error instanceof DecodeStreamError) return new ResponseDecodeError(unknownToError(error.cause), context);
+	return new ResponseBodyError(cause, context);
+}
+function toWebFetchError(error, signal) {
+	if (signal?.aborted) return signal.reason ?? new DOMException("This operation was aborted", "AbortError");
+	if (error instanceof DOMException || error instanceof TypeError) return error;
+	return new TypeError("fetch failed", { cause: unknownToError(error) });
+}
+function toWebBodyReadError(error, signal) {
+	if (signal?.aborted) return signal.reason ?? new DOMException("This operation was aborted", "AbortError");
+	if (error instanceof DOMException || error instanceof TypeError || error instanceof RangeError) return error;
+	return new TypeError("Failed to read response body", { cause: unknownToError(error) });
+}
+//#endregion
+export { toConnectError, toSendError, toWebBodyReadError, toWebFetchError };

package/_internal/guards.cjs

@@ -0,0 +1,23 @@
+require("../_virtual/_rolldown/runtime.cjs");
+let node_stream = require("node:stream");
+//#region src/_internal/guards.ts
+var isReadable = (object) => Boolean(node_stream.Readable.isReadable(object));
+var isIterable = (object) => typeof object?.[Symbol.asyncIterator] === "function" || typeof object?.[Symbol.iterator] === "function";
+var isMultipartFormDataStream = (object) => typeof object?.getBoundary === "function" && typeof object?.hasKnownLength === "function" && typeof object?.getLengthSync === "function" && Boolean(node_stream.Readable.isReadable(object));
+var isFormData = (object) => typeof object === "object" && typeof object?.append === "function" && typeof object?.set === "function" && typeof object?.get === "function" && typeof object?.getAll === "function" && typeof object?.delete === "function" && typeof object?.keys === "function" && typeof object?.values === "function" && typeof object?.entries === "function" && typeof object?.constructor === "function" && object?.[Symbol.toStringTag] === "FormData";
+var isURLSearchParameters = (object) => typeof object === "object" && typeof object?.append === "function" && typeof object?.delete === "function" && typeof object?.get === "function" && typeof object?.getAll === "function" && typeof object?.has === "function" && typeof object?.set === "function" && typeof object?.sort === "function" && object?.[Symbol.toStringTag] === "URLSearchParams";
+var isReadableStream = (object) => typeof object === "object" && typeof object?.getReader === "function" && typeof object?.cancel === "function" && typeof object?.tee === "function";
+var isFumanReadable = (object) => typeof object?.read === "function" && typeof object?.close === "function" && !isReadable(object) && !isReadableStream(object);
+var isBlob = (object) => {
+	if (typeof object === "object" && object !== null && typeof object.arrayBuffer === "function" && typeof object.size === "number" && typeof object.slice === "function" && typeof object.stream === "function" && typeof object.text === "function" && typeof object.type === "string") return true;
+	return false;
+};
+//#endregion
+exports.isBlob = isBlob;
+exports.isFormData = isFormData;
+exports.isFumanReadable = isFumanReadable;
+exports.isIterable = isIterable;
+exports.isMultipartFormDataStream = isMultipartFormDataStream;
+exports.isReadable = isReadable;
+exports.isReadableStream = isReadableStream;
+exports.isURLSearchParameters = isURLSearchParameters;

package/_internal/guards.d.cts

@@ -0,0 +1,15 @@
+import { Readable } from 'node:stream';
+import { IClosable, IReadable } from '@fuman/io';
+export interface FormDataPolyfill extends Readable {
+    getBoundary(): string;
+    getLengthSync(): number;
+    hasKnownLength(): boolean;
+}
+export declare const isReadable: (object: any) => object is Readable;
+export declare const isIterable: (object: any) => object is AsyncIterable<any> | Iterable<any>;
+export declare const isMultipartFormDataStream: (object: any) => object is FormDataPolyfill;
+export declare const isFormData: (object: any) => object is FormData;
+export declare const isURLSearchParameters: (object: any) => object is URLSearchParams;
+export declare const isReadableStream: (object: any) => object is ReadableStream;
+export declare const isFumanReadable: (object: any) => object is IReadable & IClosable;
+export declare const isBlob: (object: any) => object is Blob;

package/_internal/guards.d.ts

@@ -0,0 +1,15 @@
+import { Readable } from 'node:stream';
+import { IClosable, IReadable } from '@fuman/io';
+export interface FormDataPolyfill extends Readable {
+    getBoundary(): string;
+    getLengthSync(): number;
+    hasKnownLength(): boolean;
+}
+export declare const isReadable: (object: any) => object is Readable;
+export declare const isIterable: (object: any) => object is AsyncIterable<any> | Iterable<any>;
+export declare const isMultipartFormDataStream: (object: any) => object is FormDataPolyfill;
+export declare const isFormData: (object: any) => object is FormData;
+export declare const isURLSearchParameters: (object: any) => object is URLSearchParams;
+export declare const isReadableStream: (object: any) => object is ReadableStream;
+export declare const isFumanReadable: (object: any) => object is IReadable & IClosable;
+export declare const isBlob: (object: any) => object is Blob;

package/_internal/guards.js

@@ -0,0 +1,15 @@
+import { Readable } from "node:stream";
+//#region src/_internal/guards.ts
+var isReadable = (object) => Boolean(Readable.isReadable(object));
+var isIterable = (object) => typeof object?.[Symbol.asyncIterator] === "function" || typeof object?.[Symbol.iterator] === "function";
+var isMultipartFormDataStream = (object) => typeof object?.getBoundary === "function" && typeof object?.hasKnownLength === "function" && typeof object?.getLengthSync === "function" && Boolean(Readable.isReadable(object));
+var isFormData = (object) => typeof object === "object" && typeof object?.append === "function" && typeof object?.set === "function" && typeof object?.get === "function" && typeof object?.getAll === "function" && typeof object?.delete === "function" && typeof object?.keys === "function" && typeof object?.values === "function" && typeof object?.entries === "function" && typeof object?.constructor === "function" && object?.[Symbol.toStringTag] === "FormData";
+var isURLSearchParameters = (object) => typeof object === "object" && typeof object?.append === "function" && typeof object?.delete === "function" && typeof object?.get === "function" && typeof object?.getAll === "function" && typeof object?.has === "function" && typeof object?.set === "function" && typeof object?.sort === "function" && object?.[Symbol.toStringTag] === "URLSearchParams";
+var isReadableStream = (object) => typeof object === "object" && typeof object?.getReader === "function" && typeof object?.cancel === "function" && typeof object?.tee === "function";
+var isFumanReadable = (object) => typeof object?.read === "function" && typeof object?.close === "function" && !isReadable(object) && !isReadableStream(object);
+var isBlob = (object) => {
+	if (typeof object === "object" && object !== null && typeof object.arrayBuffer === "function" && typeof object.size === "number" && typeof object.slice === "function" && typeof object.stream === "function" && typeof object.text === "function" && typeof object.type === "string") return true;
+	return false;
+};
+//#endregion
+export { isBlob, isFormData, isFumanReadable, isIterable, isMultipartFormDataStream, isReadable, isReadableStream, isURLSearchParameters };

package/_internal/net.cjs

@@ -0,0 +1,95 @@
+require("../_virtual/_rolldown/runtime.cjs");
+let node_net = require("node:net");
+let node_tls = require("node:tls");
+let _fuman_node = require("@fuman/node");
+//#region src/_internal/net.ts
+function toAbortError(reason) {
+	if (reason instanceof Error && reason.name === "AbortError") return reason;
+	const message = reason instanceof Error ? reason.message : typeof reason === "string" ? reason : "The operation was aborted";
+	if (typeof DOMException !== "undefined") return new DOMException(message, "AbortError");
+	const error = new Error(message);
+	error.name = "AbortError";
+	return error;
+}
+function throwIfAborted(signal) {
+	if (signal?.aborted) throw toAbortError(signal.reason);
+}
+async function withSocketSignal(createSocket, wrapConnection, signal, readyEvent = "connect", onFailureCleanup) {
+	return new Promise((resolve, reject) => {
+		throwIfAborted(signal);
+		const socket = createSocket();
+		let settled = false;
+		const cleanup = () => {
+			socket.removeListener("error", onError);
+			socket.removeListener("timeout", onError);
+			socket.removeListener(readyEvent, onReady);
+			signal?.removeEventListener("abort", onAbort);
+		};
+		const safeCleanup = () => {
+			try {
+				onFailureCleanup?.();
+			} catch {}
+		};
+		const resolveOnce = (value) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			resolve(value);
+		};
+		const rejectOnce = (error) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			reject(error);
+		};
+		const onError = (error) => {
+			safeCleanup();
+			rejectOnce(error);
+		};
+		const onAbort = () => {
+			const error = toAbortError(signal?.reason);
+			safeCleanup();
+			rejectOnce(error);
+			try {
+				socket.destroy(error);
+			} catch {}
+		};
+		const onReady = () => {
+			resolveOnce(wrapConnection(socket));
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+		socket.on("error", onError);
+		socket.on("timeout", onError);
+		socket.on(readyEvent, onReady);
+	});
+}
+var connectTcp = async ({ address, port, signal }) => {
+	return withSocketSignal(() => (0, node_net.createConnection)({
+		host: address,
+		port
+	}), (socket) => new _fuman_node.TcpConnection(socket), signal);
+};
+var connectTls = async (options) => {
+	const { address, port, signal, sni, caCerts, alpnProtocols, extraOptions } = options;
+	return withSocketSignal(() => (0, node_tls.connect)({
+		host: address,
+		port,
+		ca: caCerts,
+		ALPNProtocols: alpnProtocols,
+		servername: sni,
+		...extraOptions
+	}), (socket) => new _fuman_node.TlsConnection(socket), signal, "secureConnect");
+};
+var upgradeTls = async (conn, options) => {
+	return withSocketSignal(() => (0, node_tls.connect)({
+		socket: conn.socket,
+		ca: options.caCerts,
+		ALPNProtocols: options.alpnProtocols,
+		servername: options.sni,
+		...options.extraOptions
+	}), (socket) => new _fuman_node.TlsConnection(socket), options.signal, "secureConnect", () => conn.close());
+};
+//#endregion
+exports.connectTcp = connectTcp;
+exports.connectTls = connectTls;
+exports.upgradeTls = upgradeTls;

package/_internal/net.d.cts

@@ -0,0 +1,11 @@
+import { ConnectFunction, TcpEndpoint, TlsUpgradeFunction } from '@fuman/net';
+import { NodeTlsConnectOptions, NodeTlsUpgradeOptions, TcpConnection, TlsConnection } from '@fuman/node';
+export type WithSignal<T = {}> = T & {
+    signal?: AbortSignal;
+};
+export interface AbortError extends Error {
+    name: "AbortError";
+}
+export declare const connectTcp: ConnectFunction<WithSignal<TcpEndpoint>, TcpConnection>;
+export declare const connectTls: ConnectFunction<WithSignal<NodeTlsConnectOptions>, TlsConnection>;
+export declare const upgradeTls: TlsUpgradeFunction<WithSignal<NodeTlsUpgradeOptions>, TcpConnection, TlsConnection>;

package/_internal/net.d.ts

@@ -0,0 +1,11 @@
+import { ConnectFunction, TcpEndpoint, TlsUpgradeFunction } from '@fuman/net';
+import { NodeTlsConnectOptions, NodeTlsUpgradeOptions, TcpConnection, TlsConnection } from '@fuman/node';
+export type WithSignal<T = {}> = T & {
+    signal?: AbortSignal;
+};
+export interface AbortError extends Error {
+    name: "AbortError";
+}
+export declare const connectTcp: ConnectFunction<WithSignal<TcpEndpoint>, TcpConnection>;
+export declare const connectTls: ConnectFunction<WithSignal<NodeTlsConnectOptions>, TlsConnection>;
+export declare const upgradeTls: TlsUpgradeFunction<WithSignal<NodeTlsUpgradeOptions>, TcpConnection, TlsConnection>;

package/_internal/net.js

@@ -0,0 +1,92 @@
+import { createConnection } from "node:net";
+import { connect } from "node:tls";
+import { TcpConnection, TlsConnection } from "@fuman/node";
+//#region src/_internal/net.ts
+function toAbortError(reason) {
+	if (reason instanceof Error && reason.name === "AbortError") return reason;
+	const message = reason instanceof Error ? reason.message : typeof reason === "string" ? reason : "The operation was aborted";
+	if (typeof DOMException !== "undefined") return new DOMException(message, "AbortError");
+	const error = new Error(message);
+	error.name = "AbortError";
+	return error;
+}
+function throwIfAborted(signal) {
+	if (signal?.aborted) throw toAbortError(signal.reason);
+}
+async function withSocketSignal(createSocket, wrapConnection, signal, readyEvent = "connect", onFailureCleanup) {
+	return new Promise((resolve, reject) => {
+		throwIfAborted(signal);
+		const socket = createSocket();
+		let settled = false;
+		const cleanup = () => {
+			socket.removeListener("error", onError);
+			socket.removeListener("timeout", onError);
+			socket.removeListener(readyEvent, onReady);
+			signal?.removeEventListener("abort", onAbort);
+		};
+		const safeCleanup = () => {
+			try {
+				onFailureCleanup?.();
+			} catch {}
+		};
+		const resolveOnce = (value) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			resolve(value);
+		};
+		const rejectOnce = (error) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			reject(error);
+		};
+		const onError = (error) => {
+			safeCleanup();
+			rejectOnce(error);
+		};
+		const onAbort = () => {
+			const error = toAbortError(signal?.reason);
+			safeCleanup();
+			rejectOnce(error);
+			try {
+				socket.destroy(error);
+			} catch {}
+		};
+		const onReady = () => {
+			resolveOnce(wrapConnection(socket));
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+		socket.on("error", onError);
+		socket.on("timeout", onError);
+		socket.on(readyEvent, onReady);
+	});
+}
+var connectTcp = async ({ address, port, signal }) => {
+	return withSocketSignal(() => createConnection({
+		host: address,
+		port
+	}), (socket) => new TcpConnection(socket), signal);
+};
+var connectTls = async (options) => {
+	const { address, port, signal, sni, caCerts, alpnProtocols, extraOptions } = options;
+	return withSocketSignal(() => connect({
+		host: address,
+		port,
+		ca: caCerts,
+		ALPNProtocols: alpnProtocols,
+		servername: sni,
+		...extraOptions
+	}), (socket) => new TlsConnection(socket), signal, "secureConnect");
+};
+var upgradeTls = async (conn, options) => {
+	return withSocketSignal(() => connect({
+		socket: conn.socket,
+		ca: options.caCerts,
+		ALPNProtocols: options.alpnProtocols,
+		servername: options.sni,
+		...options.extraOptions
+	}), (socket) => new TlsConnection(socket), options.signal, "secureConnect", () => conn.close());
+};
+//#endregion
+export { connectTcp, connectTls, upgradeTls };

package/_internal/promises.cjs

@@ -0,0 +1,18 @@
+//#region src/_internal/promises.ts
+function raceSignal(promise, signal) {
+	return Promise.race([promise, new Promise((_, reject) => {
+		function onAbort() {
+			reject(signal.reason);
+		}
+		if (signal.aborted) onAbort();
+		else {
+			signal.addEventListener("abort", onAbort, { once: true });
+			function cleanup() {
+				signal.removeEventListener("abort", onAbort);
+			}
+			promise.then(cleanup, cleanup);
+		}
+	})]);
+}
+//#endregion
+exports.raceSignal = raceSignal;

package/_internal/promises.d.cts

@@ -0,0 +1 @@
+export declare function raceSignal<T>(promise: PromiseLike<T>, signal: AbortSignal): Promise<T>;

package/_internal/promises.d.ts

@@ -0,0 +1 @@
+export declare function raceSignal<T>(promise: PromiseLike<T>, signal: AbortSignal): Promise<T>;

package/_internal/promises.js

@@ -0,0 +1,18 @@
+//#region src/_internal/promises.ts
+function raceSignal(promise, signal) {
+	return Promise.race([promise, new Promise((_, reject) => {
+		function onAbort() {
+			reject(signal.reason);
+		}
+		if (signal.aborted) onAbort();
+		else {
+			signal.addEventListener("abort", onAbort, { once: true });
+			function cleanup() {
+				signal.removeEventListener("abort", onAbort);
+			}
+			promise.then(cleanup, cleanup);
+		}
+	})]);
+}
+//#endregion
+export { raceSignal };

package/_internal/streams.cjs

@@ -0,0 +1,37 @@
+//#region src/_internal/streams.ts
+/**
+* Create a ReadableStream from a Uint8Array.
+*
+* The stream will emit the entire byte array as a single chunk,
+* then close immediately.
+*
+* @param bytes - The byte array to wrap.
+* @returns A ReadableStream that emits the bytes.
+*/
+function bytesToStream(bytes) {
+	return new ReadableStream({ start(controller) {
+		controller.enqueue(bytes);
+		controller.close();
+	} });
+}
+/**
+* A TransformStream that limits the total number of bytes passed through.
+*
+* It accumulates the byte count from incoming chunks and enqueues them
+* if the total remains within the limit; otherwise, it errors.
+*
+* @param maxBytes - The maximum allowed bytes before erroring.
+*/
+var MaxBytesTransformStream = class extends TransformStream {
+	constructor(maxBytes) {
+		if (!(maxBytes >= 0)) throw new TypeError("maxBytes must be a non-negative number");
+		let bytesRead = 0;
+		super({ transform: (chunk, ctrl) => {
+			if ((bytesRead += chunk.length) <= maxBytes) ctrl.enqueue(chunk);
+			else ctrl.error(/* @__PURE__ */ new Error("Response too large"));
+		} });
+	}
+};
+//#endregion
+exports.MaxBytesTransformStream = MaxBytesTransformStream;
+exports.bytesToStream = bytesToStream;

package/_internal/streams.d.cts

@@ -0,0 +1,21 @@
+/**
+ * Create a ReadableStream from a Uint8Array.
+ *
+ * The stream will emit the entire byte array as a single chunk,
+ * then close immediately.
+ *
+ * @param bytes - The byte array to wrap.
+ * @returns A ReadableStream that emits the bytes.
+ */
+export declare function bytesToStream(bytes: Uint8Array): ReadableStream<Uint8Array<ArrayBufferLike>>;
+/**
+ * A TransformStream that limits the total number of bytes passed through.
+ *
+ * It accumulates the byte count from incoming chunks and enqueues them
+ * if the total remains within the limit; otherwise, it errors.
+ *
+ * @param maxBytes - The maximum allowed bytes before erroring.
+ */
+export declare class MaxBytesTransformStream extends TransformStream<Uint8Array, Uint8Array> {
+    constructor(maxBytes: number);
+}

package/_internal/streams.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Create a ReadableStream from a Uint8Array.
+ *
+ * The stream will emit the entire byte array as a single chunk,
+ * then close immediately.
+ *
+ * @param bytes - The byte array to wrap.
+ * @returns A ReadableStream that emits the bytes.
+ */
+export declare function bytesToStream(bytes: Uint8Array): ReadableStream<Uint8Array<ArrayBufferLike>>;
+/**
+ * A TransformStream that limits the total number of bytes passed through.
+ *
+ * It accumulates the byte count from incoming chunks and enqueues them
+ * if the total remains within the limit; otherwise, it errors.
+ *
+ * @param maxBytes - The maximum allowed bytes before erroring.
+ */
+export declare class MaxBytesTransformStream extends TransformStream<Uint8Array, Uint8Array> {
+    constructor(maxBytes: number);
+}