brass-runtime 1.15.0 → 1.16.0

package/dist/http/index.d.ts

@@ -1,242 +1,178 @@
-import { A as Async, t as AsyncWithPromise } from '../effect-CMOQKX8y.js';
-import { Z as ZStream } from '../stream-FQm9h4Mg.js';
-import { a as CircuitBreakerConfig, T as Tracer } from '../tracing-DNT9jEbr.js';
+import { e as HttpClientFn, c as HttpError, b as HttpWireResponse, a as HttpRequest, d as HttpMiddleware, R as RetryPolicy, H as HttpClient, M as MakeHttpConfig, f as HttpWireResponseStream, g as HttpClientStream, h as HttpClientStats, i as AdaptiveLimiter, j as AdaptiveLimiterConfig, k as HttpMethod, l as AdaptiveLimiterPreset, m as HttpPoolConfig } from '../client-CtFmoDvM.js';
+export { n as AdaptiveAcquireOptions, o as AdaptiveBaselineStrategy, p as AdaptiveHeadroomContext, q as AdaptiveHeadroomMode, r as AdaptiveHeadroomStrategy, s as AdaptiveLease, t as AdaptiveLimiterDiagnostics, u as AdaptiveLimiterKeySnapshot, A as AdaptiveLimiterStats, v as AdaptiveQueueLoadShedding, w as AdaptiveQueueStrategy, x as AdaptiveReleaseInfo, y as HttpBody, z as HttpClientStreamFn, B as HttpConcurrencyPool, C as HttpInit, D as HttpPoolKeyResolver, E as HttpPoolKeyStats, F as HttpPoolLease, G as HttpPoolStats, L as LimitChangeEvent, P as PerRequestRetryOverride, I as ResolvedConfig, J as RetryEvent, K as RetryScheduleInput, N as adaptiveLimiterPresets, O as backoffDelayMs, Q as decorate, S as defaultRetryOnError, T as defaultRetryOnStatus, U as defaultRetryableMethods, V as makeAdaptiveLimiterConfig, W as makeHttp, X as makeHttpStream, Y as normalizeHeadersInit, Z as normalizeRetryBudget, _ as resolveConfig, $ as resolveHttpPoolKey, a0 as retryAfterMs, a1 as validateConfig, a2 as withMiddleware, a3 as withRetry, a4 as withRetryStream } from '../client-CtFmoDvM.js';
+import { A as Async, C as AsyncWithPromise, f as Runtime, h as RuntimeOptions } from '../effect-CGNl5Rqp.js';
+import { SchemaIssue, JsonSchemaLike, AnyJsonSchemaLike, InferJsonSchema } from '../schema/index.js';
+export { AnySchema, ConfigValidationError, InferObject, InferSchema, JsonValidator, JsonValidatorResult, NumberSchemaOptions, ObjectSchemaOptions, Schema, SchemaPathPart, SchemaResult, SchemaShape, SchemaValidationException, StringSchemaOptions, formatIssues, isSchema, makeSchemaIssue, parseConfig, s, schema, validateValue } from '../schema/index.js';
+import { g as CircuitBreakerConfig, h as CircuitBreakerError } from '../tracer-B5tRH9H7.js';
+import { T as Tracer, R as Resource } from '../tracing-Dt9S_6V8.js';
+import { Server } from 'node:http';
+import { AddressInfo } from 'node:net';
+import { S as Schedule } from '../schedule-Fque9Abz.js';
+import { O as Observability, p as HttpServerObservabilityOptions, Z as RuntimeHealthOptions } from '../server-C8hDXA74.js';
+import '../stream-dvSs0QS5.js';
 
 /**
- * Observable event emitted on each retry attempt via the `onRetry` callback.
+ * A fixed-size circular buffer that stores latency samples and supports
+ * efficient min and percentile computation using the nearest-rank method.
+ *
+ * The ring preserves eviction order while `sorted` keeps an exact sorted view.
+ * Recording is O(windowSize) because it removes/inserts by binary search +
+ * splice, but percentile reads are O(1) and avoid sorting on every call.
  */
-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;
-};
-/**
- * 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;
-    retryOnStatus?: (status: number) => boolean;
-};
-type RetryPolicy = {
-    maxRetries: number;
-    baseDelayMs: number;
-    maxDelayMs: number;
-    /** 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;
+declare class LatencyWindow {
+    private readonly buffer;
+    private readonly sorted;
+    private readonly size;
+    private head;
+    private count;
+    constructor(size: number);
+    /**
+     * Record a latency sample. Discards non-positive, NaN, and Infinity values.
+     * Evicts the oldest sample when the buffer is full.
+     */
+    record(latencyMs: number): void;
+    /**
+     * Returns the minimum latency in the current window, or undefined if empty.
+     */
+    min(): number | undefined;
+    /**
+     * Computes the percentile using the nearest-rank method.
+     * Returns undefined if fewer than 2 samples are present.
+     * @param p - Percentile value in [0, 100]
+     */
+    percentile(p: number): number | undefined;
+    /**
+     * Computes a percentile where newer samples receive exponentially higher
+     * weight. A decay of 1 is identical to `percentile`; lower values adapt
+     * faster to recent latency shifts.
+     */
+    weightedPercentile(p: number, decay: number): number | undefined;
+    /** Number of samples currently in the window. */
+    get length(): number;
+    /** Maximum capacity of the window. */
+    get capacity(): number;
+    /** Returns a copy of the current samples (oldest to newest). */
+    samples(): number[];
+    private insertSorted;
+    private removeSorted;
+    private lowerBound;
+}
 
