brass-runtime 1.17.0 → 1.18.1

package/dist/chunk-MIIYDLGM.js

@@ -1,2874 +0,0 @@
-import {
-  registerHttpEffect
-} from "./chunk-TRM4JUZQ.js";
-import {
-  streamFromReadableStream
-} from "./chunk-7JIJOVCT.js";
-import {
-  makeScheduleDriver,
-  sleep
-} from "./chunk-6IXXWIUM.js";
-import {
-  getHttpRequestPolicy,
-  isExternalAbortError,
-  isHttpError,
-  isRetryableHttpError,
-  toHttpError,
-  withHttpRequestPolicy
-} from "./chunk-3Y2RIUMM.js";
-import {
-  fromPromiseAbortable,
-  resolveWasmModule
-} from "./chunk-FH2X7BVP.js";
-import {
-  Cause,
-  asyncEffect,
-  asyncFail,
-  asyncFlatMap,
-  asyncFold,
-  asyncSucceed
-} from "./chunk-UB4B6OFY.js";
-import {
-  Schema,
-  parseConfig
-} from "./chunk-C3MDXTRZ.js";
-
-// src/http/retry/wasmRetryPlanner.ts
-var WasmRetryPlannerBridge = class {
-  planner;
-  constructor(Ctor) {
-    this.planner = new Ctor();
-  }
-  start(options) {
-    return this.planner.start(
-      options.nowMs,
-      options.maxRetries,
-      options.baseDelayMs,
-      options.maxDelayMs,
-      options.maxElapsedMs ?? -1,
-      BigInt(this.seed())
-    );
-  }
-  nextDelayMs(retryId, options) {
-    const delay = this.planner.next_delay_ms(retryId, options.nowMs, options.retryable, options.retryAfterMs ?? -1);
-    return delay < 0 ? void 0 : delay;
-  }
-  drop(retryId) {
-    this.planner.drop_state(retryId);
-  }
-  stats() {
-    return {
-      live: this.planner.metric_u64(0),
-      planned: this.planner.metric_u64(1),
-      exhausted: this.planner.metric_u64(2),
-      dropped: this.planner.metric_u64(3)
-    };
-  }
-  seed() {
-    return Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
-  }
-};
-function makeWasmRetryPlanner() {
-  const mod = resolveWasmModule();
-  const Ctor = mod?.BrassWasmRetryPlanner;
-  if (!Ctor) throw new Error("brass-runtime wasm retry planner is not available. Run npm run build:wasm first.");
-  return new WasmRetryPlannerBridge(Ctor);
-}
-
-// src/http/retry/retry.ts
-var defaultRetryableMethods = ["GET", "HEAD", "OPTIONS"];
-var defaultRetryOnStatus = (s) => s === 408 || s === 429 || s === 500 || s === 502 || s === 503 || s === 504;
-var defaultRetryOnError = (e) => isRetryableHttpError(e, { retryOnStatus: defaultRetryOnStatus });
-var clamp = (n, min, max) => Math.max(min, Math.min(max, n));
-var backoffDelayMs = (attempt, base, cap) => {
-  const b = Math.max(0, base);
-  const c = Math.max(0, cap);
-  const exp = b * Math.pow(2, attempt);
-  const lim = clamp(exp, 0, c);
-  return Math.floor(Math.random() * lim);
-};
-var headerCI = (h, name) => {
-  const k = Object.keys(h).find((x) => x.toLowerCase() === name.toLowerCase());
-  return k ? h[k] : void 0;
-};
-var retryAfterMs = (headers) => {
-  const v = headerCI(headers, "retry-after")?.trim();
-  if (!v) return void 0;
-  const secs = Number(v);
-  if (Number.isFinite(secs)) return Math.max(0, Math.floor(secs * 1e3));
-  const t = Date.parse(v);
-  if (Number.isFinite(t)) return Math.max(0, t - Date.now());
-  return void 0;
-};
-var normalizeRetryBudget = (ms) => {
-  if (ms === void 0 || !Number.isFinite(ms)) return void 0;
-  return Math.max(0, Math.floor(ms));
-};
-var resolveEffectivePolicy = (req, basePolicy) => {
-  const override = getHttpRequestPolicy(req).retry;
-  if (override === false) return null;
-  if (override === void 0) return basePolicy;
-  return {
-    ...basePolicy,
-    ...override.maxRetries !== void 0 && { maxRetries: override.maxRetries },
-    ...override.baseDelayMs !== void 0 && { baseDelayMs: override.baseDelayMs },
-    ...override.maxDelayMs !== void 0 && { maxDelayMs: override.maxDelayMs },
-    ...override.schedule !== void 0 && { schedule: override.schedule },
-    ...override.retryOnStatus !== void 0 && { retryOnStatus: override.retryOnStatus }
-  };
-};
-var resolveRetryEngine = (p) => {
-  if (p.engine !== void 0) {
-    if (p.engine === "ts" || p.engine === "wasm") return p.engine;
-    throw new Error(`brass-runtime retry engine must be 'ts' or 'wasm'; received '${String(p.engine)}'`);
-  }
-  if (p.wasm === true) return "wasm";
-  if (p.wasm === false) return "ts";
-  return "ts";
-};
-var withRetry = (p) => (next) => {
-  const retryOnMethods = p.retryOnMethods ?? defaultRetryableMethods;
-  const retryEngine = resolveRetryEngine(p);
-  const wasmPlanner = retryEngine === "wasm" ? makeWasmRetryPlanner() : void 0;
-  const isMethodRetryable = (req) => retryOnMethods.includes(req.method);
-  const nextDelay = (ep, epMaxElapsedMs, retryId, attempt, startedAt, retryable, scheduleDriver, input) => {
-    if (!retryable) return void 0;
-    const remainingBudget = epMaxElapsedMs === void 0 ? Number.POSITIVE_INFINITY : epMaxElapsedMs - (performance.now() - startedAt);
-    if (remainingBudget <= 0) return void 0;
-    if (scheduleDriver) {
-      const decision = scheduleDriver.next(input);
-      if (!decision.continue) return void 0;
-      const rawDelay2 = input.retryAfterMs === void 0 ? decision.delayMs : Math.min(input.retryAfterMs, ep.maxDelayMs);
-      return {
-        delayMs: Math.max(0, Math.min(rawDelay2, remainingBudget))
-      };
-    }
-    if (wasmPlanner && retryId !== void 0) {
-      const delay = wasmPlanner.nextDelayMs(retryId, {
-        nowMs: performance.now(),
-        retryable,
-        retryAfterMs: input.retryAfterMs
-      });
-      return delay === void 0 ? void 0 : { delayMs: delay };
-    }
-    const rawDelay = input.retryAfterMs === void 0 ? backoffDelayMs(attempt, ep.baseDelayMs, ep.maxDelayMs) : Math.min(input.retryAfterMs, ep.maxDelayMs);
-    return { delayMs: Math.max(0, Math.min(rawDelay, remainingBudget)) };
-  };
-  const sleepWithCleanup = (ms, onCancel) => {
-    return asyncEffect((_env, cb) => {
-      const delay = Math.max(0, Math.floor(ms));
-      const id = setTimeout(() => cb({ _tag: "Success", value: void 0 }), delay);
-      return () => {
-        clearTimeout(id);
-        onCancel();
-      };
-    });
-  };
-  const loop = (req, attempt, startedAt, retryId, ep, epMaxElapsedMs, epRetryOnStatus, epRetryOnError, originalPriority, safeDrop, scheduleDriver) => {
-    if (!isMethodRetryable(req)) return next(req);
-    const effectiveReq = attempt > 0 ? withHttpRequestPolicy(req, { priority: Math.max(0, originalPriority - 1) }) : req;
-    const remainingBudget = () => epMaxElapsedMs === void 0 ? Number.POSITIVE_INFINITY : epMaxElapsedMs - (performance.now() - startedAt);
-    return asyncFold(
-      next(effectiveReq),
-      (e) => {
-        if (e._tag === "Abort" || e._tag === "BadUrl" || e._tag === "PoolRejected" || e._tag === "PoolClosed" || e._tag === "CircuitBreakerOpen") {
-          safeDrop(retryId);
-          return asyncFail(e);
-        }
-        const retryable = attempt < ep.maxRetries && epRetryOnError(e) && remainingBudget() > 0;
-        const retryDecision = nextDelay(ep, epMaxElapsedMs, retryId, attempt, startedAt, retryable, scheduleDriver, {
-          attempt,
-          elapsedMs: performance.now() - startedAt,
-          request: req,
-          error: e
-        });
-        if (retryDecision === void 0 || retryDecision.delayMs <= 0 && epMaxElapsedMs !== void 0) {
-          safeDrop(retryId);
-          return asyncFail(e);
-        }
-        if (ep.onRetry) {
-          ep.onRetry({
-            attempt,
-            delayMs: retryDecision.delayMs,
-            error: e,
-            status: void 0,
-            url: req.url,
-            method: req.method,
-            timestamp: Date.now()
-          });
-        }
-        return asyncFlatMap(sleepWithCleanup(retryDecision.delayMs, () => safeDrop(retryId)), () => loop(req, attempt + 1, startedAt, retryId, ep, epMaxElapsedMs, epRetryOnStatus, epRetryOnError, originalPriority, safeDrop, scheduleDriver));
-      },
-      (w) => {
-        const retryable = attempt < ep.maxRetries && epRetryOnStatus(w.status) && remainingBudget() > 0;
-        const ra = ep.respectRetryAfter === false ? void 0 : retryAfterMs(w.headers);
-        const retryDecision = nextDelay(ep, epMaxElapsedMs, retryId, attempt, startedAt, retryable, scheduleDriver, {
-          attempt,
-          elapsedMs: performance.now() - startedAt,
-          request: req,
-          status: w.status,
-          retryAfterMs: ra
-        });
-        if (retryDecision === void 0 || retryDecision.delayMs <= 0 && epMaxElapsedMs !== void 0) {
-          safeDrop(retryId);
-          return asyncSucceed(w);
-        }
-        if (ep.onRetry) {
-          ep.onRetry({
-            attempt,
-            delayMs: retryDecision.delayMs,
-            error: void 0,
-            status: w.status,
-            url: req.url,
-            method: req.method,
-            timestamp: Date.now()
-          });
-        }
-        return asyncFlatMap(sleepWithCleanup(retryDecision.delayMs, () => safeDrop(retryId)), () => loop(req, attempt + 1, startedAt, retryId, ep, epMaxElapsedMs, epRetryOnStatus, epRetryOnError, originalPriority, safeDrop, scheduleDriver));
-      }
-    );
-  };
-  return (req) => {
-    const effectivePolicy = resolveEffectivePolicy(req, p);
-    if (effectivePolicy === null) return next(req);
-    if (!isMethodRetryable(req)) return next(req);
-    const epRetryOnStatus = effectivePolicy.retryOnStatus ?? defaultRetryOnStatus;
-    const epRetryOnError = effectivePolicy.retryOnError ?? defaultRetryOnError;
-    const epMaxElapsedMs = normalizeRetryBudget(effectivePolicy.maxElapsedMs);
-    const originalPriority = getHttpRequestPolicy(req).priority ?? 5;
-    const startedAt = performance.now();
-    const retryId = wasmPlanner?.start({
-      nowMs: startedAt,
-      maxRetries: effectivePolicy.maxRetries,
-      baseDelayMs: effectivePolicy.baseDelayMs,
-      maxDelayMs: effectivePolicy.maxDelayMs,
-      maxElapsedMs: epMaxElapsedMs
-    });
-    let plannerDropped = false;
-    const safeDrop = (id) => {
-      if (id !== void 0 && !plannerDropped) {
-        plannerDropped = true;
-        wasmPlanner?.drop(id);
-      }
-    };
-    const scheduleDriver = effectivePolicy.schedule ? makeScheduleDriver(effectivePolicy.schedule, {
-      name: effectivePolicy.schedule.name ?? "http.retry",
-      startedAtMs: startedAt,
-      onDecision: effectivePolicy.onScheduleDecision
-    }) : void 0;
-    return loop(req, 0, startedAt, retryId, effectivePolicy, epMaxElapsedMs, epRetryOnStatus, epRetryOnError, originalPriority, safeDrop, scheduleDriver);
-  };
-};
-
-// src/http/wasmPermitPool.ts
-var DECISION_RUN_NOW = 0;
-var DECISION_QUEUED = 1;
-var WasmHttpPermitPoolBridge = class {
-  pool;
-  keyCache = /* @__PURE__ */ new Map();
-  constructor(Ctor, options) {
-    this.pool = new Ctor(options.concurrency, options.maxQueue, toU64(options.queueTimeoutMs));
-  }
-  acquire(key, subjectId, nowMs2 = Date.now()) {
-    const keyId = this.internKey(key);
-    const decision = this.pool.acquire(subjectId, keyId, toU64(nowMs2));
-    const permitId = this.pool.last_permit_id();
-    if (decision === DECISION_RUN_NOW) return { kind: "run", keyId, permitId };
-    if (decision === DECISION_QUEUED) return { kind: "queued", keyId, permitId };
-    return { kind: "rejected", keyId, permitId };
-  }
-  release(keyId, nowMs2 = Date.now()) {
-    const ptr = this.pool.release(keyId, toU64(nowMs2));
-    return this.readEvents(ptr, this.pool.permit_events_len());
-  }
-  cancel(permitId) {
-    this.pool.cancel(permitId);
-  }
-  advanceTime(nowMs2 = Date.now()) {
-    const ptr = this.pool.advance_time(toU64(nowMs2));
-    return this.readEvents(ptr, this.pool.permit_events_len());
-  }
-  nextDeadlineMs() {
-    return this.pool.next_deadline_ms();
-  }
-  stats() {
-    return {
-      running: this.pool.metric_u64(0),
-      queued: this.pool.metric_u64(1),
-      acquired: this.pool.metric_u64(2),
-      released: this.pool.metric_u64(3),
-      rejected: this.pool.metric_u64(4),
-      queueTimeouts: this.pool.metric_u64(5),
-      keys: this.pool.metric_u64(6)
-    };
-  }
-  internKey(key) {
-    const normalized = key.trim().slice(0, 160) || "global";
-    let id = this.keyCache.get(normalized);
-    if (id === void 0) {
-      id = this.pool.intern_key(normalized);
-      this.keyCache.set(normalized, id);
-    }
-    return id;
-  }
-  readEvents(ptr, len) {
-    if (ptr === 0 || len <= 1) return [];
-    const words = new Uint32Array(this.pool.memory().buffer, ptr, len);
-    const count = words[0] >>> 0;
-    const out = [];
-    for (let i = 0; i < count; i++) {
-      const base = 1 + i * 3;
-      if (base + 2 >= words.length) break;
-      out.push({
-        subjectId: words[base] >>> 0,
-        permitId: words[base + 1] >>> 0,
-        keyId: words[base + 2] >>> 0
-      });
-    }
-    return out;
-  }
-};
-function makeWasmHttpPermitPool(options) {
-  const mod = resolveWasmModule();
-  const Ctor = mod?.BrassWasmHttpPermitPool;
-  if (!Ctor) throw new Error("brass-runtime wasm HTTP permit pool is not available. Run npm run build:wasm first.");
-  return new WasmHttpPermitPoolBridge(Ctor, options);
-}
-function toU64(value) {
-  return BigInt(Math.max(0, Math.floor(value)));
-}
-
-// src/http/pool.ts
-var DEFAULT_CONCURRENCY = 64;
-var DEFAULT_MAX_QUEUE = 256;
-var clampInt = (n, fallback, min) => {
-  if (n === void 0 || !Number.isFinite(n)) return fallback;
-  return Math.max(min, Math.floor(n));
-};
-var queueTimeoutError = (key, timeoutMs) => ({
-  _tag: "PoolTimeout",
-  key,
-  timeoutMs,
-  message: `HTTP pool '${key}' did not grant a slot within ${timeoutMs}ms`
-});
-var poolRejectedError = (key, maxQueue) => ({
-  _tag: "PoolRejected",
-  key,
-  limit: maxQueue,
-  message: `HTTP pool '${key}' queue is full`
-});
-var abortError = () => ({ _tag: "Abort" });
-function resolveHttpPoolEngine(config) {
-  if (config.engine !== void 0) {
-    if (config.engine === "ts" || config.engine === "wasm") return config.engine;
-    throw new Error(`brass-runtime HTTP pool engine must be 'ts' or 'wasm'; received '${String(config.engine)}'`);
-  }
-  if (config.wasm === true) return "wasm";
-  if (config.wasm === false) return "ts";
-  return "ts";
-}
-function resolveHttpPoolKey(resolver, req, url) {
-  const custom = getHttpRequestPolicy(req).poolKey?.trim();
-  if (custom) return custom.slice(0, 160);
-  const r = resolver ?? "origin";
-  if (typeof r === "function") return r(req, url).trim().slice(0, 160) || "global";
-  if (r === "global") return "global";
-  if (r === "host") return url.host;
-  return url.origin;
-}
-var HttpConcurrencyPool = class {
-  states = /* @__PURE__ */ new Map();
-  concurrency;
-  maxQueue;
-  queueTimeoutMs;
-  keyResolver;
-  wasm;
-  wasmWaiters = /* @__PURE__ */ new Map();
-  wasmTimer;
-  nextSubjectId = 1;
-  constructor(config = {}) {
-    this.concurrency = clampInt(config.concurrency, DEFAULT_CONCURRENCY, 1);
-    this.maxQueue = clampInt(config.maxQueue, DEFAULT_MAX_QUEUE, 0);
-    this.queueTimeoutMs = config.queueTimeoutMs !== void 0 && Number.isFinite(config.queueTimeoutMs) ? Math.max(0, Math.floor(config.queueTimeoutMs)) : void 0;
-    this.keyResolver = config.key;
-    const engine = resolveHttpPoolEngine(config);
-    this.wasm = engine === "wasm" ? makeWasmHttpPermitPool({
-      concurrency: this.concurrency,
-      maxQueue: this.maxQueue,
-      queueTimeoutMs: this.queueTimeoutMs ?? 0
-    }) : void 0;
-  }
-  acquire(key, signal) {
-    return this.wasm ? this.acquireWasm(key, signal) : this.acquireJs(key, signal);
-  }
-  stats() {
-    const keys = Array.from(this.states.values()).map((state) => ({
-      key: state.key,
-      running: state.running,
-      queued: state.queue.length,
-      concurrency: this.concurrency,
-      maxQueue: this.maxQueue,
-      acquired: state.acquired,
-      released: state.released,
-      rejected: state.rejected,
-      queueTimeouts: state.queueTimeouts,
-      abortedWhileQueued: state.abortedWhileQueued
-    })).sort((a, b) => b.running + b.queued - (a.running + a.queued) || a.key.localeCompare(b.key));
-    return keys.reduce((acc, key) => ({
-      running: acc.running + key.running,
-      queued: acc.queued + key.queued,
-      acquired: acc.acquired + key.acquired,
-      released: acc.released + key.released,
-      rejected: acc.rejected + key.rejected,
-      queueTimeouts: acc.queueTimeouts + key.queueTimeouts,
-      abortedWhileQueued: acc.abortedWhileQueued + key.abortedWhileQueued,
-      wasm: this.wasm?.stats(),
-      keys: acc.keys.concat(key)
-    }), {
-      running: 0,
-      queued: 0,
-      acquired: 0,
-      released: 0,
-      rejected: 0,
-      queueTimeouts: 0,
-      abortedWhileQueued: 0,
-      ...this.wasm ? { wasm: this.wasm.stats() } : {},
-      keys: []
-    });
-  }
-  acquireJs(key, signal) {
-    const state = this.getState(key);
-    if (signal.aborted) return Promise.reject(abortError());
-    if (state.running < this.concurrency) {
-      state.running++;
-      state.acquired++;
-      return Promise.resolve(this.makeLease(state));
-    }
-    if (state.queue.length >= this.maxQueue) {
-      state.rejected++;
-      return Promise.reject(poolRejectedError(key, this.maxQueue));
-    }
-    return new Promise((resolve, reject) => {
-      const waiter = { signal, resolve, reject };
-      const removeWaiter = () => this.removeWaiter(state, waiter);
-      const cleanup = () => this.cleanupWaiter(waiter);
-      waiter.abort = () => {
-        cleanup();
-        removeWaiter();
-        state.abortedWhileQueued++;
-        reject(abortError());
-      };
-      signal.addEventListener("abort", waiter.abort, { once: true });
-      if (this.queueTimeoutMs !== void 0 && this.queueTimeoutMs > 0) {
-        waiter.timer = setTimeout(() => {
-          cleanup();
-          removeWaiter();
-          state.queueTimeouts++;
-          reject(queueTimeoutError(key, this.queueTimeoutMs));
-        }, this.queueTimeoutMs);
-      }
-      state.queue.push(waiter);
-    });
-  }
-  acquireWasm(key, signal) {
-    const wasm = this.wasm;
-    const state = this.getState(key);
-    if (signal.aborted) return Promise.reject(abortError());
-    const subjectId = this.allocateSubjectId();
-    const decision = wasm.acquire(key, subjectId);
-    if (decision.kind === "run") {
-      state.running++;
-      state.acquired++;
-      return Promise.resolve(this.makeLease(state, decision.keyId));
-    }
-    if (decision.kind === "rejected") {
-      state.rejected++;
-      return Promise.reject(poolRejectedError(key, this.maxQueue));
-    }
-    return new Promise((resolve, reject) => {
-      const waiter = { signal, resolve, reject };
-      const removeWaiter = () => this.removeWaiter(state, waiter);
-      const cleanup = () => this.cleanupWaiter(waiter);
-      waiter.abort = () => {
-        cleanup();
-        removeWaiter();
-        wasm.cancel(decision.permitId);
-        this.wasmWaiters.delete(decision.permitId);
-        state.abortedWhileQueued++;
-        reject(abortError());
-      };
-      signal.addEventListener("abort", waiter.abort, { once: true });
-      state.queue.push(waiter);
-      this.wasmWaiters.set(decision.permitId, { waiter, state, keyId: decision.keyId });
-      this.scheduleWasmTimeoutPump();
-    });
-  }
-  getState(key) {
-    const k = key.trim().slice(0, 160) || "global";
-    const existing = this.states.get(k);
-    if (existing) return existing;
-    const created = {
-      key: k,
-      running: 0,
-      queue: [],
-      acquired: 0,
-      released: 0,
-      rejected: 0,
-      queueTimeouts: 0,
-      abortedWhileQueued: 0
-    };
-    this.states.set(k, created);
-    return created;
-  }
-  makeLease(state, wasmKeyId) {
-    let released = false;
-    return {
-      key: state.key,
-      release: () => {
-        if (released) return;
-        released = true;
-        if (state.running > 0) state.running--;
-        state.released++;
-        if (this.wasm && wasmKeyId !== void 0) {
-          this.handleWasmGrants(this.wasm.release(wasmKeyId));
-          this.scheduleWasmTimeoutPump();
-          return;
-        }
-        this.drain(state);
-      }
-    };
-  }
-  drain(state) {
-    while (state.running < this.concurrency && state.queue.length > 0) {
-      const waiter = state.queue.shift();
-      this.cleanupWaiter(waiter);
-      if (waiter.signal.aborted) {
-        state.abortedWhileQueued++;
-        waiter.reject(abortError());
-        continue;
-      }
-      state.running++;
-      state.acquired++;
-      waiter.resolve(this.makeLease(state));
-    }
-  }
-  handleWasmGrants(events) {
-    for (const event of events) {
-      const pending = this.wasmWaiters.get(event.permitId);
-      if (!pending) continue;
-      this.wasmWaiters.delete(event.permitId);
-      this.cleanupWaiter(pending.waiter);
-      this.removeWaiter(pending.state, pending.waiter);
-      if (pending.waiter.signal.aborted) {
-        pending.state.abortedWhileQueued++;
-        pending.waiter.reject(abortError());
-        continue;
-      }
-      pending.state.running++;
-      pending.state.acquired++;
-      pending.waiter.resolve(this.makeLease(pending.state, event.keyId));
-    }
-  }
-  handleWasmTimeouts(events) {
-    for (const event of events) {
-      const pending = this.wasmWaiters.get(event.permitId);
-      if (!pending) continue;
-      this.wasmWaiters.delete(event.permitId);
-      this.cleanupWaiter(pending.waiter);
-      this.removeWaiter(pending.state, pending.waiter);
-      pending.state.queueTimeouts++;
-      pending.waiter.reject(queueTimeoutError(pending.state.key, this.queueTimeoutMs ?? 0));
-    }
-  }
-  scheduleWasmTimeoutPump() {
-    if (!this.wasm) return;
-    if (this.wasmTimer !== void 0) clearTimeout(this.wasmTimer);
-    this.wasmTimer = void 0;
-    const next = this.wasm.nextDeadlineMs();
-    if (!Number.isFinite(next) || next < 0) return;
-    const delay = Math.max(0, Math.min(2 ** 31 - 1, Math.floor(next - Date.now())));
-    this.wasmTimer = setTimeout(() => {
-      this.wasmTimer = void 0;
-      if (!this.wasm) return;
-      this.handleWasmTimeouts(this.wasm.advanceTime());
-      this.scheduleWasmTimeoutPump();
-    }, delay);
-    if (typeof this.wasmTimer.unref === "function") this.wasmTimer.unref();
-  }
-  cleanupWaiter(waiter) {
-    if (waiter.timer !== void 0) {
-      clearTimeout(waiter.timer);
-      waiter.timer = void 0;
-    }
-    if (waiter.abort) {
-      waiter.signal.removeEventListener("abort", waiter.abort);
-      waiter.abort = void 0;
-    }
-  }
-  removeWaiter(state, waiter) {
-    const idx = state.queue.indexOf(waiter);
-    if (idx >= 0) state.queue.splice(idx, 1);
-  }
-  allocateSubjectId() {
-    const id = this.nextSubjectId >>> 0;
-    this.nextSubjectId = this.nextSubjectId + 1 >>> 0;
-    if (this.nextSubjectId === 0) this.nextSubjectId = 1;
-    return id === 0 ? this.allocateSubjectId() : id;
-  }
-};
-
-// src/http/adaptiveLimiter/latencyWindow.ts
-var LatencyWindow = class {
-  buffer;
-  sorted = [];
-  size;
-  head = 0;
-  count = 0;
-  constructor(size) {
-    this.size = Math.max(2, Math.floor(size));
-    this.buffer = new Array(this.size);
-  }
-  /**
-   * Record a latency sample. Discards non-positive, NaN, and Infinity values.
-   * Evicts the oldest sample when the buffer is full.
-   */
-  record(latencyMs) {
-    if (!Number.isFinite(latencyMs) || latencyMs <= 0) return;
-    const evicted = this.buffer[this.head];
-    if (evicted !== void 0 && this.count === this.size) {
-      this.removeSorted(evicted);
-    }
-    this.buffer[this.head] = latencyMs;
-    this.insertSorted(latencyMs);
-    this.head = (this.head + 1) % this.size;
-    if (this.count < this.size) this.count++;
-  }
-  /**
-   * Returns the minimum latency in the current window, or undefined if empty.
-   */
-  min() {
-    return this.sorted[0];
-  }
-  /**
-   * Computes the percentile using the nearest-rank method.
-   * Returns undefined if fewer than 2 samples are present.
-   * @param p - Percentile value in [0, 100]
-   */
-  percentile(p) {
-    if (this.count < 2) return void 0;
-    const rank = Math.ceil(p / 100 * this.sorted.length);
-    return this.sorted[Math.min(rank, this.sorted.length) - 1];
-  }
-  /**
-   * Computes a percentile where newer samples receive exponentially higher
-   * weight. A decay of 1 is identical to `percentile`; lower values adapt
-   * faster to recent latency shifts.
-   */
-  weightedPercentile(p, decay) {
-    if (this.count < 2) return void 0;
-    if (!Number.isFinite(decay) || decay >= 1) return this.percentile(p);
-    const samples = this.samples();
-    const weighted = samples.map((value, index) => ({
-      value,
-      weight: Math.pow(decay, samples.length - 1 - index)
-    }));
-    weighted.sort((a, b) => a.value - b.value);
-    const total = weighted.reduce((sum, sample) => sum + sample.weight, 0);
-    const target = Math.max(0, Math.min(100, p)) / 100 * total;
-    let cumulative = 0;
-    for (const sample of weighted) {
-      cumulative += sample.weight;
-      if (cumulative >= target) return sample.value;
-    }
-    return weighted[weighted.length - 1]?.value;
-  }
-  /** Number of samples currently in the window. */
-  get length() {
-    return this.count;
-  }
-  /** Maximum capacity of the window. */
-  get capacity() {
-    return this.size;
-  }
-  /** Returns a copy of the current samples (oldest to newest). */
-  samples() {
-    const result = new Array(this.count);
-    for (let i = 0; i < this.count; i++) {
-      const idx = (this.head - this.count + i + this.size) % this.size;
-      result[i] = this.buffer[idx];
-    }
-    return result;
-  }
-  insertSorted(value) {
-    const idx = this.lowerBound(value);
-    this.sorted.splice(idx, 0, value);
-  }
-  removeSorted(value) {
-    let idx = this.lowerBound(value);
-    while (idx < this.sorted.length && this.sorted[idx] === value) {
-      this.sorted.splice(idx, 1);
-      return;
-    }
-  }
-  lowerBound(value) {
-    let lo = 0;
-    let hi = this.sorted.length;
-    while (lo < hi) {
-      const mid = lo + hi >>> 1;
-      if (this.sorted[mid] < value) lo = mid + 1;
-      else hi = mid;
-    }
-    return lo;
-  }
-};
-
-// src/http/adaptiveLimiter/ema.ts
-var EmaComputer = class {
-  alpha;
-  current = void 0;
-  /**
-   * @param alpha - Smoothing factor in (0, 1]. Higher values weight recent samples more.
-   */
-  constructor(alpha) {
-    this.alpha = alpha;
-  }
-  /**
-   * Update the EMA with a new sample and return the new EMA value.
-   * On the first sample, the EMA is initialized to that sample.
-   */
-  update(sample) {
-    if (this.current === void 0) {
-      this.current = sample;
-    } else {
-      this.current = this.alpha * sample + (1 - this.alpha) * this.current;
-    }
-    return this.current;
-  }
-  /** Returns the current EMA value, or undefined if no samples have been recorded. */
-  get value() {
-    return this.current;
-  }
-  /** Resets the EMA state. */
-  reset() {
-    this.current = void 0;
-  }
-};
-
-// src/http/adaptiveLimiter/gradient.ts
-function computeGradient(minLatency, currentLatency) {
-  if (currentLatency <= 0) return 1;
-  return minLatency / currentLatency;
-}
-function computeNewLimit(currentLimit, gradient, headroom, minBound, maxBound, options = {}) {
-  const decreaseThreshold = options.decreaseThreshold ?? 1;
-  const increaseThreshold = options.increaseThreshold ?? 1;
-  const maxDecreaseRatio = options.maxDecreaseRatio ?? 1;
-  let newLimit;
-  if (gradient < decreaseThreshold) {
-    const rawLimit = Math.floor(currentLimit * gradient);
-    const maxDecrease = Math.max(1, Math.floor(currentLimit * maxDecreaseRatio));
-    newLimit = Math.max(rawLimit, currentLimit - maxDecrease);
-  } else if (gradient >= increaseThreshold) {
-    newLimit = currentLimit + headroom;
-  } else {
-    newLimit = currentLimit;
-  }
-  return Math.max(minBound, Math.min(maxBound, newLimit));
-}
-
-// src/http/adaptiveLimiter/types.ts
-var adaptiveLimiterPresets = Object.freeze({
-  conservative: Object.freeze({
-    initialLimit: 8,
-    minLimit: 2,
-    maxLimit: 64,
-    maxQueue: 256,
-    queueTimeoutMs: 3e4,
-    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: Object.freeze({
-    initialLimit: 16,
-    minLimit: 4,
-    maxLimit: 128,
-    maxQueue: 512,
-    queueTimeoutMs: 3e4,
-    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: 0.05 },
-    queueStrategy: "priority",
-    queueLoadShedding: "priority-evict",
-    rejectionBackoffThreshold: 3,
-    rejectionBackoffMs: 100,
-    percentile: "p50"
-  }),
-  aggressive: Object.freeze({
-    initialLimit: 32,
-    minLimit: 8,
-    maxLimit: 256,
-    maxQueue: 1024,
-    queueTimeoutMs: 3e4,
-    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: 0.05 },
-    queueStrategy: "priority",
-    queueLoadShedding: "priority-evict",
-    rejectionBackoffThreshold: 3,
-    rejectionBackoffMs: 100,
-    percentile: "p50"
-  })
-});
-function makeAdaptiveLimiterConfig(preset, overrides = {}) {
-  return {
-    ...adaptiveLimiterPresets[preset],
-    ...overrides,
-    preset
-  };
-}
-function validateConfig(config) {
-  if (config.preset !== void 0 && config.preset !== "conservative" && config.preset !== "balanced" && config.preset !== "aggressive") {
-    throw new Error(
-      `AdaptiveLimiter: preset must be "conservative", "balanced", or "aggressive", got ${config.preset}`
-    );
-  }
-  if (config.smoothingFactor !== void 0) {
-    if (config.smoothingFactor <= 0 || config.smoothingFactor > 1) {
-      throw new Error(
-        `AdaptiveLimiter: smoothingFactor must be in (0, 1], got ${config.smoothingFactor}`
-      );
-    }
-  }
-  if (config.windowSize !== void 0) {
-    if (config.windowSize < 2) {
-      throw new Error(
-        `AdaptiveLimiter: windowSize must be >= 2, got ${config.windowSize}`
-      );
-    }
-  }
-  if (config.probeInterval !== void 0) {
-    if (config.probeInterval < 1) {
-      throw new Error(
-        `AdaptiveLimiter: probeInterval must be >= 1, got ${config.probeInterval}`
-      );
-    }
-  }
-  if (config.probeJitterRatio !== void 0) {
-    if (config.probeJitterRatio < 0 || config.probeJitterRatio > 1) {
-      throw new Error(
-        `AdaptiveLimiter: probeJitterRatio must be in [0, 1], got ${config.probeJitterRatio}`
-      );
-    }
-  }
-  if (config.minSamples !== void 0 && config.minSamples < 1) {
-    throw new Error(
-      `AdaptiveLimiter: minSamples must be >= 1, got ${config.minSamples}`
-    );
-  }
-  if (config.baselineStrategy !== void 0 && config.baselineStrategy !== "min" && config.baselineStrategy !== "p5" && config.baselineStrategy !== "ema-low") {
-    throw new Error(
-      `AdaptiveLimiter: baselineStrategy must be "min", "p5", or "ema-low", got ${config.baselineStrategy}`
-    );
-  }
-  if (config.decreaseCooldownSamples !== void 0 && (!Number.isFinite(config.decreaseCooldownSamples) || config.decreaseCooldownSamples < 0)) {
-    throw new Error(
-      `AdaptiveLimiter: decreaseCooldownSamples must be >= 0, got ${config.decreaseCooldownSamples}`
-    );
-  }
-  if (config.historySize !== void 0 && (!Number.isFinite(config.historySize) || config.historySize < 0)) {
-    throw new Error(
-      `AdaptiveLimiter: historySize must be >= 0, got ${config.historySize}`
-    );
-  }
-  if (config.windowDecayFactor !== void 0) {
-    if (!Number.isFinite(config.windowDecayFactor) || config.windowDecayFactor <= 0 || config.windowDecayFactor > 1) {
-      throw new Error(
-        `AdaptiveLimiter: windowDecayFactor must be in (0, 1], got ${config.windowDecayFactor}`
-      );
-    }
-  }
-  if (config.errorWeight !== void 0) {
-    if (!Number.isFinite(config.errorWeight) || config.errorWeight < 0 || config.errorWeight > 1) {
-      throw new Error(
-        `AdaptiveLimiter: errorWeight must be in [0, 1], got ${config.errorWeight}`
-      );
-    }
-  }
-  if (config.errorSmoothingFactor !== void 0) {
-    if (!Number.isFinite(config.errorSmoothingFactor) || config.errorSmoothingFactor <= 0 || config.errorSmoothingFactor > 1) {
-      throw new Error(
-        `AdaptiveLimiter: errorSmoothingFactor must be in (0, 1], got ${config.errorSmoothingFactor}`
-      );
-    }
-  }
-  if (config.errorStatusThreshold !== void 0) {
-    if (!Number.isFinite(config.errorStatusThreshold) || config.errorStatusThreshold < 100 || config.errorStatusThreshold > 599) {
-      throw new Error(
-        `AdaptiveLimiter: errorStatusThreshold must be in [100, 599], got ${config.errorStatusThreshold}`
-      );
-    }
-  }
-  if (config.queueStrategy !== void 0 && config.queueStrategy !== "fifo" && config.queueStrategy !== "priority") {
-    throw new Error(
-      `AdaptiveLimiter: queueStrategy must be "fifo" or "priority", got ${config.queueStrategy}`
-    );
-  }
-  if (config.queueLoadShedding !== void 0 && config.queueLoadShedding !== "reject-new" && config.queueLoadShedding !== "priority-evict") {
-    throw new Error(
-      `AdaptiveLimiter: queueLoadShedding must be "reject-new" or "priority-evict", got ${config.queueLoadShedding}`
-    );
-  }
-  if (config.rejectionBackoffThreshold !== void 0 && (!Number.isFinite(config.rejectionBackoffThreshold) || config.rejectionBackoffThreshold < 1)) {
-    throw new Error(
-      `AdaptiveLimiter: rejectionBackoffThreshold must be >= 1, got ${config.rejectionBackoffThreshold}`
-    );
-  }
-  if (config.rejectionBackoffMs !== void 0 && (!Number.isFinite(config.rejectionBackoffMs) || config.rejectionBackoffMs < 1)) {
-    throw new Error(
-      `AdaptiveLimiter: rejectionBackoffMs must be >= 1, got ${config.rejectionBackoffMs}`
-    );
-  }
-  if (config.stateTtlMs !== void 0 && config.stateTtlMs !== false) {
-    if (config.stateTtlMs < 1) {
-      throw new Error(
-        `AdaptiveLimiter: stateTtlMs must be >= 1ms or false, got ${config.stateTtlMs}`
-      );
-    }
-  }
-  if (config.warmupRequests !== void 0 && config.warmupRequests < 0) {
-    throw new Error(
-      `AdaptiveLimiter: warmupRequests must be >= 0, got ${config.warmupRequests}`
-    );
-  }
-  if (config.decreaseThreshold !== void 0) {
-    if (config.decreaseThreshold <= 0 || config.decreaseThreshold > 1) {
-      throw new Error(
-        `AdaptiveLimiter: decreaseThreshold must be in (0, 1], got ${config.decreaseThreshold}`
-      );
-    }
-  }
-  if (config.increaseThreshold !== void 0 && config.increaseThreshold < 1) {
-    throw new Error(
-      `AdaptiveLimiter: increaseThreshold must be >= 1, got ${config.increaseThreshold}`
-    );
-  }
-  if (config.maxDecreaseRatio !== void 0) {
-    if (config.maxDecreaseRatio <= 0 || config.maxDecreaseRatio > 1) {
-      throw new Error(
-        `AdaptiveLimiter: maxDecreaseRatio must be in (0, 1], got ${config.maxDecreaseRatio}`
-      );
-    }
-  }
-  if (config.initialLimit !== void 0 && config.initialLimit < 1) {
-    throw new Error(
-      `AdaptiveLimiter: initialLimit must be >= 1, got ${config.initialLimit}`
-    );
-  }
-  if (config.minLimit !== void 0 && config.minLimit < 1) {
-    throw new Error(
-      `AdaptiveLimiter: minLimit must be >= 1, got ${config.minLimit}`
-    );
-  }
-  if (config.maxLimit !== void 0 && config.maxLimit < 1) {
-    throw new Error(
-      `AdaptiveLimiter: maxLimit must be >= 1, got ${config.maxLimit}`
-    );
-  }
-  validateHeadroomStrategy(config.headroomStrategy);
-  if (config.slowStartSaturationThreshold !== void 0) {
-    if (config.slowStartSaturationThreshold <= 0 || config.slowStartSaturationThreshold > 1) {
-      throw new Error(
-        `AdaptiveLimiter: slowStartSaturationThreshold must be in (0, 1], got ${config.slowStartSaturationThreshold}`
-      );
-    }
-  }
-  if (config.slowStartSaturationSamples !== void 0 && config.slowStartSaturationSamples < 1) {
-    throw new Error(
-      `AdaptiveLimiter: slowStartSaturationSamples must be >= 1, got ${config.slowStartSaturationSamples}`
-    );
-  }
-}
-function validatePositiveNumber(name, value) {
-  if (value !== void 0 && (!Number.isFinite(value) || value <= 0)) {
-    throw new Error(`AdaptiveLimiter: ${name} must be > 0, got ${value}`);
-  }
-}
-function validateHeadroomStrategy(strategy) {
-  if (strategy === void 0) return;
-  if (typeof strategy === "function") return;
-  if (typeof strategy === "number") {
-    validatePositiveNumber("headroomStrategy", strategy);
-    return;
-  }
-  if (strategy === "fixed" || strategy === "proportional") return;
-  if (typeof strategy !== "object" || strategy === null) {
-    throw new Error("AdaptiveLimiter: headroomStrategy must be a number, function, 'fixed', 'proportional', or strategy object");
-  }
-  if (strategy.type === "fixed") {
-    validatePositiveNumber("headroomStrategy.value", strategy.value);
-    return;
-  }
-  if (strategy.type === "proportional") {
-    validatePositiveNumber("headroomStrategy.ratio", strategy.ratio);
-    validatePositiveNumber("headroomStrategy.min", strategy.min);
-    validatePositiveNumber("headroomStrategy.max", strategy.max);
-    return;
-  }
-  throw new Error("AdaptiveLimiter: headroomStrategy.type must be 'fixed' or 'proportional'");
-}
-var DEFAULTS = {
-  preset: void 0,
-  initialLimit: 10,
-  minLimit: 1,
-  maxLimit: 200,
-  smoothingFactor: 0.5,
-  probeInterval: 10,
-  probeJitterRatio: 0.2,
-  windowSize: 100,
-  minSamples: 10,
-  baselineStrategy: "min",
-  decreaseCooldownSamples: 0,
-  historySize: 32,
-  windowDecayFactor: 1,
-  errorWeight: 0,
-  errorSmoothingFactor: 0.5,
-  errorStatusThreshold: 500,
-  queueStrategy: "fifo",
-  queueLoadShedding: "reject-new",
-  rejectionBackoffThreshold: 3,
-  rejectionBackoffMs: void 0,
-  stateTtlMs: 3e5,
-  warmupRequests: 0,
-  decreaseThreshold: 0.75,
-  increaseThreshold: 1,
-  maxDecreaseRatio: 0.2,
-  headroomStrategy: 1,
-  slowStartRecovery: true,
-  slowStartSaturationThreshold: 0.5,
-  slowStartSaturationSamples: 3,
-  key: "origin",
-  maxQueue: 256,
-  queueTimeoutMs: void 0,
-  onLimitChange: void 0,
-  percentile: "p50"
-};
-function resolveConfig(config) {
-  if (!config) return DEFAULTS;
-  validateConfig(config);
-  const effectiveConfig = config.preset === void 0 ? config : { ...adaptiveLimiterPresets[config.preset], ...config };
-  let minLimit = effectiveConfig.minLimit ?? DEFAULTS.minLimit;
-  let maxLimit = effectiveConfig.maxLimit ?? DEFAULTS.maxLimit;
-  if (minLimit > maxLimit) {
-    maxLimit = minLimit;
-  }
-  let initialLimit = effectiveConfig.initialLimit ?? DEFAULTS.initialLimit;
-  initialLimit = Math.max(minLimit, Math.min(maxLimit, initialLimit));
-  const windowSize = Math.floor(effectiveConfig.windowSize ?? DEFAULTS.windowSize);
-  const minSamples = Math.max(1, Math.min(Math.floor(effectiveConfig.minSamples ?? DEFAULTS.minSamples), windowSize));
-  const decreaseCooldownSamples = Math.floor(effectiveConfig.decreaseCooldownSamples ?? DEFAULTS.decreaseCooldownSamples);
-  const historySize = Math.floor(effectiveConfig.historySize ?? DEFAULTS.historySize);
-  const errorSmoothingFactor = effectiveConfig.errorSmoothingFactor ?? effectiveConfig.smoothingFactor ?? DEFAULTS.smoothingFactor;
-  const stateTtlMs = effectiveConfig.stateTtlMs === false ? void 0 : Math.floor(effectiveConfig.stateTtlMs ?? DEFAULTS.stateTtlMs);
-  return {
-    preset: effectiveConfig.preset,
-    initialLimit,
-    minLimit,
-    maxLimit,
-    smoothingFactor: effectiveConfig.smoothingFactor ?? DEFAULTS.smoothingFactor,
-    probeInterval: Math.floor(effectiveConfig.probeInterval ?? DEFAULTS.probeInterval),
-    probeJitterRatio: effectiveConfig.probeJitterRatio ?? DEFAULTS.probeJitterRatio,
-    windowSize,
-    minSamples,
-    baselineStrategy: effectiveConfig.baselineStrategy ?? DEFAULTS.baselineStrategy,
-    decreaseCooldownSamples,
-    historySize,
-    windowDecayFactor: effectiveConfig.windowDecayFactor ?? DEFAULTS.windowDecayFactor,
-    errorWeight: effectiveConfig.errorWeight ?? DEFAULTS.errorWeight,
-    errorSmoothingFactor,
-    errorStatusThreshold: Math.floor(effectiveConfig.errorStatusThreshold ?? DEFAULTS.errorStatusThreshold),
-    queueStrategy: effectiveConfig.queueStrategy ?? DEFAULTS.queueStrategy,
-    queueLoadShedding: effectiveConfig.queueLoadShedding ?? DEFAULTS.queueLoadShedding,
-    rejectionBackoffThreshold: Math.floor(effectiveConfig.rejectionBackoffThreshold ?? DEFAULTS.rejectionBackoffThreshold),
-    rejectionBackoffMs: effectiveConfig.rejectionBackoffMs === void 0 ? DEFAULTS.rejectionBackoffMs : Math.floor(effectiveConfig.rejectionBackoffMs),
-    stateTtlMs,
-    warmupRequests: Math.floor(effectiveConfig.warmupRequests ?? DEFAULTS.warmupRequests),
-    decreaseThreshold: effectiveConfig.decreaseThreshold ?? DEFAULTS.decreaseThreshold,
-    increaseThreshold: effectiveConfig.increaseThreshold ?? DEFAULTS.increaseThreshold,
-    maxDecreaseRatio: effectiveConfig.maxDecreaseRatio ?? DEFAULTS.maxDecreaseRatio,
-    headroomStrategy: effectiveConfig.headroomStrategy ?? DEFAULTS.headroomStrategy,
-    slowStartRecovery: effectiveConfig.slowStartRecovery ?? DEFAULTS.slowStartRecovery,
-    slowStartSaturationThreshold: effectiveConfig.slowStartSaturationThreshold ?? DEFAULTS.slowStartSaturationThreshold,
-    slowStartSaturationSamples: Math.floor(effectiveConfig.slowStartSaturationSamples ?? DEFAULTS.slowStartSaturationSamples),
-    key: effectiveConfig.key ?? DEFAULTS.key,
-    maxQueue: effectiveConfig.maxQueue ?? DEFAULTS.maxQueue,
-    queueTimeoutMs: effectiveConfig.queueTimeoutMs,
-    onLimitChange: effectiveConfig.onLimitChange,
-    percentile: effectiveConfig.percentile ?? DEFAULTS.percentile
-  };
-}
-
-// src/http/adaptiveLimiter/adaptiveLimiter.ts
-var monotonicNow = () => {
-  const perf = globalThis.performance;
-  if (perf && typeof perf.now === "function") return perf.now();
-  return Date.now();
-};
-var wallNow = () => Date.now();
-var DEFAULT_PRIORITY = 5;
-var clampPriority = (value) => {
-  if (value === void 0 || !Number.isFinite(value)) return DEFAULT_PRIORITY;
-  return Math.max(0, Math.min(9, Math.floor(value)));
-};
-var poolTimeoutError = (key, timeoutMs) => ({
-  _tag: "PoolTimeout",
-  key,
-  timeoutMs,
-  message: `Adaptive limiter '${key}' did not grant a slot within ${timeoutMs}ms`
-});
-var poolRejectedError2 = (key, limit, retryAfterMs2) => ({
-  _tag: "PoolRejected",
-  key,
-  limit,
-  message: `Adaptive limiter '${key}' queue is full (max ${limit})`,
-  ...retryAfterMs2 === void 0 ? {} : { retryAfterMs: retryAfterMs2 }
-});
-var abortError2 = () => ({ _tag: "Abort" });
-var poolClosedError = (key) => ({
-  _tag: "PoolClosed",
-  key,
-  message: `Adaptive limiter '${key}' has been destroyed`
-});
-var AdaptiveLimiter = class {
-  config;
-  states = /* @__PURE__ */ new Map();
-  destroyed = false;
-  constructor(config) {
-    this.config = resolveConfig(config);
-  }
-  /** Key resolver for external use by the HTTP client. */
-  get keyResolver() {
-    return this.config.key;
-  }
-  /**
-   * 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, signal, options) {
-    if (this.destroyed) return Promise.reject(poolClosedError(key));
-    const state = this.getOrCreateState(key);
-    this.touch(state);
-    const priority = clampPriority(options?.priority);
-    if (signal.aborted) {
-      this.scheduleIdleEviction(state);
-      return Promise.reject(abortError2());
-    }
-    if (state.inFlight < state.limit) {
-      state.inFlight++;
-      state.acquired++;
-      state.rejectionStreak = 0;
-      return Promise.resolve(this.makeLease(state));
-    }
-    if (state.queue.length >= this.config.maxQueue) {
-      const evicted = this.tryEvictLowerPriorityWaiter(state, priority);
-      if (!evicted) {
-        state.rejected++;
-        state.rejectionStreak++;
-        this.scheduleIdleEviction(state);
-        return Promise.reject(poolRejectedError2(key, this.config.maxQueue, this.suggestedBackoffMs(state)));
-      }
-    }
-    return new Promise((resolve, reject) => {
-      const waiter = {
-        signal,
-        resolve,
-        reject,
-        priority,
-        arrivalOrder: state.queueSequence++
-      };
-      const removeWaiter = () => this.removeWaiter(state, waiter);
-      const cleanup = () => this.cleanupWaiter(waiter);
-      waiter.abort = () => {
-        cleanup();
-        removeWaiter();
-        this.touch(state);
-        state.abortedWhileQueued++;
-        this.scheduleIdleEviction(state);
-        reject(abortError2());
-      };
-      signal.addEventListener("abort", waiter.abort, { once: true });
-      if (this.config.queueTimeoutMs !== void 0 && this.config.queueTimeoutMs > 0) {
-        waiter.timer = setTimeout(() => {
-          cleanup();
-          removeWaiter();
-          this.touch(state);
-          state.queueTimeouts++;
-          this.scheduleIdleEviction(state);
-          reject(poolTimeoutError(key, this.config.queueTimeoutMs));
-        }, this.config.queueTimeoutMs);
-      }
-      this.enqueueWaiter(state, waiter);
-    });
-  }
-  /**
-   * Get stats for a specific key, or aggregate stats if no key is provided.
-   */
-  stats(key) {
-    this.evictIdleStates();
-    if (key !== void 0) {
-      const state = this.states.get(key);
-      if (!state) {
-        return {
-          limit: this.config.initialLimit,
-          inFlight: 0,
-          queueDepth: 0,
-          gradient: void 0,
-          latencyGradient: void 0,
-          errorRate: void 0,
-          smoothedLatency: void 0,
-          minLatency: void 0,
-          baselineLatency: void 0,
-          p5: void 0,
-          p50: void 0,
-          p99: void 0,
-          probeCount: 0,
-          windowSize: 0,
-          warmupCompletions: 0,
-          slowStart: false,
-          cooldownSamplesRemaining: 0,
-          utilization: 0,
-          requestsPerSecond: 0,
-          completionsPerSecond: 0,
-          rejectionRate: 0,
-          suggestedBackoffMs: void 0
-        };
-      }
-      return this.stateToStats(state);
-    }
-    if (this.states.size === 0) {
-      return {
-        limit: this.config.initialLimit,
-        inFlight: 0,
-        queueDepth: 0,
-        gradient: void 0,
-        latencyGradient: void 0,
-        errorRate: void 0,
-        smoothedLatency: void 0,
-        minLatency: void 0,
-        baselineLatency: void 0,
-        p5: void 0,
-        p50: void 0,
-        p99: void 0,
-        probeCount: 0,
-        windowSize: 0,
-        warmupCompletions: 0,
-        slowStart: false,
-        cooldownSamplesRemaining: 0,
-        utilization: 0,
-        requestsPerSecond: 0,
-        completionsPerSecond: 0,
-        rejectionRate: 0,
-        suggestedBackoffMs: void 0,
-        stateCount: 0,
-        keys: []
-      };
-    }
-    if (this.states.size === 1) {
-      const [state] = this.states.values();
-      return {
-        ...this.stateToStats(state),
-        keys: [state.key]
-      };
-    }
-    let totalLimit = 0;
-    let totalInFlight = 0;
-    let totalQueueDepth = 0;
-    let totalProbeCount = 0;
-    let totalWindowSize = 0;
-    let totalRequestsPerSecond = 0;
-    let totalCompletionsPerSecond = 0;
-    let totalRejected = 0;
-    let totalAttempts = 0;
-    const keys = [];
-    let firstState;
-    const now = monotonicNow();
-    for (const state of this.states.values()) {
-      keys.push(state.key);
-      totalLimit += state.limit;
-      totalInFlight += state.inFlight;
-      totalQueueDepth += state.queue.length;
-      totalProbeCount += state.probeCount;
-      totalWindowSize += state.window.length;
-      const stats = this.stateToStats(state, now);
-      totalRequestsPerSecond += stats.requestsPerSecond ?? 0;
-      totalCompletionsPerSecond += stats.completionsPerSecond ?? 0;
-      totalRejected += state.rejected;
-      totalAttempts += state.acquired + state.rejected + state.queueTimeouts + state.abortedWhileQueued;
-      if (!firstState) firstState = state;
-    }
-    const minLatency = firstState?.window.min();
-    return {
-      limit: totalLimit,
-      inFlight: totalInFlight,
-      queueDepth: totalQueueDepth,
-      gradient: firstState?.lastGradient,
-      latencyGradient: firstState?.lastLatencyGradient,
-      errorRate: firstState?.errorEma.value,
-      smoothedLatency: firstState?.ema.value,
-      minLatency,
-      baselineLatency: minLatency === void 0 || firstState === void 0 ? void 0 : this.baselineLatency(firstState, minLatency),
-      p5: firstState === void 0 ? void 0 : this.windowPercentile(firstState, 5),
-      p50: firstState === void 0 ? void 0 : this.windowPercentile(firstState, 50),
-      p99: firstState === void 0 ? void 0 : this.windowPercentile(firstState, 99),
-      probeCount: totalProbeCount,
-      windowSize: totalWindowSize,
-      warmupCompletions: firstState?.warmupCompletions ?? 0,
-      slowStart: firstState?.slowStartActive ?? false,
-      cooldownSamplesRemaining: firstState?.decreaseCooldownRemaining ?? 0,
-      utilization: totalLimit > 0 ? totalInFlight / totalLimit : 0,
-      requestsPerSecond: totalRequestsPerSecond,
-      completionsPerSecond: totalCompletionsPerSecond,
-      rejectionRate: totalAttempts > 0 ? totalRejected / totalAttempts : 0,
-      suggestedBackoffMs: firstState === void 0 ? void 0 : this.suggestedBackoffMs(firstState),
-      stateCount: this.states.size,
-      keys
-    };
-  }
-  /** Return the currently retained per-key state identifiers. */
-  keys() {
-    this.evictIdleStates();
-    return [...this.states.keys()];
-  }
-  /** Return a diagnostic snapshot for one retained key, if present. */
-  snapshot(key) {
-    this.evictIdleStates();
-    const state = this.states.get(key);
-    return state ? this.stateToKeySnapshot(state) : void 0;
-  }
-  /** Return a full diagnostic dump across all retained keys. */
-  dump() {
-    this.evictIdleStates();
-    const keys = [...this.states.keys()];
-    return {
-      stateCount: this.states.size,
-      keys,
-      aggregate: this.stats(),
-      states: [...this.states.values()].map((state) => this.stateToKeySnapshot(state)),
-      history: this.history()
-    };
-  }
-  /** Return retained limit-change history for one key, or all keys if omitted. */
-  history(key) {
-    this.evictIdleStates();
-    if (key !== void 0) {
-      return [...this.states.get(key)?.history ?? []];
-    }
-    return [...this.states.values()].flatMap((state) => state.history).sort((a, b) => a.timestamp - b.timestamp);
-  }
-  /**
-   * 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) {
-    if (this.destroyed) return;
-    const state = this.getOrCreateState(key);
-    this.touch(state);
-    state.saturationStreak = this.config.slowStartSaturationSamples;
-    state.slowStartActive = this.config.slowStartRecovery;
-    state.slowStartRecoveryStarted = false;
-    state.slowStartHeadroom = Math.max(1, this.resolveHeadroom(state, 0, "circuit-open"));
-    const minLatency = state.window.min() ?? 0;
-    this.applyLimit(
-      state,
-      this.config.minLimit,
-      0,
-      0,
-      state.errorEma.value ?? 0,
-      state.ema.value ?? 0,
-      minLatency,
-      state.baselineEma.value ?? minLatency,
-      "circuit-open"
-    );
-    this.scheduleIdleEviction(state);
-  }
-  /** Destroy the limiter, reject queued waiters, clear timers, and drop state. */
-  destroy() {
-    if (this.destroyed) return;
-    this.destroyed = true;
-    for (const state of this.states.values()) {
-      this.clearIdleTimer(state);
-      for (const waiter of state.queue.splice(0)) {
-        this.cleanupWaiter(waiter);
-        waiter.reject(poolClosedError(state.key));
-      }
-      state.inFlight = 0;
-    }
-    this.states.clear();
-  }
-  /** Alias for destroy(), useful for graceful shutdown code paths. */
-  shutdown() {
-    this.destroy();
-  }
-  getOrCreateState(key) {
-    const existing = this.states.get(key);
-    if (existing) return existing;
-    const now = monotonicNow();
-    const timestamp = wallNow();
-    const state = {
-      key,
-      limit: this.config.initialLimit,
-      inFlight: 0,
-      window: new LatencyWindow(this.config.windowSize),
-      ema: new EmaComputer(this.config.smoothingFactor),
-      baselineEma: new EmaComputer(this.config.smoothingFactor),
-      errorEma: new EmaComputer(this.config.errorSmoothingFactor),
-      probeCount: 0,
-      queue: [],
-      lastGradient: void 0,
-      lastLatencyGradient: void 0,
-      acquired: 0,
-      released: 0,
-      rejected: 0,
-      queueTimeouts: 0,
-      abortedWhileQueued: 0,
-      evictedWhileQueued: 0,
-      rejectionStreak: 0,
-      queueSequence: 0,
-      createdAt: now,
-      createdTimestamp: timestamp,
-      lastActivityAt: now,
-      lastActivityTimestamp: timestamp,
-      nextProbeAt: this.nextProbeInterval(),
-      warmupCompletions: 0,
-      warmupDone: this.config.warmupRequests <= 0,
-      saturationStreak: 0,
-      slowStartActive: false,
-      slowStartRecoveryStarted: false,
-      slowStartHeadroom: 1,
-      decreaseCooldownRemaining: 0,
-      history: []
-    };
-    this.states.set(key, state);
-    this.scheduleIdleEviction(state);
-    return state;
-  }
-  makeLease(state) {
-    let released = false;
-    return {
-      key: state.key,
-      release: (latencyMs, info) => {
-        if (released) return;
-        released = true;
-        if (this.destroyed) return;
-        this.touch(state);
-        if (state.inFlight > 0) state.inFlight--;
-        state.released++;
-        this.recordAndAdjust(state, latencyMs, info);
-        this.drain(state);
-        this.scheduleIdleEviction(state);
-      }
-    };
-  }
-  recordAndAdjust(state, latencyMs, info) {
-    state.window.record(latencyMs);
-    state.errorEma.update(this.isErrorSignal(info) ? 1 : 0);
-    if (Number.isFinite(latencyMs) && latencyMs > 0) {
-      state.ema.update(latencyMs);
-      state.baselineEma.update(this.lowLatencySample(state, latencyMs));
-    }
-    const minLat = state.window.min();
-    const emaValue = state.ema.value;
-    if (minLat === void 0 || emaValue === void 0) return;
-    const currentLatency = this.currentLatency(state, emaValue);
-    if (currentLatency === void 0) return;
-    const baselineLatency = this.baselineLatency(state, minLat);
-    const latencyGradient = computeGradient(baselineLatency, currentLatency);
-    const gradient = this.combineGradientWithErrors(latencyGradient, state.errorEma.value ?? 0);
-    state.lastGradient = gradient;
-    state.lastLatencyGradient = latencyGradient;
-    this.recordSaturation(state, gradient);
-    if (this.tryWarmup(
-      state,
-      gradient,
-      latencyGradient,
-      state.errorEma.value ?? 0,
-      emaValue,
-      minLat,
-      baselineLatency
-    )) return;
-    if (state.window.length < this.config.minSamples) return;
-    const mode = state.slowStartActive && gradient >= this.config.increaseThreshold ? "slow-start" : "stable";
-    let headroom = this.resolveHeadroom(state, gradient, mode);
-    if (mode === "slow-start") {
-      headroom = Math.max(headroom, state.slowStartHeadroom);
-    }
-    const cooldownActive = state.decreaseCooldownRemaining > 0;
-    if (cooldownActive) state.decreaseCooldownRemaining--;
-    const wantsDecrease = gradient < this.config.decreaseThreshold;
-    const decreaseBlockedByCooldown = wantsDecrease && cooldownActive;
-    let newLimit = decreaseBlockedByCooldown ? state.limit : computeNewLimit(
-      state.limit,
-      gradient,
-      headroom,
-      this.config.minLimit,
-      this.config.maxLimit,
-      {
-        decreaseThreshold: this.config.decreaseThreshold,
-        increaseThreshold: this.config.increaseThreshold,
-        maxDecreaseRatio: this.config.maxDecreaseRatio
-      }
-    );
-    let reason = mode === "slow-start" ? "slow-start" : "gradient";
-    if (!decreaseBlockedByCooldown) state.probeCount++;
-    if (!decreaseBlockedByCooldown && state.probeCount >= state.nextProbeAt) {
-      const probeHeadroom = this.resolveHeadroom(state, gradient, "probe");
-      newLimit = Math.min(newLimit + probeHeadroom, this.config.maxLimit);
-      state.probeCount = 0;
-      state.nextProbeAt = this.nextProbeInterval();
-      reason = "probe";
-    }
-    const previousLimit = state.limit;
-    this.applyLimit(state, newLimit, gradient, latencyGradient, state.errorEma.value ?? 0, emaValue, minLat, baselineLatency, reason);
-    if (state.limit < previousLimit) {
-      state.decreaseCooldownRemaining = this.config.decreaseCooldownSamples;
-    }
-    if (gradient < this.config.decreaseThreshold) {
-      if (state.slowStartRecoveryStarted) {
-        state.slowStartActive = false;
-        state.slowStartRecoveryStarted = false;
-        state.slowStartHeadroom = 1;
-      }
-    } else if (state.slowStartActive && gradient >= this.config.increaseThreshold && state.limit > previousLimit) {
-      state.slowStartRecoveryStarted = true;
-      state.slowStartHeadroom = Math.max(
-        1,
-        Math.min(this.config.maxLimit, Math.ceil(headroom * 2))
-      );
-    }
-  }
-  tryWarmup(state, gradient, latencyGradient, errorRate, emaValue, minLat, baselineLatency) {
-    if (state.warmupDone) return false;
-    state.warmupCompletions++;
-    if (gradient < this.config.decreaseThreshold) {
-      state.warmupDone = true;
-      return false;
-    }
-    const progress = Math.min(state.warmupCompletions, this.config.warmupRequests) / this.config.warmupRequests;
-    const target = Math.ceil(
-      this.config.initialLimit + (this.config.maxLimit - this.config.initialLimit) * progress
-    );
-    const warmupHeadroom = this.resolveHeadroom(state, gradient, "warmup");
-    const newLimit = Math.max(
-      state.limit,
-      Math.min(this.config.maxLimit, Math.max(target, state.limit + warmupHeadroom))
-    );
-    if (state.warmupCompletions >= this.config.warmupRequests) {
-      state.warmupDone = true;
-    }
-    this.applyLimit(state, newLimit, gradient, latencyGradient, errorRate, emaValue, minLat, baselineLatency, "warmup");
-    return true;
-  }
-  baselineLatency(state, minLatency) {
-    if (this.config.baselineStrategy === "p5") {
-      return this.windowPercentile(state, 5) ?? minLatency;
-    }
-    if (this.config.baselineStrategy === "ema-low") {
-      return state.baselineEma.value ?? this.windowPercentile(state, 5) ?? minLatency;
-    }
-    return minLatency;
-  }
-  lowLatencySample(state, fallback) {
-    return this.windowPercentile(state, 5) ?? state.window.min() ?? fallback;
-  }
-  isErrorSignal(info) {
-    if (!info) return false;
-    if (info.error) return true;
-    return info.status !== void 0 && info.status >= this.config.errorStatusThreshold;
-  }
-  combineGradientWithErrors(latencyGradient, errorRate) {
-    if (this.config.errorWeight <= 0 || errorRate <= 0) return latencyGradient;
-    const errorGradient = 1 - Math.min(1, errorRate * this.config.errorWeight);
-    return Math.max(0, Math.min(latencyGradient, errorGradient));
-  }
-  windowPercentile(state, percentile) {
-    return this.config.windowDecayFactor < 1 ? state.window.weightedPercentile(percentile, this.config.windowDecayFactor) : state.window.percentile(percentile);
-  }
-  recordSaturation(state, gradient) {
-    if (!this.config.slowStartRecovery) return;
-    if (gradient <= this.config.slowStartSaturationThreshold) {
-      state.saturationStreak++;
-      if (state.saturationStreak >= this.config.slowStartSaturationSamples) {
-        state.slowStartActive = true;
-        state.slowStartRecoveryStarted = false;
-        state.slowStartHeadroom = Math.max(1, this.resolveHeadroom(state, gradient, "slow-start"));
-      }
-      return;
-    }
-    if (gradient >= this.config.increaseThreshold) {
-      state.saturationStreak = 0;
-    }
-  }
-  applyLimit(state, proposedLimit, gradient, latencyGradient, errorRate, smoothedLatency, minLatency, baselineLatency, reason) {
-    const newLimit = Math.max(this.config.minLimit, Math.min(this.config.maxLimit, Math.floor(proposedLimit)));
-    if (newLimit === state.limit) {
-      state.limit = newLimit;
-      return;
-    }
-    const previousLimit = state.limit;
-    state.limit = newLimit;
-    const event = {
-      key: state.key,
-      previousLimit,
-      newLimit,
-      gradient,
-      latencyGradient,
-      errorRate,
-      smoothedLatency,
-      minLatency,
-      baselineLatency,
-      p5: this.windowPercentile(state, 5),
-      timestamp: wallNow(),
-      reason
-    };
-    this.recordLimitChange(state, event);
-    if (this.config.onLimitChange) {
-      this.config.onLimitChange(event);
-    }
-  }
-  recordLimitChange(state, event) {
-    if (this.config.historySize <= 0) return;
-    state.history.push(event);
-    if (state.history.length > this.config.historySize) {
-      state.history.splice(0, state.history.length - this.config.historySize);
-    }
-  }
-  resolveHeadroom(state, gradient, mode) {
-    const strategy = this.config.headroomStrategy;
-    let value;
-    if (typeof strategy === "function") {
-      value = strategy({
-        key: state.key,
-        currentLimit: state.limit,
-        minLimit: this.config.minLimit,
-        maxLimit: this.config.maxLimit,
-        gradient,
-        mode
-      });
-    } else if (typeof strategy === "number") {
-      value = strategy;
-    } else if (strategy === "proportional") {
-      value = Math.ceil(state.limit * 0.05);
-    } else if (strategy === "fixed") {
-      value = 1;
-    } else if (strategy.type === "proportional") {
-      const ratio = strategy.ratio ?? 0.05;
-      const min = strategy.min ?? 1;
-      const max = strategy.max ?? Number.POSITIVE_INFINITY;
-      value = Math.max(min, Math.min(max, Math.ceil(state.limit * ratio)));
-    } else {
-      value = strategy.value ?? 1;
-    }
-    if (!Number.isFinite(value) || value <= 0) return 1;
-    return Math.max(1, Math.ceil(value));
-  }
-  nextProbeInterval() {
-    const base = this.config.probeInterval;
-    const jitter = this.config.probeJitterRatio;
-    if (jitter <= 0) return base;
-    const spread = base * jitter;
-    const min = Math.max(1, base - spread);
-    const max = base + spread;
-    return Math.max(1, Math.round(min + Math.random() * (max - min)));
-  }
-  enqueueWaiter(state, waiter) {
-    state.queue.push(waiter);
-  }
-  dequeueWaiter(state) {
-    if (state.queue.length === 0) return void 0;
-    if (this.config.queueStrategy === "fifo") return state.queue.shift();
-    let bestIdx = 0;
-    for (let i = 1; i < state.queue.length; i++) {
-      const candidate = state.queue[i];
-      const best = state.queue[bestIdx];
-      if (candidate.priority < best.priority || candidate.priority === best.priority && candidate.arrivalOrder < best.arrivalOrder) {
-        bestIdx = i;
-      }
-    }
-    return state.queue.splice(bestIdx, 1)[0];
-  }
-  tryEvictLowerPriorityWaiter(state, newPriority) {
-    if (this.config.queueLoadShedding !== "priority-evict" || state.queue.length === 0) {
-      return false;
-    }
-    let evictIdx = -1;
-    for (let i = 0; i < state.queue.length; i++) {
-      const candidate = state.queue[i];
-      if (candidate.priority <= newPriority) continue;
-      if (evictIdx < 0) {
-        evictIdx = i;
-        continue;
-      }
-      const current = state.queue[evictIdx];
-      if (candidate.priority > current.priority || candidate.priority === current.priority && candidate.arrivalOrder > current.arrivalOrder) {
-        evictIdx = i;
-      }
-    }
-    if (evictIdx < 0) return false;
-    const [evicted] = state.queue.splice(evictIdx, 1);
-    if (!evicted) return false;
-    this.cleanupWaiter(evicted);
-    state.evictedWhileQueued++;
-    state.rejected++;
-    state.rejectionStreak++;
-    evicted.reject(poolRejectedError2(state.key, this.config.maxQueue, this.suggestedBackoffMs(state)));
-    return true;
-  }
-  suggestedBackoffMs(state) {
-    if (this.config.rejectionBackoffMs === void 0) return void 0;
-    if (state.rejectionStreak < this.config.rejectionBackoffThreshold) return void 0;
-    const multiplier = Math.min(8, Math.max(1, state.rejectionStreak - this.config.rejectionBackoffThreshold + 1));
-    return this.config.rejectionBackoffMs * multiplier;
-  }
-  drain(state) {
-    while (state.inFlight < state.limit && state.queue.length > 0) {
-      const waiter = this.dequeueWaiter(state);
-      this.cleanupWaiter(waiter);
-      if (waiter.signal.aborted) {
-        this.touch(state);
-        state.abortedWhileQueued++;
-        waiter.reject(abortError2());
-        continue;
-      }
-      this.touch(state);
-      state.inFlight++;
-      state.acquired++;
-      state.rejectionStreak = 0;
-      waiter.resolve(this.makeLease(state));
-    }
-  }
-  currentLatency(state, emaValue) {
-    const percentileLatency = this.config.percentile === "p99" ? this.windowPercentile(state, 99) : this.windowPercentile(state, 50);
-    return percentileLatency ?? emaValue;
-  }
-  touch(state) {
-    state.lastActivityAt = monotonicNow();
-    state.lastActivityTimestamp = wallNow();
-    this.clearIdleTimer(state);
-  }
-  scheduleIdleEviction(state) {
-    if (this.destroyed || this.config.stateTtlMs === void 0) return;
-    this.clearIdleTimer(state);
-    if (state.inFlight > 0 || state.queue.length > 0) return;
-    const delay = Math.max(1, this.config.stateTtlMs - (monotonicNow() - state.lastActivityAt));
-    state.ttlTimer = setTimeout(() => {
-      state.ttlTimer = void 0;
-      this.evictIdleState(state, monotonicNow());
-    }, delay);
-    state.ttlTimer?.unref?.();
-  }
-  clearIdleTimer(state) {
-    if (state.ttlTimer !== void 0) {
-      clearTimeout(state.ttlTimer);
-      state.ttlTimer = void 0;
-    }
-  }
-  evictIdleStates() {
-    if (this.config.stateTtlMs === void 0) return;
-    const now = monotonicNow();
-    for (const state of Array.from(this.states.values())) {
-      this.evictIdleState(state, now);
-    }
-  }
-  evictIdleState(state, now) {
-    if (this.config.stateTtlMs === void 0) return;
-    if (state.inFlight > 0 || state.queue.length > 0) {
-      this.scheduleIdleEviction(state);
-      return;
-    }
-    if (now - state.lastActivityAt < this.config.stateTtlMs) {
-      this.scheduleIdleEviction(state);
-      return;
-    }
-    this.clearIdleTimer(state);
-    this.states.delete(state.key);
-  }
-  cleanupWaiter(waiter) {
-    if (waiter.timer !== void 0) {
-      clearTimeout(waiter.timer);
-      waiter.timer = void 0;
-    }
-    if (waiter.abort) {
-      waiter.signal.removeEventListener("abort", waiter.abort);
-      waiter.abort = void 0;
-    }
-  }
-  removeWaiter(state, waiter) {
-    const idx = state.queue.indexOf(waiter);
-    if (idx >= 0) state.queue.splice(idx, 1);
-  }
-  stateToStats(state, now = monotonicNow()) {
-    const minLatency = state.window.min();
-    const elapsedSeconds = Math.max((now - state.createdAt) / 1e3, 1e-3);
-    const attempts = state.acquired + state.rejected + state.queueTimeouts + state.abortedWhileQueued;
-    return {
-      limit: state.limit,
-      inFlight: state.inFlight,
-      queueDepth: state.queue.length,
-      gradient: state.lastGradient,
-      latencyGradient: state.lastLatencyGradient,
-      errorRate: state.errorEma.value,
-      smoothedLatency: state.ema.value,
-      minLatency,
-      baselineLatency: minLatency === void 0 ? void 0 : this.baselineLatency(state, minLatency),
-      p5: this.windowPercentile(state, 5),
-      p50: this.windowPercentile(state, 50),
-      p99: this.windowPercentile(state, 99),
-      probeCount: state.probeCount,
-      windowSize: state.window.length,
-      warmupCompletions: state.warmupCompletions,
-      slowStart: state.slowStartActive,
-      cooldownSamplesRemaining: state.decreaseCooldownRemaining,
-      utilization: state.limit > 0 ? state.inFlight / state.limit : 0,
-      requestsPerSecond: state.acquired / elapsedSeconds,
-      completionsPerSecond: state.released / elapsedSeconds,
-      rejectionRate: attempts > 0 ? state.rejected / attempts : 0,
-      suggestedBackoffMs: this.suggestedBackoffMs(state),
-      stateCount: this.states.size
-    };
-  }
-  stateToKeySnapshot(state) {
-    return {
-      ...this.stateToStats(state),
-      key: state.key,
-      createdAt: state.createdAt,
-      createdTimestamp: state.createdTimestamp,
-      lastActivityAt: state.lastActivityAt,
-      lastActivityTimestamp: state.lastActivityTimestamp,
-      nextProbeAt: state.nextProbeAt,
-      warmupDone: state.warmupDone,
-      saturationStreak: state.saturationStreak,
-      slowStartRecoveryStarted: state.slowStartRecoveryStarted,
-      history: [...state.history],
-      acquired: state.acquired,
-      released: state.released,
-      rejected: state.rejected,
-      queueTimeouts: state.queueTimeouts,
-      abortedWhileQueued: state.abortedWhileQueued,
-      evictedWhileQueued: state.evictedWhileQueued
-    };
-  }
-};
-
-// src/http/optics/lens.ts
-var Lens = {
-  make(get, set) {
-    return { get, set };
-  },
-  over(ln, f) {
-    return (s) => ln.set(f(ln.get(s)))(s);
-  },
-  compose(ab, sa) {
-    return Lens.make(
-      (s) => ab.get(sa.get(s)),
-      (b) => (s) => sa.set(ab.set(b)(sa.get(s)))(s)
-    );
-  }
-};
-
-// src/http/optics/request.ts
-var Request = {
-  headers: Lens.make(
-    (req) => req.headers ?? {},
-    (headers) => (req) => ({ ...req, headers })
-  )
-};
-var mergeHeaders = (extra) => (req) => Lens.over(Request.headers, (h) => ({ ...h, ...extra }))(req);
-var mergeHeadersUnder = (under) => (req) => Lens.over(Request.headers, (h) => ({ ...under, ...h }))(req);
-var setHeaderIfMissing = (k, v) => (req) => Lens.over(Request.headers, (h) => h[k] ? h : { ...h, [k]: v })(req);
-
-// src/http/transport.ts
-var isTaggedHttpError = (error) => {
-  return isHttpError(error);
-};
-var isAbortError = (error) => isExternalAbortError(error);
-var normalizeHttpError = (error, options) => toHttpError(error, options);
-var headersOf = (response) => {
-  const headers = {};
-  response.headers.forEach((value, key) => {
-    headers[key] = value;
-  });
-  return headers;
-};
-function normalizeHttpHeaders(headers) {
-  if (!headers) return {};
-  if (typeof Headers !== "undefined" && headers instanceof Headers) {
-    const out = {};
-    headers.forEach((value, key) => {
-      out[key] = value;
-    });
-    return out;
-  }
-  if (Array.isArray(headers)) {
-    return headers.reduce((acc, item) => {
-      if (!Array.isArray(item) || item.length < 2) return acc;
-      const [key, value] = item;
-      if (key !== void 0 && value !== void 0 && value !== null) {
-        acc[String(key)] = Array.isArray(value) ? value.map(String).join(", ") : String(value);
-      }
-      return acc;
-    }, {});
-  }
-  if (typeof headers.toJSON === "function") {
-    return normalizeHttpHeaders(headers.toJSON());
-  }
-  if (typeof headers === "object") {
-    return Object.entries(headers).reduce((acc, [key, value]) => {
-      if (value !== void 0 && value !== null) {
-        acc[key] = Array.isArray(value) ? value.map(String).join(", ") : String(value);
-      }
-      return acc;
-    }, {});
-  }
-  return {};
-}
-var abortErrorForSignal = (signal) => {
-  const reason = signal.reason;
-  if (isTaggedHttpError(reason) && reason._tag === "Timeout") return reason;
-  return { _tag: "Abort" };
-};
-var linkAbortSignals = (...signals) => {
-  const activeSignals = signals.filter((signal) => signal !== void 0);
-  if (activeSignals.length === 0) {
-    const controller2 = new AbortController();
-    return { signal: controller2.signal, cleanup: () => void 0 };
-  }
-  const controller = new AbortController();
-  const listeners = [];
-  const abortFrom = (signal) => {
-    try {
-      controller.abort(signal.reason);
-    } catch {
-      controller.abort();
-    }
-  };
-  for (const signal of activeSignals) {
-    if (signal.aborted) {
-      abortFrom(signal);
-      break;
-    }
-    const abort = () => abortFrom(signal);
-    signal.addEventListener("abort", abort, { once: true });
-    listeners.push({ signal, abort });
-  }
-  return {
-    signal: controller.signal,
-    cleanup: () => {
-      for (const listener of listeners) {
-        listener.signal.removeEventListener("abort", listener.abort);
-      }
-      listeners.length = 0;
-    }
-  };
-};
-var nowMs = () => typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
-var hasMethod = (value, name) => typeof value === "object" && value !== null && typeof value[name] === "function";
-var defaultPromiseBody = (response, mode) => {
-  if (mode === "json" && hasMethod(response, "json")) return response.json();
-  if (mode === "text" && hasMethod(response, "text")) return response.text();
-  if (typeof response === "object" && response !== null) {
-    const record = response;
-    if ("data" in record) return record.data;
-    if ("bodyText" in record) return record.bodyText;
-    if ("body" in record) return record.body;
-  }
-  return response;
-};
-var encodePromiseBody = (body, mode) => {
-  if (mode === "text") return body === void 0 || body === null ? "" : String(body);
-  const encoded = JSON.stringify(body);
-  return encoded === void 0 ? "" : encoded;
-};
-var finiteNumber = (value) => {
-  const n = typeof value === "number" ? value : Number(value);
-  return Number.isFinite(n) ? n : void 0;
-};
-var isPlainRecord = (value) => Object.prototype.toString.call(value) === "[object Object]";
-var injectSignal = (config, signal) => isPlainRecord(config) ? { ...config, signal } : config;
-var inferPromiseResponseInfo = (response) => {
-  if (typeof response !== "object" || response === null) {
-    return { status: 200, statusText: "", headers: {} };
-  }
-  const record = response;
-  return {
-    status: finiteNumber(record.status) ?? finiteNumber(record.statusCode) ?? 200,
-    statusText: typeof record.statusText === "string" ? record.statusText : typeof record.statusMessage === "string" ? record.statusMessage : "",
-    headers: record.headers,
-    ms: finiteNumber(record.ms)
-  };
-};
-var toPromiseTransportResponse = (bodyText, info) => ({
-  status: info.status ?? 200,
-  statusText: info.statusText ?? "",
-  headers: normalizeHttpHeaders(info.headers),
-  bodyText,
-  ...info.ms !== void 0 ? { ms: info.ms } : {},
-  ...info.transportMeta !== void 0 ? { transportMeta: info.transportMeta } : {}
-});
-function makePromiseHttpTransport(config) {
-  return (context) => asyncEffect((_env, cb) => {
-    let done = false;
-    const finish = (exit) => {
-      if (done) return;
-      done = true;
-      context.signal.removeEventListener("abort", abort);
-      cb(exit);
-    };
-    const fail = (error) => finish({ _tag: "Failure", cause: Cause.fail(error) });
-    const abort = () => fail(abortErrorForSignal(context.signal));
-    if (context.signal.aborted) {
-      abort();
-      return;
-    }
-    context.signal.addEventListener("abort", abort, { once: true });
-    const run = async () => {
-      const startedAt = nowMs();
-      try {
-        const raw = await config.request(context);
-        const durationMs = Math.round(nowMs() - startedAt);
-        const mapped = await config.response(raw, context, { startedAt, durationMs });
-        finish({
-          _tag: "Success",
-          value: {
-            ...mapped,
-            ms: mapped.ms ?? durationMs
-          }
-        });
-      } catch (error) {
-        if (context.signal.aborted) {
-          fail(abortErrorForSignal(context.signal));
-          return;
-        }
-        fail(config.error?.(error, context) ?? normalizeHttpError(error, { signal: context.signal }));
-      }
-    };
-    void run();
-    return () => {
-      if (done) return;
-      done = true;
-      context.signal.removeEventListener("abort", abort);
-    };
-  });
-}
-function makePromiseHttpTransportBodyBuilder(config) {
-  const makeBodyTransport = (mode, body, responseMapper, currentConfig = config) => makePromiseHttpTransport({
-    ...currentConfig,
-    response: async (raw, context, timing) => {
-      const selected = await (body ?? ((value) => defaultPromiseBody(value, mode)))(raw, context, timing);
-      const inferred = inferPromiseResponseInfo(raw);
-      const mapped = responseMapper ? await responseMapper(raw, context, timing) : {};
-      return toPromiseTransportResponse(encodePromiseBody(selected, mode), {
-        ...inferred,
-        ...mapped,
-        headers: mapped.headers ?? inferred.headers
-      });
-    }
-  });
-  const makeFluentResponseBuilder = (mode, body, currentConfig = config) => {
-    return {
-      response: (responseMapper) => makeBodyTransport(mode, body, responseMapper, currentConfig),
-      error: (error) => makeFluentResponseBuilder(mode, body, { ...currentConfig, error })
-    };
-  };
-  return {
-    response: (response) => makePromiseHttpTransport({ ...config, response }),
-    json: (body, response) => makeBodyTransport("json", body, response),
-    text: (body, response) => makeBodyTransport("text", body, response),
-    fromJson: (body) => makeFluentResponseBuilder("json", body),
-    fromText: (body) => makeFluentResponseBuilder("text", body),
-    error: (error) => makePromiseHttpTransportBodyBuilder({ ...config, error })
-  };
-}
-function makePromiseHttpTransportRequestConfigBuilder(requestConfig) {
-  return {
-    send: (send) => makePromiseHttpTransportBodyBuilder({
-      request: async (context) => {
-        const config = await requestConfig({
-          request: context.request,
-          url: context.url
-        });
-        return send(injectSignal(config, context.signal));
-      }
-    })
-  };
-}
-function promiseHttpTransport() {
-  return {
-    request: (request) => makePromiseHttpTransportBodyBuilder({ request }),
-    requestConfig: (requestConfig) => makePromiseHttpTransportRequestConfigBuilder(requestConfig)
-  };
-}
-var fetchUnavailableError = () => ({
-  _tag: "FetchError",
-  message: "global `fetch` is not available; provide MakeHttpConfig.transport/streamTransport or run in an environment with fetch support."
-});
-function makeFetchTransport() {
-  return ({ request, url, signal }) => asyncEffect((_env, cb) => {
-    if (typeof fetch === "undefined") {
-      cb({ _tag: "Failure", cause: Cause.fail(fetchUnavailableError()) });
-      return;
-    }
-    const localController = new AbortController();
-    const linkedSignal = linkAbortSignals(signal, request.init?.signal, localController.signal);
-    let done = false;
-    const finish = (exit) => {
-      if (done) return;
-      done = true;
-      linkedSignal.cleanup();
-      cb(exit);
-    };
-    const run = async () => {
-      try {
-        if (linkedSignal.signal.aborted) throw abortErrorForSignal(linkedSignal.signal);
-        const started = nowMs();
-        const response = await fetch(url, {
-          ...request.init ?? {},
-          method: request.method,
-          headers: Request.headers.get(request),
-          body: request.body,
-          signal: linkedSignal.signal
-        });
-        const bodyText = await response.text();
-        const latencyMs = Math.round(nowMs() - started);
-        finish({
-          _tag: "Success",
-          value: {
-            status: response.status,
-            statusText: response.statusText,
-            headers: headersOf(response),
-            bodyText,
-            ms: latencyMs
-          }
-        });
-      } catch (error) {
-        finish({
-          _tag: "Failure",
-          cause: Cause.fail(normalizeHttpError(error, { signal: linkedSignal.signal }))
-        });
-      }
-    };
-    void run();
-    return () => {
-      if (done) return;
-      try {
-        localController.abort();
-      } catch {
-      }
-    };
-  });
-}
-function makeFetchStreamTransport() {
-  return ({ request, url, signal }) => asyncEffect((_env, cb) => {
-    if (typeof fetch === "undefined") {
-      cb({ _tag: "Failure", cause: Cause.fail(fetchUnavailableError()) });
-      return;
-    }
-    const localController = new AbortController();
-    const linkedSignal = linkAbortSignals(signal, request.init?.signal, localController.signal);
-    let done = false;
-    let cleanupTransferredToBody = false;
-    const cleanup = () => {
-      if (!cleanupTransferredToBody) linkedSignal.cleanup();
-    };
-    const finish = (exit) => {
-      if (done) return;
-      done = true;
-      cleanup();
-      cb(exit);
-    };
-    const run = async () => {
-      try {
-        if (linkedSignal.signal.aborted) throw abortErrorForSignal(linkedSignal.signal);
-        const started = nowMs();
-        const response = await fetch(url, {
-          ...request.init ?? {},
-          method: request.method,
-          headers: Request.headers.get(request),
-          body: request.body,
-          signal: linkedSignal.signal
-        });
-        const headers = headersOf(response);
-        const latencyMs = Math.round(nowMs() - started);
-        const body = streamFromReadableStream(response.body, normalizeHttpError, {
-          signal: linkedSignal.signal,
-          onRelease: linkedSignal.cleanup
-        });
-        cleanupTransferredToBody = response.body !== null;
-        finish({
-          _tag: "Success",
-          value: {
-            status: response.status,
-            statusText: response.statusText,
-            headers,
-            body,
-            ms: latencyMs
-          }
-        });
-      } catch (error) {
-        finish({
-          _tag: "Failure",
-          cause: Cause.fail(normalizeHttpError(error, { signal: linkedSignal.signal }))
-        });
-      }
-    };
-    void run();
-    return () => {
-      if (done) return;
-      try {
-        localController.abort();
-      } catch {
-      }
-    };
-  });
-}
-
-// src/http/configValidation.ts
-var fn = Schema.custom((value) => typeof value === "function", "function");
-var object = Schema.custom(
-  (value) => typeof value === "object" && value !== null && !Array.isArray(value),
-  "object"
-);
-var keyResolver = Schema.union([
-  Schema.enum(["global", "origin", "host"]),
-  fn
-]);
-var headroomStrategyConfig = Schema.union([
-  Schema.number({ min: 1 }),
-  Schema.enum(["fixed", "proportional"]),
-  fn,
-  Schema.object({
-    type: Schema.literal("fixed"),
-    value: Schema.number({ min: 1 }).optional()
-  }, { unknownKeys: "passthrough" }),
-  Schema.object({
-    type: Schema.literal("proportional"),
-    ratio: Schema.number({ min: 0 }).refine((n) => n > 0, "ratio must be > 0").optional(),
-    min: Schema.number({ min: 1 }).optional(),
-    max: Schema.number({ min: 1 }).optional()
-  }, { unknownKeys: "passthrough" })
-]);
-var poolConfig = Schema.union([
-  Schema.literal(false),
-  Schema.object({
-    concurrency: Schema.number({ min: 1, int: true }).optional(),
-    maxQueue: Schema.number({ min: 0, int: true }).optional(),
-    queueTimeoutMs: Schema.number({ min: 1, int: true }).optional(),
-    key: keyResolver.optional(),
-    engine: Schema.enum(["ts", "wasm"]).optional(),
-    wasm: Schema.boolean().optional()
-  }, { unknownKeys: "passthrough" })
-]);
-var adaptiveLimiterConfig = Schema.union([
-  Schema.literal(false),
-  Schema.object({
-    preset: Schema.enum(["conservative", "balanced", "aggressive"]).optional(),
-    initialLimit: Schema.number({ min: 1, int: true }).optional(),
-    minLimit: Schema.number({ min: 1, int: true }).optional(),
-    maxLimit: Schema.number({ min: 1, int: true }).optional(),
-    smoothingFactor: Schema.number({ min: 0, max: 1 }).refine((n) => n > 0, "smoothingFactor must be in (0, 1]").optional(),
-    probeInterval: Schema.number({ min: 1, int: true }).optional(),
-    probeJitterRatio: Schema.number({ min: 0, max: 1 }).optional(),
-    windowSize: Schema.number({ min: 2, int: true }).optional(),
-    minSamples: Schema.number({ min: 1, int: true }).optional(),
-    baselineStrategy: Schema.enum(["min", "p5", "ema-low"]).optional(),
-    decreaseCooldownSamples: Schema.number({ min: 0, int: true }).optional(),
-    historySize: Schema.number({ min: 0, int: true }).optional(),
-    windowDecayFactor: Schema.number({ min: 0, max: 1 }).refine((n) => n > 0, "windowDecayFactor must be in (0, 1]").optional(),
-    errorWeight: Schema.number({ min: 0, max: 1 }).optional(),
-    errorSmoothingFactor: Schema.number({ min: 0, max: 1 }).refine((n) => n > 0, "errorSmoothingFactor must be in (0, 1]").optional(),
-    errorStatusThreshold: Schema.number({ min: 100, max: 599, int: true }).optional(),
-    queueStrategy: Schema.enum(["fifo", "priority"]).optional(),
-    queueLoadShedding: Schema.enum(["reject-new", "priority-evict"]).optional(),
-    rejectionBackoffThreshold: Schema.number({ min: 1, int: true }).optional(),
-    rejectionBackoffMs: Schema.number({ min: 1, int: true }).optional(),
-    stateTtlMs: Schema.union([Schema.literal(false), Schema.number({ min: 1, int: true })]).optional(),
-    warmupRequests: Schema.number({ min: 0, int: true }).optional(),
-    decreaseThreshold: Schema.number({ min: 0, max: 1 }).refine((n) => n > 0, "decreaseThreshold must be in (0, 1]").optional(),
-    increaseThreshold: Schema.number({ min: 1 }).optional(),
-    maxDecreaseRatio: Schema.number({ min: 0, max: 1 }).refine((n) => n > 0, "maxDecreaseRatio must be in (0, 1]").optional(),
-    headroomStrategy: headroomStrategyConfig.optional(),
-    slowStartRecovery: Schema.boolean().optional(),
-    slowStartSaturationThreshold: Schema.number({ min: 0, max: 1 }).refine((n) => n > 0, "slowStartSaturationThreshold must be in (0, 1]").optional(),
-    slowStartSaturationSamples: Schema.number({ min: 1, int: true }).optional(),
-    key: keyResolver.optional(),
-    maxQueue: Schema.number({ min: 0, int: true }).optional(),
-    queueTimeoutMs: Schema.number({ min: 1, int: true }).optional(),
-    onLimitChange: fn.optional(),
-    percentile: Schema.enum(["p50", "p99"]).optional()
-  }, { unknownKeys: "passthrough" })
-]);
-var cacheConfig = Schema.union([
-  Schema.literal(false),
-  Schema.object({
-    ttlSeconds: Schema.number({ min: 1, int: true }).optional(),
-    maxEntries: Schema.number({ min: 1, int: true }).optional(),
-    staleWhileRevalidate: Schema.boolean().optional(),
-    cachePolicy: fn.optional(),
-    cacheRelevantHeaders: Schema.array(Schema.string()).optional(),
-    onEvent: fn.optional(),
-    onLifecycleEvent: fn.optional()
-  }, { unknownKeys: "passthrough" })
-]);
-var priorityConfig = Schema.union([
-  Schema.literal(false),
-  Schema.object({
-    concurrency: Schema.number({ min: 1, int: true }).optional(),
-    queueTimeoutMs: Schema.number({ min: 1, int: true }).optional(),
-    onEvent: fn.optional()
-  }, { unknownKeys: "passthrough" })
-]);
-var retryConfig = Schema.union([
-  Schema.literal(false),
-  Schema.object({
-    maxRetries: Schema.number({ min: 0, int: true }).optional(),
-    baseDelayMs: Schema.number({ min: 0, int: true }).optional(),
-    maxDelayMs: Schema.number({ min: 0, int: true }).optional(),
-    maxElapsedMs: Schema.number({ min: 1, int: true }).optional(),
-    respectRetryAfter: Schema.boolean().optional(),
-    retryOnMethods: Schema.array(Schema.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"])).optional(),
-    retryOnStatus: fn.optional(),
-    retryOnError: fn.optional(),
-    engine: Schema.enum(["ts", "wasm"]).optional(),
-    wasm: Schema.boolean().optional(),
-    onRetry: fn.optional()
-  }, { unknownKeys: "passthrough" })
-]);
-var requestRetryOverrideConfig = Schema.union([
-  Schema.literal(false),
-  Schema.object({
-    maxRetries: Schema.number({ min: 0, int: true }).optional(),
-    baseDelayMs: Schema.number({ min: 0, int: true }).optional(),
-    maxDelayMs: Schema.number({ min: 0, int: true }).optional(),
-    schedule: object.optional(),
-    retryOnStatus: fn.optional()
-  }, { unknownKeys: "passthrough" })
-]);
-var requestPolicyConfig = Schema.object({
-  preset: Schema.string({ minLength: 1 }).optional(),
-  lane: Schema.string({ minLength: 1 }).optional(),
-  dedupKey: Schema.string({ minLength: 1 }).optional(),
-  priority: Schema.number({ min: 0, max: 9, int: true }).optional(),
-  retry: requestRetryOverrideConfig.optional(),
-  poolKey: Schema.string({ minLength: 1 }).optional()
-}, { unknownKeys: "passthrough" });
-var policyPresetsConfig = Schema.record(Schema.union([requestPolicyConfig, fn]));
-var compressionConfig = Schema.union([
-  Schema.literal(false),
-  Schema.object({
-    encodings: Schema.array(Schema.enum(["gzip", "br", "deflate"])).optional()
-  }, { unknownKeys: "passthrough" })
-]);
-var prewarmConfig = Schema.union([
-  Schema.literal(false),
-  Schema.object({
-    origins: Schema.array(Schema.string()).optional(),
-    afterResponse: fn.optional(),
-    keepAliveDurationMs: Schema.number({ min: 1, int: true }).optional(),
-    budget: Schema.number({ min: 1, int: true }).optional(),
-    probeTimeoutMs: Schema.number({ min: 1, int: true }).optional(),
-    autoRefresh: Schema.boolean().optional(),
-    useClientPool: Schema.boolean().optional(),
-    onEvent: fn.optional()
-  }, { unknownKeys: "passthrough" })
-]);
-var batchConfig = Schema.union([
-  Schema.literal(false),
-  Schema.object({
-    batch: object,
-    windowMs: Schema.number({ min: 1, int: true }),
-    maxBatchSize: Schema.number({ min: 2, int: true }),
-    batchKey: fn
-  }, { unknownKeys: "passthrough" })
-]);
-var wireConfig = Schema.object({
-  baseUrl: Schema.string().optional(),
-  headers: Schema.record(Schema.string()).optional(),
-  timeoutMs: Schema.number({ min: 1, int: true }).optional(),
-  transport: fn.optional(),
-  streamTransport: fn.optional(),
-  pool: poolConfig.optional(),
-  adaptiveLimiter: adaptiveLimiterConfig.optional()
-}, { unknownKeys: "passthrough" });
-var lifecycleConfig = Schema.object({
-  baseUrl: Schema.string().optional(),
-  headers: Schema.record(Schema.string()).optional(),
-  timeoutMs: Schema.number({ min: 1, int: true }).optional(),
-  transport: fn.optional(),
-  streamTransport: fn.optional(),
-  pool: poolConfig.optional(),
-  adaptiveLimiter: adaptiveLimiterConfig.optional(),
-  dedup: Schema.union([Schema.literal(false), object]).optional(),
-  batch: batchConfig.optional(),
-  cache: cacheConfig.optional(),
-  priority: priorityConfig.optional(),
-  retry: retryConfig.optional(),
-  prewarm: prewarmConfig.optional(),
-  onEvent: fn.optional(),
-  policyPresets: policyPresetsConfig.optional()
-}, { unknownKeys: "passthrough" });
-var defaultClientConfig = Schema.object({
-  baseUrl: Schema.string().optional(),
-  headers: Schema.record(Schema.string()).optional(),
-  timeoutMs: Schema.number({ min: 1, int: true }).optional(),
-  transport: fn.optional(),
-  streamTransport: fn.optional(),
-  pool: poolConfig.optional(),
-  adaptiveLimiter: adaptiveLimiterConfig.optional(),
-  dedup: Schema.union([Schema.literal(false), object]).optional(),
-  batch: batchConfig.optional(),
-  cache: cacheConfig.optional(),
-  priority: priorityConfig.optional(),
-  retry: retryConfig.optional(),
-  prewarm: prewarmConfig.optional(),
-  onEvent: fn.optional(),
-  preset: Schema.enum(["minimal", "balanced", "default", "production"]).optional(),
-  compression: compressionConfig.optional(),
-  middleware: Schema.array(fn).optional(),
-  policyPresets: policyPresetsConfig.optional()
-}, { unknownKeys: "passthrough" });
-function validateMakeHttpConfig(config) {
-  parseConfig("MakeHttpConfig", wireConfig, config);
-}
-function validateLifecycleClientConfig(config) {
-  parseConfig("LifecycleClientConfig", lifecycleConfig, config);
-}
-function validateDefaultHttpClientConfig(config) {
-  parseConfig("DefaultHttpClientConfig", defaultClientConfig, config);
-}
-
-// src/http/client.ts
-var emptyStats = () => ({
-  inFlight: 0,
-  started: 0,
-  succeeded: 0,
-  failed: 0,
-  aborted: 0,
-  timedOut: 0,
-  poolRejected: 0,
-  poolTimeouts: 0
-});
-var decorate = (run, stats = emptyStats, metadata = {}) => {
-  const clientFn = ((req) => run(req));
-  Object.assign(clientFn, metadata);
-  return Object.assign(clientFn, {
-    with: (mw) => decorate(mw(clientFn), stats, metadata),
-    stats
-  }, metadata);
-};
-var withMiddleware = (mw) => (c) => decorate(mw(c), c.stats, {
-  adaptiveLimiter: c.adaptiveLimiter,
-  destroy: c.destroy,
-  shutdown: c.shutdown
-});
-var decorateStream = (run, stats = emptyStats) => Object.assign(((req) => run(req)), { stats });
-var normalizeHeadersInit = (h) => {
-  if (!h) return void 0;
-  if (typeof Headers !== "undefined" && h instanceof Headers) {
-    const out = {};
-    h.forEach((v, k) => out[k] = v);
-    return out;
-  }
-  if (Array.isArray(h)) return Object.fromEntries(h);
-  if (typeof h === "object") return { ...h };
-  return void 0;
-};
-var normalizeRequest = (defaultHeaders) => (req0) => {
-  let req = Object.keys(defaultHeaders).length ? mergeHeadersUnder(defaultHeaders)(req0) : req0;
-  const initHeaders = normalizeHeadersInit(req0.init?.headers);
-  if (initHeaders && Object.keys(initHeaders).length) {
-    req = mergeHeadersUnder(initHeaders)(req);
-  }
-  return req;
-};
-var resolvePositiveTimeout = (value) => {
-  if (value === void 0 || !Number.isFinite(value)) return void 0;
-  const n = Math.floor(value);
-  return n > 0 ? n : void 0;
-};
-var makeHttpStats = (pool, adaptiveLimiter) => {
-  const stats = {
-    inFlight: 0,
-    started: 0,
-    succeeded: 0,
-    failed: 0,
-    aborted: 0,
-    timedOut: 0,
-    poolRejected: 0,
-    poolTimeouts: 0
-  };
-  const onStart = () => {
-    stats.inFlight++;
-    stats.started++;
-  };
-  const onFinish = (finish) => {
-    if (stats.inFlight > 0) stats.inFlight--;
-    stats.lastDurationMs = finish.durationMs;
-    if (finish.outcome === "success") {
-      stats.succeeded++;
-      return;
-    }
-    if (finish.outcome === "interrupt") {
-      stats.aborted++;
-      return;
-    }
-    if (finish.outcome === "timeout") {
-      stats.timedOut++;
-      return;
-    }
-    const err = normalizeHttpError(finish.error);
-    switch (err._tag) {
-      case "Abort":
-        stats.aborted++;
-        return;
-      case "Timeout":
-        stats.timedOut++;
-        return;
-      case "PoolRejected":
-        stats.poolRejected++;
-        stats.failed++;
-        return;
-      case "PoolTimeout":
-        stats.poolTimeouts++;
-        stats.failed++;
-        return;
-      default:
-        stats.failed++;
-        return;
-    }
-  };
-  const snapshot = () => ({
-    ...stats,
-    ...pool ? { pool: pool.stats() } : {},
-    ...adaptiveLimiter ? { adaptiveLimiter: adaptiveLimiter.stats() } : {}
-  });
-  return { onStart, onFinish, snapshot };
-};
-var makePool = (cfg) => cfg.pool === void 0 || cfg.pool === false ? void 0 : new HttpConcurrencyPool(cfg.pool);
-var makeAdaptiveLimiter = (cfg) => cfg.adaptiveLimiter === void 0 || cfg.adaptiveLimiter === false ? void 0 : new AdaptiveLimiter(cfg.adaptiveLimiter);
-var resolveRequestUrl = (req, baseUrl) => {
-  try {
-    return new URL(req.url, baseUrl);
-  } catch {
-    return { _tag: "BadUrl", message: `URL inv\xE1lida: ${req.url}` };
-  }
-};
-var fetchLabel = (req, url) => `http:${req.method}:${url.origin}`;
-var timeoutReason = (req, url, timeoutMs) => ({
-  _tag: "Timeout",
-  timeoutMs,
-  phase: "request",
-  message: `HTTP ${req.method} ${url.origin} timed out after ${timeoutMs}ms`
-});
-var requestPriority = (req) => {
-  const fromPolicy = getHttpRequestPolicy(req).priority;
-  if (fromPolicy !== void 0) return fromPolicy;
-  return req.init?.priority;
-};
-var exitError = (exit) => {
-  if (exit._tag === "Success") return void 0;
-  const failure = Cause.firstFailure(exit.cause);
-  if (failure._tag === "Some") return failure.value;
-  const defect = Cause.firstDefect(exit.cause);
-  if (defect._tag === "Some") return defect.value;
-  if (Cause.containsInterrupt(exit.cause)) return { _tag: "Abort" };
-  return Cause.toError(exit.cause);
-};
-var runTransportEffect = (effect, env, signal) => new Promise((resolve, reject) => {
-  let done = false;
-  let cancel;
-  const finish = (exit) => {
-    if (done) return;
-    done = true;
-    signal.removeEventListener("abort", abort);
-    cancel = void 0;
-    if (exit._tag === "Success") {
-      resolve(exit.value);
-      return;
-    }
-    reject(exitError(exit));
-  };
-  const abort = () => {
-    if (done) return;
-    done = true;
-    signal.removeEventListener("abort", abort);
-    const currentCancel = cancel;
-    cancel = void 0;
-    currentCancel?.();
-    reject(abortErrorForSignal(signal));
-  };
-  if (signal.aborted) {
-    abort();
-    return;
-  }
-  signal.addEventListener("abort", abort, { once: true });
-  try {
-    cancel = registerHttpEffect(effect, env, finish);
-  } catch (error) {
-    if (done) return;
-    done = true;
-    signal.removeEventListener("abort", abort);
-    reject(error);
-  }
-});
-var releaseSuccess = (lease, adaptiveLimiter, response) => {
-  if (!lease) return void 0;
-  if (adaptiveLimiter) {
-    lease.release(response.ms, { status: response.status });
-  } else {
-    lease.release();
-  }
-  return void 0;
-};
-var releaseFailure = (lease, adaptiveLimiter) => {
-  if (!lease) return void 0;
-  if (adaptiveLimiter) {
-    lease.release(0, { error: true });
-  } else {
-    lease.release();
-  }
-  return void 0;
-};
-function makeHttpStream(cfg = {}) {
-  validateMakeHttpConfig(cfg);
-  const baseUrl = cfg.baseUrl ?? "";
-  const defaultHeaders = cfg.headers ?? {};
-  const normalize = normalizeRequest(defaultHeaders);
-  const adaptiveLimiter = makeAdaptiveLimiter(cfg);
-  const pool = adaptiveLimiter ? void 0 : makePool(cfg);
-  const metrics = makeHttpStats(pool, adaptiveLimiter);
-  const transport = cfg.streamTransport ?? makeFetchStreamTransport();
-  const run = (req0) => {
-    const req = normalize(req0);
-    const url = resolveRequestUrl(req, baseUrl);
-    if (!(url instanceof URL)) return asyncFail(url);
-    const timeoutMs = resolvePositiveTimeout(req.timeoutMs ?? cfg.timeoutMs);
-    return fromPromiseAbortable(
-      async (signal, env) => {
-        let lease;
-        const linkedSignal = linkAbortSignals(signal, req.init?.signal);
-        try {
-          if (linkedSignal.signal.aborted) throw abortErrorForSignal(linkedSignal.signal);
-          if (adaptiveLimiter) {
-            const key = resolveHttpPoolKey(adaptiveLimiter.keyResolver, req, url);
-            lease = await adaptiveLimiter.acquire(key, linkedSignal.signal, { priority: requestPriority(req) });
-          } else if (pool) {
-            const key = resolveHttpPoolKey(pool.keyResolver, req, url);
-            lease = await pool.acquire(key, linkedSignal.signal);
-          }
-          const response = await runTransportEffect(
-            transport({ request: req, url, signal: linkedSignal.signal }),
-            env,
-            linkedSignal.signal
-          );
-          lease = releaseSuccess(lease, adaptiveLimiter, response);
-          lease = void 0;
-          return response;
-        } finally {
-          linkedSignal.cleanup();
-          if (lease) {
-            releaseFailure(lease, adaptiveLimiter);
-          }
-        }
-      },
-      normalizeHttpError,
-      {
-        label: fetchLabel(req, url),
-        timeoutMs,
-        timeoutReason: timeoutMs ? () => timeoutReason(req, url, timeoutMs) : void 0,
-        onStart: metrics.onStart,
-        onFinish: metrics.onFinish
-      }
-    );
-  };
-  return decorateStream(run, metrics.snapshot);
-}
-function makeHttp(cfg = {}) {
-  validateMakeHttpConfig(cfg);
-  const baseUrl = cfg.baseUrl ?? "";
-  const defaultHeaders = cfg.headers ?? {};
-  const normalize = normalizeRequest(defaultHeaders);
-  const adaptiveLimiter = makeAdaptiveLimiter(cfg);
-  const pool = adaptiveLimiter ? void 0 : makePool(cfg);
-  const metrics = makeHttpStats(pool, adaptiveLimiter);
-  const transport = cfg.transport ?? makeFetchTransport();
-  const run = (req0) => {
-    const req = normalize(req0);
-    const url = resolveRequestUrl(req, baseUrl);
-    if (!(url instanceof URL)) return asyncFail(url);
-    const timeoutMs = resolvePositiveTimeout(req.timeoutMs ?? cfg.timeoutMs);
-    return fromPromiseAbortable(
-      async (signal, env) => {
-        let lease;
-        const linkedSignal = linkAbortSignals(signal, req.init?.signal);
-        try {
-          if (linkedSignal.signal.aborted) throw abortErrorForSignal(linkedSignal.signal);
-          if (adaptiveLimiter) {
-            const key = resolveHttpPoolKey(adaptiveLimiter.keyResolver, req, url);
-            lease = await adaptiveLimiter.acquire(key, linkedSignal.signal, { priority: requestPriority(req) });
-          } else if (pool) {
-            const key = resolveHttpPoolKey(pool.keyResolver, req, url);
-            lease = await pool.acquire(key, linkedSignal.signal);
-          }
-          const response = await runTransportEffect(
-            transport({ request: req, url, signal: linkedSignal.signal }),
-            env,
-            linkedSignal.signal
-          );
-          lease = releaseSuccess(lease, adaptiveLimiter, response);
-          return response;
-        } finally {
-          linkedSignal.cleanup();
-          if (lease) {
-            releaseFailure(lease, adaptiveLimiter);
-          }
-        }
-      },
-      normalizeHttpError,
-      {
-        label: fetchLabel(req, url),
-        timeoutMs,
-        timeoutReason: timeoutMs ? () => timeoutReason(req, url, timeoutMs) : void 0,
-        onStart: metrics.onStart,
-        onFinish: metrics.onFinish
-      }
-    );
-  };
-  return decorate(run, metrics.snapshot, adaptiveLimiter ? {
-    adaptiveLimiter,
-    destroy: () => adaptiveLimiter.destroy(),
-    shutdown: () => adaptiveLimiter.shutdown()
-  } : {});
-}
-var withRetryStream = (p) => (next) => {
-  const retryOnStatus = p.retryOnStatus ?? defaultRetryOnStatus;
-  const retryOnError = p.retryOnError ?? defaultRetryOnError;
-  const retryOnMethods = p.retryOnMethods ?? defaultRetryableMethods;
-  const maxElapsedMs = normalizeRetryBudget(p.maxElapsedMs);
-  const run = (req) => {
-    if (!retryOnMethods.includes(req.method)) return next(req);
-    const startedAt = performance.now();
-    const remainingBudget = () => maxElapsedMs === void 0 ? Number.POSITIVE_INFINITY : maxElapsedMs - (performance.now() - startedAt);
-    const delayWithinBudget = (delayMs) => Math.max(0, Math.min(delayMs, remainingBudget()));
-    const loop = (attempt) => asyncFold(
-      next(req),
-      (e) => {
-        if (e._tag === "Abort" || e._tag === "BadUrl" || e._tag === "PoolRejected" || e._tag === "PoolClosed") return asyncFail(e);
-        const canRetry = attempt < p.maxRetries && retryOnError(e) && remainingBudget() > 0;
-        if (!canRetry) return asyncFail(e);
-        const d = delayWithinBudget(backoffDelayMs(attempt, p.baseDelayMs, p.maxDelayMs));
-        if (d <= 0 && maxElapsedMs !== void 0) return asyncFail(e);
-        p.onRetry?.({
-          attempt,
-          delayMs: d,
-          error: e,
-          status: void 0,
-          url: req.url,
-          method: req.method,
-          timestamp: Date.now()
-        });
-        return asyncFlatMap(sleep(d), () => loop(attempt + 1));
-      },
-      (w) => {
-        const canRetry = attempt < p.maxRetries && retryOnStatus(w.status) && remainingBudget() > 0;
-        if (!canRetry) return asyncSucceed(w);
-        const ra = p.respectRetryAfter === false ? void 0 : retryAfterMs(w.headers);
-        const rawDelay = ra === void 0 ? backoffDelayMs(attempt, p.baseDelayMs, p.maxDelayMs) : Math.min(ra, p.maxDelayMs);
-        const d = delayWithinBudget(rawDelay);
-        if (d <= 0 && maxElapsedMs !== void 0) return asyncSucceed(w);
-        p.onRetry?.({
-          attempt,
-          delayMs: d,
-          error: void 0,
-          status: w.status,
-          url: req.url,
-          method: req.method,
-          timestamp: Date.now()
-        });
-        return asyncFlatMap(sleep(d), () => loop(attempt + 1));
-      }
-    );
-    return loop(0);
-  };
-  return decorateStream(run, next.stats);
-};
-
-export {
-  mergeHeaders,
-  setHeaderIfMissing,
-  defaultRetryableMethods,
-  defaultRetryOnStatus,
-  defaultRetryOnError,
-  backoffDelayMs,
-  retryAfterMs,
-  normalizeRetryBudget,
-  withRetry,
-  resolveHttpPoolKey,
-  HttpConcurrencyPool,
-  LatencyWindow,
-  EmaComputer,
-  computeGradient,
-  computeNewLimit,
-  adaptiveLimiterPresets,
-  makeAdaptiveLimiterConfig,
-  validateConfig,
-  resolveConfig,
-  AdaptiveLimiter,
-  validateLifecycleClientConfig,
-  validateDefaultHttpClientConfig,
-  isTaggedHttpError,
-  isAbortError,
-  normalizeHttpError,
-  headersOf,
-  normalizeHttpHeaders,
-  abortErrorForSignal,
-  linkAbortSignals,
-  makePromiseHttpTransport,
-  promiseHttpTransport,
-  makeFetchTransport,
-  makeFetchStreamTransport,
-  decorate,
-  withMiddleware,
-  normalizeHeadersInit,
-  makeHttpStream,
-  makeHttp,
-  withRetryStream
-};