@fncts/io 0.0.12 → 0.0.15

package/Hub/definition.d.ts

@@ -1,6 +1,5 @@
 import { PQueue } from "@fncts/io/Queue/definition";
 import { UIO, IO } from "@fncts/io/IO/definition";
-import { Has } from "@fncts/base/typeclass/Has";
 import { Scope } from "@fncts/io/Scope/definition";
 export declare const HubTypeId: unique symbol;
 export declare type HubTypeId = typeof HubTypeId;
@@ -16,8 +15,8 @@ export declare type HubTypeId = typeof HubTypeId;
  */
 export interface PHub<RA, RB, EA, EB, A, B> {
     readonly _typeId: HubTypeId;
-    readonly _RA: (_: RA) => void;
-    readonly _RB: (_: RB) => void;
+    readonly _RA: () => RA;
+    readonly _RB: () => RB;
     readonly _EA: () => EA;
     readonly _EB: () => EB;
     readonly _A: (_: A) => void;
@@ -26,7 +25,7 @@ export interface PHub<RA, RB, EA, EB, A, B> {
 /**
  * @tsplus type fncts.io.Hub
  */
-export interface Hub<A> extends PHub<unknown, unknown, never, never, A, A> {
+export interface Hub<A> extends PHub<never, never, never, never, A, A> {
 }
 /**
  * @tsplus type fncts.io.HubOps
@@ -40,8 +39,8 @@ export declare namespace Hub {
 }
 export declare abstract class PHubInternal<RA, RB, EA, EB, A, B> implements PHub<RA, RB, EA, EB, A, B> {
     _typeId: HubTypeId;
-    readonly _RA: (_: RA) => void;
-    readonly _RB: (_: RB) => void;
+    readonly _RA: () => RA;
+    readonly _RB: () => RB;
     readonly _EA: () => EA;
     readonly _EB: () => EB;
     readonly _A: (_: A) => void;
@@ -81,7 +80,7 @@ export declare abstract class PHubInternal<RA, RB, EA, EB, A, B> implements PHub
      * can be evaluated multiple times within the scope of the managed to take a
      * message from the hub each time.
      */
-    abstract subscribe: IO<Has<Scope>, never, Hub.Dequeue<RB, EB, B>>;
+    abstract subscribe: IO<Scope, never, Hub.Dequeue<RB, EB, B>>;
 }
 /**
  * @tsplus macro remove

package/Hub/internal.d.ts

@@ -3,8 +3,7 @@ import { UIO, IO } from "@fncts/io/IO/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
 import { Queue } from "@fncts/io/Queue/definition";
 import { Scope } from "@fncts/io/Scope/definition";
-import { Exit } from "@fncts/base/data/Exit";
-import { Has } from "@fncts/base/typeclass/Has";
+import { Exit } from "@fncts/base/data/Exit/definition";
 import { Hub } from "@fncts/io/Hub/definition";
 import type { Hub as HubInternal } from "@fncts/io/internal/Hub";
 import { HashSet } from "@fncts/base/collection/mutable/HashSet";

package/IO/api/acquireRelease.d.ts

@@ -1,10 +1,9 @@
-import { Lazy } from "@fncts/base/data/function";
+import { Lazy } from "@fncts/base/data/function/definition";
 import { IO } from "@fncts/io/IO/definition";
-import { Has } from "@fncts/base/typeclass/Has";
 import { Scope } from "@fncts/io/Scope/definition";
 /**
  * @tsplus static fncts.io.IOOps acquireRelease
  * @tsplus fluent fncts.io.IO acquireRelease
  * @tsplus location "@fncts/io/IO/api/acquireRelease"
  */
-export declare function acquireRelease<R, E, A, R1>(acquire: Lazy<IO<R, E, A>>, release: (a: A) => IO<R1, never, any>): IO<R & R1 & Has<Scope>, E, A>;
+export declare function acquireRelease<R, E, A, R1>(acquire: Lazy<IO<R, E, A>>, release: (a: A) => IO<R1, never, any>, __tsplusTrace?: string): IO<R | R1 | Scope, E, A>;

package/IO/api/acquireReleaseExit.d.ts

@@ -1,11 +1,10 @@
-import { Lazy } from "@fncts/base/data/function";
+import { Lazy } from "@fncts/base/data/function/definition";
 import { IO } from "@fncts/io/IO/definition";
-import { Exit } from "@fncts/base/data/Exit";
-import { Has } from "@fncts/base/typeclass/Has";
+import { Exit } from "@fncts/base/data/Exit/definition";
 import { Scope } from "@fncts/io/Scope/definition";
 /**
  * @tsplus static fncts.io.IOOps acquireReleaseExit
  * @tsplus fluent fncts.io.IO acquireReleaseExit
  * @tsplus location "@fncts/io/IO/api/acquireReleaseExit"
  */
-export declare function acquireReleaseExit<R, E, A, R1>(acquire: Lazy<IO<R, E, A>>, release: (a: A, exit: Exit<any, any>) => IO<R1, never, any>, __tsplusTrace?: string): IO<R & R1 & Has<Scope>, E, A>;
+export declare function acquireReleaseExit<R, E, A, R1>(acquire: Lazy<IO<R, E, A>>, release: (a: A, exit: Exit<any, any>) => IO<R1, never, any>, __tsplusTrace?: string): IO<R | R1 | Scope, E, A>;

package/IO/api/acquireReleaseInterruptible.d.ts

@@ -1,9 +1,8 @@
-import { Lazy } from "@fncts/base/data/function";
+import { Lazy } from "@fncts/base/data/function/definition";
 import { IO } from "@fncts/io/IO/definition";
-import { Has } from "@fncts/base/typeclass/Has";
 import { Scope } from "@fncts/io/Scope/definition";
 /**
  * @tsplus static fncts.io.IOOps acquireReleaseInterruptible
  * @tsplus location "@fncts/io/IO/api/acquireReleaseInterruptible"
  */
-export declare function acquireReleaseInterruptible<R, E, A, R1>(acquire: Lazy<IO<R, E, A>>, release: IO<R1, never, any>, __tsplusTrace?: string): IO<R & R1 & Has<Scope>, E, A>;
+export declare function acquireReleaseInterruptible<R, E, A, R1>(acquire: Lazy<IO<R, E, A>>, release: IO<R1, never, any>, __tsplusTrace?: string): IO<R | R1 | Scope, E, A>;

package/IO/api/acquireReleaseInterruptibleExit.d.ts

@@ -1,10 +1,9 @@
-import { Lazy } from "@fncts/base/data/function";
+import { Lazy } from "@fncts/base/data/function/definition";
 import { IO } from "@fncts/io/IO/definition";
-import { Exit } from "@fncts/base/data/Exit";
-import { Has } from "@fncts/base/typeclass/Has";
+import { Exit } from "@fncts/base/data/Exit/definition";
 import { Scope } from "@fncts/io/Scope/definition";
 /**
  * @tsplus static fncts.io.IOOps acquireReleaseInterruptibleExit
  * @tsplus location "@fncts/io/IO/api/acquireReleaseInterruptibleExit"
  */
-export declare function acquireReleaseInterruptibleExit<R, E, A, R1>(acquire: Lazy<IO<R, E, A>>, release: (exit: Exit<any, any>) => IO<R1, never, any>, __tsplusTrace?: string): IO<R & R1 & Has<Scope>, E, A>;
+export declare function acquireReleaseInterruptibleExit<R, E, A, R1>(acquire: Lazy<IO<R, E, A>>, release: (exit: Exit<any, any>) => IO<R1, never, any>, __tsplusTrace?: string): IO<R | R1 | Scope, E, A>;

package/IO/api/addFinalizer.d.ts

@@ -1,9 +1,8 @@
-import { Lazy } from "@fncts/base/data/function";
+import { Lazy } from "@fncts/base/data/function/definition";
 import { URIO, IO } from "@fncts/io/IO/definition";
-import { Has } from "@fncts/base/typeclass/Has";
 import { Scope } from "@fncts/io/Scope/definition";
 /**
  * @tsplus static fncts.io.IOOps addFinalizer
  * @tsplus location "@fncts/io/IO/api/addFinalizer"
  */
-export declare function addFinalizer<R>(finalizer: Lazy<URIO<R, any>>, __tsplusTrace?: string): IO<R & Has<Scope>, never, void>;
+export declare function addFinalizer<R>(finalizer: Lazy<URIO<R, any>>, __tsplusTrace?: string): IO<R | Scope, never, void>;

package/IO/api/addFinalizerExit.d.ts

@@ -1,9 +1,8 @@
-import { Exit } from "@fncts/base/data/Exit";
+import { Exit } from "@fncts/base/data/Exit/definition";
 import { URIO, IO } from "@fncts/io/IO/definition";
-import { Has } from "@fncts/base/typeclass/Has";
 import { Scope } from "@fncts/io/Scope/definition";
 /**
  * @tsplus static fncts.io.IOOps addFinalizerExit
  * @tsplus location "@fncts/io/IO/api/addFinalizerExit"
  */
-export declare function addFinalizerExit<R>(finalizer: (exit: Exit<any, any>) => URIO<R, any>): IO<R & Has<Scope>, never, void>;
+export declare function addFinalizerExit<R>(finalizer: (exit: Exit<any, any>) => URIO<R, any>, __tsplusTrace?: string): IO<R | Scope, never, void>;

package/IO/api/asyncIO.d.ts

@@ -3,4 +3,4 @@ import { IO } from "@fncts/io/IO/definition";
  * @tsplus static fncts.io.IOOps asyncIO
  * @tsplus location "@fncts/io/IO/api/asyncIO"
  */
-export declare function asyncIO<R, E, A>(register: (k: (_: IO<R, E, A>) => void) => IO<R, E, void>): IO<R, E, A>;
+export declare function asyncIO<R, E, A>(register: (k: (_: IO<R, E, A>) => void) => IO<R, E, void>, __tsplusTrace?: string): IO<R, E, A>;

package/IO/api/bracket.d.ts

@@ -1,4 +1,4 @@
-import { Lazy } from "@fncts/base/data/function";
+import { Lazy } from "@fncts/base/data/function/definition";
 import { IO } from "@fncts/io/IO/definition";
 /**
  * When this IO represents acquisition of a resource (for example,
@@ -23,4 +23,4 @@ import { IO } from "@fncts/io/IO/definition";
  * @tsplus static fncts.io.IOOps bracket
  * @tsplus location "@fncts/io/IO/api/bracket"
  */
-export declare function bracket_<R, E, A, R1, E1, A1, R2, E2, A2>(acquire: Lazy<IO<R, E, A>>, use: (a: A) => IO<R1, E1, A1>, release: (a: A) => IO<R2, E2, A2>): IO<R & R1 & R2, E | E1 | E2, A1>;
+export declare function bracket_<R, E, A, R1, E1, A1, R2, E2, A2>(acquire: Lazy<IO<R, E, A>>, use: (a: A) => IO<R1, E1, A1>, release: (a: A) => IO<R2, E2, A2>, __tsplusTrace?: string): IO<R | R1 | R2, E | E1 | E2, A1>;

package/IO/api/bracketExit.d.ts

@@ -1,6 +1,6 @@
-import { Lazy } from "@fncts/base/data/function";
+import { Lazy } from "@fncts/base/data/function/definition";
 import { IO } from "@fncts/io/IO/definition";
-import { Exit } from "@fncts/base/data/Exit";
+import { Exit } from "@fncts/base/data/Exit/definition";
 /**
  * Acquires a resource, uses the resource, and then releases the resource.
  * Neither the acquisition nor the release will be interrupted, and the
@@ -11,4 +11,4 @@ import { Exit } from "@fncts/base/data/Exit";
  * @tsplus static fncts.io.IOOps bracketExit
  * @tsplus location "@fncts/io/IO/api/bracketExit"
  */
-export declare function bracketExit_<R, E, A, E1, R1, A1, R2, E2>(acquire: Lazy<IO<R, E, A>>, use: (a: A) => IO<R1, E1, A1>, release: (a: A, e: Exit<E1, A1>) => IO<R2, E2, any>): IO<R & R1 & R2, E | E1 | E2, A1>;
+export declare function bracketExit_<R, E, A, E1, R1, A1, R2, E2>(acquire: Lazy<IO<R, E, A>>, use: (a: A) => IO<R1, E1, A1>, release: (a: A, e: Exit<E1, A1>) => IO<R2, E2, any>, __tsplusTrace?: string): IO<R | R1 | R2, E | E1 | E2, A1>;

package/IO/api/clockWith.d.ts

@@ -9,4 +9,4 @@ export declare function clockWith<R, E, A>(f: (clock: Clock) => IO<R, E, A>, __t
  * @tsplus static fncts.io.IOOps clock
  * @tsplus location "@fncts/io/IO/api/clockWith"
  */
-export declare const clock: import("../definition").IO<unknown, never, import("../../Clock").Clock>;
+export declare const clock: import("../definition").IO<never, never, import("../../Clock").Clock>;

package/IO/api/concurrency.d.ts

@@ -1,5 +1,5 @@
 import { FiberRef } from "@fncts/io/FiberRef/definition";
-import { Maybe } from "@fncts/base/data/Maybe";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { UIO, IO } from "@fncts/io/IO/definition";
 /**
  * The number of fibers used for concurrent operators.
@@ -18,18 +18,18 @@ export declare const concurrency: UIO<Maybe<number>>;
  * @tsplus static fncts.io.IOOps concurrencyWith
  * @tsplus location "@fncts/io/IO/api/concurrency"
  */
-export declare function concurrencyWith<R, E, A>(f: (concurrency: Maybe<number>) => IO<R, E, A>): IO<R, E, A>;
+export declare function concurrencyWith<R, E, A>(f: (concurrency: Maybe<number>) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * Runs the specified effect with the specified maximum number of fibers for
  * concurrent operators.
  * @tsplus fluent fncts.io.IO withConcurrency
  * @tsplus location "@fncts/io/IO/api/concurrency"
  */
-export declare function withConcurrency_<R, E, A>(ma: IO<R, E, A>, n: number): IO<R, E, A>;
+export declare function withConcurrency_<R, E, A>(ma: IO<R, E, A>, n: number, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * Runs the specified effect with an unbounded maximum number of fibers for
  * concurrent operators.
  * @tsplus getter fncts.io.IO withConcurrencyUnbounded
  * @tsplus location "@fncts/io/IO/api/concurrency"
  */
-export declare function withConcurrencyUnbounded<R, E, A>(ma: IO<R, E, A>): IO<R, E, A>;
+export declare function withConcurrencyUnbounded<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;

package/IO/api/concurrentFinalizers.d.ts

@@ -1,8 +1,7 @@
 import { IO } from "@fncts/io/IO/definition";
-import { Has } from "@fncts/base/typeclass/Has";
 import { Scope } from "@fncts/io/Scope/definition";
 /**
  * @tsplus getter fncts.io.IO concurrentFinalizers
  * @tsplus location "@fncts/io/IO/api/concurrentFinalizers"
  */
-export declare function concurrentFinalizers<R, E, A>(io: IO<R, E, A>): IO<R & Has<Scope>, E, A>;
+export declare function concurrentFinalizers<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R | Scope, E, A>;

package/IO/api/consoleWith.d.ts

@@ -4,9 +4,9 @@ import { Console } from "@fncts/io/Console";
  * @tsplus static fncts.io.IOOps consoleWith
  * @tsplus location "@fncts/io/IO/api/consoleWith"
  */
-export declare function consoleWith<R, E, A>(f: (console: Console) => IO<R, E, A>): IO<R, E, A>;
+export declare function consoleWith<R, E, A>(f: (console: Console) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * @tsplus static fncts.io.IOOps console
  * @tsplus location "@fncts/io/IO/api/consoleWith"
  */
-export declare const console: import("../definition").IO<unknown, never, Console>;
+export declare const console: import("../definition").IO<never, never, Console>;

package/IO/api/core-scope.d.ts

@@ -1,7 +1,7 @@
 import { UIO, URIO } from "@fncts/io/IO/definition";
-import { Just } from "@fncts/base/data/Maybe";
-import { Lazy } from "@fncts/base/data/function";
-import { Exit } from "@fncts/base/data/Exit";
+import { Just } from "@fncts/base/data/Maybe/definition";
+import { Lazy } from "@fncts/base/data/function/definition";
+import { Exit } from "@fncts/base/data/Exit/definition";
 import { Fiber } from "@fncts/io/Fiber/definition";
 import { FiberScope } from "../../FiberScope.js";
 import { GetForkScope, IO } from "../definition.js";
@@ -41,7 +41,7 @@ export declare function forkScopeMask_<R, E, A>(newScope: FiberScope, f: (restor
  * @tsplus fluent fncts.io.IO raceWith
  * @tsplus location "@fncts/io/IO/api/core-scope"
  */
-export declare function raceWith_<R, E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3>(left: IO<R, E, A>, right: Lazy<IO<R1, E1, A1>>, leftWins: (exit: Exit<E, A>, fiber: Fiber<E1, A1>) => IO<R2, E2, A2>, rightWins: (exit: Exit<E1, A1>, fiber: Fiber<E, A>) => IO<R3, E3, A3>, __tsplusTrace?: string): IO<R & R1 & R2 & R3, E2 | E3, A2 | A3>;
+export declare function raceWith_<R, E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3>(left: IO<R, E, A>, right: Lazy<IO<R1, E1, A1>>, leftWins: (exit: Exit<E, A>, fiber: Fiber<E1, A1>) => IO<R2, E2, A2>, rightWins: (exit: Exit<E1, A1>, fiber: Fiber<E, A>) => IO<R3, E3, A3>, __tsplusTrace?: string): IO<R | R1 | R2 | R3, E2 | E3, A2 | A3>;
 export declare type Grafter = <R, E, A>(effect: IO<R, E, A>) => IO<R, E, A>;
 /**
  * Transplants specified effects so that when those effects fork other

package/IO/api/ensuringChildren.d.ts

@@ -5,4 +5,4 @@ import { Fiber } from "@fncts/io/Fiber/definition";
  * @tsplus fluent fncts.io.IO ensuringChildren
  * @tsplus location "@fncts/io/IO/api/ensuringChildren"
  */
-export declare function ensuringChildren<R, E, A, R1>(self: IO<R, E, A>, children: (_: Conc<Fiber.Runtime<any, any>>) => IO<R1, never, void>): IO<R & R1, E, A>;
+export declare function ensuringChildren<R, E, A, R1>(self: IO<R, E, A>, children: (_: Conc<Fiber.Runtime<any, any>>) => IO<R1, never, void>, __tsplusTrace?: string): IO<R | R1, E, A>;

package/IO/api/environment.d.ts

@@ -1,8 +1,6 @@
 import { IO, URIO, FIO } from "@fncts/io/IO/definition";
-import { Environment } from "@fncts/base/data/Environment";
-import { Has } from "@fncts/base/typeclass/Has";
-import { Tag } from "@fncts/base/data/Tag";
-import type * as Intersection from "@fncts/typelevel/Intersection";
+import { Environment } from "@fncts/base/data/Environment/definition";
+import { Tag } from "@fncts/base/data/Tag/definition";
 /**
  * Provides some of the environment required to run this `IO`,
  * leaving the remainder `R0`.
@@ -27,7 +25,7 @@ export declare function environmentWith<R, A>(f: (_: Environment<R>) => A, __tsp
  * @tsplus static fncts.io.IOOps environmentWithIO
  * @tsplus location "@fncts/io/IO/api/environment"
  */
-export declare function environmentWithIO<R0, R, E, A>(f: (r: Environment<R0>) => IO<R, E, A>, __tsplusTrace?: string): IO<R & R0, E, A>;
+export declare function environmentWithIO<R0, R, E, A>(f: (r: Environment<R0>) => IO<R, E, A>, __tsplusTrace?: string): IO<R | R0, E, A>;
 /**
  * Provides all of the environment required to compute a MonadEnv
  *
@@ -41,34 +39,34 @@ export declare function provideEnvironment_<R, E, A>(self: IO<R, E, A>, r: Envir
  * @tsplus fluent fncts.io.IO provideSomeEnvironment
  * @tsplus location "@fncts/io/IO/api/environment"
  */
-export declare function provideSomeEnvironment_<R, E, A, R0>(self: IO<R, E, A>, environment: Environment<R0>, __tsplusTrace?: string): IO<Intersection.Erase<R, R0>, E, A>;
+export declare function provideSomeEnvironment_<R, E, A, R0>(self: IO<R, E, A>, environment: Environment<R0>, __tsplusTrace?: string): IO<Exclude<R, R0>, E, A>;
 /**
  * @tsplus fluent fncts.io.IO provideService
  * @tsplus location "@fncts/io/IO/api/environment"
  */
-export declare function provideService_<E, A, T>(self: IO<Has<T>, E, A>, service: T, tag: Tag<T>, __tsplusTrace?: string): FIO<E, A>;
+export declare function provideService_<E, A, T>(self: IO<T, E, A>, service: T, tag: Tag<T>, __tsplusTrace?: string): FIO<E, A>;
 /**
  * @tsplus fluent fncts.io.IO provideSomeService
  * @tsplus location "@fncts/io/IO/api/environment"
  */
-export declare function provideSomeService_<R, E, A, T>(self: IO<R, E, A>, service: T, tag: Tag<T>, __tsplusTrace?: string): IO<Intersection.Erase<R, Has<T>>, E, A>;
+export declare function provideSomeService_<R, E, A, T>(self: IO<R, E, A>, service: T, tag: Tag<T>, __tsplusTrace?: string): IO<Exclude<R, T>, E, A>;
 /**
  * @tsplus static fncts.io.IOAspects provideSomeService
  * @tsplus location "@fncts/io/IO/api/environment"
  */
-export declare function provideSomeService<T>(service: T, tag: Tag<T>, __tsplusTrace?: string): <R, E, A>(io: import("../definition").IO<R & import("@fncts/base/typeclass").Has<T>, E, A>) => import("../definition").IO<R, E, A>;
+export declare function provideSomeService<T>(service: T, tag: Tag<T>, __tsplusTrace?: string): <R, E, A>(io: import("../definition").IO<T | R, E, A>) => import("../definition").IO<R, E, A>;
 /**
  * @tsplus static fncts.io.IOOps service
  * @tsplus location "@fncts/io/IO/api/environment"
  */
-export declare function service<T>(tag: Tag<T>, __tsplusTrace?: string): IO<Has<T>, never, T>;
+export declare function service<T>(tag: Tag<T>, __tsplusTrace?: string): IO<T, never, T>;
 /**
  * @tsplus static fncts.io.IOOps serviceWith
  * @tsplus location "@fncts/io/IO/api/environment"
  */
-export declare function serviceWith<S, A>(f: (service: S) => A, tag: Tag<S>): IO<Has<S>, never, A>;
+export declare function serviceWith<S, A>(f: (service: S) => A, tag: Tag<S>, __tsplusTrace?: string): IO<S, never, A>;
 /**
  * @tsplus static fncts.io.IOOps serviceWithIO
  * @tsplus location "@fncts/io/IO/api/environment"
  */
-export declare function serviceWithIO<T, R, E, A>(f: (service: T) => IO<R, E, A>, tag: Tag<T>, __tsplusTrace?: string): IO<R & Has<T>, E, A>;
+export declare function serviceWithIO<T, R, E, A>(f: (service: T) => IO<R, E, A>, tag: Tag<T>, __tsplusTrace?: string): IO<R | T, E, A>;

package/IO/api/foreachC.d.ts

@@ -16,7 +16,7 @@ import { Queue } from "@fncts/io/Queue/definition";
  * @tsplus fluent fncts.Iterable traverseIODiscardC
  * @tsplus location "@fncts/io/IO/api/foreachC"
  */
-export declare function foreachDiscardC_<R, E, A>(as: Iterable<A>, f: (a: A) => IO<R, E, any>): IO<R, E, void>;
+export declare function foreachDiscardC_<R, E, A>(as: Iterable<A>, f: (a: A) => IO<R, E, any>, __tsplusTrace?: string): IO<R, E, void>;
 /**
  * Applies the function `f` to each element of the `Iterable<A>` in parallel,
  * and returns the results in a `Conc<B>`.
@@ -26,4 +26,4 @@ export declare function foreachDiscardC_<R, E, A>(as: Iterable<A>, f: (a: A) =>
  * @tsplus fluent fncts.Iterable traverseIOC
  * @tsplus location "@fncts/io/IO/api/foreachC"
  */
-export declare function foreachC_<R, E, A, B>(as: Iterable<A>, f: (a: A) => IO<R, E, B>): IO<R, E, Conc<B>>;
+export declare function foreachC_<R, E, A, B>(as: Iterable<A>, f: (a: A) => IO<R, E, B>, __tsplusTrace?: string): IO<R, E, Conc<B>>;

package/IO/api/foreachExec.d.ts

@@ -9,4 +9,4 @@ import { Conc } from "@fncts/base/collection/immutable/Conc";
  * @tsplus static fncts.io.IOOps foreachExec
  * @tsplus location "@fncts/io/IO/api/foreachExec"
  */
-export declare function foreachExec_<R, E, A, B>(as: Iterable<A>, es: ExecutionStrategy, f: (a: A) => IO<R, E, B>): IO<R, E, Conc<B>>;
+export declare function foreachExec_<R, E, A, B>(as: Iterable<A>, es: ExecutionStrategy, f: (a: A) => IO<R, E, B>, __tsplusTrace?: string): IO<R, E, Conc<B>>;

package/IO/api/forkScoped.d.ts

@@ -1,9 +1,8 @@
 import { IO } from "@fncts/io/IO/definition";
-import { Has } from "@fncts/base/typeclass/Has";
 import { Scope } from "@fncts/io/Scope/definition";
 import { Fiber } from "@fncts/io/Fiber/definition";
 /**
  * @tsplus getter fncts.io.IO forkScoped
  * @tsplus location "@fncts/io/IO/api/forkScoped"
  */
-export declare function forkScoped<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R & Has<Scope>, never, Fiber.Runtime<E, A>>;
+export declare function forkScoped<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R | Scope, never, Fiber.Runtime<E, A>>;

package/IO/api/fulfill.d.ts

@@ -7,4 +7,4 @@ import { Future } from "@fncts/io/Future";
  * @tsplus fluent fncts.io.IO fulfill
  * @tsplus location "@fncts/io/IO/api/fulfill"
  */
-export declare function fulfill_<R, E, A>(effect: IO<R, E, A>, p: Future<E, A>): IO<R, never, boolean>;
+export declare function fulfill_<R, E, A>(effect: IO<R, E, A>, p: Future<E, A>, __tsplusTrace?: string): IO<R, never, boolean>;

package/IO/api/interrupt.d.ts

@@ -1,8 +1,8 @@
-import { FiberId } from "@fncts/base/data/FiberId";
+import { FiberId } from "@fncts/base/data/FiberId/definition";
 import { FIO, IO } from "@fncts/io/IO/definition";
 import { InterruptStatus } from "@fncts/io/InterruptStatus";
-import { HashSet } from "@fncts/base/collection/immutable/HashSet";
-import { Lazy } from "@fncts/base/data/function";
+import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
+import { Lazy } from "@fncts/base/data/function/definition";
 /**
  * Returns an effect that is interrupted as if by the specified fiber.
  * @tsplus static fncts.io.IOOps interruptAs
@@ -15,7 +15,7 @@ export declare function interruptAs(fiberId: FiberId, __tsplusTrace?: string): F
  * @tsplus static fncts.io.IOOps interrupt
  * @tsplus location "@fncts/io/IO/api/interrupt"
  */
-export declare const interrupt: IO<unknown, never, never>;
+export declare const interrupt: IO<never, never, never>;
 /**
  * Switches the interrupt status for this effect. If `true` is used, then the
  * effect becomes interruptible (the default), while if `false` is used, then
@@ -59,7 +59,7 @@ export declare function uninterruptible<R, E, A>(self: IO<R, E, A>, __tsplusTrac
  * @tsplus static fncts.io.IOOps uninterruptibleMask
  * @tsplus location "@fncts/io/IO/api/interrupt"
  */
-export declare function uninterruptibleMask<R, E, A>(f: (restore: InterruptStatusRestore) => IO<R, E, A>): IO<R, E, A>;
+export declare function uninterruptibleMask<R, E, A>(f: (restore: InterruptStatusRestore) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * Makes the effect interruptible, but passes it a restore function that can
  * be used to restore the inherited interruptibility from whatever region the
@@ -67,21 +67,21 @@ export declare function uninterruptibleMask<R, E, A>(f: (restore: InterruptStatu
  * @tsplus static fncts.io.IOOps interruptibleMask
  * @tsplus location "@fncts/io/IO/api/interrupt"
  */
-export declare function interruptibleMask<R, E, A>(k: (restore: InterruptStatusRestore) => IO<R, E, A>): IO<R, E, A>;
+export declare function interruptibleMask<R, E, A>(k: (restore: InterruptStatusRestore) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * Calls the specified function, and runs the effect it returns, if this
  * effect is interrupted.
  * @tsplus fluent fncts.io.IO onInterrupt
  * @tsplus location "@fncts/io/IO/api/interrupt"
  */
-export declare function onInterrupt_<R, E, A, R1>(ma: IO<R, E, A>, cleanup: (interruptors: HashSet<FiberId>) => IO<R1, never, any>): IO<R & R1, E, A>;
+export declare function onInterrupt_<R, E, A, R1>(ma: IO<R, E, A>, cleanup: (interruptors: HashSet<FiberId>) => IO<R1, never, any>, __tsplusTrace?: string): IO<R | R1, E, A>;
 /**
  * Calls the specified function, and runs the effect it returns, if this
  * effect is interrupted (allows for expanding error).
  * @tsplus fluent fncts.io.IO onInterruptExtended
  * @tsplus location "@fncts/io/IO/api/interrupt"
  */
-export declare function onInterruptExtended_<R, E, A, R2, E2>(self: IO<R, E, A>, cleanup: Lazy<IO<R2, E2, any>>): IO<R & R2, E | E2, A>;
+export declare function onInterruptExtended_<R, E, A, R2, E2>(self: IO<R, E, A>, cleanup: Lazy<IO<R2, E2, any>>, __tsplusTrace?: string): IO<R | R2, E | E2, A>;
 /**
  * Returns an IO whose interruption will be disconnected from the
  * fiber's own interruption, being performed in the background without

package/IO/api/onExit.d.ts

@@ -1,7 +1,7 @@
 import { IO } from "@fncts/io/IO/definition";
-import { Exit } from "@fncts/base/data/Exit";
+import { Exit } from "@fncts/base/data/Exit/definition";
 /**
  * @tsplus fluent fncts.io.IO onExit
  * @tsplus location "@fncts/io/IO/api/onExit"
  */
-export declare function onExit_<R, E, A, R1, E1>(self: IO<R, E, A>, cleanup: (exit: Exit<E, A>) => IO<R1, E1, any>): IO<R & R1, E | E1, A>;
+export declare function onExit_<R, E, A, R1, E1>(self: IO<R, E, A>, cleanup: (exit: Exit<E, A>) => IO<R1, E1, any>, __tsplusTrace?: string): IO<R | R1, E | E1, A>;

package/IO/api/onTermination.d.ts

@@ -1,9 +1,9 @@
-import { Lazy } from "@fncts/base/data/function";
+import { Lazy } from "@fncts/base/data/function/definition";
 import { IO, URIO } from "@fncts/io/IO/definition";
-import { Cause } from "@fncts/base/data/Cause";
-import { Exit } from "@fncts/base/data/Exit";
+import { Cause } from "@fncts/base/data/Cause/definition";
+import { Exit } from "@fncts/base/data/Exit/definition";
 /**
  * @tsplus fluent fncts.io.IO onTermination
  * @tsplus location "@fncts/io/IO/api/onTermination"
  */
-export declare function onTermination<R, E, A, R1>(self: Lazy<IO<R, E, A>>, cleanup: (cause: Cause<never>) => URIO<R1, any>, __tsPlusTrace?: string): IO<R & R1, E, A>;
+export declare function onTermination<R, E, A, R1>(self: Lazy<IO<R, E, A>>, cleanup: (cause: Cause<never>) => URIO<R1, any>, __tsplusTrace?: string): IO<R | R1, E, A>;

package/IO/api/provideLayer.d.ts

@@ -4,4 +4,4 @@ import { Layer } from "@fncts/io/Layer";
  * @tsplus fluent fncts.io.IO provideLayer
  * @tsplus location "@fncts/io/IO/api/provideLayer"
  */
-export declare function provideLayer_<RIn, E, ROut, E1, A>(self: IO<ROut, E1, A>, layer: Layer<RIn, E, ROut>): IO<RIn, E | E1, A>;
+export declare function provideLayer_<RIn, E, ROut, E1, A>(self: IO<ROut, E1, A>, layer: Layer<RIn, E, ROut>, __tsplusTrace?: string): IO<RIn, E | E1, A>;

package/IO/api/provideSomeLayer.d.ts

@@ -10,4 +10,4 @@ export declare function provideSomeLayer_<R, E, A, RIn, E1, ROut>(self: IO<R, E,
  * @tsplus static fncts.io.IOAspects provideSomeLayer
  * @tsplus location "@fncts/io/IO/api/provideSomeLayer"
  */
-export declare function provideSomeLayer<RIn, E1, ROut>(layer: Layer<RIn, E1, ROut>, __tsplusTrace?: string): <R, E, A>(self: import("../definition").IO<R & ROut, E, A>) => import("../definition").IO<R & RIn, E1 | E, A>;
+export declare function provideSomeLayer<RIn, E1, ROut>(layer: Layer<RIn, E1, ROut>, __tsplusTrace?: string): <R, E, A>(self: import("../definition").IO<ROut | R, E, A>) => import("../definition").IO<RIn | R, E1 | E, A>;

package/IO/api/race.d.ts

@@ -10,4 +10,4 @@ import { IO } from "@fncts/io/IO/definition";
  * @tsplus fluent fncts.io.IO race
  * @tsplus location "@fncts/io/IO/api/race"
  */
-export declare function race_<R, E, A, R1, E1, A1>(io: IO<R, E, A>, that: IO<R1, E1, A1>): IO<R & R1, E | E1, A | A1>;
+export declare function race_<R, E, A, R1, E1, A1>(io: IO<R, E, A>, that: IO<R1, E1, A1>, __tsplusTrace?: string): IO<R | R1, E | E1, A | A1>;

package/IO/api/raceFirst.d.ts

@@ -13,4 +13,4 @@ import { IO } from "@fncts/io/IO/definition";
  * @tsplus fluent fncts.io.IO raceFirst
  * @tsplus location "@fncts/io/IO/api/raceFirst"
  */
-export declare function raceFirst_<R, E, A, R1, E1, A1>(ma: IO<R, E, A>, that: IO<R1, E1, A1>): IO<R & R1, E | E1, A | A1>;
+export declare function raceFirst_<R, E, A, R1, E1, A1>(ma: IO<R, E, A>, that: IO<R1, E1, A1>, __tsplusTrace?: string): IO<R | R1, E | E1, A | A1>;

package/IO/api/randomWith.d.ts

@@ -4,9 +4,9 @@ import { IO } from "@fncts/io/IO/definition";
  * @tsplus static fncts.io.IOOps randomWith
  * @tsplus location "@fncts/io/IO/api/randomWith"
  */
-export declare function randomWith<R, E, A>(f: (random: Random) => IO<R, E, A>): IO<R, E, A>;
+export declare function randomWith<R, E, A>(f: (random: Random) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * @tsplus static fncts.io.IOOps random
  * @tsplus location "@fncts/io/IO/api/randomWith"
  */
-export declare const random: import("../definition").IO<unknown, never, import("../../Random").Random>;
+export declare const random: import("../definition").IO<never, never, import("../../Random").Random>;

package/IO/api/repeat.d.ts

@@ -1,20 +1,20 @@
 import { IO } from "@fncts/io/IO/definition";
-import { Lazy } from "@fncts/base/data/function";
+import { Lazy } from "@fncts/base/data/function/definition";
 import { Schedule } from "@fncts/io/Schedule/definition";
-import { Maybe } from "@fncts/base/data/Maybe";
-import { Either } from "@fncts/base/data/Either";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Either } from "@fncts/base/data/Either/definition";
 /**
  * @tsplus getter fncts.io.IO repeat
  * @tsplus location "@fncts/io/IO/api/repeat"
  */
-export declare function repeat_<R, E, A>(self: IO<R, E, A>): <R1, B>(schedule0: import("@fncts/base/data/function").Lazy<import("../../Schedule").Schedule<R1, A, B>>, __tsplusTrace?: string) => import("../definition").IO<R & R1, E, B>;
+export declare function repeat_<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): <R1, B>(schedule0: import("@fncts/base/data/function").Lazy<import("../../Schedule").Schedule<R1, A, B>>, __tsplusTrace?: string) => import("../definition").IO<R | R1, E, B>;
 /**
  * @tsplus getter fncts.io.IO repeatOrElse
  * @tsplus location "@fncts/io/IO/api/repeat"
  */
-export declare function repeatOrElse_<R, E, A>(self: IO<R, E, A>): <R1, B, R2, E2>(schedule0: import("@fncts/base/data/function").Lazy<import("../../Schedule").Schedule<R1, A, B>>, orElse: (e: E, out: import("@fncts/base/data/Maybe").Maybe<B>) => import("../definition").IO<R2, E2, B>, __tsplusTrace?: string) => import("../definition").IO<R & R1 & R2, E2, B>;
+export declare function repeatOrElse_<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): <R1, B, R2, E2>(schedule0: import("@fncts/base/data/function").Lazy<import("../../Schedule").Schedule<R1, A, B>>, orElse: (e: E, out: import("@fncts/base/data/Maybe").Maybe<B>) => import("../definition").IO<R2, E2, B>, __tsplusTrace?: string) => import("../definition").IO<R | R1 | R2, E2, B>;
 /**
  * @tsplus getter fncts.io.IO repeatOrElseEither
  * @tsplus location "@fncts/io/IO/api/repeat"
  */
-export declare function repeatOrElseEither_<R, E, A>(self: IO<R, E, A>): <R1, B, R2, E2, C>(schedule0: import("@fncts/base/data/function").Lazy<import("../../Schedule").Schedule<R1, A, B>>, orElse: (e: E, out: import("@fncts/base/data/Maybe").Maybe<B>) => import("../definition").IO<R2, E2, C>, __tsplusTrace?: string) => import("../definition").IO<R & R1 & R2, E2, import("@fncts/base/data/Either").Either<C, B>>;
+export declare function repeatOrElseEither_<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): <R1, B, R2, E2, C>(schedule0: import("@fncts/base/data/function").Lazy<import("../../Schedule").Schedule<R1, A, B>>, orElse: (e: E, out: import("@fncts/base/data/Maybe").Maybe<B>) => import("../definition").IO<R2, E2, C>, __tsplusTrace?: string) => import("../definition").IO<R | R1 | R2, E2, import("@fncts/base/data/Either").Either<C, B>>;

package/IO/api/retry.d.ts

@@ -1,19 +1,19 @@
 import { IO } from "@fncts/io/IO/definition";
-import { Lazy } from "@fncts/base/data/function";
+import { Lazy } from "@fncts/base/data/function/definition";
 import { Schedule } from "@fncts/io/Schedule/definition";
-import { Either } from "@fncts/base/data/Either";
+import { Either } from "@fncts/base/data/Either/definition";
 /**
  * @tsplus getter fncts.io.IO retry
  * @tsplus location "@fncts/io/IO/api/retry"
  */
-export declare function retry<R, E, A>(self: IO<R, E, A>): <R1, O>(schedule0: import("@fncts/base/data/function").Lazy<import("../../Schedule").Schedule<R1, E, O>>, __tsplusTrace?: string) => import("../definition").IO<R & R1, E, A>;
+export declare function retry<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): <R1, O>(schedule0: import("@fncts/base/data/function").Lazy<import("../../Schedule").Schedule<R1, E, O>>, __tsplusTrace?: string) => import("../definition").IO<R | R1, E, A>;
 /**
  * @tsplus getter fncts.io.IO retryOrElse
  * @tsplus location "@fncts/io/IO/api/retry"
  */
-export declare function retryOrElse<R, E, A>(self: IO<R, E, A>): <R1, O, R2, E2>(schedule0: import("@fncts/base/data/function").Lazy<import("../../Schedule").Schedule<R1, E, O>>, orElse: (e: E, out: O) => import("../definition").IO<R2, E2, A>, __tsplusTrace?: string) => import("../definition").IO<R & R1 & R2, E2, A>;
+export declare function retryOrElse<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): <R1, O, R2, E2>(schedule0: import("@fncts/base/data/function").Lazy<import("../../Schedule").Schedule<R1, E, O>>, orElse: (e: E, out: O) => import("../definition").IO<R2, E2, A>, __tsplusTrace?: string) => import("../definition").IO<R | R1 | R2, E2, A>;
 /**
  * @tsplus getter fncts.io.IO retryOrElseEither
  * @tsplus location "@fncts/io/IO/api/retry"
  */
-export declare function retryOrElseEither_<R, E, A>(self: IO<R, E, A>): <R1, O, R2, E2, B>(schedule0: import("@fncts/base/data/function").Lazy<import("../../Schedule").Schedule<R1, E, O>>, orElse: (e: E, out: O) => import("../definition").IO<R2, E2, B>, __tsplusTrace?: string) => import("../definition").IO<R & R1 & R2, E2, import("@fncts/base/data/Either").Either<B, A>>;
+export declare function retryOrElseEither_<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): <R1, O, R2, E2, B>(schedule0: import("@fncts/base/data/function").Lazy<import("../../Schedule").Schedule<R1, E, O>>, orElse: (e: E, out: O) => import("../definition").IO<R2, E2, B>, __tsplusTrace?: string) => import("../definition").IO<R | R1 | R2, E2, import("@fncts/base/data/Either").Either<B, A>>;

package/IO/api/schedule.d.ts

@@ -1,13 +1,13 @@
 import { IO } from "@fncts/io/IO/definition";
-import { Lazy } from "@fncts/base/data/function";
+import { Lazy } from "@fncts/base/data/function/definition";
 import { Schedule } from "@fncts/io/Schedule/definition";
 /**
  * @tsplus fluent fncts.io.IO scheduleFrom
  * @tsplus location "@fncts/io/IO/api/schedule"
  */
-export declare function scheduleFrom<R, E, A extends A1, R1, A1, B>(self: IO<R, E, A>, a: Lazy<A>, schedule0: Lazy<Schedule<R1, A1, B>>): IO<R & R1, E, B>;
+export declare function scheduleFrom<R, E, A extends A1, R1, A1, B>(self: IO<R, E, A>, a: Lazy<A>, schedule0: Lazy<Schedule<R1, A1, B>>, __tsplusTrace?: string): IO<R | R1, E, B>;
 /**
  * @tsplus fluent fncts.io.IO schedule
  * @tsplus location "@fncts/io/IO/api/schedule"
  */
-export declare function schedule<R, E, A, R1, B>(io: IO<R, E, A>, schedule: Lazy<Schedule<R1, any, B>>, __tsplusTrace?: string): IO<R & R1, E, B>;
+export declare function schedule<R, E, A, R1, B>(io: IO<R, E, A>, schedule: Lazy<Schedule<R1, any, B>>, __tsplusTrace?: string): IO<R | R1, E, B>;

package/IO/api/scope.d.ts

@@ -1,8 +1,7 @@
 import { IO } from "@fncts/io/IO/definition";
-import { Has } from "@fncts/base/typeclass/Has";
 import { Scope } from "@fncts/io/Scope/definition";
 /**
  * @tsplus static fncts.io.IOOps scope
  * @tsplus location "@fncts/io/IO/api/scope"
  */
-export declare const scope: IO<Has<Scope>, never, Scope>;
+export declare const scope: IO<Scope, never, Scope>;