@fncts/io 0.0.31 → 0.0.33

package/Channel/api/runScoped.d.ts

@@ -1,6 +1,7 @@
 import { IO } from "@fncts/io/IO/definition";
 import { Channel } from "@fncts/io/Channel";
 import { Scope } from "@fncts/io/Scope/definition";
+import { Future } from "@fncts/io/Future";
 /**
  * Runs a channel until the end is received
  * @tsplus getter fncts.io.Channel runScoped

package/Channel/api.d.ts

@@ -356,6 +356,7 @@ export declare function orHaltWith<OutErr, E>(f: (e: OutErr) => E): <Env, InErr,
 export declare function pipeTo<OutErr, OutElem, OutDone, Env1, OutErr1, OutElem1, OutDone1>(right: Channel<Env1, OutErr, OutElem, OutDone, OutErr1, OutElem1, OutDone1>): <Env, InErr, InElem, InDone>(left: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>) => Channel<Env1 | Env, InErr, InElem, InDone, OutErr1, OutElem1, OutDone1>;
 /**
  * @tsplus pipeable fncts.io.Channel pipeToOrFail
+ * @tsplus pipeable-operator fncts.io.Channel >>>
  * @tsplus location "@fncts/io/Channel/api"
  */
 export declare function pipeToOrFail<OutElem, OutDone, Env1, OutErr1, OutElem1, OutDone1>(right: Channel<Env1, never, OutElem, OutDone, OutErr1, OutElem1, OutDone1>): <Env, InErr, InElem, InDone, OutErr>(left: Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>) => Channel<Env1 | Env, InErr, InElem, InDone, OutErr1 | OutErr, OutElem1, OutDone1>;

package/Channel/internal/ChannelExecutor.d.ts

@@ -1,15 +1,15 @@
 import { Channel } from "@fncts/io/Channel";
 import { Exit } from "@fncts/base/data/Exit/definition";
 import { URIO, IO } from "@fncts/io/IO/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
 import { List, Nil } from "@fncts/base/collection/immutable/List/definition";
 import { Environment } from "@fncts/base/data/Environment/definition";
-import { Cause } from "@fncts/base/data/Cause/definition";
 import { ListBuffer } from "@fncts/base/collection/mutable/ListBuffer";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import type { ChannelState } from "@fncts/io/Channel/internal/ChannelState";
 import * as State from "@fncts/io/Channel/internal/ChannelState";
 export type ErasedExecutor<R> = ChannelExecutor<R, unknown, unknown, unknown, unknown, unknown, unknown>;