-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;
+/**
+ * Exponential Moving Average computer.
+ * Smooths latency samples using the formula: ema = α * sample + (1 - α) * previous_ema
+ */
+declare class EmaComputer {
+    private readonly alpha;
+    private current;
+    /**
+     * @param alpha - Smoothing factor in (0, 1]. Higher values weight recent samples more.
+     */
+    constructor(alpha: number);
     /**
-     * Strict engine selector for permit governance. Defaults to ts.
-     * - ts: TypeScript permit pool.
-     * - wasm: require BrassWasmHttpPermitPool from wasm/pkg; never falls back.
+     * Update the EMA with a new sample and return the new EMA value.
+     * On the first sample, the EMA is initialized to that sample.
      */
-    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;
+    update(sample: number): number;
+    /** Returns the current EMA value, or undefined if no samples have been recorded. */
+    get value(): number | undefined;
+    /** Resets the EMA state. */
+    reset(): void;
 }
 
-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;
+/**
+ * Computes the gradient as the ratio of minimum latency to current (smoothed) latency.
+ * A gradient < 1.0 indicates latency is increasing (saturation).
+ * A gradient >= 1.0 indicates latency is stable or decreasing.
+ */
+declare function computeGradient(minLatency: number, currentLatency: number): number;
+/**
+ * Computes the new concurrency limit based on the gradient.
+ *
+ * - If gradient < decreaseThreshold: decrease toward `currentLimit * gradient`
+ * - If gradient >= increaseThreshold: newLimit = currentLimit + headroom
+ * - Otherwise: hold the current limit
+ *
+ * Decreases are capped by `maxDecreaseRatio` so a single noisy latency sample
+ * cannot collapse concurrency.
+ *
+ * The result is clamped to [minBound, maxBound].
+ */
+declare function computeNewLimit(currentLimit: number, gradient: number, headroom: number, minBound: number, maxBound: number, options?: {
+    readonly decreaseThreshold?: number;
+    readonly increaseThreshold?: number;
+    readonly maxDecreaseRatio?: number;
+}): number;
+
+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;
 } | {
-    _tag: "PoolTimeout";
-    key: string;
-    timeoutMs: number;
-    message: string;
+    readonly success: false;
+    readonly error: ValidationError;
 };
