@systemfsoftware/effect-daemon-spec 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -1,5 +1,4 @@
 import { Cause, Context, Duration, Effect, Layer, Metric, Option, Schedule, Schema, Scope, Stream } from "effect";
-
 //#region src/backoff.d.ts
 declare const cappedBackoff: (base: Duration.DurationInput, cap: Duration.DurationInput) => Schedule.Schedule<Duration.Duration>;
 //#endregion
@@ -80,12 +79,12 @@ declare const ChildPolicyConfig_base: Schema.Class<ChildPolicyConfig, {
     window: typeof Schema.DurationFromSelf;
   }>>;
 }>, never, {
+  readonly restart?: "permanent" | "transient" | "temporary" | undefined;
+} & {
   readonly intensity?: {
     readonly restarts: number;
     readonly window: import("effect/Duration").Duration;
   } | undefined;
-} & {
-  readonly restart?: "permanent" | "temporary" | "transient" | undefined;
 }, {}, {}>;
 declare class ChildPolicyConfig extends ChildPolicyConfig_base {}
 declare const LockPolicyConfig_base: Schema.Class<LockPolicyConfig, {
@@ -95,9 +94,9 @@ declare const LockPolicyConfig_base: Schema.Class<LockPolicyConfig, {
   mode: Schema.optional<Schema.Literal<["none", "required", "optional"]>>;
   key: Schema.optional<typeof Schema.String>;
 }>, never, {
-  readonly key?: string | undefined;
+  readonly mode?: "none" | "required" | "optional" | undefined;
 } & {
-  readonly mode?: "none" | "optional" | "required" | undefined;
+  readonly key?: string | undefined;
 }, {}, {}>;
 declare class LockPolicyConfig extends LockPolicyConfig_base {}
 declare const TickPolicyConfig_base: Schema.Class<TickPolicyConfig, {
@@ -109,11 +108,11 @@ declare const TickPolicyConfig_base: Schema.Class<TickPolicyConfig, {
   tickTimeout: typeof Schema.DurationFromSelf;
   startLogLevel: Schema.optional<Schema.Literal<["debug", "info"]>>;
 }>, never, {
+  readonly tickTimeout: import("effect/Duration").Duration;
+} & {
   readonly spanName?: string | undefined;
 } & {
   readonly startLogLevel?: "debug" | "info" | undefined;
-} & {
-  readonly tickTimeout: import("effect/Duration").Duration;
 }, {}, {}>;
 declare class TickPolicyConfig extends TickPolicyConfig_base {}
 //#endregion

package/dist/index.mjs

@@ -73,15 +73,19 @@ const make$1 = (common, loop) => ({
 	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
-	});
+	if (typeof opts.prereq === "undefined") {
+		const gate = Effect.succeed(Option.some(Effect.asVoid(opts.work)));
+		return make$1(opts, {
+			_tag: "Poll",
+			gate,
+			interval: opts.interval
+		});
+	}
 	const { prereq, work } = opts;
+	const gate = Effect.map(prereq, Option.map((data) => work(data)));
 	return make$1(opts, {
 		_tag: "Poll",
-		gate: Effect.map(prereq, Option.map((data) => work(data))),
+		gate,
 		interval: opts.interval
 	});
 };
@@ -165,10 +169,12 @@ const boundedTracker = (restarts, window) => Effect.gen(function* () {
 			yield* Ref.update(timestamps, (ts) => recordTimestamp(ts, now, windowMillis));
 		}),
 		isExceeded: Effect.gen(function* () {
-			return exceedsRestarts((yield* prune(yield* Clock.currentTimeMillis)).length, restarts);
+			const now = yield* Clock.currentTimeMillis;
+			return exceedsRestarts((yield* prune(now)).length, restarts);
 		}),
 		count: Effect.gen(function* () {
-			return (yield* prune(yield* Clock.currentTimeMillis)).length;
+			const now = yield* Clock.currentTimeMillis;
+			return (yield* prune(now)).length;
 		})
 	};
 });
