@systemfsoftware/effect-daemon-spec 0.7.2 → 2.0.0

package/dist/index.mjs

@@ -1,31 +1,43 @@
-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 { left, right } from "effect/Either";
+import { Array, Cause, Clock, Context, Duration, Effect, Equal, Exit, Fiber, HashMap, Latch, Layer, Match, Metric, Option, Predicate, Ref, Result, Schedule, Schema, Scope, Stream, pipe } from "effect";
+import { Cell, Workflow } from "@systemfsoftware/effect-cell-types";
+import * as Arr from "effect/Array";
 import * as Match$1 from "effect/Match";
+import * as Result$1 from "effect/Result";
 import * as S from "effect/Schema";
-//#region src/backoff.kernel.ts
+//#region src/Backoff.ts
 const cappedBackoff = (base, cap) => {
-	const ceiling = Duration.decode(cap);
-	return Schedule.exponential(base).pipe(Schedule.jittered, Schedule.modifyDelay((_, delay) => Duration.min(delay, ceiling)));
+	const ceiling = Duration.fromInputUnsafe(cap);
+	return Schedule.exponential(base).pipe(Schedule.jittered, Schedule.modifyDelay(({ duration }) => Effect.succeed(Duration.min(duration, ceiling))));
 };
 //#endregion
-//#region src/brands.kernel.ts
+//#region src/Brands.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)) }) {};
+//#region src/DaemonHealth.schema.ts
+var DynamicLimitExceeded = class extends Schema.TaggedError()("DynamicLimitExceeded", { limit: Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0))) }) {};
+Schema.decodeUnknownExit(DynamicLimitExceeded);
 //#endregion
-//#region src/daemon-metrics.kernel.ts
+//#region src/DaemonMetrics.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)" });
 const healthStateGauge = Metric.gauge("app.daemon.health.state", { description: "Daemon health latch open (1) or closed (0); tagged by daemon name and latch (ready | healthy | paused)" });
 //#endregion
