@fncts/io 0.0.13 → 0.0.16

package/Layer/api.d.ts

@@ -1,7 +1,7 @@
-import { Environment } from "@fncts/base/data/Environment";
-import { Lazy } from "@fncts/base/data/function";
-import { Cause } from "@fncts/base/data/Cause";
-import { Tag } from "@fncts/base/data/Tag";
+import { Environment } from "@fncts/base/data/Environment/definition";
+import { Lazy } from "@fncts/base/data/function/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
+import { Tag } from "@fncts/base/data/Tag/definition";
 import { IO, URIO } from "@fncts/io/IO/definition";
 import { Scope } from "@fncts/io/Scope/definition";
 import { Schedule } from "@fncts/io/Schedule/definition";
@@ -11,7 +11,7 @@ import { Layer } from "@fncts/io/Layer/definition";
  * @tsplus fluent fncts.io.Layer and
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function and_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn, E, ROut>, that: Layer<RIn1, E1, ROut1>): Layer<RIn | RIn1, E | E1, ROut | ROut1>;
+export declare function and_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn, E, ROut>, that: Layer<RIn1, E1, ROut1>, __tsplusTrace?: string): Layer<RIn | RIn1, E | E1, ROut | ROut1>;
 /**
  * Feeds the output services of this layer into the input of the specified
  * layer, resulting in a new layer with the inputs of this layer, and the
@@ -19,7 +19,7 @@ export declare function and_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn, E,
  * @tsplus fluent fncts.io.Layer andTo
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function andTo_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn, E, ROut>, that: Layer<RIn1, E1, ROut1>): Layer<RIn | Exclude<RIn1, ROut>, E | E1, ROut | ROut1>;
+export declare function andTo_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn, E, ROut>, that: Layer<RIn1, E1, ROut1>, __tsplusTrace?: string): Layer<RIn | Exclude<RIn1, ROut>, E | E1, ROut | ROut1>;
 /**
  * Feeds the output services of this layer into the input of the specified
  * layer, resulting in a new layer with the inputs of this layer, and the
@@ -27,69 +27,69 @@ export declare function andTo_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn, E
  * @tsplus fluent fncts.io.Layer andTo
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function andUsing_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn1, E1, ROut1>, that: Layer<RIn, E, ROut>): Layer<RIn | Exclude<RIn1, ROut>, E | E1, ROut | ROut1>;
+export declare function andUsing_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn1, E1, ROut1>, that: Layer<RIn, E, ROut>, __tsplusTrace?: string): Layer<RIn | Exclude<RIn1, ROut>, E | E1, ROut | ROut1>;
 /**
  * @tsplus fluent fncts.io.Layer catchAll
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function catchAll_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn, E, ROut>, f: (e: E) => Layer<RIn1, E1, ROut1>): Layer<RIn | RIn1, E1, ROut | ROut1>;
+export declare function catchAll_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn, E, ROut>, f: (e: E) => Layer<RIn1, E1, ROut1>, __tsplusTrace?: string): Layer<RIn | RIn1, E1, ROut | ROut1>;
 /**
  * @tsplus fluent fncts.io.Layer flatMap
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function flatMap_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn, E, ROut>, f: (r: Environment<ROut>) => Layer<RIn1, E1, ROut1>): Layer<RIn | RIn1, E | E1, ROut1>;
+export declare function flatMap_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn, E, ROut>, f: (r: Environment<ROut>) => Layer<RIn1, E1, ROut1>, __tsplusTrace?: string): Layer<RIn | RIn1, E | E1, ROut1>;
 /**
  * @tsplus fluent fncts.io.Layer compose
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function compose_<RIn, E, ROut, E1, ROut1>(self: Layer<RIn, E, ROut>, that: Layer<ROut, E1, ROut1>): Layer<RIn, E | E1, ROut1>;
+export declare function compose_<RIn, E, ROut, E1, ROut1>(self: Layer<RIn, E, ROut>, that: Layer<ROut, E1, ROut1>, __tsplusTrace?: string): Layer<RIn, E | E1, ROut1>;
 /**
  * @tsplus static fncts.io.LayerOps environment
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function environment<RIn>(): Layer<RIn, never, RIn>;
+export declare function environment<RIn>(__tsplusTrace?: string): Layer<RIn, never, RIn>;
 /**
  * @tsplus static fncts.io.LayerOps fail
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function fail<E>(e: Lazy<E>): Layer<never, E, never>;
+export declare function fail<E>(e: Lazy<E>, __tsplusTrace?: string): Layer<never, E, never>;
 /**
  * @tsplus static fncts.io.LayerOps failCause
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function failCause<E>(cause: Lazy<Cause<E>>): Layer<never, E, never>;
+export declare function failCause<E>(cause: Lazy<Cause<E>>, __tsplusTrace?: string): Layer<never, E, never>;
 /**
  * @tsplus static fncts.io.LayerOps failCauseNow
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function failCauseNow<E>(cause: Cause<E>): Layer<never, E, never>;
+export declare function failCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string): Layer<never, E, never>;
 /**
  * @tsplus static fncts.io.LayerOps failNow
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function failNow<E>(e: E): Layer<never, E, never>;
+export declare function failNow<E>(e: E, __tsplusTrace?: string): Layer<never, E, never>;
 /**
  * @tsplus getter fncts.io.Layer flatten
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function flatten<RIn, E, RIn1, E1, ROut>(self: Layer<RIn, E, Layer<RIn1, E1, ROut>>, tag: Tag<Layer<RIn1, E1, ROut>>): Layer<RIn | RIn1, E | E1, ROut>;
+export declare function flatten<RIn, E, RIn1, E1, ROut>(self: Layer<RIn, E, Layer<RIn1, E1, ROut>>, tag: Tag<Layer<RIn1, E1, ROut>>, __tsplusTrace?: string): Layer<RIn | RIn1, E | E1, ROut>;
 /**
  * @tsplus getter fncts.io.Layer fresh
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function fresh<R, E, A>(self: Layer<R, E, A>): Layer<R, E, A>;
+export declare function fresh<R, E, A>(self: Layer<R, E, A>, __tsplusTrace?: string): Layer<R, E, A>;
 /**
  * @tsplus static fncts.io.LayerOps fromFunction
  * @tsplus location "@fncts/io/Layer/api"
  */
 export declare function fromFunction<R, A>(f: (r: R) => A, 
 /** @tsplus implicit local */ tagR: Tag<R>, 
-/** @tsplus implicit local */ tagA: Tag<A>): Layer<R, never, A>;
+/** @tsplus implicit local */ tagA: Tag<A>, __tsplusTrace?: string): Layer<R, never, A>;
 /**
  * @tsplus static fncts.io.LayerOps fromFunctionIO
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function fromFunctionIO<R, E, A, R1>(f: (r: R) => IO<R1, E, A>, tagR: Tag<R>, tagA: Tag<A>): Layer<R1 | R, E, A>;
+export declare function fromFunctionIO<R, E, A, R1>(f: (r: R) => IO<R1, E, A>, tagR: Tag<R>, tagA: Tag<A>, __tsplusTrace?: string): Layer<R1 | R, E, A>;
 /**
  * @tsplus static fncts.io.LayerOps fromIOEnvironment
  * @tsplus static fncts.io.LayerOps __call
@@ -100,102 +100,102 @@ export declare function fromIOEnvironment<R, E, A>(io: IO<R, E, Environment<A>>,
  * @tsplus static fncts.io.LayerOps fromIO
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function fromIO<R, E, A>(resource: IO<R, E, A>, tag: Tag<A>): Layer<R, E, A>;
+export declare function fromIO<R, E, A>(resource: IO<R, E, A>, tag: Tag<A>, __tsplusTrace?: string): Layer<R, E, A>;
 /**
  * @tsplus static fncts.io.LayerOps fromValue
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function fromValue<A>(value: Lazy<A>, tag: Tag<A>): Layer<never, never, A>;
+export declare function fromValue<A>(value: Lazy<A>, tag: Tag<A>, __tsplusTrace?: string): Layer<never, never, A>;
 /**
  * @tsplus static fncts.io.LayerOps halt
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function halt(defect: Lazy<unknown>): Layer<never, never, never>;
+export declare function halt(defect: Lazy<unknown>, __tsplusTrace?: string): Layer<never, never, never>;
 /**
  * @tsplus static fncts.io.LayerOps haltNow
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function haltNow(defect: unknown): Layer<never, never, never>;
+export declare function haltNow(defect: unknown, __tsplusTrace?: string): Layer<never, never, never>;
 /**
  * @tsplus fluent fncts.io.Layer matchCauseLayer
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function matchCauseLayer_<RIn, E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2>(self: Layer<RIn, E, ROut>, failure: (cause: Cause<E>) => Layer<RIn1, E1, ROut1>, success: (r: Environment<ROut>) => Layer<RIn2, E2, ROut2>): Layer<RIn | RIn1 | RIn2, E1 | E2, ROut1 | ROut2>;
+export declare function matchCauseLayer_<RIn, E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2>(self: Layer<RIn, E, ROut>, failure: (cause: Cause<E>) => Layer<RIn1, E1, ROut1>, success: (r: Environment<ROut>) => Layer<RIn2, E2, ROut2>, __tsplusTrace?: string): Layer<RIn | RIn1 | RIn2, E1 | E2, ROut1 | ROut2>;
 /**
  * @tsplus fluent fncts.io.Layer matchLayer
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function matchLayer_<RIn, E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2>(self: Layer<RIn, E, ROut>, failure: (e: E) => Layer<RIn1, E1, ROut1>, success: (r: Environment<ROut>) => Layer<RIn2, E2, ROut2>): Layer<RIn | RIn1 | RIn2, E1 | E2, ROut1 | ROut2>;
+export declare function matchLayer_<RIn, E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2>(self: Layer<RIn, E, ROut>, failure: (e: E) => Layer<RIn1, E1, ROut1>, success: (r: Environment<ROut>) => Layer<RIn2, E2, ROut2>, __tsplusTrace?: string): Layer<RIn | RIn1 | RIn2, E1 | E2, ROut1 | ROut2>;
 /**
  * @tsplus fluent fncts.io.Layer map
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function map_<RIn, E, ROut, ROut1>(self: Layer<RIn, E, ROut>, f: (r: Environment<ROut>) => Environment<ROut1>): Layer<RIn, E, ROut1>;
+export declare function map_<RIn, E, ROut, ROut1>(self: Layer<RIn, E, ROut>, f: (r: Environment<ROut>) => Environment<ROut1>, __tsplusTrace?: string): Layer<RIn, E, ROut1>;
 /**
  * @tsplus fluent fncts.io.Layer mapError
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function mapError_<RIn, E, ROut, E1>(self: Layer<RIn, E, ROut>, f: (e: E) => E1): Layer<RIn, E1, ROut>;
+export declare function mapError_<RIn, E, ROut, E1>(self: Layer<RIn, E, ROut>, f: (e: E) => E1, __tsplusTrace?: string): Layer<RIn, E1, ROut>;
 /**
  * @tsplus getter fncts.io.Layer memoize
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function memoize<RIn, E, ROut>(self: Layer<RIn, E, ROut>): URIO<Scope, Layer<RIn, E, ROut>>;
+export declare function memoize<RIn, E, ROut>(self: Layer<RIn, E, ROut>, __tsplusTrace?: string): URIO<Scope, Layer<RIn, E, ROut>>;
 /**
  * @tsplus fluent fncts.io.Layer orElse
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function orElse_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn, E, ROut>, that: Layer<RIn1, E1, ROut1>): Layer<RIn | RIn1, E | E1, ROut | ROut1>;
+export declare function orElse_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn, E, ROut>, that: Layer<RIn1, E1, ROut1>, __tsplusTrace?: string): Layer<RIn | RIn1, E | E1, ROut | ROut1>;
 /**
  * @tsplus getter fncts.io.Layer orHalt
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function orHalt<RIn, E, ROut>(self: Layer<RIn, E, ROut>): Layer<RIn, never, ROut>;
+export declare function orHalt<RIn, E, ROut>(self: Layer<RIn, E, ROut>, __tsplusTrace?: string): Layer<RIn, never, ROut>;
 /**
  * @tsplus getter fncts.io.Layer passthrough
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function passthrough<RIn extends Spreadable, E, ROut extends Spreadable>(self: Layer<RIn, E, ROut>): Layer<RIn, E, RIn & ROut>;
+export declare function passthrough<RIn extends Spreadable, E, ROut extends Spreadable>(self: Layer<RIn, E, ROut>, __tsplusTrace?: string): Layer<RIn, E, RIn & ROut>;
 /**
  * @tsplus fluent fncts.io.Layer retry
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function retry_<RIn, E, ROut, S, RIn1>(self: Layer<RIn, E, ROut>, schedule: Schedule.WithState<S, RIn1, E, any>): Layer<RIn | RIn1, E, ROut>;
+export declare function retry_<RIn, E, ROut, S, RIn1>(self: Layer<RIn, E, ROut>, schedule: Schedule.WithState<S, RIn1, E, any>, __tsplusTrace?: string): Layer<RIn | RIn1, E, ROut>;
 /**
  * @tsplus static fncts.io.LayerOps scoped
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function scoped<R, E, A>(io: Lazy<IO<R, E, A>>, tag: Tag<A>): Layer<Exclude<R, Scope>, E, A>;
+export declare function scoped<R, E, A>(io: Lazy<IO<R, E, A>>, tag: Tag<A>, __tsplusTrace?: string): Layer<Exclude<R, Scope>, E, A>;
 /**
  * @tsplus static fncts.io.LayerOps scopedEnvironment
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function scopedEnvironment<R, E, A>(io: Lazy<IO<R, E, Environment<A>>>): Layer<Exclude<R, Scope>, E, A>;
+export declare function scopedEnvironment<R, E, A>(io: Lazy<IO<R, E, Environment<A>>>, __tsplusTrace?: string): Layer<Exclude<R, Scope>, E, A>;
 /**
  * @tsplus static fncts.io.LayerOps service
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function service<A>(tag: Tag<A>): Layer<A, never, A>;
+export declare function service<A>(tag: Tag<A>, __tsplusTrace?: string): Layer<A, never, A>;
 /**
  * @tsplus static fncts.io.LayerOps succeed
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function succeed<A>(resource: Lazy<A>, tag: Tag<A>): Layer<never, never, A>;
+export declare function succeed<A>(resource: Lazy<A>, tag: Tag<A>, __tsplusTrace?: string): Layer<never, never, A>;
 /**
  * @tsplus static fncts.io.LayerOps succeedEnvironment
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function succeedEnvironment<A>(a: Lazy<Environment<A>>): Layer<never, never, A>;
+export declare function succeedEnvironment<A>(a: Lazy<Environment<A>>, __tsplusTrace?: string): Layer<never, never, A>;
 /**
  * @tsplus static fncts.io.LayerOps succeedEnvironmentNow
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function succeedEnvironmentNow<A>(a: Environment<A>): Layer<never, never, A>;
+export declare function succeedEnvironmentNow<A>(a: Environment<A>, __tsplusTrace?: string): Layer<never, never, A>;
 /**
  * @tsplus static fncts.io.LayerOps succeedNow
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function succeedNow<A>(resource: A, tag: Tag<A>): Layer<never, never, A>;
+export declare function succeedNow<A>(resource: A, tag: Tag<A>, __tsplusTrace?: string): Layer<never, never, A>;
 /**
  * @tsplus fluent fncts.io.Layer to
  * @tsplus location "@fncts/io/Layer/api"

package/Layer/definition.d.ts

@@ -1,5 +1,5 @@
-import { Cause } from "@fncts/base/data/Cause";
-import { Environment } from "@fncts/base/data/Environment";
+import { Cause } from "@fncts/base/data/Cause/definition";
+import { Environment } from "@fncts/base/data/Environment/definition";
 import { Scope } from "@fncts/io/Scope/definition";
 import { IO } from "@fncts/io/IO/definition";
 export declare const LayerHash: unique symbol;
@@ -34,41 +34,48 @@ export declare class Fold<RIn, E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2> extend
     readonly self: Layer<RIn, E, ROut>;
     readonly failure: (cause: Cause<E>) => Layer<RIn1, E1, ROut1>;
     readonly success: (r: Environment<ROut>) => Layer<RIn2, E2, ROut2>;
+    readonly trace?: string | undefined;
     readonly _tag = LayerTag.Fold;
-    constructor(self: Layer<RIn, E, ROut>, failure: (cause: Cause<E>) => Layer<RIn1, E1, ROut1>, success: (r: Environment<ROut>) => Layer<RIn2, E2, ROut2>);
+    constructor(self: Layer<RIn, E, ROut>, failure: (cause: Cause<E>) => Layer<RIn1, E1, ROut1>, success: (r: Environment<ROut>) => Layer<RIn2, E2, ROut2>, trace?: string | undefined);
 }
 export declare class Fresh<RIn, E, ROut> extends Layer<RIn, E, ROut> {
     readonly self: Layer<RIn, E, ROut>;
+    readonly trace?: string | undefined;
     readonly _tag = LayerTag.Fresh;
-    constructor(self: Layer<RIn, E, ROut>);
+    constructor(self: Layer<RIn, E, ROut>, trace?: string | undefined);
 }
 export declare class FromScoped<RIn, E, ROut> extends Layer<Exclude<RIn, Scope>, E, ROut> {
     readonly self: IO<RIn, E, Environment<ROut>>;
+    readonly trace?: string | undefined;
     readonly _tag = LayerTag.Scoped;
-    constructor(self: IO<RIn, E, Environment<ROut>>);
+    constructor(self: IO<RIn, E, Environment<ROut>>, trace?: string | undefined);
 }
 export declare class Defer<RIn, E, ROut> extends Layer<RIn, E, ROut> {
     readonly self: () => Layer<RIn, E, ROut>;
+    readonly trace?: string | undefined;
     readonly _tag = LayerTag.Defer;
-    constructor(self: () => Layer<RIn, E, ROut>);
+    constructor(self: () => Layer<RIn, E, ROut>, trace?: string | undefined);
 }
 export declare class To<RIn, E, ROut, E1, ROut1> extends Layer<RIn, E | E1, ROut1> {
     readonly self: Layer<RIn, E, ROut>;
     readonly that: Layer<ROut, E1, ROut1>;
+    readonly trace?: string | undefined;
     readonly _tag = LayerTag.To;
-    constructor(self: Layer<RIn, E, ROut>, that: Layer<ROut, E1, ROut1>);
+    constructor(self: Layer<RIn, E, ROut>, that: Layer<ROut, E1, ROut1>, trace?: string | undefined);
 }
 export declare class ZipWith<RIn, E, ROut, RIn1, E1, ROut1, ROut2> extends Layer<RIn | RIn1, E | E1, ROut2> {
     readonly self: Layer<RIn, E, ROut>;
     readonly that: Layer<RIn1, E1, ROut1>;
     readonly f: (a: Environment<ROut>, b: Environment<ROut1>) => Environment<ROut2>;
+    readonly trace?: string | undefined;
     readonly _tag = LayerTag.ZipWith;
-    constructor(self: Layer<RIn, E, ROut>, that: Layer<RIn1, E1, ROut1>, f: (a: Environment<ROut>, b: Environment<ROut1>) => Environment<ROut2>);
+    constructor(self: Layer<RIn, E, ROut>, that: Layer<RIn1, E1, ROut1>, f: (a: Environment<ROut>, b: Environment<ROut1>) => Environment<ROut2>, trace?: string | undefined);
 }
 export declare class ZipWithC<RIn, E, ROut, RIn1, E1, ROut1, ROut2> extends Layer<RIn | RIn1, E | E1, ROut2> {
     readonly self: Layer<RIn, E, ROut>;
     readonly that: Layer<RIn1, E1, ROut1>;
     readonly f: (a: Environment<ROut>, b: Environment<ROut1>) => Environment<ROut2>;
+    readonly trace?: string | undefined;
     readonly _tag = LayerTag.ZipWithC;
-    constructor(self: Layer<RIn, E, ROut>, that: Layer<RIn1, E1, ROut1>, f: (a: Environment<ROut>, b: Environment<ROut1>) => Environment<ROut2>);
+    constructor(self: Layer<RIn, E, ROut>, that: Layer<RIn1, E1, ROut1>, f: (a: Environment<ROut>, b: Environment<ROut1>) => Environment<ROut2>, trace?: string | undefined);
 }

package/Logger/api.d.ts

@@ -1,7 +1,7 @@
 import { Logger } from "@fncts/io/Logger/definition";
-import { Predicate } from "@fncts/base/data/Predicate";
+import { Predicate } from "@fncts/base/data/Predicate/definition";
 import { LogLevel } from "@fncts/io/LogLevel";
-import { Maybe } from "@fncts/base/data/Maybe";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
 /**
  * @tsplus fluent fncts.io.Logger filterLogLevel
  * @tsplus location "@fncts/io/Logger/api"

package/Logger/definition.d.ts

@@ -1,10 +1,10 @@
 import { TraceElement } from "@fncts/base/data/TraceElement/definition";
-import { FiberId } from "@fncts/base/data/FiberId";
+import { FiberId } from "@fncts/base/data/FiberId/definition";
 import { LogLevel } from "@fncts/io/LogLevel";
-import { Cause } from "@fncts/base/data/Cause";
-import { HashMap } from "@fncts/base/collection/immutable/HashMap";
+import { Cause } from "@fncts/base/data/Cause/definition";
+import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
 import { FiberRef } from "@fncts/io/FiberRef/definition";
-import { List } from "@fncts/base/collection/immutable/List";
+import { List } from "@fncts/base/collection/immutable/List/definition";
 import type { LogSpan } from "@fncts/io/LogSpan";
 /**
  * @tsplus type fncts.io.Logger

package/Queue/api/dimapIO.d.ts

@@ -7,35 +7,35 @@ import { PQueue } from "@fncts/io/Queue/definition";
  * @tsplus fluent fncts.io.Queue dimap
  * @tsplus location "@fncts/io/Queue/api/dimapIO"
  */
