@astrale-os/kernel-client 0.5.1 → 0.6.0-beta.10

package/dist/graph/page/page.d.ts

@@ -0,0 +1,37 @@
+import type { GraphData } from '@astrale-os/kernel-core/graph/graph';
+import type { Node, NodeCollection } from '@astrale-os/kernel-core/graph/node';
+import type { NodeBinding, QueryAST, QueryGraphSelect, QueryNodeGraphResult, QueryResultFor } from '@astrale-os/kernel-core/graph/query';
+import type { DomainDependency } from '@astrale-os/kernel-dsl/v1/schema';
+import type { RequestOptions } from '../../transport/index.js';
+import type { QueryPageRequest, QueryResponse } from '../page-contract.js';
+export interface NodePage {
+    readonly nodes: NodeCollection;
+    readonly first: Node | null;
+    readonly graph: GraphData;
+    readonly cursor: string | null;
+    next(options?: {
+        readonly size?: number;
+        readonly signal?: AbortSignal;
+        readonly timeoutMs?: number;
+    }): Promise<NodePage | null>;
+    collect(options: {
+        readonly maximumPages: number;
+        readonly size?: number;
+        readonly signal?: AbortSignal;
+        readonly timeoutMs?: number;
+    }): Promise<{
+        readonly nodes: NodeCollection;
+        readonly cursor: string | null;
+    }>;
+}
+type PageBasis = Pick<RequestOptions, 'signal' | 'timeoutMs'> & {
+    readonly expected?: readonly DomainDependency[];
+};
+export interface PageQueryOptions extends RequestOptions {
+    readonly expected?: readonly DomainDependency[];
+    readonly page: QueryPageRequest;
+}
+export type PageQuery = <Query extends QueryAST>(ast: Query, options: PageQueryOptions) => Promise<QueryResponse<QueryResultFor<Query>>>;
+type NodeGraphQueryAST = QueryAST<QueryGraphSelect<NodeBinding>>;
+export declare function createNodePage(query: PageQuery, ast: NodeGraphQueryAST, response: QueryResponse<QueryNodeGraphResult>, basis: PageBasis, size: number): NodePage;
+export {};

package/dist/graph/page/page.js

@@ -0,0 +1,55 @@
+export function createNodePage(query, ast, response, basis, size) {
+    const { result } = response;
+    const nodes = result.graph.nodes;
+    const cursor = response.page.next ?? null;
+    const next = async (controls) => {
+        if (cursor === null)
+            return null;
+        const options = {
+            ...basis,
+            ...(controls?.signal === undefined ? {} : { signal: controls.signal }),
+            ...(controls?.timeoutMs === undefined ? {} : { timeoutMs: controls.timeoutMs }),
+            page: { size: controls?.size ?? size, after: cursor },
+        };
+        const continuation = await query(ast, options);
+        if (continuation.result.kind !== 'graph' || continuation.result.selection.kind !== 'node') {
+            throw new TypeError('Node page continuation returned a non-Node graph result.');
+        }
+        return createNodePage(query, ast, continuation, basis, controls?.size ?? size);
+    };
+    const page = {
+        nodes,
+        first: nodes[0] ?? null,
+        graph: result.graph,
+        cursor,
+        next,
+        async collect(options) {
+            requireMaximumPages(options.maximumPages);
+            const collected = [...nodes];
+            let current = page;
+            let pages = 1;
+            while (current.cursor !== null && pages < options.maximumPages) {
+                const continuation = await current.next({
+                    ...(options.size === undefined ? {} : { size: options.size }),
+                    ...(options.signal === undefined ? {} : { signal: options.signal }),
+                    ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
+                });
+                if (continuation === null)
+                    break;
+                collected.push(...continuation.nodes);
+                current = continuation;
+                pages += 1;
+            }
+            return Object.freeze({
+                nodes: Object.freeze(collected),
+                cursor: current.cursor,
+            });
+        },
+    };
+    return Object.freeze(page);
+}
+function requireMaximumPages(value) {
+    if (!Number.isSafeInteger(value) || value < 1) {
+        throw new TypeError('NodePage maximumPages must be a positive safe integer.');
+    }
+}

