shelving 1.184.1 → 1.185.1

package/api/provider/APIProvider.d.ts

@@ -34,6 +34,8 @@ export declare abstract class APIProvider<P = unknown, R = unknown> {
      * @throws {RequiredError} if this is a `HEAD` or `GET` request but `payload` is not a data object.
      */
     abstract getRequest<PP extends P, RR extends R>(endpoint: Endpoint<PP, RR>, payload: PP, options?: RequestOptions, caller?: AnyCaller): Request;
+    /** Fetch a `Resource` using this provider (defaults to Javascript `fetch()` API). */
+    abstract fetch(request: Request): Promise<Response>;
     /**
      * Parse an HTTP `Response` for this endpoint.
      * - Non-2xx responses become `ResponseError`.
@@ -41,5 +43,5 @@ export declare abstract class APIProvider<P = unknown, R = unknown> {
      */
     abstract parseResponse<PP extends P, RR extends R>(_endpoint: Endpoint<PP, RR>, response: Response, caller?: AnyCaller): Promise<RR>;
     /** Send a payload to an `Endpoint` and retrieve the result. */
-    abstract fetch<PP extends P, RR extends R>(endpoint: Endpoint<PP, RR>, payload: PP, options?: RequestOptions, caller?: AnyCaller): Promise<RR>;
+    call<PP extends P, RR extends R>(endpoint: Endpoint<PP, RR>, payload: PP, options?: RequestOptions, caller?: AnyCaller): Promise<RR>;
 }

package/api/provider/APIProvider.js

@@ -1,3 +1,9 @@
 /** Provider for API endpoints rooted at a common base URL. */
 export class APIProvider {
+    /** Send a payload to an `Endpoint` and retrieve the result. */
+    async call(endpoint, payload, options, caller) {
+        const request = this.getRequest(endpoint, payload, options, caller);
+        const response = await this.fetch(request);
+        return this.parseResponse(endpoint, response, caller);
+    }
 }

package/api/provider/ClientAPIProvider.d.ts

@@ -4,8 +4,28 @@ import type { Nullish } from "../../util/null.js";
 import { type PossibleURIParams } from "../../util/uri.js";
 import { type PossibleURL, type URL, type URLString } from "../../util/url.js";
 import type { Endpoint } from "../endpoint/Endpoint.js";
