brass-runtime 1.19.1 → 1.19.2

package/dist/{chunk-IHXF6NQG.js → chunk-HKLZJ5UK.js}

@@ -12,6 +12,8 @@ import {
 } from "./chunk-6W5DC3TX.js";
 import {
   fromPromiseAbortable,
+  recordAbortablePromiseFinish,
+  recordAbortablePromiseStart,
   resolveWasmModule,
   toPromise
 } from "./chunk-TN2P7RNK.js";
@@ -3182,6 +3184,275 @@ var noopSignal = (() => {
   globalThis.__brassNoopSignal = s;
   return s;
 })();
+var PoolRequestState = class {
+  constructor(req, url, transport, metrics, pool, adaptiveLimiter, timerWheel, timeoutMs, env, cb, previousSignal, controller, signal, label, startedAt) {
+    this.req = req;
+    this.url = url;
+    this.transport = transport;
+    this.metrics = metrics;
+    this.pool = pool;
+    this.adaptiveLimiter = adaptiveLimiter;
+    this.timerWheel = timerWheel;
+    this.timeoutMs = timeoutMs;
+    this.env = env;
+    this.cb = cb;
+    this.previousSignal = previousSignal;
+    this.controller = controller;
+    this.signal = signal;
+    this.label = label;
+    this.startedAt = startedAt;
+  }
+  req;
+  url;
+  transport;
+  metrics;
+  pool;
+  adaptiveLimiter;
+  timerWheel;
+  timeoutMs;
+  env;
+  cb;
+  previousSignal;
+  controller;
+  signal;
+  label;
+  startedAt;
+  done = false;
+  cancelInner = void 0;
+  timerHandle = void 0;
+  timeoutHandle = void 0;
+  lease = void 0;
+  finish(outcome, exit, error) {
+    if (this.done) return;
+    this.done = true;
+    if (this.timerHandle) {
+      this.timerHandle.cancel();
+      this.timerHandle = void 0;
+    }
+    if (this.timeoutHandle !== void 0) {
+      clearTimeout(this.timeoutHandle);
+      this.timeoutHandle = void 0;
+    }
+    if (this.previousSignal) this.previousSignal.removeEventListener("abort", this.boundAbortFromPrevious);
+    this.cancelInner = void 0;
+    recordAbortablePromiseFinish(this.label, outcome);
+    this.metrics.onFinish({
+      label: this.label,
+      outcome,
+      durationMs: Math.round(performance.now() - this.startedAt),
+      error
+    });
+    this.cb(exit);
+  }
+  finishFailure(error, outcome = "failure") {
+    this.finish(outcome, { _tag: "Failure", cause: Cause.fail(error) }, error);
+  }
+  abortCurrent(reason) {
+    if (!this.controller) return;
+    try {
+      this.controller.abort(reason);
+    } catch {
+      this.controller.abort();
+    }
+  }
+  /**
+   * Bound reference for addEventListener/removeEventListener.
+   * Only allocated when previousSignal is present (not on the hot path).
+   */
+  boundAbortFromPrevious = void 0;
+  abortFromPrevious() {
+    const error = this.previousSignal ? abortErrorForSignal(this.previousSignal) : { _tag: "Abort" };
+    this.abortCurrent(this.previousSignal?.reason);
+    const cancel = this.cancelInner;
+    this.cancelInner = void 0;
+    if (this.lease) {
+      releaseFailure(this.lease, this.adaptiveLimiter);
+      this.lease = void 0;
+    }
+    queueMicrotask(() => {
+      this.finishFailure(error);
+      cancel?.();
+    });
+  }
+  runTransportInner() {
+    const { transport, req, url, signal, env } = this;
+    try {
+      const effect = transport({ request: req, url, signal });
+      if (effect._tag === "Succeed") {
+        if (this.lease) releaseSuccess(this.lease, this.adaptiveLimiter, effect.value);
+        this.finish("success", { _tag: "Success", value: effect.value });
+      } else if (effect._tag === "Fail") {
+        if (this.lease) releaseFailure(this.lease, this.adaptiveLimiter);
+        this.finishFailure(effect.error);
+      } else if (effect._tag === "Async") {
+        try {
+          const cancel = effect.register(env, (exit) => {
+            if (this.done) return;
+            this.cancelInner = void 0;
+            if (exit._tag === "Success") {
+              if (this.lease) releaseSuccess(this.lease, this.adaptiveLimiter, exit.value);
+              this.finish("success", exit);
+            } else {
+              if (this.lease) releaseFailure(this.lease, this.adaptiveLimiter);
+              this.finish("failure", exit, exitError(exit));
+            }
+          });
+          if (!this.done) this.cancelInner = typeof cancel === "function" ? cancel : void 0;
+        } catch (error) {
+          if (this.lease) releaseFailure(this.lease, this.adaptiveLimiter);
+          this.finishFailure(normalizeHttpError(error));
+        }
+      } else {
+        const innerCancel = registerHttpEffect(
+          effect,
+          env,
+          (exit) => {
+            if (this.done) return;
+            this.cancelInner = void 0;
+            if (exit._tag === "Success") {
+              if (this.lease) releaseSuccess(this.lease, this.adaptiveLimiter, exit.value);
+              this.finish("success", exit);
+            } else {
+              if (this.lease) releaseFailure(this.lease, this.adaptiveLimiter);
+              this.finish("failure", exit, exitError(exit));
+            }
+          }
+        );
+        if (!this.done) this.cancelInner = innerCancel;
+      }
+    } catch (error) {
+      if (this.lease) releaseFailure(this.lease, this.adaptiveLimiter);
+      this.finishFailure(normalizeHttpError(error));
+    }
+  }
+};
+var runPoolTransport = (req, url, transport, metrics, pool, adaptiveLimiter, timerWheel, timeoutMs) => ({
+  _tag: "Async",
+  register: (env, cb) => {
+    const previousSignal = req.init?.signal;
+    const controller = new AbortController();
+    const signal = controller.signal;
+    const label = fetchLabel(req, url);
+    const startedAt = performance.now();
+    const state = new PoolRequestState(
+      req,
+      url,
+      transport,
+      metrics,
+      pool,
+      adaptiveLimiter,
+      timerWheel,
+      timeoutMs,
+      env,
+      cb,
+      previousSignal,
+      controller,
+      signal,
+      label,
+      startedAt
+    );
+    recordAbortablePromiseStart(label);
+    metrics.onStart();
+    if (previousSignal) {
+      state.boundAbortFromPrevious = () => state.abortFromPrevious();
+      if (previousSignal.aborted) {
+        state.abortFromPrevious();
+        return () => void 0;
+      }
+      previousSignal.addEventListener("abort", state.boundAbortFromPrevious, ONCE_OPTIONS);
+    }
+    if (timeoutMs !== void 0 && timeoutMs > 0) {
+      const onTimeout = () => {
+        const reason = timeoutReason(req, url, timeoutMs);
+        if (state.lease) {
+          releaseFailure(state.lease, adaptiveLimiter);
+          state.lease = void 0;
+        }
+        const cancel = state.cancelInner;
+        state.cancelInner = void 0;
+        state.finishFailure(reason, "timeout");
+        state.abortCurrent(reason);
+        cancel?.();
+      };
+      if (timerWheel) {
+        state.timerHandle = timerWheel.schedule(timeoutMs, onTimeout, startedAt);
+      } else {
+        state.timeoutHandle = setTimeout(onTimeout, timeoutMs);
+      }
+    }
+    if (adaptiveLimiter) {
+      const key = resolveHttpPoolKey(adaptiveLimiter.keyResolver, req, url);
+      const syncLease = adaptiveLimiter.tryAcquireSync(key, signal);
+      if (syncLease) {
+        state.lease = syncLease;
+      } else {
+        adaptiveLimiter.acquire(key, signal, { priority: requestPriority(req) }).then(
+          (asyncLease) => {
+            if (state.done) {
+              asyncLease.release(0);
+              return;
+            }
+            state.lease = asyncLease;
+            state.runTransportInner();
+          },
+          (err) => {
+            if (state.done) return;
+            state.finishFailure(normalizeHttpError(err));
+          }
+        );
+        return () => {
+          if (state.done) return;
+          const cancel = state.cancelInner;
+          state.cancelInner = void 0;
+          state.abortCurrent();
+          if (state.lease) releaseFailure(state.lease, adaptiveLimiter);
+          state.finish("interrupt", { _tag: "Failure", cause: Cause.interrupt() });
+          cancel?.();
+        };
+      }
+    } else if (pool) {
+      const key = resolveHttpPoolKey(pool.keyResolver, req, url);
+      const syncLease = pool.tryAcquireSync(key, signal);
+      if (syncLease) {
+        state.lease = syncLease;
+      } else {
+        pool.acquire(key, signal).then(
+          (asyncLease) => {
+            if (state.done) {
+              asyncLease.release();
+              return;
+            }
+            state.lease = asyncLease;
+            state.runTransportInner();
+          },
+          (err) => {
+            if (state.done) return;
+            state.finishFailure(normalizeHttpError(err));
+          }
+        );
+        return () => {
+          if (state.done) return;
+          const cancel = state.cancelInner;
+          state.cancelInner = void 0;
+          state.abortCurrent();
+          if (state.lease) releaseFailure(state.lease, void 0);
+          state.finish("interrupt", { _tag: "Failure", cause: Cause.interrupt() });
+          cancel?.();
+        };
+      }
+    }
+    state.runTransportInner();
+    return () => {
+      if (state.done) return;
+      const cancel = state.cancelInner;
+      state.cancelInner = void 0;
+      state.abortCurrent();
+      if (state.lease) releaseFailure(state.lease, adaptiveLimiter);
+      state.finish("interrupt", { _tag: "Failure", cause: Cause.interrupt() });
+      cancel?.();
+    };
+  }
+});
 function makeHttp(cfg = {}) {
   validateMakeHttpConfig(cfg);
   const baseUrl = cfg.baseUrl ?? "";
@@ -3200,42 +3471,7 @@ function makeHttp(cfg = {}) {
     if (!adaptiveLimiter && !pool && timeoutMs === void 0) {
       return runDirectTransport(req, url, transport, metrics);
     }
-    return fromPromiseAbortable(
-      async (signal, env) => {
-        let lease;
-        const linkedSignal = linkAbortSignals(signal, req.init?.signal);
-        try {
-          if (linkedSignal.signal.aborted) throw abortErrorForSignal(linkedSignal.signal);
-          if (adaptiveLimiter) {
-            const key = resolveHttpPoolKey(adaptiveLimiter.keyResolver, req, url);
-            lease = await adaptiveLimiter.acquire(key, linkedSignal.signal, { priority: requestPriority(req) });
-          } else if (pool) {
-            const key = resolveHttpPoolKey(pool.keyResolver, req, url);
-            lease = await pool.acquire(key, linkedSignal.signal);
-          }
-          const response = await runTransportEffect(
-            transport({ request: req, url, signal: linkedSignal.signal }),
-            env,
-            linkedSignal.signal
-          );
-          lease = releaseSuccess(lease, adaptiveLimiter, response);
-          return response;
-        } finally {
-          linkedSignal.cleanup();
-          if (lease) {
-            releaseFailure(lease, adaptiveLimiter);
-          }
-        }
-      },
-      normalizeHttpError,
-      {
-        label: fetchLabel(req, url),
-        timeoutMs,
-        timeoutReason: timeoutMs ? () => timeoutReason(req, url, timeoutMs) : void 0,
-        onStart: metrics.onStart,
-        onFinish: metrics.onFinish
-      }
-    );
+    return runPoolTransport(req, url, transport, metrics, pool, adaptiveLimiter, void 0, timeoutMs);
   };
   const metadata = {};
   if (adaptiveLimiter) metadata.adaptiveLimiter = adaptiveLimiter;

package/dist/{chunk-22HYIE56.mjs → chunk-IA6BDGXW.mjs}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-S6KSHYAT.mjs";
 import {
   withHttpObservability
-} from "./chunk-AITYRQX2.mjs";
+} from "./chunk-ZXXOXB3T.mjs";
 import {
   makeObservability
 } from "./chunk-SCHM2MDA.mjs";