-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`. */
+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 InitNoMethodBody$1 = Omit<RequestInit, "method" | "body"> & {
     timeoutMs?: number;
-    /** Optional stable key for downstream isolation. When omitted, the pool uses origin/host/global config. */
     poolKey?: string;
+    headers?: any;
 };
-type HttpWireResponse = {
-    status: number;
-    statusText: string;
-    headers: Record<string, string>;
-    bodyText: string;
-    ms: number;
+type JsonInitNoSchema$1 = InitNoMethodBody$1 & {
+    schema?: undefined;
+    schemaName?: string;
 };
-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;
-};
-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;
+type JsonInitWithSchema<Validator extends AnyJsonSchemaLike> = InitNoMethodBody$1 & {
+    schema: Validator;
+    schemaName?: string;
 };
-type HttpWireResponseStream = {
-    status: number;
-    statusText: string;
-    headers: Record<string, string>;
-    body: ZStream<unknown, HttpError, Uint8Array>;
-    ms: number;
+type PostJsonInitNoSchema$1 = AnyInitWithHeaders & {
+    schema?: undefined;
+    schemaName?: string;
+    bodySchema?: undefined;
+    bodySchemaName?: string;
 };
-type HttpClientStreamFn = (req: HttpRequest) => Async<unknown, HttpError, HttpWireResponseStream>;
-type HttpClientStream = HttpClientStreamFn & {
-    stats: () => HttpClientStats;
+type PostJsonInitWithBodySchema<BodyValidator extends AnyJsonSchemaLike> = AnyInitWithHeaders & {
+    schema?: undefined;
+    schemaName?: string;
+    bodySchema: BodyValidator;
+    bodySchemaName?: string;
 };
-type HttpClientFn = (req: HttpRequest) => Async<unknown, HttpError, HttpWireResponse>;
-type HttpMiddleware = (next: HttpClientFn) => HttpClientFn;
-type HttpClient = HttpClientFn & {
-    with: (mw: HttpMiddleware) => HttpClient;
-    stats: () => HttpClientStats;
+type PostJsonInitWithSchema<Validator extends AnyJsonSchemaLike> = AnyInitWithHeaders & {
+    schema: Validator;
+    schemaName?: string;
+    bodySchema?: undefined;
+    bodySchemaName?: string;
 };
-declare const decorate: (run: HttpClientFn, stats?: () => HttpClientStats) => 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;
-
-type InitNoMethodBody = Omit<RequestInit, "method" | "body"> & {
-    timeoutMs?: number;
-    poolKey?: string;
-    headers?: any;
+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;
@@ -268,9 +204,17 @@ 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) => AsyncWithPromise<unknown, HttpError, HttpResponse<string>>;
-    getJson: <A>(url: string, init?: InitNoMethodBody) => AsyncWithPromise<unknown, HttpError, HttpResponse<A>>;
-    postJson: <A>(url: string, bodyObj: unknown, init?: AnyInitWithHeaders) => AsyncWithPromise<unknown, HttpError, HttpResponse<A>>;
+    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;
@@ -282,11 +226,11 @@ declare function httpClientWithMeta(cfg?: MakeHttpConfig): {
         wire: HttpWireResponse;
         meta: HttpMeta;
     }>;
-    get: (url: string, init?: InitNoMethodBody) => AsyncWithPromise<unknown, HttpError, {
+    get: (url: string, init?: InitNoMethodBody$1) => AsyncWithPromise<unknown, HttpError, {
         wire: HttpWireResponse;
         meta: HttpMeta;
     }>;
-    getText: (url: string, init?: InitNoMethodBody) => AsyncWithPromise<unknown, HttpError, {
+    getText: (url: string, init?: InitNoMethodBody$1) => AsyncWithPromise<unknown, HttpError, {
         wire: HttpWireResponse;
         response: {
             status: number;
@@ -296,37 +240,30 @@ declare function httpClientWithMeta(cfg?: MakeHttpConfig): {
         };
         meta: HttpMeta;
     }>;
-    getJson: <A>(url: string, init?: InitNoMethodBody) => AsyncWithPromise<unknown, HttpError, {
+    getJson: <A>(url: string, init?: AnyJsonInit) => AsyncWithPromise<unknown, HttpError | ValidationError, {
         wire: HttpWireResponse;
-        response: {
-            status: number;
-            statusText: string;
-            headers: Record<string, string>;
-            body: A;
-        };
+        response: HttpResponse<A>;
         meta: HttpMeta;
     }>;
-    post: (url: string, body?: string, init?: InitNoMethodBody) => AsyncWithPromise<unknown, HttpError, {
+    post: (url: string, body?: string, init?: InitNoMethodBody$1) => AsyncWithPromise<unknown, HttpError, {
         wire: HttpWireResponse;
         meta: HttpMeta;
     }>;
-    postJson: <A>(url: string, bodyObj: unknown, init?: HttpInit & {
-        headers?: Record<string, string>;
-    }) => AsyncWithPromise<unknown, HttpError, {
+    postJson: <A>(url: string, bodyObj: unknown, init?: AnyInitWithHeaders & {
+        schema?: AnyJsonSchemaLike;
+        schemaName?: string;
+        bodySchema?: AnyJsonSchemaLike;
+        bodySchemaName?: string;
+    }) => AsyncWithPromise<unknown, HttpError | ValidationError, {
         wire: HttpWireResponse;
-        response: {
-            status: number;
-            statusText: string;
-            headers: Record<string, string>;
-            body: A;
-        };
+        response: HttpResponse<A>;
         meta: HttpMeta;
     }>;
 };
 declare function httpClientStream(cfg?: MakeHttpConfig): {
     request: (req: HttpRequest) => AsyncWithPromise<unknown, HttpError, HttpWireResponseStream>;
-    getStream: (url: string, init?: InitNoMethodBody) => AsyncWithPromise<unknown, HttpError, HttpWireResponseStream>;
-    get: (url: string, init?: InitNoMethodBody) => AsyncWithPromise<unknown, HttpError, HttpWireResponseStream>;
+    getStream: (url: string, init?: InitNoMethodBody$1) => AsyncWithPromise<unknown, HttpError, HttpWireResponseStream>;
+    get: (url: string, init?: InitNoMethodBody$1) => AsyncWithPromise<unknown, HttpError, HttpWireResponseStream>;
     with: (mw: (n: HttpClientStream) => HttpClientStream) => /*elided*/ any;
     withRetry: (p: RetryPolicy) => /*elided*/ any;
     wire: HttpClientStream;
@@ -336,6 +273,10 @@ declare function httpClientStream(cfg?: MakeHttpConfig): {
 type HttpCircuitBreakerConfig = CircuitBreakerConfig & {
     /** Key resolver for per-origin circuit breakers. Default: per-origin. */
     perOrigin?: boolean;
+    /** Optional limiter to notify when this breaker is already/opened. Defaults to `next.adaptiveLimiter` when available. */
+    adaptiveLimiter?: Pick<AdaptiveLimiter, "keyResolver" | "markCircuitOpen">;
+    /** Optional resolver when the limiter key differs from the request URL origin/global fallback. */
+    adaptiveLimiterKey?: (req: HttpRequest) => string;
 };
 /**
  * HTTP middleware that wraps requests in a circuit breaker.
@@ -348,36 +289,193 @@ declare function withCircuitBreaker(config?: HttpCircuitBreakerConfig): HttpMidd
  */
 declare function withTracing(tracer: Tracer): HttpMiddleware;
 
-type ValidationError = {
-    _tag: "ValidationError";
-    message: string;
-    body: string;
-    schema?: string;
+type KnownHttpError = HttpError | ValidationError | CircuitBreakerError;
+type KnownHttpErrorTag = KnownHttpError["_tag"];
+type HttpErrorHandlers<R> = {
+    readonly [K in KnownHttpErrorTag]?: (error: Extract<KnownHttpError, {
+        readonly _tag: K;
+    }>) => R;
+} & {
+    readonly default?: (error: unknown) => R;
 };
-type JsonValidator<A> = (data: unknown) => {
-    success: true;
-    data: A;
-} | {
-    success: false;
-    error: string;
+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 matchHttpError<R>(error: unknown, handlers: HttpErrorHandlers<R>): R | undefined;
+declare function formatHttpError(error: unknown): string;
+
+/**
+ * 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[];
 };
 /**
- * Creates a validated JSON getter that checks the response body against a schema.
+ * Configuration for the Batch_Middleware.
  *
- * Usage:
- * ```ts
- * const getUser = validatedJson<User>(client, (data) => {
- *   if (typeof data === "object" && data !== null && "id" in data) {
- *     return { success: true, data: data as User };
- *   }
- *   return { success: false, error: "Invalid user shape" };
- * });
+ * @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.
  *
- * const user = await run(getUser({ method: "GET", url: "/users/1" }));
- * ```
+ * @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 validatedJson<A>(client: HttpClientFn, validator: JsonValidator<A>): (req: Parameters<HttpClientFn>[0]) => Async<unknown, HttpError | ValidationError, A>;
+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.
  *
@@ -484,12 +582,18 @@ type PriorityConfig$1 = {
 type LifecycleClientConfig = MakeHttpConfig & {
     /** Dedup layer config. Set to `false` to explicitly disable. Default: undefined (disabled). */
     dedup?: DedupConfig$1 | 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$1 | false;
     /** Priority scheduler config. Set to `false` to explicitly disable. Default: undefined (disabled). */
     priority?: PriorityConfig$1 | 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;
 };
@@ -514,6 +618,10 @@ type LifecycleClient = HttpClientFn & {
     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. */
@@ -536,7 +644,7 @@ type LifecycleClient = HttpClientFn & {
  * - `"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";
