@fncts/io 0.0.11 → 0.0.14

package/Ref/api/dimap.d.ts

@@ -1,4 +1,4 @@
-import { Either } from "@fncts/base/data/Either";
+import { Either } from "@fncts/base/data/Either/definition";
 import type { PRef } from "../definition.js";
 /**
  * Transforms the `set` value of the `Ref` with the specified function.
@@ -6,7 +6,7 @@ import type { PRef } from "../definition.js";
  * @tsplus fluent fncts.io.Ref.Synchronized contramap
  * @tsplus location "@fncts/io/Ref/api/dimap"
  */
-export declare function contramap_<RA, RB, EA, EB, B, A, C>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: C) => A): PRef<RA, RB, EA, EB, C, B>;
+export declare function contramap_<RA, RB, EA, EB, B, A, C>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: C) => A, __tsplusTrace?: string): PRef<RA, RB, EA, EB, C, B>;
 /**
  * Transforms the `set` value of the `Ref` with the specified fallible
  * function.
@@ -14,7 +14,7 @@ export declare function contramap_<RA, RB, EA, EB, B, A, C>(ref: PRef<RA, RB, EA
  * @tsplus fluent fncts.io.Ref.Synchronized contramapEither
  * @tsplus location "@fncts/io/Ref/api/dimap"
  */
-export declare function contramapEither_<RA, RB, EA, EB, A, B, EC, C>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: C) => Either<EC, A>): PRef<RA, RB, EC | EA, EB, C, B>;
+export declare function contramapEither_<RA, RB, EA, EB, A, B, EC, C>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: C) => Either<EC, A>, __tsplusTrace?: string): PRef<RA, RB, EC | EA, EB, C, B>;
 /**
  * Transforms both the `set` and `get` values of the `Ref` with the
  * specified functions.
@@ -22,7 +22,7 @@ export declare function contramapEither_<RA, RB, EA, EB, A, B, EC, C>(ref: PRef<
  * @tsplus fluent fncts.io.Ref.Synchronized dimap
  * @tsplus location "@fncts/io/Ref/api/dimap"
  */
-export declare function dimap_<RA, RB, EA, EB, A, B, C, D>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: C) => A, g: (_: B) => D): PRef<RA, RB, EA, EB, C, D>;
+export declare function dimap_<RA, RB, EA, EB, A, B, C, D>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: C) => A, g: (_: B) => D, __tsplusTrace?: string): PRef<RA, RB, EA, EB, C, D>;
 /**
  * Transforms both the `set` and `get` values of the `Ref` with the
  * specified fallible functions.
@@ -30,7 +30,7 @@ export declare function dimap_<RA, RB, EA, EB, A, B, C, D>(ref: PRef<RA, RB, EA,
  * @tsplus fluent fncts.io.Ref.Synchronized dimapEither
  * @tsplus location "@fncts/io/Ref/api/dimap"
  */
-export declare function dimapEither_<RA, RB, EA, EB, A, B, C, EC, D, ED>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: C) => Either<EC, A>, g: (_: B) => Either<ED, D>): PRef<RA, RB, EC | EA, ED | EB, C, D>;
+export declare function dimapEither_<RA, RB, EA, EB, A, B, C, EC, D, ED>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: C) => Either<EC, A>, g: (_: B) => Either<ED, D>, __tsplusTrace?: string): PRef<RA, RB, EC | EA, ED | EB, C, D>;
 /**
  * Transforms both the `set` and `get` errors of the `Ref` with the
  * specified functions.
@@ -38,7 +38,7 @@ export declare function dimapEither_<RA, RB, EA, EB, A, B, C, EC, D, ED>(ref: PR
  * @tsplus fluent fncts.io.Ref.Synchronized dimapError
  * @tsplus location "@fncts/io/Ref/api/dimap"
  */
-export declare function dimapError_<RA, RB, EA, EB, A, B, EC, ED>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: EA) => EC, g: (_: EB) => ED): PRef<RA, RB, EC, ED, A, B>;
+export declare function dimapError_<RA, RB, EA, EB, A, B, EC, ED>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: EA) => EC, g: (_: EB) => ED, __tsplusTrace?: string): PRef<RA, RB, EC, ED, A, B>;
 /**
  * Transforms the `get` value of the `Ref` with the specified fallible
  * function.
@@ -46,11 +46,11 @@ export declare function dimapError_<RA, RB, EA, EB, A, B, EC, ED>(ref: PRef<RA,
  * @tsplus fluent fncts.io.Ref.Synchronized mapEither
  * @tsplus location "@fncts/io/Ref/api/dimap"
  */
