brass-runtime 1.16.0 → 1.16.1

package/dist/{chunk-7TL2LHQJ.js → chunk-5VRJNBLZ.mjs}

@@ -1,24 +1,37 @@
+import {
+  registerHttpEffect
+} from "./chunk-MOO4L7F4.mjs";
 import {
   streamFromReadableStream
-} from "./chunk-OOGJ73B6.js";
+} from "./chunk-FHQGHPMO.mjs";
 import {
+  makeScheduleDriver,
   sleep
-} from "./chunk-ROJC3NBJ.js";
+} from "./chunk-2HQTDLHF.mjs";
+import {
+  getHttpRequestPolicy,
+  isExternalAbortError,
+  isHttpError,
+  isRetryableHttpError,
+  toHttpError,
+  withHttpRequestPolicy
+} from "./chunk-PWC3RBQE.mjs";
 import {
   fromPromiseAbortable,
   resolveWasmModule
-} from "./chunk-7LVI2GIN.js";
+} from "./chunk-GYM3LLGS.mjs";
 import {
+  Cause,
   asyncEffect,
   asyncFail,
   asyncFlatMap,
   asyncFold,
   asyncSucceed
-} from "./chunk-PNVFW245.js";
+} from "./chunk-36I3M4UC.mjs";
 import {
   Schema,
   parseConfig
-} from "./chunk-TDVMADDN.js";
+} from "./chunk-DNFJLJMW.mjs";
 
 // src/http/retry/wasmRetryPlanner.ts
 var WasmRetryPlannerBridge = class {
@@ -65,7 +78,7 @@ function makeWasmRetryPlanner() {
 // 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) => e._tag === "FetchError" || e._tag === "Timeout" || e._tag === "PoolTimeout";
+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);
@@ -92,7 +105,7 @@ var normalizeRetryBudget = (ms) => {
   return Math.max(0, Math.floor(ms));
 };
 var resolveEffectivePolicy = (req, basePolicy) => {
-  const override = req.retry;
+  const override = getHttpRequestPolicy(req).retry;
   if (override === false) return null;
   if (override === void 0) return basePolicy;
   return {
@@ -118,17 +131,16 @@ var withRetry = (p) => (next) => {
   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, scheduleState, input) => {
+  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 (ep.schedule) {
-      const [decision, nextScheduleState] = ep.schedule.step(scheduleState, input);
+    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)),
-        scheduleState: nextScheduleState
+        delayMs: Math.max(0, Math.min(rawDelay2, remainingBudget))
       };
     }
     if (wasmPlanner && retryId !== void 0) {
@@ -137,10 +149,10 @@ var withRetry = (p) => (next) => {
         retryable,
         retryAfterMs: input.retryAfterMs
       });
-      return delay === void 0 ? void 0 : { delayMs: delay, scheduleState };
+      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)), scheduleState };
+    return { delayMs: Math.max(0, Math.min(rawDelay, remainingBudget)) };
   };
   const sleepWithCleanup = (ms, onCancel) => {
     return asyncEffect((_env, cb) => {
@@ -152,13 +164,9 @@ var withRetry = (p) => (next) => {
       };
     });
   };
