@fncts/io 0.0.12 → 0.0.15

package/ScopedRef/api.d.ts

@@ -1,11 +1,10 @@
 import { IO, UIO, FIO } from "@fncts/io/IO/definition";
-import { Has } from "@fncts/base/typeclass/Has";
 import { Scope } from "@fncts/io/Scope/definition";
 import { ScopedRef } from "@fncts/io/ScopedRef/definition";
 import { Ref } from "@fncts/io/Ref";
-import { Exit } from "@fncts/base/data/Exit";
+import { Exit } from "@fncts/base/data/Exit/definition";
 /**
  * @tsplus static fncts.io.ScopedRefOps fromAcquire
  * @tsplus location "@fncts/io/ScopedRef/api"
  */
-export declare function fromAcquire<R, E, A>(acquire: IO<R, E, A>, __tsplusTrace?: string): IO<R & Has<Scope>, E, ScopedRef<A>>;
+export declare function fromAcquire<R, E, A>(acquire: IO<R, E, A>, __tsplusTrace?: string): IO<R | Scope, E, ScopedRef<A>>;

package/ScopedRef/definition.d.ts

@@ -1,5 +1,4 @@
 import { IO, UIO } from "@fncts/io/IO/definition";
-import { Has } from "@fncts/base/typeclass/Has";
 import { Scope } from "@fncts/io/Scope/definition";
 export declare const ScopedRefTypeId: unique symbol;
 export declare type ScopedRefTypeId = typeof ScopedRefTypeId;
@@ -9,6 +8,6 @@ export declare type ScopedRefTypeId = typeof ScopedRefTypeId;
  */
 export declare abstract class ScopedRef<A> {
     readonly _typeId: ScopedRefTypeId;
-    abstract set<R, E>(acquire: IO<R & Has<Scope>, E, A>, __tsplusTrace?: string): IO<R, E, void>;
+    abstract set<R, E>(acquire: IO<R | Scope, E, A>, __tsplusTrace?: string): IO<Exclude<R, Scope>, E, void>;
     abstract get: UIO<A>;
 }

package/Sink/api.d.ts

@@ -1,46 +1,45 @@
 import { Sink } from "@fncts/io/Sink/definition";
-import { Lazy } from "@fncts/base/data/function";
+import { Lazy } from "@fncts/base/data/function/definition";
 import { Conc, ConcBuilder } from "@fncts/base/collection/immutable/Conc";
-import { Predicate } from "@fncts/base/data/Predicate";
+import { Predicate } from "@fncts/base/data/Predicate/definition";
 import { Channel } from "@fncts/io/Channel";
 import { IO } from "@fncts/io/IO/definition";
-import { Environment } from "@fncts/base/data/Environment";
-import { Cause } from "@fncts/base/data/Cause";
-import { Maybe } from "@fncts/base/data/Maybe";
-import { Has } from "@fncts/base/typeclass/Has";
+import { Environment } from "@fncts/base/data/Environment/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Either } from "@fncts/base/data/Either/definition";
 import { Scope } from "@fncts/io/Scope/definition";
-import { Either } from "@fncts/base/data/Either";
 import { Queue } from "@fncts/io/Queue/definition";
 import { Hub } from "@fncts/io/Hub/definition";
-import { Exit } from "@fncts/base/data/Exit";
-import { Tag } from "@fncts/base/data/Tag";
+import { Exit } from "@fncts/base/data/Exit/definition";
+import { Tag } from "@fncts/base/data/Tag/definition";
 import { Ref } from "@fncts/io/Ref";
