@fncts/io 0.0.1

package/Stream/definition.d.ts

@@ -0,0 +1,38 @@
+import { Channel } from "@fncts/io/Channel";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import type { _A, _E, _R } from "@fncts/base/types";
+export declare const StreamTypeId: unique symbol;
+export declare type StreamTypeId = typeof StreamTypeId;
+/**
+ * A `Stream<R, E, A>` is a description of a program that, when evaluated,
+ * may emit 0 or more values of type `A`, may fail with errors of type `E`
+ * and uses an environment of type `R`.
+ * One way to think of `Stream` is as a `Effect` program that could emit multiple values.
+ *
+ * `Stream` is a purely functional *pull* based stream. Pull based streams offer
+ * inherent laziness and backpressure, relieving users of the need to manage buffers
+ * between operators. As an optimization `Stream` does not emit single values, but
+ * rather an array of values. This allows the cost of effect evaluation to be
+ * amortized.
+ *
+ * `Stream` forms a monad on its `A` type parameter, and has error management
+ * facilities for its `E` type parameter, modeled similarly to `Effect` (with some
+ * adjustments for the multiple-valued nature of `Stream`). These aspects allow
+ * for rich and expressive composition of streams.
+ *
+ * @tsplus type fncts.io.Stream
+ * @tsplus companion fncts.io.StreamOps
+ */
+export declare class Stream<R, E, A> {
+    readonly channel: Channel<R, unknown, unknown, unknown, E, Conc<A>, unknown>;
+    readonly [StreamTypeId]: StreamTypeId;
+    readonly _R: (_: R) => void;
+    readonly _E: () => E;
+    readonly _A: () => A;
+    constructor(channel: Channel<R, unknown, unknown, unknown, E, Conc<A>, unknown>);
+}
+/**
+ * @tsplus unify fncts.io.Stream
+ */
+export declare function unifyStream<X extends Stream<any, any, any>>(_: X): Stream<_R<X>, _E<X>, _A<X>>;
+export declare const DEFAULT_CHUNK_SIZE = 4096;

package/Stream/internal/DebounceState.d.ts

@@ -0,0 +1,61 @@
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import type { HandoffSignal } from "./Handoff.js";
+export declare const enum DebounceStateTag {
+    NotStarted = "NotStarted",
+    Previous = "Previous",
+    Current = "Current"
+}
+export declare const NotStartedTag: unique symbol;
+export declare type NotStartedTag = typeof NotStartedTag;
+export declare class NotStarted {
+    readonly _tag = DebounceStateTag.NotStarted;
+}
+export declare const PreviousTag: unique symbol;
+export declare type PreviousTag = typeof PreviousTag;
+export declare class Previous<A> {
+    readonly fiber: Fiber<never, Conc<A>>;
+    readonly _tag = DebounceStateTag.Previous;
+    constructor(fiber: Fiber<never, Conc<A>>);
+}
+export declare const CurrentTag: unique symbol;
+export declare type CurrentTag = typeof CurrentTag;
+export declare class Current<E, A> {
+    readonly fiber: Fiber<E, HandoffSignal<void, E, A>>;
+    readonly _tag = DebounceStateTag.Current;
+    constructor(fiber: Fiber<E, HandoffSignal<void, E, A>>);
+}
+/**
+ * @tsplus type fncts.io.Stream.DebounceState
+ */
+export declare type DebounceState<E, A> = NotStarted | Previous<A> | Current<E, A>;
+/**
+ * @tsplus type fncts.io.Stream.DebounceStateOps
+ */
+export interface DebounceStateOps {
+}
+export declare const DebounceState: DebounceStateOps;
+/**
+ * @tsplus static fncts.io.Stream.DebounceStateOps NotStarted
+ * @tsplus location "@fncts/io/Stream/internal/DebounceState"
+ */
+export declare const notStarted: DebounceState<never, never>;
+/**
+ * @tsplus static fncts.io.Stream.DebounceStateOps Previous
+ * @tsplus location "@fncts/io/Stream/internal/DebounceState"
+ */
+export declare function previous<A>(fiber: Fiber<never, Conc<A>>): DebounceState<never, A>;
+/**
+ * @tsplus static fncts.io.Stream.DebounceStateOps Current
+ * @tsplus location "@fncts/io/Stream/internal/DebounceState"
+ */
+export declare function current<E, A>(fiber: Fiber<E, HandoffSignal<void, E, A>>): DebounceState<E, A>;
+/**
+ * @tsplus fluent fncts.io.Stream.DebounceState match
+ * @tsplus location "@fncts/io/Stream/internal/DebounceState"
+ */
+export declare function match_<E, A, B, C, D>(ds: DebounceState<E, A>, cases: {
+    NotStarted: (_: NotStarted) => B;
+    Current: (_: Current<E, A>) => C;
+    Previous: (_: Previous<A>) => D;
+}): B | C | D;