-import type { APIProvider } from "./APIProvider.js";
-export declare class ClientAPIProvider<P = unknown, R = unknown> implements APIProvider<P, R> {
+import { APIProvider } from "./APIProvider.js";
+/** Options for a `ClientAPIProvider`. */
+export interface ClientAPIProviderOptions {
+    /** The common base URL for all rendered endpoint requests. */
+    readonly url: PossibleURL;
+    /**
+     * Options used for HTTP requests created with `this.getRequest()` and `this.fetch()`
+     * - Omits `signal` because it's not relevant at the provider level.
+     */
+    readonly options?: Omit<RequestOptions, "signal">;
+    /** Timeout in milliseconds, or `undefined` for no timeout. */
+    readonly timeout?: number | undefined;
+}
+/**
+ * A client-side API provider that sends requests over the network using `fetch()`.
+ * - Can be used on a server environment to make outgoing API calls, or in a browser environment to call a server API.
+ * - Renders endpoint paths and query params into the URL and sends body payloads as JSON.
+ * - Parses JSON responses and throws `ResponseError` for non-2xx responses.
+ * - Extendable with custom request-building and response-parsing logic by overriding `getRequest()` and `parseResponse()`.
+ * - Wrap in `ValidationAPIProvider` to add automatic validation of request payloads and response results against endpoint schemas.
+ */
+export declare class ClientAPIProvider<P = unknown, R = unknown> extends APIProvider<P, R> {
     /** The common base URL for all rendered endpoint requests. */
     readonly url: URLString;
     /** Default options used for HTTP requests created with `this.getRequest()` and `this.fetch()` */
@@ -21,18 +41,6 @@ export declare class ClientAPIProvider<P = unknown, R = unknown> implements APIP
     /** Internal implementation function for `getRequest()` used for requests that have a body.  */
     protected _getBodyRequest(method: RequestBodyMethod, //
     url: PossibleURL, payload: P, options: RequestOptions, caller: AnyCaller): Request;
+    fetch(request: Request): Promise<Response>;
     parseResponse<PP extends P, RR extends R>(_endpoint: Endpoint<PP, RR>, response: Response, caller?: AnyCaller): Promise<RR>;
-    fetch<PP extends P, RR extends R>(endpoint: Endpoint<PP, RR>, payload: PP, options?: RequestOptions, caller?: AnyCaller): Promise<RR>;
-}
-/** Options for an `APIProvider`. */
-export interface ClientAPIProviderOptions {
-    /** The common base URL for all rendered endpoint requests. */
-    readonly url: PossibleURL;
-    /**
-     * Options used for HTTP requests created with `this.getRequest()` and `this.fetch()`
-     * - Omits `signal` because it's not relevant at the provider level.
-     */
-    readonly options?: Omit<RequestOptions, "signal">;
-    /** Timeout in milliseconds, or `undefined` for no timeout. */
-    readonly timeout?: number | undefined;
 }

package/api/provider/ClientAPIProvider.js

@@ -5,7 +5,16 @@ import { assertRequestHeadPayload, getHeadRequest, getRequest, isRequestHeadMeth
 import { omitProps } from "../../util/object.js";
 import { withURIParams } from "../../util/uri.js";
 import { requireBaseURL, requireURL } from "../../util/url.js";
-export class ClientAPIProvider {
+import { APIProvider } from "./APIProvider.js";
+/**
+ * A client-side API provider that sends requests over the network using `fetch()`.
+ * - Can be used on a server environment to make outgoing API calls, or in a browser environment to call a server API.
+ * - Renders endpoint paths and query params into the URL and sends body payloads as JSON.
+ * - Parses JSON responses and throws `ResponseError` for non-2xx responses.
+ * - Extendable with custom request-building and response-parsing logic by overriding `getRequest()` and `parseResponse()`.
+ * - Wrap in `ValidationAPIProvider` to add automatic validation of request payloads and response results against endpoint schemas.
+ */
+export class ClientAPIProvider extends APIProvider {
     /** The common base URL for all rendered endpoint requests. */
     url;
     /** Default options used for HTTP requests created with `this.getRequest()` and `this.fetch()` */
@@ -13,6 +22,7 @@ export class ClientAPIProvider {
     /** Timeout in milliseconds, or `undefined` for no timeout. */
     timeout;
     constructor({ url, options = {}, timeout }) {
+        super();
         this.url = requireBaseURL(url, undefined, ClientAPIProvider);
         this.options = options;
         this.timeout = timeout;
@@ -53,6 +63,10 @@ export class ClientAPIProvider {
     url, payload, options, caller) {
         return getRequest(method, url, payload, options, caller);
     }
+    // Override to set default functionality of a client provider to send requests over the network with `fetch()` and parse responses with `parseResponse()`.
+    async fetch(request) {
+        return fetch(request);
+    }
     async parseResponse(_endpoint, response, caller = this.parseResponse) {
         const { ok, status } = response;
         const content = await parseResponseBody(response, caller);
@@ -60,9 +74,4 @@ export class ClientAPIProvider {
             throw new ResponseError(getMessage(content) ?? `Error ${status}`, { code: status, cause: response, caller });
         return content;
     }
-    async fetch(endpoint, payload, options, caller = this.fetch) {
-        const request = this.getRequest(endpoint, payload, options, caller);
-        const response = await fetch(request);
-        return this.parseResponse(endpoint, response, caller);
-    }
 }

package/api/provider/DebugAPIProvider.d.ts

@@ -4,5 +4,5 @@ import type { Endpoint } from "../endpoint/Endpoint.js";
 import { ThroughAPIProvider } from "./ThroughAPIProvider.js";
 /** Provider that logs API operations to the console. */
 export declare class DebugAPIProvider<P, R> extends ThroughAPIProvider<P, R> {
-    fetch<PP extends P, RR extends R>(endpoint: Endpoint<PP, RR>, payload: PP, options?: RequestOptions, caller?: AnyCaller): Promise<RR>;
+    call<PP extends P, RR extends R>(endpoint: Endpoint<PP, RR>, payload: PP, options?: RequestOptions, caller?: AnyCaller): Promise<RR>;
 }

package/api/provider/DebugAPIProvider.js

@@ -1,15 +1,37 @@
+import { debugFullRequest, debugFullResponse } from "../../util/debug.js";
 import { ThroughAPIProvider } from "./ThroughAPIProvider.js";
 /** Provider that logs API operations to the console. */
 export class DebugAPIProvider extends ThroughAPIProvider {
-    async fetch(endpoint, payload, options, caller = this.fetch) {
+    async call(endpoint, payload, options, caller = this.call) {
+        // Turn the payload into a request and debug it before sending.
+        let request;
         try {
-            console.debug("⋯ FETCH", endpoint.method, endpoint.path, payload);
-            const result = await super.fetch(endpoint, payload, options, caller);
-            console.debug("↩ FETCH", endpoint.method, endpoint.path, result);
+            request = this.getRequest(endpoint, payload, options, caller);
+        }
+        catch (reason) {
+            console.error("✘ FETCH", this.url, endpoint.toString(), payload, reason);
+            throw reason;
+        }
+        const debuggedRequest = await debugFullRequest(request);
+        console.debug("… FETCH", this.url, endpoint.toString(), payload, debuggedRequest);
+        // Fetch the response and debug if it throws.
+        let response;
+        try {
+            response = await this.fetch(request);
+        }
+        catch (reason) {
+            console.error("✘ FETCH", this.url, endpoint.toString(), payload, debuggedRequest, reason);
+            throw reason;
+        }
+        const debuggedResponse = await debugFullResponse(response);
+        // Convert the  result or any parsing error.
+        try {
+            const result = await this.parseResponse(endpoint, response, caller);
+            console.debug("✔ FETCH", this.url, endpoint.toString(), payload, debuggedRequest, debuggedResponse, result);
             return result;
         }
         catch (reason) {
-            console.error("✘ FETCH", endpoint.method, endpoint.path, payload, reason);
+            console.error("✘ FETCH", this.url, endpoint.toString(), payload, debuggedRequest, debuggedResponse, reason);
             throw reason;
         }
     }

package/api/provider/MockAPIProvider.d.ts

@@ -1,14 +1,20 @@
 import type { AnyCaller } from "../../util/function.js";
 import type { RequestHandler, RequestOptions } from "../../util/http.js";
 import type { AnyEndpoint, Endpoint } from "../endpoint/Endpoint.js";
-import { ClientAPIProvider } from "./ClientAPIProvider.js";
+import type { APIProvider } from "./APIProvider.js";
 import { ThroughAPIProvider } from "./ThroughAPIProvider.js";
-/** A structured log entry emitted by `MockAPIProvider` for one of its provider operations. */
-export type MockAPICall = {
-    readonly type: "fetch";
+export type MockAPIFetchCall = {
+    readonly request: Request;
+    readonly response: Response;
+};
+export type MockAPIRequestCall = {
     readonly endpoint: AnyEndpoint;
     readonly payload: unknown;
+    readonly options: RequestOptions | undefined;
     readonly request: Request;
+};
+export type MockAPIResponseCall = {
+    readonly endpoint: AnyEndpoint;
     readonly response: Response;
     readonly result: unknown;
 };
@@ -18,8 +24,12 @@ export type MockAPICall = {
  * - The source provider's `fetch()` is never called — this provider intercepts all fetches and routes them through a `RequestHandler`.
  */
 export declare class MockAPIProvider<P = unknown, R = unknown> extends ThroughAPIProvider<P, R> {
-    readonly calls: MockAPICall[];
+    readonly requestCalls: MockAPIRequestCall[];
+    readonly fetchCalls: MockAPIFetchCall[];
+    readonly responseCalls: MockAPIResponseCall[];
     readonly handler: RequestHandler;
-    constructor(handler?: RequestHandler, source?: ClientAPIProvider<P, R>);
-    fetch<PP extends P, RR extends R>(endpoint: Endpoint<PP, RR>, payload: PP, options?: RequestOptions, caller?: AnyCaller): Promise<RR>;
+    constructor(handler?: RequestHandler, source?: APIProvider<P, R>);
+    getRequest<PP extends P, RR extends R>(endpoint: Endpoint<PP, RR>, payload: PP, options?: RequestOptions, caller?: AnyCaller): Request;
+    parseResponse<PP extends P, RR extends R>(endpoint: Endpoint<PP, RR>, response: Response, caller?: AnyCaller): Promise<RR>;
+    fetch(request: Request): Promise<Response>;
 }

package/api/provider/MockAPIProvider.js

@@ -1,8 +1,9 @@
+import { debugRequest } from "../../util/debug.js";
 import { ClientAPIProvider } from "./ClientAPIProvider.js";
 import { ThroughAPIProvider } from "./ThroughAPIProvider.js";
 /** Default handler just echoes back the input request as text. */
-async function _passthroughHandler(request) {
-    return new Response(await request.text());
+async function _mockHandler(request) {
+    return new Response(`Mocked response to ${debugRequest(request)}`, { status: 200, statusText: "OK" });
 }
 /**
  * Provider that logs API calls without sending network requests.
@@ -10,18 +11,30 @@ async function _passthroughHandler(request) {
  * - The source provider's `fetch()` is never called — this provider intercepts all fetches and routes them through a `RequestHandler`.
  */
 export class MockAPIProvider extends ThroughAPIProvider {
-    calls = [];
+    requestCalls = [];
+    fetchCalls = [];
+    responseCalls = [];
     handler;
-    constructor(handler = _passthroughHandler, source = new ClientAPIProvider({ url: "https://api.mock.com" })) {
+    constructor(handler = _mockHandler, source = new ClientAPIProvider({ url: "https://api.mock.com" })) {
         super(source);
         this.handler = handler;
     }
-    // Log a `fetch()` call without using the network.
-    async fetch(endpoint, payload, options = {}, caller = this.fetch) {
-        const request = this.getRequest(endpoint, payload, options, caller);
-        const response = await this.handler(request);
-        const result = await this.parseResponse(endpoint, response, caller);
-        this.calls.push({ type: "fetch", endpoint, payload, request, response, result });
+    // Override `getRequest()` to log the endpoint and payload before delegating to the source provider for request building.
+    getRequest(endpoint, payload, options, caller = this.getRequest) {
+        const request = super.getRequest(endpoint, payload, options, caller);
+        this.requestCalls.push({ endpoint, payload, options, request });
+        return request;
+    }
+    // Override `parseResponse()` to log the response and result.
+    async parseResponse(endpoint, response, caller = this.parseResponse) {
+        const result = await super.parseResponse(endpoint, response, caller);
+        this.responseCalls.push({ endpoint, response, result });
         return result;
     }
+    // Override `fetch()` to route through the handler instead of the network.
+    async fetch(request) {
+        const response = await this.handler(request);
+        this.fetchCalls.push({ request, response });
+        return response;
+    }
 }

package/api/provider/MockEndpointAPIProvider.js

@@ -13,6 +13,6 @@ import { MockAPIProvider } from "./MockAPIProvider.js";
  */
 export class MockEndpointAPIProvider extends MockAPIProvider {
     constructor(handlers, context, source) {
-        super(request => handleEndpoints(this.url, handlers, request, context, this.fetch), source);
+        super(request => handleEndpoints(this.url, handlers, request, context, this.call), source);
     }
 }

package/api/provider/ThroughAPIProvider.d.ts

@@ -3,17 +3,17 @@ import type { RequestOptions } from "../../util/http.js";
 import type { Sourceable } from "../../util/source.js";
 import type { URL, URLString } from "../../util/url.js";
 import type { Endpoint } from "../endpoint/Endpoint.js";
-import type { APIProvider } from "./APIProvider.js";
+import { APIProvider } from "./APIProvider.js";
 /**
  * Provider wrapper that delegates API operations to a source provider.
  * - Extend this when you want to intercept only selected API operations, such as injecting auth headers or logging.
  */
-export declare class ThroughAPIProvider<P, R> implements APIProvider<P, R>, Sourceable<APIProvider<P, R>> {
+export declare class ThroughAPIProvider<P, R> extends APIProvider<P, R> implements Sourceable<APIProvider<P, R>> {
     get url(): URLString;
     readonly source: APIProvider<P, R>;
     constructor(source: APIProvider<P, R>);
     renderURL<PP extends P, RR extends R>(endpoint: Endpoint<PP, RR>, payload: PP, caller?: AnyCaller): URL;
     getRequest<PP extends P, RR extends R>(endpoint: Endpoint<PP, RR>, payload: PP, options?: RequestOptions, caller?: AnyCaller): Request;
     parseResponse<PP extends P, RR extends R>(endpoint: Endpoint<PP, RR>, response: Response, caller?: AnyCaller): Promise<RR>;
-    fetch<PP extends P, RR extends R>(endpoint: Endpoint<PP, RR>, payload: PP, options?: RequestOptions, caller?: AnyCaller): Promise<RR>;
+    fetch(request: Request): Promise<Response>;
 }

package/api/provider/ThroughAPIProvider.js

@@ -1,13 +1,15 @@
+import { APIProvider } from "./APIProvider.js";
 /**
  * Provider wrapper that delegates API operations to a source provider.
  * - Extend this when you want to intercept only selected API operations, such as injecting auth headers or logging.
  */
-export class ThroughAPIProvider {
+export class ThroughAPIProvider extends APIProvider {
     get url() {
         return this.source.url;
     }
     source;
     constructor(source) {
+        super();
         this.source = source;
     }
     renderURL(endpoint, payload, caller = this.renderURL) {
@@ -19,7 +21,7 @@ export class ThroughAPIProvider {
     parseResponse(endpoint, response, caller = this.parseResponse) {
         return this.source.parseResponse(endpoint, response, caller);
     }
-    fetch(endpoint, payload, options, caller = this.fetch) {
-        return this.source.fetch(endpoint, payload, options, caller);
+    fetch(request) {
+        return this.source.fetch(request);
     }
 }

package/api/provider/ValidationAPIProvider.d.ts

@@ -4,5 +4,6 @@ import type { Endpoint } from "../endpoint/Endpoint.js";
 import { ThroughAPIProvider } from "./ThroughAPIProvider.js";
 /** Validate an asynchronous source provider (source can have any type because validation guarantees the type). */
 export declare class ValidationAPIProvider<P, R> extends ThroughAPIProvider<P, R> {
-    fetch<PP extends P, RR extends R>(endpoint: Endpoint<PP, RR>, payload: PP, options?: RequestOptions, caller?: AnyCaller): Promise<RR>;
+    getRequest<PP extends P, RR extends R>(endpoint: Endpoint<PP, RR>, payload: PP, options?: RequestOptions, caller?: AnyCaller): Request;
+    parseResponse<PP extends P, RR extends R>(endpoint: Endpoint<PP, RR>, response: Response, caller?: AnyCaller): Promise<RR>;
 }

package/api/provider/ValidationAPIProvider.js

@@ -2,22 +2,19 @@ import { ResponseError } from "../../error/ResponseError.js";
 import { ThroughAPIProvider } from "./ThroughAPIProvider.js";
 /** Validate an asynchronous source provider (source can have any type because validation guarantees the type). */
 export class ValidationAPIProvider extends ThroughAPIProvider {
-    async fetch(endpoint, payload, options, caller = this.fetch) {
+    getRequest(endpoint, payload, options, caller = this.getRequest) {
         // Validate payload — let thrown strings bubble up as user-readable messages for e.g. form handlers.
-        const validPayload = endpoint.payload.validate(payload);
-        // Call through to source (raw transport, no schema validation).
-        const content = await this.source.fetch(endpoint, validPayload, options, caller);
-        // Validate result — wrap in ResponseError as this is a server/transport problem, not user error.
-        return _validateResult(endpoint, content, caller);
+        return super.getRequest(endpoint, endpoint.payload.validate(payload), options, caller);
     }
-}
-function _validateResult(endpoint, content, caller) {
-    try {
-        return endpoint.result.validate(content);
-    }
-    catch (thrown) {
-        if (typeof thrown === "string")
-            throw new ResponseError(`Invalid result for ${endpoint}:\n${thrown}`, { endpoint, code: 422, caller });
-        throw thrown;
+    async parseResponse(endpoint, response, caller = this.parseResponse) {
+        try {
+            // Validate result — wrap in ResponseError as this is a server/transport problem, not user error.
+            return endpoint.result.validate(await super.parseResponse(endpoint, response, caller));
+        }
+        catch (thrown) {
+            if (typeof thrown === "string")
+                throw new ResponseError(`Invalid result for ${endpoint}:\n${thrown}`, { provider: this, endpoint, code: 422, caller });
+            throw thrown;
+        }
     }
 }

package/api/provider/XMLAPIProvider.d.ts

@@ -5,7 +5,7 @@ import type { PossibleURL } from "../../util/url.js";
 import type { Endpoint } from "../endpoint/Endpoint.js";
 import { ClientAPIProvider } from "./ClientAPIProvider.js";
 /** API provider that always sends request bodies as XML and parses responses as plain text. */
-export declare class XMLAPIProvider<P extends Data = Data, R = string> extends ClientAPIProvider<P, R> {
+export declare class XMLAPIProvider<P extends Data = Data, R extends string = string> extends ClientAPIProvider<P, R> {
     protected _getBodyRequest(method: RequestBodyMethod, url: PossibleURL, payload: P, options: RequestOptions, caller: AnyCaller): Request;
     /**
      * Parse a text `Response` for an endpoint.

package/api/store/EndpointStore.js

@@ -93,7 +93,7 @@ export class EndpointStore extends Store {
     /** Fetch the result from the API endpoint now. */
     async _fetch(abort) {
         try {
-            const value = await this.provider.fetch(this.endpoint, this._payload, { signal: abort.signal });
+            const value = await this.provider.call(this.endpoint, this._payload, { signal: abort.signal });
             this.reason = undefined;
             this.value = value;
         }

package/db/collection/Collection.d.ts

@@ -15,6 +15,7 @@ export declare class Collection<N extends string = string, I extends Identifier
     /** Schema for a complete item (id + data). */
     readonly item: DataSchema<Item<I, T>>;
     constructor(name: N, id: Schema<I>, data: Schemas<T> | DataSchema<T>);
+    toString(): string;
 }
 /** Shortcut factory for creating a Collection. */
 export declare function COLLECTION<K extends string, I extends Identifier, T extends Data>(name: K, id: Schema<I>, data: Schemas<T> | DataSchema<T>): Collection<K, I, T>;

package/db/collection/Collection.js

@@ -24,6 +24,9 @@ export class Collection extends DataSchema {
         this.id = id;
         this.item = ITEM(id, dataSchema);
     }
+    toString() {
+        return this.name;
+    }
 }
 /** Shortcut factory for creating a Collection. */
 export function COLLECTION(name, id, data) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "shelving",
-	"version": "1.184.1",
+	"version": "1.185.1",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"repository": {
 		"type": "git",

package/util/debug.d.ts

@@ -6,6 +6,25 @@ import type { ImmutableSet } from "./set.js";
 export declare function debug(value: unknown, depth?: number): string;
 /** Debug a string. */
 export declare const debugString: (value: string) => string;
+/** Debug a set of `Headers` as a string. */
+export declare function debugHeaders(headers: Headers): string;
+/**
+ * Debug a full `Request` as a string including its body.
+ * - Clones the request before reading the body so the original request can still be sent or parsed later.
+ * - Omits the body section when the request body is empty.
+ */
+export declare function debugFullRequest(request: Request): Promise<string>;
+/**
+ * Debug a full `Response` as a string including its headers and body.
+ * - Clones the response before reading the body so the original response can still be parsed later.
+ * - Omits the headers section when there are no headers.
+ * - Omits the body section when the response body is empty.
+ */
+export declare function debugFullResponse(response: Response): Promise<string>;
+/** Debug a `Request` as a string. */
+export declare function debugRequest(request: Request): string;
+/** Debug a `Response` as a string. */
+export declare function debugResponse(response: Response): string;
 /** Debug an array. */
 export declare function debugArray(value: ImmutableArray, depth?: number): string;
 /** Debug a set. */

package/util/debug.js

@@ -19,6 +19,12 @@ export function debug(value, depth = 1) {
             return value.toISOString();
         if (value instanceof Error)
             return value.toString();
+        if (value instanceof Request)
+            return debugRequest(value);
+        if (value instanceof Response)
+            return debugResponse(value);
+        if (value instanceof Headers)
+            return debugHeaders(value);
         // biome-ignore lint/suspicious/useIsArray: Intential in this context.
         if (value instanceof Array)
             return debugArray(value, depth);
@@ -45,6 +51,43 @@ const ESCAPE_LIST = {
     "\v": "\\v",
 };
 const _escapeChar = (char) => ESCAPE_LIST[char] || `\\x${char.charCodeAt(0).toString(16).padStart(2, "00")}`;
+/** Debug a set of `Headers` as a string. */
+export function debugHeaders(headers) {
+    return Array.from(headers, ([key, value]) => `${key}: ${value}`).join("\n");
+}
+/**
+ * Debug a full `Request` as a string including its body.
+ * - Clones the request before reading the body so the original request can still be sent or parsed later.
+ * - Omits the body section when the request body is empty.
+ */
+export async function debugFullRequest(request) {
+    return _debugFullMessage(debugRequest(request), request);
+}
+/**
+ * Debug a full `Response` as a string including its headers and body.
+ * - Clones the response before reading the body so the original response can still be parsed later.
+ * - Omits the headers section when there are no headers.
+ * - Omits the body section when the response body is empty.
+ */
+export async function debugFullResponse(response) {
+    return _debugFullMessage(debugResponse(response), response);
+}
+async function _debugFullMessage(head, message) {
+    const headers = debugHeaders(message.headers);
+    const body = await _debugMessageBody(message);
+    return `${head}${headers && `\n${headers}`}${body && `\n\n${body}`}`;
+}
+async function _debugMessageBody(message) {
+    return message.bodyUsed ? "[body used]" : await message.clone().text();
+}
+/** Debug a `Request` as a string. */
+export function debugRequest(request) {
+    return `${request.method} ${request.url}`;
+}
+/** Debug a `Response` as a string. */
+export function debugResponse(response) {
+    return `${response.status} ${response.statusText}`;
+}
 /** Debug an array. */
 export function debugArray(value, depth = 1) {
     const prototype = Object.getPrototypeOf(value);