@fncts/io 0.0.20 → 0.0.22

package/FiberRefs/api.d.ts

@@ -3,6 +3,7 @@ import { FiberRef } from "@fncts/io/FiberRef/definition";
 import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
 import { Cons } from "@fncts/base/collection/immutable/List/definition";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { FiberRefs } from "@fncts/io/FiberRefs/definition";
 /**
  * @tsplus getter fncts.io.FiberRefs fiberRefs
@@ -10,12 +11,39 @@ import { FiberRefs } from "@fncts/io/FiberRefs/definition";
  */
 export declare function fiberRefs(self: FiberRefs): HashSet<FiberRef<unknown>>;
 /**
+ * @tsplus macro identity
  * @tsplus static fncts.io.FiberRefsOps __call
  * @tsplus location "@fncts/io/FiberRefs/api"
  */
 export declare function make(fiberRefLocals: HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>): FiberRefs;
 /**
- * @tsplus fluent fncts.io.FiberRefs forkAs
+ * @tsplus pipeable fncts.io.FiberRefs forkAs
  * @tsplus location "@fncts/io/FiberRefs/api"
  */
-export declare function forkAs(self: FiberRefs, childId: FiberId.Runtime): FiberRefs;
+export declare function forkAs(childId: FiberId.Runtime): (self: FiberRefs) => FiberRefs;
+/**
+ * @tsplus fluent fncts.io.FiberRefs get
+ * @tsplus location "@fncts/io/FiberRefs/api"
+ */
+export declare function get<A>(self: FiberRefs, fiberRef: FiberRef<A>): Maybe<A>;
+/**
+ * @tsplus fluent fncts.io.FiberRefs getOrDefault
+ * @tsplus location "@fncts/io/FiberRefs/api"
+ */
+export declare function getOrDefault<A>(self: FiberRefs, fiberRef: FiberRef<A>): A;
+/**
+ * @tsplus fluent fncts.io.FiberRefs updateAs
+ * @tsplus location "@fncts/io/FiberRefs/api"
+ */
+export declare function updateAs<A>(self: FiberRefs, fiberId: FiberId.Runtime, fiberRef: FiberRef<A>, value: A): FiberRefs;
+/**
+ * @tsplus fluent fncts.io.FiberRefs delete
+ * @tsplus location "@fncts/io/FiberRefs/api"
+ */
+export declare function remove(self: FiberRefs, fiberRef: FiberRef<any>): FiberRefs;
+/**
+ * @tsplus getter fncts.io.FiberRefs unFiberRefs
+ * @tsplus macro identity
+ * @tsplus location "@fncts/io/FiberRefs/api"
+ */
+export declare function unFiberRefs(self: FiberRefs): HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>;

package/FiberRefs/definition.d.ts

@@ -1,15 +1,22 @@
+import { HKT } from "@fncts/typelevel/HKT";
+import { Newtype, NewtypeIso } from "@fncts/base/data/Newtype";
 import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
 import { FiberRef } from "@fncts/io/FiberRef/definition";
 import { Cons } from "@fncts/base/collection/immutable/List/definition";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
-export declare const FiberRefsTypeId: unique symbol;
-export type FiberRefsTypeId = typeof FiberRefsTypeId;
+export interface FiberRefsN extends HKT {
+    readonly type: FiberRefs;
+}
 /**
  * @tsplus type fncts.io.FiberRefs
- * @tsplus companion fncts.io.FiberRefsOps
  */