-export declare function dimap_<RA, RB, EA, EB, A, B, C, D>(self: PQueue<RA, RB, EA, EB, A, B>, f: (c: C) => A, g: (b: B) => D): import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, C, D>;
+export declare function dimap_<RA, RB, EA, EB, A, B, C, D>(self: PQueue<RA, RB, EA, EB, A, B>, f: (c: C) => A, g: (b: B) => D, __tsplusTrace?: string): import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, C, D>;
 /**
  * Transforms elements enqueued into and dequeued from this queue with the
  * specified effectual functions.
  * @tsplus fluent fncts.io.Queue dimapIO
  * @tsplus location "@fncts/io/Queue/api/dimapIO"
  */
-export declare function dimapIO_<RA, RB, EA, EB, A, B, C, RC, EC, RD, ED, D>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (c: C) => IO<RC, EC, A>, g: (b: B) => IO<RD, ED, D>): PQueue<RC | RA, RD | RB, EC | EA, ED | EB, C, D>;
+export declare function dimapIO_<RA, RB, EA, EB, A, B, C, RC, EC, RD, ED, D>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (c: C) => IO<RC, EC, A>, g: (b: B) => IO<RD, ED, D>, __tsplusTrace?: string): PQueue<RC | RA, RD | RB, EC | EA, ED | EB, C, D>;
 /**
  * Transforms elements enqueued into this queue with an effectful function.
  * @tsplus fluent fncts.io.Queue contramapIO
  * @tsplus location "@fncts/io/Queue/api/dimapIO"
  */
