@fncts/test 0.0.12 → 0.0.15

package/control/TestAspect/api.d.ts

@@ -1,8 +1,7 @@
-import { Has } from "@fncts/base/typeclass";
-import { IO } from "@fncts/io/IO";
+import { IO } from "@fncts/io/IO/definition";
 import { Schedule } from "@fncts/io/Schedule/definition";
-import { Environment } from "@fncts/base/data/Environment";
-import { Duration } from "@fncts/base/data/Duration";
+import { Environment } from "@fncts/base/data/Environment/definition";
+import { Duration } from "@fncts/base/data/Duration/definition";
 import { Vector } from "@fncts/base/collection/immutable/Vector";
 import type { TestAspect } from "@fncts/test/control/TestAspect/definition";
 import type { TestSuccess } from "@fncts/test/data/TestSuccess";
@@ -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,6 +1,5 @@
 import { Layer } from "@fncts/io/Layer";
-import { Has } from "@fncts/base/typeclass";
-import { IO } from "@fncts/io/IO";
+import { IO } from "@fncts/io/IO/definition";
 import { Annotations } from "@fncts/test/control/Annotations";
 import { Live } from "@fncts/test/control/Live";
 import { Data, TestClock } from "@fncts/test/control/TestClock/definition";
@@ -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

@@ -1,16 +1,16 @@
-import { List } from "@fncts/base/collection/immutable/List";
+import { List } from "@fncts/base/collection/immutable/List/definition";
 import { Future } from "@fncts/io/Future";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
-import { Fiber } from "@fncts/io/Fiber";
-import { Clock } from "@fncts/io/Clock";
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { Clock } from "@fncts/io/Clock/definition";
 import { Ref } from "@fncts/io/Ref";
 import { Lazy } from "@fncts/base/data/function/definition";
