@systemfsoftware/effect-daemon-spec 0.5.0 → 0.7.0

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

@@ -9,6 +9,7 @@ import { Option as Option_2 } from 'effect';
 import { Schedule } from 'effect';
 import { Schema } from 'effect';
 import { Scope } from 'effect';
+import { Scope as Scope_2 } from 'effect/Scope';
 import { Stream } from 'effect';
 
 export declare class BoundedIntensity extends BoundedIntensity_base {
@@ -79,11 +80,9 @@ export declare interface DaemonHealth {
     readonly paused: Effect.Latch;
 }
 
-export declare class DaemonReporter extends DaemonReporter_base {
-    static readonly Noop: Layer.Layer<DaemonReporter>;
-}
+export declare class DaemonReporter extends DaemonReporter_base {}
 
-declare const DaemonReporter_base: Context.TagClass<DaemonReporter, "@systemfsoftware/effect-daemon-spec/daemon-reporter/DaemonReporter", DaemonReporterService>;
+declare const DaemonReporter_base: Context.TagClass<DaemonReporter, "@systemfsoftware/effect-daemon-spec/daemon-reporter.adapter/DaemonReporter", DaemonReporterService>;
 
 export declare interface DaemonReporterService {
     readonly onRestart: (name: string, cause: Cause.Cause<never>) => Effect.Effect<void>;
@@ -135,13 +134,11 @@ export declare const IntensityConfig: Schema.Struct<{
 
 export declare type IntensityConfig = typeof IntensityConfig.Type;
 
-export declare const IntensityTypeId: unique symbol;
-
-export declare type IntensityTypeId = typeof IntensityTypeId;
+declare const IntensityTypeId: unique symbol;
 
-export declare const isSupervisor: <E, R>(x: Child<E, R>) => x is Supervisor<E, R>;
+declare type IntensityTypeId = typeof IntensityTypeId;
 
-export declare const isWorker: <E, R>(x: Child<E, R>) => x is Worker_2<E, R>;
+export declare const leader: (cap: Duration.DurationInput) => Effect.Effect<SupervisionPolicy>;
 
 export declare class LeaderConfig extends LeaderConfig_base {}
 
@@ -151,7 +148,7 @@ 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>;
+declare const LeaderLock_base: Context.TagClass<LeaderLock, "@systemfsoftware/effect-daemon-spec/leader-lock.adapter/LeaderLock", LeaderLockService>;
 
 export declare type LeaderLockAcquireError = LeaderLockNotAcquired | LeaderLockInfraError;
 
@@ -177,6 +174,7 @@ declare const LeaderLockNotAcquired_base: Schema.TaggedErrorClass<LeaderLockNotA
 export declare interface LeaderLockOptions {
     readonly key: string;
     readonly mode: 'required' | 'optional';
+    readonly acquireRetryBackoff?: Schedule.Schedule<Duration.Duration>;
 }
 
 export declare interface LeaderLockService {
@@ -210,7 +208,7 @@ declare const LockPolicyConfig_base: Schema.Class<LockPolicyConfig, {
 
 export declare class LockPrimitive extends LockPrimitive_base {}
 
-declare const LockPrimitive_base: Context.TagClass<LockPrimitive, "@systemfsoftware/effect-daemon-spec/lock-primitive/LockPrimitive", LockPrimitiveService>;
+declare const LockPrimitive_base: Context.TagClass<LockPrimitive, "@systemfsoftware/effect-daemon-spec/leader-lock.adapter/LockPrimitive", LockPrimitiveService>;
 
 export declare class LockPrimitiveError extends LockPrimitiveError_base {}
 
@@ -227,6 +225,8 @@ export declare interface LockPrimitiveService {
 
 export declare type LoopShape<E, R> = PollLoop<E, R> | StreamLoop<E, R> | SubscriptionLoop<E, R>;
 
+export declare const Noop: Layer.Layer<DaemonReporter>;
+
 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>;
@@ -257,9 +257,14 @@ export declare interface ReporterPolicyHooks {
 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>;
+    readonly worker: {
+        <E, R>(w: Worker_2<E, R, {
+            mode: "none";
+        }>): Effect.Effect<DaemonHealth, never, R | Scope_2>;
+        <E, R>(w: Worker_2<E, R, LockConfig>): Effect.Effect<DaemonHealth, never, R | WithLeaderLockExecutorDeps | Scope_2>;
+    };
+    readonly supervisor: <E, R>(s: Supervisor<E, R, LockConfig>) => Effect.Effect<SupervisorHealth, never, R | SupervisorBodyExecutorDeps | WithLeaderLockExecutorDeps | Scope_2>;
+    readonly dynamic: <E, R, Args>(spec: DynamicSpec<E, R, Args>) => Effect.Effect<DynamicHandle<Args, R | WithLeaderLockExecutorDeps | SupervisorBodyExecutorDeps | Scope_2>, never, R | WithLeaderLockExecutorDeps | SupervisorBodyExecutorDeps | Scope_2>;
 };
 
 export declare const stream: <A, E, R, L extends LockConfig>(opts: CommonOpts<L> & {
@@ -284,9 +289,11 @@ 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>;
+    readonly custom: <P>(policy: P) => Effect.Effect<P>;
 };
 
+export declare const supervision: (cap: Duration.DurationInput) => Effect.Effect<SupervisionPolicy>;
+
 export declare interface SupervisionConfig {
     readonly backoffBase: Duration.DurationInput;
     readonly intensity: Intensity;
@@ -309,11 +316,16 @@ export declare interface Supervisor<E, R, L extends LockConfig = LockConfig> {
     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 const supervisor: <E, R>(s: Supervisor<E, R, LockConfig>) => Effect.Effect<SupervisorHealth, never, R | SupervisorBodyExecutorDeps | WithLeaderLockExecutorDeps | Scope.Scope>;
+
+export declare class SupervisorBodyExecutorDeps extends SupervisorBodyExecutorDeps_base {}
+
+declare const SupervisorBodyExecutorDeps_base: Context.TagClass<SupervisorBodyExecutorDeps, "SupervisorBodyExecutorDeps", {
+    readonly onRestart: DaemonReporter["Type"]["onRestart"];
+    readonly onExhausted: DaemonReporter["Type"]["onExhausted"];
+}>;
 
-export declare function supervisor<E, R>(s: Supervisor<E, R, LockConfig>): Effect.Effect<SupervisorHealth, never, R | LeaderLock | DaemonReporter | Scope.Scope>;
+export declare const SupervisorBodyExecutorLive: Layer.Layer<SupervisorBodyExecutorDeps, never, DaemonReporter>;
 
 export declare const supervisorChildrenGauge: Metric.Metric.Gauge<number>;
 
@@ -341,6 +353,8 @@ export declare const SupervisorTypeId: unique symbol;
 
 export declare type SupervisorTypeId = typeof SupervisorTypeId;
 
+export declare const task: (budget: Duration.DurationInput) => Effect.Effect<SupervisionPolicy>;
+
 export declare class TaskConfig extends TaskConfig_base {}
 
 declare const TaskConfig_base: Context.ReferenceClass<TaskConfig, "@systemfsoftware/effect-daemon-spec/TaskConfig", SupervisionConfig>;
@@ -377,16 +391,22 @@ declare const UnboundedIntensity_base: Schema.TaggedClass<UnboundedIntensity, "U
     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 withLeaderLock<A, E, R>(self: Effect.Effect<A, E, R>, options: LeaderLockOptions): Effect.Effect<A | void, E | LeaderLockAcquireError, R | WithLeaderLockExecutorDeps>;
 
-export declare function worker<E, R>(w: Worker_2<E, R, {
-    mode: 'none';
-}>): Effect.Effect<DaemonHealth, never, R | DaemonReporter | Scope.Scope>;
+export declare class WithLeaderLockExecutorDeps extends WithLeaderLockExecutorDeps_base {}
 
-export declare function worker<E, R>(w: Worker_2<E, R, LockConfig>): Effect.Effect<DaemonHealth, never, R | LeaderLock | DaemonReporter | Scope.Scope>;
+declare const WithLeaderLockExecutorDeps_base: Context.TagClass<WithLeaderLockExecutorDeps, "WithLeaderLockExecutorDeps", {
+    readonly withLock: LeaderLock["Type"]["withLock"];
+}>;
+
+export declare const WithLeaderLockExecutorLive: Layer.Layer<WithLeaderLockExecutorDeps, never, LeaderLock>;
+
+export declare const worker: {
+    <E, R>(w: Worker_2<E, R, {
+        mode: 'none';
+    }>): Effect.Effect<DaemonHealth, never, R | Scope.Scope>;
+    <E, R>(w: Worker_2<E, R, LockConfig>): Effect.Effect<DaemonHealth, never, R | WithLeaderLockExecutorDeps | Scope.Scope>;
+};
 
 declare interface Worker_2<E, R, L extends LockConfig = LockConfig> {
     readonly [WorkerTypeId]: WorkerTypeId;

package/dist/index.d.ts

@@ -1,7 +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
 //#region src/daemon-health.schema.d.ts
 declare const DynamicLimitExceeded_base: Schema.TaggedErrorClass<DynamicLimitExceeded, "DynamicLimitExceeded", {
   readonly _tag: Schema.tag<"DynamicLimitExceeded">;
@@ -9,8 +6,6 @@ declare const DynamicLimitExceeded_base: Schema.TaggedErrorClass<DynamicLimitExc
   limit: Schema.filter<typeof Schema.Int>;
 }>;
 declare class DynamicLimitExceeded extends DynamicLimitExceeded_base {}
-//#endregion
-//#region src/daemon-health.d.ts
 interface DaemonHealth {
   readonly name: string;
   readonly ready: Effect.Latch;
@@ -35,7 +30,18 @@ type ChildRef = {
   readonly removed: Effect.Effect<void>;
 };
 //#endregion
-//#region src/daemon-metrics.d.ts
+//#region src/backoff.kernel.d.ts
+declare const cappedBackoff: (base: Duration.DurationInput, cap: Duration.DurationInput) => Schedule.Schedule<Duration.Duration>;
+//#endregion
+//#region src/brands.kernel.d.ts
+declare const WorkerTypeId: unique symbol;
+type WorkerTypeId = typeof WorkerTypeId;
+declare const SupervisorTypeId: unique symbol;
+type SupervisorTypeId = typeof SupervisorTypeId;
+declare const DynamicSpecTypeId: unique symbol;
+type DynamicSpecTypeId = typeof DynamicSpecTypeId;
+//#endregion
+//#region src/daemon-metrics.kernel.d.ts
 declare const supervisorRestartsCounter: Metric.Metric.Counter<number>;
 declare const supervisorExhaustionsCounter: Metric.Metric.Counter<number>;
 declare const supervisorChildrenGauge: Metric.Metric.Gauge<number>;
@@ -116,47 +122,16 @@ declare const TickPolicyConfig_base: Schema.Class<TickPolicyConfig, {
 }, {}, {}>;
 declare class TickPolicyConfig extends TickPolicyConfig_base {}
 //#endregion
-//#region src/daemon-reporter.d.ts
+//#region src/daemon-reporter.adapter.d.ts
 interface DaemonReporterService {
   readonly onRestart: (name: string, cause: Cause.Cause<never>) => Effect.Effect<void>;
   readonly onExhausted: (name: string, cause: Cause.Cause<never>) => Effect.Effect<void>;
 }
-declare const DaemonReporter_base: Context.TagClass<DaemonReporter, "@systemfsoftware/effect-daemon-spec/daemon-reporter/DaemonReporter", DaemonReporterService>;
-declare class DaemonReporter extends DaemonReporter_base {
-  static readonly Noop: Layer.Layer<DaemonReporter>;
-}
-//#endregion
-//#region src/supervision-preset.d.ts
-interface SupervisionPolicy {
-  readonly intensity: Intensity;
-  readonly backoff: Schedule.Schedule<Duration.Duration>;
-  readonly cooldown: Duration.DurationInput;
-}
-interface SupervisionConfig {
-  readonly backoffBase: Duration.DurationInput;
-  readonly intensity: Intensity;
-  readonly cooldown: Duration.DurationInput;
-}
-declare const LeaderConfig_base: Context.ReferenceClass<LeaderConfig, "@systemfsoftware/effect-daemon-spec/LeaderConfig", SupervisionConfig>;
-declare class LeaderConfig extends LeaderConfig_base {}
-declare const WorkerConfig_base: Context.ReferenceClass<WorkerConfig, "@systemfsoftware/effect-daemon-spec/WorkerConfig", SupervisionConfig>;
-declare class WorkerConfig extends WorkerConfig_base {}
-declare const TaskConfig_base: Context.ReferenceClass<TaskConfig, "@systemfsoftware/effect-daemon-spec/TaskConfig", SupervisionConfig>;
-declare class TaskConfig extends TaskConfig_base {}
-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>;
-};
+declare const DaemonReporter_base: Context.TagClass<DaemonReporter, "@systemfsoftware/effect-daemon-spec/daemon-reporter.adapter/DaemonReporter", DaemonReporterService>;
+declare class DaemonReporter extends DaemonReporter_base {}
+declare const Noop: Layer.Layer<DaemonReporter>;
 //#endregion
-//#region src/daemon-spec.d.ts
-declare const WorkerTypeId: unique symbol;
-type WorkerTypeId = typeof WorkerTypeId;
-declare const SupervisorTypeId: unique symbol;
-type SupervisorTypeId = typeof SupervisorTypeId;
-declare const DynamicSpecTypeId: unique symbol;
-type DynamicSpecTypeId = typeof DynamicSpecTypeId;
+//#region src/daemon-spec.schema.d.ts
 type LockConfig = {
   mode: 'none';
 } | {
@@ -167,6 +142,22 @@ type LockConfig = {
   key: string;
   acquireRetryBackoff: Schedule.Schedule<Duration.Duration>;
 };
+interface CommonOpts<L extends LockConfig> {
+  readonly name: string;
+  readonly child?: typeof ChildPolicyConfig.Type;
+  readonly tick: typeof TickPolicyConfig.Type;
+  readonly tickHooks?: TickPolicyHooks;
+  readonly lock: L;
+}
+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.Option<A>, E, R>;
+  readonly work: (data: A) => Effect.Effect<void, E, R>;
+});
 interface TickPolicyHooks {
   readonly spanAttributes?: Effect.Effect<Record<string, string | number | boolean>>;
   readonly innerRetry?: Schedule.Schedule<unknown>;
@@ -215,42 +206,23 @@ interface DynamicSpec<E, R, Args> {
   readonly maxChildren: number;
 }
 type Child<E, R> = Worker<E, R> | Supervisor<E, R>;
-declare const isWorker: <E, R>(x: Child<E, R>) => x is Worker<E, R>;
-declare const isSupervisor: <E, R>(x: Child<E, R>) => x is Supervisor<E, R>;
-//#endregion
-//#region src/daemon.d.ts
-interface CommonOpts<L extends LockConfig> {
+interface SupervisionPolicy {
+  readonly intensity: Intensity;
+  readonly backoff: Schedule.Schedule<Duration.Duration>;
+  readonly cooldown: Duration.DurationInput;
+}
+interface SupervisionConfig {
+  readonly backoffBase: Duration.DurationInput;
+  readonly intensity: Intensity;
+  readonly cooldown: Duration.DurationInput;
+}
+interface SupervisorOpts<E, R, L extends LockConfig> {
   readonly name: string;
-  readonly child?: typeof ChildPolicyConfig.Type;
-  readonly tick: typeof TickPolicyConfig.Type;
-  readonly tickHooks?: TickPolicyHooks;
+  readonly children: ReadonlyArray<Child<E, R>>;
+  readonly supervision: Effect.Effect<SupervisionPolicy>;
   readonly lock: L;
+  readonly reporter?: ReporterPolicyHooks;
 }
-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.Option<A>, E, R>;
-  readonly work: (data: A) => Effect.Effect<void, E, R>;
-});
-declare const poll: <A, E, R, L extends LockConfig>(opts: PollOpts<A, E, R, L>) => Worker<E, R, L>;
-declare const stream: <A, E, R, L extends LockConfig>(opts: CommonOpts<L> & {
-  readonly stream: Stream.Stream<A, E, R>;
-}) => Worker<E, R, L>;
-declare const subscription: <A, E, R, L extends LockConfig>(opts: CommonOpts<L> & {
-  readonly acquire: Effect.Effect<A, E, R>;
-}) => Worker<E, R, L>;
-declare const Daemon: {
-  readonly poll: <A, E, R, L extends LockConfig>(opts: PollOpts<A, E, R, L>) => Worker<E, R, L>;
-  readonly stream: <A, E, R, L extends LockConfig>(opts: CommonOpts<L> & {
-    readonly stream: Stream.Stream<A, E, R>;
-  }) => Worker<E, R, L>;
-  readonly subscription: <A, E, R, L extends LockConfig>(opts: CommonOpts<L> & {
-    readonly acquire: Effect.Effect<A, E, R>;
-  }) => Worker<E, R, L>;
-};
 //#endregion
 //#region src/leader-lock.schema.d.ts
 declare const LeaderLockNotAcquired_base: Schema.TaggedErrorClass<LeaderLockNotAcquired, "LeaderLockNotAcquired", {
@@ -268,23 +240,6 @@ declare const LeaderLockInfraError_base: Schema.TaggedErrorClass<LeaderLockInfra
 declare class LeaderLockInfraError extends LeaderLockInfraError_base {}
 type LeaderLockAcquireError = LeaderLockNotAcquired | LeaderLockInfraError;
 //#endregion
-//#region src/leader-lock.d.ts
-interface LeaderLockService {
-  readonly withLock: <A, E, R>(key: string, self: Effect.Effect<A, E, R>) => Effect.Effect<Option.Option<A>, E | LeaderLockInfraError, R>;
-}
-declare const LeaderLock_base: Context.TagClass<LeaderLock, "@systemfsoftware/effect-daemon-spec/leader-lock/LeaderLock", LeaderLockService>;
-declare class LeaderLock extends LeaderLock_base {
-  static readonly Noop: Layer.Layer<LeaderLock>;
-}
-interface LeaderLockOptions {
-  readonly key: string;
-  readonly mode: 'required' | 'optional';
-}
-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>;
-};
-//#endregion
 //#region src/lock-primitive.schema.d.ts
 declare const LockPrimitiveError_base: Schema.TaggedErrorClass<LockPrimitiveError, "LockPrimitiveError", {
   readonly _tag: Schema.tag<"LockPrimitiveError">;
@@ -294,44 +249,106 @@ declare const LockPrimitiveError_base: Schema.TaggedErrorClass<LockPrimitiveErro
 }>;
 declare class LockPrimitiveError extends LockPrimitiveError_base {}
 //#endregion
-//#region src/lock-primitive.d.ts
+//#region src/leader-lock.adapter.d.ts
+interface LeaderLockService {
+  readonly withLock: <A, E, R>(key: string, self: Effect.Effect<A, E, R>) => Effect.Effect<Option.Option<A>, E | LeaderLockInfraError, R>;
+}
+declare const LeaderLock_base: Context.TagClass<LeaderLock, "@systemfsoftware/effect-daemon-spec/leader-lock.adapter/LeaderLock", LeaderLockService>;
+declare class LeaderLock extends LeaderLock_base {
+  static readonly Noop: Layer.Layer<LeaderLock>;
+}
 interface LockPrimitiveService {
   readonly tryAcquire: (key: string) => Effect.Effect<boolean, LockPrimitiveError, Scope.Scope>;
 }
-declare const LockPrimitive_base: Context.TagClass<LockPrimitive, "@systemfsoftware/effect-daemon-spec/lock-primitive/LockPrimitive", LockPrimitiveService>;
+declare const LockPrimitive_base: Context.TagClass<LockPrimitive, "@systemfsoftware/effect-daemon-spec/leader-lock.adapter/LockPrimitive", LockPrimitiveService>;
 declare class LockPrimitive extends LockPrimitive_base {}
 declare const LeaderLockFromPrimitive: Layer.Layer<LeaderLock, never, LockPrimitive>;
 //#endregion
-//#region src/run.d.ts
-declare function worker<E, R>(w: Worker<E, R, {
-  mode: 'none';
-}>): Effect.Effect<DaemonHealth, never, R | DaemonReporter | Scope.Scope>;
-declare function worker<E, R>(w: Worker<E, R, LockConfig>): Effect.Effect<DaemonHealth, never, R | LeaderLock | DaemonReporter | Scope.Scope>;
-declare function supervisor<E, R>(s: Supervisor<E, R, {
-  mode: 'none';
-}>): Effect.Effect<SupervisorHealth, never, R | DaemonReporter | Scope.Scope>;
-declare function supervisor<E, R>(s: Supervisor<E, R, LockConfig>): Effect.Effect<SupervisorHealth, never, R | LeaderLock | DaemonReporter | Scope.Scope>;
-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>;
+//#region src/internal/with-leader-lock.executor.d.ts
+interface LeaderLockOptions {
+  readonly key: string;
+  readonly mode: 'required' | 'optional';
+  readonly acquireRetryBackoff?: Schedule.Schedule<Duration.Duration>;
+}
+declare const WithLeaderLockExecutorDeps_base: Context.TagClass<WithLeaderLockExecutorDeps, "WithLeaderLockExecutorDeps", {
+  readonly withLock: LeaderLock["Type"]["withLock"];
+}>;
+declare class WithLeaderLockExecutorDeps extends WithLeaderLockExecutorDeps_base {}
+declare function withLeaderLock<A, E, R>(self: Effect.Effect<A, E, R>, options: LeaderLockOptions): Effect.Effect<A | void, E | LeaderLockAcquireError, R | WithLeaderLockExecutorDeps>;
+//#endregion
+//#region src/daemon-worker.executor.d.ts
+declare const worker: {
+  <E, R>(w: Worker<E, R, {
+    mode: 'none';
+  }>): Effect.Effect<DaemonHealth, never, R | Scope.Scope>;
+  <E, R>(w: Worker<E, R, LockConfig>): Effect.Effect<DaemonHealth, never, R | WithLeaderLockExecutorDeps | Scope.Scope>;
 };
 //#endregion
-//#region src/supervisor.d.ts
-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;
-}
-declare const oneForOne: <E, R, L extends LockConfig = LockConfig>(opts: SupervisorOpts<E, R, L>) => Supervisor<E, R, L>;
-declare const oneForAll: <E, R, L extends LockConfig = LockConfig>(opts: SupervisorOpts<E, R, L>) => Supervisor<E, R, L>;
-declare const restForOne: <E, R, L extends LockConfig = LockConfig>(opts: SupervisorOpts<E, R, L>) => Supervisor<E, R, L>;
+//#region src/internal/supervisor-body.executor.d.ts
+declare const SupervisorBodyExecutorDeps_base: Context.TagClass<SupervisorBodyExecutorDeps, "SupervisorBodyExecutorDeps", {
+  readonly onRestart: DaemonReporter["Type"]["onRestart"];
+  readonly onExhausted: DaemonReporter["Type"]["onExhausted"];
+}>;
+declare class SupervisorBodyExecutorDeps extends SupervisorBodyExecutorDeps_base {}
+declare const supervisor: <E, R>(s: Supervisor<E, R, LockConfig>) => Effect.Effect<SupervisorHealth, never, R | SupervisorBodyExecutorDeps | WithLeaderLockExecutorDeps | Scope.Scope>;
+//#endregion
+//#region src/internal/supervision-leader.state.d.ts
+declare const LeaderConfig_base: Context.ReferenceClass<LeaderConfig, "@systemfsoftware/effect-daemon-spec/LeaderConfig", SupervisionConfig>;
+declare class LeaderConfig extends LeaderConfig_base {}
+//#endregion
+//#region src/internal/supervision-task.state.d.ts
+declare const TaskConfig_base: Context.ReferenceClass<TaskConfig, "@systemfsoftware/effect-daemon-spec/TaskConfig", SupervisionConfig>;
+declare class TaskConfig extends TaskConfig_base {}
+//#endregion
+//#region src/internal/supervision-worker.state.d.ts
+declare const WorkerConfig_base: Context.ReferenceClass<WorkerConfig, "@systemfsoftware/effect-daemon-spec/WorkerConfig", SupervisionConfig>;
+declare class WorkerConfig extends WorkerConfig_base {}
+//#endregion
+//#region src/mod.d.ts
+declare const poll: <A, E, R, L extends LockConfig>(opts: PollOpts<A, E, R, L>) => Worker<E, R, L>;
+declare const stream: <A, E, R, L extends LockConfig>(opts: CommonOpts<L> & {
+  readonly stream: Stream.Stream<A, E, R>;
+}) => Worker<E, R, L>;
+declare const subscription: <A, E, R, L extends LockConfig>(opts: CommonOpts<L> & {
+  readonly acquire: Effect.Effect<A, E, R>;
+}) => Worker<E, R, L>;
+declare const Daemon: {
+  readonly poll: <A, E, R, L extends LockConfig>(opts: PollOpts<A, E, R, L>) => Worker<E, R, L>;
+  readonly stream: <A, E, R, L extends LockConfig>(opts: CommonOpts<L> & {
+    readonly stream: Stream.Stream<A, E, R>;
+  }) => Worker<E, R, L>;
+  readonly subscription: <A, E, R, L extends LockConfig>(opts: CommonOpts<L> & {
+    readonly acquire: Effect.Effect<A, E, R>;
+  }) => Worker<E, R, L>;
+};
+declare const run: {
+  readonly worker: {
+    <E, R>(w: Worker<E, R, {
+      mode: "none";
+    }>): Effect.Effect<DaemonHealth, never, R | import("effect/Scope").Scope>;
+    <E, R>(w: Worker<E, R, LockConfig>): Effect.Effect<DaemonHealth, never, R | WithLeaderLockExecutorDeps | import("effect/Scope").Scope>;
+  };
+  readonly supervisor: <E, R>(s: Supervisor<E, R, LockConfig>) => Effect.Effect<SupervisorHealth, never, R | SupervisorBodyExecutorDeps | WithLeaderLockExecutorDeps | import("effect/Scope").Scope>;
+  readonly dynamic: <E, R, Args>(spec: DynamicSpec<E, R, Args>) => Effect.Effect<DynamicHandle<Args, R | WithLeaderLockExecutorDeps | SupervisorBodyExecutorDeps | import("effect/Scope").Scope>, never, R | WithLeaderLockExecutorDeps | SupervisorBodyExecutorDeps | import("effect/Scope").Scope>;
+};
+declare const leader: (cap: Duration.DurationInput) => Effect.Effect<SupervisionPolicy>;
+declare const task: (budget: Duration.DurationInput) => Effect.Effect<SupervisionPolicy>;
+declare const supervision: (cap: Duration.DurationInput) => Effect.Effect<SupervisionPolicy>;
+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: <P>(policy: P) => Effect.Effect<P>;
+};
 declare const dynamic: <E, R, Args>(opts: {
   readonly name: string;
   readonly child: (args: Args) => Worker<E, R>;
   readonly maxChildren?: number;
 }) => DynamicSpec<E, R, Args>;
+declare const oneForAll: <E, R, L extends LockConfig = LockConfig>(opts: SupervisorOpts<E, R, L>) => Supervisor<E, R, L>;
+declare const oneForOne: <E, R, L extends LockConfig = LockConfig>(opts: SupervisorOpts<E, R, L>) => Supervisor<E, R, L>;
+declare const restForOne: <E, R, L extends LockConfig = LockConfig>(opts: SupervisorOpts<E, R, L>) => Supervisor<E, R, L>;
+declare const WithLeaderLockExecutorLive: Layer.Layer<WithLeaderLockExecutorDeps, never, LeaderLock>;
+declare const SupervisorBodyExecutorLive: Layer.Layer<SupervisorBodyExecutorDeps, never, DaemonReporter>;
 //#endregion
-export { BoundedIntensity, Child, ChildPolicyConfig, ChildRef, CommonOpts, Daemon, DaemonHealth, DaemonReporter, DaemonReporterService, DynamicHandle, DynamicLimitExceeded, DynamicSpec, DynamicSpecTypeId, Intensity, IntensityConfig, IntensityTypeId, LeaderConfig, LeaderLock, type LeaderLockAcquireError, LeaderLockFromPrimitive, LeaderLockInfraError, LeaderLockNotAcquired, LeaderLockOptions, LeaderLockService, LockConfig, LockPolicyConfig, LockPrimitive, LockPrimitiveError, LockPrimitiveService, LoopShape, PollLoop, PollOpts, ReporterPolicyHooks, StreamLoop, SubscriptionLoop, Supervision, SupervisionConfig, SupervisionPolicy, Supervisor, SupervisorHealth, type SupervisorOpts, SupervisorTypeId, TaskConfig, TickPolicyConfig, TickPolicyHooks, UnboundedIntensity, Worker, WorkerConfig, WorkerTypeId, cappedBackoff, dynamic, healthStateGauge, isSupervisor, isWorker, oneForAll, oneForOne, poll, restForOne, run, stream, subscription, supervisor, supervisorChildrenGauge, supervisorExhaustionsCounter, supervisorRestartsCounter, withLeaderLock, worker };
+export { BoundedIntensity, Child, ChildPolicyConfig, ChildRef, CommonOpts, Daemon, DaemonHealth, DaemonReporter, DaemonReporterService, DynamicHandle, DynamicLimitExceeded, DynamicSpec, DynamicSpecTypeId, Intensity, IntensityConfig, LeaderConfig, LeaderLock, LeaderLockAcquireError, LeaderLockFromPrimitive, LeaderLockInfraError, LeaderLockNotAcquired, type LeaderLockOptions, LeaderLockService, LockConfig, LockPolicyConfig, LockPrimitive, LockPrimitiveError, LockPrimitiveService, LoopShape, Noop, PollLoop, PollOpts, ReporterPolicyHooks, StreamLoop, SubscriptionLoop, Supervision, SupervisionConfig, SupervisionPolicy, Supervisor, SupervisorBodyExecutorDeps, SupervisorBodyExecutorLive, SupervisorHealth, SupervisorOpts, SupervisorTypeId, TaskConfig, TickPolicyConfig, TickPolicyHooks, UnboundedIntensity, WithLeaderLockExecutorDeps, WithLeaderLockExecutorLive, Worker, WorkerConfig, WorkerTypeId, cappedBackoff, dynamic, healthStateGauge, leader, oneForAll, oneForOne, poll, restForOne, run, stream, subscription, supervision, supervisor, supervisorChildrenGauge, supervisorExhaustionsCounter, supervisorRestartsCounter, task, withLeaderLock, worker };