@systemfsoftware/effect-daemon-spec 0.1.0

package/dist/index.mjs

@@ -0,0 +1,737 @@
+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
+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/daemon-health.schema.ts
+var DynamicLimitExceeded = class extends Schema.TaggedError()("DynamicLimitExceeded", { limit: Schema.Int.pipe(Schema.greaterThanOrEqualTo(0)) }) {};
+//#endregion
+//#region src/daemon-metrics.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
+const IntensityConfig = Schema.Struct({
+	restarts: Schema.Int.pipe(Schema.greaterThanOrEqualTo(0)),
+	window: Schema.DurationFromSelf
+});
+const IntensityTypeId = Symbol.for("@systemfsoftware/effect-daemon-spec/Intensity");
+var BoundedIntensity = class extends Schema.TaggedClass()("Bounded", IntensityConfig.fields) {
+	[IntensityTypeId] = IntensityTypeId;
+};
+var UnboundedIntensity = class extends Schema.TaggedClass()("Unbounded", {}) {
+	[IntensityTypeId] = IntensityTypeId;
+};
+const Intensity = Schema.Union(BoundedIntensity, UnboundedIntensity);
+var ChildPolicyConfig = class extends Schema.Class("ChildPolicyConfig")({
+	restart: Schema.optional(Schema.Literal("permanent", "transient", "temporary")),
+	intensity: Schema.optional(IntensityConfig)
+}) {};
+Schema.Class("SupervisorPolicyConfig")({
+	intensity: Schema.optional(IntensityConfig),
+	cooldown: Schema.optional(Schema.DurationFromSelf)
+});
+var LockPolicyConfig = class extends Schema.Class("LockPolicyConfig")({
+	mode: Schema.optional(Schema.Literal("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"))
+}) {};
+//#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;
+//#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) => {
+	if (typeof opts.prereq === "undefined") return make$1(opts, {
+		_tag: "Poll",
+		gate: Effect.succeed(Option.some(Effect.asVoid(opts.work))),
+		interval: opts.interval
+	});
+	const { prereq, work } = opts;
+	return make$1(opts, {
+		_tag: "Poll",
+		gate: Effect.map(prereq, Option.map((data) => work(data))),
+		interval: opts.interval
+	});
+};
+const stream = (opts) => make$1(opts, {
+	_tag: "Stream",
+	stream: opts.stream
+});
+const subscription = (opts) => make$1(opts, {
+	_tag: "Subscription",
+	acquire: Effect.asVoid(opts.acquire)
+});
+const Daemon = {
+	poll,
+	stream,
+	subscription
+};
+//#endregion
+//#region src/leader-lock.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/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")() {};
+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({
+			key,
+			cause
+		})), Effect.onError(() => Scope.close(scope, Exit.void))))) {
+			yield* Scope.close(scope, Exit.void);
+			return Option.none();
+		}
+		const result = yield* restore(self).pipe(Effect.ensuring(Scope.close(scope, Exit.void)));
+		return Option.some(result);
+	})) });
+}));
+//#endregion
+//#region src/internal/intensity-window.ts
+const isWithinWindow = (now, windowMillis) => (t) => now - t <= windowMillis;
+const pruneTimestamps = (ts, now, windowMillis) => ts.filter(isWithinWindow(now, windowMillis));
+const recordTimestamp = (ts, now, windowMillis) => [now, ...pruneTimestamps(ts, now, windowMillis)];
+const exceedsRestarts = (count, restarts) => count > restarts;
+//#endregion
+//#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 windowMillis = Duration.toMillis(window);
+	const timestamps = yield* Ref.make([]);
+	const prune = (now) => Ref.modify(timestamps, (ts) => {
+		const active = pruneTimestamps(ts, now, windowMillis);
+		return [active, active];
+	});
+	return {
+		record: Effect.gen(function* () {
+			const now = yield* Clock.currentTimeMillis;
+			yield* Ref.update(timestamps, (ts) => recordTimestamp(ts, now, windowMillis));
+		}),
+		isExceeded: Effect.gen(function* () {
+			return exceedsRestarts((yield* prune(yield* Clock.currentTimeMillis)).length, restarts);
+		}),
+		count: Effect.gen(function* () {
+			return (yield* prune(yield* Clock.currentTimeMillis)).length;
+		})
+	};
+});
+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/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,
+	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.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)];
+};
+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) });
+};
+//#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
+const EpochStepTypeId = Symbol.for("@systemfsoftware/effect-daemon/EpochStep");
+var StopEpoch = class extends Schema.TaggedClass()("StopEpoch", {}) {
+	[EpochStepTypeId] = EpochStepTypeId;
+};
+var RestartEpoch = class extends Schema.TaggedClass()("RestartEpoch", {}) {
+	[EpochStepTypeId] = EpochStepTypeId;
+};
+var CooldownEpoch = class extends Schema.TaggedClass()("CooldownEpoch", {}) {
+	[EpochStepTypeId] = EpochStepTypeId;
+};
+Schema.Union(StopEpoch, RestartEpoch, CooldownEpoch);
+const SupervisionEpochResultTypeId = Symbol.for("@systemfsoftware/effect-daemon/SupervisionEpochResult");
+var StopSupervision = class extends Schema.TaggedClass()("StopSupervision", {}) {
+	[SupervisionEpochResultTypeId] = SupervisionEpochResultTypeId;
+};
+var ContinueSupervision = class extends Schema.TaggedClass()("ContinueSupervision", {}) {
+	[SupervisionEpochResultTypeId] = SupervisionEpochResultTypeId;
+};
+Schema.Union(StopSupervision, ContinueSupervision);
+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);
+	return new CooldownEpoch();
+});
+const handleRestart = (ctx, cause, onSignal) => Effect.gen(function* () {
+	yield* ctx.reportRestart(cause);
+	yield* onSignal;
+	return new RestartEpoch();
+});
+const reopenHealthyAfterCooldown = (ctx) => Effect.zipRight(ctx.health.healthy.open, Metric.set(Metric.tagged(Metric.tagged(healthStateGauge, "daemon", ctx.name), "latch", "healthy"), 1));
+const runSupervisionEpochWithBackoff = (attempt, ctx) => Effect.gen(function* () {
+	const driver = yield* Schedule.driver(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* () {
+			yield* Effect.sleep(Duration.decode(ctx.policy.cooldown));
+			yield* reopenHealthyAfterCooldown(ctx);
+			return new ContinueSupervision();
+		})), Match.tag("RestartEpoch", () => Effect.gen(function* () {
+			const stepped = yield* Effect.either(driver.next(void 0));
+			if (Either.isLeft(stepped)) return new StopSupervision();
+			return yield* loop();
+		})), Match.exhaustive);
+	});
+	return yield* loop();
+});
+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 epochResult = yield* runSupervisionEpochWithBackoff(Effect.gen(function* () {
+			yield* ctx.health.paused.await;
+			const fiber = yield* Effect.forkScoped(child.run);
+			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({
+					strategy: "one_for_one",
+					exitSuccess: false,
+					intensityExceeded: yield* supIntensity.isExceeded,
+					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 new StopEpoch();
+		}), ctx);
+		return yield* Match.value(epochResult).pipe(Match.tag("ContinueSupervision", () => loop()), Match.tag("StopSupervision", () => Effect.void), Match.exhaustive);
+	});
+	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();
+	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* make(ctx.policy.intensity);
+		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)
+		}));
+		const cursor = yield* Ref.make(0);
+		const epochResult = yield* runSupervisionEpochWithBackoff(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 [failedOffset, firstExit] = yield* raceForExit(fibers);
+			if (!Exit.isSuccess(firstExit)) {
+				const failedIdx = failedIndexOf(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({
+					strategy,
+					exitSuccess: false,
+					intensityExceeded: yield* intensity.isExceeded,
+					failedIndex: failedIdx,
+					totalChildren: ctx.booted.length
+				});
+				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();
+		}), ctx);
+		return yield* Match.value(epochResult).pipe(Match.tag("ContinueSupervision", () => loop()), Match.tag("StopSupervision", () => Effect.void), Match.exhaustive);
+	});
+	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 reportRestart = (cause) => Effect.gen(function* () {
+		const reporter = yield* DaemonReporter;
+		yield* Metric.increment(Metric.tagged(supervisorRestartsCounter, "supervisor", sup.name));
+		yield* reporter.onRestart(sup.name, cause);
+		yield* Option.match(Option.fromNullable(sup.reporter.onRestart), {
+			onNone: () => Effect.void,
+			onSome: (fn) => fn(cause)
+		});
+	});
+	const reportExhausted = (cause) => Effect.gen(function* () {
+		const reporter = yield* DaemonReporter;
+		yield* Metric.increment(Metric.tagged(supervisorExhaustionsCounter, "supervisor", sup.name));
+		yield* reporter.onExhausted(sup.name, cause);
+		yield* Option.match(Option.fromNullable(sup.reporter.onExhausted), {
+			onNone: () => Effect.void,
+			onSome: (fn) => fn(cause)
+		});
+	});
+	const runStrategy = superviseTree(sup.strategy, {
+		name: sup.name,
+		booted,
+		health,
+		policy,
+		reportRestart,
+		reportExhausted,
+		intensityEff
+	});
+	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);
+	});
+	return wrapSpan(worker, applyInnerRetry(worker.tickHooks)(body).pipe(Effect.asVoid));
+};
+const buildSubscriptionLoop = (worker, loop, health) => {
+	return wrapSpan(worker, 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;
+	}).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);
+		return {
+			name: child.name,
+			health,
+			run,
+			childPolicy: {}
+		};
+	});
+};
+//#endregion
+//#region src/internal/dynamic.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 worker = spec.child(args);
+		const loop = buildWorkerLoop(worker, yield* allocateWorkerHealth(worker.name)).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
+	};
+});
+//#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 run = {
+	worker,
+	supervisor,
+	dynamic: dynamic$1
+};
+//#endregion
+//#region src/supervision-preset.ts
+var LeaderConfig = class extends Context.Reference()("@systemfsoftware/effect-daemon-spec/LeaderConfig", { defaultValue: () => ({
+	backoffBase: Duration.seconds(1),
+	intensity: new UnboundedIntensity(),
+	cooldown: Duration.zero
+}) }) {};
+var WorkerConfig = class extends Context.Reference()("@systemfsoftware/effect-daemon-spec/WorkerConfig", { defaultValue: () => ({
+	backoffBase: Duration.seconds(10),
+	intensity: new BoundedIntensity({
+		restarts: 10,
+		window: Duration.seconds(60)
+	}),
+	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) => ({
+	[SupervisorTypeId]: SupervisorTypeId,
+	name: opts.name,
+	strategy,
+	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,
+	name: opts.name,
+	child: opts.child,
+	maxChildren: opts.maxChildren ?? 1e3
+});
+//#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 };