-import { Duration } from "@fncts/base/data/Duration";
+import { Duration } from "@fncts/base/data/Duration/definition";
 import { MergeDecision } from "../Channel/internal/MergeDecision.js";
 /**
  * Like {@link zip }, but keeps only the result from this sink
  * @tsplus fluent fncts.io.Sink apFirst
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function apFirst<R, E, In, L, Z, R1, E1, In1 extends In, L1 extends L, Z1>(self: Sink<R, E, In, L, Z>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>): Sink<R & R1, E | E1, In & In1, L | L1, Z>;
+export declare function apFirst<R, E, In, L, Z, R1, E1, In1 extends In, L1 extends L, Z1>(self: Sink<R, E, In, L, Z>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): Sink<R | R1, E | E1, In & In1, L | L1, Z>;
 /**
  * Like {@link zipC }, but keeps only the result from this sink
  * @tsplus fluent fncts.io.Sink apFirstC
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function apFirstC<R, E, In, L, Z, R1, E1, In1 extends In, L1 extends L, Z1>(self: Sink<R, E, In, L, Z>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>): Sink<R & R1, E | E1, In & In1, L | L1, Z>;
+export declare function apFirstC<R, E, In, L, Z, R1, E1, In1 extends In, L1 extends L, Z1>(self: Sink<R, E, In, L, Z>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): Sink<R | R1, E | E1, In & In1, L | L1, Z>;
 /**
  * Like {@link zip }, but keeps only the result from the `that` sink
  * @tsplus fluent fncts.io.Sink apSecond
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function apSecond<R, E, In, L, Z, R1, E1, In1 extends In, L1 extends L, Z1>(self: Sink<R, E, In, L, Z>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): Sink<R & R1, E | E1, In & In1, L | L1, Z1>;
+export declare function apSecond<R, E, In, L, Z, R1, E1, In1 extends In, L1 extends L, Z1>(self: Sink<R, E, In, L, Z>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): Sink<R | R1, E | E1, In & In1, L | L1, Z1>;
 /**
  * Like {@link zipC }, but keeps only the result from the `that` sink
  * @tsplus fluent fncts.io.Sink apSecondC
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function apSecondC<R, E, In, L, Z, R1, E1, In1 extends In, L1 extends L, Z1>(self: Sink<R, E, In, L, Z>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): Sink<R & R1, E | E1, In & In1, L | L1, Z1>;
+export declare function apSecondC<R, E, In, L, Z, R1, E1, In1 extends In, L1 extends L, Z1>(self: Sink<R, E, In, L, Z>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): Sink<R | R1, E | E1, In & In1, L | L1, Z1>;
 /**
  * Replaces this sink's result with the provided value.
  * @tsplus fluent fncts.io.Sink as
@@ -86,13 +85,13 @@ export declare function contramapChunks<R, E, In, L, Z, In1>(self: Sink<R, E, In
  * @tsplus fluent fncts.io.Sink contramapChunksIO
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function contramapChunksIO<R, E, In, L, Z, R1, E1, In1>(self: Sink<R, E, In, L, Z>, f: (chunk: Conc<In1>) => IO<R1, E1, Conc<In>>, __tsplusTrace?: string): Sink<R & R1, E | E1, In1, L, Z>;
+export declare function contramapChunksIO<R, E, In, L, Z, R1, E1, In1>(self: Sink<R, E, In, L, Z>, f: (chunk: Conc<In1>) => IO<R1, E1, Conc<In>>, __tsplusTrace?: string): Sink<R | R1, E | E1, In1, L, Z>;
 /**
  * Effectfully transforms this sink's input elements.
  * @tsplus fluent fncts.io.Sink contramapIO
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function contramapIO<R, E, In, L, Z, R1, E1, In1>(self: Sink<R, E, In, L, Z>, f: (inp: In1) => IO<R1, E1, In>, __tsplusTrace?: string): Sink<R & R1, E | E1, In1, L, Z>;
+export declare function contramapIO<R, E, In, L, Z, R1, E1, In1>(self: Sink<R, E, In, L, Z>, f: (inp: In1) => IO<R1, E1, In>, __tsplusTrace?: string): Sink<R | R1, E | E1, In1, L, Z>;
 /**
  * Transforms both inputs and result of this sink using the provided
  * functions.
@@ -113,14 +112,14 @@ export declare function dimapChunks<R, E, In, L, Z, In1, Z1>(self: Sink<R, E, In
  * @tsplus fluent fncts.io.Sink dimapChunksIO
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function dimapChunksIO<R, E, In, L, Z, R1, E1, In1, R2, E2, Z1>(self: Sink<R, E, In, L, Z>, f: (chunk: Conc<In1>) => IO<R1, E1, Conc<In>>, g: (z: Z) => IO<R2, E2, Z1>, __tsplusTrace?: string): Sink<R & R1 & R2, E | E1 | E2, In1, L, Z1>;
+export declare function dimapChunksIO<R, E, In, L, Z, R1, E1, In1, R2, E2, Z1>(self: Sink<R, E, In, L, Z>, f: (chunk: Conc<In1>) => IO<R1, E1, Conc<In>>, g: (z: Z) => IO<R2, E2, Z1>, __tsplusTrace?: string): Sink<R | R1 | R2, E | E1 | E2, In1, L, Z1>;
 /**
  * Effectfully transforms both inputs and result of this sink using the
  * provided functions.
  * @tsplus fluent fncts.io.Sink dimapIO
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function dimapIO<R, E, In, L, Z, R1, E1, In1, R2, E2, Z1>(self: Sink<R, E, In, L, Z>, f: (inp: In1) => IO<R1, E1, In>, g: (z: Z) => IO<R2, E2, Z1>, __tsplusTrace?: string): Sink<R & R1 & R2, E | E1 | E2, In1, L, Z1>;
+export declare function dimapIO<R, E, In, L, Z, R1, E1, In1, R2, E2, Z1>(self: Sink<R, E, In, L, Z>, f: (inp: In1) => IO<R1, E1, In>, g: (z: Z) => IO<R2, E2, Z1>, __tsplusTrace?: string): Sink<R | R1 | R2, E | E1 | E2, In1, L, Z1>;
 /**
  * Returns a lazily constructed sink that may require effects for its
  * creation.
@@ -133,13 +132,13 @@ export declare function defer<R, E, In, L, Z>(sink: Lazy<Sink<R, E, In, L, Z>>,
  * @tsplus static fncts.io.SinkOps drain
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare const drain: Sink<unknown, never, unknown, never, void>;
+export declare const drain: Sink<never, never, unknown, never, void>;
 /**
  * Drops incoming elements until the predicate `p` is satisfied.
  * @tsplus static fncts.io.SinkOps dropUntil
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function makeDropUntil<In>(p: Predicate<In>, __tsplusTrace?: string): Sink<unknown, never, In, In, void>;
+export declare function makeDropUntil<In>(p: Predicate<In>, __tsplusTrace?: string): Sink<never, never, In, In, void>;
 /**
  * Drops incoming elements until the effectful predicate `p` is satisfied.
  * @tsplus static fncts.io.SinkOps dropUntilIO
@@ -151,7 +150,7 @@ export declare function makeDropUntilIO<R, E, In>(p: (inp: In) => IO<R, E, boole
  * @tsplus static fncts.io.SinkOps dropWhile
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function makeDropWhile<Err, In>(predicate: Predicate<In>, __tsplusTrace?: string): Sink<unknown, never, In, In, any>;
+export declare function makeDropWhile<Err, In>(predicate: Predicate<In>, __tsplusTrace?: string): Sink<never, never, In, In, any>;
 /**
  * Drops incoming elements as long as the effectful predicate `p` is
  * satisfied.
@@ -176,37 +175,37 @@ export declare function environmentWith<R, Z>(f: (r: Environment<R>) => Z, __tsp
  * @tsplus static fncts.io.SinkOps environmentWithIO
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function environmentWithIO<R, R1, E, Z>(f: (r: Environment<R>) => IO<R1, E, Z>, __tsplusTrace?: string): Sink<R & R1, E, unknown, never, Z>;
+export declare function environmentWithIO<R, R1, E, Z>(f: (r: Environment<R>) => IO<R1, E, Z>, __tsplusTrace?: string): Sink<R | R1, E, unknown, never, Z>;
 /**
  * Accesses the environment of the sink in the context of a sink.
  * @tsplus static fncts.io.SinkOps environmentWithSink
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function environmentWithSink<R, R1, E, In, L, Z>(f: (r: Environment<R>) => Sink<R1, E, In, L, Z>, __tsplusTrace?: string): Sink<R & R1, E, In, L, Z>;
+export declare function environmentWithSink<R, R1, E, In, L, Z>(f: (r: Environment<R>) => Sink<R1, E, In, L, Z>, __tsplusTrace?: string): Sink<R | R1, E, In, L, Z>;
 /**
  * A sink that always fails with the specified error.
  * @tsplus static fncts.io.SinkOps fail
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function fail<E>(e: Lazy<E>, __tsplusTrace?: string): Sink<unknown, E, unknown, never, never>;
+export declare function fail<E>(e: Lazy<E>, __tsplusTrace?: string): Sink<never, E, unknown, never, never>;
 /**
  * Creates a sink halting with a specified cause.
  * @tsplus static fncts.io.SinkOps failCause
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function failCause<E>(cause: Lazy<Cause<E>>, __tsplusTrace?: string): Sink<unknown, E, unknown, never, never>;
+export declare function failCause<E>(cause: Lazy<Cause<E>>, __tsplusTrace?: string): Sink<never, E, unknown, never, never>;
 /**
  * Creates a sink halting with a specified cause.
  * @tsplus static fncts.io.SinkOps failCauseNow
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function failCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string): Sink<unknown, E, unknown, never, never>;
+export declare function failCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string): Sink<never, E, unknown, never, never>;
 /**
  * A sink that always fails with the specified error.
  * @tsplus static fncts.io.SinkOps failNow
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function failNow<E>(e: E, __tsplusTrace?: string): Sink<unknown, E, unknown, never, never>;
+export declare function failNow<E>(e: E, __tsplusTrace?: string): Sink<never, E, unknown, never, never>;
 /**
  * Filters the sink's input with the given predicate
  * @tsplus static fncts.io.SinkOps filterInput
@@ -218,13 +217,13 @@ export declare function filterInput<R, E, In, L, Z>(self: Sink<R, E, In, L, Z>,
  * @tsplus static fncts.io.SinkOps filterInputIO
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function filterInputIO<R, E, In, L, Z, R1, E1>(self: Sink<R, E, In, L, Z>, p: (inp: In) => IO<R1, E1, boolean>, __tsplusTrace?: string): Sink<R & R1, E | E1, In, L, Z>;
+export declare function filterInputIO<R, E, In, L, Z, R1, E1>(self: Sink<R, E, In, L, Z>, p: (inp: In) => IO<R1, E1, boolean>, __tsplusTrace?: string): Sink<R | R1, E | E1, In, L, Z>;
 /**
  * Creates a sink that produces values until one verifies the predicate `f`.
  * @tsplus fluent fncts.io.Sink findIO
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function findIO<R, E, In extends L, L, Z, R1, E1>(self: Sink<R, E, In, L, Z>, f: (z: Z) => IO<R1, E1, boolean>, __tsplusTrace?: string): Sink<R & R1, E | E1, In, L, Maybe<Z>>;
+export declare function findIO<R, E, In extends L, L, Z, R1, E1>(self: Sink<R, E, In, L, Z>, f: (z: Z) => IO<R1, E1, boolean>, __tsplusTrace?: string): Sink<R | R1, E | E1, In, L, Maybe<Z>>;
 /**
  * Runs this sink until it yields a result, then uses that result to create
  * another sink from the provided function which will continue to run until it
@@ -234,46 +233,46 @@ export declare function findIO<R, E, In extends L, L, Z, R1, E1>(self: Sink<R, E
  * @tsplus fluent fncts.io.Sink flatMap
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function flatMap<R, E, In, L, Z, R1, E1, In1 extends In, L1, Z1>(self: Sink<R, E, In, L, Z>, f: (z: Z) => Sink<R1, E1, In1, L1, Z1>, __tsplusTrace?: string): Sink<R & R1, E | E1, In1, L | L1, Z1>;
+export declare function flatMap<R, E, In, L, Z, R1, E1, In1 extends In, L1, Z1>(self: Sink<R, E, In, L, Z>, f: (z: Z) => Sink<R1, E1, In1, L1, Z1>, __tsplusTrace?: string): Sink<R | R1, E | E1, In1, L | L1, Z1>;
 /**
  * Creates a sink from a {@link Channel }
  * @tsplus static fncts.io.SinkOps fromChannel
  * @tsplus static fncts.io.SinkOps __call
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function fromChannel<R, E, In, L, Z>(channel: Channel<R, never, Conc<In>, unknown, E, Conc<L>, Z>): Sink<R, E, In, L, Z>;
+export declare function fromChannel<R, E, In, L, Z>(channel: Channel<R, never, Conc<In>, unknown, E, Conc<L>, Z>, __tsplusTrace?: string): Sink<R, E, In, L, Z>;
 /**
  * Creates a sink from a chunk processing function.
  * @tsplus static fncts.io.SinkOps fromPush
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function fromPush<R, E, In, L, Z, R1>(push: IO<Has<Scope> & R, never, (_: Maybe<Conc<In>>) => IO<R1, readonly [Either<E, Z>, Conc<L>], void>>, __tsplusTrace?: string): Sink<R & R1, E, In, L, Z>;
+export declare function fromPush<R, E, In, L, Z, R1>(push: IO<R, never, (_: Maybe<Conc<In>>) => IO<R1, readonly [Either<E, Z>, Conc<L>], void>>, __tsplusTrace?: string): Sink<Exclude<R, Scope> | R1, E, In, L, Z>;
 /**
  * Create a sink which enqueues each element into the specified queue.
  * @tsplus static fncts.io.SinkOps fromQueue
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function fromQueue<In>(queue: Lazy<Queue.Enqueue<In>>, __tsplusTrace?: string): Sink<unknown, never, In, never, void>;
+export declare function fromQueue<In>(queue: Lazy<Queue.Enqueue<In>>, __tsplusTrace?: string): Sink<never, never, In, never, void>;
 /**
  * Create a sink which enqueues each element into the specified queue. The
  * queue will be shutdown once the stream is closed.
  * @tsplus static fncts.io.SinkOps fromQueueWithShutdown
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function fromQueueWithShutdown<In>(queue: Lazy<Queue.Enqueue<In>>, __tsplusTrace?: string): Sink<unknown, never, In, never, void>;
+export declare function fromQueueWithShutdown<In>(queue: Lazy<Queue.Enqueue<In>>, __tsplusTrace?: string): Sink<never, never, In, never, void>;
 /**
  * Create a sink which publishes each element to the specified hub.
  * @tsplus static fncts.io.SinkOps fromHub
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function fromHub<In>(hub: Lazy<Hub<In>>, __tsplusTrace?: string): Sink<unknown, never, In, never, void>;
+export declare function fromHub<In>(hub: Lazy<Hub<In>>, __tsplusTrace?: string): Sink<never, never, In, never, void>;
 /**
  * Create a sink which publishes each element to the specified hub. The hub
  * will be shutdown once the stream is closed.
  * @tsplus static fncts.io.SinkOps fromHubWithShutdown
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function fromHubWithShutdown<In>(hub: Lazy<Hub<In>>, __tsplusTrace?: string): Sink<unknown, never, In, never, void>;
+export declare function fromHubWithShutdown<In>(hub: Lazy<Hub<In>>, __tsplusTrace?: string): Sink<never, never, In, never, void>;
 /**
  * Creates a single-value sink produced from an effect
  * @tsplus static fncts.io.SinkOps fromIO
@@ -285,19 +284,19 @@ export declare function fromIO<R, E, Z>(b: Lazy<IO<R, E, Z>>, __tsplusTrace?: st
  * @tsplus static fncts.io.SinkOps halt
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function halt(defect: Lazy<unknown>, __tsplusTrace?: string): Sink<unknown, never, unknown, never, never>;
+export declare function halt(defect: Lazy<unknown>, __tsplusTrace?: string): Sink<never, never, unknown, never, never>;
 /**
  * Creates a sink halting with the specified unchecked value.
  * @tsplus static fncts.io.SinkOps haltNow
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function haltNow(defect: unknown, __tsplusTrace?: string): Sink<unknown, never, unknown, never, never>;
+export declare function haltNow(defect: unknown, __tsplusTrace?: string): Sink<never, never, unknown, never, never>;
 /**
  * Creates a sink containing the first value.
  * @tsplus static fncts.io.SinkOps head
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function head<In>(__tsplusTrace?: string): Sink<unknown, never, In, In, Maybe<In>>;
+export declare function head<In>(__tsplusTrace?: string): Sink<never, never, In, In, Maybe<In>>;
 /**
  * Drains the remaining elements from the stream after the sink finishes
  * @tsplus getter fncts.io.Sink ignoreLeftover
@@ -309,33 +308,33 @@ export declare function ignoreLeftover<R, E, In, L, Z>(self: Sink<R, E, In, L, Z
  * @tsplus static fncts.io.SinkOps last
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function last<In>(__tsplusTrace?: string): Sink<unknown, never, In, In, Maybe<In>>;
+export declare function last<In>(__tsplusTrace?: string): Sink<never, never, In, In, Maybe<In>>;
 /**
  * Creates a sink that does not consume any input but provides the given chunk
  * as its leftovers
  * @tsplus static fncts.io.SinkOps leftover
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function leftover<L>(c: Lazy<Conc<L>>, __tsplusTrace?: string): Sink<unknown, never, unknown, L, void>;
+export declare function leftover<L>(c: Lazy<Conc<L>>, __tsplusTrace?: string): Sink<never, never, unknown, L, void>;
 /**
  * Logs the specified message at the current log level.
  * @tsplus static fncts.io.SinkOps log
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function log(message: Lazy<string>, __tsplusTrace?: string): Sink<unknown, never, unknown, never, void>;
+export declare function log(message: Lazy<string>, __tsplusTrace?: string): Sink<never, never, unknown, never, void>;
 /**
  * A sink that collects all of its inputs into a chunk.
  * @tsplus static fncts.io.SinkOps collectAll
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function makeCollectAll<In>(): Sink<unknown, never, In, never, Conc<In>>;
+export declare function makeCollectAll<In>(__tsplusTrace?: string): Sink<never, never, In, never, Conc<In>>;
 /**
  * A sink that collects first `n` elements into a chunk. Note that the chunk
  * is preallocated and must fit in memory.
  * @tsplus static fncts.io.SinkOps collectAllN
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function makeCollectAllN<In>(n: Lazy<number>): Sink<unknown, never, In, In, Conc<In>>;
+export declare function makeCollectAllN<In>(n: Lazy<number>, __tsplusTrace?: string): Sink<never, never, In, In, Conc<In>>;
 /**
  * A sink that executes the provided effectful function for every element fed to it.
  * @tsplus static fncts.io.SinkOps foreach
@@ -369,7 +368,7 @@ export declare function makeForeachChunkWhile<R, E, In>(f: (chunk: Conc<In>) =>
  * @tsplus static fncts.io.SinkOps fold
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function makeFold<In, S>(z: Lazy<S>, contFn: Predicate<S>, f: (s: S, inp: In) => S, __tsplusTrace?: string): Sink<unknown, never, In, In, S>;
+export declare function makeFold<In, S>(z: Lazy<S>, contFn: Predicate<S>, f: (s: S, inp: In) => S, __tsplusTrace?: string): Sink<never, never, In, In, S>;
 /**
  * Creates a sink that folds elements of type `In` into a structure of type
  * `S` until `max` elements have been folded.
@@ -378,7 +377,7 @@ export declare function makeFold<In, S>(z: Lazy<S>, contFn: Predicate<S>, f: (s:
  * @tsplus static fncts.io.SinkOps foldUntil
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function makeFoldUntil<In, S>(z: Lazy<S>, max: Lazy<number>, f: (s: S, inp: In) => S, __tsplusTrace?: string): Sink<unknown, never, In, In, S>;
+export declare function makeFoldUntil<In, S>(z: Lazy<S>, max: Lazy<number>, f: (s: S, inp: In) => S, __tsplusTrace?: string): Sink<never, never, In, In, S>;
 /**
  * A sink that folds its input chunks with the provided function, termination
  * predicate and initial state. `contFn` condition is checked only for the
@@ -387,7 +386,7 @@ export declare function makeFoldUntil<In, S>(z: Lazy<S>, max: Lazy<number>, f: (
  * @tsplus static fncts.io.SinkOps foldChunks
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function makeFoldChunks<In, S>(z: Lazy<S>, contFn: Predicate<S>, f: (s: S, inp: Conc<In>) => S, __tsplusTrace?: string): Sink<unknown, never, In, never, S>;
+export declare function makeFoldChunks<In, S>(z: Lazy<S>, contFn: Predicate<S>, f: (s: S, inp: Conc<In>) => S, __tsplusTrace?: string): Sink<never, never, In, never, S>;
 /**
  * A sink that effectfully folds its input chunks with the provided function,
  * termination predicate and initial state. `contFn` condition is checked only
@@ -402,14 +401,14 @@ export declare function makeFoldChunksIO<Env, Err, In, S>(z: Lazy<S>, contFn: Pr
  * @tsplus static fncts.io.SinkOps foldLeft
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function makeFoldLeft<In, S>(z: Lazy<S>, f: (s: S, inp: In) => S): Sink<unknown, never, In, never, S>;
+export declare function makeFoldLeft<In, S>(z: Lazy<S>, f: (s: S, inp: In) => S, __tsplusTrace?: string): Sink<never, never, In, never, S>;
 /**
  * A sink that folds its input chunks with the provided function and initial
  * state. `f` must preserve chunking-invariance.
  * @tsplus static fncts.io.SinkOps foldLeftChunks
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function makeFoldLeftChunks<In, S>(z: Lazy<S>, f: (s: S, inp: Conc<In>) => S): Sink<unknown, never, In, never, S>;
+export declare function makeFoldLeftChunks<In, S>(z: Lazy<S>, f: (s: S, inp: Conc<In>) => S, __tsplusTrace?: string): Sink<never, never, In, never, S>;
 /**
  * A sink that effectfully folds its input chunks with the provided function
  * and initial state. `f` must preserve chunking-invariance.
@@ -430,7 +429,7 @@ export declare function makeFoldLeftIO<R, E, In, S>(z: Lazy<S>, f: (s: S, inp: I
  * @tsplus static fncts.io.SinkOps foldIO
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function makeFoldIO<R, E, In, S>(z: Lazy<S>, contFn: Predicate<S>, f: (s: S, inp: In) => IO<R, E, S>): Sink<R, E, In, In, S>;
+export declare function makeFoldIO<R, E, In, S>(z: Lazy<S>, contFn: Predicate<S>, f: (s: S, inp: In) => IO<R, E, S>, __tsplusTrace?: string): Sink<R, E, In, In, S>;
 /**
  * Creates a sink that effectfully folds elements of type `In` into a
  * structure of type `S` until `max` elements have been folded.
@@ -459,7 +458,7 @@ export declare function makeFoldUntilIO<R, E, In, S>(z: Lazy<S>, max: Lazy<numbe
  * @tsplus static fncts.io.SinkOps foldWeightedDecompose
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function makeFoldWeightedDecompose<In, S>(z: Lazy<S>, costFn: (s: S, inp: In) => number, max: Lazy<number>, decompose: (inp: In) => Conc<In>, f: (s: S, inp: In) => S, __tsplusTrace?: string): Sink<unknown, never, In, In, S>;
+export declare function makeFoldWeightedDecompose<In, S>(z: Lazy<S>, costFn: (s: S, inp: In) => number, max: Lazy<number>, decompose: (inp: In) => Conc<In>, f: (s: S, inp: In) => S, __tsplusTrace?: string): Sink<never, never, In, In, S>;
 /**
  * Creates a sink that effectfully folds elements of type `In` into a
  * structure of type `S`, until `max` worth of elements (determined by the
@@ -474,7 +473,7 @@ export declare function makeFoldWeightedDecompose<In, S>(z: Lazy<S>, costFn: (s:
  * @tsplus static fncts.io.SinkOps foldWeightedDecomposeIO
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function makeFoldWeightedDecomposeIO<R, E, In, S, R1, E1, R2, E2>(z: Lazy<S>, costFn: (s: S, inp: In) => IO<R1, E1, number>, max: Lazy<number>, decompose: (inp: In) => IO<R2, E2, Conc<In>>, f: (s: S, inp: In) => IO<R, E, S>, __tsplusTrace?: string): Sink<R & R1 & R2, E | E1 | E2, In, In, S>;
+export declare function makeFoldWeightedDecomposeIO<R, E, In, S, R1, E1, R2, E2>(z: Lazy<S>, costFn: (s: S, inp: In) => IO<R1, E1, number>, max: Lazy<number>, decompose: (inp: In) => IO<R2, E2, Conc<In>>, f: (s: S, inp: In) => IO<R, E, S>, __tsplusTrace?: string): Sink<R | R1 | R2, E | E1 | E2, In, In, S>;
 /**
  * Creates a sink that folds elements of type `In` into a structure of type
  * `S`, until `max` worth of elements (determined by the `costFn`) have been
@@ -485,7 +484,7 @@ export declare function makeFoldWeightedDecomposeIO<R, E, In, S, R1, E1, R2, E2>
  * @tsplus static fncts.io.SinkOps foldWeighted
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function makeFoldWeighted<In, S>(z: Lazy<S>, costFn: (s: S, inp: In) => number, max: Lazy<number>, f: (s: S, inp: In) => S, __tsplusTrace?: string): Sink<unknown, never, In, In, S>;
+export declare function makeFoldWeighted<In, S>(z: Lazy<S>, costFn: (s: S, inp: In) => number, max: Lazy<number>, f: (s: S, inp: In) => S, __tsplusTrace?: string): Sink<never, never, In, In, S>;
 /**
  * Creates a sink that effectfully folds elements of type `In` into a
  * structure of type `S`, until `max` worth of elements (determined by the
@@ -496,7 +495,7 @@ export declare function makeFoldWeighted<In, S>(z: Lazy<S>, costFn: (s: S, inp:
  * @tsplus static fncts.io.SinkOps foldWeightedIO
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function makeFoldWeightedIO<R, E, In, S, R1, E1>(z: Lazy<S>, costFn: (s: S, inp: In) => IO<R, E, number>, max: Lazy<number>, f: (s: S, inp: In) => IO<R1, E1, S>, __tsplusTrace?: string): Sink<R & R1, E | E1, In, In, S>;
+export declare function makeFoldWeightedIO<R, E, In, S, R1, E1>(z: Lazy<S>, costFn: (s: S, inp: In) => IO<R, E, number>, max: Lazy<number>, f: (s: S, inp: In) => IO<R1, E1, S>, __tsplusTrace?: string): Sink<R | R1, E | E1, In, In, S>;
 /**
  * Transforms this sink's result.
  * @tsplus fluent fncts.io.Sink map
@@ -514,7 +513,7 @@ export declare function mapError_<R, E, In, L, Z, E1>(self: Sink<R, E, In, L, Z>
  * @tsplus fluent fncts.io.Sink mapIO
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function mapIO_<R, E, In, L, Z, R1, E1, Z1>(self: Sink<R, E, In, L, Z>, f: (z: Z) => IO<R1, E1, Z1>, __tsplusTrace?: string): Sink<R & R1, E | E1, In, L, Z1>;
+export declare function mapIO_<R, E, In, L, Z, R1, E1, Z1>(self: Sink<R, E, In, L, Z>, f: (z: Z) => IO<R1, E1, Z1>, __tsplusTrace?: string): Sink<R | R1, E | E1, In, L, Z1>;
 /**
  * Runs this sink until it yields a result, then uses that result to create
  * another sink from the provided function which will continue to run until it
@@ -524,54 +523,54 @@ export declare function mapIO_<R, E, In, L, Z, R1, E1, Z1>(self: Sink<R, E, In,
  * @tsplus fluent fncts.io.Sink matchSink
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function matchSink_<R, E, In, L, Z, R1, E1, In1 extends In, L1, Z1, R2, E2, In2 extends In, L2, Z2>(self: Sink<R, E, In, L, Z>, onFailure: (e: E) => Sink<R1, E1, In1, L1, Z1>, onSuccess: (z: Z) => Sink<R2, E2, In2, L2, Z2>, __tsplusTrace?: string): Sink<R & R1 & R2, E1 | E2, In1 & In2, L | L1 | L2, Z1 | Z2>;
+export declare function matchSink_<R, E, In, L, Z, R1, E1, In1 extends In, L1, Z1, R2, E2, In2 extends In, L2, Z2>(self: Sink<R, E, In, L, Z>, onFailure: (e: E) => Sink<R1, E1, In1, L1, Z1>, onSuccess: (z: Z) => Sink<R2, E2, In2, L2, Z2>, __tsplusTrace?: string): Sink<R | R1 | R2, E1 | E2, In1 & In2, L | L1 | L2, Z1 | Z2>;
 /**
  * Switch to another sink in case of failure
  * @tsplus fluent fncts.io.Sink orElse
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function orElse<R, E, In, L, Z, R1, E1, In1, L1, Z1>(self: Sink<R, E, In, L, Z>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): Sink<R & R1, E | E1, In & In1, L | L1, Z | Z1>;
+export declare function orElse<R, E, In, L, Z, R1, E1, In1, L1, Z1>(self: Sink<R, E, In, L, Z>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): Sink<R | R1, E | E1, In & In1, L | L1, Z | Z1>;
 /**
  * Provides the sink with its required environment, which eliminates its
  * dependency on `R`.
  * @tsplus fluent fncts.io.Sink provideEnvironment
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function provideEnvironment<R, E, In, L, Z>(self: Sink<R, E, In, L, Z>, r: Lazy<Environment<R>>, __tsplusTrace?: string): Sink<unknown, E, In, L, Z>;
+export declare function provideEnvironment<R, E, In, L, Z>(self: Sink<R, E, In, L, Z>, r: Lazy<Environment<R>>, __tsplusTrace?: string): Sink<never, E, In, L, Z>;
 /**
  * Runs both sinks in parallel on the input, returning the result or the
  * error from the one that finishes first.
  * @tsplus fluent fncts.io.Sink race
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function race<R, E, In, L, Z, R1, E1, In1, L1, Z1>(self: Sink<R, E, In, L, Z>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): Sink<R & R1, E | E1, In & In1, L | L1, Z | Z1>;
+export declare function race<R, E, In, L, Z, R1, E1, In1, L1, Z1>(self: Sink<R, E, In, L, Z>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): Sink<R | R1, E | E1, In & In1, L | L1, Z | Z1>;
 /**
  * Runs both sinks in parallel on the input, returning the result or the error
  * from the one that finishes first.
  * @tsplus fluent fncts.io.Sink raceBoth
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function raceBoth<R, E, In, L, Z, R1, E1, In1, L1, Z1>(self: Sink<R, E, In, L, Z>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, capacity?: Lazy<number>, __tsplusTrace?: string): Sink<R & R1, E | E1, In & In1, L | L1, Either<Z, Z1>>;
+export declare function raceBoth<R, E, In, L, Z, R1, E1, In1, L1, Z1>(self: Sink<R, E, In, L, Z>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, capacity?: Lazy<number>, __tsplusTrace?: string): Sink<R | R1, E | E1, In & In1, L | L1, Either<Z, Z1>>;
 /**
  * Runs both sinks in parallel on the input, using the specified merge
  * function as soon as one result or the other has been computed.
  * @tsplus fluent fncts.io.Sink raceWith
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function raceWith<R, E, In, L, Z, R1, E1, In1, L1, Z1, R2, E2, Z2, R3, E3, Z3>(self: Sink<R, E, In, L, Z>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, leftDone: (exit: Exit<E, Z>) => MergeDecision<R1, E1, Z1, E2, Z2>, rightDone: (exit: Exit<E1, Z1>) => MergeDecision<R, E, Z, E3, Z3>, capacity?: Lazy<number>, __tsplusTrace?: string): Sink<R & R1 & R2 & R3, E2 | E3, In & In1, L | L1, Z2 | Z3>;
+export declare function raceWith<R, E, In, L, Z, R1, E1, In1, L1, Z1, R2, E2, Z2, R3, E3, Z3>(self: Sink<R, E, In, L, Z>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, leftDone: (exit: Exit<E, Z>) => MergeDecision<R1, E1, Z1, E2, Z2>, rightDone: (exit: Exit<E1, Z1>) => MergeDecision<R, E, Z, E3, Z3>, capacity?: Lazy<number>, __tsplusTrace?: string): Sink<R | R1 | R2 | R3, E2 | E3, In & In1, L | L1, Z2 | Z3>;
 /**
  * Accesses the specified service in the environment of the effect.
  * @tsplus static fncts.io.SinkOps service
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function service<S>(/** @tsplus auto */ tag: Tag<S>): Sink<Has<S>, never, unknown, never, S>;
+export declare function service<S>(/** @tsplus auto */ tag: Tag<S>): Sink<S, never, unknown, never, S>;
 /**
  * Accesses the specified service in the environment of the sink.
  * @tsplus static fncts.io.SinkOps serviceWith
  * @tsplus location "@fncts/io/Sink/api"
  */
 export declare function serviceWith<S, Z>(f: (service: S) => Z, 
-/** @tsplus auto */ tag: Tag<S>): Sink<Has<S>, never, unknown, never, Z>;
+/** @tsplus auto */ tag: Tag<S>): Sink<S, never, unknown, never, Z>;
 /**
  * Accesses the specified service in the environment of the sink in the
  * context of an effect.
@@ -579,7 +578,7 @@ export declare function serviceWith<S, Z>(f: (service: S) => Z,
  * @tsplus location "@fncts/io/Sink/api"
  */
 export declare function serviceWithIO<S, R, E, Z>(f: (service: S) => IO<R, E, Z>, 
-/** @tsplus auto */ tag: Tag<S>): Sink<Has<S> & R, E, unknown, never, Z>;
+/** @tsplus auto */ tag: Tag<S>): Sink<S | R, E, unknown, never, Z>;
 /**
  * Accesses the specified service in the environment of the sink in the
  * context of a sink.
@@ -587,7 +586,7 @@ export declare function serviceWithIO<S, R, E, Z>(f: (service: S) => IO<R, E, Z>
  * @tsplus location "@fncts/io/Sink/api"
  */
 export declare function serviceWithSink<S, R, E, In, L, Z>(f: (service: S) => Sink<R, E, In, L, Z>, 
-/** @tsplus auto */ tag: Tag<S>): Sink<Has<S> & R, E, In, L, Z>;
+/** @tsplus auto */ tag: Tag<S>): Sink<S | R, E, In, L, Z>;
 /**
  * Splits the sink on the specified predicate, returning a new sink that
  * consumes elements until an element after the first satisfies the specified
@@ -601,20 +600,20 @@ export declare function splitWhere<R, E, In, L extends In, Z>(self: Sink<R, E, I
  * @tsplus static fncts.io.SinkOps succeed
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function succeed<Z>(z: Lazy<Z>, __tsplusTrace?: string): Sink<unknown, never, unknown, never, Z>;
+export declare function succeed<Z>(z: Lazy<Z>, __tsplusTrace?: string): Sink<never, never, unknown, never, Z>;
 /**
  * A sink that immediately ends with the specified value.
  * @tsplus static fncts.io.SinkOps succeedNow
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function succeedNow<Z>(z: Z, __tsplusTrace?: string): Sink<unknown, never, unknown, never, Z>;
+export declare function succeedNow<Z>(z: Z, __tsplusTrace?: string): Sink<never, never, unknown, never, Z>;
 /**
  * Summarize a sink by running an effect when the sink starts and again when
  * it completes
  * @tsplus fluent fncts.io.Sink summarized
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function summarized<R, E, In, L, Z, R1, E1, B, C>(self: Sink<R, E, In, L, Z>, summary: Lazy<IO<R1, E1, B>>, f: (b1: B, b2: B) => C, __tsplusTrace?: string): Sink<R & R1, E | E1, In, L, readonly [Z, C]>;
+export declare function summarized<R, E, In, L, Z, R1, E1, B, C>(self: Sink<R, E, In, L, Z>, summary: Lazy<IO<R1, E1, B>>, f: (b1: B, b2: B) => C, __tsplusTrace?: string): Sink<R | R1, E | E1, In, L, readonly [Z, C]>;
 /**
  * @tsplus getter fncts.io.Sink timed
  * @tsplus location "@fncts/io/Sink/api"
@@ -625,13 +624,13 @@ export declare function timed<R, E, In, L, Z>(self: Sink<R, E, In, L, Z>, __tspl
  * @tsplus static fncts.io.SinkOps unwrap
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function unwrap<R, E, R1, E1, In, L, Z>(io: Lazy<IO<R, E, Sink<R1, E1, In, L, Z>>>): Sink<R & R1, E | E1, In, L, Z>;
+export declare function unwrap<R, E, R1, E1, In, L, Z>(io: Lazy<IO<R, E, Sink<R1, E1, In, L, Z>>>, __tsplusTrace?: string): Sink<R | R1, E | E1, In, L, Z>;
 /**
  * Creates a sink produced from a scoped effect.
  * @tsplus static fncts.io.SinkOps unwrapScoped
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function unwrapScoped<R, E, R1, E1, In, L, Z>(scoped: Lazy<IO<Has<Scope> & R, E, Sink<R1, E1, In, L, Z>>>, __tsplusTrace?: string): Sink<R & R1, E | E1, In, L, Z>;
+export declare function unwrapScoped<R, E, R1, E1, In, L, Z>(scoped: Lazy<IO<R, E, Sink<R1, E1, In, L, Z>>>, __tsplusTrace?: string): Sink<Exclude<R, Scope> | R1, E | E1, In, L, Z>;
 /**
  * Feeds inputs to this sink until it yields a result, then switches over to
  * the provided sink until it yields a result, finally combining the two
@@ -639,14 +638,14 @@ export declare function unwrapScoped<R, E, R1, E1, In, L, Z>(scoped: Lazy<IO<Has
  * @tsplus fluent fncts.io.Sink zip
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function zip<R, E, In, L, Z, R1, E1, In1 extends In, L1 extends L, Z1>(self: Sink<R, E, In, L, Z>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): Sink<R & R1, E | E1, In & In1, L | L1, readonly [Z, Z1]>;
+export declare function zip<R, E, In, L, Z, R1, E1, In1 extends In, L1 extends L, Z1>(self: Sink<R, E, In, L, Z>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): Sink<R | R1, E | E1, In & In1, L | L1, readonly [Z, Z1]>;
 /**
  * Runs both sinks in parallel on the input and combines the results in a
  * tuple.
  * @tsplus fluent fncts.io.Sink zipC
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function zipC<R, E, In, L, Z, R1, E1, In1 extends In, L1 extends L, Z1>(self: Sink<R, E, In, L, Z>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): Sink<R & R1, E | E1, In & In1, L | L1, readonly [Z, Z1]>;
+export declare function zipC<R, E, In, L, Z, R1, E1, In1 extends In, L1 extends L, Z1>(self: Sink<R, E, In, L, Z>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): Sink<R | R1, E | E1, In & In1, L | L1, readonly [Z, Z1]>;
 /**
  * Feeds inputs to this sink until it yields a result, then switches over to
  * the provided sink until it yields a result, finally combining the two
@@ -654,11 +653,11 @@ export declare function zipC<R, E, In, L, Z, R1, E1, In1 extends In, L1 extends
  * @tsplus fluent fncts.io.Sink zipWith
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function zipWith<R, E, In, L, Z, R1, E1, In1 extends In, L1 extends L, Z1, Z2>(self: Lazy<Sink<R, E, In, L, Z>>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, f: (z: Z, z1: Z1) => Z2, __tsplusTrace?: string): Sink<R & R1, E | E1, In & In1, L | L1, Z2>;
+export declare function zipWith<R, E, In, L, Z, R1, E1, In1 extends In, L1 extends L, Z1, Z2>(self: Lazy<Sink<R, E, In, L, Z>>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, f: (z: Z, z1: Z1) => Z2, __tsplusTrace?: string): Sink<R | R1, E | E1, In & In1, L | L1, Z2>;
 /**
  * Runs both sinks in parallel on the input and combines the results using the
  * provided function.
  * @tsplus fluent fncts.io.Sink zipWithC
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function zipWithC<R, E, In, L, Z, R1, E1, In1, L1, Z1, Z2>(self: Lazy<Sink<R, E, In, L, Z>>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, f: (z: Z, z1: Z1) => Z2, __tsplusTrace?: string): Sink<R & R1, E | E1, In & In1, L | L1, Z2>;
+export declare function zipWithC<R, E, In, L, Z, R1, E1, In1, L1, Z1, Z2>(self: Lazy<Sink<R, E, In, L, Z>>, that: Lazy<Sink<R1, E1, In1, L1, Z1>>, f: (z: Z, z1: Z1) => Z2, __tsplusTrace?: string): Sink<R | R1, E | E1, In & In1, L | L1, Z2>;

package/State/api.d.ts

@@ -1,7 +1,6 @@
 import { UIO } from "@fncts/io/IO/definition";
-import { Tag } from "@fncts/base/data/Tag";
+import { Tag } from "@fncts/base/data/Tag/definition";
 import { Layer } from "@fncts/io/Layer";
-import { Has } from "@fncts/base/typeclass/Has";
 import type { State } from "./definition.js";
 /**
  * @tsplus getter fncts.io.State get
@@ -12,7 +11,7 @@ export declare function get_<S>(self: State<S>, __tsplusTrace?: string): UIO<S>;
  * @tsplus static fncts.io.StateOps initial
  * @tsplus location "@fncts/io/State/api"
  */
