effect 4.0.0-beta.78 → 4.0.0-beta.79

package/dist/Schema.js

@@ -1,85 +1,13 @@
 /**
- * Define data shapes, validate unknown input, and transform values between formats.
- *
- * ## Mental model
- *
- * - **Schema** — a description of a data shape. Every schema carries a decoded
- *   *Type* (the value you work with) and an *Encoded* representation (the
- *   serialized form, e.g. JSON).
- * - **Decoding** — turning unknown external data (API responses, form
- *   submissions, config files) into typed, validated values.
- * - **Encoding** — turning typed values back into a serializable format.
- * - **Codec** — a schema that tracks both Type and Encoded, so it can decode
- *   *and* encode. Most concrete schemas are Codecs.
- * - **Check / Filter** — a constraint attached to a schema (e.g. `isMinLength`,
- *   `isGreaterThan`). Attach them with `.check(...)`.
- * - **Transformation** — a pair of functions (decode + encode) that convert
- *   values between two schemas. Created with {@link decodeTo} / {@link encodeTo}.
- * - **Annotation** — metadata attached to a schema (title, description, custom
- *   keys). Attach with `.annotate(...)`.
- *
- * ## Common tasks
- *
- * - Define a struct: {@link Struct}
- * - Define a union: {@link Union}, {@link TaggedUnion}, {@link Literals}
- * - Define an array: {@link ArraySchema}, {@link NonEmptyArray}
- * - Define a record: {@link Record}
- * - Define a tuple: {@link Tuple}, {@link TupleWithRest}
- * - Validate unknown data synchronously: {@link decodeUnknownSync}
- * - Validate unknown data (Effect): {@link decodeUnknownEffect}
- * - Encode a value: {@link encodeUnknownSync}, {@link encodeUnknownEffect}
- * - Type guard: {@link is}
- * - Assertion: {@link asserts}
- * - Add constraints: `.check(...)` with filters like {@link isMinLength},
- *   {@link isGreaterThan}, {@link isPattern}, {@link isUUID}, {@link isGUID}
- * - Transform between schemas: {@link decodeTo}, {@link encodeTo}
- * - Add a default for missing keys: {@link withDecodingDefault}, {@link withDecodingDefaultKey}
- * - Create branded types: {@link brand}
- * - Define classes with validation: {@link Class}, {@link TaggedClass}
- * - Define error classes: {@link ErrorClass}, {@link TaggedErrorClass}
- * - Generate JSON Schema: {@link toJsonSchemaDocument}
- * - Generate test data: {@link toArbitrary}
- * - Derive equivalence: {@link toEquivalence}
- *
- * ## Gotchas
- *
- * - `Schema.optional` creates `T | undefined` (key can be missing *or*
- *   `undefined`). Use `Schema.optionalKey` for exact optional properties.
- * - `decodeTo` is curried: use `from.pipe(Schema.decodeTo(to, ...))`.
- * - `decodeUnknownSync` throws on failure. Use `decodeUnknownExit` or
- *   `decodeUnknownOption` for non-throwing alternatives.
- * - Filters do not change the TypeScript type. Use {@link refine} or
- *   {@link brand} to narrow the type.
- * - Recursive schemas require {@link suspend} to avoid infinite loops.
- *
- * ## Quickstart
- *
- * **Example** (Validate a user object)
+ * Describes data shapes and how unknown input becomes trusted values.
  *
- * ```ts
- * import { Schema } from "effect"
- *
- * const User = Schema.Struct({
- *   name: Schema.String.check(Schema.isMinLength(1)),
- *   age: Schema.Number.check(Schema.isGreaterThanOrEqualTo(0)),
- *   email: Schema.optionalKey(Schema.String)
- * })
- *
- * // Decode unknown input — throws on failure
- * const user = Schema.decodeUnknownSync(User)({
- *   name: "Alice",
- *   age: 30
- * })
- *
- * console.log(user)
- * // { name: "Alice", age: 30 }
- * ```
- *
- * @see {@link Schema} — type-level view tracking only the decoded Type
- * @see {@link Codec} — type-level view tracking both Type and Encoded
- * @see {@link Struct} — define object shapes
- * @see {@link decodeUnknownSync} — synchronous validation
- * @see {@link decodeTo} — schema transformations
+ * A schema can validate input, decode it into an application type, and encode
+ * that value back to another representation. This module contains the main
+ * schema, codec, decoder, and encoder APIs, together with schemas for common
+ * JavaScript values and Effect data types. It also supports refinements,
+ * transformations, defaults, classes, JSON Schema generation, test data
+ * generation, formatting, equivalence, optics, and differs derived from schema
+ * definitions.
  *
  * @since 4.0.0
  */
