brass-runtime 1.16.1 → 1.18.0

package/dist/chunk-L2SYFEBS.js

@@ -1,194 +0,0 @@
-import {
-  getCurrentFiber
-} from "./chunk-FH2X7BVP.js";
-import {
-  Cause,
-  Exit,
-  asyncEffect,
-  asyncFlatMap,
-  asyncFold,
-  unit
-} from "./chunk-UB4B6OFY.js";
-
-// 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
-};