@fncts/io 0.0.49 → 0.0.51

package/Push/api.d.ts

@@ -1,285 +1,202 @@
+import { Exit } from "@fncts/base/data/Exit/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
+import { CountdownLatch } from "@fncts/io/CountdownLatch";
+import { Environment } from "@fncts/base/data/Environment/definition";
 import { Cause } from "@fncts/base/data/Cause/definition";
-import { Either } from "@fncts/base/data/Either/definition";
-import { Duration } from "@fncts/base/data/Duration/definition";
-import { Maybe, Nothing, Just } from "@fncts/base/data/Maybe/definition";
-import { Refinement } from "@fncts/base/data/Refinement/definition";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
-import { UIO, URIO } from "@fncts/io/IO/definition";
-import { Environment } from "@fncts/base/data/Environment/definition";
-import { Fiber } from "@fncts/io/Fiber/definition";
-import { Scope } from "@fncts/io/Scope/definition";
-import { Conc } from "@fncts/base/collection/immutable/Conc";
-import { Future } from "@fncts/io/Future";
-import { AtomicReference } from "@fncts/base/internal/AtomicReference";
+import { Refinement } from "@fncts/base/data/Refinement/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
+import { Schedule } from "@fncts/io/Schedule/definition";
+import { Layer } from "@fncts/io/Layer";
+import type { MergeStrategy } from "./MergeStrategy.js";
 import { IO } from "@fncts/io/IO";
