@fncts/io 0.0.1

package/Fiber/FiberContext.d.ts

@@ -0,0 +1,145 @@
+import { HashMap } from "@fncts/base/collection/immutable/HashMap";
+import { FiberRef } from "@fncts/io/FiberRef/definition";
+import { Cons, List } from "@fncts/base/collection/immutable/List";
+import { IO, UIO } from "@fncts/io/IO/definition";
+import { Maybe } from "@fncts/base/data/Maybe";
+import { Hashable } from "@fncts/base/typeclass/Hashable";
+import { Equatable } from "@fncts/base/typeclass/Equatable";
+import { Supervisor } from "@fncts/io/Supervisor/definition";
+import { RuntimeConfig } from "@fncts/io/RuntimeConfig";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { Exit } from "@fncts/base/data/Exit";
+import { Either } from "@fncts/base/data/Either";
+import { FiberScope } from "@fncts/io/FiberScope/definition";
+import { Trace } from "@fncts/base/data/Trace/definition";
+import { FiberId } from "@fncts/base/data/FiberId";
+import { Cause } from "@fncts/base/data/Cause";
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { LogLevel } from "@fncts/io/LogLevel";
+import type { Instruction, Match } from "@fncts/io/IO/definition";
+import { TraceElement } from "@fncts/base/data/TraceElement";
+import { AtomicReference } from "@fncts/base/internal/AtomicReference";
+import { Stack } from "@fncts/base/internal/Stack";
+import { FiberTypeId } from "@fncts/io/Fiber/definition";
+import { FiberState } from "@fncts/io/FiberState";
+import { FiberStatus } from "@fncts/io/FiberStatus";
+export declare type FiberRefLocals = AtomicReference<HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>>;
+declare type Erased = IO<any, any, any>;
+declare type ErasedCont = (a: any) => Erased;
+export declare class InterruptExit {
+    readonly apply: ErasedCont;
+    readonly trace?: string | undefined;
+    readonly _tag = "InterruptExit";
+    constructor(apply: ErasedCont, trace?: string | undefined);
+}
+export declare class HandlerFrame {
+    readonly apply: ErasedCont;
+    readonly trace?: string | undefined;
+    readonly _tag = "HandlerFrame";
+    constructor(apply: ErasedCont, trace?: string | undefined);
+}
+export declare class TracedCont {
+    readonly apply: ErasedCont;
+    readonly trace?: string | undefined;
+    readonly _tag = "TracedCont";
+    constructor(apply: ErasedCont, trace?: string | undefined);
+}
+export declare class Finalizer {
+    readonly finalizer: UIO<any>;
+    readonly apply: ErasedCont;
+    readonly trace?: string | undefined;
+    readonly _tag = "Finalizer";
+    constructor(finalizer: UIO<any>, apply: ErasedCont, trace?: string | undefined);
+}
+export declare type Frame = InterruptExit | Match<any, any, any, any, any, any, any, any, any> | HandlerFrame | TracedCont | Finalizer;
+export declare const currentFiber: AtomicReference<FiberContext<any, any> | null>;
+export declare function unsafeCurrentFiber(): Maybe<FiberContext<any, any>>;
+/**
+ * `FiberContext` provides all of the context and facilities required to run a `IO`
+ *
+ * @tsplus type fncts.io.Fiber
+ */
+export declare class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equatable {
+    protected readonly fiberId: FiberId.Runtime;
+    private runtimeConfig;
+    private interruptStatus;
+    private fiberRefLocals;
+    private readonly _children;
+    readonly _typeId: FiberTypeId;
+    readonly _tag = "RuntimeFiber";
+    readonly _E: () => E;
+    readonly _A: () => A;
+    get [Symbol.hash](): number;
+    [Symbol.equals](that: unknown): boolean;
+    private state;
+    private asyncEpoch;
+    private stack;
+    nextIO: Instruction | null;
+    private currentSupervisor;
+    constructor(fiberId: FiberId.Runtime, runtimeConfig: RuntimeConfig, interruptStatus: Stack<boolean>, fiberRefLocals: FiberRefLocals, _children: Set<FiberContext<unknown, unknown>>);
+    get poll(): import("@fncts/io/IO/definition").UIO<import("@fncts/base/data/Maybe").Maybe<import("@fncts/base/data/Exit").Success<A> | import("@fncts/base/data/Exit").Failure<E>>>;
+    get inheritRefs(): UIO<void>;
+    get id(): import("@fncts/base/data/FiberId").Runtime;
+    awaitAsync(k: FiberState.Callback<E, A>): void;
+    get children(): UIO<Conc<Fiber.Runtime<any, any>>>;
+    evalOnIO<R1, E1, B, R2, E2, C>(effect: IO<R1, E1, B>, orElse: IO<R2, E2, C>, __tsplusTrace?: string): IO<R1 & R2, E1 | E2, B | C>;
+    get await(): UIO<Exit<E, A>>;
+    run(): void;
+    get scope(): FiberScope;
+    get status(): UIO<FiberStatus>;
+    get trace(): UIO<Trace>;
+    interruptAs(fiberId: FiberId): UIO<Exit<E, A>>;
+    evalOn(effect: UIO<any>, orElse: UIO<any>): UIO<void>;
+    get location(): TraceElement;
+    /**
+     * The main evaluator loop for the fiber. For purely synchronous effects, this will run either
+     * to completion, or for the specified maximum operation count. For effects with asynchronous
+     * callbacks, the loop will proceed no further than the first asynchronous boundary.
+     */
+    runUntil(maxOpCount: number): void;
+    unsafeRunLater(i0: Instruction): void;
+    private unsafeGetRef;
+    private unsafeGetRefs;
+    private unsafeSetRef;
+    private unsafeDeleteRef;
+    private unsafePoll;
+    private interruptExit;
+    private unsafeAddFinalizer;
+    private get unsafeIsInterruptible();
+    private get unsafeIsInterrupted();
+    private get unsafeIsInterrupting();
+    private get unsafeShouldInterrupt();
+    private unsafeDisableInterruption;
+    private unsafeRestoreInterruptStatus;
+    private unsafeAddSuppressedCause;
+    /**
+     * Unwinds the stack, looking for the first error handler, and exiting
+     * interruptible / uninterruptible regions.
+     */
+    private unsafeUnwindStack;
+    private unsafeAddObserver;
+    private unsafeNextEffect;
+    private unsafeNotifyObservers;
+    private unsafeRemoveObserver;
+    private unsafeInterruptAs;
+    private unsafeTryDone;
+    private unsafeSetAsyncCanceller;
+    private unsafeReportUnhandled;
+    private unsafeSetInterrupting;
+    private unsafeEnterAsync;
+    private unsafeExitAsync;
+    private unsafeCreateAsyncResume;
+    private unsafeFork;
+    unsafeOnDone(k: FiberState.Callback<never, Exit<E, A>>): void;
+    private unsafeClearSuppressedCause;
+    private unsafeGetDescriptor;
+    private unsafeRace;
+    private unsafeCompleteRace;
+    private unsafeCaptureTrace;
+    private unsafeEvalOn;
+    private unsafeDrainMailbox;
+    unsafeAddChild(child: FiberContext<unknown, unknown>): void;
+    private unsafeLog;
+    private unsafeLogWith;
+}
+export {};

