@fncts/test 0.0.12 → 0.0.13

package/control/Gen/api.d.ts

@@ -2,7 +2,6 @@ import { Lazy } from "@fncts/base/data/function/definition";
 import { Refinement } from "@fncts/base/data/Refinement/definition";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
 import { IO, URIO } from "@fncts/io/IO";
-import { Has } from "@fncts/base/typeclass";
 import { Stream } from "@fncts/io/Stream";
 import { Maybe } from "@fncts/base/data/Maybe";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
@@ -15,17 +14,17 @@ import { Gen } from "./definition.js";
  * @tsplus static fncts.test.GenOps anyBigInt
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare const anyBigInt: Gen<unknown, bigint>;
+export declare const anyBigInt: Gen<never, bigint>;
 /**
  * @tsplus static fncts.test.GenOps anyDouble
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare const anyDouble: Gen<unknown, number>;
+export declare const anyDouble: Gen<never, number>;
 /**
  * @tsplus static fncts.test.GenOps anyInt
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare const anyInt: Gen<unknown, number>;
+export declare const anyInt: Gen<never, number>;
 /**
  * @tsplus static fncts.test.GenOps bounded
  * @tsplus location "@fncts/test/control/Gen/api"
@@ -35,12 +34,12 @@ export declare function bounded<R, A>(min: number, max: number, f: (n: number) =
  * @tsplus static fncts.test.GenOps constant
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare function constant<A>(a: A): Gen<unknown, A>;
+export declare function constant<A>(a: A): Gen<never, A>;
 /**
  * @tsplus fluent fncts.test.Gen flatMap
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare function flatMap_<R, A, R1, B>(ma: Gen<R, A>, f: (a: A) => Gen<R1, B>): Gen<R & R1, B>;
+export declare function flatMap_<R, A, R1, B>(ma: Gen<R, A>, f: (a: A) => Gen<R1, B>): Gen<R | R1, B>;
 /**
  * @tsplus static fncts.test.GenOps defer
  * @tsplus location "@fncts/test/control/Gen/api"
@@ -50,7 +49,7 @@ export declare function defer<R, A>(gen: Lazy<Gen<R, A>>): Gen<R, A>;
  * @tsplus static fncts.test.GenOps empty
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare const empty: Gen<unknown, never>;
+export declare const empty: Gen<never, never>;
 /**
  * @tsplus fluent fncts.test.Gen filter
  * @tsplus location "@fncts/test/control/Gen/api"
@@ -66,7 +65,7 @@ export declare function filterNot_<R, A>(fa: Gen<R, A>, p: Predicate<A>): Gen<R,
  * @tsplus getter fncts.test.Gen flatten
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare function flatten<R, R1, A>(mma: Gen<R, Gen<R1, A>>): Gen<R & R1, A>;
+export declare function flatten<R, R1, A>(mma: Gen<R, Gen<R1, A>>): Gen<R | R1, A>;
 /**
  * @tsplus static fncts.test.GenOps fromIO
  * @tsplus location "@fncts/test/control/Gen/api"
@@ -81,7 +80,7 @@ export declare function fromIOSample<R, A>(effect: IO<R, never, Sample<R, A>>):
  * @tsplus static fncts.test.GenOps int
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare function int(constraints?: NumberConstraints): Gen<unknown, number>;
+export declare function int(constraints?: NumberConstraints): Gen<never, number>;
 /**
  * @tsplus fluent fncts.test.Gen map
  * @tsplus location "@fncts/test/control/Gen/api"
@@ -91,22 +90,22 @@ export declare function map_<R, A, B>(self: Gen<R, A>, f: (a: A) => B): Gen<R, B
  * @tsplus fluent fncts.test.Gen mapIO
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare function mapIO_<R, A, R1, B>(self: Gen<R, A>, f: (a: A) => IO<R1, never, B>): Gen<R & R1, B>;
+export declare function mapIO_<R, A, R1, B>(self: Gen<R, A>, f: (a: A) => IO<R1, never, B>): Gen<R | R1, B>;
 /**
  * @tsplus static fncts.test.GenOps exponential
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare const exponential: Gen<unknown, number>;
+export declare const exponential: Gen<never, number>;
 /**
  * @tsplus static fncts.test.GenOps size
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare const size: Gen<Has<Sized>, number>;
+export declare const size: Gen<Sized, number>;
 /**
  * @tsplus static fncts.test.GenOps medium
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare function medium<R, A>(f: (n: number) => Gen<R, A>, min?: number): Gen<R & Has<Sized>, A>;
+export declare function medium<R, A>(f: (n: number) => Gen<R, A>, min?: number): Gen<R | Sized, A>;
 /**
  * @tsplus static fncts.test.GenOps memo
  * @tsplus location "@fncts/test/control/Gen/api"
@@ -126,22 +125,22 @@ export declare function oneOf<A extends ReadonlyArray<Gen<any, any>>>(...gens: A
  * @tsplus fluent fncts.test.Gen reshrink
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare function reshrink_<R, A, R1, B>(gen: Gen<R, A>, f: (a: A) => Sample<R1, B>): Gen<R & R1, B>;
+export declare function reshrink_<R, A, R1, B>(gen: Gen<R, A>, f: (a: A) => Sample<R1, B>): Gen<R | R1, B>;
 /**
  * @tsplus static fncts.test.GenOps sized
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare function sized<R, A>(f: (size: number) => Gen<R, A>): Gen<R & Has<Sized>, A>;
+export declare function sized<R, A>(f: (size: number) => Gen<R, A>): Gen<R | Sized, A>;
 /**
  * @tsplus static fncts.test.GenOps small
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare function small<R, A>(f: (size: number) => Gen<R, A>, min?: number): Gen<R & Has<Sized>, A>;
+export declare function small<R, A>(f: (size: number) => Gen<R, A>, min?: number): Gen<R | Sized, A>;
 /**
  * @tsplus static fncts.test.GenOps unfoldGen
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare function unfoldGen<S, R, A>(s: S, f: (s: S) => Gen<R, readonly [S, A]>): Gen<R & Has<Sized>, Conc<A>>;
+export declare function unfoldGen<S, R, A>(s: S, f: (s: S) => Gen<R, readonly [S, A]>): Gen<R | Sized, Conc<A>>;
 /**
  * @tsplus static fncts.test.GenOps unfoldGenN
  * @tsplus location "@fncts/test/control/Gen/api"
@@ -151,12 +150,12 @@ export declare function unfoldGenN<S, R, A>(n: number, s: S, f: (s: S) => Gen<R,
  * @tsplus static fncts.test.GenOps uniform
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare const uniform: Gen<unknown, number>;
+export declare const uniform: Gen<never, number>;
 /**
  * @tsplus static fncts.test.GenOps unwrap
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare function unwrap<R, R1, A>(effect: URIO<R, Gen<R1, A>>): Gen<R & R1, A>;
+export declare function unwrap<R, R1, A>(effect: URIO<R, Gen<R1, A>>): Gen<R | R1, A>;
 /**
  * @tsplus static fncts.test.GenOps weighted
  * @tsplus location "@fncts/test/control/Gen/api"
@@ -166,4 +165,4 @@ export declare function weighted<R, A>(...gens: ReadonlyArray<readonly [Gen<R, A
  * @tsplus fluent fncts.test.Gen zipWith
  * @tsplus location "@fncts/test/control/Gen/api"
  */