-import { Push, PushTypeId, PushVariance, Sink } from "./definition.js";
-/**
- * @tsplus pipeable fncts.io.Push as
- * @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 UnsafeSink<E, A> {
-    event: (value: A) => void;
-    error: (cause: Cause<E>) => void;
-}
+import { Push } from "@fncts/io/Push/definition";
+import { FlattenStrategy } from "@fncts/io/Push/FlattenStrategy";
+import { SyncProducer } from "@fncts/io/Push/Producer/SyncProducer";
+import { Scope } from "@fncts/io/Scope";
+import { type IOProducer } from "./Producer/IOProducer.js";
 /**
- * @tsplus static fncts.io.PushOps asyncInterrupt
+ * @tsplus static fncts.io.PushOps bracketExit
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function asyncInterrupt<R, E, A>(make: (emitter: UnsafeSink<E, A>) => Either<IO<R, never, void>, Push<R, E, A>>): Push<R, E, A>;
+export declare function bracketExit<R, E, A, R1, E1, B, R2, E2, C>(acquire: IO<R, E, A>, use: (a: A) => Push<R1, E1, B>, release: (a: A, exit: Exit<unknown, unknown>) => IO<R2, E2, C>): Push<R | R1 | R2, E | E1 | E2, B>;
 /**
- * @tsplus static fncts.io.PushOps async
+ * @tsplus static fncts.io.PushOps defer
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function async<E, A>(make: (sink: UnsafeSink<E, A>) => void): Push<never, E, A>;
+export declare function defer<R, E, A>(self: Lazy<Push<R, E, A>>): Push<R, E, A>;
 /**
  * @tsplus static fncts.io.PushOps combineLatest
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function combineLatest<A extends ReadonlyArray<Push<any, any, any>>>(streams: [...A]): Push<Push.EnvironmentOf<A[number]>, Push.ErrorOf<A[number]>, {
+export declare function combineLatest<A extends ReadonlyArray<Push<any, any, any>>>(streams: [...A]): Push<Push.EnvironmentOf<A[number]> | Scope, Push.ErrorOf<A[number]>, {
     [K in keyof A]: Push.ValueOf<A[K]>;
 }>;
-export declare function combineLatest<R, E, A>(streams: Iterable<Push<R, E, A>>): Push<R, E, ReadonlyArray<A>>;
-/**
- * @tsplus pipeable fncts.io.PushOps combineLatestWith
- * @tsplus location "@fncts/io/Push/api"
- */
-export declare function combineLatestWith<A, R1, E1, B, C>(that: Push<R1, E1, B>, f: (a: A, b: B) => C): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, C>;
-/**
- * @tsplus pipeable fncts.io.Push debounce
- * @tsplus location "@fncts/io/Push/api"
- */
-export declare function debounce(duration: Lazy<Duration>): <R, E, A>(self: Push<R, E, A>) => Push<R, E, A>;
-/**
- * @tsplus static fncts.io.PushOps defer
- * @tsplus location "@fncts/io/Push/api"
- */
-export declare function defer<R, E, A>(self: Lazy<Push<R, E, A>>): Push<R, E, A>;
+export declare function combineLatest<R, E, A>(streams: Iterable<Push<R, E, A>>): Push<R | Scope, E, ReadonlyArray<A>>;
 /**
- * @tsplus pipeable fncts.io.Push exhaustMap
+ * @tsplus pipeable fncts.io.Push contramapEnvironment
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function exhaustMap<A, R1, E1, B>(f: (a: A) => Push<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, B>;
+export declare function contramapEnvironment<R, R1>(f: (r: Environment<R1>) => Environment<R>): <E, A>(self: Push<R, E, A>) => Push<R1, E, A>;
 /**
- * @tsplus pipeable fncts.io.Push exhaustMapIO
+ * @tsplus static fncts.io.PushOps failCause
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function exhaustMapIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, B>;
+export declare function failCause<E>(cause: Lazy<Cause<E>>): Push<never, E, never>;
 /**
- * @tsplus pipeable fncts.io.Push filterIO
+ * @tsplus static fncts.io.PushOps failCauseNow
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function filterIO<A, R1, E1>(predicate: (a: A) => IO<R1, E1, boolean>): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, A>;
+export declare function failCauseNow<E>(cause: Cause<E>): Push<never, E, never>;
 /**
- * @tsplus pipeable fncts.io.Push filterMapIO
+ * @tsplus static fncts.io.PushOps failNow
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function filterMapIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, Maybe<B>>): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, B>;
+export declare function failNow<E>(error: E): Push<never, E, never>;
 /**
  * @tsplus pipeable fncts.io.Push filter
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function filter<A, B extends A>(refinement: Refinement<A, B>): <R, E>(self: Push<R, E, A>) => Push<R, E, B>;
-export declare function filter<A>(predicate: Predicate<A>): <R, E>(self: Push<R, E, A>) => Push<R, E, A>;
+export declare function filter<A, B extends A>(p: Refinement<A, B>): <R, E>(self: Push<R, E, A>) => Push<R, E, B>;
+export declare function filter<A>(p: Predicate<A>): <R, E>(self: Push<R, E, A>) => Push<R, E, A>;
 /**
  * @tsplus pipeable fncts.io.Push filterMap
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function filterMap<A, B>(f: (a: A) => Maybe<B>): <R, E>(self: Push<R, E, A>) => Push<R, E, B>;
+export declare function filterMap<A, B>(f: (value: A) => Maybe<B>): <R, E>(self: Push<R, E, A>) => Push<R, E, B>;
 /**
- * @tsplus pipeable fncts.io.Push flatMapConcurrentBounded
- * @tsplus location "@fncts/io/Push/api"
- */
-export declare function flatMapConcurrentBounded<A, R1, E1, B>(f: (a: A) => Push<R1, E1, B>, concurrency: number): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, B>;
-/**
- * @tsplus pipeable fncts.io.Push flatMapConcurrentUnbounded
+ * @tsplus pipeable fncts.io.Push flatMap
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function flatMapConcurrentUnbounded<A, R1, E1, B>(f: (a: A) => Push<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, B>;
+export declare function flatMap<A, R1, E1, B>(f: (a: A) => Push<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, B>;
 /**
- * @tsplus pipeable fncts.io.Push flatMapConcurrent
+ * @tsplus pipeable fncts.io.Push flatMapUnbounded
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function flatMapConcurrent<A, R1, E1, B>(f: (a: A) => Push<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, B>;
+export declare function flatMapUnbounded<A, R1, E1, B>(f: (a: A) => Push<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, B>;
 /**
- * @tsplus pipeable fncts.io.Push flatMap
+ * @tsplus pipeable fncts.io.Push flatMapWithStrategy
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function flatMap<A, R1, E1, B>(f: (a: A) => Push<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, B>;
+export declare function flatMapWithStrategy<A, R1, E1, B>(f: (a: A) => Push<R1, E1, B>, flattenStrategy: FlattenStrategy, executionStrategy: ExecutionStrategy): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, B>;
 /**
- * @tsplus getter fncts.io.Push flatten
+ * @tsplus static fncts.io.PushOps fromArray
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function flatten<R, E, R1, E1, A>(self: Push<R, E, Push<R1, E1, A>>): Push<R | R1, E | E1, A>;
+export declare function fromArray<A extends ReadonlyArray<any>>(array: A): Push<never, never, A[number]>;
 /**
  * @tsplus static fncts.io.PushOps fromIO
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function fromIO<R, E, A>(io: Lazy<IO<R, E, A>>): Push<R, E, A>;
+export declare function fromIO<R, E, A>(io: IO<R, E, A>): Push<R, E, A>;
 /**
- * @tsplus static fncts.io.PushOps fromAsyncIterable
+ * @tsplus static fncts.io.PushOps fromIOProducer
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function fromAsyncIterable<A>(iterable: AsyncIterable<A>): Push<never, never, A>;
+export declare function fromIOProducer<R, E, A>(producer: IOProducer<R, E, A>): Push<R, E, A>;
 /**
  * @tsplus static fncts.io.PushOps fromIterable
  * @tsplus location "@fncts/io/Push/api"
  */
 export declare function fromIterable<A>(iterable: Iterable<A>): Push<never, never, A>;
 /**
- * @tsplus getter fncts.io.Push multicast
- * @tsplus location "@fncts/io/Push/api"
- */
-export declare function multicast<R, E, A>(self: Push<R, E, A>): Push<R, E, A>;
-interface MulticastObserver<E, A> {
-    readonly sink: Sink<any, E, A>;
-    readonly environment: Environment<any>;
-}
-export declare class Multicast<R, E, A> implements Push<R, E, A>, Sink<never, E, A> {
-    readonly push: Push<R, E, A>;
-    readonly [PushTypeId]: PushTypeId;
-    [PushVariance]: {
-        readonly _R: (_: never) => R;
-        readonly _E: (_: never) => E;
-        readonly _A: (_: never) => A;
-    };
-    protected observers: Array<MulticastObserver<E, A>>;
-    protected fiber: Fiber<never, unknown> | undefined;
-    constructor(push: Push<R, E, A>);
-    run<R1>(sink: Sink<R1, E, A>): IO<R | R1, never, void>;
-    event(value: A): IO<never, never, void>;
-    error(cause: Cause<E>): IO<never, never, void>;
-    protected runValue(value: A, observer: MulticastObserver<E, A>): IO<never, never, void>;
-    protected runError(cause: Cause<E>, observer: MulticastObserver<E, A>): IO<never, never, void>;
-    protected removeSink(sink: Sink<any, E, A>): IO<never, never, void>;
-}
-/**
- * @tsplus getter fncts.io.Push hold
- * @tsplus location "@fncts/io/Push/api"
- */
-export declare function hold<R, E, A>(self: Push<R, E, A>): Push<R, E, A>;
-export declare class Hold<R, E, A> extends Multicast<R, E, A> {
-    push: Push<R, E, A>;
-    readonly current: AtomicReference<import("@fncts/base/data/Maybe.js").Maybe<A>>;
-    constructor(push: Push<R, E, A>);
-    run<R1>(sink: Sink<R1, E, A>): IO<R | R1, never, void>;
-    event(value: A): IO<never, never, void>;
-}
-/**
- * @tsplus pipeable fncts.io.Push map 1
+ * @tsplus static fncts.io.PushOps fromScheduled
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function map<A, B>(f: (a: A) => B): <R, E>(self: Push<R, E, A>) => Push<R, E, B>;
+export declare function fromScheduled<R, E, I, R1, O>(io: IO<R, E, I>, schedule: Schedule<R1, I, O>): Push<R | R1, E, O>;
 /**
- * @tsplus pipeable fncts.io.Push mapError
+ * @tsplus static fncts.io.PushOps fromSyncProducer
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function mapError<E, E1>(f: (e: E) => E1): <R, A>(self: Push<R, E, A>) => Push<R, E1, A>;
+export declare function fromSyncProducer<A>(producer: SyncProducer<A>): Push<never, never, A>;
 /**
- * @tsplus pipeable fncts.io.Push mapErrorCause
+ * @tsplus static fncts.io.PushOps haltNow
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function mapErrorCause<E, E1>(f: (cause: Cause<E>) => Cause<E1>): <R, A>(self: Push<R, E, A>) => Push<R, E1, A>;
-/**
- * @tsplus pipeable fncts.io.Push mapIO
- * @tsplus location "@fncts/io/Push/api"
- */
-export declare function mapIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, B>;
+export declare function haltNow(error: unknown): Push<never, never, never>;
 /**
- * @tsplus pipeable fncts.io.Push merge
+ * @tsplus static fncts.io.PushOps __call
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function merge<R1, E1, B>(that: Push<R1, E1, B>): <R, E, A>(self: Push<R, E, A>) => Push<R | R1, E | E1, A | B>;
+export declare function makePush<R, E, A>(run: <R1>(sink: Push.UnsafeSink<R1, E, A>) => IO<R | R1, never, unknown>): Push<R, E, A>;
 /**
- * @tsplus static fncts.io.PushOps mergeAll
+ * @tsplus pipeable fncts.io.Push map
  * @tsplus location "@fncts/io/Push/api"
  */
