create-request 2.2.0 → 2.2.1

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 2.2.1 — 2026-10-10
+
+### Fixed
+
+- `getJson()`, `getText()`, `getBlob()`, `getArrayBuffer()`, `getFormData()`, `getData()` and `getResult()` now read the body as part of each attempt, so a failure while reading it goes through the retry policy and the error interceptors like a failure before the response. Before, the body was read after both had finished: a body that stalled past `withTimeout()` was not retried, and error interceptors never saw a timeout or abort during the read, a connection dropped mid-body, invalid JSON, a schema mismatch or GraphQL errors. The default policy retries only the timeout; a custom `shouldRetry` now also receives the other errors (with `status` set). A `ResponseWrapper` returned by an error interceptor is read by the same reader, and if that read fails, the next interceptor receives the error. `getResponse()` and `getBody()` are unchanged: they resolve before the body is read.
+- A `getData()` selector that returns a rejected promise is reported as a `"PARSE"` error, like a selector that throws; it used to reject with the raw error.
+- A Node.js stream (`fs.createReadStream()`, a `Readable`) or another async iterable passed to `withBody()` is sent as a stream body (`duplex: "half"`, never retried), the way undici's `fetch` expects. Before, it was JSON-encoded: `withBody(fs.createReadStream(file))` sent the stream object's fields, local file path included, as `application/json`, and an async generator sent `{}`.
+- `getBody()` now has the type `fetch` gives `response.body` (`Response["body"]`), so piping it through a `TextDecoderStream`, the usual way to read server-sent events or LLM output, compiles with TypeScript 5.9 and later. Its old type, `ReadableStream<Uint8Array>`, allows `SharedArrayBuffer`-backed chunks, which `TextDecoderStream` in the TypeScript 5.9 DOM lib rejects. In a Node-only project (`@types/node` without the DOM lib) the type is `@types/node`'s, as for `fetch`.
+
+### Internal
+
+- The full import is 16 B smaller (min+gzip) than in 2.2.0 despite both fixes: class fields are declared instead of being emitted as parameter properties, and the schema check is shorter.
+- CI fails on packaging problems found by attw or publint (`npm run pack:check`); the build only warned about them.
+- The release workflow runs the full check and packs the tarball in a job without credentials. A separate job in the `npm` environment publishes that tarball with trusted publishing and provenance; it checks out nothing and runs no scripts, so no dependency runs while an npm token can be minted. A third job creates the GitHub release. Actions are pinned to commit SHAs and kept current by Dependabot.
+
 ## 2.2.0 — 2026-10-09
 
 ### Added

package/README.md

@@ -141,7 +141,7 @@ create
   .withQueryParams({ page: 2, tags: ["a", "b"], since: new Date() })
   .withQueryParam("q", "search term")
   // body (POST, PUT, PATCH, DELETE, QUERY only): objects → JSON, strings → text/plain,
-  // FormData / Blob / URLSearchParams / ArrayBuffer / typed arrays / ReadableStream → sent as-is
+  // FormData / Blob / URLSearchParams / ArrayBuffer / typed arrays / streams → sent as-is
   .withBody({ name: "Ada" })
   // resilience
   .withTimeout(5000) // per attempt; covers the response and the body read
@@ -328,7 +328,10 @@ How retries behave:
 - Aborted requests and requests with a stream body are never retried, whatever the policy. That
   includes a timeout from your own `AbortSignal.timeout()` signal, which stays aborted (only
   `withTimeout()` timeouts are retried).
-- The timeout applies to each attempt; error interceptors run once, after the last attempt.
+- The timeout applies to each attempt. With `getJson()`, `getText()`, `getData()` and the other
+  readers an attempt includes reading the body, so a body that stalls past the timeout is
+  retried too; `getResponse()` and `getBody()` hand you the body unread.
+- Error interceptors run once, after the last attempt.
 
 `onRetry(callback)` also exists as a method; it does not enable retries by itself.
 
@@ -392,6 +395,11 @@ it. A request or response interceptor that throws fails the request with code `"
 an error interceptor that throws replaces the error with an `"INTERCEPTOR"` one (a thrown
 `RequestError` is kept as-is).
 
+Error interceptors also see failures while `getJson()`, `getText()` and the other readers read
+the body: invalid JSON (`"PARSE"`), a schema mismatch (`"VALIDATION"`), GraphQL errors
+(`"GRAPHQL"`) and a timeout or abort during the read. A `ResponseWrapper` they return is read the
+same way, so `getJson()` parses the recovered response.
+
 ## Schema validation
 
 Pass any [Standard Schema](https://standardschema.dev) (zod 3.24+, valibot 1+, arktype 2+,
@@ -445,8 +453,21 @@ for (;;) {
 }
 ```
 