-export declare function contramapIO_<RA, RB, EA, EB, A, B, RC, EC, C>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (c: C) => IO<RC, EC, A>): PQueue<RA | RC, RB, EA | EC, EB, C, B>;
+export declare function contramapIO_<RA, RB, EA, EB, A, B, RC, EC, C>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (c: C) => IO<RC, EC, A>, __tsplusTrace?: string): PQueue<RA | RC, RB, EA | EC, EB, C, B>;
 /**
  * Transforms elements enqueued into this queue with an effectful function.
  * @tsplus fluent fncts.io.Queue contramap
  * @tsplus location "@fncts/io/Queue/api/dimapIO"
  */
-export declare function contramap_<RA, RB, EA, EB, A, B, C>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (c: C) => A): PQueue<RA, RB, EA, EB, C, B>;
+export declare function contramap_<RA, RB, EA, EB, A, B, C>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (c: C) => A, __tsplusTrace?: string): PQueue<RA, RB, EA, EB, C, B>;
 /**
  * Transforms elements dequeued from this queue with an effectful function.
  * @tsplus fluent fncts.io.Queue mapIO
  * @tsplus location "@fncts/io/Queue/api/dimapIO"
  */
-export declare function mapIO_<RA, RB, EA, EB, A, B, R2, E2, C>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (b: B) => IO<R2, E2, C>): PQueue<RA, R2 | RB, EA, EB | E2, A, C>;
+export declare function mapIO_<RA, RB, EA, EB, A, B, R2, E2, C>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (b: B) => IO<R2, E2, C>, __tsplusTrace?: string): PQueue<RA, R2 | RB, EA, EB | E2, A, C>;
 /**
  * Transforms elements dequeued from this queue with a function.
  * @tsplus fluent fncts.io.Queue map
  * @tsplus location "@fncts/io/Queue/api/dimapIO"
  */
