@fncts/io 0.0.1

package/Channel/definition.d.ts

@@ -0,0 +1,164 @@
+import { Cause } from "@fncts/base/data/Cause";
+import { Exit } from "@fncts/base/data/Exit";
+import { URIO, IO } from "@fncts/io/IO/definition";
+import { Environment } from "@fncts/base/data/Environment";
+import type { ChildExecutorDecision } from "./ChildExecutorDecision.js";
+import type { AsyncInputProducer } from "./internal/AsyncInputProducer.js";
+import type { UpstreamPullRequest } from "./UpstreamPullRequest.js";
+import type { UpstreamPullStrategy } from "./UpstreamPullStrategy.js";
+export declare const enum ChannelTag {
+    PipeTo = "PipeTo",
+    ContinuationK = "ContinuationK",
+    ContinuationFinalizer = "ContinuationFinalizer",
+    Fold = "Fold",
+    Bridge = "Bridge",
+    Read = "Read",
+    Done = "Done",
+    Halt = "Halt",
+    FromIO = "FromIO",
+    Emit = "Emit",
+    Defer = "Defer",
+    Ensuring = "Ensuring",
+    ConcatAll = "ConcatAll",
+    BracketOut = "BracketOut",
+    Provide = "Provide"
+}
+/**
+ * @tsplus type fncts.io.Channel
+ * @tsplus companion fncts.io.ChannelOps
+ */
+export declare abstract class Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> {
+    readonly _Env: (_: Env) => void;
+    readonly _InErr: (_: InErr) => void;
+    readonly _InElem: (_: InElem) => void;
+    readonly _InDone: (_: InDone) => void;
+    readonly _OutErr: () => OutErr;
+    readonly _OutElem: () => OutElem;
+    readonly _OutDone: () => OutDone;
+}
+/**
+ * @tsplus unify fncts.io.Channel
+ */
+export declare function unifyChannel<X extends Channel<any, any, any, any, any, any, any>>(_: X): Channel<[
+    X
+] extends [Channel<infer Env, any, any, any, any, any, any>] ? Env : never, [
+    X
+] extends [Channel<any, infer InErr, any, any, any, any, any>] ? InErr : never, [
+    X
+] extends [Channel<any, any, infer InElem, any, any, any, any>] ? InElem : never, [
+    X
+] extends [Channel<any, any, any, infer InDone, any, any, any>] ? InDone : never, [
+    X
+] extends [Channel<any, any, any, any, infer OutErr, any, any>] ? OutErr : never, [
+    X
+] extends [Channel<any, any, any, any, any, infer OutElem, any>] ? OutElem : never, [
+    X
+] extends [Channel<any, any, any, any, any, any, infer OutDone>] ? OutDone : never>;
+export declare abstract class Continuation<Env, InErr, InElem, InDone, OutErr, OutErr2, OutElem, OutDone, OutDone2> {
+    readonly _Env: (_: Env) => void;
+    readonly _InErr: (_: InErr) => void;
+    readonly _InElem: (_: InElem) => void;
+    readonly _InDone: (_: InDone) => void;
+    readonly _OutErr: (_: OutErr) => OutErr;
+    readonly _OutErr2: () => OutErr2;
+    readonly _OutElem: () => OutElem;
+    readonly _OutDone: (_: OutDone) => OutDone;
+    readonly _OutDone2: () => OutDone2;
+}
+export declare class ContinuationK<Env, InErr, InElem, InDone, OutErr, OutErr2, OutElem, OutDone, OutDone2> extends Continuation<Env, InErr, InElem, InDone, OutErr, OutErr2, OutElem, OutDone, OutDone2> {
+    readonly onSuccess: (_: OutDone) => Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone2>;
+    readonly onHalt: (_: Cause<OutErr>) => Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone2>;
+    readonly _tag = ChannelTag.ContinuationK;
+    constructor(onSuccess: (_: OutDone) => Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone2>, onHalt: (_: Cause<OutErr>) => Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone2>);
+    onExit(exit: Exit<OutErr, OutDone>): Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone2>;
+}
+export declare class ContinuationFinalizer<Env, OutErr, OutDone> extends Continuation<Env, unknown, unknown, unknown, OutErr, never, never, OutDone, never> {
+    readonly finalizer: (_: Exit<OutErr, OutDone>) => URIO<Env, any>;
+    readonly _tag = ChannelTag.ContinuationFinalizer;
+    constructor(finalizer: (_: Exit<OutErr, OutDone>) => URIO<Env, any>);
+}
+/**
+ * @optimize remove
+ */
+export declare function concreteContinuation<Env, InErr, InElem, InDone, OutErr, OutErr2, OutElem, OutDone, OutDone2>(_: Continuation<Env, InErr, InElem, InDone, OutErr, OutErr2, OutElem, OutDone, OutDone2>): asserts _ is ContinuationK<Env, InErr, InElem, InDone, OutErr, OutErr2, OutElem, OutDone, OutDone2> | ContinuationFinalizer<Env, OutErr, OutDone>;
+export declare class PipeTo<Env, InErr, InElem, InDone, OutErr, OutErr2, OutElem, OutElem2, OutDone, OutDone2> extends Channel<Env, InErr, InElem, InDone, OutErr2, OutElem2, OutDone2> {
+    readonly left: () => Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>;
+    readonly right: () => Channel<Env, OutErr, OutElem, OutDone, OutErr2, OutElem2, OutDone2>;
+    readonly _tag = ChannelTag.PipeTo;
+    constructor(left: () => Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>, right: () => Channel<Env, OutErr, OutElem, OutDone, OutErr2, OutElem2, OutDone2>);
+}
+export declare class Fold<Env, InErr, InElem, InDone, OutErr, OutErr2, OutElem, OutDone, OutDone2> extends Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone2> {
+    readonly value: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>;
+    readonly k: ContinuationK<Env, InErr, InElem, InDone, OutErr, OutErr2, OutElem, OutDone, OutDone2>;
+    readonly _tag = ChannelTag.Fold;
+    constructor(value: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>, k: ContinuationK<Env, InErr, InElem, InDone, OutErr, OutErr2, OutElem, OutDone, OutDone2>);
+}
+export declare class Read<Env, InErr, InElem, InDone, OutErr, OutErr2, OutElem, OutDone, OutDone2> extends Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone2> {
+    readonly more: (_: InElem) => Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone2>;
+    readonly done: ContinuationK<Env, InErr, InElem, InDone, OutErr, OutErr2, OutElem, OutDone, OutDone2>;
+    readonly _tag = ChannelTag.Read;
+    constructor(more: (_: InElem) => Channel<Env, InErr, InElem, InDone, OutErr2, OutElem, OutDone2>, done: ContinuationK<Env, InErr, InElem, InDone, OutErr, OutErr2, OutElem, OutDone, OutDone2>);
+}
+export declare class Done<OutDone> extends Channel<unknown, unknown, unknown, unknown, never, never, OutDone> {
+    readonly terminal: () => OutDone;
+    readonly _tag = ChannelTag.Done;
+    constructor(terminal: () => OutDone);
+}
+export declare class Fail<OutErr> extends Channel<unknown, unknown, unknown, unknown, OutErr, never, never> {
+    readonly cause: () => Cause<OutErr>;
+    readonly _tag = ChannelTag.Halt;
+    constructor(cause: () => Cause<OutErr>);
+}
+export declare class FromIO<Env, OutErr, OutDone> extends Channel<Env, unknown, unknown, unknown, OutErr, never, OutDone> {
+    readonly io: IO<Env, OutErr, OutDone>;
+    readonly _tag = ChannelTag.FromIO;
+    constructor(io: IO<Env, OutErr, OutDone>);
+}
+export declare class Defer<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> extends Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> {
+    readonly effect: () => Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>;
+    readonly _tag = ChannelTag.Defer;
+    constructor(effect: () => Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>);
+}
+export declare class Ensuring<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> extends Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> {
+    readonly channel: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>;
+    readonly finalizer: (_: Exit<OutErr, OutDone>) => IO<Env, never, any>;
+    readonly _tag = ChannelTag.Ensuring;
+    constructor(channel: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>, finalizer: (_: Exit<OutErr, OutDone>) => IO<Env, never, any>);
+}
+export declare class ConcatAll<Env, InErr, InElem, InDone, OutErr, OutElem, OutElem2, OutDone, OutDone2, OutDone3> extends Channel<Env, InErr, InElem, InDone, OutErr, OutElem2, OutDone3> {
+    readonly combineInners: (_: OutDone, __: OutDone) => OutDone;
+    readonly combineAll: (_: OutDone, __: OutDone2) => OutDone3;
+    readonly onPull: (_: UpstreamPullRequest<OutElem>) => UpstreamPullStrategy<OutElem2>;
+    readonly onEmit: (_: OutElem2) => ChildExecutorDecision;
+    readonly value: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone2>;
+    readonly k: (_: OutElem) => Channel<Env, InErr, InElem, InDone, OutErr, OutElem2, OutDone>;
+    readonly _tag = ChannelTag.ConcatAll;
+    constructor(combineInners: (_: OutDone, __: OutDone) => OutDone, combineAll: (_: OutDone, __: OutDone2) => OutDone3, onPull: (_: UpstreamPullRequest<OutElem>) => UpstreamPullStrategy<OutElem2>, onEmit: (_: OutElem2) => ChildExecutorDecision, value: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone2>, k: (_: OutElem) => Channel<Env, InErr, InElem, InDone, OutErr, OutElem2, OutDone>);
+}
+export declare class BracketOut<R, E, Z, OutDone> extends Channel<R, unknown, unknown, unknown, E, Z, OutDone> {
+    readonly acquire: IO<R, E, Z>;
+    readonly finalizer: (_: Z, exit: Exit<any, any>) => URIO<R, any>;
+    readonly _tag = ChannelTag.BracketOut;
+    constructor(acquire: IO<R, E, Z>, finalizer: (_: Z, exit: Exit<any, any>) => URIO<R, any>);
+}
+export declare class Provide<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> extends Channel<unknown, InErr, InElem, InDone, OutErr, OutElem, OutDone> {
+    readonly environment: Environment<Env>;
+    readonly inner: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>;
+    readonly _tag = ChannelTag.Provide;
+    constructor(environment: Environment<Env>, inner: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>);
+}
+export declare class Emit<OutElem, OutDone> extends Channel<unknown, unknown, unknown, unknown, never, OutElem, OutDone> {
+    readonly out: () => OutElem;
+    readonly _tag = ChannelTag.Emit;
+    constructor(out: () => OutElem);
+}
+export declare class Bridge<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> extends Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> {
+    readonly input: AsyncInputProducer<InErr, InElem, InDone>;
+    readonly channel: Channel<Env, unknown, unknown, unknown, OutErr, OutElem, OutDone>;
+    readonly _tag = ChannelTag.Bridge;
+    constructor(input: AsyncInputProducer<InErr, InElem, InDone>, channel: Channel<Env, unknown, unknown, unknown, OutErr, OutElem, OutDone>);
+}
+/**
+ * @tsplus macro remove
+ */
+export declare function concrete<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(_: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>): asserts _ is PipeTo<Env, InErr, InElem, InDone, OutErr, any, OutElem, any, OutDone, any> | Read<Env, InErr, InElem, InDone, OutErr, any, OutElem, OutDone, any> | Done<OutDone> | Fail<OutErr> | FromIO<Env, OutErr, OutDone> | Emit<OutElem, OutDone> | ConcatAll<Env, InErr, InElem, InDone, OutErr, any, OutElem, any, OutDone, any> | Bridge<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> | Fold<Env, InErr, InElem, InDone, OutErr, any, OutElem, OutDone, any> | Provide<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> | BracketOut<Env, OutErr, OutElem, OutDone> | Ensuring<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> | Defer<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>;

