Repository: dubzzz/fast-check
Pull request #2524 (2021-11-30 08:22:46)

💥🚚 Rename `NextValue` into `Value`
`NextValue` has been introduced by version 2.15.0 of fast-check. It aims to provide an easy migration path towards version 3.0.0 by exposing the new types while keeping the legacy ones by default.

With the upcoming release of 3.0.0, those legacy types will disappear forever and Next versions will take the lead and be the new defaults. As a consequence there is no more `NextValue` but `Value`.

<!-- Context of the PR: short description and potentially linked issues -->

<!-- ...a few words to describe the content of this PR...               -->
<!-- ... -->

<!-- Type of PR: [ ] unchecked / [ ] checked -->
**_Category:_**

- [ ] ✨ Introduce new features
- [ ] 📝 Add or update documentation
- [ ] ✅ Add or update tests
- [ ] 🐛 Fix a bug
- [ ] 🏷️ Add or update types
- [ ] ⚡️ Improve performance
- [x] _Other(s):_ Breaking
<!-- Don't forget to add the gitmoji icon in the name of the PR -->
<!-- See: https://gitmoji.dev/                                  -->

<!-- Fixing bugs, adding features... may impact existing ones           -->
<!-- in order to track potential issues that could be related to your PR -->
<!-- please check the impacts and describe more precisely what to expect -->

**_Potential impacts:_**

<!-- Generated values: Can your change impact any of the existing generators in terms of generated values, if so which ones? when? -->
<!-- Shrink values:    Can your change impact any of the existing generators in terms of shrink values, if so which ones? when? -->
<!-- Performance:      Can it require some typings changes on user side? Please give more details -->
<!-- Typings:          Is there a potential performance impact? In which cases? -->
- [ ] Generated values
- [ ] Shrink values
- [ ] Performance
- [ ] Typings
- [ ] _Other(s):_ ...