-export declare function map_<RA, RB, EA, EB, A, B, C>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (b: B) => C): PQueue<RA, RB, EA, EB, A, C>;
+export declare function map_<RA, RB, EA, EB, A, B, C>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (b: B) => C, __tsplusTrace?: string): PQueue<RA, RB, EA, EB, A, C>;

package/Queue/api/filterInputIO.d.ts

@@ -1,5 +1,5 @@
 import { IO, UIO } from "@fncts/io/IO/definition";
-import { Just, Nothing } from "@fncts/base/data/Maybe";
+import { Just, Nothing } from "@fncts/base/data/Maybe/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
 import { PQueue } from "@fncts/io/Queue/definition";
 import { QueueInternal } from "@fncts/io/Queue/definition";
@@ -23,11 +23,11 @@ export declare class FilterInputIO<RA, RB, EA, EB, B, A, A1 extends A, R2, E2> e
  * @tsplus fluent fncts.io.Queue filterInputIO
  * @tsplus location "@fncts/io/Queue/api/filterInputIO"
  */
-export declare function filterInputIO_<RA, RB, EA, EB, B, A, A1 extends A, R2, E2>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (_: A1) => IO<R2, E2, boolean>): PQueue<RA | R2, RB, EA | E2, EB, A1, B>;
+export declare function filterInputIO_<RA, RB, EA, EB, B, A, A1 extends A, R2, E2>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (_: A1) => IO<R2, E2, boolean>, __tsplusTrace?: string): PQueue<RA | R2, RB, EA | E2, EB, A1, B>;
 /**
  * Applies a filter to elements enqueued into this queue. Elements that do not
  * pass the filter will be immediately dropped.
  * @tsplus fluent fncts.io.Queue filterInput
  * @tsplus location "@fncts/io/Queue/api/filterInputIO"
  */