package/Fiber/api/await.d.ts

@@ -0,0 +1,8 @@
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { UIO } from "@fncts/io/IO/definition";
+import { Exit } from "@fncts/base/data/Exit";
+/**
+ * @tsplus getter fncts.io.Fiber await
+ * @tsplus location "@fncts/io/Fiber/api/await"
+ */
+export declare function wait<E, A>(fiber: Fiber<E, A>): UIO<Exit<E, A>>;

package/Fiber/api/awaitAll.d.ts

@@ -0,0 +1,10 @@
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { IO } from "@fncts/io/IO/definition";
+import { Exit } from "@fncts/base/data/Exit";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+/**
+ * Awaits on all fibers to be completed, successfully or not.
+ * @tsplus static fncts.io.FiberOps awaitAll
+ * @tsplus location "@fncts/io/Fiber/api/awaitAll"
+ */
+export declare function awaitAll<E, A>(as: Iterable<Fiber<E, A>>): IO<unknown, never, Exit<E, Conc<A>>>;

package/Fiber/api/children.d.ts

@@ -0,0 +1,8 @@
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { UIO } from "@fncts/io/IO/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+/**
+ * @tsplus getter fncts.io.Fiber children
+ * @tsplus location "@fncts/io/Fiber/api/children"
+ */
+export declare function children<E, A>(self: Fiber<E, A>): UIO<Conc<Fiber.Runtime<any, any>>>;

