brass-runtime 1.16.0 → 1.16.1

package/dist/chunk-KQLYONSE.cjs

@@ -0,0 +1,2871 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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 _class3;
+
+
+
+
+
+
+
+
+var _chunk5EC274J5cjs = require('./chunk-5EC274J5.cjs');
+
+
+var _chunkL6VB5N7Qcjs = require('./chunk-L6VB5N7Q.cjs');
+
+
+
+var _chunk3LOYJFRRcjs = require('./chunk-3LOYJFRR.cjs');
+
+
+var _chunkGLE2WY7Zcjs = require('./chunk-GLE2WY7Z.cjs');
+
+
+
+
+
+
+
+
+var _chunkMVGUEJ5Zcjs = require('./chunk-MVGUEJ5Z.cjs');
+
+
+
+
+
+var _chunkCZIVE6NTcjs = require('./chunk-CZIVE6NT.cjs');
+
+
+var _chunkOBGZSXTJcjs = require('./chunk-OBGZSXTJ.cjs');
+
+// src/http/validation.ts
+function decodeJsonBody(bodyText, validator, options = {}) {
+  let parsed;
+  try {
+    parsed = JSON.parse(bodyText);
+  } catch (error) {
+    return {
+      success: false,
+      error: {
+        _tag: "ValidationError",
+        message: `JSON parse error: ${error instanceof Error ? error.message : String(error)}`,
+        body: bodyText,
+        phase: "response",
+        schema: options.schemaName,
+        issues: [_chunkCZIVE6NTcjs.makeSchemaIssue.call(void 0, [], "valid JSON", bodyText, "Response body is not valid JSON")]
+      }
+    };
+  }
+  if (!validator) return { success: true, data: parsed };
+  let legacyMessage;
+  const validation = _chunkCZIVE6NTcjs.isSchema.call(void 0, validator) ? validator.safeParse(parsed) : (() => {
+    const result = validator(parsed);
+    if (result.success) return { success: true, data: result.data };
+    legacyMessage = result.error;
+    return {
+      success: false,
+      issues: _nullishCoalesce(result.issues, () => ( [_chunkCZIVE6NTcjs.makeSchemaIssue.call(void 0, [], "valid JSON shape", parsed, result.error)]))
+    };
+  })();
+  if (validation.success) return { success: true, data: validation.data };
+  return {
+    success: false,
+    error: {
+      _tag: "ValidationError",
+      message: _nullishCoalesce(legacyMessage, () => ( `JSON response failed validation: ${_chunkCZIVE6NTcjs.formatIssues.call(void 0, validation.issues)}`)),
+      body: bodyText,
+      phase: "response",
+      schema: options.schemaName,
+      issues: validation.issues
+    }
+  };
+}
+function encodeJsonBodyEffect(bodyObj, validator, options = {}) {
+  if (validator) {
+    const validation = _chunkCZIVE6NTcjs.validateValue.call(void 0, bodyObj, validator);
+    if (!validation.success) {
+      return _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, {
+        _tag: "ValidationError",
+        message: `JSON request body failed validation: ${_chunkCZIVE6NTcjs.formatIssues.call(void 0, validation.issues)}`,
+        body: previewJson(bodyObj),
+        phase: "request",
+        schema: options.schemaName,
+        issues: validation.issues
+      });
+    }
+  }
+  try {
+    return _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, JSON.stringify(_nullishCoalesce(bodyObj, () => ( {}))));
+  } catch (error) {
+    return _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, {
+      _tag: "ValidationError",
+      message: `JSON request body could not be serialized: ${error instanceof Error ? error.message : String(error)}`,
+      body: "",
+      phase: "request",
+      schema: options.schemaName,
+      issues: [
+        _chunkCZIVE6NTcjs.makeSchemaIssue.call(void 0, [], "JSON-serializable value", bodyObj, "Request body could not be serialized to JSON")
+      ]
+    });
+  }
+}
+function decodeJsonBodyEffect(bodyText, validator, options) {
+  const result = decodeJsonBody(bodyText, validator, options);
+  return result.success ? _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, result.data) : _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, result.error);
+}
+function validatedJson(client, validator) {
+  return (req) => _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
+    client(req),
+    (error) => _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, error),
+    (response) => decodeJsonBodyEffect(response.bodyText, validator)
+  );
+}
+function validatedJsonResponse(client, validator) {
+  return (req) => _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
+    client(req),
+    (error) => _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, error),
+    (response) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
+      decodeJsonBodyEffect(response.bodyText, validator),
+      (body) => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, { ...response, body })
+    )
+  );
+}
+function previewJson(value) {
+  try {
+    return JSON.stringify(value);
+  } catch (e2) {
+    return "[unserializable]";
+  }
+}
+
+// src/http/body.ts
+function httpBodyByteLength(body) {
+  if (body === void 0) return 0;
+  if (typeof body === "string") return Buffer.byteLength(body, "utf8");
+  if (body instanceof ArrayBuffer) return body.byteLength;
+  return body.byteLength;
+}
+function httpBodyToBuffer(body) {
+  if (typeof body === "string") return Buffer.from(body, "utf8");
+  if (body instanceof ArrayBuffer) return Buffer.from(body);
+  return Buffer.from(body);
+}
+function httpBodyKeyPart(body) {
+  if (body === void 0) return "";
+  if (typeof body === "string") return body;
+  return `base64:${httpBodyToBuffer(body).toString("base64")}`;
+}
+
+// src/http/lifecycle/cacheKey.ts
+var SEPARATOR = "\0";
+var DEFAULT_CACHE_RELEVANT_HEADERS = ["accept", "authorization", "content-type"];
+function computeCacheKey(req, baseUrl, extraHeaders = []) {
+  const method = req.method.toUpperCase();
+  const resolvedUrl = resolveKeyUrl(req.url, baseUrl);
+  const relevantSet = /* @__PURE__ */ new Set([
+    ...DEFAULT_CACHE_RELEVANT_HEADERS,
+    ...extraHeaders.map((h) => h.toLowerCase())
+  ]);
+  const headers = _nullishCoalesce(req.headers, () => ( {}));
+  const sortedHeaders = Object.keys(headers).filter((k) => relevantSet.has(k.toLowerCase())).sort().map((k) => `${k.toLowerCase()}:${headers[k]}`).join(",");
+  const body = httpBodyKeyPart(req.body);
+  return `${method}${SEPARATOR}${resolvedUrl}${SEPARATOR}${sortedHeaders}${SEPARATOR}${body}`;
+}
+function resolveKeyUrl(url, baseUrl) {
+  if (url.length > 0 && url.charCodeAt(0) === 47 && url.charCodeAt(1) !== 47 && baseUrl) {
+    const origin = absoluteOrigin(baseUrl);
+    if (origin) return `${origin}${url}`;
+  }
+  return new URL(url, baseUrl || void 0).toString();
+}
+function absoluteOrigin(url) {
+  const schemeIdx = url.indexOf("://");
+  if (schemeIdx <= 0) return void 0;
+  const authorityStart = schemeIdx + 3;
+  const pathIdx = url.indexOf("/", authorityStart);
+  return pathIdx === -1 ? url : url.slice(0, pathIdx);
+}
+function parseCacheKey(key) {
+  const [method, resolvedUrl, headersStr, ...bodyParts] = key.split(SEPARATOR);
+  const body = bodyParts.join(SEPARATOR);
+  const headers = {};
+  if (headersStr) {
+    for (const entry of headersStr.split(",")) {
+      const colonIdx = entry.indexOf(":");
+      if (colonIdx > 0) {
+        headers[entry.slice(0, colonIdx)] = entry.slice(colonIdx + 1);
+      }
+    }
+  }
+  return { method, resolvedUrl, headers, body };
+}
+
+// src/http/lifecycle/dedupKey.ts
+var HOP_BY_HOP = /* @__PURE__ */ new Set([
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+]);
+var SAFE_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
+function computeDedupKey(req, baseUrl) {
+  const method = req.method.toUpperCase();
+  const resolvedUrl = resolveKeyUrl(req.url, baseUrl);
+  const headers = _nullishCoalesce(req.headers, () => ( {}));
+  const sortedHeaders = Object.keys(headers).filter((k) => {
+    const lower = k.toLowerCase();
+    return !HOP_BY_HOP.has(lower) && lower !== "authorization";
+  }).sort().map((k) => `${k.toLowerCase()}:${headers[k]}`).join(",");
+  const body = httpBodyKeyPart(req.body);
+  return `${method}${SEPARATOR}${resolvedUrl}${SEPARATOR}${sortedHeaders}${SEPARATOR}${body}`;
+}
+
+// src/http/lifecycle/dedup.ts
+function safeEmit(onEvent, event) {
+  if (!onEvent) return;
+  try {
+    onEvent(event);
+  } catch (e3) {
+  }
+}
+function causeDefectMessage(cause) {
+  const defect = _chunkMVGUEJ5Zcjs.Cause.firstDefect(cause);
+  if (defect._tag === "Some") return String(defect.value);
+  return _chunkMVGUEJ5Zcjs.Cause.pretty(cause, { singleLine: true });
+}
+function withDedup(config) {
+  const inFlight = /* @__PURE__ */ new Map();
+  const customKeyFn = _optionalChain([config, 'optionalAccess', _ => _.dedupKey]);
+  const onEvent = _optionalChain([config, 'optionalAccess', _2 => _2.onEvent]);
+  return (next) => {
+    return (req) => {
+      if (!SAFE_METHODS.has(req.method.toUpperCase())) {
+        return next(req);
+      }
+      let key;
+      const policyKey = _chunk3LOYJFRRcjs.getHttpRequestPolicy.call(void 0, req).dedupKey;
+      if (policyKey !== void 0) {
+        key = policyKey;
+        if (!key) {
+          return next(req);
+        }
+      } else if (customKeyFn) {
+        try {
+          key = customKeyFn(req);
+        } catch (e4) {
+          return next(req);
+        }
+        if (!key) {
+          return next(req);
+        }
+      } else {
+        key = computeDedupKey(req, "");
+      }
+      return {
+        _tag: "Async",
+        register: (_env, cb) => {
+          const existing = inFlight.get(key);
+          let callerDone = false;
+          const finishCaller = (exit) => {
+            if (callerDone) return;
+            callerDone = true;
+            cb(exit);
+          };
+          if (existing) {
+            safeEmit(onEvent, { type: "dedup-hit", cacheKey: key });
+            existing.refCount++;
+            const waiter = {
+              resolve: (res) => {
+                finishCaller({ _tag: "Success", value: res });
+              },
+              reject: (err) => {
+                finishCaller({ _tag: "Failure", cause: _chunkMVGUEJ5Zcjs.Cause.fail(err) });
+              }
+            };
+            existing.waiters.push(waiter);
+            return () => {
+              if (callerDone) return;
+              existing.refCount--;
+              const idx = existing.waiters.indexOf(waiter);
+              if (idx >= 0) {
+                existing.waiters.splice(idx, 1);
+              }
+              if (existing.refCount <= 0) {
+                inFlight.delete(key);
+                safeEmit(onEvent, { type: "dedup-active", active: inFlight.size });
+                existing.controller.abort();
+              }
+              finishCaller({ _tag: "Failure", cause: _chunkMVGUEJ5Zcjs.Cause.interrupt() });
+            };
+          }
+          safeEmit(onEvent, { type: "dedup-miss", cacheKey: key });
+          const controller = new AbortController();
+          const entry = {
+            key,
+            controller,
+            refCount: 1,
+            waiters: []
+          };
+          inFlight.set(key, entry);
+          safeEmit(onEvent, { type: "dedup-active", active: inFlight.size });
+          const dedupReq = {
+            ...req,
+            init: {
+              ..._nullishCoalesce(req.init, () => ( {})),
+              signal: controller.signal
+            }
+          };
+          const innerEffect = next(dedupReq);
+          const innerCancel = _chunkL6VB5N7Qcjs.registerHttpEffect.call(void 0, innerEffect, _env, (exit) => {
+            inFlight.delete(key);
+            safeEmit(onEvent, { type: "dedup-active", active: inFlight.size });
+            if (exit._tag === "Success") {
+              resolveAll(entry, exit.value);
+              finishCaller(exit);
+              return;
+            }
+            if (_chunkMVGUEJ5Zcjs.Cause.isInterruptedOnly(exit.cause)) {
+              rejectAll(entry, { _tag: "Abort" });
+              finishCaller({ _tag: "Failure", cause: _chunkMVGUEJ5Zcjs.Cause.interrupt() });
+              return;
+            }
+            const failure = _chunkMVGUEJ5Zcjs.Cause.firstFailure(exit.cause);
+            if (failure._tag === "Some") {
+              rejectAll(entry, failure.value);
+              finishCaller(exit);
+              return;
+            }
+            const err = { _tag: "FetchError", message: causeDefectMessage(exit.cause) };
+            rejectAll(entry, err);
+            finishCaller({ _tag: "Failure", cause: _chunkMVGUEJ5Zcjs.Cause.fail(err) });
+          });
+          return () => {
+            if (callerDone) return;
+            entry.refCount--;
+            if (entry.refCount <= 0) {
+              inFlight.delete(key);
+              safeEmit(onEvent, { type: "dedup-active", active: inFlight.size });
+              controller.abort();
+              if (innerCancel) {
+                innerCancel();
+              }
+            }
+            finishCaller({ _tag: "Failure", cause: _chunkMVGUEJ5Zcjs.Cause.interrupt() });
+          };
+        }
+      };
+    };
+  };
+}
+function resolveAll(entry, res) {
+  const waiters = entry.waiters.slice();
+  for (const w of waiters) {
+    w.resolve(res);
+  }
+}
+function rejectAll(entry, err) {
+  const waiters = entry.waiters.slice();
+  for (const w of waiters) {
+    w.reject(err);
+  }
+}
+
+// src/http/lifecycle/batch.ts
+function clamp(value, min, max) {
+  if (!Number.isFinite(value)) return min;
+  return Math.max(min, Math.min(max, Math.floor(value)));
+}
+function safeEmitBatch(onEvent, event) {
+  if (!onEvent) return;
+  try {
+    onEvent(event);
+  } catch (e5) {
+  }
+}
+function causeDefectMessage2(cause) {
+  const defect = _chunkMVGUEJ5Zcjs.Cause.firstDefect(cause);
+  if (defect._tag === "Some") return String(defect.value);
+  return _chunkMVGUEJ5Zcjs.Cause.pretty(cause, { singleLine: true });
+}
+function withBatch(config, onEvent) {
+  const windowMs = clamp(config.windowMs, 1, 5e3);
+  const maxBatchSize = clamp(config.maxBatchSize, 2, 1e4);
+  const { batch, batchKey } = config;
+  const groups = /* @__PURE__ */ new Map();
+  return (next) => {
+    function dispatch(group) {
+      group.dispatched = true;
+      if (group.timer !== null) {
+        clearTimeout(group.timer);
+        group.timer = null;
+      }
+      groups.delete(group.key);
+      const requests = group.waiters.map((w) => w.request);
+      const waiterCount = group.waiters.length;
+      let coalescedReq;
+      try {
+        coalescedReq = batch.coalesce(requests);
+      } catch (err) {
+        const error = { _tag: "FetchError", message: String(err) };
+        rejectAllWaiters(group, error);
+        return;
+      }
+      coalescedReq = {
+        ...coalescedReq,
+        init: {
+          ..._nullishCoalesce(coalescedReq.init, () => ( {})),
+          signal: group.controller.signal
+        }
+      };
+      safeEmitBatch(onEvent, { type: "batch-dispatch", batchKey: group.key, batchSize: waiterCount });
+      const innerEffect = next(coalescedReq);
+      _chunkL6VB5N7Qcjs.registerHttpEffect.call(void 0, innerEffect, void 0, (exit) => {
+        if (exit._tag === "Success") {
+          let responses;
+          try {
+            responses = batch.split(exit.value, requests);
+          } catch (err2) {
+            const error = { _tag: "FetchError", message: String(err2) };
+            rejectAllWaiters(group, error);
+            return;
+          }
+          if (responses.length !== waiterCount) {
+            const error = {
+              _tag: "BatchSplitError",
+              expected: waiterCount,
+              actual: responses.length,
+              message: `split returned ${responses.length} responses but expected ${waiterCount}`
+            };
+            rejectAllWaiters(group, error);
+            return;
+          }
+          const waiters = group.waiters.slice();
+          for (let i = 0; i < waiters.length; i++) {
+            waiters[i].resolve(responses[i]);
+          }
+          return;
+        }
+        const failure = _chunkMVGUEJ5Zcjs.Cause.firstFailure(exit.cause);
+        if (failure._tag === "Some") {
+          rejectAllWaiters(group, failure.value);
+          return;
+        }
+        if (_chunkMVGUEJ5Zcjs.Cause.isInterruptedOnly(exit.cause)) {
+          rejectAllWaiters(group, { _tag: "Abort" });
+          return;
+        }
+        const err = { _tag: "FetchError", message: causeDefectMessage2(exit.cause) };
+        rejectAllWaiters(group, err);
+      });
+    }
+    return (req) => {
+      let key;
+      try {
+        key = batchKey(req);
+      } catch (e6) {
+        return next(req);
+      }
+      if (!key) {
+        return next(req);
+      }
+      return {
+        _tag: "Async",
+        register: (_env, cb) => {
+          let callerDone = false;
+          const finishCaller = (exit) => {
+            if (callerDone) return;
+            callerDone = true;
+            cb(exit);
+          };
+          const waiter = {
+            request: req,
+            resolve: (res) => {
+              finishCaller({ _tag: "Success", value: res });
+            },
+            reject: (err) => {
+              finishCaller({ _tag: "Failure", cause: _chunkMVGUEJ5Zcjs.Cause.fail(err) });
+            }
+          };
+          const existing = groups.get(key);
+          if (existing && !existing.dispatched) {
+            existing.waiters.push(waiter);
+            safeEmitBatch(onEvent, { type: "batch-hit", batchKey: key });
+            if (existing.waiters.length >= maxBatchSize) {
+              dispatch(existing);
+            }
+            return () => {
+              if (callerDone) return;
+              const idx = existing.waiters.indexOf(waiter);
+              if (idx >= 0) {
+                existing.waiters.splice(idx, 1);
+              }
+              if (existing.waiters.length === 0 && !existing.dispatched) {
+                if (existing.timer !== null) {
+                  clearTimeout(existing.timer);
+                  existing.timer = null;
+                }
+                groups.delete(key);
+              }
+              if (existing.waiters.length === 0 && existing.dispatched) {
+                existing.controller.abort();
+              }
+              finishCaller({ _tag: "Failure", cause: _chunkMVGUEJ5Zcjs.Cause.interrupt() });
+            };
+          }
+          const controller = new AbortController();
+          const group = {
+            key,
+            controller,
+            waiters: [waiter],
+            timer: null,
+            dispatched: false
+          };
+          group.timer = setTimeout(() => {
+            if (!group.dispatched && group.waiters.length > 0) {
+              dispatch(group);
+            }
+          }, windowMs);
+          groups.set(key, group);
+          return () => {
+            if (callerDone) return;
+            const idx = group.waiters.indexOf(waiter);
+            if (idx >= 0) {
+              group.waiters.splice(idx, 1);
+            }
+            if (group.waiters.length === 0 && !group.dispatched) {
+              if (group.timer !== null) {
+                clearTimeout(group.timer);
+                group.timer = null;
+              }
+              groups.delete(key);
+            }
+            if (group.waiters.length === 0 && group.dispatched) {
+              group.controller.abort();
+            }
+            finishCaller({ _tag: "Failure", cause: _chunkMVGUEJ5Zcjs.Cause.interrupt() });
+          };
+        }
+      };
+    };
+  };
+}
+function rejectAllWaiters(group, err) {
+  const waiters = group.waiters.slice();
+  for (const w of waiters) {
+    w.reject(err);
+  }
+}
+
+// src/http/lifecycle/timing.ts
+var now = typeof performance !== "undefined" && typeof performance.now === "function" ? () => performance.now() : () => Date.now();
+
+// src/http/lifecycle/lruCache.ts
+function isExpired(node) {
+  return now() - node.storedAt >= node.ttlMs;
+}
+var LRUCache = (_class = class {
+  __init() {this.map = /* @__PURE__ */ new Map()}
+  __init2() {this.head = null}
+  __init3() {this.tail = null}
+  
+  
+  /**
+   * Creates a new LRU cache instance.
+   *
+   * @param config - Cache configuration options.
+   * @param config.maxEntries - Maximum number of entries. Must be >= 1. Default: 1024.
+   * @param config.onEvict - Optional eviction callback.
+   *
+   * @example
+   * ```typescript
+   * import { LRUCache } from "./lruCache";
+   *
+   * const cache = new LRUCache<number>({ maxEntries: 50 });
+   * ```
+   */
+  constructor(config = {}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);
+    const max = _nullishCoalesce(config.maxEntries, () => ( 1024));
+    this.maxEntries = Math.max(1, Math.floor(max));
+    this.onEvict = config.onEvict;
+  }
+  /**
+   * Returns the number of entries currently in the cache.
+   *
+   * @returns The current entry count.
+   *
+   * @example
+   * ```typescript
+   * import { LRUCache } from "./lruCache";
+   *
+   * const cache = new LRUCache<string>();
+   * cache.set("a", "1", 10_000);
+   * console.log(cache.size); // 1
+   * ```
+   */
+  get size() {
+    return this.map.size;
+  }
+  /**
+   * Retrieves a value by key.
+   *
+   * Returns `undefined` if the key is not found or the entry has expired.
+   * On a hit (non-expired), the entry is moved to the head (most recently used).
+   * Expired entries are lazily removed on access.
+   *
+   * @param key - The cache key to look up.
+   * @returns The cached value, or `undefined` if not found or expired.
+   *
+   * @example
+   * ```typescript
+   * import { LRUCache } from "./lruCache";
+   *
+   * const cache = new LRUCache<string>();
+   * cache.set("greeting", "hello", 30_000);
+   * const val = cache.get("greeting"); // "hello"
+   * const miss = cache.get("unknown"); // undefined
+   * ```
+   */
+  get(key) {
+    const node = this.map.get(key);
+    if (!node) return void 0;
+    if (isExpired(node)) {
+      this.removeNode(node);
+      this.map.delete(key);
+      return void 0;
+    }
+    this.moveToHead(node);
+    return node.value;
+  }
+  /**
+   * Inserts or updates an entry in the cache.
+   *
+   * If the key already exists, the value and TTL are updated and the entry is
+   * moved to the head. If inserting a new entry causes the cache to exceed
+   * `maxEntries` (must be >= 1), the least recently used entry is evicted.
+   *
+   * @param key - The cache key.
+   * @param value - The value to store.
+   * @param ttlMs - Time-to-live in milliseconds. The entry expires after this duration.
+   *
+   * @example
+   * ```typescript
+   * import { LRUCache } from "./lruCache";
+   *
+   * const cache = new LRUCache<string>({ maxEntries: 2 });
+   * cache.set("a", "alpha", 60_000);
+   * cache.set("b", "beta", 60_000);
+   * cache.set("c", "gamma", 60_000); // evicts "a" (LRU)
+   * ```
+   */
+  set(key, value, ttlMs) {
+    const existing = this.map.get(key);
+    if (existing) {
+      existing.value = value;
+      existing.storedAt = now();
+      existing.ttlMs = ttlMs;
+      this.moveToHead(existing);
+      return;
+    }
+    const node = {
+      key,
+      value,
+      storedAt: now(),
+      ttlMs,
+      prev: null,
+      next: null
+    };
+    this.map.set(key, node);
+    this.addToHead(node);
+    if (this.map.size > this.maxEntries) {
+      this.evictTail();
+    }
+  }
+  /**
+   * Removes an entry by key.
+   *
+   * @param key - The cache key to remove.
+   * @returns `true` if the entry was found and removed, `false` otherwise.
+   *
+   * @example
+   * ```typescript
+   * import { LRUCache } from "./lruCache";
+   *
+   * const cache = new LRUCache<string>();
+   * cache.set("x", "value", 10_000);
+   * cache.delete("x"); // true
+   * cache.delete("x"); // false (already removed)
+   * ```
+   */
+  delete(key) {
+    const node = this.map.get(key);
+    if (!node) return false;
+    this.removeNode(node);
+    this.map.delete(key);
+    return true;
+  }
+  /**
+   * Removes all entries from the cache, resetting it to an empty state.
+   *
+   * @example
+   * ```typescript
+   * import { LRUCache } from "./lruCache";
+   *
+   * const cache = new LRUCache<string>();
+   * cache.set("a", "1", 10_000);
+   * cache.clear();
+   * console.log(cache.size); // 0
+   * ```
+   */
+  clear() {
+    this.map.clear();
+    this.head = null;
+    this.tail = null;
+  }
+  // --- Doubly-linked list operations ---
+  /** Adds a node to the head of the list (most recently used position). */
+  addToHead(node) {
+    node.prev = null;
+    node.next = this.head;
+    if (this.head) {
+      this.head.prev = node;
+    }
+    this.head = node;
+    if (!this.tail) {
+      this.tail = node;
+    }
+  }
+  /** Removes a node from its current position in the list. */
+  removeNode(node) {
+    if (node.prev) {
+      node.prev.next = node.next;
+    } else {
+      this.head = node.next;
+    }
+    if (node.next) {
+      node.next.prev = node.prev;
+    } else {
+      this.tail = node.prev;
+    }
+    node.prev = null;
+    node.next = null;
+  }
+  /** Moves an existing node to the head of the list. */
+  moveToHead(node) {
+    if (this.head === node) return;
+    this.removeNode(node);
+    this.addToHead(node);
+  }
+  /** Evicts the tail node (least recently used) and notifies via callback. */
+  evictTail() {
+    if (!this.tail) return;
+    const evicted = this.tail;
+    this.removeNode(evicted);
+    this.map.delete(evicted.key);
+    if (this.onEvict) {
+      this.onEvict(1);
+    }
+  }
+}, _class);
+
+// src/http/lifecycle/responseCache.ts
+function clamp2(n, min, max) {
+  return Math.max(min, Math.min(max, n));
+}
+function safeEmit2(onEvent, event) {
+  if (!onEvent) return;
+  try {
+    onEvent(event);
+  } catch (e7) {
+  }
+}
+function withCache(config) {
+  const ttlSeconds = clamp2(_nullishCoalesce(_optionalChain([config, 'optionalAccess', _3 => _3.ttlSeconds]), () => ( 60)), 1, 86400);
+  const ttlMs = ttlSeconds * 1e3;
+  const maxEntries = Math.max(1, Math.floor(_nullishCoalesce(_optionalChain([config, 'optionalAccess', _4 => _4.maxEntries]), () => ( 1024))));
+  const staleWhileRevalidate = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _5 => _5.staleWhileRevalidate]), () => ( false));
+  const cachePolicy = _optionalChain([config, 'optionalAccess', _6 => _6.cachePolicy]);
+  const cacheRelevantHeaders = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _7 => _7.cacheRelevantHeaders]), () => ( []));
+  const baseUrl = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _8 => _8.baseUrl]), () => ( ""));
+  const onEvent = _optionalChain([config, 'optionalAccess', _9 => _9.onEvent]);
+  const onLifecycleEvent = _optionalChain([config, 'optionalAccess', _10 => _10.onLifecycleEvent]);
+  const cache = new LRUCache({
+    maxEntries,
+    onEvict: (count) => _optionalChain([onLifecycleEvent, 'optionalCall', _11 => _11({ type: "cache-eviction", count })])
+  });
+  const revalidating = /* @__PURE__ */ new Set();
+  const invalidate = (key) => {
+    cache.delete(key);
+  };
+  const clear = () => {
+    cache.clear();
+  };
+  const middleware = (next) => {
+    return (req) => {
+      const method = req.method.toUpperCase();
+      if (!SAFE_METHODS.has(method) && !cachePolicy) {
+        return next(req);
+      }
+      const key = computeCacheKey(req, baseUrl, cacheRelevantHeaders);
+      return {
+        _tag: "Async",
+        register: (env, cb) => {
+          const cached = cache.get(key);
+          if (cached !== void 0) {
+            _optionalChain([onLifecycleEvent, 'optionalCall', _12 => _12({ type: "cache-hit", cacheKey: key })]);
+            cb({ _tag: "Success", value: cached });
+            return;
+          }
+          _optionalChain([onLifecycleEvent, 'optionalCall', _13 => _13({ type: "cache-miss", cacheKey: key })]);
+          const innerEffect = next(req);
+          return _chunkL6VB5N7Qcjs.registerHttpEffect.call(void 0, innerEffect, env, (exit) => {
+            if (exit._tag === "Success") {
+              storeIfCacheable(req, exit.value, key);
+            }
+            cb(exit);
+          });
+        }
+      };
+    };
+  };
+  function storeIfCacheable(req, res, key) {
+    const method = req.method.toUpperCase();
+    if (cachePolicy) {
+      const result = cachePolicy(req, res);
+      if (!result.cacheable) return;
+      const entryTtlMs = result.ttlSeconds !== void 0 ? clamp2(result.ttlSeconds, 1, 86400) * 1e3 : ttlMs;
+      cache.set(key, res, entryTtlMs);
+      return;
+    }
+    if (!SAFE_METHODS.has(method)) return;
+    cache.set(key, res, ttlMs);
+  }
+  function triggerRevalidation(next, req, key) {
+    if (revalidating.has(key)) return;
+    revalidating.add(key);
+    const innerEffect = next(req);
+    const handleExit = (exit) => {
+      revalidating.delete(key);
+      if (exit._tag === "Success") {
+        storeIfCacheable(req, exit.value, key);
+      } else {
+        safeEmit2(onEvent, {
+          type: "revalidation-failure",
+          cacheKey: key,
+          error: _chunkMVGUEJ5Zcjs.Cause.squash(exit.cause)
+        });
+      }
+    };
+    _chunkL6VB5N7Qcjs.registerHttpEffect.call(void 0, innerEffect, void 0, handleExit);
+  }
+  const expirationMap = /* @__PURE__ */ new Map();
+  const swrMiddleware = (next) => {
+    return (req) => {
+      const method = req.method.toUpperCase();
+      if (!SAFE_METHODS.has(method) && !cachePolicy) {
+        return next(req);
+      }
+      const key = computeCacheKey(req, baseUrl, cacheRelevantHeaders);
+      return {
+        _tag: "Async",
+        register: (env, cb) => {
+          const cached = cache.get(key);
+          if (cached !== void 0) {
+            const expiresAt = expirationMap.get(key);
+            if (expiresAt !== void 0 && now() < expiresAt) {
+              _optionalChain([onLifecycleEvent, 'optionalCall', _14 => _14({ type: "cache-hit", cacheKey: key })]);
+              cb({ _tag: "Success", value: cached });
+              return;
+            }
+            _optionalChain([onLifecycleEvent, 'optionalCall', _15 => _15({ type: "cache-hit", cacheKey: key })]);
+            cb({ _tag: "Success", value: cached });
+            triggerRevalidation(next, req, key);
+            return;
+          }
+          _optionalChain([onLifecycleEvent, 'optionalCall', _16 => _16({ type: "cache-miss", cacheKey: key })]);
+          const innerEffect = next(req);
+          const handleSuccess = (res) => {
+            swrStoreIfCacheable(req, res, key);
+          };
+          return _chunkL6VB5N7Qcjs.registerHttpEffect.call(void 0, innerEffect, env, (exit) => {
+            if (exit._tag === "Success") {
+              handleSuccess(exit.value);
+            }
+            cb(exit);
+          });
+        }
+      };
+    };
+  };
+  function swrStoreIfCacheable(req, res, key) {
+    const method = req.method.toUpperCase();
+    let entryTtlMs = ttlMs;
+    if (cachePolicy) {
+      const result = cachePolicy(req, res);
+      if (!result.cacheable) return;
+      entryTtlMs = result.ttlSeconds !== void 0 ? clamp2(result.ttlSeconds, 1, 86400) * 1e3 : ttlMs;
+    } else if (!SAFE_METHODS.has(method)) {
+      return;
+    }
+    const lruTtl = Number.MAX_SAFE_INTEGER;
+    cache.set(key, res, lruTtl);
+    expirationMap.set(key, now() + entryTtlMs);
+  }
+  const swrInvalidate = (key) => {
+    cache.delete(key);
+    expirationMap.delete(key);
+  };
+  const swrClear = () => {
+    cache.clear();
+    expirationMap.clear();
+  };
+  if (staleWhileRevalidate) {
+    return {
+      middleware: swrMiddleware,
+      invalidate: swrInvalidate,
+      clear: swrClear
+    };
+  }
+  return {
+    middleware,
+    invalidate,
+    clear
+  };
+}
+
+// src/http/lifecycle/priorityQueue.ts
+function clampPriority(value) {
+  if (value === void 0 || !Number.isFinite(value)) return 5;
+  return Math.max(0, Math.min(9, Math.trunc(value)));
+}
+function comparePriority(a, b) {
+  if (a.priority !== b.priority) return a.priority - b.priority;
+  return a.arrivalOrder - b.arrivalOrder;
+}
+var PriorityQueue = (_class2 = class {constructor() { _class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this); }
+  __init4() {this.heap = []}
+  __init5() {this.counter = 0}
+  /**
+   * Returns the number of entries in the queue (including cancelled entries).
+   *
+   * @returns The total number of entries in the internal heap.
+   *
+   * @example
+   * ```typescript
+   * import { PriorityQueue } from "./priorityQueue";
+   *
+   * const queue = new PriorityQueue<string>();
+   * queue.enqueue("task", 5);
+   * console.log(queue.size); // 1
+   * ```
+   */
+  get size() {
+    return this.heap.length;
+  }
+  /** Returns the number of entries that have not been cancelled. */
+  get activeSize() {
+    return this.heap.reduce((n, entry) => n + (entry.cancelled ? 0 : 1), 0);
+  }
+  /**
+   * Adds a value to the queue with the given priority.
+   *
+   * Priority is clamped to the valid range [0, 9] via `clampPriority`.
+   * Returns the created entry, which can be used for later cancellation
+   * by setting `entry.cancelled = true`.
+   *
+   * @param value - The value to enqueue.
+   * @param priority - Priority level, integer from 0 (highest) to 9 (lowest).
+   *   Clamped to [0, 9]. Defaults to 5 if undefined.
+   * @returns The created queue entry.
+   *
+   * @example
+   * ```typescript
+   * import { PriorityQueue } from "./priorityQueue";
+   *
+   * const queue = new PriorityQueue<string>();
+   * const entry = queue.enqueue("urgent-task", 0);
+   * entry.cancelled = true; // cancel later if needed
+   * ```
+   */
+  enqueue(value, priority) {
+    const entry = {
+      priority: clampPriority(priority),
+      arrivalOrder: this.counter++,
+      value,
+      cancelled: false
+    };
+    this.heap.push(entry);
+    this.bubbleUp(this.heap.length - 1);
+    return entry;
+  }
+  /**
+   * Removes and returns the highest-priority non-cancelled entry.
+   *
+   * Skips (and discards) any cancelled entries at the top of the heap.
+   * Returns `undefined` if the queue is empty or all entries are cancelled.
+   *
+   * @returns The highest-priority non-cancelled entry, or `undefined` if none available.
+   *
+   * @example
+   * ```typescript
+   * import { PriorityQueue } from "./priorityQueue";
+   *
+   * const queue = new PriorityQueue<string>();
+   * queue.enqueue("first", 1);
+   * queue.enqueue("second", 2);
+   * const entry = queue.dequeue(); // { value: "first", priority: 1, ... }
+   * ```
+   */
+  dequeue() {
+    while (this.heap.length > 0) {
+      const top = this.heap[0];
+      if (top.cancelled) {
+        this.removeTop();
+        continue;
+      }
+      this.removeTop();
+      return top;
+    }
+    return void 0;
+  }
+  /**
+   * Returns the highest-priority non-cancelled entry without removing it.
+   *
+   * Discards cancelled entries at the top of the heap as a side effect.
+   * Returns `undefined` if the queue is empty or all entries are cancelled.
+   *
+   * @returns The highest-priority non-cancelled entry, or `undefined` if none available.
+   *
+   * @example
+   * ```typescript
+   * import { PriorityQueue } from "./priorityQueue";
+   *
+   * const queue = new PriorityQueue<string>();
+   * queue.enqueue("task", 3);
+   * const top = queue.peek(); // { value: "task", priority: 3, ... }
+   * console.log(queue.size);  // 1 (not removed)
+   * ```
+   */
+  peek() {
+    while (this.heap.length > 0) {
+      const top = this.heap[0];
+      if (top.cancelled) {
+        this.removeTop();
+        continue;
+      }
+      return top;
+    }
+    return void 0;
+  }
+  /**
+   * Marks all entries matching the predicate as cancelled (lazy removal).
+   *
+   * Cancelled entries are skipped on subsequent dequeue/peek calls.
+   * This does not immediately remove entries from the heap; they are
+   * discarded lazily when encountered at the top during dequeue or peek.
+   *
+   * @param predicate - A function that returns `true` for entries to cancel.
+   * @returns The number of entries marked as cancelled.
+   *
+   * @example
+   * ```typescript
+   * import { PriorityQueue } from "./priorityQueue";
+   *
+   * const queue = new PriorityQueue<string>();
+   * queue.enqueue("a", 1);
+   * queue.enqueue("b", 2);
+   * const removed = queue.remove((e) => e.value === "a"); // 1
+   * ```
+   */
+  remove(predicate) {
+    let count = 0;
+    for (const entry of this.heap) {
+      if (!entry.cancelled && predicate(entry)) {
+        entry.cancelled = true;
+        count++;
+      }
+    }
+    return count;
+  }
+  // --- Binary heap operations ---
+  /** Removes the top element from the heap and restores heap property. */
+  removeTop() {
+    const last = this.heap.pop();
+    if (this.heap.length > 0 && last !== void 0) {
+      this.heap[0] = last;
+      this.sinkDown(0);
+    }
+  }
+  /** Moves an element up the heap until the heap property is restored. */
+  bubbleUp(index) {
+    while (index > 0) {
+      const parentIndex = index - 1 >>> 1;
+      const current = this.heap[index];
+      const parent = this.heap[parentIndex];
+      if (comparePriority(current, parent) >= 0) break;
+      this.heap[index] = parent;
+      this.heap[parentIndex] = current;
+      index = parentIndex;
+    }
+  }
+  /** Moves an element down the heap until the heap property is restored. */
+  sinkDown(index) {
+    const length = this.heap.length;
+    while (true) {
+      const leftIndex = 2 * index + 1;
+      const rightIndex = 2 * index + 2;
+      let smallest = index;
+      if (leftIndex < length && comparePriority(this.heap[leftIndex], this.heap[smallest]) < 0) {
+        smallest = leftIndex;
+      }
+      if (rightIndex < length && comparePriority(this.heap[rightIndex], this.heap[smallest]) < 0) {
+        smallest = rightIndex;
+      }
+      if (smallest === index) break;
+      const temp = this.heap[index];
+      this.heap[index] = this.heap[smallest];
+      this.heap[smallest] = temp;
+      index = smallest;
+    }
+  }
+}, _class2);
+
+// src/http/lifecycle/priorityScheduler.ts
+var DEFAULT_CONCURRENCY = 32;
+function extractPriority(req) {
+  const fromPolicy = _chunk3LOYJFRRcjs.getHttpRequestPolicy.call(void 0, req).priority;
+  if (fromPolicy !== void 0) return clampPriority(fromPolicy);
+  const fromInit = _optionalChain([req, 'access', _17 => _17.init, 'optionalAccess', _18 => _18.priority]);
+  if (fromInit !== void 0) return clampPriority(fromInit);
+  return 5;
+}
+function safeEmit3(onEvent, event) {
+  if (!onEvent) return;
+  try {
+    onEvent(event);
+  } catch (e8) {
+  }
+}
+function withPriority(config) {
+  const concurrency = resolveConcurrency(_optionalChain([config, 'optionalAccess', _19 => _19.concurrency]));
+  const queueTimeoutMs = resolveQueueTimeout(_optionalChain([config, 'optionalAccess', _20 => _20.queueTimeoutMs]));
+  const onEvent = _optionalChain([config, 'optionalAccess', _21 => _21.onEvent]);
+  const queue = new PriorityQueue();
+  let inFlight = 0;
+  const queueDepth = () => {
+    return queue.activeSize;
+  };
+  const middleware = (next) => {
+    return (req) => {
+      const priority = extractPriority(req);
+      return {
+        _tag: "Async",
+        register: (env, cb) => {
+          if (inFlight < concurrency) {
+            return dispatchRequest(next, req, env, cb);
+          }
+          const queued = { req, env, cb, signal: getSignal(req) };
+          const entry = queue.enqueue(queued, priority);
+          safeEmit3(onEvent, { type: "queue-enqueue", priority });
+          if (queueTimeoutMs !== void 0) {
+            queued.timer = setTimeout(() => {
+              entry.cancelled = true;
+              queued.timer = void 0;
+              cb({
+                _tag: "Failure",
+                cause: _chunkMVGUEJ5Zcjs.Cause.fail({
+                  _tag: "PoolTimeout",
+                  key: "priority",
+                  timeoutMs: queueTimeoutMs,
+                  message: `Priority queue did not dispatch within ${queueTimeoutMs}ms`
+                })
+              });
+            }, queueTimeoutMs);
+          }
+          const signal = queued.signal;
+          let abortHandler;
+          if (signal && !signal.aborted) {
+            abortHandler = () => {
+              entry.cancelled = true;
+              if (queued.timer !== void 0) {
+                clearTimeout(queued.timer);
+                queued.timer = void 0;
+              }
+              cb({ _tag: "Failure", cause: _chunkMVGUEJ5Zcjs.Cause.fail({ _tag: "Abort" }) });
+            };
+            signal.addEventListener("abort", abortHandler, { once: true });
+          } else if (_optionalChain([signal, 'optionalAccess', _22 => _22.aborted])) {
+            entry.cancelled = true;
+            cb({ _tag: "Failure", cause: _chunkMVGUEJ5Zcjs.Cause.fail({ _tag: "Abort" }) });
+            return;
+          }
+          return () => {
+            entry.cancelled = true;
+            if (queued.timer !== void 0) {
+              clearTimeout(queued.timer);
+              queued.timer = void 0;
+            }
+            if (abortHandler && signal) {
+              signal.removeEventListener("abort", abortHandler);
+            }
+            cb({ _tag: "Failure", cause: _chunkMVGUEJ5Zcjs.Cause.interrupt() });
+          };
+        }
+      };
+    };
+    function dispatchRequest(downstream, req, env, cb) {
+      inFlight++;
+      safeEmit3(onEvent, { type: "queue-dispatch", priority: extractPriority(req) });
+      const innerEffect = downstream(req);
+      let completed = false;
+      const onComplete = (exit) => {
+        if (completed) return;
+        completed = true;
+        inFlight--;
+        cb(exit);
+        drainNext(downstream);
+      };
+      const innerCancel = _chunkL6VB5N7Qcjs.registerHttpEffect.call(void 0, innerEffect, env, onComplete);
+      return () => {
+        innerCancel();
+      };
+    }
+    function drainNext(downstream) {
+      while (inFlight < concurrency) {
+        const entry = queue.dequeue();
+        if (!entry) break;
+        if (entry.cancelled) continue;
+        const queued = entry.value;
+        if (queued.timer !== void 0) {
+          clearTimeout(queued.timer);
+          queued.timer = void 0;
+        }
+        if (_optionalChain([queued, 'access', _23 => _23.signal, 'optionalAccess', _24 => _24.aborted])) {
+          queued.cb({ _tag: "Failure", cause: _chunkMVGUEJ5Zcjs.Cause.fail({ _tag: "Abort" }) });
+          continue;
+        }
+        dispatchRequest(downstream, queued.req, queued.env, queued.cb);
+      }
+    }
+  };
+  return Object.assign(middleware, { queueDepth });
+}
+function resolveConcurrency(value) {
+  if (value === void 0 || !Number.isFinite(value)) return DEFAULT_CONCURRENCY;
+  return Math.max(1, Math.floor(value));
+}
+function resolveQueueTimeout(value) {
+  if (value === void 0 || !Number.isFinite(value)) return void 0;
+  const n = Math.floor(value);
+  return n > 0 ? n : void 0;
+}
+function getSignal(req) {
+  return _optionalChain([req, 'access', _25 => _25.init, 'optionalAccess', _26 => _26.signal]);
+}
+
+// src/http/lifecycle/stats.ts
+var LifecycleStatsTracker = (_class3 = class {
+  __init6() {this._cacheHits = 0}
+  __init7() {this._cacheMisses = 0}
+  __init8() {this._cacheEvictions = 0}
+  __init9() {this._dedupHits = 0}
+  __init10() {this._dedupActive = 0}
+  __init11() {this._queueDepth = 0}
+  __init12() {this._requestsStarted = 0}
+  __init13() {this._requestsCompleted = 0}
+  __init14() {this._requestsFailed = 0}
+  __init15() {this._retries = 0}
+  __init16() {this._batchDispatches = 0}
+  __init17() {this._batchedRequests = 0}
+  
+  
+  /**
+   * Creates a new lifecycle stats tracker.
+   *
+   * @param opts - Configuration options for the tracker.
+   * @param opts.onEvent - Optional callback invoked on each lifecycle event.
+   *   Errors thrown by this callback are silently discarded.
+   * @param opts.wireStats - A function returning the current wire-level HTTP client stats.
+   *
+   * @example
+   * ```typescript
+   * import { LifecycleStatsTracker } from "./stats";
+   *
+   * const tracker = new LifecycleStatsTracker({
+   *   wireStats: () => ({ requestCount: 0, errorCount: 0 }),
+   * });
+   * ```
+   */
+  constructor(opts) {;_class3.prototype.__init6.call(this);_class3.prototype.__init7.call(this);_class3.prototype.__init8.call(this);_class3.prototype.__init9.call(this);_class3.prototype.__init10.call(this);_class3.prototype.__init11.call(this);_class3.prototype.__init12.call(this);_class3.prototype.__init13.call(this);_class3.prototype.__init14.call(this);_class3.prototype.__init15.call(this);_class3.prototype.__init16.call(this);_class3.prototype.__init17.call(this);
+    this._onEvent = opts.onEvent;
+    this._wireStats = opts.wireStats;
+  }
+  // --- Increment methods ---
+  /**
+   * Records a cache hit. Increments the cache hit counter by 1.
+   *
+   * @example
+   * ```typescript
+   * import { LifecycleStatsTracker } from "./stats";
+   *
+   * const tracker = new LifecycleStatsTracker({ wireStats: () => ({ requestCount: 0, errorCount: 0 }) });
+   * tracker.cacheHit();
+   * ```
+   */
+  cacheHit() {
+    this._cacheHits++;
+  }
+  /**
+   * Records a cache miss. Increments the cache miss counter by 1.
+   *
+   * @example
+   * ```typescript
+   * import { LifecycleStatsTracker } from "./stats";
+   *
+   * const tracker = new LifecycleStatsTracker({ wireStats: () => ({ requestCount: 0, errorCount: 0 }) });
+   * tracker.cacheMiss();
+   * ```
+   */
+  cacheMiss() {
+    this._cacheMisses++;
+  }
+  /**
+   * Records a cache eviction. Increments the cache eviction counter by 1.
+   *
+   * @example
+   * ```typescript
+   * import { LifecycleStatsTracker } from "./stats";
+   *
+   * const tracker = new LifecycleStatsTracker({ wireStats: () => ({ requestCount: 0, errorCount: 0 }) });
+   * tracker.cacheEviction();
+   * ```
+   */
+  cacheEviction() {
+    this._cacheEvictions++;
+  }
+  /**
+   * Records a dedup hit (a request that joined an in-flight duplicate).
+   * Increments the dedup hit counter by 1.
+   *
+   * @example
+   * ```typescript
+   * import { LifecycleStatsTracker } from "./stats";
+   *
+   * const tracker = new LifecycleStatsTracker({ wireStats: () => ({ requestCount: 0, errorCount: 0 }) });
+   * tracker.dedupHit();
+   * ```
+   */
+  dedupHit() {
+    this._dedupHits++;
+  }
+  /**
+   * Sets the current number of active dedup groups.
+   *
+   * @param n - The current count of active dedup groups. Must be >= 0.
+   *
+   * @example
+   * ```typescript
+   * import { LifecycleStatsTracker } from "./stats";
+   *
+   * const tracker = new LifecycleStatsTracker({ wireStats: () => ({ requestCount: 0, errorCount: 0 }) });
+   * tracker.setDedupActive(3);
+   * ```
+   */
+  setDedupActive(n) {
+    this._dedupActive = n;
+  }
+  /**
+   * Sets the current priority queue depth.
+   *
+   * @param n - The current number of entries in the priority queue. Must be >= 0.
+   *
+   * @example
+   * ```typescript
+   * import { LifecycleStatsTracker } from "./stats";
+   *
+   * const tracker = new LifecycleStatsTracker({ wireStats: () => ({ requestCount: 0, errorCount: 0 }) });
+   * tracker.setQueueDepth(5);
+   * ```
+   */
+  setQueueDepth(n) {
+    this._queueDepth = n;
+  }
+  /**
+   * Records that a request has started. Increments the requests started counter by 1.
+   *
+   * @example
+   * ```typescript
+   * import { LifecycleStatsTracker } from "./stats";
+   *
+   * const tracker = new LifecycleStatsTracker({ wireStats: () => ({ requestCount: 0, errorCount: 0 }) });
+   * tracker.requestStarted();
+   * ```
+   */
+  requestStarted() {
+    this._requestsStarted++;
+  }
+  /**
+   * Records that a request has completed successfully.
+   * Increments the requests completed counter by 1.
+   *
+   * @example
+   * ```typescript
+   * import { LifecycleStatsTracker } from "./stats";
+   *
+   * const tracker = new LifecycleStatsTracker({ wireStats: () => ({ requestCount: 0, errorCount: 0 }) });
+   * tracker.requestCompleted();
+   * ```
+   */
+  requestCompleted() {
+    this._requestsCompleted++;
+  }
+  /**
+   * Records that a request has failed.
+   * Increments the requests failed counter by 1.
+   *
+   * @example
+   * ```typescript
+   * import { LifecycleStatsTracker } from "./stats";
+   *
+   * const tracker = new LifecycleStatsTracker({ wireStats: () => ({ requestCount: 0, errorCount: 0 }) });
+   * tracker.requestFailed();
+   * ```
+   */
+  requestFailed() {
+    this._requestsFailed++;
+  }
+  retry() {
+    this._retries++;
+  }
+  /**
+   * Records a batch dispatch. Increments the batch dispatches counter by 1.
+   */
+  batchDispatch() {
+    this._batchDispatches++;
+  }
+  /**
+   * Records requests that were coalesced into a batch.
+   * @param count - The number of individual requests in the batch.
+   */
+  batchedRequests(count) {
+    this._batchedRequests += count;
+  }
+  // --- Event emission ---
+  /**
+   * Emits a lifecycle event to the registered `onEvent` callback.
+   *
+   * The callback is wrapped in a try-catch so that any exception thrown by
+   * the callback is silently discarded and request processing continues
+   * unaffected. If no `onEvent` callback was provided, this is a no-op.
+   *
+   * @param type - The lifecycle event type to emit (e.g., `"cache-hit"`, `"request-start"`).
+   * @param extra - Optional additional event data.
+   *
+   * @example
+   * ```typescript
+   * import { LifecycleStatsTracker } from "./stats";
+   *
+   * const tracker = new LifecycleStatsTracker({
+   *   onEvent: (event) => console.log(event.type, event.timestamp),
+   *   wireStats: () => ({ requestCount: 0, errorCount: 0 }),
+   * });
+   * tracker.emit("cache-hit", { cacheKey: "GET|/api/users" });
+   * ```
+   */
+  emit(type, extra) {
+    if (!this._onEvent) return;
+    try {
+      const event = {
+        type,
+        timestamp: now(),
+        ...extra
+      };
+      this._onEvent(event);
+    } catch (e9) {
+    }
+  }
+  // --- Snapshot ---
+  /**
+   * Returns a frozen snapshot of all lifecycle statistics including wire stats.
+   *
+   * The returned object is frozen (immutable) and represents a point-in-time
+   * view of all counters and gauges.
+   *
+   * @returns A frozen `LifecycleStats` object containing all current statistics.
+   *
+   * @example
+   * ```typescript
+   * import { LifecycleStatsTracker } from "./stats";
+   *
+   * const tracker = new LifecycleStatsTracker({
+   *   wireStats: () => ({ requestCount: 10, errorCount: 1 }),
+   * });
+   * tracker.cacheHit();
+   * tracker.cacheHit();
+   * const stats = tracker.snapshot();
+   * console.log(stats.cacheHits); // 2
+   * ```
+   */
+  snapshot() {
+    return Object.freeze({
+      cacheHits: this._cacheHits,
+      cacheMisses: this._cacheMisses,
+      cacheEvictions: this._cacheEvictions,
+      dedupHits: this._dedupHits,
+      dedupActive: this._dedupActive,
+      queueDepth: this._queueDepth,
+      requestsStarted: this._requestsStarted,
+      requestsCompleted: this._requestsCompleted,
+      requestsFailed: this._requestsFailed,
+      retries: this._retries,
+      batchDispatches: this._batchDispatches,
+      batchedRequests: this._batchedRequests,
+      wire: this._wireStats()
+    });
+  }
+}, _class3);
+
+// src/http/prewarm/validation.ts
+function validateOrigin(origin) {
+  if (!origin || typeof origin !== "string") {
+    throw new Error(`validateOrigin: origin must be a non-empty string, got "${origin}"`);
+  }
+  const trimmed = origin.trim();
+  if (!trimmed) {
+    throw new Error(`validateOrigin: origin must be a non-empty string, got "${origin}"`);
+  }
+  const stripped = stripTrailingSlashes(trimmed);
+  const lower = stripped.toLowerCase();
+  if (!lower.startsWith("http://") && !lower.startsWith("https://")) {
+    throw new Error(
+      `validateOrigin: invalid origin "${origin}" \u2014 must start with http:// or https://`
+    );
+  }
+  let parsed;
+  try {
+    parsed = new URL(stripped);
+  } catch (e10) {
+    throw new Error(
+      `validateOrigin: invalid origin "${origin}" \u2014 must be a valid URL origin (scheme + host + optional port)`
+    );
+  }
+  if (parsed.pathname !== "/" && parsed.pathname !== "") {
+    throw new Error(
+      `validateOrigin: invalid origin "${origin}" \u2014 must not contain a path`
+    );
+  }
+  if (parsed.search) {
+    throw new Error(
+      `validateOrigin: invalid origin "${origin}" \u2014 must not contain query parameters`
+    );
+  }
+  if (parsed.hash) {
+    throw new Error(
+      `validateOrigin: invalid origin "${origin}" \u2014 must not contain a fragment`
+    );
+  }
+  return parsed.origin;
+}
+function stripTrailingSlashes(value) {
+  let end = value.length;
+  while (end > 0 && value.charCodeAt(end - 1) === 47) {
+    end--;
+  }
+  return end === value.length ? value : value.slice(0, end);
+}
+
+// src/http/prewarm/platform.ts
+function detectPlatform() {
+  return typeof window !== "undefined" && typeof window.document !== "undefined" ? "browser" : "node";
+}
+function validateFetchAvailable() {
+  if (typeof globalThis.fetch !== "function") {
+    throw new Error(
+      "makePrewarmManager: global fetch is not available. Requires Node.js 18+ or modern browser."
+    );
+  }
+  if (typeof globalThis.AbortController !== "function") {
+    throw new Error(
+      "makePrewarmManager: global AbortController is not available."
+    );
+  }
+}
+
+// src/http/prewarm/probe.ts
+async function executeProbe(origin, options) {
+  const { timeoutMs, signal, platform } = options;
+  const url = `${origin}/`;
+  const start = Date.now();
+  const timeoutController = new AbortController();
+  const timeoutId = setTimeout(() => timeoutController.abort(), timeoutMs);
+  const onExternalAbort = () => timeoutController.abort();
+  signal.addEventListener("abort", onExternalAbort);
+  try {
+    if (options.client) {
+      const result = await executeProbeViaClient(options.client, url, timeoutController.signal);
+      const durationMs2 = Date.now() - start;
+      if (result.ok) {
+        return { ok: true, durationMs: durationMs2 };
+      }
+      return { ok: false, durationMs: durationMs2, error: result.error };
+    }
+    const fetchOptions = {
+      method: "HEAD",
+      signal: timeoutController.signal,
+      // Prevent caching of probe requests
+      cache: "no-store"
+    };
+    if (platform === "browser") {
+      fetchOptions.mode = "no-cors";
+    }
+    await globalThis.fetch(url, fetchOptions);
+    const durationMs = Date.now() - start;
+    return { ok: true, durationMs };
+  } catch (err) {
+    const durationMs = Date.now() - start;
+    if (signal.aborted) {
+      return { ok: false, durationMs, error: "cancelled" };
+    }
+    if (timeoutController.signal.aborted && !signal.aborted) {
+      return { ok: false, durationMs, error: `Probe timed out after ${timeoutMs}ms` };
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, durationMs, error: message };
+  } finally {
+    clearTimeout(timeoutId);
+    signal.removeEventListener("abort", onExternalAbort);
+  }
+}
+async function executeProbeViaClient(client, url, signal) {
+  const { registerHttpEffect: registerHttpEffect2 } = await Promise.resolve().then(() => _interopRequireWildcard(require("./effectRunner-CFLC32IK.cjs")));
+  return new Promise((resolve) => {
+    const effect = client({
+      method: "HEAD",
+      url,
+      init: { signal }
+    });
+    const cancel = registerHttpEffect2(effect, {}, (exit) => {
+      if (exit._tag === "Success") {
+        resolve({ ok: true });
+      } else {
+        const cause = exit.cause;
+        if (_optionalChain([cause, 'optionalAccess', _27 => _27._tag]) === "Fail") {
+          const err = cause.error;
+          resolve({ ok: false, error: _nullishCoalesce(_nullishCoalesce(_optionalChain([err, 'optionalAccess', _28 => _28.message]), () => ( _optionalChain([err, 'optionalAccess', _29 => _29._tag]))), () => ( "Unknown error")) });
+        } else {
+          resolve({ ok: false, error: "cancelled" });
+        }
+      }
+    });
+    if (signal.aborted) {
+      cancel();
+    } else {
+      signal.addEventListener("abort", () => {
+        cancel();
+      }, { once: true });
+    }
+  });
+}
+
+// src/http/prewarm/connectionState.ts
+function makeConnectionStateMap(origins, keepAliveDurationMs) {
+  const entries = /* @__PURE__ */ new Map();
+  for (const origin of origins) {
+    entries.set(origin, {
+      origin,
+      status: "idle",
+      lastProbeAt: void 0,
+      warmUntil: void 0
+    });
+  }
+  function markWarm(origin, now2) {
+    const entry = entries.get(origin);
+    if (!entry) return;
+    const timestamp = _nullishCoalesce(now2, () => ( Date.now()));
+    entry.status = "warm";
+    entry.lastProbeAt = timestamp;
+    entry.warmUntil = timestamp + keepAliveDurationMs;
+  }
+  function markExpired(origin) {
+    const entry = entries.get(origin);
+    if (!entry) return;
+    entry.status = "expired";
+  }
+  function markIdle(origin) {
+    const entry = entries.get(origin);
+    if (!entry) return;
+    entry.status = "idle";
+    entry.lastProbeAt = void 0;
+    entry.warmUntil = void 0;
+  }
+  function markProbing(origin) {
+    const entry = entries.get(origin);
+    if (!entry) return;
+    entry.status = "probing";
+  }
+  function isWarm(origin, now2) {
+    const entry = entries.get(origin);
+    if (!entry) return false;
+    if (entry.status !== "warm") return false;
+    if (entry.lastProbeAt === void 0 || entry.warmUntil === void 0) return false;
+    const currentTime = _nullishCoalesce(now2, () => ( Date.now()));
+    if (currentTime >= entry.warmUntil) {
+      entry.status = "expired";
+      return false;
+    }
+    return true;
+  }
+  function getState(origin) {
+    const entry = entries.get(origin);
+    if (!entry) return void 0;
+    return {
+      origin: entry.origin,
+      status: entry.status,
+      lastProbeAt: entry.lastProbeAt,
+      warmUntil: entry.warmUntil
+    };
+  }
+  function snapshot() {
+    const result = [];
+    for (const entry of entries.values()) {
+      result.push({
+        origin: entry.origin,
+        status: entry.status,
+        lastProbeAt: entry.lastProbeAt,
+        warmUntil: entry.warmUntil
+      });
+    }
+    return { origins: result };
+  }
+  return { markWarm, markExpired, markIdle, markProbing, isWarm, getState, snapshot };
+}
+
+// src/http/prewarm/budgetSemaphore.ts
+function makeBudgetSemaphore(capacity) {
+  if (capacity < 1 || !Number.isFinite(capacity)) {
+    throw new Error(`makeBudgetSemaphore: capacity must be >= 1, got ${capacity}`);
+  }
+  capacity = Math.floor(capacity);
+  let active = 0;
+  const waiters = [];
+  function release() {
+    active--;
+    if (waiters.length > 0) {
+      const next = waiters.shift();
+      active++;
+      next({ release });
+    }
+  }
+  function acquire() {
+    if (active < capacity) {
+      active++;
+      return Promise.resolve({ release });
+    }
+    return new Promise((resolve) => {
+      waiters.push(resolve);
+    });
+  }
+  function tryAcquire() {
+    if (active < capacity) {
+      active++;
+      return { release };
+    }
+    return void 0;
+  }
+  function available() {
+    return capacity - active;
+  }
+  function queued() {
+    return waiters.length;
+  }
+  return { acquire, tryAcquire, available, queued };
+}
+
+// src/http/prewarm/prewarmManager.ts
+var DEFAULTS = {
+  keepAliveDurationMs: 55e3,
+  budget: 4,
+  probeTimeoutMs: 5e3,
+  autoRefresh: false,
+  useClientPool: false
+};
+function makePrewarmManager(config) {
+  validateFetchAvailable();
+  const keepAliveDurationMs = _nullishCoalesce(config.keepAliveDurationMs, () => ( DEFAULTS.keepAliveDurationMs));
+  const budget = _nullishCoalesce(config.budget, () => ( DEFAULTS.budget));
+  const probeTimeoutMs = _nullishCoalesce(config.probeTimeoutMs, () => ( DEFAULTS.probeTimeoutMs));
+  const autoRefresh = _nullishCoalesce(config.autoRefresh, () => ( DEFAULTS.autoRefresh));
+  const useClientPool = _nullishCoalesce(config.useClientPool, () => ( DEFAULTS.useClientPool));
+  const onEvent = config.onEvent;
+  const client = config.client;
+  const origins = config.origins.map((o) => validateOrigin(o));
+  const platform = detectPlatform();
+  const stateMap = makeConnectionStateMap(origins, keepAliveDurationMs);
+  const semaphore = makeBudgetSemaphore(budget);
+  const abortControllers = /* @__PURE__ */ new Map();
+  const refreshTimers = /* @__PURE__ */ new Map();
+  let disposed = false;
+  function emit(event) {
+    if (onEvent) {
+      try {
+        onEvent(event);
+      } catch (e11) {
+      }
+    }
+  }
+  function scheduleAutoRefresh(origin) {
+    if (!autoRefresh || disposed) return;
+    clearRefreshTimer(origin);
+    const delay = Math.floor(0.8 * keepAliveDurationMs);
+    const timer = setTimeout(() => {
+      refreshTimers.delete(origin);
+      if (disposed) return;
+      if (stateMap.isWarm(origin)) {
+        stateMap.markExpired(origin);
+        emit({
+          type: "connection-expired",
+          origin,
+          timestamp: Date.now()
+        });
+      }
+      warm(origin).catch(() => {
+      });
+    }, delay);
+    if (typeof timer === "object" && "unref" in timer) {
+      timer.unref();
+    }
+    refreshTimers.set(origin, timer);
+  }
+  function clearRefreshTimer(origin) {
+    const timer = refreshTimers.get(origin);
+    if (timer !== void 0) {
+      clearTimeout(timer);
+      refreshTimers.delete(origin);
+    }
+  }
+  function clearAllRefreshTimers() {
+    for (const [, timer] of refreshTimers) {
+      clearTimeout(timer);
+    }
+    refreshTimers.clear();
+  }
+  async function warm(origin) {
+    if (disposed) {
+      return { origin, status: "cancelled", durationMs: 0 };
+    }
+    if (stateMap.isWarm(origin)) {
+      return { origin, status: "already-warm", durationMs: 0 };
+    }
+    const { release } = await semaphore.acquire();
+    if (disposed) {
+      release();
+      return { origin, status: "cancelled", durationMs: 0 };
+    }
+    const controller = new AbortController();
+    abortControllers.set(origin, controller);
+    stateMap.markProbing(origin);
+    try {
+      const probeOptions = {
+        timeoutMs: probeTimeoutMs,
+        signal: controller.signal,
+        platform,
+        client: useClientPool ? client : void 0
+      };
+      const outcome = await executeProbe(origin, probeOptions);
+      if (controller.signal.aborted) {
+        stateMap.markIdle(origin);
+        emit({
+          type: "connection-cancelled",
+          origin,
+          timestamp: Date.now()
+        });
+        return { origin, status: "cancelled", durationMs: outcome.durationMs };
+      }
+      if (outcome.ok) {
+        stateMap.markWarm(origin);
+        emit({
+          type: "connection-warmed",
+          origin,
+          timestamp: Date.now(),
+          durationMs: outcome.durationMs
+        });
+        scheduleAutoRefresh(origin);
+        return { origin, status: "warmed", durationMs: outcome.durationMs };
+      } else {
+        stateMap.markIdle(origin);
+        emit({
+          type: "connection-failed",
+          origin,
+          timestamp: Date.now(),
+          error: outcome.error
+        });
+        return { origin, status: "failed", durationMs: outcome.durationMs, error: outcome.error };
+      }
+    } catch (err) {
+      stateMap.markIdle(origin);
+      const error = err instanceof Error ? err.message : String(err);
+      emit({
+        type: "connection-failed",
+        origin,
+        timestamp: Date.now(),
+        error
+      });
+      return { origin, status: "failed", durationMs: 0, error };
+    } finally {
+      abortControllers.delete(origin);
+      release();
+    }
+  }
+  async function warmAll() {
+    const results = await Promise.all(origins.map((o) => warm(o)));
+    return results;
+  }
+  function cancel(origin) {
+    const controller = abortControllers.get(origin);
+    if (controller) {
+      controller.abort();
+    }
+    clearRefreshTimer(origin);
+  }
+  function cancelAll() {
+    for (const [, controller] of abortControllers) {
+      controller.abort();
+    }
+    clearAllRefreshTimers();
+  }
+  function isWarm(origin) {
+    if (disposed) return false;
+    return stateMap.isWarm(origin);
+  }
+  function status() {
+    return stateMap.snapshot();
+  }
+  function dispose() {
+    if (disposed) return;
+    disposed = true;
+    cancelAll();
+    for (const origin of origins) {
+      stateMap.markIdle(origin);
+    }
+  }
+  return {
+    warm,
+    warmAll,
+    isWarm,
+    cancel,
+    cancelAll,
+    status,
+    dispose
+  };
+}
+
+// src/http/lifecycle/lifecycleClient.ts
+function validateGlobals(config) {
+  if (config.transport === void 0 && typeof fetch === "undefined") {
+    throw new Error(
+      "makeLifecycleClient: global `fetch` is not available. Ensure you are running in an environment with fetch support (Node.js 18+ or modern browser), or provide `transport` in the client config."
+    );
+  }
+  if (typeof AbortController === "undefined") {
+    throw new Error(
+      "makeLifecycleClient: global `AbortController` is not available. Ensure you are running in an environment with AbortController support (Node.js 15+ or modern browser)."
+    );
+  }
+}
+function extractWireConfig(config) {
+  const { dedup, batch, cache, priority, retry, prewarm, onEvent, ...wireConfig } = config;
+  return wireConfig;
+}
+function makeLifecycleClient(config = {}) {
+  _chunk5EC274J5cjs.validateLifecycleClientConfig.call(void 0, config);
+  validateGlobals(config);
+  const wireConfig = extractWireConfig(config);
+  const wireClient = _chunk5EC274J5cjs.makeHttp.call(void 0, wireConfig);
+  const activeControllers = /* @__PURE__ */ new Set();
+  const tracker = new LifecycleStatsTracker({
+    onEvent: config.onEvent,
+    wireStats: wireClient.stats
+  });
+  const hasDedup = config.dedup !== void 0 && config.dedup !== false;
+  const hasBatch = config.batch !== void 0 && config.batch !== false;
+  const hasCache = config.cache !== void 0 && config.cache !== false;
+  const hasPriority = config.priority !== void 0 && config.priority !== false;
+  const hasRetry = config.retry !== void 0 && config.retry !== false;
+  if (!hasDedup && !hasBatch && !hasCache && !hasPriority && !hasRetry) {
+    let prewarmMgr2;
+    const hasPrewarm2 = config.prewarm !== void 0 && config.prewarm !== false;
+    if (hasPrewarm2) {
+      const prewarmConfig = config.prewarm;
+      const prewarmOrigins = _nullishCoalesce(prewarmConfig.origins, () => ( []));
+      if (prewarmOrigins.length > 0) {
+        prewarmMgr2 = makePrewarmManager({
+          origins: prewarmOrigins,
+          keepAliveDurationMs: prewarmConfig.keepAliveDurationMs,
+          budget: prewarmConfig.budget,
+          probeTimeoutMs: prewarmConfig.probeTimeoutMs,
+          autoRefresh: prewarmConfig.autoRefresh,
+          useClientPool: prewarmConfig.useClientPool,
+          client: prewarmConfig.useClientPool ? wireClient : void 0,
+          onEvent: prewarmConfig.onEvent
+        });
+      }
+    }
+    return buildLifecycleClient(wireClient, tracker, {
+      cacheInvalidate: noopInvalidate,
+      cacheClear: noopClear,
+      cancelAll: () => cancelControllers(activeControllers, prewarmMgr2),
+      shutdown: () => shutdownClient(activeControllers, prewarmMgr2, wireClient.shutdown),
+      activeControllers,
+      adaptiveLimiter: wireClient.adaptiveLimiter,
+      prewarmManager: prewarmMgr2,
+      afterResponse: hasPrewarm2 ? config.prewarm.afterResponse : void 0
+    });
+  }
+  let priorityMiddleware;
+  if (hasPriority) {
+    const priorityConfig = config.priority;
+    priorityMiddleware = withPriority({
+      ...priorityConfig,
+      onEvent: (event) => {
+        tracker.setQueueDepth(_nullishCoalesce(_optionalChain([priorityMiddleware, 'optionalAccess', _30 => _30.queueDepth, 'call', _31 => _31()]), () => ( 0)));
+        tracker.emit(event.type, { priority: event.priority });
+      }
+    });
+  }
+  let cacheLayer;
+  if (hasCache) {
+    const cacheConfig = config.cache;
+    cacheLayer = withCache({
+      ...cacheConfig,
+      baseUrl: wireConfig.baseUrl,
+      onLifecycleEvent: (event) => {
+        if (event.type === "cache-hit") tracker.cacheHit();
+        if (event.type === "cache-miss") tracker.cacheMiss();
+        if (event.type === "cache-eviction") tracker.cacheEviction();
+        if (event.type === "cache-hit" || event.type === "cache-miss") {
+          tracker.emit(event.type, { cacheKey: event.cacheKey });
+        }
+      }
+    });
+  }
+  let dedupMiddleware;
+  if (hasDedup) {
+    const dedupConfig = config.dedup;
+    const baseUrl = _nullishCoalesce(wireConfig.baseUrl, () => ( ""));
+    const effectiveDedupConfig = dedupConfig.dedupKey || !baseUrl ? dedupConfig : { ...dedupConfig, dedupKey: (req) => computeDedupKey(req, baseUrl) };
+    dedupMiddleware = withDedup({
+      ...effectiveDedupConfig,
+      onEvent: (event) => {
+        if (event.type === "dedup-hit") tracker.dedupHit();
+        if (event.type === "dedup-active") {
+          tracker.setDedupActive(_nullishCoalesce(event.active, () => ( 0)));
+          return;
+        }
+        tracker.emit(event.type, { cacheKey: event.cacheKey });
+      }
+    });
+  }
+  let batchMiddleware;
+  if (hasBatch) {
+    const batchConfig = config.batch;
+    batchMiddleware = withBatch(batchConfig, (event) => {
+      if (event.type === "batch-dispatch") {
+        tracker.batchDispatch();
+        tracker.batchedRequests(_nullishCoalesce(event.batchSize, () => ( 0)));
+      }
+      tracker.emit(event.type, { batchKey: event.batchKey, batchSize: event.batchSize });
+    });
+  }
+  let composedFn = wireClient;
+  if (priorityMiddleware) {
+    composedFn = priorityMiddleware(composedFn);
+  }
+  if (hasRetry) {
+    const retryConfig = config.retry;
+    composedFn = _chunk5EC274J5cjs.withRetry.call(void 0, {
+      ...retryConfig,
+      onRetry: (event) => {
+        tracker.retry();
+        tracker.emit("retry", {
+          attempt: event.attempt,
+          delayMs: event.delayMs,
+          status: event.status,
+          errorTag: _optionalChain([event, 'access', _32 => _32.error, 'optionalAccess', _33 => _33._tag])
+        });
+        _optionalChain([retryConfig, 'access', _34 => _34.onRetry, 'optionalCall', _35 => _35(event)]);
+      }
+    })(composedFn);
+  }
+  if (cacheLayer) {
+    composedFn = cacheLayer.middleware(composedFn);
+  }
+  if (batchMiddleware) {
+    composedFn = batchMiddleware(composedFn);
+  }
+  if (dedupMiddleware) {
+    composedFn = dedupMiddleware(composedFn);
+  }
+  let prewarmMgr;
+  const hasPrewarm = config.prewarm !== void 0 && config.prewarm !== false;
+  if (hasPrewarm) {
+    const prewarmConfig = config.prewarm;
+    const prewarmOrigins = _nullishCoalesce(prewarmConfig.origins, () => ( []));
+    if (prewarmOrigins.length > 0) {
+      prewarmMgr = makePrewarmManager({
+        origins: prewarmOrigins,
+        keepAliveDurationMs: prewarmConfig.keepAliveDurationMs,
+        budget: prewarmConfig.budget,
+        probeTimeoutMs: prewarmConfig.probeTimeoutMs,
+        autoRefresh: prewarmConfig.autoRefresh,
+        useClientPool: prewarmConfig.useClientPool,
+        client: prewarmConfig.useClientPool ? wireClient : void 0,
+        onEvent: prewarmConfig.onEvent
+      });
+    }
+  }
+  return buildLifecycleClient(composedFn, tracker, {
+    cacheInvalidate: _nullishCoalesce(_optionalChain([cacheLayer, 'optionalAccess', _36 => _36.invalidate]), () => ( noopInvalidate)),
+    cacheClear: _nullishCoalesce(_optionalChain([cacheLayer, 'optionalAccess', _37 => _37.clear]), () => ( noopClear)),
+    cancelAll: () => cancelControllers(activeControllers, prewarmMgr),
+    shutdown: () => shutdownClient(activeControllers, prewarmMgr, wireClient.shutdown),
+    activeControllers,
+    adaptiveLimiter: wireClient.adaptiveLimiter,
+    queueDepth: _optionalChain([priorityMiddleware, 'optionalAccess', _38 => _38.queueDepth]),
+    prewarmManager: prewarmMgr,
+    afterResponse: hasPrewarm ? config.prewarm.afterResponse : void 0
+  });
+}
+function makeHttpClient(config = {}) {
+  return makeLifecycleClient(config);
+}
+function noopInvalidate(_key) {
+}
+function noopClear() {
+}
+function buildLifecycleClient(fn, tracker, internals) {
+  const client = (req) => trackRequest(fn, req, tracker, internals);
+  const stats = () => {
+    tracker.setQueueDepth(_nullishCoalesce(_optionalChain([internals, 'access', _39 => _39.queueDepth, 'optionalCall', _40 => _40()]), () => ( 0)));
+    return tracker.snapshot();
+  };
+  const withMw = (mw) => {
+    const wrappedFn = mw(withLifecycleMetadata(fn, internals));
+    return buildLifecycleClient(wrappedFn, tracker, internals);
+  };
+  const lifecycleClient = Object.assign(client, {
+    with: withMw,
+    stats,
+    cancelAll: internals.cancelAll,
+    shutdown: internals.shutdown,
+    adaptiveLimiter: internals.adaptiveLimiter,
+    cache: {
+      invalidate: internals.cacheInvalidate,
+      clear: internals.cacheClear
+    }
+  });
+  return lifecycleClient;
+}
+function withLifecycleMetadata(fn, internals) {
+  if (!internals.adaptiveLimiter) return fn;
+  return Object.assign(((req) => fn(req)), {
+    adaptiveLimiter: internals.adaptiveLimiter
+  });
+}
+function cancelControllers(activeControllers, prewarmMgr) {
+  for (const controller of Array.from(activeControllers)) {
+    try {
+      controller.abort();
+    } catch (e12) {
+    }
+  }
+  if (prewarmMgr) {
+    prewarmMgr.cancelAll();
+  }
+  return _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, void 0);
+}
+function shutdownClient(activeControllers, prewarmMgr, wireShutdown) {
+  cancelControllers(activeControllers, prewarmMgr);
+  _optionalChain([wireShutdown, 'optionalCall', _41 => _41()]);
+  return _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, void 0);
+}
+function trackRequest(fn, req, tracker, internals) {
+  return {
+    _tag: "Async",
+    register: (env, cb) => {
+      const controller = new AbortController();
+      const previousSignal = _optionalChain([req, 'access', _42 => _42.init, 'optionalAccess', _43 => _43.signal]);
+      let done = false;
+      let abortedByPreviousSignal = false;
+      let cancelInner;
+      const abortFromPrevious = () => {
+        abortedByPreviousSignal = true;
+        try {
+          controller.abort(_optionalChain([previousSignal, 'optionalAccess', _44 => _44.reason]));
+        } catch (e13) {
+          controller.abort();
+        }
+        _optionalChain([cancelInner, 'optionalCall', _45 => _45()]);
+      };
+      if (_optionalChain([previousSignal, 'optionalAccess', _46 => _46.aborted])) {
+        abortFromPrevious();
+      } else {
+        _optionalChain([previousSignal, 'optionalAccess', _47 => _47.addEventListener, 'call', _48 => _48("abort", abortFromPrevious, { once: true })]);
+      }
+      internals.activeControllers.add(controller);
+      tracker.requestStarted();
+      tracker.emit("request-start");
+      const finish = (exit0) => {
+        if (done) return;
+        done = true;
+        const exit = abortedByPreviousSignal && exit0._tag === "Failure" && _chunkMVGUEJ5Zcjs.Cause.isInterruptedOnly(exit0.cause) ? { _tag: "Failure", cause: _chunkMVGUEJ5Zcjs.Cause.fail({ _tag: "Abort" }) } : exit0;
+        _optionalChain([previousSignal, 'optionalAccess', _49 => _49.removeEventListener, 'call', _50 => _50("abort", abortFromPrevious)]);
+        internals.activeControllers.delete(controller);
+        if (exit._tag === "Success") {
+          tracker.requestCompleted();
+          if (internals.afterResponse && internals.prewarmManager) {
+            try {
+              const originsToWarm = internals.afterResponse(exit.value, req);
+              if (originsToWarm && originsToWarm.length > 0) {
+                for (const origin of originsToWarm) {
+                  internals.prewarmManager.warm(origin).catch(() => {
+                  });
+                }
+              }
+            } catch (e14) {
+            }
+          }
+        } else {
+          tracker.requestFailed();
+        }
+        tracker.emit("request-end");
+        cb(exit);
+      };
+      const trackedReq = {
+        ...req,
+        init: {
+          ..._nullishCoalesce(req.init, () => ( {})),
+          signal: controller.signal
+        }
+      };
+      try {
+        cancelInner = _chunkL6VB5N7Qcjs.registerHttpEffect.call(void 0, fn(trackedReq), env, finish);
+      } catch (error) {
+        finish({
+          _tag: "Failure",
+          cause: _chunkMVGUEJ5Zcjs.Cause.fail({ _tag: "FetchError", message: String(error) })
+        });
+      }
+      return () => {
+        if (done) return;
+        try {
+          controller.abort();
+        } catch (e15) {
+        }
+        if (cancelInner) {
+          cancelInner();
+        } else {
+          finish({ _tag: "Failure", cause: _chunkMVGUEJ5Zcjs.Cause.interrupt() });
+        }
+      };
+    }
+  };
+}
+
+// src/http/compression/types.ts
+var SUPPORTED_ENCODINGS = ["br", "gzip", "deflate"];
+function emptyStats() {
+  return {
+    decompressed: { gzip: 0, br: 0, deflate: 0 },
+    compressedBytes: 0,
+    decompressedBytes: 0,
+    passthroughCount: 0,
+    errorCount: 0,
+    unsupportedEncodingCount: 0
+  };
+}
+function emptyRequestCompressionStats() {
+  return {
+    compressedCount: 0,
+    skippedCount: 0,
+    errorCount: 0,
+    originalBytes: 0,
+    compressedBytes: 0
+  };
+}
+
+// src/http/compression/decompressor.ts
+var _zlib = require('zlib'); var _zlib2 = _interopRequireDefault(_zlib);
+
+// src/http/compression/environment.ts
+function isNodeEnvironment() {
+  return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+}
+
+// src/http/compression/decompressor.node.ts
+function createNodeDecompressor(zlib2) {
+  return {
+    isPassthrough: false,
+    decompress(data, encoding) {
+      try {
+        const input = Buffer.isBuffer(data) ? data : Buffer.from(data);
+        let result;
+        switch (encoding) {
+          case "gzip":
+            result = zlib2.gunzipSync(input);
+            break;
+          case "br":
+            result = zlib2.brotliDecompressSync(input);
+            break;
+          case "deflate":
+            result = zlib2.inflateSync(input);
+            break;
+          default:
+            return { ok: false, error: `Unsupported encoding: ${encoding}` };
+        }
+        return { ok: true, data: result };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { ok: false, error: message };
+      }
+    }
+  };
+}
+
+// src/http/compression/decompressor.noop.ts
+function createNoopDecompressor() {
+  return {
+    isPassthrough: true,
+    decompress(data, _encoding) {
+      const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+      return { ok: true, data: buf };
+    }
+  };
+}
+
+// src/http/compression/decompressor.ts
+function createDecompressor() {
+  if (isNodeEnvironment()) {
+    return createNodeDecompressor(_zlib2.default);
+  }
+  return createNoopDecompressor();
+}
+
+// src/http/compression/middleware.ts
+function injectAcceptEncoding(req, encodings) {
+  const headers = _nullishCoalesce(req.headers, () => ( {}));
+  const hasAcceptEncoding = Object.keys(headers).some(
+    (k) => k.toLowerCase() === "accept-encoding"
+  );
+  if (hasAcceptEncoding) return req;
+  return {
+    ...req,
+    headers: {
+      ...headers,
+      "Accept-Encoding": encodings.join(", ")
+    }
+  };
+}
+function isSupportedEncoding(enc) {
+  return SUPPORTED_ENCODINGS.includes(enc);
+}
+function processResponse(res, decompressor, enabledEncodings, stats) {
+  const contentEncodingKey = Object.keys(res.headers).find(
+    (k) => k.toLowerCase() === "content-encoding"
+  );
+  const contentEncodingValue = contentEncodingKey ? _optionalChain([res, 'access', _51 => _51.headers, 'access', _52 => _52[contentEncodingKey], 'optionalAccess', _53 => _53.trim, 'call', _54 => _54()]) : void 0;
+  if (!contentEncodingValue || contentEncodingValue.toLowerCase() === "identity") {
+    stats.passthroughCount++;
+    return res;
+  }
+  const encodings = contentEncodingValue.split(",").map((e) => e.trim().toLowerCase());
+  const reversedEncodings = [...encodings].reverse();
+  let currentData = Buffer.from(res.bodyText, "latin1");
+  let decompressedCount = 0;
+  for (let i = 0; i < reversedEncodings.length; i++) {
+    const enc = reversedEncodings[i];
+    if (!isSupportedEncoding(enc)) {
+      stats.unsupportedEncodingCount++;
+      if (decompressedCount === 0) {
+        stats.passthroughCount++;
+        return res;
+      }
+      const remainingEncodings = reversedEncodings.slice(i).reverse();
+      const newHeaders2 = { ...res.headers };
+      if (contentEncodingKey) {
+        newHeaders2[contentEncodingKey] = remainingEncodings.join(", ");
+      }
+      newHeaders2["Content-Length"] = String(currentData.byteLength);
+      return {
+        ...res,
+        headers: newHeaders2,
+        bodyText: currentData.toString("latin1")
+      };
+    }
+    if (!enabledEncodings.includes(enc)) {
+      stats.passthroughCount++;
+      if (decompressedCount === 0) {
+        return res;
+      }
+      const remainingEncodings = reversedEncodings.slice(i).reverse();
+      const newHeaders2 = { ...res.headers };
+      if (contentEncodingKey) {
+        newHeaders2[contentEncodingKey] = remainingEncodings.join(", ");
+      }
+      newHeaders2["Content-Length"] = String(currentData.byteLength);
+      return {
+        ...res,
+        headers: newHeaders2,
+        bodyText: currentData.toString("latin1")
+      };
+    }
+    const result = decompressor.decompress(currentData, enc);
+    if (!result.ok) {
+      stats.errorCount++;
+      return res;
+    }
+    stats.compressedBytes += currentData.byteLength;
+    stats.decompressedBytes += result.data.byteLength;
+    stats.decompressed[enc]++;
+    decompressedCount++;
+    currentData = result.data;
+  }
+  const newHeaders = { ...res.headers };
+  if (contentEncodingKey) {
+    delete newHeaders[contentEncodingKey];
+  }
+  const lowerKey = Object.keys(newHeaders).find(
+    (k) => k.toLowerCase() === "content-encoding"
+  );
+  if (lowerKey) {
+    delete newHeaders[lowerKey];
+  }
+  newHeaders["Content-Length"] = String(currentData.byteLength);
+  return {
+    ...res,
+    headers: newHeaders,
+    bodyText: currentData.toString("utf-8")
+  };
+}
+function makeCompressionMiddleware(config) {
+  const enabledEncodings = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _55 => _55.encodings]), () => ( [...SUPPORTED_ENCODINGS]));
+  const decompressor = createDecompressor();
+  const mutableStats = emptyStats();
+  const middleware = (next) => {
+    return (req) => {
+      const modifiedReq = injectAcceptEncoding(req, enabledEncodings);
+      return _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
+        next(modifiedReq),
+        // Pass HttpErrors through unchanged
+        (error) => _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, error),
+        // Process successful responses
+        (res) => {
+          if (decompressor.isPassthrough) {
+            mutableStats.passthroughCount++;
+            return _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, res);
+          }
+          const processed = processResponse(
+            res,
+            decompressor,
+            enabledEncodings,
+            mutableStats
+          );
+          return _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, processed);
+        }
+      );
+    };
+  };
+  const stats = () => Object.freeze({
+    decompressed: Object.freeze({ ...mutableStats.decompressed }),
+    compressedBytes: mutableStats.compressedBytes,
+    decompressedBytes: mutableStats.decompressedBytes,
+    passthroughCount: mutableStats.passthroughCount,
+    errorCount: mutableStats.errorCount,
+    unsupportedEncodingCount: mutableStats.unsupportedEncodingCount
+  });
+  return { middleware, stats };
+}
+var makeResponseCompressionMiddleware = makeCompressionMiddleware;
+var DEFAULT_REQUEST_COMPRESS_METHODS = ["POST", "PUT", "PATCH"];
+function makeRequestCompressionMiddleware(config) {
+  const encoding = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _56 => _56.encoding]), () => ( "gzip"));
+  const minBytes = Math.max(0, Math.floor(_nullishCoalesce(_optionalChain([config, 'optionalAccess', _57 => _57.minBytes]), () => ( 1024))));
+  const methods = new Set((_nullishCoalesce(_optionalChain([config, 'optionalAccess', _58 => _58.methods]), () => ( DEFAULT_REQUEST_COMPRESS_METHODS))).map((m) => m.toUpperCase()));
+  const mutableStats = emptyRequestCompressionStats();
+  const middleware = (next) => {
+    return (req) => {
+      const compressed = compressRequest(req, encoding, minBytes, methods, mutableStats);
+      return next(compressed);
+    };
+  };
+  const stats = () => Object.freeze({
+    compressedCount: mutableStats.compressedCount,
+    skippedCount: mutableStats.skippedCount,
+    errorCount: mutableStats.errorCount,
+    originalBytes: mutableStats.originalBytes,
+    compressedBytes: mutableStats.compressedBytes
+  });
+  return { middleware, stats };
+}
+function compressRequest(req, encoding, minBytes, methods, stats) {
+  if (!methods.has(req.method.toUpperCase())) {
+    stats.skippedCount++;
+    return req;
+  }
+  if (req.body === void 0 || hasHeader(req.headers, "content-encoding")) {
+    stats.skippedCount++;
+    return req;
+  }
+  const originalBytes = httpBodyByteLength(req.body);
+  if (originalBytes < minBytes) {
+    stats.skippedCount++;
+    return req;
+  }
+  try {
+    const compressed = compressBuffer(httpBodyToBuffer(req.body), encoding);
+    stats.compressedCount++;
+    stats.originalBytes += originalBytes;
+    stats.compressedBytes += compressed.byteLength;
+    return {
+      ...req,
+      body: compressed,
+      headers: setHeaders(req.headers, {
+        "Content-Encoding": encoding,
+        "Content-Length": String(compressed.byteLength)
+      })
+    };
+  } catch (e16) {
+    stats.errorCount++;
+    return req;
+  }
+}
+function compressBuffer(input, encoding) {
+  const zlib2 = _chunkOBGZSXTJcjs.__require.call(void 0, "zlib");
+  switch (encoding) {
+    case "gzip":
+      return zlib2.gzipSync(input);
+    case "br":
+      return zlib2.brotliCompressSync(input);
+    case "deflate":
+      return zlib2.deflateSync(input);
+  }
+}
+function hasHeader(headers, name) {
+  if (!headers) return false;
+  const lower = name.toLowerCase();
+  return Object.keys(headers).some((key) => key.toLowerCase() === lower);
+}
+function setHeaders(headers, values) {
+  const out = { ..._nullishCoalesce(headers, () => ( {})) };
+  for (const [key, value] of Object.entries(values)) {
+    const existing = Object.keys(out).find((h) => h.toLowerCase() === key.toLowerCase());
+    if (existing) out[existing] = value;
+    else out[key] = value;
+  }
+  return out;
+}
+
+// src/http/requestBuilder.ts
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function splitHttpRequestInit(init) {
+  const {
+    headers,
+    timeoutMs,
+    poolKey,
+    policy,
+    lane,
+    dedupKey,
+    priority,
+    retry,
+    schema: _schema,
+    schemaName: _schemaName,
+    bodySchema: _bodySchema,
+    bodySchemaName: _bodySchemaName,
+    ...rest
+  } = _nullishCoalesce(init, () => ( {}));
+  const policyFields = {
+    ...isRecord(policy) ? policy : {},
+    ...typeof lane === "string" ? { lane } : {},
+    ...typeof dedupKey === "string" ? { dedupKey } : {},
+    ...typeof priority === "number" ? { priority } : {},
+    ...retry !== void 0 ? { retry } : {}
+  };
+  const policyRef = typeof policy === "string" ? Object.keys(policyFields).length > 0 ? { preset: policy, ...policyFields } : policy : Object.keys(policyFields).length > 0 ? policyFields : void 0;
+  return {
+    headers: _chunk5EC274J5cjs.normalizeHeadersInit.call(void 0, headers),
+    timeoutMs: typeof timeoutMs === "number" ? timeoutMs : void 0,
+    poolKey: typeof poolKey === "string" ? poolKey : void 0,
+    policy: policyRef,
+    init: rest
+  };
+}
+function buildHttpRequest(method, url, init, body) {
+  const split = splitHttpRequestInit(init);
+  const req = {
+    method,
+    url,
+    ...body && body.length > 0 ? { body } : {},
+    ...split.timeoutMs !== void 0 ? { timeoutMs: split.timeoutMs } : {},
+    ...split.poolKey !== void 0 ? { poolKey: split.poolKey } : {},
+    ...split.policy !== void 0 ? { policy: split.policy } : {},
+    init: split.init
+  };
+  return split.headers ? _chunk5EC274J5cjs.mergeHeaders.call(void 0, split.headers)(req) : req;
+}
+
+// src/http/defaultClient.ts
+var MINIMAL_PRESET_CONFIG = {
+  timeoutMs: 3e4
+};
+var BALANCED_PRESET_CONFIG = {
+  ...MINIMAL_PRESET_CONFIG,
+  dedup: {},
+  priority: {
+    concurrency: 32,
+    queueTimeoutMs: 3e4
+  },
+  retry: {
+    maxRetries: 2,
+    baseDelayMs: 100,
+    maxDelayMs: 1e3,
+    maxElapsedMs: 5e3,
+    respectRetryAfter: true
+  },
+  adaptiveLimiter: _chunk5EC274J5cjs.makeAdaptiveLimiterConfig.call(void 0, "balanced")
+};
+var DEFAULT_CACHEABLE_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
+var DEFAULT_PRESET_CONFIG = {
+  ...BALANCED_PRESET_CONFIG,
+  cache: {
+    ttlSeconds: 60,
+    maxEntries: 1024,
+    staleWhileRevalidate: true,
+    cachePolicy: (req, res) => ({ cacheable: isDefaultCacheableResponse(req, res) })
+  },
+  priority: {
+    concurrency: 64,
+    queueTimeoutMs: 3e4
+  },
+  retry: {
+    maxRetries: 3,
+    baseDelayMs: 100,
+    maxDelayMs: 2e3,
+    maxElapsedMs: 1e4,
+    respectRetryAfter: true
+  },
+  adaptiveLimiter: _chunk5EC274J5cjs.makeAdaptiveLimiterConfig.call(void 0, "aggressive")
+};
+var PRESET_CONFIGS = {
+  minimal: MINIMAL_PRESET_CONFIG,
+  balanced: BALANCED_PRESET_CONFIG,
+  default: DEFAULT_PRESET_CONFIG,
+  production: DEFAULT_PRESET_CONFIG
+};
+function isDefaultCacheableResponse(req, res) {
+  if (!DEFAULT_CACHEABLE_METHODS.has(req.method)) return false;
+  if (res.status < 200 || res.status >= 400) return false;
+  const cacheControl = _optionalChain([headerValue, 'call', _59 => _59(res.headers, "cache-control"), 'optionalAccess', _60 => _60.toLowerCase, 'call', _61 => _61()]);
+  if (cacheControl) {
+    const directives = cacheControl.split(",").map((part) => part.trim());
+    if (directives.includes("no-store") || directives.includes("no-cache")) return false;
+  }
+  if (_optionalChain([headerValue, 'call', _62 => _62(res.headers, "pragma"), 'optionalAccess', _63 => _63.toLowerCase, 'call', _64 => _64()]) === "no-cache") return false;
+  if (headerValue(res.headers, "set-cookie") !== void 0) return false;
+  return true;
+}
+function headerValue(headers, name) {
+  return _nullishCoalesce(_nullishCoalesce(headers[name], () => ( headers[name.toLowerCase()])), () => ( headers[name.toUpperCase()]));
+}
+var defaultHttpClientPreset = "default";
+function makeDefaultHttpClient(config = {}) {
+  _chunk5EC274J5cjs.validateDefaultHttpClientConfig.call(void 0, config);
+  const {
+    preset = defaultHttpClientPreset,
+    compression,
+    middleware = [],
+    policyPresets,
+    ...lifecycleOverrides
+  } = config;
+  const lifecycleConfig = mergeLifecycleConfig(PRESET_CONFIGS[preset], lifecycleOverrides);
+  let wire = makeLifecycleClient(lifecycleConfig);
+  const compressionResult = compression === false || compression === void 0 && preset === "minimal" ? void 0 : makeCompressionMiddleware(compression === void 0 ? void 0 : compression);
+  if (compressionResult) {
+    wire = wire.with(compressionResult.middleware);
+  }
+  for (const mw of middleware) {
+    wire = wire.with(mw);
+  }
+  if (policyPresets && Object.keys(policyPresets).length > 0) {
+    wire = wire.with(_chunk3LOYJFRRcjs.withHttpPolicyPresets.call(void 0, policyPresets));
+  }
+  const features = featureSnapshot(lifecycleConfig, compressionResult !== void 0, middleware.length);
+  return buildDefaultClient(wire, {
+    preset,
+    features,
+    compressionStats: _optionalChain([compressionResult, 'optionalAccess', _65 => _65.stats])
+  });
+}
+function buildDefaultClient(wire, meta) {
+  const withPromise = (eff) => _chunkMVGUEJ5Zcjs.withAsyncPromise.call(void 0, (e, env) => _chunkGLE2WY7Zcjs.toPromise.call(void 0, e, env))(eff);
+  const requestRaw = (req) => wire(req);
+  const request = (req) => withPromise(requestRaw(req));
+  const get = (url, init) => request(buildHttpRequest("GET", url, init));
+  const post = (url, body, init) => request(buildHttpRequest("POST", url, init, body));
+  const getText = (url, init) => {
+    const req = buildHttpRequest("GET", url, init);
+    return withPromise(
+      _chunkMVGUEJ5Zcjs.mapTryAsync.call(void 0, requestRaw(req), (w) => toResponse(w, w.bodyText))
+    );
+  };
+  const getJson = ((url, init) => {
+    const req = _chunk5EC274J5cjs.setHeaderIfMissing.call(void 0, "accept", "application/json")(
+      buildHttpRequest("GET", url, init)
+    );
+    return withPromise(
+      _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, requestRaw(req), (w) => decodeResponse(w, _optionalChain([init, 'optionalAccess', _66 => _66.schema]), _optionalChain([init, 'optionalAccess', _67 => _67.schemaName])))
+    );
+  });
+  const postJson = ((url, bodyObj, init) => {
+    return withPromise(
+      _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
+        encodeJsonBodyEffect(bodyObj, _optionalChain([init, 'optionalAccess', _68 => _68.bodySchema]), { schemaName: _optionalChain([init, 'optionalAccess', _69 => _69.bodySchemaName]) }),
+        (bodyText) => {
+          const req = _chunk5EC274J5cjs.setHeaderIfMissing.call(void 0, "content-type", "application/json")(
+            _chunk5EC274J5cjs.setHeaderIfMissing.call(void 0, "accept", "application/json")(
+              buildHttpRequest("POST", url, init, bodyText)
+            )
+          );
+          return _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, requestRaw(req), (w) => decodeResponse(w, _optionalChain([init, 'optionalAccess', _70 => _70.schema]), _optionalChain([init, 'optionalAccess', _71 => _71.schemaName])));
+        }
+      )
+    );
+  });
+  return {
+    request,
+    get,
+    post,
+    getText,
+    getJson,
+    postJson,
+    with: (mw) => buildDefaultClient(wire.with(mw), {
+      ...meta,
+      features: {
+        ...meta.features,
+        middleware: meta.features.middleware + 1
+      }
+    }),
+    wire,
+    stats: () => wire.stats(),
+    cache: wire.cache,
+    cancelAll: wire.cancelAll,
+    shutdown: wire.shutdown,
+    preset: meta.preset,
+    features: meta.features,
+    ...meta.compressionStats ? {
+      compression: {
+        stats: meta.compressionStats
+      }
+    } : {}
+  };
+}
+function toResponse(wire, body) {
+  return {
+    status: wire.status,
+    statusText: wire.statusText,
+    headers: wire.headers,
+    body
+  };
+}
+function decodeResponse(wire, schema, schemaName) {
+  return _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
+    decodeJsonBodyEffect(wire.bodyText, schema, { schemaName }),
+    (body) => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, toResponse(wire, body))
+  );
+}
+function mergeLifecycleConfig(defaults, overrides) {
+  return {
+    ...defaults,
+    ...overrides,
+    headers: mergeRecord(defaults.headers, overrides.headers),
+    dedup: mergeLayer(defaults.dedup, overrides.dedup),
+    batch: mergeLayer(defaults.batch, overrides.batch),
+    cache: mergeLayer(defaults.cache, overrides.cache),
+    priority: mergeLayer(defaults.priority, overrides.priority),
+    retry: mergeLayer(defaults.retry, overrides.retry),
+    prewarm: mergeLayer(defaults.prewarm, overrides.prewarm),
+    adaptiveLimiter: mergeAdaptiveLimiterLayer(defaults.adaptiveLimiter, overrides.adaptiveLimiter),
+    pool: mergeLayer(defaults.pool, overrides.pool)
+  };
+}
+function mergeRecord(defaults, overrides) {
+  if (!defaults) return overrides;
+  if (!overrides) return defaults;
+  return { ...defaults, ...overrides };
+}
+function mergeLayer(defaults, overrides) {
+  if (overrides === void 0) return defaults;
+  if (overrides === false) return false;
+  if (defaults === void 0 || defaults === false) return overrides;
+  return { ...defaults, ...overrides };
+}
+function mergeAdaptiveLimiterLayer(defaults, overrides) {
+  if (overrides === void 0) return defaults;
+  if (overrides === false) return false;
+  if (defaults === void 0 || defaults === false) return overrides;
+  if (overrides.preset !== void 0) return overrides;
+  return { ...defaults, ...overrides };
+}
+function featureSnapshot(config, compression, middleware) {
+  return Object.freeze({
+    dedup: isEnabled(config.dedup),
+    batch: isEnabled(config.batch),
+    cache: isEnabled(config.cache),
+    priority: isEnabled(config.priority),
+    retry: isEnabled(config.retry),
+    prewarm: isEnabled(config.prewarm),
+    adaptiveLimiter: isEnabled(config.adaptiveLimiter),
+    compression,
+    middleware
+  });
+}
+function isEnabled(value) {
+  return value !== void 0 && value !== false;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.decodeJsonBody = decodeJsonBody; exports.encodeJsonBodyEffect = encodeJsonBodyEffect; exports.decodeJsonBodyEffect = decodeJsonBodyEffect; exports.validatedJson = validatedJson; exports.validatedJsonResponse = validatedJsonResponse; exports.buildHttpRequest = buildHttpRequest; exports.SEPARATOR = SEPARATOR; exports.DEFAULT_CACHE_RELEVANT_HEADERS = DEFAULT_CACHE_RELEVANT_HEADERS; exports.computeCacheKey = computeCacheKey; exports.parseCacheKey = parseCacheKey; exports.withDedup = withDedup; exports.withBatch = withBatch; exports.now = now; exports.LRUCache = LRUCache; exports.withCache = withCache; exports.clampPriority = clampPriority; exports.PriorityQueue = PriorityQueue; exports.withPriority = withPriority; exports.LifecycleStatsTracker = LifecycleStatsTracker; exports.validateOrigin = validateOrigin; exports.detectPlatform = detectPlatform; exports.validateFetchAvailable = validateFetchAvailable; exports.executeProbe = executeProbe; exports.makeConnectionStateMap = makeConnectionStateMap; exports.makeBudgetSemaphore = makeBudgetSemaphore; exports.makePrewarmManager = makePrewarmManager; exports.makeLifecycleClient = makeLifecycleClient; exports.makeHttpClient = makeHttpClient; exports.SUPPORTED_ENCODINGS = SUPPORTED_ENCODINGS; exports.makeCompressionMiddleware = makeCompressionMiddleware; exports.makeResponseCompressionMiddleware = makeResponseCompressionMiddleware; exports.makeRequestCompressionMiddleware = makeRequestCompressionMiddleware; exports.defaultHttpClientPreset = defaultHttpClientPreset; exports.makeDefaultHttpClient = makeDefaultHttpClient;