brass-runtime 1.13.8 → 1.14.0

package/dist/http/index.cjs

@@ -1,8 +1,8 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2;
 
-var _chunkZTDK2DLGcjs = require('../chunk-ZTDK2DLG.cjs');
 
 
+var _chunkSKVY72E5cjs = require('../chunk-SKVY72E5.cjs');
 
 
 
@@ -10,7 +10,10 @@ var _chunkZTDK2DLGcjs = require('../chunk-ZTDK2DLG.cjs');
 
 
 
-var _chunk2P4PD6D7cjs = require('../chunk-2P4PD6D7.cjs');
+
+
+
+var _chunkBKBFSOGTcjs = require('../chunk-BKBFSOGT.cjs');
 
 // src/http/optics/lens.ts
 var Lens = {
@@ -39,36 +42,389 @@ var mergeHeaders = (extra) => (req) => Lens.over(Request.headers, (h) => ({ ...h
 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/sleep.ts
-var isHttpError = (e) => typeof e === "object" && e !== null && "_tag" in e;
-var normalizeHttpError = (e) => {
-  if (isHttpError(e)) return e;
-  if (typeof e === "object" && e !== null && e.name === "AbortError") {
-    return { _tag: "Abort" };
+// src/http/wasmPermitPool.ts
+var DECISION_RUN_NOW = 0;
+var DECISION_QUEUED = 1;
+var WasmHttpPermitPoolBridge = (_class = class {
+  
+  __init() {this.keyCache = /* @__PURE__ */ new Map()}
+  constructor(Ctor, options) {;_class.prototype.__init.call(this);
+    this.pool = new Ctor(options.concurrency, options.maxQueue, toU64(options.queueTimeoutMs));
   }
-  return { _tag: "FetchError", message: String(e) };
+  acquire(key, subjectId, nowMs = Date.now()) {
+    const keyId = this.internKey(key);
+    const decision = this.pool.acquire(subjectId, keyId, toU64(nowMs));
+    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, nowMs = Date.now()) {
+    const ptr = this.pool.release(keyId, toU64(nowMs));
+    return this.readEvents(ptr, this.pool.permit_events_len());
+  }
+  cancel(permitId) {
+    this.pool.cancel(permitId);
+  }
+  advanceTime(nowMs = Date.now()) {
+    const ptr = this.pool.advance_time(toU64(nowMs));
+    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;
+  }
+}, _class);
+function makeWasmHttpPermitPool(options) {
+  const mod = _chunkBKBFSOGTcjs.resolveWasmModule.call(void 0, );
+  const Ctor = _optionalChain([mod, 'optionalAccess', _ => _.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 sleepMs = (ms) => _chunk2P4PD6D7cjs.fromPromiseAbortable.call(void 0, 
-  (signal) => new Promise((resolve, reject) => {
-    if (signal.aborted) return reject({ _tag: "Abort" });
-    const id = setTimeout(resolve, ms);
-    const onAbort = () => {
-      clearTimeout(id);
-      reject({ _tag: "Abort" });
+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 = _optionalChain([req, 'access', _2 => _2.poolKey, 'optionalAccess', _3 => _3.trim, 'call', _4 => _4()]);
+  if (custom) return custom.slice(0, 160);
+  const r = _nullishCoalesce(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 = (_class2 = class {
+  __init2() {this.states = /* @__PURE__ */ new Map()}
+  
+  
+  
+  
+  
+  __init3() {this.wasmWaiters = /* @__PURE__ */ new Map()}
+  
+  __init4() {this.nextSubjectId = 1}
+  constructor(config = {}) {;_class2.prototype.__init2.call(this);_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);
+    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: _nullishCoalesce(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: _optionalChain([this, 'access', _5 => _5.wasm, 'optionalAccess', _6 => _6.stats, 'call', _7 => _7()]),
+      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);
+      }
     };
-    signal.addEventListener("abort", onAbort, { once: true });
-  }),
-  normalizeHttpError
-);
+  }
+  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, _nullishCoalesce(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;
+  }
+}, _class2);
 
 // src/http/client.ts
-var withMiddleware = (mw) => (c) => decorate(mw(c));
-var decorate = (run) => Object.assign(((req) => run(req)), {
-  with: (mw) => decorate(mw(run))
+var emptyStats = () => ({
+  inFlight: 0,
+  started: 0,
+  succeeded: 0,
+  failed: 0,
+  aborted: 0,
+  timedOut: 0,
+  poolRejected: 0,
+  poolTimeouts: 0
+});
+var decorate = (run, stats = emptyStats) => Object.assign(((req) => run(req)), {
+  with: (mw) => decorate(mw(run), stats),
+  stats
 });
-var normalizeHttpError2 = (e) => {
-  if (e instanceof DOMException && e.name === "AbortError") return { _tag: "Abort" };
-  if (typeof e === "object" && e && "_tag" in e) return e;
+var withMiddleware = (mw) => (c) => decorate(mw(c), c.stats);
+var decorateStream = (run, stats = emptyStats) => Object.assign(((req) => run(req)), { stats });
+var isTaggedHttpError = (e) => {
+  if (typeof e !== "object" || e === null || !("_tag" in e)) return false;
+  const tag = e._tag;
+  return tag === "Abort" || tag === "BadUrl" || tag === "FetchError" || tag === "Timeout" || tag === "PoolRejected" || tag === "PoolTimeout";
+};
+var isAbortError = (e) => typeof e === "object" && e !== null && "name" in e && e.name === "AbortError";
+var normalizeHttpError = (e) => {
+  if (isTaggedHttpError(e)) return e;
+  if (isAbortError(e)) return { _tag: "Abort" };
   return { _tag: "FetchError", message: String(e) };
 };
 var normalizeHeadersInit = (h) => {
@@ -84,87 +440,202 @@ var normalizeHeadersInit = (h) => {
 };
 var normalizeRequest = (defaultHeaders) => (req0) => {
   let req = Object.keys(defaultHeaders).length ? mergeHeadersUnder(defaultHeaders)(req0) : req0;
-  const initHeaders = normalizeHeadersInit(_optionalChain([req0, 'access', _ => _.init, 'optionalAccess', _2 => _2.headers]));
+  const initHeaders = normalizeHeadersInit(_optionalChain([req0, 'access', _8 => _8.init, 'optionalAccess', _9 => _9.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) => {
+  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() } : {}
+  });
+  return { onStart, onFinish, snapshot };
+};
+var makePool = (cfg) => cfg.pool === void 0 || cfg.pool === false ? void 0 : new HttpConcurrencyPool(cfg.pool);
+var resolveRequestUrl = (req, baseUrl) => {
+  try {
+    return new URL(req.url, baseUrl);
+  } catch (e2) {
+    return { _tag: "BadUrl", message: `URL inv\xE1lida: ${req.url}` };
+  }
+};
+var headersOf = (res) => {
+  const headers = {};
+  res.headers.forEach((v, k) => headers[k] = v);
+  return headers;
+};
+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`
+});
 function makeHttpStream(cfg = {}) {
   const baseUrl = _nullishCoalesce(cfg.baseUrl, () => ( ""));
   const defaultHeaders = _nullishCoalesce(cfg.headers, () => ( {}));
   const normalize = normalizeRequest(defaultHeaders);
-  return (req0) => _chunk2P4PD6D7cjs.fromPromiseAbortable.call(void 0, 
-    async (signal) => {
-      const req = normalize(req0);
-      let url;
-      try {
-        url = new URL(req.url, baseUrl);
-      } catch (e2) {
-        throw { _tag: "BadUrl", message: `URL inv\xE1lida: ${req.url}` };
+  const pool = makePool(cfg);
+  const metrics = makeHttpStats(pool);
+  const run = (req0) => {
+    const req = normalize(req0);
+    const url = resolveRequestUrl(req, baseUrl);
+    if (!(url instanceof URL)) return _chunkBKBFSOGTcjs.asyncFail.call(void 0, url);
+    const timeoutMs = resolvePositiveTimeout(_nullishCoalesce(req.timeoutMs, () => ( cfg.timeoutMs)));
+    return _chunkBKBFSOGTcjs.fromPromiseAbortable.call(void 0, 
+      async (signal) => {
+        let lease;
+        try {
+          if (pool) {
+            const key = resolveHttpPoolKey(pool.keyResolver, req, url);
+            lease = await pool.acquire(key, signal);
+          }
+          const started = performance.now();
+          const res = await fetch(url, {
+            ..._nullishCoalesce(req.init, () => ( {})),
+            method: req.method,
+            headers: Request.headers.get(req),
+            body: req.body,
+            signal
+          });
+          const headers = headersOf(res);
+          const body = _chunkSKVY72E5cjs.streamFromReadableStream.call(void 0, res.body, normalizeHttpError);
+          _optionalChain([lease, 'optionalAccess', _10 => _10.release, 'call', _11 => _11()]);
+          lease = void 0;
+          return {
+            status: res.status,
+            statusText: res.statusText,
+            headers,
+            body,
+            ms: Math.round(performance.now() - started)
+          };
+        } finally {
+          _optionalChain([lease, 'optionalAccess', _12 => _12.release, 'call', _13 => _13()]);
+        }
+      },
+      normalizeHttpError,
+      {
+        label: fetchLabel(req, url),
+        timeoutMs,
+        timeoutReason: timeoutMs ? () => timeoutReason(req, url, timeoutMs) : void 0,
+        onStart: metrics.onStart,
+        onFinish: metrics.onFinish
       }
-      const started = performance.now();
-      const res = await fetch(url, {
-        ..._nullishCoalesce(req.init, () => ( {})),
-        method: req.method,
-        headers: Request.headers.get(req),
-        // 👈 optics: headers ya normalizados
-        body: req.body,
-        signal
-      });
-      const headers = {};
-      res.headers.forEach((v, k) => headers[k] = v);
-      const body = _chunkZTDK2DLGcjs.streamFromReadableStream.call(void 0, res.body, normalizeHttpError2);
-      return {
-        status: res.status,
-        statusText: res.statusText,
-        headers,
-        body,
-        ms: Math.round(performance.now() - started)
-      };
-    },
-    normalizeHttpError2
-  );
+    );
+  };
+  return decorateStream(run, metrics.snapshot);
 }
 function makeHttp(cfg = {}) {
   const baseUrl = _nullishCoalesce(cfg.baseUrl, () => ( ""));
   const defaultHeaders = _nullishCoalesce(cfg.headers, () => ( {}));
   const normalize = normalizeRequest(defaultHeaders);
-  const run = (req0) => _chunk2P4PD6D7cjs.fromPromiseAbortable.call(void 0, 
-    async (signal) => {
-      const req = normalize(req0);
-      let url;
-      try {
-        url = new URL(req.url, baseUrl);
-      } catch (e3) {
-        throw { _tag: "BadUrl", message: `URL inv\xE1lida: ${req.url}` };
+  const pool = makePool(cfg);
+  const metrics = makeHttpStats(pool);
+  const run = (req0) => {
+    const req = normalize(req0);
+    const url = resolveRequestUrl(req, baseUrl);
+    if (!(url instanceof URL)) return _chunkBKBFSOGTcjs.asyncFail.call(void 0, url);
+    const timeoutMs = resolvePositiveTimeout(_nullishCoalesce(req.timeoutMs, () => ( cfg.timeoutMs)));
+    return _chunkBKBFSOGTcjs.fromPromiseAbortable.call(void 0, 
+      async (signal) => {
+        let lease;
+        try {
+          if (pool) {
+            const key = resolveHttpPoolKey(pool.keyResolver, req, url);
+            lease = await pool.acquire(key, signal);
+          }
+          const started = performance.now();
+          const res = await fetch(url, {
+            ..._nullishCoalesce(req.init, () => ( {})),
+            method: req.method,
+            headers: Request.headers.get(req),
+            body: req.body,
+            signal
+          });
+          const bodyText = await res.text();
+          const headers = headersOf(res);
+          return {
+            status: res.status,
+            statusText: res.statusText,
+            headers,
+            bodyText,
+            ms: Math.round(performance.now() - started)
+          };
+        } finally {
+          _optionalChain([lease, 'optionalAccess', _14 => _14.release, 'call', _15 => _15()]);
+        }
+      },
+      normalizeHttpError,
+      {
+        label: fetchLabel(req, url),
+        timeoutMs,
+        timeoutReason: timeoutMs ? () => timeoutReason(req, url, timeoutMs) : void 0,
+        onStart: metrics.onStart,
+        onFinish: metrics.onFinish
       }
-      const started = performance.now();
-      const res = await fetch(url, {
-        ..._nullishCoalesce(req.init, () => ( {})),
-        method: req.method,
-        headers: Request.headers.get(req),
-        // 👈 optics
-        body: req.body,
-        signal
-      });
-      const bodyText = await res.text();
-      const headers = {};
-      res.headers.forEach((v, k) => headers[k] = v);
-      return {
-        status: res.status,
-        statusText: res.statusText,
-        headers,
-        bodyText,
-        ms: Math.round(performance.now() - started)
-      };
-    },
-    normalizeHttpError2
-  );
-  return decorate(run);
+    );
+  };
+  return decorate(run, metrics.snapshot);
 }
 var clamp = (n, min, max) => Math.max(min, Math.min(max, n));
-var defaultRetryOnError = (e) => e._tag === "FetchError";
+var defaultRetryOnError = (e) => e._tag === "FetchError" || e._tag === "Timeout" || e._tag === "PoolTimeout";
 var defaultRetryOnStatus = (s) => s === 408 || s === 429 || s === 500 || s === 502 || s === 503 || s === 504;
 var backoffDelayMs = (attempt, base, cap) => {
   const exp = base * Math.pow(2, attempt);
@@ -174,7 +645,7 @@ var backoffDelayMs = (attempt, base, cap) => {
 var retryAfterMs = (headers) => {
   const key = Object.keys(headers).find((k) => k.toLowerCase() === "retry-after");
   if (!key) return void 0;
-  const v = _optionalChain([headers, 'access', _3 => _3[key], 'optionalAccess', _4 => _4.trim, 'call', _5 => _5()]);
+  const v = _optionalChain([headers, 'access', _16 => _16[key], 'optionalAccess', _17 => _17.trim, 'call', _18 => _18()]);
   if (!v) return void 0;
   const secs = Number(v);
   if (Number.isFinite(secs)) return Math.max(0, Math.floor(secs * 1e3));
@@ -182,31 +653,85 @@ var retryAfterMs = (headers) => {
   if (Number.isFinite(t)) return Math.max(0, t - Date.now());
   return void 0;
 };
-var withRetryStream = (p) => (next) => ((req) => {
-  const loop = (attempt) => _chunk2P4PD6D7cjs.asyncFold.call(void 0, 
-    next(req),
-    (e) => {
-      if (e._tag === "Abort" || e._tag === "BadUrl") return _chunk2P4PD6D7cjs.asyncFail.call(void 0, e);
-      const canRetry = attempt < p.maxRetries && (_nullishCoalesce(p.retryOnError, () => ( defaultRetryOnError)))(e);
-      if (!canRetry) return _chunk2P4PD6D7cjs.asyncFail.call(void 0, e);
-      const d = backoffDelayMs(attempt, p.baseDelayMs, p.maxDelayMs);
-      return _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, sleepMs(d), () => loop(attempt + 1));
-    },
-    (w) => {
-      const canRetry = attempt < p.maxRetries && (_nullishCoalesce(p.retryOnStatus, () => ( defaultRetryOnStatus)))(w.status);
-      if (!canRetry) return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, w);
-      const ra = retryAfterMs(w.headers);
-      const d = _nullishCoalesce(ra, () => ( backoffDelayMs(attempt, p.baseDelayMs, p.maxDelayMs)));
-      return _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, sleepMs(d), () => loop(attempt + 1));
-    }
-  );
-  return loop(0);
-});
+var withRetryStream = (p) => (next) => {
+  const retryOnStatus = _nullishCoalesce(p.retryOnStatus, () => ( defaultRetryOnStatus));
+  const retryOnError = _nullishCoalesce(p.retryOnError, () => ( defaultRetryOnError));
+  const maxElapsedMs = p.maxElapsedMs !== void 0 && Number.isFinite(p.maxElapsedMs) ? Math.max(0, Math.floor(p.maxElapsedMs)) : void 0;
+  const run = (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) => _chunkBKBFSOGTcjs.asyncFold.call(void 0, 
+      next(req),
+      (e) => {
+        if (e._tag === "Abort" || e._tag === "BadUrl" || e._tag === "PoolRejected") return _chunkBKBFSOGTcjs.asyncFail.call(void 0, e);
+        const canRetry = attempt < p.maxRetries && retryOnError(e) && remainingBudget() > 0;
+        if (!canRetry) return _chunkBKBFSOGTcjs.asyncFail.call(void 0, e);
+        const d = delayWithinBudget(backoffDelayMs(attempt, p.baseDelayMs, p.maxDelayMs));
+        if (d <= 0 && maxElapsedMs !== void 0) return _chunkBKBFSOGTcjs.asyncFail.call(void 0, e);
+        return _chunkBKBFSOGTcjs.asyncFlatMap.call(void 0, _chunkSKVY72E5cjs.sleep.call(void 0, d), () => loop(attempt + 1));
+      },
+      (w) => {
+        const canRetry = attempt < p.maxRetries && retryOnStatus(w.status) && remainingBudget() > 0;
+        if (!canRetry) return _chunkBKBFSOGTcjs.asyncSucceed.call(void 0, 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 _chunkBKBFSOGTcjs.asyncSucceed.call(void 0, w);
+        return _chunkBKBFSOGTcjs.asyncFlatMap.call(void 0, _chunkSKVY72E5cjs.sleep.call(void 0, d), () => loop(attempt + 1));
+      }
+    );
+    return loop(0);
+  };
+  return decorateStream(run, next.stats);
+};
+
+// src/http/retry/wasmRetryPlanner.ts
+var WasmRetryPlannerBridge = class {
+  
+  constructor(Ctor) {
+    this.planner = new Ctor();
+  }
+  start(options) {
+    return this.planner.start(
+      options.nowMs,
+      options.maxRetries,
+      options.baseDelayMs,
+      options.maxDelayMs,
+      _nullishCoalesce(options.maxElapsedMs, () => ( -1)),
+      BigInt(this.seed())
+    );
+  }
+  nextDelayMs(retryId, options) {
+    const delay = this.planner.next_delay_ms(retryId, options.nowMs, options.retryable, _nullishCoalesce(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 = _chunkBKBFSOGTcjs.resolveWasmModule.call(void 0, );
+  const Ctor = _optionalChain([mod, 'optionalAccess', _19 => _19.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 defaultRetryOnStatus2 = (s) => s === 408 || s === 429 || s === 500 || s === 502 || s === 503 || s === 504;
-var defaultRetryOnError2 = (e) => e._tag === "FetchError";
+var defaultRetryOnError2 = (e) => e._tag === "FetchError" || e._tag === "Timeout" || e._tag === "PoolTimeout";
 var clamp2 = (n, min, max) => Math.max(min, Math.min(max, n));
 var backoffDelayMs2 = (attempt, base, cap) => {
   const b = Math.max(0, base);
@@ -220,7 +745,7 @@ var headerCI = (h, name) => {
   return k ? h[k] : void 0;
 };
 var retryAfterMs2 = (headers) => {
-  const v = _optionalChain([headerCI, 'call', _6 => _6(headers, "retry-after"), 'optionalAccess', _7 => _7.trim, 'call', _8 => _8()]);
+  const v = _optionalChain([headerCI, 'call', _20 => _20(headers, "retry-after"), 'optionalAccess', _21 => _21.trim, 'call', _22 => _22()]);
   if (!v) return void 0;
   const secs = Number(v);
   if (Number.isFinite(secs)) return Math.max(0, Math.floor(secs * 1e3));
@@ -228,50 +753,106 @@ var retryAfterMs2 = (headers) => {
   if (Number.isFinite(t)) return Math.max(0, t - Date.now());
   return void 0;
 };
+var normalizeBudget = (ms) => {
+  if (ms === void 0 || !Number.isFinite(ms)) return void 0;
+  return Math.max(0, Math.floor(ms));
+};
+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 = _nullishCoalesce(p.retryOnMethods, () => ( defaultRetryableMethods));
   const retryOnStatus = _nullishCoalesce(p.retryOnStatus, () => ( defaultRetryOnStatus2));
   const retryOnError = _nullishCoalesce(p.retryOnError, () => ( defaultRetryOnError2));
+  const maxElapsedMs = normalizeBudget(p.maxElapsedMs);
+  const retryEngine = resolveRetryEngine(p);
+  const wasmPlanner = retryEngine === "wasm" ? makeWasmRetryPlanner() : void 0;
   const isMethodRetryable = (req) => retryOnMethods.includes(req.method);
-  const loop = (req, attempt) => {
+  const nextDelay = (retryId, attempt, startedAt, retryable, retryAfter) => {
+    if (!retryable) return void 0;
+    if (wasmPlanner && retryId !== void 0) {
+      return wasmPlanner.nextDelayMs(retryId, {
+        nowMs: performance.now(),
+        retryable,
+        retryAfterMs: retryAfter
+      });
+    }
+    const remainingBudget = maxElapsedMs === void 0 ? Number.POSITIVE_INFINITY : maxElapsedMs - (performance.now() - startedAt);
+    if (remainingBudget <= 0) return void 0;
+    const rawDelay = retryAfter === void 0 ? backoffDelayMs2(attempt, p.baseDelayMs, p.maxDelayMs) : Math.min(retryAfter, p.maxDelayMs);
+    return Math.max(0, Math.min(rawDelay, remainingBudget));
+  };
+  const dropPlanner = (retryId) => {
+    if (retryId !== void 0) _optionalChain([wasmPlanner, 'optionalAccess', _23 => _23.drop, 'call', _24 => _24(retryId)]);
+  };
+  const loop = (req, attempt, startedAt, retryId) => {
     if (!isMethodRetryable(req)) return next(req);
-    return _chunk2P4PD6D7cjs.asyncFold.call(void 0, 
+    const remainingBudget = () => maxElapsedMs === void 0 ? Number.POSITIVE_INFINITY : maxElapsedMs - (performance.now() - startedAt);
+    return _chunkBKBFSOGTcjs.asyncFold.call(void 0, 
       next(req),
       (e) => {
-        if (e._tag === "Abort" || e._tag === "BadUrl") return _chunk2P4PD6D7cjs.asyncFail.call(void 0, e);
-        const canRetry = attempt < p.maxRetries && retryOnError(e);
-        if (!canRetry) return _chunk2P4PD6D7cjs.asyncFail.call(void 0, e);
-        const d = backoffDelayMs2(attempt, p.baseDelayMs, p.maxDelayMs);
-        return _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, sleepMs(d), () => loop(req, attempt + 1));
+        if (e._tag === "Abort" || e._tag === "BadUrl" || e._tag === "PoolRejected") {
+          dropPlanner(retryId);
+          return _chunkBKBFSOGTcjs.asyncFail.call(void 0, e);
+        }
+        const retryable = attempt < p.maxRetries && retryOnError(e) && remainingBudget() > 0;
+        const d = nextDelay(retryId, attempt, startedAt, retryable);
+        if (d === void 0 || d <= 0 && maxElapsedMs !== void 0) {
+          dropPlanner(retryId);
+          return _chunkBKBFSOGTcjs.asyncFail.call(void 0, e);
+        }
+        return _chunkBKBFSOGTcjs.asyncFlatMap.call(void 0, _chunkSKVY72E5cjs.sleep.call(void 0, d), () => loop(req, attempt + 1, startedAt, retryId));
       },
       (w) => {
-        const canRetry = attempt < p.maxRetries && retryOnStatus(w.status);
-        if (!canRetry) return _chunk2P4PD6D7cjs.asyncSucceed.call(void 0, w);
-        const ra = retryAfterMs2(w.headers);
-        const d = _nullishCoalesce(ra, () => ( backoffDelayMs2(attempt, p.baseDelayMs, p.maxDelayMs)));
-        return _chunk2P4PD6D7cjs.asyncFlatMap.call(void 0, sleepMs(d), () => loop(req, attempt + 1));
+        const retryable = attempt < p.maxRetries && retryOnStatus(w.status) && remainingBudget() > 0;
+        const ra = p.respectRetryAfter === false ? void 0 : retryAfterMs2(w.headers);
+        const d = nextDelay(retryId, attempt, startedAt, retryable, ra);
+        if (d === void 0 || d <= 0 && maxElapsedMs !== void 0) {
+          dropPlanner(retryId);
+          return _chunkBKBFSOGTcjs.asyncSucceed.call(void 0, w);
+        }
+        return _chunkBKBFSOGTcjs.asyncFlatMap.call(void 0, _chunkSKVY72E5cjs.sleep.call(void 0, d), () => loop(req, attempt + 1, startedAt, retryId));
       }
     );
   };
-  return (req) => loop(req, 0);
+  return (req) => {
+    if (!isMethodRetryable(req)) return next(req);
+    const startedAt = performance.now();
+    const retryId = _optionalChain([wasmPlanner, 'optionalAccess', _25 => _25.start, 'call', _26 => _26({
+      nowMs: startedAt,
+      maxRetries: p.maxRetries,
+      baseDelayMs: p.baseDelayMs,
+      maxDelayMs: p.maxDelayMs,
+      maxElapsedMs
+    })]);
+    return loop(req, 0, startedAt, retryId);
+  };
 };
 
 // src/http/httpClient.ts
 var resolveFinalUrl = (baseUrl, url) => {
   try {
     return new URL(url, _nullishCoalesce(baseUrl, () => ( ""))).toString();
-  } catch (e4) {
+  } catch (e3) {
     return (_nullishCoalesce(baseUrl, () => ( ""))) + url;
   }
 };
 var createHttpCore = (cfg = {}) => {
   const wire = makeHttp(cfg);
-  const withPromise = (eff) => _chunk2P4PD6D7cjs.withAsyncPromise.call(void 0, (e, env) => _chunk2P4PD6D7cjs.toPromise.call(void 0, e, env))(eff);
+  const withPromise = (eff) => _chunkBKBFSOGTcjs.withAsyncPromise.call(void 0, (e, env) => _chunkBKBFSOGTcjs.toPromise.call(void 0, e, env))(eff);
   const requestRaw = (req) => wire(req);
   const splitInit = (init) => {
-    const { headers, ...rest } = _nullishCoalesce(init, () => ( {}));
+    const { headers, timeoutMs, poolKey, ...rest } = _nullishCoalesce(init, () => ( {}));
     return {
       headers: normalizeHeadersInit(headers),
+      timeoutMs: typeof timeoutMs === "number" ? timeoutMs : void 0,
+      poolKey: typeof poolKey === "string" ? poolKey : void 0,
       init: rest
     };
   };
@@ -282,6 +863,8 @@ var createHttpCore = (cfg = {}) => {
       method,
       url,
       ...body && body.length > 0 ? { body } : {},
+      ...s.timeoutMs !== void 0 ? { timeoutMs: s.timeoutMs } : {},
+      ...s.poolKey !== void 0 ? { poolKey: s.poolKey } : {},
       init: s.init
     };
     return applyInitHeaders(s.headers)(req);
@@ -312,12 +895,12 @@ function httpClient(cfg = {}) {
     const post = (url, body, init) => request(core.buildReq("POST", url, init, body));
     const getText = (url, init) => {
       const req = core.buildReq("GET", url, init);
-      return core.withPromise(_chunk2P4PD6D7cjs.mapTryAsync.call(void 0, requestRaw(req), (w) => core.toResponse(w, w.bodyText)));
+      return core.withPromise(_chunkBKBFSOGTcjs.mapTryAsync.call(void 0, requestRaw(req), (w) => core.toResponse(w, w.bodyText)));
     };
     const getJson = (url, init) => {
       const base = core.buildReq("GET", url, init);
       const req = setHeaderIfMissing("accept", "application/json")(base);
-      return core.withPromise(_chunk2P4PD6D7cjs.mapTryAsync.call(void 0, requestRaw(req), (w) => core.toResponse(w, JSON.parse(w.bodyText))));
+      return core.withPromise(_chunkBKBFSOGTcjs.mapTryAsync.call(void 0, requestRaw(req), (w) => core.toResponse(w, JSON.parse(w.bodyText))));
     };
     const postJson = (url, bodyObj, init) => {
       const base = core.buildReq("POST", url, init, JSON.stringify(_nullishCoalesce(bodyObj, () => ( {}))));
@@ -325,7 +908,7 @@ function httpClient(cfg = {}) {
         setHeaderIfMissing("accept", "application/json")(base)
       );
       return core.withPromise(
-        _chunk2P4PD6D7cjs.mapTryAsync.call(void 0, requestRaw(req), (w) => core.toResponse(w, JSON.parse(w.bodyText)))
+        _chunkBKBFSOGTcjs.mapTryAsync.call(void 0, requestRaw(req), (w) => core.toResponse(w, JSON.parse(w.bodyText)))
       );
     };
     return {
@@ -337,7 +920,8 @@ function httpClient(cfg = {}) {
       postJson,
       with: (mw) => make(wire.with(mw)),
       withRetry: (p) => make(wire.with(withRetry(p))),
-      wire
+      wire,
+      stats: () => wire.stats()
     };
   };
   return make(core.wire);
@@ -353,7 +937,7 @@ function httpClientWithMeta(cfg = {}) {
   const request = (req) => {
     const startedAt = Date.now();
     return core.withPromise(
-      _chunk2P4PD6D7cjs.mapTryAsync.call(void 0, core.requestRaw(req), (w) => ({
+      _chunkBKBFSOGTcjs.mapTryAsync.call(void 0, core.requestRaw(req), (w) => ({
         wire: w,
         meta: mkMeta(req, w, startedAt)
       }))
@@ -374,7 +958,7 @@ function httpClientWithMeta(cfg = {}) {
     );
     const startedAt = Date.now();
     return core.withPromise(
-      _chunk2P4PD6D7cjs.mapTryAsync.call(void 0, core.requestRaw(req), (w) => ({
+      _chunkBKBFSOGTcjs.mapTryAsync.call(void 0, core.requestRaw(req), (w) => ({
         wire: w,
         response: core.toResponse(w, JSON.parse(w.bodyText)),
         meta: mkMeta(req, w, startedAt)
@@ -385,7 +969,7 @@ function httpClientWithMeta(cfg = {}) {
     const req = core.buildReq("GET", url, init);
     const startedAt = Date.now();
     return core.withPromise(
-      _chunk2P4PD6D7cjs.mapTryAsync.call(void 0, core.requestRaw(req), (w) => ({
+      _chunkBKBFSOGTcjs.mapTryAsync.call(void 0, core.requestRaw(req), (w) => ({
         wire: w,
         response: core.toResponse(w, w.bodyText),
         meta: mkMeta(req, w, startedAt)
@@ -397,7 +981,7 @@ function httpClientWithMeta(cfg = {}) {
     const req = setHeaderIfMissing("accept", "application/json")(base);
     const startedAt = Date.now();
     return core.withPromise(
-      _chunk2P4PD6D7cjs.mapTryAsync.call(void 0, core.requestRaw(req), (w) => ({
+      _chunkBKBFSOGTcjs.mapTryAsync.call(void 0, core.requestRaw(req), (w) => ({
         wire: w,
         response: core.toResponse(w, JSON.parse(w.bodyText)),
         meta: mkMeta(req, w, startedAt)
@@ -422,7 +1006,7 @@ function httpClientWithMeta(cfg = {}) {
 function httpClientStream(cfg = {}) {
   const wire = makeHttpStream(cfg);
   const make = (w) => {
-    const withPromise = (eff) => _chunk2P4PD6D7cjs.withAsyncPromise.call(void 0, (e, env) => _chunk2P4PD6D7cjs.toPromise.call(void 0, e, env))(eff);
+    const withPromise = (eff) => _chunkBKBFSOGTcjs.withAsyncPromise.call(void 0, (e, env) => _chunkBKBFSOGTcjs.toPromise.call(void 0, e, env))(eff);
     const request = (req) => withPromise(w(req));
     const getStream = (url, init) => {
       const base = { method: "GET", url, init };
@@ -435,12 +1019,96 @@ function httpClientStream(cfg = {}) {
       get: getStream,
       with: (mw) => make(mw(w)),
       withRetry: (p) => make(withRetryStream(p)(w)),
-      wire: w
+      wire: w,
+      stats: () => w.stats()
     };
   };
   return make(wire);
 }
 
+// src/http/circuitBreaker.ts
+function withCircuitBreaker(config = {}) {
+  if (config.perOrigin) {
+    const breakers = /* @__PURE__ */ new Map();
+    const getBreaker = (url) => {
+      try {
+        const origin = new URL(url).origin;
+        if (!breakers.has(origin)) {
+          breakers.set(origin, _chunkSKVY72E5cjs.makeCircuitBreaker.call(void 0, config));
+        }
+        return breakers.get(origin);
+      } catch (e4) {
+        if (!breakers.has("__global__")) {
+          breakers.set("__global__", _chunkSKVY72E5cjs.makeCircuitBreaker.call(void 0, config));
+        }
+        return breakers.get("__global__");
+      }
+    };
+    return (next) => (req) => {
+      const breaker2 = getBreaker(req.url);
+      return breaker2.protect(next(req));
+    };
+  }
+  const breaker = _chunkSKVY72E5cjs.makeCircuitBreaker.call(void 0, {
+    ...config,
+    isFailure: _nullishCoalesce(config.isFailure, () => ( ((e) => {
+      const err = e;
+      return err._tag !== "BadUrl" && err._tag !== "Abort";
+    })))
+  });
+  return (next) => (req) => {
+    return breaker.protect(next(req));
+  };
+}
+
+// src/http/tracing.ts
+function withTracing(tracer) {
+  return (next) => (req) => {
+    return tracer.span(
+      `HTTP ${req.method} ${req.url}`,
+      next(req),
+      {
+        "http.method": req.method,
+        "http.url": req.url,
+        ..._optionalChain([req, 'access', _27 => _27.headers, 'optionalAccess', _28 => _28["content-type"]]) ? { "http.content_type": req.headers["content-type"] } : {}
+      }
+    );
+  };
+}
+
+// src/http/validation.ts
+function validatedJson(client, validator) {
+  return (req) => _chunkBKBFSOGTcjs.asyncFold.call(void 0, 
+    client(req),
+    (error) => _chunkBKBFSOGTcjs.asyncFail.call(void 0, error),
+    (response) => {
+      try {
+        const parsed = JSON.parse(response.bodyText);
+        const result = validator(parsed);
+        if (result.success) {
+          return _chunkBKBFSOGTcjs.asyncSucceed.call(void 0, result.data);
+        }
+        return _chunkBKBFSOGTcjs.asyncFail.call(void 0, {
+          _tag: "ValidationError",
+          message: result.error,
+          body: response.bodyText
+        });
+      } catch (e) {
+        return _chunkBKBFSOGTcjs.asyncFail.call(void 0, {
+          _tag: "ValidationError",
+          message: `JSON parse error: ${String(e)}`,
+          body: response.bodyText
+        });
+      }
+    }
+  );
+}
+
+
+
+
+
+
 
 
 
@@ -450,4 +1118,4 @@ function httpClientStream(cfg = {}) {
 
 
 
-exports.decorate = decorate; exports.httpClient = httpClient; exports.httpClientStream = httpClientStream; exports.httpClientWithMeta = httpClientWithMeta; exports.makeHttp = makeHttp; exports.makeHttpStream = makeHttpStream; exports.normalizeHeadersInit = normalizeHeadersInit; exports.withMiddleware = withMiddleware; exports.withRetryStream = withRetryStream;
+exports.HttpConcurrencyPool = HttpConcurrencyPool; exports.decorate = decorate; exports.httpClient = httpClient; exports.httpClientStream = httpClientStream; exports.httpClientWithMeta = httpClientWithMeta; exports.makeHttp = makeHttp; exports.makeHttpStream = makeHttpStream; exports.normalizeHeadersInit = normalizeHeadersInit; exports.resolveHttpPoolKey = resolveHttpPoolKey; exports.validatedJson = validatedJson; exports.withCircuitBreaker = withCircuitBreaker; exports.withMiddleware = withMiddleware; exports.withRetryStream = withRetryStream; exports.withTracing = withTracing;