package/Fiber/api/collectAll.d.ts

@@ -0,0 +1,11 @@
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { FiberId } from "@fncts/base/data/FiberId";
+import { Exit } from "@fncts/base/data/Exit";
+/**
+ * Collects all fibers into a single fiber producing an in-order list of the
+ * results.
+ * @tsplus static fncts.io.FiberOps sequenceIterable
+ * @tsplus location "@fncts/io/Fiber/api/collectAll"
+ */
+export declare function sequenceIterable<E, A>(fibers: Iterable<Fiber<E, A>>): Fiber.Synthetic<E, Conc<A>>;

package/Fiber/api/evalOn.d.ts

@@ -0,0 +1,7 @@
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { UIO } from "@fncts/io/IO/definition";
+/**
+ * @tsplus fluent fncts.io.Fiber evalOn
+ * @tsplus location "@fncts/io/Fiber/api/evalOn"
+ */
+export declare function evalOn_<E, A>(fiber: Fiber<E, A>, effect: UIO<any>, orElse: UIO<any>): UIO<void>;

package/Fiber/api/evalOnIO.d.ts

@@ -0,0 +1,9 @@
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { IO } from "@fncts/io/IO/definition";
+/**
+ * A fully-featured, but much slower version of `evalOn`, which is useful
+ * when environment and error are required.
+ * @tsplus fluent fncts.io.Fiber evalOnIO
+ * @tsplus location "@fncts/io/Fiber/api/evalOnIO"
+ */
+export declare function evalOnIO_<E, A, R1, E1, B, R2, E2, C>(fiber: Fiber<E, A>, effect: IO<R1, E1, B>, orElse: IO<R2, E2, C>): IO<R1 & R2, E1 | E2, B | C>;

package/Fiber/api/fromIO.d.ts

@@ -0,0 +1,8 @@
+import { FIO, UIO } from "@fncts/io/IO/definition";
+import { Fiber } from "@fncts/io/Fiber/definition";
+/**
+ * Lifts an `IO` into a `Fiber`.
+ * @tsplus static fncts.io.FiberOps fromIO
+ * @tsplus location "@fncts/io/Fiber/api/fromIO"
+ */
+export declare function fromIO<E, A>(effect: FIO<E, A>): UIO<Fiber<E, A>>;

package/Fiber/api/id.d.ts

@@ -0,0 +1,7 @@
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { FiberId } from "@fncts/base/data/FiberId";
+/**
+ * @tsplus getter fncts.io.Fiber id
+ * @tsplus location "@fncts/io/Fiber/api/id"
+ */
+export declare function id<E, A>(self: Fiber<E, A>): FiberId;

package/Fiber/api/inheritRefs.d.ts

@@ -0,0 +1,7 @@
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { UIO } from "@fncts/io/IO/definition";
+/**
+ * @tsplus getter fncts.io.Fiber inheritRefs
+ * @tsplus location "@fncts/io/Fiber/api/inheritRefs"
+ */
+export declare function inheritRefs<E, A>(fiber: Fiber<E, A>): UIO<void>;

package/Fiber/api/interrupt.d.ts

@@ -0,0 +1,11 @@
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { UIO } from "@fncts/io/IO/definition";
+import { Exit } from "@fncts/base/data/Exit";
+/**
+ * Interrupts the fiber from whichever fiber is calling this method. If the
+ * fiber has already exited, the returned effect will resume immediately.
+ * Otherwise, the effect will resume when the fiber exits.
+ * @tsplus getter fncts.io.Fiber interrupt
+ * @tsplus location "@fncts/io/Fiber/api/interrupt"
+ */
+export declare function interrupt<E, A>(fiber: Fiber<E, A>): UIO<Exit<E, A>>;

