@systemfsoftware/effect-daemon-spec 0.7.2 → 2.0.0

package/dist/index.d.ts

@@ -1,23 +1,32 @@
-import { Cause, Context, Duration, Effect, Layer, Metric, Option, Schedule, Schema, Scope, Stream } from "effect";
-//#region src/daemon-health.schema.d.ts
-declare const DynamicLimitExceeded_base: Schema.TaggedErrorClass<DynamicLimitExceeded, "DynamicLimitExceeded", {
-  readonly _tag: Schema.tag<"DynamicLimitExceeded">;
-} & {
-  limit: Schema.filter<typeof Schema.Int>;
-}>;
+import { Cause, Context, Duration, Effect, Latch, Layer, Metric, Option, Schedule, Schema, Scope, Stream } from "effect";
+//#region src/Backoff.d.ts
+declare const cappedBackoff: (base: Duration.Input, cap: Duration.Input) => Schedule.Schedule<Duration.Duration>;
+//#endregion
+//#region src/Brands.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/DaemonHealth.schema.d.ts
+declare const DynamicLimitExceeded_base: Schema.Class<DynamicLimitExceeded, Schema.TaggedStruct<"DynamicLimitExceeded", {
+  readonly limit: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
 declare class DynamicLimitExceeded extends DynamicLimitExceeded_base {}
 interface DaemonHealth {
   readonly name: string;
-  readonly ready: Effect.Latch;
-  readonly healthy: Effect.Latch;
-  readonly paused: Effect.Latch;
+  readonly ready: Latch.Latch;
+  readonly healthy: Latch.Latch;
+  readonly paused: Latch.Latch;
 }
 interface SupervisorHealth {
   readonly name: string;
-  readonly ready: Effect.Latch;
-  readonly healthy: Effect.Latch;
-  readonly paused: Effect.Latch;
-  readonly children: ReadonlyArray<DaemonHealth | SupervisorHealth>;
+  readonly ready: Latch.Latch;
+  readonly healthy: Latch.Latch;
+  readonly paused: Latch.Latch;
+  readonly children: readonly (DaemonHealth | SupervisorHealth)[];
 }
 interface DynamicHandle<Args, R = never> {
   readonly health: SupervisorHealth;
@@ -30,108 +39,65 @@ type ChildRef = {
   readonly removed: Effect.Effect<void>;
 };
 //#endregion
-//#region src/backoff.kernel.d.ts
-declare const cappedBackoff: (base: Duration.DurationInput, cap: Duration.DurationInput) => Schedule.Schedule<Duration.Duration>;
+//#region src/DaemonMetrics.d.ts
+declare const supervisorRestartsCounter: Metric.Counter<number>;
+declare const supervisorExhaustionsCounter: Metric.Counter<number>;
+declare const supervisorChildrenGauge: Metric.Gauge<number>;
+declare const healthStateGauge: Metric.Gauge<number>;
 //#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>;
-declare const healthStateGauge: Metric.Metric.Gauge<number>;
-//#endregion
-//#region src/daemon-policy.schema.d.ts
+//#region src/DaemonPolicy.schema.d.ts
 declare const IntensityConfig: Schema.Struct<{
-  restarts: Schema.filter<typeof Schema.Int>;
-  window: typeof Schema.DurationFromSelf;
+  readonly restarts: Schema.Int;
+  readonly window: Schema.Duration;
 }>;
 type IntensityConfig = typeof IntensityConfig.Type;
 declare const IntensityTypeId: unique symbol;
 type IntensityTypeId = typeof IntensityTypeId;
-declare const BoundedIntensity_base: Schema.TaggedClass<BoundedIntensity, "Bounded", {
-  readonly _tag: Schema.tag<"Bounded">;
-} & Readonly<{
-  restarts: Schema.filter<typeof Schema.Int>;
-  window: typeof Schema.DurationFromSelf;
-}>>;
+declare const BoundedIntensity_base: Schema.Class<BoundedIntensity, Schema.TaggedStruct<"Bounded", {
+  readonly restarts: Schema.Int;
+  readonly window: Schema.Duration;
+}>, {}>;
 declare class BoundedIntensity extends BoundedIntensity_base {
   readonly [IntensityTypeId]: symbol;
 }
-declare const UnboundedIntensity_base: Schema.TaggedClass<UnboundedIntensity, "Unbounded", {
-  readonly _tag: Schema.tag<"Unbounded">;
-}>;
+declare const UnboundedIntensity_base: Schema.Class<UnboundedIntensity, Schema.TaggedStruct<"Unbounded", {}>, {}>;
 declare class UnboundedIntensity extends UnboundedIntensity_base {
   readonly [IntensityTypeId]: symbol;
 }
-declare const Intensity: Schema.Union<[typeof BoundedIntensity, typeof UnboundedIntensity]>;
+declare const Intensity: Schema.Union<readonly [typeof BoundedIntensity, typeof UnboundedIntensity]>;
 type Intensity = typeof Intensity.Type;
-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;
+declare const ChildPolicyConfig_base: Schema.Class<ChildPolicyConfig, Schema.Struct<{
+  readonly restart: Schema.optional<Schema.Literals<readonly ["permanent", "transient", "temporary"]>>;
+  readonly intensity: Schema.optional<Schema.Struct<{
+    readonly restarts: Schema.Int;
+    readonly window: Schema.Duration;
   }>>;
-}, 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 restart?: "permanent" | "transient" | "temporary" | undefined;
-} & {
-  readonly intensity?: {
-    readonly restarts: number;
-    readonly window: import("effect/Duration").Duration;
-  } | undefined;
-}, {}, {}>;
+}>, {}>;
 declare class ChildPolicyConfig extends ChildPolicyConfig_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 mode?: "none" | "required" | "optional" | undefined;
