@fncts/io 0.0.11 → 0.0.14

package/Schedule/api.d.ts

@@ -1,123 +1,135 @@
 import { IO, URIO, UIO } from "@fncts/io/IO/definition";
 import { Schedule } from "@fncts/io/Schedule/definition";
-import { Either } from "@fncts/base/data/Either";
-import { Lazy } from "@fncts/base/data/function";
-import { Environment } from "@fncts/base/data/Environment";
-import { Maybe } from "@fncts/base/data/Maybe";
+import { Either } from "@fncts/base/data/Either/definition";
+import { Lazy } from "@fncts/base/data/function/definition";
+import { Environment } from "@fncts/base/data/Environment/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Intervals } from "@fncts/base/data/Intervals";
 import { Interval } from "@fncts/base/data/Interval";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
-import { List } from "@fncts/base/collection/immutable/List";
+import { List } from "@fncts/base/collection/immutable/List/definition";
 import { Decision } from "./Decision.js";
 /**
  * @tsplus static fncts.io.ScheduleOps __call
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function make<State, Env, In, Out>(initial: State, step: (now: number, inp: In, state: State, __tsplusTrace?: string) => IO<Env, never, readonly [State, Out, Decision]>): Schedule.WithState<State, Env, In, Out>;
+export declare function make<State, Env, In, Out>(initial: State, step: (now: number, inp: In, state: State, __tsplusTrace?: string) => IO<Env, never, readonly [State, Out, Decision]>, __tsplusTrace?: string): Schedule.WithState<State, Env, In, Out>;
 /**
  * @tsplus fluent fncts.io.Schedule addDelay
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function addDelay_<State, Env, In, Out>(self: Schedule.WithState<State, Env, In, Out>, f: (out: Out) => number): Schedule.WithState<State, Env, In, Out>;
+export declare function addDelay_<State, Env, In, Out>(self: Schedule.WithState<State, Env, In, Out>, f: (out: Out) => number, __tsplusTrace?: string): Schedule.WithState<State, Env, In, Out>;
 /**
  * @tsplus fluent fncts.io.Schedule addDelayIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function addDelayIO_<State, Env, In, Out, Env1>(self: Schedule.WithState<State, Env, In, Out>, f: (out: Out) => URIO<Env1, number>): Schedule.WithState<State, Env & Env1, In, Out>;
+export declare function addDelayIO_<State, Env, In, Out, Env1>(self: Schedule.WithState<State, Env, In, Out>, f: (out: Out) => URIO<Env1, number>, __tsplusTrace?: string): Schedule.WithState<State, Env | Env1, In, Out>;
 /**
  * @tsplus fluent fncts.io.Schedule andThen
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function andThen<State, Env, In, Out, State1, Env1, In1, Out1>(self: Schedule.WithState<State, Env, In, Out>, that: Schedule.WithState<State1, Env1, In1, Out1>): Schedule.WithState<readonly [State, State1, boolean], Env & Env1, In & In1, Out | Out1>;
+export declare function andThen<State, Env, In, Out, State1, Env1, In1, Out1>(self: Schedule.WithState<State, Env, In, Out>, that: Schedule.WithState<State1, Env1, In1, Out1>, __tsplusTrace?: string): Schedule.WithState<readonly [State, State1, boolean], Env | Env1, In & In1, Out | Out1>;
 /**
  * @tsplus fluent fncts.io.Schedule andThenEither
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function andThenEither_<State, Env, In, Out, State1, Env1, In1, Out1>(self: Schedule.WithState<State, Env, In, Out>, that: Schedule.WithState<State1, Env1, In1, Out1>): Schedule.WithState<readonly [State, State1, boolean], Env & Env1, In & In1, Either<Out, Out1>>;
+export declare function andThenEither_<State, Env, In, Out, State1, Env1, In1, Out1>(self: Schedule.WithState<State, Env, In, Out>, that: Schedule.WithState<State1, Env1, In1, Out1>, __tsplusTrace?: string): Schedule.WithState<readonly [State, State1, boolean], Env | Env1, In & In1, Either<Out, Out1>>;
 /**
  * @tsplus fluent fncts.io.Schedule as
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function as_<State, Env, In, Out, Out2>(self: Schedule.WithState<State, Env, In, Out>, out2: Lazy<Out2>): Schedule.WithState<State, Env, In, Out2>;
+export declare function as_<State, Env, In, Out, Out2>(self: Schedule.WithState<State, Env, In, Out>, out2: Lazy<Out2>, __tsplusTrace?: string): Schedule.WithState<State, Env, In, Out2>;
 /**
  * @tsplus fluent fncts.io.Schedule check
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function check_<State, Env, In, Out>(self: Schedule.WithState<State, Env, In, Out>, test: (inp: In, out: Out) => boolean): Schedule.WithState<State, Env, In, Out>;
+export declare function check_<State, Env, In, Out>(self: Schedule.WithState<State, Env, In, Out>, test: (inp: In, out: Out) => boolean, __tsplusTrace?: string): Schedule.WithState<State, Env, In, Out>;
 /**
  * @tsplus fluent fncts.io.Schedule checkIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function checkIO_<State, Env, In, Out, Env1>(self: Schedule.WithState<State, Env, In, Out>, test: (inp: In, out: Out) => URIO<Env1, boolean>): Schedule.WithState<State, Env & Env1, In, Out>;
+export declare function checkIO_<State, Env, In, Out, Env1>(self: Schedule.WithState<State, Env, In, Out>, test: (inp: In, out: Out) => URIO<Env1, boolean>, __tsplusTrace?: string): Schedule.WithState<State, Env | Env1, In, Out>;
 /**
  * @tsplus fluent fncts.io.Schedule compose_
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function compose_<S, R, I, O, S1, R1, O2>(self: Schedule.WithState<S, R, I, O>, that: Schedule.WithState<S1, R1, O, O2>): Schedule.WithState<readonly [S, S1], R & R1, I, O2>;
+export declare function compose_<S, R, I, O, S1, R1, O2>(self: Schedule.WithState<S, R, I, O>, that: Schedule.WithState<S1, R1, O, O2>, __tsplusTrace?: string): Schedule.WithState<readonly [S, S1], R | R1, I, O2>;
 /**
  * @tsplus fluent fncts.io.Schedule contramap
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function contramap_<S, R, I, O, I2>(self: Schedule.WithState<S, R, I, O>, f: (inp: I2) => I): Schedule.WithState<S, R, I2, O>;
+export declare function contramap_<S, R, I, O, I2>(self: Schedule.WithState<S, R, I, O>, f: (inp: I2) => I, __tsplusTrace?: string): Schedule.WithState<S, R, I2, O>;
 /**
  * @tsplus fluent fncts.io.Schedule contramapEnvironment
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function contramapEnvironment_<S, R, I, O, R1>(self: Schedule.WithState<S, R, I, O>, f: (env: Environment<R1>) => Environment<R>): Schedule.WithState<S, R1, I, O>;
+export declare function contramapEnvironment_<S, R, I, O, R1>(self: Schedule.WithState<S, R, I, O>, f: (env: Environment<R1>) => Environment<R>, __tsplusTrace?: string): Schedule.WithState<S, R1, I, O>;
 /**
  * @tsplus fluent fncts.io.Schedule contramapIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function contramapIO_<S, R, I, O, R1, I2>(self: Schedule.WithState<S, R, I, O>, f: (inp: I2) => URIO<R1, I>): Schedule.WithState<S, R & R1, I2, O>;
+export declare function contramapIO_<S, R, I, O, R1, I2>(self: Schedule.WithState<S, R, I, O>, f: (inp: I2) => URIO<R1, I>, __tsplusTrace?: string): Schedule.WithState<S, R | R1, I2, O>;
 /**
  * @tsplus static fncts.io.ScheduleOps delayed
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function delayed<S, R, I>(schedule: Schedule.WithState<S, R, I, number>): Schedule.WithState<S, R, I, number>;
+export declare function delayed<S, R, I>(schedule: Schedule.WithState<S, R, I, number>, __tsplusTrace?: string): Schedule.WithState<S, R, I, number>;
 /**
  * @tsplus fluent fncts.io.Schedule delayed
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function delayedSelf_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, f: (delay: number) => number): Schedule.WithState<S, R, I, O>;
+export declare function delayedSelf_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, f: (delay: number) => number, __tsplusTrace?: string): Schedule.WithState<S, R, I, O>;
 /**
  * @tsplus fluent fncts.io.Schedule delayedIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function delayedIO_<S, R, I, O, R1>(self: Schedule.WithState<S, R, I, O>, f: (delay: number) => URIO<R1, number>): Schedule.WithState<S, R & R1, I, O>;
+export declare function delayedIO_<S, R, I, O, R1>(self: Schedule.WithState<S, R, I, O>, f: (delay: number) => URIO<R1, number>, __tsplusTrace?: string): Schedule.WithState<S, R | R1, I, O>;
 /**
  * @tsplus getter fncts.io.Schedule delays
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function delays<S, R, I, O>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, R, I, number>;
+export declare function delays<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, __tsplusTrace?: string): Schedule.WithState<S, R, I, number>;
 /**
  * @tsplus fluent fncts.io.Schedule dimap
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function dimap_<S, R, I, O, I2, O2>(self: Schedule.WithState<S, R, I, O>, f: (inp2: I2) => I, g: (out: O) => O2): Schedule.WithState<S, R, I2, O2>;
+export declare function dimap_<S, R, I, O, I2, O2>(self: Schedule.WithState<S, R, I, O>, f: (inp2: I2) => I, g: (out: O) => O2, __tsplusTrace?: string): Schedule.WithState<S, R, I2, O2>;
 /**
  * @tsplus fluent fncts.io.Schedule dimapIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function dimapIO_<S, R, I, O, R1, I2, R2, O2>(self: Schedule.WithState<S, R, I, O>, f: (inp2: I2) => URIO<R1, I>, g: (out: O) => URIO<R2, O2>): Schedule.WithState<S, R & R1 & R2, I2, O2>;
+export declare function dimapIO_<S, R, I, O, R1, I2, R2, O2>(self: Schedule.WithState<S, R, I, O>, f: (inp2: I2) => URIO<R1, I>, g: (out: O) => URIO<R2, O2>, __tsplusTrace?: string): Schedule.WithState<S, R | R1 | R2, I2, O2>;
 /**
  * @tsplus static fncts.io.ScheduleOps duration
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function duration(duration: number): Schedule.WithState<boolean, unknown, unknown, number>;
+export declare function duration(duration: number, __tsplusTrace?: string): Schedule.WithState<boolean, never, unknown, number>;
+/**
+ * @tsplus fluent fncts.io.Schedule either
+ * @tsplus operator fncts.io.Schedule ||
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function either<S, R, I, O, S1, R1, I1, O1>(self: Schedule.WithState<S, R, I, O>, that: Schedule.WithState<S1, R1, I1, O1>, __tsplusTrace?: string): Schedule.WithState<readonly [S, S1], R | R1, I & I1, readonly [O, O1]>;
+/**
+ * @tsplus fluent fncts.io.Schedule eitherWith
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function eitherWith<S, R, I, O, S1, R1, I1, O1, O2>(self: Schedule.WithState<S, R, I, O>, that: Schedule.WithState<S1, R1, I1, O1>, f: (out1: O, out2: O1) => O2, __tsplusTrace?: string): Schedule.WithState<readonly [S, S1], R | R1, I & I1, O2>;
 /**
  * @tsplus static fncts.io.ScheduleOps elapsed
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare const elapsed: Schedule.WithState<Maybe<number>, unknown, unknown, number>;
+export declare const elapsed: Schedule.WithState<Maybe<number>, never, unknown, number>;
 /**
  * @tsplus fluent fncts.io.Schedule ensuring
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function ensuring_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, finalizer: UIO<any>): Schedule.WithState<S, R, I, O>;
+export declare function ensuring_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, finalizer: UIO<any>, __tsplusTrace?: string): Schedule.WithState<S, R, I, O>;
 /**
  * @tsplus static fncts.io.ScheduleOps exponential
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function exponential(base: number, factor?: number): Schedule.WithState<number, unknown, unknown, number>;
+export declare function exponential(base: number, factor?: number, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, number>;
 /**
  * A schedule that recurs on a fixed interval. Returns the number of
  * repetitions of the schedule so far.
@@ -132,229 +144,229 @@ export declare function exponential(base: number, factor?: number): Schedule.Wit
  * @tsplus static fncts.io.ScheduleOps fixed
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function fixed(interval: number): Schedule.WithState<readonly [Maybe<readonly [number, number]>, number], unknown, unknown, number>;
+export declare function fixed(interval: number, __tsplusTrace?: string): Schedule.WithState<readonly [Maybe<readonly [number, number]>, number], never, unknown, number>;
 /**
  * @tsplus fluent fncts.io.Schedule fold
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function fold_<S, R, I, O, Z>(self: Schedule.WithState<S, R, I, O>, z: Z, f: (z: Z, out: O) => Z): Schedule.WithState<readonly [S, Z], R, I, Z>;
+export declare function fold_<S, R, I, O, Z>(self: Schedule.WithState<S, R, I, O>, z: Z, f: (z: Z, out: O) => Z, __tsplusTrace?: string): Schedule.WithState<readonly [S, Z], R, I, Z>;
 /**
  * @tsplus fluent fncts.io.Schedule foldIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function foldIO_<S, R, I, O, Z, R1>(self: Schedule.WithState<S, R, I, O>, z: Z, f: (z: Z, out: O) => URIO<R1, Z>): Schedule.WithState<readonly [S, Z], R & R1, I, Z>;
+export declare function foldIO_<S, R, I, O, Z, R1>(self: Schedule.WithState<S, R, I, O>, z: Z, f: (z: Z, out: O) => URIO<R1, Z>, __tsplusTrace?: string): Schedule.WithState<readonly [S, Z], R | R1, I, Z>;
 /**
  * @tsplus getter fncts.io.Schedule forever
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function foreverSelf<S, R, I, O>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<S, R, I, O>;
+export declare function foreverSelf<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, __tsplusTrace?: string): Schedule.WithState<S, R, I, O>;
 /**
  * @tsplus static fncts.io.ScheduleOps forever
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare const forever: import("./definition.js").Schedule.WithState<number, unknown, unknown, number>;
+export declare const forever: import("./definition.js").Schedule.WithState<number, never, unknown, number>;
 /**
  * @tsplus static fncts.io.ScheduleOps identity
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function identity<A>(): Schedule.WithState<void, unknown, A, A>;
+export declare function identity<A>(__tsplusTrace?: string): Schedule.WithState<void, never, A, A>;
 /**
  * @tsplus fluent fncts.io.Schedule intersectWith
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function intersectWith_<S, R, I, O, S1, R1, I1, O1>(self: Schedule.WithState<S, R, I, O>, that: Schedule.WithState<S1, R1, I1, O1>, f: (int1: Interval, int2: Interval) => Interval): Schedule.WithState<readonly [S, S1], R & R1, I & I1, readonly [O, O1]>;
+export declare function intersectWith_<S, R, I, O, S1, R1, I1, O1>(self: Schedule.WithState<S, R, I, O>, that: Schedule.WithState<S1, R1, I1, O1>, f: (int1: Intervals, int2: Intervals) => Intervals, __tsplusTrace?: string): Schedule.WithState<readonly [S, S1], R | R1, I & I1, readonly [O, O1]>;
 /**
  * @tsplus static fncts.io.Schedule linear
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function linear(base: number): Schedule.WithState<number, unknown, unknown, number>;
+export declare function linear(base: number, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, number>;
 /**
  * @tsplus fluent fncts.io.Schedule map
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function map_<State, Env, In, Out, Out1>(self: Schedule.WithState<State, Env, In, Out>, f: (out: Out) => Out1): Schedule.WithState<State, Env, In, Out1>;
+export declare function map_<State, Env, In, Out, Out1>(self: Schedule.WithState<State, Env, In, Out>, f: (out: Out) => Out1, __tsplusTrace?: string): Schedule.WithState<State, Env, In, Out1>;
 /**
  * @tsplus fluent fncts.io.Schedule mapIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function mapIO_<State, Env, In, Out, Env1, Out1>(self: Schedule.WithState<State, Env, In, Out>, f: (out: Out) => URIO<Env1, Out1>): Schedule.WithState<State, Env & Env1, In, Out1>;
+export declare function mapIO_<State, Env, In, Out, Env1, Out1>(self: Schedule.WithState<State, Env, In, Out>, f: (out: Out) => URIO<Env1, Out1>, __tsplusTrace?: string): Schedule.WithState<State, Env | Env1, In, Out1>;
 /**
  * @tsplus fluent fncts.io.Schedule modifyDelayIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function modifyDelayIO_<State, Env, In, Out, Env1>(self: Schedule.WithState<State, Env, In, Out>, f: (out: Out, duration: number) => URIO<Env1, number>): Schedule.WithState<State, Env & Env1, In, Out>;
+export declare function modifyDelayIO_<State, Env, In, Out, Env1>(self: Schedule.WithState<State, Env, In, Out>, f: (out: Out, duration: number) => URIO<Env1, number>, __tsplusTrace?: string): Schedule.WithState<State, Env | Env1, In, Out>;
 /**
  * @tsplus fluent fncts.io.Schedule onDecision
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function onDecision_<S, R, I, O, R1>(self: Schedule.WithState<S, R, I, O>, f: (state: S, out: O, decision: Decision) => URIO<R1, any>): Schedule.WithState<S, R & R1, I, O>;
+export declare function onDecision_<S, R, I, O, R1>(self: Schedule.WithState<S, R, I, O>, f: (state: S, out: O, decision: Decision) => URIO<R1, any>, __tsplusTrace?: string): Schedule.WithState<S, R | R1, I, O>;
 /**
  * @tsplus fluent fncts.io.Schedule provideEnvironment
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function provideEnvironment_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, env: Environment<R>): Schedule.WithState<S, unknown, I, O>;
+export declare function provideEnvironment_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, env: Environment<R>, __tsplusTrace?: string): Schedule.WithState<S, never, I, O>;
 /**
  * @tsplus fluent fncts.io.Schedule reconsider
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function reconsider_<S, R, I, O, O2>(self: Schedule.WithState<S, R, I, O>, f: (state: S, out: O, decision: Decision) => Either<O2, readonly [O2, Interval]>): Schedule.WithState<S, R, I, O2>;
+export declare function reconsider_<S, R, I, O, O2>(self: Schedule.WithState<S, R, I, O>, f: (state: S, out: O, decision: Decision) => Either<O2, readonly [O2, Interval]>, __tsplusTrace?: string): Schedule.WithState<S, R, I, O2>;
 /**
  * @tsplus fluent fncts.io.Schedule reconsiderIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function reconsiderIO_<S, R, I, O, R1, O1>(self: Schedule.WithState<S, R, I, O>, f: (state: S, out: O, decision: Decision) => URIO<R1, Either<O1, readonly [O1, Interval]>>): Schedule.WithState<S, R & R1, I, O1>;
+export declare function reconsiderIO_<S, R, I, O, R1, O1>(self: Schedule.WithState<S, R, I, O>, f: (state: S, out: O, decision: Decision) => URIO<R1, Either<O1, readonly [O1, Interval]>>, __tsplusTrace?: string): Schedule.WithState<S, R | R1, I, O1>;
 /**
  * @tsplus static fncts.io.Schedule recurs
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function recurs(n: number): Schedule.WithState<number, unknown, unknown, number>;
+export declare function recurs(n: number, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, number>;
 /**
  * @tsplus static fncts.io.Schedule recurWhile
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function recurWhile<A>(f: (a: A) => boolean): Schedule.WithState<void, unknown, A, A>;
+export declare function recurWhile<A>(f: (a: A) => boolean, __tsplusTrace?: string): Schedule.WithState<void, never, A, A>;
 /**
  * @tsplus static fncts.io.Schedule recurWhileIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function recurWhileIO<R, A>(f: (a: A) => URIO<R, boolean>): Schedule.WithState<void, R, A, A>;
+export declare function recurWhileIO<R, A>(f: (a: A) => URIO<R, boolean>, __tsplusTrace?: string): Schedule.WithState<void, R, A, A>;
 /**
  * @tsplus static fncts.io.Schedule recurWhileEquals
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function recurWhileEquals<A>(value: Lazy<A>): Schedule.WithState<void, unknown, A, A>;
+export declare function recurWhileEquals<A>(value: Lazy<A>, __tsplusTrace?: string): Schedule.WithState<void, never, A, A>;
 /**
  * @tsplus static fncts.io.Schedule recurUntil
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function recurUntil<A>(f: (a: A) => boolean): Schedule.WithState<void, unknown, A, A>;
+export declare function recurUntil<A>(f: (a: A) => boolean, __tsplusTrace?: string): Schedule.WithState<void, never, A, A>;
 /**
  * @tsplus static fncts.io.Schedule recurUntilIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function recurUntilIO<R, A>(f: (a: A) => URIO<R, boolean>): Schedule.WithState<void, R, A, A>;
+export declare function recurUntilIO<R, A>(f: (a: A) => URIO<R, boolean>, __tsplusTrace?: string): Schedule.WithState<void, R, A, A>;
 /**
  * @tsplus static fncts.io.Schedule recurUntilEquals
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function recurUntilEquals<A>(value: Lazy<A>): Schedule.WithState<void, unknown, A, A>;
+export declare function recurUntilEquals<A>(value: Lazy<A>, __tsplusTrace?: string): Schedule.WithState<void, never, A, A>;
 /**
  * @tsplus getter fncts.io.Schedule repetitions
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function repetitions<S, R, I, O>(self: Schedule.WithState<S, R, I, O>): Schedule.WithState<readonly [S, number], R, I, number>;
+export declare function repetitions<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, __tsplusTrace?: string): Schedule.WithState<readonly [S, number], R, I, number>;
 /**
  * @tsplus fluent fncts.io.Schedule resetAfter
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function resetAfter_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, duration: number): Schedule.WithState<readonly [S, Maybe<number>], R, I, O>;
+export declare function resetAfter_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, duration: number, __tsplusTrace?: string): Schedule.WithState<readonly [S, Maybe<number>], R, I, O>;
 /**
  * @tsplus fluent fncts.io.Schedule resetWhen
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function resetWhen_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, f: (out: O) => boolean): Schedule.WithState<S, R, I, O>;
+export declare function resetWhen_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, f: (out: O) => boolean, __tsplusTrace?: string): Schedule.WithState<S, R, I, O>;
 /**
  * @tsplus fluent fncts.io.Schedule run
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function run_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, now: number, input: Iterable<I>): URIO<R, Conc<O>>;
+export declare function run_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, now: number, input: Iterable<I>, __tsplusTrace?: string): URIO<R, Conc<O>>;
 /**
  * @tsplus static fncts.io.Schedule spaced
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function spaced(duration: number): Schedule.WithState<number, unknown, unknown, number>;
+export declare function spaced(duration: number, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, number>;
 /**
  * @tsplus static fncts.io.Schedule succeed
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function succeed<A>(a: Lazy<A>): Schedule.WithState<number, unknown, unknown, A>;
+export declare function succeed<A>(a: Lazy<A>, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, A>;
 /**
  * @tsplus fluent fncts.io.Schedule tapInput
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function tapInput_<S, R, I, O, R1>(self: Schedule.WithState<S, R, I, O>, f: (inp: I) => URIO<R1, any>): Schedule.WithState<S, R & R1, I, O>;
+export declare function tapInput_<S, R, I, O, R1>(self: Schedule.WithState<S, R, I, O>, f: (inp: I) => URIO<R1, any>, __tsplusTrace?: string): Schedule.WithState<S, R | R1, I, O>;
 /**
  * @tsplus fluent fncts.io.Schedule tapOutput
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function tapOutput_<S, R, I, O, R1>(self: Schedule.WithState<S, R, I, O>, f: (out: O) => URIO<R1, any>): Schedule.WithState<S, R & R1, I, O>;
+export declare function tapOutput_<S, R, I, O, R1>(self: Schedule.WithState<S, R, I, O>, f: (out: O) => URIO<R1, any>, __tsplusTrace?: string): Schedule.WithState<S, R | R1, I, O>;
 /**
  * @tsplus fluent fncts.io.Schedule unionWith
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function unionWith_<S, R, I, O, S1, R1, I1, O1>(self: Schedule.WithState<S, R, I, O>, that: Schedule.WithState<S1, R1, I1, O1>, f: (int1: Interval, int2: Interval) => Interval): Schedule.WithState<readonly [S, S1], R & R1, I & I1, readonly [O, O1]>;
+export declare function unionWith_<S, R, I, O, S1, R1, I1, O1>(self: Schedule.WithState<S, R, I, O>, that: Schedule.WithState<S1, R1, I1, O1>, f: (int1: Intervals, int2: Intervals) => Intervals, __tsplusTrace?: string): Schedule.WithState<readonly [S, S1], R | R1, I & I1, readonly [O, O1]>;
 /**
  * @tsplus static fncts.io.ScheduleOps unfold
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function unfold<A>(a: Lazy<A>, f: (a: A) => A): Schedule.WithState<A, unknown, unknown, A>;
+export declare function unfold<A>(a: Lazy<A>, f: (a: A) => A, __tsplusTrace?: string): Schedule.WithState<A, never, unknown, A>;
 /**
  * @tsplus fluent fncts.io.Schedule untilInput
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function untilInput_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, f: (inp: I) => boolean): Schedule.WithState<S, R, I, O>;
+export declare function untilInput_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, f: (inp: I) => boolean, __tsplusTrace?: string): Schedule.WithState<S, R, I, O>;
 /**
  * @tsplus fluent fncts.io.Schedule untilInputIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function untilInputIO_<S, R, I, O, R1>(self: Schedule.WithState<S, R, I, O>, f: (inp: I) => URIO<R1, boolean>): Schedule.WithState<S, R & R1, I, O>;
+export declare function untilInputIO_<S, R, I, O, R1>(self: Schedule.WithState<S, R, I, O>, f: (inp: I) => URIO<R1, boolean>, __tsplusTrace?: string): Schedule.WithState<S, R | R1, I, O>;
 /**
  * @tsplus fluent fncts.io.Schedule untilOutput
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function untilOutput_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, f: (out: O) => boolean): Schedule.WithState<S, R, I, O>;
+export declare function untilOutput_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, f: (out: O) => boolean, __tsplusTrace?: string): Schedule.WithState<S, R, I, O>;
 /**
  * @tsplus fluent fncts.io.Schedule untilOutputIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function untilOutputIO_<S, R, I, O, R1>(self: Schedule.WithState<S, R, I, O>, f: (out: O) => URIO<R1, boolean>): Schedule.WithState<S, R & R1, I, O>;
+export declare function untilOutputIO_<S, R, I, O, R1>(self: Schedule.WithState<S, R, I, O>, f: (out: O) => URIO<R1, boolean>, __tsplusTrace?: string): Schedule.WithState<S, R | R1, I, O>;
 /**
  * @tsplus static fncts.io.Schedule upTo
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function upTo(duration: number): Schedule.WithState<Maybe<number>, unknown, unknown, number>;
+export declare function upTo(duration: number, __tsplusTrace?: string): Schedule.WithState<Maybe<number>, never, unknown, number>;
 /**
  * @tsplus fluent fncts.io.Schedule whileInput
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function whileInput_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, f: (inp: I) => boolean): Schedule.WithState<S, R, I, O>;
+export declare function whileInput_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, f: (inp: I) => boolean, __tsplusTrace?: string): Schedule.WithState<S, R, I, O>;
 /**
  * @tsplus fluent fncts.io.Schedule whileInputIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function whileInputIO_<S, R, I, O, R1>(self: Schedule.WithState<S, R, I, O>, f: (inp: I) => URIO<R1, boolean>): Schedule.WithState<S, R & R1, I, O>;
+export declare function whileInputIO_<S, R, I, O, R1>(self: Schedule.WithState<S, R, I, O>, f: (inp: I) => URIO<R1, boolean>, __tsplusTrace?: string): Schedule.WithState<S, R | R1, I, O>;
 /**
  * @tsplus fluent fncts.io.Schedule whileOutput
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function whileOutput_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, f: (out: O) => boolean): Schedule.WithState<S, R, I, O>;
+export declare function whileOutput_<S, R, I, O>(self: Schedule.WithState<S, R, I, O>, f: (out: O) => boolean, __tsplusTrace?: string): Schedule.WithState<S, R, I, O>;
 /**
  * @tsplus fluent fncts.io.Schedule whileOutputIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function whileOutputIO_<S, R, I, O, R1>(self: Schedule.WithState<S, R, I, O>, f: (out: O) => URIO<R1, boolean>): Schedule.WithState<S, R & R1, I, O>;
+export declare function whileOutputIO_<S, R, I, O, R1>(self: Schedule.WithState<S, R, I, O>, f: (out: O) => URIO<R1, boolean>, __tsplusTrace?: string): Schedule.WithState<S, R | R1, I, O>;
 /**
  * @tsplus static fncts.io.Schedule windowed
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function windowed(interval: number): Schedule.WithState<readonly [Maybe<number>, number], unknown, unknown, number>;
+export declare function windowed(interval: number, __tsplusTrace?: string): Schedule.WithState<readonly [Maybe<number>, number], never, unknown, number>;
 /**
  * @tsplus fluent fncts.io.Schedule zip
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function zip_<S, R, I, O, S1, R1, I1, O1>(self: Schedule.WithState<S, R, I, O>, that: Schedule.WithState<S1, R1, I1, O1>): Schedule.WithState<readonly [S, S1], R & R1, I & I1, readonly [O, O1]>;
+export declare function zip_<S, R, I, O, S1, R1, I1, O1>(self: Schedule.WithState<S, R, I, O>, that: Schedule.WithState<S1, R1, I1, O1>, __tsplusTrace?: string): Schedule.WithState<readonly [S, S1], R | R1, I & I1, readonly [O, O1]>;
 /**
  * @tsplus fluent fncts.io.Schedule zipLeft
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function zipLeft_<S, R, I, O, S1, R1, I1, O1>(self: Schedule.WithState<S, R, I, O>, that: Schedule.WithState<S1, R1, I1, O1>): Schedule.WithState<readonly [S, S1], R & R1, I & I1, O>;
+export declare function zipLeft_<S, R, I, O, S1, R1, I1, O1>(self: Schedule.WithState<S, R, I, O>, that: Schedule.WithState<S1, R1, I1, O1>, __tsplusTrace?: string): Schedule.WithState<readonly [S, S1], R | R1, I & I1, O>;
 /**
  * @tsplus fluent fncts.io.Schedule zipRight
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function zipRight_<S, R, I, O, S1, R1, I1, O1>(self: Schedule.WithState<S, R, I, O>, that: Schedule.WithState<S1, R1, I1, O1>): Schedule.WithState<readonly [S, S1], R & R1, I & I1, O1>;
+export declare function zipRight_<S, R, I, O, S1, R1, I1, O1>(self: Schedule.WithState<S, R, I, O>, that: Schedule.WithState<S1, R1, I1, O1>, __tsplusTrace?: string): Schedule.WithState<readonly [S, S1], R | R1, I & I1, O1>;
 /**
  * @tsplus fluent fncts.io.Schedule zipWith
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function zipWith_<S, R, I, O, S1, R1, I1, O2, O3>(self: Schedule.WithState<S, R, I, O>, that: Schedule.WithState<S1, R1, I1, O2>, f: (out1: O, out2: O2) => O3): Schedule.WithState<readonly [S, S1], R & R1, I & I1, O3>;
+export declare function zipWith_<S, R, I, O, S1, R1, I1, O2, O3>(self: Schedule.WithState<S, R, I, O>, that: Schedule.WithState<S1, R1, I1, O2>, f: (out1: O, out2: O2) => O3, __tsplusTrace?: string): Schedule.WithState<readonly [S, S1], R | R1, I & I1, O3>;

package/Schedule/definition.d.ts

@@ -32,7 +32,7 @@ import type { Driver as Driver_ } from "./Driver.js";
  * @tsplus companion fncts.io.ScheduleOps
  */
 export declare abstract class Schedule<Env, In, Out> {
-    readonly _Env: (_: Env) => void;
+    readonly _Env: () => Env;
     readonly _In: (_: In) => void;
     readonly _Out: () => Out;
     readonly _State: unknown;

package/Scope/Finalizer/definition.d.ts

@@ -1,16 +1,16 @@
 import { HKT } from "@fncts/typelevel/HKT";
 import { Newtype } from "@fncts/base/data/Newtype";
-import { Exit } from "@fncts/base/data/Exit";
+import { Exit } from "@fncts/base/data/Exit/definition";
 import { IO } from "@fncts/io/IO/definition";
 interface FinalizerN extends HKT {
-    readonly [HKT.T]: Finalizer;
+    readonly type: Finalizer;
 }
 /**
  * @tsplus type fncts.io.Managed.Finalizer
  */
 export interface Finalizer extends Newtype<{
     readonly Finalizer: unique symbol;
-}, (exit: Exit<any, any>) => IO<unknown, never, any>> {
+}, (exit: Exit<any, any>) => IO<never, never, any>> {
 }
 /**
  * @tsplus type fncts.io.Managed.FinalizerOps

package/Scope/ReleaseMap/api/releaseAll.d.ts

@@ -1,4 +1,4 @@
-import { Exit } from "@fncts/base/data/Exit";
+import { Exit } from "@fncts/base/data/Exit/definition";
 import { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
 import { UIO } from "@fncts/io/IO/definition";
 import { ReleaseMap } from "../definition.js";
@@ -6,4 +6,4 @@ import { ReleaseMap } from "../definition.js";
  * @tsplus fluent fncts.io.Scope.ReleaseMap releaseAll
  * @tsplus location "@fncts/io/Scope/ReleaseMap/api/releaseAll"
  */
-export declare function releaseAll_(releaseMap: ReleaseMap, exit: Exit<any, any>, execStrategy: ExecutionStrategy): UIO<any>;
+export declare function releaseAll_(releaseMap: ReleaseMap, exit: Exit<any, any>, execStrategy: ExecutionStrategy, __tsplusTrace?: string): UIO<any>;

package/Scope/ReleaseMap/api.d.ts

@@ -1,30 +1,30 @@
 import { Finalizer } from "@fncts/io/Scope/Finalizer";
 import { UIO, IO } from "@fncts/io/IO/definition";
-import { Maybe } from "@fncts/base/data/Maybe";
-import { Exit } from "@fncts/base/data/Exit";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Exit } from "@fncts/base/data/Exit/definition";
 import { ReleaseMap } from "./definition.js";
 /**
  * @tsplus fluent fncts.io.Scope.ReleaseMap addIfOpen
  * @tsplus location "@fncts/io/Scope/ReleaseMap/api"
  */