package/Channel/internal/AsyncInputConsumer.d.ts

@@ -0,0 +1,8 @@
+import { Cause } from "@fncts/base/data/Cause";
+import { UIO } from "@fncts/io/IO/definition";
+/**
+ * Consumer-side view of `SingleProducerAsyncInput` for variance purposes.
+ */
+export interface AsyncInputConsumer<Err, Elem, Done> {
+    takeWith<A>(onError: (cause: Cause<Err>) => A, onElement: (element: Elem) => A, onDone: (done: Done) => A): UIO<A>;
+}

package/Channel/internal/AsyncInputProducer.d.ts

@@ -0,0 +1,8 @@
+import { UIO } from "@fncts/io/IO/definition";
+import { Cause } from "@fncts/base/data/Cause";
+export interface AsyncInputProducer<Err, Elem, Done> {
+    emit(el: Elem): UIO<unknown>;
+    done(a: Done): UIO<unknown>;
+    error(cause: Cause<Err>): UIO<unknown>;
+    awaitRead: UIO<void>;
+}

package/Channel/internal/ChannelExecutor.d.ts

@@ -0,0 +1,51 @@
+import { Channel } from "@fncts/io/Channel";
+import { Exit } from "@fncts/base/data/Exit";
+import { URIO, IO } from "@fncts/io/IO/definition";
+import { List } from "@fncts/base/collection/immutable/List";
+import { Environment } from "@fncts/base/data/Environment";
+import { Maybe } from "@fncts/base/data/Maybe";
+import { Cause } from "@fncts/base/data/Cause";
+import type { ChannelState } from "@fncts/io/Channel/internal/ChannelState";
+import * as State from "@fncts/io/Channel/internal/ChannelState";
+export declare type ErasedExecutor<R> = ChannelExecutor<R, unknown, unknown, unknown, unknown, unknown, unknown>;
+export declare function readUpstream<R, E, A>(r: State.Read<R, E>, cont: () => IO<R, E, A>): IO<R, E, A>;
+export declare class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> {
+    private providedEnv;
+    private executeCloseLastSubstream;
+    private input;
+    private inProgressFinalizer;
+    private activeSubexecutor;
+    private doneStack;
+    private done;
+    private cancelled;
+    private emitted;
+    private currentChannel;
+    private closeLastSubstream;
+    constructor(initialChannel: () => Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>, providedEnv: Environment<unknown> | null, executeCloseLastSubstream: (_: URIO<Env, unknown>) => URIO<Env, unknown>);
+    getDone(): import("@fncts/base/data/Exit").Exit<OutErr, OutDone>;
+    getEmit(): OutElem;
+    cancelWith(exit: Exit<OutErr, OutDone>): void;
+    run(): ChannelState<Env, OutErr>;
+    private restorePipe;
+    private popAllFinalizers;
+    private popNextFinalizers;
+    private storeInProgressFinalizer;
+    private clearInProgressFinalizer;
+    private ifNotNull;
+    close(exit: Exit<unknown, unknown>): IO<Env, never, unknown> | null;
+    private processCancellation;
+    private finishSubexecutorWithCloseEffect;
+    private runFinalizers;
+    private runSubexecutor;
+    private replaceSubexecutor;
+    private applyUpstreamPullStrategy;
+    private pullFromUpstream;
+    private performPullFromUpstream;
+    private drainChildExecutors;
+    private pullFromChild;
+    private doneSucceed;
+    private doneHalt;
+    private addFinalizer;
+    private runBracketOut;
+    private runEnsuring;
+}

