brass-runtime 1.13.8 → 1.14.0

package/dist/{chunk-ATHSSDUF.js → chunk-UWMMYKVK.mjs}

@@ -22,7 +22,214 @@ import {
   sync,
   unsafeGetCurrentRuntime,
   unsafeRunFoldWithEnv
-} from "./chunk-L6KKKM66.js";
+} from "./chunk-4N2JEK4H.mjs";
+
+// 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
+  };
+}
 
 // src/core/stream/stream.ts
 var widenOpt = (opt) => opt._tag === "None" ? none : some(opt.value);
@@ -111,6 +318,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)),
@@ -244,6 +457,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,27 +542,66 @@ 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 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 = async((_, cb) => {
     reader.read().then(({ done, value }) => {
@@ -385,6 +639,12 @@ function streamFromReadableStream(body, normalizeError) {
 }
 
 export {
+  sleep,
+  timeout,
+  retry,
+  retryN,
+  retryWithBackoff,
+  makeCircuitBreaker,
   widenOpt,
   fromPull,
   unwrapScoped,

package/dist/{chunk-INZBKOHY.js → chunk-WJESVBWN.js}

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