@fncts/io 0.0.1

package/Hub/api.d.ts

@@ -0,0 +1,191 @@
+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 { Has } from "@fncts/base/typeclass/Has";
+import { Scope } from "@fncts/io/Scope/definition";
+/**
+ * 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>): 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>): number;
+/**
+ * Transforms messages published to the hub using the specified effectual
+ * function.
+ * @tsplus fluent 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>): PHub<RC & RA, RB, EA | EC, EB, C, B>;
+/**
+ * Transforms messages published to and taken from the hub using the
+ * specified functions.
+ * @tsplus fluent 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): 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 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>): PHub<RC & RA, RD & RB, EA | EC, EB | ED, C, D>;
+/**
+ * Filters messages published to the hub using the specified effectual
+ * function.
+ * @tsplus fluent 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>): PHub<RA & RA1, RB, EA | EA1, EB, A, B>;
+/**
+ * Filters messages published to the hub using the specified function.
+ * @tsplus fluent 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): 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 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>): PHub<RA, RB & RB1, EA, EB | EB1, A, B>;
+/**
+ * Filters messages taken from the hub using the specified function.
+ * @tsplus fluent 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): 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>): 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): 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): 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): UIO<Hub<A>>;
+/**
+ * Creates an unbounded hub.
+ * @tsplus static fncts.io.HubOps makeUnbounded
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function makeUnbounded<A>(): UIO<Hub<A>>;
+/**
+ * Transforms messages taken from the hub using the specified function.
+ * @tsplus fluent 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): 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 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>): 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 fluent 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): 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 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>): 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>): 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>): IO<Has<Scope>, never, Hub.Dequeue<RB, EB, 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>): 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>): Hub.Enqueue<RA, EA, A>;
+/**
+ * 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

@@ -0,0 +1,89 @@
+import { PQueue } from "@fncts/io/Queue/definition";
+import { UIO, IO } from "@fncts/io/IO/definition";
+import { Has } from "@fncts/base/typeclass/Has";
+import { Scope } from "@fncts/io/Scope/definition";
+export declare const HubTypeId: unique symbol;
+export declare 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
+ */
+export interface PHub<RA, RB, EA, EB, A, B> {
+    readonly _typeId: HubTypeId;
+    readonly _RA: (_: RA) => void;
+    readonly _RB: (_: RB) => void;
+    readonly _EA: () => EA;
+    readonly _EB: () => EB;
+    readonly _A: (_: A) => void;
+    readonly _B: () => B;
+}
+/**
+ * @tsplus type fncts.io.Hub
+ */
+export interface Hub<A> extends PHub<unknown, unknown, never, never, A, A> {
+}
+/**
+ * @tsplus type fncts.io.HubOps
+ */
+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> {
+    _typeId: HubTypeId;
+    readonly _RA: (_: RA) => void;
+    readonly _RB: (_: RB) => void;
+    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<Has<Scope>, never, Hub.Dequeue<RB, EB, B>>;
+}
+/**
+ * @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

@@ -0,0 +1,97 @@
+import { Future } from "@fncts/io/Future";
+import { UIO, IO } from "@fncts/io/IO/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { Has } from "@fncts/base/typeclass/Has";
+import { Scope } from "@fncts/io/Scope/definition";
+import { Hub } from "@fncts/io/Hub/definition";
+import type { Hub as HubInternal } from "@fncts/io/internal/Hub";
+import { HashSet } from "@fncts/base/collection/mutable/HashSet";
+import { AtomicBoolean } from "@fncts/base/internal/AtomicBoolean";
+import { HashedPair } from "@fncts/io/internal/HashedPair";
+import { MutableQueue } from "@fncts/io/internal/MutableQueue";
+/**
+ * A `Strategy<A>` describes the protocol for how publishers and subscribers
+ * will communicate with each other through the hub.
+ */
+export declare abstract class Strategy<A> {
+    /**
+     * Describes how publishers should signal to subscribers that they are
+     * waiting for space to become available in the hub.
+     */
+    abstract handleSurplus(hub: HubInternal<A>, subscribers: HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>, as: Iterable<A>, isShutdown: AtomicBoolean): UIO<boolean>;
+    /**
+     * Describes any finalization logic associated with this strategy.
+     */
+    abstract shutdown: UIO<void>;
+    /**
+     * Describes how subscribers should signal to publishers waiting for space
+     * to become available in the hub that space may be available.
+     */
+    abstract unsafeOnHubEmptySpace(hub: HubInternal<A>, subscribers: HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>): void;
+    /**
+     * Describes how subscribers waiting for additional values from the hub
+     * should take those values and signal to publishers that they are no
+     * longer waiting for additional values.
+     */
+    unsafeCompletePollers(hub: HubInternal<A>, subscribers: HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>, subscription: HubInternal.Subscription<A>, pollers: MutableQueue<Future<never, A>>): void;
+    /**
+     * Describes how publishers should signal to subscribers waiting for
+     * additional values from the hub that new values are available.
+     */
+    unsafeCompleteSubscribers(hub: HubInternal<A>, subscribers: HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>): void;
+}
+/**
+ * A strategy that applies back pressure to publishers when the hub is at
+ * capacity. This guarantees that all subscribers will receive all messages
+ * published to the hub while they are subscribed. However, it creates the
+ * risk that a slow subscriber will slow down the rate at which messages
+ * are published and received by other subscribers.
+ */
+export declare class BackPressure<A> extends Strategy<A> {
+    publishers: MutableQueue<readonly [A, Future<never, boolean>, boolean]>;
+    handleSurplus(hub: HubInternal<A>, subscribers: HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>, as: Iterable<A>, isShutdown: AtomicBoolean): UIO<boolean>;
+    get shutdown(): UIO<void>;
+    unsafeOnHubEmptySpace(hub: HubInternal<A>, subscribers: HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>): void;
+    private unsafeOffer;
+    private unsafeRemove;
+}
+/**
+ * A strategy that drops new messages when the hub is at capacity. This
+ * guarantees that a slow subscriber will not slow down the rate at which
+ * messages are published. However, it creates the risk that a slow
+ * subscriber will slow down the rate at which messages are received by
+ * other subscribers and that subscribers may not receive all messages
+ * published to the hub while they are subscribed.
+ */
+export declare class Dropping<A> extends Strategy<A> {
+    handleSurplus(_hub: HubInternal<A>, _subscribers: HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>, _as: Iterable<A>, _isShutdown: AtomicBoolean): UIO<boolean>;
+    shutdown: UIO<void>;
+    unsafeOnHubEmptySpace(_hub: HubInternal<A>, _subscribers: HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>): void;
+}
+/**
+ * A strategy that adds new messages and drops old messages when the hub is
+ * at capacity. This guarantees that a slow subscriber will not slow down
+ * the rate at which messages are published and received by other
+ * subscribers. However, it creates the risk that a slow subscriber will
+ * not receive some messages published to the hub while it is subscribed.
+ */
+export declare class Sliding<A> extends Strategy<A> {
+    private unsafeSlidingPublish;
+    handleSurplus(hub: HubInternal<A>, subscribers: HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>, as: Iterable<A>, _isShutdown: AtomicBoolean): UIO<boolean>;
+    shutdown: UIO<void>;
+    unsafeOnHubEmptySpace(_hub: HubInternal<A>, _subscribers: HashSet<HashedPair<HubInternal.Subscription<A>, MutableQueue<Future<never, A>>>>): void;
+}
+/**
+ * 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<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>): 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

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

package/IO/api/acquireRelease.d.ts

@@ -0,0 +1,10 @@
+import { Lazy } from "@fncts/base/data/function";
+import { IO } from "@fncts/io/IO/definition";
+import { Has } from "@fncts/base/typeclass/Has";
+import { Scope } from "@fncts/io/Scope/definition";
+/**
+ * @tsplus static fncts.io.IOOps acquireRelease
+ * @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>): IO<R & R1 & Has<Scope>, E, A>;

package/IO/api/acquireReleaseExit.d.ts

@@ -0,0 +1,11 @@
+import { Lazy } from "@fncts/base/data/function";
+import { IO } from "@fncts/io/IO/definition";
+import { Exit } from "@fncts/base/data/Exit";
+import { Has } from "@fncts/base/typeclass/Has";
+import { Scope } from "@fncts/io/Scope/definition";
+/**
+ * @tsplus static fncts.io.IOOps acquireReleaseExit
+ * @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 & Has<Scope>, E, A>;

package/IO/api/acquireReleaseInterruptible.d.ts

@@ -0,0 +1,9 @@
+import { Lazy } from "@fncts/base/data/function";
+import { IO } from "@fncts/io/IO/definition";
+import { Has } from "@fncts/base/typeclass/Has";
+import { Scope } from "@fncts/io/Scope/definition";
+/**
+ * @tsplus static fncts.io.IOOps acquireReleaseInterruptible
+ * @tsplus location "@fncts/io/IO/api/acquireReleaseInterruptible"
+ */
+export declare function acquireReleaseInterruptible<R, E, A, R1>(acquire: Lazy<IO<R, E, A>>, release: IO<R1, never, any>, __tsplusTrace?: string): IO<R & R1 & Has<Scope>, E, A>;