-  const loop = (req, attempt, startedAt, retryId, ep, epMaxElapsedMs, epRetryOnStatus, epRetryOnError, originalPriority, safeDrop, scheduleState) => {
+  const loop = (req, attempt, startedAt, retryId, ep, epMaxElapsedMs, epRetryOnStatus, epRetryOnError, originalPriority, safeDrop, scheduleDriver) => {
     if (!isMethodRetryable(req)) return next(req);
-    const effectiveReq = attempt > 0 ? (() => {
-      const boostedReq = { ...req };
-      boostedReq.priority = Math.max(0, originalPriority - 1);
-      return boostedReq;
-    })() : 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),
@@ -168,7 +176,7 @@ var withRetry = (p) => (next) => {
           return asyncFail(e);
         }
         const retryable = attempt < ep.maxRetries && epRetryOnError(e) && remainingBudget() > 0;
-        const retryDecision = nextDelay(ep, epMaxElapsedMs, retryId, attempt, startedAt, retryable, scheduleState, {
+        const retryDecision = nextDelay(ep, epMaxElapsedMs, retryId, attempt, startedAt, retryable, scheduleDriver, {
           attempt,
           elapsedMs: performance.now() - startedAt,
           request: req,
@@ -189,12 +197,12 @@ var withRetry = (p) => (next) => {
             timestamp: Date.now()
           });
         }
-        return asyncFlatMap(sleepWithCleanup(retryDecision.delayMs, () => safeDrop(retryId)), () => loop(req, attempt + 1, startedAt, retryId, ep, epMaxElapsedMs, epRetryOnStatus, epRetryOnError, originalPriority, safeDrop, retryDecision.scheduleState));
+        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, scheduleState, {
+        const retryDecision = nextDelay(ep, epMaxElapsedMs, retryId, attempt, startedAt, retryable, scheduleDriver, {
           attempt,
           elapsedMs: performance.now() - startedAt,
           request: req,
@@ -216,7 +224,7 @@ var withRetry = (p) => (next) => {
             timestamp: Date.now()
           });
         }
-        return asyncFlatMap(sleepWithCleanup(retryDecision.delayMs, () => safeDrop(retryId)), () => loop(req, attempt + 1, startedAt, retryId, ep, epMaxElapsedMs, epRetryOnStatus, epRetryOnError, originalPriority, safeDrop, retryDecision.scheduleState));
+        return asyncFlatMap(sleepWithCleanup(retryDecision.delayMs, () => safeDrop(retryId)), () => loop(req, attempt + 1, startedAt, retryId, ep, epMaxElapsedMs, epRetryOnStatus, epRetryOnError, originalPriority, safeDrop, scheduleDriver));
       }
     );
   };
@@ -227,7 +235,7 @@ var withRetry = (p) => (next) => {
     const epRetryOnStatus = effectivePolicy.retryOnStatus ?? defaultRetryOnStatus;
     const epRetryOnError = effectivePolicy.retryOnError ?? defaultRetryOnError;
     const epMaxElapsedMs = normalizeRetryBudget(effectivePolicy.maxElapsedMs);
-    const originalPriority = req.priority ?? 5;
+    const originalPriority = getHttpRequestPolicy(req).priority ?? 5;
     const startedAt = performance.now();
     const retryId = wasmPlanner?.start({
       nowMs: startedAt,
@@ -243,8 +251,12 @@ var withRetry = (p) => (next) => {
         wasmPlanner?.drop(id);
       }
     };
-    const scheduleState = effectivePolicy.schedule?.initial();
-    return loop(req, 0, startedAt, retryId, effectivePolicy, epMaxElapsedMs, epRetryOnStatus, epRetryOnError, originalPriority, safeDrop, scheduleState);
+    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);
   };
 };
 
