@fncts/test 0.0.31 → 0.0.33

package/_src/control/Gen/api.ts

@@ -1,10 +1,16 @@
-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";
 
 import { SortedMap } from "@fncts/base/collection/immutable/SortedMap";
 import { IllegalArgumentError, NoSuchElementError } from "@fncts/base/data/exceptions";
-import { tuple } from "@fncts/base/data/function";
 import { identity } from "@fncts/base/data/function";
 
 import {
@@ -27,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
  */
@@ -59,6 +148,7 @@ export function alphaNumericStringWith(constraints: LengthConstraints = {}): Gen
 export const alphaNumericString: Gen<Sized, string> = alphaNumericChar.string();
 
 /**
+ * @tsplus static fncts.test.GenOps array
  * @tsplus getter fncts.test.Gen array
  */
 export function array<R, A>(self: Gen<R, A>): Gen<R | Sized, ReadonlyArray<A>> {
@@ -183,6 +273,7 @@ export function concWith(constraints: LengthConstraints = {}) {
 
 /**
  * @tsplus getter fncts.test.Gen conc
+ * @tsplus static fncts.test.GenOps conc
  */
 export function conc<R, A>(self: Gen<R, A>): Gen<R | Sized, Conc<A>> {
   return self.conc();
@@ -347,6 +438,11 @@ export function floatWith(constraints: NumberConstraints & FloatConstraints = {}
   );
 }
 
+/**
+ * @tsplus static fncts.test.GenOps float
+ */
+export const float: Gen<never, number> = floatWith();
+
 /**
  * @tsplus static fncts.test.GenOps fullUnicodeChar
  */
@@ -463,6 +559,9 @@ export function oneOf<A extends ReadonlyArray<Gen<any, any>>>(...gens: A): Gen<_
   else return Gen.intWith({ min: 0, max: gens.length - 1 }).flatMap((i) => gens[i]!);
 }
 
+/**
+ * @tsplus static fncts.test.GenOps partial
+ */
 export function partial<P extends Record<string, Gen<any, any>>>(
   properties: P,
 ): Gen<
@@ -540,6 +639,9 @@ export function stringN(n: number) {
   };
 }
 
+/**
+ * @tsplus static fncts.test.GenOps struct
+ */
 export function struct<P extends Record<string, Gen<any, any>>>(
   properties: P,
 ): Gen<
@@ -626,10 +728,13 @@ export function unwrap<R, R1, A>(effect: URIO<R, Gen<R1, A>>): Gen<R | R1, A> {
  */
 export function weighted<R, A>(...gens: ReadonlyArray<readonly [Gen<R, A>, number]>): Gen<R, A> {
   const sum   = gens.map(([, weight]) => weight).foldLeft(0, (b, a) => b + a);
-  const [map] = gens.foldLeft(tuple(SortedMap.make<number, Gen<R, A>>(Number.Ord), 0), ([map, acc], [gen, d]) => {
-    if ((acc + d) / sum > acc / sum) return tuple(map.set((acc + d) / sum, gen), acc + d);
-    else return tuple(map, acc);
-  });
+  const [map] = gens.foldLeft(
+    Function.tuple(SortedMap.make<number, Gen<R, A>>(Number.Ord), 0),
+    ([map, acc], [gen, d]) => {
+      if ((acc + d) / sum > acc / sum) return Function.tuple(map.set((acc + d) / sum, gen), acc + d);
+      else return Function.tuple(map, acc);
+    },
+  );
   return Gen.uniform.flatMap((n) =>
     map.getGte(n).getOrElse(() => {
       throw new NoSuchElementError("Gen.weighted");
@@ -651,10 +756,99 @@ export function zipWith<A, R1, B, C>(that: Gen<R1, B>, f: (a: A, b: B) => C) {
  */
 export function zip<R1, B>(that: Gen<R1, B>) {
   return <R, A>(self: Gen<R, A>): Gen<R | R1, readonly [A, B]> => {
-    return self.zipWith(that, tuple);
+    return self.zipWith(that, Function.tuple);
   };
 }
 
+/**
+ * @tsplus static fncts.test.GenOps tuple
+ */
+export function tuple<A extends [...Gen<any, any>[]]>(
+  ...components: A
+): Gen<
+  { [K in keyof A]: [A[K]] extends [Gen<infer R, any>] ? R : never }[keyof A & number],
+  { [K in keyof A]: [A[K]] extends [Gen<any, infer A>] ? A : never }
+> {
+  return components.foldLeft(Gen.constant<Array<any>>([]) as Gen<any, ReadonlyArray<any>>, (b, a) =>
+    b.zipWith(a, (vs, v) => [...vs, v]),
+  ) 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/demo.ts

@@ -1,10 +1,12 @@
 import { DefaultRunnableSpec } from "@fncts/test/control/DefaultRunnableSpec";
 
-import { suite, test, testIO } from "./api.js";
+import { suite, test } from "./api.js";
 import { strictEqualTo } from "./control/Assertion.js";
+
 const ServiceATag = Tag<{
   x: number;
 }>("fncts.test.demo.ServiceA");
+
 class DemoSpec extends DefaultRunnableSpec {
   spec = suite(
     "TestSuite",
@@ -12,4 +14,4 @@ class DemoSpec extends DefaultRunnableSpec {
     test("Demo failure", { a: { b: { c: { d: 100 } } } }.assert(strictEqualTo({ a: { b: { c: { d: 0 } } } }))),
   );
 }
-new DemoSpec().main();
+new DemoSpec().run().unsafeRunFiber();

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>;

package/control/AbstractRunnableSpec.d.ts

@@ -1,13 +1,26 @@
-import { URIO } from "@fncts/io/IO/definition";
+import { Scope } from "@fncts/io/Scope/definition";
+import { Layer } from "@fncts/io/Layer";
+import { UIO, IO } from "@fncts/io/IO/definition";
+import { Either } from "@fncts/base/data/Either/definition";
+import { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
+import { Clock } from "@fncts/io/Clock/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";
-import type { TestRunner } from "@fncts/test/control/TestRunner";
-import type { ExecutedSpec } from "@fncts/test/data/ExecutedSpec";
+import { TestEnvironment } from "@fncts/test/control/TestEnvironment";
+import { ExecutedSpec } from "@fncts/test/data/ExecutedSpec";
+/**
+ * @tsplus type fncts.test.AbstractRunnableSpec
+ */
 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<TestLogger, ExecutedSpec<E>>;
-    runSpec(spec: Spec<R, E>): URIO<TestLogger, ExecutedSpec<E>>;
+    aspects: ReadonlyArray<TestAspect<R | TestEnvironment, any>>;
+    abstract spec: Spec<R | TestEnvironment | Scope, E>;
+    abstract bootstrap: Layer<never, never, R>;
+    runSpec(spec: Spec<R | TestEnvironment | Scope, E>, __tsplusTrace?: string): UIO<ExecutedSpec<E>>;
+    run(__tsplusTrace?: string): UIO<number>;
 }
+/**
+ * @tsplus pipeable fncts.test.AbstractRunnableSpec combine
+ * @tsplus pipeable-operator fncts.test.AbstractRunnableSpec +
+ * @tsplus location "@fncts/test/control/AbstractRunnableSpec"
+ */
+export declare function combine<R1, E1>(that: AbstractRunnableSpec<R1, E1>): <R, E>(self: AbstractRunnableSpec<R, E>) => AbstractRunnableSpec<R1 | R, E1 | E>;

package/control/Annotations/definition.d.ts

@@ -3,12 +3,15 @@ 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 const AnnotationsTypeId: unique symbol;
+export type AnnotationsTypeId = typeof AnnotationsTypeId;
 export type Annotated<A> = readonly [A, TestAnnotationMap];
 /**
  * @tsplus type fncts.test.Annotations
  * @tsplus companion fncts.test.AnnotationsOps
  */
 export declare abstract class Annotations {
+    readonly [AnnotationsTypeId]: AnnotationsTypeId;
     abstract annotate<V>(key: TestAnnotation<V>, value: V): UIO<void>;
     abstract get<V>(key: TestAnnotation<V>): UIO<V>;
     abstract withAnnotation<R, E, A>(io: IO<R, E, A>): IO<R, Annotated<E>, Annotated<A>>;

package/control/DefaultRunnableSpec.d.ts

@@ -1,7 +1,7 @@
-import { RunnableSpec } from "@fncts/test/control/RunnableSpec";
+import { Layer } from "@fncts/io/Layer";
+import { AbstractRunnableSpec } from "@fncts/test/control/AbstractRunnableSpec";
 import { TestEnvironment } from "@fncts/test/control/TestEnvironment";
-import { TestRunner } from "@fncts/test/control/TestRunner";
-export declare abstract class DefaultRunnableSpec extends RunnableSpec<TestEnvironment, any> {
+export declare abstract class DefaultRunnableSpec extends AbstractRunnableSpec<TestEnvironment, any> {
     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>;
+    bootstrap: Layer<never, never, TestEnvironment>;
 }

package/control/Gen/api.d.ts

@@ -6,12 +6,17 @@ import { IO, URIO } from "@fncts/io/IO/definition";
 import { Stream } from "@fncts/io/Stream/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Eq } from "@fncts/base/data/Eq/definition";
-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";
 import { Sample } from "../Sample.js";
 import { Sized } from "../Sized.js";
 import { Gen } from "./definition.js";
+/**
+ * @tsplus static fncts.test.GenOps anything
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function anything<C extends ObjectConstraints>(constraints?: C): Gen<ObjectConstraints extends C ? Sized : unknown extends C["key"] ? Sized : _R<C["key"]> | C["values"] extends Array<infer A> ? _R<A> : Sized, unknown>;
 /**
  * @tsplus static fncts.test.GenOps size
  * @tsplus location "@fncts/test/control/Gen/api"
@@ -38,6 +43,7 @@ export declare function alphaNumericStringWith(constraints?: LengthConstraints):
  */
 export declare const alphaNumericString: Gen<Sized, string>;
 /**
+ * @tsplus static fncts.test.GenOps array
  * @tsplus getter fncts.test.Gen array
  * @tsplus location "@fncts/test/control/Gen/api"
  */
@@ -119,6 +125,7 @@ export declare const char16: Gen<never, string>;
 export declare function concWith(constraints?: LengthConstraints): <R, A>(self: Gen<R, A>) => Gen<Sized | R, import("@fncts/base/collection/immutable/Conc.js").Conc<A>>;
 /**
  * @tsplus getter fncts.test.Gen conc
+ * @tsplus static fncts.test.GenOps conc
  * @tsplus location "@fncts/test/control/Gen/api"
  */
 export declare function conc<R, A>(self: Gen<R, A>): Gen<R | Sized, Conc<A>>;
@@ -193,6 +200,11 @@ export declare function fromIOSample<R, A>(effect: IO<R, never, Sample<R, A>>):
  * @tsplus location "@fncts/test/control/Gen/api"
  */
 export declare function floatWith(constraints?: NumberConstraints & FloatConstraints): Gen<never, number>;
+/**
+ * @tsplus static fncts.test.GenOps float
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare const float: Gen<never, number>;
 /**
  * @tsplus static fncts.test.GenOps fullUnicodeChar
  * @tsplus location "@fncts/test/control/Gen/api"
@@ -253,6 +265,10 @@ export declare function nat(max?: number): Gen<unknown, number>;
  * @tsplus location "@fncts/test/control/Gen/api"
  */
 export declare function oneOf<A extends ReadonlyArray<Gen<any, any>>>(...gens: A): Gen<_R<A[number]>, _A<A[number]>>;
+/**
+ * @tsplus static fncts.test.GenOps partial
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
 export declare function partial<P extends Record<string, Gen<any, any>>>(properties: P): Gen<_R<P[keyof P]>, Partial<{
     readonly [K in keyof P]: _A<P[K]>;
 }>>;
@@ -291,6 +307,10 @@ export declare function string(constraints?: LengthConstraints): <R>(char: Gen<R
  * @tsplus location "@fncts/test/control/Gen/api"
  */
 export declare function stringN(n: number): <R>(char: Gen<R, string>) => Gen<R, string>;
+/**
+ * @tsplus static fncts.test.GenOps struct
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
 export declare function struct<P extends Record<string, Gen<any, any>>>(properties: P): Gen<_R<P[keyof P]>, {
     readonly [K in keyof P]: _A<P[K]>;
 }>;
@@ -349,3 +369,52 @@ export declare function zipWith<A, R1, B, C>(that: Gen<R1, B>, f: (a: A, b: B) =
  * @tsplus location "@fncts/test/control/Gen/api"
  */
 export declare function zip<R1, B>(that: Gen<R1, B>): <R, A>(self: Gen<R, A>) => Gen<R1 | R, readonly [A, B]>;
+/**
+ * @tsplus static fncts.test.GenOps tuple
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function tuple<A extends [...Gen<any, any>[]]>(...components: A): Gen<{
+    [K in keyof A]: [A[K]] extends [Gen<infer R, any>] ? R : never;
+}[keyof A & number], {
+    [K in keyof A]: [A[K]] extends [Gen<any, infer A>] ? A : never;
+}>;
+/**
+ * @tsplus static fncts.test.GenOps record
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function record<R, R1, A>(key: Gen<R, string>, value: Gen<R1, A>, constraints?: LengthConstraints): Gen<Sized | R | R1, Record<string, A>>;
+/**
+ * @tsplus static fncts.test.GenOps date
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function date(constraints?: DateConstraints): Gen<never, Date>;
+/**
+ * @tsplus static fncts.test.GenOps int8Array
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function int8Array(constraints?: LengthConstraints & NumberConstraints): Gen<Sized, Int8Array>;
+/**
+ * @tsplus static fncts.test.GenOps int16Array
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function int16Array(constraints?: LengthConstraints & NumberConstraints): Gen<Sized, Int16Array>;
+/**
+ * @tsplus static fncts.test.GenOps int32Array
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function int32Array(constraints?: LengthConstraints & NumberConstraints): Gen<Sized, Int32Array>;
+/**
+ * @tsplus static fncts.test.GenOps uint8Array
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function uint8Array(constraints?: LengthConstraints & NumberConstraints): Gen<Sized, Uint8Array>;
+/**
+ * @tsplus static fncts.test.GenOps uint16Array
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function uint16Array(constraints?: LengthConstraints & NumberConstraints): Gen<Sized, Uint16Array>;
+/**
+ * @tsplus static fncts.test.GenOps uint32Array
+ * @tsplus location "@fncts/test/control/Gen/api"
+ */
+export declare function uint32Array(constraints?: LengthConstraints & NumberConstraints): Gen<Sized, Uint32Array>;

package/control/Live/definition.d.ts

@@ -12,11 +12,15 @@ 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, Live>;
-    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>;
 }
+/**
+ * @tsplus static fncts.io.IOOps liveWith
+ * @tsplus location "@fncts/test/control/Live/definition"
+ */
+export declare function liveWith<R, E, A>(f: (live: Live) => 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<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/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@fncts/test",
-  "version": "0.0.31",
+  "version": "0.0.33",
   "dependencies": {
-    "@fncts/base": "0.0.26",
-    "@fncts/io": "0.0.31",
+    "@fncts/base": "0.0.28",
+    "@fncts/io": "0.0.33",
     "@fncts/typelevel": "0.0.15"
   },
   "exports": {

package/_cjs/control/RunnableSpec.cjs

@@ -1,52 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.RunnableSpec = void 0;
-exports.isRunnableSpec = isRunnableSpec;
-var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/test/control/TestLogger"));
-var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO/api"));
-var tsplus_module_3 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/test/control/SummaryBuilder"));
-var tsplus_module_4 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Either/api"));
-var tsplus_module_5 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/test/data/ExecutedSpec/api"));
-var tsplus_module_6 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Exit/api"));
-var tsplus_module_7 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO/api/provideLayer"));
-var tsplus_module_8 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/io/IO/runtime"));
-var _pattern = /*#__PURE__*/require("@fncts/base/util/pattern");
-var _predicates = /*#__PURE__*/require("@fncts/base/util/predicates");
-var _AbstractRunnableSpec = /*#__PURE__*/require("@fncts/test/control/AbstractRunnableSpec");
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-const fileName_1 = "(@fncts/test) src/control/RunnableSpec.ts";
-class RunnableSpec extends _AbstractRunnableSpec.AbstractRunnableSpec {
-  constructor() {
-    super(...arguments);
-    this._tag = "RunnableSpec";
-  }
-  run(spec) {
-    const self = this;
-    return tsplus_module_2.flatMap(results => {
-      const hasFailures = tsplus_module_5.some((0, _pattern.matchTag)({
-        Test: ({
-          test
-        }) => tsplus_module_4.isLeft(test)
-      }, () => false))(results);
-      const summary = tsplus_module_3.buildSummary(results);
-      return tsplus_module_2.map(() => hasFailures ? 1 : 0, fileName_1 + ":25:8")(tsplus_module_1.logLine(summary.summary));
-    }, fileName_1 + ":15:28")(self.runSpec(spec));
-  }
-  main(_args) {
-    // const filteredSpec = this.spec.filterByArgs(args);
-    tsplus_module_8.unsafeRunAsyncWith(tsplus_module_7.provideLayer(this.runner.bootstrap, fileName_1 + ":33:20")(this.run(this.spec)), exit => {
-      tsplus_module_6.match(() => {
-        process.exit(1);
-      }, code => process.exit(code))(exit);
-    }, fileName_1 + ":34:26");
-  }
-}
-exports.RunnableSpec = RunnableSpec;
-function isRunnableSpec(u) {
-  return (0, _predicates.isObject)(u) && "_tag" in u && u["_tag"] === "RunnableSpec";
-}
-//# sourceMappingURL=RunnableSpec.cjs.map

package/_cjs/control/RunnableSpec.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"RunnableSpec.cjs","mappings":";;;;;;;;;;;;;;;AAGA;AACA;AACA;AAAgF;AAAA;;AAI1E,MAAgBA,YAAmB,SAAQC,0CAA0B;EAA3EC;;IACW,SAAI,GAAG,cAAc;EAgChC;EA/BEC,GAAG,CAACC,IAAgB;IAClB,MAAMC,IAAI,GAAG,IAAI;IACjB,+BACQC,OAAO;MACb,MAAMC,WAAW,GAAGC,qBAClB,qBAAQ,EACN;QACEC,IAAI,EAAE,CAAC;UAAEC;QAAI,CAAE,KAAKC,2BAAI;OACzB,EACD,MAAM,KAAK,CACZ,EANiBL,OAAO,CAO1B;MACD,MAAMM,OAAO,GAAGC,6BAA4BP,OAAO,CAAC;uCAE7CC,WAAW,GAAG,CAAC,GAAG,CAAC,wBADxBO,wBAAmBF,OAAO,CAACA,OAAO,CAAC;8BAVfP,IAAI,CAACU,OAAO,CAACX,IAAI,CAAC;EAa5C;EAEAY,IAAI,CAACC,KAAgB;IACnB;IACAC,gEACgB,IAAI,CAACC,MAAM,CAACC,SAAS,yBADrC,IAAI,CAACjB,GAAG,CAAC,IAAI,CAACC,IAAI,CAAC,CACmB,EACfiB,IAAI,IAAI;MAC3BC,sBACE,MAAK;QACHC,OAAO,CAACF,IAAI,CAAC,CAAC,CAAC;MACjB,CAAC,EACAG,IAAI,IAAKD,OAAO,CAACF,IAAI,CAACG,IAAI,CAAC,EAJ9BH,IAAI,CAKH;IACH,CAAC,wBAAC;EACN;;AACD;AAEK,SAAUI,cAAc,CAACC,CAAU;EACvC,OAAO,wBAAQ,EAACA,CAAC,CAAC,IAAI,MAAM,IAAIA,CAAC,IAAIA,CAAC,CAAC,MAAM,CAAC,KAAK,cAAc;AACnE","names":["RunnableSpec","AbstractRunnableSpec","constructor","run","spec","self","results","hasFailures","tsplus_module_5","Test","test","tsplus_module_4","summary","tsplus_module_3","tsplus_module_1","runSpec","main","_args","tsplus_module_8","runner","bootstrap","exit","tsplus_module_6","process","code","isRunnableSpec","u"],"sourceRoot":"","sources":["../../_src/control/RunnableSpec.ts"],"sourcesContent":[null]}