@fncts/test 0.0.32 → 0.0.34

package/_mjs/vitest.mjs

@@ -0,0 +1,79 @@
+const fileName_1 = "(@fncts/test) src/vitest.ts";
+import * as tsplus_module_1 from "@fncts/test/data/FreeBooleanAlgebra/api";
+import * as tsplus_module_2 from "@fncts/base/collection/immutable/List/constructors";
+import * as tsplus_module_3 from "@fncts/base/collection/immutable/List/api";
+import * as tsplus_module_4 from "@fncts/test/data/ExecutionResult";
+import * as tsplus_module_5 from "@fncts/test/control/TestAnnotationRenderer/api";
+import * as tsplus_module_6 from "@fncts/test/control/TestRenderer/ConsoleRenderer";
+import * as tsplus_module_7 from "@fncts/io/IO/api";
+import * as tsplus_module_8 from "@fncts/io/IO/api/provideLayer";
+import * as tsplus_module_9 from "@fncts/io/IO/runtime";
+import { check, checkAllConcurrently, checkAllIOConcurrently, checkIO } from "@fncts/test/api";
+import { renderFragment } from "@fncts/test/control/DefaultTestReporter";
+import { TestEnvironment } from "@fncts/test/control/TestEnvironment";
+import { Failed, rendered, Test } from "@fncts/test/data/ExecutionResult";
+import * as V from "vitest";
+export const describe = V.describe;
+export const suite = V.suite;
+export const it = /*#__PURE__*/(() => {
+  function runTest(test) {
+    const result = test();
+    if (tsplus_module_1.isFailure(result)) {
+      const lines = assertionValues => tsplus_module_3.flatMap(value => tsplus_module_2.from(renderFragment(value, 0).lines))(assertionValues);
+      const renderedResult = tsplus_module_6.renderSingle(tsplus_module_1.fold({
+        Value: details => rendered(Test, "", Failed, 0, lines(details.failureDetails.assertion)),
+        And: (l, r) => tsplus_module_4.and(r)(l),
+        Or: (l, r) => tsplus_module_4.or(r)(l),
+        Not: v => tsplus_module_4.invert(v)
+      })(tsplus_module_1.not(result)), tsplus_module_5.Default);
+      const error = new Error(renderedResult);
+      error.stack = undefined;
+      throw error;
+    }
+  }
+  function it(name, test, timeout = 5000) {
+    return V.it.concurrent(name, () => runTest(test), timeout);
+  }
+  function runTestIO(io) {
+    return tsplus_module_9.unsafeRunPromise(tsplus_module_8.provideLayer(TestEnvironment, fileName_1 + ":69:20")(tsplus_module_7.flatMap(result => tsplus_module_7.defer(() => {
+      if (tsplus_module_1.isFailure(result)) {
+        const lines = assertionValues => tsplus_module_3.flatMap(value => tsplus_module_2.from(renderFragment(value, 0).lines))(assertionValues);
+        const renderedResult = tsplus_module_6.renderSingle(tsplus_module_1.fold({
+          Value: details => rendered(Test, "", Failed, 0, lines(details.failureDetails.assertion)),
+          And: (l, r) => tsplus_module_4.and(r)(l),
+          Or: (l, r) => tsplus_module_4.or(r)(l),
+          Not: v => tsplus_module_4.invert(v)
+        })(tsplus_module_1.not(result)), tsplus_module_5.Default);
+        const error = new Error(renderedResult);
+        error.stack = undefined;
+        return tsplus_module_7.haltNow(error, fileName_1 + ":63:30");
+      }
+      return tsplus_module_7.unit;
+    }, fileName_1 + ":48:17"), fileName_1 + ":46:23")(tsplus_module_7.defer(io, fileName_1 + ":46:32"))), fileName_1 + ":70:24");
+  }
+  function itIO(name, io, timeout = 5000) {
+    return V.it.concurrent(name, () => runTestIO(io), timeout);
+  }
+  return Object.assign(it, {
+    skip: (name, test, timeout = 5000) => {
+      return V.it.skip(name, () => runTest(test), timeout);
+    },
+    only: (name, test, timeout = 5000) => {
+      return V.it.only(name, () => runTest(test), timeout);
+    },
+    check: check,
+    checkIO: checkIO,
+    checkAll: checkAllConcurrently,
+    checkAllIO: checkAllIOConcurrently,
+    io: Object.assign(itIO, {
+      skip: (name, io, timeout = 5000) => {
+        return V.it.skip(name, () => runTestIO(io), timeout);
+      },
+      only: (name, io, timeout = 5000) => {
+        return V.it.only(name, () => runTestIO(io), timeout);
+      }
+    })
+  });
+})();
+export const test = it;
+//# sourceMappingURL=vitest.mjs.map

