@fncts/io 0.0.48 → 0.0.49

package/Fiber/FiberRuntime.d.ts

@@ -1,114 +1,145 @@
 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 { FiberRefs } from "@fncts/io/FiberRefs";
+import { FiberId } from "@fncts/base/data/FiberId/definition";
+import { Maybe, Just } from "@fncts/base/data/Maybe/definition";
+import { FiberScope } from "@fncts/io/FiberScope";
+import { List, Cons } from "@fncts/base/collection/immutable/List/definition";
 import { FiberRef } from "@fncts/io/FiberRef/definition";
-import { Maybe } from "@fncts/base/data/Maybe/definition";
-import { IllegalStateError, NoSuchElementError, isInterruptedException } from "@fncts/base/data/exceptions";
 import { TraceElement } from "@fncts/base/data/TraceElement/definition";
-import { FiberScope } from "@fncts/io/FiberScope";
+import { Cause } from "@fncts/base/data/Cause/definition";
+import { Supervisor } from "@fncts/io/Supervisor/definition";
 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 { NoSuchElementError, IllegalStateError } from "@fncts/base/data/exceptions";
+import { Either } from "@fncts/base/data/Either/definition";
+import type { OnSuccess, OnSuccessAndFailure, UIO, UpdateRuntimeFlags } from "../IO/definition.js";
 import type { WhileLoop } 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 { IOTag } from "../IO/definition.js";
+import { FiberStatus } from "../FiberStatus.js";
 import { FiberMessage } from "./FiberMessage.js";
-export declare class RevertFlags {
-    readonly patch: RuntimeFlags.Patch;
-    readonly trace?: string | undefined;
-    readonly _ioOpCode = IOTag.RevertFlags;
-    constructor(patch: RuntimeFlags.Patch, trace?: string | undefined);
-}
-export declare class UpdateTrace {
-    readonly trace?: string | undefined;
-    readonly _ioOpCode = IOTag.UpdateTrace;
-    constructor(trace?: string | undefined);
-}
-export type Continuation = OnSuccess | OnSuccessAndFailure | OnFailure | WhileLoop | UpdateTrace | RevertFlags;
+export type Continuation = OnSuccess | OnSuccessAndFailure | WhileLoop | UpdateRuntimeFlags;
 /**
  * @tsplus type fncts.io.Fiber
  */
 export declare class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
     readonly fiberId: FiberId.Runtime;
     readonly runtimeFlags0: RuntimeFlags;
+    readonly _tag = "RuntimeFiber";
     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>;
+    location: string | undefined;
     get await(): UIO<Exit<E, A>>;
     get children(): UIO<Conc<FiberRuntime<any, any>>>;
     get fiberRefs(): UIO<FiberRefs>;
+    get id(): FiberId.Runtime;
     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>;
+    get runtimeFlags(): UIO<RuntimeFlags>;
+    get scope(): import("../FiberScope.js").FiberScope;
+    get status(): UIO<FiberStatus>;
+    get trace(): UIO<Trace>;
+    private _asyncContWith;
+    private _blockingOn;
+    private _children;
+    private _exitValue;
+    private _fiberRefs;
+    private _forksSinceYield;
+    private _lastTrace;
+    private _runtimeFlags;
+    private _stack;
+    private _stackSize;
+    private inbox;
+    private observers;
+    private running;
+    constructor(fiberId: FiberId.Runtime, fiberRefs0: FiberRefs, runtimeFlags0: RuntimeFlags);
+    addChild(child: FiberRuntime<any, any>): void;
+    addChildren(children: Iterable<FiberRuntime<any, any>>): void;
     addObserver(observer: (exit: Exit<E, A>) => void): void;
+    deleteFiberRef(ref: FiberRef<any>): void;
+    exitValue(): Exit<E, A> | null;
+    generateStackTrace(): Trace;
     getChildren(): Set<FiberRuntime<any, any>>;
+    getFiberRef<A>(fiberRef: FiberRef<A>): A;
     getFiberRefs(): FiberRefs;
