@systemfsoftware/effect-daemon-spec 0.7.2 → 2.0.0

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

@@ -1,54 +1,39 @@
 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 { Latch } 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 { Scope as Scope_2 } from 'effect/Scope';
 import { Stream } from 'effect';
+import { YieldableError } from 'effect/Cause';
 
 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;
-}>>;
+declare const BoundedIntensity_base: Schema.Class<BoundedIntensity, Schema.TaggedStruct<"Bounded", {
+    readonly restarts: Schema.Int;
+    readonly window: Schema.Duration;
+}>, {}>;
 
-export declare const cappedBackoff: (base: Duration.DurationInput, cap: Duration.DurationInput) => Schedule.Schedule<Duration.Duration>;
+export declare const cappedBackoff: (base: Duration.Input, cap: Duration.Input) => 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;
+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: Duration_2;
-    } | undefined;
-}, {}, {}>;
+}>, {}>;
 
 export declare type ChildRef = {
     readonly id: number;
@@ -63,36 +48,36 @@ export declare interface CommonOpts<L extends LockConfig> {
     readonly lock: L;
 }
 
+declare const custom: <P>(policy: P) => Effect.Effect<P>;
+
 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>;
+    readonly poll: typeof poll;
+    readonly stream: typeof stream;
+    readonly subscription: typeof subscription;
 };
 
 export declare 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;
 }
 
 export declare class DaemonReporter extends DaemonReporter_base {}
 
-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>;
 
 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>;
 }
 
+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>;
+
 export declare const dynamic: <E, R, Args>(opts: {
     readonly name: string;
     readonly child: (args: Args) => Worker_2<E, R>;
-    readonly maxChildren?: number;
+    readonly maxChildren?: MaxChildren;
 }) => DynamicSpec<E, R, Args>;
 
 export declare interface DynamicHandle<Args, R = never> {
@@ -104,32 +89,30 @@ export declare interface DynamicHandle<Args, R = never> {
 
 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>;
-}>;
+declare const DynamicLimitExceeded_base: Schema.Class<DynamicLimitExceeded, Schema.TaggedStruct<"DynamicLimitExceeded", {
+    readonly limit: Schema.Int;
+}>, YieldableError>;
 
 export declare interface DynamicSpec<E, R, Args> {
     readonly [DynamicSpecTypeId]: DynamicSpecTypeId;
     readonly name: string;
     readonly child: (args: Args) => Worker_2<E, R>;
-    readonly maxChildren: number;
+    readonly maxChildren: MaxChildren;
 }
 
 export declare const DynamicSpecTypeId: unique symbol;
 
 export declare type DynamicSpecTypeId = typeof DynamicSpecTypeId;
 
-export declare const healthStateGauge: Metric.Metric.Gauge<number>;
+export declare const healthStateGauge: Metric.Gauge<number>;
 
-export declare const Intensity: Schema.Union<[typeof BoundedIntensity, typeof UnboundedIntensity]>;
+export declare const Intensity: Schema.Union<readonly [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;
+    readonly restarts: Schema.Int;
+    readonly window: Schema.Duration;
 }>;
 
 export declare type IntensityConfig = typeof IntensityConfig.Type;
@@ -138,17 +121,15 @@ declare const IntensityTypeId: unique symbol;
 
 declare type IntensityTypeId = typeof IntensityTypeId;
 
-export declare const leader: (cap: Duration.DurationInput) => Effect.Effect<SupervisionPolicy>;
-
-export declare class LeaderConfig extends LeaderConfig_base {}
+export declare const leader: (cap: Duration.Input) => Effect.Effect<SupervisionPolicy>;
 
-declare const LeaderConfig_base: Context.ReferenceClass<LeaderConfig, "@systemfsoftware/effect-daemon-spec/LeaderConfig", SupervisionConfig>;
+export declare const LeaderConfig: Context.Reference<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.adapter/LeaderLock", LeaderLockService>;
+declare const LeaderLock_base: Context.ServiceClass<LeaderLock, "@systemfsoftware/effect-daemon-spec/LeaderLockAdapter/LeaderLock", LeaderLockService>;
 
 export declare type LeaderLockAcquireError = LeaderLockNotAcquired | LeaderLockInfraError;
 
@@ -156,20 +137,16 @@ export declare const LeaderLockFromPrimitive: Layer.Layer<LeaderLock, never, Loc
 
 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;
-}>;
+declare const LeaderLockInfraError_base: Schema.Class<LeaderLockInfraError, Schema.TaggedStruct<"LeaderLockInfraError", {
+    readonly key: Schema.String;
+    readonly cause: Schema.Unknown;
+}>, YieldableError>;
 
 export declare class LeaderLockNotAcquired extends LeaderLockNotAcquired_base {}
 