-//#region src/daemon-policy.schema.ts
+//#region src/SupervisorDynamic.ts
+const MAX_CHILDREN_CEILING = 1e3;
+const dynamic$2 = (opts) => ({
+	[DynamicSpecTypeId]: DynamicSpecTypeId,
+	name: opts.name,
+	child: opts.child,
+	maxChildren: opts.maxChildren
+});
+//#endregion
+//#region src/DaemonPolicy.schema.ts
 const IntensityConfig = Schema.Struct({
-	restarts: Schema.Int.pipe(Schema.greaterThanOrEqualTo(0)),
-	window: Schema.DurationFromSelf
+	restarts: Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0))),
+	window: Schema.Duration
 });
 const IntensityTypeId = Symbol.for("@systemfsoftware/effect-daemon-spec/Intensity");
 var BoundedIntensity = class extends Schema.TaggedClass()("Bounded", IntensityConfig.fields) {
@@ -34,33 +46,54 @@ var BoundedIntensity = class extends Schema.TaggedClass()("Bounded", IntensityCo
 var UnboundedIntensity = class extends Schema.TaggedClass()("Unbounded", {}) {
 	[IntensityTypeId] = IntensityTypeId;
 };
-const Intensity = Schema.Union(BoundedIntensity, UnboundedIntensity);
+const Intensity = Schema.Union([BoundedIntensity, UnboundedIntensity]);
 var ChildPolicyConfig = class extends Schema.Class("ChildPolicyConfig")({
-	restart: Schema.optional(Schema.Literal("permanent", "transient", "temporary")),
+	restart: Schema.optional(Schema.Literals([
+		"permanent",
+		"transient",
+		"temporary"
+	])),
 	intensity: Schema.optional(IntensityConfig)
 }) {};
-Schema.Class("SupervisorPolicyConfig")({
+var SupervisorPolicyConfig = class extends Schema.Class("SupervisorPolicyConfig")({
 	intensity: Schema.optional(IntensityConfig),
-	cooldown: Schema.optional(Schema.DurationFromSelf)
-});
+	cooldown: Schema.optional(Schema.Duration)
+}) {};
 var LockPolicyConfig = class extends Schema.Class("LockPolicyConfig")({
-	mode: Schema.optional(Schema.Literal("none", "required", "optional")),
+	mode: Schema.optional(Schema.Literals([
+		"none",
+		"required",
+		"optional"
+	])),
 	key: Schema.optional(Schema.String)
 }) {};
 var TickPolicyConfig = class extends Schema.Class("TickPolicyConfig")({
 	spanName: Schema.optional(Schema.String),
-	tickTimeout: Schema.DurationFromSelf,
-	startLogLevel: Schema.optional(Schema.Literal("debug", "info"))
+	tickTimeout: Schema.Duration,
+	startLogLevel: Schema.optional(Schema.Literals(["debug", "info"]))
 }) {};
-//#endregion
-//#region src/daemon-reporter.adapter.ts
-var DaemonReporter = class extends Context.Tag("@systemfsoftware/effect-daemon-spec/daemon-reporter.adapter/DaemonReporter")() {};
+const MaxChildren = Schema.Int.pipe(Schema.check(Schema.isBetween({
+	minimum: 1,
+	maximum: MAX_CHILDREN_CEILING
+})), Schema.brand("MaxChildren"));
+Schema.Int.pipe(Schema.check(Schema.makeFilter((children) => children < 1 || children > 1e3)));
+Schema.Finite.pipe(Schema.check(Schema.isBetween({
+	minimum: 1,
+	maximum: MAX_CHILDREN_CEILING
+})), Schema.check(Schema.makeFilter((children) => !Number.isInteger(children))));
+Schema.decodeUnknownExit(ChildPolicyConfig);
+Schema.decodeUnknownExit(LockPolicyConfig);
+Schema.decodeUnknownExit(TickPolicyConfig);
+Schema.decodeUnknownExit(SupervisorPolicyConfig);
+//#endregion
+//#region src/DaemonReporterAdapter.ts
+var DaemonReporter = class extends Context.Service()("@systemfsoftware/effect-daemon-spec/DaemonReporterAdapter/DaemonReporter") {};
 const Noop = Layer.succeed(DaemonReporter, DaemonReporter.of({
 	onRestart: () => Effect.void,
 	onExhausted: () => Effect.void
 }));
 //#endregion
-//#region src/daemon-poll.kernel.ts
+//#region src/DaemonPoll.ts
 const poll$1 = (opts) => {
 	if (typeof opts.prereq === "undefined") {
 		const gate = Effect.succeed(Option.some(Effect.asVoid(opts.work)));
@@ -95,7 +128,7 @@ const poll$1 = (opts) => {
 	};
 };
 //#endregion
-//#region src/daemon-stream.kernel.ts
+//#region src/DaemonStream.ts
 const stream$1 = (opts) => ({
 	[WorkerTypeId]: WorkerTypeId,
 	name: opts.name,
@@ -109,7 +142,7 @@ const stream$1 = (opts) => ({
 	lock: opts.lock
 });
 //#endregion
-//#region src/daemon-subscription.kernel.ts
+//#region src/DaemonSubscription.ts
 const subscription$1 = (opts) => ({
 	[WorkerTypeId]: WorkerTypeId,
 	name: opts.name,
@@ -123,29 +156,32 @@ const subscription$1 = (opts) => ({
 	lock: opts.lock
 });
 //#endregion
-//#region src/leader-lock.schema.ts
+//#region src/LeaderLock.ts
+const isModeNone = (lock) => lock.mode === "none";
+//#endregion
+//#region src/LeaderLock.schema.ts
 var LeaderLockNotAcquired = class extends Schema.TaggedError()("LeaderLockNotAcquired", { key: Schema.String }) {};
 var LeaderLockInfraError = class extends Schema.TaggedError()("LeaderLockInfraError", {
 	key: Schema.String,
 	cause: Schema.Unknown
 }) {};
 //#endregion
-//#region src/lock-primitive.schema.ts
+//#region src/LockPrimitive.schema.ts
 var LockPrimitiveError = class extends Schema.TaggedError()("LockPrimitiveError", {
 	key: Schema.String,
 	cause: Schema.Unknown
 }) {};
 //#endregion
-//#region src/leader-lock.adapter.ts
-var LeaderLock = class LeaderLock extends Context.Tag("@systemfsoftware/effect-daemon-spec/leader-lock.adapter/LeaderLock")() {
+//#region src/LeaderLockAdapter.ts
+var LeaderLock = class LeaderLock extends Context.Service()("@systemfsoftware/effect-daemon-spec/LeaderLockAdapter/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")() {};
+var LockPrimitive = class extends Context.Service()("@systemfsoftware/effect-daemon-spec/LeaderLockAdapter/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* () {
 		const scope = yield* Scope.make();
-		if (!(yield* restore(primitive.tryAcquire(key)).pipe(Scope.extend(scope), Effect.mapError((cause) => new LeaderLockInfraError({
+		if (!(yield* restore(primitive.tryAcquire(key)).pipe(Scope.provide(scope), Effect.mapError((cause) => LeaderLockInfraError.make({
 			key,
 			cause
 		})), Effect.onError(() => Scope.close(scope, Exit.void))))) {
@@ -157,14 +193,23 @@ const LeaderLockFromPrimitive = Layer.effect(LeaderLock, Effect.gen(function* ()
 	})) });
 }));
 //#endregion
-//#region src/internal/allocate-worker-health.kernel.ts
+//#region src/internal/AllocateWorkerHealth.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);
+	const ready = yield* Latch.make(false);
+	const healthy = yield* Latch.make(true);
+	const paused = yield* Latch.make(true);
+	yield* Metric.update(Metric.withAttributes(healthStateGauge, {
+		daemon: name,
+		latch: "ready"
+	}), 0);
+	yield* Metric.update(Metric.withAttributes(healthStateGauge, {
+		daemon: name,
+		latch: "healthy"
+	}), 1);
+	yield* Metric.update(Metric.withAttributes(healthStateGauge, {
+		daemon: name,
+		latch: "paused"
+	}), 1);
 	return {
 		name,
 		ready,
@@ -173,25 +218,22 @@ const allocateWorkerHealth = (name) => Effect.gen(function* () {
 	};
 });
 //#endregion
-//#region src/internal/build-worker-loop.kernel.ts
+//#region src/internal/BuildWorkerLoop.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)));
+		return Effect.tap(effect, () => Effect.orElseSucceed(spanAttributes, () => ({})).pipe(Effect.flatMap(Effect.annotateCurrentSpan)));
 	};
 };
 const applyTrackDuration = (hooks) => {
 	const { trackDuration } = hooks;
 	return (effect) => {
 		if (typeof trackDuration === "undefined") return effect;
-		return Metric.trackDuration(effect, trackDuration);
+		return Effect.trackDuration(effect, trackDuration);
 	};
 };
-const applyTimeout = (timeout) => (effect) => Effect.timeoutFail(effect, {
-	duration: timeout,
-	onTimeout: () => new Cause.TimeoutException()
-});
+const applyTimeout = (timeout) => (effect) => effect.pipe(Effect.timeout(timeout), Effect.catchTag("TimeoutError", () => Effect.fail(new Cause.TimeoutError())));
 const applyInnerRetry = (hooks) => {
 	const { innerRetry } = hooks;
 	return (effect) => {
@@ -199,7 +241,10 @@ const applyInnerRetry = (hooks) => {
 		return Effect.retry(effect, innerRetry);
 	};
 };
-const openReadyGauge = (gauge, name) => Metric.set(Metric.tagged(Metric.tagged(gauge, "daemon", name), "latch", "ready"), 1);
+const openReadyGauge = (gauge, name) => Metric.update(Metric.withAttributes(gauge, {
+	daemon: name,
+	latch: "ready"
+}), 1);
 const buildPollTick = (worker, health, gate, readyGauge) => {
 	const spanName = worker.tick.spanName ?? "daemon.tick";
 	const withSpanAttrs = applySpanAttributes(worker.tickHooks);
@@ -213,7 +258,7 @@ const buildPollTick = (worker, health, gate, readyGauge) => {
 	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);
+	}))))).pipe(Effect.tap(() => Effect.andThen(health.ready.open, openReadyGauge(readyGauge, worker.name))), Effect.asVoid);
 };
 const wrapSpan = (worker, effect, spanName) => {
 	const finalSpan = spanName ?? "daemon.worker";
@@ -230,10 +275,10 @@ const propagateExit = (exit) => Match.value(exit).pipe(Match.tag("Failure", ({ c
 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 fiber = yield* Effect.forkScoped(loop.stream.pipe(Stream.tap(() => Effect.andThen(health.ready.open, openReadyGauge(readyGauge, worker.name))), Stream.runDrain), { startImmediately: true });
 		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));
+		yield* Effect.raceFirst(ready, Fiber.await(fiber).pipe(Effect.flatMap(propagateExit)));
+		yield* Fiber.await(fiber).pipe(Effect.flatMap(propagateExit));
 	});
 	const retried = applyInnerRetry(worker.tickHooks)(body);
 	return wrapSpan(worker, retried.pipe(Effect.asVoid));
@@ -242,20 +287,19 @@ 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));
+		yield* Effect.andThen(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("@systemfsoftware/effect-daemon-spec/internal/with-leader-lock.executor/WithLeaderLockExecutorDeps")() {};
-function withLeaderLock(self, options) {
+//#region src/internal/WithLeaderLockExecutor.ts
+function withLeaderLock(self, options, lock) {
 	const acquire = Effect.gen(function* () {
-		const out = yield* (yield* WithLeaderLockExecutorDeps).withLock(options.key, self);
+		const out = yield* lock.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);
+		return yield* Match.value(options.mode).pipe(Match.when("required", () => Effect.fail(LeaderLockNotAcquired.make({ key: options.key }))), Match.when("optional", () => Effect.void), Match.exhaustive);
 	});
 	const retryOnce = (current) => Effect.retry(acquire, {
 		schedule: current,
@@ -266,37 +310,59 @@ function withLeaderLock(self, options) {
 	return acquire;
 }
 //#endregion
-//#region src/leader-lock.kernel.ts
-const isModeNone = (lock) => lock.mode === "none";
-Context.Tag("@systemfsoftware/effect-daemon-spec/daemon-worker.executor/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,
+//#region src/internal/WithLockByModeExecutor.ts
+/**
+* Runs `self` under whichever lock discipline the binding asks for.
+*
+* An absent lock adapter and a `mode: 'none'` spec are one case, not two: a spec that
+* declines the lock and a composition root that supplies no adapter both leave the
+* body unwrapped, and nothing downstream can tell them apart from the effect that
+* comes back. `unlocked` is that single case; `locked` dispatches on the spec's mode
+* to the existing `withLeaderLock` calls. There is no null arm because the null state
+* is now a constructor choice, not a runtime case.
+*
+* The worker and the supervisor make the same choice over the same cases, so it is
+* made here once rather than in each of them.
+*/
+const withLockByMode = (self, binding) => {
+	if (binding.kind === "unlocked") return self;
+	if (binding.spec.mode === "required") return withLeaderLock(self, {
+		key: binding.spec.key,
 		mode: "required",
-		acquireRetryBackoff: w.lock.acquireRetryBackoff
-	});
-	else locked = withLeaderLock(loop, {
-		key: w.lock.key,
+		acquireRetryBackoff: binding.spec.acquireRetryBackoff
+	}, binding.lock);
+	return withLeaderLock(self, {
+		key: binding.spec.key,
 		mode: "optional"
-	});
+	}, binding.lock);
+};
+//#endregion
+//#region src/DaemonWorkerExecutor.ts
+const worker$2 = (w, binding) => Effect.gen(function* () {
+	const health = yield* allocateWorkerHealth(w.name);
+	const loop = buildWorkerLoop(w, health, healthStateGauge).pipe(Effect.orDie);
+	const locked = withLockByMode(loop, binding);
 	yield* Effect.forkScoped(locked.pipe(Effect.orDie));
 	return health;
 });
 //#endregion
-//#region src/internal/allocate-supervisor-health.kernel.ts
+//#region src/internal/AllocateSupervisorHealth.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);
+	const ready = yield* Latch.make(false);
+	const healthy = yield* Latch.make(true);
+	const paused = yield* Latch.make(true);
+	yield* Metric.update(Metric.withAttributes(healthStateGauge, {
+		daemon: name,
+		latch: "ready"
+	}), 0);
+	yield* Metric.update(Metric.withAttributes(healthStateGauge, {
+		daemon: name,
+		latch: "healthy"
+	}), 1);
+	yield* Metric.update(Metric.withAttributes(healthStateGauge, {
+		daemon: name,
+		latch: "paused"
+	}), 1);
 	return {
 		name,
 		ready,
@@ -306,20 +372,114 @@ const allocateSupervisorHealth = (name, children) => Effect.gen(function* () {
 	};
 });
 //#endregion
-//#region src/internal/intensity-window.kernel.ts
+//#region src/internal/BuildDynamicExecutor.ts
+const buildDynamic = (spec, health) => Effect.gen(function* () {
+	const state = yield* Ref.make({
+		nextId: 0,
+		children: HashMap.empty()
+	});
+	const startChildImpl = (args) => Effect.gen(function* () {
+		const childWorker = spec.child(args);
+		const workerHealth = yield* allocateWorkerHealth(childWorker.name);
+		const loop = buildWorkerLoop(childWorker, workerHealth, healthStateGauge).pipe(Effect.orDie);
+		const removed = yield* Latch.make(false);
+		const reservedId = yield* Ref.modify(state, (current) => {
+			if (HashMap.size(current.children) >= spec.maxChildren) return [Option.none(), current];
+			const children = HashMap.set(current.children, current.nextId, Equal.byReferenceUnsafe({
+				fiber: Option.none(),
+				removed
+			}));
+			return [Option.some(current.nextId), {
+				nextId: current.nextId + 1,
+				children
+			}];
+		});
+		if (Option.isNone(reservedId)) return yield* DynamicLimitExceeded.make({ limit: spec.maxChildren });
+		const id = reservedId.value;
+		yield* Metric.update(supervisorChildrenGauge, HashMap.size(yield* Ref.get(state).pipe(Effect.map((s) => s.children))));
+		const cleanup = Effect.gen(function* () {
+			const count = yield* Ref.modify(state, (current) => {
+				const children = HashMap.remove(current.children, id);
+				return [HashMap.size(children), {
+					...current,
+					children
+				}];
+			});
+			yield* Metric.update(supervisorChildrenGauge, count);
+			yield* removed.open;
+		}).pipe(Effect.asVoid);
+		const fiber = yield* Effect.forkScoped(loop.pipe(Effect.ensuring(cleanup)));
+		const count = yield* Ref.modify(state, (current) => {
+			const childOpt = HashMap.get(current.children, id);
+			if (Option.isNone(childOpt)) return [HashMap.size(current.children), current];
+			const children = HashMap.set(current.children, id, Equal.byReferenceUnsafe({
+				...childOpt.value,
+				fiber: Option.some(fiber)
+			}));
+			return [HashMap.size(children), {
+				nextId: current.nextId,
+				children
+			}];
+		});
+		yield* Metric.update(supervisorChildrenGauge, count);
+		return {
+			id,
+			removed: removed.await
+		};
+	});
+	const stopChildImpl = (ref) => Effect.gen(function* () {
+		const [stateOpt, count] = yield* Ref.modify(state, (current) => {
+			const found = HashMap.get(current.children, ref.id);
+			const children = HashMap.remove(current.children, ref.id);
+			return [[found, HashMap.size(children)], {
+				...current,
+				children
+			}];
+		});
+		if (Option.isSome(stateOpt)) {
+			const { fiber, removed } = stateOpt.value;
+			yield* Option.match(fiber, {
+				onNone: () => Effect.void,
+				onSome: (running) => Effect.gen(function* () {
+					yield* Fiber.interrupt(running);
+					yield* Fiber.await(running);
+				})
+			});
+			yield* Metric.update(supervisorChildrenGauge, count);
+			yield* removed.open;
+		}
+	});
+	const countImpl = Ref.get(state).pipe(Effect.map((current) => HashMap.size(current.children)));
+	yield* Effect.andThen(health.ready.open, Metric.update(Metric.withAttributes(healthStateGauge, {
+		daemon: spec.name,
+		latch: "ready"
+	}), 1));
+	return {
+		health,
+		startChild: startChildImpl,
+		stopChild: stopChildImpl,
+		count: countImpl
+	};
+});
+const dynamic$1 = (spec) => Effect.gen(function* () {
+	const health = yield* allocateSupervisorHealth(spec.name, []);
+	return yield* buildDynamic(spec, health);
+});
+//#endregion
+//#region src/internal/IntensityWindow.ts
 const isWithinWindow = (now, windowMillis) => (t) => now - t <= 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.kernel.ts
+//#region src/internal/Intensity.ts
 const neverExceeds = {
 	record: Effect.void,
 	isExceeded: Effect.succeed(false),
 	count: Effect.succeed(0)
 };
-const boundedTracker = (restarts, window) => Effect.gen(function* () {
+const make = (restarts, window) => Effect.gen(function* () {
 	const windowMillis = Duration.toMillis(window);
 	const timestamps = yield* Ref.make([]);
 	const prune = (now) => Ref.modify(timestamps, (ts) => {
@@ -333,7 +493,8 @@ const boundedTracker = (restarts, window) => Effect.gen(function* () {
 		}),
 		isExceeded: Effect.gen(function* () {
 			const now = yield* Clock.currentTimeMillis;
-			return exceedsRestarts((yield* prune(now)).length, restarts);
+			const active = yield* prune(now);
+			return exceedsRestarts(active.length, restarts);
 		}),
 		count: Effect.gen(function* () {
 			const now = yield* Clock.currentTimeMillis;
@@ -341,34 +502,27 @@ 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 RestartStrategy = Schema.Literal("one_for_one", "one_for_all", "rest_for_one");
-Schema.Struct({
-	strategy: RestartStrategy,
-	totalChildren: Schema.Int.pipe(Schema.between(1, 10)),
-	failedIndex: Schema.Int.pipe(Schema.greaterThanOrEqualTo(0)),
-	exitSuccess: Schema.Boolean,
-	intensityExceeded: Schema.Boolean
-}).pipe(Schema.filter((s) => s.failedIndex < s.totalChildren, { message: () => "failedIndex must be < totalChildren" }), Schema.annotations({ arbitrary: () => (fc) => fc.integer({
-	min: 1,
-	max: 10
-}).chain((totalChildren) => fc.integer({
-	min: 0,
-	max: totalChildren - 1
-}).chain((failedIndex) => fc.record({
-	strategy: fc.constantFrom("one_for_one", "one_for_all", "rest_for_one"),
-	totalChildren: fc.constant(totalChildren),
-	failedIndex: fc.constant(failedIndex),
-	exitSuccess: fc.boolean(),
-	intensityExceeded: fc.boolean()
-}))) }));
-//#endregion
-//#region src/internal/restart-decision.workflow.ts
+//#region src/internal/RaceForExit.ts
+const raceForExit = (fibers) => Effect.raceAll(fibers.map((f, idx) => Fiber.await(f).pipe(Effect.map((exit) => [idx, exit]))));
+//#endregion
+//#region src/internal/RestartDecision.workflow.ts
+/**
+* The child indices a restart covers, by supervision strategy.
+*
+* A pure total function: the one part of the restart decision that is computation rather
+* than dispatch, so it lives in the decision cell beside the `Workflow.make` it serves.
+*/
+const restartIndicesFor = (strategy, failedIndex, total) => Match$1.value(strategy).pipe(Match$1.when("one_for_one", () => [failedIndex]), Match$1.when("one_for_all", () => Arr.range(0, total - 1)), Match$1.when("rest_for_one", () => Arr.range(failedIndex, total - 1)), Match$1.exhaustive);
+/**
+* The cross-field invariant the decode input carries: a failed child's index addresses one of
+* the children that exist.
+*
+* It lives here rather than inline in `Schema.filter` because naming it makes it reachable by
+* a property test, which an inline arrow is not. The schema imports the name to build its
+* filter; the decision file is where the invariant is owned.
+*/
+const failedIndexAddressesAChild = (input) => input.failedIndex < input.totalChildren;
 const RestartDecisionTypeId = Symbol.for("@systemfsoftware/effect-daemon/RestartDecision");
 var RestartDecisionContinue = class extends S.TaggedClass()("Continue", {}) {
 	[RestartDecisionTypeId] = RestartDecisionTypeId;
@@ -379,13 +533,32 @@ var RestartDecisionRestart = class extends S.TaggedClass()("Restart", { indices:
 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({
+const decideRestart = Workflow.make((command) => Match$1.value(command).pipe(Match$1.when({ exitSuccess: true }, () => Result$1.succeed(RestartDecisionContinue.make())), Match$1.when({
 	exitSuccess: false,
 	intensityExceeded: true
-}, () => left(new RestartDecisionExhausted())), Match$1.orElse(() => right(new RestartDecisionRestart({ indices: restartIndicesFor(input.strategy, input.failedIndex, input.totalChildren) }))));
+}, () => Result$1.fail(RestartDecisionExhausted.make())), Match$1.orElse(() => Result$1.succeed(RestartDecisionRestart.make({ indices: restartIndicesFor(command.strategy, command.failedIndex, command.totalChildren) })))));
+//#endregion
+//#region src/internal/RestartDecision.schema.ts
+const RestartStrategy = Schema.Literals([
+	"one_for_one",
+	"one_for_all",
+	"rest_for_one"
+]);
+Schema.Struct({
+	strategy: RestartStrategy,
+	totalChildren: Schema.Int.pipe(Schema.check(Schema.isBetween({
+		minimum: 1,
+		maximum: MAX_CHILDREN_CEILING
+	}))),
+	failedIndex: Schema.Int.pipe(Schema.check(Schema.isBetween({
+		minimum: 0,
+		maximum: MAX_CHILDREN_CEILING
+	}))),
+	exitSuccess: Schema.Boolean,
+	intensityExceeded: Schema.Boolean
+}).pipe(Schema.check(Schema.makeFilter(failedIndexAddressesAChild, { message: "failedIndex must be < totalChildren" })));
 //#endregion
-//#region src/internal/supervision-epoch.schema.ts
+//#region src/internal/SupervisionEpoch.schema.ts
 const EpochStepTypeId = Symbol.for("@systemfsoftware/effect-daemon/EpochStep");
 var StopEpoch = class extends Schema.TaggedClass()("StopEpoch", {}) {
 	[EpochStepTypeId] = EpochStepTypeId;
@@ -396,7 +569,11 @@ var RestartEpoch = class extends Schema.TaggedClass()("RestartEpoch", {}) {
 var CooldownEpoch = class extends Schema.TaggedClass()("CooldownEpoch", {}) {
 	[EpochStepTypeId] = EpochStepTypeId;
 };
-Schema.Union(StopEpoch, RestartEpoch, CooldownEpoch);
+Schema.Union([
+	StopEpoch,
+	RestartEpoch,
+	CooldownEpoch
+]);
 const SupervisionEpochResultTypeId = Symbol.for("@systemfsoftware/effect-daemon/SupervisionEpochResult");
 var StopSupervision = class extends Schema.TaggedClass()("StopSupervision", {}) {
 	[SupervisionEpochResultTypeId] = SupervisionEpochResultTypeId;
@@ -404,76 +581,115 @@ var StopSupervision = class extends Schema.TaggedClass()("StopSupervision", {})
 var ContinueSupervision = class extends Schema.TaggedClass()("ContinueSupervision", {}) {
 	[SupervisionEpochResultTypeId] = SupervisionEpochResultTypeId;
 };
-Schema.Union(StopSupervision, ContinueSupervision);
+Schema.Union([StopSupervision, ContinueSupervision]);
 //#endregion
-//#region src/internal/supervisor-body.executor.ts
-var SupervisorBodyExecutorDeps = class extends Context.Tag("@systemfsoftware/effect-daemon-spec/internal/supervisor-body.executor/SupervisorBodyExecutorDeps")() {};
+//#region src/internal/SupervisorBodyExecutor.ts
 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* Effect.andThen(ctx.health.healthy.close, Metric.update(Metric.withAttributes(healthStateGauge, {
+		daemon: ctx.name,
+		latch: "healthy"
+	}), 0));
 	yield* ctx.reportExhausted(cause);
-	return new CooldownEpoch();
+	return CooldownEpoch.make();
 });
 const handleRestart = (ctx, cause, onSignal) => Effect.gen(function* () {
 	yield* ctx.reportRestart(cause);
 	yield* onSignal;
-	return new RestartEpoch();
+	return RestartEpoch.make();
 });
-const reopenHealthyAfterCooldown = (ctx) => Effect.zipRight(ctx.health.healthy.open, Metric.set(Metric.tagged(Metric.tagged(healthStateGauge, "daemon", ctx.name), "latch", "healthy"), 1));
+/**
+* The restart decision, as a description whose phases chain by type and read in the order
+* they run.
+*
+* The read is a bump-and-report: recording a restart is how the current rate is obtained, so
+* the mutation is a product gathered across the read's interior rather than a write standing
+* before a decision. That is what keeps this one layer instead of two, and it is why
+* `intensity.record` sits where it does.
+*
+* `encode` is the identity because nothing needs shaping — the decision is already what the
+* write consumes — and the write only dispatches over the tags the decision produced.
+*
+* A description is built per failure because the write needs that failure's context, and the
+* phase signatures hand the command to the read alone. Restarts are rare, so the allocation is
+* paid only when a supervised child has actually died.
+*/
+const restartDescription = (spec) => pipe(Cell.read((intensity) => Effect.andThen(intensity.record, intensity.isExceeded)), Cell.decode((intensityExceeded) => Result.succeed({
+	strategy: spec.strategy,
+	totalChildren: spec.totalChildren,
+	failedIndex: spec.failedIndex,
+	exitSuccess: false,
+	intensityExceeded
+})), Cell.decide(decideRestart), Cell.encode((outcome) => outcome), Cell.write((outcome) => Result.match(outcome, {
+	onFailure: () => handleExhausted(spec.ctx, spec.cause),
+	onSuccess: (right) => Match.value(right).pipe(Match.tag("Continue", () => Effect.succeed(StopEpoch.make())), Match.tag("Restart", (decision) => handleRestart(spec.ctx, spec.cause, spec.onRestart(decision))), Match.exhaustive)
+})));
+const reopenHealthyAfterCooldown = (ctx) => Effect.andThen(ctx.health.healthy.open, Metric.update(Metric.withAttributes(healthStateGauge, {
+	daemon: ctx.name,
+	latch: "healthy"
+}), 1));
 const runSupervisionEpochWithBackoff = (attempt, ctx) => Effect.gen(function* () {
-	const driver = yield* Schedule.driver(ctx.policy.backoff);
+	const advance = yield* Schedule.toStep(ctx.policy.backoff);
 	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* () {
+		const epochStep = yield* attempt.pipe(Effect.scoped);
+		return yield* Match.value(epochStep).pipe(Match.tag("StopEpoch", () => Effect.succeed(StopSupervision.make())), Match.tag("CooldownEpoch", () => Effect.gen(function* () {
 			yield* Effect.sleep(ctx.policy.cooldown);
 			yield* reopenHealthyAfterCooldown(ctx);
-			return new ContinueSupervision();
+			return ContinueSupervision.make();
 		})), Match.tag("RestartEpoch", () => Effect.gen(function* () {
-			const stepped = yield* Effect.either(driver.next(void 0));
-			if (Either.isLeft(stepped)) return new StopSupervision();
+			const now = yield* Clock.currentTimeMillis;
+			const pulled = yield* Effect.result(advance(now, void 0));
+			if (Result.isFailure(pulled)) return StopSupervision.make();
+			const [, delay] = pulled.success;
+			yield* Effect.sleep(delay);
 			return yield* loop();
 		})), Match.exhaustive);
 	});
 	return yield* loop();
 });
 const openAllReady = (ctx) => Effect.gen(function* () {
-	yield* Effect.yieldNow();
+	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));
+	yield* Effect.andThen(ctx.health.ready.open, Metric.update(Metric.withAttributes(healthStateGauge, {
+		daemon: ctx.name,
+		latch: "ready"
+	}), 1));
+});
+/**
+* Records one restart against the child's intensity tracker and reports whether the
+* child's restart budget is now exceeded. A child without a bounded intensity policy
+* never hits the budget.
+*/
+const isChildIntensityBudgetDone = (tracker) => Option.match(tracker, {
+	onNone: () => Effect.succeed(false),
+	onSome: (ci) => Effect.gen(function* () {
+		yield* ci.record;
+		return yield* ci.isExceeded;
+	})
 });
 const superviseChild = (ctx, child, idx) => Effect.gen(function* () {
-	const childIntensityOpt = yield* Option.match(Option.fromNullable(child.childPolicy.intensity), {
+	const childIntensityOpt = yield* Option.match(Option.fromNullishOr(child.childPolicy.intensity), {
 		onNone: () => Effect.succeed(Option.none()),
-		onSome: (cfg) => Effect.map(make(new BoundedIntensity(cfg)), Option.some)
+		onSome: (cfg) => Effect.map(make(cfg.restarts, cfg.window), Option.some)
 	});
 	const loop = () => Effect.gen(function* () {
 		const supIntensity = yield* ctx.intensityEff;
 		const attempt = Effect.gen(function* () {
 			yield* ctx.health.paused.await;
-			const fiber = yield* Effect.forkScoped(child.run);
+			const fiber = yield* Effect.forkScoped(child.run, { startImmediately: true });
 			const exit = yield* Fiber.await(fiber);
 			if (!Exit.isSuccess(exit)) {
-				if (child.childPolicy.restart === "temporary") return new StopEpoch();
-				if (yield* Option.match(childIntensityOpt, {
-					onNone: () => Effect.succeed(false),
-					onSome: (ci) => Effect.gen(function* () {
-						yield* ci.record;
-						return yield* ci.isExceeded;
-					})
-				})) return new StopEpoch();
-				yield* supIntensity.record;
-				const decision = decideRestart({
+				if (child.childPolicy.restart === "temporary") return StopEpoch.make();
+				if (yield* isChildIntensityBudgetDone(childIntensityOpt)) return StopEpoch.make();
+				return yield* Cell.apply(restartDescription({
 					strategy: "one_for_one",
-					exitSuccess: false,
-					intensityExceeded: yield* supIntensity.isExceeded,
 					failedIndex: idx,
-					totalChildren: ctx.booted.length
-				});
-				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)
-				});
+					totalChildren: ctx.booted.length,
+					ctx,
+					cause: exit.cause,
+					onRestart: () => Effect.void
+				}), supIntensity);
 			}
-			return new StopEpoch();
+			return StopEpoch.make();
 		});
 		const epochResult = yield* runSupervisionEpochWithBackoff(attempt, ctx);
 		return yield* Match.value(epochResult).pipe(Match.tag("ContinueSupervision", () => loop()), Match.tag("StopSupervision", () => Effect.void), Match.exhaustive);
@@ -481,54 +697,44 @@ const superviseChild = (ctx, child, idx) => Effect.gen(function* () {
 	return yield* loop();
 });
 const runIndependent = (ctx) => Effect.gen(function* () {
-	const fibers = yield* Effect.forEach(ctx.booted, (child, childIdx) => Effect.forkScoped(superviseChild(ctx, child, childIdx)));
-	yield* Effect.yieldNow();
+	const fibers = yield* Effect.forEach(ctx.booted, (child, childIdx) => Effect.forkScoped(superviseChild(ctx, child, childIdx), { startImmediately: true }));
+	yield* Effect.yieldNow;
 	yield* openAllReady(ctx);
 	yield* Effect.forEach(fibers, (f) => Fiber.await(f), { concurrency: "unbounded" });
 });
 const runGroup = (strategy, ctx) => Effect.gen(function* () {
 	const loop = () => Effect.gen(function* () {
 		const intensity = yield* ctx.intensityEff;
-		const childIntensityTrackers = yield* Effect.forEach(ctx.booted, (b) => Option.match(Option.fromNullable(b.childPolicy.intensity), {
+		const childIntensityTrackers = yield* Effect.forEach(ctx.booted, (b) => Option.match(Option.fromNullishOr(b.childPolicy.intensity), {
 			onNone: () => Effect.succeed(Option.none()),
-			onSome: (cfg) => Effect.map(make(new BoundedIntensity(cfg)), Option.some)
+			onSome: (cfg) => Effect.map(make(cfg.restarts, cfg.window), Option.some)
 		}));
 		const cursor = yield* Ref.make(0);
 		const attempt = Effect.gen(function* () {
 			yield* ctx.health.paused.await;
 			const startIdx = yield* Ref.get(cursor);
 			const slice = ctx.booted.slice(startIdx);
-			const fibers = yield* Effect.forEach(slice, (c) => Effect.forkScoped(c.run));
-			yield* Effect.yieldNow();
-			yield* Effect.forkScoped(openAllReady(ctx));
+			const fibers = yield* Effect.forEach(slice, (c) => Effect.forkScoped(c.run, { startImmediately: true }));
+			yield* Effect.yieldNow;
+			yield* Effect.forkScoped(openAllReady(ctx), { startImmediately: true });
 			const [failedOffset, firstExit] = yield* raceForExit(fibers);
 			if (!Exit.isSuccess(firstExit)) {
 				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();
-				const cIntForFailed = Option.flatten(Array$1.get(childIntensityTrackers, failedIdx));
-				if (yield* Option.match(cIntForFailed, {
-					onNone: () => Effect.succeed(false),
-					onSome: (cInt) => Effect.gen(function* () {
-						yield* cInt.record;
-						return yield* cInt.isExceeded;
-					})
-				})) return new StopEpoch();
-				yield* intensity.record;
-				const decision = decideRestart({
+				const failedBootedOpt = Option.fromNullishOr(ctx.booted[failedIdx]);
+				if (Option.isNone(failedBootedOpt)) return StopEpoch.make();
+				if (failedBootedOpt.value.childPolicy.restart === "temporary") return StopEpoch.make();
+				const cIntForFailed = Option.flatten(Array.get(childIntensityTrackers, failedIdx));
+				if (yield* isChildIntensityBudgetDone(cIntForFailed)) return StopEpoch.make();
+				return yield* Cell.apply(restartDescription({
 					strategy,
-					exitSuccess: false,
-					intensityExceeded: yield* intensity.isExceeded,
+					failedIndex: failedIdx,
 					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)
-				});
+					ctx,
+					cause: firstExit.cause,
+					onRestart: (decision) => Ref.set(cursor, decision.indices[0])
+				}), intensity);
 			}
-			return new StopEpoch();
+			return StopEpoch.make();
 		});
 		const epochResult = yield* runSupervisionEpochWithBackoff(attempt, ctx);
 		return yield* Match.value(epochResult).pipe(Match.tag("ContinueSupervision", () => loop()), Match.tag("StopSupervision", () => Effect.void), Match.exhaustive);
@@ -536,24 +742,23 @@ 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);
-const buildSupervisorBody = (sup, health, booted) => Effect.gen(function* () {
+const intensityTracker = (intensity) => Match.value(intensity).pipe(Match.tag("Unbounded", () => Effect.succeed(neverExceeds)), Match.tag("Bounded", ({ restarts, window }) => make(restarts, window)), Match.exhaustive);
+const buildSupervisorBody = (sup, health, booted, reporter) => Effect.gen(function* () {
 	const policy = yield* sup.supervision;
-	const tracker = make(policy.intensity).pipe(Effect.runSync);
+	const tracker = yield* intensityTracker(policy.intensity);
 	const intensityEff = Effect.succeed(tracker);
 	const reportRestart = (cause) => Effect.gen(function* () {
-		const reporter = yield* SupervisorBodyExecutorDeps;
-		yield* Metric.increment(Metric.tagged(supervisorRestartsCounter, "supervisor", sup.name));
+		yield* Metric.update(Metric.withAttributes(supervisorRestartsCounter, { supervisor: sup.name }), 1);
 		yield* reporter.onRestart(sup.name, cause);
-		yield* Option.match(Option.fromNullable(sup.reporter.onRestart), {
+		yield* Option.match(Option.fromNullishOr(sup.reporter.onRestart), {
 			onNone: () => Effect.void,
 			onSome: (fn) => fn(cause)
 		});
 	});
 	const reportExhausted = (cause) => Effect.gen(function* () {
-		const reporter = yield* SupervisorBodyExecutorDeps;
-		yield* Metric.increment(Metric.tagged(supervisorExhaustionsCounter, "supervisor", sup.name));
+		yield* Metric.update(Metric.withAttributes(supervisorExhaustionsCounter, { supervisor: sup.name }), 1);
 		yield* reporter.onExhausted(sup.name, cause);
-		yield* Option.match(Option.fromNullable(sup.reporter.onExhausted), {
+		yield* Option.match(Option.fromNullishOr(sup.reporter.onExhausted), {
 			onNone: () => Effect.void,
 			onSome: (fn) => fn(cause)
 		});
@@ -570,7 +775,7 @@ const buildSupervisorBody = (sup, health, booted) => Effect.gen(function* () {
 	yield* Effect.andThen(health.paused.await, runStrategy);
 });
 const isWorker = (x) => WorkerTypeId in x;
-const bootChild = (child) => Effect.gen(function* () {
+const bootChild = (child, reporter) => Effect.gen(function* () {
 	if (isWorker(child)) {
 		const health = yield* allocateWorkerHealth(child.name);
 		const loop = buildWorkerLoop(child, health, healthStateGauge).pipe(Effect.orDie);
@@ -581,9 +786,9 @@ const bootChild = (child) => Effect.gen(function* () {
 			childPolicy: child.child
 		};
 	}
-	const bootedChildren = yield* Effect.forEach(child.children, bootChild);
+	const bootedChildren = yield* Effect.forEach(child.children, (c) => bootChild(c, reporter));
 	const health = yield* allocateSupervisorHealth(child.name, bootedChildren.map((b) => b.health));
-	const body = buildSupervisorBody(child, health, bootedChildren).pipe(Effect.orDie);
+	const body = buildSupervisorBody(child, health, bootedChildren, reporter).pipe(Effect.orDie);
 	return {
 		name: child.name,
 		health,
@@ -591,171 +796,64 @@ const bootChild = (child) => Effect.gen(function* () {
 		childPolicy: {}
 	};
 });
-const supervisor = (s) => Effect.gen(function* () {
-	const booted = yield* Effect.forEach(s.children, bootChild);
+const supervisor$1 = (s, reporter, binding) => Effect.gen(function* () {
+	const booted = yield* Effect.forEach(s.children, (child) => bootChild(child, reporter));
 	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
-	});
-	else locked = withLeaderLock(body, {
-		key: s.lock.key,
-		mode: "optional"
-	});
-	yield* Effect.forkScoped(locked.pipe(Effect.orDie));
+	const body = buildSupervisorBody(s, health, booted, reporter).pipe(Effect.orDie);
+	const locked = withLockByMode(body, binding);
+	yield* Effect.forkScoped(locked.pipe(Effect.orDie), { startImmediately: true });
 	return health;
 });
-Context.Tag("@systemfsoftware/effect-daemon-spec/internal/build-dynamic.executor/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 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];
-			const children = HashMap.set(current.children, current.nextId, {
-				fiber: Option.none(),
-				removed
-			});
-			return [Option.some(current.nextId), {
-				nextId: current.nextId + 1,
-				children
-			}];
-		});
-		if (Option.isNone(reservedId)) return yield* new DynamicLimitExceeded({ limit: spec.maxChildren });
-		const id = reservedId.value;
-		yield* Metric.set(supervisorChildrenGauge, HashMap.size(yield* Ref.get(state).pipe(Effect.map((s) => s.children))));
-		const cleanup = Effect.gen(function* () {
-			const count = yield* Ref.modify(state, (current) => {
-				const children = HashMap.remove(current.children, id);
-				return [HashMap.size(children), {
-					...current,
-					children
-				}];
-			});
-			yield* Metric.set(supervisorChildrenGauge, count);
-			yield* removed.open;
-		}).pipe(Effect.asVoid);
-		const fiber = yield* Effect.forkScoped(loop.pipe(Effect.ensuring(cleanup)));
-		const count = yield* Ref.modify(state, (current) => {
-			const childOpt = HashMap.get(current.children, id);
-			if (Option.isNone(childOpt)) return [HashMap.size(current.children), current];
-			const children = HashMap.set(current.children, id, {
-				...childOpt.value,
-				fiber: Option.some(fiber)
-			});
-			return [HashMap.size(children), {
-				nextId: current.nextId,
-				children
-			}];
-		});
-		yield* Metric.set(supervisorChildrenGauge, count);
-		return {
-			id,
-			removed: removed.await
-		};
-	});
-	const stopChildImpl = (ref) => Effect.gen(function* () {
-		const [stateOpt, count] = yield* Ref.modify(state, (current) => {
-			const found = HashMap.get(current.children, ref.id);
-			const children = HashMap.remove(current.children, ref.id);
-			return [[found, HashMap.size(children)], {
-				...current,
-				children
-			}];
-		});
-		if (Option.isSome(stateOpt)) {
-			const { fiber, removed } = stateOpt.value;
-			yield* Option.match(fiber, {
-				onNone: () => Effect.void,
-				onSome: (running) => Effect.gen(function* () {
-					yield* Fiber.interrupt(running);
-					yield* Fiber.await(running);
-				})
-			});
-			yield* Metric.set(supervisorChildrenGauge, count);
-			yield* removed.open;
-		}
-	});
-	const countImpl = Ref.get(state).pipe(Effect.map((current) => HashMap.size(current.children)));
-	yield* Effect.zipRight(health.ready.open, Metric.set(Metric.tagged(Metric.tagged(healthStateGauge, "daemon", spec.name), "latch", "ready"), 1));
-	return {
-		health,
-		startChild: startChildImpl,
-		stopChild: stopChildImpl,
-		count: countImpl
-	};
-});
-const dynamic$2 = (spec) => Effect.gen(function* () {
-	const health = yield* allocateSupervisorHealth(spec.name, []);
-	return yield* buildDynamic(spec, health);
-});
 //#endregion
-//#region src/internal/supervision-leader.state.ts
-var LeaderConfig = class extends Context.Reference()("@systemfsoftware/effect-daemon-spec/LeaderConfig", { defaultValue: () => ({
+//#region src/internal/SupervisionLeader.ts
+const LeaderConfig = Context.Reference("@systemfsoftware/effect-daemon-spec/LeaderConfig", { defaultValue: () => ({
 	backoffBase: Duration.seconds(1),
-	intensity: new UnboundedIntensity(),
+	intensity: UnboundedIntensity.make(),
 	cooldown: Duration.zero
-}) }) {};
+}) });
 //#endregion
-//#region src/internal/supervision-task.state.ts
-var TaskConfig = class extends Context.Reference()("@systemfsoftware/effect-daemon-spec/TaskConfig", { defaultValue: () => ({
+//#region src/internal/SupervisionTask.ts
+const TaskConfig = Context.Reference("@systemfsoftware/effect-daemon-spec/TaskConfig", { defaultValue: () => ({
 	backoffBase: Duration.seconds(1),
-	intensity: new UnboundedIntensity(),
+	intensity: UnboundedIntensity.make(),
 	cooldown: Duration.zero
-}) }) {};
+}) });
 //#endregion
-//#region src/internal/supervision-worker.state.ts
-var WorkerConfig = class extends Context.Reference()("@systemfsoftware/effect-daemon-spec/WorkerConfig", { defaultValue: () => ({
+//#region src/internal/SupervisionWorker.ts
+const WorkerConfig = Context.Reference("@systemfsoftware/effect-daemon-spec/WorkerConfig", { defaultValue: () => ({
 	backoffBase: Duration.seconds(10),
-	intensity: new BoundedIntensity({
+	intensity: BoundedIntensity.make({
 		restarts: 10,
 		window: Duration.seconds(60)
 	}),
 	cooldown: Duration.seconds(30)
-}) }) {};
+}) });
 //#endregion
-//#region src/supervision-custom.kernel.ts
+//#region src/SupervisionCustom.ts
 const custom = (policy) => Effect.succeed(policy);
 //#endregion
-//#region src/supervision-leader.kernel.ts
+//#region src/SupervisionLeader.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
+//#region src/SupervisionTask.ts
 const task$1 = (config, budget) => Effect.succeed({
 	intensity: config.intensity,
-	backoff: Schedule.exponential(config.backoffBase).pipe(Schedule.jittered, Schedule.upTo(budget)),
+	backoff: Schedule.exponential(config.backoffBase).pipe(Schedule.jittered, Schedule.upTo({ duration: budget })),
 	cooldown: config.cooldown
 });
 //#endregion
-//#region src/supervision-worker.kernel.ts
+//#region src/SupervisionWorker.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
+//#region src/SupervisorOneForAll.ts
 const oneForAll$1 = (opts) => ({
 	[SupervisorTypeId]: SupervisorTypeId,
 	name: opts.name,
@@ -766,7 +864,7 @@ const oneForAll$1 = (opts) => ({
 	reporter: opts.reporter ?? {}
 });
 //#endregion
-//#region src/supervisor-one-for-one.kernel.ts
+//#region src/SupervisorOneForOne.ts
 const oneForOne$1 = (opts) => ({
 	[SupervisorTypeId]: SupervisorTypeId,
 	name: opts.name,
@@ -777,7 +875,7 @@ const oneForOne$1 = (opts) => ({
 	reporter: opts.reporter ?? {}
 });
 //#endregion
-//#region src/supervisor-rest-for-one.kernel.ts
+//#region src/SupervisorRestForOne.ts
 const restForOne$1 = (opts) => ({
 	[SupervisorTypeId]: SupervisorTypeId,
 	name: opts.name,
@@ -797,10 +895,49 @@ const Daemon = {
 	stream,
 	subscription
 };
+/**
+* Boots a worker. The leader-lock capability is acquired here, at the composition
+* root, and handed down as part of the lock binding: the executor behind this
+* entry point never sees the tag. A worker whose lock is `{ mode: 'none' }`
+* takes no lock at all.
+*/
+const worker = (w) => Effect.gen(function* () {
+	let binding;
+	if (isModeNone(w.lock)) binding = { kind: "unlocked" };
+	else {
+		const lock = yield* LeaderLock;
+		binding = {
+			kind: "locked",
+			spec: w.lock,
+			lock
+		};
+	}
+	return yield* worker$2(w, binding);
+});
+/**
+* The supervisor: acquires the `DaemonReporter` and — unless the lock mode is none —
+* the `LeaderLock` capabilities at the composition root, then hands them down to the
+* supervisor body via the lock binding. The body itself only ever sees the service
+* values.
+*/
+const supervisor = (s) => Effect.gen(function* () {
+	const reporter = yield* DaemonReporter;
+	let binding;
+	if (isModeNone(s.lock)) binding = { kind: "unlocked" };
+	else {
+		const lock = yield* LeaderLock;
+		binding = {
+			kind: "locked",
+			spec: s.lock,
+			lock
+		};
+	}
+	return yield* supervisor$1(s, reporter, binding);
+});
 const run = {
 	worker,
 	supervisor,
-	dynamic: dynamic$2
+	dynamic: dynamic$1
 };
 const leader = (cap) => Effect.flatMap(LeaderConfig, (config) => leader$1(config, cap));
 const task = (budget) => Effect.flatMap(TaskConfig, (config) => task$1(config, budget));
@@ -811,19 +948,12 @@ const Supervision = {
 	task,
 	custom
 };
-const dynamic = (opts) => dynamic$1(opts);
+const dynamic = (opts) => dynamic$2({
+	...opts,
+	maxChildren: opts.maxChildren ?? MaxChildren.make(1e3)
+});
 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 };
+export { BoundedIntensity, ChildPolicyConfig, Daemon, DaemonReporter, DynamicLimitExceeded, DynamicSpecTypeId, Intensity, IntensityConfig, LeaderConfig, LeaderLock, LeaderLockFromPrimitive, LeaderLockInfraError, LeaderLockNotAcquired, LockPolicyConfig, LockPrimitive, LockPrimitiveError, MaxChildren, Noop, Supervision, SupervisorTypeId, TaskConfig, TickPolicyConfig, UnboundedIntensity, WorkerConfig, WorkerTypeId, cappedBackoff, dynamic, healthStateGauge, leader, oneForAll, oneForOne, poll, restForOne, run, stream, subscription, supervision, supervisor, supervisorChildrenGauge, supervisorExhaustionsCounter, supervisorRestartsCounter, task, withLeaderLock, worker };