-export declare function mapEither_<RA, RB, EA, EB, A, B, EC, C>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: B) => Either<EC, C>): PRef<RA, RB, EA, EC | EB, A, C>;
+export declare function mapEither_<RA, RB, EA, EB, A, B, EC, C>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: B) => Either<EC, C>, __tsplusTrace?: string): PRef<RA, RB, EA, EC | EB, A, C>;
 /**
  * Transforms the `get` value of the `Ref` with the specified function.
  * @tsplus fluent fncts.io.Ref map
  * @tsplus fluent fncts.io.Ref.Synchronized map
  * @tsplus location "@fncts/io/Ref/api/dimap"
  */
-export declare function map_<RA, RB, EA, EB, A, B, C>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: B) => C): PRef<RA, RB, EA, EB, A, C>;
+export declare function map_<RA, RB, EA, EB, A, B, C>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: B) => C, __tsplusTrace?: string): PRef<RA, RB, EA, EB, A, C>;

package/Ref/api/filter.d.ts

@@ -1,4 +1,4 @@
-import { Maybe } from "@fncts/base/data/Maybe";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
 import type { PRef } from "../definition.js";
 /**
  * Filters the `set` value of the `Ref` with the specified predicate,
@@ -8,7 +8,7 @@ import type { PRef } from "../definition.js";
  * @tsplus fluent fncts.io.Ref.Synchronized filterInput
  * @tsplus location "@fncts/io/Ref/api/filter"
  */
-export declare function filterInput_<RA, RB, EA, EB, B, A, A1 extends A>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: A1) => boolean): PRef<RA, RB, Maybe<EA>, EB, A1, B>;
+export declare function filterInput_<RA, RB, EA, EB, B, A, A1 extends A>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: A1) => boolean, __tsplusTrace?: string): PRef<RA, RB, Maybe<EA>, EB, A1, B>;
 /**
  * Filters the `get` value of the `Ref` with the specified predicate,
  * returning a `Ref` with a `get` value that succeeds if the predicate is
@@ -17,4 +17,4 @@ export declare function filterInput_<RA, RB, EA, EB, B, A, A1 extends A>(ref: PR
  * @tsplus fluent fncts.io.Ref.Synchronized filterOutput
  * @tsplus location "@fncts/io/Ref/api/filter"
  */
-export declare function filterOutput_<RA, RB, EA, EB, A, B>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: B) => boolean): PRef<RA, RB, EA, Maybe<EB>, A, B>;
+export declare function filterOutput_<RA, RB, EA, EB, A, B>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: B) => boolean, __tsplusTrace?: string): PRef<RA, RB, EA, Maybe<EB>, A, B>;

package/Ref/api/get.d.ts

@@ -6,4 +6,4 @@ import type { PRef } from "../definition.js";
  * @tsplus getter fncts.io.Ref.Synchronized get
  * @tsplus location "@fncts/io/Ref/api/get"
  */
-export declare function get<RA, RB, EA, EB, A, B>(self: PRef<RA, RB, EA, EB, A, B>): IO<RA & RB, EA | EB, B>;
+export declare function get<RA, RB, EA, EB, A, B>(self: PRef<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): IO<RA | RB, EA | EB, B>;

package/Ref/api/match.d.ts

@@ -1,4 +1,4 @@
-import { Either } from "@fncts/base/data/Either";
+import { Either } from "@fncts/base/data/Either/definition";
 import type { PRef } from "../definition.js";
 /**
  * Folds over the error and value types of the `Ref`. This is a highly

package/Ref/api/matchAll.d.ts

@@ -1,4 +1,4 @@
-import { Either } from "@fncts/base/data/Either";
+import { Either } from "@fncts/base/data/Either/definition";
 import type { PRef } from "../definition.js";
 /**
  * Folds over the error and value types of the `Ref`, allowing access to

package/Ref/api/modify.d.ts

@@ -1,5 +1,5 @@
 import { IO } from "@fncts/io/IO/definition";
-import { Maybe } from "@fncts/base/data/Maybe";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
 import type { PRef } from "../definition.js";
 /**
  * Atomically modifies the `Ref` with the specified function, which
@@ -9,7 +9,7 @@ import type { PRef } from "../definition.js";
  * @tsplus fluent fncts.io.Ref.Synchronized modify
  * @tsplus location "@fncts/io/Ref/api/modify"
  */