package/IO/api/acquireReleaseInterruptibleExit.d.ts

@@ -0,0 +1,10 @@
+import { Lazy } from "@fncts/base/data/function";
+import { IO } from "@fncts/io/IO/definition";
+import { Exit } from "@fncts/base/data/Exit";
+import { Has } from "@fncts/base/typeclass/Has";
+import { Scope } from "@fncts/io/Scope/definition";
+/**
+ * @tsplus static fncts.io.IOOps acquireReleaseInterruptibleExit
+ * @tsplus location "@fncts/io/IO/api/acquireReleaseInterruptibleExit"
+ */
+export declare function acquireReleaseInterruptibleExit<R, E, A, R1>(acquire: Lazy<IO<R, E, A>>, release: (exit: Exit<any, any>) => IO<R1, never, any>, __tsplusTrace?: string): IO<R & R1 & Has<Scope>, E, A>;

package/IO/api/addFinalizer.d.ts

@@ -0,0 +1,9 @@
+import { Lazy } from "@fncts/base/data/function";
+import { URIO, IO } from "@fncts/io/IO/definition";
+import { Has } from "@fncts/base/typeclass/Has";
+import { Scope } from "@fncts/io/Scope/definition";
+/**
+ * @tsplus static fncts.io.IOOps addFinalizer
+ * @tsplus location "@fncts/io/IO/api/addFinalizer"
+ */
+export declare function addFinalizer<R>(finalizer: Lazy<URIO<R, any>>, __tsplusTrace?: string): IO<R & Has<Scope>, never, void>;

