@fncts/io 0.0.13 → 0.0.16

package/STM/api/core-constructors.d.ts

@@ -1,18 +1,18 @@
 import { STM } from "@fncts/io/STM/definition";
-import { Lazy } from "@fncts/base/data/function";
-import { FiberId } from "@fncts/base/data/FiberId";
+import { Lazy } from "@fncts/base/data/function/definition";
+import { FiberId } from "@fncts/base/data/FiberId/definition";
 /**
  * Returns a value that models failure in the transaction.
  * @tsplus static fncts.io.STMOps failNow
  * @tsplus location "@fncts/io/STM/api/core-constructors"
  */
-export declare function failNow<E>(e: E): STM<never, E, never>;
+export declare function failNow<E>(e: E, __tsplusTrace?: string): STM<never, E, never>;
 /**
  * Returns a value that models failure in the transaction.
  * @tsplus static fncts.io.STMOps fail
  * @tsplus location "@fncts/io/STM/api/core-constructors"
  */
-export declare function fail<E>(e: Lazy<E>): STM<never, E, never>;
+export declare function fail<E>(e: Lazy<E>, __tsplusTrace?: string): STM<never, E, never>;
 /**
  * Returns the fiber id of the fiber committing the transaction.
  * @tsplus static fncts.io.STMOps fiberId
@@ -24,7 +24,7 @@ export declare const fiberId: STM<never, never, FiberId>;
  * @tsplus static fncts.io.STMOps interruptAs
  * @tsplus location "@fncts/io/STM/api/core-constructors"
  */
-export declare function interruptAs(fiberId: FiberId): STM<never, never, never>;
+export declare function interruptAs(fiberId: FiberId, __tsplusTrace?: string): STM<never, never, never>;
 /**
  * @tsplus static fncts.io.STMOps retry
  * @tsplus location "@fncts/io/STM/api/core-constructors"
@@ -36,10 +36,10 @@ export declare const retry: STM<never, never, never>;
  * @tsplus static fncts.io.STMOps __call
  * @tsplus location "@fncts/io/STM/api/core-constructors"
  */
-export declare function succeed<A>(effect: Lazy<A>): STM<never, never, A>;
+export declare function succeed<A>(effect: Lazy<A>, __tsplusTrace?: string): STM<never, never, A>;
 /**
  * Returns an `STM` effect that succeeds with the specified value.
  * @tsplus static fncts.io.STMOps succeedNow
  * @tsplus location "@fncts/io/STM/api/core-constructors"
  */
-export declare function succeedNow<A>(a: A): STM<never, never, A>;
+export declare function succeedNow<A>(a: A, __tsplusTrace?: string): STM<never, never, A>;

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 { Environment } from "@fncts/base/data/Environment";
+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 { 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: Environment<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, Environment<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: Environment<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: Environment<R0>) => STM<R, E, A>): STM<R0 | R, 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,77 +101,77 @@ 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<never, 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
@@ -198,69 +198,69 @@ 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<never, 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<never, 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: Environment<R>): STM<never, 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: Environment<R0>) => Environment<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<never, 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<never, 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
@@ -272,38 +272,38 @@ export declare const interrupt: STM<never, never, never>;
  * @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>;
+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.
  *
@@ -318,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.
  *
@@ -333,32 +333,32 @@ 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<never, 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
@@ -371,4 +371,4 @@ export declare const unit: STM<never, never, void>;
  * @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,5 +1,5 @@
-import { FiberId } from "@fncts/base/data/FiberId";
-import { Environment } from "@fncts/base/data/Environment";
+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 {

package/STM/driver.d.ts

@@ -1,6 +1,6 @@
 import { STM } from "@fncts/io/STM/definition";
-import { Environment } from "@fncts/base/data/Environment";
-import { FiberId } from "@fncts/base/data/FiberId";
+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,7 +1,7 @@
-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";

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/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

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"