package/dist/graph/page-contract.d.ts

@@ -0,0 +1,13 @@
+import type { QueryResult } from '@astrale-os/kernel-core/graph/query';
+/** Caller-selected bounds and continuation for one graph query page. */
+export interface QueryPageRequest {
+    readonly size: number;
+    readonly after?: string;
+}
+/** Decoded graph result and its optional opaque continuation. */
+export interface QueryResponse<Result extends QueryResult = QueryResult> {
+    readonly result: Result;
+    readonly page: {
+        readonly next?: string;
+    };
+}

package/dist/graph/page-contract.js

@@ -0,0 +1 @@
+export {};

package/dist/graph/provenance.d.ts

@@ -0,0 +1,12 @@
+import type { Edge } from '@astrale-os/kernel-core/graph/edge';
+import type { Node } from '@astrale-os/kernel-core/graph/node';
+import type { DomainDependency } from '@astrale-os/kernel-dsl/v1/schema';
+import type { QueryResponse } from './page-contract.js';
+export interface QueryProvenance {
+    readonly closure: readonly DomainDependency[];
+    readonly page: object;
+}
+/** Retain authenticated query provenance without adding serialized response metadata. */
+export declare function retainQueryProvenance(response: QueryResponse, closure: readonly DomainDependency[]): QueryResponse;
+export declare function provenanceOfGraphValue(value: Node | Edge): QueryProvenance | undefined;
+export declare function provenanceOfResponse(value: QueryResponse): QueryProvenance | undefined;

package/dist/graph/provenance.js

@@ -0,0 +1,37 @@
+const graphValues = new WeakMap();
+const responses = new WeakMap();
+/** Retain authenticated query provenance without adding serialized response metadata. */
+export function retainQueryProvenance(response, closure) {
+    const provenance = Object.freeze({ closure, page: Object.freeze({}) });
+    responses.set(response, provenance);
+    const { result } = response;
+    if (result.kind === 'graph') {
+        for (const node of result.graph.nodes)
+            graphValues.set(node, provenance);
+        for (const edge of result.graph.edges)
+            graphValues.set(edge, provenance);
+    }
+    else if (result.kind === 'nodes') {
+        for (const item of result.nodes) {
+            if (item.kind === 'value')
+                graphValues.set(item.value, provenance);
+        }
+    }
+    else {
+        for (const item of result.edges) {
+            if (item.edge.kind === 'value')
+                graphValues.set(item.edge.value, provenance);
+            if (item.source.kind === 'value')
+                graphValues.set(item.source.value, provenance);
+            if (item.target.kind === 'value')
+                graphValues.set(item.target.value, provenance);
+        }
+    }
+    return response;
+}
+export function provenanceOfGraphValue(value) {
+    return graphValues.get(value);
+}
+export function provenanceOfResponse(value) {
+    return responses.get(value);
+}

package/dist/graph/query.d.ts

@@ -0,0 +1,4 @@
+import type { QueryAST as QueryASTValue, QueryResultFor } from '@astrale-os/kernel-core/graph/query';
+import type { GraphCall, GraphQueryOptions } from './graph.js';
+import type { QueryResponse } from './page-contract.js';
+export declare function queryGraph<Query extends QueryASTValue>(call: GraphCall, input: Query, options: GraphQueryOptions): Promise<QueryResponse<QueryResultFor<Query>>>;

package/dist/graph/query.js