-export declare function addIfOpen_(releaseMap: ReleaseMap, finalizer: Finalizer): UIO<Maybe<number>>;
+export declare function addIfOpen_(releaseMap: ReleaseMap, finalizer: Finalizer, __tsplusTrace?: string): UIO<Maybe<number>>;
 /**
  * @tsplus fluent fncts.io.Scope.ReleaseMap release
  * @tsplus location "@fncts/io/Scope/ReleaseMap/api"
  */
-export declare function release_(releaseMap: ReleaseMap, key: number, exit: Exit<any, any>): IO<unknown, never, any>;
+export declare function release_(releaseMap: ReleaseMap, key: number, exit: Exit<any, any>, __tsplusTrace?: string): IO<never, never, any>;
 /**
  * @tsplus fluent fncts.io.Scope.ReleaseMap add
  * @tsplus location "@fncts/io/Scope/ReleaseMap/api"
  */
-export declare function add_(releaseMap: ReleaseMap, finalizer: Finalizer): UIO<Finalizer>;
+export declare function add_(releaseMap: ReleaseMap, finalizer: Finalizer, __tsplusTrace?: string): UIO<Finalizer>;
 /**
  * @tsplus fluent fncts.io.Scope.ReleaseMap replace
  * @tsplus location "@fncts/io/Scope/ReleaseMap/api"
  */
