@shajara/kernel 0.1.0

package/dist/index.js

@@ -0,0 +1,1986 @@
+import { A as e, B as t, C as n, D as r, E as i, F as a, I as o, J as s, L as c, N as l, O as u, P as d, R as f, S as p, V as m, W as h, X as g, Y as _, _ as v, a as ee, b as te, c as y, d as b, f as x, g as ne, h as re, i as ie, j as ae, k as S, l as C, m as oe, n as se, o as ce, p as le, q as ue, r as de, t as w, u as T, v as fe, w as E, x as pe, y as me, z as he } from "./utils-PwEUjNtC.js";
+import { bind as ge, branch as D, cancel as _e, cede as ve, defer as ye, future as O, halt as be, lookup as xe, poll as Se, receive as Ce, self as we, send as Te, settle as k, spawn as A, unbind as Ee, wait as j } from "./sigils.js";
+//#region src/contracts/wisp.ts
+function M(e, t) {
+	return {
+		bearing: "stirring",
+		resonate: t,
+		sigil: e
+	};
+}
+function N(e) {
+	return {
+		bearing: "resting",
+		relic: e
+	};
+}
+function De(e) {
+	return M(e, N);
+}
+//#endregion
+//#region src/contracts/message-key.ts
+function Oe() {
+	return {};
+}
+//#endregion
+//#region src/contracts/context-key.ts
+function ke() {
+	return {};
+}
+//#endregion
+//#region ../../../../home/vscode/.yarn/berry/cache/fp-ts-npm-2.16.11-62e43e1078-10c0.zip/node_modules/fp-ts/es6/ReadonlyNonEmptyArray.js
+var Ae = function(e, t, n) {
+	if (n || arguments.length === 2) for (var r = 0, i = t.length, a; r < i; r++) (a || !(r in t)) && (a ||= Array.prototype.slice.call(t, 0, r), a[r] = t[r]);
+	return e.concat(a || Array.prototype.slice.call(t));
+}, je = t, Me = h, Ne = function(e) {
+	return function(t) {
+		return Ae(Ae([], t, !0), [e], !1);
+	};
+}, Pe = function(e) {
+	return e.length === 0;
+}, Fe = Me, Ie = Ne, Le = function(e, t, n) {
+	return g(e, ze(t, n));
+}, Re = function() {
+	return Ve;
+}, P = function(e) {
+	return function(t) {
+		return t.map(function(t) {
+			return e(t);
+		});
+	};
+}, ze = function(e, t) {
+	return Be(e, function(e, n, r) {
+		return t(n, r);
+	});
+}, Be = function(e, t) {
+	return function(n) {
+		for (var r = n.length, i = e, a = 0; a < r; a++) i = t(a, i, n[a]);
+		return i;
+	};
+}, F = function(e) {
+	return function(t) {
+		return Le(t, e.of(Re()), function(t, n) {
+			return e.ap(e.map(t, function(e) {
+				return function(t) {
+					return g(e, Ie(t));
+				};
+			}), n);
+		});
+	};
+}, Ve = je;
+//#endregion
+//#region ../../../../home/vscode/.yarn/berry/cache/fp-ts-npm-2.16.11-62e43e1078-10c0.zip/node_modules/fp-ts/es6/EitherT.js
+function He(e) {
+	return _(S, e.of);
+}
+function Ue(e) {
+	return _(i, e.of);
+}
+function We(e) {
+	return function(t) {
+		return e.map(t, S);
+	};
+}
+function Ge(e) {
+	return function(t) {
+		return e.map(t, i);
+	};
+}
+function Ke(e) {
+	return function(t) {
+		return _(pe(t), e.of);
+	};
+}
+function qe(e) {
+	var t = Ke(e);
+	return function(e) {
+		var n = t(e);
+		return function(e) {
+			return _(e, n);
+		};
+	};
+}
+function Je(e) {
+	var t = Ze(e), n = qe(e);
+	return function(e) {
+		var r = n(e);
+		return function(e) {
+			return t(r(e));
+		};
+	};
+}
+function Ye(e) {
+	return f(e, v);
+}
+function Xe(e) {
+	return he(e, ne);
+}
+function Ze(e) {
+	var t = Qe(e);
+	return function(e) {
+		return function(n) {
+			return t(n, e);
+		};
+	};
+}
+function Qe(e) {
+	return function(t, n) {
+		return e.chain(t, function(t) {
+			return E(t) ? e.of(t) : n(t.right);
+		});
+	};
+}
+function $e(e) {
+	return function(t) {
+		return function(n) {
+			return e.chain(n, function(n) {
+				return E(n) ? t() : e.of(n);
+			});
+		};
+	};
+}
+function et(e) {
+	var t = tt(e);
+	return function(e, n) {
+		return function(r) {
+			return t(r, e, n);
+		};
+	};
+}
+function tt(e) {
+	return function(t, n, r) {
+		return e.map(t, fe(n, r));
+	};
+}
+function nt(e) {
+	var t = rt(e);
+	return function(e) {
+		return function(n) {
+			return t(n, e);
+		};
+	};
+}
+function rt(e) {
+	return function(t, n) {
+		return e.map(t, r(n));
+	};
+}
+function it(e) {
+	return function(t, n) {
+		return function(r) {
+			return e.map(r, u(t, n));
+		};
+	};
+}
+function at(e) {
+	return function(t, n) {
+		return function(r) {
+			return e.chain(r, u(t, n));
+		};
+	};
+}
+function ot(e) {
+	return function(t) {
+		return function(n) {
+			return e.chain(n, u(t, e.of));
+		};
+	};
+}
+function st(e) {
+	return function(t) {
+		return function(n) {
+			return e.chain(n, function(n) {
+				return E(n) ? t(n.left) : e.of(n);
+			});
+		};
+	};
+}
+function ct(e) {
+	var t = lt(e);
+	return function(e) {
+		return function(n) {
+			return t(n, e);
+		};
+	};
+}
+function lt(e) {
+	var t = st(e);
+	return function(n, r) {
+		return g(n, t(function(t) {
+			return e.map(r(t), function(e) {
+				return E(e) ? e : i(t);
+			});
+		}));
+	};
+}
+function ut(e) {
+	return function(t) {
+		return function(n) {
+			return e.chain(n, u(function(n) {
+				return e.map(t(n), i);
+			}, function(t) {
+				return e.of(S(t));
+			}));
+		};
+	};
+}
+function dt(t) {
+	return function(n) {
+		return t.map(n, e);
+	};
+}
+function ft(e) {
+	return function(t) {
+		return e.map(t, ae);
+	};
+}
+//#endregion
+//#region ../../../../home/vscode/.yarn/berry/cache/fp-ts-npm-2.16.11-62e43e1078-10c0.zip/node_modules/fp-ts/es6/FromIO.js
+function I(e, t) {
+	return function(n) {
+		var r = _(n, e.fromIO);
+		return function(e) {
+			return t.chain(e, r);
+		};
+	};
+}
+function L(e, t) {
+	var n = pt(e, t);
+	return function(e) {
+		return function(t) {
+			return n(t, e);
+		};
+	};
+}
+function pt(e, t) {
+	var n = a(t);
+	return function(t, r) {
+		return n(t, _(r, e.fromIO));
+	};
+}
+//#endregion
+//#region ../../../../home/vscode/.yarn/berry/cache/fp-ts-npm-2.16.11-62e43e1078-10c0.zip/node_modules/fp-ts/es6/IO.js
+var mt = function(e, t) {
+	return function() {
+		return t(e());
+	};
+}, ht = function(e, t) {
+	return function() {
+		return e()(t());
+	};
+}, gt = ue, _t = /* @__PURE__ */ s(2, function(e, t) {
+	return function() {
+		return t(e())();
+	};
+}), vt = {
+	URI: "IO",
+	map: mt
+};
+s(2, o(vt)), c(vt), a({
+	URI: "IO",
+	map: mt,
+	ap: ht,
+	chain: _t
+});
+var yt = /* @__PURE__ */ gt(m);
+//#endregion
+//#region ../../../../home/vscode/.yarn/berry/cache/fp-ts-npm-2.16.11-62e43e1078-10c0.zip/node_modules/fp-ts/es6/OptionT.js
+function bt(e) {
+	return _(b, e.of);
+}
+function xt(e) {
+	return ue(e.of(T));
+}
+function St(e) {
+	return function(t) {
+		return e.map(t, b);
+	};
+}
+function Ct(e) {
+	return _(ee, e.of);
+}
+function wt(e) {
+	var t = Ct(e);
+	return function(e) {
+		return _(e, t);
+	};
+}
+function Tt(e) {
+	var t = R(e), n = wt(e);
+	return function(e) {
+		return t(n(e));
+	};
+}
+function Et(e) {
+	return function(t) {
+		return _(t, e.of);
+	};
+}
+function Dt(e) {
+	var t = R(e), n = Et(e);
+	return function(e) {
+		return t(n(e));
+	};
+}
+function Ot(e) {
+	return function(t) {
+		return function(n) {
+			return e.of(ce(t)(n));
+		};
+	};
+}
+function kt(e) {
+	return _(ie, e.of);
+}
+function At(e) {
+	return function(t, n) {
+		return function(r) {
+			return e.map(r, C(t, n));
+		};
+	};
+}
+function jt(e) {
+	return function(t, n) {
+		return function(r) {
+			return e.chain(r, C(t, n));
+		};
+	};
+}
+function Mt(e) {
+	return function(t) {
+		return function(n) {
+			return e.chain(n, C(t, e.of));
+		};
+	};
+}
+function Nt(e) {
+	return f(e, de);
+}
+function Pt(e) {
+	return he(e, se);
+}
+function R(e) {
+	var t = Ft(e);
+	return function(e) {
+		return function(n) {
+			return t(n, e);
+		};
+	};
+}
+function Ft(e) {
+	var t = xt(e);
+	return function(n, r) {
+		return e.chain(n, C(function() {
+			return t();
+		}, r));
+	};
+}
+function It(e) {
+	var t = bt(e);
+	return function(n) {
+		return function(r) {
+			return e.chain(r, C(n, t));
+		};
+	};
+}
+//#endregion
+//#region ../../../../home/vscode/.yarn/berry/cache/fp-ts-npm-2.16.11-62e43e1078-10c0.zip/node_modules/fp-ts/es6/pipeable.js
+function Lt(e) {
+	return function(t) {
+		return function(n) {
+			return e.map(n, t);
+		};
+	};
+}
+function Rt(e) {
+	return function(t) {
+		return function(n) {
+			return e.ap(n, t);
+		};
+	};
+}
+function zt(e) {
+	return function(t) {
+		return function(n) {
+			return e.chain(n, t);
+		};
+	};
+}
+//#endregion
+//#region ../../../../home/vscode/.yarn/berry/cache/fp-ts-npm-2.16.11-62e43e1078-10c0.zip/node_modules/fp-ts/es6/ReadonlySet.js
+var z = function(e) {
+	return e.size === 0;
+}, B;
+(function(e) {
+	function t(e) {
+		let t = zt(e);
+		return (n) => t(_(n, e.liftF));
+	}
+	e.chainF = t;
+	function n(e) {
+		let t = d(e);
+		return (n) => t(_(n, e.liftF));
+	}
+	e.chainFirstF = n;
+	function r(e) {
+		let t = l(e);
+		return (n, r) => t(n, _(r, e.liftF));
+	}
+	e.bindF = r;
+})(B ||= {});
+//#endregion
+//#region src/internal/fp/wisp.ts
+var V;
+(function(e) {
+	let t = e.URI = "Wisp", n = e.Pointed = {
+		URI: t,
+		of: N
+	}, r = e.Functor = {
+		URI: t,
+		map: (e, t) => e.bearing === "resting" ? N(t(e.relic)) : M(e.sigil, (n) => r.map(e.resonate(n), t))
+	}, i = e.Apply = {
+		URI: t,
+		ap: (e, t) => e.bearing === "resting" ? r.map(t, e.relic) : M(e.sigil, (n) => i.ap(e.resonate(n), t)),
+		map: r.map
+	}, a = e.Applicative = {
+		URI: t,
+		ap: i.ap,
+		map: r.map,
+		of: n.of
+	}, o = e.Chain = {
+		URI: t,
+		ap: i.ap,
+		chain: (e, t) => e.bearing === "resting" ? t(e.relic) : M(e.sigil, (n) => o.chain(e.resonate(n), t)),
+		map: r.map
+	};
+	e.Monad = {
+		URI: t,
+		ap: i.ap,
+		chain: o.chain,
+		map: r.map,
+		of: n.of
+	}, e.Do = N(null);
+	let s = e.Lifting = {
+		URI: t,
+		ap: i.ap,
+		chain: o.chain,
+		liftF: De,
+		map: r.map
+	}, c = e.FromIO = {
+		URI: t,
+		fromIO: (e) => n.of(e())
+	}, { of: u } = n;
+	e.of = u, e.map = Lt(r), e.ap = Rt(i), e.chain = zt(o), e.bind = l(o), e.chainFirst = d(o), e.sequence = F(a);
+	let { liftF: f } = s;
+	e.liftF = f, e.bindF = B.bindF(s), e.chainF = B.chainF(s), e.chainFirstF = B.chainFirstF(s);
+	let { fromIO: p } = c;
+	e.fromIO = p, e.chainFirstIOK = L(c, o), e.chainIOK = I(c, o);
+})(V ||= {});
+//#endregion
+//#region src/internal/fp/wisp-either.ts
+var H;
+(function(e) {
+	let t = e.URI = "WispEither";
+	e.left = Ue(V.Pointed);
+	let n = e.right = He(V.Pointed), r = e.map = Ye(V.Functor), i = e.ap = Xe(V.Apply), a = e.chain = Ze(V.Monad);
+	e.leftWisp = Ge(V.Functor);
+	let o = e.rightWisp = We(V.Functor), s = e.Pointed = {
+		URI: t,
+		of: n
+	}, c = e.Functor = {
+		URI: t,
+		map: (e, t) => r(t)(e)
+	}, u = e.Apply = {
+		URI: t,
+		ap: (e, t) => i(t)(e),
+		map: c.map
+	}, f = e.Applicative = {
+		URI: t,
+		ap: u.ap,
+		map: c.map,
+		of: s.of
+	}, p = e.Chain = {
+		URI: t,
+		ap: u.ap,
+		chain: (e, t) => a(t)(e),
+		map: c.map
+	};
+	e.Monad = {
+		URI: t,
+		ap: u.ap,
+		chain: p.chain,
+		map: c.map,
+		of: s.of
+	};
+	let m = e.Lifting = {
+		URI: t,
+		ap: u.ap,
+		chain: p.chain,
+		liftF: _(V.liftF, o),
+		map: c.map
+	}, h = e.FromIO = {
+		URI: t,
+		fromIO: (e) => s.of(e())
+	};
+	e.bind = l(p), e.chainFirst = d(p), e.sequence = F(f);
+	let { liftF: g } = m;
+	e.liftF = g, e.bindF = B.bindF(m), e.chainF = B.chainF(m), e.chainFirstF = B.chainFirstF(m);
+	let { fromIO: v } = h;
+	e.fromIO = v, e.chainFirstIOK = L(h, p), e.chainIOK = I(h, p), e.alt = $e(V.Monad), e.bimap = et(V.Monad), e.chainNullableK = Je(V.Monad), e.fromNullable = Ke(V.Pointed), e.getOrElse = ot(V.Monad), e.mapLeft = nt(V.Functor), e.match = it(V.Chain), e.matchE = at(V.Chain), e.orElse = st(V.Monad), e.orElseFirst = ct(V.Monad), e.orLeft = ut(V.Monad), e.swap = dt(V.Functor), e.toUnion = ft(V.Functor);
+})(H ||= {});
+//#endregion
+//#region src/internal/fp/wisp-option.ts
+var Bt;
+(function(e) {
+	let t = e.URI = "WispOption", n = e.some = bt(V.Pointed), r = e.map = Nt(V.Functor), i = e.ap = Pt(V.Apply), a = e.chain = R(V.Monad), o = e.fromWisp = St(V.Functor), s = e.Pointed = {
+		URI: t,
+		of: n
+	}, c = e.Functor = {
+		URI: t,
+		map: (e, t) => r(t)(e)
+	}, u = e.Apply = {
+		URI: t,
+		ap: (e, t) => i(t)(e),
+		map: c.map
+	}, f = e.Applicative = {
+		URI: t,
+		ap: u.ap,
+		map: c.map,
+		of: s.of
+	}, p = e.Chain = {
+		URI: t,
+		ap: u.ap,
+		chain: (e, t) => a(t)(e),
+		map: c.map
+	};
+	e.Monad = {
+		URI: t,
+		ap: u.ap,
+		chain: p.chain,
+		map: c.map,
+		of: s.of
+	};
+	let m = e.Lifting = {
+		URI: t,
+		ap: u.ap,
+		chain: p.chain,
+		liftF: _(V.liftF, o),
+		map: c.map
+	}, h = e.FromIO = {
+		URI: t,
+		fromIO: (e) => s.of(e())
+	};
+	e.bind = l(p), e.chainFirst = d(p), e.sequence = F(f);
+	let { liftF: g } = m;
+	e.liftF = g, e.bindF = B.bindF(m), e.chainF = B.chainF(m), e.chainFirstF = B.chainFirstF(m);
+	let { fromIO: v } = h;
+	e.fromIO = v, e.chainFirstIOK = L(h, p), e.chainIOK = I(h, p), e.alt = It(V.Monad), e.chainNullableK = Tt(V.Monad), e.chainOptionK = Dt(V.Monad), e.fromEither = kt(V.Pointed), e.fromNullable = Ct(V.Pointed), e.fromPredicate = Ot(V.Pointed), e.getOrElse = Mt(V.Monad), e.match = At(V.Functor), e.matchE = jt(V.Chain), e.zero = xt(V.Pointed);
+})(Bt ||= {});
+//#endregion
+//#region src/internal/fp/sigil.ts
+var Vt;
+(function(e) {
+	e.URI = "Sigil";
+})(Vt ||= {});
+//#endregion
+//#region src/primitives-kit/process.ts
+function Ht(e) {
+	return g(j(e.exitFuture), V.liftF, V.map(oe()), V.map(({ right: e }) => e));
+}
+//#endregion
+//#region src/primitives-kit/resumable.ts
+var Ut = ke(), Wt = Oe();
+//#endregion
+//#region src/primitives/all.ts
+function Gt(e) {
+	return g(A(Kt(e)), V.liftF, V.map((e) => e.exitFuture));
+}
+function Kt(e) {
+	return () => g(e, P(_(A, V.liftF)), V.sequence, V.map(P(Ht)), V.chain(V.sequence), V.map(le()));
+}
+//#endregion
+//#region src/primitives/wait.ts
+function qt(e) {
+	return V.liftF(j(e));
+}
+//#endregion
+//#region src/primitives/bind.ts
+function Jt(e, t) {
+	return V.liftF(ge(e, t));
+}
+//#endregion
+//#region src/primitives/cancel.ts
+function Yt() {
+	return V.liftF(_e());
+}
+//#endregion
+//#region src/primitives/cede.ts
+function Xt() {
+	return V.liftF(ve());
+}
+//#endregion
+//#region src/primitives/defer.ts
+function Zt(e) {
+	return V.liftF(ye(e));
+}
+//#endregion
+//#region src/primitives/spawn.ts
+function Qt(e) {
+	return g(A(e), V.liftF, V.map((e) => e.exitFuture));
+}
+//#endregion
+//#region src/primitives/future.ts
+function $t() {
+	return V.liftF(O());
+}
+//#endregion
+//#region src/primitives/halt.ts
+function en(e) {
+	return V.liftF(be(e));
+}
+//#endregion
+//#region src/primitives/lookup.ts
+function tn(e) {
+	return V.liftF(xe(e));
+}
+//#endregion
+//#region src/primitives/poll.ts
+function nn(e) {
+	return V.liftF(Se(e));
+}
+//#endregion
+//#region src/primitives/park.ts
+function rn() {
+	return V.liftF(Ce(an));
+}
+var an = Oe();
+//#endregion
+//#region src/primitives/race.ts
+function on(e) {
+	return g(O(), V.liftF, V.chainFirstF(([, t]) => D(sn(e, t))), V.map(([e]) => e));
+}
+function sn(e, t) {
+	return () => g(e, P((e) => g(A(cn(e, t)), V.liftF)), V.sequence);
+}
+function cn(e, t) {
+	return () => g(e(), V.chainF((e) => k(t, S(e))), V.chainF(_e));
+}
+//#endregion
+//#region src/primitives/resource.ts
+function ln(e) {
+	return g(O(), V.liftF, V.chainFirstF(([, t]) => A(un(e, t))), V.map(([e]) => e));
+}
+function un(e, t) {
+	return () => e((e) => g(k(t, S(e)), V.liftF, V.chain(rn)));
+}
+//#endregion
+//#region src/primitives/resumable.ts
+function dn(e) {
+	return g(D(e, { failureMode: "contain" }), V.liftF, V.chainF(({ scope: e }) => A(fn(e.exitFuture))), V.map(({ exitFuture: e }) => e));
+}
+function fn(e) {
+	return () => g(j(e), V.liftF, H.orElse((e) => g(xe(Ut), V.liftF, V.map(p(() => e)), H.map((e) => ({ delegateScope: e })), H.bindF("resolver", () => O()), H.chainFirstF(({ resolver: [, t], delegateScope: n }) => Te(n, Wt, {
+		failure: e,
+		recoverySettle: t
+	})), H.chainF(({ resolver: [e] }) => j(e)), V.map(te))), H.getOrElse(_(be, V.liftF)));
+}
+//#endregion
+//#region src/primitives/guard.ts
+function pn(e, t) {
+	return g(D(mn(e, t)), V.liftF, V.map(({ scope: e }) => e.exitFuture));
+}
+function mn(e, t) {
+	return () => g(we(), V.liftF, V.chainF(({ scope: e }) => ge(Ut, e)), V.chainF(() => A(hn(t), { completionMode: "detached" })), V.chain(e));
+}
+function hn(e) {
+	return function t() {
+		return g(Ce(Wt), V.liftF, V.chainF((t) => A(gn(t, e))), V.chain(t));
+	};
+}
+function gn(e, t) {
+	return () => g(t(e.failure), V.chainF((t) => k(e.recoverySettle, t)));
+}
+//#endregion
+//#region src/primitives/enclose.ts
+function _n(e) {
+	return g(D(e, { failureMode: "contain" }), V.liftF, V.chainF(({ scope: e }) => j(e.exitFuture)));
+}
+//#endregion
+//#region src/primitives/self.ts
+function vn() {
+	return V.liftF(we());
+}
+//#endregion
+//#region src/primitives/settle.ts
+function yn(e, t) {
+	return V.liftF(k(e, t));
+}
+//#endregion
+//#region src/primitives/unbind.ts
+function bn(e) {
+	return V.liftF(Ee(e));
+}
+//#endregion
+//#region src/failures/canceled.ts
+var U = {
+	kind: "canceled",
+	message: "Canceled before completion"
+};
+//#endregion
+//#region src/failures/external.ts
+function xn(e, t) {
+	return {
+		kind: "external",
+		message: t,
+		raw: e
+	};
+}
+//#endregion
+//#region src/failures/interrupted.ts
+function W(e) {
+	return {
+		cause: e,
+		kind: "interrupted",
+		message: "Scope progression was interrupted by an out-of-band failure"
+	};
+}
+//#endregion
+//#region src/failures/scope.ts
+function Sn(e, t) {
+	return {
+		cause: e,
+		kind: "scope",
+		message: "Scope failed during closing",
+		suppressed: t
+	};
+}
+//#endregion
+//#region src/executor/domains/domain.ts
+var Cn = class e {
+	static *domains(e) {
+		yield e;
+		for (let t of e.#t) yield* this.domains(t);
+	}
+	static sentinel() {
+		return e.#e;
+	}
+	constructor(e) {
+		this.parent = e;
+	}
+	close() {
+		this.parent.removeChild(this);
+	}
+	addChild(e) {
+		this.#t.add(e);
+	}
+	removeChild(e) {
+		this.#t.delete(e);
+	}
+	get isRoot() {
+		return this.parent === e.#e;
+	}
+	static #e = null;
+	#t = /* @__PURE__ */ new Set();
+}, wn = class e extends Cn {
+	static root(t) {
+		return new e(e.sentinel(), t);
+	}
+	nest(t) {
+		let n = new e(this, t);
+		return super.addChild(n), n;
+	}
+	setScopeRoot(e) {
+		this.#e = e, this.addLeafScope(e);
+	}
+	addLeafScope(e) {
+		this.#n.add(e);
+	}
+	removeLeafScope(e) {
+		this.#n.delete(e);
+	}
+	trackScope(e, t) {
+		t.status === "closing" ? this.#t.add(e) : z(this.#t) || this.#t.delete(e);
+	}
+	*createWorkers(e) {
+		for (let t of this.#n) e(t).status === "closing" && (yield {
+			scope: t,
+			worker: () => this.reaper.adjudicate(t)
+		});
+	}
+	close() {
+		this.#t.clear(), this.#n.clear(), super.close();
+	}
+	get hasClosingScope() {
+		return !z(this.#t);
+	}
+	get scopeRoot() {
+		return this.#e;
+	}
+	constructor(e, t) {
+		super(e), this.reaper = t;
+	}
+	#e;
+	#t = /* @__PURE__ */ new Set();
+	#n = /* @__PURE__ */ new Set();
+}, Tn = class e extends Cn {
+	static root(t, n) {
+		return new e(e.sentinel(), t, n);
+	}
+	nest(t, n) {
+		let r = new e(this, t, n);
+		return super.addChild(r), r;
+	}
+	admitProcess(e, t) {
+		t.status === "open" && t.activity === "running" && this.scheduler.assign(e).admit(this.createTask(e));
+	}
+	constructor(e, t, n) {
+		super(e), this.scheduler = t, this.createTask = n;
+	}
+}, G = class {
+	constructor(e) {
+		this.message = e;
+	}
+	capture(e) {
+		this.#e.push(e);
+	}
+	drain() {
+		let e = this.#e;
+		switch (this.#e = [], e.length) {
+			case 0: return T;
+			case 1: return b(e[0]);
+			default: return b(AggregateError(e, this.message));
+		}
+	}
+	throwIfAny() {
+		let e = this.drain();
+		if (y(e)) throw e.value;
+	}
+	[Symbol.dispose]() {
+		this.throwIfAny();
+	}
+	#e = [];
+};
+//#endregion
+//#region src/interpreter/process-step.ts
+function K() {
+	return { disposition: "waiting" };
+}
+function En() {
+	return { disposition: "ceded" };
+}
+function q() {
+	return { disposition: "interpreted" };
+}
+function Dn() {
+	return { disposition: "resonated" };
+}
+function J(e) {
+	return {
+		disposition: "exited",
+		result: e
+	};
+}
+//#endregion
+//#region src/interpreter/runtime-future.ts
+var Y = class {
+	poll() {
+		return this.#t ? b(this.#t) : T;
+	}
+	wait(e) {
+		if (this.#t) return w();
+		let t = [e];
+		return this.#e.add(t), () => {
+			this.#e.delete(t);
+		};
+	}
+	settle(e) {
+		return this.#t ? () => [] : (this.#t = e, (t) => {
+			for (let [n] of this.#e) n(e, t);
+			this.#e.clear();
+		});
+	}
+	handle() {
+		return [this, this];
+	}
+	#e = /* @__PURE__ */ new Set();
+	#t = null;
+}, On = class {
+	current() {
+		switch (this.#t.status) {
+			case "echo": {
+				let { wisp: e } = this.#t;
+				return {
+					accept: (t) => {
+						this.#e(e, t);
+					},
+					kind: "echo",
+					sigil: this.#t.wisp.sigil
+				};
+			}
+			case "relic": return {
+				kind: "relic",
+				relic: this.#t.relic
+			};
+			case "resonate": return w();
+		}
+	}
+	next() {
+		switch (this.#t.status) {
+			case "echo": {
+				let { wisp: e } = this.#t;
+				return {
+					accept: (t) => {
+						this.#e(e, t);
+					},
+					kind: "echo",
+					sigil: this.#t.wisp.sigil
+				};
+			}
+			case "relic": return {
+				kind: "relic",
+				relic: this.#t.relic
+			};
+			case "resonate": {
+				let e = this.#t.resonate();
+				return e.bearing === "resting" ? (this.#t = {
+					relic: e.relic,
+					status: "relic"
+				}, {
+					kind: "relic",
+					relic: e.relic
+				}) : (this.#t = {
+					status: "echo",
+					wisp: e
+				}, {
+					kind: "resonate",
+					sigil: this.#t.wisp.sigil
+				});
+			}
+		}
+	}
+	constructor(e) {
+		this.#t = {
+			resonate: e,
+			status: "resonate"
+		};
+	}
+	#e(e, t) {
+		this.#t = {
+			resonate: () => e.resonate(t),
+			status: "resonate"
+		};
+	}
+	#t;
+}, kn = class e {
+	static create(t, n, r) {
+		return new e(t, n, r);
+	}
+	selfHandle() {
+		return {
+			process: this,
+			scope: this.scopeRef
+		};
+	}
+	runner() {
+		return this;
+	}
+	keeper() {
+		return this;
+	}
+	stateAs(e) {
+		return this.#i;
+	}
+	resume(e) {
+		let t = this.stateAs("waiting");
+		t.stepper.current().accept(e), this.#i = An(t.stepper);
+	}
+	wait(e) {
+		this.#i = {
+			dispose: e,
+			status: "waiting",
+			stepper: this.stateAs("running").stepper
+		};
+	}
+	complete(e) {
+		return this.#t(), this.#i = {
+			result: e,
+			status: "completed"
+		}, this.#e(S(e));
+	}
+	fail(e) {
+		return this.#t(), this.#i = {
+			failure: e,
+			status: "failed"
+		}, this.#e(i(e));
+	}
+	cancel() {
+		return this.#t(), this.#i = { status: "canceled" }, this.#e(i(U));
+	}
+	defer(e) {
+		this.#r.push(e);
+	}
+	get exitFuture() {
+		return this.#n;
+	}
+	get descriptor() {
+		return this.processDescriptor;
+	}
+	get scopeRef() {
+		return this.scopeReference;
+	}
+	get status() {
+		return this.#i.status;
+	}
+	get isClosed() {
+		switch (this.status) {
+			case "running":
+			case "waiting": return !1;
+			case "completed":
+			case "canceled":
+			case "failed": return !0;
+		}
+	}
+	constructor(e, t, n) {
+		this.scopeReference = e, this.processDescriptor = n, this.#i = An(new On(t));
+	}
+	#e(e) {
+		let t = this.#r;
+		return this.#r = [], {
+			cleanups: t,
+			notification: this.#n.settle(e)
+		};
+	}
+	#t() {
+		this.#i.status === "waiting" && this.#i.dispose();
+	}
+	#n = new Y();
+	#r = [];
+	#i;
+};
+function An(e) {
+	return {
+		next: () => e.next(),
+		status: "running",
+		stepper: e
+	};
+}
+//#endregion
+//#region src/interpreter/runtime-scope/runtime-mailbox.ts
+var jn = class {
+	tryReceive(e) {
+		let t = this.#n.get(e);
+		if (t) switch (t.length) {
+			case 0:
+				this.#n.delete(e);
+				break;
+			case 1: return this.#n.delete(e), b(t[0]);
+			default: return b(t.shift());
+		}
+		return T;
+	}
+	enqueueReceiver(e, t) {
+		this.#i.getOrInsertComputed(e, () => /* @__PURE__ */ new Set()).add(t), this.#r.getOrInsertComputed(t, () => []).push(e);
+	}
+	send(e, t) {
+		let n = this.#r.get(e);
+		if (n) switch (n.length) {
+			case 0:
+				this.#r.delete(e);
+				break;
+			case 1: {
+				this.#r.delete(e);
+				let [t] = n;
+				return t;
+			}
+			default: return n.shift();
+		}
+		return this.#t(e, t), null;
+	}
+	cancelReceiver(e) {
+		let t = this.#i.get(e);
+		if (t) {
+			for (let n of t) this.#e(n, e);
+			this.#i.delete(e);
+		}
+	}
+	clear() {
+		this.#n.clear(), this.#r.clear(), this.#i.clear();
+	}
+	#e(e, t) {
+		let n = this.#r.get(e);
+		if (!n) return;
+		let r = n.filter((e) => e !== t);
+		Pe(r) ? this.#r.delete(e) : n.splice(0, n.length, ...r);
+	}
+	#t(e, t) {
+		this.#n.getOrInsertComputed(e, () => []).push(t);
+	}
+	#n = /* @__PURE__ */ new Map();
+	#r = /* @__PURE__ */ new Map();
+	#i = /* @__PURE__ */ new Map();
+}, X = class {
+	constructor(e, t) {
+		this.cause = e, this.resolveFailure = t;
+	}
+	capture(e) {
+		this.#e.push(e);
+	}
+	build() {
+		return Sn({
+			...this.cause,
+			failure: this.resolveFailure()
+		}, this.#e);
+	}
+	#e = [];
+}, Mn = class e {
+	static root(t, n, r, i) {
+		let a = new e(t, n, e.#w, r);
+		return r.trackProcess(a.entryProcess, i), r.trackScope(a, i), a;
+	}
+	complete(e, t, n) {
+		let r = e.complete(t);
+		this.#p(e).delete(e), this.#m(r.cleanups, n), this.scopeZone.trackProcess(e, n), this.#e([r.notification], n);
+	}
+	halt(e, t, n) {
+		let r = "failed", i = e.fail(t);
+		this.#p(e).delete(e);
+		let a = () => this.#m(i.cleanups, n);
+		this.scopeZone.trackProcess(e, n);
+		let o = [i.notification], s = this.#D;
+		if (s.status === "failing") {
+			re(() => {
+				s.draft.capture(e.stateAs(r).failure), this.#i(s.draft, a, o, { propagateFailure: this.#S }, n);
+			});
+			return;
+		}
+		this.#i(new X({
+			kind: "process",
+			process: e
+		}, () => e.stateAs(r).failure), a, o, { propagateFailure: this.#S }, n);
+	}
+	cancel(e) {
+		this.#D.status === "failing" ? this.#i(this.#D.draft, x, [], { propagateFailure: !1 }, e) : this.#r(e);
+	}
+	branch(t, n, r, i) {
+		let a = new e(t, n, this, r);
+		return this.#k.add(a), r.trackProcess(a.entryProcess, i), r.trackScope(a, i), a;
+	}
+	spawn(e, t, n) {
+		let r = e(this, t);
+		return this.#p(r).add(r), this.scopeZone.trackProcess(r, n), r;
+	}
+	createFuture() {
+		let e = new Y();
+		return this.#j.add(e), e.wait(() => {
+			this.#j.delete(e);
+		}), e;
+	}
+	wait(e, t, n) {
+		let r = t.wait((t, n) => {
+			e.resume(t), this.scopeZone.trackProcess(e, n);
+		});
+		e.wait(r), this.scopeZone.trackProcess(e, n);
+	}
+	send(e, t, n, r) {
+		e.#f(t, n, r);
+	}
+	receive(e, t, n) {
+		this.#A.enqueueReceiver(e, t), e.wait(() => {
+			this.#A.cancelReceiver(e);
+		}), this.scopeZone.trackProcess(e, n);
+	}
+	tryReceive(e) {
+		return this.#A.tryReceive(e);
+	}
+	lookup(e) {
+		return this.#P.has(e) ? b(this.#P.get(e)) : this.#C ? T : this.parentScope.lookup(e);
+	}
+	bind(e, t) {
+		this.#P.set(e, t);
+	}
+	unbind(e) {
+		this.#P.delete(e);
+	}
+	forceFailed(e, t) {
+		let n = new X({
+			kind: "scope",
+			scope: this
+		}, () => e);
+		for (this.#D.status === "failing" && n.capture(this.#D.draft.build()), this.#i(n, x, [], { propagateFailure: this.#S }, t); this.#D.status === "failing";) this.#i(this.#D.draft, x, [], { propagateFailure: !1 }, t);
+	}
+	get descriptor() {
+		return this.scopeDescriptor;
+	}
+	get entryProcess() {
+		return this.#E;
+	}
+	get zone() {
+		return this.scopeZone;
+	}
+	get parent() {
+		return this.#C ? null : this.parentScope;
+	}
+	get children() {
+		return [...this.#k];
+	}
+	get exitFuture() {
+		return this.#T;
+	}
+	get status() {
+		return this.#D.status;
+	}
+	get isClosed() {
+		switch (this.status) {
+			case "running":
+			case "closing":
+			case "canceling":
+			case "failing": return !1;
+			case "completed":
+			case "canceled":
+			case "failed": return !0;
+		}
+	}
+	constructor(e, t, n, r) {
+		this.scopeDescriptor = t, this.parentScope = n, this.scopeZone = r, this.#T = new Y();
+		let i = e(this, { completionMode: "structural" });
+		this.#p(i).add(i), this.#E = i;
+	}
+	#e(e, t) {
+		switch (this.#D.status) {
+			case "running":
+				this.#t(e, t);
+				return;
+			case "closing":
+				this.#a(e, t);
+				return;
+			case "canceling":
+				this.#o(e, t);
+				return;
+			case "failing":
+				this.#s(this.#D.draft, e, t);
+				return;
+			case "canceled":
+			case "completed":
+			case "failed": return w();
+		}
+	}
+	#t(e, t) {
+		if (this.#b) {
+			this.#n(e, t);
+			return;
+		}
+		Z(e, t);
+	}
+	#n(e, t) {
+		using n = this.#v();
+		this.#c({ status: "closing" }, e, t), this.#a([], t);
+	}
+	#r(e) {
+		using t = this.#v();
+		this.#c({ status: "canceling" }, [], e), this.#o([], e);
+	}
+	#i(e, t, n, r, i) {
+		using a = this.#v();
+		this.#c({
+			draft: e,
+			status: "failing"
+		}, n, i), t(), r.propagateFailure && this.parentScope.#y(Nn) && this.parentScope.#h(this, i), this.#s(e, [], i);
+	}
+	#a(e, t) {
+		if (this.#x) {
+			let { result: n } = this.#E.stateAs("completed");
+			this.#c({
+				result: n,
+				status: "completed"
+			}, e, t), !this.#C && this.parentScope.#y(Pn) && this.parentScope.#e([], t);
+			return;
+		}
+		Z(e, t);
+	}
+	#o(e, t) {
+		if (this.#x) {
+			this.#c({ status: "canceled" }, e, t), !this.#C && this.parentScope.#y(Pn) && this.parentScope.#e([], t);
+			return;
+		}
+		Z(e, t);
+	}
+	#s(e, t, n) {
+		if (this.#x) {
+			this.#c({
+				failure: e.build(),
+				status: "failed"
+			}, t, n), !this.#C && this.parentScope.#y(Pn) && this.parentScope.#e([], n);
+			return;
+		}
+		Z(t, n);
+	}
+	#c(e, t, n) {
+		switch (this.#D = e, e.status) {
+			case "running": return w();
+			case "closing":
+				t.push(...this.#u(n));
+				break;
+			case "canceling":
+			case "failing":
+				t.push(...this.#l(n));
+				break;
+			case "canceled":
+				t.push(...this.#d(i(U)));
+				break;
+			case "completed":
+				t.push(...this.#d(S(e.result)));
+				break;
+			case "failed":
+				t.push(...this.#d(i(e.failure)));
+				break;
+		}
+		Z(t, n), this.scopeZone.trackScope(this, n);
+	}
+	#l(e) {
+		let t = [...this.#M, ...this.#N], n = [...this.#k];
+		this.#M.clear(), this.#N.clear();
+		let r = [];
+		for (let n of t) {
+			let t = n.cancel();
+			this.#m(t.cleanups, e), this.scopeZone.trackProcess(n, e), r.push(t.notification);
+		}
+		for (let t of n) t.#y(Fn) && t.cancel(e);
+		return r;
+	}
+	#u(e) {
+		let t = [...this.#N];
+		this.#N.clear();
+		let n = [];
+		for (let r of t) {
+			let t = r.cancel();
+			this.#m(t.cleanups, e), this.scopeZone.trackProcess(r, e), n.push(t.notification);
+		}
+		return n;
+	}
+	#d(e) {
+		this.#C || this.parentScope.#g(this), this.#A.clear();
+		let t = i(U);
+		return [...Array.from(this.#j, (e) => e.settle(t)), this.#T.settle(e)];
+	}
+	#f(e, t, n) {
+		let r = this.#A.send(e, t);
+		r && (r.resume(t), this.scopeZone.trackProcess(r, n));
+	}
+	#p(e) {
+		return e.descriptor.completionMode === "structural" ? this.#M : this.#N;
+	}
+	#m(e, t) {
+		let n = (e) => {
+			this.spawn(e, { completionMode: "structural" }, t);
+		};
+		for (let t of e) t(n);
+	}
+	#h(e, t) {
+		if (this.#D.status === "failing") {
+			this.#i(this.#D.draft, x, [], { propagateFailure: this.#S }, t);
+			return;
+		}
+		this.#i(new X({
+			kind: "scope",
+			scope: e
+		}, () => e.#_("failed").failure), x, [], { propagateFailure: this.#S }, t);
+	}
+	#g(e) {
+		this.#D.status === "failing" && e.status === "failed" && e.descriptor.failureMode === "propagate" && this.#D.draft.capture(e.#_(e.status).failure), this.#k.delete(e);
+	}
+	#_(e) {
+		return this.#D;
+	}
+	#v() {
+		let e = this.#O;
+		return this.#O = !0, { [Symbol.dispose]: () => {
+			this.#O = e;
+		} };
+	}
+	#y(e) {
+		return !this.#O || !e(this.status);
+	}
+	get #b() {
+		return z(this.#M) && z(this.#k);
+	}
+	get #x() {
+		return this.#b && z(this.#N);
+	}
+	get #S() {
+		return this.scopeDescriptor.failureMode === "propagate";
+	}
+	get #C() {
+		return this.parentScope === e.#w;
+	}
+	static #w = null;
+	#T;
+	#E;
+	#D = { status: "running" };
+	#O = !1;
+	#k = /* @__PURE__ */ new Set();
+	#A = new jn();
+	#j = /* @__PURE__ */ new Set();
+	#M = /* @__PURE__ */ new Set();
+	#N = /* @__PURE__ */ new Set();
+	#P = /* @__PURE__ */ new Map();
+};
+function Z(e, t) {
+	for (let n of e) n(t);
+}
+function Nn(e) {
+	return e === "failing";
+}
+function Pn(e) {
+	return !0;
+}
+function Fn(e) {
+	return e === "canceling" || e === "failing";
+}
+//#endregion
+//#region src/interpreter/interpreter.ts
+var In = class e {
+	static create(t, n) {
+		let r = new e(t, n);
+		return r.initialize(), r;
+	}
+	step(e, t) {
+		let n = this.#r(e), r = n.runner();
+		switch (r.status) {
+			case "waiting": return K();
+			case "completed": return J(S(r.stateAs(r.status).result));
+			case "canceled": return J(i(U));
+			case "failed": return J(i(r.stateAs(r.status).failure));
+			case "running": {
+				let e;
+				try {
+					e = r.stateAs(r.status).next();
+				} catch (e) {
+					return Un(this.#r(n.scopeRef), n.keeper(), W(e), t), J(i(r.stateAs("failed").failure));
+				}
+				switch (e.kind) {
+					case "echo": return this.#e(n, e, t);
+					case "resonate": return Dn();
+					case "relic": return this.#r(n.scopeRef).complete(n.keeper(), e.relic, t), J(S(e.relic));
+				}
+			}
+		}
+	}
+	spawn(e, t, n) {
+		return this.#r(e).spawn(this.#t(t), { completionMode: "structural" }, n);
+	}
+	lookup(e, t) {
+		return this.#r(e).lookup(t);
+	}
+	poll(e) {
+		return this.#r(e).poll();
+	}
+	wait(e, t) {
+		return this.#r(e).wait(t);
+	}
+	forceFailed(e, t, n) {
+		this.#r(e).forceFailed(t, n);
+	}
+	scopeState(e) {
+		let t = this.#r(e);
+		switch (t.status) {
+			case "running": return {
+				...Q(t),
+				status: "open"
+			};
+			case "closing": return {
+				...Q(t),
+				status: "closing"
+			};
+			case "canceling": return {
+				...Q(t),
+				status: "closing"
+			};
+			case "failing": return {
+				...Q(t),
+				status: "closing"
+			};
+			case "canceled":
+			case "completed":
+			case "failed": return {
+				...Q(t),
+				status: "closed"
+			};
+		}
+	}
+	processState(e) {
+		switch (this.#r(e).runner().status) {
+			case "running": return {
+				activity: "running",
+				status: "open"
+			};
+			case "waiting": return {
+				activity: "waiting",
+				status: "open"
+			};
+			case "completed":
+			case "canceled":
+			case "failed": return { status: "closed" };
+		}
+	}
+	scope(e) {
+		return this.#r(e).scopeRef;
+	}
+	get scopeRoot() {
+		return this.#i;
+	}
+	get processRoot() {
+		return this.#i.entryProcess;
+	}
+	get isClosed() {
+		return this.#i.isClosed;
+	}
+	constructor(e, t) {
+		this.entry = e, this.zoneRoot = t;
+	}
+	scopeBranch(e, t, n, r, i) {
+		let a = zn(this.#r(e), this.#t(t), n, r, i);
+		return this.#n(a), a;
+	}
+	initialize() {
+		this.#i = Mn.root(this.#t(this.entry), { failureMode: "contain" }, this.zoneRoot, { capture: w }), this.#n(this.#i);
+	}
+	#e(e, t, n) {
+		let r = this.#r(e.scopeRef), a = e.runner(), [o, s, c] = Ln(t);
+		switch (o) {
+			case "bind": return Rn(r, s.key, s.value), c($), q();
+			case "branch": {
+				let e = this.scopeBranch(r, s.entry, s.descriptor, r.zone, n), t = this.#r(e);
+				return c({
+					process: t.entryProcess,
+					scope: t
+				}), q();
+			}
+			case "cede": return c($), En();
+			case "cancel": return Vn(r, n), J(i(U));
+			case "defer": return Bn(a, (e) => {
+				e(this.#t(s.cleanup));
+			}), c($), q();
+			case "future": {
+				let e = Hn(r);
+				return this.#n(e), c(e.handle()), q();
+			}
+			case "halt": return Un(r, e.keeper(), s.failure, n), J(i(a.stateAs("failed").failure));
+			case "lookup": return c(Kn(r, s.key)), q();
+			case "poll": return c(qn(this.#r(s.future))), q();
+			case "self": return c(Jn(a)), q();
+			case "settle": return Wn(this.#r(s.futureSettle), s.result, n), c($), q();
+			case "spawn": return c(Gn(r, this.#t(s.worker), s.descriptor, n)), q();
+			case "unbind": return Zn(r, s.key), c($), q();
+			case "wait": {
+				let t = this.#r(s.future), i = Yn(t);
+				return y(i) ? (c(i.value), q()) : (Xn(r, e.keeper(), t, n), K());
+			}
+			case "receive": {
+				let t = Qn(r, s.messageKey);
+				return y(t) ? (c(t.value), q()) : ($n(r, e.keeper(), s.messageKey, n), K());
+			}
+			case "send": return er(r, this.#r(s.scope), s.messageKey, s.value, n), c($), q();
+		}
+	}
+	#t(e) {
+		return (t, n) => {
+			let r = kn.create(t, e, n);
+			return this.#n(r), r.keeper();
+		};
+	}
+	#n(e) {}
+	#r(e) {
+		return e;
+	}
+	#i;
+};
+function Ln(e) {
+	return [
+		e.sigil.kind,
+		e.sigil,
+		e.accept
+	];
+}
+function Rn(e, t, n) {
+	e.bind(t, n);
+}
+function zn(e, t, n, r, i) {
+	return e.branch(t, n, r, i);
+}
+function Bn(e, t) {
+	e.defer(t);
+}
+function Vn(e, t) {
+	e.cancel(t);
+}
+function Hn(e) {
+	return e.createFuture();
+}
+function Un(e, t, n, r) {
+	e.halt(t, n, r);
+}
+function Wn(e, t, n) {
+	e.settle(t)(n);
+}
+function Gn(e, t, n, r) {
+	return e.spawn(t, n, r);
+}
+function Kn(e, t) {
+	return e.lookup(t);
+}
+function qn(e) {
+	return e.poll();
+}
+function Jn(e) {
+	return e.selfHandle();
+}
+function Yn(e) {
+	return e.poll();
+}
+function Xn(e, t, n, r) {
+	e.wait(t, n, r);
+}
+function Zn(e, t) {
+	e.unbind(t);
+}
+function Qn(e, t) {
+	return e.tryReceive(t);
+}
+function $n(e, t, n, r) {
+	e.receive(t, n, r);
+}
+function er(e, t, n, r, i) {
+	e.send(t, n, r, i);
+}
+function Q(e) {
+	return {
+		children: e.children,
+		descriptor: e.descriptor,
+		parent: e.parent,
+		zone: e.zone
+	};
+}
+var $ = void 0;
+//#endregion
+//#region src/executor/autonomy.ts
+function tr(e) {
+	return {
+		autonomy: e,
+		failureMode: "propagate"
+	};
+}
+function nr(e) {
+	return rr(e) ? e.autonomy : null;
+}
+function rr(e) {
+	return "autonomy" in e;
+}
+//#endregion
+//#region src/executor/domain-interpreter.ts
+var ir = class e extends In {
+	static createByAutonomy(t, n) {
+		let r = new e(t, n);
+		return r.initialize(), r;
+	}
+	*startReaperTasks(e) {
+		for (let t of wn.domains(this.#s)) if (t.hasClosingScope) for (let { scope: n, worker: r } of t.createWorkers((e) => this.scopeState(e))) {
+			using i = new G("Out-of-band failures occurred while spawning a reaper adjudication process");
+			let a = this.spawn(t.scopeRoot, r, i), o = i.drain();
+			if (y(o)) {
+				this.forceFailed(n, W(o.value), e);
+				continue;
+			}
+			yield [n, a];
+		}
+	}
+	constructor(e, t) {
+		let n = Tn.root(t.scheduler, (e) => this.#a(e)), r = wn.root(t.reaper);
+		super(e, {
+			reaperDomain: r,
+			schedulerDomain: n,
+			trackProcess: (e) => {
+				n.admitProcess(e, this.processState(e));
+			},
+			trackScope: (e) => {
+				r.trackScope(e, this.scopeState(e));
+			}
+		}), this.#s = r;
+	}
+	initialize() {
+		super.initialize(), this.#s.setScopeRoot(this.scopeRoot);
+	}
+	scopeBranch(e, t, n, r, i) {
+		let a = ar(r), o = nr(n), s = o ? this.#r(a, o) : or(a), c = s.zone, l = super.scopeBranch(e, t, n, c, i);
+		return this.#i(l) ? (s.rollback(), l) : (this.#e(a.reaperDomain, c.reaperDomain, e, l), this.#n(a.schedulerDomain, c.schedulerDomain, l), l);
+	}
+	#e(e, t, n, r) {
+		if (t === e) {
+			this.#t(e, n, r);
+			return;
+		}
+		t.setScopeRoot(r), this.wait(r.exitFuture, () => {
+			t.close(), this.#o(e, n);
+		});
+	}
+	#t(e, t, n) {
+		e.removeLeafScope(t), e.addLeafScope(n), this.wait(n.exitFuture, () => {
+			e.removeLeafScope(n), this.#o(e, t);
+		});
+	}
+	#n(e, t, n) {
+		t !== e && this.wait(n.exitFuture, () => {
+			t.close();
+		});
+	}
+	#r(e, t) {
+		let n = "scheduler" in t ? e.schedulerDomain.nest(t.scheduler, (e) => this.#a(e)) : e.schedulerDomain, r = "reaper" in t ? e.reaperDomain.nest(t.reaper) : e.reaperDomain, i = "scheduler" in t ? (e, t) => {
+			try {
+				n.admitProcess(e, this.processState(e));
+			} catch (n) {
+				this.forceFailed(this.scope(e), W(n), t);
+			}
+		} : e.trackProcess, a = "reaper" in t ? (e) => {
+			r.trackScope(e, this.scopeState(e));
+		} : e.trackScope;
+		function o() {
+			n !== e.schedulerDomain && n.close(), r !== e.reaperDomain && r.close();
+		}
+		return {
+			rollback: o,
+			zone: {
+				reaperDomain: r,
+				schedulerDomain: n,
+				trackProcess: i,
+				trackScope: a
+			}
+		};
+	}
+	#i(e) {
+		return this.scopeState(e).status === "closed";
+	}
+	#a(e) {
+		return { step: (t) => {
+			switch (this.step(e, t).disposition) {
+				case "waiting": return "waiting";
+				case "exited": return "exited";
+				case "ceded": return "cede";
+				case "interpreted":
+				case "resonated": return "ready";
+			}
+		} };
+	}
+	#o(e, t) {
+		let n = this.scopeState(t);
+		n.status === "closed" || Fe(n.children) || e.addLeafScope(t);
+	}
+	#s;
+};
+function ar(e) {
+	return e;
+}
+function or(e) {
+	return {
+		rollback: () => {},
+		zone: e
+	};
+}
+//#endregion
+//#region src/executor/executor-driver.ts
+var sr = class {
+	stop() {
+		this.#i = !0;
+	}
+	driveSyncUnsafely(e) {
+		for (;;) {
+			let t = this.stepProcess(e);
+			switch (t.disposition) {
+				case "interpreted":
+				case "resonated": continue;
+				case "ceded":
+				case "waiting":
+				case "exited": return t;
+			}
+		}
+	}
+	constructor(e, t) {
+		this.pacer = e, this.stepProcess = t;
+	}
+	get processor() {
+		return this.#s;
+	}
+	#e() {
+		this.#i || this.#a || !this.#r || (this.#a = !0, this.pacer.continueLater(() => {
+			if (this.#i) {
+				this.#a = !1;
+				return;
+			}
+			try {
+				this.#t();
+			} finally {
+				this.#a = !1, this.#e();
+			}
+		}));
+	}
+	#t() {
+		let e = this.pacer.beginSlice();
+		for (; this.#r && !e.shouldYield();) this.#n();
+	}
+	#n() {
+		let [e] = this.#o;
+		for (;;) {
+			using t = new G("Out-of-band failures occurred while processing executor work");
+			switch (e.step(t)) {
+				case "ready": continue;
+				case "cede":
+					this.#o.shift(), this.#o.push(e);
+					return;
+				case "waiting":
+				case "exited":
+					this.#o.shift();
+					return;
+			}
+		}
+	}
+	get #r() {
+		return Fe(this.#o);
+	}
+	#i = !1;
+	#a = !1;
+	#o = [];
+	#s = { admit: (e) => {
+		this.#o.push(e), this.#e();
+	} };
+}, cr = class {
+	constructor(e) {
+		this.roundLimit = e;
+	}
+	adjudicate(e) {
+		let t = this.#t.getOrInsertComputed(e, () => ({ round: 0 })), { round: n } = t;
+		return t.round += 1, n >= this.roundLimit ? V.of(b(this.#e(n))) : V.of(T);
+	}
+	#e(e) {
+		return xn({
+			round: e,
+			roundLimit: this.roundLimit
+		}, "Scope did not finish closing within the executor reaper round limit");
+	}
+	#t = /* @__PURE__ */ new WeakMap();
+}, lr = class {
+	onSettled(e) {
+		return this.lifecycle.onSettled(this.executionScope, e);
+	}
+	constructor(e, t) {
+		this.executionScope = e, this.lifecycle = t;
+	}
+	get scope() {
+		return this.executionScope;
+	}
+	get status() {
+		return this.lifecycle.status(this.executionScope);
+	}
+};
+//#endregion
+//#region src/executor/executor.ts
+function ur(e) {
+	return new dr(e);
+}
+var dr = class {
+	constructor(e) {
+		this.#s = new sr(e(() => {
+			this.#e();
+		}), (e) => this.#c.step(e, { capture: w })), this.#c = ir.createByAutonomy(rn, {
+			reaper: new cr(mr),
+			scheduler: { assign: () => this.#s.processor }
+		}), this.#l = this.#a(this.#c.scopeRoot), this.#c.wait(this.#l.exitFuture, () => {
+			this.#s.stop();
+		});
+	}
+	launch(e, t) {
+		if (!this.#t(e)) return T;
+		using n = new G("Out-of-band failures occurred while spawning a launched scope");
+		let r = this.#c.spawn(e, fr(t), n), i = n.drain();
+		if (y(i)) return this.#n(e, i.value), T;
+		let a = this.#s.driveSyncUnsafely(r).result.right;
+		return b(new lr(this.#a(a), {
+			onSettled: (e, t) => this.#r(e, t),
+			status: (e) => this.#i(e)
+		}));
+	}
+	settle(e, t) {
+		return y(this.#c.poll(e)) ? !1 : (this.#c.spawn(this.scope, () => yn(e, t), { capture: w }), !0);
+	}
+	cancel(e) {
+		if (!this.#t(e)) return !1;
+		using t = new G("Out-of-band failures occurred while spawning a cancellation process");
+		this.#c.spawn(e, Yt, t);
+		let n = t.drain();
+		return y(n) ? (this.#n(e, n.value), !1) : !0;
+	}
+	onSettled(e) {
+		return this.#r(this.#l, e);
+	}
+	get scope() {
+		return this.#l;
+	}
+	get status() {
+		return this.#i(this.#l);
+	}
+	#e() {
+		using e = new G("Out-of-band failures occurred while starting a reaper round");
+		for (let [t, r] of this.#c.startReaperTasks(e)) this.#c.wait(r.exitFuture, (e, r) => {
+			this.#c.scopeState(t).status !== "closed" && g(e, me(C(() => S(yt), (e) => i(e))), n((e) => () => {
+				this.#c.spawn(t, () => en(e), r);
+			}), (e) => e());
+		});
+	}
+	#t(e) {
+		return this.#o(e) && this.#c.scopeState(e).status === "open";
+	}
+	#n(e, t) {
+		using n = new G("Out-of-band failures occurred while force failing a scope");
+		this.#c.forceFailed(e, W(t), n);
+	}
+	#r(e, t) {
+		let n = this.#c.poll(e.exitFuture);
+		return y(n) ? (t(pr(n.value)), x) : this.#c.wait(e.exitFuture, (e, n) => {
+			try {
+				t(pr(e));
+			} catch (e) {
+				n.capture(e);
+			}
+		});
+	}
+	#i(e) {
+		return this.#c.scopeState(e).status;
+	}
+	#a(e) {
+		return this.#u.add(e), e;
+	}
+	#o(e) {
+		return this.#u.has(e);
+	}
+	#s;
+	#c;
+	#l;
+	#u = /* @__PURE__ */ new WeakSet();
+};
+function fr(e) {
+	return () => g(D(e, { failureMode: "contain" }), V.liftF, V.map(({ scope: e }) => e));
+}
+function pr(e) {
+	return E(e) ? e.left === U ? { kind: "canceled" } : {
+		failure: e.left,
+		kind: "failure"
+	} : {
+		kind: "success",
+		result: e.right
+	};
+}
+var mr = 2;
+//#endregion
+//#region src/executor/primitives/autonomy.ts
+function hr(e, t) {
+	return g(D(e, tr(t)), V.liftF, V.map(({ scope: e }) => e.exitFuture));
+}
+//#endregion
+export { Gt as all, hr as autonomy, Jt as bind, Yt as cancel, U as canceledFailure, Xt as cede, ke as contextKey, ur as createExecutor, Zt as defer, _n as enclose, De as evoke, xn as externalFailure, $t as future, pn as guard, en as halt, W as interruptedFailure, tn as lookup, Oe as messageKey, rn as park, nn as poll, on as race, ln as resource, N as restingWisp, dn as resumable, Sn as scopeFailure, vn as self, yn as settle, Qt as spawn, M as stirringWisp, bn as unbind, qt as wait };