-} & {
-  readonly key?: string | undefined;
-}, {}, {}>;
+declare const LockPolicyConfig_base: Schema.Class<LockPolicyConfig, Schema.Struct<{
+  readonly mode: Schema.optional<Schema.Literals<readonly ["none", "required", "optional"]>>;
+  readonly key: Schema.optional<Schema.String>;
+}>, {}>;
 declare class LockPolicyConfig extends LockPolicyConfig_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 tickTimeout: import("effect/Duration").Duration;
-} & {
-  readonly spanName?: string | undefined;
-} & {
-  readonly startLogLevel?: "debug" | "info" | undefined;
-}, {}, {}>;
+declare const TickPolicyConfig_base: Schema.Class<TickPolicyConfig, Schema.Struct<{
+  readonly spanName: Schema.optional<Schema.String>;
+  readonly tickTimeout: Schema.Duration;
+  readonly startLogLevel: Schema.optional<Schema.Literals<readonly ["debug", "info"]>>;
+}>, {}>;
 declare class TickPolicyConfig extends TickPolicyConfig_base {}
+declare const MaxChildren: Schema.brand<Schema.Int, "MaxChildren">;
+type MaxChildren = typeof MaxChildren.Type;
 //#endregion
-//#region src/daemon-reporter.adapter.d.ts
+//#region src/DaemonReporterAdapter.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.adapter/DaemonReporter", DaemonReporterService>;
+declare const DaemonReporter_base: Context.ServiceClass<DaemonReporter, "@systemfsoftware/effect-daemon-spec/DaemonReporterAdapter/DaemonReporter", DaemonReporterService>;
 declare class DaemonReporter extends DaemonReporter_base {}
 declare const Noop: Layer.Layer<DaemonReporter>;
 //#endregion