-    setFiberRefs(fiberRefs0: FiberRefs): void;
-    private patchRuntimeFlags;
-    private sendInterruptSignalToAllChildren;
-    private interruptAllChildren;
-    private initiateAsync;
+    getInterruptedCause(): Cause<never>;
+    getSupervisor(): Supervisor<any>;
+    interruptAs(fiberId: FiberId, __tsplusTrace?: string): UIO<Exit<E, A>>;
+    interruptAsFork(fiberId: FiberId, __tsplusTrace?: string): UIO<void>;
+    isAlive(): boolean;
+    isDone(): boolean;
+    isFatal(t: unknown): boolean;
+    isInterrupted(): boolean;
+    log(message: () => string, cause: Cause<any>, overrideLogLevel: Maybe<LogLevel>, trace?: string): void;
+    removeChild(child: FiberRuntime<any, any>): void;
+    removeObserver(observer: (exit: Exit<E, A>) => void): void;
+    resume<R>(effect: IO<R, E, A>): void;
+    runLoop(effect: IO.Concrete, minStackIndex: number, startStackIndex: number, currentDepth: number, currentOps: number): Exit<any, any> | null;
     setFiberRef<A>(fiberRef: FiberRef<A>, value: A): void;
+    setFiberRefs(fiberRefs0: FiberRefs): void;
+    shouldYieldBeforeFork(): boolean;
+    start<R>(effect: IO<R, E, A>): import("@fncts/base/data/Exit").Exit<E, A> | null;
+    startConcurrently(io: IO<any, E, A>): void;
+    startFork<R>(effect: IO<R, E, A>): void;
+    startSuspended(): (io: IO<any, E, A>) => any;
+    tell(message: FiberMessage): void;
+    tellAddChild(child: FiberRuntime<any, any>): void;
+    tellAddChildren(children: Iterable<FiberRuntime<any, any>>): void;
+    tellInterrupt(cause: Cause<never>): void;
+    transferChildren(scope: FiberScope): void;
+    updateFiberRef<A>(fiberRef: FiberRef<A>, f: (a: A) => A): void;
     private addInterruptedCause;
-    private processNewInterruptSignal;
+    private awaitUnsafe;
+    private childrenChunk;
+    private drainQueueAfterAsync;
+    private drainQueueLaterOnExecutor;
+    private drainQueueOnCurrentThread;
+    private drainQueueWhileRunning;
+    private ensureStackCapacity;
+    private evaluateEffect;
     private evaluateMessageWhileSuspended;
-    private generateStackTrace;
+    /**
+     * Removes references of entries from the stack higher than the current index
+     * so that they can be garbage collected.
+     *
+     * @note
+     *   We only GC up to the {@link STACK_IDX_GC_THRESHOLD} index because
+     *   we know that entries in indices higher than that have been auto-gc'd
+     *   during the runloop
+     * @note
+     *   This method MUST be invoked by the fiber itself while it's still running.
+     */
+    private gcStack;
+    private getStatus;
+    private initiateAsync;
+    private interruptAllChildren;
+    private isInterruptible;
+    private patchRuntimeFlags;
+    private patchRuntimeFlagsOnly;
+    /**
+     * Sets the `_stackSize` to `nextStackIndex`.
+     *
+     * This method might also null out the entry in the stack to allow it to be
+     * GC'd, but only if the index is >= `FiberRuntime.StackIdxGcThreshold`.
+     *
+     * This is based on the assumption that when the stack is shallow, the entries
+     * in the array will keep being overwritten as the pointer moves up and down.
+     */
+    private popStackFrame;
+    private processNewInterruptSignal;
+    private processStatefulMessage;
+    private pushStackFrame;
+    private run;
+    private sendInterruptSignalToAllChildren;
     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 | OnSuccess | WhileLoop | RevertFlags | UpdateTrace | undefined;
-    getNextFailCont(): OnSuccessAndFailure | OnFailure | RevertFlags | UpdateTrace | undefined;
-    isFatal(t: unknown): boolean;
+    private shouldInterrupt;
+    private updateLastTrace;
 }
+export declare function highestOneBit(i: number): number;

package/Fiber/api/interruptAs.d.ts