package/Channel/internal/ChannelState.d.ts

@@ -0,0 +1,44 @@
+import { UIO, IO } from "@fncts/io/IO/definition";
+import { Exit } from "@fncts/base/data/Exit";
+import type { ErasedExecutor } from "@fncts/io/Channel/internal/ChannelExecutor";
+export declare const enum ChannelStateTag {
+    Emit = "Emit",
+    Done = "Done",
+    Effect = "Effect",
+    Read = "Read"
+}
+export declare const ChannelStateTypeId: unique symbol;
+export declare type ChannelStateTypeId = typeof ChannelStateTypeId;
+export declare class Emit {
+    readonly _tag = ChannelStateTag.Emit;
+    readonly _R: (_: unknown) => void;
+    readonly _E: () => never;
+    get effect(): UIO<any>;
+}
+export declare const _Emit: Emit;
+export declare class Done {
+    readonly _tag = ChannelStateTag.Done;
+    readonly _R: (_: unknown) => void;
+    readonly _E: () => never;
+    get effect(): UIO<any>;
+}
+export declare const _Done: Done;
+export declare class Effect<R, E> {
+    readonly io: IO<R, E, any>;
+    readonly _tag = ChannelStateTag.Effect;
+    readonly _R: (_: R) => void;
+    readonly _E: () => E;
+    constructor(io: IO<R, E, any>);
+    get effect(): IO<R, E, any>;
+}
+export declare class Read<R, E> {
+    readonly upstream: ErasedExecutor<R> | null;
+    readonly onEffect: (_: IO<R, never, void>) => IO<R, never, void>;
+    readonly onEmit: (_: any) => IO<R, never, void> | null;
+    readonly onDone: (exit: Exit<any, any>) => IO<R, never, void> | null;
+    readonly _tag = ChannelStateTag.Read;
+    constructor(upstream: ErasedExecutor<R> | null, onEffect: (_: IO<R, never, void>) => IO<R, never, void>, onEmit: (_: any) => IO<R, never, void> | null, onDone: (exit: Exit<any, any>) => IO<R, never, void> | null);
+    get effect(): IO<R, E, any>;
+}
+export declare type ChannelState<R, E> = Emit | Done | Effect<R, E> | Read<R, E>;
+export declare function effectOrNullIgnored<R, E>(channelState: ChannelState<R, E> | null): IO<R, never, void> | null;