-export declare class FiberRefs {
-    readonly fiberRefLocals: HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>;
-    readonly _typeId: FiberRefsTypeId;
-    constructor(fiberRefLocals: HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>);
+export interface FiberRefs extends Newtype<{
+    readonly FiberRefs: unique symbol;
+}, HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>> {
+}
+/**
+ * @tsplus type fncts.io.FiberRefsOps
+ */
+export interface FiberRefsOps extends NewtypeIso<FiberRefsN> {
 }
+export declare const FiberRefs: FiberRefsOps;

package/FiberRefs/join.d.ts

@@ -1,9 +1,9 @@
-import { FiberRefs } from "@fncts/io/FiberRefs";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
+import { FiberRefs } from "@fncts/io/FiberRefs";
 import { Cons, List } from "@fncts/base/collection/immutable/List/definition";
 import { FiberRef } from "@fncts/io/FiberRef/definition";
 /**
- * @tsplus fluent fncts.io.FiberRefs join
+ * @tsplus pipeable fncts.io.FiberRefs join
  * @tsplus location "@fncts/io/FiberRefs/join"
  */
-export declare function join(self: FiberRefs, fiberId: FiberId.Runtime, that: FiberRefs): FiberRefs;
+export declare function join(fiberId: FiberId.Runtime, that: FiberRefs): (self: FiberRefs) => FiberRefs;

package/FiberScope/constructors.d.ts

@@ -1,5 +1,5 @@
 import { FiberScope } from "@fncts/io/FiberScope";
-import type { FiberContext } from "@fncts/io/Fiber/FiberContext";
+import type { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
 import { Global } from "@fncts/io/FiberScope/definition";
 /**
  * The global scope. Anything forked onto the global scope is not supervised,
@@ -13,4 +13,4 @@ export declare const global: Global;
  * @tsplus static fncts.io.FiberScopeOps unsafeMake
  * @tsplus location "@fncts/io/FiberScope/constructors"
  */
-export declare function unsafeMake(fiber: FiberContext<any, any>): FiberScope;
+export declare function unsafeMake(fiber: FiberRuntime<any, any>): FiberScope;

package/FiberScope/definition.d.ts

@@ -1,5 +1,8 @@
 import { FiberId } from "@fncts/base/data/FiberId/definition";
-import type { FiberContext } from "@fncts/io/Fiber/FiberContext";
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
+import type { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
+import type { RuntimeFlags } from "@fncts/io/RuntimeFlags";
 /**
  * A `Scope` represents the scope of a fiber lifetime. The scope of a fiber can
  * be retrieved using IO.descriptor, and when forking fibers, you can
@@ -10,15 +13,15 @@ import type { FiberContext } from "@fncts/io/Fiber/FiberContext";
  */
 export declare abstract class FiberScope {
     abstract fiberId: FiberId;
-    abstract unsafeAdd(child: FiberContext<unknown, unknown>): boolean;
+    abstract unsafeAdd(currentFiber: FiberRuntime<any, any>, runtimeFlags: RuntimeFlags, child: FiberRuntime<any, any>): void;
 }
 export declare class Global extends FiberScope {
     get fiberId(): FiberId;
-    unsafeAdd(_child: FiberContext<any, any>): boolean;
+    unsafeAdd(_currentFiber: FiberRuntime<any, any>, runtimeFlags: RuntimeFlags, child: FiberRuntime<any, any>): void;
 }
 export declare class Local extends FiberScope {
     readonly fiberId: FiberId;
     private parentRef;
-    constructor(fiberId: FiberId, parentRef: WeakRef<FiberContext<unknown, unknown>>);
-    unsafeAdd(child: FiberContext<unknown, unknown>): boolean;
+    constructor(fiberId: FiberId, parentRef: WeakRef<FiberRuntime<unknown, unknown>>);
+    unsafeAdd(currentFiber: FiberRuntime<any, any>, _runtimeFlags: RuntimeFlags, child: FiberRuntime<any, any>): void;
 }

package/FiberStatus/constructors.d.ts

@@ -1,22 +1,18 @@
 import { FiberId } from "@fncts/base/data/FiberId/definition";
+import type { RuntimeFlags } from "../RuntimeFlags.js";
 import type { FiberStatus } from "./definition.js";
 /**
  * @tsplus static fncts.FiberStatusOps done
  * @tsplus location "@fncts/io/FiberStatus/constructors"
  */
 export declare const done: FiberStatus;
-/**
- * @tsplus static fncts.FiberStatusOps finishing
- * @tsplus location "@fncts/io/FiberStatus/constructors"
- */
-export declare function finishing(interrupting: boolean): FiberStatus;
 /**
  * @tsplus static fncts.FiberStatusOps running
  * @tsplus location "@fncts/io/FiberStatus/constructors"
  */
-export declare function running(interrupting: boolean): FiberStatus;
+export declare function running(runtimeFlags: RuntimeFlags, trace?: string): FiberStatus;
 /**
  * @tsplus static fncts.FiberStatusOps suspended
  * @tsplus location "@fncts/io/FiberStatus/constructors"
  */
-export declare function suspended(interrupting: boolean, interruptible: boolean, epoch: number, blockingOn: FiberId, asyncTrace?: string): FiberStatus;
+export declare function suspended(runtimeFlags: RuntimeFlags, blockingOn: FiberId, trace?: string): FiberStatus;

package/FiberStatus/definition.d.ts

@@ -1,56 +1,44 @@
+import { Trace } from "@fncts/base/data/Trace/definition";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
+import type { RuntimeFlags } from "../RuntimeFlags.js";
 export declare const enum FiberStatusTag {
-    Done = "Done",
-    Finishing = "Finishing",
-    Running = "Running",
-    Suspended = "Suspended"
+    Done = 0,
+    Running = 1,
+    Suspended = 2
 }
 /**
  * @tsplus companion fncts.FiberStatus.DoneOps
  */
 export declare class Done {
     readonly _tag = FiberStatusTag.Done;
-    get isInterrupting(): boolean;
-    withInterrupting(): FiberStatus;
-}
-/**
- * @tsplus companion fncts.FiberStatus.FinishingOps
- */
-export declare class Finishing {
-    readonly interrupting: boolean;
-    readonly _tag = FiberStatusTag.Finishing;
-    constructor(interrupting: boolean);
-    get isInterrupting(): boolean;
-    withInterrupting(newInterrupting: boolean): FiberStatus;
+    readonly trace: import("@fncts/base/data/Trace.js").Trace;
+    readonly isFinished = true;
 }
 /**
  * @tsplus companion fncts.FiberStatus.RunningOps
  */
 export declare class Running {
-    readonly interrupting: boolean;
+    readonly runtimeFlags: RuntimeFlags;
+    readonly trace?: string | undefined;
     readonly _tag = FiberStatusTag.Running;
-    constructor(interrupting: boolean);
-    get isInterrupting(): boolean;
-    withInterrupting(newInterrupting: boolean): FiberStatus;
+    constructor(runtimeFlags: RuntimeFlags, trace?: string | undefined);
+    readonly isFinished = false;
 }
 /**
  * @tsplus companion fncts.FiberStatus.SuspendedOps
  */
 export declare class Suspended {
-    readonly interrupting: boolean;
-    readonly interruptible: boolean;
-    readonly epoch: number;
+    readonly runtimeFlags: RuntimeFlags;
     readonly blockingOn: FiberId;
-    readonly asyncTrace?: string | undefined;
+    readonly trace?: string | undefined;
     readonly _tag = FiberStatusTag.Suspended;
-    constructor(interrupting: boolean, interruptible: boolean, epoch: number, blockingOn: FiberId, asyncTrace?: string | undefined);
-    get isInterrupting(): boolean;
-    withInterrupting(newInterrupting: boolean): Suspended;
+    constructor(runtimeFlags: RuntimeFlags, blockingOn: FiberId, trace?: string | undefined);
+    readonly isFinished = false;
 }
 /**
  * @tsplus type fncts.FiberStatus
  */
-export type FiberStatus = Done | Finishing | Running | Suspended;
+export type FiberStatus = Done | Running | Suspended;
 /**
  * @tsplus type fncts.FiberStatusOps
  */

package/Future/api.d.ts

@@ -1,5 +1,5 @@
-import { Future } from "@fncts/io/Future";
 import { Exit } from "@fncts/base/data/Exit/definition";
+import { Future } from "@fncts/io/Future";
 import { UIO, IO, FIO } from "@fncts/io/IO/definition";
 import { Cause } from "@fncts/base/data/Cause/definition";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
@@ -7,34 +7,34 @@ import { Maybe } from "@fncts/base/data/Maybe/definition";
 /**
  * Exits the future with the specified exit, which will be propagated to all
  * fibers waiting on the value of the future.
- * @tsplus fluent fncts.io.Future done
+ * @tsplus pipeable fncts.io.Future done
  * @tsplus location "@fncts/io/Future/api"
  */
-export declare function done_<E, A>(future: Future<E, A>, exit: Exit<E, A>, __tsplusTrace?: string): UIO<boolean>;
+export declare function done<E, A>(exit: Exit<E, A>, __tsplusTrace?: string): (future: Future<E, A>) => import("@fncts/io/IO").UIO<boolean>;
 /**
  * Fails the future with the specified error, which will be propagated to all
  * fibers waiting on the value of the future.
- * @tsplus fluent fncts.io.Future fail
+ * @tsplus pipeable fncts.io.Future fail
  * @tsplus location "@fncts/io/Future/api"
  */
-export declare function fail_<E, A>(future: Future<E, A>, e: E, __tsplusTrace?: string): UIO<boolean>;
+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>;
 /**
  * Halts the future with the specified cause, which will be propagated to all
  * fibers waiting on the value of the future.
- * @tsplus fluent fncts.io.Future failCause
+ * @tsplus pipeable fncts.io.Future failCause
  * @tsplus location "@fncts/io/Future/api"
  */
-export declare function failCause_<E, A>(future: Future<E, A>, cause: Cause<E>, __tsplusTrace?: string): UIO<boolean>;
+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>;
 /**
  * Completes the future with the result of the specified effect. If the
  * future has already been completed, the method will produce false.
  *
  * Note that `Future.completeWith` will be much faster, so consider using
  * that if you do not need to memoize the result of the specified effect.
- * @tsplus fluent fncts.io.Future fulfill
+ * @tsplus pipeable fncts.io.Future fulfill
  * @tsplus location "@fncts/io/Future/api"
  */
-export declare function fulfill_<R, E, A>(future: Future<E, A>, io: IO<R, E, A>, __tsplusTrace?: string): IO<R, never, boolean>;
+export declare function fulfill<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): (future: Future<E, A>) => IO<R, never, boolean>;
 /**
  * Completes the future with the specified effect. If the future has
  * already been completed, the method will produce false.
@@ -47,17 +47,17 @@ export declare function fulfill_<R, E, A>(future: Future<E, A>, io: IO<R, E, A>,
  * future can be completed with exactly one effect. For a version that
  * completes the future with the result of an IO see
  * `Future.complete`.
- * @tsplus fluent fncts.io.Future fulfillWith
+ * @tsplus pipeable fncts.io.Future fulfillWith
  * @tsplus location "@fncts/io/Future/api"
  */
-export declare function fulfillWith_<E, A>(future: Future<E, A>, io: FIO<E, A>, __tsplusTrace?: string): UIO<boolean>;
+export declare function fulfillWith<E, A>(io: FIO<E, A>, __tsplusTrace?: string): (future: Future<E, A>) => import("@fncts/io/IO").UIO<boolean>;
 /**
  * Kills the future with the specified error, which will be propagated to all
  * fibers waiting on the value of the future.
- * @tsplus fluent fncts.io.Future halt
+ * @tsplus pipeable fncts.io.Future halt
  * @tsplus location "@fncts/io/Future/api"
  */
-export declare function halt_<E, A>(future: Future<E, A>, defect: unknown, __tsplusTrace?: string): UIO<boolean>;
+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>;
 /**
  * Completes the future with interruption. This will interrupt all fibers
  * waiting on the value of the future as by the fiber calling this method.
@@ -68,10 +68,10 @@ export declare function interrupt<E, A>(future: Future<E, A>, __tsplusTrace?: st
 /**
  * Completes the future with interruption. This will interrupt all fibers
  * waiting on the value of the future as by the specified fiber.
- * @tsplus fluent fncts.io.Future interruptAs
+ * @tsplus pipeable fncts.io.Future interruptAs
  * @tsplus location "@fncts/io/Future/api"
  */
-export declare function interruptAs_<E, A>(future: Future<E, A>, id: FiberId, __tsplusTrace?: string): UIO<boolean>;
+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>;
 /**
  * Checks for completion of this Future. Produces true if this future has
  * already been completed with a value or an error and false otherwise.
@@ -88,22 +88,22 @@ export declare function isDone<E, A>(future: Future<E, A>, __tsplusTrace?: strin
 export declare function poll<E, A>(future: Future<E, A>, __tsplusTrace?: string): UIO<Maybe<FIO<E, A>>>;
 /**
  * Completes the future with the specified value.
- * @tsplus fluent fncts.io.Future succeed
+ * @tsplus pipeable fncts.io.Future succeed
  * @tsplus location "@fncts/io/Future/api"
  */
-export declare function succeed_<A, E>(future: Future<E, A>, a: A, __tsplusTrace?: string): import("@fncts/io/IO").UIO<boolean>;
+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>;
 /**
  * Retrieves the value of the future, suspending the fiber running the action
  * until the result is available.
- * @tsplus fluent fncts.io.Future unsafeDone
+ * @tsplus pipeable fncts.io.Future unsafeDone
  * @tsplus location "@fncts/io/Future/api"
  */
-export declare function unsafeDone_<E, A>(future: Future<E, A>, io: FIO<E, A>, __tsplusTrace?: string): void;
+export declare function unsafeDone<E, A>(io: FIO<E, A>, __tsplusTrace?: string): (future: Future<E, A>) => void;
 /**
- * @tsplus fluent fncts.io.Future unsafeSucceed
+ * @tsplus pipeable fncts.io.Future unsafeSucceed
  * @tsplus location "@fncts/io/Future/api"
  */
-export declare function unsafeSucceed_<A>(future: Future<never, A>, a: A, __tsplusTrace?: string): void;
+export declare function unsafeSucceed<A>(a: A, __tsplusTrace?: string): (future: Future<never, A>) => void;
 /**
  * Retrieves the value of the future, suspending the fiber running the action
  * until the result is available.

package/Hub/api.d.ts

@@ -1,7 +1,9 @@
 import { PHub, Hub } from "@fncts/io/Hub/definition";
 import { UIO, IO } from "@fncts/io/IO/definition";
-import { Conc } from "@fncts/base/collection/immutable/Conc";
 import { Scope } from "@fncts/io/Scope/definition";
+import { unsafeCoerce } from "@fncts/base/data/function/api";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import type { PDequeue, PEnqueue } from "@fncts/io/Queue";
 /**
  * Waits for the hub to be shut down.
  * @tsplus getter fncts.io.Hub awaitShutdown
@@ -17,50 +19,50 @@ export declare function capacity<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB
 /**
  * Transforms messages published to the hub using the specified effectual
  * function.
- * @tsplus fluent fncts.io.Hub contramapIO
+ * @tsplus pipeable fncts.io.Hub contramapIO
  * @tsplus location "@fncts/io/Hub/api"
  */
-export declare function contramapIO_<RA, RB, RC, EA, EB, EC, A, B, C>(self: PHub<RA, RB, EA, EB, A, B>, f: (c: C) => IO<RC, EC, A>, __tsplusTrace?: string): PHub<RC | RA, RB, EA | EC, 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: 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>;
 /**
  * Transforms messages published to and taken from the hub using the
  * specified functions.
- * @tsplus fluent fncts.io.Hub dimap
+ * @tsplus pipeable fncts.io.Hub dimap
  * @tsplus location "@fncts/io/Hub/api"
  */
-export declare function dimap_<RA, RB, EA, EB, A, B, C, D>(self: PHub<RA, RB, EA, EB, A, B>, f: (c: C) => A, g: (b: B) => D, __tsplusTrace?: string): 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: import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, B>) => import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, C, D>;
 /**
  * Transforms messages published to and taken from the hub using the
  * specified effectual functions.
- * @tsplus fluent fncts.io.Hub dimapIO
+ * @tsplus pipeable fncts.io.Hub dimapIO
  * @tsplus location "@fncts/io/Hub/api"
  */
-export declare function dimapIO_<RA, RB, RC, RD, EA, EB, EC, ED, A, B, C, D>(source: PHub<RA, RB, EA, EB, A, B>, f: (c: C) => IO<RC, EC, A>, g: (b: B) => IO<RD, ED, D>, __tsplusTrace?: string): PHub<RC | RA, RD | RB, EA | EC, EB | ED, 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: 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>;
 /**
  * Filters messages published to the hub using the specified effectual
  * function.
- * @tsplus fluent fncts.io.Hub filterInputIO
+ * @tsplus pipeable fncts.io.Hub filterInputIO
  * @tsplus location "@fncts/io/Hub/api"
  */
-export declare function filterInputIO_<RA, RA1, RB, EA, EA1, EB, A, B>(source: PHub<RA, RB, EA, EB, A, B>, f: (a: A) => IO<RA1, EA1, boolean>, __tsplusTrace?: string): PHub<RA | RA1, RB, EA | EA1, 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: 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>;
 /**
  * Filters messages published to the hub using the specified function.
- * @tsplus fluent fncts.io.Hub filterInput
+ * @tsplus pipeable fncts.io.Hub filterInput
  * @tsplus location "@fncts/io/Hub/api"
  */
-export declare function filterInput_<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, f: (a: A) => boolean, __tsplusTrace?: string): 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: import("@fncts/io/Hub/definition").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 fluent fncts.io.Hub filterOutputIO
+ * @tsplus pipeable fncts.io.Hub filterOutputIO
  * @tsplus location "@fncts/io/Hub/api"
  */