package/Stream/internal/Handoff.d.ts

@@ -0,0 +1,111 @@
+import { Ref } from "@fncts/io/Ref";
+import { Future } from "@fncts/io/Future";
+import { UIO } from "@fncts/io/IO/definition";
+import { Maybe } from "@fncts/base/data/Maybe";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { Cause } from "@fncts/base/data/Cause";
+import type { SinkEndReason } from "./SinkEndReason.js";
+/**
+ * @tsplus type fncts.io.Stream.Handoff
+ * @tsplus companion fncts.io.Stream.HandoffOps
+ */
+export declare class Handoff<A> {
+    readonly ref: Ref<State<A>>;
+    constructor(ref: Ref<State<A>>);
+}
+export declare const StateTypeId: unique symbol;
+export declare const EmptyTypeId: unique symbol;
+export declare class Empty {
+    readonly notifyConsumer: Future<never, void>;
+    readonly _typeId: typeof StateTypeId;
+    readonly _tag: typeof EmptyTypeId;
+    constructor(notifyConsumer: Future<never, void>);
+}
+export declare const FullTypeId: unique symbol;
+export declare class Full<A> {
+    readonly a: A;
+    readonly notifyProducer: Future<never, void>;
+    readonly _typeId: typeof StateTypeId;
+    readonly _tag: typeof FullTypeId;
+    constructor(a: A, notifyProducer: Future<never, void>);
+}
+export declare type State<A> = Empty | Full<A>;
+/**
+ * @tsplus static fncts.io.Stream.HandoffOps __call
+ * @tsplus location "@fncts/io/Stream/internal/Handoff"
+ */
+export declare function make<A>(): UIO<Handoff<A>>;
+/**
+ * @tsplus fluent fncts.io.Stream.Handoff offer
+ * @tsplus location "@fncts/io/Stream/internal/Handoff"
+ */
+export declare function offer<A>(handoff: Handoff<A>, a: A): UIO<void>;
+/**
+ * @tsplus getter fncts.io.Stream.Handoff take
+ * @tsplus location "@fncts/io/Stream/internal/Handoff"
+ */
+export declare function take<A>(handoff: Handoff<A>): UIO<A>;
+/**
+ * @tsplus getter fncts.io.Stream.Handoff poll
+ * @tsplus location "@fncts/io/Stream/internal/Handoff"
+ */
+export declare function poll<A>(handoff: Handoff<A>): UIO<Maybe<A>>;
+export declare const HandoffSignalTypeId: unique symbol;
+export declare const EmitTypeId: unique symbol;
+export declare type EmitTypeId = typeof EmitTypeId;
+export declare class Emit<A> {
+    readonly els: Conc<A>;
+    readonly _typeId: typeof HandoffSignalTypeId;
+    readonly _tag: typeof EmitTypeId;
+    constructor(els: Conc<A>);
+}
+export declare const HaltTypeId: unique symbol;
+export declare type HaltTypeId = typeof HaltTypeId;
+export declare class Halt<E> {
+    readonly error: Cause<E>;
+    readonly _typeId: typeof HandoffSignalTypeId;
+    readonly _tag: typeof HaltTypeId;
+    constructor(error: Cause<E>);
+}
+export declare const EndTypeId: unique symbol;
+export declare type EndTypeId = typeof EndTypeId;
+export declare class End<C> {
+    readonly reason: SinkEndReason<C>;
+    readonly _typeId: typeof HandoffSignalTypeId;
+    readonly _tag: typeof EndTypeId;
+    constructor(reason: SinkEndReason<C>);
+}
+/**
+ * @tsplus type fncts.io.Stream.HandoffSignal
+ */
+export declare type HandoffSignal<C, E, A> = Emit<A> | Halt<E> | End<C>;
+/**
+ * @tsplus type fncts.io.Stream.HandoffSignalOps
+ */
+export interface HandoffSignalOps {
+}
+export declare const HandoffSignal: HandoffSignalOps;
+/**
+ * @tsplus static fncts.io.Stream.HandoffSignalOps Emit
+ * @tsplus location "@fncts/io/Stream/internal/Handoff"
+ */
+export declare function emit<A>(els: Conc<A>): HandoffSignal<never, never, A>;
+/**
+ * @tsplus static fncts.io.Stream.HandoffSignalOps Halt
+ * @tsplus location "@fncts/io/Stream/internal/Handoff"
+ */
+export declare function halt<E>(error: Cause<E>): HandoffSignal<never, E, never>;
+/**
+ * @tsplus static fncts.io.Stream.HandoffSignalOps End
+ * @tsplus location "@fncts/io/Stream/internal/Handoff"
+ */
+export declare function end<C>(reason: SinkEndReason<C>): HandoffSignal<C, never, never>;
+/**
+ * @tsplus fluent fncts.io.Stream.HandoffSignal match
+ * @tsplus location "@fncts/io/Stream/internal/Handoff"
+ */
+export declare function matchSignal_<C, E, A, B, D, F>(signal: HandoffSignal<C, E, A>, cases: {
+    Emit: (_: Emit<A>) => B;
+    Halt: (_: Halt<E>) => D;
+    End: (_: End<C>) => F;
+}): B | D | F;

