brass-runtime 1.13.8 → 1.14.0

package/dist/http/index.mjs

@@ -1,6 +1,8 @@
 import {
+  makeCircuitBreaker,
+  sleep,
   streamFromReadableStream
-} from "../chunk-XNOTJSMZ.mjs";
+} from "../chunk-UWMMYKVK.mjs";
 import {
   asyncFail,
   asyncFlatMap,
@@ -8,9 +10,10 @@ import {
   asyncSucceed,
   fromPromiseAbortable,
   mapTryAsync,
+  resolveWasmModule,
   toPromise,
   withAsyncPromise
-} from "../chunk-7F2R7A2V.mjs";
+} from "../chunk-4N2JEK4H.mjs";
 
 // 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 {
+  pool;
+  keyCache = /* @__PURE__ */ new Map();
+  constructor(Ctor, options) {
+    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;
+  }
+};
+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 sleepMs = (ms) => fromPromiseAbortable(
-  (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 = 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
     };
-    signal.addEventListener("abort", onAbort, { once: true });
-  }),
-  normalizeHttpError
-);
+    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/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 normalizeHttpError2 = (e) => {
-  if (e instanceof DOMException && e.name === "AbortError") return { _tag: "Abort" };
-  if (typeof e === "object" && e && "_tag" in e) return e;
+var decorate = (run, stats = emptyStats) => Object.assign(((req) => run(req)), {
+  with: (mw) => decorate(mw(run), stats),
+  stats
+});
+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) => {
@@ -90,81 +446,196 @@ var normalizeRequest = (defaultHeaders) => (req0) => {
   }
   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 {
+    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 = cfg.baseUrl ?? "";
   const defaultHeaders = cfg.headers ?? {};
   const normalize = normalizeRequest(defaultHeaders);
-  return (req0) => fromPromiseAbortable(
-    async (signal) => {
-      const req = normalize(req0);
-      let url;
-      try {
-        url = new URL(req.url, baseUrl);
-      } catch {
-        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 asyncFail(url);
+    const timeoutMs = resolvePositiveTimeout(req.timeoutMs ?? cfg.timeoutMs);
+    return fromPromiseAbortable(
+      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, {
+            ...req.init ?? {},
+            method: req.method,
+            headers: Request.headers.get(req),
+            body: req.body,
+            signal
+          });
+          const headers = headersOf(res);
+          const body = streamFromReadableStream(res.body, normalizeHttpError);
+          lease?.release();
+          lease = void 0;
+          return {
+            status: res.status,
+            statusText: res.statusText,
+            headers,
+            body,
+            ms: Math.round(performance.now() - started)
+          };
+        } finally {
+          lease?.release();
+        }
+      },
+      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, {
-        ...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 = streamFromReadableStream(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 = cfg.baseUrl ?? "";
   const defaultHeaders = cfg.headers ?? {};
   const normalize = normalizeRequest(defaultHeaders);
-  const run = (req0) => fromPromiseAbortable(
-    async (signal) => {
-      const req = normalize(req0);
-      let url;
-      try {
-        url = new URL(req.url, baseUrl);
-      } catch {
-        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 asyncFail(url);
+    const timeoutMs = resolvePositiveTimeout(req.timeoutMs ?? cfg.timeoutMs);
+    return fromPromiseAbortable(
+      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, {
+            ...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 {
+          lease?.release();
+        }
+      },
+      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, {
-        ...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);
@@ -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) => asyncFold(
-    next(req),
-    (e) => {
-      if (e._tag === "Abort" || e._tag === "BadUrl") return asyncFail(e);
-      const canRetry = attempt < p.maxRetries && (p.retryOnError ?? defaultRetryOnError)(e);
-      if (!canRetry) return asyncFail(e);
-      const d = backoffDelayMs(attempt, p.baseDelayMs, p.maxDelayMs);
-      return asyncFlatMap(sleepMs(d), () => loop(attempt + 1));
-    },
-    (w) => {
-      const canRetry = attempt < p.maxRetries && (p.retryOnStatus ?? defaultRetryOnStatus)(w.status);
-      if (!canRetry) return asyncSucceed(w);
-      const ra = retryAfterMs(w.headers);
-      const d = ra ?? backoffDelayMs(attempt, p.baseDelayMs, p.maxDelayMs);
-      return asyncFlatMap(sleepMs(d), () => loop(attempt + 1));
-    }
-  );
-  return loop(0);
-});
+var withRetryStream = (p) => (next) => {
+  const retryOnStatus = p.retryOnStatus ?? defaultRetryOnStatus;
+  const retryOnError = 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) => asyncFold(
+      next(req),
+      (e) => {
+        if (e._tag === "Abort" || e._tag === "BadUrl" || e._tag === "PoolRejected") 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);
+        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);
+        return asyncFlatMap(sleep(d), () => loop(attempt + 1));
+      }
+    );
+    return loop(0);
+  };
+  return decorateStream(run, next.stats);
+};
+
+// 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 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);
@@ -228,32 +753,86 @@ 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 = p.retryOnMethods ?? defaultRetryableMethods;
   const retryOnStatus = p.retryOnStatus ?? defaultRetryOnStatus2;
   const retryOnError = 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) wasmPlanner?.drop(retryId);
+  };
+  const loop = (req, attempt, startedAt, retryId) => {
     if (!isMethodRetryable(req)) return next(req);
+    const remainingBudget = () => maxElapsedMs === void 0 ? Number.POSITIVE_INFINITY : maxElapsedMs - (performance.now() - startedAt);
     return asyncFold(
       next(req),
       (e) => {
-        if (e._tag === "Abort" || e._tag === "BadUrl") return asyncFail(e);
-        const canRetry = attempt < p.maxRetries && retryOnError(e);
-        if (!canRetry) return asyncFail(e);
-        const d = backoffDelayMs2(attempt, p.baseDelayMs, p.maxDelayMs);
-        return asyncFlatMap(sleepMs(d), () => loop(req, attempt + 1));
+        if (e._tag === "Abort" || e._tag === "BadUrl" || e._tag === "PoolRejected") {
+          dropPlanner(retryId);
+          return asyncFail(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 asyncFail(e);
+        }
+        return asyncFlatMap(sleep(d), () => loop(req, attempt + 1, startedAt, retryId));
       },
       (w) => {
-        const canRetry = attempt < p.maxRetries && retryOnStatus(w.status);
-        if (!canRetry) return asyncSucceed(w);
-        const ra = retryAfterMs2(w.headers);
-        const d = ra ?? backoffDelayMs2(attempt, p.baseDelayMs, p.maxDelayMs);
-        return asyncFlatMap(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 asyncSucceed(w);
+        }
+        return asyncFlatMap(sleep(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 = wasmPlanner?.start({
+      nowMs: startedAt,
+      maxRetries: p.maxRetries,
+      baseDelayMs: p.baseDelayMs,
+      maxDelayMs: p.maxDelayMs,
+      maxElapsedMs
+    });
+    return loop(req, 0, startedAt, retryId);
+  };
 };
 
 // src/http/httpClient.ts
@@ -269,9 +848,11 @@ var createHttpCore = (cfg = {}) => {
   const withPromise = (eff) => withAsyncPromise((e, env) => toPromise(e, env))(eff);
   const requestRaw = (req) => wire(req);
   const splitInit = (init) => {
-    const { headers, ...rest } = init ?? {};
+    const { headers, timeoutMs, poolKey, ...rest } = 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);
@@ -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);
@@ -435,12 +1019,92 @@ 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, makeCircuitBreaker(config));
+        }
+        return breakers.get(origin);
+      } catch {
+        if (!breakers.has("__global__")) {
+          breakers.set("__global__", makeCircuitBreaker(config));
+        }
+        return breakers.get("__global__");
+      }
+    };
+    return (next) => (req) => {
+      const breaker2 = getBreaker(req.url);
+      return breaker2.protect(next(req));
+    };
+  }
+  const breaker = makeCircuitBreaker({
+    ...config,
+    isFailure: 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,
+        ...req.headers?.["content-type"] ? { "http.content_type": req.headers["content-type"] } : {}
+      }
+    );
+  };
+}
+
+// src/http/validation.ts
+function validatedJson(client, validator) {
+  return (req) => asyncFold(
+    client(req),
+    (error) => asyncFail(error),
+    (response) => {
+      try {
+        const parsed = JSON.parse(response.bodyText);
+        const result = validator(parsed);
+        if (result.success) {
+          return asyncSucceed(result.data);
+        }
+        return asyncFail({
+          _tag: "ValidationError",
+          message: result.error,
+          body: response.bodyText
+        });
+      } catch (e) {
+        return asyncFail({
+          _tag: "ValidationError",
+          message: `JSON parse error: ${String(e)}`,
+          body: response.bodyText
+        });
+      }
+    }
+  );
+}
 export {
+  HttpConcurrencyPool,
   decorate,
   httpClient,
   httpClientStream,
@@ -448,6 +1112,10 @@ export {
   makeHttp,
   makeHttpStream,
   normalizeHeadersInit,
+  resolveHttpPoolKey,
+  validatedJson,
+  withCircuitBreaker,
   withMiddleware,
-  withRetryStream
+  withRetryStream,
+  withTracing
 };