@fncts/io 0.0.11 → 0.0.14

package/Queue/api/zipWithIO.d.ts

@@ -2,7 +2,7 @@ import { IO, UIO } from "@fncts/io/IO/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
 import { PQueue } from "@fncts/io/Queue/definition";
 import { QueueInternal } from "@fncts/io/Queue/definition";
-export declare class ZipWithIO<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B, R3, E3, D, A> extends QueueInternal<RA & RA1, RB & RB1 & R3, EA | EA1, E3 | EB | EB1, A1, D> {
+export declare class ZipWithIO<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B, R3, E3, D, A> extends QueueInternal<RA | RA1, RB | RB1 | R3, EA | EA1, E3 | EB | EB1, A1, D> {
     readonly fa: QueueInternal<RA, RB, EA, EB, A, B>;
     readonly fb: QueueInternal<RA1, RB1, EA1, EB1, A1, C>;
     readonly f: (b: B, c: C) => IO<R3, E3, D>;
@@ -10,13 +10,13 @@ export declare class ZipWithIO<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A,
     awaitShutdown: UIO<void>;
     capacity: number;
     isShutdown: UIO<boolean>;
-    offer(a: A1): IO<RA & RA1, EA1 | EA, boolean>;
-    offerAll(as: Iterable<A1>): IO<RA & RA1, EA1 | EA, boolean>;
+    offer(a: A1): IO<RA | RA1, EA1 | EA, boolean>;
+    offerAll(as: Iterable<A1>): IO<RA | RA1, EA1 | EA, boolean>;
     shutdown: UIO<void>;
     size: UIO<number>;
-    take: IO<RB & RB1 & R3, E3 | EB | EB1, D>;
-    takeAll: IO<RB & RB1 & R3, E3 | EB | EB1, Conc<D>>;
-    takeUpTo(max: number): IO<RB & RB1 & R3, E3 | EB | EB1, Conc<D>>;
+    take: IO<RB | RB1 | R3, E3 | EB | EB1, D>;
+    takeAll: IO<RB | RB1 | R3, E3 | EB | EB1, Conc<D>>;
+    takeUpTo(max: number): IO<RB | RB1 | R3, E3 | EB | EB1, Conc<D>>;
 }
 /**
  * Creates a new queue from this queue and another. Offering to the composite queue
@@ -29,16 +29,16 @@ export declare class ZipWithIO<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A,
  * @tsplus fluent fncts.io.Queue zipWithIO
  * @tsplus location "@fncts/io/Queue/api/zipWithIO"
  */
-export declare function zipWithIO_<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B, R3, E3, D, A>(fa: PQueue<RA, RB, EA, EB, A, B>, fb: PQueue<RA1, RB1, EA1, EB1, A1, C>, f: (b: B, c: C) => IO<R3, E3, D>): PQueue<RA & RA1, RB & RB1 & R3, EA | EA1, E3 | EB | EB1, A1, D>;
+export declare function zipWithIO_<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B, R3, E3, D, A>(fa: PQueue<RA, RB, EA, EB, A, B>, fb: PQueue<RA1, RB1, EA1, EB1, A1, C>, f: (b: B, c: C) => IO<R3, E3, D>, __tsplusTrace?: string): PQueue<RA | RA1, RB | RB1 | R3, EA | EA1, E3 | EB | EB1, A1, D>;
 /**
  * Like `zipWithM`, but uses a pure function.
  * @tsplus fluent fncts.io.Queue zipWith
  * @tsplus location "@fncts/io/Queue/api/zipWithIO"
  */
-export declare function zipWith_<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B, D, A>(queue: PQueue<RA, RB, EA, EB, A, B>, that: PQueue<RA1, RB1, EA1, EB1, A1, C>, f: (b: B, c: C) => D): PQueue<RA & RA1, RB & RB1, EA | EA1, EB | EB1, A1, D>;
+export declare function zipWith_<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B, D, A>(queue: PQueue<RA, RB, EA, EB, A, B>, that: PQueue<RA1, RB1, EA1, EB1, A1, C>, f: (b: B, c: C) => D, __tsplusTrace?: string): PQueue<RA | RA1, RB | RB1, EA | EA1, EB | EB1, A1, D>;
 /**
  * Like `zipWith`, but tuples the elements instead of applying a function.
  * @tsplus fluent fncts.io.Queue zip
  * @tsplus location "@fncts/io/Queue/api/zipWithIO"
  */
-export declare function zip_<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B, A>(queue: PQueue<RA, RB, EA, EB, A, B>, that: PQueue<RA1, RB1, EA1, EB1, A1, C>): PQueue<RA & RA1, RB & RB1, EA | EA1, EB | EB1, A1, readonly [B, C]>;
+export declare function zip_<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B, A>(queue: PQueue<RA, RB, EA, EB, A, B>, that: PQueue<RA1, RB1, EA1, EB1, A1, C>, __tsplusTrace?: string): PQueue<RA | RA1, RB | RB1, EA | EA1, EB | EB1, A1, readonly [B, C]>;

package/Queue/constructors.d.ts

@@ -4,19 +4,19 @@ import type { Queue } from "@fncts/io/Queue/definition";
  * @tsplus static fncts.io.QueueOps makeSliding
  * @tsplus location "@fncts/io/Queue/constructors"
  */
-export declare function makeSliding<A>(capacity: number): UIO<Queue<A>>;
+export declare function makeSliding<A>(capacity: number, __tsplusTrace?: string): UIO<Queue<A>>;
 /**
  * @tsplus static fncts.io.QueueOps makeUnbounded
  * @tsplus location "@fncts/io/Queue/constructors"
  */
-export declare function makeUnbounded<A>(): UIO<Queue<A>>;
+export declare function makeUnbounded<A>(__tsplusTrace?: string): UIO<Queue<A>>;
 /**
  * @tsplus static fncts.io.QueueOps makeDropping
  * @tsplus location "@fncts/io/Queue/constructors"
  */
-export declare function makeDropping<A>(capacity: number): UIO<Queue<A>>;
+export declare function makeDropping<A>(capacity: number, __tsplusTrace?: string): UIO<Queue<A>>;
 /**
  * @tsplus static fncts.io.QueueOps makeBounded
  * @tsplus location "@fncts/io/Queue/constructors"
  */
-export declare function makeBounded<A>(capacity: number): UIO<Queue<A>>;
+export declare function makeBounded<A>(capacity: number, __tsplusTrace?: string): UIO<Queue<A>>;

package/Queue/definition.d.ts

@@ -10,8 +10,8 @@ import { Conc } from "@fncts/base/collection/immutable/Conc";
  * @tsplus type fncts.io.Queue
  */
 export interface PQueue<RA, RB, EA, EB, A, B> {
-    readonly _RA: (_: RA) => void;
-    readonly _RB: (_: RB) => void;
+    readonly _RA: () => RA;
+    readonly _RB: () => RB;
     readonly _EA: () => EA;
     readonly _EB: () => EB;
     readonly _A: (_: A) => void;
@@ -35,8 +35,8 @@ export declare function concrete<RA, RB, EA, EB, A, B>(_: PQueue<RA, RB, EA, EB,
  * with errors of type `EB`.
  */
 export declare abstract class QueueInternal<RA, RB, EA, EB, A, B> implements PQueue<RA, RB, EA, EB, A, B> {
-    readonly _RA: (_: RA) => void;
-    readonly _RB: (_: RB) => void;
+    readonly _RA: () => RA;
+    readonly _RB: () => RB;
     readonly _EA: () => EA;
     readonly _EB: () => EB;
     readonly _A: (_: A) => void;
@@ -58,7 +58,7 @@ export declare abstract class QueueInternal<RA, RB, EA, EB, A, B> implements PQu
     /**
      * Places one value in the queue.
      */
-    abstract offer(a: A): IO<RA, EA, boolean>;
+    abstract offer(a: A, __tsplusTrace?: string): IO<RA, EA, boolean>;
     /**
      * For Bounded Queue: uses the `BackPressure` Strategy, places the values in the queue and always returns true.
      * If the queue has reached capacity, then
@@ -76,7 +76,7 @@ export declare abstract class QueueInternal<RA, RB, EA, EB, A, B> implements PQu
      * It places the values in the queue but if there is no room it will not enqueue them and return false.
      *
      */
-    abstract offerAll(as: Iterable<A>): IO<RA, EA, boolean>;
+    abstract offerAll(as: Iterable<A>, __tsplusTrace?: string): IO<RA, EA, boolean>;
     /**
      * Interrupts any fibers that are suspended on `offer` or `take`.
      * Future calls to `offer*` and `take*` will be interrupted immediately.
@@ -101,7 +101,7 @@ export declare abstract class QueueInternal<RA, RB, EA, EB, A, B> implements PQu
     /**
      * Takes up to max number of values in the queue.
      */
-    abstract takeUpTo(n: number): IO<RB, EB, Conc<B>>;
+    abstract takeUpTo(n: number, __tsplusTrace?: string): IO<RB, EB, Conc<B>>;
 }
 /**
  * A `Queue<A>` is a lightweight, asynchronous queue into which
@@ -109,7 +109,7 @@ export declare abstract class QueueInternal<RA, RB, EA, EB, A, B> implements PQu
  *
  * @tsplus type fncts.io.Queue
  */
-export interface Queue<A> extends PQueue<unknown, unknown, never, never, A, A> {
+export interface Queue<A> extends PQueue<never, never, never, never, A, A> {
 }
 export declare namespace Queue {
     /**
@@ -117,13 +117,13 @@ export declare namespace Queue {
      *
      * @tsplus type fncts.io.Queue
      */
-    interface Dequeue<A> extends PQueue<never, unknown, unknown, never, never, A> {
+    interface Dequeue<A> extends PQueue<never, never, unknown, never, never, A> {
     }
     /**
      * A queue that can only be enqueued.
      *
      * @tsplus type fncts.io.Queue
      */
-    interface Enqueue<A> extends PQueue<unknown, never, never, unknown, A, any> {
+    interface Enqueue<A> extends PQueue<never, never, never, unknown, A, any> {
     }
 }

package/Queue/internal.d.ts

@@ -4,7 +4,7 @@ import { Conc } from "@fncts/base/collection/immutable/Conc";
 import type { MutableQueue } from "@fncts/io/internal/MutableQueue";
 import type { Queue } from "@fncts/io/Queue/definition";
 import type { Strategy } from "@fncts/io/Queue/strategy";
-export declare function _makeQueue<A>(strategy: Strategy<A>): (queue: MutableQueue<A>) => IO<unknown, never, Queue<A>>;
+export declare function _makeQueue<A>(strategy: Strategy<A>): (queue: MutableQueue<A>) => IO<never, never, Queue<A>>;
 export declare function _unsafeOfferAll<A>(q: MutableQueue<A>, as: Conc<A>): Conc<A>;
 export declare function _unsafePollAll<A>(q: MutableQueue<A>): Conc<A>;
 export declare function _unsafeCompletePromise<A>(p: Future<never, A>, a: A): void;

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

@@ -4,39 +4,39 @@ import type { ArrayInt } from "@fncts/base/util/rand";
  * @tsplus static fncts.io.RandomOps nextDouble
  * @tsplus location "@fncts/io/Random/api"
  */
-export declare const nextDouble: import("../IO").IO<unknown, never, number>;
+export declare const nextDouble: import("../IO").IO<never, never, number>;
 /**
  * @tsplus static fncts.io.RandomOps nextBoolean
  * @tsplus location "@fncts/io/Random/api"
  */
-export declare const nextBoolean: import("../IO").IO<unknown, never, boolean>;
+export declare const nextBoolean: import("../IO").IO<never, never, boolean>;
 /**
  * @tsplus static fncts.io.RandomOps nextInt
  * @tsplus location "@fncts/io/Random/api"
  */
-export declare const nextInt: import("../IO").IO<unknown, never, number>;
+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<unknown, 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

@@ -7,11 +7,11 @@ export declare class LiveRandom implements Random {
     setSeed(seed: number): UIO<void>;
     nextDouble: import("../IO").UIO<number>;
     nextInt: import("../IO").UIO<number>;
-    nextBoolean: import("../IO").IO<unknown, 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>;
+    nextBoolean: import("../IO").IO<never, never, boolean>;
+    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,16 +1,16 @@
-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";
 /**
  * @tsplus type fncts.io.Ref.Atomic
  */
-export declare class Atomic<A> extends RefInternal<unknown, unknown, never, never, A, A> {
+export declare class Atomic<A> extends RefInternal<never, never, never, never, A, A> {
     private value;
     readonly _tag = "Atomic";
     constructor(value: A);
-    match<EC, ED, C, D>(_ea: (_: never) => EC, _eb: (_: never) => ED, ca: (_: C) => Either<EC, A>, bd: (_: A) => Either<ED, D>): PRef<unknown, unknown, EC, ED, C, D>;
-    matchAll<EC, ED, C, D>(_ea: (_: never) => EC, _eb: (_: never) => ED, _ec: (_: never) => EC, ca: (_: C) => (_: A) => Either<EC, A>, bd: (_: A) => Either<ED, D>): PRef<unknown, unknown, EC, ED, C, D>;
+    match<EC, ED, C, D>(_ea: (_: never) => EC, _eb: (_: never) => ED, ca: (_: C) => Either<EC, A>, bd: (_: A) => Either<ED, D>): PRef<never, never, EC, ED, C, D>;
+    matchAll<EC, ED, C, D>(_ea: (_: never) => EC, _eb: (_: never) => ED, _ec: (_: never) => EC, ca: (_: C) => (_: A) => Either<EC, A>, bd: (_: A) => Either<ED, D>): PRef<never, never, EC, ED, C, D>;
     get unsafeGet(): A;
     unsafeSet(a: A): void;
     get get(): UIO<A>;

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,14 +1,14 @@
-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";
 import { RefInternal } from "./definition.js";
-export declare class Derived<EA, EB, A, B> extends RefInternal<unknown, unknown, EA, EB, A, B> {
+export declare class Derived<EA, EB, A, B> extends RefInternal<never, never, EA, EB, A, B> {
     readonly use: <X>(f: <S>(value: Atomic<S>, getEither: (s: S) => Either<EB, B>, setEither: (a: A) => Either<EA, S>) => X) => X;
     readonly _tag = "Derived";
     constructor(use: <X>(f: <S>(value: Atomic<S>, getEither: (s: S) => Either<EB, B>, setEither: (a: A) => Either<EA, S>) => X) => X);
-    match<EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => Either<EC, A>, bd: (_: B) => Either<ED, D>): PRef<unknown, unknown, EC, ED, C, D>;
-    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<unknown, unknown, EC, ED, C, D>;
+    match<EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => Either<EC, A>, bd: (_: B) => Either<ED, D>): PRef<never, never, EC, ED, C, D>;
+    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<never, never, EC, ED, C, D>;
     get get(): FIO<EB, B>;
     set(a: A): FIO<EA, void>;
 }

package/Ref/DerivedAll.d.ts

@@ -1,14 +1,14 @@
-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";
 import { RefInternal } from "./definition.js";
-export declare class DerivedAll<EA, EB, A, B> extends RefInternal<unknown, unknown, EA, EB, A, B> {
+export declare class DerivedAll<EA, EB, A, B> extends RefInternal<never, never, EA, EB, A, B> {
     readonly use: <X>(f: <S>(value: Atomic<S>, getEither: (s: S) => Either<EB, B>, setEither: (a: A) => (s: S) => Either<EA, S>) => X) => X;
     readonly _tag = "DerivedAll";
     constructor(use: <X>(f: <S>(value: Atomic<S>, getEither: (s: S) => Either<EB, B>, setEither: (a: A) => (s: S) => Either<EA, S>) => X) => X);
-    match<EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => Either<EC, A>, bd: (_: B) => Either<ED, D>): PRef<unknown, unknown, EC, ED, C, D>;
-    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<unknown, unknown, EC, ED, C, D>;
+    match<EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => Either<EC, A>, bd: (_: B) => Either<ED, D>): PRef<never, never, EC, ED, C, D>;
+    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<never, never, EC, ED, C, D>;
     get get(): FIO<EB, B>;
     set(a: A): FIO<EA, void>;
 }

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,32 +39,32 @@ 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"
  */
-export declare function matchIO_<RA, RB, EA, EB, A, B, RC, RD, EC, ED, C, D>(self: PRef.Synchronized<RA, RB, EA, EB, A, B>, ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => IO<RC, EC, A>, bd: (_: B) => IO<RD, ED, D>, __tsplusTrace?: string): PRef.Synchronized<RA & RC, RB & RD, EC, ED, C, D>;
+export declare function matchIO_<RA, RB, EA, EB, A, B, RC, RD, EC, ED, C, D>(self: PRef.Synchronized<RA, RB, EA, EB, A, B>, ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => IO<RC, EC, A>, bd: (_: B) => IO<RD, ED, D>, __tsplusTrace?: string): PRef.Synchronized<RA | RC, RB | RD, EC, ED, C, D>;
 /**
  * @tsplus fluent fncts.io.Ref.Synchronized matchAllIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function matchAllIO_<RA, RB, EA, EB, A, B, RC, RD, EC, ED, C, D>(self: PRef.Synchronized<RA, RB, EA, EB, A, B>, ea: (_: EA) => EC, eb: (_: EB) => ED, ec: (_: EB) => EC, ca: (_: C) => (_: B) => IO<RC, EC, A>, bd: (_: B) => IO<RD, ED, D>, __tsplusTrace?: string): PRef.Synchronized<RA & RB & RC, RB & RD, EC, ED, C, D>;
+export declare function matchAllIO_<RA, RB, EA, EB, A, B, RC, RD, EC, ED, C, D>(self: PRef.Synchronized<RA, RB, EA, EB, A, B>, ea: (_: EA) => EC, eb: (_: EB) => ED, ec: (_: EB) => EC, ca: (_: C) => (_: B) => IO<RC, EC, A>, bd: (_: B) => IO<RD, ED, D>, __tsplusTrace?: string): PRef.Synchronized<RA | RB | RC, RB & RD, EC, ED, C, D>;
 /**
  * @tsplus fluent fncts.io.Ref.Synchronized modifyIO
  * @tsplus location "@fncts/io/Ref/Synchronized/api"
  */
-export declare function modifyIO_<RA, RB, EA, EB, A, R1, E1, B>(self: PRef.Synchronized<RA, RB, EA, EB, A, A>, f: (a: A) => IO<R1, E1, readonly [B, A]>, __tsplusTrace?: string): IO<RA & RB & R1, EA | EB | E1, B>;
+export declare function modifyIO_<RA, RB, EA, EB, A, R1, E1, B>(self: PRef.Synchronized<RA, RB, EA, EB, A, A>, f: (a: A) => IO<R1, E1, readonly [B, A]>, __tsplusTrace?: string): IO<RA | RB | R1, EA | EB | E1, B>;
 /**
  * Atomically modifies the `Synchronized` with the specified function, which computes
  * a return value for the modification if the function is defined in the current value
@@ -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";
@@ -30,8 +30,8 @@ export declare class PSynchronizedInternal<RA, RB, EA, EB, A, B> extends RefInte
     constructor(semaphores: Set<TSemaphore>, unsafeGet: IO<RB, EB, B>, unsafeSet: (a: A) => IO<RA, EA, void>);
     get get(): IO<RB, EB, B>;
     set(a: A, __tsplusTrace?: string): IO<RA, EA, void>;
-    matchAllIO<RC, RD, EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ec: (_: EB) => EC, ca: (_: C) => (_: B) => IO<RC, EC, A>, bd: (_: B) => IO<RD, ED, D>, __tsplusTrace?: string): PSynchronizedInternal<RA & RC & RB, RB & RD, EC, ED, C, D>;
-    matchIO<RC, RD, EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => IO<RC, EC, A>, bd: (_: B) => IO<RD, ED, D>, __tsplusTrace?: string): PSynchronizedInternal<RA & RC, RB & RD, EC, ED, C, D>;
+    matchAllIO<RC, RD, EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ec: (_: EB) => EC, ca: (_: C) => (_: B) => IO<RC, EC, A>, bd: (_: B) => IO<RD, ED, D>, __tsplusTrace?: string): PSynchronizedInternal<RA | RC | RB, RB | RD, EC, ED, C, D>;
+    matchIO<RC, RD, EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => IO<RC, EC, A>, bd: (_: B) => IO<RD, ED, D>, __tsplusTrace?: string): PSynchronizedInternal<RA | RC, RB | RD, EC, ED, C, D>;
     match<EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => Either<EC, A>, bd: (_: B) => Either<ED, D>, __tsplusTrace?: string): PSynchronizedInternal<RA, RB, EC, ED, C, D>;
     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>, __tsplusTrace?: string): PSynchronizedInternal<RA, RB, EC, ED, C, D>;
     withPermit<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;

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