@fncts/io 0.0.21 → 0.0.22

package/Channel/api/mapOutConcurrentIO.d.ts

@@ -0,0 +1,8 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Channel } from "@fncts/io/Channel";
+import { Either } from "@fncts/base/data/Either/definition";
+/**
+ * @tsplus pipeable fncts.io.Channel mapOutConcurrentIO
+ * @tsplus location "@fncts/io/Channel/api/mapOutConcurrentIO"
+ */
+export declare function mapOutConcurrentIO<OutElem, Env1, OutErr1, OutElem1>(n: number, f: (_: OutElem) => IO<Env1, OutErr1, OutElem1>): <Env, InErr, InElem, InDone, OutErr, OutDone>(self: import("../definition").Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>) => import("../definition").Channel<Env1 | Env, InErr, InElem, InDone, OutErr1 | OutErr, OutElem1, OutDone>;

package/Channel/api/zipConcurrent.d.ts

@@ -0,0 +1,16 @@
+import { Channel } from "@fncts/io/Channel";
+/**
+ * @tsplus pipeable fncts.io.Channel zipConcurrent
+ * @tsplus location "@fncts/io/Channel/api/zipConcurrent"
+ */
+export declare function zipConcurrent<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(that: Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>): <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(self: import("../definition").Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>) => import("../definition").Channel<Env1 | Env, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr1 | OutErr, OutElem1 | OutElem, readonly [OutDone, OutDone1]>;
+/**
+ * @tsplus pipeable fncts.io.Channel zipLeftConcurrent
+ * @tsplus location "@fncts/io/Channel/api/zipConcurrent"
+ */
+export declare function zipLeftConcurrent<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(that: Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>): <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(self: import("../definition").Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>) => import("../definition").Channel<Env1 | Env, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr1 | OutErr, OutElem1 | OutElem, OutDone>;
+/**
+ * @tsplus pipeable fncts.io.Channel zipRightConcurrent
+ * @tsplus location "@fncts/io/Channel/api/zipConcurrent"
+ */
+export declare function zipRightConcurrent<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(that: Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>): <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(self: import("../definition").Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>) => import("../definition").Channel<Env1 | Env, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr1 | OutErr, OutElem1 | OutElem, OutDone1>;

package/Channel/api.d.ts

@@ -3,12 +3,12 @@ import { Environment } from "@fncts/base/data/Environment/definition";
 import { IO, URIO } from "@fncts/io/IO/definition";
 import { Exit } from "@fncts/base/data/Exit/definition";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
-import { Ref } from "@fncts/io/Ref";
+import { Ref } from "@fncts/io/Ref/definition";
 import { Conc, ConcBuilder } from "@fncts/base/collection/immutable/Conc";
 import { Cause } from "@fncts/base/data/Cause/definition";
 import { Either } from "@fncts/base/data/Either/definition";
 import { Maybe, Nothing } from "@fncts/base/data/Maybe/definition";
-import { Dequeue, Enqueue } from "@fncts/io/Queue/definition";
+import { Queue } from "@fncts/io/Queue/definition";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
 import { Scope } from "@fncts/io/Scope/definition";
 import { Hub } from "@fncts/io/Hub/definition";
@@ -244,7 +244,7 @@ export declare function fromOption<A>(option: Lazy<Maybe<A>>): Channel<never, un
  * @tsplus static fncts.io.ChannelOps fromQueue
  * @tsplus location "@fncts/io/Channel/api"
  */
-export declare function fromQueue<Err, Elem, Done>(queue: Dequeue<Either<Exit<Err, Done>, Elem>>): Channel<never, unknown, unknown, unknown, Err, Elem, Done>;
+export declare function fromQueue<Err, Elem, Done>(queue: Queue.Dequeue<Either<Exit<Err, Done>, Elem>>): Channel<never, unknown, unknown, unknown, Err, Elem, Done>;
 /**
  * Provides the channel with its required environment, which eliminates
  * its dependency on `Env`.
@@ -316,7 +316,7 @@ export declare function mapOut<OutElem, OutElem2>(f: (o: OutElem) => OutElem2):
  * @tsplus pipeable fncts.io.Channel mapOutIO
  * @tsplus location "@fncts/io/Channel/api"
  */
