brass-runtime 1.15.0 → 1.16.0

package/dist/client-CtFmoDvM.d.ts

@@ -0,0 +1,645 @@
+import { A as Async } from './effect-CGNl5Rqp.js';
+import { Z as ZStream } from './stream-dvSs0QS5.js';
+import { S as Schedule } from './schedule-Fque9Abz.js';
+
+/**
+ * Observable event emitted on each retry attempt via the `onRetry` callback.
+ */
+type RetryEvent = {
+    /** Zero-based attempt number (0 = first retry, not the initial request). */
+    attempt: number;
+    /** Computed delay in milliseconds before the next attempt. */
+    delayMs: number;
+    /** The error that triggered this retry, if the request failed with an HttpError. */
+    error?: HttpError;
+    /** The HTTP status code that triggered this retry, if the request returned a retryable status. */
+    status?: number;
+    /** The request URL. */
+    url: string;
+    /** The request HTTP method. */
+    method: HttpMethod;
+    /** Timestamp (ms since epoch) when the retry decision was made. */
+    timestamp: number;
+};
+type RetryScheduleInput = {
+    readonly attempt: number;
+    readonly elapsedMs: number;
+    readonly request: HttpRequest;
+    readonly error?: HttpError;
+    readonly status?: number;
+    readonly retryAfterMs?: number;
+};
+/**
+ * Per-request retry override. Attached as `(req as any).retry`.
+ * - `false` disables retry entirely for this request.
+ * - A partial policy object merges with the middleware-level policy (per-request wins).
+ */
+type PerRequestRetryOverride = false | {
+    maxRetries?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    schedule?: Schedule<RetryScheduleInput, unknown>;
+    retryOnStatus?: (status: number) => boolean;
+};
+type RetryPolicy = {
+    maxRetries: number;
+    baseDelayMs: number;
+    maxDelayMs: number;
+    /** Optional declarative schedule. When present, it provides retry delays. */
+    schedule?: Schedule<RetryScheduleInput, unknown>;
+    /** Optional total retry budget, including request attempts and sleeps. */
+    maxElapsedMs?: number;
+    /** Defaults to true. When true, Retry-After is honored but capped by maxDelayMs/budget. */
+    respectRetryAfter?: boolean;
+    retryOnMethods?: HttpMethod[];
+    retryOnStatus?: (status: number) => boolean;
+    retryOnError?: (e: HttpError) => boolean;
+    /** Strict engine selector for retry planning. Defaults to ts. */
+    engine?: "ts" | "wasm";
+    /** Back-compat knob: wasm=true maps to engine="wasm", wasm=false maps to engine="ts". */
+    wasm?: boolean;
+    /** Called synchronously before each retry delay begins. Zero overhead when omitted. */
+    onRetry?: (event: RetryEvent) => void;
+};
+declare const defaultRetryableMethods: HttpMethod[];
+declare const defaultRetryOnStatus: (s: number) => s is 408 | 429 | 500 | 502 | 503 | 504;
+declare const defaultRetryOnError: (e: HttpError) => e is {
+    _tag: "FetchError";
+    message: string;
+} | {
+    _tag: "Timeout";
+    timeoutMs: number;
+    message: string;
+    phase?: "request" | "queue" | "retry";
+} | {
+    _tag: "PoolTimeout";
+    key: string;
+    timeoutMs: number;
+    message: string;
+};
+declare const backoffDelayMs: (attempt: number, base: number, cap: number) => number;
+declare const retryAfterMs: (headers: Record<string, string>) => number | undefined;
+declare const normalizeRetryBudget: (ms: number | undefined) => number | undefined;
+declare const withRetry: (p: RetryPolicy) => HttpMiddleware;
+
+type HttpPoolKeyResolver = "global" | "origin" | "host" | ((req: HttpRequest, url: URL) => string);
+type HttpPoolConfig = {
+    /** Max concurrent downstream calls per resolved key. */
+    readonly concurrency?: number;
+    /** Max queued waiters per key. `0` means fail fast when the pool is full. */
+    readonly maxQueue?: number;
+    /** Max time a request may wait for a pool slot before failing fast. */
+    readonly queueTimeoutMs?: number;
+    /** How to isolate pools. Default: `origin`; useful values: `global`, `host`, `origin`. */
+    readonly key?: HttpPoolKeyResolver;
+    /**
+     * Strict engine selector for permit governance. Defaults to ts.
+     * - ts: TypeScript permit pool.
+     * - wasm: require BrassWasmHttpPermitPool from wasm/pkg; never falls back.
+     */
+    readonly engine?: "ts" | "wasm";
+    /** Back-compat knob: wasm=true maps to engine="wasm", wasm=false maps to engine="ts". */
+    readonly wasm?: boolean;
+};
+type HttpPoolKeyStats = {
+    readonly key: string;
+    readonly running: number;
+    readonly queued: number;
+    readonly concurrency: number;
+    readonly maxQueue: number;
+    readonly acquired: number;
+    readonly released: number;
+    readonly rejected: number;
+    readonly queueTimeouts: number;
+    readonly abortedWhileQueued: number;
+};
+type HttpPoolStats = {
+    readonly running: number;
+    readonly queued: number;
+    readonly acquired: number;
+    readonly released: number;
+    readonly rejected: number;
+    readonly queueTimeouts: number;
+    readonly abortedWhileQueued: number;
+    readonly wasm?: unknown;
+    readonly keys: HttpPoolKeyStats[];
+};
+type HttpPoolLease = {
+    readonly key: string;
+    release: () => void;
+};
+declare function resolveHttpPoolKey(resolver: HttpPoolKeyResolver | undefined, req: HttpRequest, url: URL): string;
+declare class HttpConcurrencyPool {
+    private readonly states;
+    private readonly concurrency;
+    private readonly maxQueue;
+    private readonly queueTimeoutMs;
+    readonly keyResolver: HttpPoolKeyResolver | undefined;
+    private readonly wasm;
+    private readonly wasmWaiters;
+    private wasmTimer;
+    private nextSubjectId;
+    constructor(config?: HttpPoolConfig);
+    acquire(key: string, signal: AbortSignal): Promise<HttpPoolLease>;
+    stats(): HttpPoolStats;
+    private acquireJs;
+    private acquireWasm;
+    private getState;
+    private makeLease;
+    private drain;
+    private handleWasmGrants;
+    private handleWasmTimeouts;
+    private scheduleWasmTimeoutPump;
+    private cleanupWaiter;
+    private removeWaiter;
+    private allocateSubjectId;
+}
+
+type AdaptiveHeadroomMode = "stable" | "probe" | "warmup" | "slow-start" | "circuit-open";
+type AdaptiveHeadroomContext = {
+    readonly key: string;
+    readonly currentLimit: number;
+    readonly minLimit: number;
+    readonly maxLimit: number;
+    readonly gradient: number;
+    readonly mode: AdaptiveHeadroomMode;
+};
+type AdaptiveHeadroomStrategy = number | "fixed" | "proportional" | {
+    readonly type: "fixed";
+    readonly value?: number;
+} | {
+    readonly type: "proportional";
+    readonly ratio?: number;
+    readonly min?: number;
+    readonly max?: number;
+} | ((context: AdaptiveHeadroomContext) => number);
+type AdaptiveBaselineStrategy = "min" | "p5" | "ema-low";
+type AdaptiveQueueStrategy = "fifo" | "priority";
+type AdaptiveQueueLoadShedding = "reject-new" | "priority-evict";
+type AdaptiveLimiterPreset = "conservative" | "balanced" | "aggressive";
+type AdaptiveAcquireOptions = {
+    /** Request priority from 0 (highest) to 9 (lowest). Default: 5. */
+    readonly priority?: number;
+};
+type AdaptiveReleaseInfo = {
+    /** HTTP response status, used by the error signal when >= 500 by default. */
+    readonly status?: number;
+    /** Marks a failed request without an HTTP response, e.g. fetch error or timeout. */
+    readonly error?: boolean;
+};
+/**
+ * Configuration for the adaptive concurrency limiter.
+ * All fields are optional with sensible defaults.
+ */
+type AdaptiveLimiterConfig = {
+    /** Named production preset used before caller overrides are applied. */
+    readonly preset?: AdaptiveLimiterPreset;
+    /** Initial concurrency limit. Default: 10. */
+    readonly initialLimit?: number;
+    /** Minimum concurrency limit. Default: 1. */
+    readonly minLimit?: number;
+    /** Maximum concurrency limit. Default: 200. */
+    readonly maxLimit?: number;
+    /** EMA smoothing factor in (0, 1]. Default: 0.5. */
+    readonly smoothingFactor?: number;
+    /** Number of completions between probes. Default: 10. */
+    readonly probeInterval?: number;
+    /** Random probe interval spread. 0 disables jitter, 0.2 means ±20%. Default: 0.2. */
+    readonly probeJitterRatio?: number;
+    /** Sliding window size for latency samples. Default: 100. */
+    readonly windowSize?: number;
+    /** Minimum samples before the limiter may change its limit. Default: 10. */
+    readonly minSamples?: number;
+    /** Baseline used for gradient computation. Default: "min". */
+    readonly baselineStrategy?: AdaptiveBaselineStrategy;
+    /** Samples to wait after a decrease before allowing another decrease. Default: 0. */
+    readonly decreaseCooldownSamples?: number;
+    /** Number of limit-change events retained per key for diagnostics. Default: 32. */
+    readonly historySize?: number;
+    /** Exponential decay applied to percentile windows. 1 disables weighting. Default: 1. */
+    readonly windowDecayFactor?: number;
+    /** Error signal weight blended with latency gradient. 0 disables. Default: 0. */
+    readonly errorWeight?: number;
+    /** EMA smoothing factor for the error rate signal. Defaults to smoothingFactor. */
+    readonly errorSmoothingFactor?: number;
+    /** HTTP status at/above which responses count as downstream errors. Default: 500. */
+    readonly errorStatusThreshold?: number;
+    /** Internal queue ordering. Default: "fifo". */
+    readonly queueStrategy?: AdaptiveQueueStrategy;
+    /** Queue-full behavior. Default: "reject-new". */
+    readonly queueLoadShedding?: AdaptiveQueueLoadShedding;
+    /** Rejection streak before PoolRejected carries retryAfterMs. Default: 3. */
+    readonly rejectionBackoffThreshold?: number;
+    /** Backoff hint for sustained PoolRejected errors. Default: undefined. */
+    readonly rejectionBackoffMs?: number;
+    /** Remove inactive per-key state after this idle period. Use false to disable. Default: 300000. */
+    readonly stateTtlMs?: number | false;
+    /** Number of valid completions used for explicit linear warmup. 0 disables. Default: 0. */
+    readonly warmupRequests?: number;
+    /** Gradient below which the limiter decreases concurrency. Default: 0.75. */
+    readonly decreaseThreshold?: number;
+    /** Gradient at or above which the limiter may increase concurrency. Default: 1.0. */
+    readonly increaseThreshold?: number;
+    /** Maximum fraction of the current limit that can be removed in one adjustment. Default: 0.2. */
+    readonly maxDecreaseRatio?: number;
+    /** Fixed, proportional, or custom headroom added on stable growth/probes. Default: 1. */
+    readonly headroomStrategy?: AdaptiveHeadroomStrategy;
+    /** Enable fast recovery after sustained saturation. Default: true. */
+    readonly slowStartRecovery?: boolean;
+    /** Gradient at/below which samples count as strong saturation. Default: 0.5. */
+    readonly slowStartSaturationThreshold?: number;
+    /** Consecutive strong-saturation samples before slow-start recovery arms. Default: 3. */
+    readonly slowStartSaturationSamples?: number;
+    /** Key resolver for isolation scope. Default: "origin". */
+    readonly key?: HttpPoolKeyResolver;
+    /** Maximum queue depth per key. Default: 256. */
+    readonly maxQueue?: number;
+    /** Queue timeout in ms. Default: undefined (no timeout). */
+    readonly queueTimeoutMs?: number;
+    /** Callback invoked when the limit changes. */
+    readonly onLimitChange?: (event: LimitChangeEvent) => void;
+    /** Which percentile to use for gradient computation. Default: "p50". */
+    readonly percentile?: "p50" | "p99";
+};
+/**
+ * Event emitted when the concurrency limit changes.
+ */
+type LimitChangeEvent = {
+    readonly key: string;
+    readonly previousLimit: number;
+    readonly newLimit: number;
+    readonly gradient: number;
+    readonly latencyGradient: number;
+    readonly errorRate: number;
+    readonly smoothedLatency: number;
+    readonly minLatency: number;
+    readonly baselineLatency: number;
+    readonly p5: number | undefined;
+    readonly timestamp: number;
+    readonly reason?: "gradient" | "probe" | "warmup" | "slow-start" | "circuit-open";
+};
+/**
+ * Snapshot of the adaptive limiter's current state for a given key.
+ */
+type AdaptiveLimiterStats = {
+    readonly limit: number;
+    readonly inFlight: number;
+    readonly queueDepth: number;
+    readonly gradient: number | undefined;
+    readonly latencyGradient: number | undefined;
+    readonly errorRate: number | undefined;
+    readonly smoothedLatency: number | undefined;
+    readonly minLatency: number | undefined;
+    readonly baselineLatency: number | undefined;
+    readonly p5: number | undefined;
+    readonly p50: number | undefined;
+    readonly p99: number | undefined;
+    readonly probeCount: number;
+    readonly windowSize: number;
+    readonly warmupCompletions?: number;
+    readonly slowStart?: boolean;
+    readonly cooldownSamplesRemaining?: number;
+    readonly utilization?: number;
+    readonly requestsPerSecond?: number;
+    readonly completionsPerSecond?: number;
+    readonly rejectionRate?: number;
+    readonly suggestedBackoffMs?: number;
+    readonly stateCount?: number;
+    readonly keys?: readonly string[];
+};
+type AdaptiveLimiterKeySnapshot = AdaptiveLimiterStats & {
+    readonly key: string;
+    readonly createdAt: number;
+    readonly createdTimestamp: number;
+    readonly lastActivityAt: number;
+    readonly lastActivityTimestamp: number;
+    readonly nextProbeAt: number;
+    readonly warmupDone: boolean;
+    readonly saturationStreak: number;
+    readonly slowStartRecoveryStarted: boolean;
+    readonly history: readonly LimitChangeEvent[];
+    readonly acquired: number;
+    readonly released: number;
+    readonly rejected: number;
+    readonly queueTimeouts: number;
+    readonly abortedWhileQueued: number;
+    readonly evictedWhileQueued: number;
+};
+type AdaptiveLimiterDiagnostics = {
+    readonly stateCount: number;
+    readonly keys: readonly string[];
+    readonly aggregate: AdaptiveLimiterStats;
+    readonly states: readonly AdaptiveLimiterKeySnapshot[];
+    readonly history: readonly LimitChangeEvent[];
+};
+/**
+ * A lease representing an acquired concurrency slot.
+ * Call `release(latencyMs)` when the request completes to record latency and free the slot.
+ */
+type AdaptiveLease = {
+    readonly key: string;
+    release(latencyMs: number, info?: AdaptiveReleaseInfo): void;
+};
+/** Resolved (non-optional) configuration with defaults applied. */
+type ResolvedConfig = {
+    readonly preset: AdaptiveLimiterPreset | undefined;
+    readonly initialLimit: number;
+    readonly minLimit: number;
+    readonly maxLimit: number;
+    readonly smoothingFactor: number;
+    readonly probeInterval: number;
+    readonly probeJitterRatio: number;
+    readonly windowSize: number;
+    readonly minSamples: number;
+    readonly baselineStrategy: AdaptiveBaselineStrategy;
+    readonly decreaseCooldownSamples: number;
+    readonly historySize: number;
+    readonly windowDecayFactor: number;
+    readonly errorWeight: number;
+    readonly errorSmoothingFactor: number;
+    readonly errorStatusThreshold: number;
+    readonly queueStrategy: AdaptiveQueueStrategy;
+    readonly queueLoadShedding: AdaptiveQueueLoadShedding;
+    readonly rejectionBackoffThreshold: number;
+    readonly rejectionBackoffMs: number | undefined;
+    readonly stateTtlMs: number | undefined;
+    readonly warmupRequests: number;
+    readonly decreaseThreshold: number;
+    readonly increaseThreshold: number;
+    readonly maxDecreaseRatio: number;
+    readonly headroomStrategy: AdaptiveHeadroomStrategy;
+    readonly slowStartRecovery: boolean;
+    readonly slowStartSaturationThreshold: number;
+    readonly slowStartSaturationSamples: number;
+    readonly key: HttpPoolKeyResolver;
+    readonly maxQueue: number;
+    readonly queueTimeoutMs: number | undefined;
+    readonly onLimitChange: ((event: LimitChangeEvent) => void) | undefined;
+    readonly percentile: "p50" | "p99";
+};
+declare const adaptiveLimiterPresets: Readonly<{
+    conservative: Readonly<{
+        initialLimit: 8;
+        minLimit: 2;
+        maxLimit: 64;
+        maxQueue: 256;
+        queueTimeoutMs: 30000;
+        smoothingFactor: 0.3;
+        probeInterval: 40;
+        probeJitterRatio: 0.2;
+        windowSize: 100;
+        minSamples: 80;
+        baselineStrategy: "p5";
+        windowDecayFactor: 0.99;
+        errorWeight: 0.2;
+        decreaseThreshold: 0.65;
+        maxDecreaseRatio: 0.08;
+        headroomStrategy: "fixed";
+        queueStrategy: "priority";
+        queueLoadShedding: "priority-evict";
+        rejectionBackoffThreshold: 2;
+        rejectionBackoffMs: 150;
+        percentile: "p50";
+    }>;
+    balanced: Readonly<{
+        initialLimit: 16;
+        minLimit: 4;
+        maxLimit: 128;
+        maxQueue: 512;
+        queueTimeoutMs: 30000;
+        smoothingFactor: 0.35;
+        probeInterval: 25;
+        probeJitterRatio: 0.2;
+        windowSize: 100;
+        minSamples: 50;
+        baselineStrategy: "p5";
+        windowDecayFactor: 0.98;
+        errorWeight: 0.25;
+        decreaseThreshold: 0.5;
+        maxDecreaseRatio: 0.1;
+        headroomStrategy: {
+            type: "proportional";
+            ratio: number;
+        };
+        queueStrategy: "priority";
+        queueLoadShedding: "priority-evict";
+        rejectionBackoffThreshold: 3;
+        rejectionBackoffMs: 100;
+        percentile: "p50";
+    }>;
+    aggressive: Readonly<{
+        initialLimit: 32;
+        minLimit: 8;
+        maxLimit: 256;
+        maxQueue: 1024;
+        queueTimeoutMs: 30000;
+        smoothingFactor: 0.35;
+        probeInterval: 20;
+        probeJitterRatio: 0.2;
+        windowSize: 160;
+        minSamples: 100;
+        baselineStrategy: "p5";
+        windowDecayFactor: 0.98;
+        errorWeight: 0.25;
+        decreaseThreshold: 0.5;
+        maxDecreaseRatio: 0.1;
+        headroomStrategy: {
+            type: "proportional";
+            ratio: number;
+        };
+        queueStrategy: "priority";
+        queueLoadShedding: "priority-evict";
+        rejectionBackoffThreshold: 3;
+        rejectionBackoffMs: 100;
+        percentile: "p50";
+    }>;
+}>;
+declare function makeAdaptiveLimiterConfig(preset: AdaptiveLimiterPreset, overrides?: AdaptiveLimiterConfig): AdaptiveLimiterConfig;
+/**
+ * Validates the adaptive limiter configuration.
+ * Throws a descriptive error for invalid combinations.
+ */
+declare function validateConfig(config: AdaptiveLimiterConfig): void;
+/**
+ * Resolves a partial configuration into a fully-resolved configuration with defaults applied.
+ * Handles minLimit > maxLimit by treating minLimit as the effective maxLimit.
+ */
+declare function resolveConfig(config?: AdaptiveLimiterConfig): ResolvedConfig;
+
+/**
+ * Adaptive concurrency limiter that dynamically adjusts the number of concurrent
+ * requests based on observed latency patterns using a gradient-based algorithm.
+ */
+declare class AdaptiveLimiter {
+    private readonly config;
+    private readonly states;
+    private destroyed;
+    constructor(config?: AdaptiveLimiterConfig);
+    /** Key resolver for external use by the HTTP client. */
+    get keyResolver(): HttpPoolKeyResolver | undefined;
+    /**
+     * Acquire a concurrency slot for the given key.
+     * Resolves immediately if under the limit, otherwise queues the request.
+     * Rejects with PoolRejected if the queue is full, or PoolTimeout if the queue timeout expires.
+     */
+    acquire(key: string, signal: AbortSignal, options?: AdaptiveAcquireOptions): Promise<AdaptiveLease>;
+    /**
+     * Get stats for a specific key, or aggregate stats if no key is provided.
+     */
+    stats(key?: string): AdaptiveLimiterStats;
+    /** Return the currently retained per-key state identifiers. */
+    keys(): readonly string[];
+    /** Return a diagnostic snapshot for one retained key, if present. */
+    snapshot(key: string): AdaptiveLimiterKeySnapshot | undefined;
+    /** Return a full diagnostic dump across all retained keys. */
+    dump(): AdaptiveLimiterDiagnostics;
+    /** Return retained limit-change history for one key, or all keys if omitted. */
+    history(key?: string): readonly LimitChangeEvent[];
+    /**
+     * Circuit-breaker feedback hook. When a circuit is already open for `key`,
+     * collapse that key's limit to minLimit immediately instead of waiting for
+     * latency gradients to discover the saturation indirectly.
+     */
+    markCircuitOpen(key: string): void;
+    /** Destroy the limiter, reject queued waiters, clear timers, and drop state. */
+    destroy(): void;
+    /** Alias for destroy(), useful for graceful shutdown code paths. */
+    shutdown(): void;
+    private getOrCreateState;
+    private makeLease;
+    private recordAndAdjust;
+    private tryWarmup;
+    private baselineLatency;
+    private lowLatencySample;
+    private isErrorSignal;
+    private combineGradientWithErrors;
+    private windowPercentile;
+    private recordSaturation;
+    private applyLimit;
+    private recordLimitChange;
+    private resolveHeadroom;
+    private nextProbeInterval;
+    private enqueueWaiter;
+    private dequeueWaiter;
+    private tryEvictLowerPriorityWaiter;
+    private suggestedBackoffMs;
+    private drain;
+    private currentLatency;
+    private touch;
+    private scheduleIdleEviction;
+    private clearIdleTimer;
+    private evictIdleStates;
+    private evictIdleState;
+    private cleanupWaiter;
+    private removeWaiter;
+    private stateToStats;
+    private stateToKeySnapshot;
+}
+
+type HttpError = {
+    _tag: "Abort";
+} | {
+    _tag: "BadUrl";
+    message: string;
+} | {
+    _tag: "FetchError";
+    message: string;
+} | {
+    _tag: "Timeout";
+    timeoutMs: number;
+    message: string;
+    phase?: "request" | "queue" | "retry";
+} | {
+    _tag: "PoolRejected";
+    key: string;
+    limit: number;
+    message: string;
+    retryAfterMs?: number;
+} | {
+    _tag: "PoolTimeout";
+    key: string;
+    timeoutMs: number;
+    message: string;
+} | {
+    _tag: "PoolClosed";
+    key: string;
+    message: string;
+} | {
+    _tag: "BatchSplitError";
+    expected: number;
+    actual: number;
+    message: string;
+};
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
+type HttpInit = Omit<RequestInit, "method" | "body" | "headers">;
+type HttpBody = string | Uint8Array | ArrayBuffer;
+type HttpRequest = {
+    method: HttpMethod;
+    url: string;
+    headers?: Record<string, string>;
+    body?: HttpBody;
+    init?: HttpInit;
+    /** Per-request override for `MakeHttpConfig.timeoutMs`. */
+    timeoutMs?: number;
+    /** Optional stable key for downstream isolation. When omitted, the pool uses origin/host/global config. */
+    poolKey?: string;
+};
+type HttpWireResponse = {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    bodyText: string;
+    ms: number;
+};
+type HttpClientStats = {
+    readonly inFlight: number;
+    readonly started: number;
+    readonly succeeded: number;
+    readonly failed: number;
+    readonly aborted: number;
+    readonly timedOut: number;
+    readonly poolRejected: number;
+    readonly poolTimeouts: number;
+    readonly lastDurationMs?: number;
+    readonly pool?: HttpPoolStats;
+    readonly adaptiveLimiter?: AdaptiveLimiterStats;
+};
+type MakeHttpConfig = {
+    baseUrl?: string;
+    headers?: Record<string, string>;
+    /** Request budget covering pool wait + fetch + body read. Disabled when omitted. */
+    timeoutMs?: number;
+    /** Downstream pool/concurrency limiter. Disabled by default to preserve existing behavior. */
+    pool?: false | HttpPoolConfig;
+    /** Adaptive concurrency limiter. Replaces fixed pool when enabled. */
+    adaptiveLimiter?: false | AdaptiveLimiterConfig;
+};
+type HttpWireResponseStream = {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: ZStream<unknown, HttpError, Uint8Array>;
+    ms: number;
+};
+type HttpClientStreamFn = (req: HttpRequest) => Async<unknown, HttpError, HttpWireResponseStream>;
+type HttpClientStream = HttpClientStreamFn & {
+    stats: () => HttpClientStats;
+};
+type HttpClientFn = (req: HttpRequest) => Async<unknown, HttpError, HttpWireResponse>;
+type HttpMiddleware = (next: HttpClientFn) => HttpClientFn;
+type HttpClient = HttpClientFn & {
+    with: (mw: HttpMiddleware) => HttpClient;
+    stats: () => HttpClientStats;
+    adaptiveLimiter?: AdaptiveLimiter;
+    destroy?: () => void;
+    shutdown?: () => void;
+};
+type HttpClientMetadata = Pick<HttpClient, "adaptiveLimiter" | "destroy" | "shutdown">;
+declare const decorate: (run: HttpClientFn, stats?: () => HttpClientStats, metadata?: HttpClientMetadata) => HttpClient;
+declare const withMiddleware: (mw: HttpMiddleware) => (c: HttpClient) => HttpClient;
+declare const normalizeHeadersInit: (h: any) => Record<string, string> | undefined;
+declare function makeHttpStream(cfg?: MakeHttpConfig): HttpClientStream;
+declare function makeHttp(cfg?: MakeHttpConfig): HttpClient;
+declare const withRetryStream: (p: RetryPolicy) => (next: HttpClientStream) => HttpClientStream;
+
+export { resolveHttpPoolKey as $, type AdaptiveLimiterStats as A, HttpConcurrencyPool as B, type HttpInit as C, type HttpPoolKeyResolver as D, type HttpPoolKeyStats as E, type HttpPoolLease as F, type HttpPoolStats as G, type HttpClient as H, type ResolvedConfig as I, type RetryEvent as J, type RetryScheduleInput as K, type LimitChangeEvent as L, type MakeHttpConfig as M, adaptiveLimiterPresets as N, backoffDelayMs as O, type PerRequestRetryOverride as P, decorate as Q, type RetryPolicy as R, defaultRetryOnError as S, defaultRetryOnStatus as T, defaultRetryableMethods as U, makeAdaptiveLimiterConfig as V, makeHttp as W, makeHttpStream as X, normalizeHeadersInit as Y, normalizeRetryBudget as Z, resolveConfig as _, type HttpRequest as a, retryAfterMs as a0, validateConfig as a1, withMiddleware as a2, withRetry as a3, withRetryStream as a4, type HttpWireResponse as b, type HttpError as c, type HttpMiddleware as d, type HttpClientFn as e, type HttpWireResponseStream as f, type HttpClientStream as g, type HttpClientStats as h, AdaptiveLimiter as i, type AdaptiveLimiterConfig as j, type HttpMethod as k, type AdaptiveLimiterPreset as l, type HttpPoolConfig as m, type AdaptiveAcquireOptions as n, type AdaptiveBaselineStrategy as o, type AdaptiveHeadroomContext as p, type AdaptiveHeadroomMode as q, type AdaptiveHeadroomStrategy as r, type AdaptiveLease as s, type AdaptiveLimiterDiagnostics as t, type AdaptiveLimiterKeySnapshot as u, type AdaptiveQueueLoadShedding as v, type AdaptiveQueueStrategy as w, type AdaptiveReleaseInfo as x, type HttpBody as y, type HttpClientStreamFn as z };