-export declare function zipWith_<R, A, R1, B, C>(self: Gen<R, A>, that: Gen<R1, B>, f: (a: A, b: B) => C): Gen<R & R1, C>;
+export declare function zipWith_<R, A, R1, B, C>(self: Gen<R, A>, that: Gen<R1, B>, f: (a: A, b: B) => C): Gen<R | R1, C>;

package/control/Gen/definition.d.ts

@@ -7,5 +7,7 @@ import type { Sample } from "../Sample.js";
  */
 export declare class Gen<R, A> {
     readonly sample: Stream<R, never, Maybe<Sample<R, A>>>;
+    _R: () => R;
+    _A: () => A;
     constructor(sample: Stream<R, never, Maybe<Sample<R, A>>>);
 }

package/control/Live/definition.d.ts

@@ -1,7 +1,5 @@
 import { IO } from "@fncts/io/IO";
 import { Layer } from "@fncts/io/Layer";
-import { Has } from "@fncts/base/typeclass";
-import type { Erase } from "@fncts/typelevel/Intersection";
 import { IOEnv } from "@fncts/io/IOEnv";
 /**
  * @tsplus static fncts.test.LiveOps Tag
@@ -13,12 +11,12 @@ export declare const LiveTag: import("@fncts/base/data/Tag").Tag<Live>;
  */
 export declare abstract class Live {
     abstract provide<R, E, A>(io: IO<R, E, A>): IO<R, E, A>;
-    static Default: Layer<IOEnv, never, Has<Live>>;
-    static Live<R extends Has<Live>, E, A>(io: IO<R, E, A>): IO<R & Has<Live>, E, A>;
+    static Default: Layer<IOEnv, never, Live>;
+    static Live<R extends Live, E, A>(io: IO<R, E, A>): IO<R | Live, E, A>;
 }
 /**
  * @tsplus static fncts.test.LiveOps withLive
  * @tsplus location "@fncts/test/control/Live/definition"
  */
-export declare function withLive_<R, E, A, E1, B>(io: IO<R, E, A>, f: (_: IO<unknown, E, A>) => IO<IOEnv, E1, B>): IO<Erase<R, Has<Live>>, E | E1, B>;
-export declare function withLive<R extends Has<Live>, E, A>(io: IO<R, E, A>): <E1, B>(f: (_: IO<R, E, A>) => import("@fncts/io/IO").IO<R, E1, B>) => import("@fncts/io/IO").IO<R & import("@fncts/base/typeclass").Has<Live>, E1, B>;
+export declare function withLive_<R, E, A, E1, B>(io: IO<R, E, A>, f: (_: IO<never, E, A>) => IO<IOEnv, E1, B>): IO<Exclude<R, Live>, E | E1, B>;
+export declare function withLive<R extends Live, E, A>(io: IO<R, E, A>): <E1, B>(f: (_: IO<R, E, A>) => import("@fncts/io/IO").IO<R, E1, B>) => import("@fncts/io/IO").IO<Live | R, E1, B>;

