Repository: dubzzz/fast-check
Pull request #2945 (2022-05-08 18:51:14)

💥 Rename `NextValue` into `Value`
This PR was initially merged as #2524 for the alpha versions of the v3. We re-opened it for the final release to ease its review and simplify the history with a clean PR not being merged and re-merged all the time throughout many intermediate versions.

`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):_ Towards v3
  <!-- 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/2945/builds/247894) or the icon next to each commit SHA.

Latest deployment of this branch, based on commit a1537adbf328b6380ac7b86f52d5c70947776058:

|Sandbox| Source |
|--|--|
|[Vanilla](https://codesandbox.io/s/vanilla-26pd2z)| Configuration |
|[fast-check-examples](https://codesandbox.io/s/fast-check-examples-sxs19s)| Configuration |

codecov[bot]: # [Codecov](https://codecov.io/gh/dubzzz/fast-check/pull/2945?src=pr&el=h1&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Nicolas+DUBIEN) Report
> Merging [#2945](https://codecov.io/gh/dubzzz/fast-check/pull/2945?src=pr&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Nicolas+DUBIEN) (a1537ad) into [main](https://codecov.io/gh/dubzzz/fast-check/commit/51f32655b2341bd7732d637b773df68bd8b149a3?el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Nicolas+DUBIEN) (51f3265) will **decrease** coverage by `0.00%`.
> The diff coverage is `97.12%`.

```diff
@@            Coverage Diff             @@
##             main    #2945      +/-   ##
==========================================
- Coverage   96.27%   96.27%   -0.01%     
==========================================
  Files         193      193              
  Lines        4513     4511       -2     
  Branches      974      974              
==========================================
- Hits         4345     4343       -2     
  Misses        158      158              
  Partials       10       10              
