@fncts/io 0.0.38 → 0.0.40

package/Fiber/api/zipWith.d.ts

@@ -6,4 +6,4 @@ import { Fiber } from "@fncts/io/Fiber/definition";
  * @tsplus pipeable fncts.io.Fiber zipWith
  * @tsplus location "@fncts/io/Fiber/api/zipWith"
  */
-export declare function zipWith<A, E1, B, C>(that: Fiber<E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): <E>(self: import("@fncts/io/Fiber/definition").Fiber<E, A>) => import("@fncts/io/Fiber/definition").Fiber<E1 | E, C>;
+export declare function zipWith<A, E1, B, C>(that: Fiber<E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): <E>(self: Fiber<E, A>) => Fiber<E | E1, C>;

package/Fiber.d.ts

@@ -1,22 +1,22 @@
-export * from "./Fiber/constructors.js";
 export * from "./Fiber/definition.js";
-export * from "./Fiber/FiberMessage.js";
+export * from "./Fiber/constructors.js";
 export * from "./Fiber/FiberRuntime.js";
-export * from "./Fiber/api/await.js";
-export * from "./Fiber/api/awaitAll.js";
-export * from "./Fiber/api/children.js";
-export * from "./Fiber/api/collectAll.js";
-export * from "./Fiber/api/fromIO.js";
-export * from "./Fiber/api/id.js";
-export * from "./Fiber/api/inheritRefs.js";
-export * from "./Fiber/api/interrupt.js";
-export * from "./Fiber/api/interruptAll.js";
-export * from "./Fiber/api/interruptAs.js";
-export * from "./Fiber/api/interruptFork.js";
-export * from "./Fiber/api/join.js";
-export * from "./Fiber/api/joinAll.js";
-export * from "./Fiber/api/location.js";
-export * from "./Fiber/api/mapFiber.js";
-export * from "./Fiber/api/mapIO.js";
-export * from "./Fiber/api/poll.js";
+export * from "./Fiber/FiberMessage.js";
 export * from "./Fiber/api/zipWith.js";
+export * from "./Fiber/api/poll.js";
+export * from "./Fiber/api/mapIO.js";
+export * from "./Fiber/api/mapFiber.js";
+export * from "./Fiber/api/location.js";
+export * from "./Fiber/api/joinAll.js";
+export * from "./Fiber/api/join.js";
+export * from "./Fiber/api/interruptFork.js";
+export * from "./Fiber/api/interruptAs.js";
+export * from "./Fiber/api/interruptAll.js";
+export * from "./Fiber/api/interrupt.js";
+export * from "./Fiber/api/inheritRefs.js";
+export * from "./Fiber/api/id.js";
+export * from "./Fiber/api/fromIO.js";
+export * from "./Fiber/api/collectAll.js";
+export * from "./Fiber/api/children.js";
+export * from "./Fiber/api/awaitAll.js";
+export * from "./Fiber/api/await.js";

package/FiberRef/api.d.ts

