brass-runtime 1.16.1 → 1.18.0

package/dist/client-CZHU674n.d.ts

@@ -1,820 +0,0 @@
-import { A as Async } from './effect-DIUHZ9IN.js';
-import { Z as ZStream } from './stream-B4oK9JFP.js';
-import { S as Schedule, a as ScheduleObserver, C as CircuitBreakerError } from './schedule-CK3Ml_7p.js';
-import { SchemaIssue, JsonSchemaLike } from './schema/index.js';
-
-type HttpRetryScheduleInput = {
-    readonly attempt: number;
-    readonly elapsedMs: number;
-    readonly request: HttpRequest;
-    readonly error?: HttpError;
-    readonly status?: number;
-    readonly retryAfterMs?: number;
-};
-type HttpRequestRetryOverride = false | {
-    readonly maxRetries?: number;
-    readonly baseDelayMs?: number;
-    readonly maxDelayMs?: number;
-    readonly schedule?: Schedule<HttpRetryScheduleInput, unknown>;
-    readonly retryOnStatus?: (status: number) => boolean;
-};
-type HttpRequestPolicy = {
-    readonly preset?: string;
-    readonly lane?: string;
-    readonly dedupKey?: string;
-    readonly priority?: number;
-    readonly retry?: HttpRequestRetryOverride;
-    readonly poolKey?: string;
-};
-type HttpRequestPolicyRef = HttpRequestPolicy | string;
-type HttpPolicyPreset = HttpRequestPolicy | ((request: HttpRequest, presetName: string) => HttpRequestPolicy);
-type HttpPolicyPresets = Record<string, HttpPolicyPreset>;
-type ResolveHttpRequestPolicyOptions = {
-    readonly presets?: HttpPolicyPresets;
-};
-declare const defineHttpPolicyPresets: <Presets extends HttpPolicyPresets>(presets: Presets) => Presets;
-declare const httpPolicy: Readonly<{
-    preset: (preset: string, overrides?: Omit<HttpRequestPolicy, "preset">) => HttpRequestPolicy;
-    lane: (lane: string, overrides?: Omit<HttpRequestPolicy, "preset" | "lane">) => HttpRequestPolicy;
-    define: <Presets extends HttpPolicyPresets>(presets: Presets) => Presets;
-}>;
-declare const getHttpRequestPolicy: (req: HttpRequest, options?: ResolveHttpRequestPolicyOptions) => HttpRequestPolicy;
-declare const withHttpRequestPolicy: (req: HttpRequest, patch: Partial<HttpRequestPolicy>) => HttpRequest;
-declare const resolveHttpRequestPolicyPresets: (req: HttpRequest, presets: HttpPolicyPresets) => HttpRequest;
-declare const withHttpPolicyPresets: (presets: HttpPolicyPresets) => HttpMiddleware;
-
-/**
- * Observable event emitted on each retry attempt via the `onRetry` callback.
- */
-type RetryEvent = {
-    /** Zero-based attempt number (0 = first retry, not the initial request). */
-    attempt: number;
-    /** Computed delay in milliseconds before the next attempt. */
-    delayMs: number;
-    /** The error that triggered this retry, if the request failed with an HttpError. */
-    error?: HttpError;
-    /** The HTTP status code that triggered this retry, if the request returned a retryable status. */
-    status?: number;
-    /** The request URL. */
-    url: string;
-    /** The request HTTP method. */
-    method: HttpMethod;
-    /** Timestamp (ms since epoch) when the retry decision was made. */
-    timestamp: number;
-};
-type RetryScheduleInput = HttpRetryScheduleInput;
-/**
- * Per-request retry override. Prefer `req.policy.retry`; legacy top-level `req.retry`
- * is still supported.
- * - `false` disables retry entirely for this request.
- * - A partial policy object merges with the middleware-level policy (per-request wins).
- */
-type PerRequestRetryOverride = HttpRequestRetryOverride;
-type RetryPolicy = {
-    maxRetries: number;
-    baseDelayMs: number;
-    maxDelayMs: number;
-    /** Optional declarative schedule. When present, it provides retry delays. */
-    schedule?: Schedule<RetryScheduleInput, unknown>;
-    /** Optional observer for declarative schedule decisions. */
-    onScheduleDecision?: ScheduleObserver<RetryScheduleInput, unknown>;
-    /** Optional total retry budget, including request attempts and sleeps. */
-    maxElapsedMs?: number;
-    /** Defaults to true. When true, Retry-After is honored but capped by maxDelayMs/budget. */
-    respectRetryAfter?: boolean;
-    retryOnMethods?: HttpMethod[];
-    retryOnStatus?: (status: number) => boolean;
-    retryOnError?: (e: HttpError) => boolean;
-    /** Strict engine selector for retry planning. Defaults to ts. */
-    engine?: "ts" | "wasm";
-    /** Back-compat knob: wasm=true maps to engine="wasm", wasm=false maps to engine="ts". */
-    wasm?: boolean;
-    /** Called synchronously before each retry delay begins. Zero overhead when omitted. */
-    onRetry?: (event: RetryEvent) => void;
-};
-declare const defaultRetryableMethods: HttpMethod[];
-declare const defaultRetryOnStatus: (s: number) => s is 408 | 429 | 500 | 502 | 503 | 504;
-declare const defaultRetryOnError: (e: HttpError) => boolean;
-declare const backoffDelayMs: (attempt: number, base: number, cap: number) => number;
-declare const retryAfterMs: (headers: Record<string, string>) => number | undefined;
-declare const normalizeRetryBudget: (ms: number | undefined) => number | undefined;
-declare const withRetry: (p: RetryPolicy) => HttpMiddleware;
-
-type HttpPoolKeyResolver = "global" | "origin" | "host" | ((req: HttpRequest, url: URL) => string);
-type HttpPoolConfig = {
-    /** Max concurrent downstream calls per resolved key. */
-    readonly concurrency?: number;
-    /** Max queued waiters per key. `0` means fail fast when the pool is full. */
-    readonly maxQueue?: number;
-    /** Max time a request may wait for a pool slot before failing fast. */
-    readonly queueTimeoutMs?: number;
-    /** How to isolate pools. Default: `origin`; useful values: `global`, `host`, `origin`. */
-    readonly key?: HttpPoolKeyResolver;
-    /**
-     * Strict engine selector for permit governance. Defaults to ts.
-     * - ts: TypeScript permit pool.
-     * - wasm: require BrassWasmHttpPermitPool from wasm/pkg; never falls back.
-     */
-    readonly engine?: "ts" | "wasm";
-    /** Back-compat knob: wasm=true maps to engine="wasm", wasm=false maps to engine="ts". */
-    readonly wasm?: boolean;
-};
-type HttpPoolKeyStats = {
-    readonly key: string;
-    readonly running: number;
-    readonly queued: number;
-    readonly concurrency: number;
-    readonly maxQueue: number;
-    readonly acquired: number;
-    readonly released: number;
-    readonly rejected: number;
-    readonly queueTimeouts: number;
-    readonly abortedWhileQueued: number;
-};
-type HttpPoolStats = {
-    readonly running: number;
-    readonly queued: number;
-    readonly acquired: number;
-    readonly released: number;
-    readonly rejected: number;
-    readonly queueTimeouts: number;
-    readonly abortedWhileQueued: number;
-    readonly wasm?: unknown;
-    readonly keys: HttpPoolKeyStats[];
-};
-type HttpPoolLease = {
-    readonly key: string;
-    release: () => void;
-};
-declare function resolveHttpPoolKey(resolver: HttpPoolKeyResolver | undefined, req: HttpRequest, url: URL): string;
-declare class HttpConcurrencyPool {
-    private readonly states;
-    private readonly concurrency;
-    private readonly maxQueue;
-    private readonly queueTimeoutMs;
-    readonly keyResolver: HttpPoolKeyResolver | undefined;
-    private readonly wasm;
-    private readonly wasmWaiters;
-    private wasmTimer;
-    private nextSubjectId;
-    constructor(config?: HttpPoolConfig);
-    acquire(key: string, signal: AbortSignal): Promise<HttpPoolLease>;
-    stats(): HttpPoolStats;
-    private acquireJs;
-    private acquireWasm;
-    private getState;
-    private makeLease;
-    private drain;
-    private handleWasmGrants;
-    private handleWasmTimeouts;
-    private scheduleWasmTimeoutPump;
-    private cleanupWaiter;
-    private removeWaiter;
-    private allocateSubjectId;
-}
-
-type AdaptiveHeadroomMode = "stable" | "probe" | "warmup" | "slow-start" | "circuit-open";
-type AdaptiveHeadroomContext = {
-    readonly key: string;
-    readonly currentLimit: number;
-    readonly minLimit: number;
-    readonly maxLimit: number;
-    readonly gradient: number;
-    readonly mode: AdaptiveHeadroomMode;
-};
-type AdaptiveHeadroomStrategy = number | "fixed" | "proportional" | {
-    readonly type: "fixed";
-    readonly value?: number;
-} | {
-    readonly type: "proportional";
-    readonly ratio?: number;
-    readonly min?: number;
-    readonly max?: number;
-} | ((context: AdaptiveHeadroomContext) => number);
-type AdaptiveBaselineStrategy = "min" | "p5" | "ema-low";
-type AdaptiveQueueStrategy = "fifo" | "priority";
-type AdaptiveQueueLoadShedding = "reject-new" | "priority-evict";
-type AdaptiveLimiterPreset = "conservative" | "balanced" | "aggressive";
-type AdaptiveAcquireOptions = {
-    /** Request priority from 0 (highest) to 9 (lowest). Default: 5. */
-    readonly priority?: number;
-};
-type AdaptiveReleaseInfo = {
-    /** HTTP response status, used by the error signal when >= 500 by default. */
-    readonly status?: number;
-    /** Marks a failed request without an HTTP response, e.g. fetch error or timeout. */
-    readonly error?: boolean;
-};
-/**
- * Configuration for the adaptive concurrency limiter.
- * All fields are optional with sensible defaults.
- */
-type AdaptiveLimiterConfig = {
-    /** Named production preset used before caller overrides are applied. */
-    readonly preset?: AdaptiveLimiterPreset;
-    /** Initial concurrency limit. Default: 10. */
-    readonly initialLimit?: number;
-    /** Minimum concurrency limit. Default: 1. */
-    readonly minLimit?: number;
-    /** Maximum concurrency limit. Default: 200. */
-    readonly maxLimit?: number;
-    /** EMA smoothing factor in (0, 1]. Default: 0.5. */
-    readonly smoothingFactor?: number;
-    /** Number of completions between probes. Default: 10. */
-    readonly probeInterval?: number;
-    /** Random probe interval spread. 0 disables jitter, 0.2 means ±20%. Default: 0.2. */
-    readonly probeJitterRatio?: number;
-    /** Sliding window size for latency samples. Default: 100. */
-    readonly windowSize?: number;
-    /** Minimum samples before the limiter may change its limit. Default: 10. */
-    readonly minSamples?: number;
-    /** Baseline used for gradient computation. Default: "min". */
-    readonly baselineStrategy?: AdaptiveBaselineStrategy;
-    /** Samples to wait after a decrease before allowing another decrease. Default: 0. */
-    readonly decreaseCooldownSamples?: number;
-    /** Number of limit-change events retained per key for diagnostics. Default: 32. */
-    readonly historySize?: number;
-    /** Exponential decay applied to percentile windows. 1 disables weighting. Default: 1. */
-    readonly windowDecayFactor?: number;
-    /** Error signal weight blended with latency gradient. 0 disables. Default: 0. */
-    readonly errorWeight?: number;
-    /** EMA smoothing factor for the error rate signal. Defaults to smoothingFactor. */
-    readonly errorSmoothingFactor?: number;
-    /** HTTP status at/above which responses count as downstream errors. Default: 500. */
-    readonly errorStatusThreshold?: number;
-    /** Internal queue ordering. Default: "fifo". */
-    readonly queueStrategy?: AdaptiveQueueStrategy;
-    /** Queue-full behavior. Default: "reject-new". */
-    readonly queueLoadShedding?: AdaptiveQueueLoadShedding;
-    /** Rejection streak before PoolRejected carries retryAfterMs. Default: 3. */
-    readonly rejectionBackoffThreshold?: number;
-    /** Backoff hint for sustained PoolRejected errors. Default: undefined. */
-    readonly rejectionBackoffMs?: number;
-    /** Remove inactive per-key state after this idle period. Use false to disable. Default: 300000. */
-    readonly stateTtlMs?: number | false;
-    /** Number of valid completions used for explicit linear warmup. 0 disables. Default: 0. */
-    readonly warmupRequests?: number;
-    /** Gradient below which the limiter decreases concurrency. Default: 0.75. */
-    readonly decreaseThreshold?: number;
-    /** Gradient at or above which the limiter may increase concurrency. Default: 1.0. */
-    readonly increaseThreshold?: number;
-    /** Maximum fraction of the current limit that can be removed in one adjustment. Default: 0.2. */
-    readonly maxDecreaseRatio?: number;
-    /** Fixed, proportional, or custom headroom added on stable growth/probes. Default: 1. */
-    readonly headroomStrategy?: AdaptiveHeadroomStrategy;
-    /** Enable fast recovery after sustained saturation. Default: true. */
-    readonly slowStartRecovery?: boolean;
-    /** Gradient at/below which samples count as strong saturation. Default: 0.5. */
-    readonly slowStartSaturationThreshold?: number;
-    /** Consecutive strong-saturation samples before slow-start recovery arms. Default: 3. */
-    readonly slowStartSaturationSamples?: number;
-    /** Key resolver for isolation scope. Default: "origin". */
-    readonly key?: HttpPoolKeyResolver;
-    /** Maximum queue depth per key. Default: 256. */
-    readonly maxQueue?: number;
-    /** Queue timeout in ms. Default: undefined (no timeout). */
-    readonly queueTimeoutMs?: number;
-    /** Callback invoked when the limit changes. */
-    readonly onLimitChange?: (event: LimitChangeEvent) => void;
-    /** Which percentile to use for gradient computation. Default: "p50". */
-    readonly percentile?: "p50" | "p99";
-};
-/**
- * Event emitted when the concurrency limit changes.
- */
-type LimitChangeEvent = {
-    readonly key: string;
-    readonly previousLimit: number;
-    readonly newLimit: number;
-    readonly gradient: number;
-    readonly latencyGradient: number;
-    readonly errorRate: number;
-    readonly smoothedLatency: number;
-    readonly minLatency: number;
-    readonly baselineLatency: number;
-    readonly p5: number | undefined;
-    readonly timestamp: number;
-    readonly reason?: "gradient" | "probe" | "warmup" | "slow-start" | "circuit-open";
-};
-/**
- * Snapshot of the adaptive limiter's current state for a given key.
- */
-type AdaptiveLimiterStats = {
-    readonly limit: number;
-    readonly inFlight: number;
-    readonly queueDepth: number;
-    readonly gradient: number | undefined;
-    readonly latencyGradient: number | undefined;
-    readonly errorRate: number | undefined;
-    readonly smoothedLatency: number | undefined;
-    readonly minLatency: number | undefined;
-    readonly baselineLatency: number | undefined;
-    readonly p5: number | undefined;
-    readonly p50: number | undefined;
-    readonly p99: number | undefined;
-    readonly probeCount: number;
-    readonly windowSize: number;
-    readonly warmupCompletions?: number;
-    readonly slowStart?: boolean;
-    readonly cooldownSamplesRemaining?: number;
-    readonly utilization?: number;
-    readonly requestsPerSecond?: number;
-    readonly completionsPerSecond?: number;
-    readonly rejectionRate?: number;
-    readonly suggestedBackoffMs?: number;
-    readonly stateCount?: number;
-    readonly keys?: readonly string[];
-};
-type AdaptiveLimiterKeySnapshot = AdaptiveLimiterStats & {
-    readonly key: string;
-    readonly createdAt: number;
-    readonly createdTimestamp: number;
-    readonly lastActivityAt: number;
-    readonly lastActivityTimestamp: number;
-    readonly nextProbeAt: number;
-    readonly warmupDone: boolean;
-    readonly saturationStreak: number;
-    readonly slowStartRecoveryStarted: boolean;
-    readonly history: readonly LimitChangeEvent[];
-    readonly acquired: number;
-    readonly released: number;
-    readonly rejected: number;
-    readonly queueTimeouts: number;
-    readonly abortedWhileQueued: number;
-    readonly evictedWhileQueued: number;
-};
-type AdaptiveLimiterDiagnostics = {
-    readonly stateCount: number;
-    readonly keys: readonly string[];
-    readonly aggregate: AdaptiveLimiterStats;
-    readonly states: readonly AdaptiveLimiterKeySnapshot[];
-    readonly history: readonly LimitChangeEvent[];
-};
-/**
- * A lease representing an acquired concurrency slot.
- * Call `release(latencyMs)` when the request completes to record latency and free the slot.
- */
-type AdaptiveLease = {
-    readonly key: string;
-    release(latencyMs: number, info?: AdaptiveReleaseInfo): void;
-};
-/** Resolved (non-optional) configuration with defaults applied. */
-type ResolvedConfig = {
-    readonly preset: AdaptiveLimiterPreset | undefined;
-    readonly initialLimit: number;
-    readonly minLimit: number;
-    readonly maxLimit: number;
-    readonly smoothingFactor: number;
-    readonly probeInterval: number;
-    readonly probeJitterRatio: number;
-    readonly windowSize: number;
-    readonly minSamples: number;
-    readonly baselineStrategy: AdaptiveBaselineStrategy;
-    readonly decreaseCooldownSamples: number;
-    readonly historySize: number;
-    readonly windowDecayFactor: number;
-    readonly errorWeight: number;
-    readonly errorSmoothingFactor: number;
-    readonly errorStatusThreshold: number;
-    readonly queueStrategy: AdaptiveQueueStrategy;
-    readonly queueLoadShedding: AdaptiveQueueLoadShedding;
-    readonly rejectionBackoffThreshold: number;
-    readonly rejectionBackoffMs: number | undefined;
-    readonly stateTtlMs: number | undefined;
-    readonly warmupRequests: number;
-    readonly decreaseThreshold: number;
-    readonly increaseThreshold: number;
-    readonly maxDecreaseRatio: number;
-    readonly headroomStrategy: AdaptiveHeadroomStrategy;
-    readonly slowStartRecovery: boolean;
-    readonly slowStartSaturationThreshold: number;
-    readonly slowStartSaturationSamples: number;
-    readonly key: HttpPoolKeyResolver;
-    readonly maxQueue: number;
-    readonly queueTimeoutMs: number | undefined;
-    readonly onLimitChange: ((event: LimitChangeEvent) => void) | undefined;
-    readonly percentile: "p50" | "p99";
-};
-declare const adaptiveLimiterPresets: Readonly<{
-    conservative: Readonly<{
-        initialLimit: 8;
-        minLimit: 2;
-        maxLimit: 64;
-        maxQueue: 256;
-        queueTimeoutMs: 30000;
-        smoothingFactor: 0.3;
-        probeInterval: 40;
-        probeJitterRatio: 0.2;
-        windowSize: 100;
-        minSamples: 80;
-        baselineStrategy: "p5";
-        windowDecayFactor: 0.99;
-        errorWeight: 0.2;
-        decreaseThreshold: 0.65;
-        maxDecreaseRatio: 0.08;
-        headroomStrategy: "fixed";
-        queueStrategy: "priority";
-        queueLoadShedding: "priority-evict";
-        rejectionBackoffThreshold: 2;
-        rejectionBackoffMs: 150;
-        percentile: "p50";
-    }>;
-    balanced: Readonly<{
-        initialLimit: 16;
-        minLimit: 4;
-        maxLimit: 128;
-        maxQueue: 512;
-        queueTimeoutMs: 30000;
-        smoothingFactor: 0.35;
-        probeInterval: 25;
-        probeJitterRatio: 0.2;
-        windowSize: 100;
-        minSamples: 50;
-        baselineStrategy: "p5";
-        windowDecayFactor: 0.98;
-        errorWeight: 0.25;
-        decreaseThreshold: 0.5;
-        maxDecreaseRatio: 0.1;
-        headroomStrategy: {
-            type: "proportional";
-            ratio: number;
-        };
-        queueStrategy: "priority";
-        queueLoadShedding: "priority-evict";
-        rejectionBackoffThreshold: 3;
-        rejectionBackoffMs: 100;
-        percentile: "p50";
-    }>;
-    aggressive: Readonly<{
-        initialLimit: 32;
-        minLimit: 8;
-        maxLimit: 256;
-        maxQueue: 1024;
-        queueTimeoutMs: 30000;
-        smoothingFactor: 0.35;
-        probeInterval: 20;
-        probeJitterRatio: 0.2;
-        windowSize: 160;
-        minSamples: 100;
-        baselineStrategy: "p5";
-        windowDecayFactor: 0.98;
-        errorWeight: 0.25;
-        decreaseThreshold: 0.5;
-        maxDecreaseRatio: 0.1;
-        headroomStrategy: {
-            type: "proportional";
-            ratio: number;
-        };
-        queueStrategy: "priority";
-        queueLoadShedding: "priority-evict";
-        rejectionBackoffThreshold: 3;
-        rejectionBackoffMs: 100;
-        percentile: "p50";
-    }>;
-}>;
-declare function makeAdaptiveLimiterConfig(preset: AdaptiveLimiterPreset, overrides?: AdaptiveLimiterConfig): AdaptiveLimiterConfig;
-/**
- * Validates the adaptive limiter configuration.
- * Throws a descriptive error for invalid combinations.
- */
-declare function validateConfig(config: AdaptiveLimiterConfig): void;
-/**
- * Resolves a partial configuration into a fully-resolved configuration with defaults applied.
- * Handles minLimit > maxLimit by treating minLimit as the effective maxLimit.
- */
-declare function resolveConfig(config?: AdaptiveLimiterConfig): ResolvedConfig;
-
-/**
- * Adaptive concurrency limiter that dynamically adjusts the number of concurrent
- * requests based on observed latency patterns using a gradient-based algorithm.
- */
-declare class AdaptiveLimiter {
-    private readonly config;
-    private readonly states;
-    private destroyed;
-    constructor(config?: AdaptiveLimiterConfig);
-    /** Key resolver for external use by the HTTP client. */
-    get keyResolver(): HttpPoolKeyResolver | undefined;
-    /**
-     * Acquire a concurrency slot for the given key.
-     * Resolves immediately if under the limit, otherwise queues the request.
-     * Rejects with PoolRejected if the queue is full, or PoolTimeout if the queue timeout expires.
-     */
-    acquire(key: string, signal: AbortSignal, options?: AdaptiveAcquireOptions): Promise<AdaptiveLease>;
-    /**
-     * Get stats for a specific key, or aggregate stats if no key is provided.
-     */
-    stats(key?: string): AdaptiveLimiterStats;
-    /** Return the currently retained per-key state identifiers. */
-    keys(): readonly string[];
-    /** Return a diagnostic snapshot for one retained key, if present. */
-    snapshot(key: string): AdaptiveLimiterKeySnapshot | undefined;
-    /** Return a full diagnostic dump across all retained keys. */
-    dump(): AdaptiveLimiterDiagnostics;
-    /** Return retained limit-change history for one key, or all keys if omitted. */
-    history(key?: string): readonly LimitChangeEvent[];
-    /**
-     * Circuit-breaker feedback hook. When a circuit is already open for `key`,
-     * collapse that key's limit to minLimit immediately instead of waiting for
-     * latency gradients to discover the saturation indirectly.
-     */
-    markCircuitOpen(key: string): void;
-    /** Destroy the limiter, reject queued waiters, clear timers, and drop state. */
-    destroy(): void;
-    /** Alias for destroy(), useful for graceful shutdown code paths. */
-    shutdown(): void;
-    private getOrCreateState;
-    private makeLease;
-    private recordAndAdjust;
-    private tryWarmup;
-    private baselineLatency;
-    private lowLatencySample;
-    private isErrorSignal;
-    private combineGradientWithErrors;
-    private windowPercentile;
-    private recordSaturation;
-    private applyLimit;
-    private recordLimitChange;
-    private resolveHeadroom;
-    private nextProbeInterval;
-    private enqueueWaiter;
-    private dequeueWaiter;
-    private tryEvictLowerPriorityWaiter;
-    private suggestedBackoffMs;
-    private drain;
-    private currentLatency;
-    private touch;
-    private scheduleIdleEviction;
-    private clearIdleTimer;
-    private evictIdleStates;
-    private evictIdleState;
-    private cleanupWaiter;
-    private removeWaiter;
-    private stateToStats;
-    private stateToKeySnapshot;
-}
-
-type ValidationError = {
-    readonly _tag: "ValidationError";
-    readonly message: string;
-    readonly body: string;
-    readonly issues: readonly SchemaIssue[];
-    readonly phase?: "request" | "response";
-    readonly schema?: string;
-};
-type JsonDecodeResult<A> = {
-    readonly success: true;
-    readonly data: A;
-} | {
-    readonly success: false;
-    readonly error: ValidationError;
-};
-declare function decodeJsonBody<A = unknown>(bodyText: string, validator?: JsonSchemaLike<A>, options?: {
-    readonly schemaName?: string;
-}): JsonDecodeResult<A>;
-declare function encodeJsonBodyEffect(bodyObj: unknown, validator?: JsonSchemaLike<any>, options?: {
-    readonly schemaName?: string;
-}): Async<unknown, ValidationError, string>;
-declare function decodeJsonBodyEffect<A = unknown>(bodyText: string, validator?: JsonSchemaLike<A>, options?: {
-    readonly schemaName?: string;
-}): Async<unknown, ValidationError, A>;
-declare function validatedJson<A>(client: HttpClientFn, validator: JsonSchemaLike<A>): (req: Parameters<HttpClientFn>[0]) => Async<unknown, HttpError | ValidationError, A>;
-declare function validatedJsonResponse<A>(client: HttpClientFn, validator: JsonSchemaLike<A>): (req: Parameters<HttpClientFn>[0]) => Async<unknown, HttpError | ValidationError, HttpWireResponse & {
-    readonly body: A;
-}>;
-
-type KnownHttpError = HttpError | ValidationError | CircuitBreakerError;
-type KnownHttpErrorTag = KnownHttpError["_tag"];
-type ToHttpErrorOptions = {
-    readonly signal?: AbortSignal;
-    readonly timeoutMs?: number;
-    readonly phase?: "request" | "queue" | "retry";
-    readonly message?: string | ((error: unknown) => string);
-};
-type RetryableHttpErrorOptions = {
-    readonly retryOnStatus?: (status: number) => boolean;
-};
-type HttpErrorHandlers<R> = {
-    readonly [K in KnownHttpErrorTag]?: (error: Extract<KnownHttpError, {
-        readonly _tag: K;
-    }>) => R;
-} & {
-    readonly default?: (error: unknown) => R;
-};
-declare function isHttpError(error: unknown): error is HttpError;
-declare function isValidationError(error: unknown): error is ValidationError;
-declare function isCircuitBreakerOpen(error: unknown): error is CircuitBreakerError;
-declare function isKnownHttpError(error: unknown): error is KnownHttpError;
-declare function isAbortHttpError(error: unknown): error is Extract<HttpError, {
-    readonly _tag: "Abort";
-}>;
-declare function isTimeoutHttpError(error: unknown): error is Extract<HttpError, {
-    readonly _tag: "Timeout" | "PoolTimeout";
-}>;
-declare function isFetchHttpError(error: unknown): error is Extract<HttpError, {
-    readonly _tag: "FetchError";
-}>;
-declare function httpErrorStatus(error: unknown): number | undefined;
-declare function isRetryableHttpStatus(status: number): boolean;
-declare function isRetryableHttpError(error: unknown, options?: RetryableHttpErrorOptions): boolean;
-declare function isExternalAbortError(error: unknown): boolean;
-declare function isExternalTimeoutError(error: unknown): boolean;
-declare function toHttpError(error: unknown, options?: ToHttpErrorOptions): HttpError;
-declare function matchHttpError<R>(error: unknown, handlers: HttpErrorHandlers<R>): R | undefined;
-declare function formatHttpError(error: unknown): string;
-
-type HttpTransportContext = {
-    readonly request: HttpRequest;
-    readonly url: URL;
-    readonly signal: AbortSignal;
-};
-type HttpTransport = (context: HttpTransportContext) => Async<unknown, HttpError, HttpWireResponse>;
-type HttpStreamTransport = (context: HttpTransportContext) => Async<unknown, HttpError, HttpWireResponseStream>;
-type HttpTransportTiming = {
-    readonly startedAt: number;
-    readonly durationMs: number;
-};
-type PromiseHttpTransportResponse = Omit<HttpWireResponse, "ms"> & {
-    readonly ms?: number;
-};
-type PromiseHttpTransportConfig<Response> = {
-    readonly request: (context: HttpTransportContext) => Promise<Response>;
-    readonly response: (response: Response, context: HttpTransportContext, timing: HttpTransportTiming) => PromiseHttpTransportResponse | Promise<PromiseHttpTransportResponse>;
-    readonly error?: (error: unknown, context: HttpTransportContext) => HttpError;
-};
-type PromiseHttpTransportResponseInfo<Meta = unknown> = {
-    readonly status?: number;
-    readonly statusText?: string;
-    readonly headers?: unknown;
-    readonly ms?: number;
-    readonly transportMeta?: Meta;
-};
-type PromiseHttpTransportResponseInfoMapper<Response, Meta = unknown> = (response: Response, context: HttpTransportContext, timing: HttpTransportTiming) => PromiseHttpTransportResponseInfo<Meta> | Promise<PromiseHttpTransportResponseInfo<Meta>>;
-type PromiseHttpTransportBodySelector<Response, Body = unknown> = (response: Response, context: HttpTransportContext, timing: HttpTransportTiming) => Body | Promise<Body>;
-type PromiseHttpTransportRequestConfigContext = Omit<HttpTransportContext, "signal">;
-type PromiseHttpTransportRequestConfigMapper<Config> = (context: PromiseHttpTransportRequestConfigContext) => Config | Promise<Config>;
-type PromiseHttpTransportConfigWithSignal<Config> = Config extends object ? Config & {
-    readonly signal: AbortSignal;
-} : Config;
-type PromiseHttpTransportRequestConfigBuilder<Config> = {
-    readonly send: <Response>(send: (config: PromiseHttpTransportConfigWithSignal<Config>) => Promise<Response>) => PromiseHttpTransportBodyBuilder<Response>;
-};
-type PromiseHttpTransportFluentResponseBuilder<Response> = {
-    readonly response: (response?: PromiseHttpTransportResponseInfoMapper<Response>) => HttpTransport;
-    readonly error: (error: NonNullable<PromiseHttpTransportConfig<Response>["error"]>) => PromiseHttpTransportFluentResponseBuilder<Response>;
-};
-type PromiseHttpTransportBodyBuilder<Response> = {
-    readonly response: (response: PromiseHttpTransportConfig<Response>["response"]) => HttpTransport;
-    readonly json: <Body = unknown>(body?: PromiseHttpTransportBodySelector<Response, Body>, response?: PromiseHttpTransportResponseInfoMapper<Response>) => HttpTransport;
-    readonly text: (body?: PromiseHttpTransportBodySelector<Response, unknown>, response?: PromiseHttpTransportResponseInfoMapper<Response>) => HttpTransport;
-    readonly fromJson: <Body = unknown>(body?: PromiseHttpTransportBodySelector<Response, Body>) => PromiseHttpTransportFluentResponseBuilder<Response>;
-    readonly fromText: (body?: PromiseHttpTransportBodySelector<Response, unknown>) => PromiseHttpTransportFluentResponseBuilder<Response>;
-    readonly error: (error: NonNullable<PromiseHttpTransportConfig<Response>["error"]>) => PromiseHttpTransportBodyBuilder<Response>;
-};
-type PromiseHttpTransportStartBuilder = {
-    readonly request: <Response>(request: PromiseHttpTransportConfig<Response>["request"]) => PromiseHttpTransportBodyBuilder<Response>;
-    readonly requestConfig: <Config>(request: PromiseHttpTransportRequestConfigMapper<Config>) => PromiseHttpTransportRequestConfigBuilder<Config>;
-};
-declare const isTaggedHttpError: (error: unknown) => error is HttpError;
-declare const isAbortError: (error: unknown) => boolean;
-declare const normalizeHttpError: (error: unknown, options?: ToHttpErrorOptions) => HttpError;
-declare const headersOf: (response: Response) => Record<string, string>;
-declare function normalizeHttpHeaders(headers: unknown): Record<string, string>;
-declare const abortErrorForSignal: (signal: AbortSignal) => HttpError;
-declare const linkAbortSignals: (...signals: readonly (AbortSignal | undefined)[]) => {
-    signal: AbortSignal;
-    cleanup: () => void;
-};
-declare function makePromiseHttpTransport<Response>(config: PromiseHttpTransportConfig<Response>): HttpTransport;
-declare function promiseHttpTransport(): PromiseHttpTransportStartBuilder;
-declare function makeFetchTransport(): HttpTransport;
-declare function makeFetchStreamTransport(): HttpStreamTransport;
-
-type HttpError = {
-    _tag: "Abort";
-} | {
-    _tag: "BadUrl";
-    message: string;
-} | {
-    _tag: "FetchError";
-    message: string;
-    code?: string;
-    status?: number;
-    statusText?: string;
-    retryAfterMs?: number;
-    cause?: unknown;
-} | {
-    _tag: "Timeout";
-    timeoutMs: number;
-    message: string;
-    phase?: "request" | "queue" | "retry";
-} | {
-    _tag: "PoolRejected";
-    key: string;
-    limit: number;
-    message: string;
-    retryAfterMs?: number;
-} | {
-    _tag: "PoolTimeout";
-    key: string;
-    timeoutMs: number;
-    message: string;
-} | {
-    _tag: "PoolClosed";
-    key: string;
-    message: string;
-} | {
-    _tag: "BatchSplitError";
-    expected: number;
-    actual: number;
-    message: string;
-};
-type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
-type HttpInit = Omit<RequestInit, "method" | "body" | "headers">;
-type HttpBody = string | Uint8Array | ArrayBuffer;
-type HttpRequest = {
-    method: HttpMethod;
-    url: string;
-    headers?: Record<string, string>;
-    body?: HttpBody;
-    init?: HttpInit;
-    /** Structured per-request execution policy. Legacy top-level fields are still read. */
-    policy?: HttpRequestPolicyRef;
-    /** Per-request override for `MakeHttpConfig.timeoutMs`. */
-    timeoutMs?: number;
-    /** Optional stable key for downstream isolation. When omitted, the pool uses origin/host/global config. */
-    poolKey?: string;
-    /** @deprecated Use `policy.lane`. Kept for middleware interop. */
-    lane?: string;
-    /** @deprecated Use `policy.dedupKey`. Kept for middleware interop. */
-    dedupKey?: string;
-    /** @deprecated Use `policy.priority`. Kept for middleware interop. */
-    priority?: number;
-    /** @deprecated Use `policy.retry`. Kept for middleware interop. */
-    retry?: HttpRequestRetryOverride;
-};
-type HttpWireResponse<Meta = unknown> = {
-    status: number;
-    statusText: string;
-    headers: Record<string, string>;
-    bodyText: string;
-    ms: number;
-    transportMeta?: Meta;
-};
-type HttpClientStats = {
-    readonly inFlight: number;
-    readonly started: number;
-    readonly succeeded: number;
-    readonly failed: number;
-    readonly aborted: number;
-    readonly timedOut: number;
-    readonly poolRejected: number;
-    readonly poolTimeouts: number;
-    readonly lastDurationMs?: number;
-    readonly pool?: HttpPoolStats;
-    readonly adaptiveLimiter?: AdaptiveLimiterStats;
-};
-type MakeHttpConfig = {
-    baseUrl?: string;
-    headers?: Record<string, string>;
-    /** Request budget covering pool wait + fetch + body read. Disabled when omitted. */
-    timeoutMs?: number;
-    /** Effect-based transport. Defaults to `fetch`; provide one for axios/undici/test transports. */
-    transport?: HttpTransport;
-    /** Effect-based streaming transport. Defaults to `fetch` streaming. */
-    streamTransport?: HttpStreamTransport;
-    /** Downstream pool/concurrency limiter. Disabled by default to preserve existing behavior. */
-    pool?: false | HttpPoolConfig;
-    /** Adaptive concurrency limiter. Replaces fixed pool when enabled. */
-    adaptiveLimiter?: false | AdaptiveLimiterConfig;
-};
-type HttpWireResponseStream<Meta = unknown> = {
-    status: number;
-    statusText: string;
-    headers: Record<string, string>;
-    body: ZStream<unknown, HttpError, Uint8Array>;
-    ms: number;
-    transportMeta?: Meta;
-};
-type HttpClientStreamFn = (req: HttpRequest) => Async<unknown, HttpError, HttpWireResponseStream>;
-type HttpClientStream = HttpClientStreamFn & {
-    stats: () => HttpClientStats;
-};
-type HttpClientFn = (req: HttpRequest) => Async<unknown, HttpError, HttpWireResponse>;
-type HttpMiddleware = (next: HttpClientFn) => HttpClientFn;
-type HttpClient = HttpClientFn & {
-    with: (mw: HttpMiddleware) => HttpClient;
-    stats: () => HttpClientStats;
-    adaptiveLimiter?: AdaptiveLimiter;
-    destroy?: () => void;
-    shutdown?: () => void;
-};
-type HttpClientMetadata = Pick<HttpClient, "adaptiveLimiter" | "destroy" | "shutdown">;
-declare const decorate: (run: HttpClientFn, stats?: () => HttpClientStats, metadata?: HttpClientMetadata) => HttpClient;
-declare const withMiddleware: (mw: HttpMiddleware) => (c: HttpClient) => HttpClient;
-declare const normalizeHeadersInit: (h: any) => Record<string, string> | undefined;
-declare function makeHttpStream(cfg?: MakeHttpConfig): HttpClientStream;
-declare function makeHttp(cfg?: MakeHttpConfig): HttpClient;
-declare const withRetryStream: (p: RetryPolicy) => (next: HttpClientStream) => HttpClientStream;
-
-export { type PromiseHttpTransportBodyBuilder as $, type AdaptiveLimiterStats as A, type AdaptiveQueueStrategy as B, type AdaptiveReleaseInfo as C, type HttpBody as D, type HttpClientStreamFn as E, HttpConcurrencyPool as F, type HttpErrorHandlers as G, type HttpClient as H, type HttpInit as I, type HttpPolicyPreset as J, type HttpPoolKeyResolver as K, type HttpPoolKeyStats as L, type MakeHttpConfig as M, type HttpPoolLease as N, type HttpPoolStats as O, type HttpRequestPolicy as P, type HttpRetryScheduleInput as Q, type RetryPolicy as R, type HttpStreamTransport as S, type HttpTransportContext as T, type HttpTransportTiming as U, type ValidationError as V, type JsonDecodeResult as W, type KnownHttpError as X, type KnownHttpErrorTag as Y, type LimitChangeEvent as Z, type PerRequestRetryOverride as _, type HttpRequest as a, toHttpError as a$, type PromiseHttpTransportBodySelector as a0, type PromiseHttpTransportConfig as a1, type PromiseHttpTransportConfigWithSignal as a2, type PromiseHttpTransportFluentResponseBuilder as a3, type PromiseHttpTransportRequestConfigBuilder as a4, type PromiseHttpTransportRequestConfigContext as a5, type PromiseHttpTransportRequestConfigMapper as a6, type PromiseHttpTransportResponse as a7, type PromiseHttpTransportResponseInfo as a8, type PromiseHttpTransportResponseInfoMapper as a9, isExternalAbortError as aA, isExternalTimeoutError as aB, isFetchHttpError as aC, isHttpError as aD, isKnownHttpError as aE, isRetryableHttpError as aF, isRetryableHttpStatus as aG, isTaggedHttpError as aH, isTimeoutHttpError as aI, isValidationError as aJ, linkAbortSignals as aK, makeAdaptiveLimiterConfig as aL, makeFetchStreamTransport as aM, makeFetchTransport as aN, makeHttp as aO, makeHttpStream as aP, makePromiseHttpTransport as aQ, matchHttpError as aR, normalizeHeadersInit as aS, normalizeHttpError as aT, normalizeHttpHeaders as aU, normalizeRetryBudget as aV, promiseHttpTransport as aW, resolveConfig as aX, resolveHttpPoolKey as aY, resolveHttpRequestPolicyPresets as aZ, retryAfterMs as a_, type PromiseHttpTransportStartBuilder as aa, type ResolveHttpRequestPolicyOptions as ab, type ResolvedConfig as ac, type RetryEvent as ad, type RetryScheduleInput as ae, type RetryableHttpErrorOptions as af, type ToHttpErrorOptions as ag, abortErrorForSignal as ah, adaptiveLimiterPresets as ai, backoffDelayMs as aj, decodeJsonBody as ak, decodeJsonBodyEffect as al, decorate as am, defaultRetryOnError as an, defaultRetryOnStatus as ao, defaultRetryableMethods as ap, defineHttpPolicyPresets as aq, encodeJsonBodyEffect as ar, formatHttpError as as, getHttpRequestPolicy as at, headersOf as au, httpErrorStatus as av, httpPolicy as aw, isAbortError as ax, isAbortHttpError as ay, isCircuitBreakerOpen as az, type HttpWireResponse as b, validateConfig as b0, validatedJson as b1, validatedJsonResponse as b2, withHttpPolicyPresets as b3, withHttpRequestPolicy as b4, withMiddleware as b5, withRetry as b6, withRetryStream as b7, type HttpError as c, type HttpMiddleware as d, type HttpRequestPolicyRef as e, type HttpRequestRetryOverride as f, type HttpWireResponseStream as g, type HttpClientStream as h, type HttpClientStats as i, AdaptiveLimiter as j, type HttpClientFn as k, type AdaptiveLimiterConfig as l, type HttpMethod as m, type HttpPolicyPresets as n, type HttpTransport as o, type AdaptiveLimiterPreset as p, type HttpPoolConfig as q, type AdaptiveAcquireOptions as r, type AdaptiveBaselineStrategy as s, type AdaptiveHeadroomContext as t, type AdaptiveHeadroomMode as u, type AdaptiveHeadroomStrategy as v, type AdaptiveLease as w, type AdaptiveLimiterDiagnostics as x, type AdaptiveLimiterKeySnapshot as y, type AdaptiveQueueLoadShedding as z };