-export declare function mapOutIO_<Env1, OutErr1, OutElem, OutElem1>(f: (o: OutElem) => IO<Env1, OutErr1, OutElem1>): <Env, InErr, InElem, InDone, OutErr, OutDone>(self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>) => Channel<Env1 | Env, InErr, InElem, InDone, OutErr1 | OutErr, OutElem1, OutDone>;
+export declare function mapOutIO<Env1, OutErr1, OutElem, OutElem1>(f: (o: OutElem) => IO<Env1, OutErr1, OutElem1>): <Env, InErr, InElem, InDone, OutErr, OutDone>(self: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>) => Channel<Env1 | Env, InErr, InElem, InDone, OutErr1 | OutErr, OutElem1, OutDone>;
 /**
  * Fold the channel exposing success and full error cause
  * @tsplus pipeable fncts.io.Channel matchCauseChannel
@@ -391,7 +391,7 @@ export declare function repeated<Env, InErr, InElem, InDone, OutErr, OutElem, Ou
  * @tsplus static fncts.io.ChannelOps toQueue
  * @tsplus location "@fncts/io/Channel/api"
  */
-export declare function toQueue<Err, Done, Elem>(queue: Lazy<Enqueue<Either<Exit<Err, Done>, Elem>>>): Channel<never, Err, Elem, Done, never, never, unknown>;
+export declare function toQueue<Err, Done, Elem>(queue: Lazy<Queue.Enqueue<Either<Exit<Err, Done>, Elem>>>): Channel<never, Err, Elem, Done, never, never, unknown>;
 /**
  * Writes an output to the channel
  * @tsplus static fncts.io.ChannelOps write

package/Channel/core-api.d.ts

@@ -64,15 +64,15 @@ export declare function cross<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1,
 /**
  * Returns a new channel that is the sequential composition of this channel and the specified
  * channel. The returned channel terminates with the terminal value of this channel.
- * @tsplus pipeable fncts.io.Channel apFirst
+ * @tsplus pipeable fncts.io.Channel zipLeft
  * @tsplus location "@fncts/io/Channel/core-api"
  */
-export declare function apFirst<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(that: Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>): <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(self: import("./definition.js").Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>) => import("./definition.js").Channel<Env1 | Env, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr1 | OutErr, OutElem1 | OutElem, OutDone>;
+export declare function zipLeft<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(that: Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>): <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(self: import("./definition.js").Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>) => import("./definition.js").Channel<Env1 | Env, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr1 | OutErr, OutElem1 | OutElem, OutDone>;
 /**
  * Returns a new channel that is the sequential composition of this channel and the specified
  * channel. The returned channel terminates with the terminal value of the other channel.
- * @tsplus pipeable fncts.io.Channel apSecond
+ * @tsplus pipeable fncts.io.Channel zipRight
  * @tsplus pipeable-operator fncts.io.Channel >
  * @tsplus location "@fncts/io/Channel/core-api"
  */
-export declare function apSecond<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(that: Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>): <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(self: import("./definition.js").Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>) => import("./definition.js").Channel<Env1 | Env, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr1 | OutErr, OutElem1 | OutElem, OutDone1>;
+export declare function zipRight<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>(that: Channel<Env1, InErr1, InElem1, InDone1, OutErr1, OutElem1, OutDone1>): <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(self: import("./definition.js").Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>) => import("./definition.js").Channel<Env1 | Env, InErr & InErr1, InElem & InElem1, InDone & InDone1, OutErr1 | OutErr, OutElem1 | OutElem, OutDone1>;

package/Channel/internal/SingleProducerAsyncInput.d.ts

@@ -1,7 +1,7 @@
 import { Cause } from "@fncts/base/data/Cause/definition";
 import { Future } from "@fncts/io/Future";
 import { Either } from "@fncts/base/data/Either/definition";