@@ -1795,6 +1723,7 @@ export function Struct(fields) {
 export function fieldsAssign(fields) {
   return Struct_.lambda(struct => struct.mapFields(Struct_.assign(fields)));
 }
+const canonicalPropertyKey = key => typeof key === "symbol" ? key : globalThis.String(key);
 /**
  * Renames struct keys in the encoded form without changing the decoded type.
  *
@@ -1803,6 +1732,8 @@ export function fieldsAssign(fields) {
  * Takes a partial mapping `{ decodedKey: encodedKey }` and produces a
  * transformation schema that decodes from the renamed keys and encodes back to
  * the renamed keys. Keys not present in the mapping are left unchanged.
+ * If two existing fields would produce the same encoded key, construction
+ * fails.
  *
  * **Example** (Rename `name` to `full_name` in the encoded form)
  *
@@ -1824,19 +1755,27 @@ export function fieldsAssign(fields) {
 export function encodeKeys(mapping) {
   return function (self) {
     const fields = {};
+    const appliedMapping = {};
     const reverseMapping = {};
-    for (const k in self.fields) {
+    const seenEncodedKeys = new Set();
+    for (const k of Reflect.ownKeys(self.fields)) {
       const encoded = toEncoded(self.fields[k]);
-      if (Object.hasOwn(mapping, k)) {
-        fields[mapping[k]] = encoded;
-        reverseMapping[mapping[k]] = k;
-      } else {
-        fields[k] = encoded;
+      const hasMapping = Object.hasOwn(mapping, k);
+      const encodedKey = hasMapping ? mapping[k] : k;
+      const canonical = canonicalPropertyKey(encodedKey);
+      if (seenEncodedKeys.has(canonical)) {
+        throw new globalThis.Error(`Duplicate encoded keys: ${formatPropertyKey(encodedKey)}`);
+      }
+      seenEncodedKeys.add(canonical);
+      fields[encodedKey] = encoded;
+      if (hasMapping) {
+        appliedMapping[k] = encodedKey;
+        reverseMapping[encodedKey] = k;
       }
     }
     return Struct(fields).pipe(decodeTo(self, SchemaTransformation.transform({
       decode: Struct_.renameKeys(reverseMapping),
-      encode: Struct_.renameKeys(mapping)
+      encode: Struct_.renameKeys(appliedMapping)
     })));
   };
 }
@@ -3144,8 +3083,8 @@ export function isTrimmed(annotations) {
       _tag: "isTrimmed",
       regExp: new globalThis.RegExp(TRIMMED_PATTERN)
     },
-    toArbitraryConstraint: {
-      string: {
+    arbitrary: {
+      constraint: {
         patterns: [TRIMMED_PATTERN]
       }
     },
@@ -3418,8 +3357,8 @@ export function isStartsWith(startsWith, annotations) {
       startsWith,
       regExp: new globalThis.RegExp(`^${startsWith}`)
     },
-    toArbitraryConstraint: {
-      string: {
+    arbitrary: {
+      constraint: {
         patterns: [`^${startsWith}`]
       }
     },
@@ -3448,8 +3387,8 @@ export function isEndsWith(endsWith, annotations) {
       endsWith,
       regExp: new globalThis.RegExp(`${endsWith}$`)
     },
-    toArbitraryConstraint: {
-      string: {
+    arbitrary: {
+      constraint: {
         patterns: [`${endsWith}$`]
       }
     },
@@ -3478,8 +3417,8 @@ export function isIncludes(includes, annotations) {
       includes,
       regExp: new globalThis.RegExp(includes)
     },
-    toArbitraryConstraint: {
-      string: {
+    arbitrary: {
+      constraint: {
         patterns: [includes]
       }
     },
@@ -3506,8 +3445,8 @@ export function isUppercased(annotations) {
       _tag: "isUppercased",
       regExp: new globalThis.RegExp(UPPERCASED_PATTERN)
     },
-    toArbitraryConstraint: {
-      string: {
+    arbitrary: {
+      constraint: {
         patterns: [UPPERCASED_PATTERN]
       }
     },
@@ -3534,8 +3473,8 @@ export function isLowercased(annotations) {
       _tag: "isLowercased",
       regExp: new globalThis.RegExp(LOWERCASED_PATTERN)
     },
-    toArbitraryConstraint: {
-      string: {
+    arbitrary: {
+      constraint: {
         patterns: [LOWERCASED_PATTERN]
       }
     },
@@ -3562,8 +3501,8 @@ export function isCapitalized(annotations) {
       _tag: "isCapitalized",
       regExp: new globalThis.RegExp(CAPITALIZED_PATTERN)
     },
-    toArbitraryConstraint: {
-      string: {
+    arbitrary: {
+      constraint: {
         patterns: [CAPITALIZED_PATTERN]
       }
     },
@@ -3590,8 +3529,8 @@ export function isUncapitalized(annotations) {
       _tag: "isUncapitalized",
       regExp: new globalThis.RegExp(UNCAPITALIZED_PATTERN)
     },
-    toArbitraryConstraint: {
-      string: {
+    arbitrary: {
+      constraint: {
         patterns: [UNCAPITALIZED_PATTERN]
       }
     },
@@ -3610,8 +3549,8 @@ export function isUncapitalized(annotations) {
  *
  * Arbitrary:
  *
- * When generating test data with fast-check, this applies `noDefaultInfinity`
- * and `noNaN` constraints to ensure generated numbers are finite.
+ * When generating test data with fast-check, this applies `noNaN: true` and
+ * `noInfinity: true` constraints to ensure generated numbers are finite.
  *
  * @category Number checks
  * @since 4.0.0
@@ -3622,9 +3561,9 @@ export function isFinite(annotations) {
     meta: {
       _tag: "isFinite"
     },
-    toArbitraryConstraint: {
-      number: {
-        noDefaultInfinity: true,
+    arbitrary: {
+      constraint: {
+        noInfinity: true,
         noNaN: true
       }
     },
@@ -3644,6 +3583,15 @@ export function makeIsGreaterThan(options) {
   return (exclusiveMinimum, annotations) => {
     return makeFilter(input => gt(input, exclusiveMinimum), {
       expected: `a value greater than ${formatter(exclusiveMinimum)}`,
+      arbitrary: {
+        constraint: {
+          ordered: {
+            order: options.order,
+            minimum: exclusiveMinimum,
+            exclusiveMinimum: true
+          }
+        }
+      },
       ...options.annotate?.(exclusiveMinimum),
       ...annotations
     });
@@ -3662,6 +3610,14 @@ export function makeIsGreaterThanOrEqualTo(options) {
   return (minimum, annotations) => {
     return makeFilter(input => gte(input, minimum), {
       expected: `a value greater than or equal to ${formatter(minimum)}`,
+      arbitrary: {
+        constraint: {
+          ordered: {
+            order: options.order,
+            minimum
+          }
+        }
+      },
       ...options.annotate?.(minimum),
       ...annotations
     });
@@ -3680,6 +3636,15 @@ export function makeIsLessThan(options) {
   return (exclusiveMaximum, annotations) => {
     return makeFilter(input => lt(input, exclusiveMaximum), {
       expected: `a value less than ${formatter(exclusiveMaximum)}`,
+      arbitrary: {
+        constraint: {
+          ordered: {
+            order: options.order,
+            maximum: exclusiveMaximum,
+            exclusiveMaximum: true
+          }
+        }
+      },
       ...options.annotate?.(exclusiveMaximum),
       ...annotations
     });
@@ -3698,6 +3663,14 @@ export function makeIsLessThanOrEqualTo(options) {
   return (maximum, annotations) => {
     return makeFilter(input => lte(input, maximum), {
       expected: `a value less than or equal to ${formatter(maximum)}`,
+      arbitrary: {
+        constraint: {
+          ordered: {
+            order: options.order,
+            maximum
+          }
+        }
+      },
       ...options.annotate?.(maximum),
       ...annotations
     });
@@ -3721,6 +3694,21 @@ export function makeIsBetween(deriveOptions) {
     const lte = options.exclusiveMaximum ? lessThan : lessThanOrEqualTo;
     return makeFilter(input => gte(input, options.minimum) && lte(input, options.maximum), {
       expected: `a value between ${formatter(options.minimum)}${options.exclusiveMinimum ? " (excluded)" : ""} and ${formatter(options.maximum)}${options.exclusiveMaximum ? " (excluded)" : ""}`,
+      arbitrary: {
+        constraint: {
+          ordered: {
+            order: deriveOptions.order,
+            minimum: options.minimum,
+            maximum: options.maximum,
+            ...(options.exclusiveMinimum && {
+              exclusiveMinimum: true
+            }),
+            ...(options.exclusiveMaximum && {
+              exclusiveMaximum: true
+            })
+          }
+        }
+      },
       ...deriveOptions.annotate?.(options),
       ...annotations
     });
@@ -3754,9 +3742,9 @@ export function makeIsMultipleOf(options) {
  *
  * Arbitrary:
  *
- * When generating test data with fast-check, this applies a `min` constraint
- * with `minExcluded: true` to ensure generated numbers are greater than the
- * specified value.
+ * When generating test data with fast-check, this applies an
+ * `exclusiveMinimum` constraint to ensure generated numbers are greater than
+ * the specified value.
  *
  * @category Number checks
  * @since 4.0.0
@@ -3767,12 +3755,6 @@ export const isGreaterThan = /*#__PURE__*/makeIsGreaterThan({
     meta: {
       _tag: "isGreaterThan",
       exclusiveMinimum
-    },
-    toArbitraryConstraint: {
-      number: {
-        min: exclusiveMinimum,
-        minExcluded: true
-      }
     }
   })
 });