@@ -28,4 +28,4 @@ export declare function fork<Value, Patch>(self: FiberRef.WithPatch<Value, Patch
  * @tsplus pipeable fncts.io.FiberRef join
  * @tsplus location "@fncts/io/FiberRef/api"
  */
-export declare function join<Value>(oldValue: Value, newValue: Value): <Patch>(self: import("@fncts/io/FiberRef/definition").FiberRef.WithPatch<Value, Patch>) => Value;
+export declare function join<Value>(oldValue: Value, newValue: Value): <Patch>(self: FiberRef.WithPatch<Value, Patch>) => Value;

package/FiberRef/operations.d.ts

@@ -43,7 +43,7 @@ export declare function getAndUpdateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace
  * @tsplus fluent fncts.io.FiberRef locally
  * @tsplus location "@fncts/io/FiberRef/operations"
  */
-export declare function locally<A>(fiberRef: FiberRef<A>, value: A, __tsplusTrace?: string): <R1, E1, B>(use: import("../IO").IO<R1, E1, B>) => import("../IO").IO<R1, E1, B>;
+export declare function locally<A>(fiberRef: FiberRef<A>, value: A, __tsplusTrace?: string): <R1, E1, B>(use: IO<R1, E1, B>) => IO<R1, E1, B>;
 /**
  * Returns an `IO` that runs with `f` applied to the current fiber.
  *
@@ -51,7 +51,7 @@ export declare function locally<A>(fiberRef: FiberRef<A>, value: A, __tsplusTrac
  * @tsplus fluent fncts.io.FiberRef locallyWith
  * @tsplus location "@fncts/io/FiberRef/operations"
  */
-export declare function locallyWith<A>(self: FiberRef<A>, f: (a: A) => A, __tsplusTrace?: string): <R1, E1, B>(use: import("../IO").IO<R1, E1, B>) => import("../IO").IO<R1, E1, B>;
+export declare function locallyWith<A>(self: FiberRef<A>, f: (a: A) => A, __tsplusTrace?: string): <R1, E1, B>(use: IO<R1, E1, B>) => IO<R1, E1, B>;
 /**
  * @tsplus pipeable fncts.io.FiberRef getWith
  * @tsplus location "@fncts/io/FiberRef/operations"

package/FiberRef/unsafe.d.ts

@@ -86,3 +86,8 @@ export declare const currentIsFatal: import("./definition.js").FiberRef.WithPatc
  * @tsplus location "@fncts/io/FiberRef/unsafe"
  */
 export declare const currentReportFatal: import("./definition.js").FiberRef.WithPatch<(t: unknown) => never, (_: (t: unknown) => never) => (t: unknown) => never>;
+/**
+ * @tsplus static fncts.io.FiberRefOps currentMaxFiberOps
+ * @tsplus location "@fncts/io/FiberRef/unsafe"
+ */
+export declare const currentMaxFiberOps: import("./definition.js").FiberRef.WithPatch<number, (_: number) => number>;

package/FiberRef.d.ts

@@ -1,7 +1,7 @@
-export * from "./FiberRef/api.js";
-export * from "./FiberRef/constructors.js";
-export * from "./FiberRef/definition.js";
-export * from "./FiberRef/operations.js";
 export * from "./FiberRef/unsafe.js";
-export * from "./FiberRef/api/locallyScoped.js";
+export * from "./FiberRef/operations.js";
+export * from "./FiberRef/definition.js";
+export * from "./FiberRef/constructors.js";
+export * from "./FiberRef/api.js";
 export * from "./FiberRef/api/locallyScopedWith.js";
+export * from "./FiberRef/api/locallyScoped.js";

package/FiberRefs/Patch.d.ts

@@ -0,0 +1,62 @@
+import { FiberRef } from "@fncts/io/FiberRef/definition";
+import { FiberRefs } from "@fncts/io/FiberRefs";
+import { FiberId } from "@fncts/base/data/FiberId/definition";
+import { List } from "@fncts/base/collection/immutable/List/definition";
+export declare const enum FiberRefsPatchTag {
+    Empty = 0,
+    Add = 1,
+    Remove = 2,
+    Update = 3,
+    AndThen = 4
+}
+export declare const FiberRefsPatchTypeId: unique symbol;
+export type FiberRefsPatchTypeId = typeof FiberRefsPatchTypeId;
+/**
+ * @tsplus type fncts.io.FiberRefs.Patch
+ * @tsplus companion fncts.io.FiberRefs.PatchOps
+ */
+export declare abstract class FiberRefsPatch {
+    readonly [FiberRefsPatchTypeId]: FiberRefsPatchTypeId;
+}
+export declare class Empty extends FiberRefsPatch {
+    readonly _tag = FiberRefsPatchTag.Empty;
+}
+export declare class Add<Value> extends FiberRefsPatch {
+    readonly fiberRef: FiberRef<Value>;
+    readonly value: Value;
+    readonly _tag = FiberRefsPatchTag.Add;
+    constructor(fiberRef: FiberRef<Value>, value: Value);
+}
+export declare class AndThen extends FiberRefsPatch {
+    readonly first: FiberRefsPatch;
+    readonly second: FiberRefsPatch;
+    readonly _tag = FiberRefsPatchTag.AndThen;
+    constructor(first: FiberRefsPatch, second: FiberRefsPatch);
+}
+export declare class Remove<Value> extends FiberRefsPatch {
+    readonly fiberRef: FiberRef<Value>;
+    readonly _tag = FiberRefsPatchTag.Remove;
+    constructor(fiberRef: FiberRef<Value>);
+}
+export declare class Update<Value, Patch> extends FiberRefsPatch {
+    readonly fiberRef: FiberRef.WithPatch<Value, Patch>;
+    readonly patch: Patch;
+    readonly _tag = FiberRefsPatchTag.Update;
+    constructor(fiberRef: FiberRef.WithPatch<Value, Patch>, patch: Patch);
+}
+export declare const empty: FiberRefsPatch;
+/**
+ * @tsplus pipeable fncts.io.FiberRefs.Patch combine
+ * @tsplus location "@fncts/io/FiberRefs/Patch"
+ */
+export declare function combine(second: FiberRefsPatch): (first: FiberRefsPatch) => FiberRefsPatch;
+/**
+ * @tsplus static fncts.io.FiberRefs.PatchOps diff
+ * @tsplus location "@fncts/io/FiberRefs/Patch"
+ */
+export declare function diff(oldValue: FiberRefs, newValue: FiberRefs): FiberRefsPatch;
+/**
+ * @tsplus pipeable fncts.io.FiberRefs.Patch __call
+ * @tsplus location "@fncts/io/FiberRefs/Patch"
+ */
+export declare function apply(fiberId: FiberId.Runtime, fiberRefs: FiberRefs): (self: FiberRefsPatch) => FiberRefs;

package/FiberRefs.d.ts

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

package/FiberScope.d.ts

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

package/FiberStatus.d.ts

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

package/Future/api.d.ts

@@ -17,14 +17,14 @@ export declare function done<E, A>(exit: Exit<E, A>, __tsplusTrace?: string): (f
  * @tsplus pipeable fncts.io.Future fail
  * @tsplus location "@fncts/io/Future/api"
  */
-export declare function fail<E>(e: E, __tsplusTrace?: string): <A>(future: import("@fncts/io/Future/definition").Future<E, A>) => import("@fncts/io/IO").UIO<boolean>;
+export declare function fail<E>(e: E, __tsplusTrace?: string): <A>(future: Future<E, A>) => import("@fncts/io/IO").UIO<boolean>;
 /**
  * Halts the future with the specified cause, which will be propagated to all
  * fibers waiting on the value of the future.
  * @tsplus pipeable fncts.io.Future failCause
  * @tsplus location "@fncts/io/Future/api"
  */
-export declare function failCause<E>(cause: Cause<E>, __tsplusTrace?: string): <A>(future: import("@fncts/io/Future/definition").Future<E, A>) => import("@fncts/io/IO").UIO<boolean>;
+export declare function failCause<E>(cause: Cause<E>, __tsplusTrace?: string): <A>(future: Future<E, A>) => import("@fncts/io/IO").UIO<boolean>;
 /**
  * Completes the future with the result of the specified effect. If the
  * future has already been completed, the method will produce false.
@@ -57,7 +57,7 @@ export declare function fulfillWith<E, A>(io: FIO<E, A>, __tsplusTrace?: string)
  * @tsplus pipeable fncts.io.Future halt
  * @tsplus location "@fncts/io/Future/api"
  */
-export declare function halt(defect: unknown, __tsplusTrace?: string): <E, A>(future: import("@fncts/io/Future/definition").Future<E, A>) => import("@fncts/io/IO").UIO<boolean>;
+export declare function halt(defect: unknown, __tsplusTrace?: string): <E, A>(future: Future<E, A>) => import("@fncts/io/IO").UIO<boolean>;
 /**
  * Completes the future with interruption. This will interrupt all fibers
  * waiting on the value of the future as by the fiber calling this method.
@@ -71,7 +71,7 @@ export declare function interrupt<E, A>(future: Future<E, A>, __tsplusTrace?: st
  * @tsplus pipeable fncts.io.Future interruptAs
  * @tsplus location "@fncts/io/Future/api"
  */
-export declare function interruptAs(id: FiberId, __tsplusTrace?: string): <E, A>(future: import("@fncts/io/Future/definition").Future<E, A>) => import("@fncts/io/IO").UIO<boolean>;
+export declare function interruptAs(id: FiberId, __tsplusTrace?: string): <E, A>(future: Future<E, A>) => import("@fncts/io/IO").UIO<boolean>;
 /**
  * Checks for completion of this Future. Produces true if this future has
  * already been completed with a value or an error and false otherwise.
@@ -91,7 +91,7 @@ export declare function poll<E, A>(future: Future<E, A>, __tsplusTrace?: string)
  * @tsplus pipeable fncts.io.Future succeed
  * @tsplus location "@fncts/io/Future/api"
  */
-export declare function succeed_<A>(a: A, __tsplusTrace?: string): <E>(future: import("@fncts/io/Future/definition").Future<E, A>) => import("@fncts/io/IO").UIO<boolean>;
+export declare function succeed_<A>(a: A, __tsplusTrace?: string): <E>(future: Future<E, A>) => import("@fncts/io/IO").UIO<boolean>;
 /**
  * Retrieves the value of the future, suspending the fiber running the action
  * until the result is available.

package/Future/definition.d.ts

@@ -1,18 +1,39 @@
 import { FiberId } from "@fncts/base/data/FiberId/definition";
 import { List } from "@fncts/base/collection/immutable/List/definition";
 import { FIO } from "@fncts/io/IO/definition";
+export declare const FutureTypeId: unique symbol;
+export type FutureTypeId = typeof FutureTypeId;
+export declare const FutureVariance: unique symbol;
+export type FutureVariance = typeof FutureVariance;
 /**
  * @tsplus type fncts.io.Future
  * @tsplus companion fncts.io.FutureOps
  */
-export declare class Future<E, A> {
+export declare class Future<in out E, in out A> {
     state: State<E, A>;
     readonly blockingOn: FiberId;
+    readonly [FutureTypeId]: FutureTypeId;
+    FutureVariance: {
+        readonly _A: (_: A) => A;
+        readonly _E: (_: E) => E;
+    };
     constructor(state: State<E, A>, blockingOn: FiberId);
 }
+export declare namespace Future {
+    type ErrorOf<X> = [X] extends [{
+        [FutureVariance]: {
+            _E: (_: infer E) => infer E;
+        };
+    }] ? E : never;
+    type ValueOf<X> = [X] extends [{
+        [FutureVariance]: {
+            _A: (_: infer A) => infer A;
+        };
+    }] ? A : never;
+}
 export declare const enum FutureStateTag {
-    Done = "Done",
-    Pending = "Pending"
+    Done = 0,
+    Pending = 1
 }
 export declare class Pending<E, A> {
     readonly joiners: List<(_: FIO<E, A>) => void>;

package/Future.d.ts

@@ -1,3 +1,3 @@
-export * from "./Future/api.js";
-export * from "./Future/constructors.js";
 export * from "./Future/definition.js";
+export * from "./Future/constructors.js";
+export * from "./Future/api.js";

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