-import { Ref } from "@fncts/io/Ref";
+import { Ref } from "@fncts/io/Ref/definition";
 import { UIO, IO } from "@fncts/io/IO/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Exit } from "@fncts/base/data/Exit/definition";

package/CountdownLatch.d.ts

@@ -0,0 +1,25 @@
+import { Ref } from "@fncts/io/Ref/definition";
+import { Future } from "@fncts/io/Future";
+import { UIO, IO } from "@fncts/io/IO/definition";
+export declare const CountdownLatchTypeId: unique symbol;
+export type CountdownLatchTypeId = typeof CountdownLatchTypeId;
+/**
+ * @tsplus type fncts.io.CountdownLatch
+ * @tsplus companion fncts.io.CountdownLatchOps
+ */
+export declare class CountdownLatch {
+    private _count;
+    private _waiters;
+    readonly _typeId: CountdownLatchTypeId;
+    constructor(_count: Ref<number>, _waiters: Future<never, void>);
+    readonly await: UIO<void>;
+    readonly countDown: UIO<void>;
+    readonly count: UIO<number>;
+    readonly increment: UIO<void>;
+}
+/**
+ * @tsplus static fncts.io.CountdownLatchOps make
+ * @tsplus static fncts.io.CountdownLatchOps __call
+ * @tsplus location "@fncts/io/CountdownLatch"
+ */
+export declare function make(n: number): UIO<CountdownLatch>;

package/Fiber/FiberMessage.d.ts

@@ -0,0 +1,67 @@
+import { Cause } from "@fncts/base/data/Cause/definition";
+import { Trace } from "@fncts/base/data/Trace/definition";
+import { IO } from "@fncts/io/IO/definition";
+import type { FiberStatus } from "../FiberStatus.js";
+import type { FiberRuntime } from "./FiberRuntime.js";
+export declare const enum FiberMessageTag {
+    InterruptSignal = 0,
+    GenStackTrace = 1,
+    Stateful = 2,
+    Resume = 3,
+    YieldNow = 4
+}
+export type FiberMessage = InterruptSignal | GenStackTrace | Stateful | Resume | YieldNow;
+/**
+ * @tsplus type fncts.io.FiberMessageOps
+ */
+export interface FiberMessageOps {
+}
+export declare const FiberMessage: FiberMessageOps;
+export declare class InterruptSignal {
+    readonly cause: Cause<never>;
+    readonly _tag = FiberMessageTag.InterruptSignal;
+    constructor(cause: Cause<never>);
+}
+/**
+ * @tsplus static fncts.io.FiberMessageOps InterruptSignal
+ * @tsplus location "@fncts/io/Fiber/FiberMessage"
+ */
+export declare function mkInterruptSignal(cause: Cause<never>): FiberMessage;
+export declare class GenStackTrace {
+    readonly onTrace: (trace: Trace) => void;
+    readonly _tag = FiberMessageTag.GenStackTrace;
+    constructor(onTrace: (trace: Trace) => void);
+}
+/**
+ * @tsplus static fncts.io.FiberMessageOps GenStackTrace
+ * @tsplus location "@fncts/io/Fiber/FiberMessage"
+ */
+export declare function mkGenStackTrace(onTrace: (trace: Trace) => void): FiberMessage;
+export declare class Stateful {
+    readonly onFiber: (fiber: FiberRuntime<any, any>, status: FiberStatus) => void;
+    readonly _tag = FiberMessageTag.Stateful;
+    constructor(onFiber: (fiber: FiberRuntime<any, any>, status: FiberStatus) => void);
+}
+/**
+ * @tsplus static fncts.io.FiberMessageOps Stateful
+ * @tsplus location "@fncts/io/Fiber/FiberMessage"
+ */
+export declare function mkStateful(onFiber: (fiber: FiberRuntime<any, any>, status: FiberStatus) => void): FiberMessage;
+export declare class Resume {
+    readonly cont: IO<any, any, any>;
+    readonly _tag = FiberMessageTag.Resume;
+    constructor(cont: IO<any, any, any>);
+}
+/**
+ * @tsplus static fncts.io.FiberMessageOps Resume
+ * @tsplus location "@fncts/io/Fiber/FiberMessage"
+ */
+export declare function mkResume(cont: IO<any, any, any>): FiberMessage;
+export interface YieldNow {
+    readonly _tag: FiberMessageTag.YieldNow;
+}
+/**
+ * @tsplus static fncts.io.FiberMessageOps YieldNow
+ * @tsplus location "@fncts/io/Fiber/FiberMessage"
+ */
+export declare const YieldNow: FiberMessage;