package/Fiber/api/interruptAll.d.ts

@@ -0,0 +1,15 @@
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { FiberId } from "@fncts/base/data/FiberId";
+import { UIO } from "@fncts/io/IO/definition";
+/**
+ * Interrupts all fibers as by the specified fiber, awaiting their interruption.
+ * @tsplus static fncts.io.FiberOps interruptAllAs
+ * @tsplus location "@fncts/io/Fiber/api/interruptAll"
+ */
+export declare function interruptAllAs_(fs: Iterable<Fiber<any, any>>, id: FiberId): UIO<void>;
+/**
+ * Interrupts all fibers and awaits their interruption
+ * @tsplus static fncts.io.FiberOps interruptAll
+ * @tsplus location "@fncts/io/Fiber/api/interruptAll"
+ */
+export declare function interruptAll(fs: Iterable<Fiber<any, any>>): UIO<void>;

package/Fiber/api/interruptAs.d.ts

@@ -0,0 +1,9 @@
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { FiberId } from "@fncts/base/data/FiberId";
+import { UIO } from "@fncts/io/IO/definition";
+import { Exit } from "@fncts/base/data/Exit";
+/**
+ * @tsplus fluent fncts.io.Fiber interruptAs
+ * @tsplus location "@fncts/io/Fiber/api/interruptAs"
+ */
+export declare function interruptAs<E, A>(self: Fiber<E, A>, fiberId: FiberId): UIO<Exit<E, A>>;

package/Fiber/api/interruptFork.d.ts

@@ -0,0 +1,10 @@
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { UIO } from "@fncts/io/IO/definition";
+/**
+ * Interrupts the fiber from whichever fiber is calling this method. The
+ * interruption will happen in a separate daemon fiber, and the returned
+ * effect will always resume immediately without waiting.
+ * @tsplus getter fncts.io.Fiber interruptFork
+ * @tsplus location "@fncts/io/Fiber/api/interruptFork"
+ */
+export declare function interruptFork<E, A>(fiber: Fiber<E, A>): UIO<void>;

package/Fiber/api/join.d.ts

@@ -0,0 +1,12 @@
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { FIO } from "@fncts/io/IO/definition";
+/**
+ * Joins the fiber, which suspends the joining fiber until the result of the
+ * fiber has been determined. Attempting to join a fiber that has erred will
+ * result in a catchable error. Joining an interrupted fiber will result in an
+ * "inner interruption" of this fiber, unlike interruption triggered by another
+ * fiber, "inner interruption" can be caught and recovered.
+ * @tsplus getter fncts.io.Fiber join
+ * @tsplus location "@fncts/io/Fiber/api/join"
+ */
+export declare function join<E, A>(fiber: Fiber<E, A>): FIO<E, A>;

package/Fiber/api/joinAll.d.ts

@@ -0,0 +1,11 @@
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { IO } from "@fncts/io/IO/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+/**
+ * Joins all fibers, awaiting their _successful_ completion.
+ * Attempting to join a fiber that has erred will result in
+ * a catchable error, _if_ that error does not result from interruption.
+ * @tsplus static fncts.io.FiberOps joinAll
+ * @tsplus location "@fncts/io/Fiber/api/joinAll"
+ */
+export declare function joinAll<E, A>(as: Iterable<Fiber<E, A>>): IO<unknown, E, Conc<A>>;

package/Fiber/api/location.d.ts

@@ -0,0 +1,7 @@
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { TraceElement } from "@fncts/base/data/TraceElement/definition";
+/**
+ * @tsplus getter fncts.io.Fiber location
+ * @tsplus location "@fncts/io/Fiber/api/location"
+ */
+export declare function location<E, A>(self: Fiber<E, A>): TraceElement;

package/Fiber/api/mapFiber.d.ts

