brass-runtime 1.17.0 → 1.18.0

package/dist/defaultClient-DhpCQW9m.d.ts

@@ -0,0 +1,1623 @@
+import { A as Async, C as AsyncWithPromise } from './effect-CtUDl5M5.js';
+import { Z as ZStream } from './stream-Bb4FTejt.js';
+import { l as Schedule, r as ScheduleObserver, d as CircuitBreakerError } from './layer-BalPI6cN.js';
+import { SchemaIssue, JsonSchemaLike, AnyJsonSchemaLike, InferJsonSchema } from './schema/index.js';
+
+type HttpRetryScheduleInput = {
+    readonly attempt: number;
+    readonly elapsedMs: number;
+    readonly request: HttpRequest;
+    readonly error?: HttpError;
+    readonly status?: number;
+    readonly retryAfterMs?: number;
+};
+type HttpRequestRetryOverride = false | {
+    readonly maxRetries?: number;
+    readonly baseDelayMs?: number;
+    readonly maxDelayMs?: number;
+    readonly schedule?: Schedule<HttpRetryScheduleInput, unknown>;
+    readonly retryOnStatus?: (status: number) => boolean;
+};
+type HttpRequestPolicy = {
+    readonly preset?: string;
+    readonly lane?: string;
+    readonly dedupKey?: string;
+    readonly priority?: number;
+    readonly retry?: HttpRequestRetryOverride;
+    readonly poolKey?: string;
+};
+type HttpRequestPolicyRef = HttpRequestPolicy | string;
+type HttpPolicyPreset = HttpRequestPolicy | ((request: HttpRequest, presetName: string) => HttpRequestPolicy);
+type HttpPolicyPresets = Record<string, HttpPolicyPreset>;
+type ResolveHttpRequestPolicyOptions = {
+    readonly presets?: HttpPolicyPresets;
+};
+declare const defineHttpPolicyPresets: <Presets extends HttpPolicyPresets>(presets: Presets) => Presets;
+declare const httpPolicy: Readonly<{
+    preset: (preset: string, overrides?: Omit<HttpRequestPolicy, "preset">) => HttpRequestPolicy;
+    lane: (lane: string, overrides?: Omit<HttpRequestPolicy, "preset" | "lane">) => HttpRequestPolicy;
+    define: <Presets extends HttpPolicyPresets>(presets: Presets) => Presets;
+}>;
+declare const getHttpRequestPolicy: (req: HttpRequest, options?: ResolveHttpRequestPolicyOptions) => HttpRequestPolicy;
+declare const withHttpRequestPolicy: (req: HttpRequest, patch: Partial<HttpRequestPolicy>) => HttpRequest;
+declare const resolveHttpRequestPolicyPresets: (req: HttpRequest, presets: HttpPolicyPresets) => HttpRequest;
+declare const withHttpPolicyPresets: (presets: HttpPolicyPresets) => HttpMiddleware;
+
+/**
+ * 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 = HttpRetryScheduleInput;
+/**
+ * Per-request retry override. Prefer `req.policy.retry`; legacy top-level `req.retry`
+ * is still supported.
+ * - `false` disables retry entirely for this request.
+ * - A partial policy object merges with the middleware-level policy (per-request wins).
+ */
+type PerRequestRetryOverride = HttpRequestRetryOverride;
+type RetryPolicy = {
+    maxRetries: number;
+    baseDelayMs: number;
+    maxDelayMs: number;
+    /** Optional declarative schedule. When present, it provides retry delays. */
+    schedule?: Schedule<RetryScheduleInput, unknown>;
+    /** Optional observer for declarative schedule decisions. */
+    onScheduleDecision?: ScheduleObserver<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) => boolean;
+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 ValidationError = {
+    readonly _tag: "ValidationError";
+    readonly message: string;
+    readonly body: string;
+    readonly issues: readonly SchemaIssue[];
+    readonly phase?: "request" | "response";
+    readonly schema?: string;
+};
+type JsonDecodeResult<A> = {
+    readonly success: true;
+    readonly data: A;
+} | {
+    readonly success: false;
+    readonly error: ValidationError;
+};
+declare function makeJsonParseValidationError(bodyText: string, error: unknown, options?: {
+    readonly schemaName?: string;
+}): ValidationError;
+declare function decodeJsonBody<A = unknown>(bodyText: string, validator?: JsonSchemaLike<A>, options?: {
+    readonly schemaName?: string;
+}): JsonDecodeResult<A>;
+declare function encodeJsonBodyEffect(bodyObj: unknown, validator?: JsonSchemaLike<any>, options?: {
+    readonly schemaName?: string;
+}): Async<unknown, ValidationError, string>;
+declare function decodeJsonBodyEffect<A = unknown>(bodyText: string, validator?: JsonSchemaLike<A>, options?: {
+    readonly schemaName?: string;
+}): Async<unknown, ValidationError, A>;
+declare function validatedJson<A>(client: HttpClientFn, validator: JsonSchemaLike<A>): (req: Parameters<HttpClientFn>[0]) => Async<unknown, HttpError | ValidationError, A>;
+declare function validatedJsonResponse<A>(client: HttpClientFn, validator: JsonSchemaLike<A>): (req: Parameters<HttpClientFn>[0]) => Async<unknown, HttpError | ValidationError, HttpWireResponse & {
+    readonly body: A;
+}>;
+
+type KnownHttpError = HttpError | ValidationError | CircuitBreakerError;
+type KnownHttpErrorTag = KnownHttpError["_tag"];
+type ToHttpErrorOptions = {
+    readonly signal?: AbortSignal;
+    readonly timeoutMs?: number;
+    readonly phase?: "request" | "queue" | "retry";
+    readonly message?: string | ((error: unknown) => string);
+};
+type RetryableHttpErrorOptions = {
+    readonly retryOnStatus?: (status: number) => boolean;
+};
+type HttpErrorHandlers<R> = {
+    readonly [K in KnownHttpErrorTag]?: (error: Extract<KnownHttpError, {
+        readonly _tag: K;
+    }>) => R;
+} & {
+    readonly default?: (error: unknown) => R;
+};
+declare function isHttpError(error: unknown): error is HttpError;
+declare function isValidationError(error: unknown): error is ValidationError;
+declare function isCircuitBreakerOpen(error: unknown): error is CircuitBreakerError;
+declare function isKnownHttpError(error: unknown): error is KnownHttpError;
+declare function isAbortHttpError(error: unknown): error is Extract<HttpError, {
+    readonly _tag: "Abort";
+}>;
+declare function isTimeoutHttpError(error: unknown): error is Extract<HttpError, {
+    readonly _tag: "Timeout" | "PoolTimeout";
+}>;
+declare function isFetchHttpError(error: unknown): error is Extract<HttpError, {
+    readonly _tag: "FetchError";
+}>;
+declare function httpErrorStatus(error: unknown): number | undefined;
+declare function isRetryableHttpStatus(status: number): boolean;
+declare function isRetryableHttpError(error: unknown, options?: RetryableHttpErrorOptions): boolean;
+declare function isExternalAbortError(error: unknown): boolean;
+declare function isExternalTimeoutError(error: unknown): boolean;
+declare function toHttpError(error: unknown, options?: ToHttpErrorOptions): HttpError;
+declare function matchHttpError<R>(error: unknown, handlers: HttpErrorHandlers<R>): R | undefined;
+declare function formatHttpError(error: unknown): string;
+
+type HttpTransportContext = {
+    readonly request: HttpRequest;
+    readonly url: URL;
+    readonly signal: AbortSignal;
+};
+type HttpTransport = (context: HttpTransportContext) => Async<unknown, HttpError, HttpWireResponse>;
+type HttpStreamTransport = (context: HttpTransportContext) => Async<unknown, HttpError, HttpWireResponseStream>;
+type HttpTransportTiming = {
+    readonly startedAt: number;
+    readonly durationMs: number;
+};
+type PromiseHttpTransportResponse = Omit<HttpWireResponse, "ms"> & {
+    readonly ms?: number;
+};
+type PromiseHttpTransportConfig<Response> = {
+    readonly request: (context: HttpTransportContext) => Promise<Response>;
+    readonly response: (response: Response, context: HttpTransportContext, timing: HttpTransportTiming) => PromiseHttpTransportResponse | Promise<PromiseHttpTransportResponse>;
+    readonly error?: (error: unknown, context: HttpTransportContext) => HttpError;
+};
+type PromiseHttpTransportResponseInfo<Meta = unknown> = {
+    readonly status?: number;
+    readonly statusText?: string;
+    readonly headers?: unknown;
+    readonly ms?: number;
+    readonly transportMeta?: Meta;
+};
+type PromiseHttpTransportResponseInfoMapper<Response, Meta = unknown> = (response: Response, context: HttpTransportContext, timing: HttpTransportTiming) => PromiseHttpTransportResponseInfo<Meta> | Promise<PromiseHttpTransportResponseInfo<Meta>>;
+type PromiseHttpTransportBodySelector<Response, Body = unknown> = (response: Response, context: HttpTransportContext, timing: HttpTransportTiming) => Body | Promise<Body>;
+type PromiseHttpTransportRequestConfigContext = Omit<HttpTransportContext, "signal">;
+type PromiseHttpTransportRequestConfigMapper<Config> = (context: PromiseHttpTransportRequestConfigContext) => Config | Promise<Config>;
+type PromiseHttpTransportConfigWithSignal<Config> = Config extends object ? Config & {
+    readonly signal: AbortSignal;
+} : Config;
+type PromiseHttpTransportRequestConfigBuilder<Config> = {
+    readonly send: <Response>(send: (config: PromiseHttpTransportConfigWithSignal<Config>) => Promise<Response>) => PromiseHttpTransportBodyBuilder<Response>;
+};
+type PromiseHttpTransportFluentResponseBuilder<Response> = {
+    readonly response: (response?: PromiseHttpTransportResponseInfoMapper<Response>) => HttpTransport;
+    readonly error: (error: NonNullable<PromiseHttpTransportConfig<Response>["error"]>) => PromiseHttpTransportFluentResponseBuilder<Response>;
+};
+type PromiseHttpTransportBodyBuilder<Response> = {
+    readonly response: (response: PromiseHttpTransportConfig<Response>["response"]) => HttpTransport;
+    readonly json: <Body = unknown>(body?: PromiseHttpTransportBodySelector<Response, Body>, response?: PromiseHttpTransportResponseInfoMapper<Response>) => HttpTransport;
+    readonly text: (body?: PromiseHttpTransportBodySelector<Response, unknown>, response?: PromiseHttpTransportResponseInfoMapper<Response>) => HttpTransport;
+    readonly fromJson: <Body = unknown>(body?: PromiseHttpTransportBodySelector<Response, Body>) => PromiseHttpTransportFluentResponseBuilder<Response>;
+    readonly fromText: (body?: PromiseHttpTransportBodySelector<Response, unknown>) => PromiseHttpTransportFluentResponseBuilder<Response>;
+    readonly error: (error: NonNullable<PromiseHttpTransportConfig<Response>["error"]>) => PromiseHttpTransportBodyBuilder<Response>;
+};
+type PromiseHttpTransportStartBuilder = {
+    readonly request: <Response>(request: PromiseHttpTransportConfig<Response>["request"]) => PromiseHttpTransportBodyBuilder<Response>;
+    readonly requestConfig: <Config>(request: PromiseHttpTransportRequestConfigMapper<Config>) => PromiseHttpTransportRequestConfigBuilder<Config>;
+};
+declare const isTaggedHttpError: (error: unknown) => error is HttpError;
+declare const isAbortError: (error: unknown) => boolean;
+declare const normalizeHttpError: (error: unknown, options?: ToHttpErrorOptions) => HttpError;
+declare const headersOf: (response: Response) => Record<string, string>;
+declare function normalizeHttpHeaders(headers: unknown): Record<string, string>;
+declare const abortErrorForSignal: (signal: AbortSignal) => HttpError;
+declare const linkAbortSignals: (...signals: readonly (AbortSignal | undefined)[]) => {
+    signal: AbortSignal;
+    cleanup: () => void;
+};
+declare function makePromiseHttpTransport<Response>(config: PromiseHttpTransportConfig<Response>): HttpTransport;
+declare function promiseHttpTransport(): PromiseHttpTransportStartBuilder;
+declare function makeFetchTransport(): HttpTransport;
+declare function makeFetchStreamTransport(): HttpStreamTransport;
+
+type HttpError = {
+    _tag: "Abort";
+} | {
+    _tag: "BadUrl";
+    message: string;
+} | {
+    _tag: "FetchError";
+    message: string;
+    code?: string;
+    status?: number;
+    statusText?: string;
+    retryAfterMs?: number;
+    cause?: unknown;
+} | {
+    _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;
+    /** Structured per-request execution policy. Legacy top-level fields are still read. */
+    policy?: HttpRequestPolicyRef;
+    /** 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;
+    /** @deprecated Use `policy.lane`. Kept for middleware interop. */
+    lane?: string;
+    /** @deprecated Use `policy.dedupKey`. Kept for middleware interop. */
+    dedupKey?: string;
+    /** @deprecated Use `policy.priority`. Kept for middleware interop. */
+    priority?: number;
+    /** @deprecated Use `policy.retry`. Kept for middleware interop. */
+    retry?: HttpRequestRetryOverride;
+};
+type HttpWireResponse<Meta = unknown> = {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    bodyText: string;
+    ms: number;
+    transportMeta?: Meta;
+};
+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;
+    /** Effect-based transport. Defaults to `fetch`; provide one for axios/undici/test transports. */
+    transport?: HttpTransport;
+    /** Effect-based streaming transport. Defaults to `fetch` streaming. */
+    streamTransport?: HttpStreamTransport;
+    /** 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<Meta = unknown> = {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: ZStream<unknown, HttpError, Uint8Array>;
+    ms: number;
+    transportMeta?: Meta;
+};
+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;
+
+/**
+ * Developer-provided function that defines how to combine multiple requests
+ * into one and split the response back.
+ *
+ * @typeParam K - The item type extracted from individual requests, ensuring
+ *   type consistency between coalesce and split.
+ */
+type BatchFunction<K> = {
+    /**
+     * Combines multiple HttpRequest objects into a single batched HttpRequest.
+     * The items array corresponds 1:1 with the requests array.
+     */
+    coalesce: (requests: readonly HttpRequest[]) => HttpRequest;
+    /**
+     * Splits the batched response back into individual responses.
+     * Must return an array of the same length as the original requests array.
+     */
+    split: (response: HttpWireResponse, requests: readonly HttpRequest[]) => HttpWireResponse[];
+};
+/**
+ * Configuration for the Batch_Middleware.
+ *
+ * @typeParam K - The item type linking coalesce and split operations.
+ */
+type BatchConfig<K = unknown> = {
+    /** The batch function defining coalesce/split logic. Required. */
+    batch: BatchFunction<K>;
+    /**
+     * Time window in milliseconds to collect requests before dispatching.
+     * Valid range: [1, 5000]. Required.
+     */
+    windowMs: number;
+    /**
+     * Maximum number of requests in a single batch.
+     * When reached, the batch dispatches immediately.
+     * Valid range: [2, 10000]. Required.
+     */
+    maxBatchSize: number;
+    /**
+     * Computes the Batch_Key from a request.
+     * Requests with the same key are batched together.
+     * Return empty string to bypass batching for a request.
+     * Throwing bypasses batching for that request.
+     */
+    batchKey: (req: HttpRequest) => string;
+};
+/**
+ * Optional observer callback for batch lifecycle events.
+ */
+type BatchEventCallback = (event: {
+    type: "batch-hit" | "batch-dispatch";
+    batchKey: string;
+    batchSize?: number;
+}) => void;
+/**
+ * Creates a Batch_Middleware that collects requests by Batch_Key during
+ * a time window and dispatches them as a single batched request.
+ *
+ * @typeParam K - Inferred from the provided BatchFunction.
+ * @param config - Batch configuration.
+ * @param onEvent - Optional lifecycle event observer.
+ * @returns An HttpMiddleware conforming to (next: HttpClientFn) => HttpClientFn.
+ */
+declare function withBatch<K>(config: BatchConfig<K>, onEvent?: BatchEventCallback): HttpMiddleware;
+
+/**
+ * Status of a pre-warm probe result.
+ */
+type PrewarmResultStatus = "warmed" | "already-warm" | "failed" | "cancelled";
+/**
+ * Result of a single pre-warm probe operation.
+ */
+type PrewarmResult = {
+    /** The origin that was probed. */
+    origin: string;
+    /** Outcome of the probe operation. */
+    status: PrewarmResultStatus;
+    /** Duration of the probe in milliseconds (0 for "already-warm"). */
+    durationMs: number;
+    /** Error information if status is "failed". */
+    error?: string;
+};
+/**
+ * Event types emitted by the PrewarmManager during connection state changes.
+ */
+type PrewarmEventType = "connection-warmed" | "connection-expired" | "connection-failed" | "connection-cancelled";
+/**
+ * An event emitted by the PrewarmManager to notify observers of connection state changes.
+ */
+type PrewarmEvent = {
+    /** The type of prewarm event. */
+    type: PrewarmEventType;
+    /** The origin associated with the event. */
+    origin: string;
+    /** Timestamp (ms) when the event occurred. */
+    timestamp: number;
+    /** Duration of the probe in milliseconds, if applicable. */
+    durationMs?: number;
+    /** Error information, if applicable. */
+    error?: string;
+};
+/**
+ * Per-origin connection state in the state machine.
+ */
+type PrewarmOriginStatus = "idle" | "probing" | "warm" | "expired";
+/**
+ * State information for a single managed origin.
+ */
+type PrewarmOriginState = {
+    /** The origin string. */
+    origin: string;
+    /** Current state of the origin. */
+    status: PrewarmOriginStatus;
+    /** Timestamp of the last successful probe, if any. */
+    lastProbeAt?: number;
+    /** Timestamp until which the connection is considered warm. */
+    warmUntil?: number;
+};
+/**
+ * Snapshot of all managed origins and their current states.
+ */
+type PrewarmStatusSnapshot = {
+    /** State of each managed origin. */
+    origins: PrewarmOriginState[];
+};
+/**
+ * Configuration for creating a PrewarmManager.
+ */
+type PrewarmConfig = {
+    /** Origins to pre-warm. Each must be a valid URL origin (scheme + host + optional port). */
+    origins: string[];
+    /** Keep-alive duration in ms. Default: 55000. */
+    keepAliveDurationMs?: number;
+    /** Max concurrent in-flight probes. Default: 4. */
+    budget?: number;
+    /** Probe timeout in ms. Default: 5000. */
+    probeTimeoutMs?: number;
+    /** Auto-refresh expired connections. Default: false. */
+    autoRefresh?: boolean;
+    /** Route probes through the Wire_Client pool. Default: false. */
+    useClientPool?: boolean;
+    /** Optional Wire_Client to use when useClientPool is true. */
+    client?: HttpClientFn;
+    /** Event observer callback. */
+    onEvent?: (event: PrewarmEvent) => void;
+};
+
+/**
+ * Configuration for the prewarm layer within the lifecycle client.
+ *
+ * When provided to `makeLifecycleClient`, the lifecycle client creates and manages
+ * a PrewarmManager internally, triggering pre-warming based on the `afterResponse` hook.
+ */
+type PrewarmLifecycleConfig = {
+    /** Origins to pre-warm at client creation. */
+    origins?: string[];
+    /** Hook called after each successful response to determine origins to pre-warm. */
+    afterResponse?: (response: HttpWireResponse, request: HttpRequest) => string[];
+    /** Keep-alive duration in ms. Default: 55000. */
+    keepAliveDurationMs?: number;
+    /** Max concurrent in-flight probes. Default: 4. */
+    budget?: number;
+    /** Probe timeout in ms. Default: 5000. */
+    probeTimeoutMs?: number;
+    /** Auto-refresh expired connections. Default: false. */
+    autoRefresh?: boolean;
+    /** Route probes through the Wire_Client pool. Default: false. */
+    useClientPool?: boolean;
+    /** Event observer for prewarm events. */
+    onEvent?: (event: PrewarmEvent) => void;
+};
+/**
+ * Configuration for the deduplication layer.
+ *
+ * When enabled, the dedup layer collapses concurrent identical requests into a single
+ * in-flight Async_Effect, sharing the response across all callers with the same Cache_Key.
+ *
+ * @property {function} [dedupKey] - Custom key function that computes a dedup key from an HttpRequest.
+ *   When provided, overrides the default Cache_Key computation. Default: undefined (uses default key derivation).
+ */
+type DedupConfig = {
+    /** Custom key function. When provided, overrides default Cache_Key computation. */
+    dedupKey?: (req: HttpRequest) => string;
+    /** Internal lifecycle observer. Public callers should prefer LifecycleClientConfig.onEvent. */
+    onEvent?: (event: {
+        type: "dedup-hit" | "dedup-miss" | "dedup-active";
+        cacheKey?: string;
+        active?: number;
+    }) => void;
+};
+/**
+ * Configuration for the response cache layer.
+ *
+ * Controls how responses are stored and retrieved from the in-memory LRU cache.
+ * Each cached entry is keyed by its deterministic Cache_Key.
+ *
+ * @property {number} [ttlSeconds] - Time-to-live in seconds for cached entries. Default: 60. Valid range: [1, 86400].
+ * @property {number} [maxEntries] - Maximum number of cached entries before LRU eviction. Default: 1024. Valid range: >= 1.
+ * @property {boolean} [staleWhileRevalidate] - When true, serves stale cache entries while revalidating in the background. Default: false.
+ * @property {function} [cachePolicy] - Custom cache policy function that determines cacheability and optional TTL override for a given request/response pair. Default: undefined (uses built-in policy).
+ * @property {string[]} [cacheRelevantHeaders] - Additional HTTP headers to include in Cache_Key computation beyond the defaults. Default: undefined (uses DEFAULT_CACHE_RELEVANT_HEADERS).
+ */
+type CacheConfig = {
+    /** Time-to-live in seconds. Default: 60. Range: [1, 86400]. */
+    ttlSeconds?: number;
+    /** Maximum number of cached entries. Default: 1024. Minimum: 1. */
+    maxEntries?: number;
+    /** Enable stale-while-revalidate. Default: false. */
+    staleWhileRevalidate?: boolean;
+    /** Custom cache policy function. */
+    cachePolicy?: (req: HttpRequest, res: HttpWireResponse) => CachePolicyResult;
+    /** Additional headers to include in Cache_Key computation. */
+    cacheRelevantHeaders?: string[];
+    /** Cache-specific observer for stale revalidation failures. */
+    onEvent?: (event: {
+        type: string;
+        cacheKey?: string;
+        error?: any;
+    }) => void;
+    /** Internal lifecycle observer. Public callers should prefer LifecycleClientConfig.onEvent. */
+    onLifecycleEvent?: (event: {
+        type: "cache-hit" | "cache-miss" | "cache-eviction";
+        cacheKey?: string;
+        count?: number;
+    }) => void;
+};
+/**
+ * Result of a custom cache policy evaluation.
+ *
+ * Returned by the `cachePolicy` function in {@link CacheConfig} to control
+ * whether a response should be stored in the cache and for how long.
+ *
+ * @property {boolean} cacheable - Whether the response should be cached. Required.
+ * @property {number} [ttlSeconds] - Optional TTL override in seconds. When provided, takes precedence over the global CacheConfig ttlSeconds. Valid range: [1, 86400].
+ */
+type CachePolicyResult = {
+    /** Whether the response should be cached. */
+    cacheable: boolean;
+    /** Optional TTL override in seconds. */
+    ttlSeconds?: number;
+};
+/**
+ * Configuration for the priority scheduler layer.
+ *
+ * The priority scheduler orders outgoing requests by priority level and limits
+ * concurrency to prevent overwhelming the downstream Wire_Client.
+ *
+ * @property {number} [concurrency] - Maximum concurrent requests dispatched by the priority scheduler. Default: 32. Valid range: >= 1.
+ * @property {number} [queueTimeoutMs] - Queue timeout in milliseconds for priority-queued requests. When a request waits longer than this value, it is rejected. Default: undefined (no timeout).
+ */
+type PriorityConfig = {
+    /** Maximum concurrent requests dispatched by the priority scheduler. Default: 32. Valid range: >= 1. */
+    concurrency?: number;
+    /** Queue timeout in ms for priority-queued requests. Default: no timeout. */
+    queueTimeoutMs?: number;
+    /** Internal lifecycle observer. Public callers should prefer LifecycleClientConfig.onEvent. */
+    onEvent?: (event: {
+        type: "queue-enqueue" | "queue-dispatch";
+        priority: number;
+    }) => void;
+};
+/**
+ * Configuration for creating a lifecycle client.
+ *
+ * Extends MakeHttpConfig with optional lifecycle layer configurations.
+ * Each layer (dedup, cache, priority) can be configured with an options object
+ * or explicitly disabled by setting it to `false`. When omitted, the layer is disabled
+ * (zero-cost when disabled).
+ *
+ * @property {DedupConfig | false} [dedup] - Dedup layer configuration. Set to an object to enable with options, or `false` to explicitly disable. Default: undefined (disabled).
+ * @property {CacheConfig | false} [cache] - Cache layer configuration. Set to an object to enable with options, or `false` to explicitly disable. Default: undefined (disabled).
+ * @property {PriorityConfig | false} [priority] - Priority scheduler configuration. Set to an object to enable with options, or `false` to explicitly disable. Default: undefined (disabled).
+ * @property {function} [onEvent] - Optional event observer callback invoked for each {@link LifecycleEvent} during request processing. Default: undefined.
+ */
+type LifecycleClientConfig = MakeHttpConfig & {
+    /** Dedup layer config. Set to `false` to explicitly disable. Default: undefined (disabled). */
+    dedup?: DedupConfig | false;
+    /** Batch layer config. Set to `false` to explicitly disable. Default: undefined (disabled). */
+    batch?: BatchConfig | false;
+    /** Cache layer config. Set to `false` to explicitly disable. Default: undefined (disabled). */
+    cache?: CacheConfig | false;
+    /** Priority scheduler config. Set to `false` to explicitly disable. Default: undefined (disabled). */
+    priority?: PriorityConfig | false;
+    /** Retry policy. Set to `false` to explicitly disable. Default: undefined (disabled). */
+    retry?: RetryPolicy | false;
+    /** Prewarm layer config. Set to `false` to explicitly disable. Default: undefined (disabled). */
+    prewarm?: PrewarmLifecycleConfig | false;
+    /** Adaptive concurrency limiter config. Set to `false` to explicitly disable. Default: undefined (disabled). */
+    adaptiveLimiter?: AdaptiveLimiterConfig | false;
+    /** Optional event observer for lifecycle events. */
+    onEvent?: (event: LifecycleEvent) => void;
+};
+/**
+ * The lifecycle client interface.
+ *
+ * A callable HTTP client function (Wire_Client wrapper) with additional lifecycle
+ * management methods. Supports middleware composition via `.with()`, statistics
+ * via `.stats()`, and bulk cancellation via `.cancelAll()`.
+ *
+ * @property {function} with - Apply middleware, returning a new LifecycleClient with the middleware applied.
+ * @property {function} stats - Return a frozen snapshot of {@link LifecycleStats}.
+ * @property {function} cancelAll - Cancel all in-flight and queued requests, returning an Async_Effect that resolves when cancellation is complete.
+ * @property {object} cache - Cache management methods for manual invalidation.
+ * @property {function} cache.invalidate - Invalidate a specific cache entry by its Cache_Key.
+ * @property {function} cache.clear - Clear all cache entries.
+ */
+type LifecycleClient = HttpClientFn & {
+    /** Apply middleware, returning a new LifecycleClient with the middleware applied. */
+    with: (mw: HttpMiddleware) => LifecycleClient;
+    /** Return a frozen snapshot of lifecycle statistics. */
+    stats: () => LifecycleStats;
+    /** Cancel all in-flight and queued requests. Returns an Async_Effect that resolves when complete. */
+    cancelAll: () => Async<unknown, never, void>;
+    /** Cancel active work and release owned resources such as adaptive limiter timers. */
+    shutdown: () => Async<unknown, never, void>;
+    /** Adaptive limiter owned by the underlying wire client, when enabled. */
+    adaptiveLimiter?: AdaptiveLimiter;
+    /** Cache management methods. */
+    cache: {
+        /** Invalidate a specific cache entry by Cache_Key. */
+        invalidate: (key: string) => void;
+        /** Clear all cache entries. */
+        clear: () => void;
+    };
+};
+/**
+ * Lifecycle event types emitted during request processing.
+ *
+ * Each value represents a distinct point in the lifecycle pipeline:
+ * - `"request-start"` — Emitted when a request enters the lifecycle pipeline.
+ * - `"request-end"` — Emitted when a request completes (success or failure).
+ * - `"cache-hit"` — Emitted when a response is served from the cache.
+ * - `"cache-miss"` — Emitted when a request misses the cache and proceeds to the Wire_Client.
+ * - `"dedup-hit"` — Emitted when a request is collapsed into an existing in-flight Async_Effect.
+ * - `"dedup-miss"` — Emitted when a request initiates a new in-flight Async_Effect (no existing match).
+ * - `"queue-enqueue"` — Emitted when a request is enqueued in the priority scheduler.
+ * - `"queue-dispatch"` — Emitted when a queued request is dispatched to the Wire_Client.
+ * - `"retry"` — Emitted when the retry middleware schedules another attempt.
+ */
+type LifecycleEventType = "request-start" | "request-end" | "cache-hit" | "cache-miss" | "dedup-hit" | "dedup-miss" | "queue-enqueue" | "queue-dispatch" | "retry" | "batch-hit" | "batch-dispatch" | "limit-change";
+/**
+ * A lifecycle event emitted to the onEvent observer.
+ *
+ * Provides observability into the lifecycle pipeline by reporting events
+ * as they occur during request processing.
+ *
+ * @property {LifecycleEventType} type - The type of lifecycle event. Required.
+ * @property {number} timestamp - Timestamp in milliseconds (from `Date.now()`) when the event occurred. Required.
+ * @property {string} [cacheKey] - The Cache_Key associated with the event, if applicable (present for cache and dedup events).
+ * @property {number} [priority] - Priority level associated with the event, if applicable (present for queue events). Valid range: 0-9.
+ * @property {number} [attempt] - Zero-based retry attempt, if applicable.
+ * @property {number} [delayMs] - Retry delay in milliseconds, if applicable.
+ * @property {number} [status] - HTTP status that triggered retry, if applicable.
+ * @property {string} [errorTag] - HttpError tag that triggered retry, if applicable.
+ */
+type LifecycleEvent = {
+    /** The type of lifecycle event. */
+    type: LifecycleEventType;
+    /** Timestamp (ms) when the event occurred. */
+    timestamp: number;
+    /** Cache_Key associated with the event, if applicable. */
+    cacheKey?: string;
+    /** Priority level associated with the event, if applicable. Valid range: 0-9. */
+    priority?: number;
+    /** Batch_Key associated with the event, if applicable. Present for batch events. */
+    batchKey?: string;
+    /** Number of requests in the batch, if applicable. Present for batch-dispatch events. */
+    batchSize?: number;
+    /** Zero-based retry attempt, if applicable. */
+    attempt?: number;
+    /** Retry delay in milliseconds, if applicable. */
+    delayMs?: number;
+    /** HTTP status that triggered retry, if applicable. */
+    status?: number;
+    /** HttpError tag that triggered retry, if applicable. */
+    errorTag?: string;
+    /** Previous concurrency limit, present for limit-change events. */
+    previousLimit?: number;
+    /** New concurrency limit, present for limit-change events. */
+    newLimit?: number;
+    /** Gradient value, present for limit-change events. */
+    gradient?: number;
+    /** Smoothed latency value, present for limit-change events. */
+    smoothedLatency?: number;
+};
+/**
+ * Lifecycle statistics snapshot.
+ *
+ * All counters start at zero and increase monotonically. Returned as a frozen
+ * object by {@link LifecycleClient.stats}.
+ *
+ * @property {number} cacheHits - Number of cache hits (responses served from cache). Default: 0.
+ * @property {number} cacheMisses - Number of cache misses (requests forwarded to Wire_Client). Default: 0.
+ * @property {number} cacheEvictions - Number of cache evictions triggered by LRU policy. Default: 0.
+ * @property {number} dedupHits - Number of dedup hits (requests collapsed into an existing in-flight Async_Effect). Default: 0.
+ * @property {number} dedupActive - Number of currently active dedup groups (in-flight unique Cache_Keys). Default: 0.
+ * @property {number} queueDepth - Current depth of the priority queue (requests waiting to be dispatched). Default: 0.
+ * @property {number} requestsStarted - Total number of requests that entered the lifecycle pipeline. Default: 0.
+ * @property {number} requestsCompleted - Total number of requests that completed successfully. Default: 0.
+ * @property {number} requestsFailed - Total number of requests that failed with an error. Default: 0.
+ * @property {number} retries - Total number of retry attempts scheduled. Default: 0.
+ * @property {HttpClientStats} wire - Underlying Wire_Client statistics snapshot.
+ */
+type LifecycleStats = {
+    /** Number of cache hits. */
+    cacheHits: number;
+    /** Number of cache misses. */
+    cacheMisses: number;
+    /** Number of cache evictions (LRU). */
+    cacheEvictions: number;
+    /** Number of dedup hits (requests collapsed into existing in-flight Async_Effect). */
+    dedupHits: number;
+    /** Number of currently active dedup groups. */
+    dedupActive: number;
+    /** Current depth of the priority queue. */
+    queueDepth: number;
+    /** Total number of requests started. */
+    requestsStarted: number;
+    /** Total number of requests completed successfully. */
+    requestsCompleted: number;
+    /** Total number of requests that failed. */
+    requestsFailed: number;
+    /** Total number of retry attempts scheduled. */
+    retries: number;
+    /** Total number of batch dispatches. */
+    batchDispatches: number;
+    /** Total number of individual requests that were coalesced into batches. */
+    batchedRequests: number;
+    /** Underlying Wire_Client stats. */
+    wire: HttpClientStats;
+};
+/**
+ * Per-request lifecycle options that can be passed alongside a request.
+ *
+ * Allows fine-grained control over lifecycle behavior on a per-request basis,
+ * overriding the client-level configuration for individual requests.
+ *
+ * @property {number} [priority] - Priority level for this request. Valid range: 0-9 (0 = highest priority). Default: 5.
+ * @property {string} [dedupKey] - Custom dedup key override for this request. When provided, overrides the computed Cache_Key for dedup purposes. Default: undefined.
+ * @property {boolean} [noCache] - When true, bypasses the cache layer for this request (neither reads from nor writes to cache). Default: false.
+ * @property {boolean} [noDedup] - When true, bypasses the dedup layer for this request (always creates a new in-flight Async_Effect). Default: false.
+ */
+type LifecycleRequestOptions = {
+    /** Priority level 0-9 (0 = highest). Default: 5. Valid range: 0-9. */
+    priority?: number;
+    /** Custom dedup key override for this request. */
+    dedupKey?: string;
+    /** Skip cache for this request. Default: false. */
+    noCache?: boolean;
+    /** Skip dedup for this request. Default: false. */
+    noDedup?: boolean;
+};
+
+/**
+ * Supported content encoding algorithms.
+ */
+type SupportedEncoding = "gzip" | "br" | "deflate";
+/**
+ * All supported encodings in default preference order (Brotli first).
+ */
+declare const SUPPORTED_ENCODINGS: readonly SupportedEncoding[];
+/**
+ * Configuration for the compression middleware.
+ */
+type CompressionConfig = {
+    /**
+     * Enabled encodings in preference order.
+     * Default: ["br", "gzip", "deflate"]
+     */
+    encodings?: SupportedEncoding[];
+};
+type RequestCompressionConfig = {
+    /**
+     * Encoding to apply to outbound request bodies.
+     * Default: "gzip".
+     */
+    encoding?: SupportedEncoding;
+    /**
+     * Minimum uncompressed body size in bytes before compression is attempted.
+     * Default: 1024.
+     */
+    minBytes?: number;
+    /**
+     * HTTP methods eligible for request compression.
+     * Default: ["POST", "PUT", "PATCH"].
+     */
+    methods?: readonly string[];
+};
+/**
+ * Frozen snapshot of compression statistics.
+ */
+type CompressionStats = {
+    /** Responses decompressed per encoding type */
+    readonly decompressed: Readonly<Record<SupportedEncoding, number>>;
+    /** Total compressed bytes received */
+    readonly compressedBytes: number;
+    /** Total decompressed bytes produced */
+    readonly decompressedBytes: number;
+    /** Responses that bypassed decompression */
+    readonly passthroughCount: number;
+    /** Decompression errors encountered */
+    readonly errorCount: number;
+    /** Unsupported encoding warnings */
+    readonly unsupportedEncodingCount: number;
+};
+type RequestCompressionStats = {
+    readonly compressedCount: number;
+    readonly skippedCount: number;
+    readonly errorCount: number;
+    readonly originalBytes: number;
+    readonly compressedBytes: number;
+};
+/**
+ * Result of a decompression attempt.
+ */
+type DecompressResult = {
+    ok: true;
+    data: Buffer;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Abstraction over zlib / noop decompression.
+ */
+interface Decompressor {
+    readonly isPassthrough: boolean;
+    decompress(data: Buffer | Uint8Array, encoding: SupportedEncoding): DecompressResult;
+}
+/**
+ * Result of makeCompressionMiddleware — the middleware plus a stats accessor.
+ */
+type CompressionMiddlewareResult = {
+    middleware: HttpMiddleware;
+    stats: () => CompressionStats;
+};
+type RequestCompressionMiddlewareResult = {
+    middleware: HttpMiddleware;
+    stats: () => RequestCompressionStats;
+};
+
+type HttpRequestPolicyInit = {
+    readonly policy?: HttpRequestPolicyRef;
+    readonly lane?: string;
+    readonly dedupKey?: string;
+    readonly priority?: number;
+    readonly retry?: HttpRequestRetryOverride;
+};
+
+type InitNoMethodBody$1 = Omit<RequestInit, "method" | "body"> & HttpRequestPolicyInit & {
+    timeoutMs?: number;
+    poolKey?: string;
+    headers?: any;
+};
+type JsonInitNoSchema$1 = InitNoMethodBody$1 & {
+    schema?: undefined;
+    schemaName?: string;
+};
+type JsonInitWithSchema<Validator extends AnyJsonSchemaLike> = InitNoMethodBody$1 & {
+    schema: Validator;
+    schemaName?: string;
+};
+type PostJsonInitNoSchema$1 = AnyInitWithHeaders & {
+    schema?: undefined;
+    schemaName?: string;
+    bodySchema?: undefined;
+    bodySchemaName?: string;
+};
+type PostJsonInitWithBodySchema<BodyValidator extends AnyJsonSchemaLike> = AnyInitWithHeaders & {
+    schema?: undefined;
+    schemaName?: string;
+    bodySchema: BodyValidator;
+    bodySchemaName?: string;
+};
+type PostJsonInitWithSchema<Validator extends AnyJsonSchemaLike> = AnyInitWithHeaders & {
+    schema: Validator;
+    schemaName?: string;
+    bodySchema?: undefined;
+    bodySchemaName?: string;
+};
+type PostJsonInitWithSchemaAndBody<Validator extends AnyJsonSchemaLike, BodyValidator extends AnyJsonSchemaLike> = AnyInitWithHeaders & {
+    schema: Validator;
+    schemaName?: string;
+    bodySchema: BodyValidator;
+    bodySchemaName?: string;
+};
+type AnyJsonInit = InitNoMethodBody$1 & {
+    schema?: AnyJsonSchemaLike;
+    schemaName?: string;
+};
+type HttpMeta = {
+    request: HttpRequest;
+    urlFinal: string;
+    startedAt: number;
+    durationMs: number;
+};
+type HttpResponse<A> = {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: A;
+};
+type HttpWireWithMeta = {
+    wire: HttpWireResponse;
+    meta: HttpMeta;
+};
+type HttpResponseWithMeta<A> = {
+    wire: HttpWireResponse;
+    response: HttpResponse<A>;
+    meta: HttpMeta;
+};
+type AnyInitWithHeaders = HttpRequestPolicyInit & {
+    headers?: any;
+    timeoutMs?: number;
+    poolKey?: string;
+} & Record<string, any>;
+type Dx = {
+    request: (req: HttpRequest) => AsyncWithPromise<unknown, HttpError, HttpWireResponse>;
+    get: (url: string, init?: AnyInitWithHeaders) => AsyncWithPromise<unknown, HttpError, HttpWireResponse>;
+    post: (url: string, body?: string, init?: AnyInitWithHeaders) => AsyncWithPromise<unknown, HttpError, HttpWireResponse>;
+    getText: (url: string, init?: InitNoMethodBody$1) => AsyncWithPromise<unknown, HttpError, HttpResponse<string>>;
+    getJson: {
+        <Validator extends AnyJsonSchemaLike>(url: string, init: JsonInitWithSchema<Validator>): AsyncWithPromise<unknown, HttpError | ValidationError, HttpResponse<InferJsonSchema<Validator>>>;
+        <A = unknown>(url: string, init?: JsonInitNoSchema$1): AsyncWithPromise<unknown, HttpError | ValidationError, HttpResponse<A>>;
+    };
+    postJson: {
+        <Validator extends AnyJsonSchemaLike, BodyValidator extends AnyJsonSchemaLike>(url: string, bodyObj: InferJsonSchema<BodyValidator>, init: PostJsonInitWithSchemaAndBody<Validator, BodyValidator>): AsyncWithPromise<unknown, HttpError | ValidationError, HttpResponse<InferJsonSchema<Validator>>>;
+        <BodyValidator extends AnyJsonSchemaLike, A = unknown>(url: string, bodyObj: InferJsonSchema<BodyValidator>, init: PostJsonInitWithBodySchema<BodyValidator>): AsyncWithPromise<unknown, HttpError | ValidationError, HttpResponse<A>>;
+        <Validator extends AnyJsonSchemaLike>(url: string, bodyObj: unknown, init: PostJsonInitWithSchema<Validator>): AsyncWithPromise<unknown, HttpError | ValidationError, HttpResponse<InferJsonSchema<Validator>>>;
+        <A = unknown>(url: string, bodyObj: unknown, init?: PostJsonInitNoSchema$1): AsyncWithPromise<unknown, HttpError | ValidationError, HttpResponse<A>>;
+    };
+    with: (mw: HttpMiddleware) => Dx;
+    withRetry: (p: RetryPolicy) => Dx;
+    wire: HttpClient;
+    stats: () => ReturnType<HttpClient["stats"]>;
+};
+declare function httpClient(cfg?: MakeHttpConfig): Dx;
+declare function httpClientWithMeta(cfg?: MakeHttpConfig): {
+    request: (req: HttpRequest) => AsyncWithPromise<unknown, HttpError, {
+        wire: HttpWireResponse<unknown>;
+        meta: HttpMeta;
+    }>;
+    get: (url: string, init?: InitNoMethodBody$1) => AsyncWithPromise<unknown, HttpError, {
+        wire: HttpWireResponse<unknown>;
+        meta: HttpMeta;
+    }>;
+    getText: (url: string, init?: InitNoMethodBody$1) => AsyncWithPromise<unknown, HttpError, {
+        wire: HttpWireResponse<unknown>;
+        response: {
+            status: number;
+            statusText: string;
+            headers: Record<string, string>;
+            body: string;
+        };
+        meta: HttpMeta;
+    }>;
+    getJson: <A>(url: string, init?: AnyJsonInit) => AsyncWithPromise<unknown, HttpError | ValidationError, {
+        wire: HttpWireResponse<unknown>;
+        response: HttpResponse<A>;
+        meta: HttpMeta;
+    }>;
+    post: (url: string, body?: string, init?: InitNoMethodBody$1) => AsyncWithPromise<unknown, HttpError, {
+        wire: HttpWireResponse<unknown>;
+        meta: HttpMeta;
+    }>;
+    postJson: <A>(url: string, bodyObj: unknown, init?: AnyInitWithHeaders & {
+        schema?: AnyJsonSchemaLike;
+        schemaName?: string;
+        bodySchema?: AnyJsonSchemaLike;
+        bodySchemaName?: string;
+    }) => AsyncWithPromise<unknown, HttpError | ValidationError, {
+        wire: HttpWireResponse<unknown>;
+        response: HttpResponse<A>;
+        meta: HttpMeta;
+    }>;
+};
+declare function httpClientStream(cfg?: MakeHttpConfig): {
+    request: (req: HttpRequest) => AsyncWithPromise<unknown, HttpError, HttpWireResponseStream<unknown>>;
+    getStream: (url: string, init?: InitNoMethodBody$1) => AsyncWithPromise<unknown, HttpError, HttpWireResponseStream<unknown>>;
+    get: (url: string, init?: InitNoMethodBody$1) => AsyncWithPromise<unknown, HttpError, HttpWireResponseStream<unknown>>;
+    with: (mw: (n: HttpClientStream) => HttpClientStream) => /*elided*/ any;
+    withRetry: (p: RetryPolicy) => /*elided*/ any;
+    wire: HttpClientStream;
+    stats: () => HttpClientStats;
+};
+
+type InitNoMethodBody = Omit<RequestInit, "method" | "body"> & {
+    timeoutMs?: number;
+    poolKey?: string;
+    headers?: unknown;
+} & HttpRequestPolicyInit;
+type InitWithHeaders = {
+    headers?: unknown;
+    timeoutMs?: number;
+    poolKey?: string;
+} & HttpRequestPolicyInit & Record<string, unknown>;
+type HttpJsonInit<Validator extends AnyJsonSchemaLike> = InitNoMethodBody & {
+    readonly schema: Validator;
+    readonly schemaName?: string;
+};
+type HttpPostJsonInit<Validator extends AnyJsonSchemaLike> = InitWithHeaders & {
+    readonly schema: Validator;
+    readonly schemaName?: string;
+    readonly bodySchema?: undefined;
+    readonly bodySchemaName?: string;
+};
+type HttpPostJsonSchemaBodyInit<Validator extends AnyJsonSchemaLike, BodyValidator extends AnyJsonSchemaLike> = InitWithHeaders & {
+    readonly schema: Validator;
+    readonly schemaName?: string;
+    readonly bodySchema: BodyValidator;
+    readonly bodySchemaName?: string;
+};
+type HttpPostJsonBodyInit<BodyValidator extends AnyJsonSchemaLike> = InitWithHeaders & {
+    readonly schema?: undefined;
+    readonly schemaName?: string;
+    readonly bodySchema: BodyValidator;
+    readonly bodySchemaName?: string;
+};
+type JsonInitNoSchema = InitNoMethodBody & {
+    readonly schema?: undefined;
+    readonly schemaName?: string;
+};
+type PostJsonInitNoSchema = InitWithHeaders & {
+    readonly schema?: undefined;
+    readonly schemaName?: string;
+    readonly bodySchema?: undefined;
+    readonly bodySchemaName?: string;
+};
+type DefaultGetJson = {
+    <Validator extends AnyJsonSchemaLike>(url: string, init: HttpJsonInit<Validator>): AsyncWithPromise<unknown, HttpError | ValidationError, HttpResponse<InferJsonSchema<Validator>>>;
+    <A = unknown>(url: string, init?: JsonInitNoSchema): AsyncWithPromise<unknown, HttpError | ValidationError, HttpResponse<A>>;
+};
+type DefaultPostJson = {
+    <Validator extends AnyJsonSchemaLike, BodyValidator extends AnyJsonSchemaLike>(url: string, bodyObj: InferJsonSchema<BodyValidator>, init: HttpPostJsonSchemaBodyInit<Validator, BodyValidator>): AsyncWithPromise<unknown, HttpError | ValidationError, HttpResponse<InferJsonSchema<Validator>>>;
+    <BodyValidator extends AnyJsonSchemaLike, A = unknown>(url: string, bodyObj: InferJsonSchema<BodyValidator>, init: HttpPostJsonBodyInit<BodyValidator>): AsyncWithPromise<unknown, HttpError | ValidationError, HttpResponse<A>>;
+    <Validator extends AnyJsonSchemaLike>(url: string, bodyObj: unknown, init: HttpPostJsonInit<Validator>): AsyncWithPromise<unknown, HttpError | ValidationError, HttpResponse<InferJsonSchema<Validator>>>;
+    <A = unknown>(url: string, bodyObj: unknown, init?: PostJsonInitNoSchema): AsyncWithPromise<unknown, HttpError | ValidationError, HttpResponse<A>>;
+};
+type DefaultHttpClientPreset = "minimal" | "proxy" | "highThroughputProxy" | "balanced" | "default" | "production";
+type DefaultHttpClientFeatures = {
+    readonly dedup: boolean;
+    readonly batch: boolean;
+    readonly cache: boolean;
+    readonly priority: boolean;
+    readonly retry: boolean;
+    readonly prewarm: boolean;
+    readonly adaptiveLimiter: boolean;
+    readonly compression: boolean;
+    readonly middleware: number;
+};
+type DefaultHttpClientConfig = LifecycleClientConfig & {
+    /**
+     * Preset used as the baseline before caller overrides are applied.
+     * - minimal: wire client + timeout only.
+     * - proxy: low-latency proxy/BFF path; wire client only, no lifecycle queue or Brass timeout by default.
+     * - highThroughputProxy: explicit alias for the hot proxy path; pair with makeNodeHttpProxyClient on Node.
+     * - balanced: retry, priority, dedup, adaptive limiter, response compression.
+     * - default: balanced + short safe-method response cache.
+     * - production: stable alias for the full production-ready default preset.
+     */
+    readonly preset?: DefaultHttpClientPreset;
+    /** Response decompression. Enabled by balanced/default presets; set false to disable. */
+    readonly compression?: CompressionConfig | false;
+    /** Extra middleware applied outermost after the preset stack, e.g. withHttpObservability(obs). */
+    readonly middleware?: readonly HttpMiddleware[];
+    /**
+     * Named per-request policy presets. Requests can use `policy: "readModel"` or
+     * `policy: { preset: "readModel", ...overrides }`.
+     */
+    readonly policyPresets?: HttpPolicyPresets;
+};
+type DefaultHttpClient = {
+    readonly request: (req: HttpRequest) => AsyncWithPromise<unknown, HttpError, HttpWireResponse>;
+    readonly get: (url: string, init?: InitNoMethodBody) => AsyncWithPromise<unknown, HttpError, HttpWireResponse>;
+    readonly post: (url: string, body?: string, init?: InitWithHeaders) => AsyncWithPromise<unknown, HttpError, HttpWireResponse>;
+    readonly getText: (url: string, init?: InitNoMethodBody) => AsyncWithPromise<unknown, HttpError, HttpResponse<string>>;
+    readonly getJson: DefaultGetJson;
+    readonly postJson: DefaultPostJson;
+    readonly with: (mw: HttpMiddleware) => DefaultHttpClient;
+    readonly wire: LifecycleClient;
+    readonly stats: () => LifecycleStats;
+    readonly cache: LifecycleClient["cache"];
+    readonly cancelAll: LifecycleClient["cancelAll"];
+    readonly shutdown: LifecycleClient["shutdown"];
+    readonly preset: DefaultHttpClientPreset;
+    readonly features: DefaultHttpClientFeatures;
+    readonly compression?: {
+        readonly stats: () => CompressionStats;
+    };
+};
+declare const defaultHttpClientPreset: DefaultHttpClientPreset;
+/**
+ * Creates the recommended default HTTP client.
+ *
+ * The returned client has the easy JSON/text helpers from `httpClient`, but its
+ * wire path is the full lifecycle stack: priority, retry, cache, batch, dedup,
+ * adaptive concurrency, optional prewarm, compression, stats, and cancelAll.
+ */
+declare function makeDefaultHttpClient(config?: DefaultHttpClientConfig): DefaultHttpClient;
+
+export { type DefaultHttpClientFeatures as $, type AdaptiveLimiterStats as A, type BatchConfig as B, type CompressionConfig as C, type DefaultHttpClient as D, type AdaptiveLimiterPreset as E, type HttpPoolConfig as F, type AdaptiveAcquireOptions as G, type HttpRequest as H, type AdaptiveBaselineStrategy as I, type AdaptiveHeadroomContext as J, type AdaptiveHeadroomMode as K, type LifecycleClientConfig as L, type AdaptiveHeadroomStrategy as M, type AdaptiveLease as N, type AdaptiveLimiterDiagnostics as O, type PrewarmResult as P, type AdaptiveLimiterKeySnapshot as Q, type RequestCompressionConfig as R, type AdaptiveQueueLoadShedding as S, type AdaptiveQueueStrategy as T, type AdaptiveReleaseInfo as U, type BatchFunction as V, type CachePolicyResult as W, type CompressionStats as X, type DecompressResult as Y, type Decompressor as Z, type DefaultGetJson as _, type HttpClient as a, abortErrorForSignal as a$, type DefaultPostJson as a0, type Dx as a1, type HttpBody as a2, type HttpClientStream as a3, type HttpClientStreamFn as a4, HttpConcurrencyPool as a5, type HttpErrorHandlers as a6, type HttpInit as a7, type HttpJsonInit as a8, type HttpMeta as a9, type PerRequestRetryOverride as aA, type PrewarmEvent as aB, type PrewarmEventType as aC, type PrewarmOriginStatus as aD, type PrewarmResultStatus as aE, type PromiseHttpTransportBodyBuilder as aF, type PromiseHttpTransportBodySelector as aG, type PromiseHttpTransportConfig as aH, type PromiseHttpTransportConfigWithSignal as aI, type PromiseHttpTransportFluentResponseBuilder as aJ, type PromiseHttpTransportRequestConfigBuilder as aK, type PromiseHttpTransportRequestConfigContext as aL, type PromiseHttpTransportRequestConfigMapper as aM, type PromiseHttpTransportResponse as aN, type PromiseHttpTransportResponseInfo as aO, type PromiseHttpTransportResponseInfoMapper as aP, type PromiseHttpTransportStartBuilder as aQ, type RequestCompressionStats as aR, type ResolveHttpRequestPolicyOptions as aS, type ResolvedConfig as aT, type RetryEvent as aU, type RetryScheduleInput as aV, type RetryableHttpErrorOptions as aW, SUPPORTED_ENCODINGS as aX, type SupportedEncoding as aY, type ToHttpErrorOptions as aZ, type ValidationError as a_, type HttpPolicyPreset as aa, type HttpPolicyPresets as ab, type HttpPoolKeyResolver as ac, type HttpPoolKeyStats as ad, type HttpPoolLease as ae, type HttpPoolStats as af, type HttpPostJsonBodyInit as ag, type HttpPostJsonInit as ah, type HttpPostJsonSchemaBodyInit as ai, type HttpRequestPolicy as aj, type HttpRequestPolicyRef as ak, type HttpRequestRetryOverride as al, type HttpResponse as am, type HttpResponseWithMeta as an, type HttpRetryScheduleInput as ao, type HttpStreamTransport as ap, type HttpTransportContext as aq, type HttpTransportTiming as ar, type HttpWireResponseStream as as, type HttpWireWithMeta as at, type JsonDecodeResult as au, type KnownHttpError as av, type KnownHttpErrorTag as aw, type LifecycleRequestOptions as ax, type LimitChangeEvent as ay, type MakeHttpConfig as az, type HttpWireResponse as b, adaptiveLimiterPresets as b0, backoffDelayMs as b1, decodeJsonBody as b2, decodeJsonBodyEffect as b3, decorate as b4, defaultHttpClientPreset as b5, defaultRetryOnError as b6, defaultRetryOnStatus as b7, defaultRetryableMethods as b8, defineHttpPolicyPresets as b9, makeFetchTransport as bA, makeHttp as bB, makeHttpStream as bC, makeJsonParseValidationError as bD, makePromiseHttpTransport as bE, matchHttpError as bF, normalizeHeadersInit as bG, normalizeHttpError as bH, normalizeHttpHeaders as bI, normalizeRetryBudget as bJ, promiseHttpTransport as bK, resolveConfig as bL, resolveHttpPoolKey as bM, resolveHttpRequestPolicyPresets as bN, retryAfterMs as bO, toHttpError as bP, validateConfig as bQ, validatedJson as bR, validatedJsonResponse as bS, withBatch as bT, withHttpPolicyPresets as bU, withHttpRequestPolicy as bV, withMiddleware as bW, withRetry as bX, withRetryStream as bY, encodeJsonBodyEffect as ba, formatHttpError as bb, getHttpRequestPolicy as bc, headersOf as bd, httpClient as be, httpClientStream as bf, httpClientWithMeta as bg, httpErrorStatus as bh, httpPolicy as bi, isAbortError as bj, isAbortHttpError as bk, isCircuitBreakerOpen as bl, isExternalAbortError as bm, isExternalTimeoutError as bn, isFetchHttpError as bo, isHttpError as bp, isKnownHttpError as bq, isRetryableHttpError as br, isRetryableHttpStatus as bs, isTaggedHttpError as bt, isTimeoutHttpError as bu, isValidationError as bv, linkAbortSignals as bw, makeAdaptiveLimiterConfig as bx, makeDefaultHttpClient as by, makeFetchStreamTransport as bz, type HttpError as c, type HttpMiddleware as d, type DefaultHttpClientConfig as e, type CompressionMiddlewareResult as f, type RequestCompressionMiddlewareResult as g, type HttpTransport as h, AdaptiveLimiter as i, type LifecycleClient as j, type LifecycleEvent as k, type HttpClientStats as l, type LifecycleEventType as m, type LifecycleStats as n, type PrewarmStatusSnapshot as o, type PrewarmConfig as p, type HttpClientFn as q, type PrewarmOriginState as r, type HttpMethod as s, type DefaultHttpClientPreset as t, type DedupConfig as u, type CacheConfig as v, type PriorityConfig as w, type RetryPolicy as x, type PrewarmLifecycleConfig as y, type AdaptiveLimiterConfig as z };