package/Fiber/FiberRuntime.d.ts

@@ -0,0 +1,116 @@
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { FiberId } from "@fncts/base/data/FiberId/definition";
+import { FiberRefs } from "@fncts/io/FiberRefs";
+import { List, Cons } from "@fncts/base/collection/immutable/List/definition";
+import { Exit } from "@fncts/base/data/Exit/definition";
+import { Stack } from "@fncts/base/internal/Stack";
+import { IO } from "@fncts/io/IO/definition";
+import { Future } from "@fncts/io/Future";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { Cause } from "@fncts/base/data/Cause/definition";
+import { Supervisor } from "@fncts/io/Supervisor/definition";
+import { FiberRef } from "@fncts/io/FiberRef/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { IllegalStateError, isInterruptedException } from "@fncts/base/data/exceptions";
+import { TraceElement } from "@fncts/base/data/TraceElement/definition";
+import { FiberScope } from "@fncts/io/FiberScope";
+import { LogLevel } from "@fncts/io/LogLevel";
+import { Logger } from "@fncts/io/Logger/definition";
+import type { FiberStatus } from "../FiberStatus.js";
+import type { OnFailure, OnSuccess, OnSuccessAndFailure, UIO } from "../IO/definition.js";
+import type { RuntimeFlags } from "../RuntimeFlags.js";
+import { Trace } from "@fncts/base/data/Trace";
+import { FiberTypeId } from "@fncts/io/Fiber/definition";
+import { WhileLoop } from "../IO/definition.js";
+import { FiberMessage } from "./FiberMessage.js";
+declare const enum ContinuationTag {
+    RevertFlags = "RevertFlags",
+    UpdateTrace = "UpdateTrace"
+}
+export declare class RevertFlags {
+    readonly patch: RuntimeFlags.Patch;
+    readonly trace?: string | undefined;
+    readonly _tag = ContinuationTag.RevertFlags;
+    constructor(patch: RuntimeFlags.Patch, trace?: string | undefined);
+}
+export declare class UpdateTrace {
+    readonly trace?: string | undefined;
+    readonly _tag = ContinuationTag.UpdateTrace;
+    constructor(trace?: string | undefined);
+}
+export type Continuation = OnSuccess<any, any, any, any, any, any> | OnSuccessAndFailure<any, any, any, any, any, any, any, any, any> | OnFailure<any, any, any, any, any, any> | WhileLoop<any, any, any> | UpdateTrace | RevertFlags;
+/**
+ * @tsplus type fncts.io.Fiber
+ */
+export declare class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
+    readonly fiberId: FiberId.Runtime;
+    readonly runtimeFlags0: RuntimeFlags;
+    readonly _E: () => E;
+    readonly _A: () => A;
+    readonly _typeId: FiberTypeId;
+    readonly _tag = "RuntimeFiber";
+    constructor(fiberId: FiberId.Runtime, fiberRefs0: FiberRefs, runtimeFlags0: RuntimeFlags);
+    private _fiberRefs;
+    private _runtimeFlags;
+    private queue;
+    private _children;
+    private observers;
+    private running;
+    private stack;
+    private asyncInterruptor;
+    private asyncTrace;
+    private asyncBlockinOn;
+    private _exitValue;
+    get id(): FiberId.Runtime;
+    ask<A>(f: (fiberRuntime: FiberRuntime<any, any>, status: FiberStatus) => A): UIO<A>;
+    get await(): UIO<Exit<E, A>>;
+    get children(): UIO<Conc<FiberRuntime<any, any>>>;
+    get fiberRefs(): UIO<FiberRefs>;
+    get inheritAll(): UIO<void>;
+    get runtimeFlags(): UIO<RuntimeFlags>;
+    interruptAsFork(fiberId: FiberId): UIO<void>;
+    getSupervisor(): Supervisor<any>;
+    get poll(): UIO<Maybe<Exit<E, A>>>;
+    private run;
+    private drainQueueOnCurrentThread;
+    private drainQueueLaterOnExecutor;
+    private drainQueueWhileRunning;
+    private evaluateEffect;
+    runLoop(effect: IO<any, any, any>): Exit<any, any>;
+    getInterruptedCause(): Cause<never>;
+    isInterrupted(): boolean;
+    getFiberRef<A>(fiberRef: FiberRef<A>): A;
+    tell(message: FiberMessage): void;
+    exitValue(): Exit<E, A>;
+    addObserver(observer: (exit: Exit<E, A>) => void): void;
+    getChildren(): Set<FiberRuntime<any, any>>;
+    getFiberRefs(): FiberRefs;
+    setFiberRefs(fiberRefs0: FiberRefs): void;
+    private patchRuntimeFlags;
+    private sendInterruptSignalToAllChildren;
+    private interruptAllChildren;
+    private initiateAsync;
+    setFiberRef<A>(fiberRef: FiberRef<A>, value: A): void;
+    private addInterruptedCause;
+    private processNewInterruptSignal;
+    private evaluateMessageWhileSuspended;
+    private generateStackTrace;
+    private setExitValue;
+    resume<R>(effect: IO<R, E, A>): void;
+    start<R>(effect: IO<R, E, A>): void;
+    startFork<R>(effect: IO<R, E, A>): void;
+    updateFiberRef<A>(fiberRef: FiberRef<A>, f: (a: A) => A): void;
+    removeObserver(observer: (exit: Exit<E, A>) => void): void;
+    addChild(child: FiberRuntime<any, any>): void;
+    removeChild(child: FiberRuntime<any, any>): void;
+    get scope(): import("../FiberScope.js").FiberScope;
+    log(message: () => string, cause: Cause<any>, overrideLogLevel: Maybe<LogLevel>, trace?: string): void;
+    deleteFiberRef(ref: FiberRef<any>): void;
+    location: string | undefined;
+    get status(): UIO<FiberStatus>;
+    get trace(): UIO<Trace>;
+    getNextSuccessCont(): OnSuccessAndFailure<any, any, any, any, any, any, any, any, any> | OnSuccess<any, any, any, any, any, any> | WhileLoop<any, any, any> | RevertFlags | UpdateTrace | undefined;
+    getNextFailCont(): OnSuccessAndFailure<any, any, any, any, any, any, any, any, any> | OnFailure<any, any, any, any, any, any> | RevertFlags | UpdateTrace | undefined;
+    isFatal(t: unknown): boolean;
+}
+export {};