@@ -0,0 +1,69 @@
+import { QueryAST, QueryResult } from '@astrale-os/kernel-core/graph/query';
+import { Path } from '@astrale-os/kernel-core/path';
+import { query } from '@astrale-os/kernel-core/schema/kernel/syscalls/references';
+import { call as invocation } from '../client/index.js';
+import { retainQueryProvenance } from './provenance.js';
+const KERNEL_QUERY_PATH = Path.project(query).raw;
+export async function queryGraph(call, input, options) {
+    const ast = QueryAST.decode(input);
+    const { expected, page, ...request } = options;
+    const admittedPage = admitPage(page);
+    const capturedExpected = captureExpected(expected);
+    const output = await call(invocation(KERNEL_QUERY_PATH, Object.freeze({
+        ast,
+        ...(capturedExpected === undefined ? {} : { expected: capturedExpected }),
+        page: admittedPage,
+    })), request);
+    const response = decodeResponse(output);
+    return capturedExpected === undefined
+        ? response
+        : retainQueryProvenance(response, capturedExpected);
+}
+function captureExpected(input) {
+    if (input === undefined)
+        return undefined;
+    return Object.freeze(input.map(({ origin, revision }) => Object.freeze({ origin, revision })));
+}
+function admitPage(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        throw new TypeError('Graph query page is invalid.');
+    }
+    if (!Number.isSafeInteger(input.size) || input.size < 1) {
+        throw new TypeError('Graph query page size must be a positive safe integer.');
+    }
+    if (input.after !== undefined && (typeof input.after !== 'string' || input.after.length === 0)) {
+        throw new TypeError('Graph query page continuation is invalid.');
+    }
+    return Object.freeze({
+        size: input.size,
+        ...(input.after === undefined ? {} : { after: input.after }),
+    });
+}
+function decodeResponse(input) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        throw new TypeError('Graph query response is invalid.');
+    }
+    const value = input;
+    if (!hasExactKeys(value, ['result', 'page'])) {
+        throw new TypeError('Graph query response is invalid.');
+    }
+    const pageInput = value.page;
+    if (pageInput === null || typeof pageInput !== 'object' || Array.isArray(pageInput)) {
+        throw new TypeError('Graph query response page is invalid.');
+    }
+    const pageValue = pageInput;
+    if (!hasExactKeys(pageValue, pageValue.next === undefined ? [] : ['next'])) {
+        throw new TypeError('Graph query response page is invalid.');
+    }
+    if (pageValue.next !== undefined &&
+        (typeof pageValue.next !== 'string' || pageValue.next.length === 0)) {
+        throw new TypeError('Graph query response continuation is invalid.');
+    }
+    const result = QueryResult.decode(value.result);
+    const page = Object.freeze(pageValue.next === undefined ? {} : { next: pageValue.next });
+    return Object.freeze({ result, page });
+}
+function hasExactKeys(input, expected) {
+    const keys = Object.keys(input);
+    return keys.length === expected.length && keys.every((key) => expected.includes(key));
+}

package/dist/graph/read.d.ts

@@ -0,0 +1,6 @@
+import type { Node } from '@astrale-os/kernel-core/graph/node';
+import type { NodeTarget } from '@astrale-os/kernel-core/path';
+import type { RequestOptions } from '../transport/index.js';
+import type { GraphCall } from './graph.js';
+export declare function getNode(call: GraphCall, path: NodeTarget, options?: RequestOptions): Promise<Node | null>;
+export declare function requireNode(call: GraphCall, path: NodeTarget, options?: RequestOptions): Promise<Node>;

package/dist/graph/read.js

@@ -0,0 +1,17 @@
+import { Query } from '@astrale-os/kernel-core/graph/query';
+import { NodeUnavailableError } from './errors.js';
+import { queryGraph } from './query.js';
+export async function getNode(call, path, options) {
+    const ast = Query.from({ nodes: [path] }).select({ kind: 'graph' });
+    const response = await queryGraph(call, ast, { ...options, page: { size: 1 } });
+    const { result } = response;
+    if (result.kind !== 'graph')
+        throw new TypeError('Node read returned a projection result.');
+    return result.graph.nodes[0] ?? null;
+}
+export async function requireNode(call, path, options) {
+    const node = await getNode(call, path, options);
+    if (node === null)
+        throw new NodeUnavailableError(path);
+    return node;
+}

package/dist/index.d.ts