-export declare function modify_<RA, RB, EA, EB, B, A>(ref: PRef<RA, RB, EA, EB, A, A>, f: (a: A) => readonly [B, A]): IO<RA & RB, EA | EB, B>;
+export declare function modify_<RA, RB, EA, EB, B, A>(ref: PRef<RA, RB, EA, EB, A, A>, f: (a: A) => readonly [B, A], __tsplusTrace?: string): IO<RA | RB, EA | EB, B>;
 /**
  * Atomically modifies the `Ref` with the specified partial function,
  * which computes a return value for the modification if the function is
@@ -19,7 +19,7 @@ export declare function modify_<RA, RB, EA, EB, B, A>(ref: PRef<RA, RB, EA, EB,
  * @tsplus fluent fncts.io.Ref.Synchronized modifyJust
  * @tsplus location "@fncts/io/Ref/api/modify"
  */
-export declare function modifyJust_<RA, RB, EA, EB, A, B>(self: PRef<RA, RB, EA, EB, A, A>, def: B, f: (a: A) => Maybe<readonly [B, A]>): IO<RA & RB, EA | EB, B>;
+export declare function modifyJust_<RA, RB, EA, EB, A, B>(self: PRef<RA, RB, EA, EB, A, A>, def: B, f: (a: A) => Maybe<readonly [B, A]>, __tsplusTrace?: string): IO<RA | RB, EA | EB, B>;
 /**
  * Atomically writes the specified value to the `Ref`, returning the value
  * immediately before modification.
@@ -27,7 +27,7 @@ export declare function modifyJust_<RA, RB, EA, EB, A, B>(self: PRef<RA, RB, EA,
  * @tsplus fluent fncts.io.Ref.Synchronized getAndSet
  * @tsplus location "@fncts/io/Ref/api/modify"
  */
-export declare function getAndSet_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A, A>, a: A): IO<RA & RB, EA | EB, A>;
+export declare function getAndSet_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A, A>, a: A, __tsplusTrace?: string): IO<RA | RB, EA | EB, A>;
 /**
  * Atomically modifies the `Ref` with the specified function, returning
  * the value immediately before modification.
@@ -35,7 +35,7 @@ export declare function getAndSet_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB,
  * @tsplus fluent fncts.io.Ref.Synchronized getAndUpdate
  * @tsplus location "@fncts/io/Ref/api/modify"
  */
-export declare function getAndUpdate_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A, A>, f: (a: A) => A): IO<RA & RB, EA | EB, A>;
+export declare function getAndUpdate_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A, A>, f: (a: A) => A, __tsplusTrace?: string): IO<RA | RB, EA | EB, A>;
 /**
  * Atomically modifies the `Ref` with the specified partial function,
  * returning the value immediately before modification. If the function is
@@ -44,14 +44,14 @@ export declare function getAndUpdate_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA,
  * @tsplus fluent fncts.io.Ref.Synchronized getAndUpdateJust
  * @tsplus location "@fncts/io/Ref/api/modify"
  */
-export declare function getAndUpdateJust_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A, A>, f: (a: A) => Maybe<A>): IO<RA & RB, EA | EB, A>;
+export declare function getAndUpdateJust_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A, A>, f: (a: A) => Maybe<A>, __tsplusTrace?: string): IO<RA | RB, EA | EB, A>;
 /**
  * Atomically modifies the `Ref` with the specified function.
  * @tsplus fluent fncts.io.Ref update
  * @tsplus fluent fncts.io.Ref.Synchronized update
  * @tsplus location "@fncts/io/Ref/api/modify"
  */