-export declare function filterOutputIO_<RA, RB, RB1, EA, EB, EB1, A, B>(source: PHub<RA, RB, EA, EB, A, B>, f: (a: B) => IO<RB1, EB1, boolean>, __tsplusTrace?: string): PHub<RA, RB | RB1, EA, EB | EB1, A, B>;
+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>;
 /**
  * Filters messages taken from the hub using the specified function.
- * @tsplus fluent fncts.io.Hub filterOutput
+ * @tsplus pipeable fncts.io.Hub filterOutput
  * @tsplus location "@fncts/io/Hub/api"
  */
-export declare function filterOutput_<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, f: (b: B) => boolean, __tsplusTrace?: string): PHub<RA, RB, EA, EB, A, B>;
+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>;
 /**
  * Checks whether the hub is shut down.
  * @tsplus getter fncts.io.Hub isShutdown
@@ -103,31 +105,31 @@ export declare function makeSliding<A>(requestedCapacity: number, __tsplusTrace?
 export declare function makeUnbounded<A>(__tsplusTrace?: string): UIO<Hub<A>>;
 /**
  * Transforms messages taken from the hub using the specified function.
- * @tsplus fluent fncts.io.Hub map
+ * @tsplus pipeable fncts.io.Hub map
  * @tsplus location "@fncts/io/Hub/api"
  */