@@ -1,25 +1,6 @@
-export { KernelClient } from './client/client.js';
-export type { BoundClientView } from './client/bound.js';
-export type { CallOptions, ClientConfig, ClientLogger, Protocol, CallTransport, } from './client/config.js';
-export type { AfterReceiveCtx, AfterSignalCtx, BeforeSendCtx, ClientHooks, ErrorCtx, StreamFrameCtx, } from './client/hooks.js';
-export type { BinaryFns, CallFns, FnEntry, FnMap, SendBinaryResult, SendResult, SendStreamResult, SignalFns, StreamFns, } from './client/fn-map.js';
-export type { BatchResults, TypedBatchRequest } from './client/batch.js';
-export type { TransportName, WireMeta, WireProtocolMeta } from './wire/meta.js';
-export { RETRY_DEFAULTS, QUEUE_DEFAULTS, BATCH_DEFAULTS, RATE_LIMIT_DEFAULTS, kernelRetry, createQueue, createBatcher, createRateLimiter, } from './pacer/index.js';
-export type { KernelRetryOptions, KernelQueueOptions, KernelBatchOptions, KernelRateLimitOptions, } from './pacer/index.js';
-export { AuthBatchError, AuthenticationError, ConnectionError, DisconnectedError, InvalidTransportError, InvariantViolationError, KernelError, NodeUnavailableError, NotFoundError, PermissionDeniedError, TimeoutError, UnsupportedTransportError, ValidationError, WebOSError, mapServerError, withDetails, } from './errors/errors.js';
-export type { AuthBatchOutcome, AuthReason, ClientErrorDetails } from './errors/errors.js';
-export { classifyKernelError, isAuthBatchError, isAuthenticationError, isClientSessionError, isDelegationMintError, isDelegationPolicyError, isDelegationRefusedError, isHopLimitExceededError, isIdentityError, isInternalKernelError, isInvalidRequestError, isInvalidTransportError, isInvariantViolationError, isKernelError, isNodeUnavailableError, isNotFoundError, isParseError, isPermissionDeniedError, isPersistenceLoadFailedError, isPoolClosedError, isRedirectPolicyError, isRedirectRefusedError, isRegistryWriteFailedError, isSchemaOwnershipConflictError, isTransportError, isUnsupportedTransportError, isValidationError, isWebOSError, } from './errors/guards.js';
-export type { IdentityError, KernelErrorKind, TransportError } from './errors/guards.js';
-export { ClientSessionError } from './errors/session-error.js';
-export { SchemaRegistry } from './schema/registry.js';
-export { toFunctionSchemas } from './schema/from-entries.js';
-export type { FunctionSchema } from './schema/types.js';
-export type { ClassProxy, DefOf, InstanceDispatch, NodeProxy, ProxyCallOptions, StaticDispatch, TypeNames, } from './schema/proxy-types.js';
-export { BindTypeMismatchError, createBoundNode, createNodeBinder, createSchemaBoundView, defaultCaller, resolveNeighbors, normalizeRef, } from './schema/bound/index.js';
-export type { AnyBoundNode, BindCtx, BindOptions, BoundLinks, BoundNode, BoundNodeOperations, BoundPaged, BoundSnapshot, ClassHandle, EdgeNames, EndpointsOf, NodeBinder, NodeRefInput, SchemaBoundView, SchemaClasses, } from './schema/bound/index.js';
-export type { CreatableClassNames, CreateProps } from './schema/bound/index.js';
-export { DESCRIPTION_KEY, NAME_KEY, STATUS_KEY, descriptionOf, nameOf, statusOf, } from './graph/named.js';
-export type { NamedNodeLike } from './graph/named.js';
-export type { CredentialInput } from '@astrale-os/kernel-core';
-//# sourceMappingURL=index.d.ts.map
+export { Client, call, type AuthenticatedClient, type Call, type ClientDispatchOptions, type ClientOptions, type Binary, type BinaryResponse, type Input, type RemoteCredential, type Result, type Stream, type StreamResult, type ValueResult, } from './client/index.js';
+export * from './errors/index.js';
+export { type RequestOptions, type MissControl, type StaleControl, type Transport, type TransportRequest, type TransportResult, } from './transport/index.js';
+export { HttpTransport, type Fetch, type HttpTransportOptions } from './transport/http/index.js';
+export { WebSocketTransport, type WebSocketConstructor, type WebSocketTransportOptions, } from './transport/websocket/index.js';
+export { AutoTransport, formatClientWarning, type AutoTransportOptions, type ClientWarning, } from './transport/auto/index.js';

