@fncts/io 0.0.34 → 0.0.35

package/Fiber/FiberRuntime.d.ts

@@ -18,24 +18,24 @@ 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 { 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 { WhileLoop } from "../IO/definition.js";
-import { IOOpCode } from "../IO/definition.js";
+import { IOTag } from "../IO/definition.js";
 import { FiberMessage } from "./FiberMessage.js";
 export declare class RevertFlags {
     readonly patch: RuntimeFlags.Patch;
     readonly trace?: string | undefined;
-    readonly _tag = IOOpCode.RevertFlags;
+    readonly _tag = IOTag.RevertFlags;
     constructor(patch: RuntimeFlags.Patch, trace?: string | undefined);
 }
 export declare class UpdateTrace {
     readonly trace?: string | undefined;
-    readonly _tag = IOOpCode.UpdateTrace;
+    readonly _tag = IOTag.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;
+export type Continuation = OnSuccess | OnSuccessAndFailure | OnFailure | WhileLoop | UpdateTrace | RevertFlags;
 /**
  * @tsplus type fncts.io.Fiber
  */
@@ -108,7 +108,7 @@ export declare class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
     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;
+    getNextSuccessCont(): OnSuccessAndFailure | OnSuccess | WhileLoop | RevertFlags | UpdateTrace | undefined;
+    getNextFailCont(): OnSuccessAndFailure | OnFailure | RevertFlags | UpdateTrace | undefined;
     isFatal(t: unknown): boolean;
 }

package/IO/api/all.d.ts

@@ -0,0 +1,41 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import type { EnvironmentOf, ErrorOf, ValueOf } from "@fncts/io/IO";
+/**
+ * @tsplus static fncts.io.IOOps all
+ * @tsplus location "@fncts/io/IO/api/all"
+ */
+export declare function all<T extends ReadonlyArray<IO<any, any, any>>>(ios: [...T]): IO<{
+    [K in number]: EnvironmentOf<T[K]>;
+}[number], {
+    [K in number]: ErrorOf<T[K]>;
+}[number], {
+    [K in keyof T]: ValueOf<T[K]>;
+}>;
+export declare function all<T extends Iterable<IO<any, any, any>>>(ios: T): [T] extends [Iterable<infer A>] ? IO<EnvironmentOf<A>, ErrorOf<A>, Conc<ValueOf<A>>> : never;
+export declare function all<T extends Record<string, IO<any, any, any>>>(ios: T): IO<{
+    [K in keyof T]: EnvironmentOf<T[K]>;
+}[keyof T], {
+    [K in keyof T]: ErrorOf<T[K]>;
+}[keyof T], {
+    [K in keyof T]: ValueOf<T[K]>;
+}>;
+/**
+ * @tsplus static fncts.io.IOOps allConcurrent
+ * @tsplus location "@fncts/io/IO/api/all"
+ */
+export declare function allConcurrent<T extends ReadonlyArray<IO<any, any, any>>>(ios: [...T]): IO<{
+    [K in number]: EnvironmentOf<T[K]>;
+}[number], {
+    [K in number]: ErrorOf<T[K]>;
+}[number], {
+    [K in keyof T]: ValueOf<T[K]>;
+}>;
+export declare function allConcurrent<T extends Iterable<IO<any, any, any>>>(ios: T): [T] extends [Iterable<infer A>] ? IO<EnvironmentOf<A>, ErrorOf<A>, Conc<ValueOf<A>>> : never;
+export declare function allConcurrent<T extends Record<string, IO<any, any, any>>>(ios: T): IO<{
+    [K in keyof T]: EnvironmentOf<T[K]>;
+}[keyof T], {
+    [K in keyof T]: ErrorOf<T[K]>;
+}[keyof T], {
+    [K in keyof T]: ValueOf<T[K]>;
+}>;

package/IO/api/concurrency.d.ts

@@ -33,3 +33,14 @@ export declare function withConcurrency(n: number, __tsplusTrace?: string): <R,
  * @tsplus location "@fncts/io/IO/api/concurrency"
  */
 export declare function withConcurrencyUnbounded<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
+export type ConcurrencyRestorer = <R, E, A>(io: IO<R, E, A>) => IO<R, E, A>;
+/**
+ * @tsplus static fncts.io.IOOps withConcurrencyMask
+ * @tsplus location "@fncts/io/IO/api/concurrency"
+ */
+export declare function withConcurrencyMask<R, E, A>(n: number, f: (restore: ConcurrencyRestorer) => IO<R, E, A>): IO<R, E, A>;
+/**
+ * @tsplus static fncts.io.IOOps withConcurrencyUnboundedMask
+ * @tsplus location "@fncts/io/IO/api/concurrency"
+ */
+export declare function withConcurrencyUnboundedMask<R, E, A>(f: (restore: ConcurrencyRestorer) => IO<R, E, A>): IO<R, E, A>;

package/IO/api/interrupt.d.ts

@@ -51,7 +51,7 @@ export declare function uninterruptible<R, E, A>(self: IO<R, E, A>, __tsplusTrac
  * @tsplus static fncts.io.IOOps uninterruptibleMask
  * @tsplus location "@fncts/io/IO/api/interrupt"
  */
-export declare function uninterruptibleMask<R, E, A>(f: (restore: InterruptibilityRestorer) => IO<R, E, A>): IO<R, E, A>;
+export declare function uninterruptibleMask<R, E, A>(f: (restore: InterruptibilityRestorer) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * @tsplus pipeable fncts.io.IO ensuring
  * @tsplus location "@fncts/io/IO/api/interrupt"

package/IO/api/raceWith.d.ts

@@ -1,5 +1,6 @@
 import { Lazy } from "@fncts/base/data/function/definition";
 import { IO } from "@fncts/io/IO/definition";
+import { FiberScope } from "@fncts/io/FiberScope";
 import { Exit } from "@fncts/base/data/Exit/definition";
 import { Fiber } from "@fncts/io/Fiber/definition";
 import type { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
@@ -7,7 +8,7 @@ import type { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
  * @tsplus pipeable fncts.io.IO raceFibersWith
  * @tsplus location "@fncts/io/IO/api/raceWith"
  */
-export declare function raceFibersWith<R, E, A, R1, E1, B, R2, E2, C, R3, E3, D>(right: Lazy<IO<R1, E1, B>>, leftWins: (winner: FiberRuntime<E, A>, loser: FiberRuntime<E1, B>) => IO<R2, E2, C>, rightWins: (winner: FiberRuntime<E1, B>, loser: FiberRuntime<E, A>) => IO<R3, E3, D>, __tsplusTrace?: string): (left: IO<R, E, A>) => IO<R | R1 | R2 | R3, E2 | E3, C | D>;
+export declare function raceFibersWith<R, E, A, R1, E1, B, R2, E2, C, R3, E3, D>(right: Lazy<IO<R1, E1, B>>, leftWins: (winner: FiberRuntime<E, A>, loser: FiberRuntime<E1, B>) => IO<R2, E2, C>, rightWins: (winner: FiberRuntime<E1, B>, loser: FiberRuntime<E, A>) => IO<R3, E3, D>, leftScope?: FiberScope | null, rightScope?: FiberScope | null, __tsplusTrace?: string): (left: IO<R, E, A>) => IO<R | R1 | R2 | R3, E2 | E3, C | D>;
 /**
  * Returns an effect that races this effect with the specified effect, calling
  * the specified finisher as soon as one result or the other has been computed.

package/IO/api.d.ts

@@ -194,14 +194,14 @@ export declare function condIO<R, R1, E, A>(b: boolean, onTrue: URIO<R, A>, onFa
  * @tsplus static fncts.io.IOOps defer
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function defer<R, E, A>(io: Lazy<IO<R, E, A>>, __tsplusTrace?: string): IO<R, E, A>;
+export declare function defer<R = never, E = never, A = never>(io: Lazy<IO<R, E, A>>, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * Returns a lazily constructed effect, whose construction may itself require effects.
  * When no environment is required (i.e., when R == unknown) it is conceptually equivalent to `flatten(try(io))`.
  * @tsplus static fncts.io.IOOps deferTry
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function deferTry<R, E, A>(io: () => IO<R, E, A>, __tsplusTrace?: string): IO<R, unknown, A>;
+export declare function deferTry<R = never, E = never, A = never>(io: () => IO<R, E, A>, __tsplusTrace?: string): IO<R, unknown, A>;
 /**
  * Returns a lazily constructed effect, whose construction may itself require effects,
  * translating any thrown exceptions into typed failed effects and mapping the error.
@@ -903,6 +903,11 @@ export declare function swapWith<R, E, A, R1, E1, A1>(f: (ma: IO<R, A, E>) => IO
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function timedWith<R1, E1>(msTime: IO<R1, E1, number>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R1 | R, E1 | E, readonly [number, A]>;
+/**
+ * @tsplus static fncts.io.IOOps attempt
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function attempt<A>(effect: Lazy<A>, __tsplusTrace?: string): FIO<unknown, A>;
 /**
  * Creates a `IO` that has succeeded with a pure value
  * @tsplus static fncts.io.IOOps tryCatch

package/IO/definition.d.ts

@@ -2,16 +2,14 @@ import { HKT } from "@fncts/typelevel/HKT";
 import { NoSuchElementError } from "@fncts/base/data/exceptions";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
 import { Cause } from "@fncts/base/data/Cause/definition";
-import { Lazy } from "@fncts/base/data/function/definition";
 import { STM } from "@fncts/io/STM/definition";
 import { Nothing, Just } from "@fncts/base/data/Maybe/definition";
 import type { FiberRuntime } from "../Fiber/FiberRuntime.js";
 import type { Running } from "../FiberStatus.js";
 import type { RuntimeFlagsPatch } from "../RuntimeFlags.js";
+import type { RuntimeFlags } from "../RuntimeFlags.js";
 import type { Left, Right } from "@fncts/base/data/Either";
 import type { Failure, Success } from "@fncts/base/data/Exit";
-import type { Trace } from "@fncts/base/data/Trace";
-import { RuntimeFlags } from "../RuntimeFlags.js";
 export declare const IOVariance: unique symbol;
 export type IOVariance = typeof IOVariance;
 export declare const IOTypeId: unique symbol;
@@ -36,6 +34,21 @@ export declare abstract class IO<R, E, A> {
         _A: () => A;
     };
 }
+export type EnvironmentOf<T> = [T] extends [{
+    [IOVariance]: {
+        _R: () => infer R;
+    };
+}] ? R : never;
+export type ErrorOf<T> = [T] extends [{
+    [IOVariance]: {
+        _E: () => infer E;
+    };
+}] ? E : never;
+export type ValueOf<T> = [T] extends [{
+    [IOVariance]: {
+        _A: () => infer A;
+    };
+}] ? A : never;
 declare module "@fncts/base/data/Either/definition" {
     interface Either<E, A> extends IO<never, E, A> {
     }
@@ -85,7 +98,7 @@ export declare function unifyIO<X extends IO<any, any, any>>(self: X): IO<[
 export type UIO<A> = IO<never, never, A>;
 export type URIO<R, A> = IO<R, never, A>;
 export type FIO<E, A> = IO<never, E, A>;
-export declare const enum IOOpCode {
+export declare const enum IOTag {
     SucceedNow = 0,
     Fail = 1,
     Sync = 2,
@@ -103,133 +116,96 @@ export declare const enum IOOpCode {
     RevertFlags = 14,
     UpdateTrace = 15
 }
-export declare function isIO(u: unknown): u is IO<any, any, any>;
-export declare class Sync<A> extends IO<never, never, A> {
-    readonly evaluate: () => A;
-    readonly trace?: string | undefined;
-    readonly _tag = IOOpCode.Sync;
-    constructor(evaluate: () => A, trace?: string | undefined);
-}
-export declare class Async<R, E, A> extends IO<R, E, A> {
-    readonly registerCallback: (f: (_: IO<R, E, A>) => void) => any;
-    readonly blockingOn: () => FiberId;
-    readonly trace?: string | undefined;
-    readonly _tag = IOOpCode.Async;
-    constructor(registerCallback: (f: (_: IO<R, E, A>) => void) => any, blockingOn: () => FiberId, trace?: string | undefined);
+export type IOOp<Tag extends string | number, Body = {}> = IO<never, never, never> & Body & {
+    readonly _tag: Tag;
+};
+export declare class IOPrimitive {
+    readonly _tag: Primitive["_tag"];
+    i0: any;
+    i1: any;
+    i2: any;
+    trace: string | undefined;
+    [IOTypeId]: symbol;
+    constructor(_tag: Primitive["_tag"]);
 }
-/**
- * @internal
- */
-export declare class OnSuccessAndFailure<R, E, A, R1, E1, B, R2, E2, C> extends IO<R | R1 | R2, E1 | E2, B | C> {
-    readonly first: IO<R, E, A>;
-    readonly failureK: (cause: Cause<E>) => IO<R1, E1, B>;
-    readonly successK: (a: A) => IO<R2, E2, C>;
-    readonly trace?: string | undefined;
-    readonly _tag = IOOpCode.OnSuccessAndFailure;
-    constructor(first: IO<R, E, A>, failureK: (cause: Cause<E>) => IO<R1, E1, B>, successK: (a: A) => IO<R2, E2, C>, trace?: string | undefined);
-    onFailure(c: Cause<E>): IO<R | R1 | R2, E1 | E2, B | C>;
-    onSuccess(a: A): IO<R | R1 | R2, E1 | E2, B | C>;
-}
-export declare class OnFailure<R, E, A, R1, E1, B> extends IO<R | R1, E1, A | B> {
-    readonly first: IO<R, E, A>;
-    readonly failureK: (cause: Cause<E>) => IO<R1, E1, B>;
-    readonly trace?: string | undefined;
-    readonly _tag = IOOpCode.OnFailure;
-    constructor(first: IO<R, E, A>, failureK: (cause: Cause<E>) => IO<R1, E1, B>, trace?: string | undefined);
-    onFailure(c: Cause<E>): IO<R | R1, E1, A | B>;
-    onSuccess(a: A): IO<R | R1, E1, A | B>;
-}
-/**
- * @internal
- */
-export declare class OnSuccess<R, R1, E, E1, A, A1> extends IO<R | R1, E | E1, A1> {
-    readonly first: IO<R, E, A>;
-    readonly successK: (a: A) => IO<R1, E1, A1>;
-    readonly trace?: string | undefined;
-    readonly _tag = IOOpCode.OnSuccess;
-    constructor(first: IO<R, E, A>, successK: (a: A) => IO<R1, E1, A1>, trace?: string | undefined);
-    onFailure(c: Cause<E>): IO<R | R1, E | E1, A1>;
-    onSuccess(a: A): IO<R | R1, E | E1, A1>;
-}
-/**
- * @internal
- */
-export declare class SucceedNow<A> extends IO<never, never, A> {
-    readonly value: A;
-    readonly trace?: string | undefined;
-    readonly _tag = IOOpCode.SucceedNow;
-    constructor(value: A, trace?: string | undefined);
-}
-export declare class UpdateRuntimeFlags extends IO<never, never, void> {
-    readonly update: RuntimeFlags.Patch;
-    readonly trace?: string | undefined;
-    readonly _tag = IOOpCode.UpdateRuntimeFlags;
-    constructor(update: RuntimeFlags.Patch, trace?: string | undefined);
-}
-export declare class Interruptible<R, E, A> extends IO<R, E, A> {
-    readonly effect: IO<R, E, A>;
-    readonly trace?: string | undefined;
-    readonly _tag = IOOpCode.UpdateRuntimeFlagsWithin;
-    constructor(effect: IO<R, E, A>, trace?: string | undefined);
-    readonly update: RuntimeFlags.Patch;
-    scope(oldRuntimeFlags: RuntimeFlags): IO<R, E, A>;
-}
-export declare class Uninterruptible<R, E, A> extends IO<R, E, A> {
-    readonly effect: IO<R, E, A>;
-    readonly trace?: string | undefined;
-    readonly _tag = IOOpCode.UpdateRuntimeFlagsWithin;
-    constructor(effect: IO<R, E, A>, trace?: string | undefined);
-    readonly update: RuntimeFlags.Patch;
-    scope(oldRuntimeFlags: RuntimeFlags): IO<R, E, A>;
-}
-export declare class Dynamic<R, E, A> extends IO<R, E, A> {
-    readonly update: RuntimeFlagsPatch;
-    readonly f: (oldRuntimeFlags: RuntimeFlags) => IO<R, E, A>;
-    readonly trace?: string | undefined;
-    readonly _tag = IOOpCode.UpdateRuntimeFlagsWithin;
-    constructor(update: RuntimeFlagsPatch, f: (oldRuntimeFlags: RuntimeFlags) => IO<R, E, A>, trace?: string | undefined);
-    scope(oldRuntimeFlags: RuntimeFlags): IO<R, E, A>;
-}
-export declare class GenerateStackTrace extends IO<never, never, Trace> {
-    readonly trace?: string | undefined;
-    readonly _tag = IOOpCode.GenerateStackTrace;
-    constructor(trace?: string | undefined);
-}
-export declare class Stateful<R, E, A> extends IO<R, E, A> {
-    readonly onState: (fiber: FiberRuntime<E, A>, status: Running) => IO<R, E, A>;
-    readonly trace?: string | undefined;
-    readonly _tag = IOOpCode.Stateful;
-    constructor(onState: (fiber: FiberRuntime<E, A>, status: Running) => IO<R, E, A>, trace?: string | undefined);
-}
-export declare class WhileLoop<R, E, A> extends IO<R, E, void> {
-    readonly check: () => boolean;
-    readonly body: () => IO<R, E, A>;
-    readonly process: (a: A) => any;
-    readonly trace?: string | undefined;
-    readonly _tag = IOOpCode.WhileLoop;
-    constructor(check: () => boolean, body: () => IO<R, E, A>, process: (a: A) => any, trace?: string | undefined);
-}
-export declare class YieldNow extends IO<never, never, void> {
-    readonly trace?: string | undefined;
-    readonly _tag = IOOpCode.YieldNow;
-    constructor(trace?: string | undefined);
-}
-/**
- * @internal
- */
-export declare class Fail<E> extends IO<never, E, never> {
-    readonly cause: Lazy<Cause<E>>;
-    readonly trace?: string | undefined;
-    readonly _tag = IOOpCode.Fail;
-    constructor(cause: Lazy<Cause<E>>, trace?: string | undefined);
-}
-export type Concrete = OnSuccessAndFailure<any, any, any, any, any, any, any, any, any> | OnFailure<any, any, any, any, any, any> | OnSuccess<any, any, any, any, any, any> | UpdateRuntimeFlagsWithin | Sync<any> | Async<any, any, any> | SucceedNow<any> | UpdateRuntimeFlags | GenerateStackTrace | Stateful<any, any, any> | WhileLoop<any, any, any> | YieldNow | Fail<any> | STM<any, any, any> | Left<any> | Right<any> | Nothing | Just<any> | Failure<any> | Success<any>;
+export declare function isIO(u: unknown): u is IO<any, any, any>;
+export interface Sync<A = any> extends IOOp<IOTag.Sync, {
+    readonly i0: () => A;
+    readonly trace: string | undefined;
+}> {
+}
+export interface Async<R = any, E = any, A = any> extends IOOp<IOTag.Async, {
+    readonly i0: (resume: (io: Primitive) => void) => void;
+    readonly i1: () => FiberId;
+    readonly trace: string | undefined;
+}> {
+}
+export interface OnSuccessAndFailure extends IOOp<IOTag.OnSuccessAndFailure, {
+    readonly i0: Primitive;
+    readonly i1: (cause: Cause<unknown>) => Primitive;
+    readonly i2: (a: unknown) => Primitive;
+    readonly trace: string | undefined;
+}> {
+}
+export interface OnFailure extends IOOp<IOTag.OnFailure, {
+    readonly i0: Primitive;
+    readonly i1: (cause: Cause<unknown>) => Primitive;
+    readonly trace: string | undefined;
+}> {
+}
+export interface OnSuccess extends IOOp<IOTag.OnSuccess, {
+    readonly i0: Primitive;
+    readonly i1: (a: unknown) => Primitive;
+    readonly trace: string | undefined;
+}> {
+}
+export interface SucceedNow extends IOOp<IOTag.SucceedNow, {
+    readonly i0: any;
+    readonly trace: string | undefined;
+}> {
+}
+export interface UpdateRuntimeFlags extends IOOp<IOTag.UpdateRuntimeFlags, {
+    readonly i0: RuntimeFlags.Patch;
+    readonly trace: string | undefined;
+}> {
+}
+export interface UpdateRuntimeFlagsWithin extends IOOp<IOTag.UpdateRuntimeFlagsWithin, {
+    readonly i0: RuntimeFlagsPatch;
+    readonly i1: (oldRuntimeFlags: RuntimeFlags) => Primitive;
+    readonly trace: string | undefined;
+}> {
+}
+export interface GenerateStackTrace extends IOOp<IOTag.GenerateStackTrace, {
+    readonly trace: string | undefined;
+}> {
+}
+export interface Stateful extends IOOp<IOTag.Stateful, {
+    readonly i0: (fiber: FiberRuntime<any, any>, status: Running) => Primitive;
+    readonly trace: string | undefined;
+}> {
+}
+export interface WhileLoop extends IOOp<IOTag.WhileLoop, {
+    readonly i0: () => boolean;
+    readonly i1: () => Primitive;
+    readonly i2: (a: any) => any;
+    readonly trace: string | undefined;
+}> {
+}
+export interface YieldNow extends IOOp<IOTag.YieldNow, {
+    readonly trace: string | undefined;
+}> {
+}
+export interface Fail extends IOOp<IOTag.Fail, {
+    readonly i0: () => Cause<unknown>;
+    readonly trace: string | undefined;
+}> {
+}
+export type Primitive = OnSuccessAndFailure | OnFailure | OnSuccess | UpdateRuntimeFlagsWithin | Sync | Async | SucceedNow | UpdateRuntimeFlags | GenerateStackTrace | Stateful | WhileLoop | YieldNow | Fail | STM<any, any, any> | Left<any> | Right<any> | Nothing | Just<any> | Failure<any> | Success<any>;
 /**
  * @tsplus static fncts.io.IOOps concrete
  * @tsplus macro identity
  * @tsplus location "@fncts/io/IO/definition"
  */
-export declare function concrete(io: IO<any, any, any>): Concrete;
-export type EvaluationStep = OnSuccessAndFailure<any, any, any, any, any, any, any, any, any> | OnFailure<any, any, any, any, any, any> | OnSuccess<any, any, any, any, any, any>;
-export type UpdateRuntimeFlagsWithin = Interruptible<any, any, any> | Uninterruptible<any, any, any> | Dynamic<any, any, any>;
+export declare function concrete(io: IO<any, any, any>): Primitive;
+export type EvaluationStep = OnSuccessAndFailure | OnFailure | OnSuccess;
 export type Canceler<R> = URIO<R, void>;

package/IO.d.ts

@@ -7,6 +7,7 @@ export * from "./IO/api/acquireReleaseInterruptible.js";
 export * from "./IO/api/acquireReleaseInterruptibleExit.js";
 export * from "./IO/api/addFinalizer.js";
 export * from "./IO/api/addFinalizerExit.js";
+export * from "./IO/api/all.js";
 export * from "./IO/api/asyncInterrupt.js";
 export * from "./IO/api/asyncIO.js";
 export * from "./IO/api/blocking.js";

package/Push/api.d.ts

@@ -1,16 +1,17 @@
 import { Lazy } from "@fncts/base/data/function/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
+import { Either } from "@fncts/base/data/Either/definition";
+import { IO } from "@fncts/io/IO/definition";
 import { Duration } from "@fncts/base/data/Duration/definition";
 import { Fiber } from "@fncts/io/Fiber/definition";
-import { IO } from "@fncts/io/IO/definition";
 import { Environment } from "@fncts/base/data/Environment/definition";
 import { Future } from "@fncts/io/Future";
 import { Scope } from "@fncts/io/Scope/definition";
 import { Schedule } from "@fncts/io/Schedule/definition";
-import { Cause } from "@fncts/base/data/Cause/definition";
 import { Nothing, Just, Maybe } from "@fncts/base/data/Maybe/definition";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
-import type { _A, _E, _R } from "@fncts/base/types";
+import type { _E, _R } from "@fncts/base/types";
 import { AtomicReference } from "@fncts/base/internal/AtomicReference";
 import { Emitter, Push, PushTypeId, PushVariance } from "./definition.js";
 /**
@@ -18,6 +19,21 @@ import { Emitter, Push, PushTypeId, PushVariance } from "./definition.js";
  * @tsplus location "@fncts/io/Push/api"
  */
 export declare function as<B>(b: Lazy<B>): <R, E, A>(self: Push<R, E, A>) => Push<R, E, B>;
+interface UnsafeEmitter<E, A> {
+    emit: (value: A) => void;
+    failCause: (cause: Cause<E>) => void;
+    end: () => void;
+}
+/**
+ * @tsplus static fncts.io.PushOps asyncInterrupt
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function asyncInterrupt<R, E, A>(make: (emitter: UnsafeEmitter<E, A>) => Either<IO<R, never, void>, Push<R, E, A>>): Push<R, E, A>;
+/**
+ * @tsplus static fncts.io.PushOps async
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function async<E, A>(make: (emitter: UnsafeEmitter<E, A>) => void): Push<never, E, A>;
 /**
  * @tsplus static fncts.io.PushOps combineLatest
  * @tsplus location "@fncts/io/Push/api"
@@ -160,8 +176,13 @@ export declare function merge<R1, E1, B>(that: Push<R1, E1, B>): <R, E, A>(self:
  * @tsplus static fncts.io.PushOps mergeAll
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function mergeAll<A extends ReadonlyArray<Push<any, any, any>>>(streams: [...A]): Push<_R<A[number]>, _E<A[number]>, _A<A[number]>>;
+export declare function mergeAll<A extends ReadonlyArray<Push<any, any, any>>>(streams: [...A]): Push<Push.EnvironmentOf<A[number]>, Push.ErrorOf<A[number]>, Push.ValueOf<A[number]>>;
 export declare function mergeAll<R, E, A>(streams: Iterable<Push<R, E, A>>): Push<R, E, A>;
+/**
+ * @tsplus pipeable fncts.io.Push observe
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function observe<A, R1, E1>(f: (a: A) => IO<R1, E1, void>, __tsplusTrace?: string): <R, E>(self: Push<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R1 | R, E1 | E, void>;
 /**
  * @tsplus static fncts.io.PushOps repeatIOMaybe
  * @tsplus location "@fncts/io/Push/api"

package/Push/definition.d.ts

@@ -19,6 +19,23 @@ export declare class Push<R, E, A> {
     };
     constructor(run: <R1>(emitter: Emitter<R1, E, A>) => IO<R | R1 | Scope, never, unknown>);
 }
+export declare namespace Push {
+    type EnvironmentOf<X> = [X] extends [{
+        [PushVariance]: {
+            readonly _R: (_: never) => infer R;
+        };
+    }] ? R : never;
+    type ErrorOf<X> = [X] extends [{
+        [PushVariance]: {
+            readonly _E: (_: never) => infer E;
+        };
+    }] ? E : never;
+    type ValueOf<X> = [X] extends [{
+        [PushVariance]: {
+            readonly _A: (_: never) => infer A;
+        };
+    }] ? A : never;
+}
 /**
  * @tsplus type fncts.io.Push.Emitter
  * @tsplus companion fncts.io.Push.EmitterOps

package/STM/definition.d.ts

@@ -2,7 +2,7 @@ import { FiberId } from "@fncts/base/data/FiberId/definition";
 import { Environment } from "@fncts/base/data/Environment/definition";
 import type { Journal } from "./internal/Journal.js";
 import type { _A, _E, _R } from "@fncts/base/types";
-import { IOOpCode, IOTypeId, IOVariance } from "@fncts/io/IO/definition";
+import { IOTag, IOTypeId, IOVariance } from "@fncts/io/IO/definition";
 export declare const enum STMTag {
     Effect = "Effect",
     OnFailure = "OnFailure",
@@ -22,7 +22,7 @@ export type STMTypeId = typeof STMTypeId;
  */
 export declare abstract class STM<R, E, A> {
     readonly [IOTypeId]: IOTypeId;
-    readonly _tag = IOOpCode.Commit;
+    readonly _tag = IOTag.Commit;
     readonly trace?: string;
     readonly [STMTypeId]: STMTypeId;
     [IOVariance]: {