-export declare function replace_(releaseMap: ReleaseMap, key: number, finalizer: Finalizer): UIO<Maybe<Finalizer>>;
+export declare function replace_(releaseMap: ReleaseMap, key: number, finalizer: Finalizer, __tsplusTrace?: string): UIO<Maybe<Finalizer>>;
 /**
  * @tsplus fluent fncts.io.Scope.ReleaseMap updateAll
  * @tsplus location "@fncts/io/Scope/ReleaseMap/api"
  */
-export declare function updateAll_(releaseMap: ReleaseMap, f: (_: Finalizer) => Finalizer): UIO<void>;
+export declare function updateAll_(releaseMap: ReleaseMap, f: (_: Finalizer) => Finalizer, __tsplusTrace?: string): UIO<void>;

package/Scope/ReleaseMap/definition.d.ts

@@ -1,6 +1,6 @@
-import { Exit } from "@fncts/base/data/Exit";
+import { Exit } from "@fncts/base/data/Exit/definition";
 import { Finalizer } from "@fncts/io/Scope/Finalizer";
-import { HashMap } from "@fncts/base/collection/immutable/HashMap";
+import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
 import { HKT } from "@fncts/typelevel/HKT";
 import { Newtype } from "@fncts/base/data/Newtype";
 import { Ref } from "@fncts/io/Ref";