@@ -3788,7 +3770,7 @@ export const isGreaterThan = /*#__PURE__*/makeIsGreaterThan({
  *
  * Arbitrary:
  *
- * When generating test data with fast-check, this applies a `min` constraint
+ * When generating test data with fast-check, this applies a `minimum` constraint
  * to ensure generated numbers are greater than or equal to the specified value.
  *
  * @category Number checks
@@ -3800,11 +3782,6 @@ export const isGreaterThanOrEqualTo = /*#__PURE__*/makeIsGreaterThanOrEqualTo({
     meta: {
       _tag: "isGreaterThanOrEqualTo",
       minimum
-    },
-    toArbitraryConstraint: {
-      number: {
-        min: minimum
-      }
     }
   })
 });
@@ -3819,8 +3796,8 @@ export const isGreaterThanOrEqualTo = /*#__PURE__*/makeIsGreaterThanOrEqualTo({
  *
  * Arbitrary:
  *
- * When generating test data with fast-check, this applies a `max` constraint
- * with `maxExcluded: true` to ensure generated numbers are less than the
+ * When generating test data with fast-check, this applies an
+ * `exclusiveMaximum` constraint to ensure generated numbers are less than the
  * specified value.
  *
  * @category Number checks
@@ -3832,12 +3809,6 @@ export const isLessThan = /*#__PURE__*/makeIsLessThan({
     meta: {
       _tag: "isLessThan",
       exclusiveMaximum
-    },
-    toArbitraryConstraint: {
-      number: {
-        max: exclusiveMaximum,
-        maxExcluded: true
-      }
     }
   })
 });
@@ -3853,7 +3824,7 @@ export const isLessThan = /*#__PURE__*/makeIsLessThan({
  *
  * Arbitrary:
  *
- * When generating test data with fast-check, this applies a `max` constraint
+ * When generating test data with fast-check, this applies a `maximum` constraint
  * to ensure generated numbers are less than or equal to the specified value.
  *
  * @category Number checks
@@ -3865,11 +3836,6 @@ export const isLessThanOrEqualTo = /*#__PURE__*/makeIsLessThanOrEqualTo({
     meta: {
       _tag: "isLessThanOrEqualTo",
       maximum
-    },
-    toArbitraryConstraint: {
-      number: {
-        max: maximum
-      }
     }
   })
 });
@@ -3886,9 +3852,10 @@ export const isLessThanOrEqualTo = /*#__PURE__*/makeIsLessThanOrEqualTo({
  *
  * Arbitrary:
  *
- * When generating test data with fast-check, this applies `min` and `max`
- * constraints with optional `minExcluded` and `maxExcluded` flags to ensure
- * generated numbers fall within the specified range.
+ * When generating test data with fast-check, this applies `minimum` and
+ * `maximum` constraints with optional `exclusiveMinimum` and
+ * `exclusiveMaximum` flags to ensure generated numbers fall within the
+ * specified range.
  *
  * @category Number checks
  * @since 4.0.0
@@ -3900,18 +3867,6 @@ export const isBetween = /*#__PURE__*/makeIsBetween({
       meta: {
         _tag: "isBetween",
         ...options
-      },
-      toArbitraryConstraint: {
-        number: {
-          min: options.minimum,
-          max: options.maximum,
-          ...(options.exclusiveMinimum && {
-            minExcluded: true
-          }),
-          ...(options.exclusiveMaximum && {
-            maxExcluded: true
-          })
-        }
       }
     };
   }
@@ -3956,7 +3911,7 @@ export const isMultipleOf = /*#__PURE__*/makeIsMultipleOf({
  *
  * Arbitrary:
  *
- * When generating test data with fast-check, this applies an `isInteger: true`
+ * When generating test data with fast-check, this applies an `integer: true`
  * constraint to ensure generated numbers are integers.
  *
  * @category Integer checks
@@ -3968,9 +3923,9 @@ export function isInt(annotations) {
     meta: {
       _tag: "isInt"
     },
-    toArbitraryConstraint: {
-      number: {
-        isInteger: true
+    arbitrary: {
+      constraint: {
+        integer: true
       }
     },
     ...annotations
@@ -4045,7 +4000,7 @@ export function isUint32(annotations) {
  *
  * Arbitrary:
  *
- * When generating test data with fast-check, this applies a `noInvalidDate`
+ * When generating test data with fast-check, this applies a `valid: true`
  * constraint to ensure generated Date objects are valid.
  *
  * @category Date checks
@@ -4057,16 +4012,14 @@ export function isDateValid(annotations) {
     meta: {
       _tag: "isDateValid"
     },
-    toArbitraryConstraint: {
-      date: {
-        noInvalidDate: true
+    arbitrary: {
+      constraint: {
+        valid: true
       }
     },
     ...annotations
   });
 }
-const nextDate = date => new globalThis.Date(date.getTime() + 1);
-const previousDate = date => new globalThis.Date(date.getTime() - 1);
 /**
  * Validates that a Date is greater than the specified value (exclusive).
  *
@@ -4087,11 +4040,6 @@ export const isGreaterThanDate = /*#__PURE__*/makeIsGreaterThan({
     meta: {
       _tag: "isGreaterThanDate",
       exclusiveMinimum
-    },
-    toArbitraryConstraint: {
-      date: {
-        min: nextDate(exclusiveMinimum)
-      }
     }
   })
 });
@@ -4121,11 +4069,6 @@ export const isGreaterThanOrEqualToDate = /*#__PURE__*/makeIsGreaterThanOrEqualT
     meta: {
       _tag: "isGreaterThanOrEqualToDate",
       minimum
-    },
-    toArbitraryConstraint: {
-      date: {
-        min: minimum
-      }
     }
   })
 });
@@ -4149,11 +4092,6 @@ export const isLessThanDate = /*#__PURE__*/makeIsLessThan({
     meta: {
       _tag: "isLessThanDate",
       exclusiveMaximum
-    },
-    toArbitraryConstraint: {
-      date: {
-        max: previousDate(exclusiveMaximum)
-      }
     }
   })
 });
