@fncts/io 0.0.21 → 0.0.22

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/Hub/api.d.ts

@@ -0,0 +1,192 @@
+import { PHub, Hub } from "@fncts/io/Hub/definition";
+import { UIO, IO } from "@fncts/io/IO/definition";
+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
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function awaitShutdown<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): UIO<void>;
+/**
+ * The maximum capacity of the hub.
+ * @tsplus getter fncts.io.Hub capacity
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function capacity<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): number;
+/**
+ * Transforms messages published to the hub using the specified effectual
+ * function.
+ * @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>;
+/**
+ * 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>;
+/**
+ * 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>;
+/**
+ * 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>;
+/**
+ * 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>;
+/**
+ * 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>;
+/**
+ * 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>;
+/**
+ * Checks whether the hub is shut down.
+ * @tsplus getter fncts.io.Hub isShutdown
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function isShutdown<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): UIO<boolean>;
+/**
+ * Creates a bounded hub with the back pressure strategy. The hub will retain
+ * messages until they have been taken by all subscribers, applying back
+ * pressure to publishers if the hub is at capacity.
+ *
+ * For best performance use capacities that are powers of two.
+ * @tsplus static fncts.io.HubOps makeBounded
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function makeBounded<A>(requestedCapacity: number, __tsplusTrace?: string): UIO<Hub<A>>;
+/**
+ * Creates a bounded hub with the dropping strategy. The hub will drop new
+ * messages if the hub is at capacity.
+ *
+ * For best performance use capacities that are powers of two.
+ * @tsplus static fncts.io.HubOps makeDropping
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function makeDropping<A>(requestedCapacity: number, __tsplusTrace?: string): UIO<Hub<A>>;
+/**
+ * Creates a bounded hub with the sliding strategy. The hub will add new
+ * messages and drop old messages if the hub is at capacity.
+ *
+ * For best performance use capacities that are powers of two.
+ * @tsplus static fncts.io.HubOps makeSliding
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function makeSliding<A>(requestedCapacity: number, __tsplusTrace?: string): UIO<Hub<A>>;
+/**
+ * Creates an unbounded hub.
+ * @tsplus static fncts.io.HubOps makeUnbounded
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function makeUnbounded<A>(__tsplusTrace?: string): UIO<Hub<A>>;
+/**
+ * Transforms messages taken from the hub using the specified function.
+ * @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>;
+/**
+ * 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>;
+/**
+ * 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>;
+/**
+ * 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>;
+/**
+ * Shuts down the hub.
+ * @tsplus getter fncts.io.Hub shutdown
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function shutdown<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): UIO<void>;
+/**
+ * Subscribes to receive messages from the hub. The resulting subscription
+ * can be evaluated multiple times within the scope of the managed to take a
+ * message from the hub each time.
+ * @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, PDequeue<RA, RB, EA, EB, A, B>>;
+/**
+ * The current number of messages in the hub.
+ * @tsplus getter fncts.io.Hub size
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function size<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): UIO<number>;
+/**
+ * Views the hub as a queue that can only be written to.
+ * @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): 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
+ * pressure to publishers if the hub is at capacity.
+ *
+ * For best performance use capacities that are powers of two.
+ * @tsplus static fncts.io.HubOps unsafeMakeBounded
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function unsafeMakeBounded<A>(requestedCapacity: number): Hub<A>;
+/**
+ * Creates a bounded hub with the dropping strategy. The hub will drop new
+ * messages if the hub is at capacity.
+ *
+ * For best performance use capacities that are powers of two.
+ * @tsplus static fncts.io.HubOps unsafeMakeDropping
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function unsafeMakeDropping<A>(requestedCapacity: number): Hub<A>;
+/**
+ * Creates a bounded hub with the sliding strategy. The hub will add new
+ * messages and drop old messages if the hub is at capacity.
+ *
+ * For best performance use capacities that are powers of two.
+ * @tsplus static fncts.io.HubOps unsafeMakeSliding
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function unsafeMakeSliding<A>(requestedCapacity: number): Hub<A>;
+/**
+ * Creates an unbounded hub.
+ * @tsplus static fncts.io.HubOps unsafeMakeUnbounded
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function unsafeMakeUnbounded<A>(): Hub<A>;

package/Hub/definition.d.ts

@@ -1,44 +1,92 @@
-import { Future } from "@fncts/io/Future";
+import { UIO } from "@fncts/io/IO/definition";
 import { Scope } from "@fncts/io/Scope/definition";
-import { IO } from "@fncts/io/IO/definition";
-import { Conc } from "@fncts/base/collection/immutable/Conc";
-import { Exit } from "@fncts/base/data/Exit/definition";
-import type { HashedPair } from "../internal/HashedPair.js";
-import type { MutableQueue } from "../internal/MutableQueue.js";
-import type { UIO } from "../IO.js";
-import type { Dequeue, Enqueue } from "../Queue/definition.js";
-import type { Strategy } from "./internal.js";
-import type { HashSet } from "@fncts/base/collection/mutable/HashSet";
-import type { AtomicBoolean } from "@fncts/base/internal/AtomicBoolean";
-import type { Hub as HubInternal } from "@fncts/io/internal/Hub";
-import { QueueTypeId } from "../Queue/definition.js";
+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;
 /**
+ * A `Hub<RA, RB, EA, EB, A, B>` is an asynchronous message hub. Publishers
+ * can publish messages of type `A` to the hub and subscribers can subscribe to
+ * take messages of type `B` from the hub. Publishing messages can require an
+ * environment of type `RA` and fail with an error of type `EA`. Taking
+ * messages can require an environment of type `RB` and fail with an error of
+ * type `EB`.
+ *
  * @tsplus type fncts.io.Hub
- * @tsplus companion fncts.io.HubOps
  */
