brass-runtime 1.15.0 → 1.16.1

package/dist/{chunk-4NHES7VK.mjs → chunk-7JIJOVCT.js}

@@ -1,10 +1,17 @@
 import {
   raceWith
-} from "./chunk-ELOOF35R.mjs";
+} from "./chunk-UCUBNWM2.js";
+import {
+  Scope
+} from "./chunk-L2SYFEBS.js";
+import {
+  getCurrentFiber,
+  unsafeGetCurrentRuntime,
+  unsafeRunFoldWithEnv
+} from "./chunk-FH2X7BVP.js";
 import {
   Cause,
   Exit,
-  Scope,
   asyncEffect,
   asyncFail,
   asyncFlatMap,
@@ -14,17 +21,14 @@ import {
   asyncSync,
   fail,
   flatMap,
-  getCurrentFiber,
   map,
   mapError,
   none,
   orElseOptional,
   some,
   succeed,
-  sync,
-  unsafeGetCurrentRuntime,
-  unsafeRunFoldWithEnv
-} from "./chunk-BDF4AMWX.mjs";
+  sync
+} from "./chunk-UB4B6OFY.js";
 
 // src/core/stream/stream.ts
 var widenOpt = (opt) => opt._tag === "None" ? none : some(opt.value);
@@ -74,12 +78,18 @@ function streamToRaceWithHandler(winnerSide, leftStream, rightStream, flip, id)
       const next = winnerSide === "L" ? fromPull(makeMergePull(tailWin, rightStream, !flip, id)) : fromPull(makeMergePull(leftStream, tailWin, !flip, id));
       return asyncSucceed([a, next]);
     }
-    if (exit.cause._tag === "Interrupt") {
+    if (Cause.isInterruptedOnly(exit.cause)) {
       return asyncEffect((_env, cb) => {
         cb(Exit.failCause(Cause.interrupt()));
       });
     }
-    const opt = exit.cause.error;
+    const failure = Cause.firstFailure(exit.cause);
+    if (failure._tag === "None") {
+      return asyncEffect((_env, cb) => {
+        cb(Exit.failCause(exit.cause));
+      });
+    }
+    const opt = failure.value;
     if (opt._tag === "None") {
       return winnerSide === "L" ? uncons(rightStream) : uncons(leftStream);
     }
@@ -163,7 +173,8 @@ function uncons(self) {
         });
         const closeWith = (exit) => {
           if (exit._tag === "Failure") {
-            const err = exit.cause.error;
+            const failure = Cause.firstFailure(exit.cause);
+            const err = failure._tag === "Some" ? failure.value : void 0;
             if (err && typeof err === "object" && err._tag === "None") {
               scope.close({ _tag: "Success", value: void 0 });
               return;
@@ -191,7 +202,8 @@ function uncons(self) {
         scope.fork(self.acquire).join((ex) => {
           if (ex._tag === "Failure") {
             closeWith(ex);
-            cb({ _tag: "Failure", cause: { _tag: "Fail", error: some(ex.cause.error) } });
+            const failure = Cause.firstFailure(ex.cause);
+            cb(failure._tag === "Some" ? { _tag: "Failure", cause: Cause.fail(some(failure.value)) } : { _tag: "Failure", cause: ex.cause });
             return;
           }
           scope.addFinalizer((exit) => self.release(exit));
@@ -211,7 +223,8 @@ function uncons(self) {
         });
         const closeWith = (exit) => {
           if (exit._tag === "Failure") {
-            const err = exit.cause.error;
+            const failure = Cause.firstFailure(exit.cause);
+            const err = failure._tag === "Some" ? failure.value : void 0;
             if (err && typeof err === "object" && err._tag === "None") {
               scope.close({ _tag: "Success", value: void 0 });
               return;
@@ -222,7 +235,8 @@ function uncons(self) {
         scope.fork(self.acquire).join((ex) => {
           if (ex._tag === "Failure") {
             scope.close(ex);
-            cb({ _tag: "Failure", cause: { _tag: "Fail", error: some(ex.cause.error) } });
+            const failure = Cause.firstFailure(ex.cause);
+            cb(failure._tag === "Some" ? { _tag: "Failure", cause: Cause.fail(some(failure.value)) } : { _tag: "Failure", cause: ex.cause });
             return;
           }
           const { stream: inner, release } = ex.value;

package/dist/chunk-A2OM6NEH.mjs

@@ -0,0 +1,194 @@
+import {
+  getCurrentFiber
+} from "./chunk-GYM3LLGS.mjs";
+import {
+  Cause,
+  Exit,
+  asyncEffect,
+  asyncFlatMap,
+  asyncFold,
+  unit
+} from "./chunk-36I3M4UC.mjs";
+
+// 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 {
+  Scope,
+  withScopeAsync,
+  withScope
+};