@@ -20,7 +20,7 @@ export declare class Running {
 }
 export declare type State = Exited | Running;
 interface ReleaseMapN extends HKT {
-    readonly [HKT.T]: ReleaseMap;
+    readonly type: ReleaseMap;
 }
 /**
  * @tsplus type fncts.io.Scope.ReleaseMap

package/Scope/api.d.ts

@@ -1,21 +1,20 @@
 import { Scope } from "@fncts/io/Scope/definition";
-import { Lazy } from "@fncts/base/data/function";
+import { Lazy } from "@fncts/base/data/function/definition";
 import { UIO, IO } from "@fncts/io/IO/definition";
-import { Has } from "@fncts/base/typeclass/Has";
 import { Finalizer } from "@fncts/io/Scope/Finalizer";
-import { Exit } from "@fncts/base/data/Exit";
+import { Exit } from "@fncts/base/data/Exit/definition";
 import { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
 import { Closeable } from "./definition.js";
 /**
  * @tsplus fluent fncts.io.Scope addFinalizer
  * @tsplus location "@fncts/io/Scope/api"
  */
-export declare function addFinalizer_(self: Scope, finalizer: Lazy<UIO<any>>): UIO<void>;
+export declare function addFinalizer_(self: Scope, finalizer: Lazy<UIO<any>>, __tsplusTrace?: string): UIO<void>;
 /**
  * @tsplus static fncts.io.ScopeOps addFinalizer
  * @tsplus location "@fncts/io/Scope/api"
  */
