brass-runtime 1.16.1 → 1.18.0

package/dist/http/index.d.ts

@@ -1,15 +1,16 @@
-import { e as HttpRequestPolicyRef, f as HttpRequestRetryOverride, a as HttpRequest, c as HttpError, b as HttpWireResponse, V as ValidationError, d as HttpMiddleware, R as RetryPolicy, H as HttpClient, M as MakeHttpConfig, g as HttpWireResponseStream, h as HttpClientStream, i as HttpClientStats, j as AdaptiveLimiter, k as HttpClientFn, l as AdaptiveLimiterConfig, m as HttpMethod, n as HttpPolicyPresets, o as HttpTransport, p as AdaptiveLimiterPreset, q as HttpPoolConfig } from '../client-CZHU674n.js';
-export { r as AdaptiveAcquireOptions, s as AdaptiveBaselineStrategy, t as AdaptiveHeadroomContext, u as AdaptiveHeadroomMode, v as AdaptiveHeadroomStrategy, w as AdaptiveLease, x as AdaptiveLimiterDiagnostics, y as AdaptiveLimiterKeySnapshot, A as AdaptiveLimiterStats, z as AdaptiveQueueLoadShedding, B as AdaptiveQueueStrategy, C as AdaptiveReleaseInfo, D as HttpBody, E as HttpClientStreamFn, F as HttpConcurrencyPool, G as HttpErrorHandlers, I as HttpInit, J as HttpPolicyPreset, K as HttpPoolKeyResolver, L as HttpPoolKeyStats, N as HttpPoolLease, O as HttpPoolStats, P as HttpRequestPolicy, Q as HttpRetryScheduleInput, S as HttpStreamTransport, T as HttpTransportContext, U as HttpTransportTiming, W as JsonDecodeResult, X as KnownHttpError, Y as KnownHttpErrorTag, Z as LimitChangeEvent, _ as PerRequestRetryOverride, $ as PromiseHttpTransportBodyBuilder, a0 as PromiseHttpTransportBodySelector, a1 as PromiseHttpTransportConfig, a2 as PromiseHttpTransportConfigWithSignal, a3 as PromiseHttpTransportFluentResponseBuilder, a4 as PromiseHttpTransportRequestConfigBuilder, a5 as PromiseHttpTransportRequestConfigContext, a6 as PromiseHttpTransportRequestConfigMapper, a7 as PromiseHttpTransportResponse, a8 as PromiseHttpTransportResponseInfo, a9 as PromiseHttpTransportResponseInfoMapper, aa as PromiseHttpTransportStartBuilder, ab as ResolveHttpRequestPolicyOptions, ac as ResolvedConfig, ad as RetryEvent, ae as RetryScheduleInput, af as RetryableHttpErrorOptions, ag as ToHttpErrorOptions, ah as abortErrorForSignal, ai as adaptiveLimiterPresets, aj as backoffDelayMs, ak as decodeJsonBody, al as decodeJsonBodyEffect, am as decorate, an as defaultRetryOnError, ao as defaultRetryOnStatus, ap as defaultRetryableMethods, aq as defineHttpPolicyPresets, ar as encodeJsonBodyEffect, as as formatHttpError, at as getHttpRequestPolicy, au as headersOf, av as httpErrorStatus, aw as httpPolicy, ax as isAbortError, ay as isAbortHttpError, az as isCircuitBreakerOpen, aA as isExternalAbortError, aB as isExternalTimeoutError, aC as isFetchHttpError, aD as isHttpError, aE as isKnownHttpError, aF as isRetryableHttpError, aG as isRetryableHttpStatus, aH as isTaggedHttpError, aI as isTimeoutHttpError, aJ as isValidationError, aK as linkAbortSignals, aL as makeAdaptiveLimiterConfig, aM as makeFetchStreamTransport, aN as makeFetchTransport, aO as makeHttp, aP as makeHttpStream, aQ as makePromiseHttpTransport, aR as matchHttpError, aS as normalizeHeadersInit, aT as normalizeHttpError, aU as normalizeHttpHeaders, aV as normalizeRetryBudget, aW as promiseHttpTransport, aX as resolveConfig, aY as resolveHttpPoolKey, aZ as resolveHttpRequestPolicyPresets, a_ as retryAfterMs, a$ as toHttpError, b0 as validateConfig, b1 as validatedJson, b2 as validatedJsonResponse, b3 as withHttpPolicyPresets, b4 as withHttpRequestPolicy, b5 as withMiddleware, b6 as withRetry, b7 as withRetryStream } from '../client-CZHU674n.js';
-import { C as AsyncWithPromise, A as Async, f as Runtime, h as RuntimeOptions } from '../effect-DIUHZ9IN.js';
+import { C as CompressionConfig, f as CompressionMiddlewareResult, R as RequestCompressionConfig, g as RequestCompressionMiddlewareResult, e as DefaultHttpClientConfig, h as HttpTransport, D as DefaultHttpClient, i as AdaptiveLimiter, H as HttpRequest, d as HttpMiddleware, L as LifecycleClientConfig, j as LifecycleClient, b as HttpWireResponse, c as HttpError, k as LifecycleEvent, l as HttpClientStats, m as LifecycleEventType, n as LifecycleStats, P as PrewarmResult, o as PrewarmStatusSnapshot, p as PrewarmConfig, q as HttpClientFn, r as PrewarmOriginState, s as HttpMethod, t as DefaultHttpClientPreset, u as DedupConfig$1, B as BatchConfig, v as CacheConfig$1, w as PriorityConfig$1, x as RetryPolicy, y as PrewarmLifecycleConfig, z as AdaptiveLimiterConfig, E as AdaptiveLimiterPreset, F as HttpPoolConfig } from '../defaultClient-DhpCQW9m.js';
+export { G as AdaptiveAcquireOptions, I as AdaptiveBaselineStrategy, J as AdaptiveHeadroomContext, K as AdaptiveHeadroomMode, M as AdaptiveHeadroomStrategy, N as AdaptiveLease, O as AdaptiveLimiterDiagnostics, Q as AdaptiveLimiterKeySnapshot, A as AdaptiveLimiterStats, S as AdaptiveQueueLoadShedding, T as AdaptiveQueueStrategy, U as AdaptiveReleaseInfo, V as BatchFunction, W as CachePolicyResult, X as CompressionStats, Y as DecompressResult, Z as Decompressor, _ as DefaultGetJson, $ as DefaultHttpClientFeatures, a0 as DefaultPostJson, a1 as Dx, a2 as HttpBody, a as HttpClient, a3 as HttpClientStream, a4 as HttpClientStreamFn, a5 as HttpConcurrencyPool, a6 as HttpErrorHandlers, a7 as HttpInit, a8 as HttpJsonInit, a9 as HttpMeta, aa as HttpPolicyPreset, ab as HttpPolicyPresets, ac as HttpPoolKeyResolver, ad as HttpPoolKeyStats, ae as HttpPoolLease, af as HttpPoolStats, ag as HttpPostJsonBodyInit, ah as HttpPostJsonInit, ai as HttpPostJsonSchemaBodyInit, aj as HttpRequestPolicy, ak as HttpRequestPolicyRef, al as HttpRequestRetryOverride, am as HttpResponse, an as HttpResponseWithMeta, ao as HttpRetryScheduleInput, ap as HttpStreamTransport, aq as HttpTransportContext, ar as HttpTransportTiming, as as HttpWireResponseStream, at as HttpWireWithMeta, au as JsonDecodeResult, av as KnownHttpError, aw as KnownHttpErrorTag, ax as LifecycleRequestOptions, ay as LimitChangeEvent, az as MakeHttpConfig, aA as PerRequestRetryOverride, aB as PrewarmEvent, aC as PrewarmEventType, aD as PrewarmOriginStatus, aE as PrewarmResultStatus, aF as PromiseHttpTransportBodyBuilder, aG as PromiseHttpTransportBodySelector, aH as PromiseHttpTransportConfig, aI as PromiseHttpTransportConfigWithSignal, aJ as PromiseHttpTransportFluentResponseBuilder, aK as PromiseHttpTransportRequestConfigBuilder, aL as PromiseHttpTransportRequestConfigContext, aM as PromiseHttpTransportRequestConfigMapper, aN as PromiseHttpTransportResponse, aO as PromiseHttpTransportResponseInfo, aP as PromiseHttpTransportResponseInfoMapper, aQ as PromiseHttpTransportStartBuilder, aR as RequestCompressionStats, aS as ResolveHttpRequestPolicyOptions, aT as ResolvedConfig, aU as RetryEvent, aV as RetryScheduleInput, aW as RetryableHttpErrorOptions, aX as SUPPORTED_ENCODINGS, aY as SupportedEncoding, aZ as ToHttpErrorOptions, a_ as ValidationError, a$ as abortErrorForSignal, b0 as adaptiveLimiterPresets, b1 as backoffDelayMs, b2 as decodeJsonBody, b3 as decodeJsonBodyEffect, b4 as decorate, b5 as defaultHttpClientPreset, b6 as defaultRetryOnError, b7 as defaultRetryOnStatus, b8 as defaultRetryableMethods, b9 as defineHttpPolicyPresets, ba as encodeJsonBodyEffect, bb as formatHttpError, bc as getHttpRequestPolicy, bd as headersOf, be as httpClient, bf as httpClientStream, bg as httpClientWithMeta, bh as httpErrorStatus, bi as httpPolicy, bj as isAbortError, bk as isAbortHttpError, bl as isCircuitBreakerOpen, bm as isExternalAbortError, bn as isExternalTimeoutError, bo as isFetchHttpError, bp as isHttpError, bq as isKnownHttpError, br as isRetryableHttpError, bs as isRetryableHttpStatus, bt as isTaggedHttpError, bu as isTimeoutHttpError, bv as isValidationError, bw as linkAbortSignals, bx as makeAdaptiveLimiterConfig, by as makeDefaultHttpClient, bz as makeFetchStreamTransport, bA as makeFetchTransport, bB as makeHttp, bC as makeHttpStream, bD as makeJsonParseValidationError, bE as makePromiseHttpTransport, bF as matchHttpError, bG as normalizeHeadersInit, bH as normalizeHttpError, bI as normalizeHttpHeaders, bJ as normalizeRetryBudget, bK as promiseHttpTransport, bL as resolveConfig, bM as resolveHttpPoolKey, bN as resolveHttpRequestPolicyPresets, bO as retryAfterMs, bP as toHttpError, bQ as validateConfig, bR as validatedJson, bS as validatedJsonResponse, bT as withBatch, bU as withHttpPolicyPresets, bV as withHttpRequestPolicy, bW as withMiddleware, bX as withRetry, bY as withRetryStream } from '../defaultClient-DhpCQW9m.js';
+import { Agent, Server } from 'node:http';
+import { Agent as Agent$1 } from 'node:https';
+import { c as CircuitBreakerConfig, l as Schedule, a as LayerContext, S as ServiceTag, L as Layer } from '../layer-BalPI6cN.js';
+import { T as Tracer, R as Resource } from '../tracing-BABA5arE.js';
+import { A as Async, b as Runtime, a as RuntimeOptions } from '../effect-CtUDl5M5.js';
+import { AddressInfo } from 'node:net';
+import { O as Observability, q as HttpServerObservabilityOptions, $ as RuntimeHealthOptions } from '../server-C1zVmqE6.js';
 import { AnyJsonSchemaLike, InferJsonSchema } from '../schema/index.js';
 export { AnySchema, ConfigValidationError, InferObject, InferSchema, JsonSchemaLike, JsonValidator, JsonValidatorResult, NumberSchemaOptions, ObjectSchemaOptions, Schema, SchemaIssue, SchemaPathPart, SchemaResult, SchemaShape, SchemaValidationException, StringSchemaOptions, formatConfigError, formatIssues, isConfigValidationError, isSchema, makeSchemaIssue, parseConfig, s, schema, validateValue } from '../schema/index.js';