package/_mjs/vitest.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest.mjs","names":["check","checkAllConcurrently","checkAllIOConcurrently","checkIO","renderFragment","TestEnvironment","Failed","rendered","Test","V","describe","suite","it","runTest","test","result","tsplus_module_1","isFailure","lines","assertionValues","tsplus_module_3","flatMap","value","tsplus_module_2","from","renderedResult","tsplus_module_6","renderSingle","fold","Value","details","failureDetails","assertion","And","l","r","tsplus_module_4","and","Or","or","Not","v","invert","not","tsplus_module_5","Default","error","Error","stack","undefined","name","timeout","concurrent","runTestIO","io","tsplus_module_9","unsafeRunPromise","tsplus_module_8","provideLayer","fileName_1","tsplus_module_7","defer","haltNow","unit","itIO","Object","assign","skip","only","checkAll","checkAllIO"],"sources":["../_src/vitest.ts"],"sourcesContent":[null],"mappings":"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"}

package/_src/api.ts

@@ -59,7 +59,7 @@ export function assert<A>(assertion: Assertion<A>) {
 }
 
 /**
- * @tsplus pipeable fncts.io.IO assert
+ * @tsplus pipeable global assert
  */
 export function assertIO<A>(assertion: AssertionIO<A>) {
   return <R, E>(io: IO<R, E, A>): IO<R, E, TestResult> => {
@@ -107,18 +107,18 @@ export function checkIO<A, R1, E>(test: (a: A) => IO<R1, E, TestResult>) {
 }
 
 /**
- * @tsplus pipeable fncts.test.Gen checkAllC
+ * @tsplus pipeable fncts.test.Gen checkAllConcurrently
  */
-export function checkAllC<A>(concurrency: number, test: (a: A) => TestResult) {
+export function checkAllConcurrently<A>(concurrency: number, test: (a: A) => TestResult) {
   return <R>(rv: Gen<R, A>): IO<R | TestConfig, never, TestResult> => {
     return checkStreamC(rv.sample.forever.filterMap(identity), concurrency, (a) => IO.succeed(test(a)));
   };
 }
 
 /**
- * @tsplus pipeable fncts.test.Gen checkAllC
+ * @tsplus pipeable fncts.test.Gen checkAllConcurrently
  */
-export function checkAllIOC<A, R1, E>(concurrency: number, test: (a: A) => IO<R1, E, TestResult>) {
+export function checkAllIOConcurrently<A, R1, E>(concurrency: number, test: (a: A) => IO<R1, E, TestResult>) {
   return <R>(rv: Gen<R, A>): IO<R | R1 | TestConfig, E, TestResult> => {
     return checkStreamC(rv.sample.forever.filterMap(identity), concurrency, test);
   };

package/_src/control/Assertion/api.ts

@@ -130,6 +130,9 @@ export function fails<E>(assertion: Assertion<E>): Assertion<Exit<E, any>> {
   );
 }
 
+/**
+ * @tsplus getter fncts.test.Assertion every
+ */
 export function every<A>(assertion: Assertion<A>): Assertion<Iterable<A>> {
   return Assertion.rec(
     "every",

package/_src/control/DefaultTestReporter/render.ts

@@ -159,7 +159,7 @@ function renderFailure(label: string, offset: number, details: AssertionResult):
   return renderFailureLabel(label, offset).toMessage + renderAssertionResult(details, offset);
 }
 
-function renderAssertionResult(assertionResult: AssertionResult, offset: number): Message {
+export function renderAssertionResult(assertionResult: AssertionResult, offset: number): Message {
   return (
     renderGenFailureDetails(assertionResult.genFailureDetails, offset) +
     renderAssertionFailureDetails(assertionResult.failureDetails.assertion, offset)
@@ -170,16 +170,7 @@ function renderFailureLabel(label: string, offset: number): Line {
   return error("- " + label).toLine.withOffset(offset);
 }
 
-function renderAssertFailure(result: TestResult, label: string, depth: number): ExecutionResult {
-  return result.fold({
-    Value: (details) => rendered(Test, label, Failed, depth, List.from(renderFailure(label, depth, details).lines)),
-    And: (l, r) => l && r,
-    Or: (l, r) => l || r,
-    Not: (v) => v.invert,
-  });
-}
-
-function renderAssertionFailureDetails(failureDetails: Cons<AssertionValue<any>>, offset: number): Message {
+export function renderAssertionFailureDetails(failureDetails: Cons<AssertionValue<any>>, offset: number): Message {
   /**
    * @tsplus tailrec
    */
@@ -214,7 +205,7 @@ function renderGenFailureDetails(failureDetails: Maybe<GenFailureDetails>, offse
   );
 }
 
-function renderFragment<A>(fragment: AssertionValue<A>, offset: number): Message {
+export function renderFragment<A>(fragment: AssertionValue<A>, offset: number): Message {
   return (
     (primary(renderValue(fragment, offset + 1)) + renderSatisfied(fragment)).withOffset(offset).toMessage +
     Message(

package/_src/control/Gen/api.ts

@@ -1,4 +1,11 @@
-import type { EqConstraint, FloatConstraints, LengthConstraints, NumberConstraints } from "./constraints.js";
+import type {
+  DateConstraints,
+  EqConstraint,
+  FloatConstraints,
+  LengthConstraints,
+  NumberConstraints,
+  ObjectConstraints,
+} from "./constraints.js";
 import type { _A, _R } from "@fncts/base/types.js";
 import type { ArrayInt64 } from "@fncts/base/util/rand";
 
@@ -26,6 +33,89 @@ import { Gen } from "./definition.js";
 
 const gapSize = 0xdfff + 1 - 0xd800;
 
+/**
+ * @tsplus static fncts.test.GenOps anything
+ */
+export function anything<C extends ObjectConstraints>(
+  constraints: C = {} as C,
+): Gen<
+  ObjectConstraints extends C
+    ? Sized
+    : unknown extends C["key"]
+    ? Sized
+    : _R<C["key"]> | C["values"] extends Array<infer A>
+    ? _R<A>
+    : Sized,
+  unknown
+> {
+  const key      = constraints.key ?? Gen.alphaNumericString;
+  const maxDepth = constraints.maxDepth ?? 2;
+  const maxKeys  = constraints.maxKeys ?? 5;
+  const values   = constraints.values ?? [
+    Gen.boolean,
+    Gen.alphaNumericString,
+    Gen.double,
+    Gen.int,
+    Gen.oneOf(Gen.alphaNumericString, Gen.constant(null), Gen.constant(undefined)),
+  ];
+
+  function mapOf<R, K, R1, V>(key: Gen<R, K>, value: Gen<R1, V>) {
+    return Gen.tuple(key, value)
+      .uniqueConc({
+        eq: Eq({
+          equals:
+            ([k1]) =>
+            ([k]) =>
+              Equatable.strictEquals(k, k1),
+        }),
+        maxLength: maxKeys,
+      })
+      .map((pairs) => new Map(pairs));
+  }
+
+  function setOf<R, V>(value: Gen<R, V>) {
+    return value
+      .uniqueConc({ eq: Eq({ equals: (v1) => (v) => Equatable.strictEquals(v, v1) }), maxLength: maxKeys })
+      .map((values) => new Set(values));
+  }
+
+  const base       = Gen.oneOf(...values);
+  const arrayBase  = Gen.oneOf(...values.map((gen) => gen.arrayWith({ maxLength: maxKeys })));
+  const arrayGen   = Gen.memo((n) => Gen.oneOf(arrayBase, gen(n).arrayWith({ maxLength: maxKeys })));
+  const objectBase = Gen.oneOf(...values.map((gen) => Gen.record(key, gen)));
+  const objectGen  = Gen.memo((n) => Gen.oneOf(objectBase, Gen.record(key, gen(n))));
+  const setBase    = Gen.oneOf(...values.map(setOf));
+  const setGen     = Gen.memo((n) => Gen.oneOf(setBase, setOf(gen(n))));
+  const mapBase    = Gen.oneOf(...values.map((value) => mapOf(key, value)));
+  const mapGen     = Gen.memo((n) => Gen.oneOf(mapBase, mapOf(Gen.oneOf(key, gen(n)), gen(n))));
+
+  const gen: (n: number) => Gen<any, any> = Gen.memo((n) => {
+    if (n <= 0) return base;
+    return Gen.oneOf(
+      base,
+      arrayGen(),
+      objectGen(),
+      ...(constraints.withDate ? [Gen.date()] : []),
+      ...(constraints.withSet ? [setGen()] : []),
+      ...(constraints.withMap ? [mapGen()] : []),
+      ...(constraints.withTypedArray
+        ? [
+            Gen.oneOf(
+              Gen.int8Array(),
+              Gen.uint8Array(),
+              Gen.int16Array(),
+              Gen.uint16Array(),
+              Gen.int32Array(),
+              Gen.uint32Array(),
+            ),
+          ]
+        : []),
+    );
+  });
+
+  return gen(maxDepth);
+}
+
 /**
  * @tsplus static fncts.test.GenOps size
  */
@@ -684,6 +774,81 @@ export function tuple<A extends [...Gen<any, any>[]]>(
   ) as any;
 }
 
+/**
+ * @tsplus static fncts.test.GenOps record
+ */
+export function record<R, R1, A>(
+  key: Gen<R, string>,
+  value: Gen<R1, A>,
+  constraints?: LengthConstraints,
+): Gen<Sized | R | R1, Record<string, A>> {
+  return Gen.tuple(key, value)
+    .uniqueConc({ eq: String.Eq.contramap(([k]) => k), ...constraints })
+    .map((pairs) => pairs.foldLeft({} as Record<string, A>, (b, [k, v]) => ({ ...b, [k]: v })));
+}
+
+/**
+ * @tsplus static fncts.test.GenOps date
+ */
+export function date(constraints: DateConstraints = {}): Gen<never, Date> {
+  const min = constraints.min ? constraints.min.getTime() : -8_640_000_000_000_000;
+  const max = constraints.max ? constraints.max.getTime() : 8_640_000_000_000_000;
+  return Gen.intWith({ min, max }).map((n) => new Date(n));
+}
+
+function typedArray<A>(
+  constraints: LengthConstraints & NumberConstraints,
+  minBound: number,
+  maxBound: number,
+  ctor: { new (arg: ReadonlyArray<number>): A },
+): Gen<Sized, A> {
+  const min = constraints.min ? clamp(constraints.min, minBound, maxBound) : minBound;
+  const max = constraints.max ? clamp(constraints.max, minBound, maxBound) : maxBound;
+  return Gen.array(Gen.intWith({ min, max })).map((n) => new ctor(n));
+}
+
+/**
+ * @tsplus static fncts.test.GenOps int8Array
+ */
+export function int8Array(constraints: LengthConstraints & NumberConstraints = {}): Gen<Sized, Int8Array> {
+  return typedArray(constraints, -128, 127, Int8Array);
+}
+
+/**
+ * @tsplus static fncts.test.GenOps int16Array
+ */
+export function int16Array(constraints: LengthConstraints & NumberConstraints = {}): Gen<Sized, Int16Array> {
+  return typedArray(constraints, -32768, 32767, Int16Array);
+}
+
+/**
+ * @tsplus static fncts.test.GenOps int32Array
+ */
+export function int32Array(constraints: LengthConstraints & NumberConstraints = {}): Gen<Sized, Int32Array> {
+  return typedArray(constraints, -0x80000000, 0x7fffffff, Int32Array);
+}
+
+/**
+ * @tsplus static fncts.test.GenOps uint8Array
+ */
+export function uint8Array(constraints: LengthConstraints & NumberConstraints = {}): Gen<Sized, Uint8Array> {
+  return typedArray(constraints, 0, 255, Uint8Array);
+}
+
+/**
+ * @tsplus static fncts.test.GenOps uint16Array
+ */
+export function uint16Array(constraints: LengthConstraints & NumberConstraints = {}): Gen<Sized, Uint16Array> {
+  return typedArray(constraints, 0, 65535, Uint16Array);
+}
+
+/**
+ * @tsplus static fncts.test.GenOps uint32Array
+ */
+export function uint32Array(constraints: LengthConstraints & NumberConstraints = {}): Gen<Sized, Uint32Array> {
+  return typedArray(constraints, 0, 0xffffffff, Uint32Array);
+}
+
 function _char(min: number, max: number, mapToCode: (v: number) => number): Gen<never, string> {
   return Gen.intWith({ min, max }).map((n) => String.fromCharCode(mapToCode(n)));
 }

package/_src/control/Live/definition.ts

@@ -21,23 +21,22 @@ export abstract class Live {
     ),
     LiveTag,
   );
-  static Live<R extends Live, E, A>(io: IO<R, E, A>): IO<R | Live, E, A> {
+  static live<R extends Live, E, A>(io: IO<R, E, A>): IO<R | Live, E, A> {
     return IO.serviceWithIO((live) => live.provide(io), LiveTag);
   }
 }
 
 /**
- * @tsplus static fncts.test.LiveOps withLive
+ * @tsplus static fncts.io.IOOps liveWith
  */
-export 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> {
-  // @ts-expect-error
-  return IO.environment<R | Live>().flatMap((r) => Live.Live(f(io.provideEnvironment(r))));
+export function liveWith<R, E, A>(f: (live: Live) => IO<R, E, A>): IO<R | Live, E, A> {
+  return IO.environmentWithIO((environment) => f(environment.get(Live.Tag)));
 }
 
+/**
+ * @tsplus static fncts.test.LiveOps withLive
+ */
 export function withLive<R extends Live, E, A>(io: IO<R, E, A>) {
   return <E1, B>(f: (_: IO<R, E, A>) => IO<R, E1, B>): IO<R | Live, E1, B> =>
-    IOEnv.services.getWith((services) => Live.Live(f(IOEnv.services.locally(services)(io))));
+    IOEnv.services.getWith((services) => Live.live(f(IOEnv.services.locally(services)(io))));
 }

package/_src/control/TestAspect/api.ts

@@ -102,14 +102,14 @@ export function timeoutWarning(duration: Duration): TestAspect<Live, any> {
 
 function warn<R, E>(labels: Vector<string>, test: IO<R, TestFailure<E>, TestSuccess>, duration: Duration) {
   return test.raceWith(
-    Live.withLive(showWarning(labels, duration), (io) => Clock.sleep(duration) > io),
+    Live.withLive(showWarning(labels, duration))((io) => Clock.sleep(duration) > io),
     (result, fiber) => fiber.interrupt > IO.fromExitNow(result),
     (_, fiber) => fiber.join,
   );
 }
 
 function showWarning(labels: Vector<string>, duration: Duration) {
-  return Live.Live(Console.print(renderWarning(labels, duration)));
+  return Console.print(renderWarning(labels, duration));
 }
 
 function renderWarning(labels: Vector<string>, duration: Duration) {

package/_src/control/TestRenderer/ConsoleRenderer.ts

@@ -39,6 +39,20 @@ export function render(
   });
 }
 
+/**
+ * @tsplus static fncts.test.ConsoleRenderer renderSingle
+ */
+export function renderSingle(result: ExecutionResult, testAnnotationRenderer: TestAnnotationRenderer): string {
+  const message = new Message(Vector.from(result.lines));
+  const output  = matchTag_(result.resultType, {
+    Suite: () => renderSuite(result.status, result.offset, message),
+    Test: () => renderTest(result.status, result.offset, message),
+    Other: () => new Message(Vector.from(result.lines)),
+  });
+  const renderedAnnotations = renderAnnotations(result.annotations, testAnnotationRenderer);
+  return renderToStringLines(output + renderedAnnotations).join("");
+}
+
 function renderSuite(status: Status, offset: number, message: Message) {
   return matchTag_(status, {
     Passed: () => (info("+") + sp).withOffset(offset).toMessage + message,

package/_src/demo.ts

@@ -14,4 +14,4 @@ class DemoSpec extends DefaultRunnableSpec {
     test("Demo failure", { a: { b: { c: { d: 100 } } } }.assert(strictEqualTo({ a: { b: { c: { d: 0 } } } }))),
   );
 }
-new DemoSpec().run().unsafeRunAsync()
+new DemoSpec().run().unsafeRunFiber();

package/_src/index.ts

@@ -1,4 +1,4 @@
-// codegen:start { preset: type-barrel, include: ./*.ts }
+// codegen:start { preset: type-barrel, include: ./*.ts, exclude: ./vitest.ts }
 export type {} from "./api.js";
 export type {} from "./control.js";
 export type {} from "./data.js";

package/_src/vitest.ts

@@ -0,0 +1,99 @@
+import type { AssertionValue } from "@fncts/test/data/AssertionValue";
+import type { TestResult } from "@fncts/test/data/FailureDetails";
+
+import { identity } from "@fncts/base/data/function";
+import { check, checkAllConcurrently, checkAllIOConcurrently, checkIO } from "@fncts/test/api";
+import { renderFragment } from "@fncts/test/control/DefaultTestReporter";
+import { Gen } from "@fncts/test/control/Gen";
+import { TestAnnotationRenderer } from "@fncts/test/control/TestAnnotationRenderer";
+import { TestEnvironment } from "@fncts/test/control/TestEnvironment";
+import { ConsoleRenderer } from "@fncts/test/control/TestRenderer/ConsoleRenderer";
+import { Failed, rendered, Test } from "@fncts/test/data/ExecutionResult";
+import { TestConfig } from "@fncts/test/data/TestConfig";
+import * as V from "vitest";
+
+export const describe = V.describe;
+
+export const suite = V.suite;
+
+export const it = (() => {
+  function runTest(test: Lazy<TestResult>) {
+    const result = test();
+    if (result.isFailure) {
+      const lines = (assertionValues: Cons<AssertionValue<any>>) =>
+        assertionValues.flatMap((value) => List.from(renderFragment(value, 0).lines));
+      const renderedResult = ConsoleRenderer.renderSingle(
+        result.invert.fold({
+          Value: (details) => rendered(Test, "", Failed, 0, lines(details.failureDetails.assertion)),
+          And: (l, r) => l && r,
+          Or: (l, r) => l || r,
+          Not: (v) => v.invert,
+        }),
+        TestAnnotationRenderer.Default,
+      );
+      const error = new Error(renderedResult);
+      error.stack = undefined;
+      throw error;
+    }
+  }
+
+  function it(name: string, test: Lazy<TestResult>, timeout = 5_000) {
+    return V.it.concurrent(name, () => runTest(test), timeout);
+  }
+
+  function runTestIO<E>(io: Lazy<IO<TestEnvironment, E, TestResult>>) {
+    return Do((Δ) => {
+      const result = Δ(IO.defer(io));
+      return Δ(
+        IO.defer(() => {
+          if (result.isFailure) {
+            const lines = (assertionValues: Cons<AssertionValue<any>>) =>
+              assertionValues.flatMap((value) => List.from(renderFragment(value, 0).lines));
+            const renderedResult = ConsoleRenderer.renderSingle(
+              result.invert.fold({
+                Value: (details) => rendered(Test, "", Failed, 0, lines(details.failureDetails.assertion)),
+                And: (l, r) => l && r,
+                Or: (l, r) => l || r,
+                Not: (v) => v.invert,
+              }),
+              TestAnnotationRenderer.Default,
+            );
+            const error = new Error(renderedResult);
+            error.stack = undefined;
+            return IO.haltNow(error);
+          }
+          return IO.unit;
+        }),
+      );
+    })
+      .provideLayer(TestEnvironment)
+      .unsafeRunPromise();
+  }
+
+  function itIO<E>(name: string, io: Lazy<IO<TestEnvironment, E, TestResult>>, timeout = 5_000) {
+    return V.it.concurrent(name, () => runTestIO(io), timeout);
+  }
+
+  return Object.assign(it, {
+    skip: (name: string, test: Lazy<TestResult>, timeout = 5_000) => {
+      return V.it.skip(name, () => runTest(test), timeout);
+    },
+    only: (name: string, test: Lazy<TestResult>, timeout = 5_000) => {
+      return V.it.only(name, () => runTest(test), timeout);
+    },
+    check: check,
+    checkIO: checkIO,
+    checkAll: checkAllConcurrently,
+    checkAllIO: checkAllIOConcurrently,
+    io: Object.assign(itIO, {
+      skip: <E>(name: string, io: Lazy<IO<TestEnvironment, E, TestResult>>, timeout = 5_000) => {
+        return V.it.skip(name, () => runTestIO(io), timeout);
+      },
+      only: <E, A>(name: string, io: Lazy<IO<TestEnvironment, E, TestResult>>, timeout = 5_000) => {
+        return V.it.only(name, () => runTestIO(io), timeout);
+      },
+    }),
+  });
+})();
+
+export const test = it;

package/api.d.ts

@@ -17,7 +17,7 @@ export declare function traverseResult<A>(value: A, assertResult: AssertResult<A
  */
 export declare function assert<A>(assertion: Assertion<A>): (value: A) => TestResult;
 /**
- * @tsplus pipeable fncts.io.IO assert
+ * @tsplus pipeable global assert
  * @tsplus location "@fncts/test/api"
  */
 export declare function assertIO<A>(assertion: AssertionIO<A>): <R, E>(io: import("@fncts/io/IO.js").IO<R, E, A>) => import("@fncts/io/IO.js").IO<R, E, TestResult>;
@@ -35,12 +35,12 @@ export declare function check<A>(test: (a: A) => TestResult): <R>(rv: Gen<R, A>)
  */
 export declare function checkIO<A, R1, E>(test: (a: A) => IO<R1, E, TestResult>): <R>(rv: Gen<R, A>) => import("@fncts/io/IO.js").IO<TestConfig | R1 | R, E, TestResult>;
 /**
- * @tsplus pipeable fncts.test.Gen checkAllC
+ * @tsplus pipeable fncts.test.Gen checkAllConcurrently
  * @tsplus location "@fncts/test/api"
  */
-export declare function checkAllC<A>(concurrency: number, test: (a: A) => TestResult): <R>(rv: Gen<R, A>) => import("@fncts/io/IO.js").IO<TestConfig | R, never, TestResult>;
+export declare function checkAllConcurrently<A>(concurrency: number, test: (a: A) => TestResult): <R>(rv: Gen<R, A>) => import("@fncts/io/IO.js").IO<TestConfig | R, never, TestResult>;
 /**
- * @tsplus pipeable fncts.test.Gen checkAllC
+ * @tsplus pipeable fncts.test.Gen checkAllConcurrently
  * @tsplus location "@fncts/test/api"
  */
-export declare function checkAllIOC<A, R1, E>(concurrency: number, test: (a: A) => IO<R1, E, TestResult>): <R>(rv: Gen<R, A>) => import("@fncts/io/IO.js").IO<TestConfig | R1 | R, E, TestResult>;
+export declare function checkAllIOConcurrently<A, R1, E>(concurrency: number, test: (a: A) => IO<R1, E, TestResult>): <R>(rv: Gen<R, A>) => import("@fncts/io/IO.js").IO<TestConfig | R1 | R, E, TestResult>;

package/control/Assertion/api.d.ts

@@ -45,6 +45,10 @@ export declare function containsCause<E>(cause: Cause<E>): Assertion<Cause<E>>;
 export declare function containsString(element: string): Assertion<string>;
 export declare function some<A>(assertion: Assertion<A>): Assertion<Iterable<A>>;
 export declare function fails<E>(assertion: Assertion<E>): Assertion<Exit<E, any>>;
+/**
+ * @tsplus getter fncts.test.Assertion every
+ * @tsplus location "@fncts/test/control/Assertion/api"
+ */
 export declare function every<A>(assertion: Assertion<A>): Assertion<Iterable<A>>;
 export declare function halts(assertion: Assertion<any>): Assertion<Exit<any, any>>;
 export declare function strictEqualTo<A>(expected: A): Assertion<A>;

package/control/DefaultTestReporter/render.d.ts

@@ -3,10 +3,13 @@ import { Vector } from "@fncts/base/collection/immutable/Vector";
 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 { AssertionResult } from "../../data/AssertionResult.js";
+import type { AssertionValue } from "../../data/AssertionValue.js";
 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 { Message } from "../../data/LogLine/Message.js";
 import { TestLogger } from "../TestLogger.js";
 export type TestReporter<E> = (duration: number, spec: ExecutedSpec<E>) => URIO<TestLogger, void>;
 /**
@@ -20,3 +23,6 @@ export declare function renderStats<E>(duration: number, executedSpec: ExecutedS
  * @tsplus location "@fncts/test/control/DefaultTestReporter/render"
  */
 export declare function render<E>(executedSpec: ExecutedSpec<E>): Vector<ExecutionResult>;
+export declare function renderAssertionResult(assertionResult: AssertionResult, offset: number): Message;
+export declare function renderAssertionFailureDetails(failureDetails: Cons<AssertionValue<any>>, offset: number): Message;
+export declare function renderFragment<A>(fragment: AssertionValue<A>, offset: number): Message;