@autometa/http 1.4.20 → 2.0.0-rc.1

package/dist/index.js

@@ -1,1054 +1,1442 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result)
-    __defProp(target, key, result);
-  return result;
-};
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet = (obj, member, value, setter) => {
-  __accessCheck(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
-var __privateMethod = (obj, member, method) => {
-  __accessCheck(obj, member, "access private method");
-  return method;
-};
+import { AutomationError } from '@autometa/errors';
+import { highlight } from 'cli-highlight';
+import { EnsureError } from '@autometa/assertions';
 
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  AnySchema: () => AnySchema,
-  AxiosClient: () => AxiosClient,
-  BooleanSchema: () => BooleanSchema,
-  EmptySchema: () => EmptySchema,
-  HTTP: () => HTTP,
-  HTTPClient: () => HTTPClient,
-  HTTPRequest: () => HTTPRequest,
-  HTTPRequestBuilder: () => HTTPRequestBuilder,
-  HTTPResponse: () => HTTPResponse,
-  HTTPResponseBuilder: () => HTTPResponseBuilder,
-  JSONSchema: () => JSONSchema,
-  NullSchema: () => NullSchema,
-  NumberSchema: () => NumberSchema,
-  StringSchema: () => StringSchema,
-  UndefinedSchema: () => UndefinedSchema,
-  defaultClient: () => defaultClient
-});
-module.exports = __toCommonJS(src_exports);
+// src/http.ts
 
