@fncts/io 0.0.12 → 0.0.15

package/STM/api.d.ts

@@ -1,11 +1,11 @@
-import { Lazy } from "@fncts/base/data/function";
-import { Maybe } from "@fncts/base/data/Maybe";
-import { Either } from "@fncts/base/data/Either";
-import { FiberId } from "@fncts/base/data/FiberId";
+import { Lazy } from "@fncts/base/data/function/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Either } from "@fncts/base/data/Either/definition";
+import { FiberId } from "@fncts/base/data/FiberId/definition";
+import { Environment } from "@fncts/base/data/Environment/definition";
 import { IO } from "@fncts/io/IO/definition";
-import { Environment } from "@fncts/base/data/Environment";
-import { Refinement } from "@fncts/base/data/Refinement";
-import { Predicate } from "@fncts/base/data/Predicate";
+import { Refinement } from "@fncts/base/data/Refinement/definition";
+import { Predicate } from "@fncts/base/data/Predicate/definition";
 import type { Journal } from "./internal/Journal.js";
 import { STM } from "./definition.js";
 /**
@@ -13,60 +13,60 @@ import { STM } from "./definition.js";
  * @tsplus fluent fncts.io.STM as
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function as_<R, E, A, B>(stm: STM<R, E, A>, b: Lazy<B>): STM<R, E, B>;
+export declare function as_<R, E, A, B>(stm: STM<R, E, A>, b: Lazy<B>, __tsplusTrace?: string): STM<R, E, B>;
 /**
  * Maps the success value of this effect to an optional value.
  * @tsplus getter fncts.io.STM asJust
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function asJust<R, E, A>(stm: STM<R, E, A>): STM<R, E, Maybe<A>>;
+export declare function asJust<R, E, A>(stm: STM<R, E, A>, __tsplusTrace?: string): STM<R, E, Maybe<A>>;
 /**
  * Maps the error value of this effect to an optional value.
  * @tsplus getter fncts.io.STM asJustError
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function asJustError<R, E, A>(stm: STM<R, E, A>): STM<R, Maybe<E>, A>;
+export declare function asJustError<R, E, A>(stm: STM<R, E, A>, __tsplusTrace?: string): STM<R, Maybe<E>, A>;
 /**
  * Submerges the error case of an `Either` into the `STM`. The inverse
  * operation of `STM.either`.
  * @tsplus getter fncts.io.STM absolve
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function absolve<R, E, E1, A>(z: STM<R, E, Either<E1, A>>): STM<R, E | E1, A>;
+export declare function absolve<R, E, E1, A>(z: STM<R, E, Either<E1, A>>, __tsplusTrace?: string): STM<R, E | E1, A>;
 /**
  * @tsplus static fncts.io.STMOps Effect
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function makeEffect<R, E, A>(f: (journal: Journal, fiberId: FiberId, r: R) => A): STM<R, E, A>;
+export declare function makeEffect<R, E, A>(f: (journal: Journal, fiberId: FiberId, r: Environment<R>) => A, __tsplusTrace?: string): STM<R, E, A>;
 /**
  * Retrieves the environment inside an stm.
  * @tsplus static fncts.io.STMOps environment
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function environment<R>(): STM<R, never, R>;
+export declare function environment<R>(__tsplusTrace?: string): STM<R, never, Environment<R>>;
 /**
  * Accesses the environment of the transaction.
  * @tsplus static fncts.io.STMOps environmentWith
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function environmentWith<R, A>(f: (r: R) => A): STM<R, never, A>;
+export declare function environmentWith<R, A>(f: (r: Environment<R>) => A, __tsplusTrace?: string): STM<R, never, A>;
 /**
  * Accesses the environment of the transaction to perform a transaction.
  * @tsplus static fncts.io.STMOps environmentWithSTM
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function environmentWithSTM<R0, R, E, A>(f: (r: R0) => STM<R, E, A>): STM<R & R0, E, A>;
+export declare function environmentWithSTM<R0, R, E, A>(f: (r: Environment<R0>) => STM<R, E, A>, __tsplusTrace?: string): STM<R0 | R, E, A>;
 /**
  * @tsplus static fncts.io.STMOps atomically
  * @tsplus getter fncts.io.STM commit
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function atomically<R, E, A>(stm: STM<R, E, A>): IO<R, E, A>;
+export declare function atomically<R, E, A>(stm: STM<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * Returns an `STM` effect whose failure and success channels have been mapped by
  * the specified pair of functions, `f` and `g`.
  */