package/Stream/internal/Pull.d.ts

@@ -0,0 +1,48 @@
+import { IO, UIO, FIO } from "@fncts/io/IO/definition";
+import { Maybe } from "@fncts/base/data/Maybe";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { Cause } from "@fncts/base/data/Cause";
+import type { Queue } from "../../Queue.js";
+import type { Take } from "./Take.js";
+export declare type Pull<R, E, A> = IO<R, Maybe<E>, Conc<A>>;
+/**
+ * @tsplus type fncts.io.Stream.PullOps
+ */
+export interface PullOps {
+}
+export declare const Pull: PullOps;
+/**
+ * @tsplus static fncts.io.Stream.PullOps emit
+ * @tsplus location "@fncts/io/Stream/internal/Pull"
+ */
+export declare function emit<A>(a: A): UIO<Conc<A>>;
+/**
+ * @tsplus static fncts.io.Stream.PullOps emitChunk
+ * @tsplus location "@fncts/io/Stream/internal/Pull"
+ */
+export declare function emitChunk<A>(as: Conc<A>): UIO<Conc<A>>;
+/**
+ * @tsplus static fncts.io.Stream.PullOps fromQueue
+ * @tsplus location "@fncts/io/Stream/internal/Pull"
+ */
+export declare function fromQueue<E, A>(d: Queue.Dequeue<Take<E, A>>): FIO<Maybe<E>, Conc<A>>;
+/**
+ * @tsplus static fncts.io.Stream.PullOps fail
+ * @tsplus location "@fncts/io/Stream/internal/Pull"
+ */
+export declare function fail<E>(e: E): FIO<Maybe<E>, never>;
+/**
+ * @tsplus static fncts.io.Stream.PullOps failCause
+ * @tsplus location "@fncts/io/Stream/internal/Pull"
+ */
+export declare function failCause<E>(c: Cause<E>): FIO<Maybe<E>, never>;
+/**
+ * @tsplus static fncts.io.Stream.PullOps empty
+ * @tsplus location "@fncts/io/Stream/internal/Pull"
+ */
+export declare function empty<A>(): FIO<never, Conc<A>>;
+/**
+ * @tsplus static fncts.io.Stream.PullOps end
+ * @tsplus location "@fncts/io/Stream/internal/Pull"
+ */
+export declare const end: FIO<Maybe<never>, never>;