-export declare class Hub<A> implements Enqueue<A> {
-    readonly hub: HubInternal<A>;
-    readonly subscribers: HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>;
-    readonly scope: Scope.Closeable;
-    readonly shutdownHook: Future<never, void>;
-    readonly shutdownFlag: AtomicBoolean;
-    readonly strategy: Strategy<A>;
+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;
+    readonly _EA: () => EA;
+    readonly _EB: () => EB;
+    readonly _A: (_: A) => void;
+    readonly _B: () => B;
+}
+/**
+ * @tsplus type fncts.io.Hub
+ */
+export interface Hub<A> extends PHub<never, never, never, never, A, A> {
+}
+/**
+ * @tsplus type fncts.io.HubOps
+ */
+export interface HubOps {
+}
+export declare const Hub: HubOps;
+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 [HubTypeId]: HubTypeId;
-    _In: (_: A) => void;
-    constructor(hub: HubInternal<A>, subscribers: HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>, scope: Scope.Closeable, shutdownHook: Future<never, void>, shutdownFlag: AtomicBoolean, strategy: Strategy<A>);
-    awaitShutdown: UIO<void>;
-    get capacity(): number;
-    isShutdown: UIO<boolean>;
-    publish(this: this, a: A, __tsplusTrace?: string): UIO<boolean>;
-    publishAll(this: this, as: Iterable<A>, __tsplusTrace?: string): UIO<boolean>;
-    shutdown: UIO<void>;
-    size: UIO<number>;
-    subscribe: IO<Scope, never, Dequeue<A>>;
-    isEmpty: UIO<boolean>;
-    isFull: UIO<boolean>;
-    offer(this: this, a: A, __tsplusTrace?: string | undefined): UIO<boolean>;
-    offerAll(this: this, as: Iterable<A>, __tsplusTrace?: string | undefined): UIO<boolean>;
+    readonly [EnqueueTypeId]: EnqueueTypeId;
+    _typeId: HubTypeId;
+    readonly _RA: () => RA;
+    readonly _RB: () => RB;
+    readonly _EA: () => EA;
+    readonly _EB: () => EB;
+    readonly _A: (_: A) => void;
+    readonly _B: () => B;
+    /**
+     * Waits for the hub to be shut down.
+     */
+    abstract awaitShutdown: UIO<void>;
+    /**
+     * The maximum capacity of the hub.
+     */
+    abstract capacity: number;
+    /**
+     * Checks whether the hub is shut down.
+     */
+    abstract isShutdown: UIO<boolean>;
+    /**
+     * Publishes a message to the hub, returning whether the message was
+     * published to the hub.
+     */
+    abstract publish(a: A): IO<RA, EA, boolean>;
+    /**
+     * Publishes all of the specified messages to the hub, returning whether
+     * they were published to the hub.
+     */
+    abstract publishAll(as: Iterable<A>): IO<RA, EA, boolean>;
+    /**
+     * Shuts down the hub.
+     */
+    abstract shutdown: UIO<void>;
+    /**
+     * The current number of messages in the hub.
+     */
+    abstract size: UIO<number>;
+    /**
+     * Subscribes to receive messages from the hub. The resulting subscription
+     * 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, 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
+ */
+export declare function concrete<RA, RB, EA, EB, A, B>(_: PHub<RA, RB, EA, EB, A, B>): asserts _ is PHubInternal<RA, RB, EA, EB, A, B>;

package/Hub/internal.d.ts

@@ -1,9 +1,11 @@
 import { Future } from "@fncts/io/Future";
 import { UIO, IO } from "@fncts/io/IO/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
-import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Queue } from "@fncts/io/Queue/definition";
+import { Scope } from "@fncts/io/Scope/definition";
+import { Exit } from "@fncts/base/data/Exit/definition";
+import { Hub } from "@fncts/io/Hub/definition";
 import type { Hub as HubInternal } from "@fncts/io/internal/Hub";
