@systemfsoftware/effect-daemon-spec 2.0.0 → 3.0.0

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @systemfsoftware/effect-daemon-spec
 
+## 3.0.0
+
+### Major Changes
+
+- Published types no longer include names tagged `@internal`. If you imported one of those names from the package, switch to a public export or stop using it.
+
+### Minor Changes
+
+- The loop kinds now ship their tags as values.
+
+  `PollLoopTag`, `StreamLoopTag` and `SubscriptionLoopTag` are new exports: each is a shared `{ _tag }`
+  value together with a type of the same name, and `PollLoop`, `StreamLoop` and
+  `SubscriptionLoop` inherit their discriminant from it. Members, tag strings and every existing
+  narrowing are unchanged, and constructing a loop can now spread the carrier instead of repeating
+  the literal.
+
+### Patch Changes
+
+- The peer requirements for `effect` and for the Effect test-runner integration now accept any compatible `4.0.0-rc` release, instead of demanding one exact release candidate.
+
+  Installing alongside a newer release candidate no longer reports an unmet peer dependency or resolves a second copy of `effect` into the dependency tree.
+
+- Updated dependencies:
+  - @systemfsoftware/effect-cell-types@4.0.0
+
 ## 2.0.0
 
 ### Major Changes

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

@@ -0,0 +1,406 @@
+import { Cause } from 'effect';
+import { Context } from 'effect';
+import { Duration } from 'effect';
+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.Class<BoundedIntensity, Schema.TaggedStruct<"Bounded", {
+    readonly restarts: Schema.Int;
+    readonly window: Schema.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, 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;
+    }>>;
+}>, {}>;
+
+export declare type ChildRef = {
+    readonly id: number;
+    readonly removed: Effect.Effect<void>;
+};
+
+export declare interface CommonOpts<L extends LockConfig> {
+    readonly name: string;
+    readonly child?: ChildPolicyConfig;
+    readonly tick: TickPolicyConfig;
+    readonly tickHooks?: TickPolicyHooks;
+    readonly lock: L;
+}
+
+declare const custom: <P>(policy: P) => Effect.Effect<P>;
+
+export declare const Daemon: {
+    readonly poll: typeof poll;
+    readonly stream: typeof stream;
+    readonly subscription: typeof subscription;
+};
+
+export declare interface DaemonHealth {
+    readonly name: string;
+    readonly ready: Latch.Latch;
+    readonly healthy: Latch.Latch;
+    readonly paused: Latch.Latch;
+}
+
+export declare class DaemonReporter extends DaemonReporter_base {}
+
+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?: MaxChildren;
+}) => 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.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: MaxChildren;
+}
+
+export declare const DynamicSpecTypeId: unique symbol;
+
+export declare type DynamicSpecTypeId = typeof DynamicSpecTypeId;
+
+export declare const healthStateGauge: Metric.Gauge<number>;
+
+export declare const Intensity: Schema.Union<readonly [typeof BoundedIntensity, typeof UnboundedIntensity]>;
+
+export declare type Intensity = typeof Intensity.Type;
+
+export declare const IntensityConfig: Schema.Struct<{
+    readonly restarts: Schema.Int;
+    readonly window: Schema.Duration;
+}>;
+
+export declare type IntensityConfig = typeof IntensityConfig.Type;
+
+declare const IntensityTypeId: unique symbol;
+
+declare type IntensityTypeId = typeof IntensityTypeId;
+
+export declare const leader: (cap: Duration.Input) => Effect.Effect<SupervisionPolicy>;
+
+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.ServiceClass<LeaderLock, "@systemfsoftware/effect-daemon-spec/LeaderLockAdapter/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.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.Class<LeaderLockNotAcquired, Schema.TaggedStruct<"LeaderLockNotAcquired", {
+    readonly key: Schema.String;
+}>, YieldableError>;
+
+export declare interface LeaderLockOptions {
+    readonly key: string;
+    readonly mode: 'required' | 'optional';
+    readonly acquireRetryBackoff?: Schedule.Schedule<Duration.Duration>;
+}
+
+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, 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.ServiceClass<LockPrimitive, "@systemfsoftware/effect-daemon-spec/LeaderLockAdapter/LockPrimitive", LockPrimitiveService>;
+
+export declare class LockPrimitiveError extends LockPrimitiveError_base {}
+
+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>;
+}
+
+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>;
+
+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 interface PollLoop<E, R> extends PollLoopTag {
+    readonly gate: Effect.Effect<Option_2.Option<Effect.Effect<void, E, R>>, E, R>;
+    readonly interval: Duration.Input;
+}
+
+/**
+ * Discriminants on the public Worker loop variants.
+ *
+ * These tags are part of the published type identity of `poll`, `stream`,
+ * and `subscription`. They are not unpublished wiring.
+ */
+export declare const PollLoopTag: {
+    readonly _tag: 'Poll';
+};
+
+export declare type PollLoopTag = typeof PollLoopTag;
+
+export declare type PollOpts<A, E, R, L extends LockConfig> = CommonOpts<L> & {
+    readonly interval: Duration.Input;
+} & ({
+    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: {
+        <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 | LeaderLock | Scope_2>;
+    };
+    readonly supervisor: typeof supervisor;
+    readonly dynamic: typeof dynamic$1;
+};
+
+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 interface StreamLoop<E, R> extends StreamLoopTag {
+    readonly stream: Stream.Stream<unknown, E, R>;
+}
+
+export declare const StreamLoopTag: {
+    readonly _tag: 'Stream';
+};
+
+export declare type StreamLoopTag = typeof StreamLoopTag;
+
+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 interface SubscriptionLoop<E, R> extends SubscriptionLoopTag {
+    readonly acquire: Effect.Effect<void, E, R>;
+}
+
+export declare const SubscriptionLoopTag: {
+    readonly _tag: 'Subscription';
+};
+
+export declare type SubscriptionLoopTag = typeof SubscriptionLoopTag;
+
+export declare const Supervision: {
+    readonly leader: typeof leader;
+    readonly worker: typeof supervision;
+    readonly task: typeof task;
+    readonly custom: typeof custom;
+};
+
+export declare const supervision: (cap: Duration.Input) => Effect.Effect<SupervisionPolicy>;
+
+export declare interface SupervisionConfig {
+    readonly backoffBase: Duration.Input;
+    readonly intensity: Intensity;
+    readonly cooldown: Duration.Input;
+}
+
+export declare interface SupervisionPolicy {
+    readonly intensity: Intensity;
+    readonly backoff: Schedule.Schedule<Duration.Duration>;
+    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: readonly (Worker_2<E, R> | Supervisor<E, R>)[];
+    readonly supervision: Effect.Effect<SupervisionPolicy>;
+    readonly lock: L;
+    readonly reporter: ReporterPolicyHooks;
+}
+
+/**
+ * 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 const supervisorChildrenGauge: Metric.Gauge<number>;
+
+export declare const supervisorExhaustionsCounter: Metric.Counter<number>;
+
+export declare interface SupervisorHealth {
+    readonly name: string;
+    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: readonly Child<E, R>[];
+    readonly supervision: Effect.Effect<SupervisionPolicy>;
+    readonly lock: L;
+    readonly reporter?: ReporterPolicyHooks;
+}
+
+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.Input) => Effect.Effect<SupervisionPolicy>;
+
+export declare const TaskConfig: Context.Reference<SupervisionConfig>;
+
+export declare class TickPolicyConfig extends TickPolicyConfig_base {}
+
+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.Histogram<Duration.Duration>;
+}
+
+export declare class UnboundedIntensity extends UnboundedIntensity_base {
+    readonly [IntensityTypeId]: symbol;
+}
+
+declare const UnboundedIntensity_base: Schema.Class<UnboundedIntensity, Schema.TaggedStruct<"Unbounded", {}>, {}>;
+
+/**
+ * Runs `self` while holding the named leader lock.
+ */
+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 | LeaderLock | 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: ChildPolicyConfig;
+    readonly tick: TickPolicyConfig;
+    readonly tickHooks: TickPolicyHooks;
+    readonly lock: L;
+}
+export { Worker_2 as Worker }
+
+export declare const WorkerConfig: Context.Reference<SupervisionConfig>;
+
+export declare const WorkerTypeId: unique symbol;
+
+export declare type WorkerTypeId = typeof WorkerTypeId;
+
+export { }

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';
 import { YieldableError } from 'effect/Cause';
 
