@fncts/io 0.0.38 → 0.0.40

package/IO/api/retry.d.ts

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

package/IO/api/schedule.d.ts

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

package/IO/api/timeout.d.ts

@@ -6,9 +6,9 @@ import { Maybe } from "@fncts/base/data/Maybe/definition";
  * @tsplus pipeable fncts.io.IO timeoutTo
  * @tsplus location "@fncts/io/IO/api/timeout"
  */
-export declare function timeoutTo<A, B, B1>(duration: Lazy<Duration>, b: Lazy<B>, f: (a: A) => B1, __tsplusTrace?: string): <R, E>(self: import("../definition").IO<R, E, A>) => import("../definition").IO<R, E, B | B1>;
+export declare function timeoutTo<A, B, B1>(duration: Lazy<Duration>, b: Lazy<B>, f: (a: A) => B1, __tsplusTrace?: string): <R, E>(self: IO<R, E, A>) => IO<R, E, B | B1>;
 /**
  * @tsplus pipeable fncts.io.IO timeout
  * @tsplus location "@fncts/io/IO/api/timeout"
  */
-export declare function timeout(duration: Lazy<Duration>, __tsplusTrace?: string): <R, E, A>(self: import("../definition").IO<R, E, A>) => import("../definition").IO<R, E, import("@fncts/base/data/Maybe").Maybe<A>>;
+export declare function timeout(duration: Lazy<Duration>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R, E, Maybe<A>>;

package/IO/api/whenFiberRef.d.ts

@@ -7,4 +7,4 @@ import { Maybe } from "@fncts/base/data/Maybe/definition";
  * @tsplus static fncts.io.IOOps whenFiberRef
  * @tsplus location "@fncts/io/IO/api/whenFiberRef"
  */
-export declare function whenFiberRef<S>(ref: FiberRef<S>, f: Predicate<S>, __tsplusTrace?: string): <R, E, A>(self: import("../definition").IO<R, E, A>) => import("../definition").IO<R, E, import("@fncts/base/data/Maybe").Maybe<A>>;
+export declare function whenFiberRef<S>(ref: FiberRef<S>, f: Predicate<S>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R, E, Maybe<A>>;

package/IO/api/whenRef.d.ts

@@ -7,4 +7,4 @@ import { Maybe } from "@fncts/base/data/Maybe/definition";
  * @tsplus static fncts.io.IOOps whenRef
  * @tsplus location "@fncts/io/IO/api/whenRef"
  */
-export declare function whenRef<S>(ref: Ref<S>, f: Predicate<S>): <R, E, A>(self: import("../definition").IO<R, E, A>) => import("../definition").IO<R, E, import("@fncts/base/data/Maybe").Maybe<A>>;
+export declare function whenRef<S>(ref: Ref<S>, f: Predicate<S>): <R, E, A>(self: IO<R, E, A>) => IO<R, E, Maybe<A>>;

package/IO/api/withFinalizer.d.ts

@@ -4,4 +4,4 @@ import { Scope } from "@fncts/io/Scope/definition";
  * @tsplus pipeable fncts.io.IO withFinalizer
  * @tsplus location "@fncts/io/IO/api/withFinalizer"
  */
-export declare function withFinalizer<A, R1>(finalizer: (a: A) => URIO<R1, any>, __tsplusTrace?: string): <R, E>(self: import("../definition").IO<R, E, A>) => import("../definition").IO<import("../../Scope").Scope | R1 | R, E, A>;
+export declare function withFinalizer<A, R1>(finalizer: (a: A) => URIO<R1, any>, __tsplusTrace?: string): <R, E>(self: IO<R, E, A>) => IO<R | R1 | Scope, E, A>;

package/IO/api/withFinalizerExit.d.ts

@@ -5,4 +5,4 @@ import { Scope } from "@fncts/io/Scope/definition";
  * @tsplus pipeable fncts.io.IO withFinalizerExit
  * @tsplus location "@fncts/io/IO/api/withFinalizerExit"
  */
-export declare function withFinalizerExit<A, R1>(finalizer: (a: A, exit: Exit<any, any>) => URIO<R1, any>, __tsplusTrace?: string): <R, E>(self: import("../definition").IO<R, E, A>) => import("../definition").IO<import("../../Scope").Scope | R1 | R, E, A>;
+export declare function withFinalizerExit<A, R1>(finalizer: (a: A, exit: Exit<any, any>) => URIO<R1, any>, __tsplusTrace?: string): <R, E>(self: IO<R, E, A>) => IO<R | R1 | Scope, E, A>;

package/IO/api/zipConcurrent.d.ts

@@ -7,9 +7,9 @@ import { Fiber } from "@fncts/io/Fiber/definition";
  * @tsplus pipeable fncts.io.IO zipConcurrent
  * @tsplus location "@fncts/io/IO/api/zipConcurrent"
  */
-export declare function zipConcurrent<R1, E1, B>(that: IO<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: import("../definition.js").IO<R, E, A>) => import("../definition.js").IO<R1 | R, E1 | E, import("@fncts/base/data/Zipped.js").Zipped.Make<A, B>>;
+export declare function zipConcurrent<R1, E1, B>(that: IO<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R | R1, E | E1, Zipped.Make<A, B>>;
 /**
  * @tsplus pipeable fncts.io.IO zipWithConcurrent
  * @tsplus location "@fncts/io/IO/api/zipConcurrent"
  */
-export declare function zipWithConcurrent<A, R1, E1, B, C>(that: IO<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): <R, E>(self: import("../definition.js").IO<R, E, A>) => import("../definition.js").IO<R1 | R, E1 | E, C>;
+export declare function zipWithConcurrent<A, R1, E1, B, C>(that: IO<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): <R, E>(self: IO<R, E, A>) => IO<R | R1, E | E1, C>;

package/IO/api.d.ts

@@ -84,7 +84,7 @@ export declare function bimap<E, A, E1, B>(f: (e: E) => E1, g: (a: A) => B, __ts
  * @tsplus pipeable fncts.io.IO bitap
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function bitap<E, A, R1, E1, R2, E2>(onFailure: (e: E) => IO<R1, E1, any>, onSuccess: (a: A) => IO<R2, E2, any>, __tsplusTrace?: string): <R>(self: IO<R, E, A>) => IO<R1 | R2 | R, E | E1 | E2, A>;
+export declare function bitap<E, A, R1, E1, R2, E2>(onFailure: (e: E) => IO<R1, E1, any>, onSuccess: (a: A) => IO<R2, E2, any>, __tsplusTrace?: string): <R>(self: IO<R, E, A>) => IO<R | R1 | R2, E | E1 | E2, A>;
 /**
  * Recovers from the specified error
  * @tsplus pipeable fncts.io.IO catch
@@ -98,7 +98,7 @@ export declare function catchTagWith<N extends keyof E, K extends E[N] & string,
  * @tsplus pipeable fncts.io.IO catchAll
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function catchAll<E, R1, E1, A1>(f: (e: E) => IO<R1, E1, A1>, __tsplusTrace?: string): <R, A>(ma: IO<R, E, A>) => IO<R1 | R, E1, A1 | A>;
+export declare function catchAll<E, R1, E1, A1>(f: (e: E) => IO<R1, E1, A1>, __tsplusTrace?: string): <R, A>(ma: IO<R, E, A>) => IO<R | R1, E1, A | A1>;
 /**
  *
  * Recovers from all errors with provided cause.
@@ -111,13 +111,13 @@ export declare function catchAllCause<R, E, A, R1, E1, A1>(f: (_: Cause<E>) => I
  * @tsplus pipeable fncts.io.IO catchJust
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function catchJust<E, R1, E1, A1>(f: (e: E) => Maybe<IO<R1, E1, A1>>, __tsplusTrace?: string): <R, A>(ma: IO<R, E, A>) => IO<R1 | R, E | E1, A1 | A>;
+export declare function catchJust<E, R1, E1, A1>(f: (e: E) => Maybe<IO<R1, E1, A1>>, __tsplusTrace?: string): <R, A>(ma: IO<R, E, A>) => IO<R | R1, E | E1, A | A1>;
 /**
  * Recovers from some or all of the error cases with provided cause.
  * @tsplus pipeable fncts.io.IO catchJustCause
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function catchJustCause<E, R1, E1, A1>(f: (_: Cause<E>) => Maybe<IO<R1, E1, A1>>, __tsplusTrace?: string): <R, A>(ma: IO<R, E, A>) => IO<R1 | R, E | E1, A1 | A>;
+export declare function catchJustCause<E, R1, E1, A1>(f: (_: Cause<E>) => Maybe<IO<R1, E1, A1>>, __tsplusTrace?: string): <R, A>(ma: IO<R, E, A>) => IO<R | R1, E | E1, A | A1>;
 /**
  * Recovers from some or all of the defects with provided partial function.
  *
@@ -128,7 +128,7 @@ export declare function catchJustCause<E, R1, E1, A1>(f: (_: Cause<E>) => Maybe<
  * @tsplus pipeable fncts.io.IO catchJustDefect
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function catchJustDefect<R1, E1, A1>(f: (_: unknown) => Maybe<IO<R1, E1, A1>>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R1 | R, E1 | E, A1 | A>;
+export declare function catchJustDefect<R1, E1, A1>(f: (_: unknown) => Maybe<IO<R1, E1, A1>>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R | R1, E | E1, A | A1>;
 /**
  * Recovers from the specified error
  * @tsplus pipeable IO catchTag
@@ -138,9 +138,9 @@ export declare function catchTag<K extends E["_tag"] & string, E extends {
     _tag: string;
 }, R1, E1, A1>(k: K, f: (e: Extract<E, {
     _tag: K;
-}>) => IO<R1, E1, A1>, __tsplusTrace?: string): <R, A>(ma: IO<R, E, A>) => IO<R1 | R, E1 | Exclude<E, {
+}>) => IO<R1, E1, A1>, __tsplusTrace?: string): <R, A>(ma: IO<R, E, A>) => IO<R | R1, Exclude<E, {
     _tag: K;
-}>, A1 | A>;
+}> | E1, A | A1>;
 /**
  * @tsplus getter fncts.io.IO cause
  * @tsplus location "@fncts/io/IO/api"
@@ -150,7 +150,7 @@ export declare function cause<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string):
  * @tsplus pipeable fncts.io.IO causeAsError
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function causeAsError(__tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R, import("@fncts/base/data/Cause.js").Cause<E>, A>;
+export declare function causeAsError(__tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R, Cause<E>, A>;
 /**
  * Checks the interrupt status, and produces the IO returned by the
  * specified callback.
@@ -165,22 +165,22 @@ export declare function checkInterruptible<R, E, A>(f: (i: InterruptStatus) => I
  * @tsplus pipeable fncts.io.IO flatMap
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function flatMap<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string): <R, E>(ma: IO<R, E, A>) => IO<R1 | R, E1 | E, B>;
+export declare function flatMap<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string): <R, E>(ma: IO<R, E, A>) => IO<R | R1, E | E1, B>;
 /**
  * @tsplus pipeable fncts.io.IO flatMapError
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function flatMapError<R1, E, E1>(f: (e: E) => IO<R1, never, E1>, __tsplusTrace?: string): <R, A>(ma: IO<R, E, A>) => IO<R1 | R, E1, A>;
+export declare function flatMapError<R1, E, E1>(f: (e: E) => IO<R1, never, E1>, __tsplusTrace?: string): <R, A>(ma: IO<R, E, A>) => IO<R | R1, E1, A>;
 /**
  * @tsplus pipeable fncts.io.IO collect
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function collect<A, E1, A1>(f: Lazy<E1>, pf: (a: A) => Maybe<A1>, __tsplusTrace?: string): <R, E>(ma: IO<R, E, A>) => IO<R, E1 | E, A1>;
+export declare function collect<A, E1, A1>(f: Lazy<E1>, pf: (a: A) => Maybe<A1>, __tsplusTrace?: string): <R, E>(ma: IO<R, E, A>) => IO<R, E | E1, A1>;
 /**
  * @tsplus pipeable fncts.io.IO collectIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function collectIO<A, R1, E1, A1, E2>(f: Lazy<E2>, pf: (a: A) => Maybe<IO<R1, E1, A1>>, __tsplusTrace?: string): <R, E>(ma: IO<R, E, A>) => IO<R1 | R, E1 | E2 | E, A1>;
+export declare function collectIO<A, R1, E1, A1, E2>(f: Lazy<E2>, pf: (a: A) => Maybe<IO<R1, E1, A1>>, __tsplusTrace?: string): <R, E>(ma: IO<R, E, A>) => IO<R | R1, E | E1 | E2, A1>;
 /**
  * @tsplus static fncts.io.IOOps condIO
  * @tsplus location "@fncts/io/IO/api"
@@ -221,7 +221,7 @@ export declare function either<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string)
  * @tsplus pipeable fncts.io.IO errorAsCause
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function errorAsCause(__tsplusTrace?: string): <R, E, A>(ma: IO<R, import("@fncts/base/data/Cause.js").Cause<E>, A>) => IO<R, E, A>;
+export declare function errorAsCause(__tsplusTrace?: string): <R, E, A>(ma: IO<R, Cause<E>, A>) => IO<R, E, A>;
 /**
  * @tsplus getter fncts.io.IO eventually
  * @tsplus location "@fncts/io/IO/api"
@@ -460,13 +460,13 @@ export declare function get<R, E, A>(ma: IO<R, E, Maybe<A>>, __tsplusTrace?: str
  * @tsplus pipeable fncts.io.IO getOrElse
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function getOrElse<B>(orElse: Lazy<B>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, import("@fncts/base/data/Maybe.js").Maybe<A>>) => IO<R, E, B | A>;
+export declare function getOrElse<B>(orElse: Lazy<B>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, Maybe<A>>) => IO<R, E, A | B>;
 /**
  * Extracts the optional value, or executes the effect 'orElse'.
  * @tsplus pipeable fncts.io.IO getOrElseIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function getOrElseIO<R1, E1, B>(orElse: Lazy<IO<R1, E1, B>>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, import("@fncts/base/data/Maybe.js").Maybe<A>>) => IO<R1 | R, E1 | E, B | A>;
+export declare function getOrElseIO<R1, E1, B>(orElse: Lazy<IO<R1, E1, B>>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, Maybe<A>>) => IO<R | R1, E | E1, A | B>;
 /**
  * Lifts a Maybe into an IO. If the option is `Nothing`, fail with `onNothing`.
  * @tsplus static fncts.io.IOOps getOrFailWith
@@ -499,7 +499,7 @@ export declare function haltNow(e: unknown, __tsplusTrace?: string): UIO<never>;
  * @tsplus pipeable fncts.io.IO ifIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function ifIO<R1, E1, B, R2, E2, C>(onFalse: Lazy<IO<R1, E1, B>>, onTrue: Lazy<IO<R2, E2, C>>, __tsplusTrace?: string): <R, E>(self: IO<R, E, boolean>) => IO<R1 | R2 | R, E1 | E2 | E, B | C>;
+export declare function ifIO<R1, E1, B, R2, E2, C>(onFalse: Lazy<IO<R1, E1, B>>, onTrue: Lazy<IO<R2, E2, C>>, __tsplusTrace?: string): <R, E>(self: IO<R, E, boolean>) => IO<R | R1 | R2, E | E1 | E2, B | C>;
 /**
  * @tsplus static fncts.io.IOOps if
  * @tsplus location "@fncts/io/IO/api"
@@ -629,12 +629,12 @@ export declare function matchCause<E, A, A1, A2>(onFailure: (cause: Cause<E>) =>
  * @tsplus pipeable fncts.io.IO matchCauseIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function matchCauseIO<E, A, R1, E1, A1, R2, E2, A2>(onFailure: (cause: Cause<E>) => IO<R1, E1, A1>, onSuccess: (a: A) => IO<R2, E2, A2>, __tsplusTrace?: string): <R>(self: IO<R, E, A>) => IO<R1 | R2 | R, E1 | E2, A1 | A2>;
+export declare function matchCauseIO<E, A, R1, E1, A1, R2, E2, A2>(onFailure: (cause: Cause<E>) => IO<R1, E1, A1>, onSuccess: (a: A) => IO<R2, E2, A2>, __tsplusTrace?: string): <R>(self: IO<R, E, A>) => IO<R | R1 | R2, E1 | E2, A1 | A2>;
 /**
  * @tsplus pipeable fncts.io.IO matchIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function matchIO<R1, R2, E, E1, E2, A, A1, A2>(onFailure: (e: E) => IO<R1, E1, A1>, onSuccess: (a: A) => IO<R2, E2, A2>, __tsplusTrace?: string): <R>(self: IO<R, E, A>) => IO<R1 | R2 | R, E1 | E2, A1 | A2>;
+export declare function matchIO<R1, R2, E, E1, E2, A, A1, A2>(onFailure: (e: E) => IO<R1, E1, A1>, onSuccess: (a: A) => IO<R2, E2, A2>, __tsplusTrace?: string): <R>(self: IO<R, E, A>) => IO<R | R1 | R2, E1 | E2, A1 | A2>;
 /**
  * Folds over the failure value or the success value to yield an IO that
  * does not fail, but succeeds with the value returned by the left or right
@@ -648,7 +648,7 @@ export declare function match<E, A, B, C>(onFailure: (e: E) => B, onSuccess: (a:
  * @tsplus pipeable fncts.io.IO matchTraceIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function matchTraceIO<E, A, R1, E1, A1, R2, E2, A2>(onFailure: (e: E, trace: Trace) => IO<R1, E1, A1>, onSuccess: (a: A) => IO<R2, E2, A2>, __tsplusTrace?: string): <R>(ma: IO<R, E, A>) => IO<R1 | R2 | R, E1 | E2, A1 | A2>;
+export declare function matchTraceIO<E, A, R1, E1, A1, R2, E2, A2>(onFailure: (e: E, trace: Trace) => IO<R1, E1, A1>, onSuccess: (a: A) => IO<R2, E2, A2>, __tsplusTrace?: string): <R>(ma: IO<R, E, A>) => IO<R | R1 | R2, E1 | E2, A1 | A2>;
 /**
  * @tsplus getter fncts.io.IO maybe
  * @tsplus location "@fncts/io/IO/api"
@@ -685,17 +685,17 @@ export declare function optional<R, E, A>(ma: IO<R, Maybe<E>, A>, __tsplusTrace?
  * @tsplus pipeable-operator fncts.io.IO ||
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function or<R1, E1>(mb: IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E>(ma: IO<R, E, boolean>) => IO<R1 | R, E1 | E, boolean>;
+export declare function or<R1, E1>(mb: IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E>(ma: IO<R, E, boolean>) => IO<R | R1, E | E1, boolean>;
 /**
  * @tsplus pipeable fncts.io.IO orElse
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function orElse<R1, E1, A1>(that: Lazy<IO<R1, E1, A1>>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R1 | R, E1, A1 | A>;
+export declare function orElse<R1, E1, A1>(that: Lazy<IO<R1, E1, A1>>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R | R1, E1, A | A1>;
 /**
  * @tsplus pipeable fncts.io.IO orElseEither
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function orElseEither<R1, E1, A1>(that: Lazy<IO<R1, E1, A1>>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R1 | R, E1, import("@fncts/base/data/Either.js").Either<A, A1>>;
+export declare function orElseEither<R1, E1, A1>(that: Lazy<IO<R1, E1, A1>>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R | R1, E1, Either<A, A1>>;
 /**
  * @tsplus pipeable fncts.io.IO orElseFail
  * @tsplus location "@fncts/io/IO/api"
@@ -705,12 +705,12 @@ export declare function orElseFail<E1>(e: Lazy<E1>, __tsplusTrace?: string): <R,
  * @tsplus pipeable fncts.io.IO orElseMaybe
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function orElseMaybe<R1, E1, A1>(that: Lazy<IO<R1, Maybe<E1>, A1>>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, import("@fncts/base/data/Maybe.js").Maybe<E>, A>) => IO<R1 | R, import("@fncts/base/data/Maybe.js").Maybe<E1 | E>, A1 | A>;
+export declare function orElseMaybe<R1, E1, A1>(that: Lazy<IO<R1, Maybe<E1>, A1>>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, Maybe<E>, A>) => IO<R | R1, Maybe<E | E1>, A | A1>;
 /**
  * @tsplus pipeable fncts.io.IO orElseSucceed
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function orElseSucceed<A1>(a: Lazy<A1>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R, E, A1 | A>;
+export declare function orElseSucceed<A1>(a: Lazy<A1>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R, E, A | A1>;
 /**
  * @tsplus getter fncts.io.IO orHalt
  * @tsplus location "@fncts/io/IO/api"
@@ -731,7 +731,7 @@ export declare function orHaltWith<E>(f: (e: E) => unknown, __tsplusTrace?: stri
  * @tsplus pipeable fncts.io.IO concurrentErrors
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function concurrentErrors(__tsplusTrace?: string): <R, E, A>(io: IO<R, E, A>) => IO<R, import("@fncts/base/collection/immutable/List.js").List<E>, A>;
+export declare function concurrentErrors(__tsplusTrace?: string): <R, E, A>(io: IO<R, E, A>) => IO<R, List<E>, A>;
 /**
  * Feeds elements of type `A` to a function `f` that returns an IO.
  * Collects all successes and failures in a separated fashion.
@@ -758,7 +758,7 @@ export declare function refineOrHaltWith<E, E1>(pf: (e: E) => Maybe<E1>, f: (e:
  * @tsplus pipeable fncts.io.IO reject
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function reject<A, E1>(pf: (a: A) => Maybe<E1>, __tsplusTrace?: string): <R, E>(fa: IO<R, E, A>) => IO<R, E1 | E, A>;
+export declare function reject<A, E1>(pf: (a: A) => Maybe<E1>, __tsplusTrace?: string): <R, E>(fa: IO<R, E, A>) => IO<R, E | E1, A>;
 /**
  * Continue with the returned computation if the partial function `pf` matches,
  * translating the successful match into a failure, otherwise continue with
@@ -766,7 +766,7 @@ export declare function reject<A, E1>(pf: (a: A) => Maybe<E1>, __tsplusTrace?: s
  * @tsplus pipeable fncts.io.IO rejectIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function rejectIO<A, R1, E1>(pf: (a: A) => Maybe<IO<R1, E1, E1>>, __tsplusTrace?: string): <R, E>(fa: IO<R, E, A>) => IO<R1 | R, E1 | E, A>;
+export declare function rejectIO<A, R1, E1>(pf: (a: A) => Maybe<IO<R1, E1, E1>>, __tsplusTrace?: string): <R, E>(fa: IO<R, E, A>) => IO<R | R1, E | E1, A>;
 /**
  * Repeats this effect the specified number of times.
  * @tsplus pipeable fncts.io.IO repeatN
@@ -784,7 +784,7 @@ export declare function repeatUntil<A>(f: (a: A) => boolean, __tsplusTrace?: str
  * @tsplus pipeable fncts.io.IO repeatUntilIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function repeatUntilIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E>(ma: IO<R, E, A>) => IO<R1 | R, E1 | E, A>;
+export declare function repeatUntilIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E>(ma: IO<R, E, A>) => IO<R | R1, E | E1, A>;
 /**
  * Repeats this effect while its error satisfies the specified predicate.
  * @tsplus pipeable fncts.io.IO repeatWhile
@@ -796,17 +796,17 @@ export declare function repeatWhile<A>(f: (a: A) => boolean, __tsplusTrace?: str
  * @tsplus pipeable fncts.io.IO repeatWhileIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function repeatWhileIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E>(ma: IO<R, E, A>) => IO<R1 | R, E1 | E, A>;
+export declare function repeatWhileIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E>(ma: IO<R, E, A>) => IO<R | R1, E | E1, A>;
 /**
  * @tsplus pipeable fncts.io.IO replicate
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function replicate(n: number, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => import("@fncts/base/collection/immutable/ImmutableArray.js").ImmutableArray<IO<R, E, A>>;
+export declare function replicate(n: number, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => ImmutableArray<IO<R, E, A>>;
 /**
  * @tsplus pipeable fncts.io.IO require
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function require<E>(error: Lazy<E>, __tsplusTrace?: string): <R, A>(ma: IO<R, E, import("@fncts/base/data/Maybe.js").Maybe<A>>) => IO<R, E, A>;
+export declare function require<E>(error: Lazy<E>, __tsplusTrace?: string): <R, A>(ma: IO<R, E, Maybe<A>>) => IO<R, E, A>;
 /**
  * Returns an IO that semantically runs the IO on a fiber,
  * producing an `Exit` for the completion value of the fiber.
@@ -831,7 +831,7 @@ export declare function retryUntil<E>(f: (e: E) => boolean, __tsplusTrace?: stri
  * @tsplus pipeable fncts.io.IO retryUntilIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function retryUntilIO<E, R1, E1>(f: (e: E) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, A>(fa: IO<R, E, A>) => IO<R1 | R, E | E1, A>;
+export declare function retryUntilIO<E, R1, E1>(f: (e: E) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, A>(fa: IO<R, E, A>) => IO<R | R1, E | E1, A>;
 /**
  * Retries this effect while its error satisfies the specified predicate.
  * @tsplus pipeable fncts.io.IO retryWhile
@@ -843,7 +843,7 @@ export declare function retryWhile<E>(f: (e: E) => boolean, __tsplusTrace?: stri
  * @tsplus pipeable fncts.io.IO retryWhileIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function retryWhileIO<E, R1, E1>(f: (e: E) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, A>(fa: IO<R, E, A>) => IO<R1 | R, E | E1, A>;
+export declare function retryWhileIO<E, R1, E1>(f: (e: E) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, A>(fa: IO<R, E, A>) => IO<R | R1, E | E1, A>;
 /**
  * Exposes the full cause of failure of this effect.
  * @tsplus getter fncts.io.IO sandbox
@@ -884,7 +884,7 @@ export declare function succeed<A>(effect: Lazy<A>, __tsplusTrace?: string): UIO
  * @tsplus pipeable fncts.io.IO summarized
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function summarized<R1, E1, B, C>(summary: IO<R1, E1, B>, f: (start: B, end: B) => C, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R1 | R, E1 | E, readonly [C, A]>;
+export declare function summarized<R1, E1, B, C>(summary: IO<R1, E1, B>, f: (start: B, end: B) => C, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R | R1, E | E1, readonly [C, A]>;
 /**
  * Swaps the positions of a Bifunctor's arguments
  * @tsplus getter fncts.io.IO swap
@@ -935,7 +935,7 @@ export declare function tap<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>, __tsplusTr
  * @tsplus pipeable fncts.io.IO tapCause
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function tapCause<R, E, E2>(f: (e: Cause<E2>) => IO<R, E, any>, __tsplusTrace?: string): <R2, A2>(ma: IO<R2, E2, A2>) => IO<R | R2, E | E2, A2>;
+export declare function tapCause<R, E, E2>(f: (e: Cause<E2>) => IO<R, E, any>, __tsplusTrace?: string): <R2, A2>(ma: IO<R2, E2, A2>) => IO<R2 | R, E | E2, A2>;
 /**
  * Returns an IO that effectfully "peeks" at the failure of this effect.
  * @tsplus pipeable fncts.io.IO tapError
@@ -948,12 +948,12 @@ export declare function tapError<E, R1, E1>(f: (e: E) => IO<R1, E1, any>, __tspl
  * @tsplus pipeable fncts.io.IO tapErrorCause
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function tapErrorCause<E, R1, E1>(f: (e: Cause<E>) => IO<R1, E1, any>, __tsplusTrace?: string): <R, A>(self: IO<R, E, A>) => IO<R1 | R, E | E1, A>;
+export declare function tapErrorCause<E, R1, E1>(f: (e: Cause<E>) => IO<R1, E1, any>, __tsplusTrace?: string): <R, A>(self: IO<R, E, A>) => IO<R | R1, E | E1, A>;
 /**
  * @tsplus pipeable fncts.io.IO tryOrElse
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function tryOrElse<A, R1, E1, A1, R2, E2, A2>(that: Lazy<IO<R1, E1, A1>>, onSuccess: (a: A) => IO<R2, E2, A2>, __tsplusTrace?: string): <R, E>(ma: IO<R, E, A>) => IO<R1 | R2 | R, E1 | E2, A1 | A2>;
+export declare function tryOrElse<A, R1, E1, A1, R2, E2, A2>(that: Lazy<IO<R1, E1, A1>>, onSuccess: (a: A) => IO<R2, E2, A2>, __tsplusTrace?: string): <R, E>(ma: IO<R, E, A>) => IO<R | R1 | R2, E1 | E2, A1 | A2>;
 /**
  * @tsplus static fncts.io.IOOps unit
  * @tsplus location "@fncts/io/IO/api"
@@ -1001,7 +1001,7 @@ export declare function when(b: Lazy<boolean>, __tsplusTrace?: string): <R, E, A
  * @tsplus static fncts.io.IOOps whenIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function whenIO<R1, E1>(mb: IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R1 | R, E1 | E, import("@fncts/base/data/Maybe.js").Maybe<A>>;
+export declare function whenIO<R1, E1>(mb: IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R1 | R, E | E1, Maybe<A>>;
 /**
  * @tsplus static fncts.io.IOOps withFiberRuntime
  * @tsplus location "@fncts/io/IO/api"
@@ -1029,12 +1029,12 @@ export declare const yieldNow: UIO<void>;
  * @tsplus pipeable fncts.io.IO zip
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function zip<R1, E1, B>(that: IO<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R1 | R, E1 | E, readonly [A, B]>;
+export declare function zip<R1, E1, B>(that: IO<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R | R1, E | E1, readonly [A, B]>;
 /**
  * @tsplus pipeable fncts.io.IO zipWith
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function zipWith<A, R1, E1, B, C>(that: IO<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): <R, E>(self: IO<R, E, A>) => IO<R1 | R, E1 | E, C>;
+export declare function zipWith<A, R1, E1, B, C>(that: IO<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): <R, E>(self: IO<R, E, A>) => IO<R | R1, E | E1, C>;
 export declare class GenIO<R, E, A> {
     readonly effect: IO<R, E, A>;
     readonly _trace?: string | undefined;

package/IO/definition.d.ts

@@ -4,6 +4,7 @@ import { FiberId } from "@fncts/base/data/FiberId/definition";
 import { Cause } from "@fncts/base/data/Cause/definition";
 import { STM } from "@fncts/io/STM/definition";
 import { Nothing, Just } from "@fncts/base/data/Maybe/definition";
+import { Tag } from "@fncts/base/data/Tag/definition";
 import type { FiberRuntime } from "../Fiber/FiberRuntime.js";
 import type { Running } from "../FiberStatus.js";
 import type { RuntimeFlagsPatch } from "../RuntimeFlags.js";
@@ -65,6 +66,10 @@ declare module "@fncts/base/data/Exit/definition" {
     interface Failure<E> extends IO<never, E, never> {
     }
 }
+declare module "@fncts/base/data/Tag/definition" {
+    interface Tag<T, Identifier = T> extends IO<never, never, T> {
+    }
+}
 /**
  * @tsplus type fncts.io.IOAspects
  */
@@ -202,7 +207,7 @@ export interface Fail extends IOOp<IOTag.Fail, {
     readonly trace: string | undefined;
 }> {
 }
-export type Primitive = OnSuccessAndFailure | OnFailure | OnSuccess | UpdateRuntimeFlagsWithin | Sync | Async | SucceedNow | UpdateRuntimeFlags | GenerateStackTrace | Stateful | WhileLoop | YieldNow | Fail | STM<any, any, any> | Left<any> | Right<any> | Nothing | Just<any> | Failure<any> | Success<any>;
+export type Primitive = OnSuccessAndFailure | OnFailure | OnSuccess | UpdateRuntimeFlagsWithin | Sync | Async | SucceedNow | UpdateRuntimeFlags | GenerateStackTrace | Stateful | WhileLoop | YieldNow | Fail | STM<any, any, any> | Left<any> | Right<any> | Nothing | Just<any> | Failure<any> | Success<any> | Tag<any>;
 /**
  * @tsplus static fncts.io.IOOps concrete
  * @tsplus macro identity

package/IO/runtime.d.ts

@@ -16,12 +16,12 @@ export declare class Runtime<R> {
     readonly runtimeFlags: RuntimeFlags;
     readonly fiberRefs: FiberRefs;
     constructor(environment: Environment<R>, runtimeFlags: RuntimeFlags, fiberRefs: FiberRefs);
-    makeFiber: <E, A>(io: import("./definition.js").IO<R, E, A>, __tsplusTrace?: string) => FiberRuntime<E, A>;
-    unsafeRunFiber: <E, A>(io: import("./definition.js").IO<R, E, A>, __tsplusTrace?: string) => FiberRuntime<E, A>;
-    unsafeRunPromiseExit: <E, A>(io: import("./definition.js").IO<R, E, A>, __tsplusTrace?: string) => Promise<import("@fncts/base/data/Exit.js").Exit<E, A>>;
-    unsafeRunPromise: <E, A>(io: import("./definition.js").IO<R, E, A>, __tsplusTrace?: string) => Promise<A>;
-    unsafeRunOrFork: <E, A>(io: import("./definition.js").IO<R, E, A>, __tsplusTrace?: string) => import("@fncts/base/data/Either.js").Either<import("@fncts/io/Fiber").Fiber.Runtime<E, A>, import("@fncts/base/data/Exit.js").Exit<E, A>>;
-    unsafeRun: <E, A>(io: import("./definition.js").IO<R, E, A>, __tsplusTrace?: string) => import("@fncts/base/data/Exit.js").Exit<E, A>;
+    makeFiber: <E, A>(io: IO<R, E, A>, __tsplusTrace?: string) => FiberRuntime<E, A>;
+    unsafeRunFiber: <E, A>(io: IO<R, E, A>, __tsplusTrace?: string) => FiberRuntime<E, A>;
+    unsafeRunPromiseExit: <E, A>(io: IO<R, E, A>, __tsplusTrace?: string) => Promise<Exit<E, A>>;
+    unsafeRunPromise: <E, A>(io: IO<R, E, A>, __tsplusTrace?: string) => Promise<A>;
+    unsafeRunOrFork: <E, A>(io: IO<R, E, A>, __tsplusTrace?: string) => Either<Fiber.Runtime<E, A>, Exit<E, A>>;
+    unsafeRun: <E, A>(io: IO<R, E, A>, __tsplusTrace?: string) => Exit<E, A>;
 }
 /**
  * @tsplus static fncts.io.IOOps runtime

package/IO.d.ts

@@ -1,63 +1,65 @@
-export * from "./IO/api.js";
-export * from "./IO/definition.js";
 export * from "./IO/runtime.js";
-export * from "./IO/api/acquireRelease.js";
-export * from "./IO/api/acquireReleaseExit.js";
-export * from "./IO/api/acquireReleaseInterruptible.js";
-export * from "./IO/api/acquireReleaseInterruptibleExit.js";
-export * from "./IO/api/addFinalizer.js";
-export * from "./IO/api/addFinalizerExit.js";
-export * from "./IO/api/all.js";
-export * from "./IO/api/asyncInterrupt.js";
-export * from "./IO/api/asyncIO.js";
-export * from "./IO/api/blocking.js";
-export * from "./IO/api/bracket.js";
-export * from "./IO/api/bracketExit.js";
-export * from "./IO/api/clockWith.js";
-export * from "./IO/api/concurrency.js";
-export * from "./IO/api/concurrentFinalizers.js";
-export * from "./IO/api/consoleWith.js";
-export * from "./IO/api/daemonChildren.js";
-export * from "./IO/api/delay.js";
-export * from "./IO/api/descriptor.js";
-export * from "./IO/api/disconnect.js";
-export * from "./IO/api/ensuringChildren.js";
-export * from "./IO/api/environment.js";
-export * from "./IO/api/foreachConcurrent.js";
-export * from "./IO/api/foreachExec.js";
-export * from "./IO/api/fork.js";
-export * from "./IO/api/forkAll.js";
-export * from "./IO/api/forkDaemon.js";
-export * from "./IO/api/forkIn.js";
-export * from "./IO/api/forkScoped.js";
-export * from "./IO/api/fulfill.js";
-export * from "./IO/api/interrupt.js";
-export * from "./IO/api/memoize.js";
-export * from "./IO/api/once.js";
-export * from "./IO/api/onTermination.js";
-export * from "./IO/api/provideLayer.js";
-export * from "./IO/api/provideScope.js";
-export * from "./IO/api/provideSomeLayer.js";
-export * from "./IO/api/race.js";
-export * from "./IO/api/raceFirst.js";
-export * from "./IO/api/raceWith.js";
-export * from "./IO/api/randomWith.js";
-export * from "./IO/api/repeat.js";
-export * from "./IO/api/retry.js";
-export * from "./IO/api/schedule.js";
-export * from "./IO/api/scope.js";
+export * from "./IO/definition.js";
+export * from "./IO/api.js";
+export * from "./IO/api/zipConcurrent.js";
+export * from "./IO/api/withFinalizerExit.js";
+export * from "./IO/api/withFinalizer.js";
+export * from "./IO/api/withEarlyRelease.js";
+export * from "./IO/api/withChildren.js";
+export * from "./IO/api/whenRef.js";
+export * from "./IO/api/whenFiberRef.js";
+export * from "./IO/api/transplant.js";
+export * from "./IO/api/timeout.js";
+export * from "./IO/api/supervised.js";
+export * from "./IO/api/stateful.js";
+export * from "./IO/api/sleep.js";
+export * from "./IO/api/sequenceT.js";
 export * from "./IO/api/scoped.js";
 export * from "./IO/api/scopeWith.js";
-export * from "./IO/api/sequenceT.js";
-export * from "./IO/api/sleep.js";
-export * from "./IO/api/stateful.js";
-export * from "./IO/api/supervised.js";
-export * from "./IO/api/timeout.js";
-export * from "./IO/api/transplant.js";
-export * from "./IO/api/whenFiberRef.js";
-export * from "./IO/api/whenRef.js";
-export * from "./IO/api/withChildren.js";
-export * from "./IO/api/withEarlyRelease.js";
-export * from "./IO/api/withFinalizer.js";
-export * from "./IO/api/withFinalizerExit.js";
-export * from "./IO/api/zipConcurrent.js";
+export * from "./IO/api/scope.js";
+export * from "./IO/api/schedule.js";
+export * from "./IO/api/retry.js";
+export * from "./IO/api/repeat.js";
+export * from "./IO/api/randomWith.js";
+export * from "./IO/api/raceWith.js";
+export * from "./IO/api/raceFirst.js";
+export * from "./IO/api/race.js";
+export * from "./IO/api/provideSomeRuntime.js";
+export * from "./IO/api/provideSomeLayer.js";
+export * from "./IO/api/provideScope.js";
+export * from "./IO/api/provideLayer.js";
+export * from "./IO/api/patchFiberRefs.js";
+export * from "./IO/api/once.js";
+export * from "./IO/api/onTermination.js";
+export * from "./IO/api/memoize.js";
+export * from "./IO/api/interrupt.js";
+export * from "./IO/api/fulfill.js";
+export * from "./IO/api/forkScoped.js";
+export * from "./IO/api/forkIn.js";
+export * from "./IO/api/forkDaemon.js";
+export * from "./IO/api/forkAll.js";
+export * from "./IO/api/fork.js";
+export * from "./IO/api/foreachExec.js";
+export * from "./IO/api/foreachConcurrent.js";
+export * from "./IO/api/environment.js";
+export * from "./IO/api/ensuringChildren.js";
+export * from "./IO/api/disconnect.js";
+export * from "./IO/api/descriptor.js";
+export * from "./IO/api/delay.js";
+export * from "./IO/api/daemonChildren.js";
+export * from "./IO/api/consoleWith.js";
+export * from "./IO/api/concurrentFinalizers.js";
+export * from "./IO/api/concurrency.js";
+export * from "./IO/api/clockWith.js";
+export * from "./IO/api/bracketExit.js";
+export * from "./IO/api/bracket.js";
+export * from "./IO/api/blocking.js";
+export * from "./IO/api/asyncInterrupt.js";
+export * from "./IO/api/asyncIO.js";
+export * from "./IO/api/all.js";
+export * from "./IO/api/addFinalizerExit.js";
+export * from "./IO/api/addFinalizer.js";
+export * from "./IO/api/acquireReleaseInterruptibleExit.js";
+export * from "./IO/api/acquireReleaseInterruptible.js";
+export * from "./IO/api/acquireReleaseExit.js";
+export * from "./IO/api/acquireRelease.js";

package/IOEnv.d.ts

@@ -1,3 +1,3 @@
-export * from "./IOEnv/definition.js";
-export * from "./IOEnv/live.js";
 export * from "./IOEnv/services.js";
+export * from "./IOEnv/live.js";
+export * from "./IOEnv/definition.js";

package/InterruptStatus.d.ts

@@ -1,2 +1,2 @@
-export * from "./InterruptStatus/constructors.js";
 export * from "./InterruptStatus/definition.js";
+export * from "./InterruptStatus/constructors.js";