package/dist/index.js

@@ -1,21 +1,6 @@
-// ─── Client ─────────────────────────────────────────────
-export { KernelClient } from './client/client.js';
-// ─── Pacer (retry / queue / batcher / rate-limiter) ────
-export { RETRY_DEFAULTS, QUEUE_DEFAULTS, BATCH_DEFAULTS, RATE_LIMIT_DEFAULTS, kernelRetry, createQueue, createBatcher, createRateLimiter, } from './pacer/index.js';
-// ─── Errors ─────────────────────────────────────────────
-export { AuthBatchError, AuthenticationError, ConnectionError, DisconnectedError, InvalidTransportError, InvariantViolationError, KernelError, NodeUnavailableError, NotFoundError, PermissionDeniedError, TimeoutError, UnsupportedTransportError, ValidationError, WebOSError, mapServerError, withDetails, } from './errors/errors.js';
-// ─── Error guards (typed narrowing for error-UX) ───────
-export { classifyKernelError, isAuthBatchError, isAuthenticationError, isClientSessionError, isDelegationMintError, isDelegationPolicyError, isDelegationRefusedError, isHopLimitExceededError, isIdentityError, isInternalKernelError, isInvalidRequestError, isInvalidTransportError, isInvariantViolationError, isKernelError, isNodeUnavailableError, isNotFoundError, isParseError, isPermissionDeniedError, isPersistenceLoadFailedError, isPoolClosedError, isRedirectPolicyError, isRedirectRefusedError, isRegistryWriteFailedError, isSchemaOwnershipConflictError, isTransportError, isUnsupportedTransportError, isValidationError, isWebOSError, } from './errors/guards.js';
-export { ClientSessionError } from './errors/session-error.js';
-// Auth control plane lives on the `./auth` subpath, session delegation on
-// `./session` — the root re-exports neither (parity with `./graph`).
-// ─── Schema ─────────────────────────────────────────────
-export { SchemaRegistry } from './schema/registry.js';
-export { toFunctionSchemas } from './schema/from-entries.js';
-// NOTE: SchemaTypedClient (legacy .static/.node surface) is intentionally omitted from primary root re-exports.
-// It remains available via deep import for migration compat but is deprecated in favor of .classes + direct BoundNode methods.
-// ─── Schema-bound surface (SchemaBoundView / BoundNode) ──
-export { BindTypeMismatchError, createBoundNode, createNodeBinder, createSchemaBoundView, defaultCaller, resolveNeighbors, normalizeRef, } from './schema/bound/index.js';
-// ─── Universal-prop helpers (blessed; single-sourced from K) ──
-export { DESCRIPTION_KEY, NAME_KEY, STATUS_KEY, descriptionOf, nameOf, statusOf, } from './graph/named.js';
-//# sourceMappingURL=index.js.map
+export { Client, call, } from './client/index.js';
+export * from './errors/index.js';
+export {} from './transport/index.js';
+export { HttpTransport } from './transport/http/index.js';
+export { WebSocketTransport, } from './transport/websocket/index.js';
+export { AutoTransport, formatClientWarning, } from './transport/auto/index.js';

package/dist/pacer/batcher/batcher.d.ts

@@ -0,0 +1,7 @@
+import type { AsyncBatcherOptions } from '@tanstack/pacer';
+import { AsyncBatcher } from '@tanstack/pacer';
+export type BatchOptions<Value> = Omit<AsyncBatcherOptions<Value>, 'maxSize' | 'wait'> & {
+    readonly maxSize?: number;
+    readonly wait?: number;
+};
+export declare function createBatcher<Value>(consume: (values: Value[]) => Promise<unknown>, options?: BatchOptions<Value>): AsyncBatcher<Value>;

package/dist/pacer/batcher/batcher.js