package/Channel/internal/MergeDecision.d.ts

@@ -0,0 +1,51 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Exit } from "@fncts/base/data/Exit";
+export declare const enum MergeDecisionTag {
+    Done = "Done",
+    Await = "Await"
+}
+export declare const MergeDecisionTypeId: unique symbol;
+export declare type MergeDecisionTypeId = typeof MergeDecisionTypeId;
+/**
+ * @tsplus type fncts.io.Channel.MergeDecision
+ * @tsplus companion fncts.io.Channel.MergeDecisionOps
+ */
+export declare abstract class MergeDecision<R, E0, Z0, E, Z> {
+    readonly _typeId: MergeDecisionTypeId;
+    readonly _R: (_: R) => void;
+    readonly _E0: (_: E0) => void;
+    readonly _Z0: (_: Z0) => void;
+    readonly _E: () => E;
+    readonly _Z: () => Z;
+}
+/**
+ * @tsplus fluent fncts.io.Channel.MergeDecision concrete
+ * @tsplus macro remove
+ * @tsplus location "@fncts/io/Channel/internal/MergeDecision"
+ */
+export declare function concrete<R, E0, Z0, E, Z>(_: MergeDecision<R, E0, Z0, E, Z>): asserts _ is Done<R, E, Z> | Await<R, E0, Z0, E, Z>;
+export declare class Done<R, E, Z> extends MergeDecision<R, unknown, unknown, E, Z> {
+    readonly io: IO<R, E, Z>;
+    readonly _tag = MergeDecisionTag.Done;
+    constructor(io: IO<R, E, Z>);
+}
+export declare class Await<R, E0, Z0, E, Z> extends MergeDecision<R, E0, Z0, E, Z> {
+    readonly f: (_: Exit<E0, Z0>) => IO<R, E, Z>;
+    readonly _tag = MergeDecisionTag.Await;
+    constructor(f: (_: Exit<E0, Z0>) => IO<R, E, Z>);
+}
+/**
+ * @tsplus static fncts.io.Channel.MergeDecisionOps Done
+ * @tsplus location "@fncts/io/Channel/internal/MergeDecision"
+ */
+export declare function done<R, E, Z>(io: IO<R, E, Z>): MergeDecision<R, unknown, unknown, E, Z>;
+/**
+ * @tsplus static fncts.io.Channel.MergeDecisionOps Await
+ * @tsplus location "@fncts/io/Channel/internal/MergeDecision"
+ */
+export declare function wait<R, E0, Z0, E, Z>(f: (exit: Exit<E0, Z0>) => IO<R, E, Z>): MergeDecision<R, E0, Z0, E, Z>;
+/**
+ * @tsplus static fncts.io.Channel.MergeDecisionOps AwaitConst
+ * @tsplus location "@fncts/io/Channel/internal/MergeDecision"
+ */
+export declare function awaitConst<R, E, Z>(io: IO<R, E, Z>): MergeDecision<R, unknown, unknown, E, Z>;