-export declare function update_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A, A>, f: (a: A) => A): IO<RA & RB, EA | EB, void>;
+export declare function update_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A, A>, f: (a: A) => A, __tsplusTrace?: string): IO<RA | RB, EA | EB, void>;
 /**
  * Atomically modifies the `Ref` with the specified function and returns
  * the updated value.
@@ -59,7 +59,7 @@ export declare function update_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A,
  * @tsplus fluent fncts.io.Ref.Synchronized updateAndGet
  * @tsplus location "@fncts/io/Ref/api/modify"
  */
-export declare function updateAndGet_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A, A>, f: (a: A) => A): IO<RA & RB, EA | EB, A>;
+export declare function updateAndGet_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A, A>, f: (a: A) => A, __tsplusTrace?: string): IO<RA | RB, EA | EB, A>;
 /**
  * Atomically modifies the `Ref` with the specified partial function. If
  * the function is undefined on the current value it doesn't change it.
@@ -67,7 +67,7 @@ export declare function updateAndGet_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA,
  * @tsplus fluent fncts.io.Ref.Synchronized updateJust
  * @tsplus location "@fncts/io/Ref/api/modify"
  */
-export declare function updateJust_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A, A>, f: (a: A) => Maybe<A>): IO<RA & RB, EA | EB, void>;
+export declare function updateJust_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A, A>, f: (a: A) => Maybe<A>, __tsplusTrace?: string): IO<RA | RB, EA | EB, void>;
 /**
  * Atomically modifies the `Ref` with the specified partial function. If
  * the function is undefined on the current value it returns the old value
@@ -76,4 +76,4 @@ export declare function updateJust_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB
  * @tsplus fluent fncts.io.Ref.Synchronized updateJustAndGet
  * @tsplus location "@fncts/io/Ref/api/modify"
  */
-export declare function updateJustAndGet_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A, A>, f: (a: A) => Maybe<A>): IO<RA & RB, EA | EB, A>;
+export declare function updateJustAndGet_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A, A>, f: (a: A) => Maybe<A>, __tsplusTrace?: string): IO<RA | RB, EA | EB, A>;

package/Ref/api/set.d.ts

@@ -7,4 +7,4 @@ import type { PRef } from "../definition.js";
  * @tsplus fluent fncts.io.Ref.Synchronized set
  * @tsplus location "@fncts/io/Ref/api/set"
  */
-export declare function set_<RA, RB, EA, EB, A, B>(self: PRef<RA, RB, EA, EB, A, B>, a: A): IO<RA & RB, EA | EB, void>;
+export declare function set_<RA, RB, EA, EB, A, B>(self: PRef<RA, RB, EA, EB, A, B>, a: A, __tsplusTrace?: string): IO<RA | RB, EA | EB, void>;

package/Ref/constructors.d.ts

@@ -1,13 +1,13 @@
-import { Lazy } from "@fncts/base/data/function";
+import { Lazy } from "@fncts/base/data/function/definition";
 import { UIO } from "@fncts/io/IO/definition";
 import { Ref } from "@fncts/io/Ref";
 /**
  * @tsplus static fncts.io.RefOps make
  * @tsplus location "@fncts/io/Ref/constructors"
  */
-export declare function make<A>(a: Lazy<A>): UIO<Ref<A>>;
+export declare function make<A>(a: Lazy<A>, __tsplusTrace?: string): UIO<Ref<A>>;
 /**
  * @tsplus static fncts.io.RefOps unsafeMake
  * @tsplus location "@fncts/io/Ref/constructors"
  */
-export declare function unsafeMake<A>(a: A): Ref.Atomic<A>;
+export declare function unsafeMake<A>(a: A, __tsplusTrace?: string): Ref.Atomic<A>;

package/Ref/definition.d.ts

@@ -1,4 +1,4 @@
-import { Either } from "@fncts/base/data/Either";
+import { Either } from "@fncts/base/data/Either/definition";
 import { IO } from "@fncts/io/IO/definition";
 import type { Atomic as Atomic_ } from "./Atomic/Atomic.js";
 import type { Derived } from "./Derived.js";
@@ -11,24 +11,24 @@ export declare type RefTypeId = typeof RefTypeId;
  */
 export interface PRef<RA, RB, EA, EB, A, B> {
     readonly _U: RefTypeId;
-    readonly _RA: (_: RA) => void;
-    readonly _RB: (_: RB) => void;
+    readonly _RA: () => RA;
+    readonly _RB: () => RB;
     readonly _EA: () => EA;
     readonly _EB: () => EB;
     readonly _A: (_: A) => void;
     readonly _B: () => B;
 }