-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>;
+export declare function map<A, B>(f: (a: A) => B): <R, E>(self: Push<R, E, A>) => Push<R, E, B>;
 /**
- * @tsplus pipeable fncts.io.Push observe
+ * @tsplus pipeable fncts.io.Push mapAccum
  * @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>) => IO<R | R1 | Scope, E | E1, void>;
+export declare function mapAccum<A, S, B>(seed: S, f: (acc: S, a: A) => readonly [S, B]): <R, E>(self: Push<R, E, A>) => Push<R, E, B>;
 /**
- * @tsplus static fncts.io.PushOps repeatIOMaybe
+ * @tsplus pipeable fncts.io.Push mapIO
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function repeatIOMaybe<R, E, A>(io: IO<R, Maybe<E>, A>, __tsplusTrace?: string): Push<R, E, A>;
+export declare function mapIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, B>;
 /**
- * @tsplus getter fncts.io.Push runCollect
+ * @tsplus pipeable fncts.io.Push mapIOWithStrategy
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function runCollect<R, E, A>(self: Push<R, E, A>): IO<R | Scope, E, Conc<A>>;
+export declare function mapIOWithStrategy<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>, flattenStrategy: FlattenStrategy, executionStrategy: ExecutionStrategy): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, B>;
 /**
- * @tsplus getter fncts.io.Push runDrain
+ * @tsplus static fncts.io.PushOps mergeWithStrategy
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function runDrain<R, E, A>(self: Push<R, E, A>): IO<R | Scope, E, void>;
+export declare function mergeWithStrategy<Ps extends ReadonlyArray<Push<any, any, any>>>(streams: Ps, mergeStrategy: MergeStrategy): Push<Push.EnvironmentOf<Ps[number]>, Push.ErrorOf<Ps[number]>, Push.ValueOf<Ps[number]>>;
 /**
- * @tsplus static fncts.io.PushOps scoped
+ * @tsplus pipeable fncts.io.Push observe
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function scoped<R, E, A>(io: Lazy<IO<R, E, A>>, __tsplusTrace?: string): Push<Exclude<R, Scope>, E, A>;
+export declare function observe<A, R1>(f: (a: A) => IO<R1, never, void>): <R, E>(self: Push<R, E, A>) => IO<R | R1, never, void>;
 /**
- * @tsplus static fncts.io.PushOps succeed
+ * @tsplus pipeable fncts.io.Push orElseCause
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function succeed<A>(value: Lazy<A>): Push<never, never, A>;
+export declare function orElseCause<E, R1, E1, B>(that: (cause: Cause<E>) => Push<R1, E1, B>): <R, A>(self: Push<R, E, A>) => Push<R | R1, E | E1, A | B>;
 /**
- * @tsplus pipeable fncts.io.Push switchMap
+ * @tsplus pipeable fncts.io.Push provideEnvironment
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function switchMap<A, R1, E1, B>(f: (a: A) => Push<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, B>;
+export declare function provideEnvironment<R>(environment: Environment<R>): <E, A>(self: Push<R, E, A>) => Push<never, E, A>;
 /**
- * @tsplus pipeable fncts.io.Push switchMapIO
+ * @tsplus pipeable fncts.io.Push provideLayer
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function switchMapIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, B>;
+export declare function provideLayer<R1, E1, R2>(layer: Layer<R1, E1, R2>): <R, E, A>(self: Push<R, E, A>) => Push<Exclude<R, R2> | R1, E | E1, A>;
 /**
- * @tsplus pipeable fncts.io.Push tap
+ * @tsplus pipeable fncts.io.Push provideSomeEnvironment
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function tap<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, A>;
+export declare function provideSomeEnvironment<R1>(environment: Environment<R1>): <R, E, A>(self: Push<R, E, A>) => Push<Exclude<R, R1>, E, A>;
 /**
- * @tsplus pipeable fncts.io.Push transform
+ * @tsplus static fncts.io.PushOps schedule
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function transform<R1 = never>(f: <R, E, A>(io: IO<R, E, A>) => IO<R | R1, E, A>): <R, E, A>(self: Push<R, E, A>) => Push<R | R1, E, A>;
+export declare function schedule<R, E, A, R1, O>(io: IO<R, E, A>, schedule: Schedule<R1, unknown, O>): Push<R | R1, E, A>;
 /**
- * @tsplus static fncts.io.PushOps unfold
+ * @tsplus static fncts.io.PushOps succeed
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function unfold<S, A>(s: S, f: (s: S) => Maybe<readonly [A, S]>): Push<never, never, A>;
+export declare function succeed<A>(value: Lazy<A>): Push<never, never, A>;
 /**
- * @tsplus static fncts.io.PushOps unfoldIO
+ * @tsplus static fncts.io.PushOps succeedNow
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function unfoldIO<S, R, E, A>(s: S, f: (s: S) => IO<R, E, Maybe<readonly [A, S]>>): Push<R, E, A>;
+export declare function succeedNow<A>(value: A): Push<never, never, A>;
 /**
- * @tsplus pipeable fncts.io.Push untilFuture
+ * @tsplus pipeable fncts.io.Push switchMap
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function untilFuture<E1, B>(future: Future<E1, B>): <R, E, A>(self: Push<R, E, A>) => Push<R, E | E1, A>;
+export declare function switchMap<A, R1, E1, B>(f: (a: A) => Push<R1, E1, B>, executionStrategy?: ExecutionStrategy): <R, E>(self: Push<R, E, A>) => Push<R | R1, E | E1, B>;
 /**
- * @tsplus pipeable fncts.io.Push untilPush
+ * @tsplus pipeable fncts.io.Push transform
  * @tsplus location "@fncts/io/Push/api"
  */
