@fncts/io 0.0.13 → 0.0.16

package/Queue/strategy.d.ts

@@ -4,29 +4,29 @@ import { UIO, IO } from "@fncts/io/IO/definition";
 import type { AtomicBoolean } from "@fncts/base/internal/AtomicBoolean";
 import type { MutableQueue } from "@fncts/io/internal/MutableQueue";
 export interface Strategy<A> {
-    readonly handleSurplus: (as: Conc<A>, queue: MutableQueue<A>, takers: MutableQueue<Future<never, A>>, isShutdown: AtomicBoolean) => UIO<boolean>;
-    readonly unsafeOnQueueEmptySpace: (queue: MutableQueue<A>, takers: MutableQueue<Future<never, A>>) => void;
+    readonly handleSurplus: (as: Conc<A>, queue: MutableQueue<A>, takers: MutableQueue<Future<never, A>>, isShutdown: AtomicBoolean, __tsplusTrace?: string) => UIO<boolean>;
+    readonly unsafeOnQueueEmptySpace: (queue: MutableQueue<A>, takers: MutableQueue<Future<never, A>>, __tsplusTrace?: string) => void;
     readonly surplusSize: number;
     readonly shutdown: UIO<void>;
 }
 export declare class BackPressureStrategy<A> implements Strategy<A> {
     private putters;
-    handleSurplus(as: Conc<A>, queue: MutableQueue<A>, takers: MutableQueue<Future<never, A>>, isShutdown: AtomicBoolean): UIO<boolean>;
-    unsafeRemove(p: Future<never, boolean>): void;
-    unsafeOffer(as: Conc<A>, p: Future<never, boolean>): void;
-    unsafeOnQueueEmptySpace(queue: MutableQueue<A>, takers: MutableQueue<Future<never, A>>): void;
+    handleSurplus(as: Conc<A>, queue: MutableQueue<A>, takers: MutableQueue<Future<never, A>>, isShutdown: AtomicBoolean, __tsplusTrace?: string): UIO<boolean>;
+    unsafeRemove(p: Future<never, boolean>, __tsplusTrace?: string): void;
+    unsafeOffer(as: Conc<A>, p: Future<never, boolean>, __tsplusTrace?: string): void;
+    unsafeOnQueueEmptySpace(queue: MutableQueue<A>, takers: MutableQueue<Future<never, A>>, __tsplusTrace?: string): void;
     get shutdown(): UIO<void>;
     get surplusSize(): number;
 }
 export declare class DroppingStrategy<A> implements Strategy<A> {
-    handleSurplus(_as: Conc<A>, _queue: MutableQueue<A>, _takers: MutableQueue<Future<never, A>>, _isShutdown: AtomicBoolean): UIO<boolean>;
-    unsafeOnQueueEmptySpace(_queue: MutableQueue<A>): void;
+    handleSurplus(_as: Conc<A>, _queue: MutableQueue<A>, _takers: MutableQueue<Future<never, A>>, _isShutdown: AtomicBoolean, __tsplusTrace?: string): UIO<boolean>;
+    unsafeOnQueueEmptySpace(_queue: MutableQueue<A>, _takers: MutableQueue<Future<never, A>>, __tsplusTrace?: string): void;
     get shutdown(): UIO<void>;
     get surplusSize(): number;
 }
 export declare class SlidingStrategy<A> implements Strategy<A> {
-    handleSurplus(as: Conc<A>, queue: MutableQueue<A>, takers: MutableQueue<Future<never, A>>, _isShutdown: AtomicBoolean): UIO<boolean>;
-    unsafeOnQueueEmptySpace(_queue: MutableQueue<A>): void;
+    handleSurplus(as: Conc<A>, queue: MutableQueue<A>, takers: MutableQueue<Future<never, A>>, _isShutdown: AtomicBoolean, __tsplusTrace?: string): UIO<boolean>;
+    unsafeOnQueueEmptySpace(_queue: MutableQueue<A>, _takers: MutableQueue<Future<never, A>>, __tsplusTrace?: string): void;
     get shutdown(): UIO<void>;
     get surplusSize(): number;
     private unsafeSlidingOffer;

package/Random/api.d.ts

@@ -19,24 +19,24 @@ export declare const nextInt: import("../IO").IO<never, never, number>;
  * @tsplus static fncts.io.RandomOps nextRange
  * @tsplus location "@fncts/io/Random/api"
  */
-export declare function nextRange(low: number, high: number): IO<never, never, number>;
+export declare function nextRange(low: number, high: number, __tsplusTrace?: string): IO<never, never, number>;
 /**
  * @tsplus static fncts.io.RandomOps nextIntBetween
  * @tsplus location "@fncts/io/Random/api"
  */
-export declare function nextIntBetween(low: number, high: number): UIO<number>;
+export declare function nextIntBetween(low: number, high: number, __tsplusTrace?: string): UIO<number>;
 /**
  * @tsplus static fncts.io.RandomOps nextBigIntBetween
  * @tsplus location "@fncts/io/Random/api"
  */
-export declare function nextBigIntBetween(low: bigint, high: bigint): UIO<bigint>;
+export declare function nextBigIntBetween(low: bigint, high: bigint, __tsplusTrace?: string): UIO<bigint>;
 /**
  * @tsplus static fncts.io.RandomOps nextArrayIntBetween
  * @tsplus location "@fncts/io/Random/api"
  */
-export declare function nextArrayIntBetween(low: ArrayInt, high: ArrayInt): UIO<ArrayInt>;
+export declare function nextArrayIntBetween(low: ArrayInt, high: ArrayInt, __tsplusTrace?: string): UIO<ArrayInt>;
 /**
  * @tsplus static fncts.io.RandomOps setSeed
  * @tsplus location "@fncts/io/Random/api"
  */
-export declare function setSeed(seed: number): UIO<void>;
+export declare function setSeed(seed: number, __tsplusTrace?: string): UIO<void>;

package/Random/definition.d.ts

@@ -13,9 +13,9 @@ export declare abstract class Random {
     abstract readonly nextDouble: UIO<number>;
     abstract readonly nextBoolean: UIO<boolean>;
     abstract readonly nextInt: UIO<number>;
-    abstract nextRange(low: number, high: number): UIO<number>;
-    abstract nextIntBetween(low: number, high: number): UIO<number>;
-    abstract nextBigIntBetween(low: bigint, high: bigint): UIO<bigint>;
-    abstract nextArrayIntBetween(low: ArrayInt, high: ArrayInt): UIO<ArrayInt>;
-    abstract setSeed(seed: number): UIO<void>;
+    abstract nextRange(low: number, high: number, __tsplusTrace?: string): UIO<number>;
+    abstract nextIntBetween(low: number, high: number, __tsplusTrace?: string): UIO<number>;
+    abstract nextBigIntBetween(low: bigint, high: bigint, __tsplusTrace?: string): UIO<bigint>;
+    abstract nextArrayIntBetween(low: ArrayInt, high: ArrayInt, __tsplusTrace?: string): UIO<ArrayInt>;
+    abstract setSeed(seed: number, __tsplusTrace?: string): UIO<void>;
 }

package/Random/live.d.ts

@@ -8,10 +8,10 @@ export declare class LiveRandom implements Random {
     nextDouble: import("../IO").UIO<number>;
     nextInt: import("../IO").UIO<number>;
     nextBoolean: import("../IO").IO<never, never, boolean>;
-    nextRange(low: number, high: number): UIO<number>;
-    nextIntBetween(low: number, high: number): UIO<number>;
-    nextBigIntBetween(low: bigint, high: bigint): UIO<bigint>;
-    nextArrayIntBetween(low: ArrayInt, high: ArrayInt): UIO<ArrayInt>;
+    nextRange(low: number, high: number, __tsplusTrace?: string): UIO<number>;
+    nextIntBetween(low: number, high: number, __tsplusTrace?: string): UIO<number>;
+    nextBigIntBetween(low: bigint, high: bigint, __tsplusTrace?: string): UIO<bigint>;
+    nextArrayIntBetween(low: ArrayInt, high: ArrayInt, __tsplusTrace?: string): UIO<ArrayInt>;
 }
 /**
  * @tsplus static fncts.io.RandomOps Live

package/Ref/Atomic/Atomic.d.ts

@@ -1,4 +1,4 @@
-import { Either } from "@fncts/base/data/Either";
+import { Either } from "@fncts/base/data/Either/definition";
 import { UIO, IO } from "@fncts/io/IO/definition";
 import type { PRef } from "../definition.js";
 import { RefInternal } from "../definition.js";

package/Ref/Atomic/api.d.ts

@@ -1,53 +1,53 @@
 import { UIO } from "@fncts/io/IO/definition";
-import { Maybe } from "@fncts/base/data/Maybe";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
 import type { Atomic } from "./Atomic.js";
 /**
  * @tsplus fluent fncts.io.Ref.Atomic getAndSet
  * @tsplus location "@fncts/io/Ref/Atomic/api"
  */
-export declare function getAndSet<A>(self: Atomic<A>, a: A): UIO<A>;
+export declare function getAndSet<A>(self: Atomic<A>, a: A, __tsplusTrace?: string): UIO<A>;
 /**
  * @tsplus fluent fncts.io.Ref.Atomic getAndUpdate
  * @tsplus location "@fncts/io/Ref/Atomic/api"
  */
-export declare function getAndUpdate<A>(self: Atomic<A>, f: (a: A) => A): import("../../IO.js").UIO<A>;
+export declare function getAndUpdate<A>(self: Atomic<A>, f: (a: A) => A, __tsplusTrace?: string): import("../../IO.js").UIO<A>;
 /**
  * @tsplus fluent fncts.io.Ref.Atomic getAndUpdateJust
  * @tsplus location "@fncts/io/Ref/Atomic/api"
  */
-export declare function getAndUpdateJust<A>(self: Atomic<A>, f: (a: A) => Maybe<A>): import("../../IO.js").UIO<A>;
+export declare function getAndUpdateJust<A>(self: Atomic<A>, f: (a: A) => Maybe<A>, __tsplusTrace?: string): import("../../IO.js").UIO<A>;
 /**
  * @tsplus fluent fncts.io.Ref.Atomic modify
  * @tsplus location "@fncts/io/Ref/Atomic/api"
  */
-export declare function modify<A, B>(self: Atomic<A>, f: (a: A) => readonly [B, A]): import("../../IO.js").UIO<B>;
+export declare function modify<A, B>(self: Atomic<A>, f: (a: A) => readonly [B, A], __tsplusTrace?: string): import("../../IO.js").UIO<B>;
 /**
  * @tsplus fluent fncts.io.Ref.Atomic modifyJust
  * @tsplus location "@fncts/io/Ref/Atomic/api"
  */
-export declare function modifyJust<A, B>(self: Atomic<A>, def: B, f: (a: A) => Maybe<readonly [B, A]>): import("../../IO.js").UIO<B>;
+export declare function modifyJust<A, B>(self: Atomic<A>, def: B, f: (a: A) => Maybe<readonly [B, A]>, __tsplusTrace?: string): import("../../IO.js").UIO<B>;
 /**
  * @tsplus fluent fncts.io.Ref.Atomic update
  * @tsplus location "@fncts/io/Ref/Atomic/api"
  */
-export declare function update<A>(self: Atomic<A>, f: (a: A) => A): import("../../IO.js").UIO<void>;
+export declare function update<A>(self: Atomic<A>, f: (a: A) => A, __tsplusTrace?: string): import("../../IO.js").UIO<void>;
 /**
  * @tsplus fluent fncts.io.Ref.Atomic updateAndGet
  * @tsplus location "@fncts/io/Ref/Atomic/api"
  */
-export declare function updateAndGet<A>(self: Atomic<A>, f: (a: A) => A): import("../../IO.js").UIO<A>;
+export declare function updateAndGet<A>(self: Atomic<A>, f: (a: A) => A, __tsplusTrace?: string): import("../../IO.js").UIO<A>;
 /**
  * @tsplus fluent fncts.io.Ref.Atomic updateJust
  * @tsplus location "@fncts/io/Ref/Atomic/api"
  */
-export declare function updateJust<A>(self: Atomic<A>, f: (a: A) => Maybe<A>): import("../../IO.js").UIO<void>;
+export declare function updateJust<A>(self: Atomic<A>, f: (a: A) => Maybe<A>, __tsplusTrace?: string): import("../../IO.js").UIO<void>;
 /**
  * @tsplus fluent fncts.io.Ref.Atomic updateJustAndGet
  * @tsplus location "@fncts/io/Ref/Atomic/api"
  */
-export declare function updateJustAndGet<A>(self: Atomic<A>, f: (a: A) => Maybe<A>): import("../../IO.js").UIO<A>;
+export declare function updateJustAndGet<A>(self: Atomic<A>, f: (a: A) => Maybe<A>, __tsplusTrace?: string): import("../../IO.js").UIO<A>;
 /**
  * @tsplus fluent fncts.io.Ref.Atomic unsafeUpdate
  * @tsplus location "@fncts/io/Ref/Atomic/api"
  */
-export declare function unsafeUpdate<A>(self: Atomic<A>, f: (a: A) => A): void;
+export declare function unsafeUpdate<A>(self: Atomic<A>, f: (a: A) => A, __tsplusTrace?: string): void;

package/Ref/Derived.d.ts

@@ -1,4 +1,4 @@
-import { Either } from "@fncts/base/data/Either";
+import { Either } from "@fncts/base/data/Either/definition";
 import { FIO, IO } from "@fncts/io/IO/definition";
 import type { Atomic } from "./Atomic/Atomic.js";
 import type { PRef } from "./definition.js";

package/Ref/DerivedAll.d.ts

@@ -1,4 +1,4 @@
-import { Either } from "@fncts/base/data/Either";
+import { Either } from "@fncts/base/data/Either/definition";
 import { FIO, IO } from "@fncts/io/IO/definition";
 import type { Atomic } from "./Atomic/Atomic.js";
 import type { PRef } from "./definition.js";

package/Ref/Synchronized/api.d.ts

@@ -1,4 +1,4 @@
-import { Maybe } from "@fncts/base/data/Maybe";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { IO } from "@fncts/io/IO/definition";
 import type { PRef } from "../definition.js";
 /**
@@ -9,21 +9,21 @@ import type { PRef } from "../definition.js";
  * @tsplus fluent fncts.io.Ref.Synchronized collectIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function collectIO_<RA, RB, EA, EB, A, B, RC, EC, C>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>, f: (b: B) => Maybe<IO<RC, EC, C>>): PRef.Synchronized<RA, RB | RC, EA, Maybe<EB | EC>, A, C>;
+export declare function collectIO_<RA, RB, EA, EB, A, B, RC, EC, C>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>, f: (b: B) => Maybe<IO<RC, EC, C>>, __tsplusTrace?: string): PRef.Synchronized<RA, RB | RC, EA, Maybe<EB | EC>, A, C>;
 /**
  * Transforms the `set` value of the `SRef` with the specified effectual
  * function.
  * @tsplus fluent fncts.io.Ref.Synchronized contramapIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function contramapIO_<RA, RB, EA, EB, B, A, RC, EC, C>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>, f: (c: C) => IO<RC, EC, A>): PRef.Synchronized<RA | RC, RB, EC | EA, EB, C, B>;
+export declare function contramapIO_<RA, RB, EA, EB, B, A, RC, EC, C>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>, f: (c: C) => IO<RC, EC, A>, __tsplusTrace?: string): PRef.Synchronized<RA | RC, RB, EC | EA, EB, C, B>;
 /**
  * Transforms both the `set` and `get` values of the `Synchronized` with the
  * specified effectual functions.
  * @tsplus fluent fncts.io.Ref.Synchronized dimapIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function dimapIO_<RA, RB, EA, EB, B, RC, EC, A, RD, ED, C = A, D = B>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>, f: (c: C) => IO<RC, EC, A>, g: (b: B) => IO<RD, ED, D>): PRef.Synchronized<RA | RC, RB | RD, EA | EC, EB | ED, C, D>;
+export declare function dimapIO_<RA, RB, EA, EB, B, RC, EC, A, RD, ED, C = A, D = B>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>, f: (c: C) => IO<RC, EC, A>, g: (b: B) => IO<RD, ED, D>, __tsplusTrace?: string): PRef.Synchronized<RA | RC, RB | RD, EA | EC, EB | ED, C, D>;
 /**
  * Filters the `set` value of the `SRef` with the specified effectual
  * predicate, returning a `SRef` with a `set` value that succeeds if the
@@ -31,7 +31,7 @@ export declare function dimapIO_<RA, RB, EA, EB, B, RC, EC, A, RD, ED, C = A, D
  * @tsplus fluent fncts.io.Ref.Synchronized filterInputIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function filterInputIO_<RA, RB, EA, EB, B, A, RC, EC, A1 extends A = A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>, f: (a: A1) => IO<RC, EC, boolean>): PRef.Synchronized<RA | RC, RB, Maybe<EC | EA>, EB, A1, B>;
+export declare function filterInputIO_<RA, RB, EA, EB, B, A, RC, EC, A1 extends A = A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>, f: (a: A1) => IO<RC, EC, boolean>, __tsplusTrace?: string): PRef.Synchronized<RA | RC, RB, Maybe<EC | EA>, EB, A1, B>;
 /**
  * Filters the `get` value of the `SRef` with the specified effectual predicate,
  * returning a `SRef` with a `get` value that succeeds if the predicate is
@@ -39,17 +39,17 @@ export declare function filterInputIO_<RA, RB, EA, EB, B, A, RC, EC, A1 extends
  * @tsplus fluent fncts.io.Ref.Synchronized filterOutputIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function filterOutputIO_<RA, RB, EA, EB, A, B, RC, EC>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>, f: (b: B) => IO<RC, EC, boolean>): PRef.Synchronized<RA, RB | RC, EA, Maybe<EC | EB>, A, B>;
+export declare function filterOutputIO_<RA, RB, EA, EB, A, B, RC, EC>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>, f: (b: B) => IO<RC, EC, boolean>, __tsplusTrace?: string): PRef.Synchronized<RA, RB | RC, EA, Maybe<EC | EB>, A, B>;
 /**
  * Atomically modifies the `Synchronized` with the specified function, returning the
  * value immediately before modification.
  */
-export declare function getAndUpdateIO_<RA, RB, EA, EB, R1, E1, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>, f: (a: A) => IO<R1, E1, A>): IO<RA | RB | R1, EA | EB | E1, A>;
+export declare function getAndUpdateIO_<RA, RB, EA, EB, R1, E1, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>, f: (a: A) => IO<R1, E1, A>, __tsplusTrace?: string): IO<RA | RB | R1, EA | EB | E1, A>;
 /**
  * Atomically modifies the `SRef` with the specified function, returning the
  * value immediately before modification.
  */
