@fncts/test 0.0.12 → 0.0.15

package/_src/control/TestClock/definition.ts

@@ -114,7 +114,7 @@ export class TestClock extends Clock {
     );
   }
 
-  private get freeze(): IO<unknown, void, HashMap<FiberId, FiberStatus>> {
+  private get freeze(): IO<never, void, HashMap<FiberId, FiberStatus>> {
     return this.supervizedFibers.flatMap((fibers) =>
       IO.foldLeft(fibers, HashMap.makeDefault<FiberId, FiberStatus>(), (map, fiber) =>
         fiber.status.flatMap((status) => {
@@ -166,7 +166,7 @@ export class TestClock extends Clock {
     );
   }
 
-  private get suspended(): IO<unknown, void, HashMap<FiberId, FiberStatus>> {
+  private get suspended(): IO<never, void, HashMap<FiberId, FiberStatus>> {
     return this.freeze.zip(this.delay > this.freeze).flatMap(([first, last]) => {
       if (Equatable.strictEquals(first, last)) {
         return IO.succeedNow(first);
@@ -190,7 +190,7 @@ export class TestClock extends Clock {
         Start: () =>
           Just(this.live.provide(Clock.sleep((5).seconds) > Console.print(warning)).interruptible.fork.map(Pending)),
       },
-      () => Nothing<IO<unknown, never, WarningData>>(),
+      () => Nothing<IO<never, never, WarningData>>(),
     ),
   );
 }

package/_src/control/TestConsole/api.ts

@@ -7,15 +7,15 @@ import { TestConsole } from "@fncts/test/control/TestConsole/definition";
 /**
  * @tsplus static fncts.test.TestConsoleOps make
  */
-export function make(data: ConsoleData, debug = true): Layer<Has<Live>, never, Has<TestConsole>> {
+export function make(data: ConsoleData, debug = true): Layer<Live, never, TestConsole> {
   return Layer.scopedEnvironment(
     IO.serviceWithIO(
       (live) =>
-        IO.gen(function* (_) {
-          const ref      = yield* _(Ref.make(data));
-          const debugRef = yield* _(FiberRef.make(debug));
+        Do((_) => {
+          const ref      = _(Ref.make(data));
+          const debugRef = _(FiberRef.make(debug));
           const test     = new TestConsole(ref, live, debugRef);
-          yield* _(IOEnv.services.locallyScopedWith((_) => _.add(test, Console.Tag)));
+          _(IOEnv.services.locallyScopedWith((_) => _.add(test, Console.Tag)));
           return Environment.empty.add(test, TestConsole.Tag);
         }),
       Live.Tag,

package/_src/control/TestEnvironment.ts

@@ -9,16 +9,17 @@ import { TestConsole } from "@fncts/test/control/TestConsole";
 import { TestRandom } from "@fncts/test/control/TestRandom";
 import { TestConfig } from "@fncts/test/data/TestConfig";
 
-export type TestEnvironment = Has<Annotations> &
-  Has<Live> &
-  Has<Sized> &
-  Has<TestClock> &
-  Has<TestConfig> &
-  Has<TestRandom> &
-  Has<Clock> &
-  Has<Random> &
-  Has<Console> &
-  Has<TestConsole>;
+export type TestEnvironment =
+  | Annotations
+  | Live
+  | Sized
+  | TestClock
+  | TestConfig
+  | TestRandom
+  | Clock
+  | Random
+  | Console
+  | TestConsole;
 
 export const LiveTestEnvironment: Layer<IOEnv, never, TestEnvironment> = Annotations.Live.and(Live.Default)
   .and(Sized.Live(100))

package/_src/control/TestExecutor.ts

@@ -11,15 +11,13 @@ import { TestAnnotationMap } from "../data/TestAnnotationMap.js";
 import { RuntimeFailure } from "../data/TestFailure.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 function defaultTestExecutor<R>(
-  env: Layer<unknown, never, R & Has<Annotations>>,
-): TestExecutor<R & Has<Annotations>> {
+export function defaultTestExecutor<R>(env: Layer<never, never, R | Annotations>): TestExecutor<R | Annotations> {
   return {
-    run: <E>(spec: Spec<R & Has<Annotations>, E>, defExec: ExecutionStrategy): UIO<ExecutedSpec<E>> =>
+    run: <E>(spec: Spec<R | Annotations, E>, defExec: ExecutionStrategy): UIO<ExecutedSpec<E>> =>
       spec.annotated
         .provideLayer(env)
         .foreachExec(
@@ -35,7 +33,7 @@ export function defaultTestExecutor<R>(
         .scoped.flatMap(
           (s) =>
             s.foldScoped(
-              (spec: SpecCase<unknown, never, Annotated<Either<TestFailure<E>, TestSuccess>>, ExecutedSpec<E>>) =>
+              (spec: SpecCase<never, never, Annotated<Either<TestFailure<E>, TestSuccess>>, ExecutedSpec<E>>) =>
                 matchTag_(spec, {
                   Exec: ({ spec }) => IO.succeedNow(spec),
                   Labeled: ({ label, spec }) => IO.succeedNow(ExecutedSpec.labeled(spec, label)),

package/_src/control/TestLogger.ts

@@ -16,7 +16,7 @@ export const TestLoggerTag = Tag<TestLogger>();
 /**
  * @tsplus static fncts.test.TestLoggerOps fromConsole
  */
-export const fromConsole: Layer<unknown, never, Has<TestLogger>> = Layer.fromIO(
+export const fromConsole: Layer<never, never, TestLogger> = Layer.fromIO(
   IO.consoleWith((console) =>
     IO.succeedNow(
       new (class extends TestLogger {
@@ -32,6 +32,6 @@ export const fromConsole: Layer<unknown, never, Has<TestLogger>> = Layer.fromIO(
 /**
  * @tsplus static fncts.test.TestLoggerOps logLine
  */
-export function logLine(line: string): URIO<Has<TestLogger>, void> {
+export function logLine(line: string): URIO<TestLogger, void> {
   return IO.serviceWithIO((testLogger) => testLogger.logLine(line), TestLogger.Tag);
 }

package/_src/control/TestRandom/api.ts

@@ -41,11 +41,11 @@ export function feedBooleans(...booleans: ReadonlyArray<boolean>) {
 /**
  * @tsplus static fncts.test.TestRandomOps make
  */
-export function make(initialData: Data): Layer<unknown, never, unknown & Has<TestRandom>> {
+export function make(initialData: Data): Layer<never, never, Random | TestRandom> {
   return Layer.fromIOEnvironment(
-    IO.gen(function* (_) {
-      const data   = yield* _(Ref.make(initialData));
-      const buffer = yield* _(Ref.make(new Buffer()));
+    Do((_) => {
+      const data   = _(Ref.make(initialData));
+      const buffer = _(Ref.make(new Buffer()));
       const test   = new TestRandom(data, buffer);
       return Environment().add(test, TestRandom.Tag).add(test, Random.Tag);
     }),
@@ -62,13 +62,13 @@ export const determinictic = TestRandom.make(defaultData);
 /**
  * @tsplus static fncts.test.TestRandomOps Random
  */
-export const random: Layer<unknown, never, Has<TestRandom>> = determinictic.to(
+export const random: Layer<unknown, never, TestRandom> = determinictic.to(
   Layer.scoped(
-    IO.gen(function* (_) {
-      const testRandom = yield* _(IO.service(TestRandom.Tag));
-      const time       = yield* _(Clock.currentTime);
-      yield* _(testRandom.setSeed(time));
-      yield* _(IOEnv.services.locallyScopedWith((_) => _.add(testRandom, Random.Tag)));
+    Do((_) => {
+      const testRandom = _(IO.service(TestRandom.Tag));
+      const time       = _(Clock.currentTime);
+      _(testRandom.setSeed(time));
+      _(IOEnv.services.locallyScopedWith((_) => _.add(testRandom, Random.Tag)));
       return testRandom;
     }),
     TestRandom.Tag,

package/_src/control/TestRunner.ts

@@ -14,18 +14,18 @@ import { ConsoleRenderer } from "@fncts/test/control/TestRenderer/ConsoleRendere
 
 export class TestRunner<R, E> {
   readonly reporter: TestReporter<E>;
-  readonly bootstrap: Layer<unknown, never, Has<TestLogger>>;
+  readonly bootstrap: Layer<never, never, TestLogger>;
   constructor(
     readonly executor: TestExecutor<R>,
     readonly runtimeConfig: RuntimeConfig = defaultRuntimeConfig,
     reporter?: TestReporter<E>,
-    bootstrap?: Layer<unknown, never, Has<TestLogger>>,
+    bootstrap?: Layer<never, never, TestLogger>,
   ) {
     this.reporter  = reporter ?? DefaultTestReporter.report(ConsoleRenderer.render, TestAnnotationRenderer.Default);
     this.bootstrap = bootstrap ?? TestLogger.fromConsole;
   }
 
-  run(spec: Spec<R & Has<Annotations>, E>): URIO<Has<TestLogger>, ExecutedSpec<E>> {
+  run(spec: Spec<R | Annotations, E>): URIO<TestLogger, ExecutedSpec<E>> {
     return this.executor
       .run(spec, ExecutionStrategy.concurrentBounded(10))
       .timedWith(Clock.currentTime)

package/_src/control.ts

@@ -0,0 +1,26 @@
+// codegen:start { preset: type-barrel, include: ./control/*.ts }
+export type {} from "./control/AbstractRunnableSpec.js";
+export type {} from "./control/Annotations.js";
+export type {} from "./control/Assertion.js";
+export type {} from "./control/AssertionIO.js";
+export type {} from "./control/DefaultRunnableSpec.js";
+export type {} from "./control/DefaultTestReporter.js";
+export type {} from "./control/FreeBooleanAlgebraIO.js";
+export type {} from "./control/Gen.js";
+export type {} from "./control/Live.js";
+export type {} from "./control/RunnableSpec.js";
+export type {} from "./control/Sample.js";
+export type {} from "./control/Sized.js";
+export type {} from "./control/Spec.js";
+export type {} from "./control/SummaryBuilder.js";
+export type {} from "./control/Test.js";
+export type {} from "./control/TestAnnotationRenderer.js";
+export type {} from "./control/TestAspect.js";
+export type {} from "./control/TestClock.js";
+export type {} from "./control/TestConsole.js";
+export type {} from "./control/TestEnvironment.js";
+export type {} from "./control/TestExecutor.js";
+export type {} from "./control/TestLogger.js";
+export type {} from "./control/TestRandom.js";
+export type {} from "./control/TestRunner.js";
+// codegen:end

package/_src/data/TestConfig.ts

@@ -17,7 +17,7 @@ export const TestConfigTag = Tag<TestConfig>();
 /**
  * @tsplus static fncts.test.data.TestConfigOps Live
  */
-export function live(_: TestConfig): Layer<unknown, never, Has<TestConfig>> {
+export function live(_: TestConfig): Layer<never, never, TestConfig> {
   return Layer.succeed(
     new (class extends TestConfig {
       repeats = _.repeats;

package/_src/data.ts

@@ -0,0 +1,21 @@
+// codegen:start { preset: type-barrel, include: ./data/*.ts }
+export type {} from "./data/AssertionData.js";
+export type {} from "./data/AssertionResult.js";
+export type {} from "./data/AssertionValue.js";
+export type {} from "./data/ExecutedSpec.js";
+export type {} from "./data/ExecutionResult.js";
+export type {} from "./data/FailureDetails.js";
+export type {} from "./data/FreeBooleanAlgebra.js";
+export type {} from "./data/GenFailureDetails.js";
+export type {} from "./data/LogLine.js";
+export type {} from "./data/Render.js";
+export type {} from "./data/RenderParam.js";
+export type {} from "./data/Summary.js";
+export type {} from "./data/TestAnnotation.js";
+export type {} from "./data/TestAnnotationMap.js";
+export type {} from "./data/TestArgs.js";
+export type {} from "./data/TestConfig.js";
+export type {} from "./data/TestFailure.js";
+export type {} from "./data/TestSuccess.js";
+export type {} from "./data/TestTimeoutException.js";
+// codegen:end

package/_src/global.ts

@@ -0,0 +1,8 @@
+/**
+ * @tsplus global
+ */
+import type {} from "@fncts/io/global";
+/**
+ * @tsplus global
+ */
+import type {} from "@fncts/test";

package/_src/index.ts

@@ -0,0 +1,8 @@
+// codegen:start { preset: type-barrel, include: ./*.ts }
+export type {} from "./api.js";
+export type {} from "./control.js";
+export type {} from "./data.js";
+export type {} from "./demo.js";
+export type {} from "./global.js";
+export type {} from "./util.js";
+// codegen:end

package/_src/util/math.ts

@@ -10,7 +10,7 @@ const INDEX_POSITIVE_INFINITY_32 = 2139095040; // floatToIndex(MAX_VALUE_32) + 1
 /** @internal */
 const INDEX_NEGATIVE_INFINITY_32 = -2139095041; // floatToIndex(-MAX_VALUE_32) - 1
 
-export function safeFloatToIndex(f: number, label: string): IO<unknown, never, number> {
+export function safeFloatToIndex(f: number, label: string): IO<never, never, number> {
   const conversionTrick = "you can convert any double to a 32-bit float by using `new Float32Array([myDouble])[0]`";
   const errorMessage    = "fc.floatNext constraints." + label + " must be a 32-bit float - " + conversionTrick;
   if (Number.isNaN(f) || (Number.isFinite(f) && (f < -MAX_VALUE_32 || f > MAX_VALUE_32))) {
@@ -397,7 +397,7 @@ export function indexToDouble(index: ArrayInt64): number {
  *
  * @internal
  */
-export function safeDoubleToIndex(d: number, label: string): IO<unknown, never, ArrayInt64> {
+export function safeDoubleToIndex(d: number, label: string): IO<never, never, ArrayInt64> {
   if (Number.isNaN(d)) {
     // Number.NaN does not have any associated index in the current implementation
     return IO.haltNow(new Error("fc.doubleNext constraints." + label + " must be a 32-bit float"));
@@ -478,7 +478,7 @@ export function computeArrayInt64GenerateRange(
   max: ArrayInt64,
   biasFactor: number | undefined,
   biasedRanges: { min: ArrayInt64; max: ArrayInt64 }[] | undefined,
-): URIO<unknown, { min: ArrayInt64; max: ArrayInt64 }> {
+): UIO<{ min: ArrayInt64; max: ArrayInt64 }> {
   return IO.gen(function* (_) {
     if (biasFactor === undefined || (yield* _(Random.nextIntBetween(1, biasFactor))) !== 1) {
       return { min, max };

package/_src/util.ts

@@ -0,0 +1,3 @@
+// codegen:start { preset: type-barrel, include: ./util/*.ts }
+export type {} from "./util/math.js";
+// codegen:end

package/api.d.ts

@@ -1,7 +1,6 @@
-import { IO } from "@fncts/io/IO";
+import { IO } from "@fncts/io/IO/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
-import { Has } from "@fncts/base/typeclass";
-import { Stream } from "@fncts/io/Stream";
+import { Stream } from "@fncts/io/Stream/definition";
 import { Either } from "@fncts/base/data/Either/definition";
 import type { AssertResult } from "./control/Assertion.js";
 import type { AssertionIO } from "./control/AssertionIO.js";
@@ -24,24 +23,24 @@ export declare function assert_<A>(value: A, assertion: Assertion<A>): TestResul
 export declare function assertIO_<R, E, A>(io: IO<R, E, A>, assertion: AssertionIO<A>): IO<R, E, TestResult>;
 export declare function suite<Specs extends ReadonlyArray<Spec<any, any>>>(label: string, ...specs: Specs): Spec<_R<Specs[number]>, _E<Specs[number]>>;
 export declare function testIO<R, E>(label: string, assertion: Lazy<IO<R, E, TestResult>>): Spec<R, E>;
-export declare function test(label: string, assertion: Lazy<TestResult>): Spec<unknown, never>;
+export declare function test(label: string, assertion: Lazy<TestResult>): Spec<never, never>;
 /**
  * @tsplus fluent fncts.test.Gen check
  * @tsplus location "@fncts/test/api"
  */
-export declare function check<R, A>(rv: Gen<R, A>, test: (a: A) => TestResult): IO<R & Has<TestConfig>, never, TestResult>;
+export declare function check<R, A>(rv: Gen<R, A>, test: (a: A) => TestResult): IO<R | TestConfig, never, TestResult>;
 /**
  * @tsplus fluent fncts.test.Gen check
  * @tsplus location "@fncts/test/api"
  */
-export declare function checkIO<R, A, R1, E>(rv: Gen<R, A>, test: (a: A) => IO<R1, E, TestResult>): IO<R & R1 & Has<TestConfig>, E, TestResult>;
+export declare function checkIO<R, A, R1, E>(rv: Gen<R, A>, test: (a: A) => IO<R1, E, TestResult>): IO<R | R1 | TestConfig, E, TestResult>;
 /**
  * @tsplus fluent fncts.test.Gen checkAllC
  * @tsplus location "@fncts/test/api"
  */
-export declare function checkAllC<R, A>(rv: Gen<R, A>, concurrency: number, test: (a: A) => TestResult): IO<R & Has<TestConfig>, never, TestResult>;
+export declare function checkAllC<R, A>(rv: Gen<R, A>, concurrency: number, test: (a: A) => TestResult): IO<R | TestConfig, never, TestResult>;
 /**
  * @tsplus fluent fncts.test.Gen checkAllC
  * @tsplus location "@fncts/test/api"
  */
-export declare function checkAllIOC<R, A, R1, E>(rv: Gen<R, A>, concurrency: number, test: (a: A) => IO<R1, E, TestResult>): IO<R & R1 & Has<TestConfig>, E, TestResult>;
+export declare function checkAllIOC<R, A, R1, E>(rv: Gen<R, A>, concurrency: number, test: (a: A) => IO<R1, E, TestResult>): IO<R | R1 | TestConfig, E, TestResult>;

package/control/AbstractRunnableSpec.d.ts

@@ -1,5 +1,4 @@
-import { URIO } from "@fncts/io/IO";
-import { Has } from "@fncts/base/typeclass";
+import { URIO } from "@fncts/io/IO/definition";
 import type { Spec } from "@fncts/test/control/Spec";
 import type { TestAspect } from "@fncts/test/control/TestAspect";
 import type { TestLogger } from "@fncts/test/control/TestLogger";
@@ -9,7 +8,7 @@ export declare abstract class AbstractRunnableSpec<R, E> {
     abstract aspects: ReadonlyArray<TestAspect<R, any>>;
     abstract runner: TestRunner<R, E>;
     abstract spec: Spec<R, E>;
-    get _run(): URIO<Has<TestLogger>, ExecutedSpec<E>>;
-    runSpec(spec: Spec<R, E>): URIO<Has<TestLogger>, ExecutedSpec<E>>;
+    get _run(): URIO<TestLogger, ExecutedSpec<E>>;
+    runSpec(spec: Spec<R, E>): URIO<TestLogger, ExecutedSpec<E>>;
     get platform(): import("@fncts/io/RuntimeConfig").RuntimeConfig;
 }

package/control/Annotations/api.d.ts

@@ -1,7 +1,6 @@
-import { URIO, IO } from "@fncts/io/IO";
-import { Has } from "@fncts/base/typeclass";
-import { HashSet } from "@fncts/base/collection/immutable/HashSet";
-import { Fiber } from "@fncts/io/Fiber";
+import { URIO, IO } from "@fncts/io/IO/definition";
+import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
+import { Fiber } from "@fncts/io/Fiber/definition";
 import type { TestAnnotation } from "../../data/TestAnnotation.js";
 import type { Annotated } from "./definition.js";
 import { Annotations } from "./definition.js";
@@ -9,19 +8,19 @@ import { Annotations } from "./definition.js";
  * @tsplus static fncts.test.AnnotationsOps annotate
  * @tsplus location "@fncts/test/control/Annotations/api"
  */
-export declare function annotate<V>(key: TestAnnotation<V>, value: V): URIO<Has<Annotations>, void>;
+export declare function annotate<V>(key: TestAnnotation<V>, value: V): URIO<Annotations, void>;
 /**
  * @tsplus static fncts.test.AnnotationsOps get
  * @tsplus location "@fncts/test/control/Annotations/api"
  */
-export declare function get<V>(key: TestAnnotation<V>): URIO<Has<Annotations>, V>;
+export declare function get<V>(key: TestAnnotation<V>): URIO<Annotations, V>;
 /**
  * @tsplus static fncts.test.AnnotationsOps withAnnotations
  * @tsplus location "@fncts/test/control/Annotations/api"
  */
-export declare function withAnnotation<R, E, A>(io: IO<R, E, A>): IO<R & Has<Annotations>, Annotated<E>, Annotated<A>>;
+export declare function withAnnotation<R, E, A>(io: IO<R, E, A>): IO<R | Annotations, Annotated<E>, Annotated<A>>;
 /**
  * @tsplus static fncts.test.AnnotationsOps supervisedFibers
  * @tsplus location "@fncts/test/control/Annotations/api"
  */
-export declare const supervisedFibers: URIO<Has<Annotations>, HashSet<Fiber.Runtime<any, any>>>;
+export declare const supervisedFibers: URIO<Annotations, HashSet<Fiber.Runtime<any, any>>>;

package/control/Annotations/definition.d.ts

@@ -1,6 +1,6 @@
-import { UIO, IO } from "@fncts/io/IO";
-import { HashSet } from "@fncts/base/collection/immutable/HashSet";
-import { Fiber } from "@fncts/io/Fiber";
+import { UIO, IO } from "@fncts/io/IO/definition";
+import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
+import { Fiber } from "@fncts/io/Fiber/definition";
 import type { TestAnnotation } from "../../data/TestAnnotation.js";
 import type { TestAnnotationMap } from "../../data/TestAnnotationMap.js";
 export declare type Annotated<A> = readonly [A, TestAnnotationMap];

package/control/Annotations/live.d.ts

@@ -1,8 +1,8 @@
-import { FiberRef } from "@fncts/io/FiberRef";
-import { UIO, IO } from "@fncts/io/IO";
-import { HashSet } from "@fncts/base/collection/immutable/HashSet";
-import { Fiber } from "@fncts/io/Fiber";
-import { Equatable } from "@fncts/base/typeclass";
+import { FiberRef } from "@fncts/io/FiberRef/definition";
+import { UIO, IO } from "@fncts/io/IO/definition";
+import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { Equatable } from "@fncts/base/typeclass/Equatable";
 import { TestAnnotation } from "../../data/TestAnnotation.js";
 import { TestAnnotationMap } from "../../data/TestAnnotationMap.js";
 import { Annotations } from "./definition.js";
@@ -10,12 +10,12 @@ export declare class LiveAnnotations extends Annotations {
     private fiberRef;
     constructor(fiberRef: FiberRef<TestAnnotationMap>);
     annotate<V>(key: TestAnnotation<V>, value: V): UIO<void>;
-    get<V>(key: TestAnnotation<V>): import("@fncts/io/IO.js").IO<unknown, never, V>;
+    get<V>(key: TestAnnotation<V>): import("@fncts/io/IO.js").IO<never, never, V>;
     withAnnotation<R, E, A>(io: IO<R, E, A>): import("@fncts/io/IO.js").IO<R, readonly [E, TestAnnotationMap], readonly [A, TestAnnotationMap]>;
-    supervisedFibers: import("@fncts/io/IO.js").IO<unknown, never, import("@fncts/base/collection/immutable/HashSet.js").HashSet<import("@fncts/io/Fiber.js").Fiber.Runtime<any, any>>>;
+    supervisedFibers: import("@fncts/io/IO.js").IO<never, never, import("@fncts/base/collection/immutable/HashSet.js").HashSet<import("@fncts/io/Fiber.js").Fiber.Runtime<any, any>>>;
 }
 /**
  * @tsplus static fncts.test.AnnotationsOps Live
  * @tsplus location "@fncts/test/control/Annotations/live"
  */
-export declare const live: import("@fncts/io/Layer.js").Layer<unknown, never, import("@fncts/base/typeclass.js").Has<Annotations>>;
+export declare const live: import("@fncts/io/Layer.js").Layer<never, never, Annotations>;

package/control/Assertion/api.d.ts

@@ -1,6 +1,6 @@
 import { LazyValue } from "@fncts/base/control/LazyValue";
-import { Maybe } from "@fncts/base/data/Maybe";
-import { Cause } from "@fncts/base/data/Cause";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
 import { Exit } from "@fncts/base/data/Exit/definition";
 import { Either } from "@fncts/base/data/Either/definition";
 import type { Eq } from "@fncts/base/typeclass";

package/control/Assertion/definition.d.ts

@@ -1,4 +1,4 @@
-import { IO } from "@fncts/io/IO";
+import { IO } from "@fncts/io/IO/definition";
 import type { AssertionValue } from "../../data/AssertionValue.js";
 import type { FreeBooleanAlgebra } from "../../data/FreeBooleanAlgebra.js";
 import type { Render } from "../../data/Render.js";

package/control/AssertionIO/definition.d.ts

@@ -1,7 +1,7 @@
 import type { AssertionValue } from "../../data/AssertionValue.js";
 import type { Render } from "../../data/Render.js";
 import type { FreeBooleanAlgebraIO } from "../FreeBooleanAlgebraIO.js";
-export declare type AssertResultIO<A> = FreeBooleanAlgebraIO<unknown, never, AssertionValue<A>>;
+export declare type AssertResultIO<A> = FreeBooleanAlgebraIO<never, never, AssertionValue<A>>;
 export declare const AssertionIOTypeId: unique symbol;
 export declare type AssertionIOTypeId = typeof AssertionIOTypeId;
 /**

package/control/DefaultRunnableSpec.d.ts

@@ -2,6 +2,6 @@ import { RunnableSpec } from "@fncts/test/control/RunnableSpec";
 import { TestEnvironment } from "@fncts/test/control/TestEnvironment";
 import { TestRunner } from "@fncts/test/control/TestRunner";
 export declare abstract class DefaultRunnableSpec extends RunnableSpec<TestEnvironment, any> {
-    aspects: import("@fncts/test/control/TestAspect").TestAspect<import("@fncts/base/typeclass").Has<import("./Live").Live>, any>[];
-    runner: TestRunner<import("@fncts/base/typeclass").Has<import("./Live").Live> & import("@fncts/base/typeclass").Has<import("./Sized").Sized> & import("@fncts/base/typeclass").Has<import("./TestClock").TestClock> & import("@fncts/base/typeclass").Has<import("../data/TestConfig").TestConfig> & import("@fncts/base/typeclass").Has<import("./TestRandom").TestRandom> & import("@fncts/base/typeclass").Has<import("@fncts/io/Clock").Clock> & import("@fncts/base/typeclass").Has<import("@fncts/io/Random").Random> & import("@fncts/base/typeclass").Has<import("@fncts/io/Console").Console> & import("@fncts/base/typeclass").Has<import("./TestConsole").TestConsole> & import("@fncts/base/typeclass").Has<import("./Annotations").Annotations>, unknown>;
+    aspects: import("@fncts/test/control/TestAspect").TestAspect<import("./Live").Live, any>[];
+    runner: TestRunner<import("./Sized").Sized | import("./Annotations").Annotations | import("../data/TestConfig").TestConfig | import("@fncts/io/Clock").Clock | import("@fncts/io/Random").Random | import("@fncts/io/Console").Console | import("./Live").Live | import("./TestClock").TestClock | import("./TestConsole").TestConsole | import("./TestRandom").TestRandom, unknown>;
 }

package/control/DefaultTestReporter/render.d.ts

@@ -1,15 +1,14 @@
-import { URIO } from "@fncts/io/IO";
-import { Has } from "@fncts/base/typeclass";
+import { URIO } from "@fncts/io/IO/definition";
 import { Vector } from "@fncts/base/collection/immutable/Vector";
-import { List, Cons } from "@fncts/base/collection/immutable/List";
-import { Maybe } from "@fncts/base/data/Maybe";
-import { Cause } from "@fncts/base/data/Cause";
+import { List, Cons } from "@fncts/base/collection/immutable/List/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
 import type { ExecutedSpec } from "../../data/ExecutedSpec.js";
 import type { ExecutionResult } from "../../data/ExecutionResult.js";
 import type { TestAnnotationRenderer } from "../TestAnnotationRenderer.js";
 import type { TestRenderer } from "../TestRenderer/definition.js";
 import { TestLogger } from "../TestLogger.js";
-export declare type TestReporter<E> = (duration: number, spec: ExecutedSpec<E>) => URIO<Has<TestLogger>, void>;
+export declare type TestReporter<E> = (duration: number, spec: ExecutedSpec<E>) => URIO<TestLogger, void>;
 /**
  * @tsplus static fncts.test.DefaultTestReporter report
  * @tsplus location "@fncts/test/control/DefaultTestReporter/render"

package/control/FreeBooleanAlgebraIO/api.d.ts

@@ -1,17 +1,17 @@
-import { IO } from "@fncts/io/IO";
+import { IO } from "@fncts/io/IO/definition";
 import type { FreeBooleanAlgebraIO } from "./definition.js";
 /**
  * @tsplus fluent fncts.test.FreeBooleanAlgebraIO and
  * @tsplus operator fncts.test.FreeBooleanAlgebraIO &&
  * @tsplus location "@fncts/test/control/FreeBooleanAlgebraIO/api"
  */
-export declare function and_<R, E, A extends A1, R1, E1, A1>(self: FreeBooleanAlgebraIO<R, E, A>, that: FreeBooleanAlgebraIO<R1, E1, A1>): FreeBooleanAlgebraIO<R & R1, E | E1, A | A1>;
+export declare function and_<R, E, A extends A1, R1, E1, A1>(self: FreeBooleanAlgebraIO<R, E, A>, that: FreeBooleanAlgebraIO<R1, E1, A1>): FreeBooleanAlgebraIO<R | R1, E | E1, A | A1>;
 /**
  * @tsplus fluent fncts.test.FreeBooleanAlgebraIO or
  * @tsplus operator fncts.test.FreeBooleanAlgebraIO ||
  * @tsplus location "@fncts/test/control/FreeBooleanAlgebraIO/api"
  */
-export declare function or_<R, E, A extends A1, R1, E1, A1>(self: FreeBooleanAlgebraIO<R, E, A>, that: FreeBooleanAlgebraIO<R1, E1, A1>): FreeBooleanAlgebraIO<R & R1, E | E1, A | A1>;
+export declare function or_<R, E, A extends A1, R1, E1, A1>(self: FreeBooleanAlgebraIO<R, E, A>, that: FreeBooleanAlgebraIO<R1, E1, A1>): FreeBooleanAlgebraIO<R | R1, E | E1, A | A1>;
 /**
  * @tsplus fluent fncts.test.FreeBooleanAlgebraIO invert
  * @tsplus location "@fncts/test/control/FreeBooleanAlgebraIO/api"
@@ -31,12 +31,12 @@ export declare function isFailure<R, E, A>(self: FreeBooleanAlgebraIO<R, E, A>):
  * @tsplus static fncts.test.FreeBooleanAlgebraIOOps success
  * @tsplus location "@fncts/test/control/FreeBooleanAlgebraIO/api"
  */
-export declare function success<A>(a: A): FreeBooleanAlgebraIO<unknown, never, A>;
+export declare function success<A>(a: A): FreeBooleanAlgebraIO<never, never, A>;
 /**
  * @tsplus static fncts.test.FreeBooleanAlgebraIOOps failure
  * @tsplus location "@fncts/test/control/FreeBooleanAlgebraIO/api"
  */
-export declare function failure<A>(a: A): FreeBooleanAlgebraIO<unknown, never, A>;
+export declare function failure<A>(a: A): FreeBooleanAlgebraIO<never, never, A>;
 /**
  * @tsplus static fncts.test.FreeBooleanAlgebraIOOps fromIO
  * @tsplus location "@fncts/test/control/FreeBooleanAlgebraIO/api"

package/control/FreeBooleanAlgebraIO/definition.d.ts

@@ -1,4 +1,4 @@
-import { IO } from "@fncts/io/IO";
+import { IO } from "@fncts/io/IO/definition";
 import type { FreeBooleanAlgebra } from "../../data/FreeBooleanAlgebra.js";
 /**
  * @tsplus type fncts.test.FreeBooleanAlgebraIO

package/control/Gen/api/array.d.ts

@@ -1,4 +1,3 @@
-import { Has } from "@fncts/base/typeclass";
 import type { Sized } from "../../Sized.js";
 import type { EqConstraint, LengthConstraints } from "../constraints.js";
 import { Gen } from "../definition.js";
@@ -6,7 +5,7 @@ import { Gen } from "../definition.js";
  * @tsplus fluent fncts.test.Gen array
  * @tsplus location "@fncts/test/control/Gen/api/array"
  */
-export declare function array<R, A>(g: Gen<R, A>, constraints?: LengthConstraints): Gen<R & Has<Sized>, ReadonlyArray<A>>;
+export declare function array<R, A>(g: Gen<R, A>, constraints?: LengthConstraints): Gen<R | Sized, ReadonlyArray<A>>;
 /**
  * @tsplus fluent fncts.test.Gen arrayN
  * @tsplus location "@fncts/test/control/Gen/api/array"
@@ -16,4 +15,4 @@ export declare function arrayN_<R, A>(self: Gen<R, A>, n: number): Gen<R, Readon
  * @tsplus fluent fncts.test.Gen uniqueArray
  * @tsplus location "@fncts/test/control/Gen/api/array"
  */
-export declare function uniqueArray_<R, A>(gen: Gen<R, A>, constraints?: LengthConstraints & EqConstraint<A>): Gen<Has<Sized> & R, ReadonlyArray<A>>;
+export declare function uniqueArray_<R, A>(gen: Gen<R, A>, constraints?: LengthConstraints & EqConstraint<A>): Gen<Sized | R, ReadonlyArray<A>>;

package/control/Gen/api/char.d.ts

@@ -4,44 +4,44 @@ import { Gen } from "../definition.js";
  * @tsplus static fncts.test.GenOps alphaNumericChar
  * @tsplus location "@fncts/test/control/Gen/api/char"
  */
-export declare const alphaNumericChar: Gen<unknown, string>;
+export declare const alphaNumericChar: Gen<never, string>;
 /**
  * @tsplus static fncts.test.GenOps asciiChar
  * @tsplus location "@fncts/test/control/Gen/api/char"
  */
-export declare const asciiChar: Gen<unknown, string>;
+export declare const asciiChar: Gen<never, string>;
 /**
  * @tsplus static fncts.test.GenOps base64Char
  * @tsplus location "@fncts/test/control/Gen/api/char"
  */
-export declare const base64Char: Gen<unknown, string>;
+export declare const base64Char: Gen<never, string>;
 /**
  * @tsplus static fncts.test.GenOps char
  * @tsplus location "@fncts/test/control/Gen/api/char"
  */
-export declare function char(constraints: Required<NumberConstraints>): Gen<unknown, string>;
+export declare function char(constraints: Required<NumberConstraints>): Gen<never, string>;
 /**
  * @tsplus static fncts.test.GenOps char16
  * @tsplus location "@fncts/test/control/Gen/api/char"
  */
-export declare const char16: Gen<unknown, string>;
+export declare const char16: Gen<never, string>;
 /**
  * @tsplus static fncts.test.GenOps fullUnicodeChar
  * @tsplus location "@fncts/test/control/Gen/api/char"
  */
-export declare const fullUnicodeChar: Gen<unknown, string>;
+export declare const fullUnicodeChar: Gen<never, string>;
 /**
  * @tsplus static fncts.test.GenOps hexChar
  * @tsplus location "@fncts/test/control/Gen/api/char"
  */
-export declare const hexChar: Gen<unknown, string>;
+export declare const hexChar: Gen<never, string>;
 /**
  * @tsplus static fncts.test.GenOps printableChar
  * @tsplus location "@fncts/test/control/Gen/api/char"
  */
-export declare const printableChar: Gen<unknown, string>;
+export declare const printableChar: Gen<never, string>;
 /**
  * @tsplus static fncts.test.GenOps unicodeChar
  * @tsplus location "@fncts/test/control/Gen/api/char"
  */
-export declare const unicodeChar: Gen<unknown, string>;
+export declare const unicodeChar: Gen<never, string>;