-export declare function addFinalizer(finalizer: Lazy<UIO<void>>): IO<Has<Scope>, never, void>;
+export declare function addFinalizer(finalizer: Lazy<UIO<void>>, __tsplusTrace?: string): IO<Scope, never, void>;
 /**
  * @tsplus static fncts.io.ScopeOps concurrent
  * @tsplus static fncts.io.Scope.CloseableOps concurrent
@@ -26,7 +25,7 @@ export declare const concurrent: UIO<Scope.Closeable>;
  * @tsplus fluent fncts.io.Scope extend
  * @tsplus location "@fncts/io/Scope/api"
  */
-export declare function extend_<R, E, A>(self: Scope, io: Lazy<IO<R & Has<Scope>, E, A>>): IO<R, E, A>;
+export declare function extend_<R, E, A>(self: Scope, io: Lazy<IO<R, E, A>>, __tsplusTrace?: string): IO<Exclude<R, Scope>, E, A>;
 /**
  * @tsplus static fncts.io.ScopeOps global
  * @tsplus location "@fncts/io/Scope/api"
@@ -43,19 +42,19 @@ export declare const make: UIO<Scope.Closeable>;
  * @tsplus static fncts.io.Scope.CloseableOps makeWith
  * @tsplus location "@fncts/io/Scope/api"
  */