@@ -6,9 +6,9 @@ import { Exit } from "@fncts/base/data/Exit/definition";
  * @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>;
+export declare function interruptAsFork<E, A>(self: Fiber<E, A>, fiberId: FiberId, __tsplusTrace?: string): UIO<void>;
 /**
  * @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>>;
+export declare function interruptAs<E, A>(self: Fiber<E, A>, fiberId: FiberId, __tsplusTrace?: string): UIO<Exit<E, A>>;

package/Fiber/definition.d.ts

@@ -49,6 +49,7 @@ export interface FiberCommon<E, A> extends Fiber<E, A> {
      * Otherwise, the effect will resume when the fiber exits.
      */
     readonly interruptAsFork: (fiberId: FiberId) => UIO<void>;
+    readonly interruptAs: (fiberId: FiberId) => UIO<Exit<E, A>>;
     /**
      * Tentatively observes the fiber, but returns immediately if it is not already done.
      */
@@ -92,6 +93,7 @@ export declare class SyntheticFiber<E, A> implements FiberCommon<E, A> {
     };
     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>);
+    interruptAs: (fiberId: FiberId) => UIO<Exit<E, A>>;
 }
 export type ConcreteFiber<E, A> = Fiber.Runtime<E, A> | Fiber.Synthetic<E, A>;
 /**

package/FiberScope/definition.d.ts

@@ -14,14 +14,17 @@ import type { RuntimeFlags } from "@fncts/io/RuntimeFlags";
 export declare abstract class FiberScope {
     abstract fiberId: FiberId;
     abstract unsafeAdd(currentFiber: FiberRuntime<any, any>, runtimeFlags: RuntimeFlags, child: FiberRuntime<any, any>): void;
+    abstract unsafeAddAll(currentFiber: FiberRuntime<any, any>, runtimeFlags: RuntimeFlags, children: Iterable<FiberRuntime<any, any>>): void;
 }
 export declare class Global extends FiberScope {
     get fiberId(): FiberId;
     unsafeAdd(_currentFiber: FiberRuntime<any, any>, runtimeFlags: RuntimeFlags, child: FiberRuntime<any, any>): void;
+    unsafeAddAll(_currentFiber: FiberRuntime<any, any>, runtimeFlags: RuntimeFlags, children: Iterable<FiberRuntime<any, any>>): void;
 }
 export declare class Local extends FiberScope {
     readonly fiberId: FiberId;
     private parentRef;
     constructor(fiberId: FiberId, parentRef: WeakRef<FiberRuntime<unknown, unknown>>);
     unsafeAdd(currentFiber: FiberRuntime<any, any>, _runtimeFlags: RuntimeFlags, child: FiberRuntime<any, any>): void;
+    unsafeAddAll(currentFiber: FiberRuntime<any, any>, _runtimeFlags: RuntimeFlags, children: Iterable<FiberRuntime<any, any>>): void;
 }

package/FiberSet.d.ts

@@ -8,11 +8,12 @@ export type FiberSetTypeId = typeof FiberSetTypeId;
  * @tsplus type fncts.io.FiberSet
  * @tsplus companion fncts.io.FiberSetOps
  */