@@ -4183,11 +4121,6 @@ export const isLessThanOrEqualToDate = /*#__PURE__*/makeIsLessThanOrEqualTo({
     meta: {
       _tag: "isLessThanOrEqualToDate",
       maximum
-    },
-    toArbitraryConstraint: {
-      date: {
-        max: maximum
-      }
     }
   })
 });
@@ -4217,17 +4150,9 @@ export const isBetweenDate = /*#__PURE__*/makeIsBetween({
     meta: {
       _tag: "isBetweenDate",
       ...options
-    },
-    toArbitraryConstraint: {
-      date: {
-        min: options.exclusiveMinimum ? nextDate(options.minimum) : options.minimum,
-        max: options.exclusiveMaximum ? previousDate(options.maximum) : options.maximum
-      }
     }
   })
 });
-const nextBigInt = n => n + globalThis.BigInt(1);
-const previousBigInt = n => n - globalThis.BigInt(1);
 /**
  * Validates that a BigInt is greater than the specified value (exclusive).
  *
@@ -4248,11 +4173,6 @@ export const isGreaterThanBigInt = /*#__PURE__*/makeIsGreaterThan({
     meta: {
       _tag: "isGreaterThanBigInt",
       exclusiveMinimum
-    },
-    toArbitraryConstraint: {
-      bigint: {
-        min: nextBigInt(exclusiveMinimum)
-      }
     }
   })
 });
@@ -4277,11 +4197,6 @@ export const isGreaterThanOrEqualToBigInt = /*#__PURE__*/makeIsGreaterThanOrEqua
     meta: {
       _tag: "isGreaterThanOrEqualToBigInt",
       minimum
-    },
-    toArbitraryConstraint: {
-      bigint: {
-        min: minimum
-      }
     }
   })
 });
@@ -4305,11 +4220,6 @@ export const isLessThanBigInt = /*#__PURE__*/makeIsLessThan({
     meta: {
       _tag: "isLessThanBigInt",
       exclusiveMaximum
-    },
-    toArbitraryConstraint: {
-      bigint: {
-        max: previousBigInt(exclusiveMaximum)
-      }
     }
   })
 });
@@ -4334,11 +4244,6 @@ export const isLessThanOrEqualToBigInt = /*#__PURE__*/makeIsLessThanOrEqualTo({
     meta: {
       _tag: "isLessThanOrEqualToBigInt",
       maximum
-    },
-    toArbitraryConstraint: {
-      bigint: {
-        max: maximum
-      }
     }
   })
 });
@@ -4363,12 +4268,6 @@ export const isBetweenBigInt = /*#__PURE__*/makeIsBetween({
     meta: {
       _tag: "isBetweenBigInt",
       ...options
-    },
-    toArbitraryConstraint: {
-      bigint: {
-        min: options.exclusiveMinimum ? nextBigInt(options.minimum) : options.minimum,
-        max: options.exclusiveMaximum ? previousBigInt(options.maximum) : options.maximum
-      }
     }
   })
 });