-declare const LeaderLockNotAcquired_base: Schema.TaggedErrorClass<LeaderLockNotAcquired, "LeaderLockNotAcquired", {
-    readonly _tag: Schema.tag<"LeaderLockNotAcquired">;
-} & {
-    key: typeof Schema.String;
-}>;
+declare const LeaderLockNotAcquired_base: Schema.Class<LeaderLockNotAcquired, Schema.TaggedStruct<"LeaderLockNotAcquired", {
+    readonly key: Schema.String;
+}>, YieldableError>;
 
 export declare interface LeaderLockOptions {
     readonly key: string;
@@ -194,30 +171,21 @@ export declare type LockConfig = {
 
 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 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>;
+}>, {}>;
 
 export declare class LockPrimitive extends LockPrimitive_base {}
 
-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>;
 
 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;
-}>;
+declare const LockPrimitiveError_base: Schema.Class<LockPrimitiveError, Schema.TaggedStruct<"LockPrimitiveError", {
+    readonly key: Schema.String;
+    readonly cause: Schema.Unknown;
+}>, YieldableError>;
 
 export declare interface LockPrimitiveService {
     readonly tryAcquire: (key: string) => Effect.Effect<boolean, LockPrimitiveError, Scope.Scope>;
@@ -225,6 +193,10 @@ export declare interface LockPrimitiveService {
 
 export declare type LoopShape<E, R> = PollLoop<E, R> | StreamLoop<E, R> | SubscriptionLoop<E, R>;
 
+export declare const MaxChildren: Schema.brand<Schema.Int, "MaxChildren">;
+
+export declare type MaxChildren = typeof MaxChildren.Type;
+
 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>;
@@ -236,11 +208,11 @@ export declare const poll: <A, E, R, L extends LockConfig>(opts: PollOpts<A, E,
 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;
+    readonly interval: Duration.Input;
 };
 
 export declare 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>;
@@ -259,12 +231,12 @@ export declare const restForOne: <E, R, L extends LockConfig = LockConfig>(opts:
 export declare const run: {
     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>;
+            mode: 'none';
+        }>): Effect.Effect<DaemonHealth, never, R | Scope.Scope>;
+        <E, R>(w: Worker_2<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 | 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>;
+    readonly supervisor: typeof supervisor;
+    readonly dynamic: typeof dynamic$1;
 };
 
 export declare const stream: <A, E, R, L extends LockConfig>(opts: CommonOpts<L> & {
@@ -286,126 +258,107 @@ export declare type SubscriptionLoop<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: <P>(policy: P) => Effect.Effect<P>;
+    readonly leader: typeof leader;
+    readonly worker: typeof supervision;
+    readonly task: typeof task;
+    readonly custom: typeof custom;
 };
 
-export declare const supervision: (cap: Duration.DurationInput) => Effect.Effect<SupervisionPolicy>;
+export declare const supervision: (cap: Duration.Input) => Effect.Effect<SupervisionPolicy>;
 
 export declare interface SupervisionConfig {
-    readonly backoffBase: Duration.DurationInput;
+    readonly backoffBase: Duration.Input;
     readonly intensity: Intensity;
-    readonly cooldown: Duration.DurationInput;
+    readonly cooldown: Duration.Input;
 }
 
 export declare interface SupervisionPolicy {
     readonly intensity: Intensity;
     readonly backoff: Schedule.Schedule<Duration.Duration>;
-    readonly cooldown: Duration.DurationInput;
+    readonly cooldown: Duration.Input;
 }
 
 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 children: readonly (Worker_2<E, R> | Supervisor<E, R>)[];
     readonly supervision: Effect.Effect<SupervisionPolicy>;
     readonly lock: L;
     readonly reporter: ReporterPolicyHooks;
 }
 
-export declare const supervisor: <E, R>(s: Supervisor<E, R, LockConfig>) => Effect.Effect<SupervisorHealth, never, R | SupervisorBodyExecutorDeps | WithLeaderLockExecutorDeps | 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.
+ */
+export declare const supervisor: <E, R>(s: Supervisor<E, R, LockConfig>) => Effect.Effect<SupervisorHealth, never, R | DaemonReporter | LeaderLock | Scope.Scope>;
 
-export declare class SupervisorBodyExecutorDeps extends SupervisorBodyExecutorDeps_base {}
+export declare const supervisorChildrenGauge: Metric.Gauge<number>;
 
-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"];
-}>;
-
-export declare const SupervisorBodyExecutorLive: Layer.Layer<SupervisorBodyExecutorDeps, never, DaemonReporter>;
-
-export declare const supervisorChildrenGauge: Metric.Metric.Gauge<number>;
-
-export declare const supervisorExhaustionsCounter: Metric.Metric.Counter<number>;
+export declare const supervisorExhaustionsCounter: 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>;
+    readonly ready: Latch.Latch;
+    readonly healthy: Latch.Latch;
+    readonly paused: Latch.Latch;
+    readonly children: readonly (DaemonHealth | SupervisorHealth)[];
 }
 
 export declare 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;
 }
 