-export declare function map_<RA, RB, EA, EB, A, B, C>(self: PHub<RA, RB, EA, EB, A, B>, f: (b: B) => C, __tsplusTrace?: string): 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: import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, B>) => import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, C>;
 /**
  * Transforms messages taken from the hub using the specified effectual
  * function.
- * @tsplus fluent fncts.io.Hub mapIO
+ * @tsplus pipeable fncts.io.Hub mapIO
  * @tsplus location "@fncts/io/Hub/api"
  */
-export declare function mapIO_<RA, RB, RC, EA, EB, EC, A, B, C>(self: PHub<RA, RB, EA, EB, A, B>, f: (b: B) => IO<RC, EC, C>, __tsplusTrace?: string): PHub<RA, RC | RB, EA, EB | EC, 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: 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>;
 /**
  * Publishes a message to the hub, returning whether the message was
  * published to the hub.
- * @tsplus fluent fncts.io.Hub publish
+ * @tsplus pipeable fncts.io.Hub publish
  * @tsplus location "@fncts/io/Hub/api"
  */
-export declare function publish_<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, a: A, __tsplusTrace?: string): IO<RA, EA, boolean>;
+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>;
 /**
  * Publishes all of the specified messages to the hub, returning whether
  * they were published to the hub.
- * @tsplus fluent fncts.io.Hub publishAll
+ * @tsplus pipeable fncts.io.Hub publishAll
  * @tsplus location "@fncts/io/Hub/api"
  */