codesandbox[bot]: This pull request is automatically built and testable in [CodeSandbox](https://codesandbox.io).

  To see build info of the built libraries, click [here](https://ci.codesandbox.io/status/dubzzz/fast-check/pr/2524/builds/193365) or the icon next to each commit SHA.

Latest deployment of this branch, based on commit 2ab3019636d454a22ff39ab43653685276bfe450:

|Sandbox| Source |
|--|--|
|[Vanilla](https://codesandbox.io/s/vanilla-mguu4)| Configuration |
|[fast-check-examples](https://codesandbox.io/s/fast-check-examples-73ydl)| Configuration |

codecov[bot]: # [Codecov](https://codecov.io/gh/dubzzz/fast-check/pull/2524?src=pr&el=h1&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Nicolas+DUBIEN) Report
> Merging [#2524](https://codecov.io/gh/dubzzz/fast-check/pull/2524?src=pr&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Nicolas+DUBIEN) (2ab3019) into [next-2_19_0](https://codecov.io/gh/dubzzz/fast-check/commit/9672885c2839182bd351d47664c0816a9bb6062d?el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Nicolas+DUBIEN) (9672885) will **decrease** coverage by `0.00%`.
> The diff coverage is `90.76%`.

[![Impacted file tree graph](https://codecov.io/gh/dubzzz/fast-check/pull/2524/graphs/tree.svg?width=650&height=150&src=pr&token=fRi2fJN730&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Nicolas+DUBIEN)](https://codecov.io/gh/dubzzz/fast-check/pull/2524?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Nicolas+DUBIEN)

```diff
@@               Coverage Diff               @@
##           next-2_19_0    #2524      +/-   ##
===============================================
- Coverage        94.41%   94.41%   -0.01%     
===============================================
  Files              186      186              
  Lines             4172     4170       -2     
  Branches           865      865              
===============================================
- Hits              3939     3937       -2     
  Misses             229      229              
  Partials             4        4              
```

| Flag | Coverage Δ | |
|---|---|---|
| unit-tests | `94.41% <90.76%> (-0.01%)` | :arrow_down: |

Flags with carried forward coverage won't be shown. [Click here](https://docs.codecov.io/docs/carryforward-flags?utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Nicolas+DUBIEN#carryforward-flags-in-the-pull-request-comment) to find out more.

| [Impacted Files](https://codecov.io/gh/dubzzz/fast-check/pull/2524?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Nicolas+DUBIEN) | Coverage Δ | |
|---|---|---|
| [src/check/property/IRawProperty.ts](https://codecov.io/gh/dubzzz/fast-check/pull/2524/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Nicolas+DUBIEN#diff-c3JjL2NoZWNrL3Byb3BlcnR5L0lSYXdQcm9wZXJ0eS50cw==) | `100.00% <ø> (ø)` | |
| [src/check/property/IgnoreEqualValuesProperty.ts](https://codecov.io/gh/dubzzz/fast-check/pull/2524/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Nicolas+DUBIEN#diff-c3JjL2NoZWNrL3Byb3BlcnR5L0lnbm9yZUVxdWFsVmFsdWVzUHJvcGVydHkudHM=) | `78.57% <0.00%> (ø)` | |
| [src/check/runner/Runner.ts](https://codecov.io/gh/dubzzz/fast-check/pull/2524/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Nicolas+DUBIEN#diff-c3JjL2NoZWNrL3J1bm5lci9SdW5uZXIudHM=) | `100.00% <ø> (ø)` | |
| [src/arbitrary/\_internals/CommandsArbitrary.ts](https://codecov.io/gh/dubzzz/fast-check/pull/2524/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Nicolas+DUBIEN#diff-c3JjL2FyYml0cmFyeS9faW50ZXJuYWxzL0NvbW1hbmRzQXJiaXRyYXJ5LnRz) | `12.19% <6.66%> (ø)` | |
| [src/check/property/UnbiasedProperty.ts](https://codecov.io/gh/dubzzz/fast-check/pull/2524/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Nicolas+DUBIEN#diff-c3JjL2NoZWNrL3Byb3BlcnR5L1VuYmlhc2VkUHJvcGVydHkudHM=) | `40.00% <50.00%> (ø)` | |
| [.../arbitrary/\_internals/AlwaysShrinkableArbitrary.ts](https://codecov.io/gh/dubzzz/fast-check/pull/2524/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Nicolas+DUBIEN#diff-c3JjL2FyYml0cmFyeS9faW50ZXJuYWxzL0Fsd2F5c1Nocmlua2FibGVBcmJpdHJhcnkudHM=) | `100.00% <100.00%> (ø)` | |
| [src/arbitrary/\_internals/ArrayArbitrary.ts](https://codecov.io/gh/dubzzz/fast-check/pull/2524/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Nicolas+DUBIEN#diff-c3JjL2FyYml0cmFyeS9faW50ZXJuYWxzL0FycmF5QXJiaXRyYXJ5LnRz) | `100.00% <100.00%> (ø)` | |
| [src/arbitrary/\_internals/ArrayInt64Arbitrary.ts](https://codecov.io/gh/dubzzz/fast-check/pull/2524/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Nicolas+DUBIEN#diff-c3JjL2FyYml0cmFyeS9faW50ZXJuYWxzL0FycmF5SW50NjRBcmJpdHJhcnkudHM=) | `94.25% <100.00%> (ø)` | |
| [src/arbitrary/\_internals/BigIntArbitrary.ts](https://codecov.io/gh/dubzzz/fast-check/pull/2524/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Nicolas+DUBIEN#diff-c3JjL2FyYml0cmFyeS9faW50ZXJuYWxzL0JpZ0ludEFyYml0cmFyeS50cw==) | `93.33% <100.00%> (ø)` | |
| [src/arbitrary/\_internals/CloneArbitrary.ts](https://codecov.io/gh/dubzzz/fast-check/pull/2524/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Nicolas+DUBIEN#diff-c3JjL2FyYml0cmFyeS9faW50ZXJuYWxzL0Nsb25lQXJiaXRyYXJ5LnRz) | `100.00% <100.00%> (ø)` | |
| ... and [24 more](https://codecov.io/gh/dubzzz/fast-check/pull/2524/diff?src=pr&el=tree-more&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Nicolas+DUBIEN) | |

------

[Continue to review full report at Codecov](https://codecov.io/gh/dubzzz/fast-check/pull/2524?src=pr&el=continue&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Nicolas+DUBIEN).
> **Legend** - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta?utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Nicolas+DUBIEN)
> `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data`
> Powered by [Codecov](https://codecov.io/gh/dubzzz/fast-check/pull/2524?src=pr&el=footer&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Nicolas+DUBIEN). Last update [9672885...2ab3019](https://codecov.io/gh/dubzzz/fast-check/pull/2524?src=pr&el=lastupdated&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Nicolas+DUBIEN). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments?utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Nicolas+DUBIEN).


Patch:
diff --git a/src/arbitrary/_internals/AlwaysShrinkableArbitrary.ts b/src/arbitrary/_internals/AlwaysShrinkableArbitrary.ts
index f28298ba..196e1133 100644
--- a/src/arbitrary/_internals/AlwaysShrinkableArbitrary.ts
+++ b/src/arbitrary/_internals/AlwaysShrinkableArbitrary.ts
@@ -1,5 +1,5 @@
 import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary';
-import { NextValue } from '../../check/arbitrary/definition/NextValue';
+import { Value } from '../../check/arbitrary/definition/Value';
 import { Random } from '../../random/generator/Random';
 import { Stream } from '../../stream/Stream';
 import { noUndefinedAsContext, UndefinedContextPlaceholder } from './helpers/NoUndefinedAsContext';
@@ -15,7 +15,7 @@ export class AlwaysShrinkableArbitrary<Ts> extends Arbitrary<Ts> {
     super();
   }
 
-  generate(mrng: Random, biasFactor: number | undefined): NextValue<Ts> {
+  generate(mrng: Random, biasFactor: number | undefined): Value<Ts> {
     const value = this.arb.generate(mrng, biasFactor);
     return noUndefinedAsContext(value);
   }
@@ -24,7 +24,7 @@ export class AlwaysShrinkableArbitrary<Ts> extends Arbitrary<Ts> {
     return true;
   }
 
-  shrink(value: Ts, context: unknown): Stream<NextValue<Ts>> {
+  shrink(value: Ts, context: unknown): Stream<Value<Ts>> {
     if (context === undefined && !this.arb.canShrinkWithoutContext(value)) {
       // This arbitrary will never produce any context being `undefined`
       // neither during `generate` nor during `shrink`
diff --git a/src/arbitrary/_internals/ArrayArbitrary.ts b/src/arbitrary/_internals/ArrayArbitrary.ts
index c34afde8..651e8f20 100644
--- a/src/arbitrary/_internals/ArrayArbitrary.ts
+++ b/src/arbitrary/_internals/ArrayArbitrary.ts
@@ -5,7 +5,7 @@ import { integer } from '../integer';
 import { makeLazy } from '../../stream/LazyIterableIterator';
 import { buildCompareFilter } from './helpers/BuildCompareFilter';
 import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary';
-import { NextValue } from '../../check/arbitrary/definition/NextValue';
+import { Value } from '../../check/arbitrary/definition/Value';
 
 /** @internal */
 type ArrayArbitraryContext = {
@@ -18,7 +18,7 @@ type ArrayArbitraryContext = {
 /** @internal */
 export class ArrayArbitrary<T> extends Arbitrary<T[]> {
   readonly lengthArb: Arbitrary<number>;
-  readonly preFilter: (tab: NextValue<T>[]) => NextValue<T>[];
+  readonly preFilter: (tab: Value<T>[]) => Value<T>[];
 
   constructor(
     readonly arb: Arbitrary<T>,
@@ -30,10 +30,10 @@ export class ArrayArbitrary<T> extends Arbitrary<T[]> {
   ) {
     super();
     this.lengthArb = integer(minLength, maxLength);
-    this.preFilter = this.isEqual !== undefined ? buildCompareFilter(this.isEqual) : (tab: NextValue<T>[]) => tab;
+    this.preFilter = this.isEqual !== undefined ? buildCompareFilter(this.isEqual) : (tab: Value<T>[]) => tab;
   }
 
-  private static makeItCloneable<T>(vs: T[], shrinkables: NextValue<T>[]) {
+  private static makeItCloneable<T>(vs: T[], shrinkables: Value<T>[]) {
     (vs as any)[cloneMethod] = () => {
       const cloned = [];
       for (let idx = 0; idx !== shrinkables.length; ++idx) {
@@ -46,8 +46,8 @@ export class ArrayArbitrary<T> extends Arbitrary<T[]> {
   }
 
   private static canAppendItem<T>(
-    items: NextValue<T>[],
-    newItem: NextValue<T>,
+    items: Value<T>[],
+    newItem: Value<T>,
     isEqual: (valueA: T, valueB: T) => boolean
   ): boolean {
     for (let idx = 0; idx !== items.length; ++idx) {
@@ -58,9 +58,9 @@ export class ArrayArbitrary<T> extends Arbitrary<T[]> {
     return true;
   }
 
-  private generateNItemsNoDuplicates(N: number, mrng: Random, biasFactorItems: number | undefined): NextValue<T>[] {
+  private generateNItemsNoDuplicates(N: number, mrng: Random, biasFactorItems: number | undefined): Value<T>[] {
     let numSkippedInRow = 0;
-    const items: NextValue<T>[] = [];
+    const items: Value<T>[] = [];
     // Try to append into items up to the target size
     // In the case of a set we may reject some items as they are already part of the set
     // so we need to retry and generate other ones. In order to prevent infinite loop,
@@ -78,8 +78,8 @@ export class ArrayArbitrary<T> extends Arbitrary<T[]> {
     return items;
   }
 
-  private generateNItems(N: number, mrng: Random, biasFactorItems: number | undefined): NextValue<T>[] {
-    const items: NextValue<T>[] = [];
+  private generateNItems(N: number, mrng: Random, biasFactorItems: number | undefined): Value<T>[] {
+    const items: Value<T>[] = [];
     for (let index = 0; index !== N; ++index) {
       const current = this.arb.generate(mrng, biasFactorItems);
       items.push(current);
@@ -88,11 +88,11 @@ export class ArrayArbitrary<T> extends Arbitrary<T[]> {
   }
 
   private wrapper(
-    itemsRaw: NextValue<T>[],
+    itemsRaw: Value<T>[],
     shrunkOnce: boolean,
     itemsRawLengthContext: unknown,
     startIndex: number
-  ): NextValue<T[]> {
+  ): Value<T[]> {
     // We need to explicitly apply filtering on shrink items
     // has they might have duplicates (on non shrunk it is not the case by construct)
     const items = shrunkOnce ? this.preFilter(itemsRaw) : itemsRaw;
@@ -117,10 +117,10 @@ export class ArrayArbitrary<T> extends Arbitrary<T[]> {
       itemsContexts,
       startIndex,
     };
-    return new NextValue(vs, context);
+    return new Value(vs, context);
   }
 
-  generate(mrng: Random, biasFactor: number | undefined): NextValue<T[]> {
+  generate(mrng: Random, biasFactor: number | undefined): Value<T[]> {
     const biasMeta = this.applyBias(mrng, biasFactor);
     const targetSize = biasMeta.size;
     const items =
@@ -171,7 +171,7 @@ export class ArrayArbitrary<T> extends Arbitrary<T[]> {
     }
     // `preFilter` only drops items, it does not reorder them or add some more
     // if calling it with `value` results into a smaller array it means that the value was not generated by this instance
-    const filtered = this.preFilter(value.map((item) => new NextValue(item, undefined)));
+    const filtered = this.preFilter(value.map((item) => new Value(item, undefined)));
     return filtered.length === value.length;
   }
 
@@ -179,33 +179,31 @@ export class ArrayArbitrary<T> extends Arbitrary<T[]> {
     value: T[],
     safeContext: ArrayArbitraryContext,
     endIndex: number
-  ): IterableIterator<[NextValue<T>[], unknown, number]> {
-    let shrinks = Stream.nil<[NextValue<T>[], unknown, number]>();
+  ): IterableIterator<[Value<T>[], unknown, number]> {
+    let shrinks = Stream.nil<[Value<T>[], unknown, number]>();
     for (let index = safeContext.startIndex; index < endIndex; ++index) {
       shrinks = shrinks.join(
         makeLazy(() =>
-          this.arb
-            .shrink(value[index], safeContext.itemsContexts[index])
-            .map((v): [NextValue<T>[], unknown, number] => {
-              const beforeCurrent = value
-                .slice(0, index)
-                .map((v, i) => new NextValue(cloneIfNeeded(v), safeContext.itemsContexts[i]));
-              const afterCurrent = value
-                .slice(index + 1)
-                .map((v, i) => new NextValue(cloneIfNeeded(v), safeContext.itemsContexts[i + index + 1]));
-              return [
-                beforeCurrent.concat(v).concat(afterCurrent),
-                undefined, // no length context
-                index, // avoid shrinking entries before index in sub-shrinks
-              ];
-            })
+          this.arb.shrink(value[index], safeContext.itemsContexts[index]).map((v): [Value<T>[], unknown, number] => {
+            const beforeCurrent = value
+              .slice(0, index)
+              .map((v, i) => new Value(cloneIfNeeded(v), safeContext.itemsContexts[i]));
+            const afterCurrent = value
+              .slice(index + 1)
+              .map((v, i) => new Value(cloneIfNeeded(v), safeContext.itemsContexts[i + index + 1]));
+            return [
+              beforeCurrent.concat(v).concat(afterCurrent),
+              undefined, // no length context
+              index, // avoid shrinking entries before index in sub-shrinks
+            ];
+          })
         )
       );
     }
     return shrinks;
   }
 
-  private shrinkImpl(value: T[], context?: unknown): Stream<[NextValue<T>[], unknown, number]> {
+  private shrinkImpl(value: T[], context?: unknown): Stream<[Value<T>[], unknown, number]> {
     if (value.length === 0) {
       return Stream.nil();
     }
@@ -228,12 +226,12 @@ export class ArrayArbitrary<T> extends Arbitrary<T[]> {
         .drop(
           safeContext.shrunkOnce && safeContext.lengthContext === undefined && value.length > this.minLength + 1 ? 1 : 0
         )
-        .map((lengthValue): [NextValue<T>[], unknown, number] => {
+        .map((lengthValue): [Value<T>[], unknown, number] => {
           const sliceStart = value.length - lengthValue.value;
           return [
             value
               .slice(sliceStart)
-              .map((v, index) => new NextValue(cloneIfNeeded(v), safeContext.itemsContexts[index + sliceStart])), // array of length lengthValue.value
+              .map((v, index) => new Value(cloneIfNeeded(v), safeContext.itemsContexts[index + sliceStart])), // array of length lengthValue.value
             lengthValue.context, // integer context for value lengthValue.value (the length)
             0,
           ];
@@ -261,9 +259,9 @@ export class ArrayArbitrary<T> extends Arbitrary<T[]> {
                 };
                 return this.shrinkImpl(value.slice(1), subContext)
                   .filter((v) => this.minLength <= v[0].length + 1)
-                  .map((v): [NextValue<T>[], unknown, number] => {
+                  .map((v): [Value<T>[], unknown, number] => {
                     return [
-                      [new NextValue(cloneIfNeeded(value[0]), safeContext.itemsContexts[0])].concat(v[0]),
+                      [new Value(cloneIfNeeded(value[0]), safeContext.itemsContexts[0])].concat(v[0]),
                       undefined,
                       0,
                     ];
@@ -274,7 +272,7 @@ export class ArrayArbitrary<T> extends Arbitrary<T[]> {
     );
   }
 
-  shrink(value: T[], context?: unknown): Stream<NextValue<T[]>> {
+  shrink(value: T[], context?: unknown): Stream<Value<T[]>> {
     return this.shrinkImpl(value, context).map((contextualValue) =>
       this.wrapper(contextualValue[0], true, contextualValue[1], contextualValue[2])
     );
diff --git a/src/arbitrary/_internals/ArrayInt64Arbitrary.ts b/src/arbitrary/_internals/ArrayInt64Arbitrary.ts
index fdbe6030..f6fc87d8 100644
--- a/src/arbitrary/_internals/ArrayInt64Arbitrary.ts
+++ b/src/arbitrary/_internals/ArrayInt64Arbitrary.ts
@@ -1,7 +1,7 @@
 import { Random } from '../../random/generator/Random';
 import { stream, Stream } from '../../stream/Stream';
 import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary';
-import { NextValue } from '../../check/arbitrary/definition/NextValue';
+import { Value } from '../../check/arbitrary/definition/Value';
 import {
   add64,
   ArrayInt64,
@@ -25,14 +25,14 @@ class ArrayInt64Arbitrary extends Arbitrary<ArrayInt64> {
     super();
   }
 
-  generate(mrng: Random, biasFactor: number | undefined): NextValue<ArrayInt64> {
+  generate(mrng: Random, biasFactor: number | undefined): Value<ArrayInt64> {
     const range = this.computeGenerateRange(mrng, biasFactor);
     const uncheckedValue = mrng.nextArrayInt(range.min, range.max);
     if (uncheckedValue.data.length === 1) {
       // either 1 or 2, never 0 or >2
       uncheckedValue.data.unshift(0); // prepend a zero
     }
-    return new NextValue(uncheckedValue as ArrayInt64, undefined);
+    return new Value(uncheckedValue as ArrayInt64, undefined);
   }
   private computeGenerateRange(mrng: Random, biasFactor: number | undefined): { min: ArrayInt64; max: ArrayInt64 } {
     if (biasFactor === undefined || mrng.nextInt(1, biasFactor) !== 1) {
@@ -60,25 +60,21 @@ class ArrayInt64Arbitrary extends Arbitrary<ArrayInt64> {
     );
   }
 
-  private shrinkArrayInt64(
-    value: ArrayInt64,
-    target: ArrayInt64,
-    tryTargetAsap?: boolean
-  ): Stream<NextValue<ArrayInt64>> {
+  private shrinkArrayInt64(value: ArrayInt64, target: ArrayInt64, tryTargetAsap?: boolean): Stream<Value<ArrayInt64>> {
     const realGap = substract64(value, target);
-    function* shrinkGen(): IterableIterator<NextValue<ArrayInt64>> {
+    function* shrinkGen(): IterableIterator<Value<ArrayInt64>> {
       let previous: ArrayInt64 | undefined = tryTargetAsap ? undefined : target;
       const gap = tryTargetAsap ? realGap : halve64(realGap);
       for (let toremove = gap; !isZero64(toremove); toremove = halve64(toremove)) {
         const next = substract64(value, toremove);
-        yield new NextValue(next, previous); // previous indicates the last passing value
+        yield new Value(next, previous); // previous indicates the last passing value
         previous = next;
       }
     }
     return stream(shrinkGen());
   }
 
-  shrink(current: ArrayInt64, context?: unknown): Stream<NextValue<ArrayInt64>> {
+  shrink(current: ArrayInt64, context?: unknown): Stream<Value<ArrayInt64>> {
     if (!ArrayInt64Arbitrary.isValidContext(current, context)) {
       // No context:
       //   Take default target and shrink towards it
@@ -90,7 +86,7 @@ class ArrayInt64Arbitrary extends Arbitrary<ArrayInt64> {
       // Last chance try...
       // context is set to undefined, so that shrink will restart
       // without any assumptions in case our try find yet another bug
-      return Stream.of(new NextValue(context, undefined));
+      return Stream.of(new Value(context, undefined));
     }
     // Normal shrink process
     return this.shrinkArrayInt64(current, context, false);
diff --git a/src/arbitrary/_internals/BigIntArbitrary.ts b/src/arbitrary/_internals/BigIntArbitrary.ts
index 8c63fa5c..c41170da 100644
--- a/src/arbitrary/_internals/BigIntArbitrary.ts
+++ b/src/arbitrary/_internals/BigIntArbitrary.ts
@@ -1,7 +1,7 @@
 import { Random } from '../../random/generator/Random';
 import { Stream } from '../../stream/Stream';
 import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary';
-import { NextValue } from '../../check/arbitrary/definition/NextValue';
+import { Value } from '../../check/arbitrary/definition/Value';
 import { biasNumericRange, bigIntLogLike } from './helpers/BiasNumericRange';
 import { shrinkBigInt } from './helpers/ShrinkBigInt';
 
@@ -11,9 +11,9 @@ export class BigIntArbitrary extends Arbitrary<bigint> {
     super();
   }
 
-  generate(mrng: Random, biasFactor: number | undefined): NextValue<bigint> {
+  generate(mrng: Random, biasFactor: number | undefined): Value<bigint> {
     const range = this.computeGenerateRange(mrng, biasFactor);
-    return new NextValue(mrng.nextBigInt(range.min, range.max), undefined);
+    return new Value(mrng.nextBigInt(range.min, range.max), undefined);
   }
   private computeGenerateRange(mrng: Random, biasFactor: number | undefined): { min: bigint; max: bigint } {
     if (biasFactor === undefined || mrng.nextInt(1, biasFactor) !== 1) {
@@ -31,7 +31,7 @@ export class BigIntArbitrary extends Arbitrary<bigint> {
     return typeof value === 'bigint' && this.min <= value && value <= this.max;
   }
 
-  shrink(current: bigint, context?: unknown): Stream<NextValue<bigint>> {
+  shrink(current: bigint, context?: unknown): Stream<Value<bigint>> {
     if (!BigIntArbitrary.isValidContext(current, context)) {
       // No context:
       //   Take default target and shrink towards it
@@ -43,7 +43,7 @@ export class BigIntArbitrary extends Arbitrary<bigint> {
       // Last chance try...
       // context is set to undefined, so that shrink will restart
       // without any assumptions in case our try find yet another bug
-      return Stream.of(new NextValue(context, undefined));
+      return Stream.of(new Value(context, undefined));
     }
     // Normal shrink process
     return shrinkBigInt(current, context, false);
diff --git a/src/arbitrary/_internals/CloneArbitrary.ts b/src/arbitrary/_internals/CloneArbitrary.ts
index 33974fb3..966bf772 100644
--- a/src/arbitrary/_internals/CloneArbitrary.ts
+++ b/src/arbitrary/_internals/CloneArbitrary.ts
@@ -1,5 +1,5 @@
 import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary';
-import { NextValue } from '../../check/arbitrary/definition/NextValue';
+import { Value } from '../../check/arbitrary/definition/Value';
 import { cloneMethod } from '../../check/symbols';
 import { Random } from '../../random/generator/Random';
 import { Stream } from '../../stream/Stream';
@@ -10,8 +10,8 @@ export class CloneArbitrary<T> extends Arbitrary<T[]> {
     super();
   }
 
-  generate(mrng: Random, biasFactor: number | undefined): NextValue<T[]> {
-    const items: NextValue<T>[] = [];
+  generate(mrng: Random, biasFactor: number | undefined): Value<T[]> {
+    const items: Value<T>[] = [];
     if (this.numValues <= 0) {
       return this.wrapper(items);
     }
@@ -41,7 +41,7 @@ export class CloneArbitrary<T> extends Arbitrary<T[]> {
     return this.arb.canShrinkWithoutContext(value[0]);
   }
 
-  shrink(value: T[], context?: unknown): Stream<NextValue<T[]>> {
+  shrink(value: T[], context?: unknown): Stream<Value<T[]>> {
     if (value.length === 0) {
       return Stream.nil();
     }
@@ -50,7 +50,7 @@ export class CloneArbitrary<T> extends Arbitrary<T[]> {
     );
   }
 
-  private *shrinkImpl(value: T[], contexts: unknown[]): IterableIterator<NextValue<T>[]> {
+  private *shrinkImpl(value: T[], contexts: unknown[]): IterableIterator<Value<T>[]> {
     const its = value.map((v, idx) => this.arb.shrink(v, contexts[idx])[Symbol.iterator]());
     let cur = its.map((it) => it.next());
     while (!cur[0].done) {
@@ -59,7 +59,7 @@ export class CloneArbitrary<T> extends Arbitrary<T[]> {
     }
   }
 
-  private static makeItCloneable<T>(vs: T[], shrinkables: NextValue<T>[]) {
+  private static makeItCloneable<T>(vs: T[], shrinkables: Value<T>[]) {
     (vs as any)[cloneMethod] = () => {
       const cloned = [];
       for (let idx = 0; idx !== shrinkables.length; ++idx) {
@@ -71,7 +71,7 @@ export class CloneArbitrary<T> extends Arbitrary<T[]> {
     return vs;
   }
 
-  private wrapper(items: NextValue<T>[]): NextValue<T[]> {
+  private wrapper(items: Value<T>[]): Value<T[]> {
     let cloneable = false;
     const vs: T[] = [];
     const contexts: unknown[] = [];
@@ -84,6 +84,6 @@ export class CloneArbitrary<T> extends Arbitrary<T[]> {
     if (cloneable) {
       CloneArbitrary.makeItCloneable(vs, items);
     }
-    return new NextValue(vs, contexts);
+    return new Value(vs, contexts);
   }
 }
diff --git a/src/arbitrary/_internals/CommandsArbitrary.ts b/src/arbitrary/_internals/CommandsArbitrary.ts
index 3b526db8..20d17ef1 100644
--- a/src/arbitrary/_internals/CommandsArbitrary.ts
+++ b/src/arbitrary/_internals/CommandsArbitrary.ts
@@ -1,5 +1,5 @@
 import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary';
-import { NextValue } from '../../check/arbitrary/definition/NextValue';
+import { Value } from '../../check/arbitrary/definition/Value';
 import { ICommand } from '../../check/model/command/ICommand';
 import { CommandsIterable } from '../../check/model/commands/CommandsIterable';
 import { CommandWrapper } from '../../check/model/commands/CommandWrapper';
@@ -13,7 +13,7 @@ import { IntegerArbitrary } from './IntegerArbitrary';
 // eslint-disable-next-line @typescript-eslint/ban-types
 type CommandsArbitraryContext<Model extends object, Real, RunResult, CheckAsync extends boolean> = {
   shrunkOnce: boolean;
-  items: NextValue<CommandWrapper<Model, Real, RunResult, CheckAsync>>[];
+  items: Value<CommandWrapper<Model, Real, RunResult, CheckAsync>>[];
 };
 
 /** @internal */
@@ -42,27 +42,24 @@ export class CommandsArbitrary<Model extends object, Real, RunResult, CheckAsync
     return this.disableReplayLog ? '' : `replayPath=${JSON.stringify(ReplayPath.stringify(this.replayPath))}`;
   }
 
-  private buildNextValueFor(
-    items: NextValue<CommandWrapper<Model, Real, RunResult, CheckAsync>>[],
-    shrunkOnce: boolean
-  ) {
+  private buildValueFor(items: Value<CommandWrapper<Model, Real, RunResult, CheckAsync>>[], shrunkOnce: boolean) {
     const commands = items.map((item) => item.value_);
     const context: CommandsArbitraryContext<Model, Real, RunResult, CheckAsync> = { shrunkOnce, items };
-    return new NextValue(new CommandsIterable(commands, () => this.metadataForReplay()), context);
+    return new Value(new CommandsIterable(commands, () => this.metadataForReplay()), context);
   }
 
-  generate(mrng: Random): NextValue<CommandsIterable<Model, Real, RunResult, CheckAsync>> {
+  generate(mrng: Random): Value<CommandsIterable<Model, Real, RunResult, CheckAsync>> {
     // For the moment, we fully ignore the bias on commands...
     const size = this.lengthArb.generate(mrng, undefined);
     const sizeValue = size.value;
-    const items: NextValue<CommandWrapper<Model, Real, RunResult, CheckAsync>>[] = Array(sizeValue);
+    const items: Value<CommandWrapper<Model, Real, RunResult, CheckAsync>>[] = Array(sizeValue);
     for (let idx = 0; idx !== sizeValue; ++idx) {
       // ...even when generating the commands themselves
       const item = this.oneCommandArb.generate(mrng, undefined);
       items[idx] = item;
     }
     this.replayPathPosition = 0; // reset replay
-    return this.buildNextValueFor(items, false);
+    return this.buildValueFor(items, false);
   }
 
   canShrinkWithoutContext(value: unknown): value is CommandsIterable<Model, Real, RunResult, CheckAsync> {
@@ -71,7 +68,7 @@ export class CommandsArbitrary<Model extends object, Real, RunResult, CheckAsync
   }
 
   /** Filter commands based on the real status of the execution */
-  private filterOnExecution(itemsRaw: NextValue<CommandWrapper<Model, Real, RunResult, CheckAsync>>[]) {
+  private filterOnExecution(itemsRaw: Value<CommandWrapper<Model, Real, RunResult, CheckAsync>>[]) {
     const items: typeof itemsRaw = [];
     for (const c of itemsRaw) {
       if (c.value_.hasRan) {
@@ -83,7 +80,7 @@ export class CommandsArbitrary<Model extends object, Real, RunResult, CheckAsync
   }
 
   /** Filter commands based on the internal replay state */
-  private filterOnReplay(itemsRaw: NextValue<CommandWrapper<Model, Real, RunResult, CheckAsync>>[]) {
+  private filterOnReplay(itemsRaw: Value<CommandWrapper<Model, Real, RunResult, CheckAsync>>[]) {
     return itemsRaw.filter((c, idx) => {
       const state = this.replayPath[this.replayPathPosition + idx];
       if (state === undefined) throw new Error(`Too short replayPath`);
@@ -93,7 +90,7 @@ export class CommandsArbitrary<Model extends object, Real, RunResult, CheckAsync
   }
 
   /** Filter commands for shrinking purposes */
-  private filterForShrinkImpl(itemsRaw: NextValue<CommandWrapper<Model, Real, RunResult, CheckAsync>>[]) {
+  private filterForShrinkImpl(itemsRaw: Value<CommandWrapper<Model, Real, RunResult, CheckAsync>>[]) {
     if (this.replayPathPosition === 0) {
       this.replayPath = this.sourceReplayPath !== null ? ReplayPath.parse(this.sourceReplayPath) : [];
     }
@@ -108,9 +105,9 @@ export class CommandsArbitrary<Model extends object, Real, RunResult, CheckAsync
   shrink(
     _value: CommandsIterable<Model, Real, RunResult, CheckAsync>,
     context: unknown
-  ): Stream<NextValue<CommandsIterable<Model, Real, RunResult, CheckAsync>>> {
+  ): Stream<Value<CommandsIterable<Model, Real, RunResult, CheckAsync>>> {
     if (context === undefined) {
-      return Stream.nil<NextValue<CommandsIterable<Model, Real, RunResult, CheckAsync>>>();
+      return Stream.nil<Value<CommandsIterable<Model, Real, RunResult, CheckAsync>>>();
     }
     const safeContext = context as CommandsArbitraryContext<Model, Real, RunResult, CheckAsync>;
 
@@ -119,12 +116,12 @@ export class CommandsArbitrary<Model extends object, Real, RunResult, CheckAsync
 
     const items = this.filterForShrinkImpl(itemsRaw); // filter out commands that have not been executed
     if (items.length === 0) {
-      return Stream.nil<NextValue<CommandsIterable<Model, Real, RunResult, CheckAsync>>>();
+      return Stream.nil<Value<CommandsIterable<Model, Real, RunResult, CheckAsync>>>();
     }
 
     // The shrinker of commands have to keep the last item
     // because it is the one causing the failure
-    const rootShrink: Stream<NextValue<CommandWrapper<Model, Real, RunResult, CheckAsync>>[]> = shrunkOnce
+    const rootShrink: Stream<Value<CommandWrapper<Model, Real, RunResult, CheckAsync>>[]> = shrunkOnce
       ? Stream.nil()
       : new Stream([[]][Symbol.iterator]());
 
@@ -134,7 +131,7 @@ export class CommandsArbitrary<Model extends object, Real, RunResult, CheckAsync
     // Indeed calling stream[n].next() would require to call stream[n-1].next() and so on...
     // Instead of that we define stream[n] = rootShrink.join(nextFor[0], ..., nextFor[n])
     // So that calling next on stream[n] will not have to run too many recursions
-    const nextShrinks: IterableIterator<NextValue<CommandWrapper<Model, Real, RunResult, CheckAsync>>[]>[] = [];
+    const nextShrinks: IterableIterator<Value<CommandWrapper<Model, Real, RunResult, CheckAsync>>[]>[] = [];
 
     // keep fixed number commands at the beginning
     // remove items in remaining part except the last one
@@ -161,8 +158,8 @@ export class CommandsArbitrary<Model extends object, Real, RunResult, CheckAsync
     }
 
     return rootShrink.join(...nextShrinks).map((shrinkables) => {
-      return this.buildNextValueFor(
-        shrinkables.map((c) => new NextValue(c.value_.clone(), c.context)),
+      return this.buildValueFor(
+        shrinkables.map((c) => new Value(c.value_.clone(), c.context)),
         true
       );
     });
diff --git a/src/arbitrary/_internals/ConstantArbitrary.ts b/src/arbitrary/_internals/ConstantArbitrary.ts
index a00ab8a8..7250203b 100644
--- a/src/arbitrary/_internals/ConstantArbitrary.ts
+++ b/src/arbitrary/_internals/ConstantArbitrary.ts
@@ -1,7 +1,7 @@
 import { Random } from '../../random/generator/Random';
 import { Stream } from '../../stream/Stream';
 import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary';
-import { NextValue } from '../../check/arbitrary/definition/NextValue';
+import { Value } from '../../check/arbitrary/definition/Value';
 import { cloneMethod, hasCloneMethod } from '../../check/symbols';
 
 /** @internal */
@@ -9,13 +9,13 @@ export class ConstantArbitrary<T> extends Arbitrary<T> {
   constructor(readonly values: T[]) {
     super();
   }
-  generate(mrng: Random, _biasFactor: number | undefined): NextValue<T> {
+  generate(mrng: Random, _biasFactor: number | undefined): Value<T> {
     const idx = this.values.length === 1 ? 0 : mrng.nextInt(0, this.values.length - 1);
     const value = this.values[idx];
     if (!hasCloneMethod(value)) {
-      return new NextValue(value, idx);
+      return new Value(value, idx);
     }
-    return new NextValue(value, idx, () => value[cloneMethod]());
+    return new Value(value, idx, () => value[cloneMethod]());
   }
   canShrinkWithoutContext(value: unknown): value is T {
     for (let idx = 0; idx !== this.values.length; ++idx) {
@@ -25,10 +25,10 @@ export class ConstantArbitrary<T> extends Arbitrary<T> {
     }
     return false;
   }
-  shrink(value: T, context?: unknown): Stream<NextValue<T>> {
+  shrink(value: T, context?: unknown): Stream<Value<T>> {
     if (context === 0 || Object.is(value, this.values[0])) {
       return Stream.nil();
     }
-    return Stream.of(new NextValue(this.values[0], 0));
+    return Stream.of(new Value(this.values[0], 0));
   }
 }
diff --git a/src/arbitrary/_internals/FrequencyArbitrary.ts b/src/arbitrary/_internals/FrequencyArbitrary.ts
index d23be59f..91a64409 100644
--- a/src/arbitrary/_internals/FrequencyArbitrary.ts
+++ b/src/arbitrary/_internals/FrequencyArbitrary.ts
@@ -1,7 +1,7 @@
 import { Random } from '../../random/generator/Random';
 import { Stream } from '../../stream/Stream';
 import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary';
-import { NextValue } from '../../check/arbitrary/definition/NextValue';
+import { Value } from '../../check/arbitrary/definition/Value';
 import { DepthContext, getDepthContextFor } from './helpers/DepthContext';
 
 /** @internal */
@@ -57,7 +57,7 @@ export class FrequencyArbitrary<T> extends Arbitrary<T> {
     this.totalWeight = currentWeight;
   }
 
-  generate(mrng: Random, biasFactor: number | undefined): NextValue<T> {
+  generate(mrng: Random, biasFactor: number | undefined): Value<T> {
     if (this.mustGenerateFirst()) {
       // index=0 can be selected even if it has a weight equal to zero
       return this.safeGenerateForIndex(mrng, 0, biasFactor);
@@ -75,7 +75,7 @@ export class FrequencyArbitrary<T> extends Arbitrary<T> {
     return this.canShrinkWithoutContextIndex(value) !== -1;
   }
 
-  shrink(value: T, context?: unknown): Stream<NextValue<T>> {
+  shrink(value: T, context?: unknown): Stream<Value<T>> {
     if (context !== undefined) {
       const safeContext = context as _FrequencyArbitraryContext<T>;
       const selectedIndex = safeContext.selectedIndex;
@@ -83,7 +83,7 @@ export class FrequencyArbitrary<T> extends Arbitrary<T> {
       const originalArbitrary = this.warbs[selectedIndex].arbitrary;
       const originalShrinks = originalArbitrary
         .shrink(value, safeContext.originalContext)
-        .map((v) => this.mapIntoNextValue(selectedIndex, v, null, originalBias));
+        .map((v) => this.mapIntoValue(selectedIndex, v, null, originalBias));
       if (safeContext.clonedMrngForFallbackFirst !== null) {
         if (safeContext.cachedGeneratedForFirst === undefined) {
           safeContext.cachedGeneratedForFirst = this.safeGenerateForIndex(
@@ -104,12 +104,12 @@ export class FrequencyArbitrary<T> extends Arbitrary<T> {
     return this.defaultShrinkForFirst(potentialSelectedIndex).join(
       this.warbs[potentialSelectedIndex].arbitrary
         .shrink(value, undefined) // re-checked by canShrinkWithoutContextIndex
-        .map((v) => this.mapIntoNextValue(potentialSelectedIndex, v, null, undefined))
+        .map((v) => this.mapIntoValue(potentialSelectedIndex, v, null, undefined))
     );
   }
 
   /** Generate shrink values for first arbitrary when no context and no value was provided */
-  private defaultShrinkForFirst(selectedIndex: number): Stream<NextValue<T>> {
+  private defaultShrinkForFirst(selectedIndex: number): Stream<Value<T>> {
     ++this.context.depth; // increase depth
     try {
       if (!this.mustFallbackToFirstInShrink(selectedIndex) || this.warbs[0].fallbackValue === undefined) {
@@ -120,8 +120,8 @@ export class FrequencyArbitrary<T> extends Arbitrary<T> {
       --this.context.depth; // decrease depth (reset depth)
     }
     // The arbitrary at [0] accepts to shrink fallbackValue.default without any context (context=undefined)
-    const rawShrinkValue = new NextValue(this.warbs[0].fallbackValue.default, undefined);
-    return Stream.of(this.mapIntoNextValue(0, rawShrinkValue, null, undefined));
+    const rawShrinkValue = new Value(this.warbs[0].fallbackValue.default, undefined);
+    return Stream.of(this.mapIntoValue(0, rawShrinkValue, null, undefined));
   }
 
   /** Extract the index of the generator that would have been able to gennrate the value */
@@ -144,28 +144,28 @@ export class FrequencyArbitrary<T> extends Arbitrary<T> {
   }
 
   /** Map the output of one of the children with the context of frequency */
-  private mapIntoNextValue(
+  private mapIntoValue(
     idx: number,
-    value: NextValue<T>,
+    value: Value<T>,
     clonedMrngForFallbackFirst: Random | null,
     biasFactor: number | undefined
-  ): NextValue<T> {
+  ): Value<T> {
     const context: _FrequencyArbitraryContext<T> = {
       selectedIndex: idx,
       originalBias: biasFactor,
       originalContext: value.context,
       clonedMrngForFallbackFirst,
     };
-    return new NextValue(value.value, context);
+    return new Value(value.value, context);
   }
 
   /** Generate using Arbitrary at index idx and safely handle depth context */
-  private safeGenerateForIndex(mrng: Random, idx: number, biasFactor: number | undefined): NextValue<T> {
+  private safeGenerateForIndex(mrng: Random, idx: number, biasFactor: number | undefined): Value<T> {
     ++this.context.depth; // increase depth
     try {
       const value = this.warbs[idx].arbitrary.generate(mrng, biasFactor);
       const clonedMrngForFallbackFirst = this.mustFallbackToFirstInShrink(idx) ? mrng.clone() : null;
-      return this.mapIntoNextValue(idx, value, clonedMrngForFallbackFirst, biasFactor);
+      return this.mapIntoValue(idx, value, clonedMrngForFallbackFirst, biasFactor);
     } finally {
       --this.context.depth; // decrease depth (reset depth)
     }
@@ -225,5 +225,5 @@ type _FrequencyArbitraryContext<T> = {
   originalBias: number | undefined;
   originalContext: unknown;
   clonedMrngForFallbackFirst: Random | null;
-  cachedGeneratedForFirst?: NextValue<T>;
+  cachedGeneratedForFirst?: Value<T>;
 };
diff --git a/src/arbitrary/_internals/IntegerArbitrary.ts b/src/arbitrary/_internals/IntegerArbitrary.ts
index ae37b4b4..5c9cfa29 100644
--- a/src/arbitrary/_internals/IntegerArbitrary.ts
+++ b/src/arbitrary/_internals/IntegerArbitrary.ts
@@ -1,5 +1,5 @@
 import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary';
-import { NextValue } from '../../check/arbitrary/definition/NextValue';
+import { Value } from '../../check/arbitrary/definition/Value';
 import { Random } from '../../random/generator/Random';
 import { Stream } from '../../stream/Stream';
 import { integerLogLike, biasNumericRange } from './helpers/BiasNumericRange';
@@ -11,9 +11,9 @@ export class IntegerArbitrary extends Arbitrary<number> {
     super();
   }
 
-  generate(mrng: Random, biasFactor: number | undefined): NextValue<number> {
+  generate(mrng: Random, biasFactor: number | undefined): Value<number> {
     const range = this.computeGenerateRange(mrng, biasFactor);
-    return new NextValue(mrng.nextInt(range.min, range.max), undefined);
+    return new Value(mrng.nextInt(range.min, range.max), undefined);
   }
 
   canShrinkWithoutContext(value: unknown): value is number {
@@ -26,7 +26,7 @@ export class IntegerArbitrary extends Arbitrary<number> {
     );
   }
 
-  shrink(current: number, context?: unknown): Stream<NextValue<number>> {
+  shrink(current: number, context?: unknown): Stream<Value<number>> {
     if (!IntegerArbitrary.isValidContext(current, context)) {
       // No context:
       //   Take default target and shrink towards it
@@ -38,7 +38,7 @@ export class IntegerArbitrary extends Arbitrary<number> {
       // Last chance try...
       // context is set to undefined, so that shrink will restart
       // without any assumptions in case our try find yet another bug
-      return Stream.of(new NextValue(context, undefined));
+      return Stream.of(new Value(context, undefined));
     }
     // Normal shrink process
     return shrinkInteger(current, context, false);
diff --git a/src/arbitrary/_internals/LazyArbitrary.ts b/src/arbitrary/_internals/LazyArbitrary.ts
index 78118e00..01020a48 100644
--- a/src/arbitrary/_internals/LazyArbitrary.ts
+++ b/src/arbitrary/_internals/LazyArbitrary.ts
@@ -1,5 +1,5 @@
 import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary';
-import { NextValue } from '../../check/arbitrary/definition/NextValue';
+import { Value } from '../../check/arbitrary/definition/Value';
 import { Random } from '../../random/generator/Random';
 import { Stream } from '../../stream/Stream';
 
@@ -9,7 +9,7 @@ export class LazyArbitrary<T> extends Arbitrary<T> {
   constructor(readonly name: string) {
     super();
   }
-  generate(mrng: Random, biasFactor: number | undefined): NextValue<T> {
+  generate(mrng: Random, biasFactor: number | undefined): Value<T> {
     if (!this.underlying) {
       throw new Error(`Lazy arbitrary ${JSON.stringify(this.name)} not correctly initialized`);
     }
@@ -21,7 +21,7 @@ export class LazyArbitrary<T> extends Arbitrary<T> {
     }
     return this.underlying.canShrinkWithoutContext(value);
   }
-  shrink(value: T, context?: unknown): Stream<NextValue<T>> {
+  shrink(value: T, context?: unknown): Stream<Value<T>> {
     if (!this.underlying) {
       throw new Error(`Lazy arbitrary ${JSON.stringify(this.name)} not correctly initialized`);
     }
diff --git a/src/arbitrary/_internals/MixedCaseArbitrary.ts b/src/arbitrary/_internals/MixedCaseArbitrary.ts
index d7e3d5cf..f3a0023f 100644
--- a/src/arbitrary/_internals/MixedCaseArbitrary.ts
+++ b/src/arbitrary/_internals/MixedCaseArbitrary.ts
@@ -2,7 +2,7 @@ import { Random } from '../../random/generator/Random';
 import { Stream } from '../../stream/Stream';
 import { bigUintN } from '../bigUintN';
 import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary';
-import { NextValue } from '../../check/arbitrary/definition/NextValue';
+import { Value } from '../../check/arbitrary/definition/Value';
 import { makeLazy } from '../../stream/LazyIterableIterator';
 import {
   applyFlagsOnChars,
@@ -31,32 +31,29 @@ export class MixedCaseArbitrary extends Arbitrary<string> {
 
   /**
    * Create a proper context
-   * @param rawStringNextValue
-   * @param flagsNextValue
+   * @param rawStringValue
+   * @param flagsValue
    */
-  private buildContextFor(
-    rawStringNextValue: NextValue<string>,
-    flagsNextValue: NextValue<bigint>
-  ): MixedCaseArbitraryContext {
+  private buildContextFor(rawStringValue: Value<string>, flagsValue: Value<bigint>): MixedCaseArbitraryContext {
     return {
-      rawString: rawStringNextValue.value,
-      rawStringContext: rawStringNextValue.context,
-      flags: flagsNextValue.value,
-      flagsContext: flagsNextValue.context,
+      rawString: rawStringValue.value,
+      rawStringContext: rawStringValue.context,
+      flags: flagsValue.value,
+      flagsContext: flagsValue.context,
     };
   }
 
-  generate(mrng: Random, biasFactor: number | undefined): NextValue<string> {
-    const rawStringNextValue = this.stringArb.generate(mrng, biasFactor);
+  generate(mrng: Random, biasFactor: number | undefined): Value<string> {
+    const rawStringValue = this.stringArb.generate(mrng, biasFactor);
 
-    const chars = [...rawStringNextValue.value]; // split into valid unicode (keeps surrogate pairs)
+    const chars = [...rawStringValue.value]; // split into valid unicode (keeps surrogate pairs)
     const togglePositions = computeTogglePositions(chars, this.toggleCase);
 
     const flagsArb = bigUintN(togglePositions.length);
-    const flagsNextValue = flagsArb.generate(mrng, undefined); // true => toggle the char, false => keep it as-is
+    const flagsValue = flagsArb.generate(mrng, undefined); // true => toggle the char, false => keep it as-is
 
-    applyFlagsOnChars(chars, flagsNextValue.value, togglePositions, this.toggleCase);
-    return new NextValue(chars.join(''), this.buildContextFor(rawStringNextValue, flagsNextValue));
+    applyFlagsOnChars(chars, flagsValue.value, togglePositions, this.toggleCase);
+    return new Value(chars.join(''), this.buildContextFor(rawStringValue, flagsValue));
   }
 
   canShrinkWithoutContext(value: unknown): value is string {
@@ -69,7 +66,7 @@ export class MixedCaseArbitrary extends Arbitrary<string> {
         this.stringArb.canShrinkWithoutContext(value);
   }
 
-  shrink(value: string, context?: unknown): Stream<NextValue<string>> {
+  shrink(value: string, context?: unknown): Stream<Value<string>> {
     let contextSafe: MixedCaseArbitraryContext;
     if (context !== undefined) {
       contextSafe = context as MixedCaseArbitraryContext;
@@ -100,8 +97,8 @@ export class MixedCaseArbitrary extends Arbitrary<string> {
     const flags = contextSafe.flags;
     return this.stringArb
       .shrink(rawString, contextSafe.rawStringContext)
-      .map((nRawStringNextValue) => {
-        const nChars = [...nRawStringNextValue.value];
+      .map((nRawStringValue) => {
+        const nChars = [...nRawStringValue.value];
         const nTogglePositions = computeTogglePositions(nChars, this.toggleCase);
         const nFlags = computeNextFlags(flags, nTogglePositions.length);
         // Potentially new value for nTogglePositions.length, new value for nFlags
@@ -109,10 +106,7 @@ export class MixedCaseArbitrary extends Arbitrary<string> {
         applyFlagsOnChars(nChars, nFlags, nTogglePositions, this.toggleCase);
         // Remark: Value nFlags can be attached to a context equal to undefined
         // as `canShrinkWithoutContext(nFlags) === true` for the bigint arbitrary
-        return new NextValue(
-          nChars.join(''),
-          this.buildContextFor(nRawStringNextValue, new NextValue(nFlags, undefined))
-        );
+        return new Value(nChars.join(''), this.buildContextFor(nRawStringValue, new Value(nFlags, undefined)));
       })
       .join(
         makeLazy(() => {
@@ -120,12 +114,12 @@ export class MixedCaseArbitrary extends Arbitrary<string> {
           const togglePositions = computeTogglePositions(chars, this.toggleCase);
           return bigUintN(togglePositions.length)
             .shrink(flags, contextSafe.flagsContext)
-            .map((nFlagsNextValue) => {
+            .map((nFlagsValue) => {
               const nChars = chars.slice(); // cloning chars
-              applyFlagsOnChars(nChars, nFlagsNextValue.value, togglePositions, this.toggleCase);
-              return new NextValue(
+              applyFlagsOnChars(nChars, nFlagsValue.value, togglePositions, this.toggleCase);
+              return new Value(
                 nChars.join(''),
-                this.buildContextFor(new NextValue(rawString, contextSafe.rawStringContext), nFlagsNextValue)
+                this.buildContextFor(new Value(rawString, contextSafe.rawStringContext), nFlagsValue)
               );
             });
         })
diff --git a/src/arbitrary/_internals/SchedulerArbitrary.ts b/src/arbitrary/_internals/SchedulerArbitrary.ts
index d3b7c341..94eeb03e 100644
--- a/src/arbitrary/_internals/SchedulerArbitrary.ts
+++ b/src/arbitrary/_internals/SchedulerArbitrary.ts
@@ -1,5 +1,5 @@
 import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary';
-import { NextValue } from '../../check/arbitrary/definition/NextValue';
+import { Value } from '../../check/arbitrary/definition/Value';
 import { Random } from '../../random/generator/Random';
 import { Stream } from '../../stream/Stream';
 import { Scheduler } from './interfaces/Scheduler';
@@ -26,8 +26,8 @@ export class SchedulerArbitrary<TMetaData> extends Arbitrary<Scheduler<TMetaData
     super();
   }
 
-  generate(mrng: Random, _biasFactor: number | undefined): NextValue<Scheduler<TMetaData>> {
-    return new NextValue(new SchedulerImplem<TMetaData>(this.act, buildNextTaskIndex(mrng.clone())), undefined);
+  generate(mrng: Random, _biasFactor: number | undefined): Value<Scheduler<TMetaData>> {
+    return new Value(new SchedulerImplem<TMetaData>(this.act, buildNextTaskIndex(mrng.clone())), undefined);
   }
 
   canShrinkWithoutContext(value: unknown): value is Scheduler<TMetaData> {
@@ -35,7 +35,7 @@ export class SchedulerArbitrary<TMetaData> extends Arbitrary<Scheduler<TMetaData
     return false;
   }
 
-  shrink(_value: Scheduler<TMetaData>, _context?: unknown): Stream<NextValue<Scheduler<TMetaData>>> {
+  shrink(_value: Scheduler<TMetaData>, _context?: unknown): Stream<Value<Scheduler<TMetaData>>> {
     // Not supported yet
     return Stream.nil();
   }
diff --git a/src/arbitrary/_internals/StreamArbitrary.ts b/src/arbitrary/_internals/StreamArbitrary.ts
index 675688d8..59df8fbf 100644
--- a/src/arbitrary/_internals/StreamArbitrary.ts
+++ b/src/arbitrary/_internals/StreamArbitrary.ts
@@ -1,5 +1,5 @@
 import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary';
-import { NextValue } from '../../check/arbitrary/definition/NextValue';
+import { Value } from '../../check/arbitrary/definition/Value';
 import { cloneMethod } from '../../check/symbols';
 import { Random } from '../../random/generator/Random';
 import { Stream } from '../../stream/Stream';
@@ -16,7 +16,7 @@ export class StreamArbitrary<T> extends Arbitrary<Stream<T>> {
     super();
   }
 
-  generate(mrng: Random, biasFactor: number | undefined): NextValue<Stream<T>> {
+  generate(mrng: Random, biasFactor: number | undefined): Value<Stream<T>> {
     const appliedBiasFactor = biasFactor !== undefined && mrng.nextInt(1, biasFactor) === 1 ? biasFactor : undefined;
     const enrichedProducer = () => {
       const seenValues: T[] = [];
@@ -36,7 +36,7 @@ export class StreamArbitrary<T> extends Arbitrary<Stream<T>> {
         [cloneMethod]: { value: enrichedProducer, enumerable: true },
       });
     };
-    return new NextValue(enrichedProducer(), undefined);
+    return new Value(enrichedProducer(), undefined);
   }
 
   canShrinkWithoutContext(value: unknown): value is Stream<T> {
@@ -45,7 +45,7 @@ export class StreamArbitrary<T> extends Arbitrary<Stream<T>> {
     return false;
   }
 
-  shrink(_value: Stream<T>, _context?: unknown): Stream<NextValue<Stream<T>>> {
+  shrink(_value: Stream<T>, _context?: unknown): Stream<Value<Stream<T>>> {
     // Not supported yet, even if context was provided
     return Stream.nil();
   }
diff --git a/src/arbitrary/_internals/SubarrayArbitrary.ts b/src/arbitrary/_internals/SubarrayArbitrary.ts
index b6f0100f..93086c4f 100644
--- a/src/arbitrary/_internals/SubarrayArbitrary.ts
+++ b/src/arbitrary/_internals/SubarrayArbitrary.ts
@@ -1,5 +1,5 @@
 import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary';
-import { NextValue } from '../../check/arbitrary/definition/NextValue';
+import { Value } from '../../check/arbitrary/definition/Value';
 import { Random } from '../../random/generator/Random';
 import { makeLazy } from '../../stream/LazyIterableIterator';
 import { Stream } from '../../stream/Stream';
@@ -35,7 +35,7 @@ export class SubarrayArbitrary<T> extends Arbitrary<T[]> {
         : this.lengthArb;
   }
 
-  generate(mrng: Random, biasFactor: number | undefined): NextValue<T[]> {
+  generate(mrng: Random, biasFactor: number | undefined): Value<T[]> {
     const lengthArb =
       biasFactor !== undefined && mrng.nextInt(1, biasFactor) === 1 ? this.biasedLengthArb : this.lengthArb;
     const size = lengthArb.generate(mrng, undefined);
@@ -52,7 +52,7 @@ export class SubarrayArbitrary<T> extends Arbitrary<T[]> {
       ids.sort((a, b) => a - b);
     }
 
-    return new NextValue(
+    return new Value(
       ids.map((i) => this.originalArray[i]),
       size.context
     );
@@ -68,16 +68,16 @@ export class SubarrayArbitrary<T> extends Arbitrary<T[]> {
     return isSubarrayOf(this.originalArray, value);
   }
 
-  shrink(value: T[], context: unknown): Stream<NextValue<T[]>> {
+  shrink(value: T[], context: unknown): Stream<Value<T[]>> {
     // shrinking one by one is not the most comprehensive
     // but allows a reasonable number of entries in the shrink
     if (value.length === 0) {
-      return Stream.nil<NextValue<T[]>>();
+      return Stream.nil<Value<T[]>>();
     }
     return this.lengthArb
       .shrink(value.length, context)
       .map((newSize) => {
-        return new NextValue(
+        return new Value(
           value.slice(value.length - newSize.value), // array of length newSize.value
           newSize.context // integer context for value newSize.value (the length)
         );
@@ -87,9 +87,9 @@ export class SubarrayArbitrary<T> extends Arbitrary<T[]> {
           ? makeLazy(() =>
               this.shrink(value.slice(1), undefined)
                 .filter((newValue) => this.minLength <= newValue.value.length + 1)
-                .map((newValue) => new NextValue([value[0]].concat(newValue.value), undefined))
+                .map((newValue) => new Value([value[0]].concat(newValue.value), undefined))
             )
-          : Stream.nil<NextValue<T[]>>()
+          : Stream.nil<Value<T[]>>()
       );
   }
 }
diff --git a/src/arbitrary/_internals/TupleArbitrary.ts b/src/arbitrary/_internals/TupleArbitrary.ts
index 103fda12..7ce73f48 100644
--- a/src/arbitrary/_internals/TupleArbitrary.ts
+++ b/src/arbitrary/_internals/TupleArbitrary.ts
@@ -2,12 +2,12 @@ import { Random } from '../../random/generator/Random';
 import { Stream } from '../../stream/Stream';
 import { cloneIfNeeded, cloneMethod, WithCloneMethod } from '../../check/symbols';
 import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary';
-import { NextValue } from '../../check/arbitrary/definition/NextValue';
+import { Value } from '../../check/arbitrary/definition/Value';
 
 /** @internal */
 type ArbsArray<Ts extends unknown[]> = { [K in keyof Ts]: Arbitrary<Ts[K]> };
 /** @internal */
-type ValuesArray<Ts extends unknown[]> = { [K in keyof Ts]: NextValue<Ts[K]> };
+type ValuesArray<Ts extends unknown[]> = { [K in keyof Ts]: Value<Ts[K]> };
 
 /** @internal */
 export class TupleArbitrary<Ts extends unknown[]> extends Arbitrary<Ts> {
@@ -19,7 +19,7 @@ export class TupleArbitrary<Ts extends unknown[]> extends Arbitrary<Ts> {
         throw new Error(`Invalid parameter encountered at index ${idx}: expecting an Arbitrary`);
     }
   }
-  private static makeItCloneable<TValue>(vs: TValue[], values: NextValue<TValue>[]): WithCloneMethod<TValue[]> {
+  private static makeItCloneable<TValue>(vs: TValue[], values: Value<TValue>[]): WithCloneMethod<TValue[]> {
     return Object.defineProperty(vs, cloneMethod, {
       value: () => {
         const cloned = [];
@@ -31,7 +31,7 @@ export class TupleArbitrary<Ts extends unknown[]> extends Arbitrary<Ts> {
       },
     }) as unknown as WithCloneMethod<TValue[]>;
   }
-  private static wrapper<Ts extends unknown[]>(values: ValuesArray<Ts>): NextValue<Ts> {
+  private static wrapper<Ts extends unknown[]>(values: ValuesArray<Ts>): Value<Ts> {
     let cloneable = false;
     const vs = [] as unknown as Ts & unknown[];
     const ctxs: unknown[] = [];
@@ -44,9 +44,9 @@ export class TupleArbitrary<Ts extends unknown[]> extends Arbitrary<Ts> {
     if (cloneable) {
       TupleArbitrary.makeItCloneable(vs, values);
     }
-    return new NextValue(vs, ctxs);
+    return new Value(vs, ctxs);
   }
-  generate(mrng: Random, biasFactor: number | undefined): NextValue<Ts> {
+  generate(mrng: Random, biasFactor: number | undefined): Value<Ts> {
     return TupleArbitrary.wrapper<Ts>(this.arbs.map((a) => a.generate(mrng, biasFactor)) as ValuesArray<Ts>);
   }
   canShrinkWithoutContext(value: unknown): value is Ts {
@@ -60,24 +60,22 @@ export class TupleArbitrary<Ts extends unknown[]> extends Arbitrary<Ts> {
     }
     return true;
   }
-  shrink(value: Ts, context?: unknown): Stream<NextValue<Ts>> {
+  shrink(value: Ts, context?: unknown): Stream<Value<Ts>> {
     // shrinking one by one is the not the most comprehensive
     // but allows a reasonable number of entries in the shrink
-    let s = Stream.nil<NextValue<Ts>>();
+    let s = Stream.nil<Value<Ts>>();
     const safeContext: unknown[] = Array.isArray(context) ? context : [];
     for (let idx = 0; idx !== this.arbs.length; ++idx) {
-      const shrinksForIndex: Stream<NextValue<Ts>> = this.arbs[idx]
+      const shrinksForIndex: Stream<Value<Ts>> = this.arbs[idx]
         .shrink(value[idx], safeContext[idx])
         .map((v) => {
-          const nextValues: NextValue<unknown>[] = value.map(
-            (v, idx) => new NextValue(cloneIfNeeded(v), safeContext[idx])
-          );
+          const nextValues: Value<unknown>[] = value.map((v, idx) => new Value(cloneIfNeeded(v), safeContext[idx]));
           return nextValues
             .slice(0, idx)
             .concat([v])
             .concat(nextValues.slice(idx + 1));
         })
-        .map((values) => TupleArbitrary.wrapper(values) as NextValue<Ts>);
+        .map((values) => TupleArbitrary.wrapper(values) as Value<Ts>);
       s = s.join(shrinksForIndex);
     }
     return s;
diff --git a/src/arbitrary/_internals/helpers/BuildCompareFilter.ts b/src/arbitrary/_internals/helpers/BuildCompareFilter.ts
index 84ee521f..5e2dd11c 100644
--- a/src/arbitrary/_internals/helpers/BuildCompareFilter.ts
+++ b/src/arbitrary/_internals/helpers/BuildCompareFilter.ts
@@ -1,4 +1,4 @@
-import { NextValue } from '../../../check/arbitrary/definition/NextValue';
+import { Value } from '../../../check/arbitrary/definition/Value';
 
 /** @internal */
 function subArrayContains<T>(tab: T[], upperBound: number, includeValue: (v: T) => boolean): boolean {
@@ -23,8 +23,8 @@ function swap<T>(tab: T[], idx1: number, idx2: number): void {
  * It returns the array without any duplicates.
  * @internal
  */
-export function buildCompareFilter<T>(compare: (a: T, b: T) => boolean): (tab: NextValue<T>[]) => NextValue<T>[] {
-  return (tab: NextValue<T>[]): NextValue<T>[] => {
+export function buildCompareFilter<T>(compare: (a: T, b: T) => boolean): (tab: Value<T>[]) => Value<T>[] {
+  return (tab: Value<T>[]): Value<T>[] => {
     let finalLength = tab.length;
     for (let idx = tab.length - 1; idx !== -1; --idx) {
       if (subArrayContains(tab, idx, (t) => compare(t.value_, tab[idx].value_))) {
diff --git a/src/arbitrary/_internals/helpers/NoUndefinedAsContext.ts b/src/arbitrary/_internals/helpers/NoUndefinedAsContext.ts
index 15748dea..6d2bad22 100644
--- a/src/arbitrary/_internals/helpers/NoUndefinedAsContext.ts
+++ b/src/arbitrary/_internals/helpers/NoUndefinedAsContext.ts
@@ -1,15 +1,15 @@
-import { NextValue } from '../../../check/arbitrary/definition/NextValue';
+import { Value } from '../../../check/arbitrary/definition/Value';
 
 /** @internal */
 export const UndefinedContextPlaceholder = Symbol('UndefinedContextPlaceholder');
 
 /** @internal */
-export function noUndefinedAsContext<Ts>(value: NextValue<Ts>): NextValue<Ts> {
+export function noUndefinedAsContext<Ts>(value: Value<Ts>): Value<Ts> {
   if (value.context !== undefined) {
     return value;
   }
   if (value.hasToBeCloned) {
-    return new NextValue(value.value_, UndefinedContextPlaceholder, () => value.value);
+    return new Value(value.value_, UndefinedContextPlaceholder, () => value.value);
   }
-  return new NextValue(value.value_, UndefinedContextPlaceholder);
+  return new Value(value.value_, UndefinedContextPlaceholder);
 }
diff --git a/src/arbitrary/_internals/helpers/ShrinkBigInt.ts b/src/arbitrary/_internals/helpers/ShrinkBigInt.ts
index bf6d678f..7951aa65 100644
--- a/src/arbitrary/_internals/helpers/ShrinkBigInt.ts
+++ b/src/arbitrary/_internals/helpers/ShrinkBigInt.ts
@@ -1,5 +1,5 @@
 import { Stream, stream } from '../../../stream/Stream';
-import { NextValue } from '../../../check/arbitrary/definition/NextValue';
+import { Value } from '../../../check/arbitrary/definition/Value';
 
 /**
  * Halve towards zero
@@ -13,23 +13,23 @@ function halveBigInt(n: bigint): bigint {
  * Compute shrunk values to move from current to target
  * @internal
  */
-export function shrinkBigInt(current: bigint, target: bigint, tryTargetAsap: boolean): Stream<NextValue<bigint>> {
+export function shrinkBigInt(current: bigint, target: bigint, tryTargetAsap: boolean): Stream<Value<bigint>> {
   const realGap = current - target;
-  function* shrinkDecr(): IterableIterator<NextValue<bigint>> {
+  function* shrinkDecr(): IterableIterator<Value<bigint>> {
     let previous: bigint | undefined = tryTargetAsap ? undefined : target;
     const gap = tryTargetAsap ? realGap : halveBigInt(realGap);
     for (let toremove = gap; toremove > 0; toremove = halveBigInt(toremove)) {
       const next = current - toremove;
-      yield new NextValue(next, previous); // previous indicates the last passing value
+      yield new Value(next, previous); // previous indicates the last passing value
       previous = next;
     }
   }
-  function* shrinkIncr(): IterableIterator<NextValue<bigint>> {
+  function* shrinkIncr(): IterableIterator<Value<bigint>> {
     let previous: bigint | undefined = tryTargetAsap ? undefined : target;
     const gap = tryTargetAsap ? realGap : halveBigInt(realGap);
     for (let toremove = gap; toremove < 0; toremove = halveBigInt(toremove)) {
       const next = current - toremove;
-      yield new NextValue(next, previous); // previous indicates the last passing value
+      yield new Value(next, previous); // previous indicates the last passing value
       previous = next;
     }
   }
diff --git a/src/arbitrary/_internals/helpers/ShrinkInteger.ts b/src/arbitrary/_internals/helpers/ShrinkInteger.ts
index 73ad1270..ebc9726f 100644
--- a/src/arbitrary/_internals/helpers/ShrinkInteger.ts
+++ b/src/arbitrary/_internals/helpers/ShrinkInteger.ts
@@ -1,4 +1,4 @@
-import { NextValue } from '../../../check/arbitrary/definition/NextValue';
+import { Value } from '../../../check/arbitrary/definition/Value';
 import { Stream, stream } from '../../../stream/Stream';
 
 /** @internal */
@@ -14,25 +14,25 @@ function halveNegInteger(n: number): number {
  * Compute shrunk values to move from current to target
  * @internal
  */
-export function shrinkInteger(current: number, target: number, tryTargetAsap: boolean): Stream<NextValue<number>> {
+export function shrinkInteger(current: number, target: number, tryTargetAsap: boolean): Stream<Value<number>> {
   const realGap = current - target;
-  function* shrinkDecr(): IterableIterator<NextValue<number>> {
+  function* shrinkDecr(): IterableIterator<Value<number>> {
     let previous: number | undefined = tryTargetAsap ? undefined : target;
     const gap = tryTargetAsap ? realGap : halvePosInteger(realGap);
     for (let toremove = gap; toremove > 0; toremove = halvePosInteger(toremove)) {
       // The check toremove === realGap ensures we will not face any overflow
       // for values like - current=4489181317763721 and target=-5692628479909134 - we overflow in realGap
       const next = toremove === realGap ? target : current - toremove;
-      yield new NextValue(next, previous); // previous indicates the last passing value
+      yield new Value(next, previous); // previous indicates the last passing value
       previous = next;
     }
   }
-  function* shrinkIncr(): IterableIterator<NextValue<number>> {
+  function* shrinkIncr(): IterableIterator<Value<number>> {
     let previous: number | undefined = tryTargetAsap ? undefined : target;
     const gap = tryTargetAsap ? realGap : halveNegInteger(realGap);
     for (let toremove = gap; toremove < 0; toremove = halveNegInteger(toremove)) {
       const next = toremove === realGap ? target : current - toremove;
-      yield new NextValue(next, previous); // previous indicates the last passing value
+      yield new Value(next, previous); // previous indicates the last passing value
       previous = next;
     }
   }
diff --git a/src/check/arbitrary/definition/Arbitrary.ts b/src/check/arbitrary/definition/Arbitrary.ts
index 7a3320fc..1d23ceca 100644
--- a/src/check/arbitrary/definition/Arbitrary.ts
+++ b/src/check/arbitrary/definition/Arbitrary.ts
@@ -1,7 +1,7 @@
 import { Random } from '../../../random/generator/Random';
 import { Stream } from '../../../stream/Stream';
 import { cloneMethod, hasCloneMethod } from '../../symbols';
-import { NextValue } from './NextValue';
+import { Value } from './Value';
 
 /**
  * Abstract class able to generate values on type `T`
@@ -22,7 +22,7 @@ export abstract class Arbitrary<T> {
    *
    * @remarks Since 0.0.1 (return type changed in 3.0.0)
    */
-  abstract generate(mrng: Random, biasFactor: number | undefined): NextValue<T>;
+  abstract generate(mrng: Random, biasFactor: number | undefined): Value<T>;
 
   /**
    * Check if a given value could be pass to `shrink` without providing any context.
@@ -53,7 +53,7 @@ export abstract class Arbitrary<T> {
    *
    * @remarks Since 3.0.0
    */
-  abstract shrink(value: T, context: unknown | undefined): Stream<NextValue<T>>;
+  abstract shrink(value: T, context: unknown | undefined): Stream<Value<T>>;
 
   /**
    * Create another arbitrary by filtering values against `predicate`
@@ -188,7 +188,7 @@ class ChainArbitrary<T, U> extends Arbitrary<U> {
   constructor(readonly arb: Arbitrary<T>, readonly chainer: (t: T) => Arbitrary<U>) {
     super();
   }
-  generate(mrng: Random, biasFactor: number | undefined): NextValue<U> {
+  generate(mrng: Random, biasFactor: number | undefined): Value<U> {
     const clonedMrng = mrng.clone();
     const src = this.arb.generate(mrng, biasFactor);
     return this.valueChainer(src, mrng, clonedMrng, biasFactor);
@@ -197,14 +197,14 @@ class ChainArbitrary<T, U> extends Arbitrary<U> {
     // TODO Need unchainer
     return false;
   }
-  shrink(value: U, context?: unknown): Stream<NextValue<U>> {
+  shrink(value: U, context?: unknown): Stream<Value<U>> {
     if (this.isSafeContext(context)) {
       return (
         !context.stoppedForOriginal
           ? this.arb
               .shrink(context.originalValue, context.originalContext)
               .map((v) => this.valueChainer(v, context.clonedMrng.clone(), context.clonedMrng, context.originalBias))
-          : Stream.nil<NextValue<U>>()
+          : Stream.nil<Value<U>>()
       ).join(
         context.chainedArbitrary.shrink(value, context.chainedContext).map((dst) => {
           const newContext: ChainArbitraryContext<T, U> = {
@@ -212,7 +212,7 @@ class ChainArbitrary<T, U> extends Arbitrary<U> {
             chainedContext: dst.context,
             stoppedForOriginal: true,
           };
-          return new NextValue(dst.value_, newContext);
+          return new Value(dst.value_, newContext);
         })
       );
     }
@@ -220,11 +220,11 @@ class ChainArbitrary<T, U> extends Arbitrary<U> {
     return Stream.nil();
   }
   private valueChainer(
-    v: NextValue<T>,
+    v: Value<T>,
     generateMrng: Random,
     clonedMrng: Random,
     biasFactor: number | undefined
-  ): NextValue<U> {
+  ): Value<U> {
     const chainedArbitrary = this.chainer(v.value_);
     const dst = chainedArbitrary.generate(generateMrng, biasFactor);
     const context: ChainArbitraryContext<T, U> = {
@@ -236,7 +236,7 @@ class ChainArbitrary<T, U> extends Arbitrary<U> {
       chainedContext: dst.context,
       clonedMrng,
     };
-    return new NextValue(dst.value_, context);
+    return new Value(dst.value_, context);
   }
   private isSafeContext(context: unknown): context is ChainArbitraryContext<T, U> {
     return (
@@ -261,12 +261,12 @@ type MapArbitraryContext<T> = {
 
 /** @internal */
 class MapArbitrary<T, U> extends Arbitrary<U> {
-  readonly bindValueMapper: (v: NextValue<T>) => NextValue<U>;
+  readonly bindValueMapper: (v: Value<T>) => Value<U>;
   constructor(readonly arb: Arbitrary<T>, readonly mapper: (t: T) => U, readonly unmapper?: (possiblyU: unknown) => T) {
     super();
     this.bindValueMapper = this.valueMapper.bind(this);
   }
-  generate(mrng: Random, biasFactor: number | undefined): NextValue<U> {
+  generate(mrng: Random, biasFactor: number | undefined): Value<U> {
     const g = this.arb.generate(mrng, biasFactor);
     return this.valueMapper(g);
   }
@@ -281,7 +281,7 @@ class MapArbitrary<T, U> extends Arbitrary<U> {
     }
     return false;
   }
-  shrink(value: U, context?: unknown): Stream<NextValue<U>> {
+  shrink(value: U, context?: unknown): Stream<Value<U>> {
     if (this.isSafeContext(context)) {
       return this.arb.shrink(context.originalValue, context.originalContext).map(this.bindValueMapper);
     }
@@ -294,7 +294,7 @@ class MapArbitrary<T, U> extends Arbitrary<U> {
     }
     return Stream.nil();
   }
-  private mapperWithCloneIfNeeded(v: NextValue<T>): [U, T] {
+  private mapperWithCloneIfNeeded(v: Value<T>): [U, T] {
     const sourceValue = v.value;
     const mappedValue = this.mapper(sourceValue);
     if (
@@ -308,10 +308,10 @@ class MapArbitrary<T, U> extends Arbitrary<U> {
     }
     return [mappedValue, sourceValue];
   }
-  private valueMapper(v: NextValue<T>): NextValue<U> {
+  private valueMapper(v: Value<T>): Value<U> {
     const [mappedValue, sourceValue] = this.mapperWithCloneIfNeeded(v);
     const context: MapArbitraryContext<T> = { originalValue: sourceValue, originalContext: v.context };
-    return new NextValue(mappedValue, context);
+    return new Value(mappedValue, context);
   }
   private isSafeContext(context: unknown): context is MapArbitraryContext<T> {
     return (
@@ -325,12 +325,12 @@ class MapArbitrary<T, U> extends Arbitrary<U> {
 
 /** @internal */
 class FilterArbitrary<T, U extends T> extends Arbitrary<U> {
-  readonly bindRefinementOnValue: (v: NextValue<T>) => v is NextValue<U>;
+  readonly bindRefinementOnValue: (v: Value<T>) => v is Value<U>;
   constructor(readonly arb: Arbitrary<T>, readonly refinement: (t: T) => t is U) {
     super();
     this.bindRefinementOnValue = this.refinementOnValue.bind(this);
   }
-  generate(mrng: Random, biasFactor: number | undefined): NextValue<U> {
+  generate(mrng: Random, biasFactor: number | undefined): Value<U> {
     // eslint-disable-next-line no-constant-condition
     while (true) {
       const g = this.arb.generate(mrng, biasFactor);
@@ -342,10 +342,10 @@ class FilterArbitrary<T, U extends T> extends Arbitrary<U> {
   canShrinkWithoutContext(value: unknown): value is U {
     return this.arb.canShrinkWithoutContext(value) && this.refinement(value);
   }
-  shrink(value: U, context?: unknown): Stream<NextValue<U>> {
+  shrink(value: U, context?: unknown): Stream<Value<U>> {
     return this.arb.shrink(value, context).filter(this.bindRefinementOnValue);
   }
-  private refinementOnValue(v: NextValue<T>): v is NextValue<U> {
+  private refinementOnValue(v: Value<T>): v is Value<U> {
     return this.refinement(v.value);
   }
 }
@@ -355,13 +355,13 @@ class NoShrinkArbitrary<T> extends Arbitrary<T> {
   constructor(readonly arb: Arbitrary<T>) {
     super();
   }
-  generate(mrng: Random, biasFactor: number | undefined): NextValue<T> {
+  generate(mrng: Random, biasFactor: number | undefined): Value<T> {
     return this.arb.generate(mrng, biasFactor);
   }
   canShrinkWithoutContext(value: unknown): value is T {
     return this.arb.canShrinkWithoutContext(value);
   }
-  shrink(_value: T, _context?: unknown): Stream<NextValue<T>> {
+  shrink(_value: T, _context?: unknown): Stream<Value<T>> {
     return Stream.nil();
   }
   noShrink() {
@@ -374,13 +374,13 @@ class NoBiasArbitrary<T> extends Arbitrary<T> {
   constructor(readonly arb: Arbitrary<T>) {
     super();
   }
-  generate(mrng: Random, _biasFactor: number | undefined): NextValue<T> {
+  generate(mrng: Random, _biasFactor: number | undefined): Value<T> {
     return this.arb.generate(mrng, undefined);
   }
   canShrinkWithoutContext(value: unknown): value is T {
     return this.arb.canShrinkWithoutContext(value);
   }
-  shrink(value: T, context?: unknown): Stream<NextValue<T>> {
+  shrink(value: T, context?: unknown): Stream<Value<T>> {
     return this.arb.shrink(value, context);
   }
   noBias() {
diff --git a/src/check/arbitrary/definition/NextValue.ts b/src/check/arbitrary/definition/Value.ts
similarity index 92%
rename from src/check/arbitrary/definition/NextValue.ts
rename to src/check/arbitrary/definition/Value.ts
index e73add5c..9e375724 100644
--- a/src/check/arbitrary/definition/NextValue.ts
+++ b/src/check/arbitrary/definition/Value.ts
@@ -1,13 +1,13 @@
 import { cloneMethod, hasCloneMethod, WithCloneMethod } from '../../symbols';
 
 /**
- * A `NextValue<T, TShrink = T>` holds an internal value of type `T`
+ * A `Value<T, TShrink = T>` holds an internal value of type `T`
  * and its associated context
  *
- * @remarks Since 2.15.0
+ * @remarks Since 3.0.0 (previously called `NextValue` in 2.15.0)
  * @public
  */
-export class NextValue<T> {
+export class Value<T> {
   /**
    * State storing the result of hasCloneMethod
    * If `true` the value will be cloned each time it gets accessed
diff --git a/src/check/property/AsyncProperty.generic.ts b/src/check/property/AsyncProperty.generic.ts
index 3c531263..04e99840 100644
--- a/src/check/property/AsyncProperty.generic.ts
+++ b/src/check/property/AsyncProperty.generic.ts
@@ -3,7 +3,7 @@ import { Arbitrary } from '../arbitrary/definition/Arbitrary';
 import { PreconditionFailure } from '../precondition/PreconditionFailure';
 import { IRawProperty, runIdToFrequency } from './IRawProperty';
 import { readConfigureGlobal, GlobalAsyncPropertyHookFunction } from '../runner/configuration/GlobalParameters';
-import { NextValue } from '../arbitrary/definition/NextValue';
+import { Value } from '../arbitrary/definition/Value';
 import { Stream } from '../../stream/Stream';
 import {
   noUndefinedAsContext,
@@ -85,12 +85,12 @@ export class AsyncProperty<Ts> implements IAsyncPropertyWithHooks<Ts> {
     return true;
   }
 
-  generate(mrng: Random, runId?: number): NextValue<Ts> {
+  generate(mrng: Random, runId?: number): Value<Ts> {
     const value = this.arb.generate(mrng, runId != null ? runIdToFrequency(runId) : undefined);
     return noUndefinedAsContext(value);
   }
 
-  shrink(value: NextValue<Ts>): Stream<NextValue<Ts>> {
+  shrink(value: Value<Ts>): Stream<Value<Ts>> {
     if (value.context === undefined && !this.arb.canShrinkWithoutContext(value.value_)) {
       // `undefined` can only be coming from values derived from examples provided by the user
       // context set to `undefined` are automatically replaced by `UndefinedContextPlaceholder` in generate
diff --git a/src/check/property/IRawProperty.ts b/src/check/property/IRawProperty.ts
index 6d8f145f..1d6b6bb0 100644
--- a/src/check/property/IRawProperty.ts
+++ b/src/check/property/IRawProperty.ts
@@ -1,6 +1,6 @@
 import { Random } from '../../random/generator/Random';
 import { Stream } from '../../stream/Stream';
-import { NextValue } from '../arbitrary/definition/NextValue';
+import { Value } from '../arbitrary/definition/Value';
 import { PreconditionFailure } from '../precondition/PreconditionFailure';
 
 /**
@@ -30,7 +30,7 @@ export interface IRawProperty<Ts, IsAsync extends boolean = boolean> {
    *
    * @remarks Since 0.0.7 (return type changed in 3.0.0)
    */
-  generate(mrng: Random, runId?: number): NextValue<Ts>;
+  generate(mrng: Random, runId?: number): Value<Ts>;
 
   /**
    * Shrink value of type Ts
@@ -39,7 +39,7 @@ export interface IRawProperty<Ts, IsAsync extends boolean = boolean> {
    *
    * @remarks Since 3.0.0
    */
-  shrink(value: NextValue<Ts>): Stream<NextValue<Ts>>;
+  shrink(value: Value<Ts>): Stream<Value<Ts>>;
 
   /**
    * Check the predicate for v
diff --git a/src/check/property/IgnoreEqualValuesProperty.ts b/src/check/property/IgnoreEqualValuesProperty.ts
index bc24a1d7..df917c69 100644
--- a/src/check/property/IgnoreEqualValuesProperty.ts
+++ b/src/check/property/IgnoreEqualValuesProperty.ts
@@ -2,7 +2,7 @@ import { IRawProperty } from './IRawProperty';
 import { Random } from '../../random/generator/Random';
 import { stringify } from '../../utils/stringify';
 import { PreconditionFailure } from '../precondition/PreconditionFailure';
-import { NextValue } from '../arbitrary/definition/NextValue';
+import { Value } from '../arbitrary/definition/Value';
 import { Stream } from '../../stream/Stream';
 
 /** @internal */
@@ -47,11 +47,11 @@ export class IgnoreEqualValuesProperty<Ts, IsAsync extends boolean> implements I
     return this.property.isAsync();
   }
 
-  generate(mrng: Random, runId?: number): NextValue<Ts> {
+  generate(mrng: Random, runId?: number): Value<Ts> {
     return this.property.generate(mrng, runId);
   }
 
-  shrink(value: NextValue<Ts>): Stream<NextValue<Ts>> {
+  shrink(value: Value<Ts>): Stream<Value<Ts>> {
     return this.property.shrink(value);
   }
 
diff --git a/src/check/property/Property.generic.ts b/src/check/property/Property.generic.ts
index b77eafb8..4b7a30c9 100644
--- a/src/check/property/Property.generic.ts
+++ b/src/check/property/Property.generic.ts
@@ -3,7 +3,7 @@ import { Arbitrary } from '../arbitrary/definition/Arbitrary';
 import { PreconditionFailure } from '../precondition/PreconditionFailure';
 import { IRawProperty, runIdToFrequency } from './IRawProperty';
 import { readConfigureGlobal, GlobalPropertyHookFunction } from '../runner/configuration/GlobalParameters';
-import { NextValue } from '../arbitrary/definition/NextValue';
+import { Value } from '../arbitrary/definition/Value';
 import { Stream } from '../../stream/Stream';
 import {
   noUndefinedAsContext,
@@ -101,12 +101,12 @@ export class Property<Ts> implements IProperty<Ts>, IPropertyWithHooks<Ts> {
     return false;
   }
 
-  generate(mrng: Random, runId?: number): NextValue<Ts> {
+  generate(mrng: Random, runId?: number): Value<Ts> {
     const value = this.arb.generate(mrng, runId != null ? runIdToFrequency(runId) : undefined);
     return noUndefinedAsContext(value);
   }
 
-  shrink(value: NextValue<Ts>): Stream<NextValue<Ts>> {
+  shrink(value: Value<Ts>): Stream<Value<Ts>> {
     if (value.context === undefined && !this.arb.canShrinkWithoutContext(value.value_)) {
       // `undefined` can only be coming from values derived from examples provided by the user
       // context set to `undefined` are automatically replaced by `UndefinedContextPlaceholder` in generate
diff --git a/src/check/property/SkipAfterProperty.ts b/src/check/property/SkipAfterProperty.ts
index c56649ce..7c87a64c 100644
--- a/src/check/property/SkipAfterProperty.ts
+++ b/src/check/property/SkipAfterProperty.ts
@@ -1,6 +1,6 @@
 import { Random } from '../../random/generator/Random';
 import { Stream } from '../../stream/Stream';
-import { NextValue } from '../arbitrary/definition/NextValue';
+import { Value } from '../arbitrary/definition/Value';
 import { PreconditionFailure } from '../precondition/PreconditionFailure';
 import { IRawProperty } from './IRawProperty';
 
@@ -20,11 +20,11 @@ export class SkipAfterProperty<Ts, IsAsync extends boolean> implements IRawPrope
     return this.property.isAsync();
   }
 
-  generate(mrng: Random, runId?: number): NextValue<Ts> {
+  generate(mrng: Random, runId?: number): Value<Ts> {
     return this.property.generate(mrng, runId);
   }
 
-  shrink(value: NextValue<Ts>): Stream<NextValue<Ts>> {
+  shrink(value: Value<Ts>): Stream<Value<Ts>> {
     return this.property.shrink(value);
   }
 
diff --git a/src/check/property/TimeoutProperty.ts b/src/check/property/TimeoutProperty.ts
index 3e0a7d4d..47e773e5 100644
--- a/src/check/property/TimeoutProperty.ts
+++ b/src/check/property/TimeoutProperty.ts
@@ -1,6 +1,6 @@
 import { Random } from '../../random/generator/Random';
 import { Stream } from '../../stream/Stream';
-import { NextValue } from '../arbitrary/definition/NextValue';
+import { Value } from '../arbitrary/definition/Value';
 import { PreconditionFailure } from '../precondition/PreconditionFailure';
 import { IRawProperty } from './IRawProperty';
 
@@ -28,11 +28,11 @@ export class TimeoutProperty<Ts> implements IRawProperty<Ts, true> {
     return true;
   }
 
-  generate(mrng: Random, runId?: number): NextValue<Ts> {
+  generate(mrng: Random, runId?: number): Value<Ts> {
     return this.property.generate(mrng, runId);
   }
 
-  shrink(value: NextValue<Ts>): Stream<NextValue<Ts>> {
+  shrink(value: Value<Ts>): Stream<Value<Ts>> {
     return this.property.shrink(value);
   }
 
diff --git a/src/check/property/UnbiasedProperty.ts b/src/check/property/UnbiasedProperty.ts
index f69d1867..48f34eee 100644
--- a/src/check/property/UnbiasedProperty.ts
+++ b/src/check/property/UnbiasedProperty.ts
@@ -1,6 +1,6 @@
 import { Random } from '../../random/generator/Random';
 import { Stream } from '../../stream/Stream';
-import { NextValue } from '../arbitrary/definition/NextValue';
+import { Value } from '../arbitrary/definition/Value';
 import { IRawProperty } from './IRawProperty';
 
 /** @internal */
@@ -11,11 +11,11 @@ export class UnbiasedProperty<Ts, IsAsync extends boolean> implements IRawProper
     return this.property.isAsync();
   }
 
-  generate(mrng: Random, _runId?: number): NextValue<Ts> {
+  generate(mrng: Random, _runId?: number): Value<Ts> {
     return this.property.generate(mrng, undefined);
   }
 
-  shrink(value: NextValue<Ts>): Stream<NextValue<Ts>> {
+  shrink(value: Value<Ts>): Stream<Value<Ts>> {
     return this.property.shrink(value);
   }
 
diff --git a/src/check/runner/Runner.ts b/src/check/runner/Runner.ts
index b6c7eb7d..38a5aa45 100644
--- a/src/check/runner/Runner.ts
+++ b/src/check/runner/Runner.ts
@@ -15,13 +15,13 @@ import { pathWalk } from './utils/PathWalker';
 import { asyncReportRunDetails, reportRunDetails } from './utils/RunDetailsFormatter';
 import { IAsyncProperty } from '../property/AsyncProperty';
 import { IProperty } from '../property/Property';
-import { NextValue } from '../arbitrary/definition/NextValue';
+import { Value } from '../arbitrary/definition/Value';
 
 /** @internal */
 function runIt<Ts>(
   property: IRawProperty<Ts>,
-  shrink: (value: NextValue<Ts>) => IterableIterator<NextValue<Ts>>,
-  sourceValues: SourceValuesIterator<NextValue<Ts>>,
+  shrink: (value: Value<Ts>) => IterableIterator<Value<Ts>>,
+  sourceValues: SourceValuesIterator<Value<Ts>>,
   verbose: VerbosityLevel,
   interruptedAsFailure: boolean
 ): RunExecution<Ts> {
@@ -36,8 +36,8 @@ function runIt<Ts>(
 /** @internal */
 async function asyncRunIt<Ts>(
   property: IRawProperty<Ts>,
-  shrink: (value: NextValue<Ts>) => IterableIterator<NextValue<Ts>>,
-  sourceValues: SourceValuesIterator<NextValue<Ts>>,
+  shrink: (value: Value<Ts>) => IterableIterator<Value<Ts>>,
+  sourceValues: SourceValuesIterator<Value<Ts>>,
   verbose: VerbosityLevel,
   interruptedAsFailure: boolean
 ): Promise<RunExecution<Ts>> {
@@ -51,10 +51,10 @@ async function asyncRunIt<Ts>(
 
 /** @internal */
 function runnerPathWalker<Ts>(
-  valueProducers: IterableIterator<() => NextValue<Ts>>,
-  shrink: (value: NextValue<Ts>) => Stream<NextValue<Ts>>,
+  valueProducers: IterableIterator<() => Value<Ts>>,
+  shrink: (value: Value<Ts>) => Stream<Value<Ts>>,
   path: string
-): Stream<() => NextValue<Ts>> {
+): Stream<() => Value<Ts>> {
   const pathPoints = path.split(':');
   const pathStream = stream(valueProducers)
     .drop(pathPoints.length > 0 ? +pathPoints[0] : 0)
@@ -65,10 +65,10 @@ function runnerPathWalker<Ts>(
 
 /** @internal */
 function buildInitialValues<Ts>(
-  valueProducers: IterableIterator<() => NextValue<Ts>>,
-  shrink: (value: NextValue<Ts>) => Stream<NextValue<Ts>>,
+  valueProducers: IterableIterator<() => Value<Ts>>,
+  shrink: (value: Value<Ts>) => Stream<Value<Ts>>,
   qParams: QualifiedParameters<Ts>
-): Stream<() => NextValue<Ts>> {
+): Stream<() => Value<Ts>> {
   if (qParams.path.length === 0) {
     return stream(valueProducers);
   }
diff --git a/src/check/runner/RunnerIterator.ts b/src/check/runner/RunnerIterator.ts
index bbdd55b7..9767f937 100644
--- a/src/check/runner/RunnerIterator.ts
+++ b/src/check/runner/RunnerIterator.ts
@@ -1,4 +1,4 @@
-import { NextValue } from '../arbitrary/definition/NextValue';
+import { Value } from '../arbitrary/definition/Value';
 import { PreconditionFailure } from '../precondition/PreconditionFailure';
 import { VerbosityLevel } from './configuration/VerbosityLevel';
 import { RunExecution } from './reporter/RunExecution';
@@ -17,11 +17,11 @@ import { SourceValuesIterator } from './SourceValuesIterator';
 export class RunnerIterator<Ts> implements IterableIterator<Ts> {
   runExecution: RunExecution<Ts>;
   private currentIdx: number;
-  private currentValue: NextValue<Ts> | undefined;
-  private nextValues: IterableIterator<NextValue<Ts>>;
+  private currentValue: Value<Ts> | undefined;
+  private nextValues: IterableIterator<Value<Ts>>;
   constructor(
-    readonly sourceValues: SourceValuesIterator<NextValue<Ts>>,
-    readonly shrink: (value: NextValue<Ts>) => IterableIterator<NextValue<Ts>>,
+    readonly sourceValues: SourceValuesIterator<Value<Ts>>,
+    readonly shrink: (value: Value<Ts>) => IterableIterator<Value<Ts>>,
     verbose: VerbosityLevel,
     interruptedAsFailure: boolean
   ) {
diff --git a/src/check/runner/Sampler.ts b/src/check/runner/Sampler.ts
index 7b9ac61a..72cb0458 100644
--- a/src/check/runner/Sampler.ts
+++ b/src/check/runner/Sampler.ts
@@ -1,6 +1,6 @@
 import { Stream, stream } from '../../stream/Stream';
 import { Arbitrary } from '../arbitrary/definition/Arbitrary';
-import { NextValue } from '../arbitrary/definition/NextValue';
+import { Value } from '../arbitrary/definition/Value';
 import { IRawProperty } from '../property/IRawProperty';
 import { Property } from '../property/Property.generic';
 import { UnbiasedProperty } from '../property/UnbiasedProperty';
@@ -33,7 +33,7 @@ function streamSample<Ts>(
   const qParams: QualifiedParameters<Ts> = QualifiedParameters.read<Ts>(extendedParams);
   const nextProperty = toProperty(generator, qParams);
   const shrink = nextProperty.shrink.bind(nextProperty);
-  const tossedValues: Stream<() => NextValue<Ts>> = stream(
+  const tossedValues: Stream<() => Value<Ts>> = stream(
     toss(nextProperty, qParams.seed, qParams.randomType, qParams.examples)
   );
   if (qParams.path.length === 0) {
diff --git a/src/check/runner/Tosser.ts b/src/check/runner/Tosser.ts
index cf8757cb..d537fbbc 100644
--- a/src/check/runner/Tosser.ts
+++ b/src/check/runner/Tosser.ts
@@ -2,10 +2,10 @@ import { RandomGenerator, skipN } from 'pure-rand';
 
 import { Random } from '../../random/generator/Random';
 import { IRawProperty } from '../property/IRawProperty';
-import { NextValue } from '../arbitrary/definition/NextValue';
+import { Value } from '../arbitrary/definition/Value';
 
 /** @internal */
-function lazyGenerate<Ts>(generator: IRawProperty<Ts>, rng: RandomGenerator, idx: number): () => NextValue<Ts> {
+function lazyGenerate<Ts>(generator: IRawProperty<Ts>, rng: RandomGenerator, idx: number): () => Value<Ts> {
   return () => generator.generate(new Random(rng), idx);
 }
 
@@ -15,8 +15,8 @@ export function* toss<Ts>(
   seed: number,
   random: (seed: number) => RandomGenerator,
   examples: Ts[]
-): IterableIterator<() => NextValue<Ts>> {
-  yield* examples.map((e) => () => new NextValue(e, undefined));
+): IterableIterator<() => Value<Ts>> {
+  yield* examples.map((e) => () => new Value(e, undefined));
   let idx = 0;
   let rng = random(seed);
   for (;;) {
diff --git a/src/check/runner/utils/PathWalker.ts b/src/check/runner/utils/PathWalker.ts
index 75e613d5..4ceab9b1 100644
--- a/src/check/runner/utils/PathWalker.ts
+++ b/src/check/runner/utils/PathWalker.ts
@@ -1,13 +1,13 @@
-import { NextValue } from '../../../fast-check-default';
+import { Value } from '../../arbitrary/definition/Value';
 import { Stream, stream } from '../../../stream/Stream';
 
 /** @internal */
 export function pathWalk<Ts>(
   path: string,
-  initialValues: IterableIterator<NextValue<Ts>>,
-  shrink: (value: NextValue<Ts>) => Stream<NextValue<Ts>>
-): IterableIterator<NextValue<Ts>> {
-  let values: Stream<NextValue<Ts>> = stream(initialValues);
+  initialValues: IterableIterator<Value<Ts>>,
+  shrink: (value: Value<Ts>) => Stream<Value<Ts>>
+): IterableIterator<Value<Ts>> {
+  let values: Stream<Value<Ts>> = stream(initialValues);
   const segments: number[] = path.split(':').map((text: string) => +text);
   if (segments.length === 0) return values;
   if (!segments.every((v) => !Number.isNaN(v))) {
diff --git a/src/fast-check-default.ts b/src/fast-check-default.ts
index 375c6e71..3b6ca3d2 100644
--- a/src/fast-check-default.ts
+++ b/src/fast-check-default.ts
@@ -150,7 +150,7 @@ import { float32Array, Float32ArrayConstraints } from './arbitrary/float32Array'
 import { float64Array, Float64ArrayConstraints } from './arbitrary/float64Array';
 import { sparseArray, SparseArrayConstraints } from './arbitrary/sparseArray';
 import { Arbitrary } from './check/arbitrary/definition/Arbitrary';
-import { NextValue } from './check/arbitrary/definition/NextValue';
+import { Value } from './check/arbitrary/definition/Value';
 
 // Explicit cast into string to avoid to have __type: "__PACKAGE_TYPE__"
 /**
@@ -302,7 +302,7 @@ export {
   SchedulerReportItem,
   // extend the framework
   Arbitrary,
-  NextValue,
+  Value,
   cloneMethod,
   cloneIfNeeded,
   hasCloneMethod,


Test patch:
diff --git a/test/e2e/NoStackOverflowOnShrink.spec.ts b/test/e2e/NoStackOverflowOnShrink.spec.ts
index 6995cd5f..d95f2761 100644
--- a/test/e2e/NoStackOverflowOnShrink.spec.ts
+++ b/test/e2e/NoStackOverflowOnShrink.spec.ts
@@ -29,7 +29,7 @@ const maxDepthForArrays = 40000;
 const maxShrinksToAsk = 100;
 
 describe(`NoStackOverflowOnShrink (seed: ${seed})`, () => {
-  const iterateOverShrunkValues = <T>(arb: fc.Arbitrary<T>, v: fc.NextValue<T>) => {
+  const iterateOverShrunkValues = <T>(arb: fc.Arbitrary<T>, v: fc.Value<T>) => {
     const it = arb.shrink(v.value, v.context).take(maxShrinksToAsk)[Symbol.iterator]();
     let cur = it.next();
     while (!cur.done) {
@@ -43,17 +43,17 @@ describe(`NoStackOverflowOnShrink (seed: ${seed})`, () => {
     expect(maxDepthForArrays).toBeGreaterThan(callStackSizeWithMargin);
 
     class InfiniteShrinkingDepth extends fc.Arbitrary<number> {
-      generate(_mrng: fc.Random): fc.NextValue<number> {
-        return new fc.NextValue(0, undefined);
+      generate(_mrng: fc.Random): fc.Value<number> {
+        return new fc.Value(0, undefined);
       }
       canShrinkWithoutContext(value: unknown): value is number {
         return false;
       }
-      shrink(value: number): fc.Stream<fc.NextValue<number>> {
+      shrink(value: number): fc.Stream<fc.Value<number>> {
         if (value <= -maxDepthForArrays) {
           return fc.Stream.nil();
         }
-        return fc.Stream.of(new fc.NextValue(value - 1, undefined));
+        return fc.Stream.of(new fc.Value(value - 1, undefined));
       }
     }
 
@@ -72,7 +72,7 @@ describe(`NoStackOverflowOnShrink (seed: ${seed})`, () => {
 
     const mrng = new fc.Random(prand.xorshift128plus(seed));
     const arb = fc.array(fc.boolean(), { maxLength: maxDepthForArrays });
-    let value: fc.NextValue<boolean[]> | null = null;
+    let value: fc.Value<boolean[]> | null = null;
     while (value === null) {
       const tempShrinkable = arb.generate(mrng, undefined);
       if (tempShrinkable.value.length >= callStackSize) {
@@ -89,7 +89,7 @@ describe(`NoStackOverflowOnShrink (seed: ${seed})`, () => {
 
     const mrng = new fc.Random(prand.xorshift128plus(seed));
     const arb = fc.shuffledSubarray([...Array(maxDepthForArrays)].map((_, i) => i));
-    let value: fc.NextValue<number[]> | null = null;
+    let value: fc.Value<number[]> | null = null;
     while (value === null) {
       const tempShrinkable = arb.generate(mrng, undefined);
       if (tempShrinkable.value.length >= callStackSize) {
@@ -112,7 +112,7 @@ describe(`NoStackOverflowOnShrink (seed: ${seed})`, () => {
 
     const mrng = new fc.Random(prand.xorshift128plus(seed));
     const arb = fc.commands([fc.boolean().map((b) => new AnyCommand(b))], { maxCommands: maxDepthForArrays });
-    let value: fc.NextValue<Iterable<fc.Command<Record<string, unknown>, unknown>>> | null = null;
+    let value: fc.Value<Iterable<fc.Command<Record<string, unknown>, unknown>>> | null = null;
     while (value === null) {
       const tempShrinkable = arb.generate(mrng, undefined);
       const cmds = [...tempShrinkable.value];
diff --git a/test/e2e/StateFullArbitraries.spec.ts b/test/e2e/StateFullArbitraries.spec.ts
index 4099d4f8..405d3c2e 100644
--- a/test/e2e/StateFullArbitraries.spec.ts
+++ b/test/e2e/StateFullArbitraries.spec.ts
@@ -12,12 +12,12 @@ describe(`StateFullArbitraries (seed: ${seed})`, () => {
               return v;
             },
           };
-          return new fc.NextValue(v, undefined);
+          return new fc.Value(v, undefined);
         }
         canShrinkWithoutContext(value: unknown): value is any {
           return false;
         }
-        shrink(): fc.Stream<fc.NextValue<any>> {
+        shrink(): fc.Stream<fc.Value<any>> {
           return fc.Stream.nil();
         }
       })();
diff --git a/test/unit/arbitrary/__test-helpers__/NextArbitraryAssertions.ts b/test/unit/arbitrary/__test-helpers__/NextArbitraryAssertions.ts
index 04c9cb6d..dde052c5 100644
--- a/test/unit/arbitrary/__test-helpers__/NextArbitraryAssertions.ts
+++ b/test/unit/arbitrary/__test-helpers__/NextArbitraryAssertions.ts
@@ -2,7 +2,7 @@ import * as prand from 'pure-rand';
 import * as fc from '../../../../lib/fast-check';
 
 import { Arbitrary } from '../../../../src/check/arbitrary/definition/Arbitrary';
-import { NextValue } from '../../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../../src/check/arbitrary/definition/Value';
 import { Random } from '../../../../src/random/generator/Random';
 
 // Minimal requirements
@@ -35,11 +35,11 @@ export function assertProduceSameValueGivenSameSeed<T, U = never>(
         const arb = arbitraryBuilder(extraParameters);
 
         // Act / Assert
-        let g1: NextValue<T> | null = arb.generate(randomFromSeed(seed), biasFactor);
-        let g2: NextValue<T> | null = arb.generate(randomFromSeed(seed), biasFactor);
+        let g1: Value<T> | null = arb.generate(randomFromSeed(seed), biasFactor);
+        let g2: Value<T> | null = arb.generate(randomFromSeed(seed), biasFactor);
         if (noInitialContext) {
           const originalG2 = g2!;
-          g2 = new NextValue(originalG2.value_, undefined, () => originalG2.value);
+          g2 = new Value(originalG2.value_, undefined, () => originalG2.value);
         }
         while (g1 !== null && g2 !== null) {
           assertEquality(isEqual, g1.value, g2.value, extraParameters);
@@ -80,7 +80,7 @@ export function assertProduceCorrectValues<T, U = never>(
         const arb = arbitraryBuilder(extraParameters);
 
         // Act / Assert
-        let g: NextValue<T> | null = arb.generate(randomFromSeed(seed), biasFactor);
+        let g: Value<T> | null = arb.generate(randomFromSeed(seed), biasFactor);
         while (g !== null) {
           assertCorrectness(isCorrect, g.value, extraParameters, arb);
           const pos = shrinkPath.next().value;
diff --git a/test/unit/arbitrary/__test-helpers__/NextArbitraryHelpers.ts b/test/unit/arbitrary/__test-helpers__/NextArbitraryHelpers.ts
index 400f8017..75e594bc 100644
--- a/test/unit/arbitrary/__test-helpers__/NextArbitraryHelpers.ts
+++ b/test/unit/arbitrary/__test-helpers__/NextArbitraryHelpers.ts
@@ -1,7 +1,7 @@
 import { mocked } from 'ts-jest';
 import { MaybeMocked, MockWithArgs } from 'ts-jest/dist/utils/testing';
 import { Arbitrary } from '../../../../src/check/arbitrary/definition/Arbitrary';
-import { NextValue } from '../../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../../src/check/arbitrary/definition/Value';
 import { Random } from '../../../../src/random/generator/Random';
 import { Stream } from '../../../../src/stream/Stream';
 
@@ -48,7 +48,7 @@ export function fakeNextArbitraryStaticValue<T>(
   context: () => unknown = () => undefined
 ): { instance: Arbitrary<T> } {
   const { instance, generate, map } = fakeNextArbitrary<T>();
-  generate.mockImplementation(() => new NextValue(value(), context()));
+  generate.mockImplementation(() => new Value(value(), context()));
   map.mockImplementation((mapper) => {
     return fakeNextArbitraryStaticValue(() => mapper(value())).instance;
   });
@@ -66,13 +66,13 @@ export class FakeIntegerArbitrary extends Arbitrary<number> {
   constructor(readonly offset: number = 0, readonly rangeLength: number = 100) {
     super();
   }
-  generate(mrng: Random, biasFactor: number | undefined): NextValue<number> {
+  generate(mrng: Random, biasFactor: number | undefined): Value<number> {
     const minRange = Math.floor(this.rangeLength / 10);
     const maxRange = this.rangeLength;
     // Worst case: 0-minRange
     // No bias   : 0-maxRange
     const maxLimit = biasFactor !== undefined ? Math.max(minRange, maxRange - biasFactor) : maxRange;
-    return new NextValue(mrng.nextInt(0, maxLimit) + this.offset, { step: 2 });
+    return new Value(mrng.nextInt(0, maxLimit) + this.offset, { step: 2 });
   }
   canShrinkWithoutContext(value: unknown): value is number {
     return (
@@ -82,12 +82,12 @@ export class FakeIntegerArbitrary extends Arbitrary<number> {
       Number.isInteger(value)
     );
   }
-  shrink(value: number, context?: unknown): Stream<NextValue<number>> {
+  shrink(value: number, context?: unknown): Stream<Value<number>> {
     const currentStep = context !== undefined ? (context as { step: number }).step : 2;
     const nextStep = currentStep + 1;
     return Stream.of(
-      ...(value - currentStep >= this.offset ? [new NextValue(value - currentStep, { step: nextStep })] : []),
-      ...(value - currentStep + 1 >= this.offset ? [new NextValue(value - currentStep + 1, { step: nextStep })] : [])
+      ...(value - currentStep >= this.offset ? [new Value(value - currentStep, { step: nextStep })] : []),
+      ...(value - currentStep + 1 >= this.offset ? [new Value(value - currentStep + 1, { step: nextStep })] : [])
     );
   }
 }
diff --git a/test/unit/arbitrary/__test-helpers__/ShrinkTree.ts b/test/unit/arbitrary/__test-helpers__/ShrinkTree.ts
index 51ca81db..2de71546 100644
--- a/test/unit/arbitrary/__test-helpers__/ShrinkTree.ts
+++ b/test/unit/arbitrary/__test-helpers__/ShrinkTree.ts
@@ -1,6 +1,6 @@
 import * as fc from '../../../../lib/fast-check';
 import { Arbitrary } from '../../../../src/check/arbitrary/definition/Arbitrary';
-import { NextValue } from '../../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../../src/check/arbitrary/definition/Value';
 
 const truncatedSignal: any = Symbol();
 
@@ -8,7 +8,7 @@ export type ShrinkTree<T> = [T, ShrinkTree<T>[]];
 
 export function buildNextShrinkTree<T>(
   arb: Arbitrary<T>,
-  v: NextValue<T>,
+  v: Value<T>,
   lengthLimiter: { numItems: number } = { numItems: Number.POSITIVE_INFINITY }
 ): ShrinkTree<T> {
   --lengthLimiter.numItems;
diff --git a/test/unit/arbitrary/_internals/ArrayInt64Arbitrary.spec.ts b/test/unit/arbitrary/_internals/ArrayInt64Arbitrary.spec.ts
index 1c84c93f..3512d5d8 100644
--- a/test/unit/arbitrary/_internals/ArrayInt64Arbitrary.spec.ts
+++ b/test/unit/arbitrary/_internals/ArrayInt64Arbitrary.spec.ts
@@ -3,7 +3,7 @@ import * as fc from '../../../../lib/fast-check';
 import { arrayInt64 } from '../../../../src/arbitrary/_internals/ArrayInt64Arbitrary';
 import { ArrayInt64 } from '../../../../src/arbitrary/_internals/helpers/ArrayInt64';
 
-import { NextValue } from '../../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../../src/check/arbitrary/definition/Value';
 import { fakeRandom } from '../__test-helpers__/RandomHelpers';
 import { buildNextShrinkTree, renderTree } from '../__test-helpers__/ShrinkTree';
 import {
@@ -190,7 +190,7 @@ describe('arrayInt64', () => {
     it('should shrink strictly positive value for positive range including zero', () => {
       // Arrange
       const arb = arrayInt64({ sign: 1, data: [0, 0] }, { sign: 1, data: [0, 10] });
-      const source = new NextValue({ sign: 1, data: [0, 8] }, undefined); // no context
+      const source = new Value({ sign: 1, data: [0, 8] }, undefined); // no context
 
       // Act
       const tree = buildNextShrinkTree(arb, source);
@@ -245,7 +245,7 @@ describe('arrayInt64', () => {
     it('should shrink strictly positive value for range not including zero', () => {
       // Arrange
       const arb = arrayInt64({ sign: 1, data: [1, 10] }, { sign: 1, data: [1, 20] });
-      const source = new NextValue({ sign: 1, data: [1, 18] }, undefined); // no context
+      const source = new Value({ sign: 1, data: [1, 18] }, undefined); // no context
 
       // Act
       const tree = buildNextShrinkTree(arb, source);
@@ -300,7 +300,7 @@ describe('arrayInt64', () => {
     it('should shrink strictly negative value for negative range including zero', () => {
       // Arrange
       const arb = arrayInt64({ sign: -1, data: [0, 10] }, { sign: 1, data: [0, 0] });
-      const source = new NextValue({ sign: -1, data: [0, 8] }, undefined); // no context
+      const source = new Value({ sign: -1, data: [0, 8] }, undefined); // no context
 
       // Act
       const tree = buildNextShrinkTree(arb, source);
diff --git a/test/unit/arbitrary/_internals/BigIntArbitrary.spec.ts b/test/unit/arbitrary/_internals/BigIntArbitrary.spec.ts
index 0a9ff8e6..279a0e1e 100644
--- a/test/unit/arbitrary/_internals/BigIntArbitrary.spec.ts
+++ b/test/unit/arbitrary/_internals/BigIntArbitrary.spec.ts
@@ -1,6 +1,6 @@
 import * as fc from '../../../../lib/fast-check';
 import { BigIntArbitrary } from '../../../../src/arbitrary/_internals/BigIntArbitrary';
-import { NextValue } from '../../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../../src/check/arbitrary/definition/Value';
 import { fakeRandom } from '../__test-helpers__/RandomHelpers';
 import {
   assertProduceValuesShrinkableWithoutContext,
@@ -200,7 +200,7 @@ describe('BigIntArbitrary', () => {
         fc.property(fc.bigInt(), fc.bigInt(), fc.bigInt(), (a, b, c) => {
           // Arrange
           const [min, mid, max] = [a, b, c].sort((v1, v2) => Number(v1 - v2));
-          const expectedShrinks = Stream.nil<NextValue<bigint>>();
+          const expectedShrinks = Stream.nil<Value<bigint>>();
           const shrinkBigInt = jest.spyOn(ShrinkBigIntMock, 'shrinkBigInt');
           shrinkBigInt.mockReturnValueOnce(expectedShrinks);
 
@@ -276,8 +276,8 @@ describe('BigIntArbitrary (integration)', () => {
             const arbNegate = new BigIntArbitrary(-max, -min);
 
             // Act
-            const source = new NextValue(mid, undefined);
-            const sourceNegate = new NextValue(-mid, undefined);
+            const source = new Value(mid, undefined);
+            const sourceNegate = new Value(-mid, undefined);
             const tree = buildNextShrinkTree(arb, source);
             const treeNegate = buildNextShrinkTree(arbNegate, sourceNegate);
             const flat: bigint[] = [];
@@ -310,8 +310,8 @@ describe('BigIntArbitrary (integration)', () => {
             const arbOffset = new BigIntArbitrary(min + offset, max + offset);
 
             // Act
-            const source = new NextValue(mid, undefined);
-            const sourceOffset = new NextValue(mid + offset, undefined);
+            const source = new Value(mid, undefined);
+            const sourceOffset = new Value(mid + offset, undefined);
             const tree = buildNextShrinkTree(arb, source);
             const treeOffset = buildNextShrinkTree(arbOffset, sourceOffset);
             const flat: bigint[] = [];
@@ -330,7 +330,7 @@ describe('BigIntArbitrary (integration)', () => {
     it('should shrink strictly positive value for positive range including zero', () => {
       // Arrange
       const arb = new BigIntArbitrary(BigInt(0), BigInt(10));
-      const source = new NextValue(BigInt(8), undefined);
+      const source = new Value(BigInt(8), undefined);
 
       // Act
       const tree = buildNextShrinkTree(arb, source);
@@ -394,7 +394,7 @@ describe('BigIntArbitrary (integration)', () => {
     it('should shrink strictly positive value for range not including zero', () => {
       // Arrange
       const arb = new BigIntArbitrary(BigInt(10), BigInt(20));
-      const source = new NextValue(BigInt(18), undefined);
+      const source = new Value(BigInt(18), undefined);
 
       // Act
       const tree = buildNextShrinkTree(arb, source);
@@ -449,7 +449,7 @@ describe('BigIntArbitrary (integration)', () => {
     it('should shrink strictly negative value for negative range including zero', () => {
       // Arrange
       const arb = new BigIntArbitrary(BigInt(-10), BigInt(0));
-      const source = new NextValue(BigInt(-8), undefined);
+      const source = new Value(BigInt(-8), undefined);
 
       // Act
       const tree = buildNextShrinkTree(arb, source);
diff --git a/test/unit/arbitrary/_internals/CloneArbitrary.spec.ts b/test/unit/arbitrary/_internals/CloneArbitrary.spec.ts
index a14f187d..3b3a21b2 100644
--- a/test/unit/arbitrary/_internals/CloneArbitrary.spec.ts
+++ b/test/unit/arbitrary/_internals/CloneArbitrary.spec.ts
@@ -1,7 +1,7 @@
 import fc from '../../../../lib/fast-check';
 import { CloneArbitrary } from '../../../../src/arbitrary/_internals/CloneArbitrary';
 import { Arbitrary } from '../../../../src/check/arbitrary/definition/Arbitrary';
-import { NextValue } from '../../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../../src/check/arbitrary/definition/Value';
 import { cloneMethod, hasCloneMethod } from '../../../../src/check/symbols';
 import { Random } from '../../../../src/random/generator/Random';
 import { Stream } from '../../../../src/stream/Stream';
@@ -28,7 +28,7 @@ describe('CloneArbitrary', () => {
       const { instance: mrngClone2 } = fakeRandom();
       clone.mockReturnValueOnce(mrngClone1).mockReturnValueOnce(mrngClone2);
       const { instance: sourceArb, generate } = fakeNextArbitrary<symbol>();
-      generate.mockReturnValue(new NextValue(producedValue, undefined));
+      generate.mockReturnValue(new Value(producedValue, undefined));
 
       // Act
       const arb = new CloneArbitrary(sourceArb, numValues);
@@ -51,8 +51,8 @@ describe('CloneArbitrary', () => {
       const numValues = 1;
       const { instance: mrng } = fakeRandom();
       const { instance: sourceArb, generate } = fakeNextArbitrary<unknown>();
-      if (cloneable) generate.mockReturnValue(new NextValue({ [cloneMethod]: jest.fn() }, undefined));
-      else generate.mockReturnValue(new NextValue({ m: jest.fn() }, undefined));
+      if (cloneable) generate.mockReturnValue(new Value({ [cloneMethod]: jest.fn() }, undefined));
+      else generate.mockReturnValue(new Value({ m: jest.fn() }, undefined));
 
       // Act
       const arb = new CloneArbitrary(sourceArb, numValues);
@@ -128,9 +128,9 @@ describe('CloneArbitrary', () => {
       const numValues = 3;
       const { instance: sourceArb, shrink } = fakeNextArbitrary<symbol>();
       shrink
-        .mockReturnValueOnce(Stream.of<NextValue<symbol>>(new NextValue(s1, undefined), new NextValue(s2, undefined)))
-        .mockReturnValueOnce(Stream.of<NextValue<symbol>>(new NextValue(s1, undefined), new NextValue(s2, undefined)))
-        .mockReturnValueOnce(Stream.of<NextValue<symbol>>(new NextValue(s1, undefined), new NextValue(s2, undefined)));
+        .mockReturnValueOnce(Stream.of<Value<symbol>>(new Value(s1, undefined), new Value(s2, undefined)))
+        .mockReturnValueOnce(Stream.of<Value<symbol>>(new Value(s1, undefined), new Value(s2, undefined)))
+        .mockReturnValueOnce(Stream.of<Value<symbol>>(new Value(s1, undefined), new Value(s2, undefined)));
 
       // Act
       const arb = new CloneArbitrary(sourceArb, numValues);
@@ -228,13 +228,13 @@ describe('CloneArbitrary (integration)', () => {
 const expectedFirst = 4;
 
 class FirstArbitrary extends Arbitrary<number> {
-  generate(_mrng: Random): NextValue<number> {
-    return new NextValue(expectedFirst, { step: 2 });
+  generate(_mrng: Random): Value<number> {
+    return new Value(expectedFirst, { step: 2 });
   }
   canShrinkWithoutContext(_value: unknown): _value is number {
     throw new Error('No call expected in that scenario');
   }
-  shrink(value: number, context?: unknown): Stream<NextValue<number>> {
+  shrink(value: number, context?: unknown): Stream<Value<number>> {
     if (typeof context !== 'object' || context === null || !('step' in context)) {
       throw new Error('Invalid context for FirstArbitrary');
     }
@@ -244,8 +244,8 @@ class FirstArbitrary extends Arbitrary<number> {
     const currentStep = (context as { step: number }).step;
     const nextStep = currentStep + 1;
     return Stream.of(
-      ...(value - currentStep >= 0 ? [new NextValue(value - currentStep, { step: nextStep })] : []),
-      ...(value - currentStep + 1 >= 0 ? [new NextValue(value - currentStep + 1, { step: nextStep })] : [])
+      ...(value - currentStep >= 0 ? [new Value(value - currentStep, { step: nextStep })] : []),
+      ...(value - currentStep + 1 >= 0 ? [new Value(value - currentStep + 1, { step: nextStep })] : [])
     );
   }
 }
@@ -254,13 +254,13 @@ class CloneableArbitrary extends Arbitrary<number[]> {
   private instance() {
     return Object.defineProperty([], cloneMethod, { value: () => this.instance() });
   }
-  generate(_mrng: Random): NextValue<number[]> {
-    return new NextValue(this.instance(), { shrunkOnce: false });
+  generate(_mrng: Random): Value<number[]> {
+    return new Value(this.instance(), { shrunkOnce: false });
   }
   canShrinkWithoutContext(_value: unknown): _value is number[] {
     throw new Error('No call expected in that scenario');
   }
-  shrink(value: number[], context?: unknown): Stream<NextValue<number[]>> {
+  shrink(value: number[], context?: unknown): Stream<Value<number[]>> {
     if (typeof context !== 'object' || context === null || !('shrunkOnce' in context)) {
       throw new Error('Invalid context for CloneableArbitrary');
     }
@@ -268,6 +268,6 @@ class CloneableArbitrary extends Arbitrary<number[]> {
     if (safeContext.shrunkOnce) {
       return Stream.nil();
     }
-    return Stream.of(new NextValue(this.instance(), { shrunkOnce: true }));
+    return Stream.of(new Value(this.instance(), { shrunkOnce: true }));
   }
 }
diff --git a/test/unit/arbitrary/_internals/FrequencyArbitrary.spec.ts b/test/unit/arbitrary/_internals/FrequencyArbitrary.spec.ts
index d806bdaa..3bc0b6ce 100644
--- a/test/unit/arbitrary/_internals/FrequencyArbitrary.spec.ts
+++ b/test/unit/arbitrary/_internals/FrequencyArbitrary.spec.ts
@@ -1,6 +1,6 @@
 import * as fc from '../../../../lib/fast-check';
 import { FrequencyArbitrary, _Constraints } from '../../../../src/arbitrary/_internals/FrequencyArbitrary';
-import { NextValue } from '../../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../../src/check/arbitrary/definition/Value';
 import { fakeRandom } from '../__test-helpers__/RandomHelpers';
 import { FakeIntegerArbitrary, fakeNextArbitrary } from '../__test-helpers__/NextArbitraryHelpers';
 import {
@@ -35,7 +35,7 @@ const fromValidInputs = (metas: { weight: number; arbitraryValue: number }[]) =>
   metas.map((meta) => {
     const expectedContext = Symbol();
     const arbitraryMeta = fakeNextArbitrary<number>();
-    arbitraryMeta.generate.mockReturnValue(new NextValue(meta.arbitraryValue, expectedContext));
+    arbitraryMeta.generate.mockReturnValue(new Value(meta.arbitraryValue, expectedContext));
     return {
       weight: meta.weight,
       arbitraryMeta,
@@ -294,7 +294,7 @@ describe('FrequencyArbitrary', () => {
               arbitraryMeta.generate.mockImplementation(() => {
                 calledOnce = true;
                 expect(depthContext).toEqual({ depth: initialDepth + 1 });
-                return new NextValue(expectedValue, undefined);
+                return new Value(expectedValue, undefined);
               });
             }
 
@@ -523,7 +523,7 @@ describe('FrequencyArbitrary', () => {
             const { instance: mrng, nextInt } = fakeRandom();
             nextInt.mockImplementation(() => totalWeightBefore + (generateSeed % selectedArbitrary.weight));
             selectedArbitrary.arbitraryMeta.shrink.mockReturnValue(
-              Stream.of(new NextValue(1, undefined), new NextValue(42, undefined))
+              Stream.of(new Value(1, undefined), new Value(42, undefined))
             );
 
             // Act
@@ -566,7 +566,7 @@ describe('FrequencyArbitrary', () => {
             clone.mockReturnValue(anotherMrng);
             nextInt.mockImplementation(() => totalWeightBefore + (generateSeed % selectedArbitrary.weight));
             selectedArbitrary.arbitraryMeta.shrink.mockReturnValue(
-              Stream.of(new NextValue(1, undefined), new NextValue(42, undefined))
+              Stream.of(new Value(1, undefined), new Value(42, undefined))
             );
 
             // Act
@@ -600,9 +600,7 @@ describe('FrequencyArbitrary', () => {
 
             const { instance: mrng, nextInt } = fakeRandom();
             nextInt.mockReturnValue(0);
-            warbs[0].arbitraryMeta.shrink.mockReturnValue(
-              Stream.of(new NextValue(1, undefined), new NextValue(42, undefined))
-            );
+            warbs[0].arbitraryMeta.shrink.mockReturnValue(Stream.of(new Value(1, undefined), new Value(42, undefined)));
 
             // Act
             const arb = FrequencyArbitrary.from(warbs, { ...constraints, withCrossShrink: true }, 'test');
@@ -638,7 +636,7 @@ describe('FrequencyArbitrary', () => {
               const can = index === selectedIndex;
               input.arbitraryMeta.canShrinkWithoutContext.mockReturnValue(can);
               input.arbitraryMeta.shrink.mockReturnValue(
-                Stream.of(new NextValue(42, undefined), new NextValue(index, undefined))
+                Stream.of(new Value(42, undefined), new Value(index, undefined))
               );
             }
 
@@ -675,7 +673,7 @@ describe('FrequencyArbitrary', () => {
               const can = index === selectedIndex;
               input.arbitraryMeta.canShrinkWithoutContext.mockReturnValue(can);
               input.arbitraryMeta.shrink.mockReturnValue(
-                Stream.of(new NextValue(42, undefined), new NextValue(index, undefined))
+                Stream.of(new Value(42, undefined), new Value(index, undefined))
               );
             }
             warbs[0].fallbackValue = { default: 48 };
diff --git a/test/unit/arbitrary/_internals/IntegerArbitrary.spec.ts b/test/unit/arbitrary/_internals/IntegerArbitrary.spec.ts
index 978c8dc3..3f395ba5 100644
--- a/test/unit/arbitrary/_internals/IntegerArbitrary.spec.ts
+++ b/test/unit/arbitrary/_internals/IntegerArbitrary.spec.ts
@@ -1,6 +1,6 @@
 import * as fc from '../../../../lib/fast-check';
 import { IntegerArbitrary } from '../../../../src/arbitrary/_internals/IntegerArbitrary';
-import { NextValue } from '../../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../../src/check/arbitrary/definition/Value';
 import { fakeRandom } from '../__test-helpers__/RandomHelpers';
 import {
   assertProduceValuesShrinkableWithoutContext,
@@ -197,7 +197,7 @@ describe('IntegerArbitrary', () => {
         fc.property(fc.maxSafeNat(), fc.maxSafeNat(), fc.maxSafeNat(), (a, b, c) => {
           // Arrange
           const [min, mid, max] = [a, b, c].sort((v1, v2) => v1 - v2);
-          const expectedShrinks = Stream.nil<NextValue<number>>();
+          const expectedShrinks = Stream.nil<Value<number>>();
           const shrinkInteger = jest.spyOn(ShrinkIntegerMock, 'shrinkInteger');
           shrinkInteger.mockReturnValueOnce(expectedShrinks);
 
@@ -268,8 +268,8 @@ describe('IntegerArbitrary (integration)', () => {
             const arbNegate = new IntegerArbitrary(max !== 0 ? -max : 0, min !== 0 ? -min : min); // !==0 to avoid -0
 
             // Act
-            const source = new NextValue(mid, undefined);
-            const sourceNegate = new NextValue(mid !== 0 ? -mid : 0, undefined); // !==0 to avoid -0
+            const source = new Value(mid, undefined);
+            const sourceNegate = new Value(mid !== 0 ? -mid : 0, undefined); // !==0 to avoid -0
             const tree = buildNextShrinkTree(arb, source);
             const treeNegate = buildNextShrinkTree(arbNegate, sourceNegate);
             const flat: number[] = [];
@@ -302,8 +302,8 @@ describe('IntegerArbitrary (integration)', () => {
             const arbOffset = new IntegerArbitrary(min + offset, max + offset);
 
             // Act
-            const source = new NextValue(mid, undefined);
-            const sourceOffset = new NextValue(mid + offset, undefined);
+            const source = new Value(mid, undefined);
+            const sourceOffset = new Value(mid + offset, undefined);
             const tree = buildNextShrinkTree(arb, source);
             const treeOffset = buildNextShrinkTree(arbOffset, sourceOffset);
             const flat: number[] = [];
@@ -322,7 +322,7 @@ describe('IntegerArbitrary (integration)', () => {
     it('should shrink strictly positive value for positive range including zero', () => {
       // Arrange
       const arb = new IntegerArbitrary(0, 10);
-      const source = new NextValue(8, undefined);
+      const source = new Value(8, undefined);
 
       // Act
       const tree = buildNextShrinkTree(arb, source);
@@ -386,7 +386,7 @@ describe('IntegerArbitrary (integration)', () => {
     it('should shrink strictly positive value for range not including zero', () => {
       // Arrange
       const arb = new IntegerArbitrary(10, 20);
-      const source = new NextValue(18, undefined);
+      const source = new Value(18, undefined);
 
       // Act
       const tree = buildNextShrinkTree(arb, source);
@@ -441,7 +441,7 @@ describe('IntegerArbitrary (integration)', () => {
     it('should shrink strictly negative value for negative range including zero', () => {
       // Arrange
       const arb = new IntegerArbitrary(-10, 0);
-      const source = new NextValue(-8, undefined);
+      const source = new Value(-8, undefined);
 
       // Act
       const tree = buildNextShrinkTree(arb, source);
diff --git a/test/unit/arbitrary/_internals/LazyArbitrary.spec.ts b/test/unit/arbitrary/_internals/LazyArbitrary.spec.ts
index 49e98197..38f75c28 100644
--- a/test/unit/arbitrary/_internals/LazyArbitrary.spec.ts
+++ b/test/unit/arbitrary/_internals/LazyArbitrary.spec.ts
@@ -1,5 +1,6 @@
 import { LazyArbitrary } from '../../../../src/arbitrary/_internals/LazyArbitrary';
-import { NextValue, Stream } from '../../../../src/fast-check-default';
+import { Value } from '../../../../src/check/arbitrary/definition/Value';
+import { Stream } from '../../../../src/stream/Stream';
 import { fakeNextArbitrary } from '../__test-helpers__/NextArbitraryHelpers';
 import { fakeRandom } from '../__test-helpers__/RandomHelpers';
 
@@ -7,7 +8,7 @@ describe('LazyArbitrary', () => {
   describe('generate', () => {
     it('should call underlying on generate', () => {
       // Arrange
-      const value = new NextValue(Symbol(), Symbol());
+      const value = new Value(Symbol(), Symbol());
       const { instance: mrng } = fakeRandom();
       const { instance: underlying, generate } = fakeNextArbitrary();
       generate.mockReturnValue(value);
@@ -71,7 +72,7 @@ describe('LazyArbitrary', () => {
       // Arrange
       const value = Symbol();
       const context = Symbol();
-      const streamOutput = Stream.of(new NextValue(1, undefined));
+      const streamOutput = Stream.of(new Value(1, undefined));
       const { instance: underlying, shrink } = fakeNextArbitrary();
       shrink.mockReturnValue(streamOutput);
       const lazy = new LazyArbitrary('id007');
diff --git a/test/unit/arbitrary/_internals/MixedCaseArbitrary.spec.ts b/test/unit/arbitrary/_internals/MixedCaseArbitrary.spec.ts
index cb2713af..fd8280dd 100644
--- a/test/unit/arbitrary/_internals/MixedCaseArbitrary.spec.ts
+++ b/test/unit/arbitrary/_internals/MixedCaseArbitrary.spec.ts
@@ -11,7 +11,7 @@ import { stringOf } from '../../../../src/arbitrary/stringOf';
 import { nat } from '../../../../src/arbitrary/nat';
 import * as BigUintNMock from '../../../../src/arbitrary/bigUintN';
 import { fakeNextArbitrary } from '../__test-helpers__/NextArbitraryHelpers';
-import { NextValue } from '../../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../../src/check/arbitrary/definition/Value';
 import { fakeRandom } from '../__test-helpers__/RandomHelpers';
 
 function beforeEachHook() {
@@ -215,8 +215,8 @@ function mockSourceArbitrariesForGenerate(bigIntOutput: bigint, stringOutput: st
   const { instance: bigUintNInstance, generate: bigUintNGenerate } = fakeNextArbitrary();
   const bigUintN = jest.spyOn(BigUintNMock, 'bigUintN');
   bigUintN.mockReturnValue(bigUintNInstance);
-  bigUintNGenerate.mockReturnValueOnce(new NextValue(bigIntOutput, undefined));
+  bigUintNGenerate.mockReturnValueOnce(new Value(bigIntOutput, undefined));
   const { instance: stringInstance, generate: stringGenerate } = fakeNextArbitrary();
-  stringGenerate.mockReturnValueOnce(new NextValue(stringOutput, undefined));
+  stringGenerate.mockReturnValueOnce(new Value(stringOutput, undefined));
   return { bigUintN, stringInstance };
 }
diff --git a/test/unit/arbitrary/_internals/StreamArbitrary.spec.ts b/test/unit/arbitrary/_internals/StreamArbitrary.spec.ts
index 6da29f53..4dfedd39 100644
--- a/test/unit/arbitrary/_internals/StreamArbitrary.spec.ts
+++ b/test/unit/arbitrary/_internals/StreamArbitrary.spec.ts
@@ -1,6 +1,6 @@
 import * as fc from '../../../../lib/fast-check';
 import { StreamArbitrary } from '../../../../src/arbitrary/_internals/StreamArbitrary';
-import { NextValue } from '../../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../../src/check/arbitrary/definition/Value';
 import { cloneIfNeeded, hasCloneMethod } from '../../../../src/check/symbols';
 import { Stream } from '../../../../src/stream/Stream';
 import {
@@ -78,7 +78,7 @@ describe('StreamArbitrary', () => {
       let index = 0;
       const expectedValues = [...Array(numValuesToPull)].map(() => Symbol());
       const { instance: sourceArb, generate } = fakeNextArbitrary();
-      generate.mockImplementation(() => new NextValue(expectedValues[index++], undefined));
+      generate.mockImplementation(() => new Value(expectedValues[index++], undefined));
       const { instance: mrng, clone, nextInt } = fakeRandom();
       nextInt.mockReturnValueOnce(1); // for bias
       const { instance: mrngCloned } = fakeRandom();
@@ -103,7 +103,7 @@ describe('StreamArbitrary', () => {
       const numValuesToPullS2 = 3;
       const biasFactor = 48;
       const { instance: sourceArb, generate } = fakeNextArbitrary();
-      generate.mockImplementation(() => new NextValue(Symbol(), undefined));
+      generate.mockImplementation(() => new Value(Symbol(), undefined));
       const { instance: mrng, clone, nextInt } = fakeRandom();
       nextInt.mockReturnValueOnce(1); // for bias
       const { instance: mrngClonedA } = fakeRandom();
@@ -148,7 +148,7 @@ describe('StreamArbitrary', () => {
           const biasFactor = 48;
           let index = 0;
           const { instance: sourceArb, generate } = fakeNextArbitrary<number>();
-          generate.mockImplementation(() => new NextValue(expectedValues[index++], undefined));
+          generate.mockImplementation(() => new Value(expectedValues[index++], undefined));
           const { instance: mrng, clone, nextInt } = fakeRandom();
           nextInt.mockReturnValueOnce(2); // for no bias
           const { instance: mrngCloned } = fakeRandom();
@@ -178,7 +178,7 @@ describe('StreamArbitrary', () => {
       const biasFactor = 48;
       let index = 0;
       const { instance: sourceArb, generate } = fakeNextArbitrary<number>();
-      generate.mockImplementation(() => new NextValue(index++, undefined));
+      generate.mockImplementation(() => new Value(index++, undefined));
       const { instance: mrng, clone, nextInt } = fakeRandom();
       nextInt.mockReturnValueOnce(2); // for no bias
       const { instance: mrngCloned } = fakeRandom();
@@ -248,7 +248,7 @@ describe('StreamArbitrary', () => {
     it('should always shrink to nil', () => {
       // Arrange
       const { instance: sourceArb, generate, shrink } = fakeNextArbitrary<number>();
-      generate.mockReturnValue(new NextValue(0, undefined));
+      generate.mockReturnValue(new Value(0, undefined));
       const { instance: mrng } = fakeRandom();
 
       // Act
diff --git a/test/unit/arbitrary/_internals/TupleArbitrary.spec.ts b/test/unit/arbitrary/_internals/TupleArbitrary.spec.ts
index b37dc2f6..2bff5ebc 100644
--- a/test/unit/arbitrary/_internals/TupleArbitrary.spec.ts
+++ b/test/unit/arbitrary/_internals/TupleArbitrary.spec.ts
@@ -1,5 +1,5 @@
 import { TupleArbitrary } from '../../../../src/arbitrary/_internals/TupleArbitrary';
-import { NextValue } from '../../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../../src/check/arbitrary/definition/Value';
 import { FakeIntegerArbitrary, fakeNextArbitrary } from '../__test-helpers__/NextArbitraryHelpers';
 import { fakeRandom } from '../__test-helpers__/RandomHelpers';
 import { cloneMethod, hasCloneMethod } from '../../../../src/check/symbols';
@@ -26,9 +26,9 @@ describe('TupleArbitrary', () => {
       const { instance: instanceA, generate: generateA } = fakeNextArbitrary<symbol>();
       const { instance: instanceB, generate: generateB } = fakeNextArbitrary<symbol>();
       const { instance: instanceC, generate: generateC } = fakeNextArbitrary<symbol>();
-      generateA.mockReturnValueOnce(new NextValue(vA, undefined));
-      generateB.mockReturnValueOnce(new NextValue(vB, undefined));
-      generateC.mockReturnValueOnce(new NextValue(vC, undefined));
+      generateA.mockReturnValueOnce(new Value(vA, undefined));
+      generateB.mockReturnValueOnce(new Value(vB, undefined));
+      generateC.mockReturnValueOnce(new Value(vC, undefined));
       const { instance: mrng } = fakeRandom();
 
       // Act
@@ -46,8 +46,8 @@ describe('TupleArbitrary', () => {
       // Arrange
       const { instance: fakeArbitraryNotCloneableA, generate: generateA } = fakeNextArbitrary<string[]>();
       const { instance: fakeArbitraryCloneableB, generate: generateB } = fakeNextArbitrary<string[]>();
-      generateA.mockReturnValue(new NextValue([], undefined));
-      generateB.mockReturnValue(new NextValue(Object.defineProperty([], cloneMethod, { value: jest.fn() }), undefined));
+      generateA.mockReturnValue(new Value([], undefined));
+      generateB.mockReturnValue(new Value(Object.defineProperty([], cloneMethod, { value: jest.fn() }), undefined));
       const { instance: mrng } = fakeRandom();
 
       // Act
@@ -63,8 +63,8 @@ describe('TupleArbitrary', () => {
       // Arrange
       const { instance: fakeArbitraryNotCloneableA, generate: generateA } = fakeNextArbitrary<string[]>();
       const { instance: fakeArbitraryNotCloneableB, generate: generateB } = fakeNextArbitrary<string[]>();
-      generateA.mockReturnValue(new NextValue([], undefined));
-      generateB.mockReturnValue(new NextValue([], undefined));
+      generateA.mockReturnValue(new Value([], undefined));
+      generateB.mockReturnValue(new Value([], undefined));
       const { instance: mrng } = fakeRandom();
 
       // Act
@@ -81,9 +81,9 @@ describe('TupleArbitrary', () => {
       const { instance: fakeArbitraryNotCloneableA, generate: generateA } = fakeNextArbitrary<string[]>();
       const { instance: fakeArbitraryCloneableB, generate: generateB } = fakeNextArbitrary<string[]>();
       const cloneMethodImpl = jest.fn();
-      generateA.mockReturnValue(new NextValue([], undefined));
+      generateA.mockReturnValue(new Value([], undefined));
       generateB.mockReturnValue(
-        new NextValue(Object.defineProperty([], cloneMethod, { value: cloneMethodImpl }), undefined)
+        new Value(Object.defineProperty([], cloneMethod, { value: cloneMethodImpl }), undefined)
       );
       const { instance: mrng } = fakeRandom();
 
@@ -163,24 +163,22 @@ describe('TupleArbitrary', () => {
       const { instance: instanceA, generate: generateA, shrink: shrinkA } = fakeNextArbitrary<symbol>();
       const { instance: instanceB, generate: generateB, shrink: shrinkB } = fakeNextArbitrary<symbol>();
       const { instance: instanceC, generate: generateC, shrink: shrinkC } = fakeNextArbitrary<symbol>();
-      generateA.mockReturnValueOnce(new NextValue(vA, contextA));
-      generateB.mockReturnValueOnce(new NextValue(vB, contextB));
-      generateC.mockReturnValueOnce(new NextValue(vC, contextC));
+      generateA.mockReturnValueOnce(new Value(vA, contextA));
+      generateB.mockReturnValueOnce(new Value(vB, contextB));
+      generateC.mockReturnValueOnce(new Value(vC, contextC));
       const shrinkA1 = Symbol();
       const shrinkA2 = Symbol();
       const shrinkB1 = Symbol();
       const shrinkC1 = Symbol();
       const shrinkC2 = Symbol();
       const shrinkC3 = Symbol();
-      shrinkA.mockReturnValueOnce(
-        Stream.of(new NextValue(shrinkA1 as symbol, undefined), new NextValue(shrinkA2, undefined))
-      );
-      shrinkB.mockReturnValueOnce(Stream.of(new NextValue(shrinkB1 as symbol, undefined)));
+      shrinkA.mockReturnValueOnce(Stream.of(new Value(shrinkA1 as symbol, undefined), new Value(shrinkA2, undefined)));
+      shrinkB.mockReturnValueOnce(Stream.of(new Value(shrinkB1 as symbol, undefined)));
       shrinkC.mockReturnValueOnce(
         Stream.of(
-          new NextValue(shrinkC1 as symbol, undefined),
-          new NextValue(shrinkC2, undefined),
-          new NextValue(shrinkC3, undefined)
+          new Value(shrinkC1 as symbol, undefined),
+          new Value(shrinkC2, undefined),
+          new Value(shrinkC3, undefined)
         )
       );
       const { instance: mrng } = fakeRandom();
@@ -222,25 +220,25 @@ describe('TupleArbitrary', () => {
       const cloneMethodImpl = jest
         .fn()
         .mockImplementation(() => Object.defineProperty([], cloneMethod, { value: cloneMethodImpl }));
-      generateA.mockReturnValue(new NextValue([], undefined));
-      shrinkA.mockReturnValue(Stream.of(new NextValue([], undefined), new NextValue([], undefined)));
+      generateA.mockReturnValue(new Value([], undefined));
+      shrinkA.mockReturnValue(Stream.of(new Value([], undefined), new Value([], undefined)));
       generateB.mockReturnValue(
-        new NextValue(Object.defineProperty([], cloneMethod, { value: cloneMethodImpl }), undefined)
+        new Value(Object.defineProperty([], cloneMethod, { value: cloneMethodImpl }), undefined)
       );
       shrinkB.mockReturnValue(
         Stream.of(
-          new NextValue(Object.defineProperty([], cloneMethod, { value: cloneMethodImpl }), undefined),
-          new NextValue(Object.defineProperty([], cloneMethod, { value: cloneMethodImpl }), undefined),
-          new NextValue(Object.defineProperty([], cloneMethod, { value: cloneMethodImpl }), undefined)
+          new Value(Object.defineProperty([], cloneMethod, { value: cloneMethodImpl }), undefined),
+          new Value(Object.defineProperty([], cloneMethod, { value: cloneMethodImpl }), undefined),
+          new Value(Object.defineProperty([], cloneMethod, { value: cloneMethodImpl }), undefined)
         )
       );
-      generateC.mockReturnValue(new NextValue([], undefined));
+      generateC.mockReturnValue(new Value([], undefined));
       shrinkC.mockReturnValue(
         Stream.of(
-          new NextValue([], undefined),
-          new NextValue([], undefined),
-          new NextValue([], undefined),
-          new NextValue([], undefined)
+          new Value([], undefined),
+          new Value([], undefined),
+          new Value([], undefined),
+          new Value([], undefined)
         )
       );
       const { instance: mrng } = fakeRandom();
@@ -393,13 +391,13 @@ const expectedFirst = 4;
 const expectedSecond = 97;
 
 class FirstArbitrary extends Arbitrary<number> {
-  generate(_mrng: Random): NextValue<number> {
-    return new NextValue(expectedFirst, { step: 2 });
+  generate(_mrng: Random): Value<number> {
+    return new Value(expectedFirst, { step: 2 });
   }
   canShrinkWithoutContext(_value: unknown): _value is number {
     throw new Error('No call expected in that scenario');
   }
-  shrink(value: number, context?: unknown): Stream<NextValue<number>> {
+  shrink(value: number, context?: unknown): Stream<Value<number>> {
     if (typeof context !== 'object' || context === null || !('step' in context)) {
       throw new Error('Invalid context for FirstArbitrary');
     }
@@ -409,19 +407,19 @@ class FirstArbitrary extends Arbitrary<number> {
     const currentStep = (context as { step: number }).step;
     const nextStep = currentStep + 1;
     return Stream.of(
-      ...(value - currentStep >= 0 ? [new NextValue(value - currentStep, { step: nextStep })] : []),
-      ...(value - currentStep + 1 >= 0 ? [new NextValue(value - currentStep + 1, { step: nextStep })] : [])
+      ...(value - currentStep >= 0 ? [new Value(value - currentStep, { step: nextStep })] : []),
+      ...(value - currentStep + 1 >= 0 ? [new Value(value - currentStep + 1, { step: nextStep })] : [])
     );
   }
 }
 class SecondArbitrary extends Arbitrary<number> {
-  generate(_mrng: Random): NextValue<number> {
-    return new NextValue(expectedSecond, { step: 2 });
+  generate(_mrng: Random): Value<number> {
+    return new Value(expectedSecond, { step: 2 });
   }
   canShrinkWithoutContext(_value: unknown): _value is number {
     throw new Error('No call expected in that scenario');
   }
-  shrink(value: number, context?: unknown): Stream<NextValue<number>> {
+  shrink(value: number, context?: unknown): Stream<Value<number>> {
     if (typeof context !== 'object' || context === null || !('step' in context)) {
       throw new Error('Invalid context for SecondArbitrary');
     }
@@ -431,8 +429,8 @@ class SecondArbitrary extends Arbitrary<number> {
     const currentStep = (context as { step: number }).step;
     const nextStep = currentStep + 1;
     return Stream.of(
-      ...(value + currentStep <= 100 ? [new NextValue(value + currentStep, { step: nextStep })] : []),
-      ...(value + currentStep - 1 <= 100 ? [new NextValue(value + currentStep - 1, { step: nextStep })] : [])
+      ...(value + currentStep <= 100 ? [new Value(value + currentStep, { step: nextStep })] : []),
+      ...(value + currentStep - 1 <= 100 ? [new Value(value + currentStep - 1, { step: nextStep })] : [])
     );
   }
 }
@@ -441,13 +439,13 @@ class CloneableArbitrary extends Arbitrary<number[]> {
   private instance() {
     return Object.defineProperty([], cloneMethod, { value: () => this.instance() });
   }
-  generate(_mrng: Random): NextValue<number[]> {
-    return new NextValue(this.instance(), { shrunkOnce: false });
+  generate(_mrng: Random): Value<number[]> {
+    return new Value(this.instance(), { shrunkOnce: false });
   }
   canShrinkWithoutContext(_value: unknown): _value is number[] {
     throw new Error('No call expected in that scenario');
   }
-  shrink(value: number[], context?: unknown): Stream<NextValue<number[]>> {
+  shrink(value: number[], context?: unknown): Stream<Value<number[]>> {
     if (typeof context !== 'object' || context === null || !('shrunkOnce' in context)) {
       throw new Error('Invalid context for CloneableArbitrary');
     }
@@ -455,6 +453,6 @@ class CloneableArbitrary extends Arbitrary<number[]> {
     if (safeContext.shrunkOnce) {
       return Stream.nil();
     }
-    return Stream.of(new NextValue(this.instance(), { shrunkOnce: true }));
+    return Stream.of(new Value(this.instance(), { shrunkOnce: true }));
   }
 }
diff --git a/test/unit/arbitrary/_internals/helpers/BuildCompareFilter.spec.ts b/test/unit/arbitrary/_internals/helpers/BuildCompareFilter.spec.ts
index 22cd4da7..b9d589d1 100644
--- a/test/unit/arbitrary/_internals/helpers/BuildCompareFilter.spec.ts
+++ b/test/unit/arbitrary/_internals/helpers/BuildCompareFilter.spec.ts
@@ -1,6 +1,6 @@
 import * as fc from '../../../../../lib/fast-check';
 import { buildCompareFilter } from '../../../../../src/arbitrary/_internals/helpers/BuildCompareFilter';
-import { NextValue } from '../../../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../../../src/check/arbitrary/definition/Value';
 
 describe('buildCompareFilter', () => {
   it('should filter array from duplicated values', () =>
@@ -8,7 +8,7 @@ describe('buildCompareFilter', () => {
       fc.property(fc.array(fc.nat()), (tab) => {
         // Arrange
         const filter = buildCompareFilter<number>((a, b) => a === b);
-        const adaptedTab = tab.map((v) => new NextValue(v, undefined));
+        const adaptedTab = tab.map((v) => new Value(v, undefined));
 
         // Act
         const filteredTab = filter(adaptedTab);
diff --git a/test/unit/arbitrary/_internals/helpers/NoUndefinedAsContext.spec.ts b/test/unit/arbitrary/_internals/helpers/NoUndefinedAsContext.spec.ts
index b012f85a..9456e8f8 100644
--- a/test/unit/arbitrary/_internals/helpers/NoUndefinedAsContext.spec.ts
+++ b/test/unit/arbitrary/_internals/helpers/NoUndefinedAsContext.spec.ts
@@ -2,12 +2,12 @@ import {
   noUndefinedAsContext,
   UndefinedContextPlaceholder,
 } from '../../../../../src/arbitrary/_internals/helpers/NoUndefinedAsContext';
-import { NextValue } from '../../../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../../../src/check/arbitrary/definition/Value';
 
 describe('noUndefinedAsContext', () => {
   it('should never alter value if context is not undefined', () => {
     // Arrange
-    const value = new NextValue(1, 'my-context');
+    const value = new Value(1, 'my-context');
 
     // Act
     const out = noUndefinedAsContext(value);
@@ -18,7 +18,7 @@ describe('noUndefinedAsContext', () => {
 
   it('should never alter value if context is not undefined even if cloneable', () => {
     // Arrange
-    const value = new NextValue(1, 'my-context', () => 2);
+    const value = new Value(1, 'my-context', () => 2);
 
     // Act
     const out = noUndefinedAsContext(value);
@@ -30,7 +30,7 @@ describe('noUndefinedAsContext', () => {
 
   it('should create a new value with same underlying but defined context whenever context is undefined', () => {
     // Arrange
-    const value = new NextValue(1, undefined);
+    const value = new Value(1, undefined);
 
     // Act
     const out = noUndefinedAsContext(value);
@@ -44,7 +44,7 @@ describe('noUndefinedAsContext', () => {
 
   it('should create a new value with same underlying but defined context whenever context is undefined even if cloneable', () => {
     // Arrange
-    const value = new NextValue(1, undefined, () => 2);
+    const value = new Value(1, undefined, () => 2);
 
     // Act
     const out = noUndefinedAsContext(value);
diff --git a/test/unit/arbitrary/array.spec.ts b/test/unit/arbitrary/array.spec.ts
index 872cb189..1a7c651f 100644
--- a/test/unit/arbitrary/array.spec.ts
+++ b/test/unit/arbitrary/array.spec.ts
@@ -12,7 +12,7 @@ import {
   assertShrinkProducesStrictlySmallerValue,
 } from './__test-helpers__/NextArbitraryAssertions';
 import { isStrictlySmallerArray } from './__test-helpers__/ArrayHelpers';
-import { NextValue } from '../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../src/check/arbitrary/definition/Value';
 import { buildNextShrinkTree, renderTree } from './__test-helpers__/ShrinkTree';
 
 function beforeEachHook() {
@@ -178,7 +178,7 @@ describe('array (integration)', () => {
     // Arrange
     const constraints = { minLength };
     const arb = array(new FakeIntegerArbitrary(0, 1000), constraints);
-    const value = new NextValue(rawValue, undefined);
+    const value = new Value(rawValue, undefined);
 
     // Act
     const renderedTree = renderTree(buildNextShrinkTree(arb, value, { numItems: 100 })).join('\n');
diff --git a/test/unit/arbitrary/base64String.spec.ts b/test/unit/arbitrary/base64String.spec.ts
index 303b43e5..bfa4ce07 100644
--- a/test/unit/arbitrary/base64String.spec.ts
+++ b/test/unit/arbitrary/base64String.spec.ts
@@ -9,7 +9,7 @@ import {
 
 import * as ArrayMock from '../../../src/arbitrary/array';
 import { fakeNextArbitrary } from './__test-helpers__/NextArbitraryHelpers';
-import { NextValue } from '../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../src/check/arbitrary/definition/Value';
 import { buildNextShrinkTree, renderTree } from './__test-helpers__/ShrinkTree';
 
 function beforeEachHook() {
@@ -152,7 +152,7 @@ describe('base64String (integration)', () => {
   `('should be able to shrink $rawValue', ({ rawValue }) => {
     // Arrange
     const arb = base64String();
-    const value = new NextValue(rawValue, undefined);
+    const value = new Value(rawValue, undefined);
 
     // Act
     const renderedTree = renderTree(buildNextShrinkTree(arb, value, { numItems: 100 })).join('\n');
diff --git a/test/unit/arbitrary/dictionary.spec.ts b/test/unit/arbitrary/dictionary.spec.ts
index 6f190729..ab824781 100644
--- a/test/unit/arbitrary/dictionary.spec.ts
+++ b/test/unit/arbitrary/dictionary.spec.ts
@@ -2,7 +2,7 @@ import * as fc from '../../../lib/fast-check';
 import { dictionary } from '../../../src/arbitrary/dictionary';
 
 import { Arbitrary } from '../../../src/check/arbitrary/definition/Arbitrary';
-import { NextValue } from '../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../src/check/arbitrary/definition/Value';
 import { Random } from '../../../src/random/generator/Random';
 import { Stream } from '../../../src/stream/Stream';
 import {
@@ -58,15 +58,15 @@ class FromValuesArbitrary<T> extends Arbitrary<T> {
   constructor(readonly source: T[]) {
     super();
   }
-  generate(mrng: Random, _biasFactor: number): NextValue<T> {
+  generate(mrng: Random, _biasFactor: number): Value<T> {
     const index = mrng.nextInt(0, this.source.length - 1);
-    return new NextValue(this.source[index], undefined);
+    return new Value(this.source[index], undefined);
   }
   canShrinkWithoutContext(value: unknown): value is T {
     // includes might mix 0 and -0
     return this.source.includes(value as any);
   }
-  shrink(_value: T, _context?: unknown): Stream<NextValue<T>> {
+  shrink(_value: T, _context?: unknown): Stream<Value<T>> {
     return Stream.nil();
   }
 }
diff --git a/test/unit/arbitrary/domain.spec.ts b/test/unit/arbitrary/domain.spec.ts
index 9ba915c9..f1c771af 100644
--- a/test/unit/arbitrary/domain.spec.ts
+++ b/test/unit/arbitrary/domain.spec.ts
@@ -1,6 +1,6 @@
 import fc from '../../../lib/fast-check';
 import { domain } from '../../../src/arbitrary/domain';
-import { NextValue } from '../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../src/check/arbitrary/definition/Value';
 
 import {
   assertProduceSameValueGivenSameSeed,
@@ -63,7 +63,7 @@ describe('domain (integration)', () => {
   `('should be able to shrink $rawValue', ({ rawValue }) => {
     // Arrange
     const arb = domain();
-    const value = new NextValue(rawValue, undefined);
+    const value = new Value(rawValue, undefined);
 
     // Act
     const renderedTree = renderTree(buildNextShrinkTree(arb, value, { numItems: 100 })).join('\n');
diff --git a/test/unit/arbitrary/emailAddress.spec.ts b/test/unit/arbitrary/emailAddress.spec.ts
index 6c2bd171..479d1f85 100644
--- a/test/unit/arbitrary/emailAddress.spec.ts
+++ b/test/unit/arbitrary/emailAddress.spec.ts
@@ -1,6 +1,6 @@
 import fc from '../../../lib/fast-check';
 import { emailAddress } from '../../../src/arbitrary/emailAddress';
-import { NextValue } from '../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../src/check/arbitrary/definition/Value';
 
 import {
   assertProduceSameValueGivenSameSeed,
@@ -70,7 +70,7 @@ describe('emailAddress (integration)', () => {
   `('should be able to shrink $rawValue', ({ rawValue }) => {
     // Arrange
     const arb = emailAddress();
-    const value = new NextValue(rawValue, undefined);
+    const value = new Value(rawValue, undefined);
 
     // Act
     const renderedTree = renderTree(buildNextShrinkTree(arb, value, { numItems: 100 })).join('\n');
diff --git a/test/unit/arbitrary/fullUnicodeString.spec.ts b/test/unit/arbitrary/fullUnicodeString.spec.ts
index 6ec057be..f9e1235a 100644
--- a/test/unit/arbitrary/fullUnicodeString.spec.ts
+++ b/test/unit/arbitrary/fullUnicodeString.spec.ts
@@ -1,7 +1,7 @@
 import * as fc from '../../../lib/fast-check';
 import { fullUnicodeString } from '../../../src/arbitrary/fullUnicodeString';
 
-import { NextValue } from '../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../src/check/arbitrary/definition/Value';
 import {
   assertProduceValuesShrinkableWithoutContext,
   assertShrinkProducesSameValueWithoutInitialContext,
@@ -94,7 +94,7 @@ describe('fullUnicodeString (integration)', () => {
   `('should be able to shrink $rawValue', ({ rawValue }) => {
     // Arrange
     const arb = fullUnicodeString();
-    const value = new NextValue(rawValue, undefined);
+    const value = new Value(rawValue, undefined);
 
     // Act
     const renderedTree = renderTree(buildNextShrinkTree(arb, value, { numItems: 100 })).join('\n');
diff --git a/test/unit/arbitrary/func.spec.ts b/test/unit/arbitrary/func.spec.ts
index 5bb0e969..3e03746e 100644
--- a/test/unit/arbitrary/func.spec.ts
+++ b/test/unit/arbitrary/func.spec.ts
@@ -2,7 +2,7 @@ import * as fc from '../../../lib/fast-check';
 import { func } from '../../../src/arbitrary/func';
 
 import { Arbitrary } from '../../../src/check/arbitrary/definition/Arbitrary';
-import { NextValue } from '../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../src/check/arbitrary/definition/Value';
 import { hasCloneMethod, cloneIfNeeded, cloneMethod } from '../../../src/check/symbols';
 import { Random } from '../../../src/random/generator/Random';
 import { Stream } from '../../../src/stream/Stream';
@@ -101,18 +101,18 @@ describe('func (integration)', () => {
         if (!cloneable) return [value, 0];
         return Object.defineProperty([value, 1], cloneMethod, { value: () => this.instance(value, cloneable) });
       }
-      generate(mrng: Random): NextValue<number[]> {
-        return new NextValue(this.instance(mrng.nextInt(), mrng.nextBoolean()), { shrunkOnce: false });
+      generate(mrng: Random): Value<number[]> {
+        return new Value(this.instance(mrng.nextInt(), mrng.nextBoolean()), { shrunkOnce: false });
       }
       canShrinkWithoutContext(_value: unknown): _value is number[] {
         throw new Error('No call expected in that scenario');
       }
-      shrink(value: number[], context?: unknown): Stream<NextValue<number[]>> {
+      shrink(value: number[], context?: unknown): Stream<Value<number[]>> {
         const safeContext = context as { shrunkOnce: boolean };
         if (safeContext.shrunkOnce) {
           return Stream.nil();
         }
-        return Stream.of(new NextValue(this.instance(0, value[1] === 1), { shrunkOnce: true }));
+        return Stream.of(new Value(this.instance(0, value[1] === 1), { shrunkOnce: true }));
       }
     }
     assertProduceCorrectValues(
diff --git a/test/unit/arbitrary/ipV4.spec.ts b/test/unit/arbitrary/ipV4.spec.ts
index ba36002d..3894b445 100644
--- a/test/unit/arbitrary/ipV4.spec.ts
+++ b/test/unit/arbitrary/ipV4.spec.ts
@@ -1,6 +1,6 @@
 import { ipV4 } from '../../../src/arbitrary/ipV4';
 
-import { NextValue } from '../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../src/check/arbitrary/definition/Value';
 import {
   assertProduceValuesShrinkableWithoutContext,
   assertShrinkProducesSameValueWithoutInitialContext,
@@ -72,7 +72,7 @@ describe('ipV4 (integration)', () => {
   `('should be able to shrink $rawValue', ({ rawValue }) => {
     // Arrange
     const arb = ipV4();
-    const value = new NextValue(rawValue, undefined);
+    const value = new Value(rawValue, undefined);
 
     // Act
     const renderedTree = renderTree(buildNextShrinkTree(arb, value, { numItems: 100 })).join('\n');
diff --git a/test/unit/arbitrary/ipV4Extended.spec.ts b/test/unit/arbitrary/ipV4Extended.spec.ts
index 30364703..06e2262d 100644
--- a/test/unit/arbitrary/ipV4Extended.spec.ts
+++ b/test/unit/arbitrary/ipV4Extended.spec.ts
@@ -1,6 +1,6 @@
 import { ipV4Extended } from '../../../src/arbitrary/ipV4Extended';
 
-import { NextValue } from '../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../src/check/arbitrary/definition/Value';
 import {
   assertProduceValuesShrinkableWithoutContext,
   assertShrinkProducesSameValueWithoutInitialContext,
@@ -91,7 +91,7 @@ describe('ipV4Extended (integration)', () => {
   `('should be able to shrink $rawValue', ({ rawValue }) => {
     // Arrange
     const arb = ipV4Extended();
-    const value = new NextValue(rawValue, undefined);
+    const value = new Value(rawValue, undefined);
 
     // Act
     const renderedTree = renderTree(buildNextShrinkTree(arb, value, { numItems: 100 })).join('\n');
diff --git a/test/unit/arbitrary/ipV6.spec.ts b/test/unit/arbitrary/ipV6.spec.ts
index 98cde09e..a5a2e4c3 100644
--- a/test/unit/arbitrary/ipV6.spec.ts
+++ b/test/unit/arbitrary/ipV6.spec.ts
@@ -1,6 +1,6 @@
 import { ipV6 } from '../../../src/arbitrary/ipV6';
 
-import { NextValue } from '../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../src/check/arbitrary/definition/Value';
 import {
   assertProduceValuesShrinkableWithoutContext,
   assertShrinkProducesSameValueWithoutInitialContext,
@@ -149,7 +149,7 @@ describe('ipV6 (integration)', () => {
   `('should be able to shrink $rawValue', ({ rawValue }) => {
     // Arrange
     const arb = ipV6();
-    const value = new NextValue(rawValue, undefined);
+    const value = new Value(rawValue, undefined);
 
     // Act
     const renderedTree = renderTree(buildNextShrinkTree(arb, value, { numItems: 100 })).join('\n');
diff --git a/test/unit/arbitrary/letrec.spec.ts b/test/unit/arbitrary/letrec.spec.ts
index 8c2dd6f9..38496025 100644
--- a/test/unit/arbitrary/letrec.spec.ts
+++ b/test/unit/arbitrary/letrec.spec.ts
@@ -1,6 +1,6 @@
 import { letrec } from '../../../src/arbitrary/letrec';
 import { LazyArbitrary } from '../../../src/arbitrary/_internals/LazyArbitrary';
-import { NextValue } from '../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../src/check/arbitrary/definition/Value';
 import { Stream } from '../../../src/stream/Stream';
 import { FakeIntegerArbitrary, fakeNextArbitrary } from './__test-helpers__/NextArbitraryHelpers';
 import { fakeRandom } from './__test-helpers__/RandomHelpers';
@@ -129,7 +129,7 @@ describe('letrec', () => {
       // Arrange
       const biasFactor = 69;
       const { instance: simpleArb, generate } = fakeNextArbitrary();
-      generate.mockReturnValueOnce(new NextValue(null, undefined));
+      generate.mockReturnValueOnce(new Value(null, undefined));
       const { instance: mrng } = fakeRandom();
 
       // Act
@@ -185,7 +185,7 @@ describe('letrec', () => {
       // Arrange
       const biasFactor = 42;
       const { instance: simpleArb, generate } = fakeNextArbitrary();
-      generate.mockReturnValueOnce(new NextValue(null, undefined));
+      generate.mockReturnValueOnce(new Value(null, undefined));
       const { tie } = letrec((tie) => ({
         tie: tie('__proto__'),
         ['__proto__']: tie('__defineGetter__​​'),
@@ -217,7 +217,7 @@ describe('letrec', () => {
       // Arrange
       const biasFactor = 42;
       const { instance: simpleArb, generate } = fakeNextArbitrary();
-      generate.mockReturnValueOnce(new NextValue(null, undefined));
+      generate.mockReturnValueOnce(new Value(null, undefined));
       const { a } = letrec((tie) =>
         Object.assign(Object.create(null), {
           a: tie('b'),
@@ -281,7 +281,7 @@ describe('letrec', () => {
       // Arrange
       const expectedValue = Symbol();
       const expectedContext = Symbol();
-      const expectedStream = Stream.of(new NextValue(Symbol(), undefined));
+      const expectedStream = Stream.of(new Value(Symbol(), undefined));
       const { instance: simpleArb, shrink } = fakeNextArbitrary();
       shrink.mockReturnValueOnce(expectedStream);
       const { arb1 } = letrec((tie) => {
diff --git a/test/unit/arbitrary/mapToConstant.spec.ts b/test/unit/arbitrary/mapToConstant.spec.ts
index 3fce5cd7..62090350 100644
--- a/test/unit/arbitrary/mapToConstant.spec.ts
+++ b/test/unit/arbitrary/mapToConstant.spec.ts
@@ -1,6 +1,6 @@
 import fc from '../../../lib/fast-check';
 import { mapToConstant } from '../../../src/arbitrary/mapToConstant';
-import { NextValue } from '../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../src/check/arbitrary/definition/Value';
 import {
   assertProduceValuesShrinkableWithoutContext,
   assertProduceCorrectValues,
@@ -94,7 +94,7 @@ describe('mapToConstant (integration)', () => {
       { num: 6, build: (index) => String.fromCodePoint(index + 97) } // a-f
     );
     const rawValue = 'c';
-    const value = new NextValue(rawValue, undefined);
+    const value = new Value(rawValue, undefined);
 
     // Act
     const renderedTree = renderTree(buildNextShrinkTree(arb, value)).join('\n');
diff --git a/test/unit/arbitrary/set.spec.ts b/test/unit/arbitrary/set.spec.ts
index 56682e48..afb4e0ef 100644
--- a/test/unit/arbitrary/set.spec.ts
+++ b/test/unit/arbitrary/set.spec.ts
@@ -10,7 +10,7 @@ import {
   assertProduceValuesShrinkableWithoutContext,
   assertShrinkProducesSameValueWithoutInitialContext,
 } from './__test-helpers__/NextArbitraryAssertions';
-import { NextValue } from '../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../src/check/arbitrary/definition/Value';
 import { buildNextShrinkTree, renderTree } from './__test-helpers__/ShrinkTree';
 
 function beforeEachHook() {
@@ -227,7 +227,7 @@ describe('set (integration)', () => {
     // Arrange
     const constraints = { minLength };
     const arb = set(new FakeIntegerArbitrary(0, 1000), constraints);
-    const value = new NextValue(rawValue, undefined);
+    const value = new Value(rawValue, undefined);
 
     // Act
     const renderedTree = renderTree(buildNextShrinkTree(arb, value, { numItems: 100 })).join('\n');
diff --git a/test/unit/arbitrary/string.spec.ts b/test/unit/arbitrary/string.spec.ts
index 5d1d3667..0790a6ae 100644
--- a/test/unit/arbitrary/string.spec.ts
+++ b/test/unit/arbitrary/string.spec.ts
@@ -1,7 +1,7 @@
 import * as fc from '../../../lib/fast-check';
 import { string } from '../../../src/arbitrary/string';
 
-import { NextValue } from '../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../src/check/arbitrary/definition/Value';
 import {
   assertProduceValuesShrinkableWithoutContext,
   assertShrinkProducesSameValueWithoutInitialContext,
@@ -84,7 +84,7 @@ describe('string (integration)', () => {
   `('should be able to shrink $rawValue', ({ rawValue }) => {
     // Arrange
     const arb = string();
-    const value = new NextValue(rawValue, undefined);
+    const value = new Value(rawValue, undefined);
 
     // Act
     const renderedTree = renderTree(buildNextShrinkTree(arb, value, { numItems: 100 })).join('\n');
diff --git a/test/unit/arbitrary/stringOf.spec.ts b/test/unit/arbitrary/stringOf.spec.ts
index c6b3835d..2d1741d2 100644
--- a/test/unit/arbitrary/stringOf.spec.ts
+++ b/test/unit/arbitrary/stringOf.spec.ts
@@ -2,7 +2,7 @@ import * as fc from '../../../lib/fast-check';
 import { stringOf } from '../../../src/arbitrary/stringOf';
 
 import { Arbitrary } from '../../../src/check/arbitrary/definition/Arbitrary';
-import { NextValue } from '../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../src/check/arbitrary/definition/Value';
 import { Random } from '../../../src/random/generator/Random';
 import { Stream } from '../../../src/stream/Stream';
 import {
@@ -49,7 +49,7 @@ describe('stringOf (integration)', () => {
   `('should be able to shrink $rawValue', ({ rawValue, patterns }) => {
     // Arrange
     const arb = stringOf(new PatternsArbitrary(patterns));
-    const value = new NextValue(rawValue, undefined);
+    const value = new Value(rawValue, undefined);
 
     // Act
     const renderedTree = renderTree(buildNextShrinkTree(arb, value, { numItems: 100 })).join('\n');
@@ -66,18 +66,18 @@ class PatternsArbitrary extends Arbitrary<string> {
   constructor(readonly patterns: string[]) {
     super();
   }
-  generate(mrng: Random): NextValue<string> {
-    return new NextValue(this.patterns[mrng.nextInt(0, this.patterns.length - 1)], undefined);
+  generate(mrng: Random): Value<string> {
+    return new Value(this.patterns[mrng.nextInt(0, this.patterns.length - 1)], undefined);
   }
   canShrinkWithoutContext(value: unknown): value is string {
     if (typeof value !== 'string') return false;
     return this.patterns.includes(value);
   }
-  shrink(value: string): Stream<NextValue<string>> {
+  shrink(value: string): Stream<Value<string>> {
     const patternIndex = this.patterns.indexOf(value);
     if (patternIndex <= 0) {
       return Stream.nil();
     }
-    return Stream.of(new NextValue(this.patterns[0], undefined));
+    return Stream.of(new Value(this.patterns[0], undefined));
   }
 }
diff --git a/test/unit/arbitrary/webUrl.spec.ts b/test/unit/arbitrary/webUrl.spec.ts
index 508eacff..77f42989 100644
--- a/test/unit/arbitrary/webUrl.spec.ts
+++ b/test/unit/arbitrary/webUrl.spec.ts
@@ -8,7 +8,7 @@ import {
   assertProduceValuesShrinkableWithoutContext,
   assertShrinkProducesSameValueWithoutInitialContext,
 } from './__test-helpers__/NextArbitraryAssertions';
-import { NextValue } from '../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../src/check/arbitrary/definition/Value';
 import { buildNextShrinkTree, renderTree } from './__test-helpers__/ShrinkTree';
 
 function beforeEachHook() {
@@ -75,7 +75,7 @@ describe('webUrl (integration)', () => {
       withQueryParameters: true,
       withFragments: true,
     });
-    const value = new NextValue(rawValue, undefined);
+    const value = new Value(rawValue, undefined);
 
     // Act
     const renderedTree = renderTree(buildNextShrinkTree(arb, value, { numItems: 100 })).join('\n');
diff --git a/test/unit/check/arbitrary/definition/Arbitrary.itest.spec.ts b/test/unit/check/arbitrary/definition/Arbitrary.itest.spec.ts
index 87ff051c..36924c5a 100644
--- a/test/unit/check/arbitrary/definition/Arbitrary.itest.spec.ts
+++ b/test/unit/check/arbitrary/definition/Arbitrary.itest.spec.ts
@@ -1,6 +1,6 @@
 import { Arbitrary } from '../../../../../src/check/arbitrary/definition/Arbitrary';
 
-import { NextValue } from '../../../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../../../src/check/arbitrary/definition/Value';
 import { cloneMethod, hasCloneMethod } from '../../../../../src/check/symbols';
 import { Random } from '../../../../../src/random/generator/Random';
 import { Stream } from '../../../../../src/stream/Stream';
@@ -15,21 +15,21 @@ describe('Arbitrary', () => {
     it('should produce the right shrinking tree', () => {
       // Arrange
       class MyArbitrary extends Arbitrary<number> {
-        generate(_mrng: Random): NextValue<number> {
-          return new NextValue(10, { step: 2 });
+        generate(_mrng: Random): Value<number> {
+          return new Value(10, { step: 2 });
         }
         canShrinkWithoutContext(value: unknown): value is number {
           throw new Error('No call expected in current scenario');
         }
-        shrink(value: number, context?: unknown): Stream<NextValue<number>> {
+        shrink(value: number, context?: unknown): Stream<Value<number>> {
           if (typeof context !== 'object' || context === null || !('step' in context)) {
             throw new Error('Invalid context for MyArbitrary');
           }
           const currentStep = (context as { step: number }).step;
           const nextStep = currentStep + 1;
           return Stream.of(
-            ...(value - currentStep >= 0 ? [new NextValue(value - currentStep, { step: nextStep })] : []),
-            ...(value - 1 >= 0 ? [new NextValue(value - 1, { step: nextStep })] : [])
+            ...(value - currentStep >= 0 ? [new Value(value - currentStep, { step: nextStep })] : []),
+            ...(value - 1 >= 0 ? [new Value(value - 1, { step: nextStep })] : [])
           );
         }
       }
@@ -106,17 +106,17 @@ describe('Arbitrary', () => {
           const complexInstance = { value, [cloneMethod]: () => this.create(value) };
           return complexInstance;
         }
-        generate(_mrng: Random): NextValue<MyArbitraryOutput> {
-          return new NextValue(this.create(10), undefined);
+        generate(_mrng: Random): Value<MyArbitraryOutput> {
+          return new Value(this.create(10), undefined);
         }
         canShrinkWithoutContext(value: unknown): value is MyArbitraryOutput {
           throw new Error('No call expected in current scenario');
         }
-        shrink(v: MyArbitraryOutput, _context?: unknown): Stream<NextValue<MyArbitraryOutput>> {
+        shrink(v: MyArbitraryOutput, _context?: unknown): Stream<Value<MyArbitraryOutput>> {
           const value = v.value;
           return Stream.of(
-            ...(value - 2 >= 0 ? [new NextValue(this.create(value - 2), undefined)] : []),
-            ...(value - 1 >= 0 ? [new NextValue(this.create(value - 1), undefined)] : [])
+            ...(value - 2 >= 0 ? [new Value(this.create(value - 2), undefined)] : []),
+            ...(value - 1 >= 0 ? [new Value(this.create(value - 1), undefined)] : [])
           );
         }
       }
@@ -148,17 +148,17 @@ describe('Arbitrary', () => {
           const complexInstance = { value, counter: 0, [cloneMethod]: () => this.create(value) };
           return complexInstance;
         }
-        generate(_mrng: Random): NextValue<MyArbitraryOutput> {
-          return new NextValue(this.create(10), undefined);
+        generate(_mrng: Random): Value<MyArbitraryOutput> {
+          return new Value(this.create(10), undefined);
         }
         canShrinkWithoutContext(value: unknown): value is MyArbitraryOutput {
           throw new Error('No call expected in current scenario');
         }
-        shrink(v: MyArbitraryOutput, _context?: unknown): Stream<NextValue<MyArbitraryOutput>> {
+        shrink(v: MyArbitraryOutput, _context?: unknown): Stream<Value<MyArbitraryOutput>> {
           const value = v.value;
           return Stream.of(
-            ...(value - 2 >= 0 ? [new NextValue(this.create(value - 2), undefined)] : []),
-            ...(value - 1 >= 0 ? [new NextValue(this.create(value - 1), undefined)] : [])
+            ...(value - 2 >= 0 ? [new Value(this.create(value - 2), undefined)] : []),
+            ...(value - 1 >= 0 ? [new Value(this.create(value - 1), undefined)] : [])
           );
         }
       }
@@ -187,13 +187,13 @@ describe('Arbitrary', () => {
     it('should produce the right shrinking tree', () => {
       // Arrange
       class MyArbitrary extends Arbitrary<number> {
-        generate(_mrng: Random): NextValue<number> {
-          return new NextValue(5, { step: 2 });
+        generate(_mrng: Random): Value<number> {
+          return new Value(5, { step: 2 });
         }
         canShrinkWithoutContext(value: unknown): value is number {
           throw new Error('No call expected in current scenario');
         }
-        shrink(value: number, context?: unknown): Stream<NextValue<number>> {
+        shrink(value: number, context?: unknown): Stream<Value<number>> {
           if (typeof context !== 'object' || context === null || !('step' in context)) {
             throw new Error('Invalid context for MyArbitrary');
           }
@@ -202,15 +202,15 @@ describe('Arbitrary', () => {
             return Stream.nil();
           }
           const nextStep = currentStep + 1;
-          return Stream.of(new NextValue(value - currentStep, { step: nextStep }));
+          return Stream.of(new Value(value - currentStep, { step: nextStep }));
         }
       }
       class MyChainedArbitrary extends Arbitrary<number[]> {
         constructor(readonly size: number, readonly value: number) {
           super();
         }
-        generate(_mrng: Random): NextValue<number[]> {
-          return new NextValue(Array(this.size).fill(this.value), {
+        generate(_mrng: Random): Value<number[]> {
+          return new Value(Array(this.size).fill(this.value), {
             size: this.size,
             value: this.value,
           });
@@ -218,7 +218,7 @@ describe('Arbitrary', () => {
         canShrinkWithoutContext(value: unknown): value is number[] {
           throw new Error('No call expected in current scenario');
         }
-        shrink(value: number[], context?: unknown): Stream<NextValue<number[]>> {
+        shrink(value: number[], context?: unknown): Stream<Value<number[]>> {
           if (typeof context !== 'object' || context === null || !('size' in context) || !('value' in context)) {
             throw new Error('Invalid context for MyChainedArbitrary');
           }
@@ -228,9 +228,9 @@ describe('Arbitrary', () => {
           }
           return Stream.of(
             ...(currentContext.value === value[0]
-              ? [new NextValue(Array(currentContext.size).fill(0), currentContext)]
+              ? [new Value(Array(currentContext.size).fill(0), currentContext)]
               : []),
-            ...(value.length > 1 ? [new NextValue([value[0]], currentContext)] : [])
+            ...(value.length > 1 ? [new Value([value[0]], currentContext)] : [])
           );
         }
       }
@@ -263,22 +263,22 @@ describe('Arbitrary', () => {
     it('should produce the right shrinking tree', () => {
       // Arrange
       class MyArbitrary extends Arbitrary<number> {
-        generate(_mrng: Random): NextValue<number> {
-          return new NextValue(10, { step: 3 });
+        generate(_mrng: Random): Value<number> {
+          return new Value(10, { step: 3 });
         }
         canShrinkWithoutContext(value: unknown): value is number {
           throw new Error('No call expected in current scenario');
         }
-        shrink(value: number, context?: unknown): Stream<NextValue<number>> {
+        shrink(value: number, context?: unknown): Stream<Value<number>> {
           if (typeof context !== 'object' || context === null || !('step' in context)) {
             throw new Error('Invalid context for MyArbitrary');
           }
           const currentStep = (context as { step: number }).step;
           const nextStep = currentStep + 1;
           return Stream.of(
-            ...(value - currentStep >= 0 ? [new NextValue(value - currentStep, { step: nextStep })] : []),
-            ...(value - 2 >= 0 ? [new NextValue(value - 2, { step: nextStep })] : []),
-            ...(value - 1 >= 0 ? [new NextValue(value - 1, { step: nextStep })] : [])
+            ...(value - currentStep >= 0 ? [new Value(value - currentStep, { step: nextStep })] : []),
+            ...(value - 2 >= 0 ? [new Value(value - 2, { step: nextStep })] : []),
+            ...(value - 1 >= 0 ? [new Value(value - 1, { step: nextStep })] : [])
           );
         }
       }
diff --git a/test/unit/check/arbitrary/definition/Arbitrary.utest.spec.ts b/test/unit/check/arbitrary/definition/Arbitrary.utest.spec.ts
index 7327ed0d..e080da82 100644
--- a/test/unit/check/arbitrary/definition/Arbitrary.utest.spec.ts
+++ b/test/unit/check/arbitrary/definition/Arbitrary.utest.spec.ts
@@ -1,5 +1,5 @@
 import { Arbitrary } from '../../../../../src/check/arbitrary/definition/Arbitrary';
-import { NextValue } from '../../../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../../../src/check/arbitrary/definition/Value';
 import { Stream } from '../../../../../src/stream/Stream';
 import * as stubRng from '../../../stubs/generators';
 import { cloneMethod, hasCloneMethod } from '../../../../../src/check/symbols';
@@ -15,10 +15,10 @@ describe('NextArbitrary', () => {
       const generate = jest.fn();
       const canShrinkWithoutContext = jest.fn() as any as (value: unknown) => value is any;
       const shrink = jest.fn();
-      const choice1 = new NextValue(1, Symbol());
-      const choice2 = new NextValue(2, Symbol());
-      const choice3 = new NextValue(3, Symbol());
-      const choice4 = new NextValue(4, Symbol());
+      const choice1 = new Value(1, Symbol());
+      const choice2 = new Value(2, Symbol());
+      const choice3 = new Value(3, Symbol());
+      const choice4 = new Value(4, Symbol());
       generate
         .mockReturnValueOnce(choice1)
         .mockReturnValueOnce(choice2)
@@ -35,7 +35,7 @@ describe('NextArbitrary', () => {
       const g = arb.generate(mrngNoCall, expectedBiasFactor);
 
       // Assert
-      expect(g).toBe(choice3); // just returning the first NextValue that fits
+      expect(g).toBe(choice3); // just returning the first Value that fits
       expect(generate).toHaveBeenNthCalledWith(3, mrngNoCall, expectedBiasFactor); // same Random not cloned
     });
 
@@ -46,11 +46,11 @@ describe('NextArbitrary', () => {
       const shrink = jest.fn();
       const valueToShrink = 5;
       const contextToShrink = Symbol();
-      const choice1 = new NextValue(1, Symbol());
-      const choice2 = new NextValue(2, Symbol());
-      const choice3 = new NextValue(3, Symbol());
-      const choice4 = new NextValue(4, Symbol());
-      const choice5 = new NextValue(6, Symbol());
+      const choice1 = new Value(1, Symbol());
+      const choice2 = new Value(2, Symbol());
+      const choice3 = new Value(3, Symbol());
+      const choice4 = new Value(4, Symbol());
+      const choice5 = new Value(6, Symbol());
       shrink.mockReturnValueOnce(Stream.of(choice1, choice2, choice3, choice4, choice5));
       class MyNextArbitrary extends Arbitrary<any> {
         generate = generate;
@@ -114,7 +114,7 @@ describe('NextArbitrary', () => {
       const generate = jest.fn();
       const canShrinkWithoutContext = jest.fn() as any as (value: unknown) => value is any;
       const shrink = jest.fn();
-      const choice = new NextValue(1, Symbol());
+      const choice = new Value(1, Symbol());
       generate.mockReturnValueOnce(choice);
       class MyNextArbitrary extends Arbitrary<any> {
         generate = generate;
@@ -137,7 +137,7 @@ describe('NextArbitrary', () => {
       const generate = jest.fn();
       const canShrinkWithoutContext = jest.fn() as any as (value: unknown) => value is any;
       const shrink = jest.fn();
-      const choice = new NextValue({ source: 1, [cloneMethod]: () => choice.value_ }, Symbol());
+      const choice = new Value({ source: 1, [cloneMethod]: () => choice.value_ }, Symbol());
       generate.mockReturnValueOnce(choice);
       class MyNextArbitrary extends Arbitrary<any> {
         generate = generate;
@@ -151,7 +151,7 @@ describe('NextArbitrary', () => {
 
       // Assert
       expect(g.value.stringValue).toBe(String(choice.value.source)); // value has been mapped
-      expect(g.hasToBeCloned).toBe(true); // clone has been preserved on NextValue
+      expect(g.hasToBeCloned).toBe(true); // clone has been preserved on Value
       expect(hasCloneMethod(g.value)).toBe(true); // clone has been preserved on the instance
       expect(generate).toHaveBeenCalledWith(mrngNoCall, expectedBiasFactor);
     });
@@ -162,7 +162,7 @@ describe('NextArbitrary', () => {
       const generate = jest.fn();
       const canShrinkWithoutContext = jest.fn() as any as (value: unknown) => value is any;
       const shrink = jest.fn();
-      const choice = new NextValue({ source: 1, [cloneMethod]: () => choice.value_ }, Symbol());
+      const choice = new Value({ source: 1, [cloneMethod]: () => choice.value_ }, Symbol());
       const mappedClone = jest.fn();
       const mapped = { source: 42, [cloneMethod]: mappedClone };
       generate.mockReturnValueOnce(choice);
@@ -180,7 +180,7 @@ describe('NextArbitrary', () => {
       expect(g.value_).toBe(mapped); // value has been mapped
       expect(g.value_.source).toBe(mapped.source); // value has been mapped and value not altered
       expect(g.value_[cloneMethod]).toBe(mapped[cloneMethod]); // value has been mapped and clone method has been preserved
-      expect(g.hasToBeCloned).toBe(true); // clone has been preserved on NextValue
+      expect(g.hasToBeCloned).toBe(true); // clone has been preserved on Value
       expect(hasCloneMethod(g.value_)).toBe(true); // clone has been preserved on the instance
       expect(generate).toHaveBeenCalledWith(mrngNoCall, expectedBiasFactor);
     });
@@ -191,11 +191,11 @@ describe('NextArbitrary', () => {
       const generate = jest.fn();
       const canShrinkWithoutContext = jest.fn() as any as (value: unknown) => value is any;
       const shrink = jest.fn();
-      const source = new NextValue(69, Symbol());
+      const source = new Value(69, Symbol());
       generate.mockReturnValueOnce(source);
-      const choice1 = new NextValue(1, Symbol());
-      const choice2 = new NextValue(2, Symbol());
-      const choice3 = new NextValue(3, Symbol());
+      const choice1 = new Value(1, Symbol());
+      const choice2 = new Value(2, Symbol());
+      const choice3 = new Value(3, Symbol());
       shrink.mockReturnValueOnce(Stream.of(choice1, choice2, choice3));
       class MyNextArbitrary extends Arbitrary<any> {
         generate = generate;
@@ -219,14 +219,14 @@ describe('NextArbitrary', () => {
       const generate = jest.fn();
       const canShrinkWithoutContext = jest.fn() as any as (value: unknown) => value is any;
       const shrink = jest.fn();
-      const source = new NextValue(69, Symbol());
+      const source = new Value(69, Symbol());
       generate.mockReturnValueOnce(source);
-      const choice1 = new NextValue(1, Symbol());
-      const choice2 = new NextValue(2, Symbol());
-      const choice3 = new NextValue(3, Symbol());
+      const choice1 = new Value(1, Symbol());
+      const choice2 = new Value(2, Symbol());
+      const choice3 = new Value(3, Symbol());
       shrink.mockReturnValueOnce(Stream.of(choice1, choice2, choice3));
-      const choice21 = new NextValue(21, Symbol());
-      const choice22 = new NextValue(22, Symbol());
+      const choice21 = new Value(21, Symbol());
+      const choice22 = new Value(22, Symbol());
       shrink.mockReturnValueOnce(Stream.of(choice21, choice22));
       class MyNextArbitrary extends Arbitrary<any> {
         generate = generate;
@@ -253,10 +253,10 @@ describe('NextArbitrary', () => {
       const generate = jest.fn();
       const canShrinkWithoutContext = jest.fn() as any as (value: unknown) => value is any;
       const shrink = jest.fn();
-      const source = new NextValue({ source: 1, [cloneMethod]: () => source.value_ }, Symbol());
+      const source = new Value({ source: 1, [cloneMethod]: () => source.value_ }, Symbol());
       generate.mockReturnValueOnce(source);
-      const choice1 = new NextValue({ source: 2, [cloneMethod]: () => choice1.value_ }, Symbol());
-      const choice2 = new NextValue({ source: 2, [cloneMethod]: () => choice2.value_ }, Symbol());
+      const choice1 = new Value({ source: 2, [cloneMethod]: () => choice1.value_ }, Symbol());
+      const choice2 = new Value({ source: 2, [cloneMethod]: () => choice2.value_ }, Symbol());
       shrink.mockReturnValueOnce(Stream.of(choice1, choice2));
       class MyNextArbitrary extends Arbitrary<any> {
         generate = generate;
@@ -272,7 +272,7 @@ describe('NextArbitrary', () => {
 
       // Assert
       expect(shrinksValues).toHaveLength(2);
-      expect(shrinksValues[0].hasToBeCloned).toBe(true); // clone has been preserved on NextValue
+      expect(shrinksValues[0].hasToBeCloned).toBe(true); // clone has been preserved on Value
       expect(shrinksValues[1].hasToBeCloned).toBe(true);
       expect(hasCloneMethod(shrinksValues[0].value)).toBe(true); // clone has been preserved on the instance
       expect(hasCloneMethod(shrinksValues[1].value)).toBe(true);
@@ -381,9 +381,9 @@ describe('NextArbitrary', () => {
     it('should return a mapped version of the stream produced by the source arbitrary for the unmapped value when provided an unmapper function', () => {
       // Arrange
       const expectedStreamValuesFromSource = Stream.of(
-        new NextValue('titi', undefined),
-        new NextValue('toto', undefined),
-        new NextValue('tutu', undefined)
+        new Value('titi', undefined),
+        new Value('toto', undefined),
+        new Value('tutu', undefined)
       );
       const generate = jest.fn();
       const canShrinkWithoutContext = jest.fn();
@@ -417,12 +417,12 @@ describe('NextArbitrary', () => {
       const generate = jest.fn();
       const canShrinkWithoutContext = jest.fn() as any as (value: unknown) => value is any;
       const shrink = jest.fn();
-      const choiceRoot = new NextValue(1, Symbol());
+      const choiceRoot = new Value(1, Symbol());
       generate.mockReturnValueOnce(choiceRoot);
       const generateChained = jest.fn();
       const canShrinkWithoutContextChained = jest.fn() as any as (value: unknown) => value is any;
       const shrinkChained = jest.fn();
-      const choiceChained = new NextValue(50, Symbol());
+      const choiceChained = new Value(50, Symbol());
       generateChained.mockReturnValueOnce(choiceChained);
       class MyNextArbitrary extends Arbitrary<any> {
         generate = generate;
@@ -454,26 +454,26 @@ describe('NextArbitrary', () => {
       const generate = jest.fn();
       const canShrinkWithoutContext = jest.fn() as any as (value: unknown) => value is any;
       const shrink = jest.fn();
-      const choiceRoot = new NextValue(1, Symbol());
+      const choiceRoot = new Value(1, Symbol());
       generate.mockReturnValueOnce(choiceRoot);
-      const shrinkRoot1 = new NextValue(10, Symbol());
-      const shrinkRoot2 = new NextValue(11, Symbol());
-      const shrinkRoot3 = new NextValue(15, Symbol());
+      const shrinkRoot1 = new Value(10, Symbol());
+      const shrinkRoot2 = new Value(11, Symbol());
+      const shrinkRoot3 = new Value(15, Symbol());
       shrink.mockReturnValueOnce(Stream.of(shrinkRoot1, shrinkRoot2, shrinkRoot3));
       const generateChained = jest.fn();
       const canShrinkWithoutContextChained = jest.fn() as any as (value: unknown) => value is any;
       const shrinkChained = jest.fn();
-      const choiceChained = new NextValue(50, Symbol());
-      const choiceShrink1Chained = new NextValue(58, Symbol()); // chain will be called for each sub-shrink of root
-      const choiceShrink2Chained = new NextValue(57, Symbol());
-      const choiceShrink3Chained = new NextValue(16, Symbol());
+      const choiceChained = new Value(50, Symbol());
+      const choiceShrink1Chained = new Value(58, Symbol()); // chain will be called for each sub-shrink of root
+      const choiceShrink2Chained = new Value(57, Symbol());
+      const choiceShrink3Chained = new Value(16, Symbol());
       generateChained
         .mockReturnValueOnce(choiceChained)
         .mockReturnValueOnce(choiceShrink1Chained)
         .mockReturnValueOnce(choiceShrink2Chained)
         .mockReturnValueOnce(choiceShrink3Chained);
-      const shrinkChained1 = new NextValue(25, Symbol());
-      const shrinkChained2 = new NextValue(51, Symbol());
+      const shrinkChained1 = new Value(25, Symbol());
+      const shrinkChained2 = new Value(51, Symbol());
       shrinkChained.mockReturnValueOnce(Stream.of(shrinkChained1, shrinkChained2));
       class MyNextArbitrary extends Arbitrary<any> {
         generate = generate;
@@ -514,29 +514,29 @@ describe('NextArbitrary', () => {
       const generate = jest.fn();
       const canShrinkWithoutContext = jest.fn() as any as (value: unknown) => value is any;
       const shrink = jest.fn();
-      const choiceRoot = new NextValue(1, Symbol());
+      const choiceRoot = new Value(1, Symbol());
       generate.mockReturnValueOnce(choiceRoot);
-      const shrinkRoot1 = new NextValue(10, Symbol());
-      const shrinkRoot2 = new NextValue(11, Symbol()); // will not be iterated (getNthOrLast(0))
-      const shrinkRoot3 = new NextValue(15, Symbol()); // will not be iterated (getNthOrLast(0))
+      const shrinkRoot1 = new Value(10, Symbol());
+      const shrinkRoot2 = new Value(11, Symbol()); // will not be iterated (getNthOrLast(0))
+      const shrinkRoot3 = new Value(15, Symbol()); // will not be iterated (getNthOrLast(0))
       shrink.mockReturnValueOnce(Stream.of(shrinkRoot1, shrinkRoot2, shrinkRoot3));
-      const shrinkRoot11 = new NextValue(310, Symbol());
+      const shrinkRoot11 = new Value(310, Symbol());
       shrink.mockReturnValueOnce(Stream.of(shrinkRoot11));
       const generateChained = jest.fn();
       const canShrinkWithoutContextChained = jest.fn() as any as (value: unknown) => value is any;
       const shrinkChained = jest.fn();
-      const choiceChained = new NextValue(50, Symbol());
-      const choiceShrink1Chained = new NextValue(58, Symbol()); // chain will be called for each iterated sub-shrink of root (->10)
-      const choiceShrink2Chained = new NextValue(57, Symbol()); // ->310 - 11 and 15 will not be retrieved (getNthOrLast(0))
+      const choiceChained = new Value(50, Symbol());
+      const choiceShrink1Chained = new Value(58, Symbol()); // chain will be called for each iterated sub-shrink of root (->10)
+      const choiceShrink2Chained = new Value(57, Symbol()); // ->310 - 11 and 15 will not be retrieved (getNthOrLast(0))
       generateChained
         .mockReturnValueOnce(choiceChained)
         .mockReturnValueOnce(choiceShrink1Chained)
         .mockReturnValueOnce(choiceShrink2Chained);
-      const shrinkChained1 = new NextValue(25, Symbol());
-      const shrinkChained2 = new NextValue(51, Symbol());
+      const shrinkChained1 = new Value(25, Symbol());
+      const shrinkChained2 = new Value(51, Symbol());
       shrinkChained.mockReturnValueOnce(Stream.of(shrinkChained1, shrinkChained2));
-      const shrinkChained11 = new NextValue(125, Symbol());
-      const shrinkChained12 = new NextValue(151, Symbol());
+      const shrinkChained11 = new Value(125, Symbol());
+      const shrinkChained12 = new Value(151, Symbol());
       shrinkChained.mockReturnValueOnce(Stream.of(shrinkChained11, shrinkChained12));
       class MyNextArbitrary extends Arbitrary<any> {
         generate = generate;
@@ -577,26 +577,26 @@ describe('NextArbitrary', () => {
       const generate = jest.fn();
       const canShrinkWithoutContext = jest.fn() as any as (value: unknown) => value is any;
       const shrink = jest.fn();
-      const choiceRoot = new NextValue(1, Symbol());
+      const choiceRoot = new Value(1, Symbol());
       generate.mockReturnValueOnce(choiceRoot);
-      const shrinkRoot1 = new NextValue(10, Symbol());
-      const shrinkRoot2 = new NextValue(11, Symbol());
+      const shrinkRoot1 = new Value(10, Symbol());
+      const shrinkRoot2 = new Value(11, Symbol());
       shrink.mockReturnValueOnce(Stream.of(shrinkRoot1, shrinkRoot2));
       const generateChained = jest.fn();
       const canShrinkWithoutContextChained = jest.fn() as any as (value: unknown) => value is any;
       const shrinkChained = jest.fn();
-      const choiceChained = new NextValue(50, Symbol());
-      const choiceShrink1Chained = new NextValue(58, Symbol());
-      const choiceShrink2Chained = new NextValue(57, Symbol());
+      const choiceChained = new Value(50, Symbol());
+      const choiceShrink1Chained = new Value(58, Symbol());
+      const choiceShrink2Chained = new Value(57, Symbol());
       generateChained
         .mockReturnValueOnce(choiceChained)
         .mockReturnValueOnce(choiceShrink1Chained)
         .mockReturnValueOnce(choiceShrink2Chained);
-      const shrinkChained1 = new NextValue(25, Symbol());
-      const shrinkChained2 = new NextValue(51, Symbol());
+      const shrinkChained1 = new Value(25, Symbol());
+      const shrinkChained2 = new Value(51, Symbol());
       shrinkChained.mockReturnValueOnce(Stream.of(shrinkChained1, shrinkChained2));
-      const shrinkChained11 = new NextValue(125, Symbol());
-      const shrinkChained12 = new NextValue(151, Symbol());
+      const shrinkChained11 = new Value(125, Symbol());
+      const shrinkChained12 = new Value(151, Symbol());
       shrinkChained.mockReturnValueOnce(Stream.of(shrinkChained11, shrinkChained12));
       class MyNextArbitrary extends Arbitrary<any> {
         generate = generate;
@@ -664,13 +664,13 @@ describe('NextArbitrary', () => {
   });
 
   describe('noShrink', () => {
-    it('should simply return the original instance of NextValue on generate', () => {
+    it('should simply return the original instance of Value on generate', () => {
       // Arrange
       const expectedBiasFactor = 48;
       const generate = jest.fn();
       const canShrinkWithoutContext = jest.fn() as any as (value: unknown) => value is any;
       const shrink = jest.fn();
-      const choice = new NextValue(1, Symbol());
+      const choice = new Value(1, Symbol());
       generate.mockReturnValueOnce(choice);
       class MyNextArbitrary extends Arbitrary<any> {
         generate = generate;
@@ -691,7 +691,7 @@ describe('NextArbitrary', () => {
       // Arrange
       const shrink = jest.fn();
       class MyNextArbitrary extends Arbitrary<any> {
-        generate(): NextValue<any> {
+        generate(): Value<any> {
           throw new Error('Not implemented.');
         }
         canShrinkWithoutContext(value: unknown): value is any {
@@ -713,13 +713,13 @@ describe('NextArbitrary', () => {
     it('should return itself when called twice', () => {
       // Arrange
       class MyNextArbitrary extends Arbitrary<any> {
-        generate(): NextValue<any> {
+        generate(): Value<any> {
           throw new Error('Not implemented.');
         }
         canShrinkWithoutContext(value: unknown): value is any {
           throw new Error('Not implemented.');
         }
-        shrink(): Stream<NextValue<any>> {
+        shrink(): Stream<Value<any>> {
           throw new Error('Not implemented.');
         }
       }
@@ -743,7 +743,7 @@ describe('NextArbitrary', () => {
         canShrinkWithoutContext(value: unknown): value is any {
           throw new Error('Not implemented.');
         }
-        shrink(): Stream<NextValue<any>> {
+        shrink(): Stream<Value<any>> {
           throw new Error('Not implemented.');
         }
       }
@@ -761,13 +761,13 @@ describe('NextArbitrary', () => {
     it('should return itself when called twice', () => {
       // Arrange
       class MyNextArbitrary extends Arbitrary<any> {
-        generate(): NextValue<any> {
+        generate(): Value<any> {
           throw new Error('Not implemented.');
         }
         canShrinkWithoutContext(value: unknown): value is any {
           throw new Error('Not implemented.');
         }
-        shrink(): Stream<NextValue<any>> {
+        shrink(): Stream<Value<any>> {
           throw new Error('Not implemented.');
         }
       }
diff --git a/test/unit/check/arbitrary/definition/NextValue.utest.spec.ts b/test/unit/check/arbitrary/definition/NextValue.utest.spec.ts
index 3f4e1a84..da9aef1f 100644
--- a/test/unit/check/arbitrary/definition/NextValue.utest.spec.ts
+++ b/test/unit/check/arbitrary/definition/NextValue.utest.spec.ts
@@ -1,7 +1,7 @@
-import { NextValue } from '../../../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../../../src/check/arbitrary/definition/Value';
 import { cloneMethod } from '../../../../../src/check/symbols';
 
-describe('NextValue', () => {
+describe('Value', () => {
   describe('cloneable values', () => {
     it('should not clone cloneable values on first access', () => {
       // Arrange
@@ -9,7 +9,7 @@ describe('NextValue', () => {
       const instance = { [cloneMethod]: clone };
 
       // Act
-      const nextValue = new NextValue(instance, undefined);
+      const nextValue = new Value(instance, undefined);
       const value = nextValue.value;
 
       // Assert
@@ -23,7 +23,7 @@ describe('NextValue', () => {
       const instance = { [cloneMethod]: clone };
 
       // Act
-      const nextValue = new NextValue(instance, undefined);
+      const nextValue = new Value(instance, undefined);
       const value = nextValue.value;
       const value2 = nextValue.value;
 
@@ -40,7 +40,7 @@ describe('NextValue', () => {
       const instance = { [cloneMethod]: clone };
 
       // Act
-      const nextValue = new NextValue(instance, null, cloneOverride);
+      const nextValue = new Value(instance, null, cloneOverride);
       nextValue.value;
       nextValue.value;
 
diff --git a/test/unit/check/property/AsyncProperty.spec.ts b/test/unit/check/property/AsyncProperty.spec.ts
index a9112f2c..fe587b75 100644
--- a/test/unit/check/property/AsyncProperty.spec.ts
+++ b/test/unit/check/property/AsyncProperty.spec.ts
@@ -6,7 +6,7 @@ import { configureGlobal, resetConfigureGlobal } from '../../../../src/check/run
 
 import * as stubArb from '../../stubs/arbitraries';
 import * as stubRng from '../../stubs/generators';
-import { NextValue } from '../../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../../src/check/arbitrary/definition/Value';
 import { fakeNextArbitrary } from '../../arbitrary/__test-helpers__/NextArbitraryHelpers';
 import { Stream } from '../../../../src/stream/Stream';
 
@@ -82,7 +82,7 @@ describe('AsyncProperty', () => {
 
   it('Should use the unbiased arbitrary by default', () => {
     const { instance, generate } = fakeNextArbitrary<number>();
-    generate.mockReturnValue(new NextValue(69, undefined));
+    generate.mockReturnValue(new Value(69, undefined));
     const mrng = stubRng.mutable.nocall();
 
     const p = asyncProperty(instance, async () => {});
@@ -94,7 +94,7 @@ describe('AsyncProperty', () => {
   });
   it('Should use the biased arbitrary when asked to', () => {
     const { instance, generate } = fakeNextArbitrary<number>();
-    generate.mockReturnValue(new NextValue(42, undefined));
+    generate.mockReturnValue(new Value(42, undefined));
     const mrng = stubRng.mutable.nocall();
 
     const p = asyncProperty(instance, async () => {});
@@ -273,7 +273,7 @@ describe('AsyncProperty', () => {
 
     // Act
     const p = asyncProperty(arb, jest.fn());
-    const shrinks = p.shrink(new NextValue([value], undefined)); // context=undefined in the case of user defined values
+    const shrinks = p.shrink(new Value([value], undefined)); // context=undefined in the case of user defined values
 
     // Assert
     expect(canShrinkWithoutContext).toHaveBeenCalledWith(value);
@@ -287,12 +287,12 @@ describe('AsyncProperty', () => {
     canShrinkWithoutContext.mockReturnValue(true);
     const s1 = Symbol();
     const s2 = Symbol();
-    shrink.mockReturnValue(Stream.of(new NextValue<symbol>(s1, undefined), new NextValue(s2, undefined)));
+    shrink.mockReturnValue(Stream.of(new Value<symbol>(s1, undefined), new Value(s2, undefined)));
     const value = Symbol();
 
     // Act
     const p = asyncProperty(arb, jest.fn());
-    const shrinks = p.shrink(new NextValue([value], undefined)); // context=undefined in the case of user defined values
+    const shrinks = p.shrink(new Value([value], undefined)); // context=undefined in the case of user defined values
 
     // Assert
     expect(canShrinkWithoutContext).toHaveBeenCalledWith(value);
diff --git a/test/unit/check/property/Property.spec.ts b/test/unit/check/property/Property.spec.ts
index 2c7c4efb..347d987e 100644
--- a/test/unit/check/property/Property.spec.ts
+++ b/test/unit/check/property/Property.spec.ts
@@ -7,7 +7,7 @@ import { configureGlobal, resetConfigureGlobal } from '../../../../src/check/run
 import * as stubArb from '../../stubs/arbitraries';
 import * as stubRng from '../../stubs/generators';
 import { fakeNextArbitrary } from '../../arbitrary/__test-helpers__/NextArbitraryHelpers';
-import { NextValue } from '../../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../../src/check/arbitrary/definition/Value';
 import { Stream } from '../../../../src/stream/Stream';
 
 describe('Property', () => {
@@ -83,7 +83,7 @@ describe('Property', () => {
     expect(() => property(stubArb.single(8), stubArb.single(8), {} as Arbitrary<any>, () => {})).toThrowError());
   it('Should use the unbiased arbitrary by default', () => {
     const { instance, generate } = fakeNextArbitrary<number>();
-    generate.mockReturnValue(new NextValue(69, undefined));
+    generate.mockReturnValue(new Value(69, undefined));
     const mrng = stubRng.mutable.nocall();
 
     const p = property(instance, () => {});
@@ -95,7 +95,7 @@ describe('Property', () => {
   });
   it('Should use the biased arbitrary when asked to', () => {
     const { instance, generate } = fakeNextArbitrary<number>();
-    generate.mockReturnValue(new NextValue(42, undefined));
+    generate.mockReturnValue(new Value(42, undefined));
     const mrng = stubRng.mutable.nocall();
 
     const p = property(instance, () => {});
@@ -245,7 +245,7 @@ describe('Property', () => {
 
     // Act
     const p = property(arb, jest.fn());
-    const shrinks = p.shrink(new NextValue([value], undefined)); // context=undefined in the case of user defined values
+    const shrinks = p.shrink(new Value([value], undefined)); // context=undefined in the case of user defined values
 
     // Assert
     expect(canShrinkWithoutContext).toHaveBeenCalledWith(value);
@@ -259,12 +259,12 @@ describe('Property', () => {
     canShrinkWithoutContext.mockReturnValue(true);
     const s1 = Symbol();
     const s2 = Symbol();
-    shrink.mockReturnValue(Stream.of(new NextValue<symbol>(s1, undefined), new NextValue(s2, undefined)));
+    shrink.mockReturnValue(Stream.of(new Value<symbol>(s1, undefined), new Value(s2, undefined)));
     const value = Symbol();
 
     // Act
     const p = property(arb, jest.fn());
-    const shrinks = p.shrink(new NextValue([value], undefined)); // context=undefined in the case of user defined values
+    const shrinks = p.shrink(new Value([value], undefined)); // context=undefined in the case of user defined values
 
     // Assert
     expect(canShrinkWithoutContext).toHaveBeenCalledWith(value);
diff --git a/test/unit/check/property/SkipAfterProperty.spec.ts b/test/unit/check/property/SkipAfterProperty.spec.ts
index ac94fd56..3404dc7e 100644
--- a/test/unit/check/property/SkipAfterProperty.spec.ts
+++ b/test/unit/check/property/SkipAfterProperty.spec.ts
@@ -2,7 +2,7 @@ import { SkipAfterProperty } from '../../../../src/check/property/SkipAfterPrope
 import { PreconditionFailure } from '../../../../src/check/precondition/PreconditionFailure';
 import { fakeProperty } from './__test-helpers__/PropertyHelpers';
 import { fakeRandom } from '../../arbitrary/__test-helpers__/RandomHelpers';
-import { NextValue } from '../../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../../src/check/arbitrary/definition/Value';
 
 const startTimeMs = 200;
 const timeLimitMs = 100;
@@ -62,7 +62,7 @@ describe('SkipAfterProperty', () => {
 
     // Act
     const p = new SkipAfterProperty(decoratedProperty, timerMock, 0, false);
-    p.shrink(new NextValue(Symbol('value'), Symbol('context')));
+    p.shrink(new Value(Symbol('value'), Symbol('context')));
 
     // Assert
     expect(timerMock).toHaveBeenCalledTimes(1);
diff --git a/test/unit/check/property/TimeoutProperty.spec.ts b/test/unit/check/property/TimeoutProperty.spec.ts
index db78cfb2..799cadb9 100644
--- a/test/unit/check/property/TimeoutProperty.spec.ts
+++ b/test/unit/check/property/TimeoutProperty.spec.ts
@@ -1,4 +1,4 @@
-import { NextValue } from '../../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../../src/check/arbitrary/definition/Value';
 import { TimeoutProperty } from '../../../../src/check/property/TimeoutProperty';
 import { fakeRandom } from '../../arbitrary/__test-helpers__/RandomHelpers';
 import { fakeProperty } from './__test-helpers__/PropertyHelpers';
@@ -14,7 +14,7 @@ describe('TimeoutProperty', () => {
     const { instance: decoratedProperty, generate } = fakeProperty(true);
     const { instance: mrng } = fakeRandom();
     const expectedRunId = 42;
-    const expectedOut = new NextValue(Symbol('value'), Symbol('context'));
+    const expectedOut = new Value(Symbol('value'), Symbol('context'));
     generate.mockReturnValueOnce(expectedOut);
 
     // Act
diff --git a/test/unit/check/runner/DecorateProperty.spec.ts b/test/unit/check/runner/DecorateProperty.spec.ts
index fbff6fe2..9f8cf387 100644
--- a/test/unit/check/runner/DecorateProperty.spec.ts
+++ b/test/unit/check/runner/DecorateProperty.spec.ts
@@ -1,6 +1,6 @@
 import { decorateProperty } from '../../../../src/check/runner/DecorateProperty';
 import { IRawProperty } from '../../../../src/check/property/IRawProperty';
-import { NextValue } from '../../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../../src/check/arbitrary/definition/Value';
 import { Stream } from '../../../../src/stream/Stream';
 
 // Mocks
@@ -16,7 +16,7 @@ jest.mock('../../../../src/check/property/IgnoreEqualValuesProperty');
 function buildProperty(asyncProp: boolean) {
   return {
     isAsync: () => asyncProp,
-    generate: () => new NextValue({}, undefined),
+    generate: () => new Value({}, undefined),
     shrink: () => Stream.nil(),
     run: () => null,
   } as IRawProperty<any>;
diff --git a/test/unit/check/runner/Runner.spec.ts b/test/unit/check/runner/Runner.spec.ts
index a1067913..0c3a9bac 100644
--- a/test/unit/check/runner/Runner.spec.ts
+++ b/test/unit/check/runner/Runner.spec.ts
@@ -1,6 +1,6 @@
 import * as fc from '../../../../lib/fast-check';
 
-import { NextValue } from '../../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../../src/check/arbitrary/definition/Value';
 import { char } from '../../../../src/arbitrary/char';
 import { IRawProperty } from '../../../../src/check/property/IRawProperty';
 import { check, assert as rAssert } from '../../../../src/check/runner/Runner';
@@ -29,7 +29,7 @@ describe('Runner', () => {
     `('Should throw if both reporter and asyncReporter are defined (isAsync: $isAsync)', ({ isAsync }) => {
       const p: IRawProperty<[number]> = {
         isAsync: () => isAsync,
-        generate: () => new NextValue([0], undefined),
+        generate: () => new Value([0], undefined),
         shrink: () => Stream.nil(),
         run: () => null,
       };
@@ -38,7 +38,7 @@ describe('Runner', () => {
     it('Should not throw if reporter is specified on synchronous properties', () => {
       const p: IRawProperty<[number]> = {
         isAsync: () => false,
-        generate: () => new NextValue([0], undefined),
+        generate: () => new Value([0], undefined),
         shrink: () => Stream.nil(),
         run: () => null,
       };
@@ -47,7 +47,7 @@ describe('Runner', () => {
     it('Should not throw if reporter is specified on asynchronous properties', () => {
       const p: IRawProperty<[number]> = {
         isAsync: () => true,
-        generate: () => new NextValue([0], undefined),
+        generate: () => new Value([0], undefined),
         shrink: () => Stream.nil(),
         run: () => null,
       };
@@ -56,7 +56,7 @@ describe('Runner', () => {
     it('Should throw if asyncReporter is specified on synchronous properties', () => {
       const p: IRawProperty<[number]> = {
         isAsync: () => false,
-        generate: () => new NextValue([0], undefined),
+        generate: () => new Value([0], undefined),
         shrink: () => Stream.nil(),
         run: () => null,
       };
@@ -65,7 +65,7 @@ describe('Runner', () => {
     it('Should not throw if asyncReporter is specified on asynchronous properties', () => {
       const p: IRawProperty<[number]> = {
         isAsync: () => true,
-        generate: () => new NextValue([0], undefined),
+        generate: () => new Value([0], undefined),
         shrink: () => Stream.nil(),
         run: () => null,
       };
@@ -79,7 +79,7 @@ describe('Runner', () => {
         generate: () => {
           expect(numCallsRun).toEqual(numCallsGenerate); // called run before calling back
           ++numCallsGenerate;
-          return new NextValue([numCallsGenerate] as [number], undefined);
+          return new Value([numCallsGenerate] as [number], undefined);
         },
         shrink: () => Stream.nil(),
         run: (value: [number]) => {
@@ -101,7 +101,7 @@ describe('Runner', () => {
         generate: () => {
           expect(numCallsRun).toEqual(numCallsGenerate); // called run before calling back
           ++numCallsGenerate;
-          return new NextValue([numCallsGenerate] as [number], undefined);
+          return new Value([numCallsGenerate] as [number], undefined);
         },
         shrink: () => Stream.nil(),
         run: (value: [number]) => {
@@ -122,7 +122,7 @@ describe('Runner', () => {
         isAsync: () => false,
         generate: () => {
           ++numCallsGenerate;
-          return new NextValue<[number]>([0], 'shrink-me');
+          return new Value<[number]>([0], 'shrink-me');
         },
         shrink: (value) => {
           function* g() {
@@ -130,7 +130,7 @@ describe('Runner', () => {
               return;
             }
             for (let i = 0; i !== 1234; ++i) {
-              yield new NextValue<[number]>([0], undefined);
+              yield new Value<[number]>([0], undefined);
             }
           }
           return new Stream(g());
@@ -163,7 +163,7 @@ describe('Runner', () => {
             let numCallsRun = 0;
             const p: IRawProperty<[number]> = {
               isAsync: () => isAsyncProp,
-              generate: () => new NextValue([numCallsGenerate++] as [number], undefined),
+              generate: () => new Value([numCallsGenerate++] as [number], undefined),
               shrink: () => Stream.nil(),
               run: (value: [number]) => {
                 ++numCallsRun;
@@ -204,7 +204,7 @@ describe('Runner', () => {
             let numPreconditionFailures = 0;
             const p: IRawProperty<[number]> = {
               isAsync: () => isAsyncProp,
-              generate: () => new NextValue([numCallsGenerate++] as [number], undefined),
+              generate: () => new Value([numCallsGenerate++] as [number], undefined),
               shrink: () => Stream.nil(),
               run: (value: [number]) => {
                 if (value[0] === settings.onlySuccessId) return null;
@@ -230,7 +230,7 @@ describe('Runner', () => {
         isAsync: () => false,
         generate: () => {
           ++numCallsGenerate;
-          return new NextValue([0], undefined);
+          return new Value([0], undefined);
         },
         shrink: () => {
           throw 'Not implemented';
@@ -254,7 +254,7 @@ describe('Runner', () => {
             isAsync: () => false,
             generate: () => {
               ++numCallsGenerate;
-              return new NextValue([0], undefined);
+              return new Value([0], undefined);
             },
             shrink: () => Stream.nil(),
             run: (_value: [number]) => {
@@ -279,7 +279,7 @@ describe('Runner', () => {
             isAsync: () => false,
             generate: () => {
               ++numCallsGenerate;
-              return new NextValue([0], undefined);
+              return new Value([0], undefined);
             },
             shrink: () => Stream.nil(),
             run: (_value: [number]) => {
@@ -301,7 +301,7 @@ describe('Runner', () => {
             const p: IRawProperty<[number]> = {
               isAsync: () => false,
               generate: (rng: Random) => {
-                return new NextValue([rng.nextInt()], undefined);
+                return new Value([rng.nextInt()], undefined);
               },
               shrink: () => Stream.nil(),
               run: (value: [number]) => {
@@ -323,7 +323,7 @@ describe('Runner', () => {
       const p: IRawProperty<[number]> = {
         isAsync: () => false,
         generate: () => {
-          return new NextValue([0], undefined);
+          return new Value([0], undefined);
         },
         shrink: () => {
           throw 'Not implemented';
@@ -340,13 +340,13 @@ describe('Runner', () => {
       const p: IRawProperty<[number]> = {
         isAsync: () => false,
         generate: () => {
-          return new NextValue([0], undefined);
+          return new Value([0], undefined);
         },
         shrink: (value) => {
           if (value.value[0] !== 0) {
             throw 'Not implemented';
           }
-          return Stream.of(new NextValue([42], undefined));
+          return Stream.of(new Value([42], undefined));
         },
         run: (value: [number]) => {
           return value[0] === 42 ? 'failure' : null;
@@ -359,7 +359,7 @@ describe('Runner', () => {
     it('Should not provide list of failures by default (no verbose)', () => {
       const p: IRawProperty<[number]> = {
         isAsync: () => false,
-        generate: () => new NextValue([42], undefined),
+        generate: () => new Value([42], undefined),
         shrink: () => Stream.nil(),
         run: () => 'failure',
       };
@@ -369,10 +369,10 @@ describe('Runner', () => {
     it('Should provide the list of failures in verbose mode', () => {
       const p: IRawProperty<[number]> = {
         isAsync: () => false,
-        generate: () => new NextValue([42], undefined),
+        generate: () => new Value([42], undefined),
         shrink: (value) => {
           return value.value[0] === 42
-            ? Stream.of(new NextValue([48], undefined), new NextValue([12], undefined))
+            ? Stream.of(new Value([48], undefined), new Value([12], undefined))
             : Stream.nil();
         },
         run: () => 'failure',
@@ -393,14 +393,14 @@ describe('Runner', () => {
           let remainingBeforeFailure = failurePoints[idx];
           const p: IRawProperty<[number]> = {
             isAsync: () => false,
-            generate: (_mrng: Random) => new NextValue([0], failurePoints.length - 1),
+            generate: (_mrng: Random) => new Value([0], failurePoints.length - 1),
             shrink: (value) => {
               const depth = value.context as number;
               if (depth <= 0) {
                 return Stream.nil();
               }
-              function* g(): IterableIterator<NextValue<[number]>> {
-                while (true) yield new NextValue([0], depth - 1);
+              function* g(): IterableIterator<Value<[number]>> {
+                while (true) yield new Value([0], depth - 1);
               }
               return new Stream(g());
             },
@@ -432,10 +432,10 @@ describe('Runner', () => {
             isAsync: () => true,
             generate: () => {
               ++numCallsGenerate;
-              return new NextValue([1], undefined);
+              return new Value([1], undefined);
             },
             shrink: (value) => {
-              return value.value[0] === 1 ? Stream.of(new NextValue([42], undefined)) : Stream.nil();
+              return value.value[0] === 1 ? Stream.of(new Value([42], undefined)) : Stream.nil();
             },
             run: async (_value: [number]) => {
               await new Promise<void>((resolve) => {
@@ -471,7 +471,7 @@ describe('Runner', () => {
     it('Should not timeout if no timeout defined', async () => {
       const p: IRawProperty<[number]> = {
         isAsync: () => true,
-        generate: () => new NextValue([1], undefined),
+        generate: () => new Value([1], undefined),
         shrink: () => Stream.nil(),
         run: async (_value: [number]) => null,
       };
@@ -482,7 +482,7 @@ describe('Runner', () => {
       const wait = (timeMs: number) => new Promise<null>((resolve) => setTimeout(() => resolve(null), timeMs));
       const p: IRawProperty<[number]> = {
         isAsync: () => true,
-        generate: () => new NextValue([1], undefined),
+        generate: () => new Value([1], undefined),
         shrink: () => Stream.nil(),
         run: async (_value: [number]) => await wait(0),
       };
@@ -493,7 +493,7 @@ describe('Runner', () => {
       const wait = (timeMs: number) => new Promise<null>((resolve) => setTimeout(() => resolve(null), timeMs));
       const p: IRawProperty<[number]> = {
         isAsync: () => true,
-        generate: () => new NextValue([1], undefined),
+        generate: () => new Value([1], undefined),
         shrink: () => Stream.nil(),
         run: async (_value: [number]) => await wait(100),
       };
@@ -504,7 +504,7 @@ describe('Runner', () => {
       const neverEnds = () => new Promise<null>(() => {});
       const p: IRawProperty<[number]> = {
         isAsync: () => true,
-        generate: () => new NextValue([1], undefined),
+        generate: () => new Value([1], undefined),
         shrink: () => Stream.nil(),
         run: async (_value: [number]) => await neverEnds(),
       };
@@ -517,19 +517,19 @@ describe('Runner', () => {
     const v2 = { a: 'Hello', b: 21 };
     const failingProperty: IRawProperty<[any, any]> = {
       isAsync: () => false,
-      generate: () => new NextValue([v1, v2], undefined),
+      generate: () => new Value([v1, v2], undefined),
       shrink: () => Stream.nil(),
       run: (_v: [any, any]) => 'error in failingProperty',
     };
     const failingComplexProperty: IRawProperty<[any, any, any]> = {
       isAsync: () => false,
-      generate: () => new NextValue([[v1, v2], v2, v1], undefined),
+      generate: () => new Value([[v1, v2], v2, v1], undefined),
       shrink: () => Stream.nil(),
       run: (_v: [any, any, any]) => 'error in failingComplexProperty',
     };
     const successProperty: IRawProperty<[any, any]> = {
       isAsync: () => false,
-      generate: () => new NextValue([v1, v2], undefined),
+      generate: () => new Value([v1, v2], undefined),
       shrink: () => Stream.nil(),
       run: (_v: [any, any]) => null,
     };
@@ -571,11 +571,11 @@ describe('Runner', () => {
       const p: IRawProperty<[number]> = {
         isAsync: () => false,
         generate: () => {
-          return new NextValue([42], undefined);
+          return new Value([42], undefined);
         },
         shrink: (value) => {
           return value.value[0] === 42
-            ? Stream.of(new NextValue([48], undefined), new NextValue([12], undefined))
+            ? Stream.of(new Value([48], undefined), new Value([12], undefined))
             : Stream.nil();
         },
         run: () => 'failure',
@@ -614,7 +614,7 @@ describe('Runner', () => {
       const baseErrorMessage = 'Failed to run property, too many pre-condition failures encountered';
       const p: IRawProperty<[number]> = {
         isAsync: () => false,
-        generate: () => new NextValue([42], undefined),
+        generate: () => new Value([42], undefined),
         shrink: () => Stream.nil(),
         run: () => new PreconditionFailure(),
       };
diff --git a/test/unit/check/runner/Sampler.spec.ts b/test/unit/check/runner/Sampler.spec.ts
index 456e231b..ca1eeb34 100644
--- a/test/unit/check/runner/Sampler.spec.ts
+++ b/test/unit/check/runner/Sampler.spec.ts
@@ -5,7 +5,7 @@ import { sample, statistics } from '../../../../src/check/runner/Sampler';
 import * as stubArb from '../../stubs/arbitraries';
 import { cloneMethod } from '../../../../src/check/symbols';
 import { fakeNextArbitrary } from '../../arbitrary/__test-helpers__/NextArbitraryHelpers';
-import { NextValue } from '../../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../../src/check/arbitrary/definition/Value';
 
 const MAX_NUM_RUNS = 1000;
 describe('Sampler', () => {
@@ -70,7 +70,7 @@ describe('Sampler', () => {
         },
       };
       const { instance, generate } = fakeNextArbitrary();
-      generate.mockReturnValue(new NextValue(cloneable, undefined));
+      generate.mockReturnValue(new Value(cloneable, undefined));
       sample(instance, { seed: 42 });
     });
   });
diff --git a/test/unit/check/runner/Tosser.spec.ts b/test/unit/check/runner/Tosser.spec.ts
index 8cc10cf8..808059b9 100644
--- a/test/unit/check/runner/Tosser.spec.ts
+++ b/test/unit/check/runner/Tosser.spec.ts
@@ -5,7 +5,7 @@ import { Stream, stream } from '../../../../src/stream/Stream';
 import { Arbitrary } from '../../../../src/check/arbitrary/definition/Arbitrary';
 import { IRawProperty } from '../../../../src/check/property/IRawProperty';
 import { Random } from '../../../../src/random/generator/Random';
-import { NextValue } from '../../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../../src/check/arbitrary/definition/Value';
 
 import * as stubArb from '../../stubs/arbitraries';
 import prand from 'pure-rand';
@@ -14,8 +14,8 @@ const wrap = <T>(arb: Arbitrary<T>): IRawProperty<T> =>
   new (class implements IRawProperty<T> {
     constructor(readonly arb: Arbitrary<T>) {}
     isAsync = () => false;
-    generate = (rng: Random) => new NextValue(this.arb.generate(rng, undefined).value_, undefined);
-    shrink = () => Stream.nil<NextValue<T>>();
+    generate = (rng: Random) => new Value(this.arb.generate(rng, undefined).value_, undefined);
+    shrink = () => Stream.nil<Value<T>>();
     run = () => '';
   })(arb);
 
diff --git a/test/unit/stubs/arbitraries.ts b/test/unit/stubs/arbitraries.ts
index 11d7841a..092a336c 100644
--- a/test/unit/stubs/arbitraries.ts
+++ b/test/unit/stubs/arbitraries.ts
@@ -1,5 +1,5 @@
 import { Arbitrary } from '../../../src/check/arbitrary/definition/Arbitrary';
-import { NextValue } from '../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../src/check/arbitrary/definition/Value';
 import { Random } from '../../../src/random/generator/Random';
 import { Stream } from '../../../src/stream/Stream';
 
@@ -14,15 +14,15 @@ class CounterArbitrary extends Arbitrary<number> {
   constructor(private value: number) {
     super();
   }
-  generate(_mrng: Random): NextValue<number> {
+  generate(_mrng: Random): Value<number> {
     const last = this.value++ | 0; // keep it in integer range
     this.generatedValues.push(last);
-    return new NextValue(last, undefined);
+    return new Value(last, undefined);
   }
   canShrinkWithoutContext(value: unknown): value is number {
     return false;
   }
-  shrink(_value: number, _context: unknown): Stream<NextValue<number>> {
+  shrink(_value: number, _context: unknown): Stream<Value<number>> {
     return Stream.nil();
   }
 }
@@ -36,13 +36,13 @@ class ForwardArbitrary extends Arbitrary<number> {
   constructor() {
     super();
   }
-  generate(rng: Random): NextValue<number> {
-    return new NextValue(rng.nextInt(), undefined);
+  generate(rng: Random): Value<number> {
+    return new Value(rng.nextInt(), undefined);
   }
   canShrinkWithoutContext(value: unknown): value is number {
     return false;
   }
-  shrink(_value: number, _context: unknown): Stream<NextValue<number>> {
+  shrink(_value: number, _context: unknown): Stream<Value<number>> {
     return Stream.nil();
   }
 }
@@ -56,17 +56,17 @@ class ForwardArrayArbitrary extends Arbitrary<number[]> {
   constructor(readonly num: number) {
     super();
   }
-  generate(mrng: Random): NextValue<number[]> {
+  generate(mrng: Random): Value<number[]> {
     const out = [];
     for (let idx = 0; idx !== this.num; ++idx) {
       out.push(mrng.nextInt());
     }
-    return new NextValue(out, undefined);
+    return new Value(out, undefined);
   }
   canShrinkWithoutContext(value: unknown): value is number[] {
     return false;
   }
-  shrink(_value: number[], _context: unknown): Stream<NextValue<number[]>> {
+  shrink(_value: number[], _context: unknown): Stream<Value<number[]>> {
     return Stream.nil();
   }
 }
@@ -82,17 +82,17 @@ class SingleUseArbitrary<T> extends Arbitrary<T> {
   constructor(public id: T, public noCallOnceCheck: boolean) {
     super();
   }
-  generate(_mrng: Random): NextValue<T> {
+  generate(_mrng: Random): Value<T> {
     if (!this.noCallOnceCheck && this.calledOnce) {
       throw 'Arbitrary has already been called once';
     }
     this.calledOnce = true;
-    return new NextValue(this.id, undefined);
+    return new Value(this.id, undefined);
   }
   canShrinkWithoutContext(value: unknown): value is T {
     return false;
   }
-  shrink(_value: T, _context: unknown): Stream<NextValue<T>> {
+  shrink(_value: T, _context: unknown): Stream<Value<T>> {
     return Stream.nil();
   }
 }