shelving 1.258.5 → 1.258.7

package/api/provider/LoggingAPIProvider.d.ts

@@ -5,24 +5,12 @@ import { ThroughAPIProvider } from "./ThroughAPIProvider.js";
  * Provider that logs fetches to the console to keep useful request/response logs in production.
  * - Defaults to logging requests, responses, and errors via the `log` utilities; each can be overridden.
  *
- * @example
- *  const api = new LoggingAPIProvider(source);
- *  await api.fetch(request); // logs request and response
  * @see https://shelving.cc/api/LoggingAPIProvider
  */
 export declare class LoggingAPIProvider<P, R> extends ThroughAPIProvider<P, R> {
     protected _logRequest: Callback<[Request]>;
     protected _logResponse: Callback<[Response, Request]>;
     protected _logError: Callback<[reason: unknown, Request]>;
-    /**
-     * Create a logging provider wrapping a source provider.
-     *
-     * @param source The source provider whose fetches are logged.
-     * @param onRequest Called to log each outgoing request.
-     * @param onResponse Called to log each response.
-     * @param onError Called to log each error.
-     * @example new LoggingAPIProvider(source)
-     */
     constructor(source: APIProvider<P, R>, 
     /** Log requests. */
     onRequest?: Callback<[Request]>, 
@@ -30,14 +18,6 @@ export declare class LoggingAPIProvider<P, R> extends ThroughAPIProvider<P, R> {
     onResponse?: Callback<[Response, Request]>, 
     /** Log errors for requests. */
     onError?: Callback<[reason: unknown, Request]>);
-    /**
-     * Fetch a request through the source provider, logging the request, response, and any error.
-     *
-     * @param request The request to fetch.
-     * @returns Promise resolving to the response.
-     * @throws Rethrows any error thrown by the source provider (after logging it).
-     * @example await api.fetch(request)
-     * @see https://shelving.cc/api/LoggingAPIProvider/fetch
-     */
+    /** Log the request, response, and any error while fetching. */
     fetch(request: Request): Promise<Response>;
 }

package/api/provider/LoggingAPIProvider.js

@@ -4,24 +4,12 @@ import { ThroughAPIProvider } from "./ThroughAPIProvider.js";
  * Provider that logs fetches to the console to keep useful request/response logs in production.
  * - Defaults to logging requests, responses, and errors via the `log` utilities; each can be overridden.
  *
- * @example
- *  const api = new LoggingAPIProvider(source);
- *  await api.fetch(request); // logs request and response
  * @see https://shelving.cc/api/LoggingAPIProvider
  */
 export class LoggingAPIProvider extends ThroughAPIProvider {
     _logRequest;
     _logResponse;
     _logError;
-    /**
-     * Create a logging provider wrapping a source provider.
-     *
-     * @param source The source provider whose fetches are logged.
-     * @param onRequest Called to log each outgoing request.
-     * @param onResponse Called to log each response.
-     * @param onError Called to log each error.
-     * @example new LoggingAPIProvider(source)
-     */
     constructor(source, 
     /** Log requests. */
     onRequest = logRequest, 
@@ -34,15 +22,7 @@ export class LoggingAPIProvider extends ThroughAPIProvider {
         this._logResponse = onResponse;
         this._logError = onError;
     }
-    /**
-     * Fetch a request through the source provider, logging the request, response, and any error.
-     *
-     * @param request The request to fetch.
-     * @returns Promise resolving to the response.
-     * @throws Rethrows any error thrown by the source provider (after logging it).
-     * @example await api.fetch(request)
-     * @see https://shelving.cc/api/LoggingAPIProvider/fetch
-     */
+    /** Log the request, response, and any error while fetching. */
     async fetch(request) {
         try {
             this._logRequest(request);

package/api/provider/MockAPIProvider.d.ts

@@ -36,10 +36,6 @@ export type MockAPIResponseCall = {
  * - The source provider's `fetch()` is never called — this provider intercepts all fetches and routes them through a `RequestHandler`.
  * - Records `requestCalls`, `fetchCalls`, and `responseCalls` so tests can assert on what happened.
  *
- * @example
- *  const api = new MockAPIProvider();
- *  const result = await api.call(endpoint, payload);
- *  expect(api.fetchCalls).toHaveLength(1);
  * @see https://shelving.cc/api/MockAPIProvider
  */
 export declare class MockAPIProvider<P = unknown, R = unknown> extends ThroughAPIProvider<P, R> {
@@ -63,44 +59,11 @@ export declare class MockAPIProvider<P = unknown, R = unknown> extends ThroughAP
      * @see https://shelving.cc/api/MockAPIProvider/handler
      */
     readonly handler: RequestHandler;
-    /**
-     * Create a mock provider that serves fetches from a handler.
-     *
-     * @param handler The handler that produces a response for each request (defaults to echoing the request).
-     * @param source The source provider used to build requests and parse responses.
-     * @example new MockAPIProvider()
-     */
     constructor(handler?: RequestHandler, source?: APIProvider<P, R>);
-    /**
-     * Build a request via the source provider, recording the endpoint and payload in `requestCalls`.
-     *
-     * @param endpoint The endpoint to build a request for.
-     * @param payload The payload to send.
-     * @param options Optional request options.
-     * @param caller The calling function used for error stack traces.
-     * @returns The built request.
-     * @example api.createRequest(endpoint, payload)
-     * @see https://shelving.cc/api/MockAPIProvider/createRequest
-     */
+    /** Record the endpoint and payload in `requestCalls` while building the request. */
     createRequest<PP extends P, RR extends R>(endpoint: Endpoint<PP, RR>, payload: PP, options?: RequestOptions, caller?: AnyCaller): Request;
-    /**
-     * Parse a response via the source provider, recording the response and result in `responseCalls`.
-     *
-     * @param endpoint The endpoint the response came from.
-     * @param response The response to parse.
-     * @param caller The calling function used for error stack traces.
-     * @returns Promise resolving to the parsed result.
-     * @example await api.parseResponse(endpoint, response)
-     * @see https://shelving.cc/api/MockAPIProvider/parseResponse
-     */
+    /** Record the response and result in `responseCalls` while parsing the response. */
     parseResponse<PP extends P, RR extends R>(endpoint: Endpoint<PP, RR>, response: Response, caller?: AnyCaller): Promise<RR>;
-    /**
-     * Serve a request through the handler instead of the network, recording it in `fetchCalls`.
-     *
-     * @param request The request to handle.
-     * @returns Promise resolving to the handler's response.
-     * @example await api.fetch(request)
-     * @see https://shelving.cc/api/MockAPIProvider/fetch
-     */
+    /** Serve the request through the handler instead of the network, recording it in `fetchCalls`. */
     fetch(request: Request): Promise<Response>;
 }

package/api/provider/MockAPIProvider.js

@@ -11,10 +11,6 @@ async function _mockHandler(request) {
  * - The source provider's `fetch()` is never called — this provider intercepts all fetches and routes them through a `RequestHandler`.
  * - Records `requestCalls`, `fetchCalls`, and `responseCalls` so tests can assert on what happened.
  *
- * @example
- *  const api = new MockAPIProvider();
- *  const result = await api.call(endpoint, payload);
- *  expect(api.fetchCalls).toHaveLength(1);
  * @see https://shelving.cc/api/MockAPIProvider
  */
 export class MockAPIProvider extends ThroughAPIProvider {
@@ -38,56 +34,23 @@ export class MockAPIProvider extends ThroughAPIProvider {
      * @see https://shelving.cc/api/MockAPIProvider/handler
      */
     handler;
-    /**
-     * Create a mock provider that serves fetches from a handler.
-     *
-     * @param handler The handler that produces a response for each request (defaults to echoing the request).
-     * @param source The source provider used to build requests and parse responses.
-     * @example new MockAPIProvider()
-     */
     constructor(handler = _mockHandler, source = new ClientAPIProvider({ url: "https://api.mock.com" })) {
         super(source);
         this.handler = handler;
     }
-    /**
-     * Build a request via the source provider, recording the endpoint and payload in `requestCalls`.
-     *
-     * @param endpoint The endpoint to build a request for.
-     * @param payload The payload to send.
-     * @param options Optional request options.
-     * @param caller The calling function used for error stack traces.
-     * @returns The built request.
-     * @example api.createRequest(endpoint, payload)
-     * @see https://shelving.cc/api/MockAPIProvider/createRequest
-     */
+    /** Record the endpoint and payload in `requestCalls` while building the request. */
     createRequest(endpoint, payload, options, caller = this.createRequest) {
         const request = super.createRequest(endpoint, payload, options, caller);
         this.requestCalls.push({ endpoint, payload, options, request });
         return request;
     }
-    /**
-     * Parse a response via the source provider, recording the response and result in `responseCalls`.
-     *
-     * @param endpoint The endpoint the response came from.
-     * @param response The response to parse.
-     * @param caller The calling function used for error stack traces.
-     * @returns Promise resolving to the parsed result.
-     * @example await api.parseResponse(endpoint, response)
-     * @see https://shelving.cc/api/MockAPIProvider/parseResponse
-     */
+    /** Record the response and result in `responseCalls` while parsing the response. */
     async parseResponse(endpoint, response, caller = this.parseResponse) {
         const result = await super.parseResponse(endpoint, response, caller);
         this.responseCalls.push({ endpoint, response, result });
         return result;
     }
-    /**
-     * Serve a request through the handler instead of the network, recording it in `fetchCalls`.
-     *
-     * @param request The request to handle.
-     * @returns Promise resolving to the handler's response.
-     * @example await api.fetch(request)
-     * @see https://shelving.cc/api/MockAPIProvider/fetch
-     */
+    /** Serve the request through the handler instead of the network, recording it in `fetchCalls`. */
     async fetch(request) {
         const response = await this.handler(request);
         this.fetchCalls.push({ request, response });

package/api/provider/MockEndpointAPIProvider.d.ts

@@ -5,22 +5,8 @@ import { MockAPIProvider } from "./MockAPIProvider.js";
  * Provider that mocks an API that calls and matches an array of `EndpointHandler` objects returned from `Endpoint.handler()`
  * - Used to test server-side API code, calls against an API made up of multiple `Endpoint` instances.
  *
- * @example
- *  const endpoint = POST("/squared", INTEGER, INTEGER); // Create an endpoint designed to square its input number.
- *  const handlers = [endpoint.handler(num => num * num)]; // Implement handlers for the endpoints.
- * 	const api = new MockEnpdointAPIProvider(handlers); // Create a new mock provider.
- *  const result = await api.fetch(endpoint, 4); // Mock a call to the endpoint through the provider.
- *  expect(result).toBe(16);
  * @see https://shelving.cc/api/MockEndpointAPIProvider
  */
 export declare class MockEndpointAPIProvider<P, R, C> extends MockAPIProvider<P, R> {
-    /**
-     * Create a mock provider that routes calls through an array of endpoint handlers instead of the network.
-     *
-     * @param handlers The endpoint handlers (from `Endpoint.handler()`) that serve matching requests.
-     * @param context The context value passed to each handler.
-     * @param source Optional source provider used to build requests and parse responses.
-     * @example new MockEndpointAPIProvider(handlers, context)
-     */
     constructor(handlers: EndpointHandlers<C>, context: C, source?: ClientAPIProvider<P, R>);
 }

package/api/provider/MockEndpointAPIProvider.js

@@ -4,23 +4,9 @@ import { MockAPIProvider } from "./MockAPIProvider.js";
  * Provider that mocks an API that calls and matches an array of `EndpointHandler` objects returned from `Endpoint.handler()`
  * - Used to test server-side API code, calls against an API made up of multiple `Endpoint` instances.
  *
- * @example
- *  const endpoint = POST("/squared", INTEGER, INTEGER); // Create an endpoint designed to square its input number.
- *  const handlers = [endpoint.handler(num => num * num)]; // Implement handlers for the endpoints.
- * 	const api = new MockEnpdointAPIProvider(handlers); // Create a new mock provider.
- *  const result = await api.fetch(endpoint, 4); // Mock a call to the endpoint through the provider.
- *  expect(result).toBe(16);
  * @see https://shelving.cc/api/MockEndpointAPIProvider
  */
 export class MockEndpointAPIProvider extends MockAPIProvider {
-    /**
-     * Create a mock provider that routes calls through an array of endpoint handlers instead of the network.
-     *
-     * @param handlers The endpoint handlers (from `Endpoint.handler()`) that serve matching requests.
-     * @param context The context value passed to each handler.
-     * @param source Optional source provider used to build requests and parse responses.
-     * @example new MockEndpointAPIProvider(handlers, context)
-     */
     constructor(handlers, context, source) {
         super(request => handleEndpoints(this.url, handlers, request, context, this.call), source);
     }

package/api/provider/ThroughAPIProvider.d.ts

@@ -8,21 +8,9 @@ import { APIProvider } from "./APIProvider.js";
  * - Extend this when you want to intercept only selected API operations, such as injecting auth headers or logging.
  * - Implements `Sourceable` so wrapped providers are discoverable via `getSource()` / `requireSource()`.
  *
- * @example
- * class AuthAPIProvider extends ThroughAPIProvider {
- * 	override createRequest(endpoint, payload, options, caller) {
- * 		return super.createRequest(endpoint, payload, { ...options, headers: { authorization: TOKEN } }, caller);
- * 	}
- * }
- *
  * @see https://shelving.cc/api/ThroughAPIProvider
  */
 export declare class ThroughAPIProvider<P, R> extends APIProvider<P, R> implements Sourceable<APIProvider<P, R>> {
-    /**
-     * The base URL, delegated to the wrapped `source` provider.
-     *
-     * @see https://shelving.cc/api/ThroughAPIProvider/url
-     */
     get url(): URL;
     /**
      * The wrapped source provider that operations delegate to.
@@ -30,56 +18,10 @@ export declare class ThroughAPIProvider<P, R> extends APIProvider<P, R> implemen
      * @see https://shelving.cc/api/ThroughAPIProvider/source
      */
     readonly source: APIProvider<P, R>;
-    /**
-     * Wrap a source `APIProvider`.
-     *
-     * @param source The provider that every operation delegates to.
-     * @example new ThroughAPIProvider(clientProvider)
-     * @see https://shelving.cc/api/ThroughAPIProvider
-     */
     constructor(source: APIProvider<P, R>);
-    /**
-     * Render the request URL by delegating to the source provider.
-     *
-     * @param endpoint The endpoint whose path is rendered into the base URL.
-     * @param payload The payload supplying `{placeholder}` and query-param values.
-     * @param caller The function to attribute thrown errors to (defaults to this method).
-     * @returns The fully resolved request `URL`.
-     * @example provider.renderURL(getUser, { id: "abc" })
-     * @see https://shelving.cc/api/ThroughAPIProvider/renderURL
-     */
     renderURL<PP extends P, RR extends R>(endpoint: Endpoint<PP, RR>, payload: PP, caller?: AnyCaller): URL;
-    /**
-     * Create the request by delegating to the source provider.
-     *
-     * @param endpoint The endpoint the request targets.
-     * @param payload The payload to embed into the `Request`.
-     * @param options The `RequestOptions` to use, merged over the provider's own options.
-     * @param caller The function to attribute thrown errors to (defaults to this method).
-     * @returns The created `Request`.
-     * @example provider.createRequest(getUser, { id: "abc" })
-     * @see https://shelving.cc/api/ThroughAPIProvider/createRequest
-     */
     createRequest<PP extends P, RR extends R>(endpoint: Endpoint<PP, RR>, payload: PP, options?: RequestOptions, caller?: AnyCaller): Request;
-    /**
-     * Parse the response by delegating to the source provider.
-     *
-     * @param endpoint The endpoint the response was produced for.
-     * @param response The `Response` to parse.
-     * @param caller The function to attribute thrown errors to (defaults to this method).
-     * @returns A promise resolving to the parsed result.
-     * @example await provider.parseResponse(getUser, response)
-     * @see https://shelving.cc/api/ThroughAPIProvider/parseResponse
-     */
     parseResponse<PP extends P, RR extends R>(endpoint: Endpoint<PP, RR>, response: Response, caller?: AnyCaller): Promise<RR>;
-    /**
-     * Send the request by delegating to the source provider.
-     *
-     * @param request The `Request` to send.
-     * @returns A promise resolving to the `Response`.
-     * @example await provider.fetch(request)
-     * @see https://shelving.cc/api/ThroughAPIProvider/fetch
-     */
     fetch(request: Request): Promise<Response>;
     [Symbol.asyncDispose](): Promise<void>;
 }

package/api/provider/ThroughAPIProvider.js

@@ -5,21 +5,9 @@ import { APIProvider } from "./APIProvider.js";
  * - Extend this when you want to intercept only selected API operations, such as injecting auth headers or logging.
  * - Implements `Sourceable` so wrapped providers are discoverable via `getSource()` / `requireSource()`.
  *
- * @example
- * class AuthAPIProvider extends ThroughAPIProvider {
- * 	override createRequest(endpoint, payload, options, caller) {
- * 		return super.createRequest(endpoint, payload, { ...options, headers: { authorization: TOKEN } }, caller);
- * 	}
- * }
- *
  * @see https://shelving.cc/api/ThroughAPIProvider
  */
 export class ThroughAPIProvider extends APIProvider {
-    /**
-     * The base URL, delegated to the wrapped `source` provider.
-     *
-     * @see https://shelving.cc/api/ThroughAPIProvider/url
-     */
     get url() {
         return this.source.url;
     }
@@ -29,65 +17,19 @@ export class ThroughAPIProvider extends APIProvider {
      * @see https://shelving.cc/api/ThroughAPIProvider/source
      */
     source;
-    /**
-     * Wrap a source `APIProvider`.
-     *
-     * @param source The provider that every operation delegates to.
-     * @example new ThroughAPIProvider(clientProvider)
-     * @see https://shelving.cc/api/ThroughAPIProvider
-     */
     constructor(source) {
         super();
         this.source = source;
     }
-    /**
-     * Render the request URL by delegating to the source provider.
-     *
-     * @param endpoint The endpoint whose path is rendered into the base URL.
-     * @param payload The payload supplying `{placeholder}` and query-param values.
-     * @param caller The function to attribute thrown errors to (defaults to this method).
-     * @returns The fully resolved request `URL`.
-     * @example provider.renderURL(getUser, { id: "abc" })
-     * @see https://shelving.cc/api/ThroughAPIProvider/renderURL
-     */
     renderURL(endpoint, payload, caller = this.renderURL) {
         return this.source.renderURL(endpoint, payload, caller);
     }
-    /**
-     * Create the request by delegating to the source provider.
-     *
-     * @param endpoint The endpoint the request targets.
-     * @param payload The payload to embed into the `Request`.
-     * @param options The `RequestOptions` to use, merged over the provider's own options.
-     * @param caller The function to attribute thrown errors to (defaults to this method).
-     * @returns The created `Request`.
-     * @example provider.createRequest(getUser, { id: "abc" })
-     * @see https://shelving.cc/api/ThroughAPIProvider/createRequest
-     */
     createRequest(endpoint, payload, options, caller = this.createRequest) {
         return this.source.createRequest(endpoint, payload, options, caller);
     }
-    /**
-     * Parse the response by delegating to the source provider.
-     *
-     * @param endpoint The endpoint the response was produced for.
-     * @param response The `Response` to parse.
-     * @param caller The function to attribute thrown errors to (defaults to this method).
-     * @returns A promise resolving to the parsed result.
-     * @example await provider.parseResponse(getUser, response)
-     * @see https://shelving.cc/api/ThroughAPIProvider/parseResponse
-     */
     parseResponse(endpoint, response, caller = this.parseResponse) {
         return this.source.parseResponse(endpoint, response, caller);
     }
-    /**
-     * Send the request by delegating to the source provider.
-     *
-     * @param request The `Request` to send.
-     * @returns A promise resolving to the `Response`.
-     * @example await provider.fetch(request)
-     * @see https://shelving.cc/api/ThroughAPIProvider/fetch
-     */
     fetch(request) {
         return this.source.fetch(request);
     }

package/api/provider/ValidationAPIProvider.d.ts

@@ -6,35 +6,11 @@ import { ThroughAPIProvider } from "./ThroughAPIProvider.js";
  * Provider that validates payloads and results against the endpoint's schemas, so a source of any type is made type-safe.
  * - Payload validation errors bubble up as user-readable strings; result validation errors are wrapped in `ResponseError`.
  *
- * @example
- *  const api = new ValidationAPIProvider(source);
- *  const result = await api.call(endpoint, payload); // validated payload and result
  * @see https://shelving.cc/api/ValidationAPIProvider
  */
 export declare class ValidationAPIProvider<P, R> extends ThroughAPIProvider<P, R> {
-    /**
-     * Build a request via the source provider after validating the payload against the endpoint's payload schema.
-     *
-     * @param endpoint The endpoint to build a request for.
-     * @param payload The payload to validate and send.
-     * @param options Optional request options.
-     * @param caller The calling function used for error stack traces.
-     * @returns The built request.
-     * @throws {string} A user-readable validation message if the payload is invalid.
-     * @example api.createRequest(endpoint, payload)
-     * @see https://shelving.cc/api/ValidationAPIProvider/createRequest
-     */
+    /** Validates `payload` against the endpoint's payload schema before delegating; an invalid payload throws a user-readable `string`. */
     createRequest<PP extends P, RR extends R>(endpoint: Endpoint<PP, RR>, payload: PP, options?: RequestOptions, caller?: AnyCaller): Request;
-    /**
-     * Parse a response via the source provider, then validate the result against the endpoint's result schema.
-     *
-     * @param endpoint The endpoint the response came from.
-     * @param response The response to parse and validate.
-     * @param caller The calling function used for error stack traces.
-     * @returns Promise resolving to the validated result.
-     * @throws {ResponseError} If the result fails validation (treated as a server/transport problem).
-     * @example await api.parseResponse(endpoint, response)
-     * @see https://shelving.cc/api/ValidationAPIProvider/parseResponse
-     */
+    /** Validates the parsed result against the endpoint's result schema; a failed result is wrapped as a `ResponseError`. */
     parseResponse<PP extends P, RR extends R>(endpoint: Endpoint<PP, RR>, response: Response, caller?: AnyCaller): Promise<RR>;
 }

package/api/provider/ValidationAPIProvider.js

@@ -4,39 +4,15 @@ import { ThroughAPIProvider } from "./ThroughAPIProvider.js";
  * Provider that validates payloads and results against the endpoint's schemas, so a source of any type is made type-safe.
  * - Payload validation errors bubble up as user-readable strings; result validation errors are wrapped in `ResponseError`.
  *
- * @example
- *  const api = new ValidationAPIProvider(source);
- *  const result = await api.call(endpoint, payload); // validated payload and result
  * @see https://shelving.cc/api/ValidationAPIProvider
  */
 export class ValidationAPIProvider extends ThroughAPIProvider {
-    /**
-     * Build a request via the source provider after validating the payload against the endpoint's payload schema.
-     *
-     * @param endpoint The endpoint to build a request for.
-     * @param payload The payload to validate and send.
-     * @param options Optional request options.
-     * @param caller The calling function used for error stack traces.
-     * @returns The built request.
-     * @throws {string} A user-readable validation message if the payload is invalid.
-     * @example api.createRequest(endpoint, payload)
-     * @see https://shelving.cc/api/ValidationAPIProvider/createRequest
-     */
+    /** Validates `payload` against the endpoint's payload schema before delegating; an invalid payload throws a user-readable `string`. */
     createRequest(endpoint, payload, options, caller = this.createRequest) {
         // Validate payload — let thrown strings bubble up as user-readable messages for e.g. form handlers.
         return super.createRequest(endpoint, endpoint.payload.validate(payload), options, caller);
     }
-    /**
-     * Parse a response via the source provider, then validate the result against the endpoint's result schema.
-     *
-     * @param endpoint The endpoint the response came from.
-     * @param response The response to parse and validate.
-     * @param caller The calling function used for error stack traces.
-     * @returns Promise resolving to the validated result.
-     * @throws {ResponseError} If the result fails validation (treated as a server/transport problem).
-     * @example await api.parseResponse(endpoint, response)
-     * @see https://shelving.cc/api/ValidationAPIProvider/parseResponse
-     */
+    /** Validates the parsed result against the endpoint's result schema; a failed result is wrapped as a `ResponseError`. */
     async parseResponse(endpoint, response, caller = this.parseResponse) {
         try {
             // Validate result — wrap in ResponseError as this is a server/transport problem, not user error.

package/api/provider/XMLAPIProvider.d.ts

@@ -8,26 +8,10 @@ import { ClientAPIProvider } from "./ClientAPIProvider.js";
  * Client API provider that always sends request bodies as XML and parses responses as plain text.
  * - Request payloads must be data objects (serialised to XML); results are returned as raw text strings.
  *
- * @example
- * const provider = new XMLAPIProvider({ url: "https://api.example.com" });
- * const xml = await provider.call(getFeed, { id: "abc" });
- *
  * @see https://shelving.cc/api/XMLAPIProvider
  */
 export declare class XMLAPIProvider<P extends Data = Data, R extends string = string> extends ClientAPIProvider<P, R> {
     protected _createBodyRequest(method: RequestBodyMethod, url: PossibleURL, payload: P, options: RequestOptions, caller: AnyCaller): Request;
-    /**
-     * Parse a text `Response` for an endpoint.
-     * - Non-2xx responses become `ResponseError`.
-     * - The response body is always returned as raw text.
-     *
-     * @param _endpoint The endpoint the response was produced for.
-     * @param response The `Response` whose body is read as text.
-     * @param caller The function to attribute thrown errors to (defaults to this method).
-     * @returns A promise resolving to the raw text result.
-     * @throws {ResponseError} if the response status is non-2xx.
-     * @example await provider.parseResponse(getFeed, response)
-     * @see https://shelving.cc/api/XMLAPIProvider/parseResponse
-     */
+    /** Return the response body as raw text rather than parsing it. */
     parseResponse<PP extends P, RR extends R>(_endpoint: Endpoint<PP, RR>, response: Response, caller?: AnyCaller): Promise<RR>;
 }

package/api/provider/XMLAPIProvider.js

@@ -5,29 +5,13 @@ import { ClientAPIProvider } from "./ClientAPIProvider.js";
  * Client API provider that always sends request bodies as XML and parses responses as plain text.
  * - Request payloads must be data objects (serialised to XML); results are returned as raw text strings.
  *
- * @example
- * const provider = new XMLAPIProvider({ url: "https://api.example.com" });
- * const xml = await provider.call(getFeed, { id: "abc" });
- *
  * @see https://shelving.cc/api/XMLAPIProvider
  */
 export class XMLAPIProvider extends ClientAPIProvider {
     _createBodyRequest(method, url, payload, options, caller) {
         return createXMLRequest(method, url, payload, options, caller);
     }
-    /**
-     * Parse a text `Response` for an endpoint.
-     * - Non-2xx responses become `ResponseError`.
-     * - The response body is always returned as raw text.
-     *
-     * @param _endpoint The endpoint the response was produced for.
-     * @param response The `Response` whose body is read as text.
-     * @param caller The function to attribute thrown errors to (defaults to this method).
-     * @returns A promise resolving to the raw text result.
-     * @throws {ResponseError} if the response status is non-2xx.
-     * @example await provider.parseResponse(getFeed, response)
-     * @see https://shelving.cc/api/XMLAPIProvider/parseResponse
-     */
+    /** Return the response body as raw text rather than parsing it. */
     async parseResponse(_endpoint, response, caller = this.parseResponse) {
         const { ok, status } = response;
         const content = await response.text();

package/api/store/EndpointStore.d.ts

@@ -20,14 +20,6 @@ export declare class EndpointStore<P, R> extends PayloadFetchStore<P, R> {
      * @see https://shelving.cc/api/EndpointStore/endpoint
      */
     readonly endpoint: Endpoint<P, R>;
-    /**
-     * Create a store that tracks the result of an endpoint call.
-     *
-     * @param endpoint The endpoint to call.
-     * @param payload The payload to call the endpoint with.
-     * @param provider The API provider to call the endpoint through.
-     * @example new EndpointStore(endpoint, payload, provider)
-     */
     constructor(endpoint: Endpoint<P, R>, payload: P, provider: APIProvider<P, R>);
     protected _fetch(signal: AbortSignal): Promise<R>;
 }

package/api/store/EndpointStore.js

@@ -19,14 +19,6 @@ export class EndpointStore extends PayloadFetchStore {
      * @see https://shelving.cc/api/EndpointStore/endpoint
      */
     endpoint;
-    /**
-     * Create a store that tracks the result of an endpoint call.
-     *
-     * @param endpoint The endpoint to call.
-     * @param payload The payload to call the endpoint with.
-     * @param provider The API provider to call the endpoint through.
-     * @example new EndpointStore(endpoint, payload, provider)
-     */
     constructor(endpoint, payload, provider) {
         super(payload, NONE);
         this.endpoint = endpoint;

package/bun/BunPostgreSQLProvider.d.ts

@@ -10,40 +10,12 @@ import type { Identifier } from "../util/item.js";
  * - Identifiers are escaped through `Bun.SQL`'s own `sql()` helper rather than naive string quoting, which is more secure.
  * - Requires the `bun` peer dependency and a running Bun environment.
  *
- * @example
- * import { SQL } from "bun";
- * const provider = new BunPostgreSQLProvider(new SQL(process.env.DATABASE_URL));
- *
  * @see https://shelving.cc/bun/BunPostgreSQLProvider
  */
 export declare class BunPostgreSQLProvider<I extends Identifier = Identifier, T extends Data = Data> extends PostgreSQLProvider<I, T> {
     private _sql;
-    /**
-     * Create a provider wrapping an existing `Bun.SQL` connection.
-     *
-     * @param sql The `Bun.SQL` instance to execute queries against.
-     * @see https://shelving.cc/bun/BunPostgreSQLProvider
-     */
     constructor(sql: SQL);
-    /**
-     * Execute an SQL query through the underlying `Bun.SQL` connection.
-     *
-     * @param strings The tagged-template string parts of the query.
-     * @param values The interpolated values bound as query parameters.
-     * @returns Promise resolving to the array of result rows.
-     * @example provider.exec`SELECT * FROM ${provider.sqlIdentifier("items")}`
-     * @see https://shelving.cc/bun/BunPostgreSQLProvider/exec
-     */
     exec<X extends Data>(strings: TemplateStringsArray, ...values: ImmutableArray<unknown>): Promise<ImmutableArray<X>>;
-    /**
-     * Build an SQL fragment for an identifier, escaped via `Bun.SQL`'s `sql()` helper.
-     *
-     * Overrides the base implementation because the Bun SQL engine supports first-class identifier wrapping, which is more secure than manual quoting.
-     *
-     * @param name The identifier (table or column name) to escape.
-     * @returns An `SQLFragment` wrapping the escaped identifier.
-     * @example provider.sqlIdentifier("items")
-     * @see https://shelving.cc/bun/BunPostgreSQLProvider/sqlIdentifier
-     */
+    /** Escapes the identifier via `Bun.SQL`'s first-class `sql()` wrapping rather than manual quoting, which is more secure. */
     sqlIdentifier(name: string): SQLFragment;
 }