package/control/RunnableSpec.d.ts

@@ -1,12 +1,11 @@
-import { URIO, IO } from "@fncts/io/IO";
-import { Has } from "@fncts/base/typeclass";
+import { URIO } from "@fncts/io/IO";
 import type { Spec } from "@fncts/test/control/Spec";
 import type { TestArgs } from "@fncts/test/data/TestArgs";
 import { AbstractRunnableSpec } from "@fncts/test/control/AbstractRunnableSpec";
 import { TestLogger } from "@fncts/test/control/TestLogger";
 export declare abstract class RunnableSpec<R, E> extends AbstractRunnableSpec<R, E> {
     readonly _tag = "RunnableSpec";
-    run(spec: Spec<R, E>): URIO<Has<TestLogger>, number>;
+    run(spec: Spec<R, E>): URIO<TestLogger, number>;
     main(_args?: TestArgs): void;
 }
 export declare function isRunnableSpec(u: unknown): u is RunnableSpec<unknown, unknown>;

package/control/Sample/api.d.ts

@@ -11,7 +11,7 @@ import { Sample } from "./definition.js";
  * @tsplus fluent fncts.test.Sample flatMap
  * @tsplus location "@fncts/test/control/Sample/api"
  */
-export declare function flatMap_<R, A, R1, B>(ma: Sample<R, A>, f: (a: A) => Sample<R1, B>): Sample<R & R1, B>;
+export declare function flatMap_<R, A, R1, B>(ma: Sample<R, A>, f: (a: A) => Sample<R1, B>): Sample<R | R1, B>;
 /**
  * @tsplus fluent fncts.test.Sample filter
  * @tsplus location "@fncts/test/control/Sample/api"
@@ -21,7 +21,7 @@ export declare function filter_<R, A>(ma: Sample<R, A>, f: Predicate<A>): Stream
  * @tsplus fluent fncts.test.Sample foreach
  * @tsplus location "@fncts/test/control/Sample/api"
  */
-export declare function foreach_<R, A, R1, B>(ma: Sample<R, A>, f: (a: A) => IO<R1, never, B>): IO<R & R1, never, Sample<R & R1, B>>;
+export declare function foreach_<R, A, R1, B>(ma: Sample<R, A>, f: (a: A) => IO<R1, never, B>): IO<R | R1, never, Sample<R | R1, B>>;
 /**
  * @tsplus fluent fncts.test.Sample map
  * @tsplus location "@fncts/test/control/Sample/api"
@@ -41,39 +41,39 @@ export declare function unfold<R, A, S>(s: S, f: (s: S) => readonly [A, Stream<R
  * @tsplus fluent fncts.test.Sample zip
  * @tsplus location "@fncts/test/control/Sample/api"
  */
-export declare function zip<R, A, R1, B>(ma: Sample<R, A>, mb: Sample<R1, B>): Sample<R & R1, readonly [A, B]>;
+export declare function zip<R, A, R1, B>(ma: Sample<R, A>, mb: Sample<R1, B>): Sample<R | R1, readonly [A, B]>;
 /**
  * @tsplus fluent fncts.test.Sample zipWith
  * @tsplus location "@fncts/test/control/Sample/api"
  */
-export declare function zipWith_<R, A, R1, B, C>(ma: Sample<R, A>, mb: Sample<R1, B>, f: (a: A, b: B) => C): Sample<R & R1, C>;
+export declare function zipWith_<R, A, R1, B, C>(ma: Sample<R, A>, mb: Sample<R1, B>, f: (a: A, b: B) => C): Sample<R | R1, C>;
 /**
  * @tsplus static fncts.test.SampleOps noShrink
  * @tsplus location "@fncts/test/control/Sample/api"
  */
-export declare function noShrink<A>(a: A): Sample<unknown, A>;
+export declare function noShrink<A>(a: A): Sample<never, A>;
 /**
  * @tsplus static fncts.test.SampleOps shrinkFractional
  * @tsplus location "@fncts/test/control/Sample/api"
  */
-export declare function shrinkFractional(smallest: number): (a: number) => Sample<unknown, number>;
+export declare function shrinkFractional(smallest: number): (a: number) => Sample<never, number>;
 /**
  * @tsplus static fncts.test.SampleOps shrinkBigInt
  * @tsplus location "@fncts/test/control/Sample/api"
  */
-export declare function shrinkBigInt(smallest: bigint): (a: bigint) => Sample<unknown, bigint>;
+export declare function shrinkBigInt(smallest: bigint): (a: bigint) => Sample<never, bigint>;
 /**
  * @tsplus static fncts.test.SampleOps shrinkIntegral
  * @tsplus location "@fncts/test/control/Sample/api"
  */
-export declare function shrinkIntegral(smallest: number): (a: number) => Sample<unknown, number>;
+export declare function shrinkIntegral(smallest: number): (a: number) => Sample<never, number>;
 /**
  * @tsplus static fncts.test.SampleOps shrinkArrayInt64
  * @tsplus location "@fncts/test/control/Sample/api"
  */