-export declare function initial<S>(s: S, tag: Tag<State<S>>): Layer<unknown, never, Has<State<S>>>;
+export declare function initial<S>(s: S, tag: Tag<State<S>>, __tsplusTrace?: string): Layer<never, never, State<S>>;
 /**
  * @tsplus fluent fncts.io.State set
  * @tsplus location "@fncts/io/State/api"

package/Stream/api/zipAllWith.d.ts

@@ -1,10 +1,10 @@
 import { Stream } from "@fncts/io/Stream/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
 import { IO } from "@fncts/io/IO/definition";
-import { Maybe } from "@fncts/base/data/Maybe";
-import { Exit } from "@fncts/base/data/Exit";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Exit } from "@fncts/base/data/Exit/definition";
 /**
  * @tsplus fluent fncts.io.Stream zipAllWith
  * @tsplus location "@fncts/io/Stream/api/zipAllWith"
  */
-export declare function zipAllWith_<R, E, A, R1, E1, B, C, D, F>(self: Stream<R, E, A>, that: Stream<R1, E1, B>, left: (a: A) => C, right: (b: B) => D, both: (a: A, b: B) => F): Stream<R & R1, E | E1, C | D | F>;
+export declare function zipAllWith_<R, E, A, R1, E1, B, C, D, F>(self: Stream<R, E, A>, that: Stream<R1, E1, B>, left: (a: A) => C, right: (b: B) => D, both: (a: A, b: B) => F, __tsplusTrace?: string): Stream<R | R1, E | E1, C | D | F>;

package/Stream/api/zipWith.d.ts

@@ -3,4 +3,4 @@ import { Stream } from "@fncts/io/Stream/definition";
  * @tsplus fluent fncts.io.Stream zipWith
  * @tsplus location "@fncts/io/Stream/api/zipWith"
  */
-export declare function zipWith_<R, E, A, R1, E1, B, C>(self: Stream<R, E, A>, that: Stream<R1, E1, B>, f: (a: A, b: B) => C): Stream<R & R1, E | E1, C>;
+export declare function zipWith_<R, E, A, R1, E1, B, C>(self: Stream<R, E, A>, that: Stream<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): Stream<R | R1, E | E1, C>;