brass-runtime 1.14.0 → 1.16.0

package/dist/{chunk-BMRF4FN6.js → chunk-2WC63LJK.mjs}

@@ -1,8 +1,18 @@
+import {
+  raceWith
+} from "./chunk-J3H54ZRV.mjs";
+import {
+  Scope
+} from "./chunk-CCKHV5BT.mjs";
+import {
+  getCurrentFiber,
+  unsafeGetCurrentRuntime,
+  unsafeRunFoldWithEnv
+} from "./chunk-G6IQOE4P.mjs";
 import {
   Cause,
   Exit,
-  Scope,
-  async,
+  asyncEffect,
   asyncFail,
   asyncFlatMap,
   asyncFold,
@@ -11,225 +21,14 @@ import {
   asyncSync,
   fail,
   flatMap,
-  getCurrentFiber,
   map,
   mapError,
   none,
   orElseOptional,
-  raceWith,
   some,
   succeed,
-  sync,
-  unsafeGetCurrentRuntime,
-  unsafeRunFoldWithEnv
-} from "./chunk-JT7D6M5H.js";
-
-// src/core/runtime/combinators.ts
-function sleep(ms) {
-  return async((_env, cb) => {
-    const delay = Math.max(0, Math.floor(ms));
-    const id = setTimeout(() => cb({ _tag: "Success", value: void 0 }), delay);
-    return () => clearTimeout(id);
-  });
-}
-function timeout(effect, ms) {
-  return async((env, cb) => {
-    let done = false;
-    let timerId;
-    let effectRunning = true;
-    timerId = setTimeout(() => {
-      if (done) return;
-      done = true;
-      effectRunning = false;
-      cb({
-        _tag: "Failure",
-        cause: { _tag: "Fail", error: { _tag: "TimeoutError", ms } }
-      });
-    }, Math.max(0, Math.floor(ms)));
-    const runtime = unsafeGetCurrentRuntime();
-    if (runtime) {
-      const fiber = runtime.fork(effect);
-      fiber.join((exit) => {
-        if (done) return;
-        done = true;
-        clearTimeout(timerId);
-        cb(exit);
-      });
-      return () => {
-        if (done) return;
-        done = true;
-        clearTimeout(timerId);
-        fiber.interrupt();
-      };
-    }
-    return () => {
-      if (done) return;
-      done = true;
-      clearTimeout(timerId);
-    };
-  });
-}
-function retry(effect, policy) {
-  const shouldRetry = policy.shouldRetry ?? (() => true);
-  const jitter = policy.jitter ?? "full";
-  const maxElapsedMs = policy.maxElapsedMs;
-  const computeDelay = (attempt) => {
-    const exp = policy.baseDelayMs * Math.pow(2, attempt);
-    const capped = Math.min(exp, policy.maxDelayMs);
-    if (jitter === "none") return capped;
-    return Math.floor(Math.random() * capped);
-  };
-  const loop = (attempt, startedAt) => asyncFold(
-    effect,
-    (error) => {
-      if (attempt >= policy.maxRetries) return asyncFail(error);
-      if (!shouldRetry(error, attempt)) return asyncFail(error);
-      if (maxElapsedMs !== void 0) {
-        const elapsed = performance.now() - startedAt;
-        if (elapsed >= maxElapsedMs) return asyncFail(error);
-      }
-      const delay = computeDelay(attempt);
-      return asyncFlatMap(sleep(delay), () => loop(attempt + 1, startedAt));
-    },
-    (value) => asyncSucceed(value)
-  );
-  return asyncFlatMap(
-    { _tag: "Sync", thunk: () => performance.now() },
-    (startedAt) => loop(0, startedAt)
-  );
-}
-function retryN(effect, n) {
-  return retry(effect, {
-    maxRetries: n,
-    baseDelayMs: 0,
-    maxDelayMs: 0,
-    jitter: "none"
-  });
-}
-function retryWithBackoff(effect, opts = {}) {
-  return retry(effect, {
-    maxRetries: opts.maxRetries ?? 3,
-    baseDelayMs: opts.baseDelayMs ?? 100,
-    maxDelayMs: opts.maxDelayMs ?? 1e4,
-    maxElapsedMs: opts.maxElapsedMs,
-    shouldRetry: opts.shouldRetry,
-    jitter: "full"
-  });
-}
-
-// src/core/runtime/circuitBreaker.ts
-function makeCircuitBreaker(config = {}) {
-  const failureThreshold = config.failureThreshold ?? 5;
-  const resetTimeoutMs = config.resetTimeoutMs ?? 3e4;
-  const successThreshold = config.successThreshold ?? 1;
-  const isFailure = config.isFailure ?? (() => true);
-  const onStateChange = config.onStateChange;
-  let currentState = "closed";
-  let consecutiveFailures = 0;
-  let consecutiveSuccesses = 0;
-  let openedAt = 0;
-  let totalRequests = 0;
-  let totalFailures = 0;
-  let totalSuccesses = 0;
-  let totalRejected = 0;
-  let lastFailureTime = null;
-  let lastSuccessTime = null;
-  const transition = (to) => {
-    if (currentState === to) return;
-    const from = currentState;
-    currentState = to;
-    onStateChange?.(from, to);
-  };
-  const onSuccess = () => {
-    totalSuccesses++;
-    lastSuccessTime = Date.now();
-    consecutiveFailures = 0;
-    if (currentState === "half-open") {
-      consecutiveSuccesses++;
-      if (consecutiveSuccesses >= successThreshold) {
-        consecutiveSuccesses = 0;
-        transition("closed");
-      }
-    }
-  };
-  const onFailure = (error) => {
-    if (!isFailure(error)) {
-      onSuccess();
-      return;
-    }
-    totalFailures++;
-    lastFailureTime = Date.now();
-    consecutiveSuccesses = 0;
-    consecutiveFailures++;
-    if (currentState === "half-open") {
-      openedAt = Date.now();
-      transition("open");
-    } else if (currentState === "closed" && consecutiveFailures >= failureThreshold) {
-      openedAt = Date.now();
-      transition("open");
-    }
-  };
-  const shouldAllow = () => {
-    switch (currentState) {
-      case "closed":
-        return true;
-      case "open": {
-        const elapsed = Date.now() - openedAt;
-        if (elapsed >= resetTimeoutMs) {
-          transition("half-open");
-          return true;
-        }
-        return false;
-      }
-      case "half-open":
-        return true;
-    }
-  };
-  const protect = (effect) => {
-    totalRequests++;
-    if (!shouldAllow()) {
-      totalRejected++;
-      return asyncFail({
-        _tag: "CircuitBreakerOpen",
-        openSince: openedAt,
-        failures: consecutiveFailures
-      });
-    }
-    return asyncFold(
-      effect,
-      (error) => {
-        onFailure(error);
-        return asyncFail(error);
-      },
-      (value) => {
-        onSuccess();
-        return asyncSucceed(value);
-      }
-    );
-  };
-  const stats = () => ({
-    state: currentState,
-    failures: consecutiveFailures,
-    successes: consecutiveSuccesses,
-    totalRequests,
-    totalFailures,
-    totalSuccesses,
-    totalRejected,
-    lastFailureTime,
-    lastSuccessTime
-  });
-  const reset = () => {
-    consecutiveFailures = 0;
-    consecutiveSuccesses = 0;
-    transition("closed");
-  };
-  return {
-    state: () => currentState,
-    protect,
-    stats,
-    reset
-  };
-}
+  sync
+} from "./chunk-NOYZIMUJ.mjs";
 
 // src/core/stream/stream.ts
 var widenOpt = (opt) => opt._tag === "None" ? none : some(opt.value);