@@ -0,0 +1,9 @@
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { UIO } from "@fncts/io/IO/definition";
+/**
+ * Passes the success of this fiber to the specified callback, and continues
+ * with the fiber that it returns.
+ * @tsplus fluent fncts.io.Fiber mapFiber
+ * @tsplus location "@fncts/io/Fiber/api/mapFiber"
+ */
+export declare function mapFiber_<A, E, E1, A1>(fiber: Fiber<E, A>, f: (a: A) => Fiber<E1, A1>): UIO<Fiber<E | E1, A1>>;

package/Fiber/api/mapIO.d.ts

@@ -0,0 +1,14 @@
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { FIO } from "@fncts/io/IO/definition";
+/**
+ * Effectfully maps over the value the fiber computes.
+ * @tsplus fluent fncts.io.Fiber mapIO
+ * @tsplus location "@fncts/io/Fiber/api/mapIO"
+ */
+export declare function mapIO_<E, E1, A, B>(fiber: Fiber<E, A>, f: (a: A) => FIO<E1, B>): Fiber<E | E1, B>;
+/**
+ * Maps over the value the fiber computes.
+ * @tsplus fluent fncts.io.Fiber map
+ * @tsplus location "@fncts/io/Fiber/api/mapIO"
+ */
+export declare function map_<E, A, B>(fa: Fiber<E, A>, f: (a: A) => B): Fiber<E, B>;

package/Fiber/api/poll.d.ts

@@ -0,0 +1,9 @@
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { UIO } from "@fncts/io/IO/definition";
+import { Maybe } from "@fncts/base/data/Maybe";
+import { Exit } from "@fncts/base/data/Exit";
+/**
+ * @tsplus getter fncts.io.Fiber poll
+ * @tsplus location "@fncts/io/Fiber/api/poll"
+ */
+export declare function poll<E, A>(self: Fiber<E, A>): UIO<Maybe<Exit<E, A>>>;

package/Fiber/api/zipWith.d.ts

@@ -0,0 +1,9 @@
+import { Fiber } from "@fncts/io/Fiber/definition";
+/**
+ * Zips this fiber with the specified fiber, combining their results using
+ * the specified combiner function. Both joins and interruptions are performed
+ * in sequential order from left to right.
+ * @tsplus fluent fncts.io.Fiber zipWith
+ * @tsplus location "@fncts/io/Fiber/api/zipWith"
+ */
+export declare function zipWith_<E, A, E1, B, C>(self: Fiber<E, A>, that: Fiber<E1, B>, f: (a: A, b: B) => C): Fiber<E | E1, C>;

package/Fiber/constructors.d.ts

@@ -0,0 +1,29 @@
+import { Exit } from "@fncts/base/data/Exit";
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { Cause } from "@fncts/base/data/Cause";
+import { FiberId } from "@fncts/base/data/FiberId";
+/**
+ * @tsplus static fncts.io.FiberOps done
+ * @tsplus location "@fncts/io/Fiber/constructors"
+ */
+export declare function done<E, A>(exit: Exit<E, A>): Fiber<E, A>;
+/**
+ * @tsplus static fncts.io.FiberOps fail
+ * @tsplus location "@fncts/io/Fiber/constructors"
+ */
+export declare function fail<E>(e: E): Fiber<E, never>;
+/**
+ * @tsplus static fncts.io.FiberOps failCause
+ * @tsplus location "@fncts/io/Fiber/constructors"
+ */
+export declare function failCause<E>(cause: Cause<E>): Fiber<E, never>;
+/**
+ * @tsplus static fncts.io.FiberOps interruptAs
+ * @tsplus location "@fncts/io/Fiber/constructors"
+ */
+export declare function interrupted(id: FiberId): Fiber<never, never>;
+/**
+ * @tsplus static fncts.io.FiberOps succeed
+ * @tsplus location "@fncts/io/Fiber/constructors"
+ */
+export declare function succeed<A>(a: A): Fiber<never, A>;

package/Fiber/definition.d.ts

