@systemfsoftware/effect-daemon-spec 0.5.0 → 0.7.0

package/dist/index.mjs

@@ -1,16 +1,22 @@
 import { Array as Array$1, Cause, Clock, Context, Duration, Effect, Either, Exit, Fiber, HashMap, Layer, Match, Metric, Option, Predicate, Ref, Schedule, Schema, Scope, Stream } from "effect";
-import { dual } from "effect/Function";
-import "effect/Schema";
-//#region src/backoff.ts
+import { left, right } from "effect/Either";
+import * as Match$1 from "effect/Match";
+import * as S from "effect/Schema";
+//#region src/backoff.kernel.ts
 const cappedBackoff = (base, cap) => {
 	const ceiling = Duration.decode(cap);
 	return Schedule.exponential(base).pipe(Schedule.jittered, Schedule.modifyDelay((_, delay) => Duration.min(delay, ceiling)));
 };
 //#endregion
+//#region src/brands.kernel.ts
+const WorkerTypeId = Symbol.for("@systemfsoftware/effect-daemon/Worker");
+const SupervisorTypeId = Symbol.for("@systemfsoftware/effect-daemon/Supervisor");
+const DynamicSpecTypeId = Symbol.for("@systemfsoftware/effect-daemon/DynamicSpec");
+//#endregion
 //#region src/daemon-health.schema.ts
 var DynamicLimitExceeded = class extends Schema.TaggedError()("DynamicLimitExceeded", { limit: Schema.Int.pipe(Schema.greaterThanOrEqualTo(0)) }) {};
 //#endregion
-//#region src/daemon-metrics.ts
+//#region src/daemon-metrics.kernel.ts
 const supervisorRestartsCounter = Metric.counter("app.daemon.supervisor.restart", { description: "Daemon supervisor restart count" });
 const supervisorExhaustionsCounter = Metric.counter("app.daemon.supervisor.exhaustion", { description: "Daemon supervisor exhaustion count" });
 const supervisorChildrenGauge = Metric.gauge("app.daemon.supervisor.children", { description: "Daemon supervisor current child count (dynamic supervisors only)" });
@@ -47,61 +53,75 @@ var TickPolicyConfig = class extends Schema.Class("TickPolicyConfig")({
 	startLogLevel: Schema.optional(Schema.Literal("debug", "info"))
 }) {};
 //#endregion
-//#region src/daemon-reporter.ts
-var DaemonReporter = class DaemonReporter extends Context.Tag("@systemfsoftware/effect-daemon-spec/daemon-reporter/DaemonReporter")() {
-	static Noop = Layer.succeed(DaemonReporter, DaemonReporter.of({
-		onRestart: () => Effect.void,
-		onExhausted: () => Effect.void
-	}));
-};
-//#endregion
-//#region src/daemon-spec.ts
-const WorkerTypeId = Symbol.for("@systemfsoftware/effect-daemon/Worker");
-const SupervisorTypeId = Symbol.for("@systemfsoftware/effect-daemon/Supervisor");
-const DynamicSpecTypeId = Symbol.for("@systemfsoftware/effect-daemon/DynamicSpec");
-const isWorker = (x) => WorkerTypeId in x;
-const isSupervisor = (x) => SupervisorTypeId in x;
+//#region src/daemon-reporter.adapter.ts
+var DaemonReporter = class extends Context.Tag("@systemfsoftware/effect-daemon-spec/daemon-reporter.adapter/DaemonReporter")() {};
+const Noop = Layer.succeed(DaemonReporter, DaemonReporter.of({
+	onRestart: () => Effect.void,
+	onExhausted: () => Effect.void
+}));
 //#endregion
