create-request 2.1.0 → 2.2.1

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # 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
+
+- `create.query()`, `createQuery()`, `api.query()` and the `QueryRequest` type for the HTTP `QUERY` method ([RFC 10008](https://www.rfc-editor.org/rfc/rfc10008)): a safe, idempotent read whose query is sent in the body, for searches too large or too structured for a URL. `"QUERY"` joins the `Method` and `BodyMethod` unions, so `withBody()` and `withGraphQL()` accept it and `withRetries({ methods })` can list it; a `switch` that handles every `Method` needs a `"QUERY"` case.
+
 ## 2.1.0 — 2026-10-03
 
 ### Added

package/README.md

@@ -104,15 +104,26 @@ try {
 ### Creating
 
 ```typescript
-create.get(url); // also head, options, post, put, patch, delete (alias: del)
+create.get(url); // also head, options, post, put, patch, delete (alias: del), query
 api.get("/users"); // joined to the api's base URL
 api.get(); // no path → the base URL itself
 api.get<User>("/me"); // declare the JSON type once; getJson() / getData() / getResult() use it
 ```
 
 Named factories exist as well: `createGet`, `createPost`, `createPut`, `createPatch`,
-`createDelete`, `createHead`, `createOptions` (the same functions as `create.get`, …), and
-`createApi()` is also available as `create.api()`.
+`createDelete`, `createHead`, `createOptions`, `createQuery` (the same functions as
+`create.get`, …), and `createApi()` is also available as `create.api()`.
+
+`QUERY` works like `GET`, but the query goes in the body:
+
+```typescript
+const results = await api
+  .query<Page<Post>>("/posts/search")
+  .withBody({ text: "fetch", tags: ["http"], sort: "recent" })
+  .getJson();
+```
+
+The server must support `QUERY`. In browsers, a cross-origin `QUERY` request is preflighted.
 
 ### Configuring
 
@@ -129,8 +140,8 @@ create
   // and a key set twice keeps the last value (a request can override an api default)
   .withQueryParams({ page: 2, tags: ["a", "b"], since: new Date() })
   .withQueryParam("q", "search term")
-  // body (POST, PUT, PATCH, DELETE only): objects → JSON, strings → text/plain,
-  // FormData / Blob / URLSearchParams / ArrayBuffer / typed arrays / ReadableStream → sent as-is
+  // body (POST, PUT, PATCH, DELETE, QUERY only): objects → JSON, strings → text/plain,
+  // 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
@@ -296,7 +307,7 @@ api.get("/status").withRetries({
   attempts: 3,
   delay: ({ attempt }) => attempt * 500, // ms, or a number; default: exponential backoff
   statuses: [503], // default: 408, 425, 429, 500, 502, 503, 504
-  methods: ["GET", "HEAD", "OPTIONS", "PUT", "DELETE"], // default: all, POST and PATCH included
+  methods: ["GET", "HEAD", "OPTIONS", "QUERY", "PUT", "DELETE"], // default: all, POST and PATCH included
   maxDelay: 10_000, // caps the backoff (default 30 s); a longer Retry-After gives up instead
   shouldRetry: ({ error }) => error.code === "NETWORK", // full override of the decision
   onRetry: ({ attempt, error, delay }) =>
@@ -310,14 +321,17 @@ How retries behave:
   backoff (300 ms, 600 ms, 1.2 s, … plus up to 100 ms of jitter, capped at `maxDelay`);
   validation errors and other failures are not.
 - Every method is retried by default, `POST` and `PATCH` included. Pass
-  `methods: ["GET", "HEAD", "OPTIONS", "PUT", "DELETE"]` if a repeated request could duplicate
-  work.
+  `methods: ["GET", "HEAD", "OPTIONS", "QUERY", "PUT", "DELETE"]` if a repeated request could
+  duplicate work.
 - A `Retry-After` header is honoured unless you set `delay`; one longer than `maxDelay` cancels
   the retry so you can react yourself.
 - 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.
 
@@ -381,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+,
@@ -434,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
@@ -531,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.92 KB |      4.46 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", ""));
@@ -685,7 +681,8 @@ const METHODS = [
 	"POST",
 	"PUT",
 	"PATCH",
-	"DELETE"
+	"DELETE",
+	"QUERY"
 ];
 let installed = false;
 function createApi() {
@@ -712,6 +709,7 @@ const createPost = (url) => new HttpRequest("POST", url);
 const createPut = (url) => new HttpRequest("PUT", url);
 const createPatch = (url) => new HttpRequest("PATCH", url);
 const createDelete = (url) => new HttpRequest("DELETE", url);
+const createQuery = (url) => new HttpRequest("QUERY", url);
 const create = {
 	get: createGet,
 	head: createHead,
@@ -721,6 +719,7 @@ const create = {
 	patch: createPatch,
 	delete: createDelete,
 	del: createDelete,
+	query: createQuery,
 	api: createApi
 };
 
@@ -736,5 +735,6 @@ exports.createOptions = createOptions;
 exports.createPatch = createPatch;
 exports.createPost = createPost;
 exports.createPut = createPut;
+exports.createQuery = createQuery;
 exports.default = create;
 exports.isRequestError = isRequestError;

package/dist/index.d.cts

@@ -163,10 +163,13 @@ export declare class RequestError<TData = unknown> extends Error {
 export declare const isRequestError: (error: unknown) => error is RequestError;
 //#endregion
 //#region src/types.d.ts
-/** The HTTP methods a request can be created with. */
-type Method = "GET" | "HEAD" | "OPTIONS" | "DELETE" | "POST" | "PUT" | "PATCH";
+/**
+ * The HTTP methods a request can be created with. `QUERY` ([RFC 10008](https://www.rfc-editor.org/rfc/rfc10008)) is a
+ * safe, idempotent read like `GET` whose query is sent in the body.
+ */
+type Method = "GET" | "HEAD" | "OPTIONS" | "DELETE" | "POST" | "PUT" | "PATCH" | "QUERY";
 /** The HTTP methods that may carry a request body (`withBody` / `withGraphQL` are only available on these). */
-type BodyMethod = "POST" | "PUT" | "PATCH" | "DELETE";
+type BodyMethod = "POST" | "PUT" | "PATCH" | "DELETE" | "QUERY";
 /** What `fetch` accepts as a body. */
 type FetchBody = NonNullable<RequestInit["body"]>;
 /** `"include"`, `"omit"` or `"same-origin"`. */
@@ -186,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
@@ -237,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
@@ -261,14 +267,17 @@ interface RetryConfig {
   delay?: number | ((context: RetryContext) => number) | undefined;
   /** Statuses that are retried. Default: `[408, 425, 429, 500, 502, 503, 504]`. Network errors and timeouts are retried by default. */
   statuses?: readonly number[] | undefined;
-  /** Methods that are retried. Default: all. Use `["GET", "HEAD", "OPTIONS", "PUT", "DELETE"]` to retry idempotent requests only. */
+  /** Methods that are retried. Default: all. Use `["GET", "HEAD", "OPTIONS", "QUERY", "PUT", "DELETE"]` to retry idempotent requests only. */
   methods?: readonly Method[] | undefined;
   /**
    * Upper bound, in milliseconds, for the default backoff. A `Retry-After` header longer than this
    * 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 & {
@@ -327,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>();
@@ -388,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. */
@@ -430,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
@@ -437,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.
@@ -457,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
@@ -501,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;
@@ -648,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 and DELETE 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.
+   * 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,
+   * `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
@@ -679,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
@@ -693,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. */
@@ -720,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}.
    *
@@ -799,6 +819,8 @@ interface ApiBuilder extends ApiChainables {
   delete<T = unknown>(path?: string): HttpRequest<"DELETE", T>;
   /** Alias of `delete`. */
   del<T = unknown>(path?: string): HttpRequest<"DELETE", T>;
+  /** Creates a QUERY request (RFC 10008): a safe, idempotent read whose query is sent with `withBody()`. */
+  query<T = unknown>(path?: string): HttpRequest<"QUERY", T>;
 }
 /**
  * Creates an empty {@link ApiBuilder}. Configure it once, export it, and create every request through it.
@@ -821,9 +843,11 @@ export type PutRequest<T = unknown> = HttpRequest<"PUT", T>;
 export type PatchRequest<T = unknown> = HttpRequest<"PATCH", T>;
 /** A DELETE request. */
 export type DeleteRequest<T = unknown> = HttpRequest<"DELETE", T>;
+/** A QUERY request (RFC 10008). */
+export type QueryRequest<T = unknown> = HttpRequest<"QUERY", T>;
 /** Any request — the v1 name for {@link HttpRequest}. */
 export type BaseRequest<T = unknown> = HttpRequest<Method, T>;
-/** Any request that may carry a body — the v1 name for `HttpRequest<"POST" | "PUT" | "PATCH" | "DELETE">`. */
+/** Any request that may carry a body — the v1 name for `HttpRequest<"POST" | "PUT" | "PATCH" | "DELETE" | "QUERY">`. */
 export type BodyRequest<T = unknown> = HttpRequest<BodyMethod, T>;
 /** Creates a GET request. `T` declares the JSON type the response is expected to have. */
 export declare const createGet: <T = unknown>(url: string) => GetRequest<T>;
@@ -839,6 +863,17 @@ export declare const createPut: <T = unknown>(url: string) => PutRequest<T>;
 export declare const createPatch: <T = unknown>(url: string) => PatchRequest<T>;
 /** Creates a DELETE request. */
 export declare const createDelete: <T = unknown>(url: string) => DeleteRequest<T>;
+/**
+ * Creates a QUERY request ([RFC 10008](https://www.rfc-editor.org/rfc/rfc10008)): a safe, idempotent read like GET
+ * whose query travels in the body, so it can be as large and as structured as needed. The server must support the
+ * method and needs a `Content-Type`, which is set for you except for binary and stream bodies (use `withContentType()`).
+ *
+ * @example
+ * ```typescript
+ * const open = await create.query<Issue[]>("https://api.example.com/issues").withBody({ state: "open", labels: ["bug"] }).getJson();
+ * ```
+ */
+export declare const createQuery: <T = unknown>(url: string) => QueryRequest<T>;
 /**
  * The entry point: one factory per HTTP method plus `api()` for configured instances.
  *
@@ -868,6 +903,8 @@ declare const create: {
   readonly delete: <T = unknown>(url: string) => DeleteRequest<T>;
   /** Alias of `delete`. */
   readonly del: <T = unknown>(url: string) => DeleteRequest<T>;
+  /** Creates a QUERY request (RFC 10008): a safe, idempotent read whose query is sent with `withBody()` — see {@link createQuery}. */
+  readonly query: <T = unknown>(url: string) => QueryRequest<T>;
   /** Creates an api instance — see {@link createApi}. */
   readonly api: typeof createApi;
 };

package/dist/index.d.ts

@@ -163,10 +163,13 @@ export declare class RequestError<TData = unknown> extends Error {
 export declare const isRequestError: (error: unknown) => error is RequestError;
 //#endregion
 //#region src/types.d.ts
-/** The HTTP methods a request can be created with. */
-type Method = "GET" | "HEAD" | "OPTIONS" | "DELETE" | "POST" | "PUT" | "PATCH";
+/**
+ * The HTTP methods a request can be created with. `QUERY` ([RFC 10008](https://www.rfc-editor.org/rfc/rfc10008)) is a
+ * safe, idempotent read like `GET` whose query is sent in the body.
+ */
+type Method = "GET" | "HEAD" | "OPTIONS" | "DELETE" | "POST" | "PUT" | "PATCH" | "QUERY";
 /** The HTTP methods that may carry a request body (`withBody` / `withGraphQL` are only available on these). */
-type BodyMethod = "POST" | "PUT" | "PATCH" | "DELETE";
+type BodyMethod = "POST" | "PUT" | "PATCH" | "DELETE" | "QUERY";
 /** What `fetch` accepts as a body. */
 type FetchBody = NonNullable<RequestInit["body"]>;
 /** `"include"`, `"omit"` or `"same-origin"`. */
@@ -186,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
@@ -237,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
@@ -261,14 +267,17 @@ interface RetryConfig {
   delay?: number | ((context: RetryContext) => number) | undefined;
   /** Statuses that are retried. Default: `[408, 425, 429, 500, 502, 503, 504]`. Network errors and timeouts are retried by default. */
   statuses?: readonly number[] | undefined;
-  /** Methods that are retried. Default: all. Use `["GET", "HEAD", "OPTIONS", "PUT", "DELETE"]` to retry idempotent requests only. */
+  /** Methods that are retried. Default: all. Use `["GET", "HEAD", "OPTIONS", "QUERY", "PUT", "DELETE"]` to retry idempotent requests only. */
   methods?: readonly Method[] | undefined;
   /**
    * Upper bound, in milliseconds, for the default backoff. A `Retry-After` header longer than this
    * 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 & {
@@ -327,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>();
@@ -388,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. */
@@ -430,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
@@ -437,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.
@@ -457,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
@@ -501,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;
@@ -648,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 and DELETE 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.
+   * 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,
+   * `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
@@ -679,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
@@ -693,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. */
@@ -720,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}.
    *
@@ -799,6 +819,8 @@ interface ApiBuilder extends ApiChainables {
   delete<T = unknown>(path?: string): HttpRequest<"DELETE", T>;
   /** Alias of `delete`. */
   del<T = unknown>(path?: string): HttpRequest<"DELETE", T>;
+  /** Creates a QUERY request (RFC 10008): a safe, idempotent read whose query is sent with `withBody()`. */
+  query<T = unknown>(path?: string): HttpRequest<"QUERY", T>;
 }
 /**
  * Creates an empty {@link ApiBuilder}. Configure it once, export it, and create every request through it.
@@ -821,9 +843,11 @@ export type PutRequest<T = unknown> = HttpRequest<"PUT", T>;
 export type PatchRequest<T = unknown> = HttpRequest<"PATCH", T>;
 /** A DELETE request. */
 export type DeleteRequest<T = unknown> = HttpRequest<"DELETE", T>;
+/** A QUERY request (RFC 10008). */
+export type QueryRequest<T = unknown> = HttpRequest<"QUERY", T>;
 /** Any request — the v1 name for {@link HttpRequest}. */
 export type BaseRequest<T = unknown> = HttpRequest<Method, T>;
-/** Any request that may carry a body — the v1 name for `HttpRequest<"POST" | "PUT" | "PATCH" | "DELETE">`. */
+/** Any request that may carry a body — the v1 name for `HttpRequest<"POST" | "PUT" | "PATCH" | "DELETE" | "QUERY">`. */
 export type BodyRequest<T = unknown> = HttpRequest<BodyMethod, T>;
 /** Creates a GET request. `T` declares the JSON type the response is expected to have. */
 export declare const createGet: <T = unknown>(url: string) => GetRequest<T>;
@@ -839,6 +863,17 @@ export declare const createPut: <T = unknown>(url: string) => PutRequest<T>;
 export declare const createPatch: <T = unknown>(url: string) => PatchRequest<T>;
 /** Creates a DELETE request. */
 export declare const createDelete: <T = unknown>(url: string) => DeleteRequest<T>;
+/**
+ * Creates a QUERY request ([RFC 10008](https://www.rfc-editor.org/rfc/rfc10008)): a safe, idempotent read like GET
+ * whose query travels in the body, so it can be as large and as structured as needed. The server must support the
+ * method and needs a `Content-Type`, which is set for you except for binary and stream bodies (use `withContentType()`).
+ *
+ * @example
+ * ```typescript
+ * const open = await create.query<Issue[]>("https://api.example.com/issues").withBody({ state: "open", labels: ["bug"] }).getJson();
+ * ```
+ */
+export declare const createQuery: <T = unknown>(url: string) => QueryRequest<T>;
 /**
  * The entry point: one factory per HTTP method plus `api()` for configured instances.
  *
@@ -868,6 +903,8 @@ declare const create: {
   readonly delete: <T = unknown>(url: string) => DeleteRequest<T>;
   /** Alias of `delete`. */
   readonly del: <T = unknown>(url: string) => DeleteRequest<T>;
+  /** Creates a QUERY request (RFC 10008): a safe, idempotent read whose query is sent with `withBody()` — see {@link createQuery}. */
+  readonly query: <T = unknown>(url: string) => QueryRequest<T>;
   /** Creates an api instance — see {@link createApi}. */
   readonly api: typeof createApi;
 };

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", ""));
@@ -684,7 +680,8 @@ const METHODS = [
 	"POST",
 	"PUT",
 	"PATCH",
-	"DELETE"
+	"DELETE",
+	"QUERY"
 ];
 let installed = false;
 function createApi() {
@@ -711,6 +708,7 @@ const createPost = (url) => new HttpRequest("POST", url);
 const createPut = (url) => new HttpRequest("PUT", url);
 const createPatch = (url) => new HttpRequest("PATCH", url);
 const createDelete = (url) => new HttpRequest("DELETE", url);
+const createQuery = (url) => new HttpRequest("QUERY", url);
 const create = {
 	get: createGet,
 	head: createHead,
@@ -720,8 +718,9 @@ const create = {
 	patch: createPatch,
 	delete: createDelete,
 	del: createDelete,
+	query: createQuery,
 	api: createApi
 };
 
 //#endregion
-export { HttpRequest, RequestError, ResponseWrapper, createApi, createDelete, createGet, createHead, createOptions, createPatch, createPost, createPut, create as default, isRequestError };
+export { HttpRequest, RequestError, ResponseWrapper, createApi, createDelete, createGet, createHead, createOptions, createPatch, createPost, createPut, createQuery, create as default, isRequestError };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-request",
-  "version": "2.1.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,