-export declare function filterInput_<RA, RB, EA, EB, B, A, A1 extends A>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (_: A1) => boolean): PQueue<RA, RB, EA, EB, A1, B>;
+export declare function filterInput_<RA, RB, EA, EB, B, A, A1 extends A>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (_: A1) => boolean, __tsplusTrace?: string): PQueue<RA, RB, EA, EB, A1, B>;

package/Queue/api/filterOutputIO.d.ts

@@ -1,7 +1,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 { Predicate } from "@fncts/base/data/Predicate";
+import { Predicate } from "@fncts/base/data/Predicate/definition";
 import { QueueInternal } from "@fncts/io/Queue/definition";
 export declare class FilterOutputIO<RA, RB, EA, EB, A, B, RB1, EB1> extends QueueInternal<RA, RB | RB1, EA, EB | EB1, A, B> {
     readonly queue: QueueInternal<RA, RB, EA, EB, A, B>;
@@ -23,9 +23,9 @@ export declare class FilterOutputIO<RA, RB, EA, EB, A, B, RB1, EB1> extends Queu
  * @tsplus fluent fncts.io.Queue filterOutputIO
  * @tsplus location "@fncts/io/Queue/api/filterOutputIO"
  */
-export declare function filterOutputIO_<RA, RB, EA, EB, A, B, RB1, EB1>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (b: B) => IO<RB1, EB1, boolean>): PQueue<RA, RB | RB1, EA, EB | EB1, A, B>;
+export declare function filterOutputIO_<RA, RB, EA, EB, A, B, RB1, EB1>(queue: PQueue<RA, RB, EA, EB, A, B>, f: (b: B) => IO<RB1, EB1, boolean>, __tsplusTrace?: string): PQueue<RA, RB | RB1, EA, EB | EB1, A, B>;
 /**
  * @tsplus fluent fncts.io.Queue filterOutput
  * @tsplus location "@fncts/io/Queue/api/filterOutputIO"
  */
