brass-runtime 1.13.8 → 1.14.0

package/dist/{chunk-3R7ZYRK2.mjs → chunk-MQF7HZ7Y.mjs}

@@ -11,7 +11,7 @@ import {
   fromPromiseAbortable,
   race,
   withScopeAsync
-} from "./chunk-7F2R7A2V.mjs";
+} from "./chunk-4N2JEK4H.mjs";
 
 // src/agent/core/state.ts
 var initialAgentState = (goal) => ({

package/dist/chunk-SKVY72E5.cjs

@@ -0,0 +1,667 @@
+"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 _chunkBKBFSOGTcjs = require('./chunk-BKBFSOGT.cjs');
+
+// src/core/runtime/combinators.ts
+function sleep(ms) {
+  return _chunkBKBFSOGTcjs.async.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 _chunkBKBFSOGTcjs.async.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 = _chunkBKBFSOGTcjs.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) => _chunkBKBFSOGTcjs.asyncFold.call(void 0, 
+    effect,
+    (error) => {
+      if (attempt >= policy.maxRetries) return _chunkBKBFSOGTcjs.asyncFail.call(void 0, error);
+      if (!shouldRetry(error, attempt)) return _chunkBKBFSOGTcjs.asyncFail.call(void 0, error);
+      if (maxElapsedMs !== void 0) {
+        const elapsed = performance.now() - startedAt;
+        if (elapsed >= maxElapsedMs) return _chunkBKBFSOGTcjs.asyncFail.call(void 0, error);
+      }
+      const delay = computeDelay(attempt);
+      return _chunkBKBFSOGTcjs.asyncFlatMap.call(void 0, sleep(delay), () => loop(attempt + 1, startedAt));
+    },
+    (value) => _chunkBKBFSOGTcjs.asyncSucceed.call(void 0, value)
+  );
+  return _chunkBKBFSOGTcjs.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', _2 => _2(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 _chunkBKBFSOGTcjs.asyncFail.call(void 0, {
+        _tag: "CircuitBreakerOpen",
+        openSince: openedAt,
+        failures: consecutiveFailures
+      });
+    }
+    return _chunkBKBFSOGTcjs.asyncFold.call(void 0, 
+      effect,
+      (error) => {
+        onFailure(error);
+        return _chunkBKBFSOGTcjs.asyncFail.call(void 0, error);
+      },
+      (value) => {
+        onSuccess();
+        return _chunkBKBFSOGTcjs.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
+  };
+}
+
+// src/core/stream/stream.ts
+var widenOpt = (opt) => opt._tag === "None" ? _chunkBKBFSOGTcjs.none : _chunkBKBFSOGTcjs.some.call(void 0, opt.value);
+var fromPull = (pull) => ({
+  _tag: "FromPull",
+  pull
+});
+var unwrapScoped = (acquire, release) => ({
+  _tag: "Scoped",
+  acquire,
+  release
+});
+var managedStream = (acquire) => ({
+  _tag: "Managed",
+  acquire
+});
+var mergeStream = (left, right, flip = true) => ({
+  _tag: "Merge",
+  left,
+  right,
+  flip
+});
+var EMPTY_STREAM = { _tag: "Empty" };
+var emptyStream = () => EMPTY_STREAM;
+var emitStream = (value) => ({
+  _tag: "Emit",
+  value
+});
+var concatStream = (left, right) => ({
+  _tag: "Concat",
+  left,
+  right
+});
+var flattenStream = (stream) => ({
+  _tag: "Flatten",
+  stream
+});
+function streamToRaceWithHandler(winnerSide, leftStream, rightStream, flip, id) {
+  return (exit, otherFiber, scope) => {
+    if (exit._tag === "Failure") {
+    }
+    if (exit._tag === "Success") {
+    }
+    if (exit._tag === "Success") {
+      const [a, tailWin] = exit.value;
+      otherFiber.interrupt();
+      const next = winnerSide === "L" ? fromPull(makeMergePull(tailWin, rightStream, !flip, id)) : fromPull(makeMergePull(leftStream, tailWin, !flip, id));
+      return _chunkBKBFSOGTcjs.asyncSucceed.call(void 0, [a, next]);
+    }
+    if (exit.cause._tag === "Interrupt") {
+      return _chunkBKBFSOGTcjs.async.call(void 0, (_env, cb) => {
+        cb(_chunkBKBFSOGTcjs.Exit.failCause(_chunkBKBFSOGTcjs.Cause.interrupt()));
+      });
+    }
+    const opt = exit.cause.error;
+    if (opt._tag === "None") {
+      return winnerSide === "L" ? uncons(rightStream) : uncons(leftStream);
+    }
+    return _chunkBKBFSOGTcjs.asyncFail.call(void 0, opt);
+  };
+}
+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 _chunkBKBFSOGTcjs.async.call(void 0, (_env, cb) => {
+    const runtime = _chunkBKBFSOGTcjs.unsafeGetCurrentRuntime.call(void 0, );
+    const scope = new (0, _chunkBKBFSOGTcjs.Scope)(runtime);
+    const handler = _chunkBKBFSOGTcjs.raceWith.call(void 0, 
+      uncons(onLeft),
+      uncons(onRight),
+      scope,
+      onLeftHandler,
+      onRightHandler
+    );
+    scope.fork(handler).join((ex) => {
+      scope.close(ex);
+      cb(ex);
+    });
+  });
+}
+function merge(left, right) {
+  return fromPull(makeMergePull(left, right, true, 0));
+}
+function uncons(self) {
+  switch (self._tag) {
+    case "Empty":
+      return _chunkBKBFSOGTcjs.fail.call(void 0, _chunkBKBFSOGTcjs.none);
+    case "FromArray": {
+      const arr = self.values;
+      if (arr.length === 0) return _chunkBKBFSOGTcjs.fail.call(void 0, _chunkBKBFSOGTcjs.none);
+      const tail = arr.length === 1 ? EMPTY_STREAM : { _tag: "FromArray", values: arr.slice(1) };
+      return _chunkBKBFSOGTcjs.succeed.call(void 0, [arr[0], tail]);
+    }
+    case "Emit":
+      return _chunkBKBFSOGTcjs.map.call(void 0, 
+        _chunkBKBFSOGTcjs.mapError.call(void 0, self.value, (e) => _chunkBKBFSOGTcjs.some.call(void 0, e)),
+        (a) => [a, EMPTY_STREAM]
+      );
+    case "FromPull":
+      return self.pull;
+    case "Concat":
+      return _chunkBKBFSOGTcjs.orElseOptional.call(void 0, 
+        _chunkBKBFSOGTcjs.map.call(void 0, 
+          uncons(self.left),
+          ([a, tail]) => [a, concatStream(tail, self.right)]
+        ),
+        () => uncons(self.right)
+      );
+    case "Flatten":
+      return _chunkBKBFSOGTcjs.flatMap.call(void 0, 
+        uncons(self.stream),
+        ([head, tail]) => _chunkBKBFSOGTcjs.orElseOptional.call(void 0, 
+          _chunkBKBFSOGTcjs.map.call(void 0, 
+            uncons(head),
+            ([a, as]) => [
+              a,
+              concatStream(as, flattenStream(tail))
+            ]
+          ),
+          () => uncons(flattenStream(tail))
+        )
+      );
+    case "Merge":
+      return makeMergePull(self.left, self.right, self.flip, 0);
+    case "Scoped":
+      return _chunkBKBFSOGTcjs.async.call(void 0, (env, cb) => {
+        const runtime = _chunkBKBFSOGTcjs.unsafeGetCurrentRuntime.call(void 0, );
+        const scope = new (0, _chunkBKBFSOGTcjs.Scope)(runtime);
+        const fiber = _chunkBKBFSOGTcjs.getCurrentFiber.call(void 0, );
+        _optionalChain([fiber, 'optionalAccess', _3 => _3.addFinalizer, 'call', _4 => _4((exit) => {
+          try {
+            scope.close(exit);
+          } catch (e3) {
+          }
+        })]);
+        const closeWith = (exit) => {
+          if (exit._tag === "Failure") {
+            const err = exit.cause.error;
+            if (err && typeof err === "object" && err._tag === "None") {
+              scope.close({ _tag: "Success", value: void 0 });
+              return;
+            }
+          }
+          scope.close(exit);
+        };
+        const wrap = (s) => fromPull(
+          _chunkBKBFSOGTcjs.async.call(void 0, (env2, cb2) => {
+            const pull = uncons(s);
+            _chunkBKBFSOGTcjs.unsafeRunFoldWithEnv.call(void 0, 
+              pull,
+              env2,
+              (cause) => {
+                const ex = _chunkBKBFSOGTcjs.Exit.failCause(cause);
+                closeWith(ex);
+                cb2(ex);
+              },
+              ([a, tail]) => {
+                cb2(_chunkBKBFSOGTcjs.Exit.succeed([a, wrap(tail)]));
+              }
+            );
+          })
+        );
+        scope.fork(self.acquire).join((ex) => {
+          if (ex._tag === "Failure") {
+            closeWith(ex);
+            cb({ _tag: "Failure", cause: { _tag: "Fail", error: _chunkBKBFSOGTcjs.some.call(void 0, ex.cause.error) } });
+            return;
+          }
+          scope.addFinalizer((exit) => self.release(exit));
+          const inner = ex.value;
+          _chunkBKBFSOGTcjs.unsafeGetCurrentRuntime.call(void 0, ).fork(uncons(wrap(inner))).join(cb);
+        });
+      });
+    case "Managed":
+      return _chunkBKBFSOGTcjs.async.call(void 0, (env, cb) => {
+        const runtime = _chunkBKBFSOGTcjs.unsafeGetCurrentRuntime.call(void 0, );
+        const scope = new (0, _chunkBKBFSOGTcjs.Scope)(runtime);
+        _optionalChain([_chunkBKBFSOGTcjs.getCurrentFiber.call(void 0, ), 'optionalAccess', _5 => _5.addFinalizer, 'call', _6 => _6((exit) => {
+          try {
+            scope.close(exit);
+          } catch (e4) {
+          }
+        })]);
+        const closeWith = (exit) => {
+          if (exit._tag === "Failure") {
+            const err = exit.cause.error;
+            if (err && typeof err === "object" && err._tag === "None") {
+              scope.close({ _tag: "Success", value: void 0 });
+              return;
+            }
+          }
+          scope.close(exit);
+        };
+        scope.fork(self.acquire).join((ex) => {
+          if (ex._tag === "Failure") {
+            scope.close(ex);
+            cb({ _tag: "Failure", cause: { _tag: "Fail", error: _chunkBKBFSOGTcjs.some.call(void 0, ex.cause.error) } });
+            return;
+          }
+          const { stream: inner, release } = ex.value;
+          scope.addFinalizer((exit) => release(exit));
+          const wrap = (s) => fromPull(
+            _chunkBKBFSOGTcjs.async.call(void 0, (env2, cb2) => {
+              uncons(s)(env2, (ex2) => {
+                if (ex2._tag === "Failure") {
+                  closeWith(ex2);
+                  cb2(ex2);
+                  return;
+                }
+                const [a, tail] = ex2.value;
+                cb2(_chunkBKBFSOGTcjs.Exit.succeed([a, wrap(tail)]));
+              });
+            })
+          );
+          _chunkBKBFSOGTcjs.unsafeGetCurrentRuntime.call(void 0, ).fork(uncons(wrap(inner))).join(cb);
+        });
+      });
+  }
+}
+function assertNever(x, msg) {
+  throw new Error(_nullishCoalesce(msg, () => ( `Unexpected value: ${String(x)}`)));
+}
+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(_chunkBKBFSOGTcjs.map.call(void 0, self.value, f));
+    case "FromPull":
+      return fromPull(
+        _chunkBKBFSOGTcjs.map.call(void 0, self.pull, ([a, tail]) => [f(a), mapStream(tail, f)])
+      );
+    case "Concat":
+      return concatStream(mapStream(self.left, f), mapStream(self.right, f));
+    case "Flatten": {
+      const mappedOuter = mapStream(
+        self.stream,
+        (inner) => mapStream(inner, f)
+      );
+      return flattenStream(mappedOuter);
+    }
+    case "Merge":
+      return mergeStream(
+        mapStream(self.left, f),
+        mapStream(self.right, f),
+        self.flip
+      );
+    case "Scoped":
+      return unwrapScoped(
+        _chunkBKBFSOGTcjs.map.call(void 0, self.acquire, (s) => mapStream(s, f)),
+        self.release
+      );
+    case "Managed":
+      return managedStream(
+        _chunkBKBFSOGTcjs.map.call(void 0, self.acquire, ({ stream, release }) => ({
+          stream: mapStream(stream, f),
+          release
+        }))
+      );
+    default:
+      return assertNever(self);
+  }
+}
+function rangeStream(start, end) {
+  const go = (i) => fromPull(
+    i > end ? _chunkBKBFSOGTcjs.asyncFail.call(void 0, _chunkBKBFSOGTcjs.none) : _chunkBKBFSOGTcjs.asyncSucceed.call(void 0, [i, go(i + 1)])
+  );
+  return go(start);
+}
+function zip(left, right) {
+  const pull = _chunkBKBFSOGTcjs.asyncFold.call(void 0, 
+    _chunkBKBFSOGTcjs.asyncMapError.call(void 0, uncons(left), (opt) => widenOpt(opt)),
+    // si left termina o falla, el zip termina/falla igual
+    (opt) => _chunkBKBFSOGTcjs.asyncFail.call(void 0, opt),
+    ([a, tailL]) => _chunkBKBFSOGTcjs.asyncFold.call(void 0, 
+      _chunkBKBFSOGTcjs.asyncMapError.call(void 0, uncons(right), (opt) => widenOpt(opt)),
+      (opt) => _chunkBKBFSOGTcjs.asyncFail.call(void 0, opt),
+      ([b, tailR]) => _chunkBKBFSOGTcjs.asyncSucceed.call(void 0, [
+        [a, b],
+        zip(tailL, tailR)
+      ])
+    )
+  );
+  return fromPull(pull);
+}
+function foreachStream(stream, f) {
+  const loop = (cur) => _chunkBKBFSOGTcjs.asyncFold.call(void 0, 
+    // uncons: Option<E> -> Option<E|E2>
+    _chunkBKBFSOGTcjs.asyncMapError.call(void 0, uncons(cur), (opt) => widenOpt(opt)),
+    (opt) => {
+      if (opt._tag === "None") return _chunkBKBFSOGTcjs.asyncSucceed.call(void 0, void 0);
+      return _chunkBKBFSOGTcjs.asyncFail.call(void 0, opt);
+    },
+    ([a, tail]) => _chunkBKBFSOGTcjs.asyncFlatMap.call(void 0, 
+      // f(a): E2 -> Option<E|E2>
+      _chunkBKBFSOGTcjs.asyncMapError.call(void 0, f(a), (e2) => _chunkBKBFSOGTcjs.some.call(void 0, e2)),
+      () => loop(tail)
+    )
+  );
+  return _chunkBKBFSOGTcjs.asyncFold.call(void 0, 
+    loop(stream),
+    (opt) => {
+      if (opt._tag === "None") return _chunkBKBFSOGTcjs.asyncSucceed.call(void 0, void 0);
+      return _chunkBKBFSOGTcjs.asyncFail.call(void 0, opt.value);
+    },
+    () => _chunkBKBFSOGTcjs.asyncSucceed.call(void 0, void 0)
+  );
+}
+function fromArray(values) {
+  if (values.length === 0) return emptyStream();
+  return { _tag: "FromArray", values };
+}
+function collectStream(stream) {
+  const syncResult = drainStreamSyncFull(stream);
+  if (syncResult !== null) {
+    return _chunkBKBFSOGTcjs.asyncSucceed.call(void 0, syncResult);
+  }
+  const loop = (cur, acc) => _chunkBKBFSOGTcjs.asyncFold.call(void 0, 
+    uncons(cur),
+    (opt) => {
+      if (opt._tag === "None") return _chunkBKBFSOGTcjs.succeed.call(void 0, acc);
+      return _chunkBKBFSOGTcjs.fail.call(void 0, opt);
+    },
+    ([a, tail]) => {
+      acc.push(a);
+      return loop(tail, acc);
+    }
+  );
+  return _chunkBKBFSOGTcjs.mapError.call(void 0, loop(stream, []), (opt) => {
+    if (opt._tag === "Some") return opt.value;
+    throw new Error("unreachable: stream end handled as success");
+  });
+}
+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) {
+  const pull = _chunkBKBFSOGTcjs.async.call(void 0, (_, cb) => {
+    reader.read().then(({ done, value }) => {
+      if (done) {
+        cb({ _tag: "Failure", cause: { _tag: "Fail", error: _chunkBKBFSOGTcjs.none } });
+        return;
+      }
+      cb({
+        _tag: "Success",
+        value: [value, fromPull(pull)]
+      });
+    }).catch((e) => {
+      cb({ _tag: "Failure", cause: { _tag: "Fail", error: _chunkBKBFSOGTcjs.some.call(void 0, normalizeError(e)) } });
+    });
+  });
+  return fromPull(pull);
+}
+function streamFromReadableStream(body, normalizeError) {
+  if (!body) return emptyStream();
+  let reader;
+  return unwrapScoped(
+    // acquire: produce un ZStream
+    _chunkBKBFSOGTcjs.sync.call(void 0, () => {
+      reader = body.getReader();
+      return readerStream(reader, normalizeError);
+    }),
+    // release: se corre en fin / error / interrupción
+    () => _chunkBKBFSOGTcjs.asyncSync.call(void 0, () => {
+      try {
+        _optionalChain([reader, 'optionalAccess', _7 => _7.cancel, 'call', _8 => _8()]);
+      } catch (e5) {
+      }
+    })
+  );
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.sleep = sleep; exports.timeout = timeout; exports.retry = retry; exports.retryN = retryN; exports.retryWithBackoff = retryWithBackoff; exports.makeCircuitBreaker = makeCircuitBreaker; exports.widenOpt = widenOpt; exports.fromPull = fromPull; exports.unwrapScoped = unwrapScoped; exports.managedStream = managedStream; exports.mergeStream = mergeStream; exports.emptyStream = emptyStream; exports.emitStream = emitStream; exports.concatStream = concatStream; exports.flattenStream = flattenStream; exports.merge = merge; exports.uncons = uncons; exports.assertNever = assertNever; exports.mapStream = mapStream; exports.rangeStream = rangeStream; exports.zip = zip; exports.foreachStream = foreachStream; exports.fromArray = fromArray; exports.collectStream = collectStream; exports.streamFromReadableStream = streamFromReadableStream;