brass-runtime 1.18.0 → 1.18.2

package/dist/{chunk-4YQHPIWJ.js → chunk-A6EG5WRL.js}

@@ -2,14 +2,14 @@ import {
   EventBus,
   InMemoryTracer,
   makeMetrics
-} from "./chunk-AADFFVYS.js";
+} from "./chunk-B2VXVNIS.js";
 import {
   Runtime,
   ctxExtend,
   ctxToObject,
   emptyContext,
   getCurrentFiber
-} from "./chunk-XSAHV5HQ.js";
+} from "./chunk-APQBU7TM.js";
 import {
   asyncFail,
   asyncFlatMap,
@@ -20,7 +20,7 @@ import {
 import {
   Schema,
   parseConfig
-} from "./chunk-HCJ4S3YB.js";
+} from "./chunk-FNWOH2T2.js";
 
 // src/observability/health.ts
 function snapshotRuntimeHealth(options = {}) {

package/dist/{chunk-XSAHV5HQ.js → chunk-APQBU7TM.js}

@@ -10,7 +10,7 @@ import {
 import {
   Schema,
   parseConfig
-} from "./chunk-HCJ4S3YB.js";
+} from "./chunk-FNWOH2T2.js";
 
 // src/core/runtime/ringBuffer.ts
 var PushStatus = /* @__PURE__ */ ((PushStatus3) => {
@@ -2950,31 +2950,43 @@ var Runtime = class _Runtime {
     const fiber = this.fork(effect);
     fiber.join(cb);
   }
+  static exitToError(exit) {
+    if (exit._tag === "Success") return void 0;
+    const failure = Cause.firstFailure(exit.cause);
+    if (failure._tag === "Some") return failure.value;
+    const defect = Cause.firstDefect(exit.cause);
+    if (defect._tag === "Some") {
+      return defect.value instanceof Error ? defect.value : new Error(String(defect.value));
+    }
+    if (Cause.containsInterrupt(exit.cause)) return new Error("Interrupted");
+    return Cause.toError(exit.cause);
+  }
   toPromise(effect) {
+    let syncExit;
+    let promiseResolve;
+    let promiseReject;
+    const complete = (exit) => {
+      if (promiseResolve) {
+        if (exit._tag === "Success") promiseResolve(exit.value);
+        else promiseReject(_Runtime.exitToError(exit));
+      } else {
+        syncExit = exit;
+      }
+    };
+    if (this.tryRunNativeTopLevel(effect, complete)) {
+      if (syncExit) {
+        return syncExit._tag === "Success" ? Promise.resolve(syncExit.value) : Promise.reject(_Runtime.exitToError(syncExit));
+      }
+      return new Promise((resolve, reject) => {
+        promiseResolve = resolve;
+        promiseReject = reject;
+      });
+    }
     return new Promise((resolve, reject) => {
-      const complete = (exit) => {
-        if (exit._tag === "Success") {
-          resolve(exit.value);
-          return;
-        }
-        const failure = Cause.firstFailure(exit.cause);
-        if (failure._tag === "Some") reject(failure.value);
-        else {
-          const defect = Cause.firstDefect(exit.cause);
-          if (defect._tag === "Some") {
-            reject(defect.value instanceof Error ? defect.value : new Error(String(defect.value)));
-          } else if (Cause.containsInterrupt(exit.cause)) {
-            reject(new Error("Interrupted"));
-          } else {
-            reject(Cause.toError(exit.cause));
-          }
-        }
-      };
-      if (this.tryRunNativeTopLevel(effect, complete)) return;
+      promiseResolve = resolve;
+      promiseReject = reject;
       const fiber = this.fork(effect);
-      fiber.join((exit) => {
-        complete(exit);
-      });
+      fiber.join(complete);
     });
   }
   tryRunNativeTopLevel(effect, cb) {
@@ -3017,32 +3029,43 @@ var NativeTopLevelRunner = class {
   constructor(runtime, effect, cb) {
     this.runtime = runtime;
     this.current = effect;
-    this.joiners.push(cb);
-    this.frame = {
-      id: 0,
-      runtime,
-      name: "native-fast-path",
-      fiberContext: { trace: null },
-      lane: runtime.lane,
-      status: () => this.result ? "Done" : "Running",
-      join: (joiner) => {
-        if (this.result) joiner(this.result);
-        else this.joiners.push(joiner);
-      },
-      interrupt: () => void 0,
-      addFinalizer: (finalizer) => {
-        this.finalizers.push(finalizer);
-      }
-    };
+    this.firstJoiner = cb;
   }
   runtime;
   current;
-  stack = [];
-  joiners = [];
-  finalizers = [];
+  // Lazy-allocated — most requests don't need these
+  stack;
+  joiners;
+  finalizers;
   result;
   yielded = false;
-  frame;
+  firstJoiner;
+  // Frame is now the runner itself — avoids allocating a separate frame object
+  // with 4 closures per request. We implement the Fiber-like interface inline.
+  id = 0;
+  name = "native-fast-path";
+  fiberContext = { trace: null };
+  get lane() {
+    return this.runtime.lane;
+  }
+  // Fiber-like interface methods (used by frame consumers)
+  status() {
+    return this.result ? "Done" : "Running";
+  }
+  join(joiner) {
+    if (this.result) {
+      joiner(this.result);
+      return;
+    }
+    if (!this.joiners) this.joiners = [];
+    this.joiners.push(joiner);
+  }
+  interrupt() {
+  }
+  addFinalizer(finalizer) {
+    if (!this.finalizers) this.finalizers = [];
+    this.finalizers.push(finalizer);
+  }
   start() {
     this.runLoop();
   }
@@ -3067,10 +3090,12 @@ var NativeTopLevelRunner = class {
             }
             break;
           case "FlatMap":
+            if (!this.stack) this.stack = [];
             this.stack.push({ _tag: "SuccessCont", k: current.andThen });
             this.current = current.first;
             break;
           case "Fold":
+            if (!this.stack) this.stack = [];
             this.stack.push({
               _tag: "FoldCont",
               onFailure: current.onFailure,
@@ -3085,10 +3110,12 @@ var NativeTopLevelRunner = class {
             this.onSuccess(this.runtime.fork(current.effect, current.scopeId));
             break;
           case "Interruptibility":
+            if (!this.stack) this.stack = [];
             this.stack.push({ _tag: "InterruptibilityCont" });
             this.current = current.effect;
             break;
           case "InterruptibilityMask":
+            if (!this.stack) this.stack = [];
             this.stack.push({ _tag: "InterruptibilityCont" });
             try {
               this.current = current.body((effect) => ({
@@ -3101,6 +3128,7 @@ var NativeTopLevelRunner = class {
             }
             break;
           case "InterruptibilityRestore":
+            if (!this.stack) this.stack = [];
             this.stack.push({ _tag: "InterruptibilityCont" });
             this.current = current.effect;
             break;
@@ -3109,6 +3137,7 @@ var NativeTopLevelRunner = class {
             const hadValue = refs.has(current.refId);
             const previousValue = refs.get(current.refId);
             refs.set(current.refId, current.value);
+            if (!this.stack) this.stack = [];
             this.stack.push({
               _tag: "FiberRefCont",
               refId: current.refId,
@@ -3167,7 +3196,7 @@ var NativeTopLevelRunner = class {
   onSuccess(value) {
     let currentValue = value;
     while (true) {
-      const frame = this.stack.pop();
+      const frame = this.stack ? this.stack.pop() : void 0;
       if (!frame) {
         this.notify(Exit.succeed(currentValue));
         return;
@@ -3195,7 +3224,7 @@ var NativeTopLevelRunner = class {
   }
   onCause(cause) {
     let currentCause = cause;
-    while (this.stack.length > 0) {
+    while (this.stack && this.stack.length > 0) {
       const frame = this.stack.pop();
       if (frame._tag === "InterruptibilityCont") continue;
       if (frame._tag === "FiberRefCont") {
@@ -3220,13 +3249,17 @@ var NativeTopLevelRunner = class {
   notify(exit) {
     if (this.result) return;
     this.result = exit;
-    this.runFinalizers(exit);
-    for (const joiner of this.joiners) joiner(exit);
-    this.joiners.length = 0;
+    if (this.finalizers) this.runFinalizers(exit);
+    this.firstJoiner(exit);
+    if (this.joiners) {
+      for (const joiner of this.joiners) joiner(exit);
+      this.joiners.length = 0;
+    }
   }
   runFinalizers(exit) {
-    while (this.finalizers.length > 0) {
-      const finalizer = this.finalizers.pop();
+    const finalizers = this.finalizers;
+    while (finalizers.length > 0) {
+      const finalizer = finalizers.pop();
       try {
         const result = finalizer(exit);
         if (result && typeof result === "object" && "_tag" in result) {
@@ -3237,8 +3270,8 @@ var NativeTopLevelRunner = class {
     }
   }
   fiberRefs() {
-    this.frame.fiberContext.fiberRefs ??= /* @__PURE__ */ new Map();
-    return this.frame.fiberContext.fiberRefs;
+    this.fiberContext.fiberRefs ??= /* @__PURE__ */ new Map();
+    return this.fiberContext.fiberRefs;
   }
   restoreFiberRef(frame) {
     const refs = this.fiberRefs();
@@ -3246,7 +3279,7 @@ var NativeTopLevelRunner = class {
     else refs.delete(frame.refId);
   }
   withFrame(body) {
-    return withCurrentFiber(this.frame, body);
+    return withCurrentFiber(this, body);
   }
 };
 function fork(effect, env) {
@@ -3274,6 +3307,12 @@ var abortablePromiseTotals = {
   lateSettlements: 0
 };
 var abortablePromiseLabels = /* @__PURE__ */ new Map();
+var perLabelTrackingEnabled = false;
+function setAbortablePromisePerLabelTracking(enabled) {
+  const previous = perLabelTrackingEnabled;
+  perLabelTrackingEnabled = enabled;
+  return previous;
+}
 var getAbortablePromiseLabelStats = (label) => {
   const existing = abortablePromiseLabels.get(label);
   if (existing) return existing;
@@ -3291,44 +3330,60 @@ var getAbortablePromiseLabelStats = (label) => {
   return created;
 };
 var recordAbortablePromiseStart = (label) => {
-  const byLabel = getAbortablePromiseLabelStats(label);
   abortablePromiseTotals.active++;
   abortablePromiseTotals.started++;
-  byLabel.active++;
-  byLabel.started++;
+  if (perLabelTrackingEnabled) {
+    const byLabel = getAbortablePromiseLabelStats(label);
+    byLabel.active++;
+    byLabel.started++;
+  }
 };
 var recordAbortablePromiseFinish = (label, outcome) => {
-  const byLabel = getAbortablePromiseLabelStats(label);
   if (abortablePromiseTotals.active > 0) abortablePromiseTotals.active--;
-  if (byLabel.active > 0) byLabel.active--;
   switch (outcome) {
     case "success":
       abortablePromiseTotals.succeeded++;
-      byLabel.succeeded++;
-      return;
+      break;
     case "failure":
       abortablePromiseTotals.failed++;
-      byLabel.failed++;
-      return;
+      break;
     case "interrupt":
       abortablePromiseTotals.interrupted++;
-      byLabel.interrupted++;
-      return;
+      break;
     case "timeout":
       abortablePromiseTotals.timedOut++;
-      byLabel.timedOut++;
-      return;
+      break;
+  }
+  if (perLabelTrackingEnabled) {
+    const byLabel = getAbortablePromiseLabelStats(label);
+    if (byLabel.active > 0) byLabel.active--;
+    switch (outcome) {
+      case "success":
+        byLabel.succeeded++;
+        return;
+      case "failure":
+        byLabel.failed++;
+        return;
+      case "interrupt":
+        byLabel.interrupted++;
+        return;
+      case "timeout":
+        byLabel.timedOut++;
+        return;
+    }
   }
 };
 var recordAbortablePromiseLateSettlement = (label) => {
-  const byLabel = getAbortablePromiseLabelStats(label);
   abortablePromiseTotals.lateSettlements++;
-  byLabel.lateSettlements++;
+  if (perLabelTrackingEnabled) {
+    const byLabel = getAbortablePromiseLabelStats(label);
+    byLabel.lateSettlements++;
+  }
 };
 function abortablePromiseStats() {
   return {
     ...abortablePromiseTotals,
-    byLabel: Array.from(abortablePromiseLabels.values()).map((x) => ({ ...x })).sort((a, b) => b.active - a.active || b.started - a.started || a.label.localeCompare(b.label))
+    byLabel: perLabelTrackingEnabled ? Array.from(abortablePromiseLabels.values()).map((x) => ({ ...x })).sort((a, b) => b.active - a.active || b.started - a.started || a.label.localeCompare(b.label)) : []
   };
 }
 function resetAbortablePromiseStats() {
@@ -3350,76 +3405,149 @@ var makeTimeoutReason = (timeoutMs, label) => ({
   timeoutMs,
   message: `Abortable promise '${label}' timed out after ${timeoutMs}ms`
 });
+function registerWithTimeout(make, onReject, options, env, cb, timeoutMs) {
+  const controller = new AbortController();
+  const label = normalizeAbortablePromiseLabel(options.label);
+  const startedAt = performance.now();
+  let done = false;
+  let cleanup;
+  const hasHooks = options.onStart !== void 0 || options.onFinish !== void 0;
+  const finish = hasHooks ? (outcome, exit, error) => {
+    if (done) return;
+    done = true;
+    cleanup();
+    recordAbortablePromiseFinish(label, outcome);
+    options.onFinish?.({
+      label,
+      outcome,
+      durationMs: Math.round(performance.now() - startedAt),
+      error
+    });
+    cb(exit);
+  } : (outcome, exit, _error) => {
+    if (done) return;
+    done = true;
+    cleanup();
+    recordAbortablePromiseFinish(label, outcome);
+    cb(exit);
+  };
+  recordAbortablePromiseStart(label);
+  if (hasHooks) options.onStart?.(label);
+  const onTimeout = () => {
+    const reason = options.timeoutReason?.() ?? makeTimeoutReason(timeoutMs, label);
+    try {
+      controller.abort(reason);
+    } catch {
+      controller.abort();
+    }
+    finish("timeout", Exit.failCause(Cause.fail(onReject(reason))), reason);
+  };
+  if (options.timerWheel) {
+    const handle = options.timerWheel.schedule(timeoutMs, onTimeout);
+    cleanup = () => {
+      handle.cancel();
+    };
+  } else {
+    let timeoutHandle = setTimeout(onTimeout, timeoutMs);
+    cleanup = () => {
+      if (timeoutHandle !== void 0) {
+        clearTimeout(timeoutHandle);
+        timeoutHandle = void 0;
+      }
+    };
+  }
+  let promise;
+  try {
+    promise = make(controller.signal, env);
+  } catch (err) {
+    finish("failure", Exit.failCause(Cause.fail(onReject(err))), err);
+    return () => void 0;
+  }
+  promise.then((value) => {
+    if (done) {
+      recordAbortablePromiseLateSettlement(label);
+      return;
+    }
+    finish("success", Exit.succeed(value));
+  }).catch((err) => {
+    if (done) {
+      recordAbortablePromiseLateSettlement(label);
+      return;
+    }
+    finish("failure", Exit.failCause(Cause.fail(onReject(err))), err);
+  });
+  return () => {
+    if (done) return;
+    try {
+      controller.abort();
+    } catch {
+    }
+    finish("interrupt", Exit.failCause(Cause.interrupt()));
+  };
+}
+function registerWithoutTimeout(make, onReject, options, env, cb) {
+  const controller = new AbortController();
+  const label = normalizeAbortablePromiseLabel(options.label);
+  const startedAt = performance.now();
+  let done = false;
+  const hasHooks = options.onStart !== void 0 || options.onFinish !== void 0;
+  const finish = hasHooks ? (outcome, exit, error) => {
+    if (done) return;
+    done = true;
+    recordAbortablePromiseFinish(label, outcome);
+    options.onFinish?.({
+      label,
+      outcome,
+      durationMs: Math.round(performance.now() - startedAt),
+      error
+    });
+    cb(exit);
+  } : (outcome, exit, _error) => {
+    if (done) return;
+    done = true;
+    recordAbortablePromiseFinish(label, outcome);
+    cb(exit);
+  };
+  recordAbortablePromiseStart(label);
+  if (hasHooks) options.onStart?.(label);
+  let promise;
+  try {
+    promise = make(controller.signal, env);
+  } catch (err) {
+    finish("failure", Exit.failCause(Cause.fail(onReject(err))), err);
+    return () => void 0;
+  }
+  promise.then((value) => {
+    if (done) {
+      recordAbortablePromiseLateSettlement(label);
+      return;
+    }
+    finish("success", Exit.succeed(value));
+  }).catch((err) => {
+    if (done) {
+      recordAbortablePromiseLateSettlement(label);
+      return;
+    }
+    finish("failure", Exit.failCause(Cause.fail(onReject(err))), err);
+  });
+  return () => {
+    if (done) return;
+    try {
+      controller.abort();
+    } catch {
+    }
+    finish("interrupt", Exit.failCause(Cause.interrupt()));
+  };
+}
 function fromPromiseAbortable(make, onReject, options = {}) {
   return {
     _tag: "Async",
     register: (env, cb) => {
-      const controller = new AbortController();
-      const label = normalizeAbortablePromiseLabel(options.label);
       const timeoutMs = options.timeoutMs !== void 0 && Number.isFinite(options.timeoutMs) ? Math.max(0, Math.floor(options.timeoutMs)) : void 0;
-      const startedAt = performance.now();
-      let done = false;
-      let timeoutHandle;
-      const cleanup = () => {
-        if (timeoutHandle !== void 0) {
-          clearTimeout(timeoutHandle);
-          timeoutHandle = void 0;
-        }
-      };
-      const finish = (outcome, exit, error) => {
-        if (done) return;
-        done = true;
-        cleanup();
-        recordAbortablePromiseFinish(label, outcome);
-        options.onFinish?.({
-          label,
-          outcome,
-          durationMs: Math.round(performance.now() - startedAt),
-          error
-        });
-        cb(exit);
-      };
-      recordAbortablePromiseStart(label);
-      options.onStart?.(label);
       if (timeoutMs !== void 0 && timeoutMs > 0) {
-        timeoutHandle = setTimeout(() => {
-          const reason = options.timeoutReason?.() ?? makeTimeoutReason(timeoutMs, label);
-          try {
-            controller.abort(reason);
-          } catch {
-            controller.abort();
-          }
-          finish("timeout", Exit.failCause(Cause.fail(onReject(reason))), reason);
-        }, timeoutMs);
+        return registerWithTimeout(make, onReject, options, env, cb, timeoutMs);
       }
-      let promise;
-      try {
-        promise = make(controller.signal, env);
-      } catch (err) {
-        finish("failure", Exit.failCause(Cause.fail(onReject(err))), err);
-        return () => void 0;
-      }
-      promise.then((value) => {
-        if (done) {
-          recordAbortablePromiseLateSettlement(label);
-          return;
-        }
-        finish("success", Exit.succeed(value));
-      }).catch((err) => {
-        if (done) {
-          recordAbortablePromiseLateSettlement(label);
-          return;
-        }
-        finish("failure", Exit.failCause(Cause.fail(onReject(err))), err);
-      });
-      return () => {
-        if (done) return;
-        try {
-          controller.abort();
-        } catch {
-        }
-        finish("interrupt", Exit.failCause(Cause.interrupt()));
-      };
+      return registerWithoutTimeout(make, onReject, options, env, cb);
     }
   };
 }
@@ -4256,6 +4384,9 @@ export {
   toPromiseByCaller,
   unsafeRunAsync,
   toPromise,
+  setAbortablePromisePerLabelTracking,
+  recordAbortablePromiseStart,
+  recordAbortablePromiseFinish,
   abortablePromiseStats,
   resetAbortablePromiseStats,
   fromPromiseAbortable,

package/dist/{chunk-RREBJX2S.mjs → chunk-AQQQFNYD.mjs}

@@ -6,7 +6,7 @@ import {
   getCurrentFiber,
   unsafeGetCurrentRuntime,
   unsafeRunFoldWithEnv
-} from "./chunk-2QNREG6K.mjs";
+} from "./chunk-MUMBUXU6.mjs";
 import {
   Cause,
   Exit,
@@ -412,31 +412,49 @@ function drainStreamSyncFull(stream) {
     }
   }
 }
+var ABORTED_ERROR = (() => {
+  if (typeof DOMException === "function") {
+    try {
+      return new DOMException("aborted", "AbortError");
+    } catch {
+    }
+  }
+  const e = new Error("aborted");
+  e.name = "AbortError";
+  return e;
+})();
 function readerStream(reader, normalizeError, signal) {
+  const noopSignal = globalThis.__brassNoopSignal;
+  const needsSignalListener = signal !== void 0 && signal !== noopSignal;
   const pull = asyncEffect((_, cb) => {
     let done = false;
-    const cleanup = () => signal?.removeEventListener("abort", abort);
+    let abortFn;
     const finish = (exit) => {
       if (done) return;
       done = true;
-      cleanup();
+      if (needsSignalListener && abortFn) signal.removeEventListener("abort", abortFn);
       cb(exit);
     };
-    const abort = () => {
-      try {
-        reader.cancel();
-      } catch {
+    if (needsSignalListener) {
+      if (signal.aborted) {
+        try {
+          reader.cancel();
+        } catch {
+        }
+        finish({ _tag: "Failure", cause: { _tag: "Fail", error: some(normalizeError(ABORTED_ERROR)) } });
+        return;
       }
-      const error = typeof DOMException === "function" ? new DOMException("aborted", "AbortError") : new Error("aborted");
-      finish({ _tag: "Failure", cause: { _tag: "Fail", error: some(normalizeError(error)) } });
-    };
-    if (signal?.aborted) {
-      abort();
-      return;
+      abortFn = () => {
+        try {
+          reader.cancel();
+        } catch {
+        }
+        finish({ _tag: "Failure", cause: { _tag: "Fail", error: some(normalizeError(ABORTED_ERROR)) } });
+      };
+      signal.addEventListener("abort", abortFn, { once: true });
     }
-    signal?.addEventListener("abort", abort, { once: true });
-    reader.read().then(({ done: done2, value }) => {
-      if (done2) {
+    reader.read().then(({ done: readDone, value }) => {
+      if (readDone) {
         finish({ _tag: "Failure", cause: { _tag: "Fail", error: none } });
         return;
       }
@@ -444,11 +462,13 @@ function readerStream(reader, normalizeError, signal) {
         _tag: "Success",
         value: [value, fromPull(pull)]
       });
-    }).catch((e) => {
+    }, (e) => {
       finish({ _tag: "Failure", cause: { _tag: "Fail", error: some(normalizeError(e)) } });
     });
     return () => {
-      cleanup();
+      if (done) return;
+      done = true;
+      if (needsSignalListener && abortFn) signal.removeEventListener("abort", abortFn);
       try {
         reader.cancel();
       } catch {

package/dist/{chunk-AADFFVYS.js → chunk-B2VXVNIS.js}

@@ -1,6 +1,6 @@
 import {
   makeBoundedRingBuffer
-} from "./chunk-XSAHV5HQ.js";
+} from "./chunk-APQBU7TM.js";
 import {
   Cause
 } from "./chunk-UB4B6OFY.js";

package/dist/{chunk-R6WDSZA6.mjs → chunk-BLXBZ6RE.mjs}

@@ -4,7 +4,7 @@ import {
 import {
   fromPromiseAbortable,
   withScopeAsync
-} from "./chunk-2QNREG6K.mjs";
+} from "./chunk-MUMBUXU6.mjs";
 import {
   Cause,
   Exit,

package/dist/{chunk-ITG6I7ZS.js → chunk-C3CWI42G.js}

@@ -4,7 +4,7 @@ import {
 import {
   fromPromiseAbortable,
   withScopeAsync
-} from "./chunk-XSAHV5HQ.js";
+} from "./chunk-APQBU7TM.js";
 import {
   Cause,
   Exit,