-import { d as CircuitBreakerConfig, S as Schedule } from '../schedule-CK3Ml_7p.js';
-import { T as Tracer, R as Resource } from '../tracing-DqbTKGcf.js';
-import { Server } from 'node:http';
-import { AddressInfo } from 'node:net';
-import { O as Observability, p as HttpServerObservabilityOptions, Z as RuntimeHealthOptions } from '../server-GJPg8ZSG.js';
-import '../stream-B4oK9JFP.js';
-import '../tracer-Hwt1cl7h.js';
+import '../stream-Bb4FTejt.js';
+import '../tracer-DzfuE6um.js';
 
 /**
  * A fixed-size circular buffer that stores latency samples and supports
@@ -104,150 +105,42 @@ declare function computeNewLimit(currentLimit: number, gradient: number, headroo
     readonly maxDecreaseRatio?: number;
 }): number;
 
-type HttpRequestPolicyInit = {
-    readonly policy?: HttpRequestPolicyRef;
-    readonly lane?: string;
-    readonly dedupKey?: string;
-    readonly priority?: number;
-    readonly retry?: HttpRequestRetryOverride;
-};
+/**
+ * Creates the compression middleware with optional configuration.
+ *
+ * The middleware:
+ * 1. Injects Accept-Encoding header on outgoing requests (if missing)
+ * 2. Decompresses response bodies based on Content-Encoding header
+ * 3. Tracks compression statistics
+ */
+declare function makeCompressionMiddleware(config?: CompressionConfig): CompressionMiddlewareResult;
+declare const makeResponseCompressionMiddleware: typeof makeCompressionMiddleware;
+declare function makeRequestCompressionMiddleware(config?: RequestCompressionConfig): RequestCompressionMiddlewareResult;
 