-export declare function untilPush<R1, E1, B>(signal: Push<R1, E1, B>): <R, E, A>(self: Push<R, E, A>) => Push<R | R1, E | E1, A>;
+export declare function transform<R, R1>(f: (io: IO<R, never, void>) => IO<R1, never, void>): <E, A>(self: Push<R, E, A>) => Push<R | R1, E, A>;
 /**
  * @tsplus static fncts.io.PushOps unwrap
  * @tsplus location "@fncts/io/Push/api"
  */
 export declare function unwrap<R, E, R1, E1, A>(io: IO<R, E, Push<R1, E1, A>>): Push<R | R1, E | E1, A>;
-/**
- * @tsplus static fncts.io.PushOps unwrapScoped
- * @tsplus location "@fncts/io/Push/api"
- */
-export declare function unwrapScoped<R, E, R1, E1, A>(self: IO<R, E, Push<R1, E1, A>>, __tsplusTrace?: string): Push<R1 | Exclude<R, Scope>, E | E1, A>;
-/**
- * @tsplus static fncts.io.PushOps never
- * @tsplus location "@fncts/io/Push/api"
- */
-export declare const never: Push<never, never, never>;
-export {};

package/Push/definition.d.ts

@@ -1,24 +1,43 @@
 import { IO } from "@fncts/io/IO/definition";
 import { Cause } from "@fncts/base/data/Cause/definition";