package/Stream/internal/SinkEndReason.d.ts

@@ -0,0 +1,39 @@
+export declare const enum SinkEndReasonTag {
+    SinkEnd = "SinkEnd",
+    ScheduleTimeout = "ScheduleTimeout",
+    ScheduleEnd = "ScheduleEnd",
+    UpstreamEnd = "UpstreamEnd"
+}
+export declare const SinkEndReasonTypeId: unique symbol;
+export declare class SinkEnd {
+    readonly _typeId: typeof SinkEndReasonTypeId;
+    readonly _tag = SinkEndReasonTag.SinkEnd;
+}
+export declare class ScheduleTimeout {
+    readonly _typeId: typeof SinkEndReasonTypeId;
+    readonly _tag = SinkEndReasonTag.ScheduleTimeout;
+}
+export declare class ScheduleEnd<C> {
+    readonly c: C;
+    readonly _typeId: typeof SinkEndReasonTypeId;
+    readonly _tag = SinkEndReasonTag.ScheduleEnd;
+    constructor(c: C);
+}
+export declare class UpstreamEnd {
+    readonly _typeId: typeof SinkEndReasonTypeId;
+    readonly _tag = SinkEndReasonTag.UpstreamEnd;
+}
+/**
+ * @tsplus type fncts.io.Stream.SinkEndReason
+ */
+export declare type SinkEndReason<C> = SinkEnd | ScheduleTimeout | ScheduleEnd<C> | UpstreamEnd;
+/**
+ * @tsplus fluent fncts.io.Stream.SinkEndReason match
+ * @tsplus location "@fncts/io/Stream/internal/SinkEndReason"
+ */
+export declare function matchSinkEndReason_<A, B, C, D, E>(self: SinkEndReason<A>, cases: {
+    SinkEnd: (_: SinkEnd) => B;
+    ScheduleTimeout: (_: ScheduleTimeout) => C;
+    ScheduleEnd: (_: ScheduleEnd<A>) => D;
+    UpstreamEnd: (_: UpstreamEnd) => E;
+}): B | C | D | E;

package/Stream/internal/Take.d.ts