@@ -0,0 +1,102 @@
+import { FiberId } from "@fncts/base/data/FiberId";
+import { UIO, IO } from "@fncts/io/IO/definition";
+import { Exit } from "@fncts/base/data/Exit";
+import { Maybe } from "@fncts/base/data/Maybe";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { TraceElement } from "@fncts/base/data/TraceElement/definition";
+import { Trace } from "@fncts/base/data/Trace/definition";
+import type { FiberStatus } from "@fncts/io/FiberStatus";
+export declare const FiberTypeId: unique symbol;
+export declare type FiberTypeId = typeof FiberTypeId;
+/**
+ * @tsplus type fncts.io.Fiber
+ */
+export interface Fiber<E, A> {
+    readonly _typeId: FiberTypeId;
+    readonly _E: () => E;
+    readonly _A: () => A;
+}
+/**
+ * @tsplus type fncts.io.FiberOps
+ */
+export interface FiberOps {
+}
+export declare const Fiber: FiberOps;
+export declare namespace Fiber {
+    type Runtime<E, A> = RuntimeFiber<E, A>;
+    type Synthetic<E, A> = SyntheticFiber<E, A>;
+}
+export interface FiberCommon<E, A> extends Fiber<E, A> {
+    readonly id: FiberId;
+    /**
+     * Awaits the fiber, which suspends the awaiting fiber until the result of the
+     * fiber has been determined.
+     */
+    readonly await: UIO<Exit<E, A>>;
+    /**
+     * Inherits values from all {@link FiberRef} instances into current fiber.
+     * This will resume immediately.
+     */
+    readonly inheritRefs: UIO<void>;
+    /**
+     * Interrupts the fiber as if interrupted from the specified fiber. If the
+     * fiber has already exited, the returned effect will resume immediately.
+     * Otherwise, the effect will resume when the fiber exits.
+     */
+    readonly interruptAs: (fiberId: FiberId) => UIO<Exit<E, A>>;
+    /**
+     * Tentatively observes the fiber, but returns immediately if it is not already done.
+     */
+    readonly poll: UIO<Maybe<Exit<E, A>>>;
+    /**
+     * Retrieves the immediate children of the fiber.
+     */
+    readonly children: UIO<Conc<Fiber.Runtime<any, any>>>;
+}
+export interface RuntimeFiber<E, A> extends FiberCommon<E, A> {
+    readonly _tag: "RuntimeFiber";
+    /**
+     * The identity of the Fiber
+     */
+    readonly id: FiberId.Runtime;
+    /**
+     * The location the fiber was forked from
+     */
+    readonly location: TraceElement;
+    /**
+     * Evaluates the specified effect on the fiber. If this is not possible,
+     * because the fiber has already ended life, then the specified alternate
+     * effect will be executed instead.
+     */
+    readonly evalOn: (effect: UIO<any>, orElse: UIO<any>) => UIO<void>;
+    readonly evalOnIO: <R1, E1, B, R2, E2, C>(effect: IO<R1, E1, B>, orElse: IO<R2, E2, C>) => IO<R1 & R2, E1 | E2, B | C>;
+    /**
+     * The status of the fiber.
+     */
+    readonly status: UIO<FiberStatus>;
+    /**
+     * The trace of the Fiber
+     */
+    readonly trace: UIO<Trace>;
+}
+export declare class SyntheticFiber<E, A> implements FiberCommon<E, A> {
+    readonly id: FiberId;
+    readonly children: UIO<Conc<Fiber.Runtime<any, any>>>;
+    readonly inheritRefs: UIO<void>;
+    readonly poll: UIO<Maybe<Exit<E, A>>>;
+    readonly interruptAs: (fiberId: FiberId) => UIO<Exit<E, A>>;
+    readonly _tag = "SyntheticFiber";
+    readonly _typeId: FiberTypeId;
+    readonly _E: () => E;
+    readonly _A: () => A;
+    readonly await: import("../IO").UIO<import("@fncts/base/data/Exit").Exit<E, A>>;
+    constructor(id: FiberId, wait: UIO<Exit<E, A>>, children: UIO<Conc<Fiber.Runtime<any, any>>>, inheritRefs: UIO<void>, poll: UIO<Maybe<Exit<E, A>>>, interruptAs: (fiberId: FiberId) => UIO<Exit<E, A>>);
+}
+export declare type ConcreteFiber<E, A> = Fiber.Runtime<E, A> | Fiber.Synthetic<E, A>;
+/**
+ * @tsplus fluent fncts.io.Fiber concrete
+ * @tsplus macro remove
+ * @tsplus location "@fncts/io/Fiber/definition"
+ */
+export declare function concrete<E, A>(_fiber: Fiber<E, A>): asserts _fiber is ConcreteFiber<E, A>;
+export declare function isFiber(u: unknown): u is Fiber<unknown, unknown>;