+import { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
+import type { Sink as Sink_, UnsafeSink, UnsafeSink as UnsafeSink_ } from "./Sink.js";
+import type { FlattenStrategy } from "@fncts/io/Push/FlattenStrategy";
+import type { IOProducer } from "@fncts/io/Push/Producer/IOProducer";
+import { type SyncProducer } from "@fncts/io/Push/Producer/SyncProducer";
 export declare const PushVariance: unique symbol;
 export type PushVariance = typeof PushVariance;
 export declare const PushTypeId: unique symbol;
 export type PushTypeId = typeof PushTypeId;
+export declare const enum PushTag {
+    Defer = 0,
+    ProducerSync = 1,
+    ProducerIO = 2,
+    FailCause = 3,
+    OnSuccess = 4,
+    OnSuccessWithStrategy = 5,
+    OnSuccessAndFailure = 6,
+    External = 7,
+    FromPush = 8,
+    Transform = 9
+}
 /**
  * @tsplus type fncts.io.Push
  * @tsplus companion fncts.io.PushOps
  */
-export declare class Push<R, E, A> {
-    readonly run: <R1>(emitter: Sink<R1, E, A>) => IO<R | R1, never, unknown>;
+export declare abstract class Push<R, E, A> {
     readonly [PushTypeId]: PushTypeId;
+    readonly _pushOpCode: PushTag | null;
     [PushVariance]: {
         readonly _R: (_: never) => R;
         readonly _E: (_: never) => E;
         readonly _A: (_: never) => A;
     };
-    constructor(run: <R1>(emitter: Sink<R1, E, A>) => IO<R | R1, never, unknown>);
+    constructor();
+    run<R1>(sink: UnsafeSink<R1, E, A>): IO<R | R1, never, void>;
 }
 export declare namespace Push {
+    type Run<R, E, A> = <R1>(emitter: UnsafeSink<R1, E, A>) => IO<R | R1, never, unknown>;
     type EnvironmentOf<X> = [X] extends [{
         [PushVariance]: {
             readonly _R: (_: never) => infer R;
@@ -34,23 +53,77 @@ export declare namespace Push {
             readonly _A: (_: never) => infer A;
         };
     }] ? A : never;
+    type Sink<Env, R, E, A> = Sink_<Env, R, E, A>;
+    type UnsafeSink<R, E, A> = UnsafeSink_<R, E, A>;
 }
 /**
- * @tsplus type fncts.io.Push.Sink
- * @tsplus companion fncts.io.Push.SinkOps
- */
-export declare class Sink<R, E, A> {
-    readonly event: (value: A) => IO<R, never, void>;
-    readonly error: (cause: Cause<E>) => IO<R, never, void>;
-    constructor(event: (value: A) => IO<R, never, void>, error: (cause: Cause<E>) => IO<R, never, void>);
-}
-/**
- * @tsplus static fncts.io.PushOps __call
+ * @tsplus pipeable fncts.io.Push unsafeRun
  * @tsplus location "@fncts/io/Push/definition"
  */
-export declare function makePush<R, E, A>(run: <R1>(sink: Sink<R1, E, A>) => IO<R | R1, never, unknown>): Push<R, E, A>;
-/**
- * @tsplus static fncts.io.Push.SinkOps __call
- * @tsplus location "@fncts/io/Push/definition"
- */
-export declare function makeSink<R, E, A>(value: (value: A) => IO<R, never, unknown>, error: (cause: Cause<E>) => IO<R, never, unknown>): Sink<R, E, A>;
+export declare function unsafeRun<E, A, R1>(sink: UnsafeSink<R1, E, A>): <R>(push: Push<R, E, A>) => IO<R | R1, never, void>;
+export type PushOp<Tag extends string | number | null, Body = {}> = Push<never, any, any> & Body & {
+    readonly _pushOpCode: Tag;
+};
+export declare class PushPrimitive extends Push<never, any, any> {
+    readonly _pushOpCode: PushTag | null;
+    i0: any;
+    i1: any;
+    i2: any;
+    i3: any;
+    i4: any;
+    trace: string | undefined;
+    constructor(_pushOpCode: PushTag | null);
+}
+export interface Base<R = never, E = any, A = any> extends PushOp<null, {
+    readonly run: Push.Run<R, E, A>;
+}> {
+}
+export interface Defer extends PushOp<PushTag.Defer, {
+    readonly i0: () => Primitive;
+}> {
+}
+export interface FromPush<R = never, E = any, A = any> extends PushOp<PushTag.FromPush, {
+    readonly i0: Push.Run<R, E, A>;
+}> {
+}
+export interface ProducerSync<A = any> extends PushOp<PushTag.ProducerSync, {
+    readonly i0: SyncProducer<A>;
+}> {
+}
+export interface ProducerIO<R = never, E = any, A = any> extends PushOp<PushTag.ProducerIO, {
+    readonly i0: IOProducer<R, E, A>;
+}> {
+}
+export interface Fail<E = any> extends PushOp<PushTag.FailCause, {
+    readonly i0: () => Cause<E>;
+}> {
+}
+export interface OnSuccess<A = any> extends PushOp<PushTag.OnSuccess, {
+    readonly i0: Primitive;
+    readonly i1: (a: A) => Primitive;
+}> {
+}
+export interface OnSuccessWithStrategy<A = any> extends PushOp<PushTag.OnSuccessWithStrategy, {
+    readonly i0: Primitive;
+    readonly i1: (a: A) => Primitive;
+    readonly i2: FlattenStrategy;
+    readonly i3: ExecutionStrategy;
+}> {
+}
+export interface OnSuccessAndFailure<E = any, A = any> extends PushOp<PushTag.OnSuccessAndFailure, {
+    readonly i0: Primitive;
+    readonly i1: (cause: Cause<E>) => Primitive;
+    readonly i2: (a: A) => Primitive;
+    readonly i3: FlattenStrategy;
+    readonly i4: ExecutionStrategy;
+}> {
+}
+export interface Transform extends PushOp<PushTag.Transform, {
+    i0: Primitive;
+    i1: (io: IO<any, any, any>) => IO<any, never, void>;
+}> {
+}
+type Primitive = Base | ProducerSync | ProducerIO | Fail | OnSuccess | OnSuccessWithStrategy | OnSuccessAndFailure | FromPush | Defer | Transform;
+export declare function concrete(push: Push<any, any, any>): asserts push is Primitive;
+export declare function unsafeRunPush(push: Push<any, any, any>, sink: UnsafeSink<any, any, any>): IO<any, never, void>;
+export {};

package/Push/internal.d.ts

@@ -1,6 +1,9 @@
+import { Scope } from "@fncts/io/Scope/definition";
 import { IO, URIO } from "@fncts/io/IO/definition";
+import { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
 import { Fiber } from "@fncts/io/Fiber/definition";
 import type { RuntimeFiber } from "@fncts/io/Fiber";
+export declare function withScope<R, E, A>(f: (scope: Scope.Closeable) => IO<R, E, A>, executionStrategy: ExecutionStrategy): IO<R | Scope, E, A>;
 export declare function withScopedFork<R, E, A>(f: (fork: <R, E, A>(io: IO<R, E, A>) => IO<R, never, RuntimeFiber<E, A>>) => IO<R, E, A>): IO<R, E, A>;
 export declare function withSwitch<R, E, A>(f: (fork: <R>(io: URIO<R, void>) => URIO<R, void>) => IO<R, E, A>): import("../IO").IO<R, E, void>;
 export declare function withUnboundedConcurrency<R, E, A>(f: (fork: <R>(io: URIO<R, void>) => URIO<R, RuntimeFiber<never, void>>) => IO<R, E, A>): import("../IO").IO<R, E, void>;

package/Push.d.ts

@@ -1,3 +1,9 @@
 export * from "./Push/api.js";
+export * from "./Push/Bounds.js";
 export * from "./Push/definition.js";
+export * from "./Push/FlattenStrategy.js";
+export * from "./Push/IndexedBuffer.js";
 export * from "./Push/internal.js";
+export * from "./Push/MergeStrategy.js";
+export * from "./Push/Operator.js";
+export * from "./Push/Producer.js";

package/Queue/api/dimapIO.d.ts

@@ -57,15 +57,15 @@ declare class ContramapIO<RA, RB, EA, EB, A, B, RC, EC, C> implements PEnqueueIn
         readonly _B: (_: never) => B;
     };
     constructor(queue: PEnqueueInternal<RA, RB, EA, EB, A, B>, f: (c: C) => IO<RC, EC, A>);
-    awaitShutdown: UIO<void>;
-    capacity: number;
-    isShutdown: UIO<boolean>;
+    get awaitShutdown(): UIO<void>;
+    get capacity(): number;
+    get isShutdown(): UIO<boolean>;
     get unsafeSize(): Maybe<number>;
     unsafeOffer(a: C): boolean;
     offer(c: C): IO<RC | RA, EA | EC, boolean>;
     offerAll(cs: Iterable<C>): IO<RC | RA, EC | EA, boolean>;
-    shutdown: UIO<void>;
-    size: UIO<number>;
+    get shutdown(): UIO<void>;
+    get size(): UIO<number>;
 }
 /**
  * Transforms elements enqueued into this queue with an effectful function.
@@ -87,15 +87,15 @@ declare class MapIO<RA, RB, EA, EB, A, B, RC, EC, C> implements PDequeueInternal
         readonly _B: (_: never) => C;
     };
     constructor(queue: PDequeueInternal<RA, RB, EA, EB, A, B>, f: (b: B) => IO<RC, EC, C>);
-    awaitShutdown: UIO<void>;
-    capacity: number;
-    isShutdown: UIO<boolean>;
-    shutdown: UIO<void>;
-    size: UIO<number>;
+    get awaitShutdown(): UIO<void>;
+    get capacity(): number;
+    get isShutdown(): UIO<boolean>;
+    get shutdown(): UIO<void>;
+    get size(): UIO<number>;
     get unsafeSize(): Maybe<number>;
     unsafeOffer(a: C): boolean;
-    take: IO<RB | RC, EB | EC, C>;
-    takeAll: IO<RB | RC, EB | EC, Conc<C>>;
+    get take(): IO<RB | RC, EB | EC, C>;
+    get takeAll(): IO<RB | RC, EB | EC, Conc<C>>;
     takeUpTo(n: number): IO<RB | RC, EB | EC, Conc<C>>;
 }
 /**