-export declare class FiberSet<E, A> {
+export declare class FiberSet<E, A> implements Iterable<Fiber<E, A>> {
     readonly backing: Set<Fiber.Runtime<E, A>>;
     readonly future: Future<unknown, never>;
     readonly [FiberSetTypeId]: FiberSetTypeId;
     constructor(backing: Set<Fiber.Runtime<E, A>>, future: Future<unknown, never>);
+    [Symbol.iterator](): Iterator<Fiber<E, A>>;
 }
 /**
  * @tsplus static fncts.io.FiberSetOps unsafeMake

package/Future/State.d.ts

@@ -0,0 +1,59 @@
+import { FIO } from "@fncts/io/IO/definition";
+export type FutureState<E, A> = Done<E, A> | Pending<E, A>;
+export declare const enum FutureStateTag {
+    Link = 0,
+    Empty = 1,
+    Done = 2
+}
+export declare abstract class Pending<E, A> {
+    abstract size: number;
+    abstract complete(io: FIO<E, A>): void;
+    abstract add(waiter: (io: FIO<E, A>) => any): Pending<E, A>;
+    abstract remove(waiter: (io: FIO<E, A>) => any): Pending<E, A>;
+}
+export type Concrete<E, A> = Empty | Link<E, A> | Done<E, A>;
+export type ConcretePending<E, A> = Empty | Link<E, A>;
+/**
+ * @tsplus fluent fncts.io.Future.State concrete
+ * @tsplus macro remove
+ * @tsplus location "@fncts/io/Future/State"
+ */
+export declare function concrete<E, A>(self: State<E, A>): asserts self is Concrete<E, A>;
+/**
+ * @tsplus fluent fncts.io.Future.State concretePending
+ * @tsplus macro remove
+ * @tsplus location "@fncts/io/Future/State"
+ */
+export declare function concretePending<E, A>(self: Pending<E, A>): asserts self is ConcretePending<E, A>;
+export declare class Empty extends Pending<never, never> {
+    readonly _tag = FutureStateTag.Empty;
+    size: number;
+    complete(_: FIO<never, never>): void;
+    add(waiter: (io: FIO<never, never>) => any): Pending<never, never>;
+    remove(_: (io: FIO<never, never>) => any): Pending<never, never>;
+}
+/**
+ * @tsplus static fncts.io.Future.State Empty
+ * @tsplus location "@fncts/io/Future/State"
+ */
+export declare const _Empty: Empty;
+export declare class Link<E, A> extends Pending<E, A> {
+    readonly waiter: (io: FIO<E, A>) => any;
+    readonly ws: Pending<E, A>;
+    readonly size: number;
+    readonly _tag = FutureStateTag.Link;
+    constructor(waiter: (io: FIO<E, A>) => any, ws: Pending<E, A>, size: number);
+    add(waiter: (io: FIO<E, A>) => any): Pending<E, A>;
+    complete(io: FIO<E, A>): void;
+    remove(waiter: (io: FIO<E, A>) => any): Pending<E, A>;
+}
+export declare class Done<E, A> {
+    readonly value: FIO<E, A>;
+    readonly _tag = FutureStateTag.Done;
+    constructor(value: FIO<E, A>);
+}
+/**
+ * @tsplus type fncts.io.Future.State
+ * @tsplus companion fncts.io.Future.State
+ */
+export type State<E, A> = Done<E, A> | Pending<E, A>;

package/Future/api.d.ts

@@ -29,7 +29,7 @@ export declare function failCause<E>(cause: Cause<E>, __tsplusTrace?: string): <
  * Completes the future with the result of the specified effect. If the
  * future has already been completed, the method will produce false.
  *
- * Note that `Future.completeWith` will be much faster, so consider using
+ * Note that `Future.fulfillWith` will be much faster, so consider using
  * that if you do not need to memoize the result of the specified effect.
  * @tsplus pipeable fncts.io.Future fulfill
  * @tsplus location "@fncts/io/Future/api"
@@ -46,7 +46,7 @@ export declare function fulfill<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string
  * case te meaning of the "exactly once" guarantee of `Future` is that the
  * future can be completed with exactly one effect. For a version that
  * completes the future with the result of an IO see
- * `Future.complete`.
+ * `Future.fulfill`.
  * @tsplus pipeable fncts.io.Future fulfillWith
  * @tsplus location "@fncts/io/Future/api"
  */
@@ -105,11 +105,16 @@ export declare function succeedVoid_(a: void, __tsplusTrace?: string): <E>(futur
  * @tsplus location "@fncts/io/Future/api"
  */
 export declare function unsafeDone<E, A>(io: FIO<E, A>, __tsplusTrace?: string): (future: Future<E, A>) => void;
+/**
+ * @tsplus pipeable fncts.io.Future unsafeFulfill
+ * @tsplus location "@fncts/io/Future/api"
+ */
+export declare function unsafeFulfill<E, A>(io: FIO<E, A>): (future: Future<E, A>) => boolean;
 /**
  * @tsplus pipeable fncts.io.Future unsafeSucceed
  * @tsplus location "@fncts/io/Future/api"
  */
-export declare function unsafeSucceed<A>(a: A, __tsplusTrace?: string): (future: Future<never, A>) => void;
+export declare function unsafeSucceed<A>(a: A, __tsplusTrace?: string): (future: Future<never, A>) => boolean;
 /**
  * Retrieves the value of the future, suspending the fiber running the action
  * until the result is available.

package/Future/constructors.d.ts

@@ -12,7 +12,7 @@ export declare function make<E, A>(__tsplusTrace?: string): IO<never, never, Fut
  * @tsplus static fncts.io.FutureOps makeAs
  * @tsplus location "@fncts/io/Future/constructors"
  */
-export declare function makeAs<E, A>(fiberId: FiberId, __tsplusTrace?: string): import("../IO").UIO<Future<E, A>>;
+export declare function makeAs<E, A>(fiberId: FiberId, __tsplusTrace?: string): import("../IO.js").UIO<Future<E, A>>;
 /**
  * Makes a new future to be completed by the fiber with the specified id.
  * @tsplus static fncts.io.FutureOps unsafeMake

package/Future/definition.d.ts

@@ -1,6 +1,5 @@
 import { FiberId } from "@fncts/base/data/FiberId/definition";
-import { List } from "@fncts/base/collection/immutable/List/definition";
-import { FIO } from "@fncts/io/IO/definition";
+import type { State } from "./State.js";
 export declare const FutureTypeId: unique symbol;
 export type FutureTypeId = typeof FutureTypeId;
 export declare const FutureVariance: unique symbol;
@@ -31,18 +30,3 @@ export declare namespace Future {
         };
     }] ? A : never;
 }
-export declare const enum FutureStateTag {
-    Done = 0,
-    Pending = 1
-}
-export declare class Pending<E, A> {
-    readonly joiners: List<(_: FIO<E, A>) => void>;
-    readonly _tag = FutureStateTag.Pending;
-    constructor(joiners: List<(_: FIO<E, A>) => void>);
-}
-export declare class Done<E, A> {
-    readonly value: FIO<E, A>;
-    readonly _tag = FutureStateTag.Done;
-    constructor(value: FIO<E, A>);
-}
-export type State<E, A> = Done<E, A> | Pending<E, A>;

package/Future.d.ts

@@ -1,3 +1,4 @@
 export * from "./Future/api.js";
 export * from "./Future/constructors.js";
 export * from "./Future/definition.js";
+export * from "./Future/State.js";

package/Hub/api.d.ts

@@ -37,6 +37,12 @@ export declare function dimap<A, B, C, D>(f: (c: C) => A, g: (b: B) => D, __tspl
  * @tsplus location "@fncts/io/Hub/api"
  */
 export declare function dimapIO<A, B, RC, EC, C, RD, ED, D>(f: (c: C) => IO<RC, EC, A>, g: (b: B) => IO<RD, ED, D>, __tsplusTrace?: string): <RA, RB, EA, EB>(source: PHub<RA, RB, EA, EB, A, B>) => PHub<RC | RA, RD | RB, EA | EC, EB | ED, C, D>;
+/**
+ * Filters messages published to the hub using the specified function.
+ * @tsplus pipeable fncts.io.Hub filterInput
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function filterInput<A>(f: (a: A) => boolean, __tsplusTrace?: string): <RA, RB, EA, EB, B>(self: PHub<RA, RB, EA, EB, A, B>) => import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, B>;
 /**
  * Filters messages published to the hub using the specified effectual
  * function.
@@ -45,11 +51,11 @@ export declare function dimapIO<A, B, RC, EC, C, RD, ED, D>(f: (c: C) => IO<RC,
  */
 export declare function filterInputIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(source: PHub<RA, RB, EA, EB, A, B>) => PHub<RA | R1, RB, EA | E1, EB, A, B>;
 /**
- * Filters messages published to the hub using the specified function.
- * @tsplus pipeable fncts.io.Hub filterInput
+ * Filters messages taken from the hub using the specified function.
+ * @tsplus pipeable fncts.io.Hub filterOutput
  * @tsplus location "@fncts/io/Hub/api"
  */
-export declare function filterInput<A>(f: (a: A) => boolean, __tsplusTrace?: string): <RA, RB, EA, EB, B>(self: PHub<RA, RB, EA, EB, A, B>) => import("@fncts/io/Hub/definition").PHub<RA, RB, EA, EB, A, B>;
+export declare function filterOutput<B>(f: (b: B) => boolean, __tsplusTrace?: string): <RA, RB, EA, EB, A>(self: PHub<RA, RB, EA, EB, A, B>) => PHub<RA, RB, EA, EB, A, B>;
 /**
  * Filters messages taken from the hub using the specified effectual
  * function.
@@ -57,12 +63,6 @@ export declare function filterInput<A>(f: (a: A) => boolean, __tsplusTrace?: str
  * @tsplus location "@fncts/io/Hub/api"
  */
 export declare function filterOutputIO<B, R1, E1>(f: (a: B) => IO<R1, E1, boolean>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(source: PHub<RA, RB, EA, EB, A, B>) => PHub<RA, RB | R1, EA, EB | E1, A, B>;
-/**
- * Filters messages taken from the hub using the specified function.
- * @tsplus pipeable fncts.io.Hub filterOutput
- * @tsplus location "@fncts/io/Hub/api"
- */
-export declare function filterOutput<B>(f: (b: B) => boolean, __tsplusTrace?: string): <RA, RB, EA, EB, A>(self: PHub<RA, RB, EA, EB, A, B>) => PHub<RA, RB, EA, EB, A, B>;
 /**
  * Checks whether the hub is shut down.
  * @tsplus getter fncts.io.Hub isShutdown
@@ -136,6 +136,12 @@ export declare function publishAll<A>(as: Iterable<A>, __tsplusTrace?: string):
  * @tsplus location "@fncts/io/Hub/api"
  */
 export declare function shutdown<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): UIO<void>;
+/**
+ * The current number of messages in the hub.
+ * @tsplus getter fncts.io.Hub size
+ * @tsplus location "@fncts/io/Hub/api"
+ */
+export declare function size<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): UIO<number>;
 /**
  * Subscribes to receive messages from the hub. The resulting subscription
  * can be evaluated multiple times within the scope of the managed to take a
@@ -144,12 +150,6 @@ export declare function shutdown<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB
  * @tsplus location "@fncts/io/Hub/api"
  */
 export declare function subscribe<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): IO<Scope, never, PDequeue<RA, RB, EA, EB, A, B>>;