-export declare function publishAll_<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, as: Iterable<A>, __tsplusTrace?: string): IO<RA, EA, boolean>;
+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>;
 /**
  * Shuts down the hub.
  * @tsplus getter fncts.io.Hub shutdown
@@ -141,7 +143,7 @@ export declare function shutdown<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB
  * @tsplus getter fncts.io.Hub subscribe
  * @tsplus location "@fncts/io/Hub/api"
  */
-export declare function subscribe<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): IO<Scope, never, Hub.Dequeue<RB, EB, B>>;
+export declare function subscribe<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): IO<Scope, never, PDequeue<RA, RB, EA, EB, A, B>>;
 /**
  * The current number of messages in the hub.
  * @tsplus getter fncts.io.Hub size
@@ -153,7 +155,7 @@ export declare function size<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A,
  * @tsplus getter fncts.io.Hub toQueue
  * @tsplus location "@fncts/io/Hub/api"
  */
-export declare function toQueue<RA, RB, EA, EB, A, B>(source: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): Hub.Enqueue<RA, EA, A>;
+export declare function toQueue<RA, RB, EA, EB, A, B>(source: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): PEnqueue<RA, RB, EA, EB, A, B>;
 /**
  * Creates a bounded hub with the back pressure strategy. The hub will retain
  * messages until they have been taken by all subscribers, applying back

package/Hub/definition.d.ts

@@ -1,6 +1,8 @@
-import { PQueue } from "@fncts/io/Queue/definition";
-import { UIO, IO } from "@fncts/io/IO/definition";
+import { UIO } from "@fncts/io/IO/definition";
 import { Scope } from "@fncts/io/Scope/definition";
+import type { IO } from "@fncts/io/IO";
+import type { PDequeue, PEnqueue, PEnqueueInternal } from "@fncts/io/Queue";
+import { EnqueueTypeId, QueueTypeId } from "@fncts/io/Queue";
 export declare const HubTypeId: unique symbol;
 export type HubTypeId = typeof HubTypeId;
 /**
@@ -13,7 +15,7 @@ export type HubTypeId = typeof HubTypeId;
  *
  * @tsplus type fncts.io.Hub
  */