package/Channel/internal/MergeState.d.ts

@@ -0,0 +1,50 @@
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { Either } from "@fncts/base/data/Either";
+import { Exit } from "@fncts/base/data/Exit";
+import { IO } from "@fncts/io/IO/definition";
+export declare const enum MergeStateTag {
+    BothRunning = "BothRunning",
+    LeftDone = "LeftDone",
+    RightDone = "RightDone"
+}
+export declare class BothRunning<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> {
+    readonly left: Fiber<Err, Either<Done, Elem>>;
+    readonly right: Fiber<Err1, Either<Done1, Elem>>;
+    readonly _tag = MergeStateTag.BothRunning;
+    constructor(left: Fiber<Err, Either<Done, Elem>>, right: Fiber<Err1, Either<Done1, Elem>>);
+}
+export declare class LeftDone<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> {
+    readonly f: (_: Exit<Err1, Done1>) => IO<Env, Err2, Done2>;
+    readonly _tag = MergeStateTag.LeftDone;
+    constructor(f: (_: Exit<Err1, Done1>) => IO<Env, Err2, Done2>);
+}
+export declare class RightDone<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> {
+    readonly f: (_: Exit<Err, Done>) => IO<Env, Err2, Done2>;
+    readonly _tag = MergeStateTag.RightDone;
+    constructor(f: (_: Exit<Err, Done>) => IO<Env, Err2, Done2>);
+}
+/**
+ * @tsplus type fncts.io.Channel.MergeState
+ */
+export declare type MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> = BothRunning<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> | LeftDone<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> | RightDone<Env, Err, Err1, Err2, Elem, Done, Done1, Done2>;
+/**
+ * @tsplus type fncts.io.Channel.MergeStateOps
+ */
+export interface MergeStateOps {
+}
+export declare const MergeState: MergeStateOps;
+/**
+ * @tsplus static fncts.io.Channel.MergeStateOps BothRunning
+ * @tsplus location "@fncts/io/Channel/internal/MergeState"
+ */
+export declare function bothRunning<Env, Err, Err1, Err2, Elem, Done, Done1, Done2>(left: Fiber<Err, Either<Done, Elem>>, right: Fiber<Err1, Either<Done1, Elem>>): BothRunning<Env, Err, Err1, Err2, Elem, Done, Done1, Done2>;
+/**
+ * @tsplus static fncts.io.Channel.MergeStateOps LeftDone
+ * @tsplus location "@fncts/io/Channel/internal/MergeState"
+ */
+export declare function leftDone<Env, Err, Err1, Err2, Elem, Done, Done1, Done2>(f: (_: Exit<Err1, Done1>) => IO<Env, Err2, Done2>): LeftDone<Env, Err, Err1, Err2, Elem, Done, Done1, Done2>;
+/**
+ * @tsplus static fncts.io.Channel.MergeStateOps RightDone
+ * @tsplus location "@fncts/io/Channel/internal/MergeState"
+ */
+export declare function rightDone<Env, Err, Err1, Err2, Elem, Done, Done1, Done2>(f: (_: Exit<Err, Done>) => IO<Env, Err2, Done2>): RightDone<Env, Err, Err1, Err2, Elem, Done, Done1, Done2>;