```

| Flag | Coverage Δ | |
|---|---|---|
| unit-tests | `96.27% <97.12%> (-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/2945?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/2945/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/2945/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/2945/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/check/property/UnbiasedProperty.ts](https://codecov.io/gh/dubzzz/fast-check/pull/2945/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%> (ø)` | |
| [...bitrary/\_internals/WithShrinkFromOtherArbitrary.ts](https://codecov.io/gh/dubzzz/fast-check/pull/2945/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Nicolas+DUBIEN#diff-c3JjL2FyYml0cmFyeS9faW50ZXJuYWxzL1dpdGhTaHJpbmtGcm9tT3RoZXJBcmJpdHJhcnkudHM=) | `92.00% <84.61%> (ø)` | |
| [src/arbitrary/\_internals/CommandsArbitrary.ts](https://codecov.io/gh/dubzzz/fast-check/pull/2945/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Nicolas+DUBIEN#diff-c3JjL2FyYml0cmFyeS9faW50ZXJuYWxzL0NvbW1hbmRzQXJiaXRyYXJ5LnRz) | `96.34% <93.33%> (ø)` | |
| [src/arbitrary/\_internals/AdapterArbitrary.ts](https://codecov.io/gh/dubzzz/fast-check/pull/2945/diff?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Nicolas+DUBIEN#diff-c3JjL2FyYml0cmFyeS9faW50ZXJuYWxzL0FkYXB0ZXJBcmJpdHJhcnkudHM=) | `100.00% <100.00%> (ø)` | |
| [.../arbitrary/\_internals/AlwaysShrinkableArbitrary.ts](https://codecov.io/gh/dubzzz/fast-check/pull/2945/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/2945/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/2945/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.38% <100.00%> (ø)` | |
| ... and [26 more](https://codecov.io/gh/dubzzz/fast-check/pull/2945/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/2945?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/2945?src=pr&el=footer&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=Nicolas+DUBIEN). Last update [51f3265...a1537ad](https://codecov.io/gh/dubzzz/fast-check/pull/2945?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/AdapterArbitrary.ts b/src/arbitrary/_internals/AdapterArbitrary.ts
index 794133d6..e9579e62 100644
--- a/src/arbitrary/_internals/AdapterArbitrary.ts
+++ b/src/arbitrary/_internals/AdapterArbitrary.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';
 
@@ -10,12 +10,12 @@ export type AdapterOutput<T> = { adapted: boolean; value: T };
 const AdaptedValue = Symbol('adapted-value');
 
 /** @internal */
-function toAdapterNextValue<T>(rawValue: NextValue<T>, adapter: (value: T) => AdapterOutput<T>): NextValue<T> {
+function toAdapterValue<T>(rawValue: Value<T>, adapter: (value: T) => AdapterOutput<T>): Value<T> {
   const adapted = adapter(rawValue.value_);
   if (!adapted.adapted) {
     return rawValue; // No need to adapt it
   }
-  return new NextValue(adapted.value, AdaptedValue);
+  return new Value(adapted.value, AdaptedValue);
 }
 
 /**
@@ -24,26 +24,26 @@ function toAdapterNextValue<T>(rawValue: NextValue<T>, adapter: (value: T) => Ad
  * if they don't fit the requirements
  */
 class AdapterArbitrary<T> extends Arbitrary<T> {
-  private readonly adaptNextValue: (rawValue: NextValue<T>) => NextValue<T>;
+  private readonly adaptValue: (rawValue: Value<T>) => Value<T>;
   constructor(private readonly sourceArb: Arbitrary<T>, private readonly adapter: (value: T) => AdapterOutput<T>) {
     super();
-    this.adaptNextValue = (rawValue) => toAdapterNextValue(rawValue, adapter);
+    this.adaptValue = (rawValue) => toAdapterValue(rawValue, adapter);
   }
-  generate(mrng: Random, biasFactor: number | undefined): NextValue<T> {
+  generate(mrng: Random, biasFactor: number | undefined): Value<T> {
     const rawValue = this.sourceArb.generate(mrng, biasFactor);
-    return this.adaptNextValue(rawValue);
+    return this.adaptValue(rawValue);
   }
   canShrinkWithoutContext(value: unknown): value is T {
     return this.sourceArb.canShrinkWithoutContext(value) && !this.adapter(value).adapted;
   }
-  shrink(value: T, context: unknown): Stream<NextValue<T>> {
+  shrink(value: T, context: unknown): Stream<Value<T>> {
     if (context === AdaptedValue) {
       if (!this.sourceArb.canShrinkWithoutContext(value)) {
         return Stream.nil();
       }
-      return this.sourceArb.shrink(value, undefined).map(this.adaptNextValue);
+      return this.sourceArb.shrink(value, undefined).map(this.adaptValue);
     }
-    return this.sourceArb.shrink(value, context).map(this.adaptNextValue);
+    return this.sourceArb.shrink(value, context).map(this.adaptValue);
   }
 }
 
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 f8a13bab..60f124c6 100644
--- a/src/arbitrary/_internals/ArrayArbitrary.ts
+++ b/src/arbitrary/_internals/ArrayArbitrary.ts
@@ -4,7 +4,7 @@ import { cloneIfNeeded, cloneMethod } from '../../check/symbols';
 import { integer } from '../integer';
 import { makeLazy } from '../../stream/LazyIterableIterator';
 import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary';
-import { NextValue } from '../../check/arbitrary/definition/NextValue';
+import { Value } from '../../check/arbitrary/definition/Value';
 import { CustomSetBuilder } from './interfaces/CustomSet';
 import { DepthContext, DepthIdentifier, getDepthContextFor } from './helpers/DepthContext';
 
@@ -37,14 +37,14 @@ export class ArrayArbitrary<T> extends Arbitrary<T[]> {
     depthIdentifier: DepthIdentifier | string | undefined,
     // Whenever passing a isEqual to ArrayArbitrary, you also have to filter
     // it's output just in case produced values are too small (below minLength)
-    readonly setBuilder?: CustomSetBuilder<NextValue<T>>
+    readonly setBuilder?: CustomSetBuilder<Value<T>>
   ) {
     super();
     this.lengthArb = integer({ min: minLength, max: maxGeneratedLength });
     this.depthContext = getDepthContextFor(depthIdentifier);
   }
 
-  private preFilter(tab: NextValue<T>[]): NextValue<T>[] {
+  private preFilter(tab: Value<T>[]): Value<T>[] {
     if (this.setBuilder === undefined) {
       return tab;
     }
@@ -55,7 +55,7 @@ export class ArrayArbitrary<T> extends Arbitrary<T[]> {
     return s.getData();
   }
 
-  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) {
@@ -68,11 +68,11 @@ export class ArrayArbitrary<T> extends Arbitrary<T[]> {
   }
 
   private generateNItemsNoDuplicates(
-    setBuilder: CustomSetBuilder<NextValue<T>>,
+    setBuilder: CustomSetBuilder<Value<T>>,
     N: number,
     mrng: Random,
     biasFactorItems: number | undefined
-  ): NextValue<T>[] {
+  ): Value<T>[] {
     let numSkippedInRow = 0;
     const s = setBuilder();
     // Try to append into items up to the target size
@@ -92,11 +92,11 @@ export class ArrayArbitrary<T> extends Arbitrary<T[]> {
   }
 
   private safeGenerateNItemsNoDuplicates(
-    setBuilder: CustomSetBuilder<NextValue<T>>,
+    setBuilder: CustomSetBuilder<Value<T>>,
     N: number,
     mrng: Random,
     biasFactorItems: number | undefined
-  ): NextValue<T>[] {
+  ): Value<T>[] {
     const depthImpact = Math.max(0, N - biasedMaxLength(this.minLength, this.maxGeneratedLength)); // no depth impact for biased lengths
     this.depthContext.depth += depthImpact; // increase depth
     try {
@@ -106,8 +106,8 @@ export class ArrayArbitrary<T> extends Arbitrary<T[]> {
     }
   }
 
-  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);
@@ -115,7 +115,7 @@ export class ArrayArbitrary<T> extends Arbitrary<T[]> {
     return items;
   }
 
-  private safeGenerateNItems(N: number, mrng: Random, biasFactorItems: number | undefined): NextValue<T>[] {
+  private safeGenerateNItems(N: number, mrng: Random, biasFactorItems: number | undefined): Value<T>[] {
     const depthImpact = Math.max(0, N - biasedMaxLength(this.minLength, this.maxGeneratedLength)); // no depth impact for biased lengths
     this.depthContext.depth += depthImpact; // increase depth
     try {
@@ -126,11 +126,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;
@@ -155,10 +155,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 =
@@ -209,7 +209,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;
   }
 
@@ -217,33 +217,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();
     }
@@ -266,12 +264,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,
           ];
@@ -299,9 +297,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,
                     ];
@@ -312,7 +310,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 56a8b313..deea3b46 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 { restrictedIntegerArbitraryBuilder } from './builders/RestrictedIntegerA
 // 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 */
@@ -43,27 +43,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> {
@@ -72,7 +69,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) {
@@ -84,7 +81,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`);
@@ -94,7 +91,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) : [];
     }
@@ -109,9 +106,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>;
 
@@ -120,12 +117,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]());
 
@@ -135,7 +132,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
@@ -162,8 +159,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 d57ba046..b7417e22 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, DepthIdentifier, getDepthContextFor } from './helpers/DepthContext';
 import { depthFactorFromSizeForArbitrary, DepthFactorSizeForArbitrary } from './helpers/MaxLengthFromMinLength';
 
@@ -64,7 +64,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);
@@ -82,7 +82,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;
@@ -90,7 +90,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(
@@ -111,12 +111,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) {
@@ -127,8 +127,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 */
@@ -151,28 +151,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)
     }
@@ -240,5 +240,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/WithShrinkFromOtherArbitrary.ts b/src/arbitrary/_internals/WithShrinkFromOtherArbitrary.ts
index 9e7df4b3..81242535 100644
--- a/src/arbitrary/_internals/WithShrinkFromOtherArbitrary.ts
+++ b/src/arbitrary/_internals/WithShrinkFromOtherArbitrary.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,19 +9,19 @@ function isSafeContext(context: unknown): context is { generatorContext: unknown
 }
 
 /** @internal */
-function toGeneratorNextValue<T>(value: NextValue<T>): NextValue<T> {
+function toGeneratorValue<T>(value: Value<T>): Value<T> {
   if (value.hasToBeCloned) {
-    return new NextValue(value.value_, { generatorContext: value.context }, () => value.value);
+    return new Value(value.value_, { generatorContext: value.context }, () => value.value);
   }
-  return new NextValue(value.value_, { generatorContext: value.context });
+  return new Value(value.value_, { generatorContext: value.context });
 }
 
 /** @internal */
-function toShrinkerNextValue<T>(value: NextValue<T>): NextValue<T> {
+function toShrinkerValue<T>(value: Value<T>): Value<T> {
   if (value.hasToBeCloned) {
-    return new NextValue(value.value_, { shrinkerContext: value.context }, () => value.value);
+    return new Value(value.value_, { shrinkerContext: value.context }, () => value.value);
   }
-  return new NextValue(value.value_, { shrinkerContext: value.context });
+  return new Value(value.value_, { shrinkerContext: value.context });
 }
 
 /** @internal */
@@ -30,21 +30,21 @@ export class WithShrinkFromOtherArbitrary<T> extends Arbitrary<T> {
     super();
   }
 
-  generate(mrng: Random, biasFactor: number | undefined): NextValue<T> {
-    return toGeneratorNextValue(this.generatorArbitrary.generate(mrng, biasFactor));
+  generate(mrng: Random, biasFactor: number | undefined): Value<T> {
+    return toGeneratorValue(this.generatorArbitrary.generate(mrng, biasFactor));
   }
 
   canShrinkWithoutContext(value: unknown): value is T {
     return this.shrinkerArbitrary.canShrinkWithoutContext(value);
   }
 
-  shrink(value: T, context: unknown): Stream<NextValue<T>> {
+  shrink(value: T, context: unknown): Stream<Value<T>> {
     if (!isSafeContext(context)) {
-      return this.shrinkerArbitrary.shrink(value, undefined).map(toShrinkerNextValue);
+      return this.shrinkerArbitrary.shrink(value, undefined).map(toShrinkerValue);
     }
     if ('generatorContext' in context) {
-      return this.generatorArbitrary.shrink(value, context.generatorContext).map(toGeneratorNextValue);
+      return this.generatorArbitrary.shrink(value, context.generatorContext).map(toGeneratorValue);
     }
-    return this.shrinkerArbitrary.shrink(value, context.shrinkerContext).map(toShrinkerNextValue);
+    return this.shrinkerArbitrary.shrink(value, context.shrinkerContext).map(toShrinkerValue);
   }
 }
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/arbitrary/uniqueArray.ts b/src/arbitrary/uniqueArray.ts
index 2c4ca9ca..7968e451 100644
--- a/src/arbitrary/uniqueArray.ts
+++ b/src/arbitrary/uniqueArray.ts
@@ -7,31 +7,31 @@ import {
 } from './_internals/helpers/MaxLengthFromMinLength';
 import { CustomSetBuilder } from './_internals/interfaces/CustomSet';
 import { CustomEqualSet } from './_internals/helpers/CustomEqualSet';
-import { NextValue } from '../check/arbitrary/definition/NextValue';
+import { Value } from '../check/arbitrary/definition/Value';
 import { StrictlyEqualSet } from './_internals/helpers/StrictlyEqualSet';
 import { SameValueSet } from './_internals/helpers/SameValueSet';
 import { SameValueZeroSet } from './_internals/helpers/SameValueZeroSet';
 import { DepthIdentifier } from './_internals/helpers/DepthContext';
 
 /** @internal */
-function buildUniqueArraySetBuilder<T, U>(constraints: UniqueArrayConstraints<T, U>): CustomSetBuilder<NextValue<T>> {
+function buildUniqueArraySetBuilder<T, U>(constraints: UniqueArrayConstraints<T, U>): CustomSetBuilder<Value<T>> {
   // Remark: Whenever we don't pass any custom selector U=T
   // so v of type T is simply a U
   if (typeof constraints.comparator === 'function') {
     if (constraints.selector === undefined) {
       const comparator = constraints.comparator;
-      const isEqualForBuilder = (nextA: NextValue<T>, nextB: NextValue<T>) => comparator(nextA.value_, nextB.value_);
+      const isEqualForBuilder = (nextA: Value<T>, nextB: Value<T>) => comparator(nextA.value_, nextB.value_);
       return () => new CustomEqualSet(isEqualForBuilder);
     }
     const comparator = constraints.comparator;
     const selector = constraints.selector;
-    const refinedSelector = (next: NextValue<T>) => selector(next.value_);
-    const isEqualForBuilder = (nextA: NextValue<T>, nextB: NextValue<T>) =>
+    const refinedSelector = (next: Value<T>) => selector(next.value_);
+    const isEqualForBuilder = (nextA: Value<T>, nextB: Value<T>) =>
       comparator(refinedSelector(nextA), refinedSelector(nextB));
     return () => new CustomEqualSet(isEqualForBuilder);
   }
   const selector = constraints.selector || ((v) => v);
-  const refinedSelector = (next: NextValue<T>) => selector(next.value_);
+  const refinedSelector = (next: Value<T>) => selector(next.value_);
   switch (constraints.comparator) {
     case 'IsStrictlyEqual':
       return () => new StrictlyEqualSet(refinedSelector);
diff --git a/src/check/arbitrary/definition/Arbitrary.ts b/src/check/arbitrary/definition/Arbitrary.ts
index 6b62071b..abc98528 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 b248a7cf..c1ee7097 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 96710dd9..5250c60e 100644
--- a/src/fast-check-default.ts
+++ b/src/fast-check-default.ts
@@ -157,7 +157,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';
 import {
   Size,
   SizeForArbitrary,
@@ -320,7 +320,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 eda9b0bd..371b275c 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 678aa042..555cf56f 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 98fc8797..2519c62e 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';
 import { withConfiguredGlobal } from './GlobalSettingsHelpers';
 import { sizeArb } from './SizeHelpers';
@@ -37,11 +37,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);
@@ -82,7 +82,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 f20afdec..1e354bb5 100644
--- a/test/unit/arbitrary/__test-helpers__/NextArbitraryHelpers.ts
+++ b/test/unit/arbitrary/__test-helpers__/NextArbitraryHelpers.ts
@@ -1,6 +1,6 @@
 import { MaybeMocked, MockWithArgs } from '../../__test-helpers__/Mocked';
 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';
 
@@ -47,7 +47,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;
   });
@@ -65,13 +65,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 (
@@ -81,12 +81,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/AdapterArbitrary.spec.ts b/test/unit/arbitrary/_internals/AdapterArbitrary.spec.ts
index 07b25461..87f45101 100644
--- a/test/unit/arbitrary/_internals/AdapterArbitrary.spec.ts
+++ b/test/unit/arbitrary/_internals/AdapterArbitrary.spec.ts
@@ -1,5 +1,5 @@
 import { adapter, AdapterOutput } from '../../../../src/arbitrary/_internals/AdapterArbitrary';
-import { NextValue } from '../../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../../src/check/arbitrary/definition/Value';
 import { fakeNextArbitrary } from '../__test-helpers__/NextArbitraryHelpers';
 import { fakeRandom } from '../__test-helpers__/RandomHelpers';
 import { Stream } from '../../../../src/stream/Stream';
@@ -15,7 +15,7 @@ describe('AdapterArbitrary', () => {
           fc.anything(),
           (biasFactor, v, c) => {
             // Arrange
-            const value = new NextValue(v, c);
+            const value = new Value(v, c);
             const { instance, generate, shrink, canShrinkWithoutContext } = fakeNextArbitrary();
             generate.mockReturnValueOnce(value);
             const { instance: mrng } = fakeRandom();
@@ -47,7 +47,7 @@ describe('AdapterArbitrary', () => {
           fc.anything(),
           (biasFactor, v, c, vAdapted) => {
             // Arrange
-            const value = new NextValue(v, c);
+            const value = new Value(v, c);
             const { instance, generate, shrink, canShrinkWithoutContext } = fakeNextArbitrary();
             generate.mockReturnValueOnce(value);
             const { instance: mrng } = fakeRandom();
@@ -118,9 +118,9 @@ describe('AdapterArbitrary', () => {
           (biasFactor, vA, cA, adaptedA, vAA, cAA, adaptedAA, vAB, cAB, adaptedAB, canShrinkIfAdapted) => {
             // Arrange
             fc.pre(allUniques(vA, vAA, vAB)); // check for adapterFunction
-            const valueA = new NextValue(vA, cA);
-            const valueAA = new NextValue(vAA, cAA);
-            const valueAB = new NextValue(vAB, cAB);
+            const valueA = new Value(vA, cA);
+            const valueAA = new Value(vAA, cAA);
+            const valueAB = new Value(vAB, cAB);
             const { instance, generate, shrink, canShrinkWithoutContext } = fakeNextArbitrary();
             generate.mockReturnValueOnce(valueA);
             shrink.mockReturnValueOnce(Stream.of(valueAA, valueAB));
@@ -207,11 +207,11 @@ describe('AdapterArbitrary', () => {
           ) => {
             // Arrange
             fc.pre(allUniques(vA, vAA, vAB, vAC, vABC)); // check for adapterFunction
-            const valueA = new NextValue(vA, cA);
-            const valueAA = new NextValue(vAA, cAA);
-            const valueAB = new NextValue(vAB, cAB);
-            const valueAC = new NextValue(vAC, cAC);
-            const valueABC = new NextValue(vABC, cABC);
+            const valueA = new Value(vA, cA);
+            const valueAA = new Value(vAA, cAA);
+            const valueAB = new Value(vAB, cAB);
+            const valueAC = new Value(vAC, cAC);
+            const valueABC = new Value(vABC, cABC);
             const { instance, generate, shrink, canShrinkWithoutContext } = fakeNextArbitrary();
             generate.mockReturnValueOnce(valueA);
             shrink.mockReturnValueOnce(Stream.of(valueAA, valueAB, valueAC)).mockReturnValueOnce(Stream.of(valueABC));
@@ -280,8 +280,8 @@ describe('AdapterArbitrary', () => {
           (toShrinkvalue, vAA, cAA, adaptedAA, vAB, cAB, adaptedAB) => {
             // Arrange
             fc.pre(allUniques(vAA, vAB)); // check for adapterFunction
-            const valueAA = new NextValue(vAA, cAA);
-            const valueAB = new NextValue(vAB, cAB);
+            const valueAA = new Value(vAA, cAA);
+            const valueAB = new Value(vAB, cAB);
             const { instance, generate, shrink, canShrinkWithoutContext } = fakeNextArbitrary();
             shrink.mockReturnValueOnce(Stream.of(valueAA, valueAB));
             const adapterFunction = jest
diff --git a/test/unit/arbitrary/_internals/ArrayArbitrary.spec.ts b/test/unit/arbitrary/_internals/ArrayArbitrary.spec.ts
index 256c3f7d..b39e9350 100644
--- a/test/unit/arbitrary/_internals/ArrayArbitrary.spec.ts
+++ b/test/unit/arbitrary/_internals/ArrayArbitrary.spec.ts
@@ -2,7 +2,7 @@ import fc from '../../../../lib/fast-check';
 import prand from 'pure-rand';
 
 import { ArrayArbitrary } from '../../../../src/arbitrary/_internals/ArrayArbitrary';
-import { NextValue } from '../../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../../src/check/arbitrary/definition/Value';
 import { MaxLengthUpperBound } from '../../../../src/arbitrary/_internals/helpers/MaxLengthFromMinLength';
 import { CustomSet } from '../../../../src/arbitrary/_internals/interfaces/CustomSet';
 import { Stream } from '../../../../src/stream/Stream';
@@ -38,7 +38,7 @@ describe('ArrayArbitrary', () => {
             const { acceptedValues, instance, generate } = prepareSetBuilderData(generatedValues, false);
             const { minLength, maxGeneratedLength, maxLength } = extractLengths(seed, aLength, bLength, acceptedValues);
             const { instance: integerInstance, generate: generateInteger } = fakeNextArbitrary();
-            generateInteger.mockReturnValue(new NextValue(acceptedValues.size, integerContext));
+            generateInteger.mockReturnValue(new Value(acceptedValues.size, integerContext));
             const integer = jest.spyOn(IntegerMock, 'integer');
             integer.mockReturnValue(integerInstance);
             const { instance: mrng } = fakeRandom();
@@ -76,7 +76,7 @@ describe('ArrayArbitrary', () => {
             const { acceptedValues, instance, generate, setBuilder } = prepareSetBuilderData(generatedValues, false);
             const { minLength, maxGeneratedLength, maxLength } = extractLengths(seed, aLength, bLength, acceptedValues);
             const { instance: integerInstance, generate: generateInteger } = fakeNextArbitrary();
-            generateInteger.mockReturnValue(new NextValue(acceptedValues.size, integerContext));
+            generateInteger.mockReturnValue(new Value(acceptedValues.size, integerContext));
             const integer = jest.spyOn(IntegerMock, 'integer');
             integer.mockReturnValue(integerInstance);
             const { instance: mrng } = fakeRandom();
@@ -120,7 +120,7 @@ describe('ArrayArbitrary', () => {
             );
             const { minLength, maxLength } = extractLengths(seed, aLength, aLength, acceptedValues);
             const { instance: integerInstance, generate: generateInteger } = fakeNextArbitrary();
-            generateInteger.mockReturnValue(new NextValue(minLength, integerContext));
+            generateInteger.mockReturnValue(new Value(minLength, integerContext));
             const integer = jest.spyOn(IntegerMock, 'integer');
             integer.mockReturnValue(integerInstance);
             const { instance: mrng } = fakeRandom();
@@ -186,7 +186,7 @@ describe('ArrayArbitrary', () => {
             );
             const { minLength, maxGeneratedLength, maxLength } = extractLengths(seed, aLength, bLength, acceptedValues);
             const { instance: integerInstance, generate: generateInteger } = fakeNextArbitrary();
-            generateInteger.mockReturnValue(new NextValue(minLength, integerContext));
+            generateInteger.mockReturnValue(new Value(minLength, integerContext));
             const integer = jest.spyOn(IntegerMock, 'integer');
             integer.mockReturnValue(integerInstance);
             const { instance: mrng } = fakeRandom();
@@ -219,12 +219,12 @@ describe('ArrayArbitrary', () => {
       // Arrange
       const { instance, generate } = fakeNextArbitrary<string[]>();
       generate
-        .mockReturnValueOnce(new NextValue(['a'], undefined))
-        .mockReturnValueOnce(new NextValue(Object.defineProperty(['b'], cloneMethod, { value: jest.fn() }), undefined))
-        .mockReturnValueOnce(new NextValue(['c'], undefined))
-        .mockReturnValueOnce(new NextValue(['d'], undefined));
+        .mockReturnValueOnce(new Value(['a'], undefined))
+        .mockReturnValueOnce(new Value(Object.defineProperty(['b'], cloneMethod, { value: jest.fn() }), undefined))
+        .mockReturnValueOnce(new Value(['c'], undefined))
+        .mockReturnValueOnce(new Value(['d'], undefined));
       const { instance: integerInstance, generate: generateInteger } = fakeNextArbitrary();
-      generateInteger.mockReturnValue(new NextValue(4, undefined));
+      generateInteger.mockReturnValue(new Value(4, undefined));
       const integer = jest.spyOn(IntegerMock, 'integer');
       integer.mockReturnValue(integerInstance);
       const { instance: mrng } = fakeRandom();
@@ -245,14 +245,14 @@ describe('ArrayArbitrary', () => {
       const cloneMethodImpl = jest.fn();
       const { instance, generate } = fakeNextArbitrary<string[]>();
       generate
-        .mockReturnValueOnce(new NextValue(['a'], undefined))
+        .mockReturnValueOnce(new Value(['a'], undefined))
         .mockReturnValueOnce(
-          new NextValue(Object.defineProperty(['b'], cloneMethod, { value: cloneMethodImpl }), undefined)
+          new Value(Object.defineProperty(['b'], cloneMethod, { value: cloneMethodImpl }), undefined)
         )
-        .mockReturnValueOnce(new NextValue(['c'], undefined))
-        .mockReturnValueOnce(new NextValue(['d'], undefined));
+        .mockReturnValueOnce(new Value(['c'], undefined))
+        .mockReturnValueOnce(new Value(['d'], undefined));
       const { instance: integerInstance, generate: generateInteger } = fakeNextArbitrary();
-      generateInteger.mockReturnValue(new NextValue(4, undefined));
+      generateInteger.mockReturnValue(new Value(4, undefined));
       const integer = jest.spyOn(IntegerMock, 'integer');
       integer.mockReturnValue(integerInstance);
       const { instance: mrng } = fakeRandom();
@@ -289,7 +289,7 @@ describe('ArrayArbitrary', () => {
             fc.pre(value.length < minLength || value.length > maxLength);
             const { instance, canShrinkWithoutContext } = fakeNextArbitrary();
             const data: any[] = [];
-            const customSet: CustomSet<NextValue<any>> = {
+            const customSet: CustomSet<Value<any>> = {
               size: () => data.length,
               getData: () => data,
               tryAdd: (vTest) => {
@@ -340,7 +340,7 @@ describe('ArrayArbitrary', () => {
             const { instance, canShrinkWithoutContext } = fakeNextArbitrary();
             canShrinkWithoutContext.mockImplementation((vTest) => value.find((v) => Object.is(v[0], vTest))![1]);
             const data: any[] = [];
-            const customSet: CustomSet<NextValue<any>> = {
+            const customSet: CustomSet<Value<any>> = {
               size: () => data.length,
               getData: () => data,
               tryAdd: (vTest) => {
@@ -389,7 +389,7 @@ describe('ArrayArbitrary', () => {
             const { instance, canShrinkWithoutContext } = fakeNextArbitrary();
             canShrinkWithoutContext.mockReturnValue(true);
             const data: any[] = [];
-            const customSet: CustomSet<NextValue<any>> = {
+            const customSet: CustomSet<Value<any>> = {
               size: () => data.length,
               getData: () => data,
               tryAdd: (vTest) => {
@@ -432,7 +432,7 @@ describe('ArrayArbitrary', () => {
             const { instance, canShrinkWithoutContext } = fakeNextArbitrary();
             canShrinkWithoutContext.mockReturnValue(true);
             const data: any[] = [];
-            const customSet: CustomSet<NextValue<any>> = {
+            const customSet: CustomSet<Value<any>> = {
               size: () => data.length,
               getData: () => data,
               tryAdd: (vTest) => {
@@ -476,7 +476,7 @@ describe('ArrayArbitrary', () => {
             const { instance, canShrinkWithoutContext } = fakeNextArbitrary();
             canShrinkWithoutContext.mockReturnValue(true);
             const data: any[] = [];
-            const customSet: CustomSet<NextValue<any>> = {
+            const customSet: CustomSet<Value<any>> = {
               size: () => data.length,
               getData: () => data,
               tryAdd: (vTest) => {
@@ -551,10 +551,10 @@ function prepareSetBuilderData(
   acceptAll: boolean,
   onGenerateHook?: () => void
 ) {
-  const acceptedValues = new Set<NextValue<any>>();
+  const acceptedValues = new Set<Value<any>>();
   const { instance, generate } = fakeNextArbitrary();
   for (const v of generatedValues) {
-    const value = new NextValue(v[0], v[1]);
+    const value = new Value(v[0], v[1]);
     const rejected = v[2];
     if (!rejected || acceptAll) {
       acceptedValues.add(value);
@@ -567,7 +567,7 @@ function prepareSetBuilderData(
     });
   }
   const data: any[] = [];
-  const customSet: CustomSet<NextValue<any>> = {
+  const customSet: CustomSet<Value<any>> = {
     size: () => data.length,
     getData: () => data,
     tryAdd: (value) => {
@@ -594,13 +594,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');
     }
@@ -608,6 +608,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/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 e5f42daa..fdcf9b36 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 {
@@ -36,7 +36,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,
@@ -295,7 +295,7 @@ describe('FrequencyArbitrary', () => {
               arbitraryMeta.generate.mockImplementation(() => {
                 calledOnce = true;
                 expect(depthContext).toEqual({ depth: initialDepth + 1 });
-                return new NextValue(expectedValue, undefined);
+                return new Value(expectedValue, undefined);
               });
             }
 
@@ -524,7 +524,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
@@ -567,7 +567,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
@@ -601,9 +601,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');
@@ -639,7 +637,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))
               );
             }
 
@@ -676,7 +674,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/WithShrinkFromOtherArbitrary.spec.ts b/test/unit/arbitrary/_internals/WithShrinkFromOtherArbitrary.spec.ts
index 0eaf22c1..df494829 100644
--- a/test/unit/arbitrary/_internals/WithShrinkFromOtherArbitrary.spec.ts
+++ b/test/unit/arbitrary/_internals/WithShrinkFromOtherArbitrary.spec.ts
@@ -1,5 +1,5 @@
 import { WithShrinkFromOtherArbitrary } from '../../../../src/arbitrary/_internals/WithShrinkFromOtherArbitrary';
-import { NextValue } from '../../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../../src/check/arbitrary/definition/Value';
 import { fakeNextArbitrary } from '../__test-helpers__/NextArbitraryHelpers';
 import { fakeRandom } from '../__test-helpers__/RandomHelpers';
 import { Stream } from '../../../../src/stream/Stream';
@@ -27,7 +27,7 @@ describe('WithShrinkFromOtherArbitrary', () => {
               shrink: shrinkB,
               canShrinkWithoutContext: canShrinkWithoutContextB,
             } = fakeNextArbitrary();
-            generateA.mockReturnValueOnce(new NextValue(vA, cA));
+            generateA.mockReturnValueOnce(new Value(vA, cA));
             const { instance: mrng } = fakeRandom();
 
             // Act
@@ -113,8 +113,8 @@ describe('WithShrinkFromOtherArbitrary', () => {
               shrink: shrinkB,
               canShrinkWithoutContext: canShrinkWithoutContextB,
             } = fakeNextArbitrary();
-            generateA.mockReturnValueOnce(new NextValue(vA, cA));
-            shrinkA.mockReturnValueOnce(Stream.of(new NextValue(vAA, cAA), new NextValue(vAB, cAB)));
+            generateA.mockReturnValueOnce(new Value(vA, cA));
+            shrinkA.mockReturnValueOnce(Stream.of(new Value(vAA, cAA), new Value(vAB, cAB)));
             const { instance: mrng } = fakeRandom();
 
             // Act
@@ -165,11 +165,9 @@ describe('WithShrinkFromOtherArbitrary', () => {
               shrink: shrinkB,
               canShrinkWithoutContext: canShrinkWithoutContextB,
             } = fakeNextArbitrary();
-            generateA.mockReturnValueOnce(new NextValue(vA, cA));
-            shrinkA.mockReturnValueOnce(
-              Stream.of(new NextValue(vAA, cAA), new NextValue(vAB, cAB), new NextValue(vAC, cAC))
-            );
-            shrinkA.mockReturnValueOnce(Stream.of(new NextValue(vABA, cABA)));
+            generateA.mockReturnValueOnce(new Value(vA, cA));
+            shrinkA.mockReturnValueOnce(Stream.of(new Value(vAA, cAA), new Value(vAB, cAB), new Value(vAC, cAC)));
+            shrinkA.mockReturnValueOnce(Stream.of(new Value(vABA, cABA)));
             const { instance: mrng } = fakeRandom();
 
             // Act
@@ -215,7 +213,7 @@ describe('WithShrinkFromOtherArbitrary', () => {
               shrink: shrinkB,
               canShrinkWithoutContext: canShrinkWithoutContextB,
             } = fakeNextArbitrary();
-            shrinkB.mockReturnValueOnce(Stream.of(new NextValue(vAA, cAA), new NextValue(vAB, cAB)));
+            shrinkB.mockReturnValueOnce(Stream.of(new Value(vAA, cAA), new Value(vAB, cAB)));
 
             // Act
             const arb = new WithShrinkFromOtherArbitrary(generatorArbitrary, shrinkerArbitrary);
@@ -263,10 +261,8 @@ describe('WithShrinkFromOtherArbitrary', () => {
               shrink: shrinkB,
               canShrinkWithoutContext: canShrinkWithoutContextB,
             } = fakeNextArbitrary();
-            shrinkB.mockReturnValueOnce(
-              Stream.of(new NextValue(vAA, cAA), new NextValue(vAB, cAB), new NextValue(vAC, cAC))
-            );
-            shrinkB.mockReturnValueOnce(Stream.of(new NextValue(vABA, cABA)));
+            shrinkB.mockReturnValueOnce(Stream.of(new Value(vAA, cAA), new Value(vAB, cAB), new Value(vAC, cAC)));
+            shrinkB.mockReturnValueOnce(Stream.of(new Value(vABA, cABA)));
 
             // Act
             const arb = new WithShrinkFromOtherArbitrary(generatorArbitrary, shrinkerArbitrary);
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 22673e57..c991921c 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() {
@@ -209,7 +209,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 1d1a5673..9df38c60 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';
 import { sizeForArbitraryArb } from './__test-helpers__/SizeHelpers';
 
@@ -198,7 +198,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/commands.spec.ts b/test/unit/arbitrary/commands.spec.ts
index 9aeedc2e..b14e395f 100644
--- a/test/unit/arbitrary/commands.spec.ts
+++ b/test/unit/arbitrary/commands.spec.ts
@@ -5,7 +5,7 @@ import prand from 'pure-rand';
 import { Command } from '../../../src/check/model/command/Command';
 import { Random } from '../../../src/random/generator/Random';
 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 { tuple } from '../../../src/arbitrary/tuple';
 import { nat } from '../../../src/arbitrary/nat';
@@ -141,12 +141,12 @@ describe('commands (integration)', () => {
       disableReplayLog: true,
     });
     const manyArbsIncludingCommandsOne = tuple(nat(16), commandsArb, nat(16));
-    const assertCommandsNotStarted = (value: NextValue<[number, Iterable<Cmd>, number]>) => {
+    const assertCommandsNotStarted = (value: Value<[number, Iterable<Cmd>, number]>) => {
       // Check the commands have never been executed
       // by checking the toString of the iterable is empty
       expect(String(value.value_[1])).toEqual('');
     };
-    const startCommands = (value: NextValue<[number, Iterable<Cmd>, number]>) => {
+    const startCommands = (value: Value<[number, Iterable<Cmd>, number]>) => {
       // Iterate over all the generated commands to run them all
       let ranOneCommand = false;
       for (const cmd of value.value_[1]) {
@@ -168,7 +168,7 @@ describe('commands (integration)', () => {
           // Generate the first Value
           const it = shrinkPath[Symbol.iterator]();
           const mrng = new Random(prand.xorshift128plus(seed));
-          let currentValue: NextValue<[number, Iterable<Cmd>, number]> | null = manyArbsIncludingCommandsOne.generate(
+          let currentValue: Value<[number, Iterable<Cmd>, number]> | null = manyArbsIncludingCommandsOne.generate(
             mrng,
             biasFactor
           );
@@ -206,7 +206,7 @@ describe('commands (integration)', () => {
           // Generate the first Value
           const it = shrinkPath[Symbol.iterator]();
           const mrng = new Random(prand.xorshift128plus(seed));
-          let currentValue: NextValue<Iterable<Cmd>> | null = commandsArb.generate(mrng, biasFactor);
+          let currentValue: Value<Iterable<Cmd>> | null = commandsArb.generate(mrng, biasFactor);
 
           // Run all commands of first Value
           simulateCommands(currentValue.value_);
@@ -251,7 +251,7 @@ describe('commands (integration)', () => {
             new FakeConstant(new FailureCommand(logOnCheck)),
             nat().map((v) => new SuccessIdCommand(v)),
           ]);
-          const refValue: NextValue<Iterable<Cmd>> = refArbitrary.generate(new Random(rng), biasFactor);
+          const refValue: Value<Iterable<Cmd>> = refArbitrary.generate(new Random(rng), biasFactor);
           simulateCommands(refValue.value_);
 
           // trigger computation of replayPath
@@ -276,7 +276,7 @@ describe('commands (integration)', () => {
             ],
             { replayPath }
           );
-          const noExecValue: NextValue<Iterable<Cmd>> = noExecArbitrary.generate(new Random(rng), biasFactor);
+          const noExecValue: Value<Iterable<Cmd>> = noExecArbitrary.generate(new Random(rng), biasFactor);
 
           // check shrink values are identical
           const noExecShrinks = [
@@ -298,13 +298,13 @@ class FakeConstant extends Arbitrary<Cmd> {
   constructor(private readonly cmd: Cmd) {
     super();
   }
-  generate(): NextValue<Cmd> {
-    return new NextValue(this.cmd, undefined);
+  generate(): Value<Cmd> {
+    return new Value(this.cmd, undefined);
   }
   canShrinkWithoutContext(value: unknown): value is Cmd {
     return false;
   }
-  shrink(): Stream<NextValue<Cmd>> {
+  shrink(): Stream<Value<Cmd>> {
     return Stream.nil();
   }
 }
diff --git a/test/unit/arbitrary/dictionary.spec.ts b/test/unit/arbitrary/dictionary.spec.ts
index 3df325e5..53082c39 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, DictionaryConstraints } 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 {
@@ -73,15 +73,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 93a8f8e2..cbead0c8 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, DomainConstraints } from '../../../src/arbitrary/domain';
-import { NextValue } from '../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../src/check/arbitrary/definition/Value';
 import { URL } from 'url';
 
 import {
@@ -94,7 +94,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 aea126fb..3dd96b63 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, EmailAddressConstraints } from '../../../src/arbitrary/emailAddress';
-import { NextValue } from '../../../src/check/arbitrary/definition/NextValue';
+import { Value } from '../../../src/check/arbitrary/definition/Value';
 
 import {
   assertProduceSameValueGivenSameSeed,
@@ -77,7 +77,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 1ca10e3c..9560daea 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,
@@ -96,7 +96,7 @@ describe('fullUnicodeString (integration)', () => {
   `('should be able to shrink $rawValue with fc.fullUnicodeString()', ({ 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 acefd19a..39f0c7c4 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,
@@ -154,7 +154,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 bdbd995b..8531164a 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,
@@ -96,7 +96,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/sparseArray.spec.ts b/test/unit/arbitrary/sparseArray.spec.ts
index 94bc5ef6..247d7be7 100644
--- a/test/unit/arbitrary/sparseArray.spec.ts
+++ b/test/unit/arbitrary/sparseArray.spec.ts
@@ -16,7 +16,7 @@ import {
   assertProduceSameValueGivenSameSeed,
   assertProduceValuesShrinkableWithoutContext,
 } 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';
 import { MaxLengthUpperBound } from '../../../src/arbitrary/_internals/helpers/MaxLengthFromMinLength';
 
@@ -231,7 +231,7 @@ describe('sparseArray (integration)', () => {
   `('should be able to shrink $rawValue with fc.sparseArray(..., $constraints)', ({ rawValue, constraints }) => {
     // Arrange
     const arb = sparseArray(new FakeIntegerArbitrary(), 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 bfe8767f..3ff305b0 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,
@@ -86,7 +86,7 @@ describe('string (integration)', () => {
   `('should be able to shrink $rawValue with fc.string()', ({ 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 0c1d9dcf..d6cbcc5f 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 {
@@ -67,7 +67,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');
@@ -84,18 +84,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/uniqueArray.spec.ts b/test/unit/arbitrary/uniqueArray.spec.ts
index a5c9bb48..71221c2d 100644
--- a/test/unit/arbitrary/uniqueArray.spec.ts
+++ b/test/unit/arbitrary/uniqueArray.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() {
@@ -329,7 +329,7 @@ describe('uniqueArray (integration)', () => {
   `('should be able to shrink $rawValue with fc.uniqueArray(arb, $constraints)', ({ rawValue, constraints }) => {
     // Arrange
     const arb = uniqueArray(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/webUrl.spec.ts b/test/unit/arbitrary/webUrl.spec.ts
index 6262cefc..b1f6aa06 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';
 import { relativeSizeArb, sizeArb, sizeRelatedGlobalConfigArb } from './__test-helpers__/SizeHelpers';
 
@@ -105,7 +105,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 e9b67751..8ff0c9f4 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 f00cce96..aa580145 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 ac592b1c..cbbcebc6 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();
   }
 }