@fncts/io 0.0.39 → 0.0.41

package/Hub/api.d.ts

@@ -22,47 +22,47 @@ export declare function capacity<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB
  * @tsplus pipeable fncts.io.Hub contramapIO
  * @tsplus location "@fncts/io/Hub/api"
  */
-export declare function contramapIO<A, RC, EC, C>(f: (c: C) => IO<RC, EC, A>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(self: import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, B>) => import("@fncts/io/Hub/definition").PHub<RC | RA, RB, EC | EA, EB, C, B>;
+export declare function contramapIO<A, RC, EC, C>(f: (c: C) => IO<RC, EC, A>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(self: PHub<RA, RB, EA, EB, A, B>) => PHub<RC | RA, RB, EA | EC, EB, C, B>;
 /**
  * Transforms messages published to and taken from the hub using the
  * specified functions.
  * @tsplus pipeable fncts.io.Hub dimap
  * @tsplus location "@fncts/io/Hub/api"
  */
-export declare function dimap<A, B, C, D>(f: (c: C) => A, g: (b: B) => D, __tsplusTrace?: string): <RA, RB, EA, EB>(self: import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, B>) => import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, C, D>;
+export declare function dimap<A, B, C, D>(f: (c: C) => A, g: (b: B) => D, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PHub<RA, RB, EA, EB, A, B>) => PHub<RA, RB, EA, EB, C, D>;
 /**
  * Transforms messages published to and taken from the hub using the
  * specified effectual functions.
  * @tsplus pipeable fncts.io.Hub dimapIO
  * @tsplus location "@fncts/io/Hub/api"
  */
-export declare function dimapIO<A, B, RC, EC, C, RD, ED, D>(f: (c: C) => IO<RC, EC, A>, g: (b: B) => IO<RD, ED, D>, __tsplusTrace?: string): <RA, RB, EA, EB>(source: import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, B>) => import("@fncts/io/Hub/definition").PHub<RC | RA, RD | RB, EC | EA, ED | EB, C, D>;
+export declare function dimapIO<A, B, RC, EC, C, RD, ED, D>(f: (c: C) => IO<RC, EC, A>, g: (b: B) => IO<RD, ED, D>, __tsplusTrace?: string): <RA, RB, EA, EB>(source: PHub<RA, RB, EA, EB, A, B>) => PHub<RC | RA, RD | RB, EA | EC, EB | ED, C, D>;
 /**
  * Filters messages published to the hub using the specified effectual
  * function.
  * @tsplus pipeable fncts.io.Hub filterInputIO
  * @tsplus location "@fncts/io/Hub/api"
  */
-export declare function filterInputIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(source: import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, B>) => import("@fncts/io/Hub/definition").PHub<R1 | RA, RB, E1 | EA, EB, A, B>;
+export declare function filterInputIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(source: PHub<RA, RB, EA, EB, A, B>) => PHub<RA | R1, RB, EA | E1, EB, A, B>;
 /**
  * Filters messages published to the hub using the specified function.
  * @tsplus pipeable fncts.io.Hub filterInput
  * @tsplus location "@fncts/io/Hub/api"
  */
-export declare function filterInput<A>(f: (a: A) => boolean, __tsplusTrace?: string): <RA, RB, EA, EB, B>(self: import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, B>) => import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, B>;
+export declare function filterInput<A>(f: (a: A) => boolean, __tsplusTrace?: string): <RA, RB, EA, EB, B>(self: PHub<RA, RB, EA, EB, A, B>) => import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, B>;
 /**
  * Filters messages taken from the hub using the specified effectual
  * function.
  * @tsplus pipeable fncts.io.Hub filterOutputIO
  * @tsplus location "@fncts/io/Hub/api"
  */
-export declare function filterOutputIO<B, R1, E1>(f: (a: B) => IO<R1, E1, boolean>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(source: import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, B>) => import("@fncts/io/Hub/definition").PHub<RA, R1 | RB, EA, E1 | EB, A, B>;
+export declare function filterOutputIO<B, R1, E1>(f: (a: B) => IO<R1, E1, boolean>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(source: PHub<RA, RB, EA, EB, A, B>) => PHub<RA, RB | R1, EA, EB | E1, A, B>;
 /**
  * Filters messages taken from the hub using the specified function.
  * @tsplus pipeable fncts.io.Hub filterOutput
  * @tsplus location "@fncts/io/Hub/api"
  */
-export declare function filterOutput<B>(f: (b: B) => boolean, __tsplusTrace?: string): <RA, RB, EA, EB, A>(self: import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, B>) => import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, B>;
+export declare function filterOutput<B>(f: (b: B) => boolean, __tsplusTrace?: string): <RA, RB, EA, EB, A>(self: PHub<RA, RB, EA, EB, A, B>) => PHub<RA, RB, EA, EB, A, B>;
 /**
  * Checks whether the hub is shut down.
  * @tsplus getter fncts.io.Hub isShutdown
@@ -108,28 +108,28 @@ export declare function makeUnbounded<A>(__tsplusTrace?: string): UIO<Hub<A>>;
  * @tsplus pipeable fncts.io.Hub map
  * @tsplus location "@fncts/io/Hub/api"
  */
-export declare function map<B, C>(f: (b: B) => C, __tsplusTrace?: string): <RA, RB, EA, EB, A>(self: import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, B>) => import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, C>;
+export declare function map<B, C>(f: (b: B) => C, __tsplusTrace?: string): <RA, RB, EA, EB, A>(self: PHub<RA, RB, EA, EB, A, B>) => PHub<RA, RB, EA, EB, A, C>;
 /**
  * Transforms messages taken from the hub using the specified effectual
  * function.
  * @tsplus pipeable fncts.io.Hub mapIO
  * @tsplus location "@fncts/io/Hub/api"
  */
-export declare function mapIO<B, RC, EC, C>(f: (b: B) => IO<RC, EC, C>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(self: import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, B>) => import("@fncts/io/Hub/definition").PHub<RA, RC | RB, EA, EC | EB, A, C>;
+export declare function mapIO<B, RC, EC, C>(f: (b: B) => IO<RC, EC, C>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(self: PHub<RA, RB, EA, EB, A, B>) => PHub<RA, RC | RB, EA, EB | EC, A, C>;
 /**
  * Publishes a message to the hub, returning whether the message was
  * published to the hub.
  * @tsplus pipeable fncts.io.Hub publish
  * @tsplus location "@fncts/io/Hub/api"
  */
-export declare function publish<A>(a: A, __tsplusTrace?: string): <RA, RB, EA, EB, B>(self: import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, B>) => import("../IO").IO<RA, EA, boolean>;
+export declare function publish<A>(a: A, __tsplusTrace?: string): <RA, RB, EA, EB, B>(self: PHub<RA, RB, EA, EB, A, B>) => IO<RA, EA, boolean>;
 /**
  * Publishes all of the specified messages to the hub, returning whether
  * they were published to the hub.
  * @tsplus pipeable fncts.io.Hub publishAll
  * @tsplus location "@fncts/io/Hub/api"
  */
-export declare function publishAll<A>(as: Iterable<A>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(self: import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, B>) => import("../IO").IO<RA, EA, boolean>;
+export declare function publishAll<A>(as: Iterable<A>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(self: PHub<RA, RB, EA, EB, A, B>) => IO<RA, EA, boolean>;
 /**
  * Shuts down the hub.
  * @tsplus getter fncts.io.Hub shutdown

package/Hub.d.ts

@@ -1,2 +1,2 @@
-export * from "./Hub/api.js";
 export * from "./Hub/definition.js";
+export * from "./Hub/api.js";

package/IO/api/concurrency.d.ts

@@ -25,7 +25,7 @@ export declare function concurrencyWith<R, E, A>(f: (concurrency: Maybe<number>)
  * @tsplus pipeable fncts.io.IO withConcurrency
  * @tsplus location "@fncts/io/IO/api/concurrency"
  */
-export declare function withConcurrency(n: number, __tsplusTrace?: string): <R, E, A>(ma: import("../definition").IO<R, E, A>) => import("../definition").IO<R, E, A>;
+export declare function withConcurrency(n: number, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R, E, A>;
 /**
  * Runs the specified effect with an unbounded maximum number of fibers for
  * concurrent operators.

package/IO/api/concurrentFinalizers.d.ts

@@ -1,7 +1,16 @@
 import { IO } from "@fncts/io/IO/definition";
-import { Scope } from "@fncts/io/Scope/definition";
+/**
+ * @tsplus getter fncts.io.IO sequentialFinalizers
+ * @tsplus location "@fncts/io/IO/api/concurrentFinalizers"
+ */
+export declare function sequentialFinalizers<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * @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>, __tsplusTrace?: string): IO<R | Scope, E, A>;
+export declare function concurrentFinalizers<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
+/**
+ * @tsplus static fncts.io.IOOps concurrentFinalizersMask
+ * @tsplus location "@fncts/io/IO/api/concurrentFinalizers"
+ */
+export declare function concurrentFinalizersMask<R, E, A>(f: (restore: <R, E, A>(io: IO<R, E, A>) => IO<R, E, A>) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;

package/IO/api/delay.d.ts

@@ -5,4 +5,4 @@ import { IO } from "@fncts/io/IO/definition";
  * @tsplus pipeable fncts.io.IO delay
  * @tsplus location "@fncts/io/IO/api/delay"
  */
-export declare function delay(duration: Lazy<Duration>): <R, E, A>(self: import("../definition").IO<R, E, A>) => import("../definition").IO<R, E, A>;
+export declare function delay(duration: Lazy<Duration>): <R, E, A>(self: IO<R, E, A>) => IO<R, E, A>;

package/IO/api/ensuringChildren.d.ts

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

package/IO/api/environment.d.ts

@@ -7,7 +7,7 @@ import { Tag } from "@fncts/base/data/Tag/definition";
  * @tsplus pipeable fncts.io.IO contramapEnvironment
  * @tsplus location "@fncts/io/IO/api/environment"
  */
-export declare function contramapEnvironment<R0, R>(f: (r0: Environment<R0>) => Environment<R>, __tsplusTrace?: string): <E, A>(self: import("../definition").IO<R, E, A>) => import("../definition").IO<R0, E, A>;
+export declare function contramapEnvironment<R0, R>(f: (r0: Environment<R0>) => Environment<R>, __tsplusTrace?: string): <E, A>(self: IO<R, E, A>) => IO<R0, E, A>;
 /**
  * Accesses the environment provided to an `IO`
  * @tsplus static fncts.io.IOOps environment
@@ -34,23 +34,23 @@ export declare function environmentWithIO<R0, R, E, A>(f: (r: Environment<R0>) =
  * @tsplus pipeable fncts.io.IO provideEnvironment
  * @tsplus location "@fncts/io/IO/api/environment"
  */
-export declare function provideEnvironment<R>(r: Environment<R>, __tsplusTrace?: string): <E, A>(self: import("../definition").IO<R, E, A>) => import("../definition").FIO<E, A>;
+export declare function provideEnvironment<R>(r: Environment<R>, __tsplusTrace?: string): <E, A>(self: IO<R, E, A>) => import("../definition").FIO<E, A>;
 /**
  * @tsplus pipeable fncts.io.IO provideSomeEnvironment
  * @tsplus location "@fncts/io/IO/api/environment"
  */
-export declare function provideSomeEnvironment<R0>(environment: Environment<R0>, __tsplusTrace?: string): <R, E, A>(self: import("../definition").IO<R, E, A>) => import("../definition").IO<Exclude<R, R0>, E, A>;
+export declare function provideSomeEnvironment<R0>(environment: Environment<R0>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<Exclude<R, R0>, E, A>;
 /**
  * @tsplus pipeable fncts.io.IO provideService
  * @tsplus location "@fncts/io/IO/api/environment"
  */
-export declare function provideService<T>(service: T, tag: Tag<T>, __tsplusTrace?: string): <E, A>(self: import("../definition").IO<T, E, A>) => import("../definition").FIO<E, A>;
+export declare function provideService<T>(service: T, tag: Tag<T>, __tsplusTrace?: string): <E, A>(self: IO<T, E, A>) => import("../definition").FIO<E, A>;
 /**
  * @tsplus pipeable fncts.io.IO provideSomeService
  * @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>(self: import("../definition").IO<R, E, A>) => import("../definition").IO<Exclude<R, T>, E, A>;
+export declare function provideSomeService<T>(service: T, tag: Tag<T>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<Exclude<R, T>, E, A>;
 /**
  * @tsplus static fncts.io.IOOps service
  * @tsplus location "@fncts/io/IO/api/environment"

package/IO/api/fork.d.ts

@@ -31,7 +31,7 @@ export declare function fork<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string):
  * @tsplus pipeable fncts.io.IO forkWithScopeOverride
  * @tsplus location "@fncts/io/IO/api/fork"
  */
-export declare function forkWithScopeOverride(scopeOverride: FiberScope | null, __tsplusTrace?: string): <R, E, A>(self: import("../definition").IO<R, E, A>) => import("../definition").URIO<R, FiberRuntime<E, A>>;
+export declare function forkWithScopeOverride(scopeOverride: FiberScope | null, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => import("../definition").URIO<R, FiberRuntime<E, A>>;
 export declare function unsafeFork<R, E, A, E1, B>(effect: IO<R, E, A>, parentFiber: FiberRuntime<E1, B>, parentRuntimeFlags: RuntimeFlags, overrideScope: FiberScope | null, trace?: string): FiberRuntime<E, A>;
 /**
  * @tsplus static fncts.io.IOOps unsafeMakeChildFiber

package/IO/api/forkIn.d.ts

@@ -7,4 +7,4 @@ import { Fiber } from "@fncts/io/Fiber/definition";
  * @tsplus pipeable fncts.io.IO forkIn
  * @tsplus location "@fncts/io/IO/api/forkIn"
  */
-export declare function forkIn(scope: Scope, __tsplusTrace?: string): <R, E, A>(self: import("../definition").IO<R, E, A>) => import("../definition").URIO<R, import("../../Fiber").Fiber.Runtime<E, A>>;
+export declare function forkIn(scope: Scope, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => import("../definition").URIO<R, import("../../Fiber").Fiber.Runtime<E, A>>;

package/IO/api/fulfill.d.ts

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

package/IO/api/interrupt.d.ts

@@ -56,7 +56,7 @@ export declare function uninterruptibleMask<R, E, A>(f: (restore: Interruptibili
  * @tsplus pipeable fncts.io.IO ensuring
  * @tsplus location "@fncts/io/IO/api/interrupt"
  */
-export declare function ensuring<R1>(finalizer: IO<R1, never, any>, __tsplusTrace?: string): <R, E, A>(self: import("@fncts/io/IO/definition").IO<R, E, A>) => import("@fncts/io/IO/definition").IO<R1 | R, E, A>;
+export declare function ensuring<R1>(finalizer: IO<R1, never, any>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R | R1, 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
@@ -71,16 +71,16 @@ export declare function interruptibleMask<R, E, A>(k: (restore: Interruptibility
  * @tsplus pipeable fncts.io.IO onInterrupt
  * @tsplus location "@fncts/io/IO/api/interrupt"
  */
-export declare function onInterrupt<R1, E1>(cleanup: Lazy<IO<R1, E1, any>>, __tsplusTrace?: string): <R, E, A>(ma: import("@fncts/io/IO/definition").IO<R, E, A>) => import("@fncts/io/IO/definition").IO<R1 | R, E1 | E, A>;
+export declare function onInterrupt<R1, E1>(cleanup: Lazy<IO<R1, E1, any>>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R | R1, E | E1, A>;
 /**
  * Calls the specified function, and runs the effect it returns, if this
  * effect is interrupted.
  * @tsplus pipeable fncts.io.IO onInterrupt
  * @tsplus location "@fncts/io/IO/api/interrupt"
  */
-export declare function onInterruptWith<R1, E1>(cleanup: (interruptors: HashSet<FiberId>) => IO<R1, E1, any>, __tsplusTrace?: string): <R, E, A>(ma: import("@fncts/io/IO/definition").IO<R, E, A>) => import("@fncts/io/IO/definition").IO<R1 | R, E1 | E, A>;
+export declare function onInterruptWith<R1, E1>(cleanup: (interruptors: HashSet<FiberId>) => IO<R1, E1, any>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R | R1, E | E1, A>;
 /**
  * @tsplus pipeable fncts.io.IO onExit
  * @tsplus location "@fncts/io/IO/api/interrupt"
  */
-export declare function onExit<E, A, R1, E1>(cleanup: (exit: Exit<E, A>) => IO<R1, E1, any>, __tsplusTrace?: string): <R>(self: import("@fncts/io/IO/definition").IO<R, E, A>) => import("@fncts/io/IO/definition").IO<R1 | R, E | E1, A>;
+export declare function onExit<E, A, R1, E1>(cleanup: (exit: Exit<E, A>) => IO<R1, E1, any>, __tsplusTrace?: string): <R>(self: IO<R, E, A>) => IO<R | R1, E | E1, A>;

package/IO/api/onTermination.d.ts

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

package/IO/api/patchFiberRefs.d.ts

@@ -0,0 +1,7 @@
+import { UIO } from "@fncts/io/IO/definition";
+import type { FiberRefsPatch } from "@fncts/io/FiberRefs";
+/**
+ * @tsplus static fncts.io.IOOps patchFiberRefs
+ * @tsplus location "@fncts/io/IO/api/patchFiberRefs"
+ */
+export declare function patchFiberRefs(patch: FiberRefsPatch): UIO<void>;

package/IO/api/provideLayer.d.ts

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

package/IO/api/provideScope.d.ts

@@ -4,4 +4,4 @@ import { IO } from "@fncts/io/IO/definition";
  * @tsplus pipeable fncts.io.IO provideScope
  * @tsplus location "@fncts/io/IO/api/provideScope"
  */
-export declare function provideScope(scope: Scope): <R, E, A>(self: import("../definition").IO<R, E, A>) => import("../definition").IO<Exclude<R, import("../../Scope").Scope>, E, A>;
+export declare function provideScope(scope: Scope): <R, E, A>(self: IO<R, E, A>) => IO<Exclude<R, Scope>, E, A>;

package/IO/api/provideSomeLayer.d.ts

@@ -5,4 +5,4 @@ import { IO } from "@fncts/io/IO/definition";
  * @tsplus pipeable fncts.io.IO 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, E, A>) => import("../definition").IO<RIn | Exclude<R, ROut>, E1 | E, A>;
+export declare function provideSomeLayer<RIn, E1, ROut>(layer: Layer<RIn, E1, ROut>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<RIn | Exclude<R, ROut>, E | E1, A>;

package/IO/api/provideSomeRuntime.d.ts

@@ -0,0 +1,7 @@
+import { IO } from "@fncts/io/IO/definition";
+import type { Runtime } from "@fncts/io/IO";
+/**
+ * @tsplus pipeable fncts.io.IO provideSomeRuntime
+ * @tsplus location "@fncts/io/IO/api/provideSomeRuntime"
+ */
+export declare function provideSomeRuntime<R>(runtime: Runtime<R>): <R1, E, A>(self: IO<R1, E, A>) => IO<Exclude<R1, R>, E, A>;

package/IO/api/race.d.ts

@@ -11,9 +11,9 @@ import { InterruptStatus } from "@fncts/io/InterruptStatus";
  * @tsplus pipeable fncts.io.IO race
  * @tsplus location "@fncts/io/IO/api/race"
  */
-export declare function race<R1, E1, A1>(that: IO<R1, E1, A1>): <R, E, A>(self: import("../definition").IO<R, E, A>) => import("../definition").IO<R1 | R, E1 | E, A1 | A>;
+export declare function race<R1, E1, A1>(that: IO<R1, E1, A1>): <R, E, A>(self: IO<R, E, A>) => IO<R | R1, E | E1, A | A1>;
 /**
  * @tsplus pipeable fncts.io.IO raceAwait
  * @tsplus location "@fncts/io/IO/api/race"
  */
-export declare function raceAwait<R1, E1, A1>(that: IO<R1, E1, A1>): <R, E, A>(self: import("../definition").IO<R, E, A>) => import("../definition").IO<R1 | R, E1 | E, A1 | A>;
+export declare function raceAwait<R1, E1, A1>(that: IO<R1, E1, A1>): <R, E, A>(self: IO<R, E, A>) => 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 pipeable fncts.io.IO raceFirst
  * @tsplus location "@fncts/io/IO/api/raceFirst"
  */
-export declare function raceFirst<R1, E1, A1>(that: IO<R1, E1, A1>, __tsplusTrace?: string): <R, E, A>(ma: import("../definition").IO<R, E, A>) => import("../definition").IO<R1 | R, E1 | E, A1 | A>;
+export declare function raceFirst<R1, E1, A1>(that: IO<R1, E1, A1>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R | R1, E | E1, A | A1>;

package/IO/api/repeat.d.ts

@@ -7,14 +7,14 @@ 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>, __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>;
+export declare function repeat<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): <R1, B>(schedule0: Lazy<Schedule<R1, A, B>>, __tsplusTrace?: string) => 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>, __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>;
+export declare function repeatOrElse<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): <R1, B, R2, E2>(schedule0: Lazy<Schedule<R1, A, B>>, orElse: (e: E, out: Maybe<B>) => IO<R2, E2, B>, __tsplusTrace?: string) => 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>, __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>>;
+export declare function repeatOrElseEither<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): <R1, B, R2, E2, C>(schedule0: Lazy<Schedule<R1, A, B>>, orElse: (e: E, out: Maybe<B>) => IO<R2, E2, C>, __tsplusTrace?: string) => IO<R | R1 | R2, E2, Either<C, B>>;

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