package/Channel/internal/SingleProducerAsyncInput.d.ts

@@ -0,0 +1,71 @@
+import { Cause } from "@fncts/base/data/Cause";
+import { Future } from "@fncts/io/Future";
+import { Either } from "@fncts/base/data/Either";
+import { Ref } from "@fncts/io/Ref";
+import { UIO } from "@fncts/io/IO/definition";
+import { Exit } from "@fncts/base/data/Exit";
+import type { AsyncInputConsumer } from "@fncts/io/Channel/internal/AsyncInputConsumer";
+import type { AsyncInputProducer } from "@fncts/io/Channel/internal/AsyncInputProducer";
+import { Queue } from "@fncts/base/collection/immutable/Queue";
+export declare const enum StateTag {
+    Done = "Done",
+    Error = "Error",
+    Empty = "Empty",
+    Emit = "Emit"
+}
+export declare class StateDone<Done> {
+    readonly a: Done;
+    readonly _stateTag = StateTag.Done;
+    constructor(a: Done);
+}
+export declare class StateError<E> {
+    readonly cause: Cause<E>;
+    readonly _stateTag = StateTag.Error;
+    constructor(cause: Cause<E>);
+}
+export declare class StateEmpty {
+    readonly notifyProducer: Future<never, void>;
+    readonly _stateTag = StateTag.Empty;
+    constructor(notifyProducer: Future<never, void>);
+}
+export declare class StateEmit<Err, Elem, Done> {
+    readonly notifyConsumers: Queue<Future<Err, Either<Done, Elem>>>;
+    readonly _stateTag = StateTag.Emit;
+    constructor(notifyConsumers: Queue<Future<Err, Either<Done, Elem>>>);
+}
+export declare type State<Err, Elem, Done> = StateEmpty | StateEmit<Err, Elem, Done> | StateError<Err> | StateDone<Done>;
+/**
+ * An MVar-like abstraction for sending data to channels asynchronously. Designed
+ * for one producer and multiple consumers.
+ *
+ * Features the following semantics:
+ * - Buffer of size 1
+ * - When emitting, the producer waits for a consumer to pick up the value
+ *   to prevent "reading ahead" too much.
+ * - Once an emitted element is read by a consumer, it is cleared from the buffer, so that
+ *   at most one consumer sees every emitted element.
+ * - When sending a done or error signal, the producer does not wait for a consumer
+ *   to pick up the signal. The signal stays in the buffer after being read by a consumer,
+ *   so it can be propagated to multiple consumers.
+ * - Trying to publish another emit/error/done after an error/done have already been published
+ *   results in an interruption.
+ *
+ * @tsplus companion fncts.io.Channel.SingleProducerAsyncInputOps
+ */
+export declare class SingleProducerAsyncInput<Err, Elem, Done> implements AsyncInputProducer<Err, Elem, Done>, AsyncInputConsumer<Err, Elem, Done> {
+    readonly ref: Ref<State<Err, Elem, Done>>;
+    constructor(ref: Ref<State<Err, Elem, Done>>);
+    emit(el: Elem): UIO<unknown>;
+    done(a: Done): UIO<unknown>;
+    error(cause: Cause<Err>): UIO<unknown>;
+    takeWith<X>(onError: (cause: Cause<Err>) => X, onElement: (element: Elem) => X, onDone: (done: Done) => X): UIO<X>;
+    take: import("../../IO").UIO<import("@fncts/base/data/Exit").Exit<import("@fncts/base/data/Either").Either<Err, Done>, Elem>>;
+    close: import("../../IO").IO<unknown, never, unknown>;
+    awaitRead: UIO<void>;
+}
+/**
+ * Creates a SingleProducerAsyncInput
+ * @tsplus static fncts.io.Channel.SingleProducerAsyncInputOps __call
+ * @tsplus location "@fncts/io/Channel/internal/SingleProducerAsyncInput"
+ */
+export declare function makeSingleProducerAsyncInput<Err, Elem, Done>(): UIO<SingleProducerAsyncInput<Err, Elem, Done>>;