-export declare function shrinkArrayInt64(target: ArrayInt64): (value: ArrayInt64) => Sample<unknown, ArrayInt64>;
+export declare function shrinkArrayInt64(target: ArrayInt64): (value: ArrayInt64) => Sample<never, ArrayInt64>;
 /**
  * @tsplus static fncts.test.SampleOps flatMapStream
  * @tsplus location "@fncts/test/control/Sample/api"
  */
-export declare function flatMapStream<R, A, R1, B>(stream: Stream<R, never, Maybe<A>>, f: (a: A) => Stream<R1, never, Maybe<B>>): Stream<R & R1, never, Maybe<B>>;
+export declare function flatMapStream<R, A, R1, B>(stream: Stream<R, never, Maybe<A>>, f: (a: A) => Stream<R1, never, Maybe<B>>): Stream<R | R1, never, Maybe<B>>;

package/control/Sized/api.d.ts

@@ -1,13 +1,12 @@
 import { URIO, IO } from "@fncts/io/IO";
-import { Has } from "@fncts/base/typeclass";
 import { Sized } from "./definition.js";
 /**
  * @tsplus static fncts.test.SizedOps size
  * @tsplus location "@fncts/test/control/Sized/api"
  */
-export declare const size: URIO<Has<Sized>, number>;
+export declare const size: URIO<Sized, number>;
 /**
  * @tsplus static fncts.test.SizedOps withSize
  * @tsplus location "@fncts/test/control/Sized/api"
  */
-export declare function withSize(size: number): <R, E, A>(io: import("@fncts/io/IO.js").IO<R, E, A>) => import("@fncts/io/IO.js").IO<R & import("@fncts/base/typeclass.js").Has<Sized>, E, A>;
+export declare function withSize(size: number): <R, E, A>(io: import("@fncts/io/IO.js").IO<R, E, A>) => import("@fncts/io/IO.js").IO<Sized | R, E, A>;

package/control/Sized/live.d.ts

@@ -1,9 +1,8 @@
 import { Layer } from "@fncts/io/Layer";
-import { Has } from "@fncts/base/typeclass";
 import { IO } from "@fncts/io/IO";
 import { Sized } from "./definition.js";
 /**
  * @tsplus static fncts.test.SizedOps Live
  * @tsplus location "@fncts/test/control/Sized/live"
  */
-export declare function Live(size: number): Layer<unknown, never, Has<Sized>>;
+export declare function Live(size: number): Layer<never, never, Sized>;

package/control/Spec/api.d.ts

@@ -1,4 +1,3 @@
-import { Has } from "@fncts/base/typeclass";
 import { Environment } from "@fncts/base/data/Environment";
 import { Scope } from "@fncts/io/Scope";
 import { IO } from "@fncts/io/IO";