-export interface PHub<RA, RB, EA, EB, A, B> {
+export interface PHub<RA, RB, EA, EB, A, B> extends PEnqueue<RA, RB, EA, EB, A, B> {
     readonly _typeId: HubTypeId;
     readonly _RA: () => RA;
     readonly _RB: () => RB;
@@ -33,11 +35,11 @@ export interface Hub<A> extends PHub<never, never, never, never, A, A> {
 export interface HubOps {
 }
 export declare const Hub: HubOps;
-export declare namespace Hub {
-    type Dequeue<R, E, A> = PQueue<never, R, unknown, E, never, A>;
-    type Enqueue<R, E, A> = PQueue<R, never, E, unknown, A, never>;
-}
-export declare abstract class PHubInternal<RA, RB, EA, EB, A, B> implements PHub<RA, RB, EA, EB, A, B> {
+export declare namespace PHub { }
+export declare namespace Hub { }
+export declare abstract class PHubInternal<RA, RB, EA, EB, A, B> implements PHub<RA, RB, EA, EB, A, B>, PEnqueueInternal<RA, RB, EA, EB, A, B> {
+    readonly [QueueTypeId]: QueueTypeId;
+    readonly [EnqueueTypeId]: EnqueueTypeId;
     _typeId: HubTypeId;
     readonly _RA: () => RA;
     readonly _RB: () => RB;
@@ -80,7 +82,9 @@ export declare abstract class PHubInternal<RA, RB, EA, EB, A, B> implements PHub
      * can be evaluated multiple times within the scope of the managed to take a
      * message from the hub each time.
      */
-    abstract subscribe: IO<Scope, never, Hub.Dequeue<RB, EB, B>>;
+    abstract subscribe: IO<Scope, never, PDequeue<RA, RB, EA, EB, A, B>>;
+    offer(a: A, __tsplusTrace?: string): IO<RA, EA, boolean>;
+    offerAll(as: Iterable<A>, __tsplusTrace?: string): IO<RA, EA, boolean>;
 }
 /**
  * @tsplus macro remove

package/IO/api/acquireRelease.d.ts

@@ -6,4 +6,4 @@ import { Scope } from "@fncts/io/Scope/definition";
  * @tsplus fluent fncts.io.IO acquireRelease
  * @tsplus location "@fncts/io/IO/api/acquireRelease"
  */
-export declare function acquireRelease<R, E, A, R1>(acquire: Lazy<IO<R, E, A>>, release: (a: A) => IO<R1, never, any>, __tsplusTrace?: string): IO<R | R1 | Scope, E, A>;
+export declare function acquireRelease<R, E, A, R1>(acquire: Lazy<IO<R, E, A>>, release: (a: A) => IO<R1, never, any>, __tsplusTrace?: string): IO<Scope | R | R1, E, A>;

package/IO/api/acquireReleaseExit.d.ts

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

package/IO/api/asyncInterrupt.d.ts

@@ -0,0 +1,39 @@
+import { IO, URIO, UIO } from "@fncts/io/IO/definition";
+import { Either } from "@fncts/base/data/Either/definition";
+import { FiberId } from "@fncts/base/data/FiberId/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+/**
+ * Imports an asynchronous side-effect into an IO. The side-effect
+ * has the option of returning the value synchronously, which is useful in
+ * cases where it cannot be determined if the effect is synchronous or
+ * asynchronous until the side-effect is actually executed. The effect also
+ * has the option of returning a canceler, which will be used by the runtime
+ * to cancel the asynchronous effect if the fiber executing the effect is
+ * interrupted.
+ *
+ * If the register function returns a value synchronously, then the callback
+ * function must not be called. Otherwise the callback function must be called
+ * at most once.
+ *
+ * The list of fibers, that may complete the async callback, is used to
+ * provide better diagnostics.
+ * @tsplus static fncts.io.IOOps asyncInterrupt
+ * @tsplus location "@fncts/io/IO/api/asyncInterrupt"
+ */
+export declare function asyncInterrupt<R, E, A>(register: (cb: (resolve: IO<R, E, A>) => void) => Either<URIO<R, any>, IO<R, E, A>>, blockingOn?: FiberId, __tsplusTrace?: string): IO<R, E, A>;
+/**
+ * Imports an asynchronous effect into a pure `IO`, possibly returning the value synchronously.
+ *
+ * If the register function returns a value synchronously, then the callback
+ * function must not be called. Otherwise the callback function must be called at most once.
+ * @tsplus static fncts.io.IOOps asyncMaybe
+ * @tsplus location "@fncts/io/IO/api/asyncInterrupt"
+ */
+export declare function asyncMaybe<R, E, A>(register: (resolve: (_: IO<R, E, A>) => void) => Maybe<IO<R, E, A>>, blockingOn?: FiberId, __tsplusTrace?: string): IO<R, E, A>;
+/**
+ * Returns a `IO` that will never produce anything. The moral equivalent of
+ * `while(true) {}`, only without the wasted CPU cycles.
+ * @tsplus static fncts.io.IOOps never
+ * @tsplus location "@fncts/io/IO/api/asyncInterrupt"
+ */
+export declare const never: UIO<never>;

package/IO/api/bracket.d.ts

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

package/IO/api/bracketExit.d.ts

@@ -11,4 +11,4 @@ import { Exit } from "@fncts/base/data/Exit/definition";
  * @tsplus static fncts.io.IOOps bracketExit
  * @tsplus location "@fncts/io/IO/api/bracketExit"
  */
-export declare function bracketExit_<R, E, A, E1, R1, A1, R2, E2>(acquire: Lazy<IO<R, E, A>>, use: (a: A) => IO<R1, E1, A1>, release: (a: A, e: Exit<E1, A1>) => IO<R2, E2, any>, __tsplusTrace?: string): IO<R | R1 | R2, E | E1 | E2, A1>;
+export declare function bracketExit<R, E, A, E1, R1, A1, R2, E2>(acquire: Lazy<IO<R, E, A>>, use: (a: A) => IO<R1, E1, A1>, release: (a: A, e: Exit<E1, A1>) => IO<R2, E2, any>, __tsplusTrace?: string): IO<R | R1 | R2, E | E1 | E2, A1>;

package/IO/api/concurrency.d.ts

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