+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.
  *
@@ -561,6 +669,10 @@ type LifecycleEvent = {
     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. */
@@ -569,6 +681,14 @@ type LifecycleEvent = {
     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.
@@ -609,6 +729,10 @@ type LifecycleStats = {
     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;
 };
@@ -1252,6 +1376,8 @@ declare class LifecycleStatsTracker {
     private _requestsCompleted;
     private _requestsFailed;
     private _retries;
+    private _batchDispatches;
+    private _batchedRequests;
     private readonly _onEvent;
     private readonly _wireStats;
     /**
@@ -1391,6 +1517,15 @@ declare class LifecycleStatsTracker {
      */
     requestFailed(): void;
     retry(): void;
+    /**
+     * Records a batch dispatch. Increments the batch dispatches counter by 1.
+     */
+    batchDispatch(): void;
+    /**
+     * Records requests that were coalesced into a batch.
+     * @param count - The number of individual requests in the batch.
+     */
+    batchedRequests(count: number): void;
     /**
      * Emits a lifecycle event to the registered `onEvent` callback.
      *
@@ -1415,6 +1550,8 @@ declare class LifecycleStatsTracker {
     emit(type: LifecycleEventType, extra?: {
         cacheKey?: string;
         priority?: number;
+        batchKey?: string;
+        batchSize?: number;
         attempt?: number;
         delayMs?: number;
         status?: number;
@@ -1781,6 +1918,149 @@ type RequestBatchingConfig = {
 };
 declare function withRequestBatching(config: RequestBatchingConfig): HttpMiddleware;
 
+/**
+ * The PrewarmManager interface for managing connection pre-warming.
+ */
+type PrewarmManager = {
+    /** Warm a single origin. Skips if already warm. */
+    warm: (origin: string) => Promise<PrewarmResult>;
+    /** Warm all configured origins. Skips already-warm origins. */
+    warmAll: () => Promise<PrewarmResult[]>;
+    /** Check if an origin has an active warm connection. */
+    isWarm: (origin: string) => boolean;
+    /** Cancel in-flight probe for a specific origin. */
+    cancel: (origin: string) => void;
+    /** Cancel all in-flight and queued probes. */
+    cancelAll: () => void;
+    /** Get a snapshot of all managed origins and their states. */
+    status: () => PrewarmStatusSnapshot;
+    /** Dispose the manager: cancel all, stop timers, release resources. */
+    dispose: () => void;
+};
+/**
+ * Creates a PrewarmManager that proactively establishes TCP+TLS connections
+ * to known origins using lightweight HEAD probe requests.
+ *
+ * @param config - Configuration for the prewarm manager.
+ * @returns A PrewarmManager instance.
+ * @throws Error if fetch/AbortController is unavailable or origins are invalid.
+ */
+declare function makePrewarmManager(config: PrewarmConfig): PrewarmManager;
+
+/**
+ * Validates and normalizes an origin string.
+ *
+ * A valid origin is: scheme + host + optional port (e.g., "https://api.example.com" or "http://localhost:3000").
+ * Trailing slashes are stripped. Paths, query strings, and fragments are rejected.
+ *
+ * @param origin - The origin string to validate.
+ * @returns The normalized origin string.
+ * @throws Error if the origin is invalid.
+ */
+declare function validateOrigin(origin: string): string;
+
+/**
+ * Detects the current runtime platform.
+ *
+ * @returns "browser" if running in a browser environment, "node" otherwise.
+ */
+declare function detectPlatform(): "browser" | "node";
+/**
+ * Validates that the global `fetch` API is available.
+ *
+ * @throws Error if `fetch` or `AbortController` is not available.
+ */
+declare function validateFetchAvailable(): void;
+
+/**
+ * Outcome of a probe request.
+ */
+type ProbeOutcome = {
+    /** Whether the probe succeeded (connection established). */
+    ok: boolean;
+    /** Duration of the probe in milliseconds. */
+    durationMs: number;
+    /** Error message if the probe failed. */
+    error?: string;
+};
+/**
+ * Options for executing a probe request.
+ */
+type ProbeOptions = {
+    /** Probe timeout in milliseconds. */
+    timeoutMs: number;
+    /** AbortSignal for external cancellation. */
+    signal: AbortSignal;
+    /** Runtime platform. */
+    platform: "browser" | "node";
+    /** Optional Wire_Client to route through (when useClientPool is true). */
+    client?: HttpClientFn;
+};
+/**
+ * Executes a HEAD probe request to the root path of the given origin.
+ *
+ * The probe is a lightweight HEAD request to `${origin}/` designed to trigger
+ * TCP+TLS connection establishment in the platform's connection pool.
+ *
+ * @param origin - The validated origin to probe (e.g., "https://api.example.com").
+ * @param options - Probe configuration options.
+ * @returns A ProbeOutcome indicating success or failure.
+ */
+declare function executeProbe(origin: string, options: ProbeOptions): Promise<ProbeOutcome>;
+
+/**
+ * Interface for the connection state map.
+ */
+type ConnectionStateMap = {
+    /** Mark an origin as warm with the current timestamp. */
+    markWarm: (origin: string, now?: number) => void;
+    /** Mark an origin as expired. */
+    markExpired: (origin: string) => void;
+    /** Mark an origin as idle (reset state). */
+    markIdle: (origin: string) => void;
+    /** Mark an origin as probing. */
+    markProbing: (origin: string) => void;
+    /** Check if an origin is currently warm (not expired). */
+    isWarm: (origin: string, now?: number) => boolean;
+    /** Get the current state of an origin. */
+    getState: (origin: string) => PrewarmOriginState | undefined;
+    /** Get a snapshot of all managed origins. */
+    snapshot: () => PrewarmStatusSnapshot;
+};
+/**
+ * Creates a connection state map for tracking per-origin warm/expired/idle states.
+ *
+ * @param origins - Array of origin strings to manage.
+ * @param keepAliveDurationMs - Duration in ms after which a warm connection expires.
+ * @returns A ConnectionStateMap instance.
+ */
+declare function makeConnectionStateMap(origins: string[], keepAliveDurationMs: number): ConnectionStateMap;
+
+/**
+ * A lightweight counting semaphore that limits concurrent in-flight operations.
+ */
+type BudgetSemaphore = {
+    /** Acquire a slot. Resolves with a release handle when a slot is available. */
+    acquire: () => Promise<{
+        release: () => void;
+    }>;
+    /** Try to acquire a slot synchronously. Returns undefined if no slot is available. */
+    tryAcquire: () => {
+        release: () => void;
+    } | undefined;
+    /** Number of currently available slots. */
+    available: () => number;
+    /** Number of waiters currently queued. */
+    queued: () => number;
+};
+/**
+ * Creates a budget semaphore with the given capacity.
+ *
+ * @param capacity - Maximum number of concurrent slots. Must be >= 1.
+ * @returns A BudgetSemaphore instance.
+ */
+declare function makeBudgetSemaphore(capacity: number): BudgetSemaphore;
+
 type ConnectionPrewarmAttempt = {
     url: string;
     origin: string;
@@ -1834,4 +2114,284 @@ declare function prewarmConnections(config?: ConnectionPrewarmConfig): Async<unk
 declare const prewarmHttpConnections: typeof prewarmConnections;
 declare function withConnectionPrewarming(config?: ConnectionPrewarmingMiddlewareConfig): HttpMiddleware;
 
-export { type CacheConfig$1 as CacheConfig, type CacheKeyComponents, type CachePolicyResult$1 as CachePolicyResult, type CompressionConfig, type CompressionMiddlewareResult, type CompressionStats, type ConnectionPrewarmAttempt, type ConnectionPrewarmConfig, type ConnectionPrewarmEvent, type ConnectionPrewarmResult, type ConnectionPrewarmingMiddlewareConfig, DEFAULT_CACHE_RELEVANT_HEADERS, type DecompressResult, type Decompressor, type DedupConfig$1 as DedupConfig, type Dx, type HttpBody, type HttpCircuitBreakerConfig, type HttpClient, type HttpClientFn, type HttpClientStats, type HttpClientStream, type HttpClientStreamFn, HttpConcurrencyPool, type HttpError, type HttpInit, type HttpMeta, type HttpMethod, type HttpMiddleware, type HttpPoolConfig, type HttpPoolKeyResolver, type HttpPoolKeyStats, type HttpPoolLease, type HttpPoolStats, type HttpRequest, type HttpResponse, type HttpResponseWithMeta, type HttpWireResponse, type HttpWireResponseStream, type HttpWireWithMeta, type JsonValidator, LRUCache, type LRUCacheConfig, type LifecycleClient, type LifecycleClientConfig, type LifecycleEvent, type LifecycleEventType, type LifecycleRequestOptions, type LifecycleStats, LifecycleStatsTracker, type LogEvent, type MakeHttpConfig, type PerRequestRetryOverride, type PriorityConfig$1 as PriorityConfig, PriorityQueue, type PriorityQueueEntry, type RequestBatchingConfig, type RequestBatchingEvent, type RequestCompressionConfig, type RequestCompressionMiddlewareResult, type RequestCompressionStats, type RetryEvent, type RetryPolicy, SEPARATOR, SUPPORTED_ENCODINGS, type SupportedEncoding, type ValidationError, backoffDelayMs, clampPriority, computeCacheKey, decorate, defaultRetryOnError, defaultRetryOnStatus, defaultRetryableMethods, httpClient, httpClientStream, httpClientWithMeta, makeCompressionMiddleware, makeHttp, makeHttpClient, makeHttpStream, makeLifecycleClient, makeRequestCompressionMiddleware, makeResponseCompressionMiddleware, normalizeHeadersInit, normalizeRetryBudget, parseCacheKey, prewarmConnections, prewarmHttpConnections, resolveHttpPoolKey, retryAfterMs, validatedJson, withAuth, withCache, withCircuitBreaker, withConnectionPrewarming, withDedup, withLogging, withMiddleware, withPriority, withRequestBatching, withResponseTransform, withRetry, withRetryStream, withTracing };
+type InitNoMethodBody = Omit<RequestInit, "method" | "body"> & {
+    timeoutMs?: number;
+    poolKey?: string;
+    headers?: unknown;
+};
+type InitWithHeaders = {
+    headers?: unknown;
+    timeoutMs?: number;
+    poolKey?: string;
+} & 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" | "balanced" | "default";
+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.
+     * - balanced: retry, priority, dedup, adaptive limiter, response compression.
+     * - default: balanced + short safe-method response cache.
+     */
+    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[];
+};
+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;
+
+type HttpClientBuilder = {
+    readonly config: () => DefaultHttpClientConfig;
+    readonly baseUrl: (baseUrl: string) => HttpClientBuilder;
+    readonly header: (name: string, value: string) => HttpClientBuilder;
+    readonly headers: (headers: Record<string, string>) => HttpClientBuilder;
+    readonly timeoutMs: (timeoutMs: number) => HttpClientBuilder;
+    readonly timeout: (timeoutMs: number) => HttpClientBuilder;
+    readonly preset: (preset: DefaultHttpClientPreset) => HttpClientBuilder;
+    readonly minimal: () => HttpClientBuilder;
+    readonly balanced: () => HttpClientBuilder;
+    readonly defaultPreset: () => HttpClientBuilder;
+    readonly dedup: (config?: DedupConfig$1 | false) => HttpClientBuilder;
+    readonly noDedup: () => HttpClientBuilder;
+    readonly batch: (config: BatchConfig | false) => HttpClientBuilder;
+    readonly noBatch: () => HttpClientBuilder;
+    readonly cache: (config?: CacheConfig$1 | false) => HttpClientBuilder;
+    readonly noCache: () => HttpClientBuilder;
+    readonly priority: (config?: PriorityConfig$1 | false) => HttpClientBuilder;
+    readonly noPriority: () => HttpClientBuilder;
+    readonly retry: (config?: RetryPolicy | false) => HttpClientBuilder;
+    readonly noRetry: () => HttpClientBuilder;
+    readonly prewarm: (config?: PrewarmLifecycleConfig | false) => HttpClientBuilder;
+    readonly noPrewarm: () => HttpClientBuilder;
+    readonly adaptiveLimiter: (config?: AdaptiveLimiterConfig | false) => HttpClientBuilder;
+    readonly adaptiveLimiterPreset: (preset: AdaptiveLimiterPreset, overrides?: AdaptiveLimiterConfig) => HttpClientBuilder;
+    readonly conservativeLimiter: (overrides?: AdaptiveLimiterConfig) => HttpClientBuilder;
+    readonly balancedLimiter: (overrides?: AdaptiveLimiterConfig) => HttpClientBuilder;
+    readonly aggressiveLimiter: (overrides?: AdaptiveLimiterConfig) => HttpClientBuilder;
+    readonly noAdaptiveLimiter: () => HttpClientBuilder;
+    readonly pool: (config?: HttpPoolConfig | false) => HttpClientBuilder;
+    readonly noPool: () => HttpClientBuilder;
+    readonly compression: (config?: CompressionConfig | false) => HttpClientBuilder;
+    readonly noCompression: () => HttpClientBuilder;
+    readonly middleware: (mw: HttpMiddleware) => HttpClientBuilder;
+    readonly use: (mw: HttpMiddleware) => HttpClientBuilder;
+    readonly configure: (config: DefaultHttpClientConfig) => HttpClientBuilder;
+    readonly build: () => DefaultHttpClient;
+    readonly buildWire: () => LifecycleClient;
+};
+declare function httpClientBuilder(config?: DefaultHttpClientConfig): HttpClientBuilder;
+declare const makeHttpClientBuilder: typeof httpClientBuilder;
+declare const httpBuilder: typeof httpClientBuilder;
+
+type HttpServerMethod = HttpMethod | "ALL";
+type HttpServerHeaders = Record<string, string>;
+type HttpServerQuery = Record<string, string | readonly string[]>;
+type HttpServerParams = Record<string, string>;
+type HttpServerBody = string | Uint8Array | ArrayBuffer | unknown;
+type HttpServerRequest = {
+    readonly method: string;
+    readonly url: string;
+    readonly path: string;
+    readonly target: string;
+    readonly headers: HttpServerHeaders;
+    readonly query: HttpServerQuery;
+    readonly params: HttpServerParams;
+    readonly bodyText: string;
+    readonly raw?: unknown;
+};
+type HttpServerContext<Params = HttpServerParams, Query = HttpServerQuery, Body = unknown> = Omit<HttpServerRequest, "params" | "query"> & {
+    readonly route: string;
+    readonly params: Params;
+    readonly query: Query;
+    readonly body: Body;
+};
+type HttpServerResponse<Body = unknown> = {
+    readonly status?: number;
+    readonly headers?: HttpServerHeaders;
+    readonly body?: Body;
+};
+type HttpServerHandler<R = unknown, E = unknown, Params = HttpServerParams, Query = HttpServerQuery, Body = unknown, ResponseBody = unknown> = (ctx: HttpServerContext<Params, Query, Body>) => Async<R, E, HttpServerResponse<ResponseBody>>;
+type HttpServerMiddleware = (next: HttpServerHandler<any, any, any, any, any, any>) => HttpServerHandler<any, any, any, any, any, any>;
+type HttpRouteSchemas<ParamsSchema extends AnyJsonSchemaLike | undefined = undefined, QuerySchema extends AnyJsonSchemaLike | undefined = undefined, BodySchema extends AnyJsonSchemaLike | undefined = undefined, ResponseSchema extends AnyJsonSchemaLike | undefined = undefined> = {
+    readonly params?: ParamsSchema;
+    readonly paramsSchemaName?: string;
+    readonly query?: QuerySchema;
+    readonly querySchemaName?: string;
+    readonly body?: BodySchema;
+    readonly bodySchemaName?: string;
+    readonly response?: ResponseSchema;
+    readonly responseSchemaName?: string;
+};
+type HttpRouteOptions<ParamsSchema extends AnyJsonSchemaLike | undefined = undefined, QuerySchema extends AnyJsonSchemaLike | undefined = undefined, BodySchema extends AnyJsonSchemaLike | undefined = undefined, ResponseSchema extends AnyJsonSchemaLike | undefined = undefined> = HttpRouteSchemas<ParamsSchema, QuerySchema, BodySchema, ResponseSchema> & {
+    readonly middleware?: readonly HttpServerMiddleware[];
+};
+type HttpRuntimeHealthRouteOptions = RuntimeHealthOptions & {
+    readonly path?: string;
+};
+type InferServerPart<Schema, Fallback> = Schema extends AnyJsonSchemaLike ? InferJsonSchema<Schema> : Fallback;
+type RoutePathParamNames<Path extends string> = Path extends `${string}:${infer Param}/${infer Rest}` ? StripRouteParamModifier<Param> | RoutePathParamNames<`/${Rest}`> : Path extends `${string}:${infer Param}` ? StripRouteParamModifier<Param> : never;
+type RoutePathParams<Path extends string> = [
+    RoutePathParamNames<Path>
+] extends [never] ? {} : {
+    readonly [Key in RoutePathParamNames<Path>]: string;
+};
+type StripRouteParamModifier<Param extends string> = Param extends `${infer Name}?` ? Name : Param extends `${infer Name}+` ? Name : Param extends `${infer Name}*` ? Name : Param;
+type HttpServerRoute<R = unknown, E = unknown, Path extends string = string, ParamsSchema extends AnyJsonSchemaLike | undefined = AnyJsonSchemaLike | undefined, QuerySchema extends AnyJsonSchemaLike | undefined = AnyJsonSchemaLike | undefined, BodySchema extends AnyJsonSchemaLike | undefined = AnyJsonSchemaLike | undefined, ResponseSchema extends AnyJsonSchemaLike | undefined = AnyJsonSchemaLike | undefined> = {
+    readonly method: HttpServerMethod;
+    readonly path: Path;
+    readonly options: HttpRouteOptions<ParamsSchema, QuerySchema, BodySchema, ResponseSchema>;
+    readonly handler: HttpServerHandler<R, E, InferServerPart<ParamsSchema, RoutePathParams<Path>>, InferServerPart<QuerySchema, HttpServerQuery>, InferServerPart<BodySchema, unknown>, InferServerPart<ResponseSchema, unknown>>;
+    readonly match: (path: string) => HttpServerParams | undefined;
+};
+type HttpRouterOptions = {
+    readonly middleware?: readonly HttpServerMiddleware[];
+    readonly includeErrorDetails?: boolean;
+};
+type HttpRouteMatch = {
+    readonly _tag: "Match";
+    readonly route: HttpServerRoute<any, any, any, any, any, any, any>;
+    readonly params: HttpServerParams;
+} | {
+    readonly _tag: "MethodNotAllowed";
+    readonly route: HttpServerRoute<any, any, any, any, any, any, any>;
+    readonly allowed: readonly HttpServerMethod[];
+} | {
+    readonly _tag: "NotFound";
+};
+type HttpRouter = {
+    readonly routes: readonly HttpServerRoute<any, any, any, any, any, any, any>[];
+    readonly match: (method: string, path: string) => HttpRouteMatch;
+    readonly handle: (request: HttpServerRequest, match?: HttpRouteMatch) => Async<unknown, never, HttpServerResponse>;
+    readonly listen: <R extends object = {}>(options?: Omit<NodeHttpServerOptions<R>, "router">) => Resource<unknown, NodeHttpServerError, NodeHttpServerHandle>;
+};
+type NodeHttpServerError = {
+    readonly _tag: "ListenError";
+    readonly error: unknown;
+    readonly message: string;
+} | {
+    readonly _tag: "ServerClosed";
+    readonly message: string;
+};
+type NodeHttpServerHandle = {
+    readonly server: Server;
+    readonly router: HttpRouter;
+    readonly address: () => AddressInfo | string | null;
+    readonly url: () => string | undefined;
+    readonly close: () => Promise<void>;
+};
+type NodeHttpServerOptions<R extends object = {}> = {
+    readonly router: HttpRouter | readonly HttpServerRoute<any, any, any, any, any, any, any>[];
+    readonly host?: string;
+    readonly port?: number;
+    readonly env?: R;
+    readonly runtime?: Runtime<R>;
+    readonly runtimeOptions?: Omit<RuntimeOptions<R>, "env" | "hooks">;
+    readonly observability?: Observability;
+    readonly observabilityOptions?: HttpServerObservabilityOptions<HttpServerResponse>;
+    readonly maxBodyBytes?: number;
+    readonly gracefulShutdownMs?: number;
+    readonly shutdownPollSchedule?: Schedule<NodeHttpServerShutdownState, unknown>;
+    readonly onError?: (error: unknown) => void;
+};
+type NodeHttpServerShutdownState = {
+    readonly listening: boolean;
+    readonly elapsedMs: number;
+};
+declare function route<Path extends string, ParamsSchema extends AnyJsonSchemaLike | undefined = undefined, QuerySchema extends AnyJsonSchemaLike | undefined = undefined, BodySchema extends AnyJsonSchemaLike | undefined = undefined, ResponseSchema extends AnyJsonSchemaLike | undefined = undefined, R = unknown, E = unknown>(method: HttpServerMethod, path: Path, options: HttpRouteOptions<ParamsSchema, QuerySchema, BodySchema, ResponseSchema>, handler: HttpServerHandler<R, E, InferServerPart<ParamsSchema, RoutePathParams<Path>>, InferServerPart<QuerySchema, HttpServerQuery>, InferServerPart<BodySchema, unknown>, InferServerPart<ResponseSchema, unknown>>): HttpServerRoute<R, E, Path, ParamsSchema, QuerySchema, BodySchema, ResponseSchema>;
+declare function route<Path extends string, R = unknown, E = unknown>(method: HttpServerMethod, path: Path, handler: HttpServerHandler<R, E, RoutePathParams<Path>>): HttpServerRoute<R, E, Path, undefined, undefined, undefined, undefined>;
+declare const httpRoute: typeof route;
+declare function makeHttpRouter(routes: readonly HttpServerRoute<any, any, any, any, any, any, any>[], options?: HttpRouterOptions): HttpRouter;
+declare function json<Body>(body: Body, init?: Omit<HttpServerResponse<Body>, "body">): HttpServerResponse<Body>;
+declare function text(body: string, init?: Omit<HttpServerResponse<string>, "body">): HttpServerResponse<string>;
+declare function empty(status?: number, headers?: HttpServerHeaders): HttpServerResponse<void>;
+declare function makeRuntimeHealthRoute(options?: HttpRuntimeHealthRouteOptions): HttpServerRoute<unknown, never, string, undefined, undefined, undefined, undefined>;
+declare function makeRuntimeReadinessRoute(options?: HttpRuntimeHealthRouteOptions): HttpServerRoute<unknown, never, string, undefined, undefined, undefined, undefined>;
+declare const runtimeHealthRoute: typeof makeRuntimeHealthRoute;
+declare const runtimeReadinessRoute: typeof makeRuntimeReadinessRoute;
+declare function withResponseHeader(name: string, value: string): HttpServerMiddleware;
+declare function makeNodeHttpServer<R extends object = {}>(options: NodeHttpServerOptions<R>): Async<unknown, NodeHttpServerError, NodeHttpServerHandle>;
+declare function nodeHttpServerResource<R extends object = {}>(options: NodeHttpServerOptions<R>): Resource<unknown, NodeHttpServerError, NodeHttpServerHandle>;
+declare const makeNodeHttpServerResource: typeof nodeHttpServerResource;
+declare const makeHttpServerResource: typeof nodeHttpServerResource;
+
+export { AdaptiveLimiter, AdaptiveLimiterConfig, AdaptiveLimiterPreset, AnyJsonSchemaLike, type BatchConfig, type BatchFunction, type BudgetSemaphore, type CacheConfig$1 as CacheConfig, type CacheKeyComponents, type CachePolicyResult$1 as CachePolicyResult, type CompressionConfig, type CompressionMiddlewareResult, type CompressionStats, type ConnectionPrewarmAttempt, type ConnectionPrewarmConfig, type ConnectionPrewarmEvent, type ConnectionPrewarmResult, type ConnectionPrewarmingMiddlewareConfig, type ConnectionStateMap, DEFAULT_CACHE_RELEVANT_HEADERS, type DecompressResult, type Decompressor, type DedupConfig$1 as DedupConfig, type DefaultGetJson, type DefaultHttpClient, type DefaultHttpClientConfig, type DefaultHttpClientFeatures, type DefaultHttpClientPreset, type DefaultPostJson, type Dx, EmaComputer, type HttpCircuitBreakerConfig, HttpClient, type HttpClientBuilder, HttpClientFn, HttpClientStats, HttpClientStream, HttpError, type HttpErrorHandlers, type HttpJsonInit, type HttpMeta, HttpMethod, HttpMiddleware, HttpPoolConfig, type HttpPostJsonBodyInit, type HttpPostJsonInit, type HttpPostJsonSchemaBodyInit, HttpRequest, type HttpResponse, type HttpResponseWithMeta, type HttpRouteMatch, type HttpRouteOptions, type HttpRouteSchemas, type HttpRouter, type HttpRouterOptions, type HttpRuntimeHealthRouteOptions, type HttpServerBody, type HttpServerContext, type HttpServerHandler, type HttpServerHeaders, type HttpServerMethod, type HttpServerMiddleware, type HttpServerParams, type HttpServerQuery, type HttpServerRequest, type HttpServerResponse, type HttpServerRoute, HttpWireResponse, HttpWireResponseStream, type HttpWireWithMeta, InferJsonSchema, type InferServerPart, type JsonDecodeResult, JsonSchemaLike, type KnownHttpError, type KnownHttpErrorTag, LRUCache, type LRUCacheConfig, LatencyWindow, type LifecycleClient, type LifecycleClientConfig, type LifecycleEvent, type LifecycleEventType, type LifecycleRequestOptions, type LifecycleStats, LifecycleStatsTracker, type LogEvent, MakeHttpConfig, type NodeHttpServerError, type NodeHttpServerHandle, type NodeHttpServerOptions, type NodeHttpServerShutdownState, type PrewarmConfig, type PrewarmEvent, type PrewarmEventType, type PrewarmLifecycleConfig, type PrewarmManager, type PrewarmOriginState, type PrewarmOriginStatus, type PrewarmResult, type PrewarmResultStatus, type PrewarmStatusSnapshot, type PriorityConfig$1 as PriorityConfig, PriorityQueue, type PriorityQueueEntry, type ProbeOutcome, type RequestBatchingConfig, type RequestBatchingEvent, type RequestCompressionConfig, type RequestCompressionMiddlewareResult, type RequestCompressionStats, RetryPolicy, type RoutePathParamNames, type RoutePathParams, SEPARATOR, SUPPORTED_ENCODINGS, SchemaIssue, type SupportedEncoding, type ValidationError, clampPriority, computeCacheKey, computeGradient, computeNewLimit, decodeJsonBody, decodeJsonBodyEffect, defaultHttpClientPreset, detectPlatform, empty, encodeJsonBodyEffect, executeProbe, formatHttpError, httpBuilder, httpClient, httpClientBuilder, httpClientStream, httpClientWithMeta, httpRoute, isCircuitBreakerOpen, isHttpError, isKnownHttpError, isValidationError, json, makeBudgetSemaphore, makeCompressionMiddleware, makeConnectionStateMap, makeDefaultHttpClient, makeHttpClient, makeHttpClientBuilder, makeHttpRouter, makeHttpServerResource, makeLifecycleClient, makeNodeHttpServer, makeNodeHttpServerResource, makePrewarmManager, makeRequestCompressionMiddleware, makeResponseCompressionMiddleware, makeRuntimeHealthRoute, makeRuntimeReadinessRoute, matchHttpError, nodeHttpServerResource, parseCacheKey, prewarmConnections, prewarmHttpConnections, route, runtimeHealthRoute, runtimeReadinessRoute, text, validateFetchAvailable, validateOrigin, validatedJson, validatedJsonResponse, withAuth, withBatch, withCache, withCircuitBreaker, withConnectionPrewarming, withDedup, withLogging, withPriority, withRequestBatching, withResponseHeader, withResponseTransform, withTracing };