@systemfsoftware/effect-daemon-spec 1.0.0 → 3.0.0

package/dist/index.mjs

@@ -93,6 +93,17 @@ const Noop = Layer.succeed(DaemonReporter, DaemonReporter.of({
 	onExhausted: () => Effect.void
 }));
 //#endregion
+//#region src/LoopTags.ts
+/**
+* Discriminants on the public Worker loop variants.
+*
+* These tags are part of the published type identity of `poll`, `stream`,
+* and `subscription`. They are not unpublished wiring.
+*/
+const PollLoopTag = { _tag: "Poll" };
+const StreamLoopTag = { _tag: "Stream" };
+const SubscriptionLoopTag = { _tag: "Subscription" };
+//#endregion
 //#region src/DaemonPoll.ts
 const poll$1 = (opts) => {
 	if (typeof opts.prereq === "undefined") {
@@ -101,7 +112,7 @@ const poll$1 = (opts) => {
 			[WorkerTypeId]: WorkerTypeId,
 			name: opts.name,
 			loop: {
-				_tag: "Poll",
+				...PollLoopTag,
 				gate,
 				interval: opts.interval
 			},
@@ -117,7 +128,7 @@ const poll$1 = (opts) => {
 		[WorkerTypeId]: WorkerTypeId,
 		name: opts.name,
 		loop: {
-			_tag: "Poll",
+			...PollLoopTag,
 			gate,
 			interval: opts.interval
 		},
@@ -133,7 +144,7 @@ const stream$1 = (opts) => ({
 	[WorkerTypeId]: WorkerTypeId,
 	name: opts.name,
 	loop: {
-		_tag: "Stream",
+		...StreamLoopTag,
 		stream: opts.stream
 	},
 	child: opts.child ?? {},
@@ -147,7 +158,7 @@ const subscription$1 = (opts) => ({
 	[WorkerTypeId]: WorkerTypeId,
 	name: opts.name,
 	loop: {
-		_tag: "Subscription",
+		...SubscriptionLoopTag,
 		acquire: Effect.asVoid(opts.acquire)
 	},
 	child: opts.child ?? {},
@@ -156,9 +167,6 @@ const subscription$1 = (opts) => ({
 	lock: opts.lock
 });
 //#endregion
-//#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", {
@@ -193,7 +201,35 @@ const LeaderLockFromPrimitive = Layer.effect(LeaderLock, Effect.gen(function* ()
 	})) });
 }));
 //#endregion
+//#region src/internal/AllocateSupervisorHealth.ts
+/** @internal */
+const allocateSupervisorHealth = (name, children) => Effect.gen(function* () {
+	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,
+		healthy,
+		paused,
+		children
+	};
+});
+//#endregion
 //#region src/internal/AllocateWorkerHealth.ts
+/** @internal */
 const allocateWorkerHealth = (name) => Effect.gen(function* () {
 	const ready = yield* Latch.make(false);
 	const healthy = yield* Latch.make(true);
@@ -292,87 +328,10 @@ const buildSubscriptionLoop = (worker, loop, health, readyGauge) => {
 	});
 	return wrapSpan(worker, body.pipe(Effect.asVoid));
 };
+/** @internal */
 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/WithLeaderLockExecutor.ts
-function withLeaderLock(self, options, lock) {
-	const acquire = Effect.gen(function* () {
-		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(LeaderLockNotAcquired.make({ 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/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: 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/AllocateSupervisorHealth.ts
-const allocateSupervisorHealth = (name, children) => Effect.gen(function* () {
-	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,
-		healthy,
-		paused,
-		children
-	};
-});
-//#endregion
-//#region src/internal/BuildDynamicExecutor.ts
+//#region src/RunDynamic.ts
 const buildDynamic = (spec, health) => Effect.gen(function* () {
 	const state = yield* Ref.make({
 		nextId: 0,
@@ -467,18 +426,24 @@ const dynamic$1 = (spec) => Effect.gen(function* () {
 });
 //#endregion
 //#region src/internal/IntensityWindow.ts
+/** @internal */
 const isWithinWindow = (now, windowMillis) => (t) => now - t <= windowMillis;
 const keepWithin = (now, windowMillis) => (ts) => ts.filter(isWithinWindow(now, windowMillis));
+/** @internal */
 const pruneTimestamps = (ts, now, windowMillis) => keepWithin(now, windowMillis)(ts);
+/** @internal */
 const recordTimestamp = (ts, now, windowMillis) => [now, ...pruneTimestamps(ts, now, windowMillis)];
+/** @internal */
 const exceedsRestarts = (count, restarts) => count > restarts;
 //#endregion
 //#region src/internal/Intensity.ts
+/** @internal */
 const neverExceeds = {
 	record: Effect.void,
 	isExceeded: Effect.succeed(false),
 	count: Effect.succeed(0)
 };
+/** @internal */
 const make = (restarts, window) => Effect.gen(function* () {
 	const windowMillis = Duration.toMillis(window);
 	const timestamps = yield* Ref.make([]);
@@ -504,8 +469,61 @@ const make = (restarts, window) => Effect.gen(function* () {
 });
 //#endregion
 //#region src/internal/RaceForExit.ts
+/** @internal */
 const raceForExit = (fibers) => Effect.raceAll(fibers.map((f, idx) => Fiber.await(f).pipe(Effect.map((exit) => [idx, exit]))));
 //#endregion
+//#region src/internal/RestartDecision.schema.ts
+/** @internal */
+const RestartStrategy = Schema.Literals([
+	"one_for_one",
+	"one_for_all",
+	"rest_for_one"
+]);
+/**
+* The cross-field invariant the command carries: a failed child's index addresses one of
+* the children that exist.
+*
+* It is a named function rather than an inline `Schema.filter` arrow because naming it makes
+* it reachable by this file's property block, which an inline arrow is not. It is not
+* exported: a `*.schema.ts` declares schemas and the vocabulary they are built from, never
+* loose functions, and nothing outside this module needs it.
+*
+* It lives here rather than beside the decision because the decision now imports
+* `DecideInput` as a *value* — `Workflow.make` constrains its command argument on the class
+* itself — so the dependency between these two modules has to run one way only. With the
+* predicate on the other side, both load orders reach a temporal dead zone: whichever module
+* evaluates first suspends on the other, and the name it needs at module scope is not yet
+* initialised.
+*/
+const failedIndexAddressesAChild = (input) => input.failedIndex < input.totalChildren;
+/**
+* The command's field map and cross-field check, named so the class below extends a binding
+* rather than an inline factory call. An anonymous base adds a new `ae-forgotten-export`
+* `*_base` warning to the committed API report, which this package fixes at the source
+* instead of suppressing.
+*/
+const DecideInputBase = 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" })));
+/**
+* The restart command. A `Schema.Class` rather than a `Schema.Struct` because `Workflow.make`
+* takes the command's class as its first argument, and a struct carries no `identifier` and
+* no `extend` — the constraint refuses it. Every field schema and the cross-field check are
+* the ones the struct carried.
+*/
+/** @internal */
+var DecideInput = class extends Schema.Class("DecideInput")(DecideInputBase) {};
+//#endregion
 //#region src/internal/RestartDecision.workflow.ts
 /**
 * The child indices a restart covers, by supervision strategy.
@@ -513,59 +531,38 @@ const raceForExit = (fibers) => Effect.raceAll(fibers.map((f, idx) => Fiber.awai
 * 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.
 */
+/** @internal */
 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");
+/** @internal */
 var RestartDecisionContinue = class extends S.TaggedClass()("Continue", {}) {
 	[RestartDecisionTypeId] = RestartDecisionTypeId;
 };
+/** @internal */
 var RestartDecisionRestart = class extends S.TaggedClass()("Restart", { indices: S.NonEmptyArray(S.Int) }) {
 	[RestartDecisionTypeId] = RestartDecisionTypeId;
 };
+/** @internal */
 var RestartDecisionExhausted = class extends S.TaggedError()("Exhausted", {}) {
 	[RestartDecisionTypeId] = RestartDecisionTypeId;
 };
-const decideRestart = Workflow.make((command) => Match$1.value(command).pipe(Match$1.when({ exitSuccess: true }, () => Result$1.succeed(RestartDecisionContinue.make())), Match$1.when({
+/** @internal */
+const decideRestart = Workflow.make(DecideInput, (command) => Match$1.value(command).pipe(Match$1.when({ exitSuccess: true }, () => Result$1.succeed(RestartDecisionContinue.make())), Match$1.when({
 	exitSuccess: false,
 	intensityExceeded: true
 }, () => 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/SupervisionEpoch.schema.ts
 const EpochStepTypeId = Symbol.for("@systemfsoftware/effect-daemon/EpochStep");
+/** @internal */
 var StopEpoch = class extends Schema.TaggedClass()("StopEpoch", {}) {
 	[EpochStepTypeId] = EpochStepTypeId;
 };
+/** @internal */
 var RestartEpoch = class extends Schema.TaggedClass()("RestartEpoch", {}) {
 	[EpochStepTypeId] = EpochStepTypeId;
 };
+/** @internal */
 var CooldownEpoch = class extends Schema.TaggedClass()("CooldownEpoch", {}) {
 	[EpochStepTypeId] = EpochStepTypeId;
 };
@@ -575,14 +572,63 @@ Schema.Union([
 	CooldownEpoch
 ]);
 const SupervisionEpochResultTypeId = Symbol.for("@systemfsoftware/effect-daemon/SupervisionEpochResult");
+/** @internal */
 var StopSupervision = class extends Schema.TaggedClass()("StopSupervision", {}) {
 	[SupervisionEpochResultTypeId] = SupervisionEpochResultTypeId;
 };
+/** @internal */
 var ContinueSupervision = class extends Schema.TaggedClass()("ContinueSupervision", {}) {
 	[SupervisionEpochResultTypeId] = SupervisionEpochResultTypeId;
 };
 Schema.Union([StopSupervision, ContinueSupervision]);
 //#endregion
+//#region src/WithLeaderLock.ts
+/**
+* Runs `self` while holding the named leader lock.
+*/
+function withLeaderLock(self, options, lock) {
+	const acquire = Effect.gen(function* () {
+		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(LeaderLockNotAcquired.make({ 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/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.
+*/
+/** @internal */
+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: binding.spec.acquireRetryBackoff
+	}, binding.lock);
+	return withLeaderLock(self, {
+		key: binding.spec.key,
+		mode: "optional"
+	}, binding.lock);
+};
+//#endregion
 //#region src/internal/SupervisorBodyExecutor.ts
 const handleExhausted = (ctx, cause) => Effect.gen(function* () {
 	yield* Effect.andThen(ctx.health.healthy.close, Metric.update(Metric.withAttributes(healthStateGauge, {
@@ -796,6 +842,7 @@ const bootChild = (child, reporter) => Effect.gen(function* () {
 		childPolicy: {}
 	};
 });
+/** @internal */
 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));
@@ -805,34 +852,70 @@ const supervisor$1 = (s, reporter, binding) => Effect.gen(function* () {
 	return health;
 });
 //#endregion
-//#region src/internal/SupervisionLeader.ts
-const LeaderConfig = Context.Reference("@systemfsoftware/effect-daemon-spec/LeaderConfig", { defaultValue: () => ({
-	backoffBase: Duration.seconds(1),
-	intensity: UnboundedIntensity.make(),
-	cooldown: Duration.zero
-}) });
+//#region src/LeaderLock.ts
+const isModeNone = (lock) => lock.mode === "none";
 //#endregion
-//#region src/internal/SupervisionTask.ts
-const TaskConfig = Context.Reference("@systemfsoftware/effect-daemon-spec/TaskConfig", { defaultValue: () => ({
-	backoffBase: Duration.seconds(1),
-	intensity: UnboundedIntensity.make(),
-	cooldown: Duration.zero
-}) });
+//#region src/RunSupervisor.ts
+/**
+* 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);
+});
 //#endregion
-//#region src/internal/SupervisionWorker.ts
-const WorkerConfig = Context.Reference("@systemfsoftware/effect-daemon-spec/WorkerConfig", { defaultValue: () => ({
-	backoffBase: Duration.seconds(10),
-	intensity: BoundedIntensity.make({
-		restarts: 10,
-		window: Duration.seconds(60)
-	}),
-	cooldown: Duration.seconds(30)
-}) });
+//#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/RunWorker.ts
+/**
+* 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);
+});
 //#endregion
 //#region src/SupervisionCustom.ts
 const custom = (policy) => Effect.succeed(policy);
 //#endregion
 //#region src/SupervisionLeader.ts
+const LeaderConfig = Context.Reference("@systemfsoftware/effect-daemon-spec/LeaderConfig", { defaultValue: () => ({
+	backoffBase: Duration.seconds(1),
+	intensity: UnboundedIntensity.make(),
+	cooldown: Duration.zero
+}) });
 const leader$1 = (config, cap) => Effect.succeed({
 	intensity: config.intensity,
 	backoff: cappedBackoff(config.backoffBase, cap),
@@ -840,6 +923,11 @@ const leader$1 = (config, cap) => Effect.succeed({
 });
 //#endregion
 //#region src/SupervisionTask.ts
+const TaskConfig = Context.Reference("@systemfsoftware/effect-daemon-spec/TaskConfig", { defaultValue: () => ({
+	backoffBase: Duration.seconds(1),
+	intensity: UnboundedIntensity.make(),
+	cooldown: Duration.zero
+}) });
 const task$1 = (config, budget) => Effect.succeed({
 	intensity: config.intensity,
 	backoff: Schedule.exponential(config.backoffBase).pipe(Schedule.jittered, Schedule.upTo({ duration: budget })),
@@ -847,6 +935,14 @@ const task$1 = (config, budget) => Effect.succeed({
 });
 //#endregion
 //#region src/SupervisionWorker.ts
+const WorkerConfig = Context.Reference("@systemfsoftware/effect-daemon-spec/WorkerConfig", { defaultValue: () => ({
+	backoffBase: Duration.seconds(10),
+	intensity: BoundedIntensity.make({
+		restarts: 10,
+		window: Duration.seconds(60)
+	}),
+	cooldown: Duration.seconds(30)
+}) });
 const worker$1 = (config, cap) => Effect.succeed({
 	intensity: config.intensity,
 	backoff: cappedBackoff(config.backoffBase, cap),
@@ -895,45 +991,6 @@ 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,
@@ -956,4 +1013,4 @@ const oneForAll = (opts) => oneForAll$1(opts);
 const oneForOne = (opts) => oneForOne$1(opts);
 const restForOne = (opts) => restForOne$1(opts);
 //#endregion
-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 };
+export { BoundedIntensity, ChildPolicyConfig, Daemon, DaemonReporter, DynamicLimitExceeded, DynamicSpecTypeId, Intensity, IntensityConfig, LeaderConfig, LeaderLock, LeaderLockFromPrimitive, LeaderLockInfraError, LeaderLockNotAcquired, LockPolicyConfig, LockPrimitive, LockPrimitiveError, MaxChildren, Noop, PollLoopTag, StreamLoopTag, SubscriptionLoopTag, 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 };

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@systemfsoftware/effect-daemon-spec",
   "license": "Apache-2.0",
-  "version": "1.0.0",
+  "version": "3.0.0",
   "author": "Ryan Lee <drdgvhbh@gmail.com>",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/systemfsoftware/systemfsoftware.git",
-    "directory": "packages/effect-daemon-spec"
+    "directory": "packages/core/effect/daemon-spec"
   },
-  "homepage": "https://github.com/systemfsoftware/systemfsoftware/tree/main/packages/effect-daemon-spec#readme",
+  "homepage": "https://github.com/systemfsoftware/systemfsoftware/tree/main/packages/core/effect/daemon-spec#readme",
   "bugs": "https://github.com/systemfsoftware/systemfsoftware/issues",
   "description": "Supervision-tree daemons for Effect-TS — leader election, distributed locks, restart-intensity backoff, dynamic children, and health latches as a pure typed core.",
   "keywords": [
@@ -37,31 +37,32 @@
     "dist"
   ],
   "dependencies": {
-    "@systemfsoftware/effect-cell-types": "^2.0.0"
+    "@systemfsoftware/effect-cell-types": "^4.0.0"
   },
   "devDependencies": {
-    "@effect/vitest": "4.0.0-rc.108",
+    "@effect/vitest": "4.0.0-rc.111",
     "@microsoft/api-extractor": "^7.58.7",
     "@systemfsoftware/arethetypeswrong-cli": "^1.1.1",
     "@types/node": "^24",
     "@vitest/coverage-v8": "^4",
-    "effect": "4.0.0-rc.108",
+    "effect": "4.0.0-rc.111",
     "fast-check": "^4",
     "oxlint": "^1.77.0",
     "rimraf": "^6.1.3",
     "tsdown": "^0.22.14",
+    "typescript": "^7",
     "vitest": "^4.1.10",
-    "@systemfsoftware/effect-gherkin-spec": "^1.0.0",
-    "@systemfsoftware/effect-schema-law": "^0.7.0",
-    "@systemfsoftware/effect-schema-vite": "^1.5.2",
+    "@systemfsoftware/effect-gherkin-spec": "^2.0.1",
+    "@systemfsoftware/effect-schema-vite": "^1.5.4",
     "@systemfsoftware/oxlint-config": "^0.1.0",
-    "@systemfsoftware/oxlint-plugin-cell-vocabulary": "^1.1.0",
-    "@systemfsoftware/tsconfig": "^1.3.2",
-    "@systemfsoftware/stryker-plugins": "^0.12.0",
-    "@systemfsoftware/vitest-config": "^0.1.0"
+    "@systemfsoftware/effect-schema-law": "^0.9.0",
+    "@systemfsoftware/stryker-plugins": "^0.13.1",
+    "@systemfsoftware/tsconfig": "^1.3.3",
+    "@systemfsoftware/vitest-config": "^0.1.0",
+    "@systemfsoftware/oxlint-plugin-cell-vocabulary": "^1.2.1"
   },
   "peerDependencies": {
-    "effect": "4.0.0-rc.108"
+    "effect": "^4.0.0-rc.111"
   },
   "publishConfig": {
     "provenance": true