brass-runtime 1.14.0 → 1.16.0

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

@@ -1,17 +1,23 @@
+import {
+  race
+} from "./chunk-G3XGCZDQ.js";
+import {
+  withScopeAsync
+} from "./chunk-FM4W4QPL.js";
+import {
+  fromPromiseAbortable
+} from "./chunk-7LVI2GIN.js";
 import {
   Cause,
   Exit,
-  async,
+  asyncEffect,
   asyncFail,
   asyncFlatMap,
   asyncFold,
   asyncMap,
   asyncSucceed,
-  asyncSync,
-  fromPromiseAbortable,
-  race,
-  withScopeAsync
-} from "./chunk-JT7D6M5H.js";
+  asyncSync
+} from "./chunk-PNVFW245.js";
 
 // src/agent/core/state.ts
 var initialAgentState = (goal) => ({
@@ -1425,10 +1431,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 +1690,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 +2130,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-NOYZIMUJ.mjs

@@ -0,0 +1,144 @@
+// src/core/types/asyncEffect.ts
+var Async = {
+  succeed: (value) => ({ _tag: "Succeed", value }),
+  fail: (error) => ({ _tag: "Fail", error }),
+  sync: (thunk) => ({ _tag: "Sync", thunk }),
+  async: (register) => ({ _tag: "Async", register })
+};
+function asyncFold(fa, onFailure, onSuccess) {
+  return {
+    _tag: "Fold",
+    first: fa,
+    onFailure,
+    onSuccess
+  };
+}
+function asyncCatchAll(fa, handler) {
+  return asyncFold(fa, handler, asyncSucceed);
+}
+function asyncMapError(fa, f) {
+  return asyncFold(fa, (e) => asyncFail(f(e)), asyncSucceed);
+}
+var SUCCEED_UNDEFINED = { _tag: "Succeed", value: void 0 };
+var SUCCEED_TRUE = { _tag: "Succeed", value: true };
+var SUCCEED_FALSE = { _tag: "Succeed", value: false };
+var SUCCEED_NULL = { _tag: "Succeed", value: null };
+var unit = () => SUCCEED_UNDEFINED;
+var asyncSucceed = (value) => {
+  if (value === void 0) return SUCCEED_UNDEFINED;
+  if (value === true) return SUCCEED_TRUE;
+  if (value === false) return SUCCEED_FALSE;
+  if (value === null) return SUCCEED_NULL;
+  return { _tag: "Succeed", value };
+};
+var asyncFail = (error) => ({
+  _tag: "Fail",
+  error
+});
+var asyncSync = (thunk) => ({
+  _tag: "Sync",
+  thunk
+});
+var asyncTotal = (thunk) => asyncSync(() => thunk());
+var asyncEffect = (register) => ({
+  _tag: "Async",
+  register
+});
+function asyncMap(fa, f) {
+  return asyncFlatMap(fa, (a) => asyncSucceed(f(a)));
+}
+function asyncFlatMap(fa, f) {
+  return {
+    _tag: "FlatMap",
+    first: fa,
+    andThen: f
+  };
+}
+function acquireRelease(acquire, release, scope) {
+  return asyncFlatMap(acquire, (resource) => {
+    scope.addFinalizer((exit) => release(resource, exit));
+    return asyncSucceed(resource);
+  });
+}
+function asyncInterruptible(register) {
+  return asyncEffect(register);
+}
+var withAsyncPromise = (run) => (eff) => {
+  const anyEff = eff;
+  if (!anyEff.toPromise) {
+    anyEff.toPromise = (env) => run(eff, env);
+    anyEff.unsafeRunPromise = () => run(eff, {});
+  }
+  return anyEff;
+};
+var mapAsync = (fa, f) => asyncFlatMap(fa, (a) => asyncSucceed(f(a)));
+var mapTryAsync = (fa, f) => asyncFlatMap(fa, (a) => asyncSync(() => f(a)));
+
+// src/core/types/option.ts
+var none = { _tag: "None" };
+var some = (value) => ({ _tag: "Some", value });
+
+// src/core/types/effect.ts
+var Cause = {
+  fail: (error) => ({ _tag: "Fail", error }),
+  interrupt: () => ({ _tag: "Interrupt" }),
+  die: (defect) => ({ _tag: "Die", defect })
+};
+var Exit = {
+  succeed: (value) => ({
+    _tag: "Success",
+    value
+  }),
+  failCause: (cause) => ({
+    _tag: "Failure",
+    cause
+  })
+};
+var succeed = (value) => asyncSucceed(value);
+var fail = (error) => asyncFail(error);
+var sync = (thunk) => asyncSync((env) => thunk(env));
+var map = (fa, f) => asyncMap(fa, f);
+var flatMap = (fa, f) => asyncFlatMap(fa, f);
+var mapError = (fa, f) => asyncMapError(fa, f);
+var catchAll = (fa, handler) => asyncFold(fa, handler, asyncSucceed);
+function orElseOptional(fa, that) {
+  return asyncFold(
+    fa,
+    (opt) => opt._tag === "Some" ? asyncFail(opt) : that(),
+    asyncSucceed
+  );
+}
+var end = () => fail(none);
+
+export {
+  Async,
+  asyncFold,
+  asyncCatchAll,
+  asyncMapError,
+  unit,
+  asyncSucceed,
+  asyncFail,
+  asyncSync,
+  asyncTotal,
+  asyncEffect,
+  asyncMap,
+  asyncFlatMap,
+  acquireRelease,
+  asyncInterruptible,
+  withAsyncPromise,
+  mapAsync,
+  mapTryAsync,
+  none,
+  some,
+  Cause,
+  Exit,
+  succeed,
+  fail,
+  sync,
+  map,
+  flatMap,
+  mapError,
+  catchAll,
+  orElseOptional,
+  end
+};

package/dist/chunk-NYL4D7SK.cjs

@@ -0,0 +1,131 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkDJQ7OMMBcjs = require('./chunk-DJQ7OMMB.cjs');
+
+// src/core/stream/structuredConcurrency.ts
+function race(left, right, parentScope) {
+  return _chunkDJQ7OMMBcjs.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 _chunkDJQ7OMMBcjs.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 _chunkDJQ7OMMBcjs.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 _chunkDJQ7OMMBcjs.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;

package/dist/chunk-OBGZSXTJ.cjs

@@ -0,0 +1,10 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});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');
+});
+
+
+
+exports.__require = __require;