package/Fiber.d.ts

@@ -0,0 +1,23 @@
+export * from "./Fiber/constructors.js";
+export * from "./Fiber/definition.js";
+export * from "./Fiber/FiberContext.js";
+export * from "./Fiber/api/await.js";
+export * from "./Fiber/api/awaitAll.js";
+export * from "./Fiber/api/children.js";
+export * from "./Fiber/api/collectAll.js";
+export * from "./Fiber/api/evalOn.js";
+export * from "./Fiber/api/evalOnIO.js";
+export * from "./Fiber/api/fromIO.js";
+export * from "./Fiber/api/id.js";
+export * from "./Fiber/api/inheritRefs.js";
+export * from "./Fiber/api/interrupt.js";
+export * from "./Fiber/api/interruptAll.js";
+export * from "./Fiber/api/interruptAs.js";
+export * from "./Fiber/api/interruptFork.js";
+export * from "./Fiber/api/join.js";
+export * from "./Fiber/api/joinAll.js";
+export * from "./Fiber/api/location.js";
+export * from "./Fiber/api/mapFiber.js";
+export * from "./Fiber/api/mapIO.js";
+export * from "./Fiber/api/poll.js";
+export * from "./Fiber/api/zipWith.js";

package/FiberDescriptor.d.ts

@@ -0,0 +1,18 @@
+import { InterruptStatus } from "@fncts/io/InterruptStatus";
+import type { FiberId } from "@fncts/base/data/FiberId";
+import type { FiberScope } from "@fncts/io/FiberScope";
+import type { FiberStatus } from "@fncts/io/FiberStatus";
+/**
+ * A record containing information about a `Fiber`.
+ *
+ * @tsplus type fncts.io.FiberDescriptor
+ * @tsplus companion fncts.io.FiberDescriptorOps
+ */
+export declare class FiberDescriptor {
+    readonly id: FiberId;
+    readonly status: FiberStatus;
+    readonly interruptors: ReadonlySet<FiberId>;
+    readonly interruptStatus: InterruptStatus;
+    readonly scope: FiberScope;
+    constructor(id: FiberId, status: FiberStatus, interruptors: ReadonlySet<FiberId>, interruptStatus: InterruptStatus, scope: FiberScope);
+}

package/FiberRef/api/locallyScoped.d.ts

@@ -0,0 +1,9 @@
+import { FiberRef } from "@fncts/io/FiberRef/definition";
+import { IO } from "@fncts/io/IO/definition";
+import { Has } from "@fncts/base/typeclass/Has";
+import { Scope } from "@fncts/io/Scope/definition";
+/**
+ * @tsplus fluent fncts.io.FiberRef locallyScoped
+ * @tsplus location "@fncts/io/FiberRef/api/locallyScoped"
+ */
+export declare function locallyScoped_<A>(ref: FiberRef<A>, a: A): IO<Has<Scope>, never, void>;

package/FiberRef/api/locallyScopedWith.d.ts

@@ -0,0 +1,9 @@
+import { FiberRef } from "@fncts/io/FiberRef/definition";
+import { IO } from "@fncts/io/IO/definition";
+import { Has } from "@fncts/base/typeclass/Has";
+import { Scope } from "@fncts/io/Scope/definition";
+/**
+ * @tsplus fluent fncts.io.FiberRef locallyScopedWith
+ * @tsplus location "@fncts/io/FiberRef/api/locallyScopedWith"
+ */
+export declare function locallyScopedWith<A>(self: FiberRef<A>, f: (a: A) => A): IO<Has<Scope>, never, void>;