package/Channel.d.ts

@@ -0,0 +1,3 @@
+export * from "./Channel/api.js";
+export * from "./Channel/core-api.js";
+export * from "./Channel/definition.js";

package/Clock/api.d.ts

@@ -0,0 +1,11 @@
+import { UIO } from "@fncts/io/IO/definition";
+/**
+ * @tsplus static fncts.io.ClockOps currentTime
+ * @tsplus location "@fncts/io/Clock/api"
+ */
+export declare const currentTime: import("../IO").IO<unknown, never, number>;
+/**
+ * @tsplus static fncts.io.ClockOps sleep
+ * @tsplus location "@fncts/io/Clock/api"
+ */
+export declare function sleep(duration: number, __tsplusTrace?: string): UIO<void>;

package/Clock/definition.d.ts

@@ -0,0 +1,14 @@
+import { UIO } from "@fncts/io/IO/definition";
+/**
+ * @tsplus type fncts.io.Clock
+ * @tsplus companion fncts.io.ClockOps
+ */
+export declare abstract class Clock {
+    abstract readonly currentTime: UIO<number>;
+    abstract sleep(duration: number, __tsplusTrace?: string): UIO<void>;
+}
+/**
+ * @tsplus static fncts.io.ClockOps Tag
+ * @tsplus location "@fncts/io/Clock/definition"
+ */
+export declare const ClockTag: import("@fncts/base/data/Tag").Tag<Clock>;