@@ -0,0 +1,13 @@
+import { AsyncBatcher } from '@tanstack/pacer';
+import { DEFAULT_BATCH_SIZE, DEFAULT_BATCH_WAIT_MS } from './defaults.js';
+export function createBatcher(consume, options = {}) {
+    if (typeof consume !== 'function')
+        throw new TypeError('Batch consumer is invalid.');
+    if (options === null || typeof options !== 'object')
+        throw new TypeError('Batch options are invalid.');
+    return new AsyncBatcher(consume, {
+        ...options,
+        maxSize: options.maxSize ?? DEFAULT_BATCH_SIZE,
+        wait: options.wait ?? DEFAULT_BATCH_WAIT_MS,
+    });
+}

package/dist/pacer/batcher/defaults.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_BATCH_SIZE = 100;
+export declare const DEFAULT_BATCH_WAIT_MS = 10;

package/dist/pacer/batcher/defaults.js

@@ -0,0 +1,2 @@
+export const DEFAULT_BATCH_SIZE = 100;
+export const DEFAULT_BATCH_WAIT_MS = 10;

package/dist/pacer/batcher/index.d.ts

@@ -0,0 +1 @@
+export { createBatcher, type BatchOptions } from './batcher.js';

package/dist/pacer/batcher/index.js

@@ -0,0 +1 @@
+export { createBatcher } from './batcher.js';

package/dist/pacer/index.d.ts

@@ -1,10 +1,4 @@
-export { RETRY_DEFAULTS, QUEUE_DEFAULTS, BATCH_DEFAULTS, RATE_LIMIT_DEFAULTS } from './defaults.js';
-export { kernelRetry } from './retry.js';
-export type { KernelRetryOptions } from './retry.js';
-export { createQueue } from './queue.js';
-export type { KernelQueueOptions } from './queue.js';
-export { createBatcher } from './batcher.js';
-export type { KernelBatchOptions } from './batcher.js';
-export { createRateLimiter } from './rate-limiter.js';
-export type { KernelRateLimitOptions } from './rate-limiter.js';
-//# sourceMappingURL=index.d.ts.map
+export { retry, type RetryOptions } from './retry/index.js';
+export { createQueue, type QueueOptions } from './queue/index.js';
+export { createBatcher, type BatchOptions } from './batcher/index.js';
+export { createRateLimiter, type RateLimitOptions } from './limiter/index.js';

package/dist/pacer/index.js

@@ -1,11 +1,4 @@
-// ─── Defaults ────────────────────────────────────────────
-export { RETRY_DEFAULTS, QUEUE_DEFAULTS, BATCH_DEFAULTS, RATE_LIMIT_DEFAULTS } from './defaults.js';
-// ─── Retry ───────────────────────────────────────────────
-export { kernelRetry } from './retry.js';
-// ─── Queue ───────────────────────────────────────────────
-export { createQueue } from './queue.js';
-// ─── Batcher ─────────────────────────────────────────────
-export { createBatcher } from './batcher.js';
-// ─── Rate Limiter ────────────────────────────────────────
-export { createRateLimiter } from './rate-limiter.js';
-//# sourceMappingURL=index.js.map
+export { retry } from './retry/index.js';
+export { createQueue } from './queue/index.js';
+export { createBatcher } from './batcher/index.js';
+export { createRateLimiter } from './limiter/index.js';

package/dist/pacer/limiter/defaults.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_RATE_LIMIT = 10;
+export declare const DEFAULT_RATE_WINDOW_MS = 1000;

package/dist/pacer/limiter/defaults.js

@@ -0,0 +1,2 @@
+export const DEFAULT_RATE_LIMIT = 10;
+export const DEFAULT_RATE_WINDOW_MS = 1_000;

package/dist/pacer/limiter/index.d.ts

@@ -0,0 +1 @@
+export { createRateLimiter, type RateLimitOptions } from './limiter.js';

package/dist/pacer/limiter/index.js

@@ -0,0 +1 @@
+export { createRateLimiter } from './limiter.js';

package/dist/pacer/limiter/limiter.d.ts

