@npy/fetch 0.1.1 → 0.1.2

package/io/io.cjs

@@ -1,5 +1,5 @@
-const require_encoding = require("../encoding.cjs");
 const require_streams = require("../_internal/streams.cjs");
+const require_encoding = require("../encoding.cjs");
 const require__utils = require("./_utils.cjs");
 const require_readers = require("./readers.cjs");
 const require_writers = require("./writers.cjs");
@@ -18,7 +18,70 @@ function parseStatusLine(line) {
 		statusText: m[4] ?? ""
 	};
 }
-async function readResponse(conn, options = {}, shouldIgnoreBody, onDone) {
+function toArrayBufferBytes(bytes) {
+	if (bytes.buffer instanceof ArrayBuffer) return bytes;
+	return new Uint8Array(bytes);
+}
+function wrapStreamErrors(source, mapError) {
+	const reader = source.getReader();
+	let pending = null;
+	return new ReadableStream({
+		type: "bytes",
+		async pull(controller) {
+			try {
+				const byob = controller.byobRequest;
+				if (byob?.view) {
+					const target = new Uint8Array(byob.view.buffer, byob.view.byteOffset, byob.view.byteLength);
+					if (target.byteLength === 0) {
+						byob.respond(0);
+						return;
+					}
+					let written = 0;
+					if (pending && pending.byteLength > 0) {
+						const n = Math.min(target.byteLength, pending.byteLength);
+						target.set(pending.subarray(0, n), written);
+						written += n;
+						pending = n === pending.byteLength ? null : pending.subarray(n);
+					}
+					while (written === 0) {
+						const { done, value } = await reader.read();
+						if (done) {
+							byob.respond(0);
+							controller.close();
+							return;
+						}
+						if (!value || value.byteLength === 0) continue;
+						const n = Math.min(target.byteLength - written, value.byteLength);
+						target.set(value.subarray(0, n), written);
+						written += n;
+						if (n < value.byteLength) pending = value.subarray(n);
+					}
+					byob.respond(written);
+					return;
+				}
+				if (pending && pending.byteLength > 0) {
+					const chunk = pending;
+					pending = null;
+					controller.enqueue(toArrayBufferBytes(chunk));
+					return;
+				}
+				const { done, value } = await reader.read();
+				if (done) {
+					controller.close();
+					return;
+				}
+				if (value && value.byteLength > 0) controller.enqueue(toArrayBufferBytes(value));
+			} catch (error) {
+				controller.error(mapError(error));
+			}
+		},
+		async cancel(reason) {
+			pending = null;
+			await reader.cancel(reason);
+		}
+	});
+}
+async function readResponse(conn, options = {}, shouldIgnoreBody, onDone, mapBodyError) {
 	const lr = new require_readers.LineReader(conn, options);
 	const finalize = (() => {
 		let called = false;
@@ -70,12 +133,12 @@ async function readResponse(conn, options = {}, shouldIgnoreBody, onDone) {
 		});
 	}
 	if (chunked) headers.delete("content-length");
-	const reader = chunked ? new require_readers.ChunkedBodyReader(lr, options) : new require_readers.BodyReader(lr, contentLength ?? -1, options);
+	const reader = chunked ? new require_readers.ChunkedBodyReader(lr, options) : new require_readers.BodyReader(lr, contentLength, options);
 	let body = new ReadableStream({
 		type: "bytes",
 		async pull(controller) {
 			const byob = controller.byobRequest;
-			const view = byob?.view ? new Uint8Array(byob.view.buffer, byob.view.byteOffset, byob.view.byteLength) : new Uint8Array(new ArrayBuffer(options.highWaterMark ?? 16 * 1024));
+			const view = byob?.view ? new Uint8Array(byob.view.buffer, byob.view.byteOffset, byob.view.byteLength) : new Uint8Array(new ArrayBuffer(options.readChunkSize ?? 16 * 1024));
 			try {
 				const n = await reader.read(view);
 				if (n === 0) {
@@ -117,6 +180,7 @@ async function readResponse(conn, options = {}, shouldIgnoreBody, onDone) {
 		}
 		const maxDecoded = require__utils.parseMaxBytes(options.maxDecodedBodySize);
 		if (maxDecoded != null) body = body.pipeThrough(new require_streams.MaxBytesTransformStream(maxDecoded));
+		if (mapBodyError != null) body = wrapStreamErrors(body, mapBodyError);
 	} catch (err) {
 		finalize(false);
 		throw err;

package/{src/io → io}/io.d.cts

@@ -1,5 +1,5 @@
 import { IConnection } from '@fuman/net';
 import { LineReader, Readers } from './readers';
 import { Writers } from './writers';
-export declare function readResponse(conn: IConnection<unknown>, options: (Readers.Options & LineReader.ReadHeadersOptions) | undefined, shouldIgnoreBody: (status: number) => boolean, onDone?: (reusable: boolean) => void): Promise<Response>;
+export declare function readResponse(conn: IConnection<unknown>, options: (Readers.Options & LineReader.ReadHeadersOptions) | undefined, shouldIgnoreBody: (status: number) => boolean, onDone?: (reusable: boolean) => void, mapBodyError?: (err: unknown) => unknown): Promise<Response>;
 export declare function writeRequest(conn: IConnection<unknown>, req: Writers.Request, options?: Writers.Options): Promise<void>;

package/{src/io → io}/io.d.ts

@@ -1,5 +1,5 @@
 import { IConnection } from '@fuman/net';
 import { LineReader, Readers } from './readers';
 import { Writers } from './writers';
-export declare function readResponse(conn: IConnection<unknown>, options: (Readers.Options & LineReader.ReadHeadersOptions) | undefined, shouldIgnoreBody: (status: number) => boolean, onDone?: (reusable: boolean) => void): Promise<Response>;
+export declare function readResponse(conn: IConnection<unknown>, options: (Readers.Options & LineReader.ReadHeadersOptions) | undefined, shouldIgnoreBody: (status: number) => boolean, onDone?: (reusable: boolean) => void, mapBodyError?: (err: unknown) => unknown): Promise<Response>;
 export declare function writeRequest(conn: IConnection<unknown>, req: Writers.Request, options?: Writers.Options): Promise<void>;

package/io/io.js

@@ -1,5 +1,5 @@
-import { decodeStream } from "../encoding.js";
 import { MaxBytesTransformStream } from "../_internal/streams.js";
+import { decodeStream } from "../encoding.js";
 import { parseContentLength, parseMaxBytes, parseTransferEncoding, splitTokens } from "./_utils.js";
 import { BodyReader, ChunkedBodyReader, LineReader } from "./readers.js";
 import { createRequestWriter } from "./writers.js";
@@ -18,7 +18,70 @@ function parseStatusLine(line) {
 		statusText: m[4] ?? ""
 	};
 }
-async function readResponse(conn, options = {}, shouldIgnoreBody, onDone) {
+function toArrayBufferBytes(bytes) {
+	if (bytes.buffer instanceof ArrayBuffer) return bytes;
+	return new Uint8Array(bytes);
+}
+function wrapStreamErrors(source, mapError) {
+	const reader = source.getReader();
+	let pending = null;
+	return new ReadableStream({
+		type: "bytes",
+		async pull(controller) {
+			try {
+				const byob = controller.byobRequest;
+				if (byob?.view) {
+					const target = new Uint8Array(byob.view.buffer, byob.view.byteOffset, byob.view.byteLength);
+					if (target.byteLength === 0) {
+						byob.respond(0);
+						return;
+					}
+					let written = 0;
+					if (pending && pending.byteLength > 0) {
+						const n = Math.min(target.byteLength, pending.byteLength);
+						target.set(pending.subarray(0, n), written);
+						written += n;
+						pending = n === pending.byteLength ? null : pending.subarray(n);
+					}
+					while (written === 0) {
+						const { done, value } = await reader.read();
+						if (done) {
+							byob.respond(0);
+							controller.close();
+							return;
+						}
+						if (!value || value.byteLength === 0) continue;
+						const n = Math.min(target.byteLength - written, value.byteLength);
+						target.set(value.subarray(0, n), written);
+						written += n;
+						if (n < value.byteLength) pending = value.subarray(n);
+					}
+					byob.respond(written);
+					return;
+				}
+				if (pending && pending.byteLength > 0) {
+					const chunk = pending;
+					pending = null;
+					controller.enqueue(toArrayBufferBytes(chunk));
+					return;
+				}
+				const { done, value } = await reader.read();
+				if (done) {
+					controller.close();
+					return;
+				}
+				if (value && value.byteLength > 0) controller.enqueue(toArrayBufferBytes(value));
+			} catch (error) {
+				controller.error(mapError(error));
+			}
+		},
+		async cancel(reason) {
+			pending = null;
+			await reader.cancel(reason);
+		}
+	});
+}
+async function readResponse(conn, options = {}, shouldIgnoreBody, onDone, mapBodyError) {
 	const lr = new LineReader(conn, options);
 	const finalize = (() => {
 		let called = false;
@@ -70,12 +133,12 @@ async function readResponse(conn, options = {}, shouldIgnoreBody, onDone) {
 		});
 	}
 	if (chunked) headers.delete("content-length");
-	const reader = chunked ? new ChunkedBodyReader(lr, options) : new BodyReader(lr, contentLength ?? -1, options);
+	const reader = chunked ? new ChunkedBodyReader(lr, options) : new BodyReader(lr, contentLength, options);
 	let body = new ReadableStream({
 		type: "bytes",
 		async pull(controller) {
 			const byob = controller.byobRequest;
-			const view = byob?.view ? new Uint8Array(byob.view.buffer, byob.view.byteOffset, byob.view.byteLength) : new Uint8Array(new ArrayBuffer(options.highWaterMark ?? 16 * 1024));
+			const view = byob?.view ? new Uint8Array(byob.view.buffer, byob.view.byteOffset, byob.view.byteLength) : new Uint8Array(new ArrayBuffer(options.readChunkSize ?? 16 * 1024));
 			try {
 				const n = await reader.read(view);
 				if (n === 0) {
@@ -117,6 +180,7 @@ async function readResponse(conn, options = {}, shouldIgnoreBody, onDone) {
 		}
 		const maxDecoded = parseMaxBytes(options.maxDecodedBodySize);
 		if (maxDecoded != null) body = body.pipeThrough(new MaxBytesTransformStream(maxDecoded));
+		if (mapBodyError != null) body = wrapStreamErrors(body, mapBodyError);
 	} catch (err) {
 		finalize(false);
 		throw err;

package/io/readers.cjs

@@ -1,6 +1,6 @@
 require("../_virtual/_rolldown/runtime.cjs");
-const require_consts = require("../_internal/consts.cjs");
 const require__utils = require("./_utils.cjs");
+const require_consts = require("../_internal/consts.cjs");
 let _fuman_io = require("@fuman/io");
 let _fuman_net = require("@fuman/net");
 //#region src/io/readers.ts
@@ -8,32 +8,21 @@ var invalidHeaderCharRegex = /[^\t\x20-\x7e\x80-\xff]/g;
 function sanitizeHeaderValue(v) {
 	return v.replace(invalidHeaderCharRegex, (m) => encodeURI(m));
 }
-/**
-* CRLF-delimited reader that preserves over-reads in an internal buffer.
-*
-* Key property: once you finish reading headers, any bytes already read beyond
-* the header terminator stay buffered and will be returned by read().
-*/
 var LineReader = class {
 	#src;
 	#buf;
 	#codec = new _fuman_io.DelimiterCodec(require_consts.CRLF_BYTES, { strategy: "discard" });
 	#eof = false;
-	#highWaterMark;
+	#readChunkSize;
 	#maxBufferedBytes;
 	#maxLineSize;
 	#closed = false;
 	close;
-	/**
-	* LineReader configuration.
-	*
-	* @namespace LineReader
-	*/
 	static Options;
 	constructor(src, opts = {}) {
 		this.#src = src;
 		this.#buf = _fuman_io.Bytes.alloc(opts.bufferSize);
-		this.#highWaterMark = opts.highWaterMark ?? 16 * 1024;
+		this.#readChunkSize = opts.readChunkSize ?? 16 * 1024;
 		this.#maxBufferedBytes = opts.maxBufferedBytes ?? 256 * 1024;
 		this.#maxLineSize = opts.maxLineSize ?? 64 * 1024;
 		this.close = this.#close.bind(this);
@@ -121,7 +110,7 @@ var LineReader = class {
 		return headers;
 	}
 	async #pull() {
-		const into = this.#buf.writeSync(this.#highWaterMark);
+		const into = this.#buf.writeSync(this.#readChunkSize);
 		try {
 			const n = await this.#src.read(into);
 			this.#buf.disposeWriteSync(n);
@@ -140,16 +129,9 @@ var LineReader = class {
 	async #close() {
 		if (this.#closed) return;
 		this.#closed = true;
-		try {
-			await this.#src.close();
-		} finally {
-			this.#closed = true;
-		}
+		await this.#src.close();
 	}
 };
-/**
-* Body reader that streams bytes with either a fixed Content-Length or until EOF.
-*/
 var BodyReader = class {
 	#src;
 	#remaining;
@@ -157,29 +139,23 @@ var BodyReader = class {
 	#readSoFar = 0;
 	#closed = false;
 	close;
-	/**
-	* BodyReader configuration.
-	*
-	* @namespace BodyReader
-	*/
 	static Options;
 	constructor(src, contentLength, opts = {}) {
 		this.#src = src;
-		this.#remaining = contentLength >= 0 ? contentLength : null;
+		this.#remaining = contentLength;
 		this.#maxResponseSize = require__utils.parseMaxBytes(opts.maxBodySize);
-		if (this.#maxResponseSize != null && this.#remaining != null && this.#remaining > this.#maxResponseSize) throw new Error(`body too large: content-length=${this.#remaining} > maxResponseSize=${this.#maxResponseSize}`);
 		this.close = this.#close.bind(this);
 	}
 	async read(into) {
 		if (this.#closed) return 0;
 		if (this.#remaining === 0) return 0;
-		let max = into.length;
-		if (this.#remaining != null) max = Math.min(max, this.#remaining);
 		if (this.#maxResponseSize != null) {
 			const remainingLimit = this.#maxResponseSize - this.#readSoFar;
 			if (remainingLimit <= 0) throw new Error(`body too large (> ${this.#maxResponseSize} bytes)`);
-			max = Math.min(max, remainingLimit);
+			if (into.length > remainingLimit) into = into.subarray(0, remainingLimit);
 		}
+		let max = into.length;
+		if (this.#remaining != null) max = Math.min(max, this.#remaining);
 		if (max === 0) return 0;
 		const view = max === into.length ? into : into.subarray(0, max);
 		let n = 0;
@@ -200,21 +176,14 @@ var BodyReader = class {
 	async #close() {
 		if (this.#closed) return;
 		this.#closed = true;
-		try {
-			await this.#src.close();
-		} finally {
-			this.#closed = true;
-		}
+		await this.#src.close();
 	}
 };
-/**
-* RFC 7230 chunked transfer-coding decoder.
-*/
 var ChunkedBodyReader = class {
 	#src;
 	#buf;
 	#codec = new _fuman_io.DelimiterCodec(require_consts.CRLF_BYTES, { strategy: "discard" });
-	#highWaterMark;
+	#readChunkSize;
 	#maxLineSize;
 	#maxChunkSize;
 	#maxResponseSize;
@@ -223,16 +192,11 @@ var ChunkedBodyReader = class {
 	#closed = false;
 	#state = { kind: "size" };
 	close;
-	/**
-	* ChunkedBodyReader configuration.
-	*
-	* @namespace ChunkedBodyReader
-	*/
 	static Options;
 	constructor(src, opts = {}) {
 		this.#src = src;
 		this.#buf = _fuman_io.Bytes.alloc(opts.bufferSize);
-		this.#highWaterMark = opts.highWaterMark ?? 16 * 1024;
+		this.#readChunkSize = opts.readChunkSize ?? 16 * 1024;
 		this.#maxLineSize = opts.maxLineSize ?? 64 * 1024;
 		this.#maxChunkSize = opts.maxChunkSize ?? 16 * 1024 * 1024;
 		this.#maxResponseSize = require__utils.parseMaxBytes(opts.maxBodySize);
@@ -324,7 +288,7 @@ var ChunkedBodyReader = class {
 		}
 	}
 	async #pull() {
-		const into = this.#buf.writeSync(this.#highWaterMark);
+		const into = this.#buf.writeSync(this.#readChunkSize);
 		try {
 			const n = await this.#readFromSrc(into);
 			this.#buf.disposeWriteSync(n);
@@ -363,11 +327,7 @@ var ChunkedBodyReader = class {
 	async #close() {
 		if (this.#closed) return;
 		this.#closed = true;
-		try {
-			await this.#src.close();
-		} finally {
-			this.#closed = true;
-		}
+		await this.#src.close();
 	}
 };
 //#endregion

package/io/readers.d.cts

@@ -0,0 +1,69 @@
+import { IClosable, IReadable } from '@fuman/io';
+type Source = IReadable & IClosable;
+export declare function sanitizeHeaderValue(v: string): string;
+export declare namespace Readers {
+    interface BufferingOptions {
+        bufferSize?: number;
+        readChunkSize?: number;
+    }
+    interface SizeLimitOptions {
+        maxBodySize?: number | string;
+        maxDecodedBodySize?: number | string;
+    }
+    interface DecompressionOptions {
+        decompress?: boolean;
+    }
+    interface DelimiterLimitsOptions {
+        maxLineSize?: number;
+        maxBufferedBytes?: number;
+    }
+    interface BodyOptions extends SizeLimitOptions, DecompressionOptions {
+    }
+    interface ChunkedOptions extends BufferingOptions {
+        maxLineSize?: number;
+        maxChunkSize?: number;
+    }
+    type Options = LineReader.Options & BodyOptions & ChunkedOptions;
+}
+export declare class LineReader implements IReadable, IClosable {
+    #private;
+    close: () => Promise<void> | void;
+    static Options: never;
+    constructor(src: Source, opts?: LineReader.Options);
+    read(into: Uint8Array): Promise<number>;
+    readLine(): Promise<string | null>;
+    readHeaders(opts?: LineReader.ReadHeadersOptions): Promise<Headers>;
+}
+export declare namespace LineReader {
+    interface Options extends Readers.BufferingOptions, Readers.DelimiterLimitsOptions {
+    }
+    interface ReadHeadersOptions {
+        maxHeaderSize?: number;
+    }
+}
+export declare class BodyReader implements IReadable, IClosable {
+    #private;
+    close: () => Promise<void> | void;
+    static Options: never;
+    constructor(src: Source, contentLength: number | null, opts?: BodyReader.Options);
+    read(into: Uint8Array): Promise<number>;
+}
+export declare namespace BodyReader {
+    interface Options {
+        maxBodySize?: number | string;
+    }
+}
+export declare class ChunkedBodyReader implements IReadable, IClosable {
+    #private;
+    close: () => Promise<void> | void;
+    static Options: never;
+    constructor(src: Source, opts?: ChunkedBodyReader.Options);
+    read(into: Uint8Array): Promise<number>;
+}
+export declare namespace ChunkedBodyReader {
+    interface Options extends BodyReader.Options, Readers.BufferingOptions {
+        maxLineSize?: number;
+        maxChunkSize?: number;
+    }
+}
+export {};

package/io/readers.d.ts

@@ -0,0 +1,69 @@
+import { IClosable, IReadable } from '@fuman/io';
+type Source = IReadable & IClosable;
+export declare function sanitizeHeaderValue(v: string): string;
+export declare namespace Readers {
+    interface BufferingOptions {
+        bufferSize?: number;
+        readChunkSize?: number;
+    }
+    interface SizeLimitOptions {
+        maxBodySize?: number | string;
+        maxDecodedBodySize?: number | string;
+    }
+    interface DecompressionOptions {
+        decompress?: boolean;
+    }
+    interface DelimiterLimitsOptions {
+        maxLineSize?: number;
+        maxBufferedBytes?: number;
+    }
+    interface BodyOptions extends SizeLimitOptions, DecompressionOptions {
+    }
+    interface ChunkedOptions extends BufferingOptions {
+        maxLineSize?: number;
+        maxChunkSize?: number;
+    }
+    type Options = LineReader.Options & BodyOptions & ChunkedOptions;
+}
+export declare class LineReader implements IReadable, IClosable {
+    #private;
+    close: () => Promise<void> | void;
+    static Options: never;
+    constructor(src: Source, opts?: LineReader.Options);
+    read(into: Uint8Array): Promise<number>;
+    readLine(): Promise<string | null>;
+    readHeaders(opts?: LineReader.ReadHeadersOptions): Promise<Headers>;
+}
+export declare namespace LineReader {
+    interface Options extends Readers.BufferingOptions, Readers.DelimiterLimitsOptions {
+    }
+    interface ReadHeadersOptions {
+        maxHeaderSize?: number;
+    }
+}
+export declare class BodyReader implements IReadable, IClosable {
+    #private;
+    close: () => Promise<void> | void;
+    static Options: never;
+    constructor(src: Source, contentLength: number | null, opts?: BodyReader.Options);
+    read(into: Uint8Array): Promise<number>;
+}
+export declare namespace BodyReader {
+    interface Options {
+        maxBodySize?: number | string;
+    }
+}
+export declare class ChunkedBodyReader implements IReadable, IClosable {
+    #private;
+    close: () => Promise<void> | void;
+    static Options: never;
+    constructor(src: Source, opts?: ChunkedBodyReader.Options);
+    read(into: Uint8Array): Promise<number>;
+}
+export declare namespace ChunkedBodyReader {
+    interface Options extends BodyReader.Options, Readers.BufferingOptions {
+        maxLineSize?: number;
+        maxChunkSize?: number;
+    }
+}
+export {};

package/io/readers.js

@@ -1,5 +1,5 @@
-import { CRLF_BYTES } from "../_internal/consts.js";
 import { parseMaxBytes } from "./_utils.js";
+import { CRLF_BYTES } from "../_internal/consts.js";
 import { Bytes, DelimiterCodec, read } from "@fuman/io";
 import { ConnectionClosedError } from "@fuman/net";
 //#region src/io/readers.ts
@@ -7,32 +7,21 @@ var invalidHeaderCharRegex = /[^\t\x20-\x7e\x80-\xff]/g;
 function sanitizeHeaderValue(v) {
 	return v.replace(invalidHeaderCharRegex, (m) => encodeURI(m));
 }
-/**
-* CRLF-delimited reader that preserves over-reads in an internal buffer.
-*
-* Key property: once you finish reading headers, any bytes already read beyond
-* the header terminator stay buffered and will be returned by read().
-*/
 var LineReader = class {
 	#src;
 	#buf;
 	#codec = new DelimiterCodec(CRLF_BYTES, { strategy: "discard" });
 	#eof = false;
-	#highWaterMark;
+	#readChunkSize;
 	#maxBufferedBytes;
 	#maxLineSize;
 	#closed = false;
 	close;
-	/**
-	* LineReader configuration.
-	*
-	* @namespace LineReader
-	*/
 	static Options;
 	constructor(src, opts = {}) {
 		this.#src = src;
 		this.#buf = Bytes.alloc(opts.bufferSize);
-		this.#highWaterMark = opts.highWaterMark ?? 16 * 1024;
+		this.#readChunkSize = opts.readChunkSize ?? 16 * 1024;
 		this.#maxBufferedBytes = opts.maxBufferedBytes ?? 256 * 1024;
 		this.#maxLineSize = opts.maxLineSize ?? 64 * 1024;
 		this.close = this.#close.bind(this);
@@ -120,7 +109,7 @@ var LineReader = class {
 		return headers;
 	}
 	async #pull() {
-		const into = this.#buf.writeSync(this.#highWaterMark);
+		const into = this.#buf.writeSync(this.#readChunkSize);
 		try {
 			const n = await this.#src.read(into);
 			this.#buf.disposeWriteSync(n);
@@ -139,16 +128,9 @@ var LineReader = class {
 	async #close() {
 		if (this.#closed) return;
 		this.#closed = true;
-		try {
-			await this.#src.close();
-		} finally {
-			this.#closed = true;
-		}
+		await this.#src.close();
 	}
 };
-/**
-* Body reader that streams bytes with either a fixed Content-Length or until EOF.
-*/
 var BodyReader = class {
 	#src;
 	#remaining;
@@ -156,29 +138,23 @@ var BodyReader = class {
 	#readSoFar = 0;
 	#closed = false;
 	close;
-	/**
-	* BodyReader configuration.
-	*
-	* @namespace BodyReader
-	*/
 	static Options;
 	constructor(src, contentLength, opts = {}) {
 		this.#src = src;
-		this.#remaining = contentLength >= 0 ? contentLength : null;
+		this.#remaining = contentLength;
 		this.#maxResponseSize = parseMaxBytes(opts.maxBodySize);
-		if (this.#maxResponseSize != null && this.#remaining != null && this.#remaining > this.#maxResponseSize) throw new Error(`body too large: content-length=${this.#remaining} > maxResponseSize=${this.#maxResponseSize}`);
 		this.close = this.#close.bind(this);
 	}
 	async read(into) {
 		if (this.#closed) return 0;
 		if (this.#remaining === 0) return 0;
-		let max = into.length;
-		if (this.#remaining != null) max = Math.min(max, this.#remaining);
 		if (this.#maxResponseSize != null) {
 			const remainingLimit = this.#maxResponseSize - this.#readSoFar;
 			if (remainingLimit <= 0) throw new Error(`body too large (> ${this.#maxResponseSize} bytes)`);
-			max = Math.min(max, remainingLimit);
+			if (into.length > remainingLimit) into = into.subarray(0, remainingLimit);
 		}
+		let max = into.length;
+		if (this.#remaining != null) max = Math.min(max, this.#remaining);
 		if (max === 0) return 0;
 		const view = max === into.length ? into : into.subarray(0, max);
 		let n = 0;
@@ -199,21 +175,14 @@ var BodyReader = class {
 	async #close() {
 		if (this.#closed) return;
 		this.#closed = true;
-		try {
-			await this.#src.close();
-		} finally {
-			this.#closed = true;
-		}
+		await this.#src.close();
 	}
 };
-/**
-* RFC 7230 chunked transfer-coding decoder.
-*/
 var ChunkedBodyReader = class {
 	#src;
 	#buf;
 	#codec = new DelimiterCodec(CRLF_BYTES, { strategy: "discard" });
-	#highWaterMark;
+	#readChunkSize;
 	#maxLineSize;
 	#maxChunkSize;
 	#maxResponseSize;
@@ -222,16 +191,11 @@ var ChunkedBodyReader = class {
 	#closed = false;
 	#state = { kind: "size" };
 	close;
-	/**
-	* ChunkedBodyReader configuration.
-	*
-	* @namespace ChunkedBodyReader
-	*/
 	static Options;
 	constructor(src, opts = {}) {
 		this.#src = src;
 		this.#buf = Bytes.alloc(opts.bufferSize);
-		this.#highWaterMark = opts.highWaterMark ?? 16 * 1024;
+		this.#readChunkSize = opts.readChunkSize ?? 16 * 1024;
 		this.#maxLineSize = opts.maxLineSize ?? 64 * 1024;
 		this.#maxChunkSize = opts.maxChunkSize ?? 16 * 1024 * 1024;
 		this.#maxResponseSize = parseMaxBytes(opts.maxBodySize);
@@ -323,7 +287,7 @@ var ChunkedBodyReader = class {
 		}
 	}
 	async #pull() {
-		const into = this.#buf.writeSync(this.#highWaterMark);
+		const into = this.#buf.writeSync(this.#readChunkSize);
 		try {
 			const n = await this.#readFromSrc(into);
 			this.#buf.disposeWriteSync(n);
@@ -362,11 +326,7 @@ var ChunkedBodyReader = class {
 	async #close() {
 		if (this.#closed) return;
 		this.#closed = true;
-		try {
-			await this.#src.close();
-		} finally {
-			this.#closed = true;
-		}
+		await this.#src.close();
 	}
 };
 //#endregion