-export declare function readUpstream<R, E, A>(r: State.Read<R, E>, cont: () => IO<R, E, A>): IO<R, E, A>;
+export declare function readUpstream<R, E, A, E1>(r: State.Read<R, E>, cont: () => IO<R, E1, A>, onFailure: (cause: Cause<E>) => IO<R, E1, A>): IO<R, E1, A>;
 export declare class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> {
     private providedEnv;
     private executeCloseLastSubstream;

package/Fiber/FiberMessage.d.ts

@@ -26,7 +26,7 @@ export declare class InterruptSignal {
  * @tsplus static fncts.io.FiberMessageOps InterruptSignal
  * @tsplus location "@fncts/io/Fiber/FiberMessage"
  */
-export declare function mkInterruptSignal(cause: Cause<never>): FiberMessage;
+export declare function interruptSignal(cause: Cause<never>): FiberMessage;
 export declare class GenStackTrace {
     readonly onTrace: (trace: Trace) => void;
     readonly _tag = FiberMessageTag.GenStackTrace;
@@ -36,7 +36,7 @@ export declare class GenStackTrace {
  * @tsplus static fncts.io.FiberMessageOps GenStackTrace
  * @tsplus location "@fncts/io/Fiber/FiberMessage"
  */
-export declare function mkGenStackTrace(onTrace: (trace: Trace) => void): FiberMessage;
+export declare function genStackTrace(onTrace: (trace: Trace) => void): FiberMessage;
 export declare class Stateful {
     readonly onFiber: (fiber: FiberRuntime<any, any>, status: FiberStatus) => void;
     readonly _tag = FiberMessageTag.Stateful;
@@ -46,7 +46,7 @@ export declare class Stateful {
  * @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 function stateful(onFiber: (fiber: FiberRuntime<any, any>, status: FiberStatus) => void): FiberMessage;
 export declare class Resume {
     readonly cont: IO<any, any, any>;
     readonly _tag = FiberMessageTag.Resume;
@@ -56,7 +56,7 @@ export declare class Resume {
  * @tsplus static fncts.io.FiberMessageOps Resume
  * @tsplus location "@fncts/io/Fiber/FiberMessage"
  */
-export declare function mkResume(cont: IO<any, any, any>): FiberMessage;
+export declare function resume(cont: IO<any, any, any>): FiberMessage;
 export interface YieldNow {
     readonly _tag: FiberMessageTag.YieldNow;
 }
@@ -64,4 +64,4 @@ export interface YieldNow {
  * @tsplus static fncts.io.FiberMessageOps YieldNow
  * @tsplus location "@fncts/io/Fiber/FiberMessage"
  */
-export declare const YieldNow: FiberMessage;
+export declare const yieldNow: FiberMessage;

package/Fiber/FiberRuntime.d.ts

@@ -11,7 +11,7 @@ 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 { IllegalStateError, NoSuchElementError, 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";
@@ -27,12 +27,12 @@ import { FiberMessage } from "./FiberMessage.js";
 export declare class RevertFlags {
     readonly patch: RuntimeFlags.Patch;
     readonly trace?: string | undefined;
-    readonly ioOpCode = IOOpCode.RevertFlags;
+    readonly _tag = IOOpCode.RevertFlags;
     constructor(patch: RuntimeFlags.Patch, trace?: string | undefined);
 }
 export declare class UpdateTrace {
     readonly trace?: string | undefined;
-    readonly ioOpCode = IOOpCode.UpdateTrace;
+    readonly _tag = 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;

package/IO/api/provideSomeLayer.d.ts

@@ -1,9 +1,8 @@
 import { Layer } from "@fncts/io/Layer";
 import { IO } from "@fncts/io/IO/definition";
-import type { Erase } from "@fncts/typelevel/Intersection";
 /**
  * @tsplus static fncts.io.IOAspects provideSomeLayer
  * @tsplus pipeable fncts.io.IO provideSomeLayer
  * @tsplus location "@fncts/io/IO/api/provideSomeLayer"
  */
-export declare function provideSomeLayer<RIn, E1, ROut>(layer: Layer<RIn, E1, ROut>, __tsplusTrace?: string): <R, E, A>(self: import("../definition").IO<R, E, A>) => import("../definition").IO<RIn & Erase<R, ROut>, E1 | E, A>;
+export declare function provideSomeLayer<RIn, E1, ROut>(layer: Layer<RIn, E1, ROut>, __tsplusTrace?: string): <R, E, A>(self: import("../definition").IO<R, E, A>) => import("../definition").IO<RIn | Exclude<R, ROut>, E1 | E, A>;

package/IO/api/zipConcurrent.d.ts

@@ -1,4 +1,5 @@
 import { IO } from "@fncts/io/IO/definition";
+import { Zipped } from "@fncts/base/data/Zipped";
 import { Lazy } from "@fncts/base/data/function/definition";
 import { Future } from "@fncts/io/Future";
 import { Fiber } from "@fncts/io/Fiber/definition";
@@ -6,7 +7,7 @@ import { Fiber } from "@fncts/io/Fiber/definition";
  * @tsplus pipeable fncts.io.IO zipConcurrent
  * @tsplus location "@fncts/io/IO/api/zipConcurrent"
  */
-export declare function zipConcurrent<R1, E1, B>(that: IO<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: import("../definition.js").IO<R, E, A>) => import("../definition.js").IO<R1 | R, E1 | E, readonly [A, B]>;
+export declare function zipConcurrent<R1, E1, B>(that: IO<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: import("../definition.js").IO<R, E, A>) => import("../definition.js").IO<R1 | R, E1 | E, import("@fncts/base/data/Zipped.js").Zipped.Make<A, B>>;
 /**
  * @tsplus pipeable fncts.io.IO zipWithConcurrent
  * @tsplus location "@fncts/io/IO/api/zipConcurrent"

package/IO/api.d.ts

@@ -11,6 +11,7 @@ import { Predicate } from "@fncts/base/data/Predicate/definition";
 import { NonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
 import { Eval } from "@fncts/base/control/Eval/definition";
 import { Exit } from "@fncts/base/data/Exit/definition";
+import { NoSuchElementError } from "@fncts/base/data/exceptions";
 import { Trace } from "@fncts/base/data/Trace/definition";
 import { List } from "@fncts/base/collection/immutable/List/definition";
 import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
@@ -427,7 +428,7 @@ export declare function fromMaybe<A>(maybe: Lazy<Maybe<A>>, __tsplusTrace?: stri
  * @tsplus getter fncts.Maybe toIO
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function fromMaybeNow<A = never>(maybe: Maybe<A>, __tsplusTrace?: string): IO<unknown, Maybe<never>, A>;
+export declare function fromMaybeNow<A = never>(maybe: Maybe<A>, __tsplusTrace?: string): IO<never, NoSuchElementError, A>;
 /**
  * Create an IO that when executed will construct `promise` and wait for its result,
  * errors will be handled using `onReject`

package/IO/definition.d.ts

@@ -1,11 +1,15 @@
 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 { 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;
@@ -32,6 +36,20 @@ export declare abstract class IO<R, E, A> {
         _A: () => A;
     };
 }
+declare module "@fncts/base/data/Either/definition" {
+    interface Either<E, A> extends IO<never, E, A> {
+    }
+}
+declare module "@fncts/base/data/Maybe/definition" {
+    interface Maybe<A> extends IO<never, NoSuchElementError, A> {
+    }
+}
+declare module "@fncts/base/data/Exit/definition" {
+    interface Success<A> extends IO<never, never, A> {
+    }
+    interface Failure<E> extends IO<never, E, never> {
+    }
+}
 /**
  * @tsplus type fncts.io.IOAspects
  */
@@ -89,14 +107,14 @@ 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 ioOpCode = IOOpCode.Sync;
+    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 ioOpCode = IOOpCode.Async;
+    readonly _tag = IOOpCode.Async;
     constructor(registerCallback: (f: (_: IO<R, E, A>) => void) => any, blockingOn: () => FiberId, trace?: string | undefined);
 }
 /**
@@ -107,7 +125,7 @@ export declare class OnSuccessAndFailure<R, E, A, R1, E1, B, R2, E2, C> extends
     readonly failureK: (cause: Cause<E>) => IO<R1, E1, B>;
     readonly successK: (a: A) => IO<R2, E2, C>;
     readonly trace?: string | undefined;
-    readonly ioOpCode = IOOpCode.OnSuccessAndFailure;
+    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>;
@@ -116,7 +134,7 @@ 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 ioOpCode = IOOpCode.OnFailure;
+    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>;
@@ -128,7 +146,7 @@ export declare class OnSuccess<R, R1, E, E1, A, A1> extends IO<R | R1, E | E1, A
     readonly first: IO<R, E, A>;
     readonly successK: (a: A) => IO<R1, E1, A1>;
     readonly trace?: string | undefined;
-    readonly ioOpCode = IOOpCode.OnSuccess;
+    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>;
@@ -139,19 +157,19 @@ export declare class OnSuccess<R, R1, E, E1, A, A1> extends IO<R | R1, E | E1, A
 export declare class SucceedNow<A> extends IO<never, never, A> {
     readonly value: A;
     readonly trace?: string | undefined;
-    readonly ioOpCode = IOOpCode.SucceedNow;
+    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 ioOpCode = IOOpCode.UpdateRuntimeFlags;
+    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 ioOpCode = IOOpCode.UpdateRuntimeFlagsWithin;
+    readonly _tag = IOOpCode.UpdateRuntimeFlagsWithin;
     constructor(effect: IO<R, E, A>, trace?: string | undefined);
     readonly update: RuntimeFlags.Patch;
     scope(oldRuntimeFlags: RuntimeFlags): IO<R, E, A>;
@@ -159,7 +177,7 @@ export declare class Interruptible<R, E, A> extends 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 ioOpCode = IOOpCode.UpdateRuntimeFlagsWithin;
+    readonly _tag = IOOpCode.UpdateRuntimeFlagsWithin;
     constructor(effect: IO<R, E, A>, trace?: string | undefined);
     readonly update: RuntimeFlags.Patch;
     scope(oldRuntimeFlags: RuntimeFlags): IO<R, E, A>;
@@ -168,19 +186,19 @@ 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 ioOpCode = IOOpCode.UpdateRuntimeFlagsWithin;
+    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 ioOpCode = IOOpCode.GenerateStackTrace;
+    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 ioOpCode = IOOpCode.Stateful;
+    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> {
@@ -188,12 +206,12 @@ export declare class WhileLoop<R, E, A> extends IO<R, E, void> {
     readonly body: () => IO<R, E, A>;
     readonly process: (a: A) => any;
     readonly trace?: string | undefined;
-    readonly ioOpCode = IOOpCode.WhileLoop;
+    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 ioOpCode = IOOpCode.YieldNow;
+    readonly _tag = IOOpCode.YieldNow;
     constructor(trace?: string | undefined);
 }
 /**
@@ -202,10 +220,10 @@ export declare class YieldNow extends IO<never, never, void> {
 export declare class Fail<E> extends IO<never, E, never> {
     readonly cause: Lazy<Cause<E>>;
     readonly trace?: string | undefined;
-    readonly ioOpCode = IOOpCode.Fail;
+    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>;
+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>;
 /**
  * @tsplus static fncts.io.IOOps concrete
  * @tsplus macro identity
@@ -215,11 +233,3 @@ 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 type Canceler<R> = URIO<R, void>;
-export declare const IOErrorTypeId: unique symbol;
-export type IOErrorTypeId = typeof IOErrorTypeId;
-export declare class IOError<E> {
-    readonly cause: Cause<E>;
-    readonly [IOErrorTypeId]: IOErrorTypeId;
-    constructor(cause: Cause<E>);
-}
-export declare function isIOError(u: unknown): u is IOError<unknown>;

package/IO/runtime.d.ts

@@ -6,6 +6,8 @@ import { Supervisor } from "@fncts/io/Supervisor/definition";
 import { Nothing } from "@fncts/base/data/Maybe/definition";
 import { FiberScope } from "@fncts/io/FiberScope";
 import { Exit } from "@fncts/base/data/Exit/definition";
+import { Either } from "@fncts/base/data/Either/definition";
+import { Fiber } from "@fncts/io/Fiber/definition";
 import { FiberRuntime } from "@fncts/io/Fiber";
 import { FiberRefs } from "@fncts/io/FiberRefs";
 import { RuntimeFlags } from "@fncts/io/RuntimeFlags";
@@ -14,12 +16,12 @@ export declare class Runtime<R> {
     readonly runtimeFlags: RuntimeFlags;
     readonly fiberRefs: FiberRefs;
     constructor(environment: Environment<R>, runtimeFlags: RuntimeFlags, fiberRefs: FiberRefs);
+    makeFiber: <E, A>(io: import("./definition.js").IO<R, E, A>, __tsplusTrace?: string) => FiberRuntime<E, A>;
     unsafeRunFiber: <E, A>(io: import("./definition.js").IO<R, E, A>, __tsplusTrace?: string) => FiberRuntime<E, A>;
-    unsafeRunWith: <E, A>(io: import("./definition.js").IO<R, E, A>, k: (exit: import("@fncts/base/data/Exit.js").Exit<E, A>) => any, __tsplusTrace?: string) => (fiberId: FiberId) => (f: (exit: import("@fncts/base/data/Exit.js").Exit<E, A>) => any) => void;
-    unsafeRunAsync: <E, A>(io: import("./definition.js").IO<R, E, A>, __tsplusTrace?: string) => void;
-    unsafeRunAsyncWith: <E, A>(io: import("./definition.js").IO<R, E, A>, k: (exit: import("@fncts/base/data/Exit.js").Exit<E, A>) => any, __tsplusTrace?: string) => void;
     unsafeRunPromiseExit: <E, A>(io: import("./definition.js").IO<R, E, A>, __tsplusTrace?: string) => Promise<import("@fncts/base/data/Exit.js").Exit<E, A>>;
-    unsafeRunSyncExit: <E, A>(io: import("./definition.js").IO<R, E, A>, __tsplusTrace?: string) => import("@fncts/base/data/Exit.js").Exit<E, A>;
+    unsafeRunPromise: <E, A>(io: import("./definition.js").IO<R, E, A>, __tsplusTrace?: string) => Promise<A>;
+    unsafeRunOrFork: <E, A>(io: import("./definition.js").IO<R, E, A>, __tsplusTrace?: string) => import("@fncts/base/data/Either.js").Either<import("@fncts/io/Fiber").Fiber.Runtime<E, A>, import("@fncts/base/data/Exit.js").Exit<E, A>>;
+    unsafeRun: <E, A>(io: import("./definition.js").IO<R, E, A>, __tsplusTrace?: string) => import("@fncts/base/data/Exit.js").Exit<E, A>;
 }
 /**
  * @tsplus static fncts.io.IOOps runtime
@@ -32,28 +34,18 @@ export declare const defaultRuntime: Runtime<never>;
  * @tsplus location "@fncts/io/IO/runtime"
  */
 export declare const unsafeRunFiber: <E, A>(io: import("./definition.js").IO<never, E, A>, __tsplusTrace?: string) => FiberRuntime<E, A>;
-/**
- * @tsplus fluent fncts.io.IO unsafeRunAsync
- * @tsplus location "@fncts/io/IO/runtime"
- */
-export declare const unsafeRunAsync: <E, A>(io: import("./definition.js").IO<never, E, A>, __tsplusTrace?: string) => void;
-/**
- * @tsplus fluent fncts.io.IO unsafeRunAsyncWith
- * @tsplus location "@fncts/io/IO/runtime"
- */
-export declare const unsafeRunAsyncWith: <E, A>(io: import("./definition.js").IO<never, E, A>, k: (exit: import("@fncts/base/data/Exit.js").Exit<E, A>) => any, __tsplusTrace?: string) => void;
 /**
  * @tsplus fluent fncts.io.IO unsafeRunPromiseExit
  * @tsplus location "@fncts/io/IO/runtime"
  */
 export declare const unsafeRunPromiseExit: <E, A>(io: import("./definition.js").IO<never, E, A>, __tsplusTrace?: string) => Promise<import("@fncts/base/data/Exit.js").Exit<E, A>>;
 /**
- * @tsplus fluent fncts.io.IO unsafeRunWith
+ * @tsplus getter fncts.io.IO unsafeRunOrFork
  * @tsplus location "@fncts/io/IO/runtime"
  */
-export declare const unsafeRunWith: <E, A>(io: import("./definition.js").IO<never, E, A>, k: (exit: import("@fncts/base/data/Exit.js").Exit<E, A>) => any, __tsplusTrace?: string) => (fiberId: FiberId) => (f: (exit: import("@fncts/base/data/Exit.js").Exit<E, A>) => any) => void;
+export declare const unsafeRunOrFork: <E, A>(io: import("./definition.js").IO<never, E, A>, __tsplusTrace?: string) => import("@fncts/base/data/Either.js").Either<import("@fncts/io/Fiber").Fiber.Runtime<E, A>, import("@fncts/base/data/Exit.js").Exit<E, A>>;
 /**
- * @tsplus getter fncts.io.IO unsafeRunSyncExit
+ * @tsplus getter fncts.io.IO unsafeRun
  * @tsplus location "@fncts/io/IO/runtime"
  */
-export declare const unsafeRunSyncExit: <E, A>(io: import("./definition.js").IO<never, E, A>, __tsplusTrace?: string) => import("@fncts/base/data/Exit.js").Exit<E, A>;
+export declare const unsafeRun: <E, A>(io: import("./definition.js").IO<never, E, A>, __tsplusTrace?: string) => import("@fncts/base/data/Exit.js").Exit<E, A>;

package/STM/definition.d.ts

@@ -22,7 +22,7 @@ export type STMTypeId = typeof STMTypeId;
  */
 export declare abstract class STM<R, E, A> {
     readonly [IOTypeId]: IOTypeId;
-    readonly ioOpCode = IOOpCode.Commit;
+    readonly _tag = IOOpCode.Commit;
     readonly trace?: string;
     readonly [STMTypeId]: STMTypeId;
     [IOVariance]: {

package/Stream/api.d.ts

@@ -21,7 +21,6 @@ import { Layer } from "@fncts/io/Layer";
 import type { PHub } from "../Hub.js";
 import type { Canceler } from "../IO.js";
 import type { PDequeue, PEnqueue, PQueue } from "../Queue.js";
-import { MergeDecision } from "../Channel/internal/MergeDecision.js";
 import { Hub } from "../Hub.js";
 import { Queue } from "../Queue.js";
 import { Stream } from "./definition.js";
@@ -310,6 +309,11 @@ export declare function contramapEnvironment<R, R0>(f: (r0: Environment<R0>) =>
  * @tsplus location "@fncts/io/Stream/api"
  */
 export declare function debounce(duration: Lazy<Duration>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R, E, A>;
+/**
+ * @tsplus static fncts.io.StreamOps defer
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function defer<R, E, A>(self: Lazy<Stream<R, E, A>>): Stream<R, E, A>;
 /**
  * Switches to the provided stream in case this one is empty.
  * @tsplus pipeable fncts.io.Stream defaultIfEmpty
@@ -341,7 +345,7 @@ export declare function distributedWithDynamic<E, A>(maximumLag: number, decide:
  * @tsplus getter fncts.io.Stream drain
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function drain<R, E, A>(fa: Stream<R, E, A>, __tsplusTrace?: string): Stream<R, E, void>;
+export declare function drain<R, E, A>(fa: Stream<R, E, A>, __tsplusTrace?: string): Stream<R, E, never>;
 /**
  * Drops the specified number of elements from this stream.
  * @tsplus pipeable fncts.io.Stream drop
@@ -416,6 +420,12 @@ export declare function environmentWithIO<R0, R, E, A>(f: (r0: Environment<R0>)
  * @tsplus location "@fncts/io/Stream/api"
  */
 export declare function environmentWithStream<R0, R, E, A>(f: (r0: Environment<R0>) => Stream<R, E, A>, __tsplusTrace?: string): Stream<R0 | R, E, A>;
+/**
+ * Creates a stream that executes the specified effect but emits no elements.
+ * @tsplus static fncts.io.StreamOps execute
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function execute<R, E>(io: IO<R, E, any>, __tsplusTrace?: string): Stream<R, E, never>;
 /**
  * Halt a stream with the specified error
  * @tsplus static fncts.io.StreamOps failNow
@@ -525,6 +535,12 @@ export declare function fromChunk<O>(c: Lazy<Conc<O>>, __tsplusTrace?: string):
  * @tsplus location "@fncts/io/Stream/api"
  */
 export declare function scoped<R, E, A>(stream: Lazy<IO<R, E, A>>, __tsplusTrace?: string): Stream<Exclude<R, Scope>, E, A>;
+/**
+ * Emits a sliding window of n elements.
+ * @tsplus pipeable fncts.io.Stream sliding
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function sliding(chunkSize: number, stepSize: number, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<R, E, import("@fncts/base/collection/immutable/Conc.js").Conc<A>>;
 /**
  * Creates a stream from an effect producing a value of type `A`
  * @tsplus static fncts.io.StreamOps fromIO
@@ -729,10 +745,59 @@ export declare function mapIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>, __tsplus
  * executing up to `n` invocations of `f` concurrently. Transformed elements
  * will be emitted in the original order.
  * @note This combinator destroys the chunking structure. It's recommended to use chunkN afterwards.
- * @tsplus pipeable fncts.io.Stream mapIOC
+ * @tsplus pipeable fncts.io.Stream mapIOConcurrently
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function mapIOConcurrently<A, R1, E1, B>(n: number, f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
+/**
+ * @tsplus pipeable fncts.io.Stream mapIOConcurrentlyUnordered
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function mapIOConcurrentlyUnordered<A, R1, E1, B>(n: number, f: (a: A) => IO<R1, E1, B>): <R, E>(self: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
+/**
+ * Merges this stream and the specified stream together.
+ *
+ * New produced stream will terminate when both specified stream terminate if
+ * no termination strategy is specified.
+ * @tsplus pipeable fncts.io.Stream merge
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function merge<R1, E1, B>(that: Stream<R1, E1, B>, strategy?: TerminationStrategy, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B | A>;
+/**
+ * Merges this stream and the specified stream together. New produced stream
+ * will terminate when either stream terminates.
+ * @tsplus pipeable fncts.io.Stream mergeHaltEither
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function mergeHaltEither<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B | A>;
+/**
+ * Merges this stream and the specified stream together. New produced stream
+ * will terminate when this stream terminates.
+ * @tsplus pipeable fncts.io.Stream mergeHaltLeft
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function mergeHaltLeft<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B | A>;
+/**
+ * Merges this stream and the specified stream together. New produced stream
+ * will terminate when the specified stream terminates.
+ * @tsplus pipeable fncts.io.Stream mergeHaltRight
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function mergeHaltRight<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B | A>;
+/**
+ * Merges this stream and the specified stream together, discarding the values
+ * from the right stream.
+ * @tsplus pipeable fncts.io.Stream mergeLeft
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapIOC<A, R1, E1, B>(n: number, f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
+export declare function mergeLeft<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A>;
+/**
+ * Merges this stream and the specified stream together, discarding the values
+ * from the left stream.
+ * @tsplus pipeable fncts.io.Stream mergeRight
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function mergeRight<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
 /**
  * Maps each element of this stream to another stream and returns the
  * non-deterministic merge of those streams, executing up to `n` inner streams
@@ -755,7 +820,6 @@ export declare function mergeMapIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>, n:
  * @tsplus location "@fncts/io/Stream/api"
  */
 export declare function mergeEither<R1, E1, B>(fb: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(fa: Stream<R, E, A>) => Stream<R1 | R, E1 | E, import("@fncts/base/data/Either.js").Either<A, B>>;
-export declare function mergeWithHandler<R, E>(terminate: boolean, __tsplusTrace?: string): (exit: Exit<E, unknown>) => MergeDecision<R, E, unknown, E, unknown>;
 export type TerminationStrategy = "Left" | "Right" | "Both" | "Either";
 /**
  * @tsplus pipeable fncts.io.Stream mergeWith
@@ -811,6 +875,11 @@ export declare function orElseSucceed<A1>(a: Lazy<A1>, __tsplusTrace?: string):
  * @tsplus location "@fncts/io/Stream/api"
  */
 export declare function pipeThrough<A, R1, E1, L, Z>(sa: Sink<R1, E1, A, L, Z>, __tsplusTrace?: string): <R, E>(ma: Stream<R, E, A>) => Stream<R1 | R, E1 | E, L>;
+/**
+ * @tsplus pipeable fncts.io.Stream pipeThroughChannelOrFail
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function pipeThroughChannelOrFail<A, R1, E1, B>(channel: Channel<R1, never, Conc<A>, any, E1, Conc<B>, any>): <R, E>(self: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
 /**
  * Provides the stream with its required environment, which eliminates
  * its dependency on `R`.
@@ -903,6 +972,13 @@ export declare function runIntoElementsScoped_<E, A, R1, E1>(queue: PQueue<R1, u
  * @tsplus location "@fncts/io/Stream/api"
  */
 export declare function runIntoQueueScoped<RA, RB, EA, EB, E1, A, B>(queue: PEnqueue<RA, RB, EA, EB, Take<E1, A>, B>, __tsplusTrace?: string): <R, E extends E1>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | RA | R, EA | E1 | E, void>;
+/**
+ * Like runIntoQueue, but provides the result as a scoped IO
+ * to allow for scope composition.
+ * @tsplus pipeable fncts.io.Stream runIntoQueueElementsScoped
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function runIntoQueueElementsScoped<E, A>(queue: Lazy<Queue.Enqueue<Exit<Maybe<E>, A>>>): <R>(self: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, void>;
 /**
  * Like `Stream#runIntoHub`, but provides the result as a `Managed` to allow for scope
  * composition.
@@ -944,6 +1020,11 @@ export declare function scanReduce<A extends B, B>(f: (b: B, a: A) => B, __tsplu
  * @tsplus location "@fncts/io/Stream/api"
  */
 export declare function scanReduceIO<A extends B, R1, E1, B>(f: (b: B, a: A) => IO<R1, E1, B>, __tsplusTrace?: string): <R, E>(fa: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
+/**
+ * @tsplus pipeable fncts.io.Stream split
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function split<A>(predicate: Predicate<A>, __tsplusTrace?: string): <R, E>(self: Stream<R, E, A>) => Stream<R, E, import("@fncts/base/collection/immutable/Conc.js").Conc<A>>;
 /**
  * Creates a single-valued pure stream
  * @tsplus static fncts.io.StreamOps succeedNow
@@ -979,6 +1060,33 @@ export declare function takeUntil<A>(p: Predicate<A>, __tsplusTrace?: string): <
  * @tsplus location "@fncts/io/Stream/api"
  */
 export declare function tap<A, R1, E1>(f: (a: A) => IO<R1, E1, any>, __tsplusTrace?: string): <R, E>(ma: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A>;
+/**
+ * Returns a stream that effectfully "peeks" at the failure and adds an effect
+ * to consumption of every element of the stream
+ * @tsplus pipeable fncts.io.Stream tapBoth
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function tapBoth<E, A, R1, E1, R2, E2>(f: (e: E) => IO<R1, E1, any>, g: (a: A) => IO<R2, E2, any>, __tsplusTrace?: string): <R>(self: Stream<R, E, A>) => Stream<R1 | R2 | R, E | E1 | E2, A>;
+/**
+ * Returns a stream that effectfully "peeks" at the failure of the stream.
+ * @tsplus pipeable fncts.io.Stream tapError
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function tapError<E, R1, E1>(f: (e: E) => IO<R1, E1, any>, __tsplusTrace?: string): <R, A>(self: Stream<R, E, A>) => Stream<R1 | R, E | E1, A>;
+/**
+ * Returns a stream that effectfully "peeks" at the cause of failure of the
+ * stream.
+ * @tsplus pipeable fncts.io.Stream tapErrorCause
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function tapErrorCause<E, R1, E1>(f: (cause: Cause<E>) => IO<R1, E1, any>, __tsplusTrace?: string): <R, A>(self: Stream<R, E, A>) => Stream<R1 | R, E | E1, A>;
+/**
+ * Sends all elements emitted by this stream to the specified sink in addition
+ * to emitting them.
+ * @tsplus pipeable fncts.io.Stream tapSink
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function tapSink<A, R1, E1>(sink: Sink<R1, E1, A, any, any>, __tsplusTrace?: string): <R, E>(self: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A>;
 /**
  * Throttles the chunks of this stream according to the given bandwidth parameters using the token bucket
  * algorithm. Allows for burst in the processing of elements by allowing the token bucket to accumulate

package/_cjs/Channel/api/mapOutConcurrentIO.cjs

@@ -34,7 +34,7 @@ function mapOutConcurrentIO(n, f) {
     return tsplus_module_2.unwrapScoped(() => tsplus_module_5.map(queue => {
       const consumer = tsplus_module_2.unwrap(() => tsplus_module_5.matchCause(tsplus_module_1.failCauseNow, r => tsplus_module_3.match(tsplus_module_1.endNow, outElem => tsplus_module_1.zipRight(consumer)(tsplus_module_2.writeNow(outElem)))(r), fileName_1 + ":58:42")(tsplus_module_5.flatten(tsplus_module_4.take(queue, fileName_1 + ":58:18"), fileName_1 + ":58:23")));
       return consumer;
-    }, fileName_1 + ":55:12")(tsplus_module_19.withChildren(getChildren => tsplus_module_5.flatMap(() => tsplus_module_5.flatMap(queue => tsplus_module_5.flatMap(errorSignal => tsplus_module_5.flatMap(permits => tsplus_module_5.flatMap(pull => tsplus_module_5.map(() => queue, fileName_1 + ":24:12")(tsplus_module_12.fork(tsplus_module_7.uninterruptible(tsplus_module_5.forever(tsplus_module_5.matchCauseIO(cause => tsplus_module_4.offer(tsplus_module_5.failCauseNow(cause, fileName_1 + ":26:53"), fileName_1 + ":26:37")(queue), r => tsplus_module_3.match(outDone => tsplus_module_5.asUnit(tsplus_module_5.zipRight(tsplus_module_4.offer(tsplus_module_5.succeedNow(tsplus_module_6.left(outDone), fileName_1 + ":32:72"), fileName_1 + ":32:58")(queue), fileName_1 + ":32:46")(tsplus_module_7.interruptible(permits.withPermits(n)(tsplus_module_5.unit), fileName_1 + ":31:47")), fileName_1 + ":32:96"), outElem => tsplus_module_5.flatMap(p => tsplus_module_5.flatMap(latch => tsplus_module_5.flatMap(() => tsplus_module_5.flatMap(() => tsplus_module_5.map(() => void 0, fileName_1 + ":48:24")(tsplus_module_8.wait(latch, fileName_1 + ":48:30")), fileName_1 + ":38:24")(permits.withPermit(tsplus_module_5.zipRight(tsplus_module_10.fulfill(p, fileName_1 + ":44:39")(tsplus_module_5.tapErrorCause(c => tsplus_module_8.failCause(c, fileName_1 + ":43:64")(p), fileName_1 + ":43:45")(tsplus_module_9.raceFirst(f(outElem), fileName_1 + ":42:41")(tsplus_module_8.wait(errorSignal, fileName_1 + ":41:40")))), fileName_1 + ":40:60")(tsplus_module_8.succeed_(undefined, fileName_1 + ":40:40")(latch)))), fileName_1 + ":37:24")(tsplus_module_4.offer(tsplus_module_5.map(tsplus_module_6.right, fileName_1 + ":37:48")(tsplus_module_8.wait(p, fileName_1 + ":37:38")), fileName_1 + ":37:36")(queue)), fileName_1 + ":36:38")(tsplus_module_11.make(fileName_1 + ":36:50")), fileName_1 + ":35:38")(tsplus_module_11.make(fileName_1 + ":35:50")))(r), fileName_1 + ":25:30")(pull), fileName_1 + ":51:14"), fileName_1 + ":51:22"), fileName_1 + ":51:38")), fileName_1 + ":23:32")(tsplus_module_13.toPull(self)), fileName_1 + ":22:32")(tsplus_module_14.makeSemaphore(n, fileName_1 + ":22:42")), fileName_1 + ":21:32")(tsplus_module_11.make(fileName_1 + ":21:44")), fileName_1 + ":15:26")(tsplus_module_16.acquireRelease(() => tsplus_module_15.makeBounded(n, fileName_1 + ":17:32"), queue => tsplus_module_4.shutdown(queue, fileName_1 + ":18:31"), fileName_1 + ":16:30")), fileName_1 + ":14:12")(tsplus_module_18.addFinalizer(() => tsplus_module_5.flatMap(tsplus_module_17.interruptAll, fileName_1 + ":14:48")(getChildren), fileName_1 + ":14:28")), fileName_1 + ":12:22")));
+    }, fileName_1 + ":55:12")(tsplus_module_19.withChildren(getChildren => tsplus_module_5.flatMap(() => tsplus_module_5.flatMap(queue => tsplus_module_5.flatMap(errorSignal => tsplus_module_5.flatMap(permits => tsplus_module_5.flatMap(pull => tsplus_module_5.map(() => queue, fileName_1 + ":24:12")(tsplus_module_12.fork(tsplus_module_7.uninterruptible(tsplus_module_5.forever(tsplus_module_5.matchCauseIO(cause => tsplus_module_4.offer(tsplus_module_5.failCauseNow(cause, fileName_1 + ":26:53"), fileName_1 + ":26:37")(queue), r => tsplus_module_3.match(outDone => tsplus_module_5.asUnit(tsplus_module_5.zipRight(tsplus_module_4.offer(tsplus_module_5.succeedNow(tsplus_module_6.left(outDone, fileName_1 + ":32:84"), fileName_1 + ":32:72"), fileName_1 + ":32:58")(queue), fileName_1 + ":32:46")(tsplus_module_7.interruptible(permits.withPermits(n)(tsplus_module_5.unit), fileName_1 + ":31:47")), fileName_1 + ":32:96"), outElem => tsplus_module_5.flatMap(p => tsplus_module_5.flatMap(latch => tsplus_module_5.flatMap(() => tsplus_module_5.flatMap(() => tsplus_module_5.map(() => void 0, fileName_1 + ":48:24")(tsplus_module_8.wait(latch, fileName_1 + ":48:30")), fileName_1 + ":38:24")(permits.withPermit(tsplus_module_5.zipRight(tsplus_module_10.fulfill(p, fileName_1 + ":44:39")(tsplus_module_5.tapErrorCause(c => tsplus_module_8.failCause(c, fileName_1 + ":43:64")(p), fileName_1 + ":43:45")(tsplus_module_9.raceFirst(f(outElem), fileName_1 + ":42:41")(tsplus_module_8.wait(errorSignal, fileName_1 + ":41:40")))), fileName_1 + ":40:60")(tsplus_module_8.succeed_(undefined, fileName_1 + ":40:40")(latch)))), fileName_1 + ":37:24")(tsplus_module_4.offer(tsplus_module_5.map(tsplus_module_6.right, fileName_1 + ":37:48")(tsplus_module_8.wait(p, fileName_1 + ":37:38")), fileName_1 + ":37:36")(queue)), fileName_1 + ":36:38")(tsplus_module_11.make(fileName_1 + ":36:50")), fileName_1 + ":35:38")(tsplus_module_11.make(fileName_1 + ":35:50")))(r), fileName_1 + ":25:30")(pull), fileName_1 + ":51:14"), fileName_1 + ":51:22"), fileName_1 + ":51:38")), fileName_1 + ":23:32")(tsplus_module_13.toPull(self)), fileName_1 + ":22:32")(tsplus_module_14.makeSemaphore(n, fileName_1 + ":22:42")), fileName_1 + ":21:32")(tsplus_module_11.make(fileName_1 + ":21:44")), fileName_1 + ":15:26")(tsplus_module_16.acquireRelease(() => tsplus_module_15.makeBounded(n, fileName_1 + ":17:32"), queue => tsplus_module_4.shutdown(queue, fileName_1 + ":18:31"), fileName_1 + ":16:30")), fileName_1 + ":14:12")(tsplus_module_18.addFinalizer(() => tsplus_module_5.flatMap(tsplus_module_17.interruptAll, fileName_1 + ":14:48")(getChildren), fileName_1 + ":14:28")), fileName_1 + ":12:22")));
   };
 }
 //# sourceMappingURL=mapOutConcurrentIO.cjs.map

package/_cjs/Channel/api/mapOutConcurrentIO.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"mapOutConcurrentIO.cjs","mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;AAGM,SAAUA,kBAAkB,CAChCC,CAAS,EACTC,CAA8C;EAE9C,OACEC,IAAmE,IACgB;IACnF,OAAOC,mCACLC,oBA2COC,KAAK,IAAI;MACd,MAAMC,QAAQ,GACZH,6BACEC,yDAAqDG,CAAC,IACpDC,8CAAyBC,OAAO,IAAKC,yBAAmCJ,QAAQ,EAA3CH,yBAAiBM,OAAO,CAAC,CAAmB,EAAjFF,CAAC,CAAiF,sEADpFF,KAAK,iDAEJ,CACF;MACH,OAAOC,QAAQ;IACjB,CAAC,yBAnDDK,8BAAiBC,WAAW,IAAIR,sDAGtBC,KAAK,4BAMLQ,WAAW,4BACXC,OAAO,4BACPC,IAAI,8BA8BHV,KAAK,uGA5BVD,6BACGY,KAAK,IAAKC,sBAAYb,6BAAgBY,KAAK,wBAAC,yBAAlCX,KAAK,CAA8B,EAC7CE,CAAC,IACAC,sBACGU,OAAO,IAAId,uBACVA,yBAE0Ba,sBAAYb,2BAAce,qBAAYD,OAAO,CAAC,wBAAC,yBAA/Cb,KAAK,CAA2C,uDAF1ES,OAAO,CACJM,WAAW,CAACpB,CAAC,CAAC,sBAAS,yBACiD,wBAAO,EACnFS,OAAO,IAAIL,wBAEFiB,CAAC,4BACDC,KAAK,8IAYTA,KAAK,kDATLR,OAAO,CAACS,UAAU,CAChBnB,yBACEoB,yBAGWH,CAAC,yBAHZjB,8BAEkBqB,CAAC,IAAKC,0BAAYD,CAAC,yBAAbJ,CAAC,CAAa,yBAFtCM,0BACa1B,CAAC,CAACQ,OAAO,CAAC,8CADvBI,WAAW,yBACa,CACe,CAC1B,yBAJfa,yBAAcE,SAAS,yBAAvBN,KAAK,CAAmB,CAKvB,CACF,0BATDL,sBAAYb,wFAAC,yBAAwB,yBAArCC,KAAK,CAAiC,0BADxBwB,4CAA0B,0BAD1BA,4CAAgC,CAchD,EArBNtB,CAAC,CAsBA,yBAzBLQ,IAAI,CA0BH,0HA5BmBb,IAAI,2BADJ4B,+BAAU9B,CAAC,wBAAC,0BADZ6B,4CAA6B,0BALjDE,sCACEC,6BAAyEhC,CAAC,wBAAC,EAC1EK,KAAK,IAAIY,yBAACZ,KAAK,wBAAS,wBAC1B,0BALD4B,oCAAgB7B,yFAAW,CAA4B,wBAAC,CAwC1D,wBACH,CAQC,CACH;EACH,CAAC;AACH","names":["mapOutConcurrentIO","n","f","self","tsplus_module_2","tsplus_module_5","queue","consumer","r","tsplus_module_3","outElem","tsplus_module_1","tsplus_module_19","getChildren","errorSignal","permits","pull","cause","tsplus_module_4","outDone","tsplus_module_6","withPermits","p","latch","withPermit","tsplus_module_10","c","tsplus_module_8","tsplus_module_9","undefined","tsplus_module_11","tsplus_module_14","tsplus_module_16","tsplus_module_15","tsplus_module_18"],"sourceRoot":"","sources":["../../../_src/Channel/api/mapOutConcurrentIO.ts"],"sourcesContent":[null]}
+{"version":3,"file":"mapOutConcurrentIO.cjs","mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;AAGM,SAAUA,kBAAkB,CAChCC,CAAS,EACTC,CAA8C;EAE9C,OACEC,IAAmE,IACgB;IACnF,OAAOC,mCACLC,oBA2COC,KAAK,IAAI;MACd,MAAMC,QAAQ,GACZH,6BACEC,yDAAqDG,CAAC,IACpDC,8CAAyBC,OAAO,IAAKC,yBAAmCJ,QAAQ,EAA3CH,yBAAiBM,OAAO,CAAC,CAAmB,EAAjFF,CAAC,CAAiF,sEADpFF,KAAK,iDAEJ,CACF;MACH,OAAOC,QAAQ;IACjB,CAAC,yBAnDDK,8BAAiBC,WAAW,IAAIR,sDAGtBC,KAAK,4BAMLQ,WAAW,4BACXC,OAAO,4BACPC,IAAI,8BA8BHV,KAAK,uGA5BVD,6BACGY,KAAK,IAAKC,sBAAYb,6BAAgBY,KAAK,wBAAC,yBAAlCX,KAAK,CAA8B,EAC7CE,CAAC,IACAC,sBACGU,OAAO,IAAId,uBACVA,yBAE0Ba,sBAAYb,2BAAce,qBAAYD,OAAO,wBAAC,wBAAC,yBAA/Cb,KAAK,CAA2C,uDAF1ES,OAAO,CACJM,WAAW,CAACpB,CAAC,CAAC,sBAAS,yBACiD,wBAAO,EACnFS,OAAO,IAAIL,wBAEFiB,CAAC,4BACDC,KAAK,8IAYTA,KAAK,kDATLR,OAAO,CAACS,UAAU,CAChBnB,yBACEoB,yBAGWH,CAAC,yBAHZjB,8BAEkBqB,CAAC,IAAKC,0BAAYD,CAAC,yBAAbJ,CAAC,CAAa,yBAFtCM,0BACa1B,CAAC,CAACQ,OAAO,CAAC,8CADvBI,WAAW,yBACa,CACe,CAC1B,yBAJfa,yBAAcE,SAAS,yBAAvBN,KAAK,CAAmB,CAKvB,CACF,0BATDL,sBAAYb,wFAAC,yBAAwB,yBAArCC,KAAK,CAAiC,0BADxBwB,4CAA0B,0BAD1BA,4CAAgC,CAchD,EArBNtB,CAAC,CAsBA,yBAzBLQ,IAAI,CA0BH,0HA5BmBb,IAAI,2BADJ4B,+BAAU9B,CAAC,wBAAC,0BADZ6B,4CAA6B,0BALjDE,sCACEC,6BAAyEhC,CAAC,wBAAC,EAC1EK,KAAK,IAAIY,yBAACZ,KAAK,wBAAS,wBAC1B,0BALD4B,oCAAgB7B,yFAAW,CAA4B,wBAAC,CAwC1D,wBACH,CAQC,CACH;EACH,CAAC;AACH","names":["mapOutConcurrentIO","n","f","self","tsplus_module_2","tsplus_module_5","queue","consumer","r","tsplus_module_3","outElem","tsplus_module_1","tsplus_module_19","getChildren","errorSignal","permits","pull","cause","tsplus_module_4","outDone","tsplus_module_6","withPermits","p","latch","withPermit","tsplus_module_10","c","tsplus_module_8","tsplus_module_9","undefined","tsplus_module_11","tsplus_module_14","tsplus_module_16","tsplus_module_15","tsplus_module_18"],"sourceRoot":"","sources":["../../../_src/Channel/api/mapOutConcurrentIO.ts"],"sourcesContent":[null]}