brass-runtime 1.17.0 → 1.18.1

package/dist/{chunk-GYM3LLGS.mjs → chunk-H626ZTDZ.mjs}

@@ -2,12 +2,15 @@ import {
   Async,
   Cause,
   Exit,
-  asyncEffect
+  asyncEffect,
+  asyncFlatMap,
+  asyncFold,
+  unit
 } from "./chunk-36I3M4UC.mjs";
 import {
   Schema,
   parseConfig
-} from "./chunk-DNFJLJMW.mjs";
+} from "./chunk-6MLAZPBL.mjs";
 
 // src/core/runtime/ringBuffer.ts
 var PushStatus = /* @__PURE__ */ ((PushStatus3) => {
@@ -2947,38 +2950,50 @@ 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) {
     if (this.hooks !== NoopHooks) return false;
     if (getCurrentFiber() !== null) return false;
     if (this.scheduler !== globalScheduler) return false;
-    if (this.lane !== void 0 || this.inferLane) return false;
+    if (this.inferLane) return false;
     if (this.engineMode !== "ts") return false;
     new NativeTopLevelRunner(this, effect, cb).start();
     return true;
@@ -3137,7 +3152,7 @@ var NativeTopLevelRunner = class {
         syncExit = exit;
         return;
       }
-      queueMicrotask(() => this.resumeAsync(exit));
+      this.resumeAsync(exit);
     };
     try {
       current.register(this.runtime.env, resume);
@@ -3271,6 +3286,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;
@@ -3288,44 +3309,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() {
@@ -3347,76 +3384,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);
     }
   };
 }
@@ -4035,6 +4145,183 @@ var JsFiberEngine = class {
   }
 };
 