@@ -10,7 +9,6 @@ import { Lazy } from "@fncts/base/data/function/definition";
 import type { Annotated } from "../Annotations.js";
 import type { SpecCase } from "./definition.js";
 import type { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
-import type { Spreadable } from "@fncts/base/types.js";
 import type { TestArgs } from "@fncts/test/data/TestArgs.js";
 import { TestSuccess } from "@fncts/test/data/TestSuccess";
 import { TestAnnotation } from "../../data/TestAnnotation.js";
@@ -22,12 +20,12 @@ import { PSpec } from "./definition.js";
  * @tsplus getter fncts.test.PSpec annotated
  * @tsplus location "@fncts/test/control/Spec/api"
  */
-export declare function annotated<R, E, T>(spec: PSpec<R, E, T>): PSpec<R & Has<Annotations>, Annotated<E>, Annotated<T>>;
+export declare function annotated<R, E, T>(spec: PSpec<R, E, T>): PSpec<R | Annotations, Annotated<E>, Annotated<T>>;
 /**
  * @tsplus fluent fncts.test.PSpec combine
  * @tsplus location "@fncts/test/control/Spec/api"
  */
-export declare function combine_<R, E, T, R1, E1, T1>(self: PSpec<R, E, T>, that: PSpec<R1, E1, T1>): PSpec<R & R1, E | E1, T | T1>;
+export declare function combine_<R, E, T, R1, E1, T1>(self: PSpec<R, E, T>, that: PSpec<R1, E1, T1>): PSpec<R | R1, E | E1, T | T1>;
 /**
  * @tsplus fluent fncts.test.PSpec contramapEnvironment
  * @tsplus location "@fncts/test/control/Spec/api"
@@ -37,12 +35,12 @@ export declare function contramapEnvironment_<R, E, T, R0>(self: PSpec<R, E, T>,
  * @tsplus fluent fncts.test.PSpec countTests
  * @tsplus location "@fncts/test/control/Spec/api"
  */
-export declare function countTests_<R, E, T>(spec: PSpec<R, E, T>, f: (t: T) => boolean): IO<R & Has<Scope>, E, number>;
+export declare function countTests_<R, E, T>(spec: PSpec<R, E, T>, f: (t: T) => boolean): IO<R | Scope, E, number>;
 /**
  * @tsplus static fncts.test.PSpecOps empty
  * @tsplus location "@fncts/test/control/Spec/api"
  */
-export declare const empty: PSpec<unknown, never, never>;
+export declare const empty: PSpec<never, never, never>;
 /**
  * @tsplus static fncts.test.PSpecOps exec
  * @tsplus static fncts.test.PSpec.ExecCaseOps __call
@@ -53,7 +51,7 @@ export declare function exec<R, E, T>(spec: PSpec<R, E, T>, exec: ExecutionStrat
  * @tsplus fluent fncts.test.PSpec execute
  * @tsplus location "@fncts/test/control/Spec/api"
  */
-export declare function execute<R, E, T>(self: PSpec<R, E, T>, defExec: ExecutionStrategy): IO<R & Has<Scope>, never, PSpec<unknown, E, T>>;
+export declare function execute<R, E, T>(self: PSpec<R, E, T>, defExec: ExecutionStrategy): IO<R | Scope, never, PSpec<never, E, T>>;
 /**
  * @tsplus fluent fncts.test.PSpec filterAnnotations
  * @tsplus location "@fncts/test/control/Spec/api"
@@ -83,12 +81,12 @@ export declare function fold_<R, E, T, Z>(spec: PSpec<R, E, T>, f: (_: SpecCase<
  * @tsplus fluent fncts.test.PSpec foldScoped
  * @tsplus location "@fncts/test/control/Spec/api"
  */
-export declare function foldScoped_<R, E, T, R1, E1, Z>(spec: PSpec<R, E, T>, f: (_: SpecCase<R, E, T, Z>) => IO<R1 & Has<Scope>, E1, Z>, defExec: ExecutionStrategy): IO<R & R1 & Has<Scope>, E1, Z>;
+export declare function foldScoped_<R, E, T, R1, E1, Z>(spec: PSpec<R, E, T>, f: (_: SpecCase<R, E, T, Z>) => IO<R1 | Scope, E1, Z>, defExec: ExecutionStrategy): IO<R | R1 | Scope, E1, Z>;
 /**
  * @tsplus fluent fncts.test.PSpec foreachExec
  * @tsplus location "@fncts/test/control/Spec/api"
  */
-export declare function foreachExec_<R, E, T, R1, E1, A, R2, E2, B>(spec: PSpec<R, E, T>, failure: (c: Cause<E>) => IO<R1, E1, A>, success: (t: T) => IO<R2, E2, B>, defExec: ExecutionStrategy): IO<R & R1 & R2 & Has<Scope>, never, PSpec<R & R1 & R2, E1 | E2, A | B>>;
+export declare function foreachExec_<R, E, T, R1, E1, A, R2, E2, B>(spec: PSpec<R, E, T>, failure: (c: Cause<E>) => IO<R1, E1, A>, success: (t: T) => IO<R2, E2, B>, defExec: ExecutionStrategy): IO<R | R1 | R2 | Scope, never, PSpec<R | R1 | R2, E1 | E2, A | B>>;
 /**
  * @tsplus fluent fncts.test.PSpec labeled
  * @tsplus static fncts.test.PSpecOps labeled
@@ -102,7 +100,7 @@ export declare function labeledCase<R, E, T>(spec: PSpec<R, E, T>, label: string
  * @tsplus static fncts.test.PSpec.ScopedCaseOps __call
  * @tsplus location "@fncts/test/control/Spec/api"
  */
-export declare function scoped<R, E, T>(managed: IO<R & Has<Scope>, E, PSpec<R, E, T>>): PSpec<R, E, T>;
+export declare function scoped<R, E, T>(managed: IO<R | Scope, E, PSpec<R, E, T>>): PSpec<R, E, T>;
 /**
  * @tsplus fluent fncts.test.SpecCase mapError
  * @tsplus location "@fncts/test/control/Spec/api"
@@ -124,12 +122,12 @@ export declare function multipleCase<R, E, T>(specs: Conc<PSpec<R, E, T>>): PSpe
  * @tsplus fluent fncts.test.PSpec provideEnvironment
  * @tsplus location "@fncts/test/control/Spec/api"
  */
-export declare function provideEnvironment_<R, E, T>(self: PSpec<R, E, T>, r: Environment<R>): PSpec<unknown, E, T>;
+export declare function provideEnvironment_<R, E, T>(self: PSpec<R, E, T>, r: Environment<R>): PSpec<never, E, T>;
 /**
  * @tsplus fluent fncts.test.PSpec provideLayer
  * @tsplus location "@fncts/test/control/Spec/api"
  */
-export declare function provideLayer_<RIn, E, ROut extends Spreadable, R, E1, T>(self: PSpec<ROut, E1, T>, layer: Layer<RIn, E, ROut>): PSpec<RIn, E | E1, T>;
+export declare function provideLayer_<RIn, E, ROut, E1, T>(self: PSpec<ROut, E1, T>, layer: Layer<RIn, E, ROut>): PSpec<RIn, E | E1, T>;
 /**
  * @tsplus fluent fncts.test.PSpec test
  * @tsplus static fncts.test.PSpecOps test
@@ -151,9 +149,9 @@ export declare function annotate_<R, E, T, V>(self: PSpec<R, E, T>, key: TestAnn
  * @tsplus fluent fncts.test.PSpec whenIO
  * @tsplus location "@fncts/test/control/Spec/api"
  */
-export declare function whenIO_<R, E, R1, E1>(self: PSpec<R, E, TestSuccess>, b: IO<R1, E1, boolean>): PSpec<R & R1 & Has<Annotations>, E | E1, TestSuccess>;
+export declare function whenIO_<R, E, R1, E1>(self: PSpec<R, E, TestSuccess>, b: IO<R1, E1, boolean>): PSpec<R | R1 | Annotations, E | E1, TestSuccess>;
 /**
  * @tsplus fluent fncts.test.PSpec when
  * @tsplus location "@fncts/test/control/Spec/api"
  */
-export declare function when_<R, E>(self: PSpec<R, E, TestSuccess>, b: Lazy<boolean>): PSpec<R & Has<Annotations>, E, TestSuccess>;
+export declare function when_<R, E>(self: PSpec<R, E, TestSuccess>, b: Lazy<boolean>): PSpec<R | Annotations, E, TestSuccess>;

package/control/Spec/definition.d.ts

@@ -1,6 +1,5 @@
 import { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
 import { IO } from "@fncts/io/IO";
-import { Has } from "@fncts/base/typeclass";
 import { Scope } from "@fncts/io/Scope";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
 import type { TestAnnotationMap } from "../../data/TestAnnotationMap.js";
@@ -13,7 +12,7 @@ import type { _A, _E, _R } from "@fncts/base/types.js";
  */
 export declare class PSpec<R, E, T> {
     readonly caseValue: SpecCase<R, E, T, PSpec<R, E, T>>;
-    readonly _R: (_: R) => void;
+    readonly _R: () => R;
     readonly _E: () => E;
     readonly _A: () => T;
     constructor(caseValue: SpecCase<R, E, T, PSpec<R, E, T>>);
@@ -57,9 +56,9 @@ export declare class LabeledCase<Spec> {
  * @tsplus companion fncts.test.PSpec.ScopedCaseOps
  */
 export declare class ScopedCase<R, E, Spec> {
-    readonly scoped: IO<R & Has<Scope>, E, Spec>;
+    readonly scoped: IO<R | Scope, E, Spec>;
     readonly _tag = SpecCaseTag.Scoped;
-    constructor(scoped: IO<R & Has<Scope>, E, Spec>);
+    constructor(scoped: IO<R | Scope, E, Spec>);
 }
 /**
  * @tsplus companion fncts.test.PSpec.MultipleCaseOps
@@ -75,7 +74,7 @@ export declare class MultipleCase<Spec> {
 export declare class TestCase<R, E, T> {
     readonly test: IO<R, E, T>;
     readonly annotations: TestAnnotationMap;
-    readonly _R: (_: R) => void;
+    readonly _R: () => R;
     readonly _E: () => E;
     readonly _A: () => T;
     readonly _tag = SpecCaseTag.Test;

package/control/TestAspect/api.d.ts

@@ -1,4 +1,3 @@
-import { Has } from "@fncts/base/typeclass";
 import { IO } from "@fncts/io/IO";
 import { Schedule } from "@fncts/io/Schedule/definition";
 import { Environment } from "@fncts/base/data/Environment";
@@ -12,13 +11,13 @@ import { TestFailure } from "@fncts/test/data/TestFailure";
 export declare type TestAspectAtLeastR<R> = TestAspect<R, never>;
 export declare type TestAspectPoly = TestAspect<unknown, never>;
 export declare const id: TestAspectPoly;
-export declare const ignore: TestAspectAtLeastR<Has<Annotations>>;
-export declare function perTest<R, E>(f: <R1, E1>(test: IO<R1, TestFailure<E1>, TestSuccess>) => IO<R & R1, TestFailure<E | E1>, TestSuccess>): TestAspect<R, E>;
+export declare const ignore: TestAspectAtLeastR<Annotations>;
+export declare function perTest<R, E>(f: <R1, E1>(test: IO<R1, TestFailure<E1>, TestSuccess>) => IO<R | R1, TestFailure<E | E1>, TestSuccess>): TestAspect<R, E>;
 export declare function after<R, E, A>(effect: IO<R, E, A>): TestAspect<R, E>;
-export declare function around<R, E, A, R1>(before: IO<R, E, A>, after: (a: A) => IO<R1, never, any>): TestAspect<R & R1, E>;
-export declare function aroundAll<R, E, A, R1>(before: IO<R, E, A>, after: (a: A) => IO<R1, never, any>): TestAspect<R & R1, E>;
+export declare function around<R, E, A, R1>(before: IO<R, E, A>, after: (a: A) => IO<R1, never, any>): TestAspect<R | R1, E>;
+export declare function aroundAll<R, E, A, R1>(before: IO<R, E, A>, after: (a: A) => IO<R1, never, any>): TestAspect<R | R1, E>;
 export declare function before<R0>(effect: IO<R0, never, any>): TestAspect<R0, never>;
 export declare function beforeAll<R0, E0>(effect: IO<R0, E0, any>): TestAspect<R0, E0>;
 export declare const eventually: TestAspect<unknown, unknown>;
-export declare function repeat<R0>(schedule: Schedule<R0, TestSuccess, any>): TestAspect<R0 & Has<Annotations>, never>;
-export declare function timeoutWarning(duration: Duration): TestAspect<Has<Live>, any>;
+export declare function repeat<R0>(schedule: Schedule<R0, TestSuccess, any>): TestAspect<R0 & Annotations, never>;
+export declare function timeoutWarning(duration: Duration): TestAspect<Live, any>;

package/control/TestAspect/definition.d.ts

@@ -1,2 +1,2 @@
 import type { Spec } from "@fncts/test/control/Spec";
-export declare type TestAspect<R, E> = <R1, E1>(spec: Spec<R1, E1>) => Spec<R & R1, E | E1>;
+export declare type TestAspect<R, E> = <R1, E1>(spec: Spec<R1, E1>) => Spec<R | R1, E | E1>;

package/control/TestClock/api.d.ts

@@ -1,5 +1,4 @@
 import { Layer } from "@fncts/io/Layer";
-import { Has } from "@fncts/base/typeclass";
 import { IO } from "@fncts/io/IO";
 import { Annotations } from "@fncts/test/control/Annotations";
 import { Live } from "@fncts/test/control/Live";
@@ -8,14 +7,14 @@ import { Data, TestClock } from "@fncts/test/control/TestClock/definition";
  * @tsplus static fncts.test.TestClockOps make
  * @tsplus location "@fncts/test/control/TestClock/api"
  */
-export declare function make(data: Data): Layer<Has<Live> & Has<Annotations>, never, Has<TestClock>>;
+export declare function make(data: Data): Layer<Live | Annotations, never, TestClock>;
 /**
  * @tsplus static fncts.test.TestClockOps Live
  * @tsplus location "@fncts/test/control/TestClock/api"
  */
-export declare const live: Layer<Has<Live> & Has<Annotations>, never, Has<TestClock>>;
+export declare const live: Layer<Live | Annotations, never, TestClock>;
 /**
  * @tsplus static fncts.test.TestClockOps adjust
  * @tsplus location "@fncts/test/control/TestClock/api"
  */
-export declare function adjust(duration: number): IO<Has<TestClock>, never, void>;
+export declare function adjust(duration: number): IO<TestClock, never, void>;

package/control/TestClock/definition.d.ts

@@ -53,12 +53,12 @@ export declare class TestClock extends Clock {
     readonly annotations: Annotations;
     readonly warningState: Ref.Synchronized<WarningData>;
     constructor(clockState: Ref<Data>, live: Live, annotations: Annotations, warningState: Ref.Synchronized<WarningData>);
-    sleep: (ms: Lazy<Duration>) => import("@fncts/io/IO").IO<unknown, never, void>;
-    currentTime: import("@fncts/io/IO").IO<unknown, never, number>;
+    sleep: (ms: Lazy<Duration>) => import("@fncts/io/IO").IO<never, never, void>;
+    currentTime: import("@fncts/io/IO").IO<never, never, number>;
     adjust(duration: number): UIO<void>;
     setDate(date: Date): UIO<void>;
     setTime(time: number): UIO<void>;
-    sleeps: import("@fncts/io/IO").IO<unknown, never, import("@fncts/base/collection/immutable/List").List<number>>;
+    sleeps: import("@fncts/io/IO").IO<never, never, import("@fncts/base/collection/immutable/List").List<number>>;
     get supervizedFibers(): UIO<HashSet<Fiber.Runtime<any, any>>>;
     private get freeze();
     private get delay();

package/control/TestConsole/api.d.ts

@@ -1,5 +1,4 @@
 import { Layer } from "@fncts/io/Layer";
-import { Has } from "@fncts/base/typeclass";
 import { Live } from "@fncts/test/control/Live";
 import { ConsoleData } from "@fncts/test/control/TestConsole/definition";
 import { TestConsole } from "@fncts/test/control/TestConsole/definition";
@@ -7,9 +6,9 @@ import { TestConsole } from "@fncts/test/control/TestConsole/definition";
  * @tsplus static fncts.test.TestConsoleOps make
  * @tsplus location "@fncts/test/control/TestConsole/api"
  */
-export declare function make(data: ConsoleData, debug?: boolean): Layer<Has<Live>, never, Has<TestConsole>>;
+export declare function make(data: ConsoleData, debug?: boolean): Layer<Live, never, TestConsole>;
 /**
  * @tsplus static fncts.test.TestConsoleOps Live
  * @tsplus location "@fncts/test/control/TestConsole/api"
  */
-export declare const live: import("@fncts/io/Layer").Layer<import("@fncts/base/typeclass").Has<Live>, never, import("@fncts/base/typeclass").Has<TestConsole>>;
+export declare const live: import("@fncts/io/Layer").Layer<Live, never, TestConsole>;

package/control/TestConsole/definition.d.ts

@@ -24,11 +24,11 @@ export declare class TestConsole implements Console {
     show(...input: ReadonlyArray<unknown>): UIO<void>;
     print(line: string): UIO<void>;
     error(line: string): UIO<void>;
-    clearInput: import("@fncts/io/IO").IO<unknown, never, void>;
-    clearOutput: import("@fncts/io/IO").IO<unknown, never, void>;
-    output: import("@fncts/io/IO").IO<unknown, never, import("@fncts/base/collection/immutable/Vector").Vector<string>>;
-    errOutput: import("@fncts/io/IO").IO<unknown, never, import("@fncts/base/collection/immutable/Vector").Vector<string>>;
-    debugOutput: import("@fncts/io/IO").IO<unknown, never, import("@fncts/base/collection/immutable/Vector").Vector<string>>;
+    clearInput: import("@fncts/io/IO").IO<never, never, void>;
+    clearOutput: import("@fncts/io/IO").IO<never, never, void>;
+    output: import("@fncts/io/IO").IO<never, never, import("@fncts/base/collection/immutable/Vector").Vector<string>>;
+    errOutput: import("@fncts/io/IO").IO<never, never, import("@fncts/base/collection/immutable/Vector").Vector<string>>;
+    debugOutput: import("@fncts/io/IO").IO<never, never, import("@fncts/base/collection/immutable/Vector").Vector<string>>;
     feedLines(...lines: ReadonlyArray<string>): UIO<void>;
     silent<R, E, A>(io: IO<R, E, A>): IO<R, E, A>;
     debug<R, E, A>(io: IO<R, E, A>): IO<R, E, A>;

package/control/TestEnvironment.d.ts

@@ -1,4 +1,3 @@
-import { Has } from "@fncts/base/typeclass";
 import { Clock } from "@fncts/io/Clock";
 import { Random } from "@fncts/io/Random";
 import { Layer } from "@fncts/io/Layer";
@@ -11,6 +10,6 @@ import { TestClock } from "@fncts/test/control/TestClock";
 import { TestConsole } from "@fncts/test/control/TestConsole";
 import { TestRandom } from "@fncts/test/control/TestRandom";
 import { TestConfig } from "@fncts/test/data/TestConfig";
-export declare type TestEnvironment = Has<Annotations> & Has<Live> & Has<Sized> & Has<TestClock> & Has<TestConfig> & Has<TestRandom> & Has<Clock> & Has<Random> & Has<Console> & Has<TestConsole>;
+export declare type TestEnvironment = Annotations | Live | Sized | TestClock | TestConfig | TestRandom | Clock | Random | Console | TestConsole;
 export declare const LiveTestEnvironment: Layer<IOEnv, never, TestEnvironment>;
-export declare const TestEnvironment: import("@fncts/io/Layer").Layer<unknown, never, TestEnvironment>;
+export declare const TestEnvironment: import("@fncts/io/Layer").Layer<never, never, TestEnvironment>;

package/control/TestExecutor.d.ts

@@ -1,4 +1,3 @@
-import { Has } from "@fncts/base/typeclass";
 import { UIO } from "@fncts/io/IO";
 import { Layer } from "@fncts/io/Layer";
 import { Either } from "@fncts/base/data/Either/definition";
@@ -7,7 +6,7 @@ import type { Spec } from "./Spec.js";
 import type { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
 import { ExecutedSpec } from "../data/ExecutedSpec.js";
 export interface TestExecutor<R> {
-    readonly run: <E>(spec: Spec<R & Has<Annotations>, E>, defExec: ExecutionStrategy) => UIO<ExecutedSpec<E>>;
+    readonly run: <E>(spec: Spec<R | Annotations, E>, defExec: ExecutionStrategy) => UIO<ExecutedSpec<E>>;
     readonly environment: Layer<unknown, never, R>;
 }
-export declare function defaultTestExecutor<R>(env: Layer<unknown, never, R & Has<Annotations>>): TestExecutor<R & Has<Annotations>>;
+export declare function defaultTestExecutor<R>(env: Layer<never, never, R | Annotations>): TestExecutor<R | Annotations>;

package/control/TestLogger.d.ts

@@ -1,6 +1,5 @@
 import { UIO, URIO } from "@fncts/io/IO";
 import { Layer } from "@fncts/io/Layer";
-import { Has } from "@fncts/base/typeclass";
 /**
  * @tsplus type fncts.test.TestLogger
  * @tsplus companion fncts.test.TestLoggerOps
@@ -17,9 +16,9 @@ export declare const TestLoggerTag: import("@fncts/base/data/Tag").Tag<TestLogge
  * @tsplus static fncts.test.TestLoggerOps fromConsole
  * @tsplus location "@fncts/test/control/TestLogger"
  */
-export declare const fromConsole: Layer<unknown, never, Has<TestLogger>>;
+export declare const fromConsole: Layer<never, never, TestLogger>;
 /**
  * @tsplus static fncts.test.TestLoggerOps logLine
  * @tsplus location "@fncts/test/control/TestLogger"
  */
-export declare function logLine(line: string): URIO<Has<TestLogger>, void>;
+export declare function logLine(line: string): URIO<TestLogger, void>;