package/Fiber/api/interrupt.d.ts

@@ -8,4 +8,4 @@ import { Exit } from "@fncts/base/data/Exit/definition";
  * @tsplus getter fncts.io.Fiber interrupt
  * @tsplus location "@fncts/io/Fiber/api/interrupt"
  */
-export declare function interrupt<E, A>(fiber: Fiber<E, A>, __tsplusTrace?: string): UIO<Exit<E, A>>;
+export declare function interrupt<E, A>(fiber: Fiber<E, A>): UIO<Exit<E, A>>;

package/Fiber/api/interruptAs.d.ts

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

package/Fiber/api/location.d.ts

@@ -1,7 +1,6 @@
 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;
+export declare function location<E, A>(self: Fiber<E, A>): string | undefined;

package/Fiber/definition.d.ts

@@ -1,11 +1,12 @@
-import { FiberId } from "@fncts/base/data/FiberId/definition";
-import { UIO, IO } from "@fncts/io/IO/definition";
 import { Exit } from "@fncts/base/data/Exit/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 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 { FiberId } from "@fncts/base/data/FiberId";
+import type { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
 import type { FiberStatus } from "@fncts/io/FiberStatus";
+import type { UIO } from "@fncts/io/IO/definition";
+import { IterableWeakSet } from "@fncts/base/collection/weak/IterableWeakSet";
 export declare const FiberTypeId: unique symbol;
 export type FiberTypeId = typeof FiberTypeId;
 /**
@@ -37,9 +38,11 @@ export interface FiberCommon<E, A> extends Fiber<E, A> {
      * Inherits values from all {@link FiberRef} instances into current fiber.
      * This will resume immediately.
      */
-    readonly inheritRefs: UIO<void>;
+    readonly inheritAll: UIO<void>;
     /**
-     * Interrupts the fiber as if interrupted from the specified fiber.
+     * 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 interruptAsFork: (fiberId: FiberId) => UIO<void>;
     /**
@@ -60,14 +63,7 @@ export interface RuntimeFiber<E, A> extends FiberCommon<E, A> {
     /**
      * 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>;
+    readonly location?: string;
     /**
      * The status of the fiber.
      */
@@ -80,15 +76,15 @@ export interface RuntimeFiber<E, A> extends FiberCommon<E, A> {
 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 inheritAll: UIO<void>;
     readonly poll: UIO<Maybe<Exit<E, A>>>;
     readonly interruptAsFork: (fiberId: FiberId) => UIO<void>;
     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>>>, interruptAsFork: (fiberId: FiberId) => UIO<void>);
+    readonly await: UIO<import("@fncts/base/data/Exit").Exit<E, A>>;
+    constructor(id: FiberId, wait: UIO<Exit<E, A>>, children: UIO<Conc<Fiber.Runtime<any, any>>>, inheritAll: UIO<void>, poll: UIO<Maybe<Exit<E, A>>>, interruptAsFork: (fiberId: FiberId) => UIO<void>);
 }
 export type ConcreteFiber<E, A> = Fiber.Runtime<E, A> | Fiber.Synthetic<E, A>;
 /**
@@ -98,3 +94,8 @@ export type ConcreteFiber<E, A> = Fiber.Runtime<E, A> | Fiber.Synthetic<E, A>;
  */
 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>;