package/IO/api/addFinalizerExit.d.ts

@@ -0,0 +1,9 @@
+import { Exit } from "@fncts/base/data/Exit";
+import { URIO, IO } from "@fncts/io/IO/definition";
+import { Has } from "@fncts/base/typeclass/Has";
+import { Scope } from "@fncts/io/Scope/definition";
+/**
+ * @tsplus static fncts.io.IOOps addFinalizerExit
+ * @tsplus location "@fncts/io/IO/api/addFinalizerExit"
+ */
+export declare function addFinalizerExit<R>(finalizer: (exit: Exit<any, any>) => URIO<R, any>): IO<R & Has<Scope>, never, void>;

package/IO/api/bracket.d.ts

@@ -0,0 +1,26 @@
+import { Lazy } from "@fncts/base/data/function";
+import { IO } from "@fncts/io/IO/definition";
+/**
+ * When this IO represents acquisition of a resource (for example,
+ * opening a file, launching a thread, etc.), `bracket` can be used to ensure
+ * the acquisition is not interrupted and the resource is always released.
+ *
+ * The function does two things:
+ *
+ * 1. Ensures this IO, which acquires the resource, will not be
+ * interrupted. Of course, acquisition may fail for internal reasons (an
+ * uncaught exception).
+ * 2. Ensures the `release` IO will not be interrupted, and will be
+ * executed so long as this IO successfully acquires the resource.
+ *
+ * In between acquisition and release of the resource, the `use` IO is
+ * executed.
+ *
+ * If the `release` IO fails, then the entire IO will fail even
+ * if the `use` IO succeeds. If this fail-fast behavior is not desired,
+ * errors produced by the `release` IO can be caught and ignored.
+ * @tsplus fluent fncts.io.IO bracket
+ * @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>): IO<R & R1 & R2, E | E1 | E2, A1>;

package/IO/api/bracketExit.d.ts

@@ -0,0 +1,14 @@
+import { Lazy } from "@fncts/base/data/function";
+import { IO } from "@fncts/io/IO/definition";
+import { Exit } from "@fncts/base/data/Exit";
+/**
+ * Acquires a resource, uses the resource, and then releases the resource.
+ * Neither the acquisition nor the release will be interrupted, and the
+ * resource is guaranteed to be released, so long as the `acquire` IO
+ * succeeds. If `use` fails, then after release, the returned IO will fail
+ * with the same error.
+ * @tsplus fluent fncts.io.IO bracketExit
+ * @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>): IO<R & R1 & R2, E | E1 | E2, A1>;

package/IO/api/clockWith.d.ts

@@ -0,0 +1,12 @@
+import { Clock } from "@fncts/io/Clock/definition";
+import { IO } from "@fncts/io/IO/definition";
+/**
+ * @tsplus static fncts.io.IOOps clockWith
+ * @tsplus location "@fncts/io/IO/api/clockWith"
+ */
+export declare function clockWith<R, E, A>(f: (clock: Clock) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
+/**
+ * @tsplus static fncts.io.IOOps clock
+ * @tsplus location "@fncts/io/IO/api/clockWith"
+ */
+export declare const clock: import("../definition").IO<unknown, never, import("../../Clock").Clock>;

package/IO/api/concurrency.d.ts

@@ -0,0 +1,35 @@
+import { FiberRef } from "@fncts/io/FiberRef/definition";
+import { Maybe } from "@fncts/base/data/Maybe";
+import { UIO, IO } from "@fncts/io/IO/definition";
+/**
+ * The number of fibers used for concurrent operators.
+ */
+export declare const Concurrency: FiberRef<Maybe<number>>;
+/**
+ * Retrieves the maximum number of fibers for concurrent operators or `Nothing` if
+ * it is unbounded.
+ * @tsplus static fncts.io.IOOps concurrency
+ * @tsplus location "@fncts/io/IO/api/concurrency"
+ */
+export declare const concurrency: UIO<Maybe<number>>;
+/**
+ * Retrieves the current maximum number of fibers for concurrent operators and
+ * uses it to run the specified effect.
+ * @tsplus static fncts.io.IOOps concurrencyWith
+ * @tsplus location "@fncts/io/IO/api/concurrency"
+ */
+export declare function concurrencyWith<R, E, A>(f: (concurrency: Maybe<number>) => IO<R, E, A>): IO<R, E, A>;
+/**
+ * Runs the specified effect with the specified maximum number of fibers for
+ * concurrent operators.
+ * @tsplus fluent 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): IO<R, E, A>;
+/**
+ * Runs the specified effect with an unbounded maximum number of fibers for
+ * concurrent operators.
+ * @tsplus getter fncts.io.IO withConcurrencyUnbounded
+ * @tsplus location "@fncts/io/IO/api/concurrency"
+ */
+export declare function withConcurrencyUnbounded<R, E, A>(ma: IO<R, E, A>): IO<R, E, A>;

package/IO/api/concurrentFinalizers.d.ts

@@ -0,0 +1,8 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Has } from "@fncts/base/typeclass/Has";
+import { Scope } from "@fncts/io/Scope/definition";
+/**
+ * @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>): IO<R & Has<Scope>, E, A>;

package/IO/api/consoleWith.d.ts

@@ -0,0 +1,12 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Console } from "@fncts/io/Console";
+/**
+ * @tsplus static fncts.io.IOOps consoleWith
+ * @tsplus location "@fncts/io/IO/api/consoleWith"
+ */
+export declare function consoleWith<R, E, A>(f: (console: Console) => IO<R, E, A>): IO<R, E, A>;
+/**
+ * @tsplus static fncts.io.IOOps console
+ * @tsplus location "@fncts/io/IO/api/consoleWith"
+ */
+export declare const console: import("../definition").IO<unknown, never, Console>;