-export declare function bimap_<R, E, A, E1, B>(stm: STM<R, E, A>, g: (e: E) => E1, f: (a: A) => B): STM<R, E1, B>;
+export declare function bimap_<R, E, A, E1, B>(stm: STM<R, E, A>, g: (e: E) => E1, f: (a: A) => B, __tsplusTrace?: string): STM<R, E1, B>;
 /**
  * Recovers from specified error.
  * @tsplus fluent fncts.io.STM catch
@@ -74,7 +74,7 @@ export declare function bimap_<R, E, A, E1, B>(stm: STM<R, E, A>, g: (e: E) => E
  */
 export declare function catch_<N extends keyof E, K extends E[N] & string, E, R, A, R1, E1, A1>(stm: STM<R, E, A>, tag: N, k: K, f: (e: Extract<E, {
     [n in N]: K;
-}>) => STM<R1, E1, A1>): STM<R & R1, Exclude<E, {
+}>) => STM<R1, E1, A1>, __tsplusTrace?: string): STM<R | R1, Exclude<E, {
     [n in N]: K;
 }> | E1, A | A1>;
 /**
@@ -82,7 +82,7 @@ export declare function catch_<N extends keyof E, K extends E[N] & string, E, R,
  * @tsplus fluent fncts.io.STM catchJust
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function catchJust_<R, E, A, R1, E1, B>(stm: STM<R, E, A>, f: (e: E) => Maybe<STM<R1, E1, B>>): STM<R1 & R, E | E1, A | B>;
+export declare function catchJust_<R, E, A, R1, E1, B>(stm: STM<R, E, A>, f: (e: E) => Maybe<STM<R1, E1, B>>, __tsplusTrace?: string): STM<R1 | R, E | E1, A | B>;
 /**
  * Recovers from specified error.
  * @tsplus fluent fncts.io.STM catchTag
@@ -92,7 +92,7 @@ export declare function catchTag_<K extends E["_tag"] & string, E extends {
     _tag: string;
 }, R, A, R1, E1, A1>(stm: STM<R, E, A>, k: K, f: (e: Extract<E, {
     _tag: K;
-}>) => STM<R1, E1, A1>): STM<R & R1, Exclude<E, {
+}>) => STM<R1, E1, A1>, __tsplusTrace?: string): STM<R | R1, Exclude<E, {
     _tag: K;
 }> | E1, A | A1>;
 /**
@@ -101,84 +101,84 @@ export declare function catchTag_<K extends E["_tag"] & string, E extends {
  * @tsplus fluent fncts.io.STM flatMapError
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function chainError_<R, E, A, R2, E2>(stm: STM<R, E, A>, f: (e: E) => STM<R2, never, E2>): STM<R2 & R, E2, A>;
+export declare function chainError_<R, E, A, R2, E2>(stm: STM<R, E, A>, f: (e: E) => STM<R2, never, E2>, __tsplusTrace?: string): STM<R2 | R, E2, A>;
 /**
  * Checks the condition, and if it's true, returns unit, otherwise, retries.
  * @tsplus static fncts.io.STMOps check
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function check(predicate: () => boolean): STM<unknown, never, void>;
+export declare function check(predicate: () => boolean, __tsplusTrace?: string): STM<never, never, void>;
 /**
  * Commits this transaction atomically, regardless of whether the transaction
  * is a success or a failure.
  */