-// src/http-response.ts
-var HTTPResponse = class _HTTPResponse {
-  constructor() {
-    this.headers = {};
-  }
-  static fromRaw(response) {
-    const newResponse = new _HTTPResponse();
-    Object.assign(newResponse, response);
-    return response;
-  }
-  decompose(transformFnOrVal) {
-    const value = getDecompositionValue(this.data, transformFnOrVal);
-    return new HTTPResponseBuilder().status(this.status).statusText(this.statusText).headers(this.headers).request(this.request).data(value).build();
+// src/fetch-transport.ts
+function createFetchTransport(fetchImpl = globalThis.fetch) {
+  if (!fetchImpl) {
+    throw new Error(
+      "No fetch implementation available. Provide one via createFetchTransport(fetchImpl)."
+    );
   }
-};
-function getDecompositionValue(data, transformFn) {
-  return typeof transformFn === "function" ? transformFn(data) : transformFn;
+  return {
+    async send(request, options = {}) {
+      const {
+        headers: optionHeaders,
+        body: optionBody,
+        signal: optionSignal,
+        streamResponse,
+        ...restOptions
+      } = options;
+      const headers = mergeHeaders(request.headers, optionHeaders);
+      const body = optionBody ?? createBody(request, headers);
+      const url = request.fullUrl ?? "";
+      const fetchOptions = {
+        ...restOptions,
+        method: request.method ?? "GET",
+        headers,
+        body
+      };
+      if (optionSignal !== void 0) {
+        fetchOptions.signal = optionSignal;
+      }
+      const response = await fetchImpl(url, fetchOptions);
+      const data = streamResponse ? response.body ?? null : await readBody(response);
+      return {
+        status: response.status,
+        statusText: response.statusText,
+        headers: headersToRecord(response.headers),
+        data
+      };
+    }
+  };
 }
-var _response;
-var _HTTPResponseBuilder = class _HTTPResponseBuilder {
-  constructor() {
-    __privateAdd(this, _response, new HTTPResponse());
-  }
-  static create() {
-    return new _HTTPResponseBuilder();
-  }
-  derive() {
-    return _HTTPResponseBuilder.create().data(__privateGet(this, _response).data).headers(__privateGet(this, _response).headers).request(__privateGet(this, _response).request).status(__privateGet(this, _response).status).statusText(__privateGet(this, _response).statusText);
-  }
-  status(code) {
-    __privateGet(this, _response).status = code;
-    return this;
+function mergeHeaders(base, additional) {
+  const next = { ...base };
+  if (!additional) {
+    return next;
+  }
+  for (const [key, value] of Object.entries(additional)) {
+    if (value === void 0 || value === null) {
+      delete next[key];
+    } else {
+      next[key] = String(value);
+    }
   }
-  statusText(text) {
-    __privateGet(this, _response).statusText = text;
-    return this;
+  return next;
+}
+function createBody(request, headers) {
+  const { data } = request;
+  if (data === void 0 || data === null) {
+    return void 0;
   }
-  data(data) {
-    __privateGet(this, _response).data = data;
-    return this;
+  if (isBodyInit(data)) {
+    return data;
   }
-  headers(dict) {
-    __privateGet(this, _response).headers = dict;
-    return this;
+  if (typeof data === "string") {
+    return data;
   }
-  header(name, value) {
-    __privateGet(this, _response).headers[name] = value;
-    return this;
+  if (typeof data === "object") {
+    if (!hasHeader(headers, "content-type")) {
+      headers["content-type"] = "application/json";
+    }
+    return JSON.stringify(data);
   }
-  request(request) {
-    __privateGet(this, _response).request = request;
-    return this;
+  return String(data);
+}
+async function readBody(response) {
+  if (response.status === 204 || response.status === 205) {
+    return null;
   }
-  build() {
-    return __privateGet(this, _response);
+  const text = await response.text();
+  return text.length === 0 ? null : text;
+}
+function headersToRecord(headers) {
+  const record = {};
+  headers.forEach((value, key) => {
+    record[key] = value;
+  });
+  return record;
+}
+function hasHeader(headers, name) {
+  const lower = name.toLowerCase();
+  return Object.keys(headers).some((key) => key.toLowerCase() === lower);
+}
+function isBodyInit(value) {
+  if (typeof value === "string") {
+    return true;
   }
-};
-_response = new WeakMap();
-var HTTPResponseBuilder = _HTTPResponseBuilder;
-
-// src/axios-client.ts
-var import_axios = __toESM(require("axios"), 1);
-
-// src/http-client.ts
-var defaultClient;
-var HTTPClient = class {
-  static Use(client) {
-    if (client) {
-      defaultClient = client;
-    }
-    return function(target) {
-      defaultClient = target;
-    };
+  if (typeof ArrayBuffer !== "undefined" && value instanceof ArrayBuffer) {
+    return true;
   }
-};
-
-// src/axios-client.ts
-var AxiosClient = class extends HTTPClient {
-  async request(request, options) {
-    const { baseUrl, route, params, headers, method, data } = request;
-    const url = [baseUrl, ...route].join("/");
-    const axiosRequest = {
-      url,
-      params,
-      headers,
-      method,
-      data,
-      validateStatus: function(status) {
-        return status >= 0 && status < 600;
-      },
-      ...options
-    };
-    const response = await (0, import_axios.default)(axiosRequest);
-    return HTTPResponseBuilder.create().status(response.status).statusText(response.statusText).data(response.data).headers(response.headers).request(request).build();
+  if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView(value)) {
+    return true;
   }
-};
-AxiosClient = __decorateClass([
-  HTTPClient.Use()
-], AxiosClient);
-
-// src/http.ts
-var import_injection = require("@autometa/injection");
-
-// src/default-client-factory.ts
-function defaultClientFactory() {
-  const type = defaultClient;
-  return new type();
+  return false;
 }
 
 // src/http-request.ts
-var import_url_join_ts = require("url-join-ts");
 var HTTPRequest = class _HTTPRequest {
   constructor(config) {
+    /**
+     * Normalised header collection that will be sent with the request.
+     */
     this.headers = {};
     this.params = {};
     this.route = [];
-    Object.assign(this, config);
+    this.queryOptions = {};
+    if (config) {
+      Object.assign(this, config);
+      if (config.queryOptions) {
+        this.queryOptions = { ...config.queryOptions };
+      }
+    }
   }
   /**
-   * Returns the full URL of the request, including the base url,
-   * routes, and query parameters.
-   *
-   * ```ts
-   *  console.log(request.fullUrl())// https://example.com/foo?bar=baz?array=1,2,3
-   * ```
-   *
-   * Note characters may be converted to escape codes. I.e (space => %20) and (comma => %2C)
-   *
-   * N.B this getter estimates what the url will be. The actual value
-   * might be different depending on your underlying HTTPClient and
-   * configuration. For example, query parameters might
-   * use different array formats.
+   * Full request URL derived from {@link baseUrl}, {@link route} and {@link params}.
    */
   get fullUrl() {
-    return (0, import_url_join_ts.urlJoinP)(this.baseUrl, this.route, this.params);
+    return buildFullUrl(
+      this.baseUrl,
+      this.route,
+      this.params,
+      this.queryOptions
+    );
   }
   /**
-   * Returns a new independent copy of the request.
+   * Creates a deep copy of an existing request instance.
    */
   static derive(original) {
     const request = new _HTTPRequest();
     request.headers = { ...original.headers };
-    request.params = { ...original.params };
+    request.params = cloneParams(original.params);
     request.baseUrl = original.baseUrl;
     request.route = [...original.route];
     request.method = original.method;
     request.data = original.data;
+    request.queryOptions = { ...original.queryOptions };
     return request;
   }
 };
-var _request, _dynamicHeaders, _setDynamicHeaders, setDynamicHeaders_fn;
-var _HTTPRequestBuilder = class _HTTPRequestBuilder {
+var HTTPRequestBuilder = class _HTTPRequestBuilder {
   constructor(request = () => new HTTPRequest()) {
-    __privateAdd(this, _setDynamicHeaders);
-    __privateAdd(this, _request, void 0);
-    __privateAdd(this, _dynamicHeaders, /* @__PURE__ */ new Map());
-    if (typeof request === "function") {
-      __privateSet(this, _request, request());
-      return;
-    }
-    __privateSet(this, _request, request);
+    this.dynamicHeaders = /* @__PURE__ */ new Map();
+    this.requestInstance = typeof request === "function" ? request() : request;
+    this.queryOptions = { ...this.requestInstance.queryOptions };
   }
+  /**
+   * Initializes a new builder for the default {@link HTTPRequest} type.
+   */
   static create() {
     return new _HTTPRequestBuilder();
   }
+  /**
+   * Exposes the underlying request without defensive cloning.
+   */
   get request() {
-    return __privateGet(this, _request);
+    return this.requestInstance;
   }
-  async resolveDynamicHeaders(request = __privateGet(this, _request)) {
-    for (const [name, value] of __privateGet(this, _dynamicHeaders)) {
+  /**
+   * Resolves asynchronous header factories into concrete header values on demand.
+   */
+  async resolveDynamicHeaders(request = this.requestInstance) {
+    for (const [name, factory] of this.dynamicHeaders) {
+      if (!factory) {
+        continue;
+      }
       try {
-        if (!request.headers)
-          request.headers = {};
-        request.headers[name] = String(await value());
-      } catch (e) {
-        const cause = e;
-        const msg = `Failed to resolve dynamic header "${name}": 
-${cause}`;
-        throw new Error(msg);
+        const result = await factory();
+        if (result === void 0 || result === null) {
+          delete request.headers[name];
+          continue;
+        }
+        request.headers[name] = String(result);
+      } catch (error) {
+        const cause = error;
+        throw new Error(
+          `Failed to resolve dynamic header "${name}": ${cause.message}`
+        );
       }
     }
     return this;
   }
+  /**
+   * Sets the root URL (protocol, host and optional base path).
+   */
   url(url) {
-    __privateGet(this, _request).baseUrl = url;
+    this.requestInstance.baseUrl = url;
     return this;
   }
-  route(...route) {
-    __privateGet(this, _request).route.push(...route);
+  /**
+   * Appends one or more path segments to the current request route.
+   */
+  route(...segments) {
+    const mapped = segments.map((segment) => String(segment)).filter((segment) => segment.length > 0);
+    this.requestInstance.route.push(...mapped);
     return this;
   }
+  /**
+   * Adds or removes a query parameter value.
+   */
   param(name, value) {
+    if (value === void 0) {
+      delete this.requestInstance.params[name];
+      return this;
+    }
     if (Array.isArray(value)) {
-      const asStr = value.flatMap(String);
-      __privateGet(this, _request).params[name] = asStr;
+      const list = value.filter(
+        (item) => item !== void 0 && item !== null
+      );
+      const existing = this.requestInstance.params[name];
+      if (Array.isArray(existing)) {
+        this.requestInstance.params[name] = [
+          ...existing,
+          ...list
+        ];
+      } else {
+        this.requestInstance.params[name] = list;
+      }
       return this;
     }
-    if (!Array.isArray(value) && typeof value === "object") {
-      __privateGet(this, _request).params[name] = value;
+    if (value && typeof value === "object") {
+      const dictEntries = Object.entries(
+        value
+      ).reduce((acc, [key, paramValue]) => {
+        if (paramValue !== void 0) {
+          acc[key] = paramValue;
+        }
+        return acc;
+      }, {});
+      const existing = this.requestInstance.params[name];
+      if (isPlainObject(existing)) {
+        this.requestInstance.params[name] = {
+          ...existing,
+          ...dictEntries
+        };
+      } else {
+        this.requestInstance.params[name] = dictEntries;
+      }
       return this;
     }
-    __privateGet(this, _request).params[name] = String(value);
+    this.requestInstance.params[name] = value;
     return this;
   }
+  /**
+   * Merges a dictionary of query parameters into the request.
+   */
   params(dict) {
-    Object.assign(__privateGet(this, _request).params, dict);
+    for (const [key, value] of Object.entries(dict)) {
+      this.param(key, value);
+    }
+    return this;
+  }
+  queryFormat(options) {
+    if (options.arrayFormat !== void 0) {
+      this.queryOptions.arrayFormat = options.arrayFormat;
+    }
+    if (options.objectFormat !== void 0) {
+      this.queryOptions.objectFormat = options.objectFormat;
+    }
+    if (Object.prototype.hasOwnProperty.call(options, "serializer")) {
+      const serializer = options.serializer ?? void 0;
+      if (serializer) {
+        this.queryOptions.serializer = serializer;
+      } else {
+        delete this.queryOptions.serializer;
+      }
+    }
+    this.requestInstance.queryOptions = { ...this.queryOptions };
     return this;
   }
+  /**
+   * Sets the request body payload. Passing `undefined` removes the body.
+   */
   data(data) {
-    __privateGet(this, _request).data = data;
+    if (data === void 0) {
+      delete this.requestInstance.data;
+      return this;
+    }
+    this.requestInstance.data = data;
     return this;
   }
-  header(name, value, onArray = (value2) => value2.join(",")) {
+  /**
+   * Sets a single header using direct values or a lazy factory.
+   */
+  header(name, value) {
     if (typeof value === "function") {
-      if (__privateGet(this, _request).headers[name]) {
-        delete __privateGet(this, _request).headers[name];
-      }
-      __privateGet(this, _dynamicHeaders).set(name, value);
+      this.dynamicHeaders.set(name, value);
+      delete this.requestInstance.headers[name];
       return this;
     }
-    if (__privateGet(this, _dynamicHeaders).has(name)) {
-      __privateGet(this, _dynamicHeaders).delete(name);
+    this.dynamicHeaders.delete(name);
+    if (value === void 0 || value === null) {
+      delete this.requestInstance.headers[name];
+      return this;
+    }
+    if (Array.isArray(value)) {
+      const filtered = value.filter(
+        (item) => item !== void 0 && item !== null
+      );
+      this.requestInstance.headers[name] = filtered.map(String).join(",");
+      return this;
     }
-    const val = Array.isArray(value) ? onArray(value) : String(value);
-    __privateGet(this, _request).headers[name] = val;
+    this.requestInstance.headers[name] = String(value);
     return this;
   }
+  /**
+   * Replaces or merges multiple headers in one call.
+   */
   headers(dict) {
-    Object.assign(__privateGet(this, _request).headers, dict);
+    for (const [key, value] of Object.entries(dict)) {
+      this.header(key, value);
+    }
     return this;
   }
-  get() {
-    return __privateGet(this, _request);
-  }
+  /**
+   * Stores the HTTP verb ensuring consistent casing.
+   */
   method(method) {
-    __privateGet(this, _request).method = method;
+    this.requestInstance.method = method.toUpperCase();
     return this;
   }
+  /**
+   * Returns a copy-on-write builder pointing at the same request state.
+   */
   derive() {
-    var _a;
-    const request = HTTPRequest.derive(__privateGet(this, _request));
-    return __privateMethod(_a = new _HTTPRequestBuilder(request), _setDynamicHeaders, setDynamicHeaders_fn).call(_a, __privateGet(this, _dynamicHeaders));
+    return this.clone();
   }
+  /**
+   * Produces a deep copy of the builder and the underlying request.
+   */
+  clone() {
+    const request = HTTPRequest.derive(this.requestInstance);
+    const builder = new _HTTPRequestBuilder(request);
+    builder.dynamicHeaders = new Map(this.dynamicHeaders);
+    builder.queryOptions = { ...this.queryOptions };
+    builder.requestInstance.queryOptions = { ...this.queryOptions };
+    return builder;
+  }
+  /**
+   * Returns the current request without resolving header factories.
+   */
   build() {
-    return __privateGet(this, _request);
+    this.requestInstance.queryOptions = { ...this.queryOptions };
+    return this.requestInstance;
   }
+  /**
+   * Resolves lazy headers before returning the request.
+   */
   async buildAsync() {
     await this.resolveDynamicHeaders();
-    return __privateGet(this, _request);
+    this.requestInstance.queryOptions = { ...this.queryOptions };
+    return this.requestInstance;
+  }
+};
+function cloneParams(params) {
+  return Object.entries(params).reduce((acc, [key, value]) => {
+    if (Array.isArray(value)) {
+      acc[key] = [...value];
+      return acc;
+    }
+    if (isPlainObject(value)) {
+      acc[key] = { ...value };
+      return acc;
+    }
+    acc[key] = value;
+    return acc;
+  }, {});
+}
+function buildFullUrl(baseUrl, route, params, options) {
+  const pathSegments = route.map((segment) => String(segment)).filter((segment) => segment.length > 0).map((segment) => segment.replace(/^\/+|\/+$/g, ""));
+  const query = buildQueryString(params, options);
+  if (baseUrl && /^https?:\/\//i.test(baseUrl)) {
+    const url = new URL(baseUrl);
+    if (pathSegments.length > 0) {
+      const basePath = url.pathname.replace(/^\/+|\/+$/g, "");
+      const combined = [basePath, ...pathSegments].filter(Boolean).join("/");
+      url.pathname = `/${combined}`;
+    }
+    url.search = query ? `?${query}` : "";
+    return url.toString();
+  }
+  const trimmedBase = (baseUrl ?? "").replace(/\/+$/g, "");
+  const joinedPath = pathSegments.join("/");
+  const path = [trimmedBase, joinedPath].filter((segment) => segment && segment.length > 0).join(trimmedBase && joinedPath ? "/" : "");
+  if (!path && !query) {
+    return "";
+  }
+  if (!path) {
+    return query ? `?${query}` : "";
+  }
+  return query ? `${path}?${query}` : path;
+}
+function buildQueryString(params, options) {
+  if (!params || Object.keys(params).length === 0) {
+    return "";
+  }
+  const serializer = options?.serializer ?? void 0;
+  if (serializer) {
+    return serializer(params);
+  }
+  const arrayFormat = options?.arrayFormat ?? "repeat";
+  const objectFormat = options?.objectFormat ?? "brackets";
+  const search = new URLSearchParams();
+  const append = (key, value) => {
+    if (value === void 0 || value === null) {
+      return;
+    }
+    search.append(key, String(value));
+  };
+  const encode = (key, value) => {
+    if (value === void 0 || value === null) {
+      return;
+    }
+    if (Array.isArray(value)) {
+      const filtered = value.filter(
+        (item) => item !== void 0 && item !== null
+      );
+      if (filtered.length === 0) {
+        return;
+      }
+      switch (arrayFormat) {
+        case "json": {
+          append(key, JSON.stringify(filtered));
+          return;
+        }
+        case "comma": {
+          const joined = filtered.map((item) => String(item)).join(",");
+          append(key, joined);
+          return;
+        }
+        case "indices": {
+          filtered.forEach((item, index) => {
+            encode(`${key}[${index}]`, item);
+          });
+          return;
+        }
+        case "brackets": {
+          filtered.forEach((item) => {
+            encode(`${key}[]`, item);
+          });
+          return;
+        }
+        default: {
+          filtered.forEach((item) => {
+            encode(key, item);
+          });
+          return;
+        }
+      }
+    }
+    if (isPlainObject(value)) {
+      if (objectFormat === "json") {
+        append(key, JSON.stringify(value));
+        return;
+      }
+      for (const [childKey, childValue] of Object.entries(
+        value
+      )) {
+        const nextKey = objectFormat === "dot" ? `${key}.${childKey}` : `${key}[${childKey}]`;
+        encode(nextKey, childValue);
+      }
+      return;
+    }
+    append(key, value);
+  };
+  for (const [key, value] of Object.entries(params)) {
+    encode(key, value);
+  }
+  return search.toString();
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+
+// src/http-response.ts
+var HTTPResponse = class _HTTPResponse {
+  constructor() {
+    /**
+     * Human-readable text accompanying {@link status}.
+     */
+    this.statusText = "";
+    /**
+     * Normalised response headers keyed by lowercase header names.
+     */
+    this.headers = {};
+  }
+  /**
+   * Creates a shallow clone from an existing response instance.
+   */
+  static fromRaw(response) {
+    const next = new _HTTPResponse();
+    next.status = response.status;
+    next.statusText = response.statusText;
+    next.data = response.data;
+    next.headers = { ...response.headers };
+    next.request = response.request;
+    return next;
+  }
+  /**
+   * Returns a new response with identical metadata but a transformed payload.
+   *
+   * @example
+   * const productResponse = await http.route("products", 1).get<Product>()
+   * const simplified = productResponse.mapData((product) => product.name)
+   */
+  mapData(transform) {
+    const nextValue = typeof transform === "function" ? transform(this.data) : transform;
+    return new HTTPResponseBuilder().status(this.status).statusText(this.statusText).headers(this.headers).request(this.request).data(nextValue).build();
   }
 };
-_request = new WeakMap();
-_dynamicHeaders = new WeakMap();
-_setDynamicHeaders = new WeakSet();
-setDynamicHeaders_fn = function(headers) {
-  __privateSet(this, _dynamicHeaders, new Map(headers));
-  return this;
+var HTTPResponseBuilder = class _HTTPResponseBuilder {
+  constructor() {
+    this.response = new HTTPResponse();
+  }
+  /**
+   * Creates a new empty builder.
+   */
+  static create() {
+    return new _HTTPResponseBuilder();
+  }
+  /**
+   * Produces a new builder seeded with the current response state.
+   */
+  derive() {
+    return _HTTPResponseBuilder.create().status(this.response.status).statusText(this.response.statusText).headers({ ...this.response.headers }).request(this.response.request).data(this.response.data);
+  }
+  /**
+   * Sets the response status code.
+   */
+  status(code) {
+    this.response.status = code;
+    return this;
+  }
+  /**
+   * Sets the textual status message.
+   */
+  statusText(text) {
+    this.response.statusText = text;
+    return this;
+  }
+  /**
+   * Attaches the response payload.
+   */
+  data(data) {
+    this.response.data = data;
+    return this;
+  }
+  /**
+   * Replaces the entire headers collection.
+   */
+  headers(dict) {
+    this.response.headers = { ...dict };
+    return this;
+  }
+  /**
+   * Sets or overrides a single response header.
+   */
+  header(name, value) {
+    this.response.headers[name] = value;
+    return this;
+  }
+  /**
+   * References the originating request.
+   */
+  request(request) {
+    this.response.request = request;
+    return this;
+  }
+  /**
+   * Builds the immutable {@link HTTPResponse} instance.
+   */
+  build() {
+    return this.response;
+  }
 };
-var HTTPRequestBuilder = _HTTPRequestBuilder;
 
 // src/schema.map.ts
-var _map;
-var _SchemaMap = class _SchemaMap {
+var SchemaMap = class _SchemaMap {
   constructor(map) {
-    __privateAdd(this, _map, void 0);
     if (map instanceof _SchemaMap) {
-      __privateSet(this, _map, new Map(__privateGet(map, _map)));
+      this.map = new Map(map.map);
       return;
     }
-    __privateSet(this, _map, new Map(map));
+    this.map = map ? new Map(map) : /* @__PURE__ */ new Map();
   }
   derive() {
-    return new _SchemaMap(__privateGet(this, _map));
+    return new _SchemaMap(this.map);
   }
   registerStatus(parser, ...codes) {
     codes.forEach((code) => {
-      if (__privateGet(this, _map).has(code)) {
-        const msg = `Status code ${code} is already registered with a parser`;
-        throw new Error(msg);
-      }
-      __privateGet(this, _map).set(code, parser);
+      this.map.set(code, parser);
     });
   }
   registerRange(parser, from, to) {
-    for (let i = from; i <= to; i++) {
-      if (__privateGet(this, _map).has(i)) {
-        throw new Error(`Status code ${i} is already registered with a parser`);
-      }
-      __privateGet(this, _map).set(i, parser);
+    for (let code = from; code <= to; code++) {
+      this.map.set(code, parser);
     }
   }
   validate(status, data, requireSchema) {
     const parser = this.getParser(status, requireSchema);
+    if (!parser) {
+      return data;
+    }
+    if (typeof parser === "function") {
+      return parser(data);
+    }
     if ("parse" in parser) {
       return parser.parse(data);
     }
     if ("validate" in parser) {
       return parser.validate(data);
     }
-    try {
-      return parser(data);
-    } catch (e) {
-      const msg = `Failed to schema parse response data for status code ${status} with data:
-      
-${JSON.stringify(data, null, 2)}}`;
-      throw new Error(msg);
-    }
+    return data;
   }
   getParser(status, requireSchema) {
-    const parser = __privateGet(this, _map).get(status);
+    const parser = this.map.get(status);
     if (!parser && requireSchema) {
-      const msg = `No parser registered for status code ${status} but 'requireSchema' is true`;
-      throw new Error(msg);
+      throw new Error(
+        `No schema parser registered for status code ${status} while requireSchema is true.`
+      );
     }
-    if (parser) {
-      return parser;
-    }
-    return (data) => data;
+    return parser ?? null;
   }
   toObject() {
-    return Object.fromEntries(__privateGet(this, _map));
+    return Object.fromEntries(this.map);
   }
 };
-_map = new WeakMap();
-var SchemaMap = _SchemaMap;
 
 // src/request-meta.config.ts
 var MetaConfig = class {
-  constructor() {
+  constructor(init) {
+    this.schemas = new SchemaMap();
+    this.requireSchema = false;
+    this.allowPlainText = false;
     this.onSend = [];
     this.onReceive = [];
+    this.throwOnServerError = false;
     this.options = {};
+    this.streamResponse = false;
+    this.timeoutMs = void 0;
+    Object.assign(this, init);
   }
 };
-var _schemaMap, _requireSchema, _allowPlainText, _onBeforeSend, _onAfterSend, _throwOnServerError, _options, _setOnSend, setOnSend_fn, _setOnReceive, setOnReceive_fn;
-var _MetaConfigBuilder = class _MetaConfigBuilder {
+var MetaConfigBuilder = class _MetaConfigBuilder {
   constructor() {
-    __privateAdd(this, _setOnSend);
-    __privateAdd(this, _setOnReceive);
-    __privateAdd(this, _schemaMap, new SchemaMap());
-    __privateAdd(this, _requireSchema, false);
-    __privateAdd(this, _allowPlainText, false);
-    __privateAdd(this, _onBeforeSend, []);
-    __privateAdd(this, _onAfterSend, []);
-    __privateAdd(this, _throwOnServerError, false);
-    __privateAdd(this, _options, {});
-  }
-  options(options) {
-    __privateSet(this, _options, { ...options });
+    this.schemaMapValue = new SchemaMap();
+    this.requireSchemaValue = false;
+    this.allowPlainTextValue = false;
+    this.onBeforeSendHooks = [];
+    this.onAfterReceiveHooks = [];
+    this.throwOnServerErrorValue = false;
+    this.optionsValue = {};
+    this.streamResponseValue = false;
+  }
+  merge(builder) {
+    this.schemaMapValue = builder.schemaMapValue.derive();
+    this.requireSchemaValue = builder.requireSchemaValue;
+    this.allowPlainTextValue = builder.allowPlainTextValue;
+    this.onBeforeSendHooks = [...builder.onBeforeSendHooks];
+    this.onAfterReceiveHooks = [...builder.onAfterReceiveHooks];
+    this.throwOnServerErrorValue = builder.throwOnServerErrorValue;
+    this.optionsValue = { ...builder.optionsValue };
+    this.retryOptionsValue = builder.retryOptionsValue ? { ...builder.retryOptionsValue } : void 0;
+    this.streamResponseValue = builder.streamResponseValue;
+    this.timeoutMsValue = builder.timeoutMsValue;
     return this;
   }
   schemaMap(map) {
-    __privateSet(this, _schemaMap, map);
+    this.schemaMapValue = map;
     return this;
   }
   schema(parser, ...args) {
     args.forEach((arg) => {
       if (typeof arg === "number") {
-        __privateGet(this, _schemaMap).registerStatus(parser, arg);
-      } else if (Array.isArray(arg)) {
-        __privateGet(this, _schemaMap).registerStatus(parser, ...arg);
-      } else {
-        __privateGet(this, _schemaMap).registerRange(parser, arg.from, arg.to);
+        this.schemaMapValue.registerStatus(parser, arg);
+        return;
+      }
+      if (Array.isArray(arg)) {
+        this.schemaMapValue.registerStatus(parser, ...arg);
+        return;
       }
+      this.schemaMapValue.registerRange(parser, arg.from, arg.to);
     });
     return this;
   }
   requireSchema(value) {
-    __privateSet(this, _requireSchema, value);
+    this.requireSchemaValue = value;
     return this;
   }
   allowPlainText(value) {
-    __privateSet(this, _allowPlainText, value);
+    this.allowPlainTextValue = value;
     return this;
   }
   onBeforeSend(description, hook) {
-    __privateGet(this, _onBeforeSend).push([description, hook]);
+    this.onBeforeSendHooks.push([description, hook]);
+    return this;
+  }
+  onReceiveResponse(description, hook) {
+    this.onAfterReceiveHooks.push([description, hook]);
     return this;
   }
   throwOnServerError(value) {
-    __privateSet(this, _throwOnServerError, value);
+    this.throwOnServerErrorValue = value;
     return this;
   }
-  onReceiveResponse(description, hook) {
-    __privateGet(this, _onAfterSend).push([description, hook]);
+  options(options) {
+    this.optionsValue = mergeOptions(this.optionsValue, options);
     return this;
   }
-  build() {
-    const config = new MetaConfig();
-    config.schemas = __privateGet(this, _schemaMap).derive();
-    config.requireSchema = __privateGet(this, _requireSchema);
-    config.allowPlainText = __privateGet(this, _allowPlainText);
-    config.onSend = __privateGet(this, _onBeforeSend);
-    config.onReceive = __privateGet(this, _onAfterSend);
-    config.options = __privateGet(this, _options);
-    config.throwOnServerError = __privateGet(this, _throwOnServerError);
-    return config;
+  retry(options) {
+    this.retryOptionsValue = options ? { ...options } : void 0;
+    return this;
   }
-  derive() {
-    var _a, _b;
-    return __privateMethod(_b = __privateMethod(_a = new _MetaConfigBuilder().schemaMap(__privateGet(this, _schemaMap).derive()).requireSchema(__privateGet(this, _requireSchema)).allowPlainText(__privateGet(this, _allowPlainText)).throwOnServerError(__privateGet(this, _throwOnServerError)).options(__privateGet(this, _options)), _setOnSend, setOnSend_fn).call(_a, __privateGet(this, _onBeforeSend)), _setOnReceive, setOnReceive_fn).call(_b, __privateGet(this, _onAfterSend));
+  streamResponse(value) {
+    this.streamResponseValue = value;
+    return this;
   }
-};
-_schemaMap = new WeakMap();
-_requireSchema = new WeakMap();
-_allowPlainText = new WeakMap();
-_onBeforeSend = new WeakMap();
-_onAfterSend = new WeakMap();
-_throwOnServerError = new WeakMap();
-_options = new WeakMap();
-_setOnSend = new WeakSet();
-setOnSend_fn = function(hooks) {
-  __privateSet(this, _onBeforeSend, [...hooks]);
-  return this;
-};
-_setOnReceive = new WeakSet();
-setOnReceive_fn = function(hooks) {
-  __privateSet(this, _onAfterSend, [...hooks]);
-  return this;
-};
-var MetaConfigBuilder = _MetaConfigBuilder;
-
-// src/transform-response.ts
-var import_errors = require("@autometa/errors");
-var import_assert_is_json = __toESM(require("@stdlib/assert-is-json"), 1);
-var import_cli_highlight = require("cli-highlight");
-function transformResponse(allowPlainText, data) {
-  if (data === null) {
-    return null;
+  timeout(duration) {
+    if (typeof duration === "number" && duration > 0) {
+      this.timeoutMsValue = duration;
+    } else {
+      this.timeoutMsValue = void 0;
+    }
+    return this;
   }
-  if (data === void 0) {
-    return void 0;
+  build() {
+    const retry = this.retryOptionsValue ? { ...this.retryOptionsValue } : void 0;
+    return new MetaConfig({
+      schemas: this.schemaMapValue.derive(),
+      requireSchema: this.requireSchemaValue,
+      allowPlainText: this.allowPlainTextValue,
+      onSend: [...this.onBeforeSendHooks],
+      onReceive: [...this.onAfterReceiveHooks],
+      options: { ...this.optionsValue },
+      throwOnServerError: this.throwOnServerErrorValue,
+      ...retry ? { retry } : {},
+      streamResponse: this.streamResponseValue,
+      timeoutMs: this.timeoutMsValue
+    });
   }
-  if (data === "") {
-    return data;
+  derive() {
+    return new _MetaConfigBuilder().schemaMap(this.schemaMapValue.derive()).requireSchema(this.requireSchemaValue).allowPlainText(this.allowPlainTextValue).throwOnServerError(this.throwOnServerErrorValue).options(this.optionsValue).retry(this.retryOptionsValue ?? null).streamResponse(this.streamResponseValue).timeout(this.timeoutMsValue).setOnBeforeSend(this.onBeforeSendHooks).setOnAfterReceive(this.onAfterReceiveHooks);
   }
-  if ((0, import_assert_is_json.default)(data)) {
-    return JSON.parse(data);
+  setOnBeforeSend(hooks) {
+    this.onBeforeSendHooks = [...hooks];
+    return this;
   }
-  if (typeof data === "string" && ["true", "false"].includes(data)) {
-    return JSON.parse(data);
+  setOnAfterReceive(hooks) {
+    this.onAfterReceiveHooks = [...hooks];
+    return this;
   }
-  if (typeof data === "string" && /^\d*\.?\d+$/.test(data)) {
-    return JSON.parse(data);
+};
+function mergeOptions(target, updates) {
+  const next = { ...target };
+  for (const [key, value] of Object.entries(updates)) {
+    if (value === void 0) {
+      delete next[key];
+    } else {
+      next[key] = value;
+    }
+  }
+  return next;
+}
+function transformResponse(allowPlainText, data) {
+  if (data === null || data === void 0) {
+    return data;
+  }
+  if (typeof data === "string") {
+    const trimmed = data.trim();
+    if (trimmed.length === 0) {
+      return void 0;
+    }
+    if (trimmed.toLowerCase() === "undefined") {
+      return void 0;
+    }
+  }
+  const primitive = normalizePrimitive(data);
+  if (primitive !== void 0) {
+    return primitive;
   }
   if (typeof data === "object") {
     return data;
   }
   if (allowPlainText) {
-    return data;
+    return String(data);
   }
-  const dataStr = typeof data === "string" ? data : JSON.stringify(data);
-  const response = (0, import_cli_highlight.highlight)(dataStr, { language: "html" });
+  const rendered = typeof data === "string" ? data : String(data);
   const message = [
-    `Could not parse a response as json, and this request was not configured to allow plain text responses.`,
-    `To allow plain text responses, use the 'allowPlainText' method on the HTTP client.`,
+    "Could not parse response as JSON and plain text responses are disabled.",
+    "Call 'allowPlainText(true)' or 'sharedAllowPlainText(true)' to permit plain text responses.",
     "",
-    response
-  ];
-  throw new import_errors.AutomationError(message.join("\n"));
+    highlight(rendered, { language: "html" })
+  ].join("\n");
+  throw new AutomationError(message);
+}
+function normalizePrimitive(data) {
+  if (typeof data === "string") {
+    const parsed = tryParseJson(data);
+    if (parsed !== void 0) {
+      return parsed;
+    }
+    const lowered = data.toLowerCase();
+    if (lowered === "true" || lowered === "false") {
+      return lowered === "true";
+    }
+    if (/^(?:\d+|\d*\.\d+)$/.test(data)) {
+      return Number(data);
+    }
+    return void 0;
+  }
+  if (isArrayBufferLike(data)) {
+    const text = bufferToString(data);
+    return normalizePrimitive(text) ?? text;
+  }
+  if (typeof data === "boolean" || typeof data === "number") {
+    return data;
+  }
+  return void 0;
+}
+function tryParseJson(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+function isArrayBufferLike(value) {
+  return typeof ArrayBuffer !== "undefined" && value instanceof ArrayBuffer || typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView(value);
+}
+function bufferToString(value) {
+  const view = value instanceof ArrayBuffer ? new Uint8Array(value) : new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  if (typeof TextDecoder !== "undefined") {
+    return new TextDecoder().decode(view);
+  }
+  let output = "";
+  for (let i = 0; i < view.length; i++) {
+    const code = view[i];
+    if (code === void 0) {
+      continue;
+    }
+    output += String.fromCharCode(code);
+  }
+  return output;
 }
 
 // src/http.ts
-var import_errors2 = require("@autometa/errors");
-var _request2, _metaConfig, _makeRequest, makeRequest_fn, _validateResponse, validateResponse_fn;
-var HTTP = class {
-  constructor(client = defaultClientFactory(), builder = new HTTPRequestBuilder(), metaConfig = new MetaConfigBuilder()) {
-    this.client = client;
-    __privateAdd(this, _makeRequest);
-    __privateAdd(this, _validateResponse);
-    __privateAdd(this, _request2, void 0);
-    __privateAdd(this, _metaConfig, void 0);
-    __privateSet(this, _request2, builder);
-    __privateSet(this, _metaConfig, metaConfig.derive());
-  }
-  static create(client = new AxiosClient(), builder = new HTTPRequestBuilder(), metaConfig = new MetaConfigBuilder()) {
-    const derived = new HTTP(client, builder, metaConfig);
-    return derived;
-  }
-  /**
-   * Sets the base url of the request for this client, such as
-   * `https://api.example.com`, and could include always-used routes like
-   * the api version, such as `/v1` or `/api/v1` at the end.
-   *
-   * ```ts
-   *
-   * \@Fixture(INJECTION_SCOPE.TRANSIENT)
-   * export abstract class BaseClient {
-   *   constructor(protected readonly http: HTTP) {
-   *      this.http.url("https://api.example.com");
-   *   }
-   * }
-   * ```
-   * @param url
-   * @returns
+var HTTPError = class extends AutomationError {
+  constructor(message, request, response, cause) {
+    super(message, {
+      cause: cause instanceof Error ? cause : void 0
+    });
+    this.request = request;
+    this.response = response;
+    this.originalError = cause;
+    this.name = this.constructor.name;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var HTTPTransportError = class extends HTTPError {
+  constructor(request, cause) {
+    super("Failed to execute HTTP request", request, void 0, cause);
+    this.name = "HTTPTransportError";
+  }
+};
+var HTTPSchemaValidationError = class extends HTTPError {
+  constructor(request, response, cause) {
+    super("Response schema validation failed", request, response, cause);
+    this.name = "HTTPSchemaValidationError";
+  }
+};
+var HTTPServerError = class extends HTTPError {
+  constructor(request, response) {
+    super(`Server responded with status ${response.status}`, request, response);
+    this.name = "HTTPServerError";
+  }
+};
+var _HTTP = class _HTTP {
+  constructor(transport, builder, meta, sharedPlugins, scopedPlugins) {
+    this.transport = transport;
+    this.builder = builder;
+    this.meta = meta;
+    this.sharedPlugins = sharedPlugins;
+    this.scopedPlugins = scopedPlugins;
+  }
+  /**
+   * Factory helper that prepares an {@link HTTP} instance with shared state.
+   */
+  static create(options = {}) {
+    const transport = options.transport ?? createFetchTransport();
+    const plugins = [..._HTTP.sharedPlugins, ...options.plugins ?? []];
+    return new _HTTP(
+      transport,
+      HTTPRequestBuilder.create(),
+      new MetaConfigBuilder(),
+      plugins,
+      []
+    );
+  }
+  /**
+   * Registers a plugin applied to every client created via {@link HTTP.create}.
+   */
+  static registerSharedPlugin(plugin) {
+    this.sharedPlugins = [...this.sharedPlugins, plugin];
+  }
+  /**
+   * Replaces the shared plugin registry used by {@link HTTP.create}.
+   */
+  static setSharedPlugins(plugins) {
+    this.sharedPlugins = [...plugins];
+  }
+  /**
+   * Returns a copy of the currently registered shared plugins.
+   */
+  static getSharedPlugins() {
+    return [...this.sharedPlugins];
+  }
+  /**
+   * Registers a plugin that runs for every request executed by this instance and its clones.
+   */
+  use(plugin) {
+    this.sharedPlugins.push(plugin);
+    return this;
+  }
+  /**
+   * Returns a scoped clone with an additional plugin applied only to that clone.
+   */
+  plugin(plugin) {
+    return this.derive(({ plugins }) => {
+      plugins.push(plugin);
+    });
+  }
+  /**
+   * Mutates the current instance to use a different transport implementation.
+   */
+  useTransport(transport) {
+    this.transport = transport;
+    return this;
+  }
+  /**
+   * Produces a new client with an alternate transport without changing the original instance.
+   */
+  withTransport(transport) {
+    return this.derive(void 0, { transport });
+  }
+  /**
+   * Sets the base URL shared by subsequent requests.
    */
   url(url) {
-    __privateGet(this, _request2).url(url);
+    this.builder.url(url);
     return this;
   }
+  /**
+   * Applies additional transport specific options to every request executed by this instance.
+   */
   sharedOptions(options) {
-    __privateGet(this, _metaConfig).options(options);
+    this.meta.options(options);
     return this;
   }
   /**
-   * If set to true, all requests derived from this client will require a schema be defined
-   * matching any response status code. If set to false, a schema will still be used for validation
-   * if defined, or the unadulterated original body will be returned if no schema matches.
-   *
-   * @param required Whether or not a schema is required for all responses.
-   * @returns This instance of HTTP.
+   * Returns a derived client with extra transport options applied only to that clone.
    */
-  requireSchema(required) {
-    __privateGet(this, _metaConfig).requireSchema(required);
+  withOptions(options) {
+    return this.derive(({ meta }) => {
+      meta.options(options);
+    });
+  }
+  /**
+   * Registers an {@link AbortSignal} that will be forwarded to every request issued by this instance.
+   */
+  sharedAbortSignal(signal) {
+    this.meta.options({ signal: signal ?? void 0 });
     return this;
   }
   /**
-   * If set to true, all requests derived from this client will allow plain text
-   * responses. If set to false, plain text responses will throw an serialization error.
-   *
-   * Useful when an endpoint returns a HTML or plain text response. If the plain text
-   * is the value of `true` or `false`, or a number, it will be parsed into the
-   * appropriate type.
-   *
-   * This method is a shared chain method, and will return the same instance of HTTP.
-   *
-   * @param allow Whether or not plain text responses are allowed.
-   * @returns This instance of HTTP.
+   * Returns a derived client configured with the provided {@link AbortSignal}.
    */
-  sharedAllowPlainText(allow) {
-    __privateGet(this, _metaConfig).allowPlainText(allow);
+  abortSignal(signal) {
+    return this.derive(({ meta }) => {
+      meta.options({ signal: signal ?? void 0 });
+    });
+  }
+  /**
+   * Configures automatic retries for this instance and all derived clients.
+   */
+  sharedRetry(options) {
+    this.meta.retry(options);
     return this;
   }
   /**
-   * If set to true, all requests derived from this client will allow plain text
-   * responses. If set to false, plain text responses will throw an serialization error.
-   *
-   * Useful when an endpoint returns a HTML or plain text response. If the plain text
-   * is the value of `true` or `false`, or a number, it will be parsed into the
-   * appropriate type.
-   *
-   * This method is a request chain method, and will return a new instance of HTTP.
-   *
-   * @param allow Whether or not plain text responses are allowed.
-   * @returns A new child instance of HTTP derived from this one.
+   * Returns a derived client with custom retry behaviour.
    */
-  allowPlainText(allow) {
-    return HTTP.create(
-      this.client,
-      __privateGet(this, _request2).derive(),
-      __privateGet(this, _metaConfig).derive().allowPlainText(allow)
-    );
+  retry(options) {
+    return this.derive(({ meta }) => {
+      meta.retry(options);
+    });
   }
   /**
-   * Attaches a route to the request, such as `/product` or `/user`. Subsequent calls
-   * to this method will append the route to the existing route, such as `/product/1`.
-   *
-   * Numbers will be converted to strings automatically. Routes can be defined one
-   * at a time or as a spread argument.
-   *
-   * ```ts
-   * constructor(http: HTTP) {
-   *   super(http);
-   *   this.http.sharedRoute("user", id).get();
-   * }
-   *
-   * // or
-   *
-   * constructor(http: HTTP) {
-   *   super(http);
-   *   this.http
-   *       .sharedRoute("user")
-   *       .sharedRoute(id)
-   *       .get();
-   * }
-   * ```
-   *
-   * This method is a shared chain method, and will return the same instance of HTTP. All
-   * child clients will inherit the routes defined by this method. Useful to configure
-   * in the constructor body.
-   *
-   * @param route A route or spread list of routes to append to the request.
-   * @returns This instance of HTTP.
+   * Forces subsequent requests to return raw response streams without parsing.
    */
-  sharedRoute(...route) {
-    __privateGet(this, _request2).route(...route.map((r) => r.toString()));
+  sharedStreamResponse(enabled) {
+    this.meta.streamResponse(enabled);
     return this;
   }
   /**
-   * Attaches a route to the request, such as `/product` or `/user`. Subsequent calls
-   * to this method will append the route to the existing route, such as `/product/1`.
-   *
-   * Numbers will be converted to strings automatically. Routes can be defined one
-   * at a time or as a spread argument.
-   *
-   * ```ts
-   * getUser(id: number) {
-   *   return this.http.route("user", id).get();
-   * }
-   *
-   * // or
-   *
-   * getUser(id: number) {
-   *  return this.http
-   *            .route("user")
-   *            .route(id)
-   *            .get();
-   * }
-   * ```
-   *
-   * This method is a request chain method, and will return a new instance of HTTP, inheriting
-   * any routes previously defined and appending the new route. Useful to configure
-   * in class methods as part of finalizing a request.
-   *
-   * @param route A route or spread list of routes to append to the request.
-   * @returns A new child instance of HTTP derived from this one.
-   */
-  route(...route) {
-    const mapped = route.map((r) => String(r));
-    return HTTP.create(
-      this.client,
-      __privateGet(this, _request2).derive().route(...mapped),
-      __privateGet(this, _metaConfig).derive()
-    );
+   * Returns a derived client configured for streaming responses.
+   */
+  streamResponse(enabled) {
+    return this.derive(({ meta }) => {
+      meta.streamResponse(enabled);
+    });
   }
-  sharedSchema(parser, ...args) {
-    __privateGet(this, _metaConfig).schema(parser, ...args);
+  /**
+   * Convenience helper that returns a clone configured for streaming responses.
+   */
+  asStream() {
+    return this.streamResponse(true);
+  }
+  /**
+   * Executes a GET request while preserving the raw response stream.
+   */
+  stream(options) {
+    return this.streamResponse(true).get(options);
+  }
+  /**
+   * Sets a shared timeout (in milliseconds) applied to every request from this instance.
+   */
+  sharedTimeout(duration) {
+    this.meta.timeout(duration);
     return this;
   }
-  schema(parser, ...args) {
-    return HTTP.create(
-      this.client,
-      __privateGet(this, _request2).derive(),
-      __privateGet(this, _metaConfig).derive().schema(parser, ...args)
-    );
+  /**
+   * Returns a derived client with a per-request timeout in milliseconds.
+   */
+  timeout(duration) {
+    return this.derive(({ meta }) => {
+      meta.timeout(duration);
+    });
   }
-  sharedParam(name, value) {
-    __privateGet(this, _request2).param(name, value);
+  /**
+   * Configures whether schema validation is required before resolving a response.
+   */
+  requireSchema(required) {
+    this.meta.requireSchema(required);
     return this;
   }
   /**
-   * `onSend` is a pre-request hook which will be executed in order of definition
-   * immediately before the request is sent. This hook can be used to analyze or
-   * log the request state.
-   *
-   * ```ts
-   *
-   * \@Fixture(INJECTION_SCOPE.TRANSIENT)
-   * export class UserController extends BaseController {
-   *  constructor(private readonly http: HTTP) {
-   *     super(http);
-   *     this.http
-   *         .sharedRoute("user")
-   *         .sharedOnSend("log request",
-   *                       (request) => console.log(JSON.stringify(request, null, 2))
-   *     );
-   *  }
-   * }
-   * ```
-   *
-   * This method is a shared chain method, and will return the same instance of HTTP. All
-   * child clients will inherit the onSend hooks defined by this method. Useful to configure
-   * in the constructor body.
-   *
-   * @param description A description of the hook, used for debugging.
-   * @param hook The hook to execute.
-   * @returns This instance of HTTP.
+   * Returns a clone with overridden plain text handling mode.
    */
-  sharedOnSend(description, hook) {
-    __privateGet(this, _metaConfig).onBeforeSend(description, hook);
+  allowPlainText(allow) {
+    return this.derive(({ meta }) => {
+      meta.allowPlainText(allow);
+    });
+  }
+  /**
+   * Sets plain text handling for the current instance and all future requests.
+   */
+  sharedAllowPlainText(allow) {
+    this.meta.allowPlainText(allow);
     return this;
   }
   /**
-   * `onReceive` is a post-request hook which will be executed in order of definition
-   * immediately after the response is received. This hook can be used to analyze or
-   * log the response state.
-   *
-   * ```ts
-   *
-   * \@Fixture(INJECTION_SCOPE.TRANSIENT)
-   * export class UserController extends BaseController {
-   *  constructor(private readonly http: HTTP) {
-   *     super(http);
-   *     this.http
-   *         .sharedRoute("user")
-   *         .sharedOnReceive("log response",
-   *                          (response) => console.log(JSON.stringify(response, null, 2))
-   *     );
-   *  }
-   * }
-   * ```
-   *
-   * This method is a shared chain method, and will return the same instance of HTTP. All
-   * child clients will inherit the onReceive hooks defined by this method. Useful to configure
-   * in the constructor body.
-   *
-   * @param description A description of the hook, used for debugging.
-   * @param hook The hook to execute.
-   * @returns This instance of HTTP.
+   * Adds path segments that will be included in every request.
    */
-  sharedOnReceive(description, hook) {
-    __privateGet(this, _metaConfig).onReceiveResponse(description, hook);
+  sharedRoute(...segments) {
+    this.builder.route(...segments);
     return this;
   }
   /**
-   * Attaches a query string parameter object to the request. Query string
-   * parameters are key-value pairs which are appended to the request url, such as
-   * `https://api.example.com?name=John&age=30`.
-   *
-   * This method is a shared chain method, and will return the same instance of HTTP. All
-   * child clients will inherit the query string parameters defined by this method. Useful to configure
-   * in the constructor body.
+   * Executes a request using the provided method.
    *
-   * ```ts
-   * constructor(http: HTTP) {
-   *    super(http);
-   *    this.http
-   *        .sharedParams({ 'is-test': "true" })
-   * ```
-   * @param name The name of the query string parameter.
-   * @param value The value of the query string parameter.
-   * @returns This instance of HTTP.
+   * Use this when the verb is dynamic (e.g. provided by a parameter). It
+   * behaves like calling {@link get}/{@link post}/{@link patch}, respecting any
+   * route/headers/body configured earlier in the chain.
    */
-  sharedParams(dict) {
-    __privateGet(this, _request2).params(dict);
+  fetchWith(method, options) {
+    const normalized = String(method).trim().toUpperCase();
+    return this.execute(normalized, options);
+  }
+  /**
+   * Returns a clone with additional path segments.
+   */
+  route(...segments) {
+    return this.derive(({ builder }) => {
+      builder.route(...segments);
+    });
+  }
+  /**
+   * Applies query serialization preferences to all future requests originating from this instance.
+   */
+  sharedQueryFormat(options) {
+    this.builder.queryFormat(options);
     return this;
   }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  param(name, ...value) {
-    return HTTP.create(
-      this.client,
-      __privateGet(this, _request2).derive().param(name, value),
-      __privateGet(this, _metaConfig).derive()
-    );
+  /**
+   * Returns a derived client with custom query serialization that does not affect the source instance.
+   */
+  queryFormat(options) {
+    return this.derive(({ builder }) => {
+      builder.queryFormat(options);
+    });
+  }
+  sharedSchema(parser, ...args) {
+    this.meta.schema(parser, ...args);
+    return this;
+  }
+  schema(parser, ...args) {
+    return this.derive(({ meta }) => {
+      meta.schema(parser, ...args);
+    });
+  }
+  sharedParam(name, value, ...rest) {
+    this.builder.param(name, toParamValue(value, rest));
+    return this;
+  }
+  param(name, value, ...rest) {
+    return this.derive(({ builder }) => {
+      builder.param(name, toParamValue(value, rest));
+    });
   }
   /**
-   * Attaches a query string parameter object to the request. Query string
-   * parameters are key-value pairs which are appended to the request url, such as
-   * `https://api.example.com?name=John&age=30`.
-   *
-   * This method is a shared chain method, and will return the same instance of HTTP. All
-   * child clients will inherit the query string parameters defined by this method. Useful to configure
-   * in the constructor body.
-   *
-   * ```ts
-   * getUser(id: number) {
-   *   return this.http
-   *             .route(id)
-   *             .param({ name: "John", age: "30" })
-   *
-   * @param name The name of the query string parameter.
-   * @param value The value of the query string parameter.
-   * @returns This instance of HTTP.
+   * Merges multiple shared query parameters into the instance.
+   */
+  sharedParams(dict) {
+    this.builder.params(dict);
+    return this;
+  }
+  /**
+   * Derives a client with additional query parameters applied together.
    */
   params(dict) {
-    return HTTP.create(
-      this.client,
-      __privateGet(this, _request2).derive().params(dict),
-      __privateGet(this, _metaConfig).derive()
-    );
+    return this.derive(({ builder }) => {
+      builder.params(dict);
+    });
   }
   /**
-   * Attaches a shared data payload to this client. The data payload is the body of the request,
-   * and can be any type. If the data payload is an object, it will be serialized to JSON.
-   *
-   * This method is a shared chain method, and will return the same instance of HTTP. All
-   * child clients will inherit the data payload defined by this method. Useful to configure
-   * in the constructor body.
-   *
-   * @param data The data payload to attach to the request.
-   * @returns This instance of HTTP.
+   * Sets a shared request body used by every request from this instance.
    */
   sharedData(data) {
-    __privateGet(this, _request2).data(data);
+    this.builder.data(data);
     return this;
   }
   /**
-   * Attaches a shared header to this client. Headers are string:string key-value pairs which are
-   * sent with the request, such as `Content-Type: application/json`.
-   *
-   * Numbers, Booleans and Null will be converted to string values automatically.
-   *
-   * A Factory function can also be provided to generate the header value at the time of request.
-   *
-   * This method is a shared chain method, and will return the same instance of HTTP. All
-   * child clients will inherit the header defined by this method. Useful to configure
-   * in the constructor body.
-   *
-   * @param name The name of the header.
-   * @param value The value of the header.
+   * Derives a client with a one-off request body.
+   */
+  data(data) {
+    return this.derive(({ builder }) => {
+      builder.data(data);
+    });
+  }
+  /**
+   * Registers a header that will be resolved for every request on this instance.
    */
   sharedHeader(name, value) {
-    __privateGet(this, _request2).header(name, value);
+    this.builder.header(name, value);
     return this;
   }
+  /**
+   * Returns a clone with a header applied only to the resulting client.
+   */
   header(name, value) {
-    return HTTP.create(
-      this.client,
-      __privateGet(this, _request2).derive().header(name, value),
-      __privateGet(this, _metaConfig).derive()
-    );
+    return this.derive(({ builder }) => {
+      builder.header(name, value);
+    });
   }
   /**
-   * Attaches a data payload to this request. The data payload is the body of the request,
-   * and can be any type. If the data payload is an object, it will be serialized to JSON.
-   *
-   * This method is a request chain method, and will return a new instance of HTTP, inheriting
-   * any data payload previously defined and appending the new payload. Useful to configure
-   * in class methods as part of finalizing a request.
-   *
-   * @param data The data payload to attach to the request.
-   * @returns A new child instance of HTTP derived from this one.
+   * Registers multiple shared headers for every downstream request.
    */
-  data(data) {
-    __privateGet(this, _request2).data(data);
-    return HTTP.create(
-      this.client,
-      __privateGet(this, _request2).derive().data(data),
-      __privateGet(this, _metaConfig).derive()
-    );
+  sharedHeaders(dict) {
+    this.builder.headers(dict);
+    return this;
   }
   /**
-   * `onSend` is a pre-request hook which will be executed in order of definition
-   * immediately before the request is sent. This hook can be used to modify the request,
-   * or to log the state of a request before final send-off.
-   *
-   * ```ts
-   *
-   * \@Fixture(INJECTION_SCOPE.TRANSIENT)
-   * export class UserController extends BaseController {
-   *  constructor(private readonly http: HTTP) {
-   *   super(http);
-   *  }
-   *
-   *  getUser(id: number) {
-   *   return this.http
-   *              .route(id)
-   *              .onSend("log request",
-   *                (request) => console.log(JSON.stringify(request, null, 2)
-   *              )
-   *              .get();
-   * }
-   * ```
-   *
-   * This method is a request chain method, and will return a new instance of HTTP, inheriting
-   * any onSend hooks previously defined and appending the new hook. Useful to configure
-   * in class methods as part of finalizing a request.
-   *
-   * @param description A description of the hook, used for debugging.
-   * @param hook The hook to execute.
-   * @returns A new child instance of HTTP derived from this one.
+   * Returns a derived client with additional headers.
+   */
+  headers(dict) {
+    return this.derive(({ builder }) => {
+      builder.headers(dict);
+    });
+  }
+  /**
+   * Registers a request hook that runs before every execution on this instance.
+   */
+  sharedOnSend(description, hook) {
+    this.meta.onBeforeSend(description, hook);
+    return this;
+  }
+  /**
+   * Returns a clone with a request hook used only for that clone.
    */
   onSend(description, hook) {
-    return HTTP.create(
-      this.client,
-      __privateGet(this, _request2).derive(),
-      __privateGet(this, _metaConfig).derive().onBeforeSend(description, hook)
-    );
+    return this.derive(({ meta }) => {
+      meta.onBeforeSend(description, hook);
+    });
   }
   /**
-   * `onReceive` is a post-request hook which will be executed in order of definition
-   * immediately after the response is received. This hook can be used to modify the response,
-   * or to log the state of a response after it is received.
-   *
-   * ```ts
-   *
-   * \@Fixture(INJECTION_SCOPE.TRANSIENT)
-   * export class UserController extends BaseController {
-   *  constructor(private readonly http: HTTP) {
-   *   super(http);
-   *  }
-   *
-   *  getUser(id: number) {
-   *   return this.http
-   *              .route(id)
-   *              .onReceive("log response",
-   *                (response) => console.log(JSON.stringify(response, null, 2)
-   *              )
-   *              .get();
-   * }
-   * ```
-   *
-   * This method is a request chain method, and will return a new instance of HTTP, inheriting
-   * any onReceive hooks previously defined and appending the new hook. Useful to configure
-   * in class methods as part of finalizing a request.
-   *
-   * @param description A description of the hook, used for debugging.
-   * @param hook The hook to execute.
-   * @returns A new child instance of HTTP derived from this one.
+   * Registers a response hook executed after every transport response.
+   */
+  sharedOnReceive(description, hook) {
+    this.meta.onReceiveResponse(description, hook);
+    return this;
+  }
+  /**
+   * Returns a derived client with a response hook limited to that client.
    */
   onReceive(description, hook) {
-    return HTTP.create(
-      this.client,
-      __privateGet(this, _request2).derive(),
-      __privateGet(this, _metaConfig).derive().onReceiveResponse(description, hook)
-    );
+    return this.derive(({ meta }) => {
+      meta.onReceiveResponse(description, hook);
+    });
   }
   /**
-   * Executes the current request state as a GET request.
-   *
-   * @param options Additional options to pass to the underlying http client, such
-   *                as e.g Axios configuration values.
-   * @returns A promise which resolves to the response.
+   * Configures whether server errors (>=500) throw by default for every request.
    */
-  get(options) {
-    return __privateMethod(this, _makeRequest, makeRequest_fn).call(this, __privateGet(this, _request2).derive().method("GET"), options);
+  sharedThrowOnServerError(value) {
+    this.meta.throwOnServerError(value);
+    return this;
   }
   /**
-   * Executes the current request state as a POST request.
-   *
-   * @param data The data payload to attach to the request.
-   * @param options Additional options to pass to the underlying http client, such
-   *                as e.g Axios configuration values.
-   * @returns A promise which resolves to the response.
+   * Returns a derived client with custom server error behaviour.
    */
-  post(options) {
-    return __privateMethod(this, _makeRequest, makeRequest_fn).call(this, __privateGet(this, _request2).derive().method("POST"), options);
+  throwOnServerError(value) {
+    return this.derive(({ meta }) => {
+      meta.throwOnServerError(value);
+    });
   }
   /**
-   * Executes the current request state as a DELETE request.
-   *
-   * @param options Additional options to pass to the underlying http client, such
-   *                as e.g Axios configuration values.
-   * @returns A promise which resolves to the response.
-   *               as e.g Axios configuration values.
+   * Executes a GET request using the current configuration.
    */
-  delete(options) {
-    return __privateMethod(this, _makeRequest, makeRequest_fn).call(this, __privateGet(this, _request2).derive().method("DELETE"), options);
+  get(options) {
+    return this.execute("GET", options);
   }
   /**
-   * Executes the current request state as a PUT request.
-   *
-   * @param options Additional options to pass to the underlying http client, such
-   *                as e.g Axios configuration values.
-   * @returns A promise which resolves to the response.
+   * Executes a POST request using the current configuration.
+   */
+  post(options) {
+    return this.execute("POST", options);
+  }
+  /**
+   * Executes a PUT request using the current configuration.
    */
   put(options) {
-    return __privateMethod(this, _makeRequest, makeRequest_fn).call(this, __privateGet(this, _request2).derive().method("PUT"), options);
+    return this.execute("PUT", options);
   }
   /**
-   * Executes the current request state as a PATCH request.
-   *
-   * @param options Additional options to pass to the underlying http client, such
-   *                as e.g Axios configuration values.
-   * @returns A promise which resolves to the response.
+   * Executes a PATCH request using the current configuration.
    */
   patch(options) {
-    return __privateMethod(this, _makeRequest, makeRequest_fn).call(this, __privateGet(this, _request2).derive().method("PATCH"), options);
+    return this.execute("PATCH", options);
   }
+  /**
+   * Executes a DELETE request using the current configuration.
+   */
+  delete(options) {
+    return this.execute("DELETE", options);
+  }
+  /**
+   * Executes a HEAD request using the current configuration.
+   */
   head(options) {
-    return __privateMethod(this, _makeRequest, makeRequest_fn).call(this, __privateGet(this, _request2).derive().method("HEAD"), options);
+    return this.execute("HEAD", options);
   }
+  /**
+   * Executes an OPTIONS request using the current configuration.
+   */
   options(options) {
-    return __privateMethod(this, _makeRequest, makeRequest_fn).call(this, __privateGet(this, _request2).derive().method("OPTIONS"), options);
+    return this.execute("OPTIONS", options);
   }
+  /**
+   * Executes a TRACE request using the current configuration.
+   */
   trace(options) {
-    return __privateMethod(this, _makeRequest, makeRequest_fn).call(this, __privateGet(this, _request2).derive().method("TRACE"), options);
+    return this.execute("TRACE", options);
   }
+  /**
+   * Executes a CONNECT request using the current configuration.
+   */
   connect(options) {
-    return __privateMethod(this, _makeRequest, makeRequest_fn).call(this, __privateGet(this, _request2).derive().method("CONNECT"), options);
+    return this.execute("CONNECT", options);
+  }
+  async execute(method, options) {
+    const baseBuilder = this.builder.clone().method(method);
+    const meta = this.meta.derive().build();
+    const baseOptions = mergeOptions2(meta.options, options);
+    if (meta.streamResponse) {
+      baseOptions.streamResponse = true;
+    }
+    const retryPolicy = meta.retry;
+    const maxRetries = retryPolicy?.attempts ?? 0;
+    for (let retriesUsed = 0; ; ) {
+      const attemptBuilder = baseBuilder.clone();
+      await attemptBuilder.resolveDynamicHeaders();
+      const request = attemptBuilder.build();
+      request.method = method;
+      const attemptOptions = {
+        ...baseOptions
+      };
+      let timeoutController;
+      let timeoutHandle;
+      let combinedSignal;
+      if (typeof meta.timeoutMs === "number" && meta.timeoutMs > 0) {
+        const setup = createTimeoutController(meta.timeoutMs);
+        timeoutController = setup.controller;
+        timeoutHandle = setup.timer;
+      }
+      const existingSignal = attemptOptions.signal;
+      const signals = [];
+      if (existingSignal) {
+        signals.push(existingSignal);
+      }
+      if (timeoutController) {
+        signals.push(timeoutController.signal);
+      }
+      if (signals.length === 1) {
+        const singleSignal = signals[0];
+        if (singleSignal) {
+          attemptOptions.signal = singleSignal;
+        } else if ("signal" in attemptOptions) {
+          delete attemptOptions.signal;
+        }
+      } else if (signals.length > 1) {
+        combinedSignal = combineAbortSignals(signals);
+        attemptOptions.signal = combinedSignal.signal;
+      } else if ("signal" in attemptOptions) {
+        delete attemptOptions.signal;
+      }
+      const activeSignal = attemptOptions.signal;
+      if (activeSignal?.aborted) {
+        const reason = activeSignal.reason ?? createAbortError();
+        throw new HTTPTransportError(request, reason);
+      }
+      const requestContext = {
+        request,
+        options: attemptOptions
+      };
+      let response;
+      try {
+        await this.runRequestPlugins(requestContext);
+        await this.runOnSendHooks(meta, request);
+        const raw = await this.transport.send(request, attemptOptions).catch((cause) => {
+          throw new HTTPTransportError(request, cause);
+        });
+        response = this.buildResponse(raw, request);
+        const isStreaming = meta.streamResponse;
+        if (!isStreaming) {
+          response.data = transformResponse(meta.allowPlainText, response.data);
+        }
+        if (meta.throwOnServerError && response.status >= 500) {
+          throw new HTTPServerError(request, response);
+        }
+        await this.runOnReceiveHooks(meta, response);
+        let validated;
+        if (meta.streamResponse) {
+          validated = response;
+        } else {
+          try {
+            validated = this.validateResponse(response, meta);
+          } catch (cause) {
+            throw new HTTPSchemaValidationError(request, response, cause);
+          }
+        }
+        await this.runResponsePlugins({
+          request,
+          response: validated,
+          options: attemptOptions
+        });
+        return validated;
+      } catch (thrown) {
+        const normalized = thrown instanceof HTTPError ? thrown : thrown;
+        const retryAttempt = retriesUsed + 1;
+        const policy = retryPolicy;
+        const canRetry = policy !== void 0 && retryAttempt <= maxRetries && await this.shouldRetryRequest(
+          normalized,
+          policy,
+          retryAttempt,
+          request
+        );
+        if (!canRetry) {
+          await this.runErrorPlugins({
+            request,
+            options: attemptOptions,
+            error: normalized
+          });
+          throw normalized;
+        }
+        retriesUsed += 1;
+        await this.delayRetry(retryAttempt, policy);
+      } finally {
+        if (timeoutHandle !== void 0) {
+          clearTimeout(timeoutHandle);
+        }
+        combinedSignal?.dispose();
+      }
+    }
+  }
+  async runRequestPlugins(context) {
+    for (const plugin of this.plugins()) {
+      if (plugin.onRequest) {
+        await plugin.onRequest(context);
+      }
+    }
+  }
+  async runResponsePlugins(context) {
+    for (const plugin of this.plugins()) {
+      if (plugin.onResponse) {
+        await plugin.onResponse(context);
+      }
+    }
+  }
+  async runErrorPlugins(context) {
+    for (const plugin of this.plugins()) {
+      if (plugin.onError) {
+        await plugin.onError(context);
+      }
+    }
   }
   async runOnSendHooks(meta, request) {
     for (const [description, hook] of meta.onSend) {
       try {
         await hook(request);
-      } catch (e) {
-        const cause = e;
-        const msg = `An error occurred while sending a request in hook: '${description}'`;
-        throw new import_errors2.AutomationError(msg, { cause });
+      } catch (error) {
+        throw new AutomationError(
+          `An error occurred in onSend hook "${description}"`,
+          { cause: error }
+        );
       }
     }
   }
@@ -1056,111 +1444,605 @@ var HTTP = class {
     for (const [description, hook] of meta.onReceive) {
       try {
         await hook(response);
-      } catch (e) {
-        const cause = e;
-        const msg = `An error occurred while receiving a response in hook: '${description}'`;
-        throw new import_errors2.AutomationError(msg, { cause });
+      } catch (error) {
+        throw new AutomationError(
+          `An error occurred in onReceive hook "${description}"`,
+          { cause: error }
+        );
       }
     }
   }
+  validateResponse(response, meta) {
+    const validated = meta.schemas.validate(
+      response.status,
+      response.data,
+      meta.requireSchema
+    );
+    response.data = validated;
+    return response;
+  }
+  buildResponse(raw, request) {
+    return HTTPResponseBuilder.create().status(raw.status).statusText(raw.statusText).headers(normalizeHeaders(raw.headers)).data(raw.data).request(request).build();
+  }
+  plugins() {
+    return [...this.sharedPlugins, ...this.scopedPlugins];
+  }
+  async shouldRetryRequest(error, policy, attempt, request) {
+    if (attempt > policy.attempts) {
+      return false;
+    }
+    const response = error instanceof HTTPError ? error.response : void 0;
+    if (policy.retryOn) {
+      const retryContext = response ? { error, attempt, request, response } : { error, attempt, request };
+      return await policy.retryOn(retryContext);
+    }
+    if (error instanceof HTTPTransportError) {
+      return true;
+    }
+    if (response && response.status >= 500) {
+      return true;
+    }
+    return false;
+  }
+  async delayRetry(attempt, policy) {
+    const { delay } = policy;
+    let duration;
+    if (typeof delay === "function") {
+      duration = await delay(attempt);
+    } else if (typeof delay === "number") {
+      duration = delay * attempt;
+    } else {
+      duration = attempt * 100;
+    }
+    if (!duration || duration <= 0) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, duration));
+  }
+  derive(mutate, overrides) {
+    const builder = this.builder.clone();
+    const meta = this.meta.derive();
+    const plugins = [...this.scopedPlugins];
+    if (mutate) {
+      mutate({ builder, meta, plugins });
+    }
+    return new _HTTP(
+      overrides?.transport ?? this.transport,
+      builder,
+      meta,
+      this.sharedPlugins,
+      plugins
+    );
+  }
 };
-_request2 = new WeakMap();
-_metaConfig = new WeakMap();
-_makeRequest = new WeakSet();
-makeRequest_fn = async function(builder, options) {
-  const request = (await builder.resolveDynamicHeaders()).build();
-  const meta = __privateGet(this, _metaConfig).derive().build();
-  await this.runOnSendHooks(meta, request);
-  const opts = { ...meta.options, ...options };
-  const result = await this.client.request(request, opts);
-  result.data = transformResponse(meta.allowPlainText, result.data);
-  await this.runOnReceiveHooks(meta, result);
-  const validated = __privateMethod(this, _validateResponse, validateResponse_fn).call(this, result, meta);
-  return validated;
-};
-_validateResponse = new WeakSet();
-validateResponse_fn = function(response, meta) {
-  const { status, data } = response;
-  const validated = meta.schemas.validate(
-    status,
-    data,
-    meta.requireSchema
-  );
-  response.data = validated;
-  return response;
-};
-HTTP = __decorateClass([
-  (0, import_injection.Fixture)(import_injection.INJECTION_SCOPE.TRANSIENT)
-], HTTP);
+_HTTP.sharedPlugins = [];
+var HTTP = _HTTP;
+function mergeOptions2(base, overrides) {
+  if (!overrides) {
+    return { ...base };
+  }
+  const merged = { ...base };
+  for (const [key, value] of Object.entries(overrides)) {
+    if (value === void 0) {
+      delete merged[key];
+    } else {
+      merged[key] = value;
+    }
+  }
+  return merged;
+}
+function normalizeHeaders(headers) {
+  const next = {};
+  for (const [key, value] of Object.entries(headers)) {
+    next[key] = Array.isArray(value) ? value.join(",") : String(value);
+  }
+  return next;
+}
+function toParamValue(value, rest) {
+  if (rest.length > 0) {
+    return [value, ...rest];
+  }
+  return value;
+}
+function createTimeoutController(timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => {
+    controller.abort(createAbortError(`Request timed out after ${timeoutMs} ms`));
+  }, timeoutMs);
+  maybeUnrefTimer(timer);
+  return { controller, timer };
+}
+function combineAbortSignals(signals) {
+  const controller = new AbortController();
+  const aborted = signals.find((signal) => signal.aborted);
+  if (aborted) {
+    controller.abort(aborted.reason ?? createAbortError());
+    return { signal: controller.signal, dispose: () => void 0 };
+  }
+  const listeners = [];
+  for (const signal of signals) {
+    const listener = () => {
+      controller.abort(signal.reason ?? createAbortError());
+    };
+    signal.addEventListener("abort", listener, { once: true });
+    listeners.push({ signal, listener });
+  }
+  const dispose = () => {
+    for (const { signal, listener } of listeners) {
+      signal.removeEventListener("abort", listener);
+    }
+  };
+  controller.signal.addEventListener("abort", dispose, { once: true });
+  return { signal: controller.signal, dispose };
+}
+function maybeUnrefTimer(timer) {
+  if (typeof timer === "object" && timer !== null) {
+    const maybeTimer = timer;
+    if (typeof maybeTimer.unref === "function") {
+      maybeTimer.unref();
+    }
+  }
+}
+function createAbortError(message = "The operation was aborted.") {
+  const error = new Error(message);
+  error.name = "AbortError";
+  return error;
+}
 
 // src/default-schema.ts
-var import_assert_is_json2 = __toESM(require("@stdlib/assert-is-json"), 1);
 function AnySchema(data) {
   return data;
 }
 function EmptySchema(data) {
   if (data !== null && data !== void 0 && data !== "null") {
-    throw new Error(`Expected null but got <${typeof data}> for ${data}`);
+    throw new Error(`Expected null but received ${describeValue(data)}`);
   }
   return data === "null" ? null : data;
 }
 function NullSchema(data) {
   if (data !== null && data !== "null") {
-    throw new Error(`Expected null but got <${typeof data}> for ${data}`);
+    throw new Error(`Expected null but received ${describeValue(data)}`);
   }
   return null;
 }
 function UndefinedSchema(data) {
   if (data !== void 0) {
-    throw new Error(`Expected undefined but got <${typeof data}> for ${data}`);
+    throw new Error(`Expected undefined but received ${describeValue(data)}`);
   }
   return void 0;
 }
 function BooleanSchema(data) {
-  if (!(typeof data === "boolean") && ["true", "false"].includes(String(data)) === false) {
-    throw new Error(`Expected boolean but got <${typeof data}> for ${data}`);
+  if (typeof data === "boolean" || typeof data === "string" && ["true", "false"].includes(data)) {
+    return typeof data === "boolean" ? data : data === "true";
   }
-  return JSON.parse(data);
+  throw new Error(`Expected boolean but received ${describeValue(data)}`);
 }
 function NumberSchema(data) {
-  if (!(typeof data === "number") && /^\d*\.?\d+$/.test(String(data)) === false) {
-    throw new Error(`Expected number but got <${typeof data}> for ${data}`);
+  if (typeof data === "number") {
+    return data;
+  }
+  if (typeof data === "string" && /^(?:\d+|\d*\.\d+)$/.test(data)) {
+    return Number(data);
   }
-  return JSON.parse(data);
+  throw new Error(`Expected number but received ${describeValue(data)}`);
 }
 function StringSchema(data) {
-  if (typeof data !== "string") {
-    throw new Error(`Expected string but got <${typeof data}> for ${data}`);
+  if (typeof data === "string") {
+    return data;
   }
-  return data;
+  throw new Error(`Expected string but received ${describeValue(data)}`);
 }
 function JSONSchema(data) {
-  if (typeof data === "object") {
+  if (typeof data === "object" && data !== null) {
     return data;
   }
-  if (!(0, import_assert_is_json2.default)(data)) {
-    throw new Error(`Expected JSON but got <${typeof data}> for ${data}`);
+  if (typeof data === "string") {
+    const parsed = tryParseJson2(data);
+    if (parsed !== void 0) {
+      return parsed;
+    }
+  }
+  throw new Error(`Expected JSON but received ${describeValue(data)}`);
+}
+function describeValue(value) {
+  return `<${typeof value}> ${String(value)}`;
+}
+function tryParseJson2(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/plugins.ts
+function createLoggingPlugin(sink) {
+  return {
+    name: "http-logging",
+    async onRequest(context) {
+      await sink({
+        type: "request",
+        timestamp: Date.now(),
+        request: context.request,
+        options: context.options
+      });
+    },
+    async onResponse(context) {
+      await sink({
+        type: "response",
+        timestamp: Date.now(),
+        request: context.request,
+        response: context.response,
+        options: context.options
+      });
+    },
+    async onError(context) {
+      await sink({
+        type: "error",
+        timestamp: Date.now(),
+        request: context.request,
+        error: context.error,
+        options: context.options
+      });
+    }
+  };
+}
+
+// src/axios-transport.ts
+function createAxiosTransport(axios) {
+  if (!axios || typeof axios.request !== "function") {
+    throw new Error("Axios transport requires an axios-like client instance.");
+  }
+  return {
+    async send(request, options = {}) {
+      const {
+        headers: optionHeaders,
+        streamResponse,
+        ...restOptions
+      } = options;
+      const config = {
+        url: request.fullUrl ?? "",
+        method: request.method ?? "GET",
+        headers: { ...request.headers },
+        data: request.data,
+        validateStatus: () => true,
+        ...restOptions
+      };
+      if (optionHeaders) {
+        config.headers = mergeHeaders2(config.headers ?? {}, optionHeaders);
+      }
+      if (streamResponse) {
+        config.responseType = config.responseType ?? "stream";
+      }
+      const response = await axios.request(config);
+      return {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers ?? {},
+        data: response.data
+      };
+    }
+  };
+}
+function mergeHeaders2(base, overrides) {
+  const next = {};
+  for (const [key, value] of Object.entries(base)) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    next[key] = String(value);
+  }
+  for (const [key, value] of Object.entries(overrides)) {
+    if (value === void 0 || value === null) {
+      delete next[key];
+      continue;
+    }
+    next[key] = String(value);
+  }
+  return next;
+}
+function ensureHttp(response, options = {}) {
+  return new HttpEnsureChainImpl(response, {
+    ...options.label ? { label: options.label } : {},
+    negated: Boolean(options.negated)
+  });
+}
+var HttpEnsureChainImpl = class _HttpEnsureChainImpl {
+  constructor(value, state) {
+    this.value = value;
+    this.label = state.label;
+    this.negated = state.negated;
+    this.normalized = normalizeResponse(value);
+  }
+  get not() {
+    return new _HttpEnsureChainImpl(this.value, {
+      ...this.label ? { label: this.label } : {},
+      negated: !this.negated
+    });
+  }
+  toHaveStatus(expectation) {
+    const { pass, description } = matchesStatus(
+      this.normalized.status,
+      expectation
+    );
+    if (shouldFail(pass, this.negated)) {
+      const baseMessage = this.negated ? `Expected response status not to be ${description}` : `Expected response status to be ${description}`;
+      this.fail({
+        matcher: "toHaveStatus",
+        message: baseMessage,
+        actual: this.normalized.status,
+        expected: description
+      });
+    }
+    return this;
+  }
+  toHaveHeader(name, expectation) {
+    const key = name.toLowerCase();
+    const actual = this.normalized.headers[key];
+    if (expectation === void 0) {
+      const pass2 = actual !== void 0;
+      if (shouldFail(pass2, this.negated)) {
+        const baseMessage = this.negated ? `Expected response not to include header ${name}` : `Expected response to include header ${name}`;
+        this.fail({
+          matcher: "toHaveHeader",
+          message: baseMessage,
+          actual: actual ?? "<missing>",
+          expected: name
+        });
+      }
+      return this;
+    }
+    const pass = matchHeaderValue(actual, expectation);
+    if (shouldFail(pass, this.negated)) {
+      const baseMessage = this.negated ? `Expected header ${name} not to match` : `Expected header ${name} to match`;
+      this.fail({
+        matcher: "toHaveHeader",
+        message: baseMessage,
+        actual: actual ?? "<missing>",
+        expected: expectation
+      });
+    }
+    return this;
+  }
+  toBeCacheable(expectation = {}) {
+    const cacheControl = this.normalized.headers["cache-control"];
+    if (!cacheControl) {
+      if (!this.negated) {
+        this.fail({
+          matcher: "toBeCacheable",
+          message: "Expected Cache-Control header to be present",
+          actual: "<missing>"
+        });
+      }
+      return this;
+    }
+    const directives = parseCacheControl(cacheControl);
+    const impliedCacheable = !("no-store" in directives || "no-cache" in directives);
+    const expectationPass = evaluateCacheExpectations(directives, expectation);
+    const pass = impliedCacheable && expectationPass;
+    if (shouldFail(pass, this.negated)) {
+      const baseMessage = this.negated ? "Expected response not to advertise cacheable directives" : "Expected response to advertise cacheable directives";
+      this.fail({
+        matcher: "toBeCacheable",
+        message: baseMessage,
+        actual: directives,
+        expected: expectation
+      });
+    }
+    return this;
+  }
+  toHaveCorrelationId(headerName = "x-correlation-id") {
+    const key = headerName.toLowerCase();
+    const value = this.normalized.headers[key];
+    const pass = typeof value === "string" && value.trim().length > 0;
+    if (shouldFail(pass, this.negated)) {
+      const baseMessage = this.negated ? `Expected header ${headerName} to be missing or empty` : `Expected header ${headerName} to be present`;
+      this.fail({
+        matcher: "toHaveCorrelationId",
+        message: baseMessage,
+        actual: value ?? "<missing>",
+        expected: headerName
+      });
+    }
+    return this;
+  }
+  fail(details) {
+    const merged = {
+      ...details,
+      ...this.label ? { receivedLabel: this.label } : {}
+    };
+    throw new EnsureError(merged);
+  }
+};
+function shouldFail(pass, negated) {
+  return negated ? pass : !pass;
+}
+function normalizeResponse(response) {
+  return {
+    status: response.status,
+    statusText: response.statusText ?? "",
+    headers: normalizeHeaders2(response.headers),
+    original: response.raw ?? response
+  };
+}
+function normalizeHeaders2(source) {
+  const result = {};
+  if (typeof source.get === "function") {
+    const entries = source.entries;
+    const iterator = entries ? entries.call(source) : source[Symbol.iterator]?.call(source);
+    if (iterator) {
+      for (const [name, value] of iterator) {
+        result[String(name).toLowerCase()] = String(value);
+      }
+      return result;
+    }
+  }
+  for (const [key, value] of Object.entries(
+    source
+  )) {
+    result[String(key).toLowerCase()] = String(value);
   }
-  const result = JSON.parse(data);
   return result;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AnySchema,
-  AxiosClient,
-  BooleanSchema,
-  EmptySchema,
-  HTTP,
-  HTTPClient,
-  HTTPRequest,
-  HTTPRequestBuilder,
-  HTTPResponse,
-  HTTPResponseBuilder,
-  JSONSchema,
-  NullSchema,
-  NumberSchema,
-  StringSchema,
-  UndefinedSchema,
-  defaultClient
-});
+function matchesStatus(status, expectation) {
+  if (typeof expectation === "number") {
+    return {
+      pass: status === expectation,
+      description: expectation.toString()
+    };
+  }
+  if (typeof expectation === "string") {
+    const digit = Number.parseInt(expectation.charAt(0), 10);
+    if (!Number.isNaN(digit) && expectation.endsWith("xx")) {
+      const min = digit * 100;
+      return {
+        pass: status >= min && status < min + 100,
+        description: `${digit}xx`
+      };
+    }
+    return {
+      pass: status.toString() === expectation,
+      description: expectation
+    };
+  }
+  if (Array.isArray(expectation)) {
+    const [min, max] = expectation;
+    return {
+      pass: status >= min && status <= max,
+      description: `[${min}, ${max}]`
+    };
+  }
+  if (typeof expectation === "function") {
+    return {
+      pass: expectation(status),
+      description: "predicate(status)"
+    };
+  }
+  const range = expectation;
+  return {
+    pass: status >= range.min && status <= range.max,
+    description: `[${range.min}, ${range.max}]`
+  };
+}
+function matchHeaderValue(actual, expected) {
+  if (actual === void 0) {
+    return false;
+  }
+  if (typeof expected === "string") {
+    return actual === expected;
+  }
+  if (expected instanceof RegExp) {
+    return expected.test(actual);
+  }
+  if (Array.isArray(expected)) {
+    const list = expected;
+    const actualParts = actual.split(",").map((part) => part.trim()).filter(Boolean);
+    return list.every((value) => actualParts.includes(value));
+  }
+  return expected(actual);
+}
+function parseCacheControl(value) {
+  const directives = {};
+  for (const segment of value.split(",")) {
+    const trimmed = segment.trim();
+    if (!trimmed) {
+      continue;
+    }
+    const [rawName, rawParameter] = trimmed.split("=", 2);
+    const name = rawName?.trim();
+    if (!name) {
+      continue;
+    }
+    if (rawParameter === void 0) {
+      directives[name.toLowerCase()] = true;
+      continue;
+    }
+    const parameter = rawParameter.trim().replace(/^"|"$/g, "");
+    directives[name.toLowerCase()] = parameter;
+  }
+  return directives;
+}
+function evaluateCacheExpectations(directives, expectation) {
+  if (expectation.cacheability) {
+    if (!(expectation.cacheability in directives)) {
+      return false;
+    }
+  }
+  if (expectation.maxAge !== void 0) {
+    const raw = directives["max-age"];
+    if (typeof raw !== "string") {
+      return false;
+    }
+    const parsed = Number.parseInt(raw, 10);
+    if (Number.isNaN(parsed)) {
+      return false;
+    }
+    if (typeof expectation.maxAge === "number") {
+      if (parsed !== expectation.maxAge) {
+        return false;
+      }
+    } else {
+      const { min, max } = expectation.maxAge;
+      if (min !== void 0 && parsed < min) {
+        return false;
+      }
+      if (max !== void 0 && parsed > max) {
+        return false;
+      }
+    }
+  }
+  if (expectation.sMaxAge !== void 0) {
+    const raw = directives["s-maxage"];
+    if (typeof raw !== "string") {
+      return false;
+    }
+    const parsed = Number.parseInt(raw, 10);
+    if (Number.isNaN(parsed) || parsed !== expectation.sMaxAge) {
+      return false;
+    }
+  }
+  if (expectation.revalidate) {
+    if (!("must-revalidate" in directives || "proxy-revalidate" in directives)) {
+      return false;
+    }
+  }
+  if (expectation.immutable && !("immutable" in directives)) {
+    return false;
+  }
+  return true;
+}
+
+// src/assertions/http-assertions-plugin.ts
+var httpAssertionsPlugin = () => ({ isNot }) => (_world) => {
+  const facet = (response, options) => {
+    return ensureHttp(response, {
+      ...options?.label ? { label: options.label } : {},
+      negated: isNot
+    });
+  };
+  return facet;
+};
+
+// src/assertions/http-adapters.ts
+function fromHttpResponse(response) {
+  return {
+    status: response.status,
+    statusText: response.statusText ?? "",
+    headers: response.headers,
+    data: response.data,
+    raw: response
+  };
+}
+function fromFetchResponse(response, data) {
+  return {
+    status: response.status,
+    statusText: response.statusText ?? "",
+    headers: response.headers,
+    data,
+    raw: response
+  };
+}
+
+export { AnySchema, BooleanSchema, EmptySchema, HTTP, HTTPError, HTTPRequest, HTTPRequestBuilder, HTTPResponse, HTTPResponseBuilder, HTTPSchemaValidationError, HTTPTransportError, JSONSchema, MetaConfig, MetaConfigBuilder, NullSchema, NumberSchema, SchemaMap, StringSchema, UndefinedSchema, createAxiosTransport, createFetchTransport, createLoggingPlugin, ensureHttp, fromFetchResponse, fromHttpResponse, httpAssertionsPlugin, transformResponse };
+//# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map