-//#region src/daemon.ts
-const make$1 = (common, loop) => ({
-	[WorkerTypeId]: WorkerTypeId,
-	name: common.name,
-	loop,
-	child: common.child ?? {},
-	tick: common.tick,
-	tickHooks: common.tickHooks ?? {},
-	lock: common.lock
-});
-const poll = (opts) => {
+//#region src/daemon-poll.kernel.ts
+const poll$1 = (opts) => {
 	if (typeof opts.prereq === "undefined") {
 		const gate = Effect.succeed(Option.some(Effect.asVoid(opts.work)));
-		return make$1(opts, {
-			_tag: "Poll",
-			gate,
-			interval: opts.interval
-		});
+		return {
+			[WorkerTypeId]: WorkerTypeId,
+			name: opts.name,
+			loop: {
+				_tag: "Poll",
+				gate,
+				interval: opts.interval
+			},
+			child: opts.child ?? {},
+			tick: opts.tick,
+			tickHooks: opts.tickHooks ?? {},
+			lock: opts.lock
+		};
 	}
 	const { prereq, work } = opts;
 	const gate = Effect.map(prereq, Option.map((data) => work(data)));
-	return make$1(opts, {
-		_tag: "Poll",
-		gate,
-		interval: opts.interval
-	});
+	return {
+		[WorkerTypeId]: WorkerTypeId,
+		name: opts.name,
+		loop: {
+			_tag: "Poll",
+			gate,
+			interval: opts.interval
+		},
+		child: opts.child ?? {},
+		tick: opts.tick,
+		tickHooks: opts.tickHooks ?? {},
+		lock: opts.lock
+	};
 };
-const stream = (opts) => make$1(opts, {
-	_tag: "Stream",
-	stream: opts.stream
+//#endregion
+//#region src/daemon-stream.kernel.ts
+const stream$1 = (opts) => ({
+	[WorkerTypeId]: WorkerTypeId,
+	name: opts.name,
+	loop: {
+		_tag: "Stream",
+		stream: opts.stream
+	},
+	child: opts.child ?? {},
+	tick: opts.tick,
+	tickHooks: opts.tickHooks ?? {},
+	lock: opts.lock
 });
-const subscription = (opts) => make$1(opts, {
-	_tag: "Subscription",
-	acquire: Effect.asVoid(opts.acquire)
+//#endregion
+//#region src/daemon-subscription.kernel.ts
+const subscription$1 = (opts) => ({
+	[WorkerTypeId]: WorkerTypeId,
+	name: opts.name,
+	loop: {
+		_tag: "Subscription",
+		acquire: Effect.asVoid(opts.acquire)
+	},
+	child: opts.child ?? {},
+	tick: opts.tick,
+	tickHooks: opts.tickHooks ?? {},
+	lock: opts.lock
 });
-const Daemon = {
-	poll,
-	stream,
-	subscription
-};
 //#endregion
 //#region src/leader-lock.schema.ts
 var LeaderLockNotAcquired = class extends Schema.TaggedError()("LeaderLockNotAcquired", { key: Schema.String }) {};
@@ -110,24 +130,17 @@ var LeaderLockInfraError = class extends Schema.TaggedError()("LeaderLockInfraEr
 	cause: Schema.Unknown
 }) {};
 //#endregion
-//#region src/leader-lock.ts
-var LeaderLock = class LeaderLock extends Context.Tag("@systemfsoftware/effect-daemon-spec/leader-lock/LeaderLock")() {
-	static Noop = Layer.succeed(LeaderLock, LeaderLock.of({ withLock: (_key, self) => Effect.map(self, Option.some) }));
-};
-const withLeaderLock = dual(2, (self, options) => Effect.gen(function* () {
-	const out = yield* (yield* LeaderLock).withLock(options.key, self);
-	if (Option.isSome(out)) return out.value;
-	return yield* Match.value(options.mode).pipe(Match.when("required", () => Effect.fail(new LeaderLockNotAcquired({ key: options.key }))), Match.when("optional", () => Effect.void), Match.exhaustive);
-}));
-//#endregion
 //#region src/lock-primitive.schema.ts
 var LockPrimitiveError = class extends Schema.TaggedError()("LockPrimitiveError", {
 	key: Schema.String,
 	cause: Schema.Unknown
 }) {};
 //#endregion
-//#region src/lock-primitive.ts
-var LockPrimitive = class extends Context.Tag("@systemfsoftware/effect-daemon-spec/lock-primitive/LockPrimitive")() {};
+//#region src/leader-lock.adapter.ts
+var LeaderLock = class LeaderLock extends Context.Tag("@systemfsoftware/effect-daemon-spec/leader-lock.adapter/LeaderLock")() {
+	static Noop = Layer.succeed(LeaderLock, LeaderLock.of({ withLock: (_key, self) => Effect.map(self, Option.some) }));
+};
+var LockPrimitive = class extends Context.Tag("@systemfsoftware/effect-daemon-spec/leader-lock.adapter/LockPrimitive")() {};
 const LeaderLockFromPrimitive = Layer.effect(LeaderLock, Effect.gen(function* () {
 	const primitive = yield* LockPrimitive;
 	return LeaderLock.of({ withLock: (key, self) => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
@@ -144,13 +157,163 @@ const LeaderLockFromPrimitive = Layer.effect(LeaderLock, Effect.gen(function* ()
 	})) });
 }));
 //#endregion
-//#region src/internal/intensity-window.ts
+//#region src/internal/allocate-worker-health.kernel.ts
+const allocateWorkerHealth = (name) => Effect.gen(function* () {
+	const ready = yield* Effect.makeLatch(false);
+	const healthy = yield* Effect.makeLatch(true);
+	const paused = yield* Effect.makeLatch(true);
+	yield* Metric.set(Metric.tagged(Metric.tagged(healthStateGauge, "daemon", name), "latch", "ready"), 0);
+	yield* Metric.set(Metric.tagged(Metric.tagged(healthStateGauge, "daemon", name), "latch", "healthy"), 1);
+	yield* Metric.set(Metric.tagged(Metric.tagged(healthStateGauge, "daemon", name), "latch", "paused"), 1);
+	return {
+		name,
+		ready,
+		healthy,
+		paused
+	};
+});
+//#endregion
+//#region src/internal/build-worker-loop.kernel.ts
+const applySpanAttributes = (hooks) => {
+	const { spanAttributes } = hooks;
+	return (effect) => {
+		if (typeof spanAttributes === "undefined") return effect;
+		return Effect.tap(effect, () => Effect.orElse(spanAttributes, () => Effect.succeed({})).pipe(Effect.flatMap(Effect.annotateCurrentSpan)));
+	};
+};
+const applyTrackDuration = (hooks) => {
+	const { trackDuration } = hooks;
+	return (effect) => {
+		if (typeof trackDuration === "undefined") return effect;
+		return Metric.trackDuration(effect, trackDuration);
+	};
+};
+const applyTimeout = (timeout) => (effect) => Effect.timeoutFail(effect, {
+	duration: timeout,
+	onTimeout: () => new Cause.TimeoutException()
+});
+const applyInnerRetry = (hooks) => {
+	const { innerRetry } = hooks;
+	return (effect) => {
+		if (typeof innerRetry === "undefined") return effect;
+		return Effect.retry(effect, innerRetry);
+	};
+};
+const openReadyGauge = (gauge, name) => Metric.set(Metric.tagged(Metric.tagged(gauge, "daemon", name), "latch", "ready"), 1);
+const buildPollTick = (worker, health, gate, readyGauge) => {
+	const spanName = worker.tick.spanName ?? "daemon.tick";
+	const withSpanAttrs = applySpanAttributes(worker.tickHooks);
+	const withDuration = applyTrackDuration(worker.tickHooks);
+	const withTimeout = applyTimeout(worker.tick.tickTimeout);
+	const withInnerRetry = applyInnerRetry(worker.tickHooks);
+	const runWork = (work) => work.pipe(withSpanAttrs, withDuration, Effect.withSpan(spanName, {
+		root: true,
+		attributes: { "daemon.name": worker.name }
+	}), Effect.withLogSpan(spanName));
+	return withInnerRetry(withTimeout(Effect.andThen(health.paused.await, gate).pipe(Effect.flatMap(Option.match({
+		onNone: () => Effect.void,
+		onSome: runWork
+	}))))).pipe(Effect.tap(() => Effect.zipRight(health.ready.open, openReadyGauge(readyGauge, worker.name))), Effect.asVoid);
+};
+const wrapSpan = (worker, effect, spanName) => {
+	const finalSpan = spanName ?? "daemon.worker";
+	return effect.pipe(Effect.withSpan(finalSpan, {
+		root: true,
+		attributes: { "daemon.name": worker.name }
+	}), Effect.withLogSpan(finalSpan));
+};
+const buildPollLoop = (worker, loop, health, readyGauge) => {
+	const tick = buildPollTick(worker, health, loop.gate, readyGauge);
+	return Effect.repeat(tick, Schedule.spaced(loop.interval)).pipe(Effect.asVoid);
+};
+const propagateExit = (exit) => Match.value(exit).pipe(Match.tag("Failure", ({ cause }) => Effect.failCause(cause)), Match.orElse(() => Effect.void));
+const buildStreamLoop = (worker, loop, health, readyGauge) => {
+	const body = Effect.gen(function* () {
+		yield* health.paused.await;
+		const fiber = yield* Effect.forkScoped(loop.stream.pipe(Stream.tap(() => Effect.zipRight(health.ready.open, openReadyGauge(readyGauge, worker.name))), Stream.runDrain));
+		const ready = applyTimeout(worker.tick.tickTimeout)(health.ready.await);
+		yield* Effect.raceFirst(ready, fiber.await.pipe(Effect.flatMap(propagateExit)));
+		yield* fiber.await.pipe(Effect.flatMap(propagateExit));
+	});
+	const retried = applyInnerRetry(worker.tickHooks)(body);
+	return wrapSpan(worker, retried.pipe(Effect.asVoid));
+};
+const buildSubscriptionLoop = (worker, loop, health, readyGauge) => {
+	const body = Effect.gen(function* () {
+		yield* health.paused.await;
+		yield* applyTimeout(worker.tick.tickTimeout)(loop.acquire);
+		yield* Effect.zipRight(health.ready.open, openReadyGauge(readyGauge, worker.name));
+		return yield* Effect.never;
+	});
+	return wrapSpan(worker, body.pipe(Effect.asVoid));
+};
+const buildWorkerLoop = (worker, health, readyGauge) => Match.value(worker.loop).pipe(Match.tag("Poll", (loop) => buildPollLoop(worker, loop, health, readyGauge)), Match.tag("Stream", (loop) => buildStreamLoop(worker, loop, health, readyGauge)), Match.tag("Subscription", (loop) => buildSubscriptionLoop(worker, loop, health, readyGauge)), Match.exhaustive);
+//#endregion
+//#region src/internal/with-leader-lock.executor.ts
+var WithLeaderLockExecutorDeps = class extends Context.Tag("WithLeaderLockExecutorDeps")() {};
+function withLeaderLock(self, options) {
+	const acquire = Effect.gen(function* () {
+		const out = yield* (yield* WithLeaderLockExecutorDeps).withLock(options.key, self);
+		if (Option.isSome(out)) return out.value;
+		return yield* Match.value(options.mode).pipe(Match.when("required", () => Effect.fail(new LeaderLockNotAcquired({ key: options.key }))), Match.when("optional", () => Effect.void), Match.exhaustive);
+	});
+	const retryOnce = (current) => Effect.retry(acquire, {
+		schedule: current,
+		while: Predicate.isTagged("LeaderLockNotAcquired")
+	}).pipe(Effect.catchTag("LeaderLockNotAcquired", () => retryOnce(current)));
+	const backoff = options.acquireRetryBackoff;
+	if (options.mode === "required" && backoff !== null && typeof backoff === "object") return retryOnce(backoff);
+	return acquire;
+}
+//#endregion
+//#region src/leader-lock.kernel.ts
+const isModeNone = (lock) => lock.mode === "none";
+Context.Tag("DaemonWorkerExecutorDeps")();
+const worker = (w) => Effect.gen(function* () {
+	const health = yield* allocateWorkerHealth(w.name);
+	const loop = buildWorkerLoop(w, health, healthStateGauge).pipe(Effect.orDie);
+	const lockNone = isModeNone(w.lock);
+	const required = !lockNone && w.lock.mode === "required";
+	let locked;
+	if (lockNone) locked = loop;
+	else if (required) locked = withLeaderLock(loop, {
+		key: w.lock.key,
+		mode: "required",
+		acquireRetryBackoff: w.lock.acquireRetryBackoff
+	});
+	else locked = withLeaderLock(loop, {
+		key: w.lock.key,
+		mode: "optional"
+	});
+	yield* Effect.forkScoped(locked.pipe(Effect.orDie));
+	return health;
+});
+//#endregion
+//#region src/internal/allocate-supervisor-health.kernel.ts
+const allocateSupervisorHealth = (name, children) => Effect.gen(function* () {
+	const ready = yield* Effect.makeLatch(false);
+	const healthy = yield* Effect.makeLatch(true);
+	const paused = yield* Effect.makeLatch(true);
+	yield* Metric.set(Metric.tagged(Metric.tagged(healthStateGauge, "daemon", name), "latch", "ready"), 0);
+	yield* Metric.set(Metric.tagged(Metric.tagged(healthStateGauge, "daemon", name), "latch", "healthy"), 1);
+	yield* Metric.set(Metric.tagged(Metric.tagged(healthStateGauge, "daemon", name), "latch", "paused"), 1);
+	return {
+		name,
+		ready,
+		healthy,
+		paused,
+		children
+	};
+});
+//#endregion
+//#region src/internal/intensity-window.kernel.ts
 const isWithinWindow = (now, windowMillis) => (t) => now - t <= windowMillis;
-const pruneTimestamps = (ts, now, windowMillis) => ts.filter(isWithinWindow(now, windowMillis));
+const keepWithin = (now, windowMillis) => (ts) => ts.filter(isWithinWindow(now, windowMillis));
+const pruneTimestamps = (ts, now, windowMillis) => keepWithin(now, windowMillis)(ts);
 const recordTimestamp = (ts, now, windowMillis) => [now, ...pruneTimestamps(ts, now, windowMillis)];
 const exceedsRestarts = (count, restarts) => count > restarts;
 //#endregion
-//#region src/internal/intensity.ts
+//#region src/internal/intensity.kernel.ts
 const neverExceeds = {
 	record: Effect.void,
 	isExceeded: Effect.succeed(false),
@@ -180,18 +343,10 @@ const boundedTracker = (restarts, window) => Effect.gen(function* () {
 });
 const make = (intensity) => Match.value(intensity).pipe(Match.tag("Unbounded", () => Effect.succeed(neverExceeds)), Match.tag("Bounded", ({ restarts, window }) => boundedTracker(restarts, window)), Match.exhaustive);
 //#endregion
+//#region src/internal/race-for-exit.kernel.ts
+const raceForExit = (fibers) => Effect.raceAll(fibers.map((f, idx) => f.await.pipe(Effect.map((exit) => [idx, exit]))));
+//#endregion
 //#region src/internal/restart-decision.schema.ts
-const RestartDecisionTypeId = Symbol.for("@systemfsoftware/effect-daemon/RestartDecision");
-var Continue = class extends Schema.TaggedClass()("Continue", {}) {
-	[RestartDecisionTypeId] = RestartDecisionTypeId;
-};
-var Restart = class extends Schema.TaggedClass()("Restart", { indices: Schema.NonEmptyArray(Schema.Int) }) {
-	[RestartDecisionTypeId] = RestartDecisionTypeId;
-};
-var Exhausted = class extends Schema.TaggedClass()("Exhausted", {}) {
-	[RestartDecisionTypeId] = RestartDecisionTypeId;
-};
-Schema.Union(Continue, Restart, Exhausted);
 const RestartStrategy = Schema.Literal("one_for_one", "one_for_all", "rest_for_one");
 Schema.Struct({
 	strategy: RestartStrategy,
@@ -213,30 +368,24 @@ Schema.Struct({
 	intensityExceeded: fc.boolean()
 }))) }));
 //#endregion
-//#region src/internal/restart-decision.strategy.ts
-const restartIndicesFor = (strategy, failedIndex, total) => {
-	if (strategy === "one_for_one") return [failedIndex];
-	if (strategy === "one_for_all") return [0, ...Array.from({ length: Math.max(0, total - 1) }, (_, i) => i + 1)];
-	return [failedIndex, ...Array.from({ length: Math.max(0, total - failedIndex - 1) }, (_, i) => failedIndex + 1 + i)];
+//#region src/internal/restart-decision.workflow.ts
+const RestartDecisionTypeId = Symbol.for("@systemfsoftware/effect-daemon/RestartDecision");
+var RestartDecisionContinue = class extends S.TaggedClass()("Continue", {}) {
+	[RestartDecisionTypeId] = RestartDecisionTypeId;
 };
-const decideRestart = (input) => {
-	if (input.exitSuccess) return new Continue();
-	if (input.intensityExceeded) return new Exhausted();
-	return new Restart({ indices: restartIndicesFor(input.strategy, input.failedIndex, input.totalChildren) });
+var RestartDecisionRestart = class extends S.TaggedClass()("Restart", { indices: S.NonEmptyArray(S.Int) }) {
+	[RestartDecisionTypeId] = RestartDecisionTypeId;
 };
+var RestartDecisionExhausted = class extends S.TaggedError()("Exhausted", {}) {
+	[RestartDecisionTypeId] = RestartDecisionTypeId;
+};
+const restartIndicesFor = (strategy, failedIndex, total) => Match$1.value(strategy).pipe(Match$1.when("one_for_one", () => [failedIndex]), Match$1.when("one_for_all", () => [0, ...Array.from({ length: Math.max(0, total - 1) }, (_, i) => i + 1)]), Match$1.when("rest_for_one", () => [failedIndex, ...Array.from({ length: Math.max(0, total - failedIndex - 1) }, (_, i) => failedIndex + 1 + i)]), Match$1.exhaustive);
+const decideRestart = (input) => Match$1.value(input).pipe(Match$1.when({ exitSuccess: true }, () => right(new RestartDecisionContinue())), Match$1.when({
+	exitSuccess: false,
+	intensityExceeded: true
+}, () => left(new RestartDecisionExhausted())), Match$1.orElse(() => right(new RestartDecisionRestart({ indices: restartIndicesFor(input.strategy, input.failedIndex, input.totalChildren) }))));
 //#endregion
-//#region src/internal/supervise-index.ts
-const failedIndexOf = (startIdx, failedOffset) => startIdx + failedOffset;
-//#endregion
-//#region src/internal/supervision-context.strategy.ts
-const openAllReady = (ctx) => Effect.gen(function* () {
-	yield* Effect.yieldNow();
-	yield* Effect.forEach(ctx.booted, (b) => b.health.ready.await, { concurrency: "unbounded" });
-	yield* Effect.zipRight(ctx.health.ready.open, Metric.set(Metric.tagged(Metric.tagged(healthStateGauge, "daemon", ctx.name), "latch", "ready"), 1));
-});
-const raceForExit = (fibers) => Effect.raceAll(fibers.map((f, idx) => f.await.pipe(Effect.map((exit) => [idx, exit]))));
-//#endregion
-//#region src/internal/supervise-tree.strategy.ts
+//#region src/internal/supervision-epoch.schema.ts
 const EpochStepTypeId = Symbol.for("@systemfsoftware/effect-daemon/EpochStep");
 var StopEpoch = class extends Schema.TaggedClass()("StopEpoch", {}) {
 	[EpochStepTypeId] = EpochStepTypeId;
@@ -256,6 +405,9 @@ var ContinueSupervision = class extends Schema.TaggedClass()("ContinueSupervisio
 	[SupervisionEpochResultTypeId] = SupervisionEpochResultTypeId;
 };
 Schema.Union(StopSupervision, ContinueSupervision);
+//#endregion
+//#region src/internal/supervisor-body.executor.ts
+var SupervisorBodyExecutorDeps = class extends Context.Tag("SupervisorBodyExecutorDeps")() {};
 const handleExhausted = (ctx, cause) => Effect.gen(function* () {
 	yield* Effect.zipRight(ctx.health.healthy.close, Metric.set(Metric.tagged(Metric.tagged(healthStateGauge, "daemon", ctx.name), "latch", "healthy"), 0));
 	yield* ctx.reportExhausted(cause);
@@ -272,7 +424,7 @@ const runSupervisionEpochWithBackoff = (attempt, ctx) => Effect.gen(function* ()
 	const loop = () => Effect.gen(function* () {
 		const step = yield* attempt.pipe(Effect.scoped);
 		return yield* Match.value(step).pipe(Match.tag("StopEpoch", () => Effect.succeed(new StopSupervision())), Match.tag("CooldownEpoch", () => Effect.gen(function* () {
-			yield* Effect.sleep(Duration.decode(ctx.policy.cooldown));
+			yield* Effect.sleep(ctx.policy.cooldown);
 			yield* reopenHealthyAfterCooldown(ctx);
 			return new ContinueSupervision();
 		})), Match.tag("RestartEpoch", () => Effect.gen(function* () {
@@ -283,13 +435,18 @@ const runSupervisionEpochWithBackoff = (attempt, ctx) => Effect.gen(function* ()
 	});
 	return yield* loop();
 });
+const openAllReady = (ctx) => Effect.gen(function* () {
+	yield* Effect.yieldNow();
+	yield* Effect.forEach(ctx.booted, (b) => b.health.ready.await, { concurrency: "unbounded" });
+	yield* Effect.zipRight(ctx.health.ready.open, Metric.set(Metric.tagged(Metric.tagged(healthStateGauge, "daemon", ctx.name), "latch", "ready"), 1));
+});
 const superviseChild = (ctx, child, idx) => Effect.gen(function* () {
 	const childIntensityOpt = yield* Option.match(Option.fromNullable(child.childPolicy.intensity), {
 		onNone: () => Effect.succeed(Option.none()),
 		onSome: (cfg) => Effect.map(make(new BoundedIntensity(cfg)), Option.some)
 	});
 	const loop = () => Effect.gen(function* () {
-		const supIntensity = yield* make(ctx.policy.intensity);
+		const supIntensity = yield* ctx.intensityEff;
 		const attempt = Effect.gen(function* () {
 			yield* ctx.health.paused.await;
 			const fiber = yield* Effect.forkScoped(child.run);
@@ -311,7 +468,10 @@ const superviseChild = (ctx, child, idx) => Effect.gen(function* () {
 					failedIndex: idx,
 					totalChildren: ctx.booted.length
 				});
-				return yield* Match.value(decision).pipe(Match.tag("Continue", () => Effect.succeed(new StopEpoch())), Match.tag("Exhausted", () => handleExhausted(ctx, exit.cause)), Match.tag("Restart", () => handleRestart(ctx, exit.cause, Effect.void)), Match.exhaustive);
+				return yield* Either.match(decision, {
+					onLeft: () => handleExhausted(ctx, exit.cause),
+					onRight: (right) => Match.value(right).pipe(Match.tag("Continue", () => Effect.succeed(new StopEpoch())), Match.tag("Restart", () => handleRestart(ctx, exit.cause, Effect.void)), Match.exhaustive)
+				});
 			}
 			return new StopEpoch();
 		});
@@ -328,7 +488,7 @@ const runIndependent = (ctx) => Effect.gen(function* () {
 });
 const runGroup = (strategy, ctx) => Effect.gen(function* () {
 	const loop = () => Effect.gen(function* () {
-		const intensity = yield* make(ctx.policy.intensity);
+		const intensity = yield* ctx.intensityEff;
 		const childIntensityTrackers = yield* Effect.forEach(ctx.booted, (b) => Option.match(Option.fromNullable(b.childPolicy.intensity), {
 			onNone: () => Effect.succeed(Option.none()),
 			onSome: (cfg) => Effect.map(make(new BoundedIntensity(cfg)), Option.some)
@@ -343,7 +503,7 @@ const runGroup = (strategy, ctx) => Effect.gen(function* () {
 			yield* Effect.forkScoped(openAllReady(ctx));
 			const [failedOffset, firstExit] = yield* raceForExit(fibers);
 			if (!Exit.isSuccess(firstExit)) {
-				const failedIdx = failedIndexOf(startIdx, failedOffset);
+				const failedIdx = startIdx + failedOffset;
 				const failedBootedOpt = Option.fromNullable(ctx.booted[failedIdx]);
 				if (Option.isNone(failedBootedOpt)) return new StopEpoch();
 				if (failedBootedOpt.value.childPolicy.restart === "temporary") return new StopEpoch();
@@ -360,10 +520,13 @@ const runGroup = (strategy, ctx) => Effect.gen(function* () {
 					strategy,
 					exitSuccess: false,
 					intensityExceeded: yield* intensity.isExceeded,
-					failedIndex: failedIdx,
-					totalChildren: ctx.booted.length
+					totalChildren: ctx.booted.length,
+					failedIndex: failedIdx
+				});
+				return yield* Either.match(decision, {
+					onLeft: () => handleExhausted(ctx, firstExit.cause),
+					onRight: (right) => Match.value(right).pipe(Match.tag("Continue", () => Effect.succeed(new StopEpoch())), Match.tag("Restart", (restartDecision) => handleRestart(ctx, firstExit.cause, Ref.set(cursor, restartDecision.indices[0]))), Match.exhaustive)
 				});
-				return yield* Match.value(decision).pipe(Match.tag("Continue", () => Effect.succeed(new StopEpoch())), Match.tag("Exhausted", () => handleExhausted(ctx, firstExit.cause)), Match.tag("Restart", (restartDecision) => handleRestart(ctx, firstExit.cause, Ref.set(cursor, restartDecision.indices[0]))), Match.exhaustive);
 			}
 			return new StopEpoch();
 		});
@@ -373,13 +536,12 @@ const runGroup = (strategy, ctx) => Effect.gen(function* () {
 	return yield* loop();
 });
 const superviseTree = (strategy, ctx) => Match.value(strategy).pipe(Match.when("one_for_one", () => runIndependent(ctx)), Match.when("one_for_all", () => runGroup("one_for_all", ctx)), Match.when("rest_for_one", () => runGroup("rest_for_one", ctx)), Match.exhaustive);
-//#endregion
-//#region src/internal/supervisor-runtime.ts
 const buildSupervisorBody = (sup, health, booted) => Effect.gen(function* () {
 	const policy = yield* sup.supervision;
-	const intensityEff = make(policy.intensity);
+	const tracker = make(policy.intensity).pipe(Effect.runSync);
+	const intensityEff = Effect.succeed(tracker);
 	const reportRestart = (cause) => Effect.gen(function* () {
-		const reporter = yield* DaemonReporter;
+		const reporter = yield* SupervisorBodyExecutorDeps;
 		yield* Metric.increment(Metric.tagged(supervisorRestartsCounter, "supervisor", sup.name));
 		yield* reporter.onRestart(sup.name, cause);
 		yield* Option.match(Option.fromNullable(sup.reporter.onRestart), {
@@ -388,7 +550,7 @@ const buildSupervisorBody = (sup, health, booted) => Effect.gen(function* () {
 		});
 	});
 	const reportExhausted = (cause) => Effect.gen(function* () {
-		const reporter = yield* DaemonReporter;
+		const reporter = yield* SupervisorBodyExecutorDeps;
 		yield* Metric.increment(Metric.tagged(supervisorExhaustionsCounter, "supervisor", sup.name));
 		yield* reporter.onExhausted(sup.name, cause);
 		yield* Option.match(Option.fromNullable(sup.reporter.onExhausted), {
@@ -407,143 +569,55 @@ const buildSupervisorBody = (sup, health, booted) => Effect.gen(function* () {
 	});
 	yield* Effect.andThen(health.paused.await, runStrategy);
 });
-//#endregion
-//#region src/internal/worker-loop.ts
-const applySpanAttributes = (hooks) => {
-	const { spanAttributes } = hooks;
-	return (effect) => {
-		if (typeof spanAttributes === "undefined") return effect;
-		return Effect.tap(effect, () => Effect.orElse(spanAttributes, () => Effect.succeed({})).pipe(Effect.flatMap(Effect.annotateCurrentSpan)));
-	};
-};
-const applyTrackDuration = (hooks) => {
-	const { trackDuration } = hooks;
-	return (effect) => {
-		if (typeof trackDuration === "undefined") return effect;
-		return Metric.trackDuration(effect, trackDuration);
-	};
-};
-const applyTimeout = (config) => {
-	return (effect) => Effect.timeoutFail(effect, {
-		duration: config.tickTimeout,
-		onTimeout: () => new Cause.TimeoutException()
-	});
-};
-const applyInnerRetry = (hooks) => {
-	const { innerRetry } = hooks;
-	return (effect) => {
-		if (typeof innerRetry === "undefined") return effect;
-		return Effect.retry(effect, innerRetry);
-	};
-};
-const buildPollTick = (worker, health, gate) => {
-	const { tick, tickHooks } = worker;
-	const spanName = tick.spanName ?? "daemon.tick";
-	const withSpanAttrs = applySpanAttributes(tickHooks);
-	const withDuration = applyTrackDuration(tickHooks);
-	const withTimeout = applyTimeout(tick);
-	const withInnerRetry = applyInnerRetry(tickHooks);
-	const runWork = (work) => work.pipe(withSpanAttrs, withDuration).pipe(Effect.withSpan(spanName, {
-		root: true,
-		attributes: { "daemon.name": worker.name }
-	}), Effect.withLogSpan(spanName));
-	return withInnerRetry(withTimeout(Effect.andThen(health.paused.await, gate).pipe(Effect.flatMap(Option.match({
-		onNone: () => Effect.void,
-		onSome: runWork
-	}))))).pipe(Effect.tap(() => Effect.zipRight(health.ready.open, Metric.set(Metric.tagged(Metric.tagged(healthStateGauge, "daemon", health.name), "latch", "ready"), 1))), Effect.asVoid);
-};
-const wrapSpan = (worker, effect) => {
-	const spanName = worker.tick.spanName ?? "daemon.worker";
-	return effect.pipe(Effect.withSpan(spanName, {
-		root: true,
-		attributes: { "daemon.name": worker.name }
-	}), Effect.withLogSpan(spanName));
-};
-const buildPollLoop = (worker, loop, health) => {
-	const tick = buildPollTick(worker, health, loop.gate);
-	return Effect.repeat(tick, Schedule.spaced(loop.interval)).pipe(Effect.asVoid);
-};
-const buildStreamLoop = (worker, loop, health) => {
-	const body = Effect.gen(function* () {
-		yield* health.paused.await;
-		const fiber = yield* Effect.forkScoped(loop.stream.pipe(Stream.tap(() => Effect.zipRight(health.ready.open, Metric.set(Metric.tagged(Metric.tagged(healthStateGauge, "daemon", health.name), "latch", "ready"), 1))), Stream.runDrain));
-		const ready = applyTimeout(worker.tick)(health.ready.await);
-		yield* Effect.raceFirst(ready, Fiber.join(fiber));
-		yield* Fiber.join(fiber);
-	});
-	const retried = applyInnerRetry(worker.tickHooks)(body);
-	return wrapSpan(worker, retried.pipe(Effect.asVoid));
-};
-const buildSubscriptionLoop = (worker, loop, health) => {
-	const body = Effect.gen(function* () {
-		yield* health.paused.await;
-		yield* applyTimeout(worker.tick)(loop.acquire);
-		yield* Effect.zipRight(health.ready.open, Metric.set(Metric.tagged(Metric.tagged(healthStateGauge, "daemon", health.name), "latch", "ready"), 1));
-		return yield* Effect.never;
-	});
-	return wrapSpan(worker, body.pipe(Effect.asVoid));
-};
-const buildWorkerLoop = (worker, health) => Match.value(worker.loop).pipe(Match.tag("Poll", (loop) => buildPollLoop(worker, loop, health)), Match.tag("Stream", (loop) => buildStreamLoop(worker, loop, health)), Match.tag("Subscription", (loop) => buildSubscriptionLoop(worker, loop, health)), Match.exhaustive);
-//#endregion
-//#region src/internal/boot.ts
-const allocateWorkerHealth = (name) => Effect.gen(function* () {
-	const ready = yield* Effect.makeLatch(false);
-	const healthy = yield* Effect.makeLatch(true);
-	const paused = yield* Effect.makeLatch(true);
-	yield* Metric.set(Metric.tagged(Metric.tagged(healthStateGauge, "daemon", name), "latch", "ready"), 0);
-	yield* Metric.set(Metric.tagged(Metric.tagged(healthStateGauge, "daemon", name), "latch", "healthy"), 1);
-	yield* Metric.set(Metric.tagged(Metric.tagged(healthStateGauge, "daemon", name), "latch", "paused"), 1);
-	return {
-		name,
-		ready,
-		healthy,
-		paused
-	};
-});
-const allocateSupervisorHealth = (name, children) => Effect.gen(function* () {
-	const ready = yield* Effect.makeLatch(false);
-	const healthy = yield* Effect.makeLatch(true);
-	const paused = yield* Effect.makeLatch(true);
-	yield* Metric.set(Metric.tagged(Metric.tagged(healthStateGauge, "daemon", name), "latch", "ready"), 0);
-	yield* Metric.set(Metric.tagged(Metric.tagged(healthStateGauge, "daemon", name), "latch", "healthy"), 1);
-	yield* Metric.set(Metric.tagged(Metric.tagged(healthStateGauge, "daemon", name), "latch", "paused"), 1);
-	return {
-		name,
-		ready,
-		healthy,
-		paused,
-		children
-	};
-});
-const bootChild = (child) => {
-	if (isWorker(child)) return allocateWorkerHealth(child.name).pipe(Effect.map((health) => ({
-		name: child.name,
-		health,
-		run: buildWorkerLoop(child, health).pipe(Effect.orDie),
-		childPolicy: child.child
-	})));
-	return Effect.gen(function* () {
-		const bootedChildren = yield* Effect.forEach(child.children, bootChild);
-		const health = yield* allocateSupervisorHealth(child.name, bootedChildren.map((b) => b.health));
-		const run = buildSupervisorBody(child, health, bootedChildren).pipe(Effect.orDie);
+const isWorker = (x) => WorkerTypeId in x;
+const bootChild = (child) => Effect.gen(function* () {
+	if (isWorker(child)) {
+		const health = yield* allocateWorkerHealth(child.name);
+		const loop = buildWorkerLoop(child, health, healthStateGauge).pipe(Effect.orDie);
 		return {
 			name: child.name,
 			health,
-			run,
-			childPolicy: {}
+			run: loop,
+			childPolicy: child.child
 		};
+	}
+	const bootedChildren = yield* Effect.forEach(child.children, bootChild);
+	const health = yield* allocateSupervisorHealth(child.name, bootedChildren.map((b) => b.health));
+	const body = buildSupervisorBody(child, health, bootedChildren).pipe(Effect.orDie);
+	return {
+		name: child.name,
+		health,
+		run: body,
+		childPolicy: {}
+	};
+});
+const supervisor = (s) => Effect.gen(function* () {
+	const booted = yield* Effect.forEach(s.children, bootChild);
+	const health = yield* allocateSupervisorHealth(s.name, booted.map((b) => b.health));
+	const body = buildSupervisorBody(s, health, booted).pipe(Effect.orDie);
+	let locked;
+	if (isModeNone(s.lock)) locked = body;
+	else if (s.lock.mode === "required") locked = withLeaderLock(body, {
+		key: s.lock.key,
+		mode: "required",
+		acquireRetryBackoff: s.lock.acquireRetryBackoff
 	});
-};
-//#endregion
-//#region src/internal/dynamic.ts
+	else locked = withLeaderLock(body, {
+		key: s.lock.key,
+		mode: "optional"
+	});
+	yield* Effect.forkScoped(locked.pipe(Effect.orDie));
+	return health;
+});
+Context.Tag("BuildDynamicExecutorDeps")();
 const buildDynamic = (spec, health) => Effect.gen(function* () {
 	const state = yield* Ref.make({
 		nextId: 0,
 		children: HashMap.empty()
 	});
 	const startChildImpl = (args) => Effect.gen(function* () {
-		const worker = spec.child(args);
-		const loop = buildWorkerLoop(worker, yield* allocateWorkerHealth(worker.name)).pipe(Effect.orDie);
+		const childWorker = spec.child(args);
+		const loop = buildWorkerLoop(childWorker, yield* allocateWorkerHealth(childWorker.name), healthStateGauge).pipe(Effect.orDie);
 		const removed = yield* Effect.makeLatch(false);
 		const reservedId = yield* Ref.modify(state, (current) => {
 			if (HashMap.size(current.children) >= spec.maxChildren) return [Option.none(), current];
@@ -620,69 +694,26 @@ const buildDynamic = (spec, health) => Effect.gen(function* () {
 		count: countImpl
 	};
 });
-//#endregion
-//#region src/internal/lock-gate.ts
-const decideLockGate = (lock) => {
-	if (lock.mode === "none") return Option.none();
-	return Option.some({
-		key: lock.key,
-		mode: lock.mode
-	});
-};
-//#endregion
-//#region src/run.ts
-const applyLock = (lock, effect) => {
-	const gate = decideLockGate(lock);
-	if (Option.isNone(gate)) return effect;
-	const locked = withLeaderLock(effect, gate.value);
-	if (lock.mode !== "required") return locked;
-	const retryWithRestart = (eff) => Effect.retry(eff, {
-		schedule: lock.acquireRetryBackoff,
-		while: Predicate.isTagged("LeaderLockNotAcquired")
-	}).pipe(Effect.catchTag("LeaderLockNotAcquired", () => retryWithRestart(eff)));
-	return retryWithRestart(locked);
-};
-const isModeNone = (lock) => lock.mode === "none";
-function worker(w) {
-	return Effect.gen(function* () {
-		const health = yield* allocateWorkerHealth(w.name);
-		const loop = buildWorkerLoop(w, health).pipe(Effect.orDie);
-		if (isModeNone(w.lock)) yield* Effect.forkScoped(loop);
-		else {
-			const locked = applyLock(w.lock, loop);
-			yield* Effect.forkScoped(locked.pipe(Effect.orDie));
-		}
-		return health;
-	});
-}
-function supervisor(s) {
-	return Effect.gen(function* () {
-		const booted = yield* Effect.forEach(s.children, bootChild);
-		const health = yield* allocateSupervisorHealth(s.name, booted.map((b) => b.health));
-		const body = buildSupervisorBody(s, health, booted).pipe(Effect.orDie);
-		if (isModeNone(s.lock)) yield* Effect.forkScoped(body);
-		else {
-			const locked = applyLock(s.lock, body);
-			yield* Effect.forkScoped(locked.pipe(Effect.orDie));
-		}
-		return health;
-	});
-}
-const dynamic$1 = (spec) => Effect.gen(function* () {
-	return yield* buildDynamic(spec, yield* allocateSupervisorHealth(spec.name, []));
+const dynamic$2 = (spec) => Effect.gen(function* () {
+	const health = yield* allocateSupervisorHealth(spec.name, []);
+	return yield* buildDynamic(spec, health);
 });
-const run = {
-	worker,
-	supervisor,
-	dynamic: dynamic$1
-};
 //#endregion
-//#region src/supervision-preset.ts
+//#region src/internal/supervision-leader.state.ts
 var LeaderConfig = class extends Context.Reference()("@systemfsoftware/effect-daemon-spec/LeaderConfig", { defaultValue: () => ({
 	backoffBase: Duration.seconds(1),
 	intensity: new UnboundedIntensity(),
 	cooldown: Duration.zero
 }) }) {};
+//#endregion
+//#region src/internal/supervision-task.state.ts
+var TaskConfig = class extends Context.Reference()("@systemfsoftware/effect-daemon-spec/TaskConfig", { defaultValue: () => ({
+	backoffBase: Duration.seconds(1),
+	intensity: new UnboundedIntensity(),
+	cooldown: Duration.zero
+}) }) {};
+//#endregion
+//#region src/internal/supervision-worker.state.ts
 var WorkerConfig = class extends Context.Reference()("@systemfsoftware/effect-daemon-spec/WorkerConfig", { defaultValue: () => ({
 	backoffBase: Duration.seconds(10),
 	intensity: new BoundedIntensity({
@@ -691,57 +722,108 @@ var WorkerConfig = class extends Context.Reference()("@systemfsoftware/effect-da
 	}),
 	cooldown: Duration.seconds(30)
 }) }) {};
-var TaskConfig = class extends Context.Reference()("@systemfsoftware/effect-daemon-spec/TaskConfig", { defaultValue: () => ({
-	backoffBase: Duration.seconds(1),
-	intensity: new UnboundedIntensity(),
-	cooldown: Duration.zero
-}) }) {};
-const Supervision = {
-	leader: (cap) => Effect.gen(function* () {
-		const config = yield* LeaderConfig;
-		return {
-			intensity: config.intensity,
-			backoff: cappedBackoff(config.backoffBase, cap),
-			cooldown: config.cooldown
-		};
-	}),
-	worker: (cap) => Effect.gen(function* () {
-		const config = yield* WorkerConfig;
-		return {
-			intensity: config.intensity,
-			backoff: cappedBackoff(config.backoffBase, cap),
-			cooldown: config.cooldown
-		};
-	}),
-	task: (budget) => Effect.gen(function* () {
-		const config = yield* TaskConfig;
-		return {
-			intensity: config.intensity,
-			backoff: Schedule.exponential(config.backoffBase).pipe(Schedule.jittered, Schedule.upTo(budget)),
-			cooldown: config.cooldown
-		};
-	}),
-	custom: (policy) => Effect.succeed(policy)
-};
 //#endregion
-//#region src/supervisor.ts
-const makeSupervisor = (opts, strategy) => ({
+//#region src/supervision-custom.kernel.ts
+const custom = (policy) => Effect.succeed(policy);
+//#endregion
+//#region src/supervision-leader.kernel.ts
+const leader$1 = (config, cap) => Effect.succeed({
+	intensity: config.intensity,
+	backoff: cappedBackoff(config.backoffBase, cap),
+	cooldown: config.cooldown
+});
+//#endregion
+//#region src/supervision-task.kernel.ts
+const task$1 = (config, budget) => Effect.succeed({
+	intensity: config.intensity,
+	backoff: Schedule.exponential(config.backoffBase).pipe(Schedule.jittered, Schedule.upTo(budget)),
+	cooldown: config.cooldown
+});
+//#endregion
+//#region src/supervision-worker.kernel.ts
+const worker$1 = (config, cap) => Effect.succeed({
+	intensity: config.intensity,
+	backoff: cappedBackoff(config.backoffBase, cap),
+	cooldown: config.cooldown
+});
+//#endregion
+//#region src/supervisor-dynamic.kernel.ts
+const dynamic$1 = (opts) => ({
+	[DynamicSpecTypeId]: DynamicSpecTypeId,
+	name: opts.name,
+	child: opts.child,
+	maxChildren: opts.maxChildren ?? 1e3
+});
+//#endregion
+//#region src/supervisor-one-for-all.kernel.ts
+const oneForAll$1 = (opts) => ({
 	[SupervisorTypeId]: SupervisorTypeId,
 	name: opts.name,
-	strategy,
+	strategy: "one_for_all",
 	children: opts.children,
 	supervision: opts.supervision,
 	lock: opts.lock,
 	reporter: opts.reporter ?? {}
 });
-const oneForOne = (opts) => makeSupervisor(opts, "one_for_one");
-const oneForAll = (opts) => makeSupervisor(opts, "one_for_all");
-const restForOne = (opts) => makeSupervisor(opts, "rest_for_one");
-const dynamic = (opts) => ({
-	[DynamicSpecTypeId]: DynamicSpecTypeId,
+//#endregion
+//#region src/supervisor-one-for-one.kernel.ts
+const oneForOne$1 = (opts) => ({
+	[SupervisorTypeId]: SupervisorTypeId,
 	name: opts.name,
-	child: opts.child,
-	maxChildren: opts.maxChildren ?? 1e3
+	strategy: "one_for_one",
+	children: opts.children,
+	supervision: opts.supervision,
+	lock: opts.lock,
+	reporter: opts.reporter ?? {}
+});
+//#endregion
+//#region src/supervisor-rest-for-one.kernel.ts
+const restForOne$1 = (opts) => ({
+	[SupervisorTypeId]: SupervisorTypeId,
+	name: opts.name,
+	strategy: "rest_for_one",
+	children: opts.children,
+	supervision: opts.supervision,
+	lock: opts.lock,
+	reporter: opts.reporter ?? {}
 });
 //#endregion
-export { BoundedIntensity, ChildPolicyConfig, Daemon, DaemonReporter, DynamicLimitExceeded, DynamicSpecTypeId, Intensity, IntensityConfig, IntensityTypeId, LeaderConfig, LeaderLock, LeaderLockFromPrimitive, LeaderLockInfraError, LeaderLockNotAcquired, LockPolicyConfig, LockPrimitive, LockPrimitiveError, Supervision, SupervisorTypeId, TaskConfig, TickPolicyConfig, UnboundedIntensity, WorkerConfig, WorkerTypeId, cappedBackoff, dynamic, healthStateGauge, isSupervisor, isWorker, oneForAll, oneForOne, poll, restForOne, run, stream, subscription, supervisor, supervisorChildrenGauge, supervisorExhaustionsCounter, supervisorRestartsCounter, withLeaderLock, worker };
+//#region src/mod.ts
+const poll = (opts) => poll$1(opts);
+const stream = (opts) => stream$1(opts);
+const subscription = (opts) => subscription$1(opts);
+const Daemon = {
+	poll,
+	stream,
+	subscription
+};
+const run = {
+	worker,
+	supervisor,
+	dynamic: dynamic$2
+};
+const leader = (cap) => Effect.flatMap(LeaderConfig, (config) => leader$1(config, cap));
+const task = (budget) => Effect.flatMap(TaskConfig, (config) => task$1(config, budget));
+const supervision = (cap) => Effect.flatMap(WorkerConfig, (config) => worker$1(config, cap));
+const Supervision = {
+	leader,
+	worker: supervision,
+	task,
+	custom
+};
+const dynamic = (opts) => dynamic$1(opts);
+const oneForAll = (opts) => oneForAll$1(opts);
+const oneForOne = (opts) => oneForOne$1(opts);
+const restForOne = (opts) => restForOne$1(opts);
+const WithLeaderLockExecutorLive = Layer.effect(WithLeaderLockExecutorDeps, Effect.gen(function* () {
+	return { withLock: (yield* LeaderLock).withLock };
+}));
+const SupervisorBodyExecutorLive = Layer.effect(SupervisorBodyExecutorDeps, Effect.gen(function* () {
+	const reporter = yield* DaemonReporter;
+	return {
+		onRestart: reporter.onRestart,
+		onExhausted: reporter.onExhausted
+	};
+}));
+//#endregion
+export { BoundedIntensity, ChildPolicyConfig, Daemon, DaemonReporter, DynamicLimitExceeded, DynamicSpecTypeId, Intensity, IntensityConfig, LeaderConfig, LeaderLock, LeaderLockFromPrimitive, LeaderLockInfraError, LeaderLockNotAcquired, LockPolicyConfig, LockPrimitive, LockPrimitiveError, Noop, Supervision, SupervisorBodyExecutorDeps, SupervisorBodyExecutorLive, SupervisorTypeId, TaskConfig, TickPolicyConfig, UnboundedIntensity, WithLeaderLockExecutorDeps, WithLeaderLockExecutorLive, WorkerConfig, WorkerTypeId, cappedBackoff, dynamic, healthStateGauge, leader, oneForAll, oneForOne, poll, restForOne, run, stream, subscription, supervision, supervisor, supervisorChildrenGauge, supervisorExhaustionsCounter, supervisorRestartsCounter, task, withLeaderLock, worker };