@@ -205,12 +206,23 @@ export declare const oneForOne: <E, R, L extends LockConfig = LockConfig>(opts:
 
 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';
+export declare interface PollLoop<E, R> extends PollLoopTag {
     readonly gate: Effect.Effect<Option_2.Option<Effect.Effect<void, E, R>>, E, R>;
     readonly interval: Duration.Input;
+}
+
+/**
+ * Discriminants on the public Worker loop variants.
+ *
+ * These tags are part of the published type identity of `poll`, `stream`,
+ * and `subscription`. They are not unpublished wiring.
+ */
+export declare const PollLoopTag: {
+    readonly _tag: 'Poll';
 };
 
+export declare type PollLoopTag = typeof PollLoopTag;
+
 export declare type PollOpts<A, E, R, L extends LockConfig> = CommonOpts<L> & {
     readonly interval: Duration.Input;
 } & ({
@@ -232,8 +244,8 @@ export declare const run: {
     readonly 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 | LeaderLock | Scope.Scope>;
+        }>): Effect.Effect<DaemonHealth, never, R | Scope_2>;
+        <E, R>(w: Worker_2<E, R, LockConfig>): Effect.Effect<DaemonHealth, never, R | LeaderLock | Scope_2>;
     };
     readonly supervisor: typeof supervisor;
     readonly dynamic: typeof dynamic$1;
@@ -243,20 +255,30 @@ 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';
+export declare interface StreamLoop<E, R> extends StreamLoopTag {
     readonly stream: Stream.Stream<unknown, E, R>;
+}
+
+export declare const StreamLoopTag: {
+    readonly _tag: 'Stream';
 };
 
+export declare type StreamLoopTag = typeof StreamLoopTag;
+
 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';
+export declare interface SubscriptionLoop<E, R> extends SubscriptionLoopTag {
     readonly acquire: Effect.Effect<void, E, R>;
+}
+
+export declare const SubscriptionLoopTag: {
+    readonly _tag: 'Subscription';
 };
 
+export declare type SubscriptionLoopTag = typeof SubscriptionLoopTag;
+
 export declare const Supervision: {
     readonly leader: typeof leader;
     readonly worker: typeof supervision;
@@ -346,6 +368,9 @@ export declare class UnboundedIntensity extends UnboundedIntensity_base {
 
 declare const UnboundedIntensity_base: Schema.Class<UnboundedIntensity, Schema.TaggedStruct<"Unbounded", {}>, {}>;
 
+/**
+ * Runs `self` while holding the named leader lock.
+ */
 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>;
 
 /**