-/**
- * The current number of messages in the hub.
- * @tsplus getter fncts.io.Hub size
- * @tsplus location "@fncts/io/Hub/api"
- */
-export declare function size<RA, RB, EA, EB, A, B>(self: PHub<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): UIO<number>;
 /**
  * Views the hub as a queue that can only be written to.
  * @tsplus getter fncts.io.Hub toQueue

package/IO/api/array.d.ts

@@ -0,0 +1,22 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+/**
+ * @tsplus fluent fncts.ReadonlyArray mapIOWithIndexDiscard
+ * @tsplus location "@fncts/io/IO/api/array"
+ */
+export declare function foreachArrayWithIndexDiscard<A, R, E>(array: ReadonlyArray<A>, f: (i: number, a: A) => IO<R, E, unknown>): IO<R, E, void>;
+/**
+ * @tsplus fluent fncts.ReadonlyArray mapIODiscard
+ * @tsplus location "@fncts/io/IO/api/array"
+ */
+export declare function foreachArrayDiscard<A, R, E>(array: ReadonlyArray<A>, f: (a: A) => IO<R, E, unknown>): IO<R, E, void>;
+/**
+ * @tsplus fluent fncts.ReadonlyArray mapIOWithIndex
+ * @tsplus location "@fncts/io/IO/api/array"
+ */
+export declare function foreachArrayWithIndex<A, R, E, B>(array: ReadonlyArray<A>, f: (i: number, a: A) => IO<R, E, B>): IO<R, E, Conc<B>>;
+/**
+ * @tsplus fluent fncts.ReadonlyArray mapIO
+ * @tsplus location "@fncts/io/IO/api/array"
+ */
+export declare function foreachArray<A, R, E, B>(array: ReadonlyArray<A>, f: (a: A) => IO<R, E, B>): IO<R, E, Conc<B>>;