-import { Duration } from "@fncts/base/data/Duration";
-import { IO, UIO } from "@fncts/io/IO";
-import { HashSet } from "@fncts/base/collection/immutable/HashSet";
-import { Equatable } from "@fncts/base/typeclass";
-import { HashMap } from "@fncts/base/collection/immutable/HashMap";
-import { Just, Nothing } from "@fncts/base/data/Maybe";
+import { Duration } from "@fncts/base/data/Duration/definition";
+import { IO, UIO } from "@fncts/io/IO/definition";
+import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
+import { Equatable } from "@fncts/base/typeclass/Equatable";
+import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
+import { Just, Nothing } from "@fncts/base/data/Maybe/definition";
 import type { Annotations } from "@fncts/test/control/Annotations";
 import type { Live } from "@fncts/test/control/Live";
 export declare class Data {
@@ -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

@@ -1,8 +1,8 @@
 import { CaseClass } from "@fncts/base/data/CaseClass";
 import { Vector } from "@fncts/base/collection/immutable/Vector";
 import { Ref } from "@fncts/io/Ref";
-import { FiberRef } from "@fncts/io/FiberRef";
-import { UIO, IO } from "@fncts/io/IO";
+import { FiberRef } from "@fncts/io/FiberRef/definition";
+import { UIO, IO } from "@fncts/io/IO/definition";
 import type { Console } from "@fncts/io/Console";
 import type { Live } from "@fncts/test/control/Live";
 export declare class ConsoleData extends CaseClass<{
@@ -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,6 +1,5 @@
-import { Has } from "@fncts/base/typeclass";
-import { Clock } from "@fncts/io/Clock";
-import { Random } from "@fncts/io/Random";
+import { Clock } from "@fncts/io/Clock/definition";
+import { Random } from "@fncts/io/Random/definition";
 import { Layer } from "@fncts/io/Layer";
 import type { Console } from "@fncts/io/Console";
 import { IOEnv } from "@fncts/io/IOEnv";
@@ -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,5 +1,4 @@
-import { Has } from "@fncts/base/typeclass";
-import { UIO } from "@fncts/io/IO";
+import { UIO } from "@fncts/io/IO/definition";
 import { Layer } from "@fncts/io/Layer";
 import { Either } from "@fncts/base/data/Either/definition";
 import type { Annotations } from "./Annotations.js";
@@ -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 { UIO, URIO } from "@fncts/io/IO/definition";
 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>;

package/control/TestRandom/api.d.ts

@@ -1,49 +1,49 @@
 import { Byte } from "@fncts/base/data/Byte";
 import { Layer } from "@fncts/io/Layer";
-import { Has } from "@fncts/base/typeclass";
+import { Random } from "@fncts/io/Random/definition";
 import { Data, TestRandom } from "@fncts/test/control/TestRandom";
 /**
  * @tsplus static fncts.test.TestRandom feedInts
  * @tsplus location "@fncts/test/control/TestRandom/api"
  */
-export declare function feedInts(...ints: ReadonlyArray<number>): import("@fncts/io/IO").IO<import("@fncts/base/typeclass").Has<TestRandom>, never, void>;
+export declare function feedInts(...ints: ReadonlyArray<number>): import("@fncts/io/IO").IO<TestRandom, never, void>;
 /**
  * @tsplus static fncts.test.TestRandom feedBytes
  * @tsplus location "@fncts/test/control/TestRandom/api"
  */
-export declare function feedBytes(...bytes: ReadonlyArray<ReadonlyArray<Byte>>): import("@fncts/io/IO").IO<import("@fncts/base/typeclass").Has<TestRandom>, never, void>;
+export declare function feedBytes(...bytes: ReadonlyArray<ReadonlyArray<Byte>>): import("@fncts/io/IO").IO<TestRandom, never, void>;
 /**
  * @tsplus static fncts.test.TestRandom feedChars
  * @tsplus location "@fncts/test/control/TestRandom/api"
  */
-export declare function feedChars(...chars: ReadonlyArray<string>): import("@fncts/io/IO").IO<import("@fncts/base/typeclass").Has<TestRandom>, never, void>;
+export declare function feedChars(...chars: ReadonlyArray<string>): import("@fncts/io/IO").IO<TestRandom, never, void>;
 /**
  * @tsplus static fncts.test.TestRandom feedDoubles
  * @tsplus location "@fncts/test/control/TestRandom/api"
  */
-export declare function feedDoubles(...doubles: ReadonlyArray<number>): import("@fncts/io/IO").IO<import("@fncts/base/typeclass").Has<TestRandom>, never, void>;
+export declare function feedDoubles(...doubles: ReadonlyArray<number>): import("@fncts/io/IO").IO<TestRandom, never, void>;
 /**
  * @tsplus static fncts.test.TestRandom feedStrings
  * @tsplus location "@fncts/test/control/TestRandom/api"
  */
-export declare function feedStrings(...strings: ReadonlyArray<string>): import("@fncts/io/IO").IO<import("@fncts/base/typeclass").Has<TestRandom>, never, void>;
+export declare function feedStrings(...strings: ReadonlyArray<string>): import("@fncts/io/IO").IO<TestRandom, never, void>;
 /**
  * @tsplus static fncts.test.TestRandom feedBooleans
  * @tsplus location "@fncts/test/control/TestRandom/api"
  */
-export declare function feedBooleans(...booleans: ReadonlyArray<boolean>): import("@fncts/io/IO").IO<import("@fncts/base/typeclass").Has<TestRandom>, never, void>;
+export declare function feedBooleans(...booleans: ReadonlyArray<boolean>): import("@fncts/io/IO").IO<TestRandom, never, void>;
 /**
  * @tsplus static fncts.test.TestRandomOps make
  * @tsplus location "@fncts/test/control/TestRandom/api"
  */
-export declare function make(initialData: Data): Layer<unknown, never, unknown & Has<TestRandom>>;
+export declare function make(initialData: Data): Layer<never, never, Random | TestRandom>;
 /**
  * @tsplus static fncts.test.TestRandomOps Deterministic
  * @tsplus location "@fncts/test/control/TestRandom/api"
  */
-export declare const determinictic: import("@fncts/io/Layer").Layer<unknown, never, import("@fncts/base/typeclass").Has<TestRandom>>;
+export declare const determinictic: import("@fncts/io/Layer").Layer<never, never, import("@fncts/io/Random").Random | TestRandom>;
 /**
  * @tsplus static fncts.test.TestRandomOps Random
  * @tsplus location "@fncts/test/control/TestRandom/api"
  */
-export declare const random: Layer<unknown, never, Has<TestRandom>>;
+export declare const random: Layer<unknown, never, TestRandom>;

package/control/TestRandom/definition.d.ts

@@ -1,11 +1,11 @@
-import { Random } from "@fncts/io/Random";
+import { Random } from "@fncts/io/Random/definition";
 import { Ref } from "@fncts/io/Ref";
-import { UIO, IO } from "@fncts/io/IO";
+import { UIO, IO } from "@fncts/io/IO/definition";
 import { Vector } from "@fncts/base/collection/immutable/Vector";
 import { Byte } from "@fncts/base/data/Byte";
-import { ImmutableQueue } from "@fncts/base/collection/immutable/Queue";
-import { Maybe } from "@fncts/base/data/Maybe";
-import { List } from "@fncts/base/collection/immutable/List";
+import { ImmutableQueue } from "@fncts/base/collection/immutable/Queue/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { List } from "@fncts/base/collection/immutable/List/definition";
 import type { ArrayInt } from "@fncts/base/util/rand";
 /**
  * @tsplus static fncts.test.TestRandomOps Tag

package/control/TestRenderer/ConsoleRenderer.d.ts

@@ -1,5 +1,5 @@
 import { Vector } from "@fncts/base/collection/immutable/Vector";
-import { List } from "@fncts/base/collection/immutable/List";
+import { List } from "@fncts/base/collection/immutable/List/definition";
 import type { ExecutionResult } from "../../data/ExecutionResult.js";
 import type { TestAnnotationRenderer } from "../TestAnnotationRenderer.js";
 /**

package/control/TestRunner.d.ts

@@ -1,8 +1,7 @@
 import { Layer } from "@fncts/io/Layer";
-import { Has } from "@fncts/base/typeclass";
-import { URIO } from "@fncts/io/IO";
+import { URIO } from "@fncts/io/IO/definition";
 import { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
-import { Clock } from "@fncts/io/Clock";
+import { Clock } from "@fncts/io/Clock/definition";
 import type { RuntimeConfig } from "@fncts/io/RuntimeConfig";
 import type { Annotations } from "@fncts/test/control/Annotations";
 import type { TestReporter } from "@fncts/test/control/DefaultTestReporter/render";
@@ -14,7 +13,7 @@ export declare class TestRunner<R, E> {
     readonly executor: TestExecutor<R>;
     readonly runtimeConfig: RuntimeConfig;
     readonly reporter: TestReporter<E>;
-    readonly bootstrap: Layer<unknown, never, Has<TestLogger>>;
-    constructor(executor: TestExecutor<R>, runtimeConfig?: RuntimeConfig, reporter?: TestReporter<E>, bootstrap?: Layer<unknown, never, Has<TestLogger>>);
-    run(spec: Spec<R & Has<Annotations>, E>): URIO<Has<TestLogger>, ExecutedSpec<E>>;
+    readonly bootstrap: Layer<never, never, TestLogger>;
+    constructor(executor: TestExecutor<R>, runtimeConfig?: RuntimeConfig, reporter?: TestReporter<E>, bootstrap?: Layer<never, never, TestLogger>);
+    run(spec: Spec<R | Annotations, E>): URIO<TestLogger, ExecutedSpec<E>>;
 }

package/control.d.ts

@@ -0,0 +1,24 @@
+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";

package/data/AssertionResult.d.ts

@@ -1,4 +1,4 @@
-import { Maybe, Nothing } from "@fncts/base/data/Maybe";
+import { Maybe, Nothing } from "@fncts/base/data/Maybe/definition";
 import type { FailureDetails } from "./FailureDetails.js";
 import type { GenFailureDetails } from "./GenFailureDetails.js";
 export declare class FailureDetailsResult {

package/data/AssertionValue/api.d.ts

@@ -1,4 +1,4 @@
-import { Maybe } from "@fncts/base/data/Maybe";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { AssertionValue } from "./definition.js";
 /**
  * @tsplus fluent fncts.test.data.AssertionValue label

package/data/AssertionValue/definition.d.ts

@@ -1,5 +1,5 @@
 import { LazyValue } from "@fncts/base/control/LazyValue";
-import { Maybe, Nothing } from "@fncts/base/data/Maybe";
+import { Maybe, Nothing } from "@fncts/base/data/Maybe/definition";
 import type { AssertionIO } from "../../control/AssertionIO/definition.js";
 import type { FreeBooleanAlgebra } from "../FreeBooleanAlgebra.js";
 export declare const AssertionValueTypeId: unique symbol;

package/data/ExecutionResult.d.ts

@@ -1,4 +1,4 @@
-import { List } from "@fncts/base/collection/immutable/List";
+import { List } from "@fncts/base/collection/immutable/List/definition";
 import type { Line } from "./LogLine/Line.js";
 import type { TestAnnotationMap } from "./TestAnnotationMap.js";
 export interface Failed {

package/data/FailureDetails.d.ts

@@ -1,5 +1,5 @@
-import { Cons } from "@fncts/base/collection/immutable/List";
-import { Maybe } from "@fncts/base/data/Maybe";
+import { Cons } from "@fncts/base/collection/immutable/List/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
 import type { FailureDetailsResult } from "./AssertionResult.js";
 import type { AssertionValue } from "./AssertionValue.js";
 import type { FreeBooleanAlgebra } from "./FreeBooleanAlgebra.js";

package/data/FreeBooleanAlgebra/api.d.ts

@@ -1,6 +1,6 @@
-import { Maybe } from "@fncts/base/data/Maybe";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Either } from "@fncts/base/data/Either/definition";
-import { Eval } from "@fncts/base/control/Eval";
+import { Eval } from "@fncts/base/control/Eval/definition";
 import { FreeBooleanAlgebra } from "./definition.js";
 /**
  * @tsplus fluent fncts.test.FreeBooleanAlgebra and

package/data/TestAnnotation/api.d.ts

@@ -1,8 +1,8 @@
-import { HashSet } from "@fncts/base/collection/immutable/HashSet";
+import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
 import { Either } from "@fncts/base/data/Either/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
 import { Ref } from "@fncts/io/Ref";
-import { Fiber } from "@fncts/io/Fiber";
+import { Fiber } from "@fncts/io/Fiber/definition";
 import { TestAnnotation } from "./definition.js";
 export declare const IgnoredTag: import("@fncts/base/data/Tag.js").Tag<number>;
 /**

package/data/TestAnnotation/definition.d.ts

@@ -1,5 +1,6 @@
-import { Hashable, Equatable } from "@fncts/base/typeclass";
-import { Tag } from "@fncts/base/data/Tag";
+import { Hashable } from "@fncts/base/typeclass/Hashable";
+import { Equatable } from "@fncts/base/typeclass/Equatable";
+import { Tag } from "@fncts/base/data/Tag/definition";
 export declare const TestAnnotationTypeId: unique symbol;
 export declare type TestAnnotationTypeId = typeof TestAnnotationTypeId;
 /**

package/data/TestAnnotationMap.d.ts

@@ -1,4 +1,4 @@
-import { HashMap } from "@fncts/base/collection/immutable/HashMap";
+import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
 import type { TestAnnotation } from "./TestAnnotation.js";
 export declare class TestAnnotationMap {

package/data/TestArgs/definition.d.ts

@@ -1,4 +1,4 @@
-import { Maybe } from "@fncts/base/data/Maybe";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
 export declare class TestArgs {
     readonly testSearchTerms: ReadonlyArray<string>;
     readonly tagSearchTerms: ReadonlyArray<string>;

package/data/TestConfig.d.ts

@@ -1,5 +1,4 @@
 import { Layer } from "@fncts/io/Layer";
-import { Has } from "@fncts/base/typeclass";
 /**
  * @tsplus type fncts.test.data.TestConfig
  * @tsplus companion fncts.test.data.TestConfigOps
@@ -19,24 +18,24 @@ export declare const TestConfigTag: import("@fncts/base/data/Tag").Tag<TestConfi
  * @tsplus static fncts.test.data.TestConfigOps Live
  * @tsplus location "@fncts/test/data/TestConfig"
  */
-export declare function live(_: TestConfig): Layer<unknown, never, Has<TestConfig>>;
+export declare function live(_: TestConfig): Layer<never, never, TestConfig>;
 /**
  * @tsplus static fncts.test.data.TestConfigOps repeats
  * @tsplus location "@fncts/test/data/TestConfig"
  */
-export declare const repeats: import("@fncts/io/IO").IO<import("@fncts/base/typeclass").Has<TestConfig>, never, number>;
+export declare const repeats: import("@fncts/io/IO").IO<TestConfig, never, number>;
 /**
  * @tsplus static fncts.test.data.TestConfigOps retries
  * @tsplus location "@fncts/test/data/TestConfig"
  */
-export declare const retries: import("@fncts/io/IO").IO<import("@fncts/base/typeclass").Has<TestConfig>, never, number>;
+export declare const retries: import("@fncts/io/IO").IO<TestConfig, never, number>;
 /**
  * @tsplus static fncts.test.data.TestConfigOps samples
  * @tsplus location "@fncts/test/data/TestConfig"
  */
-export declare const samples: import("@fncts/io/IO").IO<import("@fncts/base/typeclass").Has<TestConfig>, never, number>;
+export declare const samples: import("@fncts/io/IO").IO<TestConfig, never, number>;
 /**
  * @tsplus static fncts.test.data.TestConfigOps shrinks
  * @tsplus location "@fncts/test/data/TestConfig"
  */
-export declare const shrinks: import("@fncts/io/IO").IO<import("@fncts/base/typeclass").Has<TestConfig>, never, number>;
+export declare const shrinks: import("@fncts/io/IO").IO<TestConfig, never, number>;

package/data/TestFailure.d.ts

@@ -1,4 +1,4 @@
-import { Cause } from "@fncts/base/data/Cause";
+import { Cause } from "@fncts/base/data/Cause/definition";
 import type { TestResult } from "./FailureDetails.js";
 export declare const enum TestFailureTag {
     AssertionFailure = "AssertionFailure",

package/data.d.ts

@@ -0,0 +1,19 @@
+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";

package/global.d.ts

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

package/index.d.ts

@@ -0,0 +1,6 @@
+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";

package/package.json

@@ -1,15 +1,19 @@
 {
   "name": "@fncts/test",
-  "version": "0.0.12",
+  "version": "0.0.15",
   "dependencies": {
-    "@fncts/base": "0.0.12",
-    "@fncts/io": "0.0.12",
-    "@fncts/typelevel": "0.0.10"
+    "@fncts/base": "0.0.15",
+    "@fncts/io": "0.0.15",
+    "@fncts/typelevel": "0.0.12"
   },
   "exports": {
     "./*": {
       "import": "./_mjs/*.mjs",
       "require": "./_cjs/*.cjs"
+    },
+    ".": {
+      "import": "./_mjs/index.mjs",
+      "require": "./_cjs/index.cjs"
     }
   },
   "publishConfig": {

package/util/math.d.ts

@@ -1,11 +1,11 @@
-import { IO, URIO } from "@fncts/io/IO";
+import { IO, UIO } from "@fncts/io/IO/definition";
 /** @internal */
 export declare const MIN_VALUE_32: number;
 /** @internal */
 export declare const MAX_VALUE_32: number;
 /** @internal */
 export declare const EPSILON_32: number;
-export declare function safeFloatToIndex(f: number, label: string): IO<unknown, never, number>;
+export declare function safeFloatToIndex(f: number, label: string): IO<never, never, number>;
 export declare function decomposeFloat(f: number): {
     exponent: number;
     significand: number;
@@ -110,7 +110,7 @@ export declare function indexToDouble(index: ArrayInt64): number;
  *
  * @internal
  */
-export declare function safeDoubleToIndex(d: number, label: string): IO<unknown, never, ArrayInt64>;
+export declare function safeDoubleToIndex(d: number, label: string): IO<never, never, ArrayInt64>;
 export declare function nextUp(x: number): number;
 export declare function nextAfter(x: number, y: number): number;
 export declare function computeBiasedRanges(min: ArrayInt64, max: ArrayInt64, biasedRanges?: {
@@ -123,7 +123,7 @@ export declare function computeBiasedRanges(min: ArrayInt64, max: ArrayInt64, bi
 export declare function computeArrayInt64GenerateRange(min: ArrayInt64, max: ArrayInt64, biasFactor: number | undefined, biasedRanges: {
     min: ArrayInt64;
     max: ArrayInt64;
-}[] | undefined): URIO<unknown, {
+}[] | undefined): UIO<{
     min: ArrayInt64;
     max: ArrayInt64;
 }>;

package/util.d.ts

@@ -0,0 +1 @@
+export type {} from "./util/math.js";