@@ -0,0 +1,7 @@
+import type { AnyAsyncFunction, AsyncRateLimiterOptions } from '@tanstack/pacer';
+import { AsyncRateLimiter } from '@tanstack/pacer';
+export type RateLimitOptions<Operation extends AnyAsyncFunction> = Omit<AsyncRateLimiterOptions<Operation>, 'limit' | 'window'> & {
+    readonly limit?: number;
+    readonly window?: number;
+};
+export declare function createRateLimiter<Operation extends AnyAsyncFunction>(operation: Operation, options?: RateLimitOptions<Operation>): AsyncRateLimiter<Operation>;

package/dist/pacer/limiter/limiter.js

@@ -0,0 +1,14 @@
+import { AsyncRateLimiter } from '@tanstack/pacer';
+import { DEFAULT_RATE_LIMIT, DEFAULT_RATE_WINDOW_MS } from './defaults.js';
+export function createRateLimiter(operation, options = {}) {
+    if (typeof operation !== 'function')
+        throw new TypeError('Rate-limited operation is invalid.');
+    if (options === null || typeof options !== 'object') {
+        throw new TypeError('Rate-limit options are invalid.');
+    }
+    return new AsyncRateLimiter(operation, {
+        ...options,
+        limit: options.limit ?? DEFAULT_RATE_LIMIT,
+        window: options.window ?? DEFAULT_RATE_WINDOW_MS,
+    });
+}

package/dist/pacer/queue/defaults.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_QUEUE_CONCURRENCY = 4;

package/dist/pacer/queue/defaults.js

@@ -0,0 +1 @@
+export const DEFAULT_QUEUE_CONCURRENCY = 4;

package/dist/pacer/queue/index.d.ts

@@ -0,0 +1 @@
+export { createQueue, type QueueOptions } from './queue.js';

package/dist/pacer/queue/index.js

@@ -0,0 +1 @@
+export { createQueue } from './queue.js';

package/dist/pacer/queue/queue.d.ts

@@ -0,0 +1,6 @@
+import type { AsyncQueuerOptions } from '@tanstack/pacer';
+import { AsyncQueuer } from '@tanstack/pacer';
+export type QueueOptions<Value> = Omit<AsyncQueuerOptions<Value>, 'concurrency'> & {
+    readonly concurrency?: number;
+};
+export declare function createQueue<Value>(consume: (value: Value) => Promise<unknown>, options?: QueueOptions<Value>): AsyncQueuer<Value>;

package/dist/pacer/queue/queue.js

@@ -0,0 +1,12 @@
+import { AsyncQueuer } from '@tanstack/pacer';
+import { DEFAULT_QUEUE_CONCURRENCY } from './defaults.js';
+export function createQueue(consume, options = {}) {
+    if (typeof consume !== 'function')
+        throw new TypeError('Queue consumer is invalid.');
+    if (options === null || typeof options !== 'object')
+        throw new TypeError('Queue options are invalid.');
+    return new AsyncQueuer(consume, {
+        ...options,
+        concurrency: options.concurrency ?? DEFAULT_QUEUE_CONCURRENCY,
+    });
+}

package/dist/pacer/retry/defaults.d.ts

@@ -0,0 +1,6 @@
+export declare const DEFAULT_RETRY_ATTEMPTS = 3;
+export declare const DEFAULT_RETRY_BASE_WAIT_MS = 250;
+export declare const DEFAULT_RETRY_MAX_WAIT_MS = 5000;
+export declare const DEFAULT_RETRY_JITTER = 0.2;
+export declare function positive(input: number, label: string): number;
+export declare function nonNegative(input: number, label: string): number;

package/dist/pacer/retry/defaults.js

@@ -0,0 +1,16 @@
+export const DEFAULT_RETRY_ATTEMPTS = 3;
+export const DEFAULT_RETRY_BASE_WAIT_MS = 250;
+export const DEFAULT_RETRY_MAX_WAIT_MS = 5_000;
+export const DEFAULT_RETRY_JITTER = 0.2;
+export function positive(input, label) {
+    if (!Number.isSafeInteger(input) || input < 1) {
+        throw new TypeError(`${label} must be a positive safe integer.`);
+    }
+    return input;
+}
+export function nonNegative(input, label) {
+    if (!Number.isFinite(input) || input < 0) {
+        throw new TypeError(`${label} must be a finite non-negative number.`);
+    }
+    return input;
+}

