effect 4.0.0-rc.112 → 4.0.0-rc.113

package/src/internal/schema/toJsonSchemaDocument.ts

@@ -1,11 +1,11 @@
 import * as Arr from "../../Array.ts"
 import * as Equal from "../../Equal.ts"
-import { escapeToken, unescapeToken } from "../../JsonPointer.ts"
+import { decodeUriFragment, formatUriFragmentToken, unescapeToken } from "../../JsonPointer.ts"
 import type * as JsonSchema from "../../JsonSchema.ts"
 import { rewriteRefs } from "../../JsonSchema.ts"
 import * as RegEx from "../../RegExp.ts"
 import type * as Schema from "../../Schema.ts"
-import * as SchemaAST from "../../SchemaAST.ts"
+import * as InternalAST from "../../SchemaAST.ts"
 import type * as SchemaRepresentation from "../../SchemaRepresentation.ts"
 import { errorWithPath } from "../errors.ts"
 import * as InternalRecord from "../record.ts"
@@ -16,6 +16,10 @@ type CheckRepresentationAnnotation = SchemaRepresentation.CheckRepresentationAnn
   SchemaRepresentation.Representation
 >
 
+function formatDefinitionReference(key: string): string {
+  return `#/$defs/${formatUriFragmentToken(key)}`
+}
+
 const jsonSchemaAnnotationExcludedKeys = new Set([
   ...InternalAnnotations.annotationExcludedKeys,
   InternalAnnotations.IDENTIFIER_FALLBACK_KEY,
@@ -37,9 +41,9 @@ function collectJsonSchemaAnnotations(
   else if (options?.generateDescriptions === true && typeof expected === "string") out.description = expected
 
   const defaultValue = annotations.default
-  if (SchemaAST.isJson(defaultValue)) out.default = defaultValue
+  if (InternalAST.isJson(defaultValue)) out.default = defaultValue
   const examples = annotations.examples
-  if (Array.isArray(examples) && SchemaAST.isJson(examples)) out.examples = examples
+  if (Array.isArray(examples) && InternalAST.isJson(examples)) out.examples = examples
   const readOnly = annotations.readOnly
   if (typeof readOnly === "boolean") out.readOnly = readOnly
   const writeOnly = annotations.writeOnly
@@ -51,7 +55,7 @@ function collectJsonSchemaAnnotations(
   const contentMediaType = annotations.contentMediaType
   if (typeof contentMediaType === "string") out.contentMediaType = contentMediaType
   const contentSchema = annotations.contentSchema
-  if (SchemaAST.isJson(contentSchema)) out.contentSchema = contentSchema
+  if (InternalAST.isJson(contentSchema)) out.contentSchema = contentSchema
 
   if (options?.includeAnnotationKey !== undefined) {
     for (const [key, value] of Object.entries(annotations)) {
@@ -61,7 +65,7 @@ function collectJsonSchemaAnnotations(
       ) {
         continue
       }
-      if (SchemaAST.isJson(value)) InternalRecord.assignProperty(out, key, value)
+      if (InternalAST.isJson(value)) InternalRecord.assignProperty(out, key, value)
     }
   }
 
@@ -102,8 +106,10 @@ function extractJsonSchemaNumberType(schema: JsonSchema.JsonSchema): {
 }
 
 function isJsonSchemaNumberEncoding(schema: JsonSchema.JsonSchema): boolean {
-  return Array.isArray(schema.anyOf) && schema.anyOf.length === 4 && schema.anyOf[0]?.type === "number" &&
-    schema.anyOf.slice(1).every((member) => member.type === "string")
+  if (!Array.isArray(schema.anyOf) || schema.anyOf.length !== 2 || schema.anyOf[0]?.type !== "number") return false
+  const special = schema.anyOf[1]
+  return special?.type === "string" && Array.isArray(special.enum) && special.enum.length === 3 &&
+    special.enum.includes("NaN") && special.enum.includes("Infinity") && special.enum.includes("-Infinity")
 }
 
 // Keep this allowlist closed: applicators and dependent keywords can change meaning when moved across schema objects.
@@ -172,7 +178,6 @@ function compileJsonSchema(
   const definitionStates = new Map<string, JsonSchema.JsonSchema | string | null>()
   const compiledRepresentations = new WeakMap<SchemaRepresentation.Representation, JsonSchema.JsonSchema>()
   const fallbackDefinitions = new Map<string, Array<string>>()
-  let hasAliases = false
   const referenceKeys = Object.keys(references)
   for (const key of referenceKeys) {
     compileDefinition(key, ["references", key])
@@ -209,7 +214,6 @@ function compileJsonSchema(
         if (candidates === undefined) fallbackDefinitions.set(fallback, [key])
         else candidates.push(key)
       } else {
-        hasAliases = true
         definitionStates.set(key, match)
         return match
       }
@@ -219,12 +223,24 @@ function compileJsonSchema(
   }
 
   function finalizeJsonSchema(schema: JsonSchema.JsonSchema): JsonSchema.JsonSchema {
-    if (!hasAliases) return schema
-    return rewriteRefs(schema, ($ref) =>
-      $ref.replace(/^#\/\$defs\/([^/]*)/, (match, token) => {
-        const canonical = definitionStates.get(unescapeToken(token))
-        return typeof canonical === "string" ? `#/$defs/${escapeToken(canonical)}` : match
-      }))
+    return rewriteRefs(schema, ($ref) => {
+      const pointer = decodeUriFragment($ref)
+      if (pointer === undefined) {
+        if (/^#(?:\/|%2f)/i.test($ref)) {
+          throw new Error(`Invalid JSON Pointer URI fragment ${JSON.stringify($ref)}`)
+        }
+        return $ref
+      }
+      if (!pointer.startsWith("/$defs/")) return $ref
+      const separator = pointer.indexOf("/", 7)
+      const canonical = definitionStates.get(unescapeToken(pointer.slice(7, separator < 0 ? undefined : separator)))
+      if (typeof canonical !== "string") return $ref
+      // URI-encoded slashes separate pointer tokens; only ~1 represents a slash within a token.
+      return $ref.replace(
+        /^#(?:\/|%2f).*?(?:\/|%2f).*?(?=\/|%2f|$)/i,
+        formatDefinitionReference(canonical)
+      )
+    })
   }
 
   function getIdentifierFallback(
@@ -283,7 +299,7 @@ function compileJsonSchema(
   ): JsonSchema.JsonSchema {
     if (representation._tag === "Reference") {
       const canonical = compileDefinition(representation.$ref, path)
-      return { $ref: `#/$defs/${escapeToken(canonical)}` }
+      return { $ref: formatDefinitionReference(canonical) }
     }
     const cached = compiledRepresentations.get(representation)
     if (cached !== undefined) return cached
@@ -321,8 +337,11 @@ function compileJsonSchema(
       case "BigInt":
         return { type: "string", allOf: [{ pattern: "^-?\\d+$" }] }
       case "Symbol":
+        return { type: "string", allOf: [{ pattern: "^Symbol\\(([\\s\\S]*)\\)$" }] }
       case "UniqueSymbol":
-        return { type: "string", allOf: [{ pattern: "^Symbol\\((.*)\\)$" }] }
+        return globalThis.Symbol.keyFor(representation.symbol) === undefined
+          ? { not: {} }
+          : { type: "string", enum: [globalThis.String(representation.symbol)] }
       case "Declaration": {
         return {}
       }
@@ -336,9 +355,7 @@ function compileJsonSchema(
         return {
           anyOf: [
             { type: "number" },
-            { type: "string", enum: ["NaN"] },
-            { type: "string", enum: ["Infinity"] },
-            { type: "string", enum: ["-Infinity"] }
+            { type: "string", enum: ["NaN", "Infinity", "-Infinity"] }
           ]
         }
       case "Boolean":
@@ -350,11 +367,15 @@ function compileJsonSchema(
           : { type: typeof literal, enum: [literal] }
       }
       case "Enum": {
-        const types = representation.enums.map(([title, literal]) =>
-          typeof literal === "number" && !globalThis.Number.isFinite(literal)
-            ? { type: "string", enum: [globalThis.String(literal)], title }
-            : { type: typeof literal, enum: [literal], title }
-        )
+        const types = representation.enums.map(([title, literal], index) => {
+          if (typeof literal === "number" && !globalThis.Number.isFinite(literal)) {
+            throw errorWithPath(
+              `Invalid numeric enum value ${globalThis.String(literal)}`,
+              [...path, "enums", index, 1]
+            )
+          }
+          return { type: typeof literal, enum: [literal], title }
+        })
         return types.length === 0 ? { not: {} } : { anyOf: types }
       }
       case "TemplateLiteral":
@@ -388,7 +409,7 @@ function compileJsonSchema(
       }
       case "Objects": {
         if (representation.propertySignatures.length === 0 && representation.indexSignatures.length === 0) {
-          return { anyOf: [{ type: "object" }, { type: "array" }] }
+          return { not: { type: "null" } }
         }
         const out: JsonSchema.JsonSchema = { type: "object" }
         const properties: Record<string, JsonSchema.JsonSchema> = {}
@@ -416,21 +437,28 @@ function compileJsonSchema(
         if (representation.propertySignatures.length > 0) out.properties = properties
         if (required.length > 0) out.required = required
         const patternProperties: Record<string, JsonSchema.JsonSchema | false> = {}
-        const additionalProperties: Array<JsonSchema.JsonSchema | false> = []
+        const additionalPropertySchemas: Array<JsonSchema.JsonSchema | false> = []
+        const indexValueSchemas: Array<JsonSchema.JsonSchema | false> = []
+        let hasUnrepresentableIndexPattern = false
         for (let index = 0; index < representation.indexSignatures.length; index++) {
           const signature = representation.indexSignatures[index]
           let type: JsonSchema.JsonSchema | false = recur(
             signature.type,
             [...path, "indexSignatures", index, "type"]
           )
-          if (Object.keys(type).length === 1 && "not" in type) type = false
+          if (Equal.equals(type, { not: {} })) type = false
+          indexValueSchemas.push(type)
           const patterns = getParameterPatterns(
             signature.parameter,
             [...path, "indexSignatures", index, "parameter"],
             new Set()
           )
+          if (patterns === undefined) {
+            hasUnrepresentableIndexPattern = true
+            continue
+          }
           if (patterns.length === 0) {
-            additionalProperties.push(type)
+            additionalPropertySchemas.push(type)
           } else {
             for (const pattern of patterns) {
               const previous = patternProperties[pattern]
@@ -450,16 +478,36 @@ function compileJsonSchema(
         if (hasPatternProperties) {
           out.patternProperties = patternProperties
         }
-        if (representation.indexSignatures.length === 0) {
-          out.additionalProperties = options?.additionalProperties ?? false
+        if (hasUnrepresentableIndexPattern && options?.onExcessProperty === "error") {
+          const propertyNames: Array<JsonSchema.JsonSchema> = []
+          if (representation.propertySignatures.length > 0) {
+            propertyNames.push({ enum: Object.keys(properties) })
+          }
+          for (let index = 0; index < representation.indexSignatures.length; index++) {
+            propertyNames.push(
+              recur(
+                representation.indexSignatures[index].parameter,
+                [...path, "indexSignatures", index, "parameter"]
+              )
+            )
+          }
+          out.propertyNames = propertyNames.length === 1 ? propertyNames[0] : { anyOf: propertyNames }
+          out.additionalProperties = indexValueSchemas.length === 1
+            ? indexValueSchemas[0]
+            : { anyOf: indexValueSchemas }
+          if (additionalPropertySchemas.length > 0) {
+            out.allOf = additionalPropertySchemas.map((type) => ({ type: "object", additionalProperties: type }))
+          }
+        } else if (additionalPropertySchemas.length === 0) {
+          out.additionalProperties = hasUnrepresentableIndexPattern || options?.onExcessProperty !== "error"
         } else if (
-          additionalProperties.length === 1 &&
+          additionalPropertySchemas.length === 1 &&
           representation.propertySignatures.length === 0 &&
           !hasPatternProperties
         ) {
-          out.additionalProperties = additionalProperties[0]
-        } else if (additionalProperties.length > 0) {
-          out.allOf = additionalProperties.map((type) => ({ type: "object", additionalProperties: type }))
+          out.additionalProperties = additionalPropertySchemas[0]
+        } else if (additionalPropertySchemas.length > 0) {
+          out.allOf = additionalPropertySchemas.map((type) => ({ type: "object", additionalProperties: type }))
         }
         if (
           typeof out.additionalProperties === "object" &&
@@ -473,11 +521,12 @@ function compileJsonSchema(
       case "Union": {
         const types = representation.types.map((type, index) => recur(type, [...path, "types", index]))
         if (types.length === 0) return { not: {} }
-        if (representation.mode === "anyOf" && types.length > 1) {
+        const mode = representation.options?.mode ?? "anyOf"
+        if (mode === "anyOf" && types.length > 1) {
           const compacted = compactEnums(types)
           if (compacted !== undefined) return compacted
         }
-        return representation.mode === "anyOf" ? { anyOf: types } : { oneOf: types }
+        return mode === "anyOf" ? { anyOf: types } : { oneOf: types }
       }
     }
   }
@@ -486,25 +535,47 @@ function compileJsonSchema(
     parameter: SchemaRepresentation.Representation,
     path: Path,
     seenReferences: ReadonlySet<string>
-  ): ReadonlyArray<string> {
+  ): ReadonlyArray<string> | undefined {
     switch (parameter._tag) {
       case "Reference": {
         if (!Object.hasOwn(references, parameter.$ref)) {
           throw errorWithPath(`Invalid reference ${parameter.$ref}`, [...path, "$ref"])
         }
         compileDefinition(parameter.$ref, path)
-        if (seenReferences.has(parameter.$ref)) return []
+        if (seenReferences.has(parameter.$ref)) return undefined
         const next = new Set(seenReferences).add(parameter.$ref)
         return getParameterPatterns(references[parameter.$ref], ["references", parameter.$ref], next)
       }
-      case "String":
-        return collectPatterns(recur(parameter, path))
+      case "String": {
+        if (parameter.checks.length === 0) return []
+        if (
+          parameter.checks.length !== 1 ||
+          parameter.checks[0]._tag !== "Filter" ||
+          parameter.checks[0].annotations?.toJsonSchema === undefined
+        ) {
+          return undefined
+        }
+        const schema = recur(parameter, path)
+        return schema.type === "string" && typeof schema.pattern === "string" &&
+            hasOnlyKeywords(schema, "|type|pattern|title|description|default|examples|readOnly|writeOnly|")
+          ? [schema.pattern]
+          : undefined
+      }
       case "TemplateLiteral":
-        return [`^${parameter.parts.map(getPartPattern).join("")}$`]
-      case "Union":
-        return parameter.types.flatMap((type, index) =>
-          getParameterPatterns(type, [...path, "types", index], seenReferences)
-        )
+        return parameter.checks.length === 0 ? [`^${parameter.parts.map(getPartPattern).join("")}$`] : undefined
+      case "Union": {
+        if (parameter.types.length === 0 || parameter.checks.length > 0 || parameter.options?.mode === "oneOf") {
+          return undefined
+        }
+        const patterns: Array<string> = []
+        for (let index = 0; index < parameter.types.length; index++) {
+          const memberPatterns = getParameterPatterns(parameter.types[index], [...path, "types", index], seenReferences)
+          if (memberPatterns === undefined) return undefined
+          if (memberPatterns.length === 0) return []
+          patterns.push(...memberPatterns)
+        }
+        return patterns
+      }
       default:
         throw errorWithPath("Invalid schema representation document", path)
     }
@@ -528,25 +599,12 @@ function compactEnums(
     }
     if (sharedType === undefined) sharedType = schema.type
     else if (schema.type !== sharedType) return undefined
-    values.push(...schema.enum)
-  }
-  return { type: sharedType, enum: values }
-}
-
-function collectPatterns(schema: JsonSchema.JsonSchema): ReadonlyArray<string> {
-  const patterns: Array<string> = []
-  if (typeof schema.pattern === "string") patterns.push(schema.pattern)
-  for (const key of ["allOf", "anyOf", "oneOf"] as const) {
-    const members = schema[key]
-    if (Array.isArray(members)) {
-      for (const member of members) {
-        if (typeof member === "object" && member !== null && !Array.isArray(member)) {
-          patterns.push(...collectPatterns(member))
-        }
-      }
+    for (const value of schema.enum) {
+      if (values.includes(value)) return undefined
+      values.push(value)
     }
   }
-  return patterns
+  return { type: sharedType, enum: values }
 }
 
 function getPartPattern(part: SchemaRepresentation.Representation): string {
@@ -554,13 +612,13 @@ function getPartPattern(part: SchemaRepresentation.Representation): string {
     case "Literal":
       return RegEx.escape(globalThis.String(part.literal))
     case "String":
-      return SchemaAST.STRING_PATTERN
+      return InternalAST.STRING_PATTERN
     case "Number":
-      return SchemaAST.FINITE_PATTERN
+      return InternalAST.FINITE_PATTERN
     case "TemplateLiteral":
       return part.parts.map(getPartPattern).join("")
     case "Union":
-      return part.types.map(getPartPattern).join("|")
+      return `(?:${part.types.map(getPartPattern).join("|")})`
     default:
       throw errorWithPath("Invalid schema representation document", [])
   }

package/src/internal/schema/toRepresentation.ts

@@ -283,7 +283,7 @@ export function toRepresentations(
         return {
           _tag: "Union",
           types: ast.types.map((ast) => recur(ast)),
-          mode: ast.mode,
+          ...(ast.options === undefined ? {} : { options: ast.options }),
           checks,
           ...annotationsField(ast.annotations)
         }

package/src/internal/schemaError.ts

@@ -0,0 +1,8 @@
+import * as Predicate from "../Predicate.ts"
+import type { SchemaError } from "../Schema.ts"
+
+export const SchemaErrorTypeId = "~effect/Schema/SchemaError"
+
+export function isSchemaError(u: unknown): u is SchemaError {
+  return Predicate.hasProperty(u, SchemaErrorTypeId) && u[SchemaErrorTypeId] === SchemaErrorTypeId
+}

package/src/internal/stream.ts

@@ -12,17 +12,25 @@ const streamVariance = {
   _A: identity
 }
 
-const StreamProto = {
+const Stream: {
+  new<A extends Arr.NonEmptyReadonlyArray<any>, E, R>(
+    channel: Channel.Channel<A, E, void, unknown, unknown, unknown, R>
+  ): Stream<A extends Arr.NonEmptyReadonlyArray<infer A> ? A : never, E, R>
+} = function<A extends Arr.NonEmptyReadonlyArray<any>, E, R>(
+  this: any,
+  channel: Channel.Channel<A, E, void, unknown, unknown, unknown, R>
+) {
+  this.channel = channel
+} as any
+
+Stream.prototype = {
   [TypeId]: streamVariance,
   pipe() {
     return pipeArguments(this, arguments)
   }
 }
+
 /** @internal */
 export const fromChannel = <A extends Arr.NonEmptyReadonlyArray<any>, E, R>(
   channel: Channel.Channel<A, E, void, unknown, unknown, unknown, R>
-): Stream<A extends Arr.NonEmptyReadonlyArray<infer A> ? A : never, E, R> => {
-  const self = Object.create(StreamProto)
-  self.channel = channel
-  return self
-}
+): Stream<A extends Arr.NonEmptyReadonlyArray<infer A> ? A : never, E, R> => new Stream(channel)

package/src/internal/tracer.ts

@@ -1,6 +1,7 @@
 import type * as Tracer from "../Tracer.ts"
 import { getStackTraceLimit, setStackTraceLimit } from "./stackTraceLimit.ts"
 
+/** @internal */
 export interface ErrorWithStackTraceLimit {
   stackTraceLimit?: number | undefined
 }
@@ -15,6 +16,9 @@ export const addSpanStackTrace = <A extends Tracer.TraceOptions>(
     return options
   }
   const limit = getStackTraceLimit()
+  if (limit === 0 && options?.captureStackTrace !== true) {
+    return { ...options, captureStackTrace: false } as A
+  }
   setStackTraceLimit(3)
   const traceError = new Error()
   setStackTraceLimit(limit)

package/src/internal/trie.ts

@@ -12,7 +12,7 @@ import type * as TR from "../Trie.ts"
 import type { NoInfer } from "../Types.ts"
 
 /** @internal */
-export const TrieTypeId = "~effect/collections/Trie"
+export const TrieTypeId = "~effect/Trie"
 
 type TraversalMap<K, V, A> = (k: K, v: V) => A
 
@@ -516,7 +516,10 @@ export const remove = dual<
       const n2 = nStack[s]
       const d = dStack[s]
       const child = nStack[s + 1]
-      const nc = child.left === undefined && child.mid === undefined && child.right === undefined ? undefined : child
+      const nc =
+        child.value === undefined && child.left === undefined && child.mid === undefined && child.right === undefined
+          ? undefined
+          : child
       if (d === -1) {
         // left
         nStack[s] = {

package/src/internal/uuid.ts

@@ -17,7 +17,9 @@ const randomBytes = (): Uint8Array<ArrayBuffer> => globalThis.crypto.getRandomVa
 
 /** @internal */
 export function v4Bytes(): Uint8Array<ArrayBuffer>
+/** @internal */
 export function v4Bytes<A extends ArrayBufferLike>(bytes: Uint8Array<A>): Uint8Array<A>
+/** @internal */
 export function v4Bytes(bytes: Uint8Array = randomBytes()): Uint8Array {
   bytes[6] = (bytes[6] & 0x0f) | 0x40
   bytes[8] = (bytes[8] & 0x3f) | 0x80
@@ -31,7 +33,9 @@ const maxV7Timestamp = 2 ** 48 - 1
 
 /** @internal */
 export function v7Bytes(timestampMillis: number): Uint8Array<ArrayBuffer>
+/** @internal */
 export function v7Bytes<A extends ArrayBufferLike>(timestampMillis: number, bytes: Uint8Array<A>): Uint8Array<A>
+/** @internal */
 export function v7Bytes(timestampMillis: number, bytes: Uint8Array = randomBytes()): Uint8Array {
   const timestamp = Math.min(Math.max(0, Math.trunc(timestampMillis)), maxV7Timestamp)
 

package/src/testing/TestSchema.ts

@@ -10,16 +10,21 @@
  * @since 4.0.0
  */
 import * as assert from "node:assert"
+import { isDeepStrictEqual } from "node:util"
 import type * as Context from "../Context.ts"
 import * as Effect from "../Effect.ts"
 import { pipe } from "../Function.ts"
-import * as Record from "../Record.ts"
 import * as Result from "../Result.ts"
 import * as Schema from "../Schema.ts"
 import * as SchemaAST from "../SchemaAST.ts"
 import * as SchemaIssue from "../SchemaIssue.ts"
 import * as SchemaParser from "../SchemaParser.ts"
-import * as FastCheck from "../testing/FastCheck.ts"
+import * as Arbitrary from "../unstable/arbitrary/Arbitrary.ts"
+
+function assertPropertyPassed<A, E>(result: Arbitrary.CheckResult<A, E>): void {
+  const failure = Arbitrary.formatCheckFailure(result)
+  if (failure !== undefined) assert.fail(failure)
+}
 
 /**
  * Provides schema test assertions for decoding, encoding, make, arbitrary generation, and round-trip verification.
@@ -76,7 +81,10 @@ export class Asserts<S extends Schema.Constraint> {
   static ast = {
     fields: {
       equals: (a: Schema.Struct.Fields, b: Schema.Struct.Fields) => {
-        assert.deepStrictEqual(Record.map(a, SchemaAST.getAST), Record.map(b, SchemaAST.getAST))
+        assert.deepStrictEqual(
+          Object.fromEntries(Reflect.ownKeys(a).map((key) => [key, SchemaAST.getAST(a[key])])),
+          Object.fromEntries(Reflect.ownKeys(b).map((key) => [key, SchemaAST.getAST(b[key])]))
+        )
       }
     },
     elements: {
@@ -153,7 +161,8 @@ export class Asserts<S extends Schema.Constraint> {
    *
    * **Details**
    *
-   * FastCheck generates arbitrary values matching the schema's `Type`. The assertion fails if any generated value does not round-trip. Pass `options.params` to control FastCheck parameters such as `numRuns`.
+   * The native Schema arbitrary generates values matching the schema's `Type`. The assertion fails with the minimized
+   * shrunk input and replay token if any generated value does not round-trip.
    *
    * **Example** (Verifying round trips)
    *
@@ -162,30 +171,29 @@ export class Asserts<S extends Schema.Constraint> {
    * import { TestSchema } from "effect/testing"
    *
    * const asserts = new TestSchema.Asserts(Schema.String)
-   * await asserts.verifyLosslessTransformation({ params: { seed: 1, numRuns: 20 } }) // => undefined
+   * await asserts.verifyLosslessTransformation({ seed: 1, runs: 20 }) // => undefined
    * ```
    *
    * @see {@link arbitrary} for checking that generated values satisfy the schema
    */
-  verifyLosslessTransformation<S extends Schema.ConstraintCodec<unknown, unknown>>(this: Asserts<S>, options?: {
-    readonly params?: FastCheck.Parameters<[S["Type"]]>
-  }) {
+  verifyLosslessTransformation<S extends Schema.ConstraintCodec<unknown, unknown>>(
+    this: Asserts<S>,
+    options?: Arbitrary.CheckOptions
+  ): Promise<void> {
     const decodeUnknownEffect = SchemaParser.decodeUnknownEffect(this.schema)
     const encodeEffect = SchemaParser.encodeEffect(this.schema)
-    const arbitrary = Schema.toArbitrary(this.schema)(FastCheck)
-    return FastCheck.assert(
-      FastCheck.asyncProperty(arbitrary, async (t) => {
-        const r = await Effect.runPromise(
-          encodeEffect(t).pipe(
-            Effect.flatMapEager((e) => decodeUnknownEffect(e)),
-            Effect.mapErrorEager(SchemaIssue.defaultFormatter),
-            Effect.result
-          )
-        )
-        assert.deepStrictEqual(r, Result.succeed(t))
-      }),
-      options?.params
-    )
+    const arbitrary = Arbitrary.schema(this.schema)
+    return Effect.runPromise(Arbitrary.checkEffect(
+      arbitrary,
+      (value) =>
+        encodeEffect(value).pipe(
+          Effect.flatMapEager((encoded) => decodeUnknownEffect(encoded)),
+          Effect.mapErrorEager(SchemaIssue.defaultFormatter),
+          Effect.result,
+          Effect.mapEager((result) => isDeepStrictEqual(result, Result.succeed(value)))
+        ),
+      options
+    )).then(assertPropertyPassed)
   }
   /**
    * Returns a {@link Decoding} instance for this schema with helpers for decoding assertions.
@@ -258,7 +266,8 @@ export class Asserts<S extends Schema.Constraint> {
    *
    * **Details**
    *
-   * `verifyGeneration()` generates arbitrary values and asserts each value satisfies the schema's `is` predicate. It defaults to 20 runs. Pass `options.params` to override FastCheck parameters.
+   * `verifyGeneration()` generates arbitrary values and asserts each value satisfies the schema's `is` predicate. It
+   * defaults to 20 runs. Native checking options can control generation, shrinking, bounded discards, and replay.
    *
    * **Example** (Verifying arbitrary generation)
    *
@@ -267,7 +276,7 @@ export class Asserts<S extends Schema.Constraint> {
    * import { TestSchema } from "effect/testing"
    *
    * const asserts = new TestSchema.Asserts(Schema.String)
-   * asserts.arbitrary().verifyGeneration({ params: { seed: 1, numRuns: 20 } }) // => undefined
+   * asserts.arbitrary().verifyGeneration({ seed: 1, runs: 20 }) // => undefined
    * ```
    *
    * @see {@link verifyLosslessTransformation} for property-based round-trip checks
@@ -275,13 +284,10 @@ export class Asserts<S extends Schema.Constraint> {
   arbitrary<S extends Schema.ConstraintCodec<unknown, unknown>>(this: Asserts<S>) {
     const schema = this.schema
     return {
-      verifyGeneration(options?: {
-        readonly params?: FastCheck.Parameters<[S["Type"]]> | undefined
-      }) {
-        const params = options?.params
+      verifyGeneration(options?: Arbitrary.CheckOptions): void {
         const is = Schema.is(schema)
-        const arb = Schema.toArbitrary(schema)(FastCheck)
-        FastCheck.assert(FastCheck.property(arb, (a) => is(a)), { numRuns: 20, ...params })
+        const arbitrary = Arbitrary.schema(schema)
+        assertPropertyPassed(Effect.runSync(Arbitrary.checkEffect(arbitrary, is, { runs: 20, ...options })))
       }
     }
   }

package/src/testing/index.ts

@@ -4,11 +4,6 @@
 
 // @barrel: Auto-generated exports. Do not edit manually.
 
-/**
- * @since 3.10.0
- */
-export * as FastCheck from "./FastCheck.ts"
-
 /**
  * @since 2.0.0
  */