-import type { Dequeue } from "@fncts/io/Queue";
 import { HashSet } from "@fncts/base/collection/mutable/HashSet";
 import { AtomicBoolean } from "@fncts/base/internal/AtomicBoolean";
 import { HashedPair } from "@fncts/io/internal/HashedPair";
@@ -83,9 +85,14 @@ export declare class Sliding<A> extends Strategy<A> {
 /**
  * Creates a subscription with the specified strategy.
  */
-export declare function makeSubscription<A>(hub: HubInternal<A>, subscribers: HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>, strategy: Strategy<A>): UIO<Dequeue<A>>;
+export declare function makeSubscription<A>(hub: HubInternal<A>, subscribers: HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>, strategy: Strategy<A>): UIO<Queue.Dequeue<A>>;
 /**
  * Unsafely creates a subscription with the specified strategy.
  */
-export declare function unsafeMakeSubscription<A>(hub: HubInternal<A>, subscribers: HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>, subscription: HubInternal.Subscription<A>, pollers: MutableQueue<Future<never, A>>, shutdownHook: Future<never, void>, shutdownFlag: AtomicBoolean, strategy: Strategy<A>): Dequeue<A>;
+export declare function unsafeMakeSubscription<A>(hub: HubInternal<A>, subscribers: HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>, subscription: HubInternal.Subscription<A>, pollers: MutableQueue<Future<never, A>>, shutdownHook: Future<never, void>, shutdownFlag: AtomicBoolean, strategy: Strategy<A>): Queue.Dequeue<A>;
 export declare function subscribersHashSet<A>(): HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>;
+/**
+ * Unsafely creates a hub with the specified strategy.
+ */
+export declare function unsafeMakeHub<A>(hub: HubInternal<A>, subscribers: HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>, scope: Scope.Closeable, shutdownHook: Future<never, void>, shutdownFlag: AtomicBoolean, strategy: Strategy<A>): Hub<A>;
+export declare function makeHubInternal<A>(hub: HubInternal<A>, strategy: Strategy<A>): UIO<Hub<A>>;

package/Hub.d.ts

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

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/core-scope.d.ts

@@ -1,10 +1,8 @@
-import { UIO, URIO } from "@fncts/io/IO/definition";
-import { FiberRef } from "@fncts/io/FiberRef/definition";
-import { Just } from "@fncts/base/data/Maybe/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
 import { Exit } from "@fncts/base/data/Exit/definition";
 import { Fiber } from "@fncts/io/Fiber/definition";
-import { FiberScope } from "../../FiberScope.js";
+import { URIO } from "@fncts/io/IO/definition";
+import type { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
 import { IO } from "../definition.js";
 /**
  * @tsplus getter fncts.io.IO daemonChildren
@@ -12,37 +10,17 @@ import { IO } from "../definition.js";
  */
 export declare function daemonChildren<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
 /**
- * Retrieves the scope that will be used to supervise forked effects.
- * @tsplus static fncts.io.IOOps forkScope
+ * @tsplus pipeable fncts.io.IO raceFibersWith
  * @tsplus location "@fncts/io/IO/api/core-scope"
  */
-export declare const forkScope: UIO<FiberScope>;
-/**
- * Retrieves the scope that will be used to supervise forked effects.
- * @tsplus static fncts.io.IOOps forkScopeWith
- * @tsplus location "@fncts/io/IO/api/core-scope"
- */
-export declare function forkScopeWith<R, E, A>(f: (_: FiberScope) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
-export declare class ForkScopeRestore {
-    private scope;
-    constructor(scope: FiberScope);
-    readonly restore: <R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string) => IO<R, E, A>;
-}
-/**
- * Captures the fork scope, before overriding it with the specified new
- * scope, passing a function that allows restoring the fork scope to
- * what it was originally.
- * @tsplus static fncts.io.IOOps forkScopeMask
- * @tsplus location "@fncts/io/IO/api/core-scope"
- */
-export declare function forkScopeMask<R, E, A>(newScope: FiberScope, f: (restore: ForkScopeRestore) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
+export declare function raceFibersWith<R, E, A, R1, E1, B, R2, E2, C, R3, E3, D>(right: Lazy<IO<R1, E1, B>>, leftWins: (winner: FiberRuntime<E, A>, loser: FiberRuntime<E1, B>) => IO<R2, E2, C>, rightWins: (winner: FiberRuntime<E1, B>, loser: FiberRuntime<E, A>) => IO<R3, E3, D>, __tsplusTrace?: string): (left: IO<R, E, A>) => IO<R | R1 | R2 | R3, E2 | E3, C | D>;
 /**
  * Returns an effect that races this effect with the specified effect, calling
  * the specified finisher as soon as one result or the other has been computed.
  * @tsplus pipeable fncts.io.IO raceWith
  * @tsplus location "@fncts/io/IO/api/core-scope"
  */
-export declare function raceWith<E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3>(right: Lazy<IO<R1, E1, A1>>, leftWins: (exit: Exit<E, A>, fiber: Fiber<E1, A1>) => IO<R2, E2, A2>, rightWins: (exit: Exit<E1, A1>, fiber: Fiber<E, A>) => IO<R3, E3, A3>, __tsplusTrace?: string): <R>(left: IO<R, E, A>) => IO<R1 | R2 | R3 | R, E2 | E3, A2 | A3>;
+export declare function raceWith<R, E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3>(right: Lazy<IO<R1, E1, A1>>, leftWins: (exit: Exit<E, A>, fiber: Fiber<E1, A1>) => IO<R2, E2, A2>, rightWins: (exit: Exit<E1, A1>, fiber: Fiber<E, A>) => IO<R3, E3, A3>, __tsplusTrace?: string): (left: IO<R, E, A>) => IO<R | R1 | R2 | R3, E2 | E3, A2 | A3>;
 export type Grafter = <R, E, A>(effect: IO<R, E, A>) => IO<R, E, A>;
 /**
  * Transplants specified effects so that when those effects fork other
@@ -62,18 +40,4 @@ export declare function transplant<R, E, A>(f: (_: Grafter) => IO<R, E, A>, __ts
  * @tsplus getter fncts.io.IO forkDaemon
  * @tsplus location "@fncts/io/IO/api/core-scope"
  */
-export declare function forkDaemon<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): URIO<R, Fiber.Runtime<E, A>>;
-/**
- * Returns a new effect that will utilize the specified scope to supervise
- * any fibers forked within the original effect.
- * @tsplus pipeable fncts.io.IO overrideForkScope
- * @tsplus location "@fncts/io/IO/api/core-scope"
- */
-export declare function overrideForkScope(scope: FiberScope, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R, E, A>;
-/**
- * Returns a new effect that will utilize the default scope (fiber scope) to
- * supervise any fibers forked within the original effect.
- * @tsplus getter fncts.io.IO defaultForkScope
- * @tsplus location "@fncts/io/IO/api/core-scope"
- */
-export declare function defaultForkScope<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
+export declare function forkDaemon<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): URIO<R, FiberRuntime<E, A>>;

package/IO/api/delay.d.ts

@@ -0,0 +1,8 @@
+import { Lazy } from "@fncts/base/data/function/definition";
+import { Duration } from "@fncts/base/data/Duration/definition";
+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>;

package/IO/api/{foreachC.d.ts → foreachConcurrent.d.ts}

@@ -12,18 +12,18 @@ import { Queue } from "@fncts/io/Queue/definition";
  * Behaves almost like this code:
  *
  * Additionally, interrupts all effects on any failure.
- * @tsplus static fncts.io.IOOps foreachDiscardC
- * @tsplus fluent fncts.Iterable traverseIODiscardC
- * @tsplus location "@fncts/io/IO/api/foreachC"
+ * @tsplus static fncts.io.IOOps foreachConcurrentDiscard
+ * @tsplus fluent fncts.Iterable traverseIOConcurrentDiscard
+ * @tsplus location "@fncts/io/IO/api/foreachConcurrent"
  */
-export declare function foreachDiscardC<R, E, A>(as: Iterable<A>, f: (a: A) => IO<R, E, any>, __tsplusTrace?: string): IO<R, E, void>;
+export declare function foreachConcurrentDiscard<R, E, A>(as: Iterable<A>, f: (a: A) => IO<R, E, any>, __tsplusTrace?: string): IO<R, E, void>;
 /**
  * Applies the function `f` to each element of the `Iterable<A>` in parallel,
  * and returns the results in a `Conc<B>`.
  *
  * For a sequential version of this method, see `IO.foreach`.
- * @tsplus static fncts.io.IOOps foreachC
- * @tsplus fluent fncts.Iterable traverseIOC
- * @tsplus location "@fncts/io/IO/api/foreachC"
+ * @tsplus static fncts.io.IOOps foreachConcurrent
+ * @tsplus fluent fncts.Iterable traverseIOConcurrent
+ * @tsplus location "@fncts/io/IO/api/foreachConcurrent"
  */
-export declare function foreachC<R, E, A, B>(as: Iterable<A>, f: (a: A) => IO<R, E, B>, __tsplusTrace?: string): IO<R, E, Conc<B>>;
+export declare function foreachConcurrent<R, E, A, B>(as: Iterable<A>, f: (a: A) => IO<R, E, B>, __tsplusTrace?: string): IO<R, E, Conc<B>>;