@@ -0,0 +1,128 @@
+import { Exit } from "@fncts/base/data/Exit";
+import { Maybe } from "@fncts/base/data/Maybe";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { FIO, IO, URIO } from "@fncts/io/IO/definition";
+import { Cause } from "@fncts/base/data/Cause";
+import type { Pull } from "./Pull.js";
+/**
+ * A `Take<E, A>` represents a single `take` from a queue modeling a stream of
+ * values. A `Take` may be a failure cause `Cause<E>`, an chunk value `A`
+ * or an end-of-stream marker.
+ *
+ * @tsplus type fncts.io.Stream.Take
+ * @tsplus companion fncts.io.Stream.TakeOps
+ */
+export declare class Take<E, A> {
+    readonly exit: Exit<Maybe<E>, Conc<A>>;
+    readonly _E: () => E;
+    readonly _A: () => A;
+    constructor(exit: Exit<Maybe<E>, Conc<A>>);
+}
+/**
+ * Transforms `Take[E, A]` to `Effect[R, E, B]`.
+ * @tsplus getter fncts.io.Stream.Take done
+ * @tsplus location "@fncts/io/Stream/internal/Take"
+ */
+export declare function done<E, A>(self: Take<E, A>): FIO<Maybe<E>, Conc<A>>;
+/**
+ * Folds over the failure cause, success value and end-of-stream marker to
+ * yield a value.
+ * @tsplus fluent fncts.io.Stream.Take match
+ * @tsplus location "@fncts/io/Stream/internal/Take"
+ */
+export declare function match_<E, A, Z>(self: Take<E, A>, end: Z, error: (cause: Cause<E>) => Z, value: (chunk: Conc<A>) => Z): Z;
+/**
+ * Effectful version of `Take#fold`.
+ *
+ * Folds over the failure cause, success value and end-of-stream marker to
+ * yield an effect.
+ * @tsplus fluent fncts.io.Stream.Take matchIO
+ * @tsplus location "@fncts/io/Stream/internal/Take"
+ */
+export declare function matchIO_<R, R1, R2, E, E1, E2, E3, A, Z>(self: Take<E, A>, end: IO<R, E1, Z>, error: (cause: Cause<E>) => IO<R1, E2, Z>, value: (chunk: Conc<A>) => IO<R2, E3, Z>): IO<R & R1 & R2, E1 | E2 | E3, Z>;
+/**
+ * Checks if this `take` is done (`Take.end`).
+ * @tsplus getter fncts.io.Stream.Take isDone
+ * @tsplus location "@fncts/io/Stream/internal/Take"
+ */
+export declare function isDone<E, A>(self: Take<E, A>): boolean;
+/**
+ * Checks if this `take` is a failure.
+ * @tsplus getter fncts.io.Stream.Take isFailure
+ * @tsplus location "@fncts/io/Stream/internal/Take"
+ */
+export declare function isFailure<E, A>(self: Take<E, A>): boolean;
+/**
+ * Checks if this `take` is a success.
+ * @tsplus getter fncts.io.Stream.Take isSuccess
+ * @tsplus location "@fncts/io/Stream/internal/Take"
+ */
+export declare function isSuccess<E, A>(self: Take<E, A>): boolean;
+/**
+ * Transforms `Take<E, A>` to `Take<E, B>` by applying function `f`.
+ * @tsplus fluent fncts.io.Stream.Take map
+ * @tsplus location "@fncts/io/Stream/internal/Take"
+ */
+export declare function map_<E, A, B>(self: Take<E, A>, f: (a: A) => B): Take<E, B>;
+/**
+ * Returns an effect that effectfully "peeks" at the success of this take.
+ * @tsplus fluent fncts.io.Stream.Take tap
+ * @tsplus location "@fncts/io/Stream/internal/Take"
+ */
+export declare function tap_<R, E, E1, A>(self: Take<E, A>, f: (chunk: Conc<A>) => IO<R, E1, any>): IO<R, E1, void>;
+/**
+ * Creates a `Take<never, A>` with a singleton chunk.
+ * @tsplus static fncts.io.Stream.TakeOps single
+ * @tsplus location "@fncts/io/Stream/internal/Take"
+ */
+export declare function single<A>(a: A): Take<never, A>;
+/**
+ * Creates a `Take[Nothing, A]` with the specified chunk.
+ * @tsplus static fncts.io.Stream.TakeOps chunk
+ * @tsplus location "@fncts/io/Stream/internal/Take"
+ */
+export declare function chunk<A>(as: Conc<A>): Take<never, A>;
+/**
+ * Creates a failing `Take<E, unknown>` with the specified failure.
+ * @tsplus static fncts.io.Stream.TakeOps fail
+ * @tsplus location "@fncts/io/Stream/internal/Take"
+ */
+export declare function fail<E>(e: E): Take<E, never>;
+/**
+ * Creates an effect from `Effect<R, E,A>` that does not fail, but succeeds with the `Take<E, A>`.
+ * Error from stream when pulling is converted to `Take.halt`. Creates a singleton chunk.
+ * @tsplus static fncts.io.Stream.TakeOps fromIO
+ * @tsplus location "@fncts/io/Stream/internal/Take"
+ */
+export declare function fromIO<R, E, A>(effect: IO<R, E, A>): URIO<R, Take<E, A>>;
+/**
+ * Creates effect from `Pull<R, E, A>` that does not fail, but succeeds with the `Take<E, A>`.
+ * Error from stream when pulling is converted to `Take.halt`, end of stream to `Take.end`.
+ * @tsplus static fncts.io.Stream.TakeOps fromPull
+ * @tsplus location "@fncts/io/Stream/internal/Take"
+ */
+export declare function fromPull<R, E, A>(pull: Pull<R, E, A>): URIO<R, Take<E, A>>;
+/**
+ * Creates a failing `Take<E, never>` with the specified cause.
+ * @tsplus static fncts.io.Stream.TakeOps failCause
+ * @tsplus location "@fncts/io/Stream/internal/Take"
+ */
+export declare function failCause<E>(c: Cause<E>): Take<E, never>;
+/**
+ * Creates a failing `Take<never, never>` with the specified throwable.
+ * @tsplus static fncts.io.Stream.TakeOps halt
+ * @tsplus location "@fncts/io/Stream/internal/Take"
+ */
+export declare function halt<E>(e: E): Take<never, never>;
+/**
+ * Creates a `Take<E, A>` from `Exit<E, A>`.
+ * @tsplus static fncts.io.Stream.TakeOps fromExit
+ * @tsplus location "@fncts/io/Stream/internal/Take"
+ */
+export declare function fromExit<E, A>(exit: Exit<E, A>): Take<E, A>;
+/**
+ * End-of-stream marker
+ * @tsplus static fncts.io.Stream.TakeOps end
+ * @tsplus location "@fncts/io/Stream/internal/Take"
+ */
+export declare const end: Take<never, never>;