-export declare function filterOutput_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, p: Predicate<B>): PQueue<RA, RB, EA, EB, A, B>;
+export declare function filterOutput_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, p: Predicate<B>, __tsplusTrace?: string): PQueue<RA, RB, EA, EB, A, B>;

package/Queue/api/operations.d.ts

@@ -7,25 +7,25 @@ import { UIO, IO } from "@fncts/io/IO/definition";
  * @tsplus getter fncts.io.Queue awaitShutdown
  * @tsplus location "@fncts/io/Queue/api/operations"
  */
-export declare function awaitShutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>): UIO<void>;
+export declare function awaitShutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): UIO<void>;
 /**
  * How many elements can hold in the queue
  * @tsplus getter fncts.io.Queue capacity
  * @tsplus location "@fncts/io/Queue/api/operations"
  */
-export declare function capacity<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>): number;
+export declare function capacity<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): number;
 /**
  * `true` if `shutdown` has been called.
  * @tsplus getter fncts.io.Queue isShutdown
  * @tsplus location "@fncts/io/Queue/api/operations"
  */
-export declare function isShutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>): UIO<boolean>;
+export declare function isShutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): UIO<boolean>;
 /**
  * Places one value in the queue.
  * @tsplus fluent fncts.io.Queue offer
  * @tsplus location "@fncts/io/Queue/api/operations"
  */