-export declare type Ref<A> = PRef<unknown, unknown, never, never, A, A>;
+export declare type Ref<A> = PRef<never, never, never, never, A, A>;
 export declare type ERef<E, A> = PRef<unknown, unknown, E, E, A, A>;
 export declare namespace PRef {
     type Synchronized<RA, RB, EA, EB, A, B> = Synchro.PSynchronized<RA, RB, EA, EB, A, B>;
 }
 export declare namespace ERef {
-    type Synchronized<E, A> = Synchro.PSynchronized<unknown, unknown, E, E, A, A>;
+    type Synchronized<E, A> = Synchro.PSynchronized<never, never, E, E, A, A>;
 }
 export declare namespace Ref {
     type Atomic<A> = Atomic_<A>;
-    type Synchronized<A> = Synchro.PSynchronized<unknown, unknown, never, never, A, A>;
+    type Synchronized<A> = Synchro.PSynchronized<never, never, never, never, A, A>;
 }
 /**
  * @tsplus type fncts.io.RefOps
@@ -37,13 +37,13 @@ export interface RefOps {
 }
 export declare const Ref: RefOps;
 export declare abstract class RefInternal<RA, RB, EA, EB, A, B> implements PRef<RA, RB, EA, EB, A, B> {
-    readonly _U: RefTypeId;
-    readonly _RA: (_: RA) => void;
-    readonly _RB: (_: RB) => void;
-    readonly _EA: () => EA;
-    readonly _EB: () => EB;
-    readonly _A: (_: A) => void;
-    readonly _B: () => B;
+    _U: RefTypeId;
+    _RA: () => RA;
+    _RB: () => RB;
+    _EA: () => EA;
+    _EB: () => EB;
+    _A: (_: A) => void;
+    _B: () => B;
     /**
      * Folds over the error and value types of the `Ref`. This is a highly
      * polymorphic method that is capable of arbitrarily transforming the error
@@ -57,7 +57,7 @@ export declare abstract class RefInternal<RA, RB, EA, EB, A, B> implements PRef<
      * the state in transforming the `set` value. This is a more powerful version
      * of `match` but requires unifying the error types.
      */
-    abstract matchAll<EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ec: (_: EB) => EC, ca: (_: C) => (_: B) => Either<EC, A>, bd: (_: B) => Either<ED, D>): PRef<RA & RB, RB, EC, ED, C, D>;
+    abstract matchAll<EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ec: (_: EB) => EC, ca: (_: C) => (_: B) => Either<EC, A>, bd: (_: B) => Either<ED, D>): PRef<RA | RB, RB, EC, ED, C, D>;
     /**
      * Reads the value from the `Ref`.
      */
@@ -66,7 +66,7 @@ export declare abstract class RefInternal<RA, RB, EA, EB, A, B> implements PRef<
      * Writes a new value to the `Ref`, with a guarantee of immediate
      * consistency (at some cost to performance).
      */
-    abstract set(a: A): IO<RA, EA, void>;
+    abstract set(a: A, __tsplusTrace?: string): IO<RA, EA, void>;
 }
 /**
  * @tsplus macro remove

package/RuntimeConfig.d.ts

@@ -1,8 +1,8 @@
 import { CaseClass } from "@fncts/base/data/CaseClass";
-import { Cause } from "@fncts/base/data/Cause";
+import { Cause } from "@fncts/base/data/Cause/definition";
 import { Supervisor } from "@fncts/io/Supervisor/definition";
 import { Logger } from "@fncts/io/Logger/definition";
-import { HashSet } from "@fncts/base/collection/immutable/HashSet";
+import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
 export declare const RuntimeConfigFlag: {
     readonly EnableCurrentFiber: symbol;
     readonly LogRuntime: symbol;

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

@@ -4,14 +4,14 @@ import { STM } from "@fncts/io/STM/definition";
  * @tsplus fluent fncts.io.STM catchAll
  * @tsplus location "@fncts/io/STM/api/core-api"
  */