package/Stream/internal/util.d.ts

@@ -0,0 +1,3 @@
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { Either } from "@fncts/base/data/Either";
+export declare function zipChunks<A, B, C>(fa: Conc<A>, fb: Conc<B>, f: (a: A, b: B) => C): readonly [Conc<C>, Either<Conc<A>, Conc<B>>];

package/Stream.d.ts

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

package/Supervisor/api.d.ts

@@ -0,0 +1,10 @@
+import { Supervisor } from "@fncts/io/Supervisor/definition";
+import { Environment } from "@fncts/base/data/Environment";
+import { IO } from "@fncts/io/IO/definition";
+import { Maybe } from "@fncts/base/data/Maybe";
+import { Exit } from "@fncts/base/data/Exit";
+/**
+ * @tsplus fluent fncts.io.Supervisor zip
+ * @tsplus location "@fncts/io/Supervisor/api"
+ */
+export declare function zip_<A, B>(fa: Supervisor<A>, fb: Supervisor<B>): Supervisor<readonly [A, B]>;

package/Supervisor/constructors.d.ts

@@ -0,0 +1,34 @@
+import { Supervisor } from "@fncts/io/Supervisor/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { Environment } from "@fncts/base/data/Environment";
+import { IO, UIO } from "@fncts/io/IO/definition";
+import { Maybe } from "@fncts/base/data/Maybe";
+import { Exit } from "@fncts/base/data/Exit";
+import { HashSet } from "@fncts/base/collection/immutable/HashSet";
+import type { AtomicReference } from "@fncts/base/internal/AtomicReference";
+import { ConstSupervisor } from "./definition.js";
+/**
+ * @tsplus static fncts.io.SupervisorOps unsafeTrack
+ * @tsplus location "@fncts/io/Supervisor/constructors"
+ */
+export declare function unsafeTrack(): Supervisor<Conc<Fiber.Runtime<any, any>>>;
+/**
+ * @tsplus static fncts.io.SupervisorOps fibersIn
+ * @tsplus location "@fncts/io/Supervisor/constructors"
+ */
+export declare function fibersIn(ref: AtomicReference<HashSet<Fiber.Runtime<any, any>>>): UIO<Supervisor<HashSet<Fiber.Runtime<any, any>>>>;
+/**
+ * @tsplus static fncts.io.SupervisorOps fromIO
+ * @tsplus location "@fncts/io/Supervisor/constructors"
+ */
+export declare function fromIO<A>(ma: UIO<A>): Supervisor<A>;
+/**
+ * @tsplus static fncts.io.SupervisorOps none
+ * @tsplus location "@fncts/io/Supervisor/constructors"
+ */
+export declare const none: ConstSupervisor<void>;
+/**
+ * @tsplus static fncts.io.SupervisorOps track
+ * @tsplus location "@fncts/io/Supervisor/constructors"
+ */
+export declare const track: UIO<Supervisor<Conc<Fiber.Runtime<any, any>>>>;