+// src/core/runtime/scope.ts
+var nextScopeId = 1;
+function awaitAll(fibers) {
+  return asyncEffect((_env, cb) => {
+    let remaining = fibers.length;
+    if (remaining === 0) {
+      cb({ _tag: "Success", value: void 0 });
+      return;
+    }
+    for (const f of fibers) {
+      f.join(() => {
+        remaining -= 1;
+        if (remaining === 0) cb({ _tag: "Success", value: void 0 });
+      });
+    }
+  });
+}
+var Scope = class _Scope {
+  constructor(runtime, parentScopeId) {
+    this.runtime = runtime;
+    this.parentScopeId = parentScopeId;
+    this.id = nextScopeId++;
+    const inferredParent = this.parentScopeId ?? getCurrentFiber()?.scopeId;
+    if (this.runtime.hasActiveHooks()) {
+      this.runtime.emit({
+        type: "scope.open",
+        scopeId: this.id,
+        parentScopeId: inferredParent
+      });
+    }
+  }
+  runtime;
+  parentScopeId;
+  id;
+  closed = false;
+  children = /* @__PURE__ */ new Set();
+  subScopes = /* @__PURE__ */ new Set();
+  finalizers = [];
+  /** registra un finalizer (LIFO) */
+  addFinalizer(f) {
+    if (this.closed) {
+      throw new Error("Trying to add finalizer to closed scope");
+    }
+    this.finalizers.push(f);
+  }
+  /** crea un sub scope (mismo runtime) */
+  subScope() {
+    if (this.closed) throw new Error("Scope closed");
+    const s = new _Scope(this.runtime, this.id);
+    this.subScopes.add(s);
+    return s;
+  }
+  /** ✅ fork en este scope */
+  fork(eff) {
+    if (this.closed) throw new Error("Scope closed");
+    const f = this.runtime.fork(eff, this.id);
+    this.children.add(f);
+    f.join(() => this.children.delete(f));
+    return f;
+  }
+  /** close fire-and-forget (no bloquea) */
+  close(exit = { _tag: "Success", value: void 0 }) {
+    this.runtime.fork(this.closeAsync(exit));
+  }
+  /** Emit the scope.close event if hooks are active. */
+  emitCloseEvent(exit) {
+    if (this.runtime.hasActiveHooks()) {
+      const status = exit._tag === "Success" ? "success" : Cause.isInterruptedOnly(exit.cause) ? "interrupted" : "failure";
+      const failure = exit._tag === "Failure" ? Cause.firstFailure(exit.cause) : void 0;
+      this.runtime.emit({
+        type: "scope.close",
+        scopeId: this.id,
+        status,
+        error: failure?._tag === "Some" ? failure.value : exit._tag === "Failure" ? exit.cause : void 0
+      });
+    }
+  }
+  /**
+   * Build an effect that executes finalizers in LIFO order.
+   *
+   * Optimization over the original: instead of wrapping every finalizer in
+   * `asyncFold(fin(exit), () => unit(), () => unit())` which creates 3 effect
+   * nodes per finalizer (Fold + 2 Succeed), we use a single Sync thunk per
+   * finalizer that catches errors inline.  When the finalizer returns a
+   * Succeed effect (like `unit()`), the Sync thunk completes without creating
+   * additional effect nodes.
+   */
+  buildFinalizerEffect(exit) {
+    const fins = this.finalizers;
+    if (fins.length === 0) return unit();
+    let chain = unit();
+    for (let i = fins.length - 1; i >= 0; i--) {
+      const fin = fins[i];
+      chain = asyncFlatMap(chain, () => {
+        let result;
+        try {
+          result = fin(exit);
+        } catch {
+          return unit();
+        }
+        if (result._tag === "Succeed") {
+          return unit();
+        }
+        return asyncFold(
+          result,
+          () => unit(),
+          () => unit()
+        );
+      });
+    }
+    return chain;
+  }
+  closeAsync(exit = { _tag: "Success", value: void 0 }, opts = { awaitChildren: true }) {
+    return asyncFlatMap(
+      unit(),
+      () => asyncEffect((env, cb) => {
+        if (this.closed) {
+          cb({ _tag: "Success", value: void 0 });
+          return;
+        }
+        this.closed = true;
+        const children = Array.from(this.children);
+        const subScopes = Array.from(this.subScopes);
+        for (const child of children) {
+          child.interrupt();
+        }
+        const closeSubs = subScopes.reduceRight(
+          (acc, s) => asyncFlatMap(acc, () => s.closeAsync(exit, opts)),
+          unit()
+        );
+        const runFinalizers = this.buildFinalizerEffect(exit);
+        const needsAwait = opts.awaitChildren && children.length > 0;
+        const awaitChildrenEff = needsAwait ? awaitAll(children) : unit();
+        const hasSubScopes = subScopes.length > 0;
+        const hasNoFinalizers = this.finalizers.length === 0;
+        if (!hasSubScopes && !needsAwait && hasNoFinalizers) {
+          this.emitCloseEvent(exit);
+          cb({ _tag: "Success", value: void 0 });
+          return;
+        }
+        const all = asyncFlatMap(closeSubs, () => asyncFlatMap(awaitChildrenEff, () => runFinalizers));
+        this.runtime.fork(all).join(() => {
+          this.emitCloseEvent(exit);
+          cb({ _tag: "Success", value: void 0 });
+        });
+      })
+    );
+  }
+};
+function withScopeAsync(runtime, f) {
+  return asyncEffect((_env, cb) => {
+    const scope = new Scope(runtime);
+    let done = false;
+    const completeAfterClose = (exit) => {
+      runtime.fork(scope.closeAsync(exit)).join(() => {
+        if (done) return;
+        done = true;
+        cb(exit);
+      });
+    };
+    const fiber = runtime.fork(f(scope));
+    fiber.join(completeAfterClose);
+    return () => {
+      if (done) return;
+      fiber.interrupt();
+      runtime.fork(scope.closeAsync(Exit.failCause(Cause.interrupt())));
+    };
+  });
+}
+function withScope(runtime, f) {
+  return withScopeAsync(runtime, (scope) => {
+    const out = f(scope);
+    if (out && typeof out === "object" && "_tag" in out) return out;
+    return unit();
+  });
+}
+
 export {
   PushStatus,
   RingBuffer,
@@ -4076,6 +4363,9 @@ export {
   toPromiseByCaller,
   unsafeRunAsync,
   toPromise,
+  setAbortablePromisePerLabelTracking,
+  recordAbortablePromiseStart,
+  recordAbortablePromiseFinish,
   abortablePromiseStats,
   resetAbortablePromiseStats,
   fromPromiseAbortable,
@@ -4085,5 +4375,8 @@ export {
   RuntimeFiber,
   getCurrentFiber,
   unsafeGetCurrentRuntime,
-  withCurrentFiber
+  withCurrentFiber,
+  Scope,
+  withScopeAsync,
+  withScope
 };