@fncts/io 0.0.21 → 0.0.23

package/Cached/definition.d.ts

@@ -1,5 +1,5 @@
 import type { CachedInternal } from "@fncts/io/Cached/internal";
-import { CachedTypeId } from "@fncts/io/Cached/internal";
+import { CachedTypeId, CachedVariance } from "@fncts/io/Cached/internal";
 /**
  * A Cached is a possibly resourceful value that is loaded into memory, and
  * which can be refreshed either manually or automatically
@@ -8,9 +8,11 @@ import { CachedTypeId } from "@fncts/io/Cached/internal";
  * @tsplus companion fncts.io.CachedOps
  */
 export declare class Cached<Error, Resource> {
-    readonly _E: () => Error;
-    readonly _A: () => Resource;
-    readonly _typeId: CachedTypeId;
+    readonly [CachedTypeId]: CachedTypeId;
+    [CachedVariance]: {
+        readonly _E: (_: never) => Error;
+        readonly _A: (_: never) => Resource;
+    };
 }
 /**
  * @tsplus macro remove

package/Cached/internal.d.ts

@@ -1,10 +1,10 @@
+import { Cached } from "@fncts/io/Cached/definition";
 import { FIO } from "@fncts/io/IO/definition";
+export declare const CachedVariance: unique symbol;
+export type CachedVariance = typeof CachedVariance;
 export declare const CachedTypeId: unique symbol;
 export type CachedTypeId = typeof CachedTypeId;
-export declare abstract class CachedInternal<Error, Resource> {
-    readonly _E: () => Error;
-    readonly _A: () => Resource;
-    readonly _typeId: CachedTypeId;
+export declare abstract class CachedInternal<Error, Resource> extends Cached<Error, Resource> {
     abstract get: FIO<Error, Resource>;
     abstract refresh: FIO<Error, void>;
 }

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";
@@ -49,16 +49,16 @@ export declare function acquireReleaseWith<Env, InErr, InElem, InDone, OutErr, O
 export declare function acquireReleaseExitWith<Env, InErr, InElem, InDone, OutErr, OutElem1, OutDone, Acquired>(acquire: IO<Env, OutErr, Acquired>, use: (a: Acquired) => Channel<Env, InErr, InElem, InDone, OutErr, OutElem1, OutDone>, release: (a: Acquired, exit: Exit<OutErr, OutDone>) => URIO<Env, any>): Channel<Env, InErr, InElem, InDone, OutErr, OutElem1, OutDone>;
 /**
  * Construct a resource Channel with Acquire / Release
- * @tsplus static fncts.io.ChannelOps acquireReleaseOut
+ * @tsplus static fncts.io.ChannelOps acquireReleaseOutWith
  * @tsplus location "@fncts/io/Channel/api"
  */
-export declare function acquireReleaseOut<Env, OutErr, Acquired, Z>(acquire: IO<Env, OutErr, Acquired>, release: (a: Acquired) => URIO<Env, Z>): Channel<Env, unknown, unknown, unknown, OutErr, Acquired, void>;
+export declare function acquireReleaseOutWith<Env, OutErr, Acquired, Z>(acquire: IO<Env, OutErr, Acquired>, release: (a: Acquired) => URIO<Env, Z>): Channel<Env, unknown, unknown, unknown, OutErr, Acquired, void>;
 /**
  * Construct a resource Channel with Acquire / Release
- * @tsplus static fncts.io.ChannelOps acquireReleaseOutExit
+ * @tsplus static fncts.io.ChannelOps acquireReleaseOutExitWith
  * @tsplus location "@fncts/io/Channel/api"
  */