package/dist/pacer/retry/index.d.ts

@@ -0,0 +1 @@
+export { retry, type RetryOptions } from './retry.js';

package/dist/pacer/retry/index.js

@@ -0,0 +1 @@
+export { retry } from './retry.js';

package/dist/pacer/retry/retry.d.ts

@@ -0,0 +1,9 @@
+export interface RetryOptions {
+    readonly maxAttempts?: number;
+    readonly baseWait?: number;
+    readonly maxWait?: number;
+    readonly jitter?: number;
+    readonly shouldRetry?: (error: Error, attempt: number) => boolean;
+}
+/** Retry with bounded exponential backoff and never swallow the final failure. */
+export declare function retry<Result>(operation: () => Promise<Result>, options?: RetryOptions): Promise<Result>;

package/dist/pacer/retry/retry.js

@@ -0,0 +1,55 @@
+import { AsyncRetryer } from '@tanstack/pacer';
+import { DEFAULT_RETRY_ATTEMPTS, DEFAULT_RETRY_BASE_WAIT_MS, DEFAULT_RETRY_JITTER, DEFAULT_RETRY_MAX_WAIT_MS, nonNegative, positive, } from './defaults.js';
+/** Retry with bounded exponential backoff and never swallow the final failure. */
+export async function retry(operation, options = {}) {
+    if (typeof operation !== 'function')
+        throw new TypeError('Retry operation is invalid.');
+    if (options === null || typeof options !== 'object') {
+        throw new TypeError('Retry options are invalid.');
+    }
+    if (options.shouldRetry !== undefined && typeof options.shouldRetry !== 'function') {
+        throw new TypeError('Retry classifier is invalid.');
+    }
+    const attempts = positive(options.maxAttempts ?? DEFAULT_RETRY_ATTEMPTS, 'maxAttempts');
+    const baseWait = nonNegative(options.baseWait ?? DEFAULT_RETRY_BASE_WAIT_MS, 'baseWait');
+    const maxWait = nonNegative(options.maxWait ?? DEFAULT_RETRY_MAX_WAIT_MS, 'maxWait');
+    const jitter = options.jitter ?? DEFAULT_RETRY_JITTER;
+    if (!Number.isFinite(jitter) || jitter < 0 || jitter > 1) {
+        throw new TypeError('jitter must be between zero and one.');
+    }
+    let succeeded = false;
+    let failure;
+    const retryer = new AsyncRetryer(async () => {
+        try {
+            const result = await operation();
+            succeeded = true;
+            failure = undefined;
+            return result;
+        }
+        catch (error) {
+            succeeded = false;
+            failure = error;
+            throw error;
+        }
+    }, {
+        backoff: 'exponential',
+        baseWait,
+        maxWait,
+        jitter,
+        maxAttempts: (current) => {
+            const error = current.store.state.lastError;
+            const attempt = current.store.state.currentAttempt;
+            if (error !== undefined && options.shouldRetry?.(error, attempt) === false)
+                return attempt;
+            return attempts;
+        },
+        throwOnError: 'last',
+    });
+    const result = await retryer.execute();
+    if (!succeeded) {
+        if (failure !== undefined)
+            throw failure;
+        throw new Error('Retry ended without an operation result.');
+    }
+    return result;
+}

package/dist/pool/index.d.ts

@@ -1,4 +1,2 @@
-export type { ClientFactory, ClientPoolConfig } from './pool.js';
-export { ClientPool } from './pool.js';
-export { PoolClosedError } from './errors.js';
-//# sourceMappingURL=index.d.ts.map
+export { ClientPool, type ClientFactory, type ClientPoolOptions } from './pool.js';
+export type { ClientTarget } from './target.js';

package/dist/pool/index.js

@@ -1,3 +1 @@
 export { ClientPool } from './pool.js';
-export { PoolClosedError } from './errors.js';
-//# sourceMappingURL=index.js.map