-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 NodeHttpTransportConfig = {
+    readonly keepAlive?: boolean;
+    readonly maxSockets?: number;
+    readonly maxFreeSockets?: number;
+    readonly httpAgent?: Agent;
+    readonly httpsAgent?: Agent$1;
+    readonly socketTimeoutMs?: number;
+};
+type NodeHttpTransport = HttpTransport & {
+    readonly destroy: () => void;
+};
+type NodeHttpProxyClientConfig = Omit<DefaultHttpClientConfig, "preset" | "transport"> & {
+    /**
+     * Defaults to the explicit hot proxy preset. Use `proxy` only when you need
+     * the shorter compatibility name in stats/config snapshots.
+     */
+    readonly preset?: "highThroughputProxy" | "proxy";
+    /** Existing Node transport to use. When omitted, Brass creates owned keep-alive agents. */
+    readonly transport?: NodeHttpTransport;
+    /** Options for the owned Node transport when `transport` is omitted. */
+    readonly nodeTransport?: NodeHttpTransportConfig;
+};
+declare function makeNodeHttpTransport(config?: NodeHttpTransportConfig): NodeHttpTransport;
+declare function makeNodeHttpProxyClient(config?: NodeHttpProxyClientConfig): DefaultHttpClient;
 
 type HttpCircuitBreakerConfig = CircuitBreakerConfig & {
     /** Key resolver for per-origin circuit breakers. Default: per-origin. */
@@ -268,459 +161,6 @@ declare function withCircuitBreaker(config?: HttpCircuitBreakerConfig): HttpMidd
  */
 declare function withTracing(tracer: Tracer): HttpMiddleware;
 
-/**
- * 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$1 = {
-    /** 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$1 = {
-    /** 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$1;
-    /** 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$1 = {
-    /** 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$1 = {
-    /** 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$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;
-};
-/**
- * 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;
-};
-
 /**
  * Creates a lifecycle-aware HTTP client that composes deduplication, caching,
  * and priority scheduling layers on top of the Wire_Client.
@@ -1735,106 +1175,6 @@ declare function withPriority(config?: PriorityConfig): HttpMiddleware & {
     queueDepth: () => number;
 };
 
-/**
- * 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;
-};
-
-/**
- * Creates the compression middleware with optional configuration.
- *
- * The middleware:
- * 1. Injects Accept-Encoding header on outgoing requests (if missing)
- * 2. Decompresses response bodies based on Content-Encoding header
- * 3. Tracks compression statistics
- */
-declare function makeCompressionMiddleware(config?: CompressionConfig): CompressionMiddlewareResult;
-declare const makeResponseCompressionMiddleware: typeof makeCompressionMiddleware;
-declare function makeRequestCompressionMiddleware(config?: RequestCompressionConfig): RequestCompressionMiddlewareResult;
-
 type RequestBatchingEvent = {
     type: "batch-enqueue";
     key: string;
@@ -2077,118 +1417,6 @@ declare function prewarmConnections(config?: ConnectionPrewarmConfig): Async<unk
 declare const prewarmHttpConnections: typeof prewarmConnections;
 declare function withConnectionPrewarming(config?: ConnectionPrewarmingMiddlewareConfig): HttpMiddleware;
 
-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" | "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.
-     * - 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;
-
 type HttpClientBuilder = {
     readonly config: () => DefaultHttpClientConfig;
     readonly baseUrl: (baseUrl: string) => HttpClientBuilder;
@@ -2199,6 +1427,7 @@ type HttpClientBuilder = {
     readonly transport: (transport: HttpTransport) => HttpClientBuilder;
     readonly preset: (preset: DefaultHttpClientPreset) => HttpClientBuilder;
     readonly minimal: () => HttpClientBuilder;
+    readonly proxy: () => HttpClientBuilder;
     readonly balanced: () => HttpClientBuilder;
     readonly defaultPreset: () => HttpClientBuilder;
     readonly production: () => HttpClientBuilder;
@@ -2380,4 +1609,11 @@ declare const HttpServer: Readonly<{
     }>;
 }>;
 
-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 HttpJsonInit, type HttpMeta, HttpMethod, HttpMiddleware, HttpPolicyPresets, HttpPoolConfig, type HttpPostJsonBodyInit, type HttpPostJsonInit, type HttpPostJsonSchemaBodyInit, HttpRequest, HttpRequestPolicyRef, HttpRequestRetryOverride, type HttpResponse, type HttpResponseWithMeta, type HttpRouteMatch, type HttpRouteOptions, type HttpRouteSchemas, type HttpRouter, type HttpRouterOptions, type HttpRuntimeHealthRouteOptions, HttpServer, type HttpServerBody, type HttpServerContext, type HttpServerHandler, type HttpServerHeaders, type HttpServerMethod, type HttpServerMiddleware, type HttpServerParams, type HttpServerQuery, type HttpServerRequest, type HttpServerResponse, type HttpServerRoute, HttpTransport, HttpWireResponse, HttpWireResponseStream, type HttpWireWithMeta, InferJsonSchema, type InferServerPart, 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, type SupportedEncoding, ValidationError, clampPriority, computeCacheKey, computeGradient, computeNewLimit, defaultHttpClientPreset, detectPlatform, empty, executeProbe, httpBuilder, httpClient, httpClientBuilder, httpClientStream, httpClientWithMeta, httpRoute, json, makeBudgetSemaphore, makeCompressionMiddleware, makeConnectionStateMap, makeDefaultHttpClient, makeHttpClient, makeHttpClientBuilder, makeHttpRouter, makeHttpServerResource, makeLifecycleClient, makeNodeHttpServer, makeNodeHttpServerResource, makePrewarmManager, makeRequestCompressionMiddleware, makeResponseCompressionMiddleware, makeRuntimeHealthRoute, makeRuntimeReadinessRoute, nodeHttpServerResource, parseCacheKey, prewarmConnections, prewarmHttpConnections, route, runtimeHealthRoute, runtimeReadinessRoute, text, validateFetchAvailable, validateOrigin, withAuth, withBatch, withCache, withCircuitBreaker, withConnectionPrewarming, withDedup, withLogging, withPriority, withRequestBatching, withResponseHeader, withResponseTransform, withTracing };
+declare const HttpClientService: ServiceTag<DefaultHttpClient>;
+type DefaultHttpClientLayerConfig = DefaultHttpClientConfig | ((context: LayerContext) => DefaultHttpClientConfig);
+type DefaultHttpClientLayerOptions = {
+    readonly tag?: ServiceTag<DefaultHttpClient>;
+};
+declare function makeDefaultHttpClientLayer(config?: DefaultHttpClientLayerConfig, options?: DefaultHttpClientLayerOptions): Layer<LayerContext, unknown, LayerContext>;
+
+export { AdaptiveLimiter, AdaptiveLimiterConfig, AdaptiveLimiterPreset, AnyJsonSchemaLike, BatchConfig, type BudgetSemaphore, CacheConfig$1 as CacheConfig, type CacheKeyComponents, CompressionConfig, CompressionMiddlewareResult, type ConnectionPrewarmAttempt, type ConnectionPrewarmConfig, type ConnectionPrewarmEvent, type ConnectionPrewarmResult, type ConnectionPrewarmingMiddlewareConfig, type ConnectionStateMap, DEFAULT_CACHE_RELEVANT_HEADERS, DedupConfig$1 as DedupConfig, DefaultHttpClient, DefaultHttpClientConfig, type DefaultHttpClientLayerConfig, type DefaultHttpClientLayerOptions, DefaultHttpClientPreset, EmaComputer, type HttpCircuitBreakerConfig, type HttpClientBuilder, HttpClientFn, HttpClientService, HttpClientStats, HttpError, HttpMethod, HttpMiddleware, HttpPoolConfig, HttpRequest, type HttpRouteMatch, type HttpRouteOptions, type HttpRouteSchemas, type HttpRouter, type HttpRouterOptions, type HttpRuntimeHealthRouteOptions, HttpServer, type HttpServerBody, type HttpServerContext, type HttpServerHandler, type HttpServerHeaders, type HttpServerMethod, type HttpServerMiddleware, type HttpServerParams, type HttpServerQuery, type HttpServerRequest, type HttpServerResponse, type HttpServerRoute, HttpTransport, HttpWireResponse, InferJsonSchema, type InferServerPart, LRUCache, type LRUCacheConfig, LatencyWindow, LifecycleClient, LifecycleClientConfig, LifecycleEvent, LifecycleEventType, LifecycleStats, LifecycleStatsTracker, type LogEvent, type NodeHttpProxyClientConfig, type NodeHttpServerError, type NodeHttpServerHandle, type NodeHttpServerOptions, type NodeHttpServerShutdownState, type NodeHttpTransport, type NodeHttpTransportConfig, PrewarmConfig, PrewarmLifecycleConfig, type PrewarmManager, PrewarmOriginState, PrewarmResult, PrewarmStatusSnapshot, PriorityConfig$1 as PriorityConfig, PriorityQueue, type PriorityQueueEntry, type ProbeOutcome, type RequestBatchingConfig, type RequestBatchingEvent, RequestCompressionConfig, RequestCompressionMiddlewareResult, RetryPolicy, type RoutePathParamNames, type RoutePathParams, SEPARATOR, clampPriority, computeCacheKey, computeGradient, computeNewLimit, detectPlatform, empty, executeProbe, httpBuilder, httpClientBuilder, httpRoute, json, makeBudgetSemaphore, makeCompressionMiddleware, makeConnectionStateMap, makeDefaultHttpClientLayer, makeHttpClient, makeHttpClientBuilder, makeHttpRouter, makeHttpServerResource, makeLifecycleClient, makeNodeHttpProxyClient, makeNodeHttpServer, makeNodeHttpServerResource, makeNodeHttpTransport, makePrewarmManager, makeRequestCompressionMiddleware, makeResponseCompressionMiddleware, makeRuntimeHealthRoute, makeRuntimeReadinessRoute, nodeHttpServerResource, parseCacheKey, prewarmConnections, prewarmHttpConnections, route, runtimeHealthRoute, runtimeReadinessRoute, text, validateFetchAvailable, validateOrigin, withAuth, withCache, withCircuitBreaker, withConnectionPrewarming, withDedup, withLogging, withPriority, withRequestBatching, withResponseHeader, withResponseTransform, withTracing };