package/IO/api/awaitAllChildren.d.ts

@@ -0,0 +1,6 @@
+import { IO } from "@fncts/io/IO/definition";
+/**
+ * @tsplus getter fncts.io.IO awaitAllChildren
+ * @tsplus location "@fncts/io/IO/api/awaitAllChildren"
+ */
+export declare function awaitAllChildren<R, E, A>(self: IO<R, E, A>): IO<R, E, A>;

package/IO/api/cachedInvalidate.d.ts

@@ -0,0 +1,15 @@
+import { Lazy } from "@fncts/base/data/function/definition";
+import { Duration } from "@fncts/base/data/Duration/definition";
+import { IO, FIO, UIO } from "@fncts/io/IO/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Future } from "@fncts/io/Future";
+/**
+ * @tsplus pipeable fncts.io.IO cached
+ * @tsplus location "@fncts/io/IO/api/cachedInvalidate"
+ */
+export declare function cached(timeToLive: Lazy<Duration>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R, never, FIO<E, A>>;
+/**
+ * @tsplus pipeable fncts.io.IO cachedInvalidate
+ * @tsplus location "@fncts/io/IO/api/cachedInvalidate"
+ */
+export declare function cachedInvalidate(timeToLive: Lazy<Duration>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R, never, readonly [FIO<E, A>, UIO<void>]>;

package/IO/api/forkDaemon.d.ts

@@ -7,4 +7,4 @@ import type { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
  * @tsplus getter fncts.io.IO forkDaemon
  * @tsplus location "@fncts/io/IO/api/forkDaemon"
  */
-export declare function forkDaemon<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): URIO<R, FiberRuntime<E, A>>;
+export declare function forkDaemon<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): URIO<R, FiberRuntime<E, A>>;

package/IO/api/onTermination.d.ts

@@ -1,8 +1,7 @@
 import { Cause } from "@fncts/base/data/Cause/definition";
 import { URIO, IO } from "@fncts/io/IO/definition";
-import { Lazy } from "@fncts/base/data/function/definition";
 /**
  * @tsplus pipeable fncts.io.IO onTermination
  * @tsplus location "@fncts/io/IO/api/onTermination"
  */
-export declare function onTermination<R1>(cleanup: (cause: Cause<never>) => URIO<R1, any>, __tsplusTrace?: string): <R, E, A>(self: Lazy<IO<R, E, A>>) => IO<R | R1, E, A>;
+export declare function onTermination<R1>(cleanup: (cause: Cause<never>) => URIO<R1, any>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R | R1, E, A>;

package/IO/api/transplant.d.ts

@@ -1,5 +1,8 @@
 import { IO } from "@fncts/io/IO/definition";
-export type Grafter = <R, E, A>(effect: IO<R, E, A>) => IO<R, E, A>;
+import { FiberScope } from "@fncts/io/FiberScope";
+import { FiberRef } from "@fncts/io/FiberRef/definition";
+import { Just } from "@fncts/base/data/Maybe/definition";
+import { Exit } from "@fncts/base/data/Exit/definition";
 /**
  * Transplants specified effects so that when those effects fork other
  * effects, the forked effects will be governed by the scope of the
@@ -11,3 +14,10 @@ export type Grafter = <R, E, A>(effect: IO<R, E, A>) => IO<R, E, A>;
  * @tsplus location "@fncts/io/IO/api/transplant"
  */
 export declare function transplant<R, E, A>(f: (_: Grafter) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
+export declare class Grafter {
+    private readonly scope;
+    constructor(scope: FiberScope);
+    graft: <R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string) => IO<R, E, A>;
+    graftOnExit: <R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string) => IO<R, E, A>;
+    graftOnExitWith: <R, E, A>(io: IO<R, E, A>, ensuring: (exit: Exit<E, A>) => void, __tsplusTrace?: string) => IO<R, E, A>;
+}