@fncts/io 0.0.10 → 0.0.13

package/Channel/definition.d.ts

@@ -28,13 +28,13 @@ export declare const enum ChannelTag {
  * @tsplus companion fncts.io.ChannelOps
  */
 export declare abstract class Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> {
-    readonly _Env: (_: Env) => void;
-    readonly _InErr: (_: InErr) => void;
-    readonly _InElem: (_: InElem) => void;
-    readonly _InDone: (_: InDone) => void;
-    readonly _OutErr: () => OutErr;
-    readonly _OutElem: () => OutElem;
-    readonly _OutDone: () => OutDone;
+    _Env: () => Env;
+    _InErr: (_: InErr) => void;
+    _InElem: (_: InElem) => void;
+    _InDone: (_: InDone) => void;
+    _OutErr: () => OutErr;
+    _OutElem: () => OutElem;
+    _OutDone: () => OutDone;
 }
 /**
  * @tsplus unify fncts.io.Channel
@@ -55,7 +55,7 @@ export declare function unifyChannel<X extends Channel<any, any, any, any, any,
     X
 ] extends [Channel<any, any, any, any, any, any, infer OutDone>] ? OutDone : never>;
 export declare abstract class Continuation<Env, InErr, InElem, InDone, OutErr, OutErr2, OutElem, OutDone, OutDone2> {
-    readonly _Env: (_: Env) => void;
+    readonly _Env: () => Env;
     readonly _InErr: (_: InErr) => void;
     readonly _InElem: (_: InElem) => void;
     readonly _InDone: (_: InDone) => void;
@@ -99,12 +99,12 @@ export declare class Read<Env, InErr, InElem, InDone, OutErr, OutErr2, OutElem,
     readonly _tag = ChannelTag.Read;
     constructor(more: (_: InElem) => Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone2>, done: ContinuationK<Env, InErr, InElem, InDone, OutErr, OutErr2, OutElem, OutDone, OutDone2>);
 }
-export declare class Done<OutDone> extends Channel<unknown, unknown, unknown, unknown, never, never, OutDone> {
+export declare class Done<OutDone> extends Channel<never, unknown, unknown, unknown, never, never, OutDone> {
     readonly terminal: () => OutDone;
     readonly _tag = ChannelTag.Done;
     constructor(terminal: () => OutDone);
 }
-export declare class Fail<OutErr> extends Channel<unknown, unknown, unknown, unknown, OutErr, never, never> {
+export declare class Fail<OutErr> extends Channel<never, unknown, unknown, unknown, OutErr, never, never> {
     readonly cause: () => Cause<OutErr>;
     readonly _tag = ChannelTag.Halt;
     constructor(cause: () => Cause<OutErr>);
@@ -141,13 +141,13 @@ export declare class BracketOut<R, E, Z, OutDone> extends Channel<R, unknown, un
     readonly _tag = ChannelTag.BracketOut;
     constructor(acquire: IO<R, E, Z>, finalizer: (_: Z, exit: Exit<any, any>) => URIO<R, any>);
 }
-export declare class Provide<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> extends Channel<unknown, InErr, InElem, InDone, OutErr, OutElem, OutDone> {
+export declare class Provide<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> extends Channel<never, InErr, InElem, InDone, OutErr, OutElem, OutDone> {
     readonly environment: Environment<Env>;
     readonly inner: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>;
     readonly _tag = ChannelTag.Provide;
     constructor(environment: Environment<Env>, inner: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>);
 }
-export declare class Emit<OutElem, OutDone> extends Channel<unknown, unknown, unknown, unknown, never, OutElem, OutDone> {
+export declare class Emit<OutElem, OutDone> extends Channel<never, unknown, unknown, unknown, never, OutElem, OutDone> {
     readonly out: () => OutElem;
     readonly _tag = ChannelTag.Emit;
     constructor(out: () => OutElem);

package/Channel/internal/MergeDecision.d.ts

@@ -12,7 +12,7 @@ export declare type MergeDecisionTypeId = typeof MergeDecisionTypeId;
  */
 export declare abstract class MergeDecision<R, E0, Z0, E, Z> {
     readonly _typeId: MergeDecisionTypeId;
-    readonly _R: (_: R) => void;
+    readonly _R: () => R;
     readonly _E0: (_: E0) => void;
     readonly _Z0: (_: Z0) => void;
     readonly _E: () => E;

package/Channel/internal/SingleProducerAsyncInput.d.ts

@@ -61,7 +61,7 @@ export declare class SingleProducerAsyncInput<Err, Elem, Done> implements AsyncI
     error(cause: Cause<Err>): UIO<unknown>;
     takeWith<X>(onError: (cause: Cause<Err>) => X, onElement: (element: Elem) => X, onDone: (done: Done) => X): UIO<X>;
     take: import("../../IO").UIO<import("@fncts/base/data/Exit").Exit<import("@fncts/base/data/Either").Either<Err, Done>, Elem>>;
-    close: import("../../IO").IO<unknown, never, unknown>;
+    close: import("../../IO").IO<never, never, unknown>;
     awaitRead: UIO<void>;
 }
 /**

package/Clock/api.d.ts

@@ -5,7 +5,7 @@ import { UIO } from "@fncts/io/IO/definition";
  * @tsplus static fncts.io.ClockOps currentTime
  * @tsplus location "@fncts/io/Clock/api"
  */
-export declare const currentTime: import("../IO").IO<unknown, never, number>;
+export declare const currentTime: import("../IO").IO<never, never, number>;
 /**
  * @tsplus static fncts.io.ClockOps sleep
  * @tsplus location "@fncts/io/Clock/api"

package/Fiber/FiberContext.d.ts

@@ -50,11 +50,11 @@ export declare class TracedCont {
     constructor(apply: ErasedCont, trace?: string | undefined);
 }
 export declare class Finalizer {
-    readonly finalizer: UIO<any>;
+    readonly finalizer: IO<any, never, any>;
     readonly apply: ErasedCont;
     readonly trace?: string | undefined;
     readonly _tag = "Finalizer";
-    constructor(finalizer: UIO<any>, apply: ErasedCont, trace?: string | undefined);
+    constructor(finalizer: IO<any, never, any>, apply: ErasedCont, trace?: string | undefined);
 }
 export declare type Frame = InterruptExit | Match<any, any, any, any, any, any, any, any, any> | HandlerFrame | TracedCont | Finalizer;
 export declare const currentFiber: AtomicReference<FiberContext<any, any> | null>;
@@ -107,7 +107,7 @@ export declare class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable
     private unsafeGetRefs;
     private unsafeSetRef;
     private unsafeDeleteRef;
-    private unsafePoll;
+    unsafePoll(): import("@fncts/base/data/Maybe").Maybe<import("@fncts/base/data/Exit").Success<A> | import("@fncts/base/data/Exit").Failure<E>>;
     private interruptExit;
     private unsafeAddFinalizer;
     private get unsafeIsInterruptible();

package/Fiber/api/awaitAll.d.ts

@@ -7,4 +7,4 @@ import { Conc } from "@fncts/base/collection/immutable/Conc";
  * @tsplus static fncts.io.FiberOps awaitAll
  * @tsplus location "@fncts/io/Fiber/api/awaitAll"
  */
-export declare function awaitAll<E, A>(as: Iterable<Fiber<E, A>>): IO<unknown, never, Exit<E, Conc<A>>>;
+export declare function awaitAll<E, A>(as: Iterable<Fiber<E, A>>): IO<never, never, Exit<E, Conc<A>>>;

package/Fiber/api/evalOnIO.d.ts

@@ -6,4 +6,4 @@ import { IO } from "@fncts/io/IO/definition";
  * @tsplus fluent fncts.io.Fiber evalOnIO
  * @tsplus location "@fncts/io/Fiber/api/evalOnIO"
  */
-export declare function evalOnIO_<E, A, R1, E1, B, R2, E2, C>(fiber: Fiber<E, A>, effect: IO<R1, E1, B>, orElse: IO<R2, E2, C>): IO<R1 & R2, E1 | E2, B | C>;
+export declare function evalOnIO_<E, A, R1, E1, B, R2, E2, C>(fiber: Fiber<E, A>, effect: IO<R1, E1, B>, orElse: IO<R2, E2, C>): IO<R1 | R2, E1 | E2, B | C>;

package/Fiber/api/joinAll.d.ts

@@ -8,4 +8,4 @@ import { Conc } from "@fncts/base/collection/immutable/Conc";
  * @tsplus static fncts.io.FiberOps joinAll
  * @tsplus location "@fncts/io/Fiber/api/joinAll"
  */
-export declare function joinAll<E, A>(as: Iterable<Fiber<E, A>>): IO<unknown, E, Conc<A>>;
+export declare function joinAll<E, A>(as: Iterable<Fiber<E, A>>): IO<never, E, Conc<A>>;

package/Fiber/definition.d.ts

@@ -69,7 +69,7 @@ export interface RuntimeFiber<E, A> extends FiberCommon<E, A> {
      * effect will be executed instead.
      */
     readonly evalOn: (effect: UIO<any>, orElse: UIO<any>) => UIO<void>;
-    readonly evalOnIO: <R1, E1, B, R2, E2, C>(effect: IO<R1, E1, B>, orElse: IO<R2, E2, C>) => IO<R1 & R2, E1 | E2, B | C>;
+    readonly evalOnIO: <R1, E1, B, R2, E2, C>(effect: IO<R1, E1, B>, orElse: IO<R2, E2, C>) => IO<R1 | R2, E1 | E2, B | C>;
     /**
      * The status of the fiber.
      */

package/FiberRef/api/locallyScoped.d.ts

@@ -1,9 +1,8 @@
 import { FiberRef } from "@fncts/io/FiberRef/definition";
 import { IO } from "@fncts/io/IO/definition";
-import { Has } from "@fncts/base/typeclass/Has";
 import { Scope } from "@fncts/io/Scope/definition";
 /**
  * @tsplus fluent fncts.io.FiberRef locallyScoped
  * @tsplus location "@fncts/io/FiberRef/api/locallyScoped"
  */
-export declare function locallyScoped_<A>(ref: FiberRef<A>, a: A): IO<Has<Scope>, never, void>;
+export declare function locallyScoped_<A>(ref: FiberRef<A>, a: A): IO<Scope, never, void>;

package/FiberRef/api/locallyScopedWith.d.ts

@@ -1,9 +1,8 @@
 import { FiberRef } from "@fncts/io/FiberRef/definition";
 import { IO } from "@fncts/io/IO/definition";
-import { Has } from "@fncts/base/typeclass/Has";
 import { Scope } from "@fncts/io/Scope/definition";
 /**
  * @tsplus fluent fncts.io.FiberRef locallyScopedWith
  * @tsplus location "@fncts/io/FiberRef/api/locallyScopedWith"
  */
-export declare function locallyScopedWith<A>(self: FiberRef<A>, f: (a: A) => A): IO<Has<Scope>, never, void>;
+export declare function locallyScopedWith<A>(self: FiberRef<A>, f: (a: A) => A): IO<Scope, never, void>;

package/FiberRef/constructors.d.ts

@@ -1,10 +1,9 @@
 import { Lazy } from "@fncts/base/data/function";
 import { FiberRef } from "@fncts/io/FiberRef/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.FiberRefOps make
  * @tsplus location "@fncts/io/FiberRef/constructors"
  */
-export declare function make<A>(initial: A, fork?: (a: A) => A, join?: (a: A, a1: A) => A): IO<Has<Scope>, never, FiberRef<A>>;
+export declare function make<A>(initial: A, fork?: (a: A) => A, join?: (a: A, a1: A) => A): IO<Scope, never, FiberRef<A>>;

package/FiberRef/unsafe.d.ts

@@ -6,6 +6,7 @@ import { LogLevel } from "@fncts/io/LogLevel";
 import { List } from "@fncts/base/collection/immutable/List";
 import { HashMap } from "@fncts/base/collection/immutable/HashMap";
 import type { LogSpan } from "../LogSpan.js";
+import type { Scheduler } from "@fncts/io/internal/Scheduler.js";
 import { Patch } from "@fncts/base/data/Patch";
 /**
  * @tsplus static fncts.io.FiberRefOps unsafeMakePatch
@@ -52,3 +53,8 @@ export declare const currentLogSpan: import("./definition.js").FiberRef.WithPatc
  * @tsplus location "@fncts/io/FiberRef/unsafe"
  */
 export declare const currentLogAnnotations: import("./definition.js").FiberRef.WithPatch<import("@fncts/base/collection/immutable/HashMap.js").HashMap<string, string>, (_: import("@fncts/base/collection/immutable/HashMap.js").HashMap<string, string>) => import("@fncts/base/collection/immutable/HashMap.js").HashMap<string, string>>;
+/**
+ * @tsplus static fncts.io.FiberRefOps currentScheduler
+ * @tsplus location "@fncts/io/FiberRef/unsafe"
+ */
+export declare const currentScheduler: import("./definition.js").FiberRef.WithPatch<Scheduler, (_: Scheduler) => Scheduler>;

package/Future/api.d.ts

@@ -110,4 +110,4 @@ export declare function unsafeSucceed_<A>(future: Future<never, A>, a: A): void;
  * @tsplus getter fncts.io.Future await
  * @tsplus location "@fncts/io/Future/api"
  */
-export declare function wait<E, A>(future: Future<E, A>): IO<unknown, E, A>;
+export declare function wait<E, A>(future: Future<E, A>): IO<never, E, A>;

package/Future/constructors.d.ts

@@ -6,7 +6,7 @@ import { Future } from "@fncts/io/Future/definition";
  * @tsplus static fncts.io.FutureOps make
  * @tsplus location "@fncts/io/Future/constructors"
  */
-export declare function make<E, A>(): IO<unknown, never, Future<E, A>>;
+export declare function make<E, A>(): IO<never, never, Future<E, A>>;
 /**
  * Makes a new future to be completed by the fiber with the specified id.
  * @tsplus static fncts.io.FutureOps makeAs

package/Hub/api.d.ts

@@ -1,7 +1,6 @@
 import { PHub, Hub } from "@fncts/io/Hub/definition";
 import { UIO, IO } from "@fncts/io/IO/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
-import { Has } from "@fncts/base/typeclass/Has";
 import { Scope } from "@fncts/io/Scope/definition";
 /**
  * Waits for the hub to be shut down.
@@ -21,7 +20,7 @@ export declare function capacity<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB
  * @tsplus fluent fncts.io.Hub contramapIO
  * @tsplus location "@fncts/io/Hub/api"
  */
-export declare function contramapIO_<RA, RB, RC, EA, EB, EC, A, B, C>(self: PHub<RA, RB, EA, EB, A, B>, f: (c: C) => IO<RC, EC, A>): PHub<RC & RA, RB, EA | EC, EB, C, B>;
+export declare function contramapIO_<RA, RB, RC, EA, EB, EC, A, B, C>(self: PHub<RA, RB, EA, EB, A, B>, f: (c: C) => IO<RC, EC, A>): PHub<RC | RA, RB, EA | EC, EB, C, B>;
 /**
  * Transforms messages published to and taken from the hub using the
  * specified functions.
@@ -35,14 +34,14 @@ export declare function dimap_<RA, RB, EA, EB, A, B, C, D>(self: PHub<RA, RB, EA
  * @tsplus fluent fncts.io.Hub dimapIO
  * @tsplus location "@fncts/io/Hub/api"
  */
-export declare function dimapIO_<RA, RB, RC, RD, EA, EB, EC, ED, A, B, C, D>(source: PHub<RA, RB, EA, EB, A, B>, f: (c: C) => IO<RC, EC, A>, g: (b: B) => IO<RD, ED, D>): PHub<RC & RA, RD & RB, EA | EC, EB | ED, C, D>;
+export declare function dimapIO_<RA, RB, RC, RD, EA, EB, EC, ED, A, B, C, D>(source: PHub<RA, RB, EA, EB, A, B>, f: (c: C) => IO<RC, EC, A>, g: (b: B) => IO<RD, ED, D>): PHub<RC | RA, RD | RB, EA | EC, EB | ED, C, D>;
 /**
  * Filters messages published to the hub using the specified effectual
  * function.
  * @tsplus fluent fncts.io.Hub filterInputIO
  * @tsplus location "@fncts/io/Hub/api"
  */
-export declare function filterInputIO_<RA, RA1, RB, EA, EA1, EB, A, B>(source: PHub<RA, RB, EA, EB, A, B>, f: (a: A) => IO<RA1, EA1, boolean>): PHub<RA & RA1, RB, EA | EA1, EB, A, B>;
+export declare function filterInputIO_<RA, RA1, RB, EA, EA1, EB, A, B>(source: PHub<RA, RB, EA, EB, A, B>, f: (a: A) => IO<RA1, EA1, boolean>): PHub<RA | RA1, RB, EA | EA1, EB, A, B>;
 /**
  * Filters messages published to the hub using the specified function.
  * @tsplus fluent fncts.io.Hub filterInput
@@ -55,7 +54,7 @@ export declare function filterInput_<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA
  * @tsplus fluent fncts.io.Hub filterOutputIO
  * @tsplus location "@fncts/io/Hub/api"
  */
-export declare function filterOutputIO_<RA, RB, RB1, EA, EB, EB1, A, B>(source: PHub<RA, RB, EA, EB, A, B>, f: (a: B) => IO<RB1, EB1, boolean>): PHub<RA, RB & RB1, EA, EB | EB1, A, B>;
+export declare function filterOutputIO_<RA, RB, RB1, EA, EB, EB1, A, B>(source: PHub<RA, RB, EA, EB, A, B>, f: (a: B) => IO<RB1, EB1, boolean>): PHub<RA, RB | RB1, EA, EB | EB1, A, B>;
 /**
  * Filters messages taken from the hub using the specified function.
  * @tsplus fluent fncts.io.Hub filterOutput
@@ -114,7 +113,7 @@ export declare function map_<RA, RB, EA, EB, A, B, C>(self: PHub<RA, RB, EA, EB,
  * @tsplus fluent fncts.io.Hub mapIO
  * @tsplus location "@fncts/io/Hub/api"
  */
-export declare function mapIO_<RA, RB, RC, EA, EB, EC, A, B, C>(self: PHub<RA, RB, EA, EB, A, B>, f: (b: B) => IO<RC, EC, C>): PHub<RA, RC & RB, EA, EB | EC, A, C>;
+export declare function mapIO_<RA, RB, RC, EA, EB, EC, A, B, C>(self: PHub<RA, RB, EA, EB, A, B>, f: (b: B) => IO<RC, EC, C>): PHub<RA, RC | RB, EA, EB | EC, A, C>;
 /**
  * Publishes a message to the hub, returning whether the message was
  * published to the hub.
@@ -142,7 +141,7 @@ export declare function shutdown<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB
  * @tsplus getter fncts.io.Hub subscribe
  * @tsplus location "@fncts/io/Hub/api"
  */
-export declare function subscribe<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>): IO<Has<Scope>, never, Hub.Dequeue<RB, EB, B>>;
+export declare function subscribe<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>): IO<Scope, never, Hub.Dequeue<RB, EB, B>>;
 /**
  * The current number of messages in the hub.
  * @tsplus getter fncts.io.Hub size

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

@@ -4,7 +4,6 @@ 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 { 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 { 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>): IO<R | R1 | Scope, E, A>;

package/IO/api/acquireReleaseExit.d.ts

@@ -1,11 +1,10 @@
 import { Lazy } from "@fncts/base/data/function";
 import { IO } from "@fncts/io/IO/definition";
 import { Exit } from "@fncts/base/data/Exit";
-import { Has } from "@fncts/base/typeclass/Has";
 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 { 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 { IO } from "@fncts/io/IO/definition";
 import { Exit } from "@fncts/base/data/Exit";
-import { Has } from "@fncts/base/typeclass/Has";
 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 { 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 { 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>): IO<R | Scope, never, void>;

package/IO/api/bracket.d.ts

@@ -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>): IO<R | R1 | R2, E | E1 | E2, A1>;

package/IO/api/bracketExit.d.ts

@@ -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>): 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/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>): IO<R | Scope, E, A>;

package/IO/api/consoleWith.d.ts

@@ -9,4 +9,4 @@ export declare function consoleWith<R, E, A>(f: (console: Console) => 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

@@ -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>): 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";
 /**
  * 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>): 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/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/interrupt.d.ts

@@ -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
@@ -74,14 +74,14 @@ export declare function interruptibleMask<R, E, A>(k: (restore: InterruptStatusR
  * @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>): 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>>): 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

@@ -4,4 +4,4 @@ import { Exit } from "@fncts/base/data/Exit";
  * @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>): IO<R | R1, E | E1, A>;

package/IO/api/onTermination.d.ts

@@ -6,4 +6,4 @@ import { Exit } from "@fncts/base/data/Exit";
  * @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/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>): IO<R | R1, E | E1, A | A1>;