@fncts/io 0.0.11 → 0.0.14

package/Layer/api.d.ts

@@ -1,19 +1,17 @@
-import { Environment } from "@fncts/base/data/Environment";
-import { Lazy } from "@fncts/base/data/function";
-import { Cause } from "@fncts/base/data/Cause";
-import { Has } from "@fncts/base/typeclass/Has";
-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";
 import type { Spreadable } from "@fncts/base/types";
-import type { Erase } from "@fncts/typelevel/Intersection";
 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
@@ -21,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 & Erase<ROut & 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
@@ -29,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 & Erase<ROut & 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<unknown, 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<unknown, 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<unknown, 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<unknown, 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, Has<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<Has<R>, never, Has<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 & Has<R>, E, Has<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
@@ -102,109 +100,109 @@ 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, Has<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<unknown, never, Has<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<unknown, 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<unknown, 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<Has<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 & Has<Scope>, E, A>>, tag: Tag<A>): Layer<R, E, Has<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 & Has<Scope>, E, Environment<A>>>): Layer<R, 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<Has<A>, never, Has<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<unknown, never, Has<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<unknown, 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<unknown, 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<unknown, never, Has<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"
  */
-export declare function to_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn, E, ROut>, that: Layer<RIn1, E1, ROut1>): Layer<RIn & Erase<RIn1, ROut>, E | E1, ROut1>;
+export declare function to_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn, E, ROut>, that: Layer<RIn1, E1, ROut1>): Layer<RIn | Exclude<RIn1, ROut>, E | E1, ROut1>;
 /**
  * @tsplus fluent fncts.io.Layer using
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function using_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn1, E1, ROut1>, that: Layer<RIn, E, ROut>): Layer<RIn & Erase<RIn1, ROut>, E | E1, ROut1>;
+export declare function using_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn1, E1, ROut1>, that: Layer<RIn, E, ROut>): Layer<RIn | Exclude<RIn1, ROut>, E | E1, ROut1>;

package/Layer/definition.d.ts

@@ -1,8 +1,7 @@
-import { Cause } from "@fncts/base/data/Cause";
-import { Environment } from "@fncts/base/data/Environment";
-import { IO } from "@fncts/io/IO/definition";
-import { Has } from "@fncts/base/typeclass/Has";
+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;
 export declare type LayerHash = typeof LayerHash;
 /**
@@ -10,7 +9,7 @@ export declare type LayerHash = typeof LayerHash;
  * @tsplus companion fncts.io.LayerOps
  */
 export declare abstract class Layer<RIn, E, ROut> {
-    readonly _R: (_: RIn) => void;
+    readonly _R: () => RIn;
     readonly _E: () => E;
     readonly _A: () => ROut;
     [LayerHash]: PropertyKey;
@@ -35,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<RIn, E, ROut> {
-    readonly self: IO<RIn & Has<Scope>, E, Environment<ROut>>;
+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 & Has<Scope>, 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> {
+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> {
+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,17 +1,17 @@
 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";
-export declare class FilterInputIO<RA, RB, EA, EB, B, A, A1 extends A, R2, E2> extends QueueInternal<RA & R2, RB, EA | E2, EB, A1, B> {
+export declare class FilterInputIO<RA, RB, EA, EB, B, A, A1 extends A, R2, E2> extends QueueInternal<RA | R2, RB, EA | E2, EB, A1, B> {
     readonly queue: QueueInternal<RA, RB, EA, EB, A, B>;
     readonly f: (_: A1) => IO<R2, E2, boolean>;
     constructor(queue: QueueInternal<RA, RB, EA, EB, A, B>, f: (_: A1) => IO<R2, E2, boolean>);
     awaitShutdown: UIO<void>;
     capacity: number;
     isShutdown: UIO<boolean>;
-    offer(a: A1): IO<RA & R2, EA | E2, boolean>;
-    offerAll(as: Iterable<A1>): IO<RA & R2, EA | E2, boolean>;
+    offer(a: A1): IO<RA | R2, EA | E2, boolean>;
+    offerAll(as: Iterable<A1>): IO<RA | R2, EA | E2, boolean>;
     shutdown: UIO<void>;
     size: UIO<number>;
     take: IO<RB, EB, B>;
@@ -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,9 +1,9 @@
 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> {
+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>;
     readonly f: (b: B) => IO<RB1, EB1, boolean>;
     constructor(queue: QueueInternal<RA, RB, EA, EB, A, B>, f: (b: B) => IO<RB1, EB1, boolean>);
@@ -14,18 +14,18 @@ export declare class FilterOutputIO<RA, RB, EA, EB, A, B, RB1, EB1> extends Queu
     offerAll(as: Iterable<A>): IO<RA, EA, boolean>;
     shutdown: UIO<void>;
     size: UIO<number>;
-    take: IO<RB & RB1, EB1 | EB, B>;
-    takeAll: IO<RB & RB1, EB | EB1, Conc<B>>;
-    loop(max: number, acc: Conc<B>): IO<RB & RB1, EB | EB1, Conc<B>>;
-    takeUpTo(n: number): IO<RB & RB1, EB | EB1, Conc<B>>;
+    take: IO<RB | RB1, EB1 | EB, B>;
+    takeAll: IO<RB | RB1, EB | EB1, Conc<B>>;
+    loop(max: number, acc: Conc<B>): IO<RB | RB1, EB | EB1, Conc<B>>;
+    takeUpTo(n: number): IO<RB | RB1, EB | EB1, Conc<B>>;
 }
 /**
  * @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>>;