@@ -257,23 +269,23 @@ var WasmHttpPermitPoolBridge = class {
   constructor(Ctor, options) {
     this.pool = new Ctor(options.concurrency, options.maxQueue, toU64(options.queueTimeoutMs));
   }
-  acquire(key, subjectId, nowMs = Date.now()) {
+  acquire(key, subjectId, nowMs2 = Date.now()) {
     const keyId = this.internKey(key);
-    const decision = this.pool.acquire(subjectId, keyId, toU64(nowMs));
+    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, nowMs = Date.now()) {
-    const ptr = this.pool.release(keyId, toU64(nowMs));
+  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(nowMs = Date.now()) {
-    const ptr = this.pool.advance_time(toU64(nowMs));
+  advanceTime(nowMs2 = Date.now()) {
+    const ptr = this.pool.advance_time(toU64(nowMs2));
     return this.readEvents(ptr, this.pool.permit_events_len());
   }
   nextDeadlineMs() {
@@ -356,7 +368,7 @@ function resolveHttpPoolEngine(config) {
   return "ts";
 }
 function resolveHttpPoolKey(resolver, req, url) {
-  const custom = req.poolKey?.trim();
+  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";
@@ -1904,6 +1916,351 @@ 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/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(
@@ -2015,6 +2372,31 @@ var retryConfig = Schema.union([
     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({
@@ -2041,6 +2423,8 @@ 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" });
@@ -2048,6 +2432,8 @@ 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(),
@@ -2056,12 +2442,15 @@ var lifecycleConfig = Schema.object({
   priority: priorityConfig.optional(),
   retry: retryConfig.optional(),
   prewarm: prewarmConfig.optional(),
-  onEvent: fn.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(),
@@ -2071,9 +2460,10 @@ var defaultClientConfig = Schema.object({
   retry: retryConfig.optional(),
   prewarm: prewarmConfig.optional(),
   onEvent: fn.optional(),
-  preset: Schema.enum(["minimal", "balanced", "default"]).optional(),
-  compression: Schema.union([Schema.literal(false), object]).optional(),
-  middleware: Schema.array(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);
@@ -2110,17 +2500,6 @@ var withMiddleware = (mw) => (c) => decorate(mw(c), c.stats, {
   shutdown: c.shutdown
 });
 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" || tag === "PoolClosed" || tag === "BatchSplitError";
-};
-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) => {
   if (!h) return void 0;
   if (typeof Headers !== "undefined" && h instanceof Headers) {
@@ -2212,11 +2591,6 @@ var resolveRequestUrl = (req, baseUrl) => {
     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",
@@ -2225,33 +2599,73 @@ var timeoutReason = (req, url, timeoutMs) => ({
   message: `HTTP ${req.method} ${url.origin} timed out after ${timeoutMs}ms`
 });
 var requestPriority = (req) => {
-  const fromReq = req.priority;
-  if (fromReq !== void 0) return fromReq;
+  const fromPolicy = getHttpRequestPolicy(req).priority;
+  if (fromPolicy !== void 0) return fromPolicy;
   return req.init?.priority;
 };
-var linkAbortSignals = (runtimeSignal, requestSignal) => {
-  if (!requestSignal) return { signal: runtimeSignal, cleanup: () => void 0 };
-  const controller = new AbortController();
-  const abort = (source) => {
-    try {
-      controller.abort(source.reason);
-    } catch {
-      controller.abort();
+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 abortFromRuntime = () => abort(runtimeSignal);
-  const abortFromRequest = () => abort(requestSignal);
-  if (runtimeSignal.aborted) abortFromRuntime();
-  else runtimeSignal.addEventListener("abort", abortFromRuntime, { once: true });
-  if (requestSignal.aborted) abortFromRequest();
-  else requestSignal.addEventListener("abort", abortFromRequest, { once: true });
-  return {
-    signal: controller.signal,
-    cleanup: () => {
-      runtimeSignal.removeEventListener("abort", abortFromRuntime);
-      requestSignal.removeEventListener("abort", abortFromRequest);
-    }
+  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);
@@ -2261,17 +2675,18 @@ function makeHttpStream(cfg = {}) {
   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) => {
+      async (signal, env) => {
         let lease;
         const linkedSignal = linkAbortSignals(signal, req.init?.signal);
-        let cleanupTransferredToBody = false;
         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) });
@@ -2279,44 +2694,18 @@ function makeHttpStream(cfg = {}) {
             const key = resolveHttpPoolKey(pool.keyResolver, req, url);
             lease = await pool.acquire(key, linkedSignal.signal);
           }
-          const started = performance.now();
-          const res = await fetch(url, {
-            ...req.init ?? {},
-            method: req.method,
-            headers: Request.headers.get(req),
-            body: req.body,
-            signal: linkedSignal.signal
-          });
-          const headers = headersOf(res);
-          const latencyMs = Math.round(performance.now() - started);
-          const body = streamFromReadableStream(res.body, normalizeHttpError, {
-            signal: linkedSignal.signal,
-            onRelease: linkedSignal.cleanup
-          });
-          cleanupTransferredToBody = res.body !== null;
-          if (adaptiveLimiter && lease) {
-            lease.release(latencyMs, { status: res.status });
-          } else {
-            lease?.release();
-          }
+          const response = await runTransportEffect(
+            transport({ request: req, url, signal: linkedSignal.signal }),
+            env,
+            linkedSignal.signal
+          );
+          lease = releaseSuccess(lease, adaptiveLimiter, response);
           lease = void 0;
-          return {
-            status: res.status,
-            statusText: res.statusText,
-            headers,
-            body,
-            ms: latencyMs
-          };
+          return response;
         } finally {
-          if (!cleanupTransferredToBody) {
-            linkedSignal.cleanup();
-          }
+          linkedSignal.cleanup();
           if (lease) {
-            if (adaptiveLimiter) {
-              lease.release(0, { error: true });
-            } else {
-              lease.release();
-            }
+            releaseFailure(lease, adaptiveLimiter);
           }
         }
       },
@@ -2340,16 +2729,18 @@ function makeHttp(cfg = {}) {
   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) => {
+      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) });
@@ -2357,36 +2748,17 @@ function makeHttp(cfg = {}) {
             const key = resolveHttpPoolKey(pool.keyResolver, req, url);
             lease = await pool.acquire(key, linkedSignal.signal);
           }
-          const started = performance.now();
-          const res = await fetch(url, {
-            ...req.init ?? {},
-            method: req.method,
-            headers: Request.headers.get(req),
-            body: req.body,
-            signal: linkedSignal.signal
-          });
-          const bodyText = await res.text();
-          const headers = headersOf(res);
-          const latencyMs = Math.round(performance.now() - started);
-          if (adaptiveLimiter && lease) {
-            lease.release(latencyMs, { status: res.status });
-            lease = void 0;
-          }
-          return {
-            status: res.status,
-            statusText: res.statusText,
-            headers,
-            bodyText,
-            ms: latencyMs
-          };
+          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) {
-            if (adaptiveLimiter) {
-              lease.release(0, { error: true });
-            } else {
-              lease.release();
-            }
+            releaseFailure(lease, adaptiveLimiter);
           }
         }
       },
@@ -2482,6 +2854,17 @@ export {
   AdaptiveLimiter,
   validateLifecycleClientConfig,
   validateDefaultHttpClientConfig,
+  isTaggedHttpError,
+  isAbortError,
+  normalizeHttpError,
+  headersOf,
+  normalizeHttpHeaders,
+  abortErrorForSignal,
+  linkAbortSignals,
+  makePromiseHttpTransport,
+  promiseHttpTransport,
+  makeFetchTransport,
+  makeFetchStreamTransport,
   decorate,
   withMiddleware,
   normalizeHeadersInit,