@autometa/http 1.4.20 → 2.0.0-rc.1

package/dist/index.cjs

@@ -0,0 +1,2076 @@
+'use strict';
+
+var errors = require('@autometa/errors');
+var cliHighlight = require('cli-highlight');
+var assertions = require('@autometa/assertions');
+
+// src/http.ts
+
+// src/fetch-transport.ts
+function createFetchTransport(fetchImpl = globalThis.fetch) {
+  if (!fetchImpl) {
+    throw new Error(
+      "No fetch implementation available. Provide one via createFetchTransport(fetchImpl)."
+    );
+  }
+  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
+      };
+    }
+  };
+}
+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);
+    }
+  }
+  return next;
+}
+function createBody(request, headers) {
+  const { data } = request;
+  if (data === void 0 || data === null) {
+    return void 0;
+  }
+  if (isBodyInit(data)) {
+    return data;
+  }
+  if (typeof data === "string") {
+    return data;
+  }
+  if (typeof data === "object") {
+    if (!hasHeader(headers, "content-type")) {
+      headers["content-type"] = "application/json";
+    }
+    return JSON.stringify(data);
+  }
+  return String(data);
+}
+async function readBody(response) {
+  if (response.status === 204 || response.status === 205) {
+    return null;
+  }
+  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;
+  }
+  if (typeof ArrayBuffer !== "undefined" && value instanceof ArrayBuffer) {
+    return true;
+  }
+  if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView(value)) {
+    return true;
+  }
+  return false;
+}
+
+// src/http-request.ts
+var HTTPRequest = class _HTTPRequest {
+  constructor(config) {
+    /**
+     * Normalised header collection that will be sent with the request.
+     */
+    this.headers = {};
+    this.params = {};
+    this.route = [];
+    this.queryOptions = {};
+    if (config) {
+      Object.assign(this, config);
+      if (config.queryOptions) {
+        this.queryOptions = { ...config.queryOptions };
+      }
+    }
+  }
+  /**
+   * Full request URL derived from {@link baseUrl}, {@link route} and {@link params}.
+   */
+  get fullUrl() {
+    return buildFullUrl(
+      this.baseUrl,
+      this.route,
+      this.params,
+      this.queryOptions
+    );
+  }
+  /**
+   * Creates a deep copy of an existing request instance.
+   */
+  static derive(original) {
+    const request = new _HTTPRequest();
+    request.headers = { ...original.headers };
+    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 HTTPRequestBuilder = class _HTTPRequestBuilder {
+  constructor(request = () => new HTTPRequest()) {
+    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 this.requestInstance;
+  }
+  /**
+   * 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 {
+        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) {
+    this.requestInstance.baseUrl = url;
+    return this;
+  }
+  /**
+   * 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 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 (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;
+    }
+    this.requestInstance.params[name] = value;
+    return this;
+  }
+  /**
+   * Merges a dictionary of query parameters into the 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) {
+    if (data === void 0) {
+      delete this.requestInstance.data;
+      return this;
+    }
+    this.requestInstance.data = data;
+    return this;
+  }
+  /**
+   * Sets a single header using direct values or a lazy factory.
+   */
+  header(name, value) {
+    if (typeof value === "function") {
+      this.dynamicHeaders.set(name, value);
+      delete this.requestInstance.headers[name];
+      return this;
+    }
+    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;
+    }
+    this.requestInstance.headers[name] = String(value);
+    return this;
+  }
+  /**
+   * Replaces or merges multiple headers in one call.
+   */
+  headers(dict) {
+    for (const [key, value] of Object.entries(dict)) {
+      this.header(key, value);
+    }
+    return this;
+  }
+  /**
+   * Stores the HTTP verb ensuring consistent casing.
+   */
+  method(method) {
+    this.requestInstance.method = method.toUpperCase();
+    return this;
+  }
+  /**
+   * Returns a copy-on-write builder pointing at the same request state.
+   */
+  derive() {
+    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() {
+    this.requestInstance.queryOptions = { ...this.queryOptions };
+    return this.requestInstance;
+  }
+  /**
+   * Resolves lazy headers before returning the request.
+   */
+  async buildAsync() {
+    await this.resolveDynamicHeaders();
+    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();
+  }
+};
+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;
+  }
+};
+
+// src/schema.map.ts
+var SchemaMap = class _SchemaMap {
+  constructor(map) {
+    if (map instanceof _SchemaMap) {
+      this.map = new Map(map.map);
+      return;
+    }
+    this.map = map ? new Map(map) : /* @__PURE__ */ new Map();
+  }
+  derive() {
+    return new _SchemaMap(this.map);
+  }
+  registerStatus(parser, ...codes) {
+    codes.forEach((code) => {
+      this.map.set(code, parser);
+    });
+  }
+  registerRange(parser, from, to) {
+    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);
+    }
+    return data;
+  }
+  getParser(status, requireSchema) {
+    const parser = this.map.get(status);
+    if (!parser && requireSchema) {
+      throw new Error(
+        `No schema parser registered for status code ${status} while requireSchema is true.`
+      );
+    }
+    return parser ?? null;
+  }
+  toObject() {
+    return Object.fromEntries(this.map);
+  }
+};
+
+// src/request-meta.config.ts
+var MetaConfig = class {
+  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 MetaConfigBuilder = class _MetaConfigBuilder {
+  constructor() {
+    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) {
+    this.schemaMapValue = map;
+    return this;
+  }
+  schema(parser, ...args) {
+    args.forEach((arg) => {
+      if (typeof arg === "number") {
+        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) {
+    this.requireSchemaValue = value;
+    return this;
+  }
+  allowPlainText(value) {
+    this.allowPlainTextValue = value;
+    return this;
+  }
+  onBeforeSend(description, hook) {
+    this.onBeforeSendHooks.push([description, hook]);
+    return this;
+  }
+  onReceiveResponse(description, hook) {
+    this.onAfterReceiveHooks.push([description, hook]);
+    return this;
+  }
+  throwOnServerError(value) {
+    this.throwOnServerErrorValue = value;
+    return this;
+  }
+  options(options) {
+    this.optionsValue = mergeOptions(this.optionsValue, options);
+    return this;
+  }
+  retry(options) {
+    this.retryOptionsValue = options ? { ...options } : void 0;
+    return this;
+  }
+  streamResponse(value) {
+    this.streamResponseValue = value;
+    return this;
+  }
+  timeout(duration) {
+    if (typeof duration === "number" && duration > 0) {
+      this.timeoutMsValue = duration;
+    } else {
+      this.timeoutMsValue = void 0;
+    }
+    return this;
+  }
+  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
+    });
+  }
+  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);
+  }
+  setOnBeforeSend(hooks) {
+    this.onBeforeSendHooks = [...hooks];
+    return this;
+  }
+  setOnAfterReceive(hooks) {
+    this.onAfterReceiveHooks = [...hooks];
+    return this;
+  }
+};
+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 String(data);
+  }
+  const rendered = typeof data === "string" ? data : String(data);
+  const message = [
+    "Could not parse response as JSON and plain text responses are disabled.",
+    "Call 'allowPlainText(true)' or 'sharedAllowPlainText(true)' to permit plain text responses.",
+    "",
+    cliHighlight.highlight(rendered, { language: "html" })
+  ].join("\n");
+  throw new errors.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 HTTPError = class extends errors.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) {
+    this.builder.url(url);
+    return this;
+  }
+  /**
+   * Applies additional transport specific options to every request executed by this instance.
+   */
+  sharedOptions(options) {
+    this.meta.options(options);
+    return this;
+  }
+  /**
+   * Returns a derived client with extra transport options applied only to that clone.
+   */
+  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;
+  }
+  /**
+   * Returns a derived client configured with the provided {@link AbortSignal}.
+   */
+  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;
+  }
+  /**
+   * Returns a derived client with custom retry behaviour.
+   */
+  retry(options) {
+    return this.derive(({ meta }) => {
+      meta.retry(options);
+    });
+  }
+  /**
+   * Forces subsequent requests to return raw response streams without parsing.
+   */
+  sharedStreamResponse(enabled) {
+    this.meta.streamResponse(enabled);
+    return this;
+  }
+  /**
+   * Returns a derived client configured for streaming responses.
+   */
+  streamResponse(enabled) {
+    return this.derive(({ meta }) => {
+      meta.streamResponse(enabled);
+    });
+  }
+  /**
+   * 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;
+  }
+  /**
+   * Returns a derived client with a per-request timeout in milliseconds.
+   */
+  timeout(duration) {
+    return this.derive(({ meta }) => {
+      meta.timeout(duration);
+    });
+  }
+  /**
+   * Configures whether schema validation is required before resolving a response.
+   */
+  requireSchema(required) {
+    this.meta.requireSchema(required);
+    return this;
+  }
+  /**
+   * Returns a clone with overridden plain text handling mode.
+   */
+  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;
+  }
+  /**
+   * Adds path segments that will be included in every request.
+   */
+  sharedRoute(...segments) {
+    this.builder.route(...segments);
+    return this;
+  }
+  /**
+   * Executes a request using the provided method.
+   *
+   * 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.
+   */
+  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;
+  }
+  /**
+   * 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));
+    });
+  }
+  /**
+   * 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 this.derive(({ builder }) => {
+      builder.params(dict);
+    });
+  }
+  /**
+   * Sets a shared request body used by every request from this instance.
+   */
+  sharedData(data) {
+    this.builder.data(data);
+    return this;
+  }
+  /**
+   * 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) {
+    this.builder.header(name, value);
+    return this;
+  }
+  /**
+   * Returns a clone with a header applied only to the resulting client.
+   */
+  header(name, value) {
+    return this.derive(({ builder }) => {
+      builder.header(name, value);
+    });
+  }
+  /**
+   * Registers multiple shared headers for every downstream request.
+   */
+  sharedHeaders(dict) {
+    this.builder.headers(dict);
+    return this;
+  }
+  /**
+   * 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 this.derive(({ meta }) => {
+      meta.onBeforeSend(description, hook);
+    });
+  }
+  /**
+   * 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 this.derive(({ meta }) => {
+      meta.onReceiveResponse(description, hook);
+    });
+  }
+  /**
+   * Configures whether server errors (>=500) throw by default for every request.
+   */
+  sharedThrowOnServerError(value) {
+    this.meta.throwOnServerError(value);
+    return this;
+  }
+  /**
+   * Returns a derived client with custom server error behaviour.
+   */
+  throwOnServerError(value) {
+    return this.derive(({ meta }) => {
+      meta.throwOnServerError(value);
+    });
+  }
+  /**
+   * Executes a GET request using the current configuration.
+   */
+  get(options) {
+    return this.execute("GET", options);
+  }
+  /**
+   * 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 this.execute("PUT", options);
+  }
+  /**
+   * Executes a PATCH request using the current configuration.
+   */
+  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 this.execute("HEAD", options);
+  }
+  /**
+   * Executes an OPTIONS request using the current configuration.
+   */
+  options(options) {
+    return this.execute("OPTIONS", options);
+  }
+  /**
+   * Executes a TRACE request using the current configuration.
+   */
+  trace(options) {
+    return this.execute("TRACE", options);
+  }
+  /**
+   * Executes a CONNECT request using the current configuration.
+   */
+  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 (error) {
+        throw new errors.AutomationError(
+          `An error occurred in onSend hook "${description}"`,
+          { cause: error }
+        );
+      }
+    }
+  }
+  async runOnReceiveHooks(meta, response) {
+    for (const [description, hook] of meta.onReceive) {
+      try {
+        await hook(response);
+      } catch (error) {
+        throw new errors.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
+    );
+  }
+};
+_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
+function AnySchema(data) {
+  return data;
+}
+function EmptySchema(data) {
+  if (data !== null && data !== void 0 && data !== "null") {
+    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 received ${describeValue(data)}`);
+  }
+  return null;
+}
+function UndefinedSchema(data) {
+  if (data !== void 0) {
+    throw new Error(`Expected undefined but received ${describeValue(data)}`);
+  }
+  return void 0;
+}
+function BooleanSchema(data) {
+  if (typeof data === "boolean" || typeof data === "string" && ["true", "false"].includes(data)) {
+    return typeof data === "boolean" ? data : data === "true";
+  }
+  throw new Error(`Expected boolean but received ${describeValue(data)}`);
+}
+function NumberSchema(data) {
+  if (typeof data === "number") {
+    return data;
+  }
+  if (typeof data === "string" && /^(?:\d+|\d*\.\d+)$/.test(data)) {
+    return Number(data);
+  }
+  throw new Error(`Expected number but received ${describeValue(data)}`);
+}
+function StringSchema(data) {
+  if (typeof data === "string") {
+    return data;
+  }
+  throw new Error(`Expected string but received ${describeValue(data)}`);
+}
+function JSONSchema(data) {
+  if (typeof data === "object" && data !== null) {
+    return 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 assertions.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);
+  }
+  return result;
+}
+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
+  };
+}
+
+exports.AnySchema = AnySchema;
+exports.BooleanSchema = BooleanSchema;
+exports.EmptySchema = EmptySchema;
+exports.HTTP = HTTP;
+exports.HTTPError = HTTPError;
+exports.HTTPRequest = HTTPRequest;
+exports.HTTPRequestBuilder = HTTPRequestBuilder;
+exports.HTTPResponse = HTTPResponse;
+exports.HTTPResponseBuilder = HTTPResponseBuilder;
+exports.HTTPSchemaValidationError = HTTPSchemaValidationError;
+exports.HTTPTransportError = HTTPTransportError;
+exports.JSONSchema = JSONSchema;
+exports.MetaConfig = MetaConfig;
+exports.MetaConfigBuilder = MetaConfigBuilder;
+exports.NullSchema = NullSchema;
+exports.NumberSchema = NumberSchema;
+exports.SchemaMap = SchemaMap;
+exports.StringSchema = StringSchema;
+exports.UndefinedSchema = UndefinedSchema;
+exports.createAxiosTransport = createAxiosTransport;
+exports.createFetchTransport = createFetchTransport;
+exports.createLoggingPlugin = createLoggingPlugin;
+exports.ensureHttp = ensureHttp;
+exports.fromFetchResponse = fromFetchResponse;
+exports.fromHttpResponse = fromHttpResponse;
+exports.httpAssertionsPlugin = httpAssertionsPlugin;
+exports.transformResponse = transformResponse;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.cjs.map