+For text streams (server-sent events, NDJSON, LLM output), pipe the body through a
+`TextDecoderStream`:
+
+```typescript
+const stream = await api.post("/chat").withBody({ prompt: "Hello" }).getBody();
+const reader = stream!.pipeThrough(new TextDecoderStream()).getReader();
+for (let chunk = await reader.read(); !chunk.done; chunk = await reader.read()) {
+  render(chunk.value);
+}
+```
+
 Request bodies can be streams too (`withBody(readableStream)`), sent with `duplex: "half"`.
-Node.js and Chromium support that; Firefox and Safari do not. Stream bodies are never retried.
+Node.js and Chromium support that; Firefox and Safari do not. In Node.js a Node stream or any
+async iterable works the same way, so `withBody(fs.createReadStream(path))` uploads a file (set
+its `Content-Type` yourself). A stream body can be sent only once and is never retried.
 Upload _progress_ is not something `fetch` exposes in browsers, so there is no API for it.
 
 ## Testing and custom fetch
@@ -542,8 +563,8 @@ Measured with `size-limit` on the published build of this version (`npm run size
 
 | Import                         | min + gzip | min + brotli |
 | ------------------------------ | ---------: | -----------: |
-| everything (`import * as …`)   |    4.95 KB |      4.48 KB |
-| `import { createGet }` only    |    4.32 KB |              |
+| everything (`import * as …`)   |    4.93 KB |      4.47 KB |
+| `import { createGet }` only    |    4.30 KB |              |
 | `import { RequestError }` only |    0.25 KB |              |
 
 The package is one module with no side effects, so bundlers drop whatever you do not import. The

package/dist/index.cjs

@@ -34,7 +34,7 @@ const messageOf = (error) => error instanceof Error ? error.message : String(err
 
 //#endregion
 //#region src/schema.ts
-const isSchema = (value) => !!value && (typeof value === "object" || typeof value === "function") && "~standard" in value;
+const isSchema = (value) => "~standard" in Object(value);
 
 //#endregion
 //#region src/utils.ts
@@ -124,9 +124,6 @@ const retryAfter = (response) => {
 //#endregion
 //#region src/response.ts
 var ResponseWrapper = class {
-	raw;
-	url;
-	method;
 	constructor(raw, url = "", method = "GET") {
 		this.raw = raw;
 		this.url = url;
@@ -240,7 +237,7 @@ var ResponseWrapper = class {
 		const data = await this.getJson(schema);
 		if (!select) return data;
 		try {
-			return select(data);
+			return await select(data);
 		} catch (e) {
 			throw this._err(`Selector failed: ${messageOf(e)}`, "PARSE", { cause: e });
 		}
@@ -259,7 +256,6 @@ const RETRY_STATUSES = [
 	504
 ];
 var HttpRequest = class HttpRequest {
-	method;
 	_o = {
 		init: {},
 		headers: {},
@@ -269,7 +265,6 @@ var HttpRequest = class HttpRequest {
 		res: [],
 		err: []
 	};
-	_url;
 	constructor(method, url) {
 		this.method = method;
 		this._url = url;
@@ -417,8 +412,8 @@ var HttpRequest = class HttpRequest {
 	withBody(body) {
 		const o = this._o;
 		const tag = Object.prototype.toString.call(body).slice(8, -1);
-		const raw = ArrayBuffer.isView(body) || /^(String|Blob|File|FormData|URLSearchParams|ArrayBuffer|ReadableStream)$/.test(tag);
-		o.stream = tag === "ReadableStream";
+		o.stream = Symbol.asyncIterator in Object(body) || tag === "ReadableStream";
+		const raw = o.stream || ArrayBuffer.isView(body) || /^(String|Blob|File|FormData|URLSearchParams|ArrayBuffer)$/.test(tag);
 		if (raw) o.body = body;
 		else try {
 			o.body = JSON.stringify(body);
@@ -451,12 +446,15 @@ var HttpRequest = class HttpRequest {
 		};
 		return copy;
 	}
-	async getResponse() {
+	getResponse() {
+		return this._run((response) => response);
+	}
+	async _run(read) {
 		const o = this._o;
 		const retry = o.retry;
 		let error;
 		for (let attempt = 0;; attempt++) try {
-			return await this._attempt();
+			return await read(await this._attempt());
 		} catch (e) {
 			error = e instanceof RequestError ? e : this._fail(`Unexpected error: ${messageOf(e)}`, "NETWORK", { cause: e });
 			const context = {
@@ -486,7 +484,7 @@ var HttpRequest = class HttpRequest {
 		}
 		for (const interceptor of o.err) try {
 			const result = await interceptor(error, this);
-			if (result instanceof ResponseWrapper) return result;
+			if (result instanceof ResponseWrapper) return await read(result);
 			if (result) error = result;
 		} catch (e) {
 			error = e instanceof RequestError ? e : this._fail(`Error interceptor failed: ${messageOf(e)}`, "INTERCEPTOR", {
@@ -618,25 +616,25 @@ var HttpRequest = class HttpRequest {
 		if (token && !(header in config.headers)) config.headers[header] = token;
 	}
 	getJson(schema) {
-		return this.getResponse().then((response) => response.getJson(schema));
+		return this._run((response) => response.getJson(schema));
 	}
 	getText() {
-		return this.getResponse().then((response) => response.getText());
+		return this._run((response) => response.getText());
 	}
 	getBlob() {
-		return this.getResponse().then((response) => response.getBlob());
+		return this._run((response) => response.getBlob());
 	}
 	getArrayBuffer() {
-		return this.getResponse().then((response) => response.getArrayBuffer());
+		return this._run((response) => response.getArrayBuffer());
 	}
 	getFormData() {
-		return this.getResponse().then((response) => response.getFormData());
+		return this._run((response) => response.getFormData());
 	}
 	getBody() {
-		return this.getResponse().then((response) => response.getBody());
+		return this._run((response) => response.getBody());
 	}
 	getData(schemaOrSelector, selector) {
-		return this.getResponse().then((response) => response.getData(schemaOrSelector, selector));
+		return this._run((response) => response.getData(schemaOrSelector, selector));
 	}
 	async getResult(schema) {
 		try {
@@ -657,11 +655,9 @@ var HttpRequest = class HttpRequest {
 //#region src/api.ts
 const ABSOLUTE = /^([a-z][a-z0-9+.-]*:)?\/\//i;
 var Api = class Api {
-	_base;
-	_defaults;
-	constructor(_base = "", _defaults = []) {
-		this._base = _base;
-		this._defaults = _defaults;
+	constructor(base = "", defaults = []) {
+		this._base = base;
+		this._defaults = defaults;
 	}
 	_with(fn) {
 		fn(new HttpRequest("GET", ""));

package/dist/index.d.cts

@@ -189,7 +189,8 @@ type PriorityHint = "auto" | "high" | "low";
  *
  * - `string` → sent as-is (`Content-Type: text/plain` unless you set one)
  * - `Blob` / `File`, `FormData`, `URLSearchParams` → sent as-is, `fetch` sets the matching `Content-Type`
- * - `ArrayBuffer`, typed arrays, `ReadableStream` → sent as-is, no `Content-Type` unless you set one
+ * - `ArrayBuffer`, typed arrays, `ReadableStream` and, in Node.js, Node streams and other async iterables → sent as-is,
+ *   no `Content-Type` unless you set one
  * - any other JSON-serialisable object or array → `JSON.stringify`-ed (`Content-Type: application/json` unless you set one)
  *
  * @example
@@ -240,6 +241,8 @@ interface RetryContext {
  * 408, 425, 429, 500, 502, 503 or 504, with exponential backoff (300 ms, 600 ms, 1.2 s, … plus
  * up to 100 ms of jitter, capped at `maxDelay`). A `Retry-After` header is honoured when present.
  * Aborted requests and requests with a `ReadableStream` body are never retried, whatever the policy.
+ * With `getJson()`, `getText()` and the other readers an attempt includes reading the body, so a timeout
+ * during the read is retried too (`getResponse()` and `getBody()` hand the body over unread).
  *
  * @example
  * ```typescript
@@ -271,7 +274,10 @@ interface RetryConfig {
    * cancels the retry so you can react to it yourself. Default: `30000`.
    */
   maxDelay?: number | undefined;
-  /** Full override of the retry decision (`statuses` and `methods` are ignored). Aborts and stream bodies still never retry. */
+  /**
+   * Full override of the retry decision (`statuses` and `methods` are ignored). Aborts and stream bodies still never retry.
+   * It also receives the errors raised while a reader reads the body (`PARSE`, `VALIDATION`, `GRAPHQL`, with `status` set).
+   */
   shouldRetry?: ((context: RetryContext) => boolean | Promise<boolean>) | undefined;
   /** Called before every retry, after the delay has been computed. Awaited if it returns a promise. */
   onRetry?: ((context: RetryContext & {
@@ -330,6 +336,10 @@ type ResponseInterceptor = (response: ResponseWrapper, request: HttpRequest) =>
  * Return nothing to keep the error, another {@link RequestError} to replace it, or a
  * {@link ResponseWrapper} to recover — typically by replaying `request.clone()`. Throwing replaces the error as well.
  *
+ * With `getJson()`, `getText()` and the other readers, a failure while reading the body (`PARSE`, `VALIDATION`,
+ * `GRAPHQL`, or a timeout or abort during the read) also reaches error interceptors, and a recovered
+ * `ResponseWrapper` is read the same way; if that read fails, the next interceptor receives the new error.
+ *
  * @example
  * ```typescript
  * const replayed = new WeakSet<HttpRequest>();
@@ -391,23 +401,17 @@ type RequestResult<T> = {
  * ```
  */
 export declare class ResponseWrapper<T = unknown> {
+  private _bin?;
+  private _text?;
+  private _json?;
   /** The underlying `Response`. Read its body through this wrapper's methods, or take it over with `getBody()`. */
   readonly raw: Response;
   /** The URL that was requested, including the query string (after interceptors). */
   readonly url: string;
   /** The HTTP method that was used. */
   readonly method: Method;
-  private _bin?;
-  private _text?;
-  private _json?;
   /** Wraps a `Response` — useful to hand a synthetic response to an error interceptor. */
-  constructor(
-  /** The underlying `Response`. Read its body through this wrapper's methods, or take it over with `getBody()`. */
-  raw: Response,
-  /** The URL that was requested, including the query string (after interceptors). */
-  url?: string,
-  /** The HTTP method that was used. */
-  method?: Method);
+  constructor(raw: Response, url?: string, method?: Method);
   /** HTTP status code (`200`, `404`, …). */
   get status(): number;
   /** HTTP status text (`"OK"`, `"Not Found"`, …); empty over HTTP/2. */
@@ -433,6 +437,8 @@ export declare class ResponseWrapper<T = unknown> {
    * The raw body stream, for streaming consumption (downloads with progress, SSE/NDJSON, LLM output…).
    * Unlike the other readers it is not buffered: the body can be read once, and only if no other reader ran.
    * Taking the stream also ends the request's `withTimeout()` deadline — from here on the stream is yours.
+   * It has the type `fetch` gives `response.body` in your environment (DOM lib or `@types/node`), so it pipes
+   * through `TextDecoderStream` and other web streams like that one does.
    *
    * @example
    * ```typescript
@@ -440,7 +446,7 @@ export declare class ResponseWrapper<T = unknown> {
    * for (let chunk = await reader.read(); !chunk.done; chunk = await reader.read()) process(chunk.value);
    * ```
    */
-  getBody(): ReadableStream<Uint8Array> | null;
+  getBody(): Response["body"];
   /**
    * The body parsed as JSON. An empty body (`204`, `Content-Length: 0`, whitespace) yields `null` —
    * declare it in the type (`getJson<User | null>()`) for endpoints that may return nothing.
@@ -460,7 +466,8 @@ export declare class ResponseWrapper<T = unknown> {
   /**
    * `getJson()` followed by a selector, so you can pick the part you need in one call. The selector
    * receives `T` (declare it on the request: `api.get<Page>()`), or pass both type arguments explicitly.
-   * Errors thrown by the selector are reported as a `RequestError` with code `"PARSE"`. A schema can be validated first.
+   * A selector that throws (or returns a promise that rejects) is reported as a `RequestError` with code `"PARSE"`.
+   * A schema can be validated first.
    *
    * @example
    * ```typescript
@@ -504,9 +511,7 @@ export declare class HttpRequest<M extends Method = Method, T = unknown> {
   readonly method: M;
   private readonly _url;
   /** Prefer `create.get(url)`, `create.post(url)`, … or an api instance to construct requests. */
-  constructor(
-  /** The HTTP method. */
-  method: M, url: string);
+  constructor(method: M, url: string);
   /** The URL this request will be sent to, including the query string. */
   get url(): string;
   private _fail;
@@ -651,14 +656,18 @@ export declare class HttpRequest<M extends Method = Method, T = unknown> {
   withRequestInterceptor(interceptor: RequestInterceptor): this;
   /** Adds a {@link ResponseInterceptor}, run after every successful response in registration order (it also receives the request). */
   withResponseInterceptor(interceptor: ResponseInterceptor): this;
-  /** Adds an {@link ErrorInterceptor}, run once after the request has failed for good (after retries); it also receives the request, so it can replay it. */
+  /**
+   * Adds an {@link ErrorInterceptor}, run once after the request has failed for good (after retries, and including a failure while
+   * `getJson()`, `getText()`, … read the body); it also receives the request, so it can replay it.
+   */
   withErrorInterceptor(interceptor: ErrorInterceptor): this;
   /**
    * Sets the request body (POST, PUT, PATCH, DELETE and QUERY only — a compile error elsewhere). Objects and
-   * arrays are JSON-encoded; strings, `Blob`, `FormData`, `URLSearchParams`, `ArrayBuffer`, typed arrays
-   * and `ReadableStream` are sent as-is. `Content-Type` is set to `application/json` / `text/plain`
-   * unless already present, and removed for `FormData` (fetch must add the multipart boundary itself).
-   * Stream bodies are sent with `duplex: "half"` (Chromium and Node.js only) and are never retried.
+   * arrays are JSON-encoded; strings, `Blob`, `FormData`, `URLSearchParams`, `ArrayBuffer`, typed arrays,
+   * `ReadableStream` and, in Node.js, Node streams (`fs.createReadStream()`) and other async iterables are sent
+   * as-is. `Content-Type` is set to `application/json` / `text/plain` unless already present, and removed for
+   * `FormData` (fetch must add the multipart boundary itself). Stream bodies are sent with `duplex: "half"`
+   * (Chromium and Node.js only), can be sent only once and are never retried.
    *
    * @example
    * ```typescript
@@ -682,7 +691,7 @@ export declare class HttpRequest<M extends Method = Method, T = unknown> {
   withGraphQL(this: HttpRequest<BodyMethod, T>, query: string, variables?: object, options?: GraphQLOptions): this;
   /**
    * An independent copy of this request, so a configured request can serve as a template.
-   * Interceptors, signals and body objects are shared by reference (a `ReadableStream` body can only be sent once).
+   * Interceptors, signals and body objects are shared by reference (a stream body can only be sent once).
    *
    * @example
    * ```typescript
@@ -696,8 +705,16 @@ export declare class HttpRequest<M extends Method = Method, T = unknown> {
    * Sends the request (with retries, if configured) and resolves with the {@link ResponseWrapper} of a
    * successful (2xx or opaque) response. Any failure — non-2xx status, network error, timeout, abort,
    * interceptor error — rejects with a {@link RequestError}; use `getResult()` for a non-throwing variant.
+   * It resolves before the body is read, so reading it is up to you and happens after the retries and error
+   * interceptors; `getJson()`, `getText()` and the other readers read it as part of each attempt instead.
    */
   getResponse(): Promise<ResponseWrapper<T>>;
+  /**
+   * Runs the attempts, the retry policy and the error interceptors around `read`, which receives each response — so a
+   * failure while reading the body (a timeout during the read, invalid JSON, a schema or GraphQL error) is retried and
+   * intercepted like a failure before it. A response recovered by an error interceptor goes through `read` as well.
+   */
+  private _run;
   private _retriable;
   private _attempt;
   /** Attaches the CSRF token (see {@link withCsrf}) to `config.headers` when the final URL qualifies. */
@@ -723,7 +740,7 @@ export declare class HttpRequest<M extends Method = Method, T = unknown> {
   /** Sends the request and parses the body as `FormData`. */
   getFormData(): Promise<FormData>;
   /** Sends the request and returns the raw body stream — see {@link ResponseWrapper.getBody}. */
-  getBody(): Promise<ReadableStream<Uint8Array> | null>;
+  getBody(): Promise<Response["body"]>;
   /**
    * Sends the request, parses JSON and applies a selector — see {@link ResponseWrapper.getData}.
    *

package/dist/index.d.ts

@@ -189,7 +189,8 @@ type PriorityHint = "auto" | "high" | "low";
  *
  * - `string` → sent as-is (`Content-Type: text/plain` unless you set one)
  * - `Blob` / `File`, `FormData`, `URLSearchParams` → sent as-is, `fetch` sets the matching `Content-Type`
- * - `ArrayBuffer`, typed arrays, `ReadableStream` → sent as-is, no `Content-Type` unless you set one
+ * - `ArrayBuffer`, typed arrays, `ReadableStream` and, in Node.js, Node streams and other async iterables → sent as-is,
+ *   no `Content-Type` unless you set one
  * - any other JSON-serialisable object or array → `JSON.stringify`-ed (`Content-Type: application/json` unless you set one)
  *
  * @example
@@ -240,6 +241,8 @@ interface RetryContext {
  * 408, 425, 429, 500, 502, 503 or 504, with exponential backoff (300 ms, 600 ms, 1.2 s, … plus
  * up to 100 ms of jitter, capped at `maxDelay`). A `Retry-After` header is honoured when present.
  * Aborted requests and requests with a `ReadableStream` body are never retried, whatever the policy.
+ * With `getJson()`, `getText()` and the other readers an attempt includes reading the body, so a timeout
+ * during the read is retried too (`getResponse()` and `getBody()` hand the body over unread).
  *
  * @example
  * ```typescript
@@ -271,7 +274,10 @@ interface RetryConfig {
    * cancels the retry so you can react to it yourself. Default: `30000`.
    */
   maxDelay?: number | undefined;
-  /** Full override of the retry decision (`statuses` and `methods` are ignored). Aborts and stream bodies still never retry. */
+  /**
+   * Full override of the retry decision (`statuses` and `methods` are ignored). Aborts and stream bodies still never retry.
+   * It also receives the errors raised while a reader reads the body (`PARSE`, `VALIDATION`, `GRAPHQL`, with `status` set).
+   */
   shouldRetry?: ((context: RetryContext) => boolean | Promise<boolean>) | undefined;
   /** Called before every retry, after the delay has been computed. Awaited if it returns a promise. */
   onRetry?: ((context: RetryContext & {
@@ -330,6 +336,10 @@ type ResponseInterceptor = (response: ResponseWrapper, request: HttpRequest) =>
  * Return nothing to keep the error, another {@link RequestError} to replace it, or a
  * {@link ResponseWrapper} to recover — typically by replaying `request.clone()`. Throwing replaces the error as well.
  *
+ * With `getJson()`, `getText()` and the other readers, a failure while reading the body (`PARSE`, `VALIDATION`,
+ * `GRAPHQL`, or a timeout or abort during the read) also reaches error interceptors, and a recovered
+ * `ResponseWrapper` is read the same way; if that read fails, the next interceptor receives the new error.
+ *
  * @example
  * ```typescript
  * const replayed = new WeakSet<HttpRequest>();
@@ -391,23 +401,17 @@ type RequestResult<T> = {
  * ```
  */
 export declare class ResponseWrapper<T = unknown> {
+  private _bin?;
+  private _text?;
+  private _json?;
   /** The underlying `Response`. Read its body through this wrapper's methods, or take it over with `getBody()`. */
   readonly raw: Response;
   /** The URL that was requested, including the query string (after interceptors). */
   readonly url: string;
   /** The HTTP method that was used. */
   readonly method: Method;
-  private _bin?;
-  private _text?;
-  private _json?;
   /** Wraps a `Response` — useful to hand a synthetic response to an error interceptor. */
-  constructor(
-  /** The underlying `Response`. Read its body through this wrapper's methods, or take it over with `getBody()`. */
-  raw: Response,
-  /** The URL that was requested, including the query string (after interceptors). */
-  url?: string,
-  /** The HTTP method that was used. */
-  method?: Method);
+  constructor(raw: Response, url?: string, method?: Method);
   /** HTTP status code (`200`, `404`, …). */
   get status(): number;
   /** HTTP status text (`"OK"`, `"Not Found"`, …); empty over HTTP/2. */
@@ -433,6 +437,8 @@ export declare class ResponseWrapper<T = unknown> {
    * The raw body stream, for streaming consumption (downloads with progress, SSE/NDJSON, LLM output…).
    * Unlike the other readers it is not buffered: the body can be read once, and only if no other reader ran.
    * Taking the stream also ends the request's `withTimeout()` deadline — from here on the stream is yours.
+   * It has the type `fetch` gives `response.body` in your environment (DOM lib or `@types/node`), so it pipes
+   * through `TextDecoderStream` and other web streams like that one does.
    *
    * @example
    * ```typescript
@@ -440,7 +446,7 @@ export declare class ResponseWrapper<T = unknown> {
    * for (let chunk = await reader.read(); !chunk.done; chunk = await reader.read()) process(chunk.value);
    * ```
    */
-  getBody(): ReadableStream<Uint8Array> | null;
+  getBody(): Response["body"];
   /**
    * The body parsed as JSON. An empty body (`204`, `Content-Length: 0`, whitespace) yields `null` —
    * declare it in the type (`getJson<User | null>()`) for endpoints that may return nothing.
@@ -460,7 +466,8 @@ export declare class ResponseWrapper<T = unknown> {
   /**
    * `getJson()` followed by a selector, so you can pick the part you need in one call. The selector
    * receives `T` (declare it on the request: `api.get<Page>()`), or pass both type arguments explicitly.
-   * Errors thrown by the selector are reported as a `RequestError` with code `"PARSE"`. A schema can be validated first.
+   * A selector that throws (or returns a promise that rejects) is reported as a `RequestError` with code `"PARSE"`.
+   * A schema can be validated first.
    *
    * @example
    * ```typescript
@@ -504,9 +511,7 @@ export declare class HttpRequest<M extends Method = Method, T = unknown> {
   readonly method: M;
   private readonly _url;
   /** Prefer `create.get(url)`, `create.post(url)`, … or an api instance to construct requests. */
-  constructor(
-  /** The HTTP method. */
-  method: M, url: string);
+  constructor(method: M, url: string);
   /** The URL this request will be sent to, including the query string. */
   get url(): string;
   private _fail;
@@ -651,14 +656,18 @@ export declare class HttpRequest<M extends Method = Method, T = unknown> {
   withRequestInterceptor(interceptor: RequestInterceptor): this;
   /** Adds a {@link ResponseInterceptor}, run after every successful response in registration order (it also receives the request). */
   withResponseInterceptor(interceptor: ResponseInterceptor): this;
-  /** Adds an {@link ErrorInterceptor}, run once after the request has failed for good (after retries); it also receives the request, so it can replay it. */
+  /**
+   * Adds an {@link ErrorInterceptor}, run once after the request has failed for good (after retries, and including a failure while
+   * `getJson()`, `getText()`, … read the body); it also receives the request, so it can replay it.
+   */
   withErrorInterceptor(interceptor: ErrorInterceptor): this;
   /**
    * Sets the request body (POST, PUT, PATCH, DELETE and QUERY only — a compile error elsewhere). Objects and
-   * arrays are JSON-encoded; strings, `Blob`, `FormData`, `URLSearchParams`, `ArrayBuffer`, typed arrays
-   * and `ReadableStream` are sent as-is. `Content-Type` is set to `application/json` / `text/plain`
-   * unless already present, and removed for `FormData` (fetch must add the multipart boundary itself).
-   * Stream bodies are sent with `duplex: "half"` (Chromium and Node.js only) and are never retried.
+   * arrays are JSON-encoded; strings, `Blob`, `FormData`, `URLSearchParams`, `ArrayBuffer`, typed arrays,
+   * `ReadableStream` and, in Node.js, Node streams (`fs.createReadStream()`) and other async iterables are sent
+   * as-is. `Content-Type` is set to `application/json` / `text/plain` unless already present, and removed for
+   * `FormData` (fetch must add the multipart boundary itself). Stream bodies are sent with `duplex: "half"`
+   * (Chromium and Node.js only), can be sent only once and are never retried.
    *
    * @example
    * ```typescript
@@ -682,7 +691,7 @@ export declare class HttpRequest<M extends Method = Method, T = unknown> {
   withGraphQL(this: HttpRequest<BodyMethod, T>, query: string, variables?: object, options?: GraphQLOptions): this;
   /**
    * An independent copy of this request, so a configured request can serve as a template.
-   * Interceptors, signals and body objects are shared by reference (a `ReadableStream` body can only be sent once).
+   * Interceptors, signals and body objects are shared by reference (a stream body can only be sent once).
    *
    * @example
    * ```typescript
@@ -696,8 +705,16 @@ export declare class HttpRequest<M extends Method = Method, T = unknown> {
    * Sends the request (with retries, if configured) and resolves with the {@link ResponseWrapper} of a
    * successful (2xx or opaque) response. Any failure — non-2xx status, network error, timeout, abort,
    * interceptor error — rejects with a {@link RequestError}; use `getResult()` for a non-throwing variant.
+   * It resolves before the body is read, so reading it is up to you and happens after the retries and error
+   * interceptors; `getJson()`, `getText()` and the other readers read it as part of each attempt instead.
    */
   getResponse(): Promise<ResponseWrapper<T>>;
+  /**
+   * Runs the attempts, the retry policy and the error interceptors around `read`, which receives each response — so a
+   * failure while reading the body (a timeout during the read, invalid JSON, a schema or GraphQL error) is retried and
+   * intercepted like a failure before it. A response recovered by an error interceptor goes through `read` as well.
+   */
+  private _run;
   private _retriable;
   private _attempt;
   /** Attaches the CSRF token (see {@link withCsrf}) to `config.headers` when the final URL qualifies. */
@@ -723,7 +740,7 @@ export declare class HttpRequest<M extends Method = Method, T = unknown> {
   /** Sends the request and parses the body as `FormData`. */
   getFormData(): Promise<FormData>;
   /** Sends the request and returns the raw body stream — see {@link ResponseWrapper.getBody}. */
-  getBody(): Promise<ReadableStream<Uint8Array> | null>;
+  getBody(): Promise<Response["body"]>;
   /**
    * Sends the request, parses JSON and applies a selector — see {@link ResponseWrapper.getData}.
    *

package/dist/index.js

@@ -33,7 +33,7 @@ const messageOf = (error) => error instanceof Error ? error.message : String(err
 
 //#endregion
 //#region src/schema.ts
-const isSchema = (value) => !!value && (typeof value === "object" || typeof value === "function") && "~standard" in value;
+const isSchema = (value) => "~standard" in Object(value);
 
 //#endregion
 //#region src/utils.ts
@@ -123,9 +123,6 @@ const retryAfter = (response) => {
 //#endregion
 //#region src/response.ts
 var ResponseWrapper = class {
-	raw;
-	url;
-	method;
 	constructor(raw, url = "", method = "GET") {
 		this.raw = raw;
 		this.url = url;
@@ -239,7 +236,7 @@ var ResponseWrapper = class {
 		const data = await this.getJson(schema);
 		if (!select) return data;
 		try {
-			return select(data);
+			return await select(data);
 		} catch (e) {
 			throw this._err(`Selector failed: ${messageOf(e)}`, "PARSE", { cause: e });
 		}
@@ -258,7 +255,6 @@ const RETRY_STATUSES = [
 	504
 ];
 var HttpRequest = class HttpRequest {
-	method;
 	_o = {
 		init: {},
 		headers: {},
@@ -268,7 +264,6 @@ var HttpRequest = class HttpRequest {
 		res: [],
 		err: []
 	};
-	_url;
 	constructor(method, url) {
 		this.method = method;
 		this._url = url;
@@ -416,8 +411,8 @@ var HttpRequest = class HttpRequest {
 	withBody(body) {
 		const o = this._o;
 		const tag = Object.prototype.toString.call(body).slice(8, -1);
-		const raw = ArrayBuffer.isView(body) || /^(String|Blob|File|FormData|URLSearchParams|ArrayBuffer|ReadableStream)$/.test(tag);
-		o.stream = tag === "ReadableStream";
+		o.stream = Symbol.asyncIterator in Object(body) || tag === "ReadableStream";
+		const raw = o.stream || ArrayBuffer.isView(body) || /^(String|Blob|File|FormData|URLSearchParams|ArrayBuffer)$/.test(tag);
 		if (raw) o.body = body;
 		else try {
 			o.body = JSON.stringify(body);
@@ -450,12 +445,15 @@ var HttpRequest = class HttpRequest {
 		};
 		return copy;
 	}
-	async getResponse() {
+	getResponse() {
+		return this._run((response) => response);
+	}
+	async _run(read) {
 		const o = this._o;
 		const retry = o.retry;
 		let error;
 		for (let attempt = 0;; attempt++) try {
-			return await this._attempt();
+			return await read(await this._attempt());
 		} catch (e) {
 			error = e instanceof RequestError ? e : this._fail(`Unexpected error: ${messageOf(e)}`, "NETWORK", { cause: e });
 			const context = {
@@ -485,7 +483,7 @@ var HttpRequest = class HttpRequest {
 		}
 		for (const interceptor of o.err) try {
 			const result = await interceptor(error, this);
-			if (result instanceof ResponseWrapper) return result;
+			if (result instanceof ResponseWrapper) return await read(result);
 			if (result) error = result;
 		} catch (e) {
 			error = e instanceof RequestError ? e : this._fail(`Error interceptor failed: ${messageOf(e)}`, "INTERCEPTOR", {
@@ -617,25 +615,25 @@ var HttpRequest = class HttpRequest {
 		if (token && !(header in config.headers)) config.headers[header] = token;
 	}
 	getJson(schema) {
-		return this.getResponse().then((response) => response.getJson(schema));
+		return this._run((response) => response.getJson(schema));
 	}
 	getText() {
-		return this.getResponse().then((response) => response.getText());
+		return this._run((response) => response.getText());
 	}
 	getBlob() {
-		return this.getResponse().then((response) => response.getBlob());
+		return this._run((response) => response.getBlob());
 	}
 	getArrayBuffer() {
-		return this.getResponse().then((response) => response.getArrayBuffer());
+		return this._run((response) => response.getArrayBuffer());
 	}
 	getFormData() {
-		return this.getResponse().then((response) => response.getFormData());
+		return this._run((response) => response.getFormData());
 	}
 	getBody() {
-		return this.getResponse().then((response) => response.getBody());
+		return this._run((response) => response.getBody());
 	}
 	getData(schemaOrSelector, selector) {
-		return this.getResponse().then((response) => response.getData(schemaOrSelector, selector));
+		return this._run((response) => response.getData(schemaOrSelector, selector));
 	}
 	async getResult(schema) {
 		try {
@@ -656,11 +654,9 @@ var HttpRequest = class HttpRequest {
 //#region src/api.ts
 const ABSOLUTE = /^([a-z][a-z0-9+.-]*:)?\/\//i;
 var Api = class Api {
-	_base;
-	_defaults;
-	constructor(_base = "", _defaults = []) {
-		this._base = _base;
-		this._defaults = _defaults;
+	constructor(base = "", defaults = []) {
+		this._base = base;
+		this._defaults = defaults;
 	}
 	_with(fn) {
 		fn(new HttpRequest("GET", ""));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-request",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "description": "A tiny, chainable, fully typed wrapper around fetch: retries, timeouts, cancellation, interceptors, api instances, schema validation and one error type",
   "type": "module",
   "sideEffects": false,