package/Supervisor/definition.d.ts

@@ -0,0 +1,35 @@
+import { UIO, IO } from "@fncts/io/IO/definition";
+import { Environment } from "@fncts/base/data/Environment";
+import { Maybe } from "@fncts/base/data/Maybe";
+import { Exit } from "@fncts/base/data/Exit";
+/**
+ * @tsplus type fncts.io.Supervisor
+ * @tsplus companion fncts.io.SupervisorOps
+ */
+export declare abstract class Supervisor<A> {
+    abstract readonly value: UIO<A>;
+    abstract unsafeOnStart<R, E, A>(environment: Environment<R>, effect: IO<R, E, A>, parent: Maybe<Fiber.Runtime<E, A>>, fiber: Fiber.Runtime<E, A>): void;
+    abstract unsafeOnEnd<E, A>(value: Exit<E, A>, fiber: Fiber.Runtime<E, A>): void;
+    unsafeOnEffect<E, A>(_fiber: Fiber.Runtime<E, A>, _effect: IO<any, any, any>): void;
+    unsafeOnSuspend<E, A>(_fiber: Fiber.Runtime<E, A>): void;
+    unsafeOnResume<E, A>(_fiber: Fiber.Runtime<E, A>): void;
+}
+export declare class ConstSupervisor<A> extends Supervisor<A> {
+    readonly value: UIO<A>;
+    constructor(value: UIO<A>);
+    unsafeOnStart(): void;
+    unsafeOnEnd(): void;
+    unsafeOnEffect(): void;
+    unsafeOnSuspend(): void;
+    unsafeOnResume(): void;
+}
+export declare class ProxySupervisor<A> extends Supervisor<A> {
+    readonly value: UIO<A>;
+    readonly underlying: Supervisor<any>;
+    constructor(value: UIO<A>, underlying: Supervisor<any>);
+    unsafeOnStart<R, E, A>(environment: Environment<R>, effect: IO<R, E, A>, parent: Maybe<Fiber.Runtime<E, A>>, fiber: Fiber.Runtime<E, A>): void;
+    unsafeOnEnd<E, A>(value: Exit<E, A>, fiber: Fiber.Runtime<E, A>): void;
+    unsafeOnEffect<E, A>(fiber: Fiber.Runtime<E, A>, effect: IO<any, any, any>): void;
+    unsafeOnSuspend<E, A>(fiber: Fiber.Runtime<E, A>): void;
+    unsafeOnResume<E, A>(fiber: Fiber.Runtime<E, A>): void;
+}

package/Supervisor.d.ts

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

package/TExit/constructors.d.ts

@@ -0,0 +1,32 @@
+import { TExit } from "@fncts/io/TExit/definition";
+import { FiberId } from "@fncts/base/data/FiberId";
+/**
+ * @tsplus static fncts.TExitOps unit
+ * @tsplus location "@fncts/io/TExit/constructors"
+ */
+export declare const unit: TExit<never, void>;
+/**
+ * @tsplus static fncts.TExitOps succeed
+ * @tsplus location "@fncts/io/TExit/constructors"
+ */
+export declare function succeed<E = never, A = never>(a: A): TExit<E, A>;
+/**
+ * @tsplus static fncts.TExitOps fail
+ * @tsplus location "@fncts/io/TExit/constructors"
+ */
+export declare function fail<E = never, A = never>(e: E): TExit<E, A>;
+/**
+ * @tsplus static fncts.TExitOps halt
+ * @tsplus location "@fncts/io/TExit/constructors"
+ */
+export declare function halt(e: unknown): TExit<never, never>;
+/**
+ * @tsplus static fncts.TExitOps retry
+ * @tsplus location "@fncts/io/TExit/constructors"
+ */
+export declare const retry: TExit<never, never>;
+/**
+ * @tsplus static fncts.TExitOps interrupt
+ * @tsplus location "@fncts/io/TExit/constructors"
+ */
+export declare function interrupt(fiberId: FiberId): TExit<never, never>;