@@ -284,7 +290,7 @@ const superviseChild = (ctx, child, idx) => Effect.gen(function* () {
 	});
 	const loop = () => Effect.gen(function* () {
 		const supIntensity = yield* make(ctx.policy.intensity);
-		const epochResult = yield* runSupervisionEpochWithBackoff(Effect.gen(function* () {
+		const attempt = Effect.gen(function* () {
 			yield* ctx.health.paused.await;
 			const fiber = yield* Effect.forkScoped(child.run);
 			const exit = yield* Fiber.await(fiber);
@@ -308,7 +314,8 @@ const superviseChild = (ctx, child, idx) => Effect.gen(function* () {
 				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);
+		});
+		const epochResult = yield* runSupervisionEpochWithBackoff(attempt, ctx);
 		return yield* Match.value(epochResult).pipe(Match.tag("ContinueSupervision", () => loop()), Match.tag("StopSupervision", () => Effect.void), Match.exhaustive);
 	});
 	return yield* loop();
@@ -327,7 +334,7 @@ const runGroup = (strategy, ctx) => Effect.gen(function* () {
 			onSome: (cfg) => Effect.map(make(new BoundedIntensity(cfg)), Option.some)
 		}));
 		const cursor = yield* Ref.make(0);
-		const epochResult = yield* runSupervisionEpochWithBackoff(Effect.gen(function* () {
+		const attempt = Effect.gen(function* () {
 			yield* ctx.health.paused.await;
 			const startIdx = yield* Ref.get(cursor);
 			const slice = ctx.booted.slice(startIdx);
@@ -359,7 +366,8 @@ const runGroup = (strategy, ctx) => Effect.gen(function* () {
 				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);
+		});
+		const epochResult = yield* runSupervisionEpochWithBackoff(attempt, ctx);
 		return yield* Match.value(epochResult).pipe(Match.tag("ContinueSupervision", () => loop()), Match.tag("StopSupervision", () => Effect.void), Match.exhaustive);
 	});
 	return yield* loop();
@@ -463,15 +471,17 @@ const buildStreamLoop = (worker, loop, health) => {
 		yield* Effect.raceFirst(ready, Fiber.join(fiber));
 		yield* Fiber.join(fiber);
 	});
-	return wrapSpan(worker, applyInnerRetry(worker.tickHooks)(body).pipe(Effect.asVoid));
+	const retried = applyInnerRetry(worker.tickHooks)(body);
+	return wrapSpan(worker, retried.pipe(Effect.asVoid));
 };
 const buildSubscriptionLoop = (worker, loop, health) => {
-	return wrapSpan(worker, Effect.gen(function* () {
+	const body = Effect.gen(function* () {
 		yield* health.paused.await;
 		yield* applyTimeout(worker.tick)(loop.acquire);
 		yield* Effect.zipRight(health.ready.open, Metric.set(Metric.tagged(Metric.tagged(healthStateGauge, "daemon", health.name), "latch", "ready"), 1));
 		return yield* Effect.never;
-	}).pipe(Effect.asVoid));
+	});
+	return wrapSpan(worker, body.pipe(Effect.asVoid));
 };
 const buildWorkerLoop = (worker, health) => Match.value(worker.loop).pipe(Match.tag("Poll", (loop) => buildPollLoop(worker, loop, health)), Match.tag("Stream", (loop) => buildStreamLoop(worker, loop, health)), Match.tag("Subscription", (loop) => buildSubscriptionLoop(worker, loop, health)), Match.exhaustive);
 //#endregion

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@systemfsoftware/effect-daemon-spec",
   "license": "MIT",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "author": "Ryan Lee <drdgvhbh@gmail.com>",
   "repository": {
     "type": "git",
@@ -37,23 +37,22 @@
     "dist"
   ],
   "devDependencies": {
-    "@effect/vitest": "0.29.0",
+    "@effect/vitest": "0.30.0",
     "@microsoft/api-extractor": "^7.58.7",
-    "@stryker-mutator/core": "^9.6.1",
-    "@stryker-mutator/typescript-checker": "^9.6.1",
     "@stryker-mutator/vitest-runner": "^9.6.1",
     "@types/node": "^24",
     "@vitest/coverage-v8": "^4",
-    "effect": "^3.21.2",
+    "effect": "^3.22.0",
     "fast-check": "^3",
     "rimraf": "^6.1.3",
-    "tsdown": "^0.22.3",
-    "typescript": "^6.0.3",
+    "tsdown": "^0.22.9",
     "vite-tsconfig-paths": "^6.1.1",
     "vitest": "^4",
-    "@systemfsoftware/effect-gherkin-spec": "^0.1.0",
-    "@systemfsoftware/oxlint-config": "^0.1.0",
     "@systemfsoftware/effect-schema-law": "^0.1.0",
+    "@systemfsoftware/stryker-js-core": "^0.1.0",
+    "@systemfsoftware/oxlint-config": "^0.1.0",
+    "@systemfsoftware/stryker-js-typescript-checker": "^0.1.0",
+    "@systemfsoftware/effect-gherkin-spec": "^0.1.0",
     "@systemfsoftware/stryker-plugins": "^0.1.0",
     "@systemfsoftware/tsconfig": "^1.0.0",
     "@systemfsoftware/vitest-config": "^0.1.0"
@@ -64,7 +63,7 @@
   "scripts": {
     "clean": "rimraf dist",
     "build": "tsdown",
-    "typecheck": "tsgo --noEmit --incremental && tsc --noEmit --incremental",
+    "typecheck": "tsc --noEmit --incremental",
     "test": "vitest run",
     "test:run": "vitest run",
     "mutation": "stryker run --incremental",

package/dist/effect-daemon-spec.d.ts

@@ -1,410 +0,0 @@
-import { Cause } from 'effect';
-import { Context } from 'effect';
-import { Duration } from 'effect';
-import { Duration as Duration_2 } from 'effect/Duration';
-import { Effect } from 'effect';
-import { Layer } from 'effect';
-import { Metric } from 'effect';
-import { Option as Option_2 } from 'effect';
-import { Schedule } from 'effect';
-import { Schema } from 'effect';
-import { Scope } from 'effect';
-import { Stream } from 'effect';
-
-export declare class BoundedIntensity extends BoundedIntensity_base {
-    readonly [IntensityTypeId]: symbol;
-}
-
-declare const BoundedIntensity_base: Schema.TaggedClass<BoundedIntensity, "Bounded", {
-    readonly _tag: Schema.tag<"Bounded">;
-} & Readonly<{
-    restarts: Schema.filter<typeof Schema.Int>;
-    window: typeof Schema.DurationFromSelf;
-}>>;
-
-export declare const cappedBackoff: (base: Duration.DurationInput, cap: Duration.DurationInput) => Schedule.Schedule<Duration.Duration>;
-
-export declare type Child<E, R> = Worker_2<E, R> | Supervisor<E, R>;
-
-export declare class ChildPolicyConfig extends ChildPolicyConfig_base {}
-
-declare const ChildPolicyConfig_base: Schema.Class<ChildPolicyConfig, {
-    restart: Schema.optional<Schema.Literal<["permanent", "transient", "temporary"]>>;
-    intensity: Schema.optional<Schema.Struct<{
-        restarts: Schema.filter<typeof Schema.Int>;
-        window: typeof Schema.DurationFromSelf;
-    }>>;
-}, Schema.Struct.Encoded<{
-    restart: Schema.optional<Schema.Literal<["permanent", "transient", "temporary"]>>;
-    intensity: Schema.optional<Schema.Struct<{
-        restarts: Schema.filter<typeof Schema.Int>;
-        window: typeof Schema.DurationFromSelf;
-    }>>;
-}>, never, {
-    readonly intensity?: {
-        readonly restarts: number;
-        readonly window: Duration_2;
-    } | undefined;
-} & {
-    readonly restart?: "permanent" | "temporary" | "transient" | undefined;
-}, {}, {}>;
-
-export declare type ChildRef = {
-    readonly id: number;
-    readonly removed: Effect.Effect<void>;
-};
-
-export declare interface CommonOpts<L extends LockConfig> {
-    readonly name: string;
-    readonly child?: typeof ChildPolicyConfig.Type;
-    readonly tick: typeof TickPolicyConfig.Type;
-    readonly tickHooks?: TickPolicyHooks;
-    readonly lock: L;
-}
-
-export declare const Daemon: {
-    readonly poll: <A, E, R, L extends LockConfig>(opts: PollOpts<A, E, R, L>) => Worker_2<E, R, L>;
-    readonly stream: <A, E, R, L extends LockConfig>(opts: CommonOpts<L> & {
-        readonly stream: Stream.Stream<A, E, R>;
-    }) => Worker_2<E, R, L>;
-    readonly subscription: <A, E, R, L extends LockConfig>(opts: CommonOpts<L> & {
-        readonly acquire: Effect.Effect<A, E, R>;
-    }) => Worker_2<E, R, L>;
-};
-
-export declare interface DaemonHealth {
-    readonly name: string;
-    readonly ready: Effect.Latch;
-    readonly healthy: Effect.Latch;
-    readonly paused: Effect.Latch;
-}
-
-export declare class DaemonReporter extends DaemonReporter_base {
-    static readonly Noop: Layer.Layer<DaemonReporter>;
-}
-
-declare const DaemonReporter_base: Context.TagClass<DaemonReporter, "@systemfsoftware/effect-daemon-spec/daemon-reporter/DaemonReporter", DaemonReporterService>;
-
-export declare interface DaemonReporterService {
-    readonly onRestart: (name: string, cause: Cause.Cause<never>) => Effect.Effect<void>;
-    readonly onExhausted: (name: string, cause: Cause.Cause<never>) => Effect.Effect<void>;
-}
-
-export declare const dynamic: <E, R, Args>(opts: {
-    readonly name: string;
-    readonly child: (args: Args) => Worker_2<E, R>;
-    readonly maxChildren?: number;
-}) => DynamicSpec<E, R, Args>;
-
-export declare interface DynamicHandle<Args, R = never> {
-    readonly health: SupervisorHealth;
-    readonly startChild: (args: Args) => Effect.Effect<ChildRef, DynamicLimitExceeded, R>;
-    readonly stopChild: (ref: Pick<ChildRef, 'id'>) => Effect.Effect<void>;
-    readonly count: Effect.Effect<number>;
-}
-
-export declare class DynamicLimitExceeded extends DynamicLimitExceeded_base {}
-
-declare const DynamicLimitExceeded_base: Schema.TaggedErrorClass<DynamicLimitExceeded, "DynamicLimitExceeded", {
-    readonly _tag: Schema.tag<"DynamicLimitExceeded">;
-} & {
-    limit: Schema.filter<typeof Schema.Int>;
-}>;
-
-export declare interface DynamicSpec<E, R, Args> {
-    readonly [DynamicSpecTypeId]: DynamicSpecTypeId;
-    readonly name: string;
-    readonly child: (args: Args) => Worker_2<E, R>;
-    readonly maxChildren: number;
-}
-
-export declare const DynamicSpecTypeId: unique symbol;
-
-export declare type DynamicSpecTypeId = typeof DynamicSpecTypeId;
-
-export declare const healthStateGauge: Metric.Metric.Gauge<number>;
-
-export declare const Intensity: Schema.Union<[typeof BoundedIntensity, typeof UnboundedIntensity]>;
-
-export declare type Intensity = typeof Intensity.Type;
-
-export declare const IntensityConfig: Schema.Struct<{
-    restarts: Schema.filter<typeof Schema.Int>;
-    window: typeof Schema.DurationFromSelf;
-}>;
-
-export declare type IntensityConfig = typeof IntensityConfig.Type;
-
-export declare const IntensityTypeId: unique symbol;
-
-export declare type IntensityTypeId = typeof IntensityTypeId;
-
-export declare const isSupervisor: <E, R>(x: Child<E, R>) => x is Supervisor<E, R>;
-
-export declare const isWorker: <E, R>(x: Child<E, R>) => x is Worker_2<E, R>;
-
-export declare class LeaderConfig extends LeaderConfig_base {}
-
-declare const LeaderConfig_base: Context.ReferenceClass<LeaderConfig, "@systemfsoftware/effect-daemon-spec/LeaderConfig", SupervisionConfig>;
-
-export declare class LeaderLock extends LeaderLock_base {
-    static readonly Noop: Layer.Layer<LeaderLock>;
-}
-
-declare const LeaderLock_base: Context.TagClass<LeaderLock, "@systemfsoftware/effect-daemon-spec/leader-lock/LeaderLock", LeaderLockService>;
-
-export declare type LeaderLockAcquireError = LeaderLockNotAcquired | LeaderLockInfraError;
-
-export declare const LeaderLockFromPrimitive: Layer.Layer<LeaderLock, never, LockPrimitive>;
-
-export declare class LeaderLockInfraError extends LeaderLockInfraError_base {}
-
-declare const LeaderLockInfraError_base: Schema.TaggedErrorClass<LeaderLockInfraError, "LeaderLockInfraError", {
-    readonly _tag: Schema.tag<"LeaderLockInfraError">;
-} & {
-    key: typeof Schema.String;
-    cause: typeof Schema.Unknown;
-}>;
-
-export declare class LeaderLockNotAcquired extends LeaderLockNotAcquired_base {}
-
-declare const LeaderLockNotAcquired_base: Schema.TaggedErrorClass<LeaderLockNotAcquired, "LeaderLockNotAcquired", {
-    readonly _tag: Schema.tag<"LeaderLockNotAcquired">;
-} & {
-    key: typeof Schema.String;
-}>;
-
-export declare interface LeaderLockOptions {
-    readonly key: string;
-    readonly mode: 'required' | 'optional';
-}
-
-export declare interface LeaderLockService {
-    readonly withLock: <A, E, R>(key: string, self: Effect.Effect<A, E, R>) => Effect.Effect<Option_2.Option<A>, E | LeaderLockInfraError, R>;
-}
-
-export declare type LockConfig = {
-    mode: 'none';
-} | {
-    mode: 'optional';
-    key: string;
-} | {
-    mode: 'required';
-    key: string;
-    acquireRetryBackoff: Schedule.Schedule<Duration.Duration>;
-};
-
-export declare class LockPolicyConfig extends LockPolicyConfig_base {}
-
-declare const LockPolicyConfig_base: Schema.Class<LockPolicyConfig, {
-    mode: Schema.optional<Schema.Literal<["none", "required", "optional"]>>;
-    key: Schema.optional<typeof Schema.String>;
-}, Schema.Struct.Encoded<{
-    mode: Schema.optional<Schema.Literal<["none", "required", "optional"]>>;
-    key: Schema.optional<typeof Schema.String>;
-}>, never, {
-    readonly key?: string | undefined;
-} & {
-    readonly mode?: "none" | "optional" | "required" | undefined;
-}, {}, {}>;
-
-export declare class LockPrimitive extends LockPrimitive_base {}
-
-declare const LockPrimitive_base: Context.TagClass<LockPrimitive, "@systemfsoftware/effect-daemon-spec/lock-primitive/LockPrimitive", LockPrimitiveService>;
-
-export declare class LockPrimitiveError extends LockPrimitiveError_base {}
-
-declare const LockPrimitiveError_base: Schema.TaggedErrorClass<LockPrimitiveError, "LockPrimitiveError", {
-    readonly _tag: Schema.tag<"LockPrimitiveError">;
-} & {
-    key: typeof Schema.String;
-    cause: typeof Schema.Unknown;
-}>;
-
-export declare interface LockPrimitiveService {
-    readonly tryAcquire: (key: string) => Effect.Effect<boolean, LockPrimitiveError, Scope.Scope>;
-}
-
-export declare type LoopShape<E, R> = PollLoop<E, R> | StreamLoop<E, R> | SubscriptionLoop<E, R>;
-
-export declare const oneForAll: <E, R, L extends LockConfig = LockConfig>(opts: SupervisorOpts<E, R, L>) => Supervisor<E, R, L>;
-
-export declare const oneForOne: <E, R, L extends LockConfig = LockConfig>(opts: SupervisorOpts<E, R, L>) => Supervisor<E, R, L>;
-
-export declare const poll: <A, E, R, L extends LockConfig>(opts: PollOpts<A, E, R, L>) => Worker_2<E, R, L>;
-
-export declare type PollLoop<E, R> = {
-    readonly _tag: 'Poll';
-    readonly gate: Effect.Effect<Option_2.Option<Effect.Effect<void, E, R>>, E, R>;
-    readonly interval: Duration.DurationInput;
-};
-
-export declare type PollOpts<A, E, R, L extends LockConfig> = CommonOpts<L> & {
-    readonly interval: Duration.DurationInput;
-} & ({
-    readonly prereq?: undefined;
-    readonly work: Effect.Effect<A, E, R>;
-} | {
-    readonly prereq: Effect.Effect<Option_2.Option<A>, E, R>;
-    readonly work: (data: A) => Effect.Effect<void, E, R>;
-});
-
-export declare interface ReporterPolicyHooks {
-    readonly onRestart?: (cause: Cause.Cause<never>) => Effect.Effect<void>;
-    readonly onExhausted?: (cause: Cause.Cause<never>) => Effect.Effect<void>;
-}
-
-export declare const restForOne: <E, R, L extends LockConfig = LockConfig>(opts: SupervisorOpts<E, R, L>) => Supervisor<E, R, L>;
-
-export declare const run: {
-    readonly worker: typeof worker;
-    readonly supervisor: typeof supervisor;
-    readonly dynamic: <E, R, Args>(spec: DynamicSpec<E, R, Args>) => Effect.Effect<DynamicHandle<Args, R | LeaderLock | DaemonReporter | Scope.Scope>, never, R | LeaderLock | DaemonReporter | Scope.Scope>;
-};
-
-export declare const stream: <A, E, R, L extends LockConfig>(opts: CommonOpts<L> & {
-    readonly stream: Stream.Stream<A, E, R>;
-}) => Worker_2<E, R, L>;
-
-export declare type StreamLoop<E, R> = {
-    readonly _tag: 'Stream';
-    readonly stream: Stream.Stream<unknown, E, R>;
-};
-
-export declare const subscription: <A, E, R, L extends LockConfig>(opts: CommonOpts<L> & {
-    readonly acquire: Effect.Effect<A, E, R>;
-}) => Worker_2<E, R, L>;
-
-export declare type SubscriptionLoop<E, R> = {
-    readonly _tag: 'Subscription';
-    readonly acquire: Effect.Effect<void, E, R>;
-};
-
-export declare const Supervision: {
-    readonly leader: (cap: Duration.DurationInput) => Effect.Effect<SupervisionPolicy>;
-    readonly worker: (cap: Duration.DurationInput) => Effect.Effect<SupervisionPolicy>;
-    readonly task: (budget: Duration.DurationInput) => Effect.Effect<SupervisionPolicy>;
-    readonly custom: (policy: SupervisionPolicy) => Effect.Effect<SupervisionPolicy>;
-};
-
-export declare interface SupervisionConfig {
-    readonly backoffBase: Duration.DurationInput;
-    readonly intensity: Intensity;
-    readonly cooldown: Duration.DurationInput;
-}
-
-export declare interface SupervisionPolicy {
-    readonly intensity: Intensity;
-    readonly backoff: Schedule.Schedule<Duration.Duration>;
-    readonly cooldown: Duration.DurationInput;
-}
-
-export declare interface Supervisor<E, R, L extends LockConfig = LockConfig> {
-    readonly [SupervisorTypeId]: SupervisorTypeId;
-    readonly name: string;
-    readonly strategy: 'one_for_one' | 'one_for_all' | 'rest_for_one';
-    readonly children: ReadonlyArray<Worker_2<E, R> | Supervisor<E, R>>;
-    readonly supervision: Effect.Effect<SupervisionPolicy>;
-    readonly lock: L;
-    readonly reporter: ReporterPolicyHooks;
-}
-
-export declare function supervisor<E, R>(s: Supervisor<E, R, {
-    mode: 'none';
-}>): Effect.Effect<SupervisorHealth, never, R | DaemonReporter | Scope.Scope>;
-
-export declare function supervisor<E, R>(s: Supervisor<E, R, LockConfig>): Effect.Effect<SupervisorHealth, never, R | LeaderLock | DaemonReporter | Scope.Scope>;
-
-export declare const supervisorChildrenGauge: Metric.Metric.Gauge<number>;
-
-export declare const supervisorExhaustionsCounter: Metric.Metric.Counter<number>;
-
-export declare interface SupervisorHealth {
-    readonly name: string;
-    readonly ready: Effect.Latch;
-    readonly healthy: Effect.Latch;
-    readonly paused: Effect.Latch;
-    readonly children: ReadonlyArray<DaemonHealth | SupervisorHealth>;
-}
-
-export declare interface SupervisorOpts<E, R, L extends LockConfig> {
-    readonly name: string;
-    readonly children: ReadonlyArray<Child<E, R>>;
-    readonly supervision: Effect.Effect<SupervisionPolicy>;
-    readonly lock: L;
-    readonly reporter?: ReporterPolicyHooks;
-}
-
-export declare const supervisorRestartsCounter: Metric.Metric.Counter<number>;
-
-export declare const SupervisorTypeId: unique symbol;
-
-export declare type SupervisorTypeId = typeof SupervisorTypeId;
-
-export declare class TaskConfig extends TaskConfig_base {}
-
-declare const TaskConfig_base: Context.ReferenceClass<TaskConfig, "@systemfsoftware/effect-daemon-spec/TaskConfig", SupervisionConfig>;
-
-export declare class TickPolicyConfig extends TickPolicyConfig_base {}
-
-declare const TickPolicyConfig_base: Schema.Class<TickPolicyConfig, {
-    spanName: Schema.optional<typeof Schema.String>;
-    tickTimeout: typeof Schema.DurationFromSelf;
-    startLogLevel: Schema.optional<Schema.Literal<["debug", "info"]>>;
-}, Schema.Struct.Encoded<{
-    spanName: Schema.optional<typeof Schema.String>;
-    tickTimeout: typeof Schema.DurationFromSelf;
-    startLogLevel: Schema.optional<Schema.Literal<["debug", "info"]>>;
-}>, never, {
-    readonly spanName?: string | undefined;
-} & {
-    readonly startLogLevel?: "debug" | "info" | undefined;
-} & {
-    readonly tickTimeout: Duration_2;
-}, {}, {}>;
-
-export declare interface TickPolicyHooks {
-    readonly spanAttributes?: Effect.Effect<Record<string, string | number | boolean>>;
-    readonly innerRetry?: Schedule.Schedule<unknown>;
-    readonly trackDuration?: Metric.Metric.Histogram<Duration.Duration>;
-}
-
-export declare class UnboundedIntensity extends UnboundedIntensity_base {
-    readonly [IntensityTypeId]: symbol;
-}
-
-declare const UnboundedIntensity_base: Schema.TaggedClass<UnboundedIntensity, "Unbounded", {
-    readonly _tag: Schema.tag<"Unbounded">;
-}>;
-
-export declare const withLeaderLock: {
-    (options: LeaderLockOptions): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | void, E | LeaderLockAcquireError, R | LeaderLock>;
-    <A, E, R>(self: Effect.Effect<A, E, R>, options: LeaderLockOptions): Effect.Effect<A | void, E | LeaderLockAcquireError, R | LeaderLock>;
-};
-
-export declare function worker<E, R>(w: Worker_2<E, R, {
-    mode: 'none';
-}>): Effect.Effect<DaemonHealth, never, R | DaemonReporter | Scope.Scope>;
-
-export declare function worker<E, R>(w: Worker_2<E, R, LockConfig>): Effect.Effect<DaemonHealth, never, R | LeaderLock | DaemonReporter | Scope.Scope>;
-
-declare interface Worker_2<E, R, L extends LockConfig = LockConfig> {
-    readonly [WorkerTypeId]: WorkerTypeId;
-    readonly name: string;
-    readonly loop: LoopShape<E, R>;
-    readonly child: typeof ChildPolicyConfig.Type;
-    readonly tick: typeof TickPolicyConfig.Type;
-    readonly tickHooks: TickPolicyHooks;
-    readonly lock: L;
-}
-export { Worker_2 as Worker }
-
-export declare class WorkerConfig extends WorkerConfig_base {}
-
-declare const WorkerConfig_base: Context.ReferenceClass<WorkerConfig, "@systemfsoftware/effect-daemon-spec/WorkerConfig", SupervisionConfig>;
-
-export declare const WorkerTypeId: unique symbol;
-
-export declare type WorkerTypeId = typeof WorkerTypeId;
-
-export { }