-//#region src/daemon-spec.schema.d.ts
+//#region src/DaemonSpec.schema.d.ts
 type LockConfig = {
   mode: 'none';
 } | {
@@ -150,7 +116,7 @@ interface CommonOpts<L extends LockConfig> {
   readonly lock: L;
 }
 type PollOpts<A, E, R, L extends LockConfig> = CommonOpts<L> & {
-  readonly interval: Duration.DurationInput;
+  readonly interval: Duration.Input;
 } & ({
   readonly prereq?: undefined;
   readonly work: Effect.Effect<A, E, R>;
@@ -161,7 +127,7 @@ type PollOpts<A, E, R, L extends LockConfig> = CommonOpts<L> & {
 interface TickPolicyHooks {
   readonly spanAttributes?: Effect.Effect<Record<string, string | number | boolean>>;
   readonly innerRetry?: Schedule.Schedule<unknown>;
-  readonly trackDuration?: Metric.Metric.Histogram<Duration.Duration>;
+  readonly trackDuration?: Metric.Histogram<Duration.Duration>;
 }
 interface ReporterPolicyHooks {
   readonly onRestart?: (cause: Cause.Cause<never>) => Effect.Effect<void>;
@@ -170,7 +136,7 @@ interface ReporterPolicyHooks {
 type PollLoop<E, R> = {
   readonly _tag: 'Poll';
   readonly gate: Effect.Effect<Option.Option<Effect.Effect<void, E, R>>, E, R>;
-  readonly interval: Duration.DurationInput;
+  readonly interval: Duration.Input;
 };
 type StreamLoop<E, R> = {
   readonly _tag: 'Stream';
@@ -194,7 +160,7 @@ 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<E, R> | Supervisor<E, R>>;
+  readonly children: readonly (Worker<E, R> | Supervisor<E, R>)[];
   readonly supervision: Effect.Effect<SupervisionPolicy>;
   readonly lock: L;
   readonly reporter: ReporterPolicyHooks;
@@ -203,106 +169,83 @@ interface DynamicSpec<E, R, Args> {
   readonly [DynamicSpecTypeId]: DynamicSpecTypeId;
   readonly name: string;
   readonly child: (args: Args) => Worker<E, R>;
-  readonly maxChildren: number;
+  readonly maxChildren: MaxChildren;
 }
 type Child<E, R> = Worker<E, R> | Supervisor<E, R>;
 interface SupervisionPolicy {
   readonly intensity: Intensity;
   readonly backoff: Schedule.Schedule<Duration.Duration>;
-  readonly cooldown: Duration.DurationInput;
+  readonly cooldown: Duration.Input;
 }
 interface SupervisionConfig {
-  readonly backoffBase: Duration.DurationInput;
+  readonly backoffBase: Duration.Input;
   readonly intensity: Intensity;
-  readonly cooldown: Duration.DurationInput;
+  readonly cooldown: Duration.Input;
 }
 interface SupervisorOpts<E, R, L extends LockConfig> {
   readonly name: string;
-  readonly children: ReadonlyArray<Child<E, R>>;
+  readonly children: readonly Child<E, R>[];
   readonly supervision: Effect.Effect<SupervisionPolicy>;
   readonly lock: L;
   readonly reporter?: ReporterPolicyHooks;
 }
 //#endregion
-//#region src/leader-lock.schema.d.ts
-declare const LeaderLockNotAcquired_base: Schema.TaggedErrorClass<LeaderLockNotAcquired, "LeaderLockNotAcquired", {
-  readonly _tag: Schema.tag<"LeaderLockNotAcquired">;
-} & {
-  key: typeof Schema.String;
-}>;
+//#region src/LeaderLock.schema.d.ts
+declare const LeaderLockNotAcquired_base: Schema.Class<LeaderLockNotAcquired, Schema.TaggedStruct<"LeaderLockNotAcquired", {
+  readonly key: Schema.String;
+}>, import("effect/Cause").YieldableError>;
 declare class LeaderLockNotAcquired extends LeaderLockNotAcquired_base {}
-declare const LeaderLockInfraError_base: Schema.TaggedErrorClass<LeaderLockInfraError, "LeaderLockInfraError", {
-  readonly _tag: Schema.tag<"LeaderLockInfraError">;
-} & {
-  key: typeof Schema.String;
-  cause: typeof Schema.Unknown;
-}>;
+declare const LeaderLockInfraError_base: Schema.Class<LeaderLockInfraError, Schema.TaggedStruct<"LeaderLockInfraError", {
+  readonly key: Schema.String;
+  readonly cause: Schema.Unknown;
+}>, import("effect/Cause").YieldableError>;
 declare class LeaderLockInfraError extends LeaderLockInfraError_base {}
 type LeaderLockAcquireError = LeaderLockNotAcquired | LeaderLockInfraError;
 //#endregion
-//#region src/lock-primitive.schema.d.ts
-declare const LockPrimitiveError_base: Schema.TaggedErrorClass<LockPrimitiveError, "LockPrimitiveError", {
-  readonly _tag: Schema.tag<"LockPrimitiveError">;
-} & {
-  key: typeof Schema.String;
-  cause: typeof Schema.Unknown;
-}>;
+//#region src/LockPrimitive.schema.d.ts
+declare const LockPrimitiveError_base: Schema.Class<LockPrimitiveError, Schema.TaggedStruct<"LockPrimitiveError", {
+  readonly key: Schema.String;
+  readonly cause: Schema.Unknown;
+}>, import("effect/Cause").YieldableError>;
 declare class LockPrimitiveError extends LockPrimitiveError_base {}
 //#endregion
-//#region src/leader-lock.adapter.d.ts
+//#region src/LeaderLockAdapter.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 const LeaderLock_base: Context.ServiceClass<LeaderLock, "@systemfsoftware/effect-daemon-spec/LeaderLockAdapter/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/leader-lock.adapter/LockPrimitive", LockPrimitiveService>;
+declare const LockPrimitive_base: Context.ServiceClass<LockPrimitive, "@systemfsoftware/effect-daemon-spec/LeaderLockAdapter/LockPrimitive", LockPrimitiveService>;
 declare class LockPrimitive extends LockPrimitive_base {}
 declare const LeaderLockFromPrimitive: Layer.Layer<LeaderLock, never, LockPrimitive>;
 //#endregion
-//#region src/internal/with-leader-lock.executor.d.ts
+//#region src/internal/BuildDynamicExecutor.d.ts
+declare const dynamic$1: <E, R, Args>(spec: DynamicSpec<E, R, Args>) => Effect.Effect<DynamicHandle<Args, R | LeaderLock | DaemonReporter | Scope.Scope>, never, R | LeaderLock | DaemonReporter | Scope.Scope>;
+//#endregion
+//#region src/internal/WithLeaderLockExecutor.d.ts
 interface LeaderLockOptions {
   readonly key: string;
   readonly mode: 'required' | 'optional';
   readonly acquireRetryBackoff?: Schedule.Schedule<Duration.Duration>;
 }
-declare const WithLeaderLockExecutorDeps_base: Context.TagClass<WithLeaderLockExecutorDeps, "@systemfsoftware/effect-daemon-spec/internal/with-leader-lock.executor/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>;
-};
+declare function withLeaderLock<A, E, R>(self: Effect.Effect<A, E, R>, options: LeaderLockOptions, lock: LeaderLock['Service']): Effect.Effect<A | void, E | LeaderLockAcquireError, R>;
 //#endregion
-//#region src/internal/supervisor-body.executor.d.ts
-declare const SupervisorBodyExecutorDeps_base: Context.TagClass<SupervisorBodyExecutorDeps, "@systemfsoftware/effect-daemon-spec/internal/supervisor-body.executor/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>;
+//#region src/SupervisionCustom.d.ts
+declare const custom: <P>(policy: P) => Effect.Effect<P>;
 //#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 {}
+//#region src/internal/SupervisionLeader.d.ts
+declare const LeaderConfig: Context.Reference<SupervisionConfig>;
 //#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 {}
+//#region src/internal/SupervisionTask.d.ts
+declare const TaskConfig: Context.Reference<SupervisionConfig>;
 //#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 {}
+//#region src/internal/SupervisionWorker.d.ts
+declare const WorkerConfig: Context.Reference<SupervisionConfig>;
 //#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>;
@@ -313,42 +256,55 @@ 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>;
+  readonly poll: typeof poll;
+  readonly stream: typeof stream;
+  readonly subscription: typeof 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.
+ */
+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 | LeaderLock | Scope.Scope>;
 };
+/**
+ * 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.
+ */
+declare const supervisor: <E, R>(s: Supervisor<E, R, LockConfig>) => Effect.Effect<SupervisorHealth, never, R | DaemonReporter | LeaderLock | Scope.Scope>;
 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>;
+      mode: 'none';
+    }>): Effect.Effect<DaemonHealth, never, R | Scope.Scope>;
+    <E, R>(w: Worker<E, R, LockConfig>): Effect.Effect<DaemonHealth, never, R | LeaderLock | 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>;
+  readonly supervisor: typeof supervisor;
+  readonly dynamic: typeof dynamic$1;
 };
-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 leader: (cap: Duration.Input) => Effect.Effect<SupervisionPolicy>;
+declare const task: (budget: Duration.Input) => Effect.Effect<SupervisionPolicy>;
+declare const supervision: (cap: Duration.Input) => 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>;
+  readonly leader: typeof leader;
+  readonly worker: typeof supervision;
+  readonly task: typeof task;
+  readonly custom: typeof custom;
 };
 declare const dynamic: <E, R, Args>(opts: {
   readonly name: string;
   readonly child: (args: Args) => Worker<E, R>;
-  readonly maxChildren?: number;
+  readonly maxChildren?: MaxChildren;
 }) => 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, 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 };
+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, MaxChildren, Noop, PollLoop, PollOpts, ReporterPolicyHooks, StreamLoop, SubscriptionLoop, Supervision, SupervisionConfig, SupervisionPolicy, Supervisor, SupervisorHealth, SupervisorOpts, SupervisorTypeId, TaskConfig, TickPolicyConfig, TickPolicyHooks, UnboundedIntensity, Worker, WorkerConfig, WorkerTypeId, cappedBackoff, dynamic, healthStateGauge, leader, oneForAll, oneForOne, poll, restForOne, run, stream, subscription, supervision, supervisor, supervisorChildrenGauge, supervisorExhaustionsCounter, supervisorRestartsCounter, task, withLeaderLock, worker };