-export declare function catchAll_<R, E, A, R1, E1, B>(self: STM<R, E, A>, f: (e: E) => STM<R1, E1, B>): STM<R1 & R, E1, A | B>;
+export declare function catchAll_<R, E, A, R1, E1, B>(self: STM<R, E, A>, f: (e: E) => STM<R1, E1, B>, __tsplusTrace?: string): STM<R1 | R, E1, A | B>;
 /**
  * Feeds the value produced by this effect to the specified function,
  * and then runs the returned effect as well to produce its results.
  * @tsplus fluent fncts.io.STM flatMap
  * @tsplus location "@fncts/io/STM/api/core-api"
  */
-export declare function flatMap_<R, E, A, R1, E1, B>(self: STM<R, E, A>, f: (a: A) => STM<R1, E1, B>): STM<R1 & R, E | E1, B>;
+export declare function flatMap_<R, E, A, R1, E1, B>(self: STM<R, E, A>, f: (a: A) => STM<R1, E1, B>, __tsplusTrace?: string): STM<R1 | R, E | E1, B>;
 /**
  * Executes the specified finalization transaction whether or
  * not this effect succeeds. Note that as with all STM transactions,
@@ -19,17 +19,17 @@ export declare function flatMap_<R, E, A, R1, E1, B>(self: STM<R, E, A>, f: (a:
  * @tsplus fluent fncts.io.STM ensuring
  * @tsplus location "@fncts/io/STM/api/core-api"
  */
-export declare function ensuring_<R, E, A, R1, B>(self: STM<R, E, A>, finalizer: STM<R1, never, B>): STM<R & R1, E, A>;
+export declare function ensuring_<R, E, A, R1, B>(self: STM<R, E, A>, finalizer: STM<R1, never, B>, __tsplusTrace?: string): STM<R | R1, E, A>;
 /**
  * Maps the value produced by the effect.
  * @tsplus fluent fncts.io.STM map
  * @tsplus location "@fncts/io/STM/api/core-api"
  */
-export declare function map_<R, E, A, B>(self: STM<R, E, A>, f: (a: A) => B): STM<R, E, B>;
+export declare function map_<R, E, A, B>(self: STM<R, E, A>, f: (a: A) => B, __tsplusTrace?: string): STM<R, E, B>;
 /**
  * Effectfully folds over the `STM` effect, handling both failure and
  * success.
  * @tsplus fluent fncts.io.STM matchSTM
  * @tsplus location "@fncts/io/STM/api/core-api"
  */
-export declare function matchSTM_<R, E, A, R1, E1, B, R2, E2, C>(self: STM<R, E, A>, g: (e: E) => STM<R2, E2, C>, f: (a: A) => STM<R1, E1, B>): STM<R1 & R2 & R, E1 | E2, B | C>;
+export declare function matchSTM_<R, E, A, R1, E1, B, R2, E2, C>(self: STM<R, E, A>, g: (e: E) => STM<R2, E2, C>, f: (a: A) => STM<R1, E1, B>, __tsplusTrace?: string): STM<R1 | R2 | R, E1 | E2, B | C>;

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

@@ -1,45 +1,45 @@
 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<unknown, 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<unknown, 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
  * @tsplus location "@fncts/io/STM/api/core-constructors"
  */
-export declare const fiberId: STM<unknown, never, FiberId>;
+export declare const fiberId: STM<never, never, FiberId>;
 /**
  * Interrupts the fiber running the effect with the specified fiber id.
  * @tsplus static fncts.io.STMOps interruptAs
  * @tsplus location "@fncts/io/STM/api/core-constructors"
  */
-export declare function interruptAs(fiberId: FiberId): STM<unknown, 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"
  */
-export declare const retry: STM<unknown, never, never>;
+export declare const retry: STM<never, never, never>;
 /**
  * Returns an `STM` effect that succeeds with the specified value.
  * @tsplus static fncts.io.STMOps succeed
  * @tsplus static fncts.io.STMOps __call
  * @tsplus location "@fncts/io/STM/api/core-constructors"
  */
-export declare function succeed<A>(effect: Lazy<A>): STM<unknown, 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<unknown, never, A>;
+export declare function succeedNow<A>(a: A, __tsplusTrace?: string): STM<never, never, A>;