-export declare function commitEither<R, E, A>(stm: STM<R, E, A>): IO<R, E, A>;
+export declare function commitEither<R, E, A>(stm: STM<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * Fail with `e` if the supplied `PartialFunction` does not match, otherwise
  * succeed with the returned value.
  * @tsplus fluent fncts.io.STM continueOrFail
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function continueOrFail_<R, E, E1, A, A2>(fa: STM<R, E, A>, e: Lazy<E1>, pf: (a: A) => Maybe<A2>): STM<R, E | E1, A2>;
+export declare function continueOrFail_<R, E, E1, A, A2>(fa: STM<R, E, A>, e: Lazy<E1>, pf: (a: A) => Maybe<A2>, __tsplusTrace?: string): STM<R, E | E1, A2>;
 /**
  * Fail with `e` if the supplied `PartialFunction` does not match, otherwise
  * continue with the returned value.
  * @tsplus fluent fncts.io.STM continueOrFailSTM
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function continueOrFailSTM_<R, E, E1, A, R2, E2, A2>(fa: STM<R, E, A>, e: Lazy<E1>, pf: (a: A) => Maybe<STM<R2, E2, A2>>): STM<R2 & R, E | E1 | E2, A2>;
+export declare function continueOrFailSTM_<R, E, E1, A, R2, E2, A2>(fa: STM<R, E, A>, e: Lazy<E1>, pf: (a: A) => Maybe<STM<R2, E2, A2>>, __tsplusTrace?: string): STM<R2 | R, E | E1 | E2, A2>;
 /**
  * Fail with `e` if the supplied `PartialFunction` does not match, otherwise
  * succeed with the returned value.
  * @tsplus fluent fncts.io.STM continueOrRetry
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function continueOrRetry_<R, E, A, A2>(fa: STM<R, E, A>, pf: (a: A) => Maybe<A2>): STM<R, E, A2>;
+export declare function continueOrRetry_<R, E, A, A2>(fa: STM<R, E, A>, pf: (a: A) => Maybe<A2>, __tsplusTrace?: string): STM<R, E, A2>;
 /**
  * Simultaneously filters and flatMaps the value produced by this effect.
  * Continues on the effect returned from pf.
  * @tsplus fluent fncts.io.STM continueOrRetrySTM
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function continueOrRetrySTM_<R, E, A, R2, E2, A2>(fa: STM<R, E, A>, pf: (a: A) => Maybe<STM<R2, E2, A2>>): STM<R2 & R, E | E2, A2>;
+export declare function continueOrRetrySTM_<R, E, A, R2, E2, A2>(fa: STM<R, E, A>, pf: (a: A) => Maybe<STM<R2, E2, A2>>, __tsplusTrace?: string): STM<R2 | R, E | E2, A2>;
 /**
  * Suspends creation of the specified transaction lazily.
  * @tsplus static fncts.io.STMOps defer
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function defer<R, E, A>(make: Lazy<STM<R, E, A>>): STM<R, E, A>;
+export declare function defer<R, E, A>(make: Lazy<STM<R, E, A>>, __tsplusTrace?: string): STM<R, E, A>;
 /**
  * Converts the failure channel into an `Either`.
  * @tsplus getter fncts.io.STM either
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function either<R, E, A>(stm: STM<R, E, A>): STM<R, never, Either<E, A>>;
+export declare function either<R, E, A>(stm: STM<R, E, A>, __tsplusTrace?: string): STM<R, never, Either<E, A>>;
 /**
  * Returns an effect that ignores errors and runs repeatedly until it eventually succeeds.
  * @tsplus getter fncts.io.STM eventually
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function eventually<R, E, A>(stm: STM<R, E, A>): STM<R, never, A>;
+export declare function eventually<R, E, A>(stm: STM<R, E, A>, __tsplusTrace?: string): STM<R, never, A>;
 /**
  * Simultaneously filters and maps the value produced by this effect.
  * @tsplus fluent fncts.io.STM filterMap
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function filterMap_<R, E, A, B>(stm: STM<R, E, A>, f: (a: A) => Maybe<B>): STM<R, E, B>;
+export declare function filterMap_<R, E, A, B>(stm: STM<R, E, A>, f: (a: A) => Maybe<B>, __tsplusTrace?: string): STM<R, E, B>;
 /**
  * Simultaneously filters and chains the value produced by this effect.
  * Continues on the effect returned from f.
  * @tsplus fluent fncts.io.STM filterMapSTM
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function filterMapSTM_<R, E, A, R1, E1, B>(self: STM<R, E, A>, f: (a: A) => Maybe<STM<R1, E1, B>>): STM<R & R1, E | E1, B>;
+export declare function filterMapSTM_<R, E, A, R1, E1, B>(self: STM<R, E, A>, f: (a: A) => Maybe<STM<R1, E1, B>>, __tsplusTrace?: string): STM<R | R1, E | E1, B>;
 /**
  * Applies `or` if the predicate fails.
  * @tsplus fluent fncts.io.STM filterOrElse
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function filterOrElse_<R, E, A, B extends A, R2, E2, A2>(fa: STM<R, E, A>, p: Refinement<A, B>, or: (a: Exclude<A, B>) => STM<R2, E2, A2>): STM<R & R2, E | E2, B | A2>;
-export declare function filterOrElse_<R, E, A, R2, E2, A2>(fa: STM<R, E, A>, p: Predicate<A>, or: (a: A) => STM<R2, E2, A2>): STM<R & R2, E | E2, A | A2>;
+export declare function filterOrElse_<R, E, A, B extends A, R2, E2, A2>(fa: STM<R, E, A>, p: Refinement<A, B>, or: (a: Exclude<A, B>) => STM<R2, E2, A2>): STM<R | R2, E | E2, B | A2>;
+export declare function filterOrElse_<R, E, A, R2, E2, A2>(fa: STM<R, E, A>, p: Predicate<A>, or: (a: A) => STM<R2, E2, A2>): STM<R | R2, E | E2, A | A2>;
 /**
  * Fails with `failWith` if the predicate fails.
  * @tsplus fluent fncts.io.STM filterOrFail
@@ -198,124 +198,112 @@ export declare function filterOrHalt_<R, E, A>(fa: STM<R, E, A>, p: Predicate<A>
  * @tsplus getter fncts.io.STM flatten
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function flatten<R, E, R1, E1, B>(stm: STM<R, E, STM<R1, E1, B>>): STM<R1 & R, E | E1, B>;
+export declare function flatten<R, E, R1, E1, B>(stm: STM<R, E, STM<R1, E1, B>>, __tsplusTrace?: string): STM<R1 | R, E | E1, B>;
 /**
  * Unwraps the optional error, defaulting to the provided value.
  * @tsplus fluent fncts.io.STM flattenErrorOption
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function flattenErrorOption_<R, E, A, E2>(stm: STM<R, Maybe<E>, A>, def: Lazy<E2>): STM<R, E | E2, A>;
+export declare function flattenErrorOption_<R, E, A, E2>(stm: STM<R, Maybe<E>, A>, def: Lazy<E2>, __tsplusTrace?: string): STM<R, E | E2, A>;
 /**
  * Applies the function `f` to each element of the `Iterable<A>` and
  * returns a transactional effect that produces a new `ReadonlyArray<B>`.
  * @tsplus static fncts.io.STMOps foreach
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function foreach_<A, R, E, B>(it: Iterable<A>, f: (a: A) => STM<R, E, B>): STM<R, E, readonly B[]>;
+export declare function foreach_<A, R, E, B>(it: Iterable<A>, f: (a: A) => STM<R, E, B>, __tsplusTrace?: string): STM<R, E, readonly B[]>;
 /**
  * Lifts an `Either` into a `STM`.
  * @tsplus static fncts.io.STMOps fromEither
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function fromEither<E, A>(e: Lazy<Either<E, A>>): STM<unknown, E, A>;
+export declare function fromEither<E, A>(e: Lazy<Either<E, A>>, __tsplusTrace?: string): STM<never, E, A>;
 /**
  * Lifts an `Either` into a `STM`.
  * @tsplus static fncts.io.STMOps fromEitherNow
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function fromEitherNow<E, A>(e: Either<E, A>): STM<unknown, E, A>;
+export declare function fromEitherNow<E, A>(e: Either<E, A>, __tsplusTrace?: string): STM<never, E, A>;
 /**
  * Unwraps the optional success of this effect, but can fail with an None value.
  */
-export declare function get<R, E, A>(stm: STM<R, E, Maybe<A>>): STM<R, Maybe<E>, A>;
+export declare function get<R, E, A>(stm: STM<R, E, Maybe<A>>, __tsplusTrace?: string): STM<R, Maybe<E>, A>;
 /**
  * Provides the transaction its required environment, which eliminates
  * its dependency on `R`.
  * @tsplus fluent fncts.io.STM provideEnvironment
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function provideEnvironment_<R, E, A>(stm: STM<R, E, A>, r: R): STM<unknown, E, A>;
+export declare function provideEnvironment_<R, E, A>(stm: STM<R, E, A>, r: Environment<R>, __tsplusTrace?: string): STM<never, E, A>;
 /**
  * Provides some of the environment required to run this effect,
  * leaving the remainder `R0`.
  * @tsplus fluent fncts.io.STM contramapEnvironment
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function contramapEnvironment_<R, E, A, R0>(self: STM<R, E, A>, f: (r: R0) => R): STM<R0, E, A>;
+export declare function contramapEnvironment_<R, E, A, R0>(self: STM<R, E, A>, f: (r: Environment<R0>) => Environment<R>, __tsplusTrace?: string): STM<R0, E, A>;
 /**
  * Halts the fiber running the effect.
  * @tsplus static fncts.io.STMOps halt
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function halt(u: Lazy<unknown>): STM<unknown, never, never>;
+export declare function halt(u: Lazy<unknown>, __tsplusTrace?: string): STM<never, never, never>;
 /**
  * Halts the fiber running the effect.
  * @tsplus static fncts.io.STMOps haltNow
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function haltNow(u: unknown): STM<unknown, never, never>;
+export declare function haltNow(u: unknown, __tsplusTrace?: string): STM<never, never, never>;
 /**
  * Returns a successful effect with the head of the list if the list is
  * non-empty or fails with the error `None` if the list is empty.
  * @tsplus getter fncts.io.STM head
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function head<R, E, A>(stm: STM<R, E, Iterable<A>>): STM<R, Maybe<E>, A>;
+export declare function head<R, E, A>(stm: STM<R, E, Iterable<A>>, __tsplusTrace?: string): STM<R, Maybe<E>, A>;
 /**
  * Interrupts the fiber running the effect.
  * @tsplus static fncts.io.STMOps interrupt
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare const interrupt: STM<unknown, never, never>;
+export declare const interrupt: STM<never, never, never>;
 /**
  * Returns whether this effect is a failure.
  * @tsplus getter fncts.io.STM isFailure
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function isFailure<R, E, A>(stm: STM<R, E, A>): STM<R, never, boolean>;
+export declare function isFailure<R, E, A>(stm: STM<R, E, A>, __tsplusTrace?: string): STM<R, never, boolean>;
 /**
  * Returns whether this effect is a success.
  * @tsplus getter fncts.io.STM isSuccess
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function isSuccess<R, E, A>(stm: STM<R, E, A>): STM<R, never, boolean>;
-/**
- * Depending on provided environment returns either this one or the other effect.
- * @tsplus fluent fncts.io.STM join
- * @tsplus location "@fncts/io/STM/api"
- */
-export declare function join_<R, E, A, R1, E1, A1>(stm: STM<R, E, A>, that: STM<R1, E1, A1>): STM<Either<R, R1>, E | E1, A | A1>;
-/**
- * Depending on provided environment returns either this one or the other effect.
- * @tsplus fluent fncts.io.STM joinEither
- * @tsplus location "@fncts/io/STM/api"
- */
-export declare function joinEither_<R, E, A, R1, E1, A1>(stm: STM<R, E, A>, that: STM<R1, E1, A1>): STM<Either<R, R1>, E | E1, Either<A, A1>>;
+export declare function isSuccess<R, E, A>(stm: STM<R, E, A>, __tsplusTrace?: string): STM<R, never, boolean>;
 /**
  * Returns a successful effect if the value is `Left`, or fails with the error `None`.
  * @tsplus getter fncts.io.STM left
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function left<R, E, B, C>(stm: STM<R, E, Either<B, C>>): STM<R, Maybe<E>, B>;
+export declare function left<R, E, B, C>(stm: STM<R, E, Either<B, C>>, __tsplusTrace?: string): STM<R, Maybe<E>, B>;
 /**
  * Returns a successful effect if the value is `Left`, or fails with the error e.
  * @tsplus fluent fncts.io.STM leftOrFail
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function leftOrFail_<R, E, B, C, E1>(stm: STM<R, E, Either<B, C>>, orFail: (c: C) => E1): STM<R, E | E1, B>;
+export declare function leftOrFail_<R, E, B, C, E1>(stm: STM<R, E, Either<B, C>>, orFail: (c: C) => E1, __tsplusTrace?: string): STM<R, E | E1, B>;
 /**
  * Maps from one error type to another.
  * @tsplus fluent fncts.io.STM mapError
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function mapError_<R, E, A, E1>(stm: STM<R, E, A>, f: (a: E) => E1): STM<R, E1, A>;
+export declare function mapError_<R, E, A, E1>(stm: STM<R, E, A>, f: (a: E) => E1, __tsplusTrace?: string): STM<R, E1, A>;
 /**
  * Folds over the `STM` effect, handling both failure and success, but not
  * retry.
  * @tsplus fluent fncts.io.STM match
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function match_<R, E, A, B, C>(stm: STM<R, E, A>, g: (e: E) => C, f: (a: A) => B): STM<R, never, B | C>;
+export declare function match_<R, E, A, B, C>(stm: STM<R, E, A>, g: (e: E) => C, f: (a: A) => B, __tsplusTrace?: string): STM<R, never, B | C>;
 /**
  * Repeats this `STM` effect until its result satisfies the specified predicate.
  *
@@ -330,7 +318,7 @@ export declare function match_<R, E, A, B, C>(stm: STM<R, E, A>, g: (e: E) => C,
  * @tsplus fluent fncts.io.STM repeatUntil
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function repeatUntil_<R, E, A>(stm: STM<R, E, A>, f: (a: A) => boolean): STM<R, E, A>;
+export declare function repeatUntil_<R, E, A>(stm: STM<R, E, A>, f: (a: A) => boolean, __tsplusTrace?: string): STM<R, E, A>;
 /**
  * Repeats this `STM` effect while its result satisfies the specified predicate.
  *
@@ -345,42 +333,42 @@ export declare function repeatUntil_<R, E, A>(stm: STM<R, E, A>, f: (a: A) => bo
  * @tsplus fluent fncts.io.STM repeatWhile
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function repeatWhile_<R, E, A>(stm: STM<R, E, A>, f: (a: A) => boolean): STM<R, E, A>;
+export declare function repeatWhile_<R, E, A>(stm: STM<R, E, A>, f: (a: A) => boolean, __tsplusTrace?: string): STM<R, E, A>;
 /**
  * Returns an effect that swaps the error/success cases. This allows you to
  * use all methods on the error channel, possibly before flipping back.
  * @tsplus getter fncts.io.STM swap
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function swap<R, E, A>(stm: STM<R, E, A>): STM<R, A, E>;
+export declare function swap<R, E, A>(stm: STM<R, E, A>, __tsplusTrace?: string): STM<R, A, E>;
 /**
  * Swaps the error/value parameters, applies the function `f` and flips the parameters back
  * @tsplus fluent fncts.io.STM swapWith
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function swapWith_<R, E, A, R2, E2, A2>(stm: STM<R, E, A>, f: (stm: STM<R, A, E>) => STM<R2, A2, E2>): STM<R2, E2, A2>;
+export declare function swapWith_<R, E, A, R2, E2, A2>(stm: STM<R, E, A>, f: (stm: STM<R, A, E>) => STM<R2, A2, E2>, __tsplusTrace?: string): STM<R2, E2, A2>;
 /**
  * "Peeks" at the success of transactional effect.
  * @tsplus fluent fncts.io.STM tap
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function tap_<R, E, A, R1, E1, B>(stm: STM<R, E, A>, f: (a: A) => STM<R1, E1, B>): STM<R1 & R, E | E1, A>;
+export declare function tap_<R, E, A, R1, E1, B>(stm: STM<R, E, A>, f: (a: A) => STM<R1, E1, B>, __tsplusTrace?: string): STM<R1 | R, E | E1, A>;
 /**
  * Returns an effect with the value on the left part.
  * @tsplus static fncts.io.STMOps toLeft
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function toLeft<A>(a: Lazy<A>): STM<unknown, never, Either<A, never>>;
+export declare function toLeft<A>(a: Lazy<A>, __tsplusTrace?: string): STM<never, never, Either<A, never>>;
 /**
  * Returns an `STM` effect that succeeds with `Unit`.
  * @tsplus static fncts.io.STMOps unit
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare const unit: STM<unknown, never, void>;
+export declare const unit: STM<never, never, void>;
 /**
  * Sequentially zips this value with the specified one, combining the values
  * using the specified combiner function.
  * @tsplus fluent fncts.io.STM zipWith
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function zipWith_<R, E, A, R1, E1, B, C>(self: STM<R, E, A>, that: STM<R1, E1, B>, f: (a: A, b: B) => C): STM<R & R1, E | E1, C>;
+export declare function zipWith_<R, E, A, R1, E1, B, C>(self: STM<R, E, A>, that: STM<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): STM<R | R1, E | E1, C>;

package/STM/definition.d.ts

@@ -1,4 +1,5 @@
-import { FiberId } from "@fncts/base/data/FiberId";
+import { FiberId } from "@fncts/base/data/FiberId/definition";
+import { Environment } from "@fncts/base/data/Environment/definition";
 import type { Journal } from "./internal/Journal.js";
 import type { _A, _E, _R } from "@fncts/base/types";
 export declare const enum STMTag {
@@ -18,7 +19,7 @@ export declare type STMTypeId = typeof STMTypeId;
  */
 export declare abstract class STM<R, E, A> {
     readonly _typeId: STMTypeId;
-    readonly _R: (_: R) => void;
+    readonly _R: () => R;
     readonly _E: () => E;
     readonly _A: () => A;
 }
@@ -29,12 +30,12 @@ export declare function unifySTM<X extends STM<any, any, any>>(self: X): STM<_R<
 /**
  * @tsplus type fncts.io.STM
  */
-export interface USTM<A> extends STM<unknown, never, A> {
+export interface USTM<A> extends STM<never, never, A> {
 }
 export declare class Effect<R, E, A> extends STM<R, E, A> {
-    readonly f: (journal: Journal, fiberId: FiberId, r: R) => A;
+    readonly f: (journal: Journal, fiberId: FiberId, r: Environment<R>) => A;
     readonly _tag = STMTag.Effect;
-    constructor(f: (journal: Journal, fiberId: FiberId, r: R) => A);
+    constructor(f: (journal: Journal, fiberId: FiberId, r: Environment<R>) => A);
 }
 export declare class OnFailure<R, E, A, E1> extends STM<R, E1, A> {
     readonly stm: STM<R, E, A>;
@@ -56,21 +57,21 @@ export declare class OnSuccess<R, E, A, B> extends STM<R, E, B> {
     readonly _tag = STMTag.OnSuccess;
     constructor(stm: STM<R, E, A>, apply: (a: A) => STM<R, E, B>);
 }
-export declare class Succeed<A> extends STM<unknown, never, A> {
+export declare class Succeed<A> extends STM<never, never, A> {
     readonly a: () => A;
     readonly _tag = STMTag.Succeed;
     constructor(a: () => A);
 }
-export declare class SucceedNow<A> extends STM<unknown, never, A> {
+export declare class SucceedNow<A> extends STM<never, never, A> {
     readonly a: A;
     readonly _tag = STMTag.SucceedNow;
     constructor(a: A);
 }
 export declare class ContramapEnvironment<R, E, A, R0> extends STM<R0, E, A> {
     readonly stm: STM<R, E, A>;
-    readonly f: (_: R0) => R;
+    readonly f: (_: Environment<R0>) => Environment<R>;
     readonly _tag = STMTag.ContramapEnvironment;
-    constructor(stm: STM<R, E, A>, f: (_: R0) => R);
+    constructor(stm: STM<R, E, A>, f: (_: Environment<R0>) => Environment<R>);
 }
 export declare function concrete<R, E, A>(_: STM<R, E, A>): asserts _ is Effect<R, E, A> | OnFailure<R, unknown, A, E> | OnSuccess<R, E, unknown, A> | OnRetry<R, E, A> | Succeed<A> | SucceedNow<A> | ContramapEnvironment<unknown, E, A, R>;
 export declare const FailExceptionTypeId: unique symbol;

package/STM/driver.d.ts

@@ -1,6 +1,6 @@
 import { STM } from "@fncts/io/STM/definition";
-import { FiberId } from "@fncts/base/data/FiberId";
-import { Environment } from "@fncts/base/data/Environment";
+import { Environment } from "@fncts/base/data/Environment/definition";
+import { FiberId } from "@fncts/base/data/FiberId/definition";
 import { TExit } from "@fncts/io/TExit/definition";
 import type { Journal } from "./internal/Journal.js";
 export declare class STMDriver<R, E, A> {

package/STM/internal/CommitState.d.ts

@@ -1,4 +1,4 @@
-import { Exit } from "@fncts/base/data/Exit";
+import { Exit } from "@fncts/base/data/Exit/definition";
 import { TExit } from "@fncts/io/TExit/definition";
 export interface Done<E, A> {
     readonly _tag: "Done";

package/STM/internal/Journal.d.ts

@@ -1,11 +1,12 @@
-import { Exit } from "@fncts/base/data/Exit";
-import { FiberId } from "@fncts/base/data/FiberId";
+import { Exit } from "@fncts/base/data/Exit/definition";
+import { FiberId } from "@fncts/base/data/FiberId/definition";
 import { STM } from "@fncts/io/STM/definition";
-import { Environment } from "@fncts/base/data/Environment";
+import { Environment } from "@fncts/base/data/Environment/definition";
 import { IO } from "@fncts/io/IO/definition";
 import type { Entry } from "./Entry.js";
 import type { TryCommit } from "./TryCommit.js";
 import type { AtomicReference } from "@fncts/base/internal/AtomicReference";
+import type { Scheduler } from "@fncts/io/internal/Scheduler";
 import type { Atomic } from "@fncts/io/TRef";
 import type { TxnId } from "@fncts/io/TxnId";
 import { CommitState } from "./CommitState.js";
@@ -72,7 +73,7 @@ export declare function execTodos(todos: Map<TxnId, Todo>): void;
  * @tsplus fluent fncts.io.Journal completeTodos
  * @tsplus location "@fncts/io/STM/internal/Journal"
  */
-export declare function completeTodos<E, A>(journal: Journal, exit: Exit<E, A>): Done<E, A>;
+export declare function completeTodos<E, A>(journal: Journal, exit: Exit<E, A>, scheduler: Scheduler): Done<E, A>;
 /**
  * For the given transaction id, adds the specified todo effect to all
  * `TRef` values.
@@ -84,8 +85,8 @@ export declare function addTodo(journal: Journal, txnId: TxnId, todoEffect: Todo
  * Finds all the new todo targets that are not already tracked in the `oldJournal`.
  */
 export declare function untrackedTodoTargets(oldJournal: Journal, newJournal: Journal): Journal;
-export declare function tryCommitSync<R, E, A>(fiberId: FiberId, stm: STM<R, E, A>, r: Environment<R>): TryCommit<E, A>;
-export declare function tryCommitAsync<R, E, A>(journal: Journal | undefined, fiberId: FiberId, stm: STM<R, E, A>, txnId: TxnId, state: AtomicReference<CommitState<E, A>>, r: Environment<R>): (k: (_: IO<R, E, A>) => unknown) => void;
+export declare function tryCommitSync<R, E, A>(fiberId: FiberId, stm: STM<R, E, A>, r: Environment<R>, scheduler: Scheduler): TryCommit<E, A>;
+export declare function tryCommitAsync<R, E, A>(journal: Journal | undefined, fiberId: FiberId, stm: STM<R, E, A>, txnId: TxnId, state: AtomicReference<CommitState<E, A>>, r: Environment<R>, scheduler: Scheduler): (k: (_: IO<R, E, A>) => unknown) => void;
 /**
  * Determines if the journal is valid.
  * @tsplus getter fncts.io.Journal isValid

package/STM/internal/TryCommit.d.ts

@@ -1,4 +1,4 @@
-import { Exit } from "@fncts/base/data/Exit";
+import { Exit } from "@fncts/base/data/Exit/definition";
 import type { Journal } from "./Journal.js";
 export declare const TryCommitTypeId: unique symbol;
 export declare type TryCommitTypeId = typeof TryCommitTypeId;

package/Schedule/Decision.d.ts

@@ -1,12 +1,13 @@
+import { Intervals } from "@fncts/base/data/Intervals";
 import { Interval } from "@fncts/base/data/Interval";
 export declare const enum DecisionTag {
     Continue = "Continue",
     Done = "Done"
 }
 export declare class Continue {
-    readonly interval: Interval;
+    readonly interval: Intervals;
     readonly _tag = DecisionTag.Continue;
-    constructor(interval: Interval);
+    constructor(interval: Intervals);
 }
 export declare class Done {
     readonly _tag = DecisionTag.Done;
@@ -30,9 +31,14 @@ export declare const done: Decision;
  * @tsplus static fncts.io.Schedule.DecisionOps Continue
  * @tsplus location "@fncts/io/Schedule/Decision"
  */
-export declare function continue_(interval: Interval): Decision;
+export declare function continue_(interval: Intervals): Decision;
+/**
+ * @tsplus static fncts.io.Schedule.DecisionOps continueWith
+ * @tsplus location "@fncts/io/Schedule/Decision"
+ */
+export declare function continueWith(interval: Interval): Decision;
 /**
  * @tsplus fluent fncts.io.Schedule.Decision match
  * @tsplus location "@fncts/io/Schedule/Decision"
  */
-export declare function match_<A, B>(self: Decision, onDone: () => A, onContinue: (interval: Interval) => B): A | B;
+export declare function match_<A, B>(self: Decision, onDone: () => A, onContinue: (interval: Intervals) => B): A | B;

package/Schedule/Driver.d.ts

@@ -1,5 +1,5 @@
 import { IO, UIO } from "@fncts/io/IO/definition";
-import { Nothing } from "@fncts/base/data/Maybe";
+import { Nothing } from "@fncts/base/data/Maybe/definition";
 import { NoSuchElementError } from "@fncts/base/data/exceptions";
 /**
  * @tsplus type fncts.io.Schedule.Driver
@@ -7,13 +7,13 @@ import { NoSuchElementError } from "@fncts/base/data/exceptions";
  */
 export declare class Driver<State, Env, In, Out> {
     readonly next: (inp: In, __tsplusTrace?: string) => IO<Env, Nothing, Out>;
-    readonly last: IO<unknown, NoSuchElementError, Out>;
+    readonly last: IO<never, NoSuchElementError, Out>;
     readonly reset: UIO<void>;
     readonly state: UIO<State>;
-    constructor(next: (inp: In, __tsplusTrace?: string) => IO<Env, Nothing, Out>, last: IO<unknown, NoSuchElementError, Out>, reset: UIO<void>, state: UIO<State>);
+    constructor(next: (inp: In, __tsplusTrace?: string) => IO<Env, Nothing, Out>, last: IO<never, NoSuchElementError, Out>, reset: UIO<void>, state: UIO<State>);
 }
 /**
  * @tsplus static fncts.io.Schedule.DriverOps __call
  * @tsplus location "@fncts/io/Schedule/Driver"
  */
-export declare function makeDriver<State, Env, In, Out>(next: (inp: In, __tsplusTrace?: string) => IO<Env, Nothing, Out>, last: IO<unknown, NoSuchElementError, Out>, reset: UIO<void>, state: UIO<State>): Driver<State, Env, In, Out>;
+export declare function makeDriver<State, Env, In, Out>(next: (inp: In, __tsplusTrace?: string) => IO<Env, Nothing, Out>, last: IO<never, NoSuchElementError, Out>, reset: UIO<void>, state: UIO<State>): Driver<State, Env, In, Out>;

package/Schedule/api/driver.d.ts

@@ -1,6 +1,6 @@
 import { Schedule } from "@fncts/io/Schedule/definition";
 import { UIO } from "@fncts/io/IO/definition";
-import { Maybe, Nothing } from "@fncts/base/data/Maybe";
+import { Maybe, Nothing } from "@fncts/base/data/Maybe/definition";
 /**
  * @tsplus getter fncts.io.Schedule driver
  * @tsplus location "@fncts/io/Schedule/api/driver"