-export declare function acquireReleaseOutExit<R, R2, E, Z>(self: IO<R, E, Z>, release: (z: Z, e: Exit<unknown, unknown>) => URIO<R2, unknown>): Channel<R | R2, unknown, unknown, unknown, E, Z, void>;
+export declare function acquireReleaseOutExitWith<R, R2, E, Z>(self: IO<R, E, Z>, release: (z: Z, e: Exit<unknown, unknown>) => URIO<R2, unknown>): Channel<R | R2, unknown, unknown, unknown, E, Z, void>;
 /**
  * Creates a channel backed by a buffer. When the buffer is empty, the channel will simply
  * passthrough its input as output. However, when the buffer is non-empty, the value inside
@@ -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/definition.d.ts

@@ -23,18 +23,25 @@ export declare const enum ChannelTag {
     BracketOut = "BracketOut",
     Provide = "Provide"
 }
+export declare const ChannelVariance: unique symbol;
+export type ChannelVariance = typeof ChannelVariance;
+export declare const ChannelTypeId: unique symbol;
+export type ChannelTypeId = typeof ChannelTypeId;
 /**
  * @tsplus type fncts.io.Channel
  * @tsplus companion fncts.io.ChannelOps
  */
 export declare abstract class Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> {
-    _Env: () => Env;
-    _InErr: (_: InErr) => void;
-    _InElem: (_: InElem) => void;
-    _InDone: (_: InDone) => void;
-    _OutErr: () => OutErr;
-    _OutElem: () => OutElem;
-    _OutDone: () => OutDone;
+    readonly [ChannelTypeId]: ChannelTypeId;
+    [ChannelVariance]: {
+        _Env: () => Env;
+        _InErr: (_: InErr) => void;
+        _InElem: (_: InElem) => void;
+        _InDone: (_: InDone) => void;
+        _OutErr: () => OutErr;
+        _OutElem: () => OutElem;
+        _OutDone: () => OutDone;
+    };
 }
 /**
  * @tsplus unify fncts.io.Channel
@@ -43,43 +50,57 @@ export declare function unifyChannel<X extends Channel<any, any, any, any, any,
     X
 ] extends [
     {
-        _Env: () => infer Env;
+        [ChannelVariance]: {
+            _Env: () => infer Env;
+        };
     }
 ] ? Env : never, [
     X
 ] extends [
     {
-        _InErr: (_: infer InErr) => void;
+        [ChannelVariance]: {
+            _InErr: (_: infer InErr) => void;
+        };
     }
 ] ? InErr : never, [
     X
 ] extends [
     {
-        _InElem: (_: infer InElem) => void;
+        [ChannelVariance]: {
+            _InElem: (_: infer InElem) => void;
+        };
     }
 ] ? InElem : never, [
     X
 ] extends [
     {
-        _InDone: (_: infer InDone) => void;
+        [ChannelVariance]: {
+            _InDone: (_: infer InDone) => void;
+        };
     }
 ] ? InDone : never, [
     X
 ] extends [
     {
-        _OutErr: () => infer OutErr;
+        [ChannelVariance]: {
+            _OutErr: () => infer OutErr;
+        };
     }
 ] ? OutErr : never, [
     X
 ] extends [
     {
-        _OutElem: () => infer OutElem;
+        [ChannelVariance]: {
+            _OutElem: () => infer OutElem;
+        };
     }
 ] ? OutElem : never, [
     X
 ] extends [
     {
-        _OutDone: () => infer OutDone;
+        [ChannelVariance]: {
+            _OutDone: () => infer OutDone;
+        };
     }
 ] ? OutDone : never>;
 export declare abstract class Continuation<Env, InErr, InElem, InDone, OutErr, OutErr2, OutElem, OutDone, OutDone2> {

package/Channel/internal/ChannelExecutor.d.ts

@@ -47,6 +47,7 @@ export declare class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem
     private doneSucceed;
     private doneHalt;
     private addFinalizer;
+    private provide;
     private runBracketOut;
     private runEnsuring;
 }

package/Channel/internal/MergeDecision.d.ts

@@ -4,6 +4,8 @@ export declare const enum MergeDecisionTag {
     Done = "Done",
     Await = "Await"
 }
+export declare const MergeDecisionVariance: unique symbol;
+export type MergeDecisionVariance = typeof MergeDecisionVariance;
 export declare const MergeDecisionTypeId: unique symbol;
 export type MergeDecisionTypeId = typeof MergeDecisionTypeId;
 /**
@@ -11,12 +13,14 @@ export type MergeDecisionTypeId = typeof MergeDecisionTypeId;
  * @tsplus companion fncts.io.Channel.MergeDecisionOps
  */
 export declare abstract class MergeDecision<R, E0, Z0, E, Z> {
-    readonly _typeId: MergeDecisionTypeId;
-    readonly _R: () => R;
-    readonly _E0: (_: E0) => void;
-    readonly _Z0: (_: Z0) => void;
-    readonly _E: () => E;
-    readonly _Z: () => Z;
+    readonly [MergeDecisionTypeId]: MergeDecisionTypeId;
+    [MergeDecisionVariance]: {
+        readonly _R: (_: never) => R;
+        readonly _E0: (_: E0) => void;
+        readonly _Z0: (_: Z0) => void;
+        readonly _E: (_: never) => E;
+        readonly _Z: (_: never) => Z;
+    };
 }
 /**
  * @tsplus unify fncts.io.Channel.MergeDecision

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 [CountdownLatchTypeId]: 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/Differ/definition.d.ts

@@ -4,10 +4,8 @@ export type DifferTypeId = typeof DifferTypeId;
  * @tsplus type fncts.io.Differ
  * @tsplus companion fncts.io.DifferOps
  */
-export declare abstract class Differ<Value, Patch> {
-    readonly _typeId: DifferTypeId;
-    _Value: Value;
-    _Patch: Patch;
+export declare abstract class Differ<in out Value, in out Patch> {
+    readonly [DifferTypeId]: DifferTypeId;
     abstract readonly empty: Patch;
     abstract combine(first: Patch, second: Patch): Patch;
     abstract diff(oldValue: Value, newValue: Value): Patch;

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,114 @@
+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, FiberVariance } from "@fncts/io/Fiber/definition";
+import { WhileLoop } from "../IO/definition.js";
+import { IOOpCode } from "../IO/definition.js";
+import { FiberMessage } from "./FiberMessage.js";
+export declare class RevertFlags {
+    readonly patch: RuntimeFlags.Patch;
+    readonly trace?: string | undefined;
+    readonly ioOpCode = IOOpCode.RevertFlags;
+    constructor(patch: RuntimeFlags.Patch, trace?: string | undefined);
+}
+export declare class UpdateTrace {
+    readonly trace?: string | undefined;
+    readonly ioOpCode = IOOpCode.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 [FiberTypeId]: FiberTypeId;
+    [FiberVariance]: {
+        readonly _E: (_: never) => E;
+        readonly _A: (_: never) => A;
+    };
+    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;
+}

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;