@systemfsoftware/effect-daemon-spec 1.0.0 → 3.0.0

package/CHANGELOG.md

@@ -1,5 +1,124 @@
 # @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
+
+- Pass capabilities as arguments instead of requiring them through a projection tag, in these two packages
+
+  Wlaschin's second approach — dependency parameterization — is preferred over the
+  Reader, and it removes the requirement from the signature entirely rather than
+  relocating it. Each operation in `effect-daemon-spec` and `stryker-js-cli` that
+  previously reached into the context for a projection now receives what it uses,
+  and the composition root is the single place that acquires the port.
+
+  The remaining `*ExecutorDeps` projections live in `omp/**/src/internal/`, fenced
+  behind each package's own `exports` map, so they are unreachable from any consumer;
+  the exported-wiring gate scans `src/` outside `src/internal/`, so internal composition
+  stays internal and is not a migration target here.
+
+  - `effect-daemon-spec` — `withLeaderLock` takes `lock: LeaderLock['Type']`, and the
+    supervisor body takes `reporter: DaemonReporter['Type']`. Every `yield* LeaderLock`
+    and `yield* DaemonReporter` now lands in `mod.ts`; the exported `worker` and
+    `supervisor` shapes are unchanged, and `withLeaderLock` loses `LeaderLock` from `R`.
+  - `stryker-js-cli` — `StrykerCliExecutorDeps` and its service interface are gone.
+    `runStrykerCli` and the handler take `detectMode` and `createRunEventStream`, typed
+    as indexed accesses off the two port services, and both lose the requirement from
+    `R`. `main.ts` acquires both ports and passes the members down.
+
+  For these two packages, a caller that provided the projection layer now provides
+  nothing, because the operation no longer requires anything.
+
+- Carry the lock decision as a `LockBinding` so a required lock can never silently vanish.
+
+  The three lock-taking operations — the internal `worker`, `supervisor`, and the
+  `withLockByMode` operation behind them — now take a single discriminated
+  argument, `LockBinding`, in place of a `(LockConfig, LeaderLock['Type'] | null)`
+  pair. `unlocked` is the one case for a body that takes no lock; `locked` carries
+  the keyed spec and the adapter that honours it.
+
+  A spec declaring `mode: 'required'` paired with a null or missing adapter
+  previously fell through to the body unwrapped — a silent downgrade from "must
+  hold the leader lock" to "no lock at all". That combination is no longer
+  representable: `unlocked` only exists for a `{ mode: 'none' }` spec, and `locked`
+  demands both a keyed spec (via `KeyedLockConfig`) and an adapter (via
+  `LeaderLock['Type']`). The composition root — `worker` and `supervisor` in
+  `mod.ts` — is now the one place that builds the binding, and its public shapes
+  are unchanged.
+
+### Minor Changes
+
+- cut over to effect v4 (4.0.0-rc.108): public surface derives from effect types; peers flip effect ^3→^4
+
+- Produce every workflow through `Workflow.make`.
+
+  `decideRestart`, `interpretHookResult`, and `admitSurvivorsRun` are now built by the constructor rather
+  than annotated with `Workflow<Command, Decision, Error>`. Each decision is behaviourally identical —
+  `make` is the identity at runtime — but the channels are now inferred from the decider instead of
+  asserted by hand, so a total decision resolves to `UninhabitedError` and becomes uncallable rather than
+  compiling as a workflow that cannot fail.
+
+  `effect-daemon-spec` takes a minor bump because the change is consumer-visible beyond its own source:
+  `@systemfsoftware/effect-cell-types` moves from `devDependencies` to `dependencies`, so installing this
+  package now installs it. That reclassification is required, not incidental — `make` is a runtime call,
+  and `scripts/guards/check-runtime-deps.mjs` fails a runtime import declared only as a dev dependency.
+  `omp-claude-compat` gains the same dependency; `stryker-js-cli` already declared it.
+
+  `RestartDecisionWorkflow` survives as a type-only export: one in-repo consumer, its own property test,
+  references it through `ReturnType<…>`.
+
+### Patch Changes
+
+- Array types are spelled one way. `Array<T>` and `ReadonlyArray<T>` in emitted
+  declarations become `T[]` and `readonly T[]`, which the type checker cannot tell
+  apart: no exported type changes, only how it is written.
+
+- New version is published through npm trusted publishing, so it carries a provenance attestation you can verify.
+
+- Express each executor's sandwich as a `Cell` description.
+
+  Every call site that previously sequenced the phases by hand now builds one description and hands it to the interpreter, so the order these executors run in is carried by the phase types instead of by the order the statements happen to appear in. Behaviour is preserved and no public surface moves: the change is confined to `src/internal/*.executor.ts`, and each package's golden API report is unchanged.
+
+  One site needed a real fix rather than a translation. `supervisor-body.executor.ts` wrote before it could classify — it recorded a restart, then read the resulting rate — which is a read that depends on an earlier decision. Its read now gathers the restart record and the resulting rate as one product, which keeps that site a single layer, with the intensity tracker passed as the read's command rather than captured from the surrounding scope.
+
+- The base mutation preset selects at the make boundary.
+
+  The preset carries both ignorers (`effect-schema-declarations`, `workflow-make-boundary`) and
+  `disableBail: true`, so killer recording is structural for every inheriting config. The sandwich
+  packages (daemon-spec, stryker-js-cli, omp-claude-compat) widen `mutate` to all non-test source
+  at explicit 100/100/100 thresholds — the ignorer is the selector, so membership is forced by the
+  brand rather than chosen by a path list. Library packages' mutate arrays are byte-identical.
+
+- `restart-decision.workflow.ts` has its pure decision in a new internal `restart-decision.kernel.ts` with a colocated property test. Both files are internal, so the package's public surface is unchanged and the restart behaviour is identical.
+
+- Updated dependencies:
+  - @systemfsoftware/effect-cell-types@3.0.0
+
 ## 1.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>;
 
 /**