-export declare const supervisorRestartsCounter: Metric.Metric.Counter<number>;
+export declare const supervisorRestartsCounter: Metric.Counter<number>;
 
 export declare const SupervisorTypeId: unique symbol;
 
 export declare type SupervisorTypeId = typeof SupervisorTypeId;
 
-export declare const task: (budget: Duration.DurationInput) => Effect.Effect<SupervisionPolicy>;
+export declare const task: (budget: Duration.Input) => Effect.Effect<SupervisionPolicy>;
 
-export declare class TaskConfig extends TaskConfig_base {}
-
-declare const TaskConfig_base: Context.ReferenceClass<TaskConfig, "@systemfsoftware/effect-daemon-spec/TaskConfig", SupervisionConfig>;
+export declare const TaskConfig: Context.Reference<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 tickTimeout: Duration_2;
-} & {
-    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"]>>;
+}>, {}>;
 
 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>;
+    readonly trackDuration?: 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 function withLeaderLock<A, E, R>(self: Effect.Effect<A, E, R>, options: LeaderLockOptions): Effect.Effect<A | void, E | LeaderLockAcquireError, R | WithLeaderLockExecutorDeps>;
-
-export declare class WithLeaderLockExecutorDeps extends WithLeaderLockExecutorDeps_base {}
+declare const UnboundedIntensity_base: Schema.Class<UnboundedIntensity, Schema.TaggedStruct<"Unbounded", {}>, {}>;
 
-declare const WithLeaderLockExecutorDeps_base: Context.TagClass<WithLeaderLockExecutorDeps, "@systemfsoftware/effect-daemon-spec/internal/with-leader-lock.executor/WithLeaderLockExecutorDeps", {
-    readonly withLock: LeaderLock["Type"]["withLock"];
-}>;
-
-export declare const WithLeaderLockExecutorLive: Layer.Layer<WithLeaderLockExecutorDeps, never, LeaderLock>;
+export declare function withLeaderLock<A, E, R>(self: Effect.Effect<A, E, R>, options: LeaderLockOptions, lock: LeaderLock['Service']): Effect.Effect<A | void, E | LeaderLockAcquireError, R>;
 
+/**
+ * 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.
+ */
 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>;
+    <E, R>(w: Worker_2<E, R, LockConfig>): Effect.Effect<DaemonHealth, never, R | LeaderLock | Scope.Scope>;
 };
 
 declare interface Worker_2<E, R, L extends LockConfig = LockConfig> {
@@ -419,9 +372,7 @@ declare interface Worker_2<E, R, L extends LockConfig = LockConfig> {
 }
 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 WorkerConfig: Context.Reference<SupervisionConfig>;
 
 export declare const WorkerTypeId: unique symbol;