-export declare function makeWith(executionStrategy: Lazy<ExecutionStrategy>): UIO<Scope.Closeable>;
+export declare function makeWith(executionStrategy: Lazy<ExecutionStrategy>, __tsplusTrace?: string): UIO<Scope.Closeable>;
 /**
  * @tsplus static fncts.io.ScopeOps unsafeMake
  * @tsplus location "@fncts/io/Scope/api"
  */
-export declare function unsafeMake(): Closeable;
+export declare function unsafeMake(__tsplusTrace?: string): Closeable;
 /**
  * @tsplus static fncts.io.ScopeOps unsafeMakeWith
  * @tsplus location "@fncts/io/Scope/api"
  */
-export declare function unsafeMakeWith(executionStrategy: ExecutionStrategy): Scope.Closeable;
+export declare function unsafeMakeWith(executionStrategy: ExecutionStrategy, __tsplusTrace?: string): Scope.Closeable;
 /**
  * @tsplus fluent fncts.io.Scope.Closeable use
  * @tsplus location "@fncts/io/Scope/api"
  */
-export declare function use_<R, E, A>(self: Scope.Closeable, io: Lazy<IO<R & Has<Scope>, E, A>>): IO<R, E, A>;
+export declare function use_<R, E, A>(self: Scope.Closeable, io: Lazy<IO<R, E, A>>, __tsplusTrace?: string): IO<Exclude<R, Scope>, E, A>;

package/Scope/definition.d.ts

@@ -1,7 +1,7 @@
 import { Finalizer } from "@fncts/io/Scope/Finalizer";
 import { UIO } from "@fncts/io/IO/definition";
-import { Lazy } from "@fncts/base/data/function";
-import { Exit } from "@fncts/base/data/Exit";
+import { Lazy } from "@fncts/base/data/function/definition";
+import { Exit } from "@fncts/base/data/Exit/definition";
 export declare const ScopeTypeId: unique symbol;
 export declare type ScopeTypeId = typeof ScopeTypeId;
 /**