package/IO/api/core-scope.d.ts

@@ -0,0 +1,77 @@
+import { UIO, URIO } from "@fncts/io/IO/definition";
+import { Lazy } from "@fncts/base/data/function";
+import { Exit } from "@fncts/base/data/Exit";
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { FiberScope } from "../../FiberScope.js";
+import { GetForkScope, IO } from "../definition.js";
+/**
+ * @tsplus getter fncts.io.IO daemonChildren
+ * @tsplus location "@fncts/io/IO/api/core-scope"
+ */
+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 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): GetForkScope<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>;
+/**
+ * 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 fluent fncts.io.IO raceWith
+ * @tsplus location "@fncts/io/IO/api/core-scope"
+ */
+export declare function raceWith_<R, E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3>(left: IO<R, E, A>, 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): IO<R & R1 & R2 & R3, E2 | E3, A2 | A3>;
+export declare type Grafter = <R, E, A>(effect: IO<R, E, A>) => IO<R, E, A>;
+/**
+ * Transplants specified effects so that when those effects fork other
+ * effects, the forked effects will be governed by the scope of the
+ * fiber that executes this effect.
+ *
+ * This can be used to "graft" deep grandchildren onto a higher-level
+ * scope, effectively extending their lifespans into the parent scope.
+ * @tsplus static fncts.io.IOOps transplant
+ * @tsplus location "@fncts/io/IO/api/core-scope"
+ */
+export declare function transplant<R, E, A>(f: (_: Grafter) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
+/**
+ * Forks the effect into a new fiber attached to the global scope. Because the
+ * new fiber is attached to the global scope, when the fiber executing the
+ * returned effect terminates, the forked fiber will continue running.
+ * @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 fluent fncts.io.IO overrideForkScope
+ * @tsplus location "@fncts/io/IO/api/core-scope"
+ */
+export declare function overrideForkScope_<R, E, A>(ma: IO<R, E, A>, scope: FiberScope, __tsplusTrace?: string): 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>;