package/Clock/live.d.ts

@@ -0,0 +1,7 @@
+import { UIO } from "@fncts/io/IO/definition";
+import { Clock } from "@fncts/io/Clock/definition";
+/**
+ * @tsplus static fncts.io.ClockOps Live
+ * @tsplus location "@fncts/io/Clock/live"
+ */
+export declare const live: Clock;

package/Clock.d.ts

@@ -0,0 +1,3 @@
+export * from "./Clock/api.js";
+export * from "./Clock/definition.js";
+export * from "./Clock/live.js";

package/Console/api.d.ts

@@ -0,0 +1,11 @@
+import { UIO } from "@fncts/io/IO/definition";
+/**
+ * @tsplus static fncts.io.ConsoleOps show
+ * @tsplus location "@fncts/io/Console/api"
+ */
+export declare function show(...data: unknown[]): UIO<void>;
+/**
+ * @tsplus static fncts.io.ConsoleOps print
+ * @tsplus location "@fncts/io/Console/api"
+ */
+export declare function print(line: string): UIO<void>;

package/Console/definition.d.ts

@@ -0,0 +1,15 @@
+import { UIO } from "@fncts/io/IO/definition";
+/**
+ * @tsplus type fncts.io.Console
+ * @tsplus companion fncts.io.ConsoleOps
+ */
+export declare abstract class Console {
+    abstract show(...data: unknown[]): UIO<void>;
+    abstract print(line: string): UIO<void>;
+    abstract error(line: string): UIO<void>;
+}
+/**
+ * @tsplus static fncts.io.ConsoleOps Tag
+ * @tsplus location "@fncts/io/Console/definition"
+ */
+export declare const ConsoleTag: import("@fncts/base/data/Tag").Tag<Console>;

package/Console/live.d.ts

@@ -0,0 +1,11 @@
+import { Console } from "@fncts/io/Console/definition";
+export declare class LiveConsole extends Console {
+    show(...data: unknown[]): import("../IO").UIO<void>;
+    print(line: string): import("../IO").UIO<void>;
+    error(line: string): import("../IO").UIO<void>;
+}
+/**
+ * @tsplus static fncts.io.ConsoleOps Live
+ * @tsplus location "@fncts/io/Console/live"
+ */
+export declare const live: Console;

package/Console.d.ts

@@ -0,0 +1,3 @@
+export * from "./Console/api.js";
+export * from "./Console/definition.js";
+export * from "./Console/live.js";