-export declare function getAndUpdateJustIO_<RA, RB, EA, EB, R1, E1, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>, f: (a: A) => Maybe<IO<R1, E1, A>>): IO<RA | RB | R1, EA | EB | E1, A>;
+export declare function getAndUpdateJustIO_<RA, RB, EA, EB, R1, E1, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>, f: (a: A) => Maybe<IO<R1, E1, A>>, __tsplusTrace?: string): IO<RA | RB | R1, EA | EB | E1, A>;
 /**
  * @tsplus fluent fncts.io.Ref.Synchronized matchIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
@@ -73,28 +73,28 @@ export declare function modifyIO_<RA, RB, EA, EB, A, R1, E1, B>(self: PRef.Synch
  * @tsplus fluent fncts.io.Ref.Synchronized modifyJustIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function modifyJustIO_<RA, RB, EA, EB, R1, E1, A, B>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>, def: B, f: (a: A) => Maybe<IO<R1, E1, readonly [B, A]>>): IO<RA | RB | R1, EA | EB | E1, B>;
+export declare function modifyJustIO_<RA, RB, EA, EB, R1, E1, A, B>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>, def: B, f: (a: A) => Maybe<IO<R1, E1, readonly [B, A]>>, __tsplusTrace?: string): IO<RA | RB | R1, EA | EB | E1, B>;
 /**
  * Atomically modifies the `SRef` with the specified function.
  * @tsplus fluent fncts.io.Ref.Synchronized updateAndGetIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function updateAndGetIO_<RA, RB, EA, EB, R1, E1, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>, f: (a: A) => IO<R1, E1, A>): IO<RA | RB | R1, E1 | EA | EB, void>;
+export declare function updateAndGetIO_<RA, RB, EA, EB, R1, E1, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>, f: (a: A) => IO<R1, E1, A>, __tsplusTrace?: string): IO<RA | RB | R1, E1 | EA | EB, void>;
 /**
  * Atomically modifies the `Synchronized` with the specified function.
  * @tsplus fluent fncts.io.Ref.Synchronized updateIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function updateIO_<RA, RB, EA, EB, R1, E1, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>, f: (a: A) => IO<R1, E1, A>): IO<RA | RB | R1, E1 | EA | EB, void>;
+export declare function updateIO_<RA, RB, EA, EB, R1, E1, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>, f: (a: A) => IO<R1, E1, A>, __tsplusTrace?: string): IO<RA | RB | R1, E1 | EA | EB, void>;
 /**
  * Atomically modifies the `SRef` with the specified function.
  * @tsplus fluent fncts.io.Ref.Synchronized updateJustAndGetIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function updateJustAndGetIO_<RA, RB, EA, EB, R1, E1, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>, f: (a: A) => Maybe<IO<R1, E1, A>>): IO<RA | RB | R1, E1 | EA | EB, A>;
+export declare function updateJustAndGetIO_<RA, RB, EA, EB, R1, E1, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>, f: (a: A) => Maybe<IO<R1, E1, A>>, __tsplusTrace?: string): IO<RA | RB | R1, E1 | EA | EB, A>;
 /**
  * Atomically modifies the `SRef` with the specified function.
  * @tsplus fluent fncts.io.Ref.Synchronized updateJustIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function updateJustIO_<RA, RB, EA, EB, R1, E1, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>, f: (a: A) => Maybe<IO<R1, E1, A>>): IO<RA | RB | R1, E1 | EA | EB, void>;
+export declare function updateJustIO_<RA, RB, EA, EB, R1, E1, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>, f: (a: A) => Maybe<IO<R1, E1, A>>, __tsplusTrace?: string): IO<RA | RB | R1, E1 | EA | EB, void>;

package/Ref/Synchronized/constructors.d.ts

@@ -1,8 +1,8 @@
-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.Ref.SynchronizedOps make
  * @tsplus location "@fncts/io/Ref/Synchronized/constructors"
  */