+/**
+ * @tsplus static fncts.io.FiberOps _roots
+ * @tsplus location "@fncts/io/Fiber/definition"
+ */
+export declare const _roots: IterableWeakSet<FiberRuntime<any, any>>;

package/Fiber.d.ts

@@ -1,19 +1,17 @@
 export * from "./Fiber/constructors.js";
 export * from "./Fiber/definition.js";
-export * from "./Fiber/FiberContext.js";
+export * from "./Fiber/FiberMessage.js";
+export * from "./Fiber/FiberRuntime.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/interruptAsFork.js";
 export * from "./Fiber/api/interruptFork.js";
 export * from "./Fiber/api/join.js";
 export * from "./Fiber/api/joinAll.js";

package/FiberDescriptor.d.ts

@@ -1,6 +1,5 @@
-import { InterruptStatus } from "@fncts/io/InterruptStatus";
+import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
 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`.
@@ -11,8 +10,6 @@ import type { FiberStatus } from "@fncts/io/FiberStatus";
 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);
+    readonly interruptors: HashSet<FiberId>;
+    constructor(id: FiberId, status: FiberStatus, interruptors: HashSet<FiberId>);
 }

package/FiberRef/definition.d.ts

@@ -1,5 +1,5 @@
-import { Hashable } from "@fncts/base/typeclass/Hashable";
-import { Equatable } from "@fncts/base/typeclass/Equatable";
+import { Hashable } from "@fncts/base/data/Hashable";
+import { Equatable } from "@fncts/base/data/Equatable";
 export declare const FiberRefTypeId: unique symbol;
 export type FiberRefTypeId = typeof FiberRefTypeId;
 /**

package/FiberRef/unsafe.d.ts

@@ -36,6 +36,11 @@ export declare function unsafeMake<A>(initial: A, fork?: (a: A) => A, join?: (a0
  * @tsplus location "@fncts/io/FiberRef/unsafe"
  */
 export declare const forkScopeOverride: import("./definition.js").FiberRef.WithPatch<import("@fncts/base/data/Maybe.js").Maybe<import("../FiberScope.js").FiberScope>, (_: import("@fncts/base/data/Maybe.js").Maybe<import("../FiberScope.js").FiberScope>) => import("@fncts/base/data/Maybe.js").Maybe<import("../FiberScope.js").FiberScope>>;
+/**
+ * @tsplus static fncts.io.FiberRefOps interruptedCause
+ * @tsplus location "@fncts/io/FiberRef/unsafe"
+ */
+export declare const interruptedCause: import("./definition.js").FiberRef.WithPatch<import("@fncts/base/data/Cause.js").Cause<never>, (_: import("@fncts/base/data/Cause.js").Cause<never>) => import("@fncts/base/data/Cause.js").Cause<never>>;
 /**
  * @tsplus static fncts.io.FiberRefOps currentEnvironment
  * @tsplus location "@fncts/io/FiberRef/unsafe"

package/FiberRefs/api.d.ts

@@ -3,6 +3,7 @@ import { FiberRef } from "@fncts/io/FiberRef/definition";
 import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
 import { Cons } from "@fncts/base/collection/immutable/List/definition";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { FiberRefs } from "@fncts/io/FiberRefs/definition";
 /**
  * @tsplus getter fncts.io.FiberRefs fiberRefs
@@ -10,6 +11,7 @@ import { FiberRefs } from "@fncts/io/FiberRefs/definition";
  */
 export declare function fiberRefs(self: FiberRefs): HashSet<FiberRef<unknown>>;
 /**
+ * @tsplus macro identity
  * @tsplus static fncts.io.FiberRefsOps __call
  * @tsplus location "@fncts/io/FiberRefs/api"
  */
@@ -19,3 +21,29 @@ export declare function make(fiberRefLocals: HashMap<FiberRef<unknown>, Cons<rea
  * @tsplus location "@fncts/io/FiberRefs/api"
  */
 export declare function forkAs(childId: FiberId.Runtime): (self: FiberRefs) => FiberRefs;
+/**
+ * @tsplus fluent fncts.io.FiberRefs get
+ * @tsplus location "@fncts/io/FiberRefs/api"
+ */
+export declare function get<A>(self: FiberRefs, fiberRef: FiberRef<A>): Maybe<A>;
+/**
+ * @tsplus fluent fncts.io.FiberRefs getOrDefault
+ * @tsplus location "@fncts/io/FiberRefs/api"
+ */
+export declare function getOrDefault<A>(self: FiberRefs, fiberRef: FiberRef<A>): A;
+/**
+ * @tsplus fluent fncts.io.FiberRefs updateAs
+ * @tsplus location "@fncts/io/FiberRefs/api"
+ */
+export declare function updateAs<A>(self: FiberRefs, fiberId: FiberId.Runtime, fiberRef: FiberRef<A>, value: A): FiberRefs;
+/**
+ * @tsplus fluent fncts.io.FiberRefs delete
+ * @tsplus location "@fncts/io/FiberRefs/api"
+ */
+export declare function remove(self: FiberRefs, fiberRef: FiberRef<any>): FiberRefs;
+/**
+ * @tsplus getter fncts.io.FiberRefs unFiberRefs
+ * @tsplus macro identity
+ * @tsplus location "@fncts/io/FiberRefs/api"
+ */
+export declare function unFiberRefs(self: FiberRefs): HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>;

package/FiberRefs/definition.d.ts

@@ -1,15 +1,22 @@
+import { HKT } from "@fncts/typelevel/HKT";
+import { Newtype, NewtypeIso } from "@fncts/base/data/Newtype";
 import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
 import { FiberRef } from "@fncts/io/FiberRef/definition";
 import { Cons } from "@fncts/base/collection/immutable/List/definition";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
-export declare const FiberRefsTypeId: unique symbol;
-export type FiberRefsTypeId = typeof FiberRefsTypeId;
+export interface FiberRefsN extends HKT {
+    readonly type: FiberRefs;
+}
 /**
  * @tsplus type fncts.io.FiberRefs
- * @tsplus companion fncts.io.FiberRefsOps
  */
-export declare class FiberRefs {
-    readonly fiberRefLocals: HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>;
-    readonly _typeId: FiberRefsTypeId;
-    constructor(fiberRefLocals: HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>);
+export interface FiberRefs extends Newtype<{
+    readonly FiberRefs: unique symbol;
+}, HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>> {
+}
+/**
+ * @tsplus type fncts.io.FiberRefsOps
+ */
+export interface FiberRefsOps extends NewtypeIso<FiberRefsN> {
 }
+export declare const FiberRefs: FiberRefsOps;

package/FiberScope/constructors.d.ts

@@ -1,5 +1,5 @@
 import { FiberScope } from "@fncts/io/FiberScope";
-import type { FiberContext } from "@fncts/io/Fiber/FiberContext";
+import type { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
 import { Global } from "@fncts/io/FiberScope/definition";
 /**
  * The global scope. Anything forked onto the global scope is not supervised,
@@ -13,4 +13,4 @@ export declare const global: Global;
  * @tsplus static fncts.io.FiberScopeOps unsafeMake
  * @tsplus location "@fncts/io/FiberScope/constructors"
  */
-export declare function unsafeMake(fiber: FiberContext<any, any>): FiberScope;
+export declare function unsafeMake(fiber: FiberRuntime<any, any>): FiberScope;

package/FiberScope/definition.d.ts

@@ -1,5 +1,8 @@
 import { FiberId } from "@fncts/base/data/FiberId/definition";
-import type { FiberContext } from "@fncts/io/Fiber/FiberContext";
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
+import type { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
+import type { RuntimeFlags } from "@fncts/io/RuntimeFlags";
 /**
  * A `Scope` represents the scope of a fiber lifetime. The scope of a fiber can
  * be retrieved using IO.descriptor, and when forking fibers, you can
@@ -10,15 +13,15 @@ import type { FiberContext } from "@fncts/io/Fiber/FiberContext";
  */
 export declare abstract class FiberScope {
     abstract fiberId: FiberId;
-    abstract unsafeAdd(child: FiberContext<unknown, unknown>): boolean;
+    abstract unsafeAdd(currentFiber: FiberRuntime<any, any>, runtimeFlags: RuntimeFlags, child: FiberRuntime<any, any>): void;
 }
 export declare class Global extends FiberScope {
     get fiberId(): FiberId;
-    unsafeAdd(_child: FiberContext<any, any>): boolean;
+    unsafeAdd(_currentFiber: FiberRuntime<any, any>, runtimeFlags: RuntimeFlags, child: FiberRuntime<any, any>): void;
 }
 export declare class Local extends FiberScope {
     readonly fiberId: FiberId;
     private parentRef;
-    constructor(fiberId: FiberId, parentRef: WeakRef<FiberContext<unknown, unknown>>);
-    unsafeAdd(child: FiberContext<unknown, unknown>): boolean;
+    constructor(fiberId: FiberId, parentRef: WeakRef<FiberRuntime<unknown, unknown>>);
+    unsafeAdd(currentFiber: FiberRuntime<any, any>, _runtimeFlags: RuntimeFlags, child: FiberRuntime<any, any>): void;
 }