@@ -14,7 +14,7 @@ import {
 import {
   makeDefaultHttpClient,
   makeHttp
-} from "./chunk-ID2WOCBA.mjs";
+} from "./chunk-5X3MPWTR.mjs";
 import {
   Runtime,
   Scheduler

package/dist/{chunk-EZ76UNHP.cjs → chunk-QAHW7S3Q.cjs}

@@ -4,7 +4,7 @@
 var _chunkJQCQWO47cjs = require('./chunk-JQCQWO47.cjs');
 
 
-var _chunk67256TKFcjs = require('./chunk-67256TKF.cjs');
+var _chunkTWEHIAUEcjs = require('./chunk-TWEHIAUE.cjs');
 
 
 var _chunkZJC3JZIEcjs = require('./chunk-ZJC3JZIE.cjs');
@@ -14,7 +14,7 @@ var _chunkVXNWVAIGcjs = require('./chunk-VXNWVAIG.cjs');
 
 
 
-var _chunkLXNU3MRVcjs = require('./chunk-LXNU3MRV.cjs');
+var _chunkUOKXJQAIcjs = require('./chunk-UOKXJQAI.cjs');
 
 
 
@@ -862,24 +862,24 @@ function baseHttpConfig(baseUrl, scenario) {
   };
 }
 function makeWireClient(baseUrl, scenario) {
-  return _chunkLXNU3MRVcjs.makeHttp.call(void 0, baseHttpConfig(baseUrl, scenario));
+  return _chunkUOKXJQAIcjs.makeHttp.call(void 0, baseHttpConfig(baseUrl, scenario));
 }
 function makeMinimalClient(baseUrl, scenario) {
-  return _chunkLXNU3MRVcjs.makeDefaultHttpClient.call(void 0, {
+  return _chunkUOKXJQAIcjs.makeDefaultHttpClient.call(void 0, {
     preset: "minimal",
     compression: false,
     ...baseHttpConfig(baseUrl, scenario)
   });
 }
 function makeDefaultClient(baseUrl, scenario, preset, disableAdaptiveLimiter, observability) {
-  return _chunkLXNU3MRVcjs.makeDefaultHttpClient.call(void 0, {
+  return _chunkUOKXJQAIcjs.makeDefaultHttpClient.call(void 0, {
     preset,
     compression: false,
     ...baseHttpConfig(baseUrl, scenario),
     ...disableAdaptiveLimiter ? { adaptiveLimiter: false } : {},
     ...observability ? {
       middleware: [
-        _chunk67256TKFcjs.withHttpObservability.call(void 0, {
+        _chunkTWEHIAUEcjs.withHttpObservability.call(void 0, {
           metrics: observability.metrics,
           logs: false,
           spans: {},

package/dist/{chunk-67256TKF.cjs → chunk-TWEHIAUE.cjs}

@@ -20,7 +20,7 @@ var _chunkZJC3JZIEcjs = require('./chunk-ZJC3JZIE.cjs');
 
 
 
-var _chunkLXNU3MRVcjs = require('./chunk-LXNU3MRV.cjs');
+var _chunkUOKXJQAIcjs = require('./chunk-UOKXJQAI.cjs');
 
 
 var _chunkL6VB5N7Qcjs = require('./chunk-L6VB5N7Q.cjs');
@@ -217,13 +217,13 @@ function withHttpObservability(options) {
           cb({ _tag: "Success", value: res });
         };
         const onError = (error) => {
-          const status = _chunkLXNU3MRVcjs.httpErrorStatus.call(void 0, error);
+          const status = _chunkUOKXJQAIcjs.httpErrorStatus.call(void 0, error);
           const finish = completeFinish(
             httpErrorOutcome(error),
             status !== void 0 ? String(status) : void 0,
             {
               "error.type": error._tag,
-              "http.retryable": _chunkLXNU3MRVcjs.isRetryableHttpError.call(void 0, error)
+              "http.retryable": _chunkUOKXJQAIcjs.isRetryableHttpError.call(void 0, error)
             }
           );
           const adaptiveAttrs = observeAdaptiveLimiter(wireReq, next, resolved);
@@ -244,7 +244,7 @@ function withHttpObservability(options) {
               durationMs: finish.durationMs,
               ...status !== void 0 ? { status } : {},
               ...statusText ? { statusText } : {},
-              retryable: _chunkLXNU3MRVcjs.isRetryableHttpError.call(void 0, error),
+              retryable: _chunkUOKXJQAIcjs.isRetryableHttpError.call(void 0, error),
               errorTag: error._tag,
               message: httpErrorMessage(error)
             });
@@ -312,7 +312,7 @@ function withLeanHttpSampledSpanObservability(next, options, metricCache) {
         finishLeanHttpSpan(span, "success");
       } else {
         const error = httpErrorFromCause(exit.cause);
-        const status = _chunkLXNU3MRVcjs.httpErrorStatus.call(void 0, error);
+        const status = _chunkUOKXJQAIcjs.httpErrorStatus.call(void 0, error);
         recordHttpMetricsFinish(
           handles,
           httpErrorOutcome(error),
@@ -375,7 +375,7 @@ function withLeanHttpMetricsObservability(next, options, metricCache) {
         );
       } else {
         const error = httpErrorFromCause(exit.cause);
-        const status = _chunkLXNU3MRVcjs.httpErrorStatus.call(void 0, error);
+        const status = _chunkUOKXJQAIcjs.httpErrorStatus.call(void 0, error);
         recordHttpMetricsFinish(
           handles,
           httpErrorOutcome(error),
@@ -594,7 +594,7 @@ function getCachedBaseLabels(req, options, cache) {
   if (cache.disabled) return requestBaseLabels(req, options);
   const route = requestRoute(req, options);
   const host = options.includeHostLabel ? requestHost(req) : void 0;
-  const policy = _chunkLXNU3MRVcjs.getHttpRequestPolicy.call(void 0, req);
+  const policy = _chunkUOKXJQAIcjs.getHttpRequestPolicy.call(void 0, req);
   const preset = typeof policy === "string" ? policy : _optionalChain([policy, 'optionalAccess', _46 => _46.preset]);
   const key = `${req.method}|${_nullishCoalesce(host, () => ( ""))}|${_nullishCoalesce(route, () => ( ""))}|${_nullishCoalesce(preset, () => ( ""))}`;
   const existing = cache.baseLabelsCache.get(key);
@@ -727,7 +727,7 @@ function adaptiveLimiterLabels(req, stats, options) {
   });
 }
 function inferAdaptiveLimiterKey(req, stats) {
-  const policy = _chunkLXNU3MRVcjs.getHttpRequestPolicy.call(void 0, req);
+  const policy = _chunkUOKXJQAIcjs.getHttpRequestPolicy.call(void 0, req);
   if (policy.poolKey) return policy.poolKey;
   const host = requestHost(req);
   if (host) return host;
@@ -809,7 +809,7 @@ function requestLogFields(req, options) {
 }
 function requestPolicyLogFields(req, options) {
   if (!options.policy.enabled) return void 0;
-  const policy = _chunkLXNU3MRVcjs.getHttpRequestPolicy.call(void 0, req);
+  const policy = _chunkUOKXJQAIcjs.getHttpRequestPolicy.call(void 0, req);
   const fields = {
     ...policy.preset ? { preset: policy.preset } : {},
     ...policy.lane ? { lane: policy.lane } : {},
@@ -822,7 +822,7 @@ function requestPolicyLogFields(req, options) {
 }
 function requestPolicySpanAttributes(req, options) {
   if (!options.policy.enabled) return {};
-  const policy = _chunkLXNU3MRVcjs.getHttpRequestPolicy.call(void 0, req);
+  const policy = _chunkUOKXJQAIcjs.getHttpRequestPolicy.call(void 0, req);
   return {
     ...compactSpanAttributes({
       "http.request.policy.lane": policy.lane,
@@ -836,7 +836,7 @@ function requestPolicySpanAttributes(req, options) {
 }
 function requestPolicyMetricLabels(req, options) {
   if (!options.policy.enabled || options.policy.labelKeys.length === 0) return {};
-  const policy = _chunkLXNU3MRVcjs.getHttpRequestPolicy.call(void 0, req);
+  const policy = _chunkUOKXJQAIcjs.getHttpRequestPolicy.call(void 0, req);
   const values = {
     preset: policy.preset,
     lane: policy.lane,
@@ -1217,7 +1217,7 @@ function makeObservedRuntimeLayer(options = {}) {
 }
 function makeObservedHttpClientLayer(config = {}, options = {}) {
   const observabilityTag = _nullishCoalesce(options.observabilityTag, () => ( ObservabilityService));
-  const httpTag = _nullishCoalesce(options.httpTag, () => ( _chunkLXNU3MRVcjs.HttpClientService));
+  const httpTag = _nullishCoalesce(options.httpTag, () => ( _chunkUOKXJQAIcjs.HttpClientService));
   return _chunkZZ2CMYJLcjs.layerEffect.call(void 0, 
     httpTag,
     (context) => _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => {
@@ -1228,7 +1228,7 @@ function makeObservedHttpClientLayer(config = {}, options = {}) {
         context,
         observability
       );
-      return _chunkLXNU3MRVcjs.makeDefaultHttpClient.call(void 0, {
+      return _chunkUOKXJQAIcjs.makeDefaultHttpClient.call(void 0, {
         ...httpConfig,
         middleware: [
           ..._nullishCoalesce(httpConfig.middleware, () => ( [])),