-export declare function makeSynchronized<A>(a: Lazy<A>): UIO<Ref.Synchronized<A>>;
+export declare function makeSynchronized<A>(a: Lazy<A>, __tsplusTrace?: string): UIO<Ref.Synchronized<A>>;

package/Ref/Synchronized/definition.d.ts

@@ -1,6 +1,6 @@
 import { TSemaphore } from "@fncts/io/TSemaphore/definition";
 import { IO } from "@fncts/io/IO/definition";
-import { Either } from "@fncts/base/data/Either";
+import { Either } from "@fncts/base/data/Either/definition";
 import { STM } from "@fncts/io/STM/definition";
 import type { PRef } from "../definition.js";
 import { RefInternal } from "../definition.js";

package/Ref/api/collect.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";
 /**
  * Maps and filters the `get` value of the `Ref` with the specified partial
@@ -8,4 +8,4 @@ import type { PRef } from "../definition.js";
  * @tsplus fluent fncts.io.Ref.Synchronized collect
  * @tsplus location "@fncts/io/Ref/api/collect"
  */
-export declare function collect_<RA, RB, EA, EB, A, B, C>(ref: PRef<RA, RB, EA, EB, A, B>, pf: (_: B) => Maybe<C>): PRef<RA, RB, EA, Maybe<EB>, A, C>;
+export declare function collect_<RA, RB, EA, EB, A, B, C>(ref: PRef<RA, RB, EA, EB, A, B>, pf: (_: B) => Maybe<C>, __tsplusTrace?: string): PRef<RA, RB, EA, Maybe<EB>, A, C>;

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";
@@ -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>;