brass-runtime 1.13.8 → 1.15.0

package/dist/{chunk-INZBKOHY.js → chunk-K6M7MDZ4.mjs}

@@ -1,7 +1,10 @@
+import {
+  race
+} from "./chunk-ELOOF35R.mjs";
 import {
   Cause,
   Exit,
-  async,
+  asyncEffect,
   asyncFail,
   asyncFlatMap,
   asyncFold,
@@ -9,9 +12,8 @@ import {
   asyncSucceed,
   asyncSync,
   fromPromiseAbortable,
-  race,
   withScopeAsync
-} from "./chunk-L6KKKM66.js";
+} from "./chunk-BDF4AMWX.mjs";
 
 // src/agent/core/state.ts
 var initialAgentState = (goal) => ({
@@ -1425,10 +1427,10 @@ var decideNextAction = (state) => {
 };
 
 // src/agent/core/events.ts
-var nowMillis = () => async((_env, cb) => {
+var nowMillis = () => asyncEffect((_env, cb) => {
   cb({ _tag: "Success", value: Date.now() });
 });
-var emitAgentEvent = (event) => async((env, cb) => {
+var emitAgentEvent = (event) => asyncEffect((env, cb) => {
   try {
     env.events?.emit(event);
   } catch {
@@ -1684,7 +1686,7 @@ var retry = (make, options) => {
 };
 
 // src/agent/tools/timeout.ts
-var sleep = (ms) => async((_env, cb) => {
+var sleep = (ms) => asyncEffect((_env, cb) => {
   const id = setTimeout(() => cb({ _tag: "Success", value: void 0 }), ms);
   return () => clearTimeout(id);
 });
@@ -2124,7 +2126,7 @@ var chunkToString = (chunk) => {
   return typeof maybeToString === "function" ? maybeToString.call(chunk, "utf8") : String(chunk);
 };
 var NodeShell = {
-  exec: (command, options) => async((_env, cb) => {
+  exec: (command, options) => asyncEffect((_env, cb) => {
     const [bin, ...args] = command;
     if (!bin) {
       cb(

package/dist/chunk-MS34J5LY.cjs

@@ -0,0 +1,224 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+var _chunkTGIFUAK4cjs = require('./chunk-TGIFUAK4.cjs');
+
+// src/core/runtime/combinators.ts
+function sleep(ms) {
+  return _chunkTGIFUAK4cjs.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 _chunkTGIFUAK4cjs.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 = _chunkTGIFUAK4cjs.unsafeGetCurrentRuntime.call(void 0, );
+    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 = _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) => _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+    effect,
+    (error) => {
+      if (attempt >= policy.maxRetries) return _chunkTGIFUAK4cjs.asyncFail.call(void 0, error);
+      if (!shouldRetry(error, attempt)) return _chunkTGIFUAK4cjs.asyncFail.call(void 0, error);
+      if (maxElapsedMs !== void 0) {
+        const elapsed = performance.now() - startedAt;
+        if (elapsed >= maxElapsedMs) return _chunkTGIFUAK4cjs.asyncFail.call(void 0, error);
+      }
+      const delay = computeDelay(attempt);
+      return _chunkTGIFUAK4cjs.asyncFlatMap.call(void 0, sleep(delay), () => loop(attempt + 1, startedAt));
+    },
+    (value) => _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, value)
+  );
+  return _chunkTGIFUAK4cjs.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"
+  });
+}
+
+// src/core/runtime/circuitBreaker.ts
+function makeCircuitBreaker(config = {}) {
+  const failureThreshold = _nullishCoalesce(config.failureThreshold, () => ( 5));
+  const resetTimeoutMs = _nullishCoalesce(config.resetTimeoutMs, () => ( 3e4));
+  const successThreshold = _nullishCoalesce(config.successThreshold, () => ( 1));
+  const isFailure = _nullishCoalesce(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;
+    _optionalChain([onStateChange, 'optionalCall', _ => _(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 _chunkTGIFUAK4cjs.asyncFail.call(void 0, {
+        _tag: "CircuitBreakerOpen",
+        openSince: openedAt,
+        failures: consecutiveFailures
+      });
+    }
+    return _chunkTGIFUAK4cjs.asyncFold.call(void 0, 
+      effect,
+      (error) => {
+        onFailure(error);
+        return _chunkTGIFUAK4cjs.asyncFail.call(void 0, error);
+      },
+      (value) => {
+        onSuccess();
+        return _chunkTGIFUAK4cjs.asyncSucceed.call(void 0, 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
+  };
+}
+
+
+
+
+
+
+
+
+exports.sleep = sleep; exports.timeout = timeout; exports.retry = retry; exports.retryN = retryN; exports.retryWithBackoff = retryWithBackoff; exports.makeCircuitBreaker = makeCircuitBreaker;

package/dist/{chunk-XNOTJSMZ.mjs → chunk-PPUXIH5R.js}

@@ -1,8 +1,11 @@
+import {
+  raceWith
+} from "./chunk-TO7IKXYT.js";
 import {
   Cause,
   Exit,
   Scope,
-  async,
+  asyncEffect,
   asyncFail,
   asyncFlatMap,
   asyncFold,
@@ -16,13 +19,12 @@ import {
   mapError,
   none,
   orElseOptional,
-  raceWith,
   some,
   succeed,
   sync,
   unsafeGetCurrentRuntime,
   unsafeRunFoldWithEnv
-} from "./chunk-7F2R7A2V.mjs";
+} from "./chunk-BMH5AV44.js";
 
 // src/core/stream/stream.ts
 var widenOpt = (opt) => opt._tag === "None" ? none : some(opt.value);
@@ -73,7 +75,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()));
       });
     }
@@ -88,7 +90,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(
@@ -111,6 +113,12 @@ function uncons(self) {
   switch (self._tag) {
     case "Empty":
       return fail(none);
+    case "FromArray": {
+      const arr = self.values;
+      if (arr.length === 0) return fail(none);
+      const tail = arr.length === 1 ? EMPTY_STREAM : { _tag: "FromArray", values: arr.slice(1) };
+      return succeed([arr[0], tail]);
+    }
     case "Emit":
       return map(
         mapError(self.value, (e) => some(e)),
@@ -143,7 +151,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();
@@ -164,7 +172,7 @@ function uncons(self) {
           scope.close(exit);
         };
         const wrap = (s) => fromPull(
-          async((env2, cb2) => {
+          asyncEffect((env2, cb2) => {
             const pull = uncons(s);
             unsafeRunFoldWithEnv(
               pull,
@@ -192,7 +200,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) => {
@@ -220,16 +228,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);
@@ -244,6 +255,8 @@ function mapStream(self, f) {
   switch (self._tag) {
     case "Empty":
       return emptyStream();
+    case "FromArray":
+      return { _tag: "FromArray", values: self.values.map(f) };
     case "Emit":
       return emitStream(map(self.value, f));
     case "FromPull":
@@ -327,58 +340,127 @@ function foreachStream(stream, f) {
   );
 }
 function fromArray(values) {
-  let s = emptyStream();
-  for (let i = values.length - 1; i >= 0; i--) {
-    const head = emitStream(succeed(values[i]));
-    s = concatStream(head, s);
-  }
-  return s;
+  if (values.length === 0) return emptyStream();
+  return { _tag: "FromArray", values };
 }
 function collectStream(stream) {
+  const syncResult = drainStreamSyncFull(stream);
+  if (syncResult !== null) {
+    return asyncSucceed(syncResult);
+  }
   const loop = (cur, acc) => asyncFold(
     uncons(cur),
     (opt) => {
       if (opt._tag === "None") return succeed(acc);
       return fail(opt);
     },
-    ([a, tail]) => loop(tail, [...acc, a])
+    ([a, tail]) => {
+      acc.push(a);
+      return loop(tail, acc);
+    }
   );
   return mapError(loop(stream, []), (opt) => {
     if (opt._tag === "Some") return opt.value;
     throw new Error("unreachable: stream end handled as success");
   });
 }
-function readerStream(reader, normalizeError) {
-  const pull = async((_, cb) => {
-    reader.read().then(({ done, value }) => {
-      if (done) {
-        cb({ _tag: "Failure", cause: { _tag: "Fail", error: none } });
+function drainStreamSyncFull(stream) {
+  const result = [];
+  let cur = stream;
+  while (true) {
+    switch (cur._tag) {
+      case "Empty":
+        return result;
+      case "FromArray": {
+        const arr = cur.values;
+        for (let i = 0; i < arr.length; i++) {
+          result.push(arr[i]);
+        }
+        return result;
+      }
+      case "Emit": {
+        const zio = cur.value;
+        if (zio._tag === "Succeed") {
+          result.push(zio.value);
+          return result;
+        }
+        return null;
+      }
+      case "Concat": {
+        const leftItems = drainStreamSyncFull(cur.left);
+        if (leftItems === null) return null;
+        for (let i = 0; i < leftItems.length; i++) {
+          result.push(leftItems[i]);
+        }
+        cur = cur.right;
+        break;
+      }
+      default:
+        return null;
+    }
+  }
+}
+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?.();
       }
     })
   );

package/dist/chunk-R3R2FVLG.cjs

@@ -0,0 +1,131 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkTGIFUAK4cjs = require('./chunk-TGIFUAK4.cjs');
+
+// src/core/stream/structuredConcurrency.ts
+function race(left, right, parentScope) {
+  return _chunkTGIFUAK4cjs.asyncEffect.call(void 0, (env, cb) => {
+    const scope = parentScope.subScope();
+    let done = false;
+    const onResult = (exit) => {
+      if (done) return;
+      done = true;
+      scope.close(exit);
+      cb(exit);
+    };
+    const fiberLeft = scope.fork(left);
+    const fiberRight = scope.fork(right);
+    fiberLeft.join(onResult);
+    fiberRight.join(onResult);
+  });
+}
+function zipPar(left, right, parentScope) {
+  return _chunkTGIFUAK4cjs.asyncEffect.call(void 0, (env, cb) => {
+    const scope = parentScope.subScope();
+    let leftExit = null;
+    let rightExit = null;
+    let done = false;
+    const checkDone = () => {
+      if (!leftExit || !rightExit || done) return;
+      done = true;
+      if (leftExit._tag === "Success" && rightExit._tag === "Success") {
+        scope.close({ _tag: "Success", value: void 0 });
+        cb({
+          _tag: "Success",
+          value: [leftExit.value, rightExit.value]
+        });
+        return;
+      }
+      let cause;
+      if (leftExit._tag === "Failure") {
+        cause = leftExit.cause;
+      } else if (rightExit._tag === "Failure") {
+        cause = rightExit.cause;
+      } else {
+        throw new Error("zipPar: unreachable state (no Failure exit)");
+      }
+      const errExit = {
+        _tag: "Failure",
+        cause
+      };
+      scope.close(errExit);
+      cb(errExit);
+    };
+    const f1 = scope.fork(left);
+    const f2 = scope.fork(right);
+    f1.join((exit) => {
+      leftExit = exit;
+      checkDone();
+    });
+    f2.join((exit) => {
+      rightExit = exit;
+      checkDone();
+    });
+  });
+}
+function collectAllPar(effects, parentScope) {
+  return _chunkTGIFUAK4cjs.asyncEffect.call(void 0, (env, cb) => {
+    const scope = parentScope.subScope();
+    const results = new Array(effects.length);
+    let completed = 0;
+    let done = false;
+    effects.forEach((eff, i) => {
+      const f = scope.fork(eff);
+      f.join((exit) => {
+        if (done) return;
+        if (exit._tag === "Failure") {
+          done = true;
+          const errExit = {
+            _tag: "Failure",
+            cause: exit.cause
+          };
+          scope.close(errExit);
+          cb(errExit);
+          return;
+        }
+        results[i] = exit.value;
+        completed++;
+        if (completed === effects.length) {
+          done = true;
+          const successExit = {
+            _tag: "Success",
+            value: results
+          };
+          scope.close({ _tag: "Success", value: void 0 });
+          cb(successExit);
+        }
+      });
+    });
+  });
+}
+function raceWith(left, right, parentScope, onLeft, onRight) {
+  return _chunkTGIFUAK4cjs.asyncEffect.call(void 0, (env, cb) => {
+    const scope = parentScope.subScope();
+    let done = false;
+    const fiberLeft = scope.fork(left);
+    const fiberRight = scope.fork(right);
+    const finish = (next) => {
+      scope.fork(next).join((exitNext) => {
+        scope.close(exitNext);
+        cb(exitNext);
+      });
+    };
+    fiberLeft.join((exitL) => {
+      if (done) return;
+      done = true;
+      finish(onLeft(exitL, fiberRight, scope));
+    });
+    fiberRight.join((exitR) => {
+      if (done) return;
+      done = true;
+      finish(onRight(exitR, fiberLeft, scope));
+    });
+  });
+}
+
+
+
+
+
+
+exports.race = race; exports.zipPar = zipPar; exports.collectAllPar = collectAllPar; exports.raceWith = raceWith;