-export declare function offer_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, a: A): IO<RA, EA, boolean>;
+export declare function offer_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, 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
@@ -44,14 +44,14 @@ export declare function offer_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, E
  * @tsplus fluent fncts.io.Queue offerAll
  * @tsplus location "@fncts/io/Queue/api/operations"
  */
-export declare function offerAll_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, as: Iterable<A>): import("../../IO").IO<RA, EA, boolean>;
+export declare function offerAll_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, as: Iterable<A>, __tsplusTrace?: string): import("../../IO").IO<RA, EA, boolean>;
 /**
  * Interrupts any fibers that are suspended on `offer` or `take`.
  * Future calls to `offer*` and `take*` will be interrupted immediately.
  * @tsplus getter fncts.io.Queue shutdown
  * @tsplus location "@fncts/io/Queue/api/operations"
  */
-export declare function shutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>): import("../../IO").UIO<void>;
+export declare function shutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): import("../../IO").UIO<void>;
 /**
  * Retrieves the size of the queue, which is equal to the number of elements
  * in the queue. This may be negative if fibers are suspended waiting for
@@ -59,24 +59,24 @@ export declare function shutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA,
  * @tsplus getter fncts.io.Queue size
  * @tsplus location "@fncts/io/Queue/api/operations"
  */
-export declare function size<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>): import("../../IO").UIO<number>;
+export declare function size<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): import("../../IO").UIO<number>;
 /**
  * Removes the oldest value in the queue. If the queue is empty, this will
  * return a computation that resumes when an item has been added to the queue.
  * @tsplus getter fncts.io.Queue take
  * @tsplus location "@fncts/io/Queue/api/operations"
  */