@@ -280,7 +79,7 @@ function streamToRaceWithHandler(winnerSide, leftStream, rightStream, flip, id)
       return asyncSucceed([a, next]);
     }
     if (exit.cause._tag === "Interrupt") {
-      return async((_env, cb) => {
+      return asyncEffect((_env, cb) => {
         cb(Exit.failCause(Cause.interrupt()));
       });
     }
@@ -295,7 +94,7 @@ function makeMergePull(onLeft, onRight, flip, mergePullId) {
   const id = ++mergePullId;
   const onLeftHandler = streamToRaceWithHandler("L", onLeft, onRight, flip, id);
   const onRightHandler = streamToRaceWithHandler("R", onLeft, onRight, flip, id);
-  return async((_env, cb) => {
+  return asyncEffect((_env, cb) => {
     const runtime = unsafeGetCurrentRuntime();
     const scope = new Scope(runtime);
     const handler = raceWith(
@@ -356,7 +155,7 @@ function uncons(self) {
     case "Merge":
       return makeMergePull(self.left, self.right, self.flip, 0);
     case "Scoped":
-      return async((env, cb) => {
+      return asyncEffect((env, cb) => {
         const runtime = unsafeGetCurrentRuntime();
         const scope = new Scope(runtime);
         const fiber = getCurrentFiber();
@@ -377,7 +176,7 @@ function uncons(self) {
           scope.close(exit);
         };
         const wrap = (s) => fromPull(
-          async((env2, cb2) => {
+          asyncEffect((env2, cb2) => {
             const pull = uncons(s);
             unsafeRunFoldWithEnv(
               pull,
@@ -405,7 +204,7 @@ function uncons(self) {
         });
       });
     case "Managed":
-      return async((env, cb) => {
+      return asyncEffect((env, cb) => {
         const runtime = unsafeGetCurrentRuntime();
         const scope = new Scope(runtime);
         getCurrentFiber()?.addFinalizer((exit) => {
@@ -433,16 +232,19 @@ function uncons(self) {
           const { stream: inner, release } = ex.value;
           scope.addFinalizer((exit) => release(exit));
           const wrap = (s) => fromPull(
-            async((env2, cb2) => {
-              uncons(s)(env2, (ex2) => {
-                if (ex2._tag === "Failure") {
+            asyncEffect((env2, cb2) => {
+              unsafeRunFoldWithEnv(
+                uncons(s),
+                env2,
+                (cause) => {
+                  const ex2 = Exit.failCause(cause);
                   closeWith(ex2);
                   cb2(ex2);
-                  return;
+                },
+                ([a, tail]) => {
+                  cb2(Exit.succeed([a, wrap(tail)]));
                 }
-                const [a, tail] = ex2.value;
-                cb2(Exit.succeed([a, wrap(tail)]));
-              });
+              );
             })
           );
           unsafeGetCurrentRuntime().fork(uncons(wrap(inner))).join(cb);
@@ -602,49 +404,73 @@ function drainStreamSyncFull(stream) {
     }
   }
 }
-function readerStream(reader, normalizeError) {
-  const pull = async((_, cb) => {
-    reader.read().then(({ done, value }) => {
-      if (done) {
-        cb({ _tag: "Failure", cause: { _tag: "Fail", error: none } });
+function readerStream(reader, normalizeError, signal) {
+  const pull = asyncEffect((_, cb) => {
+    let done = false;
+    const cleanup = () => signal?.removeEventListener("abort", abort);
+    const finish = (exit) => {
+      if (done) return;
+      done = true;
+      cleanup();
+      cb(exit);
+    };
+    const abort = () => {
+      try {
+        reader.cancel();
+      } catch {
+      }
+      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;
+    }
+    signal?.addEventListener("abort", abort, { once: true });
+    reader.read().then(({ done: done2, value }) => {
+      if (done2) {
+        finish({ _tag: "Failure", cause: { _tag: "Fail", error: none } });
         return;
       }
-      cb({
+      finish({
         _tag: "Success",
         value: [value, fromPull(pull)]
       });
     }).catch((e) => {
-      cb({ _tag: "Failure", cause: { _tag: "Fail", error: some(normalizeError(e)) } });
+      finish({ _tag: "Failure", cause: { _tag: "Fail", error: some(normalizeError(e)) } });
     });
+    return () => {
+      cleanup();
+      try {
+        reader.cancel();
+      } catch {
+      }
+    };
   });
   return fromPull(pull);
 }
-function streamFromReadableStream(body, normalizeError) {
+function streamFromReadableStream(body, normalizeError, options = {}) {
   if (!body) return emptyStream();
   let reader;
   return unwrapScoped(
     // acquire: produce un ZStream
     sync(() => {
       reader = body.getReader();
-      return readerStream(reader, normalizeError);
+      return readerStream(reader, normalizeError, options.signal);
     }),
     // release: se corre en fin / error / interrupción
     () => asyncSync(() => {
       try {
         reader?.cancel();
       } catch {
+      } finally {
+        options.onRelease?.();
       }
     })
   );
 }
 
 export {
-  sleep,
-  timeout,
-  retry,
-  retryN,
-  retryWithBackoff,
-  makeCircuitBreaker,
   widenOpt,
   fromPull,
   unwrapScoped,

package/dist/chunk-3RG5ZIWI.js

@@ -0,0 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};

package/dist/chunk-45F7OKGT.cjs

@@ -0,0 +1,104 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkWQ5QNU5Rcjs = require('./chunk-WQ5QNU5R.cjs');
+
+
+
+
+
+
+var _chunkDJQ7OMMBcjs = require('./chunk-DJQ7OMMB.cjs');
+
+// src/core/runtime/combinators.ts
+function sleep(ms) {
+  return _chunkDJQ7OMMBcjs.asyncEffect.call(void 0, (_env, cb) => {
+    const delay = Math.max(0, Math.floor(ms));
+    const id = setTimeout(() => cb({ _tag: "Success", value: void 0 }), delay);
+    return () => clearTimeout(id);
+  });
+}
+function timeout(effect, ms) {
+  return _chunkDJQ7OMMBcjs.asyncEffect.call(void 0, (env, cb) => {
+    let done = false;
+    let timerId;
+    let effectRunning = true;
+    timerId = setTimeout(() => {
+      if (done) return;
+      done = true;
+      effectRunning = false;
+      cb({
+        _tag: "Failure",
+        cause: { _tag: "Fail", error: { _tag: "TimeoutError", ms } }
+      });
+    }, Math.max(0, Math.floor(ms)));
+    const runtime = _chunkWQ5QNU5Rcjs.unsafeGetCurrentRuntime.call(void 0, );
+    const fiber = runtime.fork(effect);
+    fiber.join((exit) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timerId);
+      cb(exit);
+    });
+    return () => {
+      if (done) return;
+      done = true;
+      clearTimeout(timerId);
+      fiber.interrupt();
+    };
+  });
+}
+function retry(effect, policy) {
+  const shouldRetry = _nullishCoalesce(policy.shouldRetry, () => ( (() => true)));
+  const jitter = _nullishCoalesce(policy.jitter, () => ( "full"));
+  const maxElapsedMs = policy.maxElapsedMs;
+  const computeDelay = (attempt) => {
+    const exp = policy.baseDelayMs * Math.pow(2, attempt);
+    const capped = Math.min(exp, policy.maxDelayMs);
+    if (jitter === "none") return capped;
+    return Math.floor(Math.random() * capped);
+  };
+  const loop = (attempt, startedAt) => _chunkDJQ7OMMBcjs.asyncFold.call(void 0, 
+    effect,
+    (error) => {
+      if (attempt >= policy.maxRetries) return _chunkDJQ7OMMBcjs.asyncFail.call(void 0, error);
+      if (!shouldRetry(error, attempt)) return _chunkDJQ7OMMBcjs.asyncFail.call(void 0, error);
+      if (maxElapsedMs !== void 0) {
+        const elapsed = performance.now() - startedAt;
+        if (elapsed >= maxElapsedMs) return _chunkDJQ7OMMBcjs.asyncFail.call(void 0, error);
+      }
+      const delay = computeDelay(attempt);
+      return _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, sleep(delay), () => loop(attempt + 1, startedAt));
+    },
+    (value) => _chunkDJQ7OMMBcjs.asyncSucceed.call(void 0, value)
+  );
+  return _chunkDJQ7OMMBcjs.asyncFlatMap.call(void 0, 
+    { _tag: "Sync", thunk: () => performance.now() },
+    (startedAt) => loop(0, startedAt)
+  );
+}
+function retryN(effect, n) {
+  return retry(effect, {
+    maxRetries: n,
+    baseDelayMs: 0,
+    maxDelayMs: 0,
+    jitter: "none"
+  });
+}
+function retryWithBackoff(effect, opts = {}) {
+  return retry(effect, {
+    maxRetries: _nullishCoalesce(opts.maxRetries, () => ( 3)),
+    baseDelayMs: _nullishCoalesce(opts.baseDelayMs, () => ( 100)),
+    maxDelayMs: _nullishCoalesce(opts.maxDelayMs, () => ( 1e4)),
+    maxElapsedMs: opts.maxElapsedMs,
+    shouldRetry: opts.shouldRetry,
+    jitter: "full"
+  });
+}
+
+
+
+
+
+
+
+exports.sleep = sleep; exports.timeout = timeout; exports.retry = retry; exports.retryN = retryN; exports.retryWithBackoff = retryWithBackoff;