package/TExit/definition.d.ts

@@ -0,0 +1,90 @@
+import { FiberId } from "@fncts/base/data/FiberId";
+/**
+ * @tsplus type fncts.TExit
+ */
+export declare type TExit<E, A> = Fail<E> | Succeed<A> | Retry | Halt | Interrupt;
+/**
+ * @tsplus type fncts.TExitOps
+ */
+export interface TExitOps {
+}
+export declare const TExit: TExitOps;
+export declare const TExitTypeId: unique symbol;
+export declare type TExitTypeId = typeof TExitTypeId;
+export declare const enum TExitTag {
+    Fail = "Fail",
+    Succeed = "Succeed",
+    Halt = "Halt",
+    Interrupt = "Interrupt",
+    Retry = "Retry"
+}
+export declare const FailTypeId: unique symbol;
+export declare type FailTypeId = typeof FailTypeId;
+/**
+ * @tsplus static fncts.TExitOps isTExit
+ * @tsplus location "@fncts/io/TExit/definition"
+ */
+export declare function isTExit(u: unknown): u is TExit<unknown, unknown>;
+export declare class Fail<E> {
+    readonly value: E;
+    readonly _typeId: TExitTypeId;
+    readonly _tag = TExitTag.Fail;
+    constructor(value: E);
+    get [Symbol.hash](): number;
+    [Symbol.equals](that: unknown): boolean;
+}
+/**
+ * @tsplus fluent fncts.TExit isFail
+ * @tsplus location "@fncts/io/TExit/definition"
+ */
+export declare function isFail<E, A>(self: TExit<E, A>): self is Fail<E>;
+export declare class Succeed<A> {
+    readonly value: A;
+    readonly _typeId: TExitTypeId;
+    readonly _tag = TExitTag.Succeed;
+    constructor(value: A);
+    get [Symbol.hash](): number;
+    [Symbol.equals](that: unknown): boolean;
+}
+/**
+ * @tsplus fluent fncts.TExit isSucceed
+ * @tsplus location "@fncts/io/TExit/definition"
+ */
+export declare function isSucceed<E, A>(self: TExit<E, A>): self is Succeed<A>;
+export declare class Halt {
+    readonly value: unknown;
+    readonly _typeId: TExitTypeId;
+    readonly _tag = TExitTag.Halt;
+    constructor(value: unknown);
+    get [Symbol.hash](): number;
+    [Symbol.equals](that: unknown): boolean;
+}
+/**
+ * @tsplus fluent fncts.TExit isHalt
+ * @tsplus location "@fncts/io/TExit/definition"
+ */
+export declare function isHalt<E, A>(self: TExit<E, A>): self is Halt;
+export declare class Interrupt {
+    readonly fiberId: FiberId;
+    readonly _typeId: symbol;
+    readonly _tag = TExitTag.Interrupt;
+    constructor(fiberId: FiberId);
+    get [Symbol.hash](): number;
+    [Symbol.equals](that: unknown): boolean;
+}
+/**
+ * @tsplus fluent fncts.TExit isInterrupt
+ * @tsplus location "@fncts/io/TExit/definition"
+ */
+export declare function isInterrupt<E, A>(self: TExit<E, A>): self is Interrupt;
+export declare class Retry {
+    readonly _typeId: TExitTypeId;
+    readonly _tag = TExitTag.Retry;
+    get [Symbol.hash](): number;
+    [Symbol.equals](that: unknown): boolean;
+}
+/**
+ * @tsplus fluent fncts.TExit isRetry
+ * @tsplus location "@fncts/io/TExit/definition"
+ */
+export declare function isRetry<E, A>(self: TExit<E, A>): self is Retry;

package/TExit.d.ts

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