@@ -4467,11 +4366,8 @@ export function isMinLength(minLength, annotations) {
       minLength
     },
     [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
-    toArbitraryConstraint: {
-      string: {
-        minLength
-      },
-      array: {
+    arbitrary: {
+      constraint: {
         minLength
       }
     },
@@ -4529,11 +4425,8 @@ export function isMaxLength(maxLength, annotations) {
       maxLength
     },
     [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
-    toArbitraryConstraint: {
-      string: {
-        maxLength
-      },
-      array: {
+    arbitrary: {
+      constraint: {
         maxLength
       }
     },
@@ -4571,12 +4464,8 @@ export function isLengthBetween(minimum, maximum, annotations) {
       maximum
     },
     [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
-    toArbitraryConstraint: {
-      string: {
-        minLength: minimum,
-        maxLength: maximum
-      },
-      array: {
+    arbitrary: {
+      constraint: {
         minLength: minimum,
         maxLength: maximum
       }
@@ -4597,9 +4486,9 @@ export function isLengthBetween(minimum, maximum, annotations) {
  *
  * Arbitrary:
  *
- * When generating test data with fast-check, this applies a `minLength`
- * constraint to the array representation to ensure generated values have at
- * least the required size.
+ * When generating test data with fast-check, this applies a node-local
+ * `minLength` constraint. Generators for values with a final `.size`, such as
+ * sets and maps, interpret it as final cardinality.
  *
  * @category Size checks
  * @since 4.0.0
@@ -4613,8 +4502,8 @@ export function isMinSize(minSize, annotations) {
       minSize
     },
     [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
-    toArbitraryConstraint: {
-      array: {
+    arbitrary: {
+      constraint: {
         minLength: minSize
       }
     },
@@ -4634,9 +4523,9 @@ export function isMinSize(minSize, annotations) {
  *
  * Arbitrary:
  *
- * When generating test data with fast-check, this applies a `maxLength`
- * constraint to the array representation to ensure generated values have at
- * most the required size.
+ * When generating test data with fast-check, this applies a node-local
+ * `maxLength` constraint. Generators for values with a final `.size`, such as
+ * sets and maps, interpret it as final cardinality.
  *
  * @category Size checks
  * @since 4.0.0
@@ -4650,8 +4539,8 @@ export function isMaxSize(maxSize, annotations) {
       maxSize
     },
     [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
-    toArbitraryConstraint: {
-      array: {
+    arbitrary: {
+      constraint: {
         maxLength: maxSize
       }
     },
@@ -4671,9 +4560,9 @@ export function isMaxSize(maxSize, annotations) {
  *
  * Arbitrary:
  *
- * When generating test data with fast-check, this applies `minLength` and
- * `maxLength` constraints to ensure generated values have a size within the
- * specified range.
+ * When generating test data with fast-check, this applies node-local
+ * `minLength` and `maxLength` constraints. Generators for values with a final
+ * `.size`, such as sets and maps, interpret them as final cardinality.
  *
  * @category Size checks
  * @since 4.0.0
@@ -4689,8 +4578,8 @@ export function isSizeBetween(minimum, maximum, annotations) {
       maximum
     },
     [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
-    toArbitraryConstraint: {
-      array: {
+    arbitrary: {
+      constraint: {
         minLength: minimum,
         maxLength: maximum
       }
@@ -4711,10 +4600,9 @@ export function isSizeBetween(minimum, maximum, annotations) {
  *
  * Arbitrary:
  *
- * When generating test data with fast-check, this applies a `minLength`
- * constraint to the array of entries that is generated before being converted
- * to an object, ensuring the resulting object has at least the required number
- * of properties.
+ * When generating test data with fast-check, this applies a node-local
+ * `minLength` constraint. Object generators interpret it as the final number
+ * of own properties.
  *
  * @category Object checks
  * @since 4.0.0
@@ -4728,8 +4616,8 @@ export function isMinProperties(minProperties, annotations) {
       minProperties
     },
     [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
-    toArbitraryConstraint: {
-      array: {
+    arbitrary: {
+      constraint: {
         minLength: minProperties
       }
     },
@@ -4748,10 +4636,9 @@ export function isMinProperties(minProperties, annotations) {
  *
  * Arbitrary:
  *
- * When generating test data with fast-check, this applies a `maxLength`
- * constraint to the array of entries that is generated before being converted
- * to an object, ensuring the resulting object has at most the required number
- * of properties.
+ * When generating test data with fast-check, this applies a node-local
+ * `maxLength` constraint. Object generators interpret it as the final number
+ * of own properties.
  *
  * @category Object checks
  * @since 4.0.0
@@ -4765,8 +4652,8 @@ export function isMaxProperties(maxProperties, annotations) {
       maxProperties
     },
     [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
-    toArbitraryConstraint: {
-      array: {
+    arbitrary: {
+      constraint: {
         maxLength: maxProperties
       }
     },
@@ -4786,9 +4673,9 @@ export function isMaxProperties(maxProperties, annotations) {
  *
  * Arbitrary:
  *
- * When generating test data with fast-check, this applies `minLength` and
- * `maxLength` constraints to the array of entries that is generated before
- * being converted to an object.
+ * When generating test data with fast-check, this applies node-local
+ * `minLength` and `maxLength` constraints. Object generators interpret them as
+ * the final number of own properties.
  *
  * @category Object checks
  * @since 4.0.0
@@ -4804,8 +4691,8 @@ export function isPropertiesLengthBetween(minimum, maximum, annotations) {
       maximum
     },
     [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
-    toArbitraryConstraint: {
-      array: {
+    arbitrary: {
+      constraint: {
         minLength: minimum,
         maxLength: maximum
       }
@@ -4865,8 +4752,9 @@ export function isPropertyNames(keySchema, annotations) {
  * This check corresponds to the `uniqueItems: true` constraint in JSON Schema.
  *
  * Arbitrary:
- * When generating test data with fast-check, this applies a comparator based on
- * Effect equality to ensure generated arrays contain only unique items.
+ * When generating test data with fast-check, this applies a node-local
+ * `unique: true` constraint. Array generators translate it to `fast-check`
+ * `uniqueArray` using Effect equality.
  *
  * @category Array checks
  * @since 4.0.0
@@ -4878,9 +4766,9 @@ export function isUnique(annotations) {
     meta: {
       _tag: "isUnique"
     },
-    toArbitraryConstraint: {
-      array: {
-        comparator: equivalence
+    arbitrary: {
+      constraint: {
+        unique: true
       }
     },
     ...annotations
@@ -4957,10 +4845,9 @@ export function Option(value) {
       }
     })),
     toArbitrary: ([value]) => (fc, ctx) => {
-      return fc.oneof(ctx?.isSuspend ? {
-        maxDepth: 2,
-        depthIdentifier: "Option"
-      } : {}, fc.constant(Option_.none()), value.map(Option_.some));
+      const terminal = fc.constant(Option_.none());
+      const arbitrary = fc.oneof(terminal, value.arbitrary.map(Option_.some));
+      return withRecursion(fc, ctx, terminal, arbitrary);
     },
     toEquivalence: ([value]) => Option_.makeEquivalence(value),
     toFormatter: ([value]) => Option_.match({
@@ -5119,10 +5006,9 @@ export function Result(success, failure) {
       }
     })),
     toArbitrary: ([success, failure]) => (fc, ctx) => {
-      return fc.oneof(ctx?.isSuspend ? {
-        maxDepth: 2,
-        depthIdentifier: "Result"
-      } : {}, success.map(Result_.succeed), failure.map(Result_.fail));
+      const terminal = oneOfArbitraries(fc, success.terminal?.map(a => Result_.succeed(a)), failure.terminal?.map(e => Result_.fail(e)));
+      const arbitrary = fc.oneof(success.arbitrary.map(a => Result_.succeed(a)), failure.arbitrary.map(e => Result_.fail(e)));
+      return withRecursion(fc, ctx, terminal, arbitrary);
     },
     toEquivalence: ([success, failure]) => Result_.makeEquivalence(success, failure),
     toFormatter: ([success, failure]) => Result_.match({
@@ -5190,9 +5076,14 @@ export function Redacted(value, options) {
       })),
       encode: options?.disallowJsonEncode ? SchemaGetter.forbidden(oe => "Cannot serialize Redacted" + (Option_.isSome(oe) && typeof oe.value.label === "string" ? ` with label: "${oe.value.label}"` : "")) : SchemaGetter.transform(Redacted_.value)
     }),
-    toArbitrary: ([value]) => () => value.map(a => Redacted_.make(a, {
-      label: options?.label
-    })),
+    toArbitrary: ([value]) => () => ({
+      arbitrary: value.arbitrary.map(a => Redacted_.make(a, {
+        label: options?.label
+      })),
+      terminal: value.terminal?.map(a => Redacted_.make(a, {
+        label: options?.label
+      }))
+    }),
     toFormatter: () => globalThis.String,
     toEquivalence: ([value]) => Redacted_.makeEquivalence(value)
   });
@@ -5311,12 +5202,11 @@ export function CauseReason(error, defect) {
 }
 function causeReasonToArbitrary(error, defect) {
   return (fc, ctx) => {
-    return fc.oneof(ctx?.isSuspend ? {
-      maxDepth: 2,
-      depthIdentifier: "Cause.Failure"
-    } : {}, fc.constant(Cause_.makeInterruptReason()), fc.integer({
+    const terminal = fc.constant(Cause_.makeInterruptReason());
+    const arbitrary = fc.oneof(terminal, fc.integer({
       min: 1
-    }).map(Cause_.makeInterruptReason), error.map(e => Cause_.makeFailReason(e)), defect.map(d => Cause_.makeDieReason(d)));
+    }).map(Cause_.makeInterruptReason), error.arbitrary.map(e => Cause_.makeFailReason(e)), defect.arbitrary.map(d => Cause_.makeDieReason(d)));
+    return withRecursion(fc, ctx, terminal, arbitrary);
   };
 }
 function causeReasonToEquivalence(error, defect) {
@@ -5404,7 +5294,10 @@ export function Cause(error, defect) {
 }
 function causeToArbitrary(error, defect) {
   return (fc, ctx) => {
-    return fc.array(causeReasonToArbitrary(error, defect)(fc, ctx)).map(Cause_.fromReasons);
+    const reason = causeReasonToArbitrary(error, defect)(fc, ctx);
+    const terminal = fc.constant(Cause_.empty);
+    const arbitrary = fc.array(reason.arbitrary).map(Cause_.fromReasons);
+    return withRecursion(fc, ctx, terminal, arbitrary);
   };
 }
 function causeToEquivalence(error, defect) {
@@ -5586,10 +5479,12 @@ export function Exit(value, error, defect) {
         cause: exit.cause
       }
     })),
-    toArbitrary: ([value, error, defect]) => (fc, ctx) => fc.oneof(ctx?.isSuspend ? {
-      maxDepth: 2,
-      depthIdentifier: "Exit"
-    } : {}, value.map(v => Exit_.succeed(v)), causeToArbitrary(error, defect)(fc, ctx).map(cause => Exit_.failCause(cause))),
+    toArbitrary: ([value, error, defect]) => (fc, ctx) => {
+      const cause = causeToArbitrary(error, defect)(fc, ctx);
+      const terminal = oneOfArbitraries(fc, value.terminal?.map(v => Exit_.succeed(v)), cause.terminal?.map(cause => Exit_.failCause(cause)));
+      const arbitrary = fc.oneof(value.arbitrary.map(v => Exit_.succeed(v)), cause.arbitrary.map(cause => Exit_.failCause(cause)));
+      return withRecursion(fc, ctx, terminal, arbitrary);
+    },
     toEquivalence: ([value, error, defect]) => {
       const cause = causeToEquivalence(error, defect);
       return (a, b) => {
@@ -5620,6 +5515,48 @@ export function Exit(value, error, defect) {
     defect
   });
 }
+function oneOfArbitraries(fc, a, b) {
+  return a === undefined ? b : b === undefined ? a : fc.oneof(a, b);
+}
+function withRecursion(fc, ctx, terminal, arbitrary) {
+  return {
+    arbitrary: terminal === undefined || ctx.recursion === undefined ? arbitrary : fc.oneof(ctx.recursion, terminal, arbitrary),
+    terminal
+  };
+}
+function arrayFromItems(fc, item, constraints, comparator) {
+  return comparator === undefined ? fc.array(item, constraints) : fc.uniqueArray(item, {
+    ...constraints,
+    comparator
+  });
+}
+function collectionArbitrary(fc, ctx, item, terminalItem, fromIterable, comparator) {
+  const constraint = ctx.constraint;
+  const constraints = constraint === undefined || constraint.minLength === undefined && constraint.maxLength === undefined ? undefined : {
+    ...(constraint.minLength !== undefined ? {
+      minLength: constraint.minLength
+    } : {}),
+    ...(constraint.maxLength !== undefined ? {
+      maxLength: constraint.maxLength
+    } : {})
+  };
+  if (constraints?.minLength !== undefined && constraints.maxLength !== undefined && constraints.minLength > constraints.maxLength) {
+    throw new globalThis.Error("Unable to derive an arbitrary for size constraints");
+  }
+  const minLength = constraints?.minLength ?? 0;
+  const terminal = minLength === 0 ? fc.constant([]) : terminalItem === undefined ? undefined : arrayFromItems(fc, terminalItem, {
+    ...constraints,
+    maxLength: minLength
+  }, comparator);
+  const arrays = withRecursion(fc, ctx, terminal, arrayFromItems(fc, item, constraints, comparator));
+  return {
+    arbitrary: arrays.arbitrary.map(fromIterable),
+    terminal: arrays.terminal?.map(fromIterable)
+  };
+}
+function entriesArbitrary(fc, ctx, key, value, fromIterable) {
+  return collectionArbitrary(fc, ctx, fc.tuple(key.arbitrary, value.arbitrary), key.terminal === undefined || value.terminal === undefined ? undefined : fc.tuple(key.terminal, value.terminal), fromIterable, ([a], [b]) => Equal.equals(a, b));
+}
 /**
  * Schema for readonly maps whose keys and values conform to the provided
  * schemas.
@@ -5652,12 +5589,7 @@ export function ReadonlyMap(key, value) {
       decode: e => new globalThis.Map(e),
       encode: map => [...map.entries()]
     })),
-    toArbitrary: ([key, value]) => (fc, ctx) => {
-      return fc.oneof(ctx?.isSuspend ? {
-        maxDepth: 2,
-        depthIdentifier: "ReadonlyMap"
-      } : {}, fc.constant([]), fc.array(fc.tuple(key, value), ctx?.constraints?.array)).map(as => new globalThis.Map(as));
-    },
+    toArbitrary: ([key, value]) => (fc, ctx) => entriesArbitrary(fc, ctx, key, value, as => new globalThis.Map(as)),
     toEquivalence: ([key, value]) => Equal.makeCompareMap(key, value),
     toFormatter: ([key, value]) => t => {
       const size = t.size;
@@ -5705,12 +5637,7 @@ export function HashMap(key, value) {
       decode: HashMap_.fromIterable,
       encode: HashMap_.toEntries
     })),
-    toArbitrary: ([key, value]) => (fc, ctx) => {
-      return fc.oneof(ctx?.isSuspend ? {
-        maxDepth: 2,
-        depthIdentifier: "HashMap"
-      } : {}, fc.constant([]), fc.array(fc.tuple(key, value), ctx?.constraints?.array)).map(HashMap_.fromIterable);
-    },
+    toArbitrary: ([key, value]) => (fc, ctx) => entriesArbitrary(fc, ctx, key, value, HashMap_.fromIterable),
     toEquivalence: ([key, value]) => Equal.makeCompareMap(key, value),
     toFormatter: ([key, value]) => t => {
       const size = HashMap_.size(t);
@@ -5757,12 +5684,7 @@ export function ReadonlySet(value) {
       decode: e => new globalThis.Set(e),
       encode: set => [...set.values()]
     })),
-    toArbitrary: ([value]) => (fc, ctx) => {
-      return fc.oneof(ctx?.isSuspend ? {
-        maxDepth: 2,
-        depthIdentifier: "ReadonlySet"
-      } : {}, fc.constant([]), fc.array(value, ctx?.constraints?.array)).map(as => new globalThis.Set(as));
-    },
+    toArbitrary: ([value]) => (fc, ctx) => collectionArbitrary(fc, ctx, value.arbitrary, value.terminal, as => new globalThis.Set(as), Equal.equals),
     toEquivalence: ([value]) => Equal.makeCompareSet(value),
     toFormatter: ([value]) => t => {
       const size = t.size;
@@ -5808,12 +5730,7 @@ export function HashSet(value) {
       decode: HashSet_.fromIterable,
       encode: Arr.fromIterable
     })),
-    toArbitrary: ([value]) => (fc, ctx) => {
-      return fc.oneof(ctx?.isSuspend ? {
-        maxDepth: 2,
-        depthIdentifier: "HashSet"
-      } : {}, fc.constant([]), fc.array(value, ctx?.constraints?.array)).map(HashSet_.fromIterable);
-    },
+    toArbitrary: ([value]) => (fc, ctx) => collectionArbitrary(fc, ctx, value.arbitrary, value.terminal, HashSet_.fromIterable, Equal.equals),
     toEquivalence: ([value]) => Equal.makeCompareSet(value),
     toFormatter: ([value]) => t => {
       const size = HashSet_.size(t);
@@ -5859,12 +5776,7 @@ export function Chunk(value) {
       decode: Chunk_.fromIterable,
       encode: Arr.fromIterable
     })),
-    toArbitrary: ([value]) => (fc, ctx) => {
-      return fc.oneof(ctx?.isSuspend ? {
-        maxDepth: 2,
-        depthIdentifier: "Chunk"
-      } : {}, fc.constant([]), fc.array(value, ctx?.constraints?.array)).map(Chunk_.fromIterable);
-    },
+    toArbitrary: ([value]) => (fc, ctx) => collectionArbitrary(fc, ctx, value.arbitrary, value.terminal, Chunk_.fromIterable),
     toEquivalence: ([value]) => Chunk_.makeEquivalence(value),
     toFormatter: ([value]) => t => {
       const size = Chunk_.size(t);
@@ -5963,6 +5875,30 @@ export const URL = /*#__PURE__*/instanceOf(globalThis.URL, {
  * @since 4.0.0
  */
 export const URLFromString = /*#__PURE__*/URLString.pipe(/*#__PURE__*/decodeTo(URL, SchemaTransformation.urlFromString));
+function dateArbitraryConstraints(constraint, ordered, base, toDate) {
+  const out = {
+    ...base
+  };
+  delete out.valid;
+  if (base?.valid || constraint?.valid) {
+    out.noInvalidDate = true;
+  }
+  if (ordered?.minimum !== undefined) {
+    const minimum = toDate === undefined ? ordered.minimum : toDate(ordered.minimum);
+    const nextMin = ordered.exclusiveMinimum ? new globalThis.Date(minimum.getTime() + 1) : minimum;
+    if (out.min === undefined || nextMin.getTime() > out.min.getTime()) {
+      out.min = nextMin;
+    }
+  }
+  if (ordered?.maximum !== undefined) {
+    const maximum = toDate === undefined ? ordered.maximum : toDate(ordered.maximum);
+    const nextMax = ordered.exclusiveMaximum ? new globalThis.Date(maximum.getTime() - 1) : maximum;
+    if (out.max === undefined || nextMax.getTime() < out.max.getTime()) {
+      out.max = nextMax;
+    }
+  }
+  return out;
+}
 const DateString = /*#__PURE__*/String.annotate({
   expected: "a string in ISO 8601 format that will be decoded as a Date"
 });
@@ -6004,7 +5940,7 @@ export const Date = /*#__PURE__*/instanceOf(globalThis.Date, {
   },
   expected: "Date",
   toCodecJson: () => link()(DateString, SchemaTransformation.dateFromString),
-  toArbitrary: () => (fc, ctx) => fc.date(ctx?.constraints?.date)
+  toArbitrary: () => (fc, ctx) => fc.date(dateArbitraryConstraints(ctx?.constraint, ctx?.constraint?.ordered?.order === Order.Date ? ctx.constraint.ordered : undefined))
 });
 /**
  * Schema that decodes a string into a JavaScript `Date`.
@@ -6187,6 +6123,53 @@ export const DurationFromMillis = /*#__PURE__*/Number.check(isGreaterThanOrEqual
 const BigDecimalString = /*#__PURE__*/String.annotate({
   expected: "a string that will be decoded as a BigDecimal"
 });
+const bigDecimalDefaultMaxScale = 20;
+const bigDecimalInvalidOrderedConstraintsError = "Unable to derive an arbitrary for the ordered BigDecimal constraints";
+function bigDecimalScaleValueAtScale(bd, scale) {
+  return BigDecimal_.scale(bd, scale).value;
+}
+function bigDecimalMinValueAtScale(minimum, scale, excluded) {
+  return excluded ? bigDecimalScaleValueAtScale(BigDecimal_.floor(minimum, scale), scale) + globalThis.BigInt(1) : bigDecimalScaleValueAtScale(BigDecimal_.ceil(minimum, scale), scale);
+}
+function bigDecimalMaxValueAtScale(maximum, scale, excluded) {
+  return excluded ? bigDecimalScaleValueAtScale(BigDecimal_.ceil(maximum, scale), scale) - globalThis.BigInt(1) : bigDecimalScaleValueAtScale(BigDecimal_.floor(maximum, scale), scale);
+}
+function bigDecimalMaxScale(ordered) {
+  return Math.max(bigDecimalDefaultMaxScale, ordered.minimum?.scale ?? 0, ordered.maximum?.scale ?? 0, ordered.exclusiveMinimum && ordered.minimum !== undefined ? ordered.minimum.scale + 1 : 0, ordered.exclusiveMaximum && ordered.maximum !== undefined ? ordered.maximum.scale + 1 : 0);
+}
+function bigDecimalValueConstraintsAtScale(ordered, scale) {
+  const constraints = {};
+  if (ordered.minimum !== undefined) {
+    constraints.min = bigDecimalMinValueAtScale(ordered.minimum, scale, ordered.exclusiveMinimum === true);
+  }
+  if (ordered.maximum !== undefined) {
+    constraints.max = bigDecimalMaxValueAtScale(ordered.maximum, scale, ordered.exclusiveMaximum === true);
+  }
+  if (constraints.min !== undefined && constraints.max !== undefined && constraints.min > constraints.max) {
+    return undefined;
+  }
+  return constraints;
+}
+function bigDecimalScaleConstraints(ordered) {
+  const max = bigDecimalMaxScale(ordered);
+  if (bigDecimalValueConstraintsAtScale(ordered, max) === undefined) {
+    throw new globalThis.Error(bigDecimalInvalidOrderedConstraintsError);
+  }
+  let min = 0;
+  let high = max;
+  while (min < high) {
+    const scale = min + Math.floor((high - min) / 2);
+    if (bigDecimalValueConstraintsAtScale(ordered, scale) === undefined) {
+      min = scale + 1;
+    } else {
+      high = scale;
+    }
+  }
+  return {
+    min,
+    max
+  };
+}
 /**
  * Schema for `BigDecimal` values.
  *
@@ -6217,10 +6200,22 @@ export const BigDecimal = /*#__PURE__*/declare(BigDecimal_.isBigDecimal, {
   },
   expected: "BigDecimal",
   toCodecJson: () => link()(BigDecimalString, SchemaTransformation.bigDecimalFromString),
-  toArbitrary: () => fc => fc.tuple(fc.bigInt(), fc.integer({
-    min: 0,
-    max: 20
-  })).map(([value, scale]) => BigDecimal_.make(value, scale)),
+  toArbitrary: () => (fc, ctx) => {
+    const ordered = ctx.constraint?.ordered?.order === BigDecimal_.Order ? ctx.constraint.ordered : undefined;
+    if (ordered === undefined) {
+      return fc.tuple(fc.bigInt(), fc.integer({
+        min: 0,
+        max: bigDecimalDefaultMaxScale
+      })).map(([value, scale]) => BigDecimal_.make(value, scale));
+    }
+    return fc.integer(bigDecimalScaleConstraints(ordered)).chain(scale => {
+      const constraints = bigDecimalValueConstraintsAtScale(ordered, scale);
+      if (constraints === undefined) {
+        throw new globalThis.Error(bigDecimalInvalidOrderedConstraintsError);
+      }
+      return fc.bigInt(constraints).map(value => BigDecimal_.make(value, scale));
+    });
+  },
   toFormatter: () => bd => BigDecimal_.format(bd),
   toEquivalence: () => BigDecimal_.Equivalence
 });
@@ -7017,10 +7012,9 @@ export const DateTimeUtc = /*#__PURE__*/declare(u => DateTime.isDateTime(u) && D
   },
   expected: "DateTime.Utc",
   toCodecJson: () => link()(String, SchemaTransformation.dateTimeUtcFromString),
-  toArbitrary: () => (fc, ctx) => fc.date({
-    noInvalidDate: true,
-    ...ctx?.constraints?.date
-  }).map(date => DateTime.fromDateUnsafe(date)),
+  toArbitrary: () => (fc, ctx) => fc.date(dateArbitraryConstraints(ctx?.constraint, ctx?.constraint?.ordered?.order === DateTime.Order ? ctx.constraint.ordered : undefined, {
+    valid: true
+  }, DateTime.toDateUtc)).map(date => DateTime.fromDateUnsafe(date)),
   toFormatter: () => utc => utc.toString(),
   toEquivalence: () => DateTime.Equivalence
 });
@@ -7243,12 +7237,11 @@ export const DateTimeZoned = /*#__PURE__*/declare(u => DateTime.isDateTime(u) &&
   },
   expected: "DateTime.Zoned",
   toCodecJson: () => link()(DateTimeZonedString, SchemaTransformation.dateTimeZonedFromString),
-  toArbitrary: () => (fc, ctx) => fc.tuple(fc.date({
-    noInvalidDate: true,
-    min: new globalThis.Date(-8640000000000000 + 14 * 60 * 60 * 1000),
+  toArbitrary: () => (fc, ctx) => fc.tuple(fc.date(dateArbitraryConstraints(ctx?.constraint, ctx?.constraint?.ordered?.order === DateTime.Order ? ctx.constraint.ordered : undefined, {
     max: new globalThis.Date(8640000000000000 - 14 * 60 * 60 * 1000),
-    ...ctx?.constraints?.date
-  }), fc.constantFrom("UTC", "Europe/London", "America/New_York", "Asia/Tokyo", "Australia/Sydney")).map(([date, zone]) => DateTime.makeZonedUnsafe(date, {
+    min: new globalThis.Date(-8640000000000000 + 14 * 60 * 60 * 1000),
+    valid: true
+  }, DateTime.toDateUtc)), fc.constantFrom("UTC", "Europe/London", "America/New_York", "Asia/Tokyo", "Australia/Sydney")).map(([date, zone]) => DateTime.makeZonedUnsafe(date, {
     timeZone: zone
   })),
   toFormatter: () => zoned => DateTime.formatIsoZoned(zoned),
@@ -7356,7 +7349,10 @@ function getClassSchemaFactory(from, identifier, annotations) {
         identifier,
         [SchemaAST.ClassTypeId]: ([from]) => new SchemaAST.Link(from, transformation),
         toCodec: ([from]) => new SchemaAST.Link(from.ast, transformation),
-        toArbitrary: ([from]) => () => from.map(args => new self(args)),
+        toArbitrary: ([from]) => () => ({
+          arbitrary: from.arbitrary.map(args => new self(args)),
+          terminal: from.terminal?.map(args => new self(args))
+        }),
         toFormatter: ([from]) => t => `${self.identifier}(${from(t)})`,
         "~sentinels": SchemaAST.collectSentinels(from.ast),
         ...annotations
@@ -7552,7 +7548,10 @@ export const TaggedErrorClass = identifier => {
  *
  * **Details**
  *
- * Prefer {@link toArbitrary} when you just need the arbitrary directly.
+ * Prefer {@link toArbitrary} when you need the arbitrary directly, or when you
+ * want derivation diagnostics via `{ report: true }`. Unsupported schema
+ * nodes, impossible constraints, invalid candidates, and recursive schemas
+ * without a finite terminal path fail immediately.
  *
  * @category Arbitrary
  * @since 4.0.0
@@ -7561,29 +7560,16 @@ export function toArbitraryLazy(schema) {
   const lawc = InternalArbitrary.memoized(schema.ast);
   return fc => lawc(fc, {});
 }
-/**
- * Derives a `fast-check` `Arbitrary` from a schema for property-based
- * testing. The derived arbitrary generates values that satisfy the schema.
- *
- * **Example** (Generating arbitrary values)
- *
- * ```ts
- * import { Schema } from "effect"
- * import * as FastCheck from "fast-check"
- *
- * const PersonArb = Schema.toArbitrary(
- *   Schema.Struct({ name: Schema.String, age: Schema.Number })
- * )
- *
- * // Sample a random value
- * const sample = FastCheck.sample(PersonArb, 1)[0]
- * console.log(typeof sample.name) // "string"
- * ```
- *
- * @category Arbitrary
- * @since 4.0.0
- */
-export function toArbitrary(schema) {
+export function toArbitrary(schema, options) {
+  if (options?.report === true) {
+    const lawc = InternalArbitrary.memoized(schema.ast);
+    const report = InternalArbitrary.makeReport();
+    InternalArbitrary.collectReport(schema.ast, report);
+    return {
+      value: lawc(FastCheck, {}),
+      report: InternalArbitrary.toReport(report)
+    };
+  }
   return toArbitraryLazy(schema)(FastCheck);
 }
 // -----------------------------------------------------------------------------
@@ -7884,7 +7870,7 @@ function toCodecJsonBase(ast, recur) {
       {
         const sortedTypes = InternalSchema.jsonReorder(ast.types);
         if (sortedTypes !== ast.types) {
-          return new SchemaAST.Union(sortedTypes, ast.mode, ast.annotations, ast.checks, ast.encoding, ast.context).recur(recur);
+          return new SchemaAST.Union(sortedTypes, ast.mode, ast.annotations, ast.checks, ast.encoding, ast.context, ast.encodingChecks).recur(recur);
         }
         return ast.recur(recur);
       }
@@ -8095,7 +8081,7 @@ function serializerTree(ast, recur, onMissingAnnotation) {
       {
         const sortedTypes = treeReorder(ast.types);
         if (sortedTypes !== ast.types) {
-          return new SchemaAST.Union(sortedTypes, ast.mode, ast.annotations, ast.checks, ast.encoding, ast.context).recur(recur);
+          return new SchemaAST.Union(sortedTypes, ast.mode, ast.annotations, ast.checks, ast.encoding, ast.context, ast.encodingChecks).recur(recur);
         }
         return ast.recur(recur);
       }