-export declare function take<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>): IO<RB, EB, B>;
+export declare function take<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): IO<RB, EB, B>;
 /**
  * Removes all the values in the queue and returns the list of the values. If the queue
  * is empty returns empty list.
  * @tsplus getter fncts.io.Queue takeAll
  * @tsplus location "@fncts/io/Queue/api/operations"
  */
-export declare function takeAll<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>): import("../../IO").IO<RB, EB, import("@fncts/base/collection/immutable/Conc").Conc<B>>;
+export declare function takeAll<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): import("../../IO").IO<RB, EB, import("@fncts/base/collection/immutable/Conc").Conc<B>>;
 /**
  * Takes up to max number of values in the queue.
  * @tsplus fluent fncts.io.Queue takeAllUpTo
  * @tsplus location "@fncts/io/Queue/api/operations"
  */
-export declare function takeAllUpTo_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, n: number): import("../../IO").IO<RB, EB, import("@fncts/base/collection/immutable/Conc").Conc<B>>;
+export declare function takeAllUpTo_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, n: number, __tsplusTrace?: string): import("../../IO").IO<RB, EB, import("@fncts/base/collection/immutable/Conc").Conc<B>>;

package/Queue/api/poll.d.ts

@@ -1,9 +1,9 @@
 import { PQueue } from "@fncts/io/Queue/definition";
 import { IO } from "@fncts/io/IO/definition";
-import { Maybe } from "@fncts/base/data/Maybe";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
 /**
  * Take the head option of values in the queue.
  * @tsplus getter fncts.io.Queue poll
  * @tsplus location "@fncts/io/Queue/api/poll"
  */
-export declare function poll<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>): IO<RB, EB, Maybe<B>>;
+export declare function poll<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): IO<RB, EB, Maybe<B>>;

package/Queue/api/takeBetween.d.ts

@@ -8,4 +8,4 @@ import { Conc } from "@fncts/base/collection/immutable/Conc";
  * @tsplus fluent fncts.io.Queue takeBetween
  * @tsplus location "@fncts/io/Queue/api/takeBetween"
  */
-export declare function takeBetween_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, min: number, max: number): IO<RB, EB, Conc<B>>;
+export declare function takeBetween_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, min: number, max: number, __tsplusTrace?: string): IO<RB, EB, Conc<B>>;

package/Queue/api/zipWithIO.d.ts

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

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