effect 4.0.0-beta.102 → 4.0.0-beta.103

package/src/Schema.ts

@@ -19,7 +19,6 @@ import * as BigDecimal_ from "./BigDecimal.ts"
 import type * as Brand from "./Brand.ts"
 import * as Cause_ from "./Cause.ts"
 import * as Chunk_ from "./Chunk.ts"
-import type * as Combiner from "./Combiner.ts"
 import * as Data from "./Data.ts"
 import * as DateTime from "./DateTime.ts"
 import type { Differ } from "./Differ.ts"
@@ -449,8 +448,8 @@ export interface declareConstructor<T, E, TypeParameters extends ReadonlyArray<C
  *
  * **Example** (Schema for a parametric `Box<A>` type)
  *
- * ```ts
- * import { Effect, Option, Schema, SchemaIssue as Issue, SchemaParser } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, Schema, SchemaIssue as Issue, SchemaParser } from "effect"
  *
  * interface Box<A> {
  *   readonly value: A
@@ -465,7 +464,7 @@ export interface declareConstructor<T, E, TypeParameters extends ReadonlyArray<C
  *     ([itemCodec]) =>
  *       (u, ast, options) => {
  *         if (!isBox(u)) {
- *           return Effect.fail(new SchemaIssue.InvalidType(ast, Option.some(u)))
+ *           return Effect.fail(new SchemaIssue.InvalidType(ast))
  *         }
  *         return Effect.map(
  *           SchemaParser.decodeUnknownEffect(itemCodec)(u.value, options),
@@ -475,6 +474,7 @@ export interface declareConstructor<T, E, TypeParameters extends ReadonlyArray<C
  *   )
  *
  * const schema = Box(Schema.Number)
+ * Effect.runSync(Schema.decodeUnknownEffect(schema)({ value: 1 })) // => { value: 1 }
  * ```
  *
  * @category constructors
@@ -526,7 +526,7 @@ export interface declare<T, Iso = T> extends declareConstructor<T, T, readonly [
  *
  * **Example** (Defining a schema for a custom `UserId` branded type)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * type UserId = string & { readonly _tag: "UserId" }
@@ -538,6 +538,7 @@ export interface declare<T, Iso = T> extends declareConstructor<T, T, readonly [
  *   title: "UserId",
  *   description: "A user identifier starting with 'user_'"
  * })
+ * Schema.decodeUnknownSync(UserId)("user_123") // => "user_123"
  * ```
  *
  * @see {@link declareConstructor} for creating schemas for parametric types.
@@ -554,7 +555,7 @@ export function declare<T, Iso = T>(
     () => (input, ast) =>
       is(input) ?
         Effect.succeed(input) :
-        Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input))),
+        Effect.fail(new SchemaIssue.InvalidType(ast)),
     annotations
   )
 }
@@ -571,7 +572,7 @@ export function declare<T, Iso = T>(
  *
  * **Example** (Inspecting all type parameters of a schema)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.String
@@ -622,7 +623,7 @@ export function revealBottom<S extends Top>(
  *
  * **Example** (Adding a title and description)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const Age = Schema.Natural.pipe(
@@ -631,6 +632,7 @@ export function revealBottom<S extends Top>(
  *     description: "A non-negative integer representing age in years"
  *   })
  * )
+ * Schema.resolveAnnotations(Age)?.title // => "Age"
  * ```
  *
  * @see {@link annotateEncoded} to annotate the encoded side instead.
@@ -654,7 +656,7 @@ export function annotate<S extends Top>(annotations: Annotations.Bottom<S["Type"
  *
  * **Example** (Adding a title to the encoded representation)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.NumberFromString.pipe(
@@ -663,8 +665,7 @@ export function annotate<S extends Top>(annotations: Annotations.Bottom<S["Type"
  *   })
  * )
  *
- * console.log(Schema.toEncoded(schema).ast.annotations?.title)
- * // "my title"
+ * Schema.toEncoded(schema).ast.annotations?.title // => "my title"
  * ```
  *
  * @see {@link annotate} to annotate the type side instead.
@@ -690,7 +691,7 @@ export function annotateEncoded<S extends Top>(annotations: Annotations.Bottom<S
  *
  * **Example** (Customizing the missing-key message for a required field)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.Struct({
@@ -701,6 +702,7 @@ export function annotateEncoded<S extends Top>(annotations: Annotations.Bottom<S
  *     })
  *   )
  * })
+ * schema.fields.username.ast.context?.annotations?.messageMissingKey // => "Username is required"
  * ```
  *
  * @category annotations
@@ -882,7 +884,7 @@ export declare namespace Schema {
    *
    * **Example** (Extracting the decoded type)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Schema } from "effect"
    *
    * const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
@@ -911,13 +913,13 @@ export declare namespace Schema {
  *
  * **Example** (Accepting any schema decoding to `string`)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
- * declare function print(schema: Schema.Schema<string>): void
+ * const accept = (_schema: Schema.Schema<string>): void => {}
  *
- * print(Schema.String)            // ok
- * print(Schema.NonEmptyString)    // ok
+ * accept(Schema.String)
+ * accept(Schema.NonEmptyString)
  * ```
  *
  * @see {@link Codec} — also tracks Encoded, DecodingServices, EncodingServices
@@ -942,7 +944,7 @@ export declare namespace Codec {
    *
    * **Example** (Extracting the encoded type)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Schema } from "effect"
    *
    * const schema = Schema.NumberFromString
@@ -960,7 +962,7 @@ export declare namespace Codec {
    *
    * **Example** (Checking decoding service requirements)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Schema } from "effect"
    *
    * const schema = Schema.String
@@ -978,7 +980,7 @@ export declare namespace Codec {
    *
    * **Example** (Checking encoding service requirements)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Schema } from "effect"
    *
    * const schema = Schema.String
@@ -1009,12 +1011,13 @@ export declare namespace Codec {
  *
  * **Example** (Accepting a codec that decodes to `number` from `string`)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
- * declare function serialize<T>(codec: Schema.Codec<T, string>): string
+ * const serialize = <T>(codec: Schema.Codec<T, string>, value: T): string =>
+ *   Schema.encodeSync(codec)(value)
  *
- * serialize(Schema.NumberFromString) // ok — decodes number, encoded as string
+ * serialize(Schema.NumberFromString, 42) // => "42"
  * ```
  *
  * @see {@link Codec.Encoded} — extract the encoded type
@@ -1090,7 +1093,7 @@ export interface Encoder<out E, out RE = never> extends Schema<unknown> {
  *
  * **Example** (Recovering encoded type from a schema variable)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema: Schema.Schema<number> = Schema.NumberFromString
@@ -1136,18 +1139,14 @@ export {
   /**
    * Returns `true` if `u` is a {@link SchemaError}.
    *
-   * **Example** (Narrowing Schema errors in a catch block)
+   * **Example** (Narrowing Schema errors)
    *
-   * ```ts
-   * import { Schema } from "effect"
+   * ```ts import.meta.vitest
+   * import { Result, Schema } from "effect"
    *
-   * try {
-   *   Schema.decodeUnknownSync(Schema.Number)("oops")
-   * } catch (err) {
-   *   if (Schema.isSchemaError(err)) {
-   *     console.log(err._tag) // "SchemaError"
-   *   }
-   * }
+   * const result = Result.try(() => Schema.decodeUnknownSync(Schema.Number)("oops"))
+   * const error: unknown = Result.isFailure(result) ? result.failure : undefined
+   * Schema.isSchemaError(error) // => true
    * ```
    *
    * @category guards
@@ -1161,25 +1160,22 @@ export {
    * **Details**
    *
    * The `issue` field contains a structured {@link SchemaIssue.Issue} tree describing
-   * every validation failure, including the path to the problematic value,
-   * expected types, and actual values received. `message` renders the issue tree
-   * as a human-readable string.
+   * every validation failure, including the path to the problematic value and
+   * the expected type or constraint. Built-in issues have no `actual` field,
+   * and built-in messages do not include the rejected value. Other Issue fields
+   * and custom annotations or messages are not sanitized. `message` renders the
+   * issue tree as a human-readable string.
    *
    * Use {@link isSchemaError} to narrow an unknown value to `SchemaError`.
    *
-   * **Example** (Catching a SchemaError)
+   * **Example** (Inspecting a SchemaError)
    *
-   * ```ts
-   * import { Schema } from "effect"
+   * ```ts import.meta.vitest
+   * import { Result, Schema } from "effect"
    *
-   * try {
-   *   Schema.decodeUnknownSync(Schema.Number)("not a number")
-   * } catch (err) {
-   *   if (Schema.isSchemaError(err)) {
-   *     console.log(err.message)
-   *     // Expected number, actual "not a number"
-   *   }
-   * }
+   * const result = Schema.decodeUnknownResult(Schema.Number)("not a number")
+   * const message = Result.isFailure(result) ? result.failure.message : ""
+   * message // => "Expected number"
    * ```
    *
    * @category errors
@@ -1207,7 +1203,7 @@ function makeStandardResult<A>(exit: Exit_.Exit<StandardSchemaV1.Result<A>>): St
  *
  * **Example** (Creating a standard schema from a regular schema)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * // Define custom hook functions for error formatting
@@ -1245,16 +1241,21 @@ function makeStandardResult<A>(exit: Exit_.Exit<StandardSchemaV1.Result<A>>): St
  *   name: "Alice",
  *   age: 30
  * })
- * console.log(validResult) // { value: { name: "Alice", age: 30 } }
- *
  * const invalidResult = standardSchema["~standard"].validate({
  *   name: "",
  *   age: 200
  * })
- * console.log(invalidResult) // { issues: [{ path: ["name"], message: "..." }, { path: ["age"], message: "..." }] }
+ *
+ * if (validResult instanceof Promise || invalidResult instanceof Promise) {
+ *   throw new Error("Expected synchronous validation")
+ * }
+ * if ("value" in validResult) {
+ *   validResult.value // => { name: "Alice", age: 30 }
+ * }
+ * invalidResult.issues?.map((issue) => issue.path) // => [["name"], ["age"]]
  * ```
  *
- * @category Standard Schema
+ * @category converting
  * @since 4.0.0
  */
 export function toStandardSchemaV1<S extends ConstraintDecoder<unknown>>(
@@ -1272,7 +1273,7 @@ export function toStandardSchemaV1<S extends ConstraintDecoder<unknown>>(
   const parseOptions: SchemaAST.ParseOptions = { errors: "all", ...options?.parseOptions }
   const formatter = SchemaIssue.makeFormatterStandardSchemaV1(options)
   const validate: StandardSchemaV1<S["Encoded"], S["Type"]>["~standard"]["validate"] = (value: unknown) => {
-    const scheduler = new Scheduler.MixedScheduler()
+    const scheduler = new Scheduler.MixedScheduler("sync")
     const fiber = Effect.runFork(
       Effect.match(decodeUnknownEffect(value, parseOptions), {
         onFailure: formatter,
@@ -1333,7 +1334,7 @@ function toBaseStandardJSONSchemaV1(self: Constraint, target: StandardJSONSchema
  *
  * https://github.com/standard-schema/standard-schema/pull/134
  *
- * @category Standard Schema
+ * @category converting
  * @since 4.0.0
  */
 export function toStandardJSONSchemaV1<S extends Constraint>(
@@ -1381,19 +1382,19 @@ export function toStandardJSONSchemaV1<S extends Constraint>(
  *
  * **Example** (Defining a basic type guard)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const isString = Schema.is(Schema.String)
  *
- * console.log(isString("hello")) // true
- * console.log(isString(42)) // false
+ * isString("hello") // => true
+ * isString(42) // => false
  *
  * // Type narrowing in action
  * const value: unknown = "hello"
  * if (isString(value)) {
  *   // value is now typed as string
- *   console.log(value.toUpperCase()) // "HELLO"
+ *   value.toUpperCase() // => "HELLO"
  * }
  * ```
  *
@@ -1424,21 +1425,23 @@ export const is = SchemaParser.is
  *
  * **Example** (Asserting and narrowing an input)
  *
- * ```ts
- * import { Schema } from "effect"
+ * ```ts import.meta.vitest
+ * import { Schema, SchemaIssue } from "effect"
  *
  * const input: unknown = "hello"
  *
  * // This will pass silently (no return value) and narrow input to string
  * Schema.asserts(Schema.String, input)
- * console.log(input.toUpperCase())
+ * input.toUpperCase() // => "HELLO"
  *
  * // This will throw an error
  * try {
  *   const invalid: unknown = 123
  *   Schema.asserts(Schema.String, invalid)
  * } catch (error) {
- *   console.log("Non-string assertion failed as expected")
+ *   if (error instanceof Error) {
+ *     SchemaIssue.isIssue(error.cause) // => true
+ *   }
  * }
  * ```
  *
@@ -1585,7 +1588,7 @@ export function decodeUnknownExit<S extends ConstraintDecoder<unknown>>(schema:
 
 function fromIssueExit<A>(exit: Exit_.Exit<A, SchemaIssue.Issue>): Exit_.Exit<A, SchemaError> {
   return Exit_.isSuccess(exit)
-    ? Exit_.succeed(exit.value)
+    ? exit as unknown as Exit_.Exit<A, SchemaError>
     : Exit_.failCause(Cause_.map(exit.cause, (issue) => new SchemaError(issue)))
 }
 
@@ -1848,19 +1851,12 @@ export const decodePromise: <S extends ConstraintDecoder<unknown>>(
  *
  * **Example** (Decoding with a transformation schema)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const NumberFromString = Schema.NumberFromString
  *
- * console.log(Schema.decodeUnknownSync(NumberFromString)("42"))
- * // Output: 42
- *
- * Schema.decodeUnknownSync(NumberFromString)("not a number")
- * // throws SchemaError: NumberFromString
- * //   └─ Encoded side transformation failure
- * //      └─ NumberFromString
- * //         └─ Expected a numeric string, actual "not a number"
+ * Schema.decodeUnknownSync(NumberFromString)("42") // => 42
  * ```
  *
  * @see {@link SchemaParser.decodeUnknownSync} for the adapter that throws an `Error` whose cause is `SchemaIssue.Issue`
@@ -1924,13 +1920,12 @@ export const decodeSync: <S extends ConstraintDecoder<unknown>>(
  *
  * **Example** (Encoding a value to a string)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Schema } from "effect"
  *
  * const NumberFromString = Schema.NumberFromString
  *
- * Effect.runPromise(Schema.encodeUnknownEffect(NumberFromString)(42)).then(console.log)
- * // Output: "42"
+ * await Effect.runPromise(Schema.encodeUnknownEffect(NumberFromString)(42)) // => "42"
  * ```
  *
  * @see {@link SchemaParser.encodeUnknownEffect} for the adapter that fails with `SchemaIssue.Issue` directly
@@ -2378,7 +2373,7 @@ interface optionalKeyLambda extends Lambda {
  *
  * **Example** (Creating a struct with optional key)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.Struct({
@@ -2445,7 +2440,7 @@ interface optionalLambda extends Lambda {
  *
  * **Example** (Defining an optional field accepting undefined)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.Struct({
@@ -2680,12 +2675,12 @@ function isFlip$(schema: Top): schema is flip<any> {
  *
  * **Example** (Flipping a number-from-string schema)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * // NumberFromString: decodes string → number
  * const flipped = Schema.flip(Schema.NumberFromString)
- * // flipped: decodes number → string
+ * Schema.decodeSync(flipped)(42) // => "42"
  * ```
  *
  * @category transforming
@@ -2717,11 +2712,12 @@ export interface Literal<L extends SchemaAST.LiteralValue>
  *
  * **Example** (Defining a string literal)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.Literal("hello")
  * // Type: Schema.Literal<"hello">
+ * Schema.decodeSync(schema)("hello") // => "hello"
  * ```
  *
  * @see {@link Literals} for a schema that represents a union of literals.
@@ -2849,11 +2845,11 @@ function templateLiteralFromParts<Parts extends TemplateLiteral.Parts>(parts: Pa
  *
  * **Example** (Defining a URL path pattern)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.TemplateLiteral(["/user/", Schema.Number])
- * // matches strings like "/user/123", "/user/42", etc.
+ * Schema.is(schema)("/user/123") // => true
  * ```
  *
  * @see {@link TemplateLiteralParser} for a schema that also parses matched parts into a tuple.
@@ -2928,11 +2924,11 @@ export interface TemplateLiteralParser<Parts extends TemplateLiteral.Parts> exte
  *
  * **Example** (Parsing path parameters)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.TemplateLiteralParser(["/user/", Schema.NumberFromString])
- * // decodes "/user/42" => readonly ["/user/", 42]
+ * Schema.decodeSync(schema)("/user/42") // => ["/user/", 42]
  * ```
  *
  * @see {@link TemplateLiteral} for a validation-only version that keeps the string encoded.
@@ -2962,7 +2958,7 @@ export interface Enum<A extends { [x: string]: string | number }>
  *
  * **Example** (Defining a direction enum)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * enum Direction {
@@ -2971,7 +2967,7 @@ export interface Enum<A extends { [x: string]: string | number }>
  * }
  *
  * const schema = Schema.Enum(Direction)
- * // accepts "Up" or "Down"
+ * Schema.decodeSync(schema)(Direction.Up) // => "Up"
  * ```
  *
  * @category constructors
@@ -3134,7 +3130,7 @@ export interface Boolean extends Bottom<boolean, boolean, never, never, SchemaAS
  *
  * @see {@link BooleanFromBit} for a schema that decodes bit literals `0` or `1` into a boolean
  *
- * @category boolean
+ * @category schemas
  * @since 4.0.0
  */
 export const Boolean: Boolean = make(SchemaAST.boolean)
@@ -3240,11 +3236,12 @@ export interface UniqueSymbol<sym extends symbol>
  *
  * **Example** (Defining a specific symbol)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const mySymbol = Symbol.for("mySymbol")
  * const schema = Schema.UniqueSymbol(mySymbol)
+ * Schema.decodeSync(schema)(mySymbol) === mySymbol // => true
  * ```
  *
  * @see {@link Symbol} for a schema that accepts any symbol.
@@ -3401,7 +3398,7 @@ export declare namespace Struct {
   type MakeInView<
     F extends Fields,
     O extends keyof F = TypeOptionalKeys<F> | TypeConstructorDefaultedKeys<F>
-  > = [O] extends [never] ? ReadonlyMakeIn<F> : Simplify<SetOptional<ReadonlyMakeIn<F>, O>>
+  > = [O] extends [never] ? Simplify<ReadonlyMakeIn<F>> : Simplify<SetOptional<ReadonlyMakeIn<F>, O>>
 
   /**
    * Computes the input object type accepted when constructing a struct value.
@@ -3437,7 +3434,7 @@ export interface Struct<Fields extends Struct.Fields> extends BottomLazy<SchemaA
    *
    * **Example** (Reusing fields across structs)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Schema } from "effect"
    *
    * const Timestamped = Schema.Struct({
@@ -3450,6 +3447,7 @@ export interface Struct<Fields extends Struct.Fields> extends BottomLazy<SchemaA
    *   name: Schema.String,
    *   email: Schema.String
    * })
+   * Object.keys(User.fields) // => ["createdAt", "updatedAt", "name", "email"]
    * ```
    */
   readonly fields: Fields
@@ -3506,7 +3504,7 @@ function makeStruct<const Fields extends Struct.Fields>(ast: SchemaAST.Objects,
  *
  * **Example** (Defining a basic struct)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const Person = Schema.Struct({
@@ -3518,9 +3516,7 @@ function makeStruct<const Fields extends Struct.Fields>(ast: SchemaAST.Objects,
  * // { readonly name: string; readonly age: number; readonly email?: string }
  * type Person = typeof Person.Type
  *
- * const alice = Schema.decodeUnknownSync(Person)({ name: "Alice", age: 30 })
- * console.log(alice)
- * // { name: 'Alice', age: 30 }
+ * Schema.decodeUnknownSync(Person)({ name: "Alice", age: 30 }) // => { name: "Alice", age: 30 }
  * ```
  *
  * @category constructors
@@ -3553,7 +3549,7 @@ interface fieldsAssign<NewFields extends Struct.Fields> extends Lambda {
  *
  * **Example** (Adding fields to a union of structs)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema, Tuple } from "effect"
  *
  * // Add a new field to all members of a union of structs
@@ -3561,6 +3557,7 @@ interface fieldsAssign<NewFields extends Struct.Fields> extends Lambda {
  *   Schema.Struct({ a: Schema.String }),
  *   Schema.Struct({ b: Schema.Number })
  * ]).mapMembers(Tuple.map(Schema.fieldsAssign({ c: Schema.Number })))
+ * Schema.decodeSync(schema)({ a: "a", c: 1 }) // => { a: "a", c: 1 }
  * ```
  *
  * @category combinators
@@ -3608,16 +3605,14 @@ const canonicalPropertyKey = (key: PropertyKey): string | symbol =>
  *
  * **Example** (Renaming `name` to `full_name` in the encoded form)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
  * const Encoded = Person.pipe(Schema.encodeKeys({ name: "full_name" }))
  *
  * // Decodes { full_name: "Alice", age: 30 } → { name: "Alice", age: 30 }
- * const alice = Schema.decodeUnknownSync(Encoded)({ full_name: "Alice", age: 30 })
- * console.log(alice)
- * // { name: 'Alice', age: 30 }
+ * Schema.decodeUnknownSync(Encoded)({ full_name: "Alice", age: 30 }) // => { name: "Alice", age: 30 }
  * ```
  *
  * @category transforming
@@ -3669,7 +3664,7 @@ export function encodeKeys<
  *
  * **Example** (Adding a computed `fullName` field)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Option, Schema } from "effect"
  *
  * const Person = Schema.Struct({ first: Schema.String, last: Schema.String })
@@ -3681,8 +3676,7 @@ export function encodeKeys<
  * )
  *
  * const alice = Schema.decodeUnknownSync(Extended)({ first: "Alice", last: "Smith" })
- * console.log(alice.fullName)
- * // Alice Smith
+ * alice.fullName // => "Alice Smith"
  * ```
  *
  * @category transforming
@@ -3885,9 +3879,16 @@ export interface $Record<Key extends Record.Key, Value extends Constraint> exten
  * For transformed key schemas, property selection is based on encoded property
  * names before the selected key is decoded.
  *
+ * **Gotchas**
+ *
+ * When decoded or encoded key transformations produce the same property key,
+ * sequential parsing applies selected own properties in selection order, so
+ * the later selected property overwrites the earlier value. With concurrency
+ * greater than `1`, completion order determines which value is retained.
+ *
  * **Example** (Defining a string-keyed record of numbers)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.Record(Schema.String, Schema.Number)
@@ -3895,9 +3896,7 @@ export interface $Record<Key extends Record.Key, Value extends Constraint> exten
  * // { readonly [x: string]: number }
  * type R = typeof schema.Type
  *
- * const result = Schema.decodeUnknownSync(schema)({ a: 1, b: 2 })
- * console.log(result)
- * // { a: 1, b: 2 }
+ * Schema.decodeUnknownSync(schema)({ a: 1, b: 2 }) // => { a: 1, b: 2 }
  * ```
  *
  * @category constructors
@@ -3905,18 +3904,9 @@ export interface $Record<Key extends Record.Key, Value extends Constraint> exten
  */
 export function Record<Key extends Record.Key, Value extends Constraint>(
   key: Key,
-  value: Value,
-  options?: {
-    readonly keyValueCombiner: {
-      readonly decode?: Combiner.Combiner<readonly [Key["Type"], Value["Type"]]> | undefined
-      readonly encode?: Combiner.Combiner<readonly [Key["Encoded"], Value["Encoded"]]> | undefined
-    }
-  }
+  value: Value
 ): $Record<Key, Value> {
-  const keyValueCombiner = options?.keyValueCombiner?.decode || options?.keyValueCombiner?.encode
-    ? new SchemaAST.KeyValueCombiner(options.keyValueCombiner.decode, options.keyValueCombiner.encode)
-    : undefined
-  return make(SchemaAST.record(key.ast, value.ast, keyValueCombiner), { key, value })
+  return make(SchemaAST.record(key.ast, value.ast), { key, value })
 }
 
 /**
@@ -4060,7 +4050,7 @@ export declare namespace StructWithRest {
    *
    * **Example** (Checking record compatibility)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Schema } from "effect"
    *
    * const user = Schema.Struct({ id: Schema.String })
@@ -4131,7 +4121,7 @@ export interface StructWithRest<
  *
  * **Example** (Defining structs with string-indexed extra keys)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.StructWithRest(
@@ -4352,14 +4342,12 @@ function makeTuple<Elements extends Tuple.Elements>(ast: SchemaAST.Arrays, eleme
  *
  * **Example** (Defining a pair of string and number)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.Tuple([Schema.String, Schema.Number])
  *
- * const pair = Schema.decodeUnknownSync(schema)(["hello", 42])
- * console.log(pair)
- * // [ 'hello', 42 ]
+ * Schema.decodeUnknownSync(schema)(["hello", 42]) // => ["hello", 42]
  * ```
  *
  * @category constructors
@@ -4530,7 +4518,7 @@ export interface TupleWithRest<
  *
  * **Example** (Defining tuples with rest elements)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * // [string, number, ...boolean[]]
@@ -4539,9 +4527,7 @@ export interface TupleWithRest<
  *   [Schema.Boolean]
  * )
  *
- * const result = Schema.decodeUnknownSync(schema)(["hello", 1, true, false])
- * console.log(result)
- * // [ 'hello', 1, true, false ]
+ * Schema.decodeUnknownSync(schema)(["hello", 1, true, false]) // => ["hello", 1, true, false]
  * ```
  *
  * @category constructors
@@ -4595,14 +4581,12 @@ export {
    *
    * **Example** (Defining an array of strings)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Schema } from "effect"
    *
    * const schema = Schema.Array(Schema.String)
    *
-   * const result = Schema.decodeUnknownSync(schema)(["a", "b", "c"])
-   * console.log(result)
-   * // [ 'a', 'b', 'c' ]
+   * Schema.decodeUnknownSync(schema)(["a", "b", "c"]) // => ["a", "b", "c"]
    * ```
    *
    * @category constructors
@@ -4644,13 +4628,12 @@ interface NonEmptyArrayLambda extends Lambda {
  *
  * **Example** (Defining a non-empty array of numbers)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.NonEmptyArray(Schema.Number)
  *
- * Schema.decodeUnknownSync(schema)([1, 2, 3])  // ok
- * Schema.decodeUnknownSync(schema)([])          // throws
+ * Schema.decodeUnknownSync(schema)([1, 2, 3]) // => [1, 2, 3]
  * ```
  *
  * @category constructors
@@ -4772,13 +4755,16 @@ interface mutableLambda extends Lambda {
  *
  * **Example** (Defining mutable arrays)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.mutable(Schema.Array(Schema.Number))
  *
  * // number[]   (mutable)
  * type T = typeof schema.Type
+ * const value: T = [1, 2]
+ * value.push(3)
+ * value // => [1, 2, 3]
  * ```
  *
  * @category transforming
@@ -4866,13 +4852,13 @@ function makeUnion<Members extends ReadonlyArray<Constraint>>(
  *
  * **Example** (Defining a string or number union)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.Union([Schema.String, Schema.Number])
  *
- * Schema.decodeUnknownSync(schema)("hello") // "hello"
- * Schema.decodeUnknownSync(schema)(42)       // 42
+ * Schema.decodeUnknownSync(schema)("hello") // => "hello"
+ * Schema.decodeUnknownSync(schema)(42) // => 42
  * ```
  *
  * @category constructors
@@ -4913,11 +4899,11 @@ export interface Literals<L extends ReadonlyArray<SchemaAST.LiteralValue>>
  *
  * **Example** (Defining status codes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.Literals(["active", "inactive", "pending"])
- * // accepts "active", "inactive", or "pending"
+ * Schema.decodeSync(schema)("active") // => "active"
  * ```
  *
  * @see {@link Literal} for a schema that represents a single literal.
@@ -5049,7 +5035,7 @@ export interface suspend<S extends Constraint> extends
  *
  * **Example** (Defining recursive tree schemas)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * interface Tree {
@@ -5061,6 +5047,7 @@ export interface suspend<S extends Constraint> extends
  *   value: Schema.Number,
  *   children: Schema.Array(Schema.suspend((): Schema.Codec<Tree> => Tree))
  * })
+ * Schema.decodeSync(Tree)({ value: 1, children: [] }) // => { value: 1, children: [] }
  * ```
  *
  * @category constructors
@@ -5076,12 +5063,14 @@ export function suspend<S extends Constraint>(f: () => S): suspend<S> {
  *
  * **Example** (Adding checks to a schema)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const AgeSchema = Schema.Finite.pipe(
  *   Schema.check(Schema.isGreaterThanOrEqualTo(0), Schema.isLessThanOrEqualTo(120))
  * )
+ * Schema.is(AgeSchema)(42) // => true
+ * Schema.is(AgeSchema)(121) // => false
  * ```
  *
  * @category filtering
@@ -5253,14 +5242,17 @@ export interface middlewareDecoding<S extends Constraint, RD> extends
  *
  * **Example** (Logging decode failures)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Schema } from "effect"
  *
+ * const events: Array<string> = []
  * const Logged = Schema.String.pipe(
  *   Schema.middlewareDecoding((effect) =>
- *     Effect.tapError(effect, (issue) => Effect.log("decode failed", issue))
+ *     Effect.tapError(effect, () => Effect.sync(() => events.push("decode failed")))
  *   )
  * )
+ * Effect.runSync(Effect.result(Schema.decodeUnknownEffect(Logged)(42)))
+ * events // => ["decode failed"]
  * ```
  *
  * @see {@link catchDecoding} for a simpler error-recovery variant
@@ -5319,14 +5311,17 @@ export interface middlewareEncoding<S extends Constraint, RE> extends
  *
  * **Example** (Logging encode failures)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Schema } from "effect"
  *
+ * const events: Array<string> = []
  * const Logged = Schema.String.pipe(
  *   Schema.middlewareEncoding((effect) =>
- *     Effect.tapError(effect, (issue) => Effect.log("encode failed", issue))
+ *     Effect.tapError(effect, () => Effect.sync(() => events.push("encode failed")))
  *   )
  * )
+ * Effect.runSync(Effect.result(Schema.encodeUnknownEffect(Logged)(42)))
+ * events // => ["encode failed"]
  * ```
  *
  * @see {@link catchEncoding} for a simpler error-recovery variant
@@ -5356,12 +5351,13 @@ export function middlewareEncoding<S extends Constraint, RE>(
  *
  * **Example** (Returning a default on decode failure)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Option, Schema } from "effect"
  *
  * const schema = Schema.Number.pipe(
  *   Schema.catchDecoding((_issue) => Effect.succeed(Option.some(0)))
  * )
+ * Effect.runSync(Schema.decodeUnknownEffect(schema)("invalid")) // => 0
  * ```
  *
  * @see {@link catchDecodingWithContext} to add service requirements to the handler
@@ -5511,7 +5507,7 @@ export interface compose<To extends Constraint, From extends Constraint> extends
  *
  * **Example** (Transforming strings to numbers with a schema transformation)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema, SchemaGetter } from "effect"
  *
  * const NumberFromString = Schema.String.pipe(
@@ -5524,8 +5520,7 @@ export interface compose<To extends Constraint, From extends Constraint> extends
  *   )
  * )
  *
- * const result = Schema.decodeUnknownSync(NumberFromString)("123")
- * // result: 123
+ * Schema.decodeUnknownSync(NumberFromString)("123") // => 123
  * ```
  *
  * @category transforming
@@ -5587,7 +5582,7 @@ export function decodeTo<To extends Constraint, From extends Constraint, RD = ne
  *
  * **Example** (Trimming string values during encoding/decoding)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema, SchemaGetter } from "effect"
  *
  * const Trimmed = Schema.String.pipe(
@@ -5597,8 +5592,7 @@ export function decodeTo<To extends Constraint, From extends Constraint, RD = ne
  *   })
  * )
  *
- * const result = Schema.decodeUnknownSync(Trimmed)("  hello  ")
- * // result: "hello"
+ * Schema.decodeUnknownSync(Trimmed)("  hello  ") // => "hello"
  * ```
  *
  * @category transforming
@@ -5628,7 +5622,7 @@ export function decode<S extends Constraint, RD = never, RE = never>(transformat
  *
  * **Example** (Encoding a number back to a string)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema, SchemaGetter } from "effect"
  *
  * const NumberFromString = Schema.Number.pipe(
@@ -5637,6 +5631,7 @@ export function decode<S extends Constraint, RD = never, RE = never>(transformat
  *     encode: SchemaGetter.transform((n: number) => String(n))
  *   })
  * )
+ * Schema.decodeSync(NumberFromString)("42") // => 42
  * ```
  *
  * @category transforming
@@ -5677,7 +5672,7 @@ export function encodeTo<To extends Constraint, From extends Constraint, RD = ne
  *
  * **Example** (Upper-casing encoded strings)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema, SchemaGetter } from "effect"
  *
  * const UpperFromLower = Schema.String.pipe(
@@ -5686,6 +5681,7 @@ export function encodeTo<To extends Constraint, From extends Constraint, RD = ne
  *     encode: SchemaGetter.transform((s: string) => s.toUpperCase())
  *   })
  * )
+ * Schema.encodeSync(UpperFromLower)("hello") // => "HELLO"
  * ```
  *
  * @category transforming
@@ -5752,7 +5748,7 @@ export interface withConstructorDefault<S extends Constraint & WithoutConstructo
  *
  * **Example** (Defining an optional field with a static default)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Schema } from "effect"
  *
  * const MySchema = Schema.Struct({
@@ -5762,8 +5758,7 @@ export interface withConstructorDefault<S extends Constraint & WithoutConstructo
  *   )
  * })
  *
- * const value = MySchema.make({})
- * // value: { name: "anonymous" }
+ * MySchema.make({}).name // => "anonymous"
  * ```
  *
  * @category constructors
@@ -5830,15 +5825,14 @@ export type DecodingDefaultOptions = {
  *
  * **Example** (Providing a default for a missing struct key)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Schema } from "effect"
  *
  * const MySchema = Schema.Struct({
  *   name: Schema.String.pipe(Schema.withDecodingDefaultKey(Effect.succeed("anonymous")))
  * })
  *
- * const result = Schema.decodeUnknownSync(MySchema)({})
- * // result: { name: "anonymous" }
+ * Schema.decodeUnknownSync(MySchema)({}).name // => "anonymous"
  * ```
  *
  * @see {@link withDecodingDefault} for the value-level variant (key absent **or** `undefined`)
@@ -5938,15 +5932,14 @@ export interface withDecodingDefault<S extends Constraint, R = never> extends de
  *
  * **Example** (Providing a default for an optional field value)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Schema } from "effect"
  *
  * const MySchema = Schema.Struct({
  *   name: Schema.String.pipe(Schema.optional, Schema.withDecodingDefault(Effect.succeed("anonymous")))
  * })
  *
- * const result = Schema.decodeUnknownSync(MySchema)({ name: undefined })
- * // result: { name: "anonymous" }
+ * Schema.decodeUnknownSync(MySchema)({ name: undefined }).name // => "anonymous"
  * ```
  *
  * @see {@link withDecodingDefaultKey} for the key-level variant (key absent only, not `undefined`)
@@ -6033,14 +6026,14 @@ export interface tag<Tag extends SchemaAST.LiteralValue> extends withConstructor
  *
  * **Example** (Defining a discriminated union tag)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const A = Schema.Struct({ _tag: Schema.tag("A"), value: Schema.Number })
  *
  * // _tag is optional in make, auto-filled to "A"
  * const a = A.make({ value: 42 })
- * // a: { _tag: "A", value: 42 }
+ * a // => { _tag: "A", value: 42 }
  * ```
  *
  * @see {@link tagDefaultOmit} to also omit the tag during encoding
@@ -6067,7 +6060,7 @@ export function tag<Tag extends SchemaAST.LiteralValue>(literal: Tag): tag<Tag>
  *
  * **Example** (Omitting tags during encoding)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const A = Schema.Struct({
@@ -6076,8 +6069,7 @@ export function tag<Tag extends SchemaAST.LiteralValue>(literal: Tag): tag<Tag>
  * })
  *
  * // Encode strips the _tag field
- * const encoded = Schema.encodeUnknownSync(A)({ _tag: "A", value: 1 })
- * // encoded: { value: 1 }
+ * Schema.encodeUnknownSync(A)({ _tag: "A", value: 1 }) // => { value: 1 }
  * ```
  *
  * @see {@link tag} for the variant that keeps the tag during encoding
@@ -6113,7 +6105,7 @@ export type TaggedStruct<Tag extends SchemaAST.LiteralValue, Fields extends Stru
  *
  * **Example** (Defining a tagged struct shorthand)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * // Defines a struct with a fixed `_tag` field
@@ -6126,19 +6118,20 @@ export type TaggedStruct<Tag extends SchemaAST.LiteralValue, Fields extends Stru
  *   _tag: Schema.tag("A"),
  *   a: Schema.String
  * })
+ * void tagged
+ * void equivalent
  * ```
  *
  * **Example** (Accessing the literal value of the tag)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const tagged = Schema.TaggedStruct("A", {
  *   a: Schema.String
  * })
  *
- * // literal: "A"
- * const literal = tagged.fields._tag.schema.literal
+ * tagged.fields._tag.schema.literal // => "A"
  * ```
  *
  * @category constructors
@@ -6213,7 +6206,7 @@ export type toTaggedUnion<
  *
  * **Example** (Adding tagged-union utilities to an existing union)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const A = Schema.TaggedStruct("A", { value: Schema.Number })
@@ -6226,6 +6219,7 @@ export type toTaggedUnion<
  *   A: (a) => `number: ${a.value}`,
  *   B: (b) => `name: ${b.name}`
  * })
+ * result // => "number: 1"
  * ```
  *
  * @see {@link TaggedUnion} for a shorthand that builds the union from scratch
@@ -6335,7 +6329,7 @@ export interface TaggedUnion<Cases extends Record<string, Constraint>> extends
  *
  * **Example** (Pattern matching a discriminated union)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const Shape = Schema.TaggedUnion({
@@ -6348,6 +6342,7 @@ export interface TaggedUnion<Cases extends Record<string, Constraint>> extends
  *   Circle: (c) => Math.PI * c.radius ** 2,
  *   Rectangle: (r) => r.width * r.height
  * })
+ * Math.round(area * 100) / 100 // => 78.54
  * ```
  *
  * @see {@link toTaggedUnion} to augment an existing union instead
@@ -6404,7 +6399,7 @@ export interface Opaque<Self, S extends Top, Brand> extends
  *
  * **Example** (Defining opaque structs)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * class Person extends Schema.Opaque<Person>()(
@@ -6415,7 +6410,7 @@ export interface Opaque<Self, S extends Top, Brand> extends
  *
  * // Decoded value is Person, not { name: string }
  * const person = Schema.decodeUnknownSync(Person)({ name: "Alice" })
- * // person: Person
+ * person.name // => "Alice"
  * ```
  *
  * @category constructors
@@ -6443,13 +6438,13 @@ export interface instanceOf<T, Iso = T> extends declare<T, Iso> {
  *
  * **Example** (Defining a schema for a built-in class)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const DateSchema = Schema.instanceOf(Date)
  *
  * const decoded = Schema.decodeUnknownSync(DateSchema)(new Date("2024-01-01"))
- * // decoded: Date
+ * decoded.toISOString() // => "2024-01-01T00:00:00.000Z"
  * ```
  *
  * @category constructors
@@ -6501,8 +6496,8 @@ export function link<T>() {
  *
  * **Example** (Reporting failure at a nested path)
  *
- * ```ts
- * import { Schema } from "effect"
+ * ```ts import.meta.vitest
+ * import { Result, Schema } from "effect"
  *
  * const schema = Schema.Struct({ password: Schema.String, confirmPassword: Schema.String }).check(
  *   Schema.makeFilter((o) =>
@@ -6512,15 +6507,16 @@ export function link<T>() {
  *   )
  * )
  *
- * console.log(String(Schema.decodeUnknownExit(schema)({ password: "123456", confirmPassword: "1234567" })))
- * // Failure(Cause([Fail(SchemaError: password and confirmPassword must match
- * //   at ["password"])]))
+ * const result = Schema.decodeUnknownResult(schema)({ password: "123456", confirmPassword: "1234567" })
+ * if (Result.isFailure(result) && result.failure.issue._tag === "Filter" && result.failure.issue.issue._tag === "Pointer") {
+ *   result.failure.issue.issue.path // => ["password"]
+ * }
  * ```
  *
  * **Example** (Reporting multiple failures at once)
  *
- * ```ts
- * import { Schema } from "effect"
+ * ```ts import.meta.vitest
+ * import { Result, Schema } from "effect"
  *
  * const schema = Schema.Struct({ a: Schema.Finite, b: Schema.Finite, c: Schema.Finite }).check(
  *   Schema.makeFilter((o) => {
@@ -6533,11 +6529,10 @@ export function link<T>() {
  *   })
  * )
  *
- * console.log(String(Schema.decodeUnknownExit(schema)({ a: 1, b: 0, c: 0 })))
- * // Failure(Cause([Fail(SchemaError: b must be greater than 0
- * //   at ["b"]
- * // c must be greater than 0
- * //   at ["c"])]))
+ * const result = Schema.decodeUnknownResult(schema)({ a: 1, b: 0, c: 0 })
+ * if (Result.isFailure(result) && result.failure.issue._tag === "Filter" && result.failure.issue.issue._tag === "Composite") {
+ *   result.failure.issue.issue.issues.map((issue) => issue._tag === "Pointer" ? issue.path : []) // => [["b"], ["c"]]
+ * }
  * ```
  *
  * @category constructors
@@ -6556,8 +6551,8 @@ export const makeFilter: <T>(
  * **Details**
  *
  * - `string`: failure with that string as the message. Produces an
- *   {@link SchemaIssue.InvalidValue} wrapping the input, with the string used as
- *   the issue's `message` annotation.
+ *   {@link SchemaIssue.InvalidValue} with the string used as the issue's
+ *   `message` annotation.
  * - {@link SchemaIssue.Issue}: a fully-formed issue, returned as-is.
  * - `{ path, issue }`: failure attached to a nested path. `issue` is either
  *   a `string` (wrapped in an {@link SchemaIssue.InvalidValue}) or a full
@@ -6583,8 +6578,8 @@ export type FilterIssue = string | SchemaIssue.Issue | {
  * - `undefined`: success. The input satisfies the filter.
  * - `true`: success. Equivalent to `undefined`, useful when the predicate is
  *   a plain boolean expression.
- * - `false`: generic failure. Produces an {@link SchemaIssue.InvalidValue} wrapping
- *   the input, with no custom message.
+ * - `false`: generic failure. Produces an {@link SchemaIssue.InvalidValue}
+ *   with no custom message.
  * - {@link FilterIssue}: a single failure. See {@link FilterIssue} for the
  *   shapes (`string`, {@link SchemaIssue.Issue}, or `{ path, issue }`).
  * - `ReadonlyArray<FilterIssue>`: several failures reported together. An
@@ -6643,7 +6638,7 @@ const TRIMMED_PATTERN = "^\\S[\\s\\S]*\\S$|^\\S$|^$"
  * When generating test data with fast-check, this applies a `patterns`
  * constraint to ensure generated strings match the trimmed pattern.
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export function isTrimmed(annotations?: Annotations.Filter) {
@@ -6677,7 +6672,7 @@ export function isTrimmed(annotations?: Annotations.Filter) {
  *
  * @see {@link isTrimmed} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export const isTrimmedReviver: SchemaRepresentation.FilterReviver<null> = InternalSchema.makeFilterReviver(
@@ -6700,7 +6695,7 @@ export const isTrimmedReviver: SchemaRepresentation.FilterReviver<null> = Intern
  * When generating test data with fast-check, this applies a `patterns`
  * constraint to ensure generated strings match the specified RegExp pattern.
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export function isPattern(
@@ -6737,7 +6732,7 @@ const IsPatternPayload = Struct({
  *
  * @see {@link isPattern} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export const isPatternReviver: SchemaRepresentation.FilterReviver<{
@@ -6764,7 +6759,7 @@ export const isPatternReviver: SchemaRepresentation.FilterReviver<{
  * When generating test data with fast-check, this applies a `patterns`
  * constraint to ensure generated strings match the number string pattern.
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export function isStringFinite(annotations?: Annotations.Filter): SchemaAST.Filter<string> {
@@ -6783,7 +6778,7 @@ export function isStringFinite(annotations?: Annotations.Filter): SchemaAST.Filt
  *
  * @see {@link isStringFinite} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export const isStringFiniteReviver: SchemaRepresentation.FilterReviver<null> = InternalSchema.makeFilterReviver(
@@ -6806,7 +6801,7 @@ export const isStringFiniteReviver: SchemaRepresentation.FilterReviver<null> = I
  * This check corresponds to a `pattern` constraint with the same signed
  * base-10 integer pattern.
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export function isStringBigInt(annotations?: Annotations.Filter): SchemaAST.Filter<string> {
@@ -6825,7 +6820,7 @@ export function isStringBigInt(annotations?: Annotations.Filter): SchemaAST.Filt
  *
  * @see {@link isStringBigInt} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export const isStringBigIntReviver: SchemaRepresentation.FilterReviver<null> = InternalSchema.makeFilterReviver(
@@ -6843,7 +6838,7 @@ export const isStringBigIntReviver: SchemaRepresentation.FilterReviver<null> = I
  * The check uses the pattern `^Symbol\((.*)\)$`. It is not a general test for
  * whether a string can be passed to JavaScript's `Symbol()` function.
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export function isStringSymbol(annotations?: Annotations.Filter): SchemaAST.Filter<string> {
@@ -6862,7 +6857,7 @@ export function isStringSymbol(annotations?: Annotations.Filter): SchemaAST.Filt
  *
  * @see {@link isStringSymbol} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export const isStringSymbolReviver: SchemaRepresentation.FilterReviver<null> = InternalSchema.makeFilterReviver(
@@ -6912,7 +6907,7 @@ const getUUIDRegExp = (version?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8): globalThis.RegE
  * constraint to ensure generated strings match the UUID pattern.
  *
  * @see {@link isGUID} for shape-only GUID validation.
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export function isUUID(version?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8, annotations?: Annotations.Filter) {
@@ -6941,7 +6936,7 @@ export function isUUID(version?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8, annotations?: An
  *
  * @see {@link isUUID} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export const isUUIDReviver: SchemaRepresentation.FilterReviver<{
@@ -6975,7 +6970,7 @@ const GUID_REGEXP = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{
  * constraint to ensure generated strings match the GUID pattern.
  *
  * @see {@link isUUID} for strict UUID validation.
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export function isGUID(annotations?: Annotations.Filter) {
@@ -7003,7 +6998,7 @@ export function isGUID(annotations?: Annotations.Filter) {
  *
  * @see {@link isGUID} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export const isGUIDReviver: SchemaRepresentation.FilterReviver<null> = InternalSchema.makeFilterReviver(
@@ -7028,7 +7023,7 @@ export const isGUIDReviver: SchemaRepresentation.FilterReviver<null> = InternalS
  * When generating test data with fast-check, this applies a `patterns`
  * constraint to ensure generated strings match the ULID pattern.
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export function isULID(annotations?: Annotations.Filter) {
@@ -7056,7 +7051,7 @@ export function isULID(annotations?: Annotations.Filter) {
  *
  * @see {@link isULID} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export const isULIDReviver: SchemaRepresentation.FilterReviver<null> = InternalSchema.makeFilterReviver(
@@ -7080,7 +7075,7 @@ export const isULIDReviver: SchemaRepresentation.FilterReviver<null> = InternalS
  * When generating test data with fast-check, this applies a `patterns`
  * constraint to ensure generated strings match the Base64 pattern.
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export function isBase64(annotations?: Annotations.Filter) {
@@ -7109,7 +7104,7 @@ export function isBase64(annotations?: Annotations.Filter) {
  *
  * @see {@link isBase64} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export const isBase64Reviver: SchemaRepresentation.FilterReviver<null> = InternalSchema.makeFilterReviver(
@@ -7134,7 +7129,7 @@ export const isBase64Reviver: SchemaRepresentation.FilterReviver<null> = Interna
  * When generating test data with fast-check, this applies a `patterns`
  * constraint to ensure generated strings match the Base64URL pattern.
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export function isBase64Url(annotations?: Annotations.Filter) {
@@ -7163,7 +7158,7 @@ export function isBase64Url(annotations?: Annotations.Filter) {
  *
  * @see {@link isBase64Url} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export const isBase64UrlReviver: SchemaRepresentation.FilterReviver<null> = InternalSchema.makeFilterReviver(
@@ -7180,7 +7175,7 @@ export const isBase64UrlReviver: SchemaRepresentation.FilterReviver<null> = Inte
  * RegExp metacharacters in the prefix are escaped in JSON Schema and arbitrary
  * metadata so that the generated patterns retain literal `startsWith` semantics.
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export function isStartsWith(startsWith: string, annotations?: Annotations.Filter) {
@@ -7215,7 +7210,7 @@ export function isStartsWith(startsWith: string, annotations?: Annotations.Filte
  *
  * @see {@link isStartsWith} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export const isStartsWithReviver: SchemaRepresentation.FilterReviver<{
@@ -7234,7 +7229,7 @@ export const isStartsWithReviver: SchemaRepresentation.FilterReviver<{
  * RegExp metacharacters in the suffix are escaped in JSON Schema and arbitrary
  * metadata so that the generated patterns retain literal `endsWith` semantics.
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export function isEndsWith(endsWith: string, annotations?: Annotations.Filter) {
@@ -7269,7 +7264,7 @@ export function isEndsWith(endsWith: string, annotations?: Annotations.Filter) {
  *
  * @see {@link isEndsWith} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export const isEndsWithReviver: SchemaRepresentation.FilterReviver<{
@@ -7289,7 +7284,7 @@ export const isEndsWithReviver: SchemaRepresentation.FilterReviver<{
  * arbitrary metadata so that the generated patterns retain literal `includes`
  * semantics.
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export function isIncludes(includes: string, annotations?: Annotations.Filter) {
@@ -7324,7 +7319,7 @@ export function isIncludes(includes: string, annotations?: Annotations.Filter) {
  *
  * @see {@link isIncludes} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export const isIncludesReviver: SchemaRepresentation.FilterReviver<{
@@ -7346,7 +7341,7 @@ const UPPERCASED_PATTERN = "^[^a-z]*$"
  * such as digits, punctuation, and whitespace. It rejects strings that would
  * change when uppercased.
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export function isUppercased(annotations?: Annotations.Filter) {
@@ -7380,7 +7375,7 @@ export function isUppercased(annotations?: Annotations.Filter) {
  *
  * @see {@link isUppercased} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export const isUppercasedReviver: SchemaRepresentation.FilterReviver<null> = InternalSchema.makeFilterReviver(
@@ -7400,7 +7395,7 @@ const LOWERCASED_PATTERN = "^[^A-Z]*$"
  * such as digits, punctuation, and whitespace. It rejects strings that would
  * change when lowercased.
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export function isLowercased(annotations?: Annotations.Filter) {
@@ -7434,7 +7429,7 @@ export function isLowercased(annotations?: Annotations.Filter) {
  *
  * @see {@link isLowercased} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export const isLowercasedReviver: SchemaRepresentation.FilterReviver<null> = InternalSchema.makeFilterReviver(
@@ -7454,7 +7449,7 @@ const CAPITALIZED_PATTERN = "^[^a-z]?.*$"
  * Empty strings pass. Strings whose first character has no lowercase form, such
  * as a digit, punctuation mark, or whitespace, also pass.
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export function isCapitalized(annotations?: Annotations.Filter) {
@@ -7488,7 +7483,7 @@ export function isCapitalized(annotations?: Annotations.Filter) {
  *
  * @see {@link isCapitalized} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export const isCapitalizedReviver: SchemaRepresentation.FilterReviver<null> = InternalSchema.makeFilterReviver(
@@ -7508,7 +7503,7 @@ const UNCAPITALIZED_PATTERN = "^[^A-Z]?.*$"
  * Empty strings pass. Strings whose first character has no uppercase form, such
  * as a digit, punctuation mark, or whitespace, also pass.
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export function isUncapitalized(annotations?: Annotations.Filter) {
@@ -7542,7 +7537,7 @@ export function isUncapitalized(annotations?: Annotations.Filter) {
  *
  * @see {@link isUncapitalized} for creating the corresponding check
  *
- * @category String checks
+ * @category validation
  * @since 4.0.0
  */
 export const isUncapitalizedReviver: SchemaRepresentation.FilterReviver<null> = InternalSchema.makeFilterReviver(
@@ -7554,7 +7549,7 @@ export const isUncapitalizedReviver: SchemaRepresentation.FilterReviver<null> =
 /**
  * Type-level representation of {@link Finite}.
  *
- * @category Number
+ * @category models
  * @since 3.10.0
  */
 export interface Finite extends Number {
@@ -7564,7 +7559,7 @@ export interface Finite extends Number {
 /**
  * Schema for finite numbers, rejecting `NaN`, `Infinity`, and `-Infinity`.
  *
- * @category Number
+ * @category schemas
  * @since 3.10.0
  */
 export const Finite: Finite = make(SchemaAST.finite)
@@ -7584,7 +7579,7 @@ export const Finite: Finite = make(SchemaAST.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
+ * @category validation
  * @since 4.0.0
  */
 export const isFinite: (annotations?: Annotations.Filter) => SchemaAST.Filter<number> = SchemaAST.isFinite
@@ -7598,7 +7593,7 @@ export const isFinite: (annotations?: Annotations.Filter) => SchemaAST.Filter<nu
  *
  * @see {@link isFinite} for creating the corresponding check
  *
- * @category Number checks
+ * @category validation
  * @since 4.0.0
  */
 export const isFiniteReviver: SchemaRepresentation.FilterReviver<null> = InternalSchema.makeFilterReviver(
@@ -7611,7 +7606,7 @@ export const isFiniteReviver: SchemaRepresentation.FilterReviver<null> = Interna
  * Creates a greater-than (`>`) check for any ordered type from an
  * `Order.Order` instance.
  *
- * @category Order checks
+ * @category validation
  * @since 4.0.0
  */
 export function makeIsGreaterThan<T>(options: {
@@ -7646,7 +7641,7 @@ export function makeIsGreaterThan<T>(options: {
  * Creates a greater-than-or-equal-to (`>=`) check for any ordered type from an
  * `Order.Order` instance.
  *
- * @category Order checks
+ * @category validation
  * @since 4.0.0
  */
 export function makeIsGreaterThanOrEqualTo<T>(options: {
@@ -7680,7 +7675,7 @@ export function makeIsGreaterThanOrEqualTo<T>(options: {
  * Creates a less-than (`<`) check for any ordered type from an `Order.Order`
  * instance.
  *
- * @category Order checks
+ * @category validation
  * @since 4.0.0
  */
 export function makeIsLessThan<T>(options: {
@@ -7715,7 +7710,7 @@ export function makeIsLessThan<T>(options: {
  * Creates a less-than-or-equal-to (`<=`) check for any ordered type from an
  * `Order.Order` instance.
  *
- * @category Order checks
+ * @category validation
  * @since 4.0.0
  */
 export function makeIsLessThanOrEqualTo<T>(options: {
@@ -7749,7 +7744,7 @@ export function makeIsLessThanOrEqualTo<T>(options: {
  * Creates an inclusive or exclusive range check for any ordered type from an
  * `Order.Order` instance.
  *
- * @category Order checks
+ * @category validation
  * @since 4.0.0
  */
 export function makeIsBetween<T>(deriveOptions: {
@@ -7805,7 +7800,7 @@ export function makeIsBetween<T>(deriveOptions: {
  * Creates a divisibility check for any numeric type from a remainder function
  * and a zero value.
  *
- * @category Numeric checks
+ * @category validation
  * @since 4.0.0
  */
 export function makeIsMultipleOf<T>(options: {
@@ -7849,7 +7844,7 @@ function encodeNumberPayload(number: number): number {
  * `exclusiveMinimum` constraint to ensure generated numbers are greater than
  * the specified value.
  *
- * @category Number checks
+ * @category validation
  * @since 4.0.0
  */
 export const isGreaterThan = makeIsGreaterThan({
@@ -7873,7 +7868,7 @@ export const isGreaterThan = makeIsGreaterThan({
  *
  * @see {@link isGreaterThan} for creating the corresponding check
  *
- * @category Number checks
+ * @category validation
  * @since 4.0.0
  */
 export const isGreaterThanReviver: SchemaRepresentation.FilterReviver<{
@@ -7899,7 +7894,7 @@ export const isGreaterThanReviver: SchemaRepresentation.FilterReviver<{
  * 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
+ * @category validation
  * @since 4.0.0
  */
 export const isGreaterThanOrEqualTo = makeIsGreaterThanOrEqualTo({
@@ -7923,7 +7918,7 @@ export const isGreaterThanOrEqualTo = makeIsGreaterThanOrEqualTo({
  *
  * @see {@link isGreaterThanOrEqualTo} for creating the corresponding check
  *
- * @category Number checks
+ * @category validation
  * @since 4.0.0
  */
 export const isGreaterThanOrEqualToReviver: SchemaRepresentation.FilterReviver<{
@@ -7949,7 +7944,7 @@ export const isGreaterThanOrEqualToReviver: SchemaRepresentation.FilterReviver<{
  * `exclusiveMaximum` constraint to ensure generated numbers are less than the
  * specified value.
  *
- * @category Number checks
+ * @category validation
  * @since 4.0.0
  */
 export const isLessThan = makeIsLessThan({
@@ -7973,7 +7968,7 @@ export const isLessThan = makeIsLessThan({
  *
  * @see {@link isLessThan} for creating the corresponding check
  *
- * @category Number checks
+ * @category validation
  * @since 4.0.0
  */
 export const isLessThanReviver: SchemaRepresentation.FilterReviver<{
@@ -7999,7 +7994,7 @@ export const isLessThanReviver: SchemaRepresentation.FilterReviver<{
  * 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
+ * @category validation
  * @since 4.0.0
  */
 export const isLessThanOrEqualTo = makeIsLessThanOrEqualTo({
@@ -8023,7 +8018,7 @@ export const isLessThanOrEqualTo = makeIsLessThanOrEqualTo({
  *
  * @see {@link isLessThanOrEqualTo} for creating the corresponding check
  *
- * @category Number checks
+ * @category validation
  * @since 4.0.0
  */
 export const isLessThanOrEqualToReviver: SchemaRepresentation.FilterReviver<{
@@ -8052,7 +8047,7 @@ export const isLessThanOrEqualToReviver: SchemaRepresentation.FilterReviver<{
  * `exclusiveMaximum` flags to ensure generated numbers fall within the
  * specified range.
  *
- * @category Number checks
+ * @category validation
  * @since 4.0.0
  */
 export const isBetween = makeIsBetween({
@@ -8093,7 +8088,7 @@ export const isBetween = makeIsBetween({
  *
  * @see {@link isBetween} for creating the corresponding check
  *
- * @category Number checks
+ * @category validation
  * @since 4.0.0
  */
 export const isBetweenReviver: SchemaRepresentation.FilterReviver<{
@@ -8126,7 +8121,7 @@ export const isBetweenReviver: SchemaRepresentation.FilterReviver<{
  * When generating test data with fast-check, this applies constraints to ensure
  * generated numbers are multiples of the specified divisor.
  *
- * @category Number checks
+ * @category validation
  * @since 4.0.0
  */
 export const isMultipleOf = makeIsMultipleOf({
@@ -8152,7 +8147,7 @@ export const isMultipleOf = makeIsMultipleOf({
  *
  * @see {@link isMultipleOf} for creating the corresponding check
  *
- * @category Number checks
+ * @category validation
  * @since 4.0.0
  */
 export const isMultipleOfReviver: SchemaRepresentation.FilterReviver<{
@@ -8178,7 +8173,7 @@ export const isMultipleOfReviver: SchemaRepresentation.FilterReviver<{
  * When generating test data with fast-check, this applies an `integer: true`
  * constraint to ensure generated numbers are integers.
  *
- * @category Integer checks
+ * @category validation
  * @since 4.0.0
  */
 export function isInt(annotations?: Annotations.Filter) {
@@ -8211,7 +8206,7 @@ export function isInt(annotations?: Annotations.Filter) {
  *
  * @see {@link isInt} for creating the corresponding check
  *
- * @category Integer checks
+ * @category validation
  * @since 4.0.0
  */
 export const isIntReviver: SchemaRepresentation.FilterReviver<null> = InternalSchema.makeFilterReviver(
@@ -8223,7 +8218,7 @@ export const isIntReviver: SchemaRepresentation.FilterReviver<null> = InternalSc
 /**
  * Type-level representation of {@link Int}.
  *
- * @category Number
+ * @category models
  * @since 3.10.0
  */
 export interface Int extends Number {
@@ -8233,7 +8228,7 @@ export interface Int extends Number {
 /**
  * Schema for integers, rejecting `NaN`, `Infinity`, and `-Infinity`.
  *
- * @category Number
+ * @category schemas
  * @since 3.10.0
  */
 export const Int: Int = Number.check(isInt())
@@ -8241,7 +8236,7 @@ export const Int: Int = Number.check(isInt())
 /**
  * Type-level representation of {@link Natural}.
  *
- * @category Number
+ * @category models
  * @since 4.0.0
  */
 export interface Natural extends Int {
@@ -8257,7 +8252,7 @@ export interface Natural extends Int {
  *
  * @see {@link Int} for safe integers that may be negative
  *
- * @category Number
+ * @category schemas
  * @since 4.0.0
  */
 export const Natural: Natural = Int.check(isGreaterThanOrEqualTo(0))
@@ -8278,7 +8273,7 @@ export const Natural: Natural = Int.check(isGreaterThanOrEqualTo(0))
  * When generating test data with fast-check, this applies integer and range
  * constraints to ensure generated numbers are 32-bit signed integers.
  *
- * @category Integer checks
+ * @category validation
  * @since 4.0.0
  */
 export function isInt32(annotations?: Annotations.Filter) {
@@ -8310,7 +8305,7 @@ export function isInt32(annotations?: Annotations.Filter) {
  * When generating test data with fast-check, this applies integer and range
  * constraints to ensure generated numbers are 32-bit unsigned integers.
  *
- * @category Integer checks
+ * @category validation
  * @since 4.0.0
  */
 export function isUint32(annotations?: Annotations.Filter) {
@@ -8348,7 +8343,7 @@ function formatDateRuntime(date: globalThis.Date): string {
  * one millisecond after the specified value to ensure generated Date objects are
  * greater than it.
  *
- * @category Date checks
+ * @category validation
  * @since 4.0.0
  */
 export const isGreaterThanDate = makeIsGreaterThan({
@@ -8383,7 +8378,7 @@ export const isGreaterThanDate = makeIsGreaterThan({
  * to ensure generated Date objects are greater than or equal to the specified
  * date.
  *
- * @category Date checks
+ * @category validation
  * @since 4.0.0
  */
 export const isGreaterThanOrEqualToDate = makeIsGreaterThanOrEqualTo({
@@ -8412,7 +8407,7 @@ export const isGreaterThanOrEqualToDate = makeIsGreaterThanOrEqualTo({
  * one millisecond before the specified value to ensure generated Date objects
  * are less than it.
  *
- * @category Date checks
+ * @category validation
  * @since 4.0.0
  */
 export const isLessThanDate = makeIsLessThan({
@@ -8447,7 +8442,7 @@ export const isLessThanDate = makeIsLessThan({
  * to ensure generated Date objects are less than or equal to the specified
  * date.
  *
- * @category Date checks
+ * @category validation
  * @since 4.0.0
  */
 export const isLessThanOrEqualToDate = makeIsLessThanOrEqualTo({
@@ -8482,7 +8477,7 @@ export const isLessThanOrEqualToDate = makeIsLessThanOrEqualTo({
  * constraints to ensure generated Date objects fall within the specified range,
  * shifting exclusive bounds by one millisecond.
  *
- * @category Date checks
+ * @category validation
  * @since 4.0.0
  */
 export const isBetweenDate = makeIsBetween({
@@ -8522,7 +8517,7 @@ export const isBetweenDate = makeIsBetween({
  * `exclusiveMinimum + 1n` to ensure generated BigInts are greater than the
  * specified value.
  *
- * @category BigInt checks
+ * @category validation
  * @since 4.0.0
  */
 export const isGreaterThanBigInt = makeIsGreaterThan({
@@ -8552,7 +8547,7 @@ export const isGreaterThanBigInt = makeIsGreaterThan({
  * to ensure generated BigInt values are greater than or equal to the specified
  * value.
  *
- * @category BigInt checks
+ * @category validation
  * @since 4.0.0
  */
 export const isGreaterThanOrEqualToBigInt = makeIsGreaterThanOrEqualTo({
@@ -8581,7 +8576,7 @@ export const isGreaterThanOrEqualToBigInt = makeIsGreaterThanOrEqualTo({
  * `exclusiveMaximum - 1n` to ensure generated BigInts are less than the
  * specified value.
  *
- * @category BigInt checks
+ * @category validation
  * @since 4.0.0
  */
 export const isLessThanBigInt = makeIsLessThan({
@@ -8611,7 +8606,7 @@ export const isLessThanBigInt = makeIsLessThan({
  * to ensure generated BigInt values are less than or equal to the specified
  * value.
  *
- * @category BigInt checks
+ * @category validation
  * @since 4.0.0
  */
 export const isLessThanOrEqualToBigInt = makeIsLessThanOrEqualTo({
@@ -8641,7 +8636,7 @@ export const isLessThanOrEqualToBigInt = makeIsLessThanOrEqualTo({
  * constraints to ensure generated BigInt values fall within the specified
  * range.
  *
- * @category BigInt checks
+ * @category validation
  * @since 4.0.0
  */
 export const isBetweenBigInt = makeIsBetween({
@@ -8673,7 +8668,7 @@ export const isBetweenBigInt = makeIsBetween({
 /**
  * Validates that a BigDecimal is greater than the specified value (exclusive).
  *
- * @category BigDecimal checks
+ * @category validation
  * @since 4.0.0
  */
 export const isGreaterThanBigDecimal = makeIsGreaterThan({
@@ -8685,7 +8680,7 @@ export const isGreaterThanBigDecimal = makeIsGreaterThan({
  * Validates that a BigDecimal is greater than or equal to the specified value
  * (inclusive).
  *
- * @category BigDecimal checks
+ * @category validation
  * @since 4.0.0
  */
 export const isGreaterThanOrEqualToBigDecimal = makeIsGreaterThanOrEqualTo({
@@ -8696,7 +8691,7 @@ export const isGreaterThanOrEqualToBigDecimal = makeIsGreaterThanOrEqualTo({
 /**
  * Validates that a BigDecimal is less than the specified value (exclusive).
  *
- * @category BigDecimal checks
+ * @category validation
  * @since 4.0.0
  */
 export const isLessThanBigDecimal = makeIsLessThan({
@@ -8708,7 +8703,7 @@ export const isLessThanBigDecimal = makeIsLessThan({
  * Validates that a BigDecimal is less than or equal to the specified value
  * (inclusive).
  *
- * @category BigDecimal checks
+ * @category validation
  * @since 4.0.0
  */
 export const isLessThanOrEqualToBigDecimal = makeIsLessThanOrEqualTo({
@@ -8724,7 +8719,7 @@ export const isLessThanOrEqualToBigDecimal = makeIsLessThanOrEqualTo({
  * The minimum and maximum boundaries are inclusive by default. Pass
  * `exclusiveMinimum` or `exclusiveMaximum` to exclude either boundary.
  *
- * @category BigDecimal checks
+ * @category validation
  * @since 4.0.0
  */
 export const isBetweenBigDecimal = makeIsBetween({
@@ -8751,14 +8746,16 @@ export const isBetweenBigDecimal = makeIsBetween({
  *
  * **Example** (Checking minimum length)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const NonEmptyStringSchema = Schema.String.check(Schema.isMinLength(1))
  * const NonEmptyArraySchema = Schema.Array(Schema.Number).check(Schema.isMinLength(1))
+ * Schema.is(NonEmptyStringSchema)("a") // => true
+ * Schema.is(NonEmptyArraySchema)([1]) // => true
  * ```
  *
- * @category Length checks
+ * @category validation
  * @since 4.0.0
  */
 export function isMinLength(minLength: number, annotations?: Annotations.Filter) {
@@ -8793,7 +8790,7 @@ export function isMinLength(minLength: number, annotations?: Annotations.Filter)
  *
  * @see {@link isMinLength} for creating the corresponding check
  *
- * @category Length checks
+ * @category validation
  * @since 4.0.0
  */
 export const isMinLengthReviver: SchemaRepresentation.FilterReviver<{
@@ -8820,7 +8817,7 @@ export const isMinLengthReviver: SchemaRepresentation.FilterReviver<{
  * When generating test data with fast-check, this applies a `minLength: 1`
  * constraint to ensure generated strings or arrays are non-empty.
  *
- * @category Length checks
+ * @category validation
  * @since 4.0.0
  */
 export function isNonEmpty(annotations?: Annotations.Filter) {
@@ -8844,7 +8841,7 @@ export function isNonEmpty(annotations?: Annotations.Filter) {
  * constraint to ensure generated strings or arrays have at most the required
  * length.
  *
- * @category Length checks
+ * @category validation
  * @since 4.0.0
  */
 export function isMaxLength(maxLength: number, annotations?: Annotations.Filter) {
@@ -8879,7 +8876,7 @@ export function isMaxLength(maxLength: number, annotations?: Annotations.Filter)
  *
  * @see {@link isMaxLength} for creating the corresponding check
  *
- * @category Length checks
+ * @category validation
  * @since 4.0.0
  */
 export const isMaxLengthReviver: SchemaRepresentation.FilterReviver<{
@@ -8907,7 +8904,7 @@ export const isMaxLengthReviver: SchemaRepresentation.FilterReviver<{
  * `maxLength` constraints to ensure generated strings or arrays have a length
  * within the specified range.
  *
- * @category Length checks
+ * @category validation
  * @since 4.0.0
  */
 export function isLengthBetween(minimum: number, maximum: number, annotations?: Annotations.Filter) {
@@ -8950,7 +8947,7 @@ export function isLengthBetween(minimum: number, maximum: number, annotations?:
  *
  * @see {@link isLengthBetween} for creating the corresponding check
  *
- * @category Length checks
+ * @category validation
  * @since 4.0.0
  */
 export const isLengthBetweenReviver: SchemaRepresentation.FilterReviver<{
@@ -8979,7 +8976,7 @@ export const isLengthBetweenReviver: SchemaRepresentation.FilterReviver<{
  * `minLength` constraint. Generators for values with a final `.size`, such as
  * sets and maps, interpret it as final cardinality.
  *
- * @category Size checks
+ * @category validation
  * @since 4.0.0
  */
 export function isMinSize(minSize: number, annotations?: Annotations.Filter) {
@@ -9014,7 +9011,7 @@ export function isMinSize(minSize: number, annotations?: Annotations.Filter) {
  *
  * @see {@link isMinSize} for creating the corresponding check
  *
- * @category Size checks
+ * @category validation
  * @since 4.0.0
  */
 export const isMinSizeReviver: SchemaRepresentation.FilterReviver<{
@@ -9042,7 +9039,7 @@ export const isMinSizeReviver: SchemaRepresentation.FilterReviver<{
  * `maxLength` constraint. Generators for values with a final `.size`, such as
  * sets and maps, interpret it as final cardinality.
  *
- * @category Size checks
+ * @category validation
  * @since 4.0.0
  */
 export function isMaxSize(maxSize: number, annotations?: Annotations.Filter) {
@@ -9077,7 +9074,7 @@ export function isMaxSize(maxSize: number, annotations?: Annotations.Filter) {
  *
  * @see {@link isMaxSize} for creating the corresponding check
  *
- * @category Size checks
+ * @category validation
  * @since 4.0.0
  */
 export const isMaxSizeReviver: SchemaRepresentation.FilterReviver<{
@@ -9105,7 +9102,7 @@ export const isMaxSizeReviver: SchemaRepresentation.FilterReviver<{
  * `minLength` and `maxLength` constraints. Generators for values with a final
  * `.size`, such as sets and maps, interpret them as final cardinality.
  *
- * @category Size checks
+ * @category validation
  * @since 4.0.0
  */
 export function isSizeBetween(minimum: number, maximum: number, annotations?: Annotations.Filter) {
@@ -9145,7 +9142,7 @@ export function isSizeBetween(minimum: number, maximum: number, annotations?: An
  *
  * @see {@link isSizeBetween} for creating the corresponding check
  *
- * @category Size checks
+ * @category validation
  * @since 4.0.0
  */
 export const isSizeBetweenReviver: SchemaRepresentation.FilterReviver<{
@@ -9174,7 +9171,7 @@ export const isSizeBetweenReviver: SchemaRepresentation.FilterReviver<{
  * `minLength` constraint. Object generators interpret it as the final number
  * of own properties.
  *
- * @category Object checks
+ * @category validation
  * @since 4.0.0
  */
 export function isMinProperties(minProperties: number, annotations?: Annotations.Filter) {
@@ -9209,7 +9206,7 @@ export function isMinProperties(minProperties: number, annotations?: Annotations
  *
  * @see {@link isMinProperties} for creating the corresponding check
  *
- * @category Object checks
+ * @category validation
  * @since 4.0.0
  */
 export const isMinPropertiesReviver: SchemaRepresentation.FilterReviver<{
@@ -9236,7 +9233,7 @@ export const isMinPropertiesReviver: SchemaRepresentation.FilterReviver<{
  * `maxLength` constraint. Object generators interpret it as the final number
  * of own properties.
  *
- * @category Object checks
+ * @category validation
  * @since 4.0.0
  */
 export function isMaxProperties(maxProperties: number, annotations?: Annotations.Filter) {
@@ -9271,7 +9268,7 @@ export function isMaxProperties(maxProperties: number, annotations?: Annotations
  *
  * @see {@link isMaxProperties} for creating the corresponding check
  *
- * @category Object checks
+ * @category validation
  * @since 4.0.0
  */
 export const isMaxPropertiesReviver: SchemaRepresentation.FilterReviver<{
@@ -9299,7 +9296,7 @@ export const isMaxPropertiesReviver: SchemaRepresentation.FilterReviver<{
  * `minLength` and `maxLength` constraints. Object generators interpret them as
  * the final number of own properties.
  *
- * @category Object checks
+ * @category validation
  * @since 4.0.0
  */
 export function isPropertiesLengthBetween(minimum: number, maximum: number, annotations?: Annotations.Filter) {
@@ -9339,7 +9336,7 @@ export function isPropertiesLengthBetween(minimum: number, maximum: number, anno
  *
  * @see {@link isPropertiesLengthBetween} for creating the corresponding check
  *
- * @category Object checks
+ * @category validation
  * @since 4.0.0
  */
 export const isPropertiesLengthBetweenReviver: SchemaRepresentation.FilterReviver<{
@@ -9364,7 +9361,7 @@ export const isPropertiesLengthBetweenReviver: SchemaRepresentation.FilterRevive
  * For string property names, this corresponds to the `propertyNames` constraint
  * in JSON Schema.
  *
- * @category Object checks
+ * @category validation
  * @since 4.0.0
  */
 export function isPropertyNames(keySchema: Constraint, annotations?: Annotations.Filter) {
@@ -9382,7 +9379,7 @@ export function isPropertyNames(keySchema: Constraint, annotations?: Annotations
         }
       }
       if (Arr.isArrayNonEmpty(issues)) {
-        return new SchemaIssue.Composite(ast, Option_.some(input), issues)
+        return new SchemaIssue.Composite(ast, issues)
       }
       return true
     },
@@ -9410,7 +9407,7 @@ export function isPropertyNames(keySchema: Constraint, annotations?: Annotations
  *
  * @see {@link isPropertyNames} for creating the corresponding check
  *
- * @category Object checks
+ * @category validation
  * @since 4.0.0
  */
 export const isPropertyNamesReviver: SchemaRepresentation.FilterReviver<null> = InternalSchema.makeFilterReviver(
@@ -9432,7 +9429,7 @@ export const isPropertyNamesReviver: SchemaRepresentation.FilterReviver<null> =
  * `unique: true` constraint. Array generators translate it to `fast-check`
  * `uniqueArray` using Effect equality.
  *
- * @category Array checks
+ * @category validation
  * @since 4.0.0
  */
 export function isUnique<T>(annotations?: Annotations.Filter) {
@@ -9465,7 +9462,7 @@ export function isUnique<T>(annotations?: Annotations.Filter) {
  *
  * @see {@link isUnique} for creating the corresponding check
  *
- * @category Array checks
+ * @category validation
  * @since 4.0.0
  */
 export const isUniqueReviver: SchemaRepresentation.FilterReviver<null> = InternalSchema.makeFilterReviver(
@@ -9481,7 +9478,7 @@ export const isUniqueReviver: SchemaRepresentation.FilterReviver<null> = Interna
 /**
  * Type-level representation of {@link NonEmptyString}.
  *
- * @category string
+ * @category models
  * @since 3.10.0
  */
 export interface NonEmptyString extends String {
@@ -9492,7 +9489,7 @@ export interface NonEmptyString extends String {
  * Schema for non-empty strings. Validates that a string has at least one
  * character.
  *
- * @category string
+ * @category schemas
  * @since 3.10.0
  */
 export const NonEmptyString: NonEmptyString = String.check(isNonEmpty())
@@ -9500,7 +9497,7 @@ export const NonEmptyString: NonEmptyString = String.check(isNonEmpty())
 /**
  * Type-level representation of {@link Char}.
  *
- * @category string
+ * @category models
  * @since 3.10.0
  */
 export interface Char extends String {
@@ -9523,7 +9520,7 @@ export interface Char extends String {
  * @see {@link NonEmptyString} for strings with length greater than zero
  * @see {@link isLengthBetween} for the underlying length check
  *
- * @category string
+ * @category schemas
  * @since 3.10.0
  */
 export const Char: Char = String.check(isLengthBetween(1, 1))
@@ -9531,7 +9528,7 @@ export const Char: Char = String.check(isLengthBetween(1, 1))
 /**
  * Type-level representation returned by {@link Option}.
  *
- * @category Option
+ * @category models
  * @since 3.10.0
  */
 export interface Option<A extends Constraint> extends
@@ -9554,7 +9551,7 @@ export interface Option<A extends Constraint> extends
  * `None` is represented as `{ _tag: "None" }`, while `Some` is represented as
  * `{ _tag: "Some", value }` using the wrapped schema's `Iso` type.
  *
- * @category Option
+ * @category utility types
  * @since 4.0.0
  */
 export type OptionIso<A extends Constraint> =
@@ -9564,7 +9561,7 @@ export type OptionIso<A extends Constraint> =
 /**
  * Schema for `Option<A>` values.
  *
- * @category Option
+ * @category schemas
  * @since 3.10.0
  */
 export function Option<A extends Constraint>(value: A): Option<A> {
@@ -9583,12 +9580,11 @@ export function Option<A extends Constraint>(value: A): Option<A> {
           SchemaParser.decodeUnknownEffect(value)(input.value, options),
           {
             onSuccess: Option_.some,
-            onFailure: (issue) =>
-              new SchemaIssue.Composite(ast, Option_.some(input), [new SchemaIssue.Pointer(["value"], issue)])
+            onFailure: (issue) => new SchemaIssue.Composite(ast, [new SchemaIssue.Pointer(["value"], issue)])
           }
         )
       }
-      return Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)))
+      return Effect.fail(new SchemaIssue.InvalidType(ast))
     },
     {
       representation: {
@@ -9640,7 +9636,7 @@ export function Option<A extends Constraint>(value: A): Option<A> {
  *
  * @see {@link Option} for creating the corresponding schema
  *
- * @category Option
+ * @category schemas
  * @since 4.0.0
  */
 export const OptionReviver = InternalSchema.makeDeclarationReviver(
@@ -9655,7 +9651,7 @@ export const OptionReviver = InternalSchema.makeDeclarationReviver(
 /**
  * Type-level representation returned by {@link OptionFromNullOr}.
  *
- * @category Option
+ * @category models
  * @since 3.10.0
  */
 export interface OptionFromNullOr<S extends Constraint> extends decodeTo<Option<toType<S>>, NullOr<S>> {
@@ -9670,7 +9666,7 @@ export interface OptionFromNullOr<S extends Constraint> extends decodeTo<Option<
  * Decoding maps `null` to `None` and all other values to `Some`. Encoding maps
  * `None` to `null` and maps `Some` to its value.
  *
- * @category Option
+ * @category schemas
  * @since 3.10.0
  */
 export function OptionFromNullOr<S extends Constraint>(schema: S): OptionFromNullOr<S> {
@@ -9683,7 +9679,7 @@ export function OptionFromNullOr<S extends Constraint>(schema: S): OptionFromNul
 /**
  * Type-level representation returned by {@link OptionFromUndefinedOr}.
  *
- * @category Option
+ * @category models
  * @since 3.10.0
  */
 export interface OptionFromUndefinedOr<S extends Constraint> extends decodeTo<Option<toType<S>>, UndefinedOr<S>> {
@@ -9699,7 +9695,7 @@ export interface OptionFromUndefinedOr<S extends Constraint> extends decodeTo<Op
  * Decoding maps `undefined` to `None` and all other values to `Some`. Encoding
  * maps `None` to `undefined` and maps `Some` to its value.
  *
- * @category Option
+ * @category schemas
  * @since 3.10.0
  */
 export function OptionFromUndefinedOr<S extends Constraint>(schema: S): OptionFromUndefinedOr<S> {
@@ -9712,7 +9708,7 @@ export function OptionFromUndefinedOr<S extends Constraint>(schema: S): OptionFr
 /**
  * Type-level representation returned by {@link OptionFromNullishOr}.
  *
- * @category Option
+ * @category models
  * @since 3.10.0
  */
 export interface OptionFromNullishOr<S extends Constraint> extends decodeTo<Option<toType<S>>, NullishOr<S>> {
@@ -9729,7 +9725,7 @@ export interface OptionFromNullishOr<S extends Constraint> extends decodeTo<Opti
  * `options.onNoneEncoding`, which defaults to `undefined`, and maps `Some` to
  * its value.
  *
- * @category Option
+ * @category schemas
  * @since 3.10.0
  */
 export function OptionFromNullishOr<S extends Constraint>(
@@ -9747,7 +9743,7 @@ export function OptionFromNullishOr<S extends Constraint>(
 /**
  * Type-level representation returned by {@link OptionFromOptionalKey}.
  *
- * @category Option
+ * @category models
  * @since 4.0.0
  */
 export interface OptionFromOptionalKey<S extends Constraint> extends decodeTo<Option<toType<S>>, optionalKey<S>> {
@@ -9762,7 +9758,7 @@ export interface OptionFromOptionalKey<S extends Constraint> extends decodeTo<Op
  * Decoding maps a missing key to `None` and a present value to `Some`.
  * Encoding maps `None` to a missing key and maps `Some` to its value.
  *
- * @category Option
+ * @category schemas
  * @since 4.0.0
  */
 export function OptionFromOptionalKey<S extends Constraint>(schema: S): OptionFromOptionalKey<S> {
@@ -9775,7 +9771,7 @@ export function OptionFromOptionalKey<S extends Constraint>(schema: S): OptionFr
 /**
  * Type-level representation returned by {@link OptionFromOptional}.
  *
- * @category Option
+ * @category models
  * @since 4.0.0
  */
 export interface OptionFromOptional<S extends Constraint> extends decodeTo<Option<toType<S>>, optional<S>> {
@@ -9792,7 +9788,7 @@ export interface OptionFromOptional<S extends Constraint> extends decodeTo<Optio
  * maps all other values to `Some`. Encoding maps `None` to a missing key and
  * maps `Some` to its value.
  *
- * @category Option
+ * @category schemas
  * @since 4.0.0
  */
 export function OptionFromOptional<S extends Constraint>(schema: S): OptionFromOptional<S> {
@@ -9805,7 +9801,7 @@ export function OptionFromOptional<S extends Constraint>(schema: S): OptionFromO
 /**
  * Type-level representation returned by {@link OptionFromOptionalNullOr}.
  *
- * @category Option
+ * @category models
  * @since 4.0.0
  */
 export interface OptionFromOptionalNullOr<S extends Constraint>
@@ -9825,7 +9821,7 @@ export interface OptionFromOptionalNullOr<S extends Constraint>
  * according to `options.onNoneEncoding`: `"omit"` encodes a missing key,
  * `null` encodes `null`, and `undefined` encodes `undefined`.
  *
- * @category Option
+ * @category schemas
  * @since 4.0.0
  */
 export function OptionFromOptionalNullOr<S extends Constraint>(
@@ -9852,7 +9848,7 @@ export function OptionFromOptionalNullOr<S extends Constraint>(
 /**
  * Type-level representation returned by {@link Result}.
  *
- * @category schemas
+ * @category models
  * @since 4.0.0
  */
 export interface Result<A extends Constraint, E extends Constraint> extends
@@ -9876,7 +9872,7 @@ export interface Result<A extends Constraint, E extends Constraint> extends
  * Successful results are represented as `{ _tag: "Success", success }`, while
  * failed results are represented as `{ _tag: "Failure", failure }`.
  *
- * @category schemas
+ * @category utility types
  * @since 4.0.0
  */
 export type ResultIso<A extends Constraint, E extends Constraint> =
@@ -9901,20 +9897,18 @@ export function Result<A extends Constraint, E extends Constraint>(
     [success, failure],
     ([success, failure]) => (input, ast, options) => {
       if (!Result_.isResult(input)) {
-        return Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)))
+        return Effect.fail(new SchemaIssue.InvalidType(ast))
       }
       switch (input._tag) {
         case "Success":
           return Effect.mapBothEager(SchemaParser.decodeEffect(success)(input.success, options), {
             onSuccess: Result_.succeed,
-            onFailure: (issue) =>
-              new SchemaIssue.Composite(ast, Option_.some(input), [new SchemaIssue.Pointer(["success"], issue)])
+            onFailure: (issue) => new SchemaIssue.Composite(ast, [new SchemaIssue.Pointer(["success"], issue)])
           })
         case "Failure":
           return Effect.mapBothEager(SchemaParser.decodeEffect(failure)(input.failure, options), {
             onSuccess: Result_.fail,
-            onFailure: (issue) =>
-              new SchemaIssue.Composite(ast, Option_.some(input), [new SchemaIssue.Pointer(["failure"], issue)])
+            onFailure: (issue) => new SchemaIssue.Composite(ast, [new SchemaIssue.Pointer(["failure"], issue)])
           })
       }
     },
@@ -9991,7 +9985,7 @@ export const ResultReviver = InternalSchema.makeDeclarationReviver(
 /**
  * Type-level representation returned by {@link Redacted}.
  *
- * @category Redacted
+ * @category models
  * @since 3.10.0
  */
 export interface Redacted<S extends Constraint> extends
@@ -10037,13 +10031,7 @@ const RedactedOptionsPayload = declare((input): input is RedactedRepresentationO
 const RedactedRepresentationPayload: Decoder<RedactedRepresentationPayload> = Union([Null, RedactedOptionsPayload])
 
 /**
- * Schema for values that hide sensitive information from error output and
- * inspection.
- *
- * **Details**
- *
- * If the wrapped schema fails, the issue will be redacted to prevent both
- * the actual value and the schema details from being exposed.
+ * Schema for `Redacted` values, which hide their contents from inspection.
  *
  * Options:
  *
@@ -10057,7 +10045,7 @@ const RedactedRepresentationPayload: Decoder<RedactedRepresentationPayload> = Un
  *   sensitive and should not be exposed in JSON.
  *
  * @see {@link RedactedFromValue} for decoding raw values and wrapping them in `Redacted`.
- * @category Redacted
+ * @category schemas
  * @since 3.10.0
  */
 export function Redacted<S extends Constraint>(value: S, options?: {
@@ -10091,17 +10079,16 @@ export function Redacted<S extends Constraint>(value: S, options?: {
               SchemaParser.decodeUnknownEffect(value)(Redacted_.value(input), poptions),
               {
                 onSuccess: () => input,
-                onFailure: (/** ignore the actual issue because of security reasons */) => {
-                  const oinput = Option_.some(input)
-                  return new SchemaIssue.Composite(ast, oinput, [
-                    new SchemaIssue.Pointer(["value"], new SchemaIssue.InvalidValue(oinput))
+                onFailure: (/** ignore the issue because of security reasons */) => {
+                  return new SchemaIssue.Composite(ast, [
+                    new SchemaIssue.Pointer(["value"], new SchemaIssue.InvalidValue())
                   ])
                 }
               }
             )
         )
       }
-      return Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)))
+      return Effect.fail(new SchemaIssue.InvalidType(ast))
     },
     {
       representation: {
@@ -10118,7 +10105,7 @@ export function Redacted<S extends Constraint>(value: S, options?: {
       expected: "Redacted",
       toCodecJson: ([value]) =>
         link<Redacted_.Redacted<S["Encoded"]>>()(
-          redact(value),
+          value,
           {
             decode: SchemaGetter.transform((e) => Redacted_.make(e, { label })),
             encode: disallowJsonEncode ?
@@ -10149,7 +10136,7 @@ export function Redacted<S extends Constraint>(value: S, options?: {
  *
  * @see {@link Redacted} for creating the corresponding schema
  *
- * @category Redacted
+ * @category schemas
  * @since 4.0.0
  */
 export const RedactedReviver = InternalSchema.makeDeclarationReviver(
@@ -10164,62 +10151,47 @@ export const RedactedReviver = InternalSchema.makeDeclarationReviver(
 /**
  * Type-level representation returned by {@link RedactedFromValue}.
  *
- * @category Redacted
+ * @category models
  * @since 4.0.0
  */
-export interface RedactedFromValue<S extends Constraint>
-  extends decodeTo<Redacted<toType<S>>, middlewareDecoding<S, S["DecodingServices"]>>
-{
+export interface RedactedFromValue<S extends Constraint> extends decodeTo<Redacted<toType<S>>, S> {
   readonly "Rebuild": RedactedFromValue<S>
 }
 
-/**
- * Middleware that wraps decoded errors in `Redacted`, preventing sensitive
- * schema details from leaking in error messages.
- *
- * @category Redacted
- * @since 4.0.0
- */
-export function redact<S extends Constraint>(schema: S): middlewareDecoding<S, S["DecodingServices"]> {
-  return middlewareDecoding<S, S["DecodingServices"]>(Effect.mapErrorEager(SchemaIssue.redact))(schema)
-}
-
 /**
  * Decodes a value and wraps it in `Redacted<A>`. Unlike {@link Redacted} which
  * expects the input to already be a `Redacted` instance, this schema decodes
  * the raw value and wraps it.
  *
  * @see {@link Redacted} for schemas whose input is already a `Redacted` value.
- * @category Redacted
+ * @category schemas
  * @since 4.0.0
  */
 export function RedactedFromValue<S extends Constraint>(value: S, options?: {
   readonly label?: string | undefined
   readonly disallowEncode?: boolean | undefined
 }): RedactedFromValue<S> {
-  return redact(value).pipe(
-    decodeTo(
-      Redacted(toType(value), {
-        label: options?.label,
-        disallowJsonEncode: options?.disallowEncode
-      }),
-      {
-        decode: SchemaGetter.transform((t) => Redacted_.make(t, { label: options?.label })),
-        encode: options?.disallowEncode ?
-          SchemaGetter.forbidden((oe) =>
-            "Cannot encode Redacted" +
-            (Option_.isSome(oe) && typeof oe.value.label === "string" ? ` with label: "${oe.value.label}"` : "")
-          ) :
-          SchemaGetter.transform(Redacted_.value)
-      }
-    )
-  )
+  return decodeTo<Redacted<toType<S>>, S>(
+    Redacted(toType(value), {
+      label: options?.label,
+      disallowJsonEncode: options?.disallowEncode
+    }),
+    {
+      decode: SchemaGetter.transform((t) => Redacted_.make(t, { label: options?.label })),
+      encode: options?.disallowEncode ?
+        SchemaGetter.forbidden((oe) =>
+          "Cannot encode Redacted" +
+          (Option_.isSome(oe) && typeof oe.value.label === "string" ? ` with label: "${oe.value.label}"` : "")
+        ) :
+        SchemaGetter.transform(Redacted_.value)
+    }
+  )(value)
 }
 
 /**
  * Type-level representation returned by {@link CauseReason}.
  *
- * @category CauseReason
+ * @category models
  * @since 4.0.0
  */
 export interface CauseReason<E extends Constraint, D extends Constraint> extends
@@ -10243,7 +10215,7 @@ export interface CauseReason<E extends Constraint, D extends Constraint> extends
  * Failures are represented with a `Fail` tag and encoded error, defects with a
  * `Die` tag and encoded defect, and interrupts with an optional `fiberId`.
  *
- * @category CauseReason
+ * @category utility types
  * @since 4.0.0
  */
 export type CauseReasonIso<E extends Constraint, D extends Constraint> = {
@@ -10274,7 +10246,7 @@ export type CauseReasonIso<E extends Constraint, D extends Constraint> = {
  * @see {@link Cause} for constructing schemas for full Cause values
  * @see {@link CauseReasonIso} for the ISO shape of each cause reason
  *
- * @category CauseReason
+ * @category schemas
  * @since 4.0.0
  */
 export function CauseReason<E extends Constraint, D extends Constraint>(error: E, defect: D): CauseReason<E, D> {
@@ -10282,7 +10254,7 @@ export function CauseReason<E extends Constraint, D extends Constraint>(error: E
     [error, defect],
     ([error, defect]) => (input, ast, options) => {
       if (!Cause_.isReason(input)) {
-        return Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)))
+        return Effect.fail(new SchemaIssue.InvalidType(ast))
       }
       switch (input._tag) {
         case "Fail":
@@ -10290,8 +10262,7 @@ export function CauseReason<E extends Constraint, D extends Constraint>(error: E
             SchemaParser.decodeUnknownEffect(error)(input.error, options),
             {
               onSuccess: Cause_.makeFailReason,
-              onFailure: (issue) =>
-                new SchemaIssue.Composite(ast, Option_.some(input), [new SchemaIssue.Pointer(["error"], issue)])
+              onFailure: (issue) => new SchemaIssue.Composite(ast, [new SchemaIssue.Pointer(["error"], issue)])
             }
           )
         case "Die":
@@ -10299,8 +10270,7 @@ export function CauseReason<E extends Constraint, D extends Constraint>(error: E
             SchemaParser.decodeUnknownEffect(defect)(input.defect, options),
             {
               onSuccess: Cause_.makeDieReason,
-              onFailure: (issue) =>
-                new SchemaIssue.Composite(ast, Option_.some(input), [new SchemaIssue.Pointer(["defect"], issue)])
+              onFailure: (issue) => new SchemaIssue.Composite(ast, [new SchemaIssue.Pointer(["defect"], issue)])
             }
           )
         case "Interrupt":
@@ -10356,7 +10326,7 @@ export function CauseReason<E extends Constraint, D extends Constraint>(error: E
  *
  * @see {@link CauseReason} for creating the corresponding schema
  *
- * @category CauseReason
+ * @category schemas
  * @since 4.0.0
  */
 export const CauseReasonReviver = InternalSchema.makeDeclarationReviver(
@@ -10414,7 +10384,7 @@ function causeReasonToFormatter<E>(error: Formatter<E>, defect: Formatter<unknow
 /**
  * Type-level representation returned by {@link Cause}.
  *
- * @category Cause
+ * @category models
  * @since 3.10.0
  */
 export interface Cause<E extends Constraint, D extends Constraint> extends
@@ -10442,7 +10412,7 @@ export interface Cause<E extends Constraint, D extends Constraint> extends
  * @see {@link Cause} for constructing schemas for full Cause values
  * @see {@link CauseReasonIso} for the ISO shape of each array element
  *
- * @category Cause
+ * @category utility types
  * @since 4.0.0
  */
 export type CauseIso<E extends Constraint, D extends Constraint> = ReadonlyArray<CauseReasonIso<E, D>>
@@ -10465,7 +10435,7 @@ export type CauseIso<E extends Constraint, D extends Constraint> = ReadonlyArray
  * @see {@link CauseReason} for the schema used by each individual cause reason
  * @see {@link CauseIso} for the ordered array representation used by the schema ISO
  *
- * @category Cause
+ * @category schemas
  * @since 3.10.0
  */
 export function Cause<E extends Constraint, D extends Constraint>(error: E, defect: D): Cause<E, D> {
@@ -10475,12 +10445,11 @@ export function Cause<E extends Constraint, D extends Constraint>(error: E, defe
       const failures = ArraySchema(CauseReason(error, defect))
       return (input, ast, options) => {
         if (!Cause_.isCause(input)) {
-          return Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)))
+          return Effect.fail(new SchemaIssue.InvalidType(ast))
         }
         return Effect.mapBothEager(SchemaParser.decodeUnknownEffect(failures)(input.reasons, options), {
           onSuccess: Cause_.fromReasons,
-          onFailure: (issue) =>
-            new SchemaIssue.Composite(ast, Option_.some(input), [new SchemaIssue.Pointer(["failures"], issue)])
+          onFailure: (issue) => new SchemaIssue.Composite(ast, [new SchemaIssue.Pointer(["failures"], issue)])
         })
       }
     },
@@ -10520,7 +10489,7 @@ export function Cause<E extends Constraint, D extends Constraint>(error: E, defe
  *
  * @see {@link Cause} for creating the corresponding schema
  *
- * @category Cause
+ * @category schemas
  * @since 4.0.0
  */
 export const CauseReviver = InternalSchema.makeDeclarationReviver(
@@ -10557,7 +10526,7 @@ function causeToFormatter<E>(error: Formatter<E>, defect: Formatter<unknown>) {
 /**
  * Type-level representation of {@link Error}.
  *
- * @category Error
+ * @category models
  * @since 4.0.0
  */
 export interface Error extends instanceOf<globalThis.Error> {
@@ -10642,7 +10611,7 @@ const errorSchemaCache: Array<Error | undefined> = []
  * traces are omitted by default for security. Pass `{ includeStack: true }` to
  * include stack traces, or `{ excludeCause: true }` to omit causes.
  *
- * @category constructors
+ * @category schemas
  * @since 4.0.0
  */
 export function Error(options?: ErrorOptions): Error {
@@ -10678,7 +10647,7 @@ export function Error(options?: ErrorOptions): Error {
  *
  * @see {@link Error} for creating the corresponding schema
  *
- * @category Error
+ * @category schemas
  * @since 4.0.0
  */
 export const ErrorReviver = InternalSchema.makeDeclarationReviver(
@@ -10693,7 +10662,7 @@ export const ErrorReviver = InternalSchema.makeDeclarationReviver(
 /**
  * Type-level representation of {@link Defect}.
  *
- * @category Defect
+ * @category models
  * @since 3.10.0
  */
 export interface Defect extends decodeTo<Unknown, typeof Json> {
@@ -10740,7 +10709,7 @@ const defectSchemaCache: Array<Defect | undefined> = []
  *   string representation.
  *
  * @see {@link Error} for a schema that only accepts JavaScript `Error` values.
- * @category constructors
+ * @category schemas
  * @since 4.0.0
  */
 export function Defect(options?: ErrorOptions): Defect {
@@ -10757,7 +10726,7 @@ export function Defect(options?: ErrorOptions): Defect {
 /**
  * Type-level representation returned by {@link Exit}.
  *
- * @category Exit
+ * @category models
  * @since 3.10.0
  */
 export interface Exit<A extends Constraint, E extends Constraint, D extends Constraint> extends
@@ -10782,7 +10751,7 @@ export interface Exit<A extends Constraint, E extends Constraint, D extends Cons
  * Successful exits are represented as `{ _tag: "Success", value }`, while failed
  * exits are represented as `{ _tag: "Failure", cause }`.
  *
- * @category Exit
+ * @category utility types
  * @since 4.0.0
  */
 export type ExitIso<A extends Constraint, E extends Constraint, D extends Constraint> = {
@@ -10802,7 +10771,7 @@ export type ExitIso<A extends Constraint, E extends Constraint, D extends Constr
  * Use when serializing or validating an effect outcome where success, typed
  * failure, and defects each need their own schema.
  *
- * @category Exit
+ * @category schemas
  * @since 3.10.0
  */
 export function Exit<A extends Constraint, E extends Constraint, D extends Constraint>(
@@ -10820,7 +10789,7 @@ export function Exit<A extends Constraint, E extends Constraint, D extends Const
       const cause = Cause(error, defect)
       return (input, ast, options) => {
         if (!Exit_.isExit(input)) {
-          return Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)))
+          return Effect.fail(new SchemaIssue.InvalidType(ast))
         }
         switch (input._tag) {
           case "Success":
@@ -10828,8 +10797,7 @@ export function Exit<A extends Constraint, E extends Constraint, D extends Const
               SchemaParser.decodeUnknownEffect(value)(input.value, options),
               {
                 onSuccess: Exit_.succeed,
-                onFailure: (issue) =>
-                  new SchemaIssue.Composite(ast, Option_.some(input), [new SchemaIssue.Pointer(["value"], issue)])
+                onFailure: (issue) => new SchemaIssue.Composite(ast, [new SchemaIssue.Pointer(["value"], issue)])
               }
             )
           case "Failure":
@@ -10837,8 +10805,7 @@ export function Exit<A extends Constraint, E extends Constraint, D extends Const
               SchemaParser.decodeUnknownEffect(cause)(input.cause, options),
               {
                 onSuccess: Exit_.failCause,
-                onFailure: (issue) =>
-                  new SchemaIssue.Composite(ast, Option_.some(input), [new SchemaIssue.Pointer(["cause"], issue)])
+                onFailure: (issue) => new SchemaIssue.Composite(ast, [new SchemaIssue.Pointer(["cause"], issue)])
               }
             )
         }
@@ -10922,7 +10889,7 @@ export function Exit<A extends Constraint, E extends Constraint, D extends Const
  *
  * @see {@link Exit} for creating the corresponding schema
  *
- * @category Exit
+ * @category schemas
  * @since 4.0.0
  */
 export const ExitReviver = InternalSchema.makeDeclarationReviver(
@@ -10937,7 +10904,7 @@ export const ExitReviver = InternalSchema.makeDeclarationReviver(
 /**
  * Type-level representation returned by {@link ReadonlyMap}.
  *
- * @category ReadonlyMap
+ * @category models
  * @since 4.0.0
  */
 export interface $ReadonlyMap<Key extends Constraint, Value extends Constraint> extends
@@ -10957,7 +10924,7 @@ export interface $ReadonlyMap<Key extends Constraint, Value extends Constraint>
  * Iso representation used for `ReadonlyMap` schemas: an array of readonly
  * `[key, value]` tuples using each entry schema's `Iso` type.
  *
- * @category ReadonlyMap
+ * @category utility types
  * @since 4.0.0
  */
 export type ReadonlyMapIso<Key extends Constraint, Value extends Constraint> = ReadonlyArray<
@@ -11058,7 +11025,7 @@ function entriesArbitrary<K, V, Out>(
  * Schema for readonly maps whose keys and values conform to the provided
  * schemas.
  *
- * @category ReadonlyMap
+ * @category schemas
  * @since 3.10.0
  */
 export function ReadonlyMap<Key extends Constraint, Value extends Constraint>(
@@ -11079,12 +11046,11 @@ export function ReadonlyMap<Key extends Constraint, Value extends Constraint>(
             SchemaParser.decodeUnknownEffect(array)([...input], options),
             {
               onSuccess: (array: ReadonlyArray<readonly [Key["Type"], Value["Type"]]>) => new globalThis.Map(array),
-              onFailure: (issue) =>
-                new SchemaIssue.Composite(ast, Option_.some(input), [new SchemaIssue.Pointer(["entries"], issue)])
+              onFailure: (issue) => new SchemaIssue.Composite(ast, [new SchemaIssue.Pointer(["entries"], issue)])
             }
           )
         }
-        return Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)))
+        return Effect.fail(new SchemaIssue.InvalidType(ast))
       }
     },
     {
@@ -11129,7 +11095,7 @@ export function ReadonlyMap<Key extends Constraint, Value extends Constraint>(
  *
  * @see {@link ReadonlyMap} for creating the corresponding schema
  *
- * @category ReadonlyMap
+ * @category schemas
  * @since 4.0.0
  */
 export const ReadonlyMapReviver = InternalSchema.makeDeclarationReviver(
@@ -11144,7 +11110,7 @@ export const ReadonlyMapReviver = InternalSchema.makeDeclarationReviver(
 /**
  * Type-level representation returned by {@link HashMap}.
  *
- * @category HashMap
+ * @category models
  * @since 3.10.0
  */
 export interface HashMap<Key extends Constraint, Value extends Constraint> extends
@@ -11164,7 +11130,7 @@ export interface HashMap<Key extends Constraint, Value extends Constraint> exten
  * Iso representation used for `HashMap` schemas: an array of readonly
  * `[key, value]` tuples using each entry schema's `Iso` type.
  *
- * @category HashMap
+ * @category utility types
  * @since 4.0.0
  */
 export type HashMapIso<Key extends Constraint, Value extends Constraint> = ReadonlyArray<
@@ -11174,7 +11140,7 @@ export type HashMapIso<Key extends Constraint, Value extends Constraint> = Reado
 /**
  * Schema for hash maps whose keys and values conform to the provided schemas.
  *
- * @category HashMap
+ * @category schemas
  * @since 3.10.0
  */
 export function HashMap<Key extends Constraint, Value extends Constraint>(key: Key, value: Value): HashMap<Key, Value> {
@@ -11192,12 +11158,11 @@ export function HashMap<Key extends Constraint, Value extends Constraint>(key: K
             SchemaParser.decodeUnknownEffect(entries)(HashMap_.toEntries(input), options),
             {
               onSuccess: HashMap_.fromIterable,
-              onFailure: (issue) =>
-                new SchemaIssue.Composite(ast, Option_.some(input), [new SchemaIssue.Pointer(["entries"], issue)])
+              onFailure: (issue) => new SchemaIssue.Composite(ast, [new SchemaIssue.Pointer(["entries"], issue)])
             }
           )
         }
-        return Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)))
+        return Effect.fail(new SchemaIssue.InvalidType(ast))
       }
     },
     {
@@ -11243,7 +11208,7 @@ export function HashMap<Key extends Constraint, Value extends Constraint>(key: K
  *
  * @see {@link HashMap} for creating the corresponding schema
  *
- * @category HashMap
+ * @category schemas
  * @since 4.0.0
  */
 export const HashMapReviver = InternalSchema.makeDeclarationReviver(
@@ -11258,7 +11223,7 @@ export const HashMapReviver = InternalSchema.makeDeclarationReviver(
 /**
  * Type-level representation returned by {@link ReadonlySet}.
  *
- * @category ReadonlySet
+ * @category models
  * @since 4.0.0
  */
 export interface $ReadonlySet<Value extends Constraint> extends
@@ -11277,7 +11242,7 @@ export interface $ReadonlySet<Value extends Constraint> extends
  * Iso representation used for `ReadonlySet` schemas: an array of element values
  * using the element schema's `Iso` type.
  *
- * @category ReadonlySet
+ * @category utility types
  * @since 4.0.0
  */
 export type ReadonlySetIso<Value extends Constraint> = ReadonlyArray<Value["Iso"]>
@@ -11285,7 +11250,7 @@ export type ReadonlySetIso<Value extends Constraint> = ReadonlyArray<Value["Iso"
 /**
  * Schema for readonly sets whose values conform to the provided element schema.
  *
- * @category ReadonlySet
+ * @category schemas
  * @since 3.10.0
  */
 export function ReadonlySet<Value extends Constraint>(value: Value): $ReadonlySet<Value> {
@@ -11303,12 +11268,11 @@ export function ReadonlySet<Value extends Constraint>(value: Value): $ReadonlySe
             SchemaParser.decodeUnknownEffect(array)([...input], options),
             {
               onSuccess: (array: ReadonlyArray<Value["Type"]>) => new globalThis.Set(array),
-              onFailure: (issue) =>
-                new SchemaIssue.Composite(ast, Option_.some(input), [new SchemaIssue.Pointer(["values"], issue)])
+              onFailure: (issue) => new SchemaIssue.Composite(ast, [new SchemaIssue.Pointer(["values"], issue)])
             }
           )
         }
-        return Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)))
+        return Effect.fail(new SchemaIssue.InvalidType(ast))
       }
     },
     {
@@ -11354,7 +11318,7 @@ export function ReadonlySet<Value extends Constraint>(value: Value): $ReadonlySe
  *
  * @see {@link ReadonlySet} for creating the corresponding schema
  *
- * @category ReadonlySet
+ * @category schemas
  * @since 4.0.0
  */
 export const ReadonlySetReviver = InternalSchema.makeDeclarationReviver(
@@ -11369,7 +11333,7 @@ export const ReadonlySetReviver = InternalSchema.makeDeclarationReviver(
 /**
  * Type-level representation returned by {@link HashSet}.
  *
- * @category HashSet
+ * @category models
  * @since 3.10.0
  */
 export interface HashSet<Value extends Constraint> extends
@@ -11388,7 +11352,7 @@ export interface HashSet<Value extends Constraint> extends
  * Iso representation used for `HashSet` schemas: an array of element values
  * using the element schema's `Iso` type.
  *
- * @category HashSet
+ * @category utility types
  * @since 4.0.0
  */
 export type HashSetIso<Value extends Constraint> = ReadonlyArray<Value["Iso"]>
@@ -11396,7 +11360,7 @@ export type HashSetIso<Value extends Constraint> = ReadonlyArray<Value["Iso"]>
 /**
  * Schema for hash sets whose values conform to the provided element schema.
  *
- * @category HashSet
+ * @category schemas
  * @since 3.10.0
  */
 export function HashSet<Value extends Constraint>(value: Value): HashSet<Value> {
@@ -11414,12 +11378,11 @@ export function HashSet<Value extends Constraint>(value: Value): HashSet<Value>
             SchemaParser.decodeUnknownEffect(values)(Arr.fromIterable(input), options),
             {
               onSuccess: HashSet_.fromIterable,
-              onFailure: (issue) =>
-                new SchemaIssue.Composite(ast, Option_.some(input), [new SchemaIssue.Pointer(["values"], issue)])
+              onFailure: (issue) => new SchemaIssue.Composite(ast, [new SchemaIssue.Pointer(["values"], issue)])
             }
           )
         }
-        return Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)))
+        return Effect.fail(new SchemaIssue.InvalidType(ast))
       }
     },
     {
@@ -11465,7 +11428,7 @@ export function HashSet<Value extends Constraint>(value: Value): HashSet<Value>
  *
  * @see {@link HashSet} for creating the corresponding schema
  *
- * @category HashSet
+ * @category schemas
  * @since 4.0.0
  */
 export const HashSetReviver = InternalSchema.makeDeclarationReviver(
@@ -11480,7 +11443,7 @@ export const HashSetReviver = InternalSchema.makeDeclarationReviver(
 /**
  * Type-level representation returned by {@link Chunk}.
  *
- * @category Chunk
+ * @category models
  * @since 3.10.0
  */
 export interface Chunk<Value extends Constraint> extends
@@ -11506,7 +11469,7 @@ export interface Chunk<Value extends Constraint> extends
  *
  * @see {@link Chunk} for the schema interface and constructor that use this ISO representation
  *
- * @category Chunk
+ * @category utility types
  * @since 4.0.0
  */
 export type ChunkIso<Value extends Constraint> = ReadonlyArray<Value["Iso"]>
@@ -11514,7 +11477,7 @@ export type ChunkIso<Value extends Constraint> = ReadonlyArray<Value["Iso"]>
 /**
  * Schema for chunks whose values conform to the provided element schema.
  *
- * @category Chunk
+ * @category schemas
  * @since 3.10.0
  */
 export function Chunk<Value extends Constraint>(value: Value): Chunk<Value> {
@@ -11532,12 +11495,11 @@ export function Chunk<Value extends Constraint>(value: Value): Chunk<Value> {
             SchemaParser.decodeUnknownEffect(values)(Arr.fromIterable(input), options),
             {
               onSuccess: Chunk_.fromIterable,
-              onFailure: (issue) =>
-                new SchemaIssue.Composite(ast, Option_.some(input), [new SchemaIssue.Pointer(["values"], issue)])
+              onFailure: (issue) => new SchemaIssue.Composite(ast, [new SchemaIssue.Pointer(["values"], issue)])
             }
           )
         }
-        return Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)))
+        return Effect.fail(new SchemaIssue.InvalidType(ast))
       }
     },
     {
@@ -11583,7 +11545,7 @@ export function Chunk<Value extends Constraint>(value: Value): Chunk<Value> {
  *
  * @see {@link Chunk} for creating the corresponding schema
  *
- * @category Chunk
+ * @category schemas
  * @since 4.0.0
  */
 export const ChunkReviver = InternalSchema.makeDeclarationReviver(
@@ -11598,7 +11560,7 @@ export const ChunkReviver = InternalSchema.makeDeclarationReviver(
 /**
  * Type-level representation of {@link RegExp}.
  *
- * @category RegExp
+ * @category models
  * @since 4.0.0
  */
 export interface RegExp extends instanceOf<globalThis.RegExp> {
@@ -11612,7 +11574,7 @@ export interface RegExp extends instanceOf<globalThis.RegExp> {
  *
  * The default JSON serializer encodes a `RegExp` as `{ source, flags }`.
  *
- * @category RegExp
+ * @category schemas
  * @since 4.0.0
  */
 export const RegExp: RegExp = instanceOf(
@@ -11637,7 +11599,7 @@ export const RegExp: RegExp = instanceOf(
           decode: (e) =>
             Effect.try({
               try: () => new globalThis.RegExp(e.source, e.flags),
-              catch: (e) => new SchemaIssue.InvalidValue(Option_.some(e), { message: globalThis.String(e) })
+              catch: () => new SchemaIssue.InvalidValue({ message: "Expected valid RegExp source and flags" })
             }),
           encode: (regExp) =>
             Effect.succeed({
@@ -11681,7 +11643,7 @@ export const RegExp: RegExp = instanceOf(
  *
  * @see {@link RegExp} for the corresponding schema
  *
- * @category RegExp
+ * @category schemas
  * @since 4.0.0
  */
 export const RegExpReviver = makeFixedDeclarationReviver(
@@ -11692,7 +11654,7 @@ export const RegExpReviver = makeFixedDeclarationReviver(
 /**
  * Type-level representation of {@link URL}.
  *
- * @category URL
+ * @category models
  * @since 4.0.0
  */
 export interface URL extends instanceOf<globalThis.URL> {
@@ -11710,7 +11672,7 @@ const URLString = String.annotate({ expected: "a string that will be decoded as
  *
  * - encodes `URL` as a `string`
  *
- * @category URL
+ * @category schemas
  * @since 4.0.0
  */
 export const URL: URL = instanceOf(
@@ -11744,7 +11706,7 @@ export const URL: URL = instanceOf(
  *
  * @see {@link URL} for the corresponding schema
  *
- * @category URL
+ * @category schemas
  * @since 4.0.0
  */
 export const URLReviver = makeFixedDeclarationReviver(
@@ -11755,7 +11717,7 @@ export const URLReviver = makeFixedDeclarationReviver(
 /**
  * Type-level representation of {@link URLFromString}.
  *
- * @category URL
+ * @category models
  * @since 4.0.0
  */
 export interface URLFromString extends decodeTo<URL, String> {
@@ -11773,7 +11735,7 @@ export interface URLFromString extends decodeTo<URL, String> {
  * Encoding:
  * - A `URL` is encoded as a `string`
  *
- * @category URL
+ * @category schemas
  * @since 4.0.0
  */
 export const URLFromString: URLFromString = URLString.pipe(decodeTo(URL, SchemaTransformation.urlFromString))
@@ -11781,7 +11743,7 @@ export const URLFromString: URLFromString = URLString.pipe(decodeTo(URL, SchemaT
 /**
  * Type-level representation of {@link Date}.
  *
- * @category Date
+ * @category models
  * @since 4.0.0
  */
 export interface Date extends declare<globalThis.Date> {
@@ -11828,17 +11790,17 @@ const DateString = String.annotate({ expected: "a string that will be decoded as
  *
  * **Example** (Defining a Date schema)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
- * Schema.decodeUnknownSync(Schema.Date)(new Date("2024-01-01"))
- * // => Date { 2024-01-01T00:00:00.000Z }
+ * const date = Schema.decodeUnknownSync(Schema.Date)(new Date("2024-01-01"))
+ * date.toISOString() // => "2024-01-01T00:00:00.000Z"
  * ```
  *
  * @see {@link DateFromString} for decoding strings into Date instances
  * @see {@link DateFromMillis} for decoding epoch milliseconds into Date instances
  *
- * @category Date
+ * @category schemas
  * @since 4.0.0
  */
 export const Date: Date = declare(
@@ -11875,7 +11837,7 @@ export const Date: Date = declare(
  *
  * @see {@link Date} for the corresponding schema
  *
- * @category Date
+ * @category schemas
  * @since 4.0.0
  */
 export const DateReviver = makeFixedDeclarationReviver(
@@ -11886,7 +11848,7 @@ export const DateReviver = makeFixedDeclarationReviver(
 /**
  * Type-level representation of {@link DateFromString}.
  *
- * @category Date
+ * @category models
  * @since 3.10.0
  */
 export interface DateFromString extends decodeTo<Date, String> {
@@ -11915,7 +11877,7 @@ export interface DateFromString extends decodeTo<Date, String> {
  * @see {@link DateTimeUtcFromString} for decoding date-time strings into UTC values
  * @see {@link Date} for accepting Date instances directly
  *
- * @category Date
+ * @category schemas
  * @since 3.10.0
  */
 export const DateFromString: DateFromString = DateString.pipe(decodeTo(Date, SchemaTransformation.dateFromString))
@@ -11923,7 +11885,7 @@ export const DateFromString: DateFromString = DateString.pipe(decodeTo(Date, Sch
 /**
  * Type-level representation of {@link DateFromMillis}.
  *
- * @category Date
+ * @category models
  * @since 4.0.0
  */
 export interface DateFromMillis extends decodeTo<Date, Int> {
@@ -11955,7 +11917,7 @@ export interface DateFromMillis extends decodeTo<Date, Int> {
  * @see {@link DateFromString} for decoding string-encoded dates
  * @see {@link DateTimeUtcFromMillis} for decoding epoch milliseconds into UTC values
  *
- * @category Date
+ * @category schemas
  * @since 4.0.0
  */
 export const DateFromMillis: DateFromMillis = Int.pipe(
@@ -11965,7 +11927,7 @@ export const DateFromMillis: DateFromMillis = Int.pipe(
 /**
  * Type-level representation of {@link Duration}.
  *
- * @category Duration
+ * @category models
  * @since 3.10.0
  */
 export interface Duration extends declare<Duration_.Duration> {
@@ -11982,14 +11944,13 @@ export interface Duration extends declare<Duration_.Duration> {
  *
  * **Example** (Defining a Duration schema)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Duration, Schema } from "effect"
  *
- * Schema.decodeUnknownSync(Schema.Duration)(Duration.seconds(5))
- * // => Duration(5s)
+ * Schema.decodeUnknownSync(Schema.Duration)(Duration.seconds(5)) // => Duration.seconds(5)
  * ```
  *
- * @category Duration
+ * @category schemas
  *
  * @since 3.10.0
  */
@@ -12062,7 +12023,7 @@ export const Duration: Duration = declare(
  *
  * @see {@link Duration} for the corresponding schema
  *
- * @category Duration
+ * @category schemas
  * @since 4.0.0
  */
 export const DurationReviver = makeFixedDeclarationReviver(
@@ -12075,7 +12036,7 @@ const DurationString = String.annotate({ expected: "a string that will be decode
 /**
  * Type-level representation of {@link DurationFromString}.
  *
- * @category Duration
+ * @category models
  * @since 4.0.0
  */
 export interface DurationFromString extends decodeTo<Duration, String> {
@@ -12094,7 +12055,7 @@ export interface DurationFromString extends decodeTo<Duration, String> {
  * Encoding:
  * - A `Duration` is encoded as a parseable `string`.
  *
- * @category Duration
+ * @category schemas
  * @since 4.0.0
  */
 export const DurationFromString: DurationFromString = DurationString.pipe(
@@ -12104,7 +12065,7 @@ export const DurationFromString: DurationFromString = DurationString.pipe(
 /**
  * Type-level representation of {@link DurationFromNanos}.
  *
- * @category Duration
+ * @category models
  * @since 3.10.0
  */
 export interface DurationFromNanos extends decodeTo<Duration, BigInt> {
@@ -12125,7 +12086,7 @@ export interface DurationFromNanos extends decodeTo<Duration, BigInt> {
  * fails when the duration cannot be represented as nanoseconds, such as
  * `Duration.infinity` or `Duration.negativeInfinity`.
  *
- * @category Duration
+ * @category schemas
  * @since 3.10.0
  */
 export const DurationFromNanos: DurationFromNanos = BigInt.pipe(
@@ -12135,7 +12096,7 @@ export const DurationFromNanos: DurationFromNanos = BigInt.pipe(
 /**
  * Type-level representation of {@link DurationFromMillis}.
  *
- * @category Duration
+ * @category models
  * @since 3.10.0
  */
 export interface DurationFromMillis extends decodeTo<Duration, Number> {
@@ -12158,7 +12119,7 @@ export interface DurationFromMillis extends decodeTo<Duration, Number> {
  *
  * `NaN` is decoded as `Duration.zero`, matching `Duration.millis`.
  *
- * @category Duration
+ * @category schemas
  * @since 3.10.0
  */
 export const DurationFromMillis: DurationFromMillis = Number.pipe(
@@ -12168,7 +12129,7 @@ export const DurationFromMillis: DurationFromMillis = Number.pipe(
 /**
  * Type-level representation of {@link BigDecimal}.
  *
- * @category BigDecimal
+ * @category models
  * @since 3.10.0
  */
 export interface BigDecimal extends declare<BigDecimal_.BigDecimal> {
@@ -12268,7 +12229,7 @@ function bigDecimalScaleConstraints(
  *
  * @see {@link BigDecimalFromString} for parsing string input into a BigDecimal
  *
- * @category BigDecimal
+ * @category schemas
  * @since 3.10.0
  */
 export const BigDecimal: BigDecimal = declare(
@@ -12320,7 +12281,7 @@ export const BigDecimal: BigDecimal = declare(
  *
  * @see {@link BigDecimal} for the corresponding schema
  *
- * @category BigDecimal
+ * @category schemas
  * @since 4.0.0
  */
 export const BigDecimalReviver = makeFixedDeclarationReviver(
@@ -12331,7 +12292,7 @@ export const BigDecimalReviver = makeFixedDeclarationReviver(
 /**
  * Type-level representation of {@link BigDecimalFromString}.
  *
- * @category BigDecimal
+ * @category models
  * @since 4.0.0
  */
 export interface BigDecimalFromString extends decodeTo<BigDecimal, String> {
@@ -12362,7 +12323,7 @@ export interface BigDecimalFromString extends decodeTo<BigDecimal, String> {
  * @see {@link BigIntFromString} for parsing base-10 integer strings into bigint values
  * @see {@link NumberFromString} for parsing JavaScript number strings
  *
- * @category BigDecimal
+ * @category schemas
  * @since 4.0.0
  */
 export const BigDecimalFromString: BigDecimalFromString = BigDecimalString.pipe(
@@ -12374,43 +12335,6 @@ const JsonString = String.annotate({
   contentMediaType: "application/json"
 })
 
-/**
- * Type-level representation of {@link UnknownFromJsonString}.
- *
- * @category models
- * @since 4.0.0
- */
-export interface UnknownFromJsonString extends fromJsonString<Unknown> {
-  readonly "Rebuild": UnknownFromJsonString
-}
-
-/**
- * Schema that decodes a JSON-encoded string into an `unknown` value.
- *
- * **Details**
- *
- * Decoding:
- * - A `string` is decoded as an `unknown` value.
- * - If the string is not valid JSON, decoding fails.
- *
- * Encoding:
- * - Any value is encoded as a JSON string using `JSON.stringify`.
- * - If the value is not a valid JSON value, encoding fails.
- *
- * **Example** (Decoding unknown JSON strings)
- *
- * ```ts
- * import { Schema } from "effect"
- *
- * Schema.decodeUnknownSync(Schema.UnknownFromJsonString)(`{"a":1,"b":2}`)
- * // => { a: 1, b: 2 }
- * ```
- *
- * @category schemas
- * @since 4.0.0
- */
-export const UnknownFromJsonString: UnknownFromJsonString = fromJsonString(Unknown)
-
 /**
  * Type-level representation returned by {@link fromJsonString}.
  *
@@ -12430,32 +12354,44 @@ export interface fromJsonString<S extends Constraint> extends decodeTo<S, String
  * This is useful when working with JSON-encoded strings where the actual
  * structure of the value is known and described by an existing schema.
  *
- * The resulting schema first parses the input string as JSON, and then runs the
- * provided schema on the parsed result.
+ * During decoding, the resulting schema first parses the input string as JSON,
+ * using `reviver` when provided, and then runs the provided schema on the
+ * parsed result. During encoding, it first encodes with the provided schema and
+ * then passes the result to `JSON.stringify` with the optional `replacer` and
+ * `space`.
  *
- * **Example** (Decoding JSON strings with a schema)
+ * **Example** (Formatting encoded JSON)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.Struct({ a: Schema.Number })
- * const schemaFromJsonString = Schema.fromJsonString(schema)
+ * const schemaFromJsonString = Schema.fromJsonString(schema, { space: 2 })
  *
- * Schema.decodeUnknownSync(schemaFromJsonString)(`{"a":1,"b":2}`)
- * // => { a: 1 }
+ * Schema.encodeSync(schemaFromJsonString)({ a: 1 }) // => "{\n  \"a\": 1\n}"
  * ```
  *
- * @category constructors
+ * @category schemas
  * @since 4.0.0
  */
-export function fromJsonString<S extends Constraint>(schema: S): fromJsonString<S> {
-  return JsonString.pipe(decodeTo(schema, SchemaTransformation.fromJsonString))
+export function fromJsonString<S extends Constraint>(
+  schema: S,
+  options?: {
+    readonly reviver?: Parameters<typeof JSON.parse>[1] | undefined
+    readonly replacer?: SchemaGetter.JsonReplacer | undefined
+    readonly space?: Parameters<typeof JSON.stringify>[2] | undefined
+  }
+): fromJsonString<S> {
+  return JsonString.pipe(decodeTo(schema, SchemaTransformation.fromJsonString(options)))
 }
 
+/** @internal */
+export const UnknownFromJsonString: fromJsonString<Unknown> = fromJsonString(Unknown)
+
 /**
  * Type-level representation of {@link File}.
  *
- * @category file
+ * @category models
  * @since 4.0.0
  */
 export interface File extends instanceOf<globalThis.File> {
@@ -12470,7 +12406,7 @@ export interface File extends instanceOf<globalThis.File> {
  * The default JSON serializer encodes a `File` as `{ data, type, name, lastModified }`
  * where `data` is base64-encoded.
  *
- * @category file
+ * @category schemas
  * @since 4.0.0
  */
 export const File: File = instanceOf(globalThis.File, {
@@ -12494,10 +12430,10 @@ export const File: File = instanceOf(globalThis.File, {
       SchemaTransformation.transformOrFail({
         decode: (e) =>
           Result_.match(Encoding.decodeBase64(e.data), {
-            onFailure: (error) =>
+            onFailure: () =>
               Effect.fail(
-                new SchemaIssue.InvalidValue(Option_.some(e.data), {
-                  message: error.message
+                new SchemaIssue.InvalidValue({
+                  message: "Expected a valid Base64 string"
                 })
               ),
             onSuccess: (bytes) => {
@@ -12518,9 +12454,9 @@ export const File: File = instanceOf(globalThis.File, {
                 lastModified: file.lastModified
               }
             },
-            catch: (e) =>
-              new SchemaIssue.InvalidValue(Option_.some(file), {
-                message: globalThis.String(e)
+            catch: () =>
+              new SchemaIssue.InvalidValue({
+                message: "Expected File to be readable"
               })
           })
       })
@@ -12536,7 +12472,7 @@ export const File: File = instanceOf(globalThis.File, {
  *
  * @see {@link File} for the corresponding schema
  *
- * @category file
+ * @category schemas
  * @since 4.0.0
  */
 export const FileReviver = makeFixedDeclarationReviver(
@@ -12547,7 +12483,7 @@ export const FileReviver = makeFixedDeclarationReviver(
 /**
  * Type-level representation of {@link FormData}.
  *
- * @category FormData
+ * @category models
  * @since 4.0.0
  */
 export interface FormData extends instanceOf<globalThis.FormData> {
@@ -12562,7 +12498,7 @@ export interface FormData extends instanceOf<globalThis.FormData> {
  * The default JSON serializer encodes a `FormData` as an array of `[key, entry]`
  * pairs where each entry is tagged as `"String"` or `"File"`.
  *
- * @category FormData
+ * @category schemas
  * @since 4.0.0
  */
 export const FormData: FormData = instanceOf(globalThis.FormData, {
@@ -12618,7 +12554,7 @@ export const FormData: FormData = instanceOf(globalThis.FormData, {
  *
  * @see {@link FormData} for the corresponding schema
  *
- * @category FormData
+ * @category schemas
  * @since 4.0.0
  */
 export const FormDataReviver = makeFixedDeclarationReviver(
@@ -12629,7 +12565,7 @@ export const FormDataReviver = makeFixedDeclarationReviver(
 /**
  * Type-level representation returned by {@link fromFormData}.
  *
- * @category FormData
+ * @category models
  * @since 4.0.0
  */
 export interface fromFormData<S extends Constraint> extends decodeTo<S, FormData> {
@@ -12657,7 +12593,7 @@ export interface fromFormData<S extends Constraint> extends decodeTo<S, FormData
  *
  * **Example** (Decoding a flat structure)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.fromFormData(
@@ -12670,13 +12606,12 @@ export interface fromFormData<S extends Constraint> extends decodeTo<S, FormData
  * formData.append("a", "1")
  * formData.append("b", "2")
  *
- * console.log(String(Schema.decodeUnknownExit(schema)(formData)))
- * // Success({"a":"1"})
+ * Schema.decodeUnknownSync(schema)(formData) // => { a: "1" }
  * ```
  *
  * **Example** (Decoding nested fields)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.fromFormData(
@@ -12694,13 +12629,12 @@ export interface fromFormData<S extends Constraint> extends decodeTo<S, FormData
  * formData.append("b[c]", "2")
  * formData.append("b[d]", "3")
  *
- * console.log(String(Schema.decodeUnknownExit(schema)(formData)))
- * // Success({"a":"1","b":{"c":"2","d":"3"}})
+ * Schema.decodeUnknownSync(schema)(formData) // => { a: "1", b: { c: "2", d: "3" } }
  * ```
  *
  * **Example** (Parsing non-string values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.fromFormData(
@@ -12714,8 +12648,7 @@ export interface fromFormData<S extends Constraint> extends decodeTo<S, FormData
  * const formData = new FormData()
  * formData.append("a", "1")
  *
- * console.log(String(Schema.decodeUnknownExit(schema)(formData)))
- * // Success({"a":1}) // Note: the value is a number
+ * Schema.decodeUnknownSync(schema)(formData) // => { a: 1 }
  * ```
  *
  * @category decoding
@@ -12728,7 +12661,7 @@ export function fromFormData<S extends Constraint>(schema: S): fromFormData<S> {
 /**
  * Type-level representation of {@link URLSearchParams}.
  *
- * @category search params
+ * @category models
  * @since 4.0.0
  */
 export interface URLSearchParams extends instanceOf<globalThis.URLSearchParams> {
@@ -12742,7 +12675,7 @@ export interface URLSearchParams extends instanceOf<globalThis.URLSearchParams>
  *
  * The default JSON serializer encodes a `URLSearchParams` as a query string.
  *
- * @category search params
+ * @category schemas
  * @since 4.0.0
  */
 export const URLSearchParams: URLSearchParams = instanceOf(globalThis.URLSearchParams, {
@@ -12774,7 +12707,7 @@ export const URLSearchParams: URLSearchParams = instanceOf(globalThis.URLSearchP
  *
  * @see {@link URLSearchParams} for the corresponding schema
  *
- * @category search params
+ * @category schemas
  * @since 4.0.0
  */
 export const URLSearchParamsReviver = makeFixedDeclarationReviver(
@@ -12785,7 +12718,7 @@ export const URLSearchParamsReviver = makeFixedDeclarationReviver(
 /**
  * Type-level representation returned by {@link fromURLSearchParams}.
  *
- * @category search params
+ * @category models
  * @since 4.0.0
  */
 export interface fromURLSearchParams<S extends Constraint> extends decodeTo<S, URLSearchParams> {
@@ -12814,7 +12747,7 @@ export interface fromURLSearchParams<S extends Constraint> extends decodeTo<S, U
  *
  * **Example** (Decoding a flat structure)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.fromURLSearchParams(
@@ -12825,13 +12758,12 @@ export interface fromURLSearchParams<S extends Constraint> extends decodeTo<S, U
  *
  * const urlSearchParams = new URLSearchParams("a=1&b=2")
  *
- * console.log(String(Schema.decodeUnknownExit(schema)(urlSearchParams)))
- * // Success({"a":"1"})
+ * Schema.decodeUnknownSync(schema)(urlSearchParams) // => { a: "1" }
  * ```
  *
  * **Example** (Decoding nested fields)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.fromURLSearchParams(
@@ -12846,13 +12778,12 @@ export interface fromURLSearchParams<S extends Constraint> extends decodeTo<S, U
  *
  * const urlSearchParams = new URLSearchParams("a=1&b[c]=2&b[d]=3")
  *
- * console.log(String(Schema.decodeUnknownExit(schema)(urlSearchParams)))
- * // Success({"a":"1","b":{"c":"2","d":"3"}})
+ * Schema.decodeUnknownSync(schema)(urlSearchParams) // => { a: "1", b: { c: "2", d: "3" } }
  * ```
  *
  * **Example** (Parsing non-string values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const schema = Schema.fromURLSearchParams(
@@ -12865,8 +12796,7 @@ export interface fromURLSearchParams<S extends Constraint> extends decodeTo<S, U
  *
  * const urlSearchParams = new URLSearchParams("a=1&b=2")
  *
- * console.log(String(Schema.decodeUnknownExit(schema)(urlSearchParams)))
- * // Success({"a":1}) // Note: the value is a number
+ * Schema.decodeUnknownSync(schema)(urlSearchParams) // => { a: 1 }
  * ```
  *
  * @category decoding
@@ -12879,7 +12809,7 @@ export function fromURLSearchParams<S extends Constraint>(schema: S): fromURLSea
 /**
  * Type-level representation of {@link NumberFromString}.
  *
- * @category Number
+ * @category models
  * @since 3.10.0
  */
 export interface NumberFromString extends decodeTo<Number, String> {
@@ -12900,7 +12830,7 @@ export interface NumberFromString extends decodeTo<Number, String> {
  * Encoding:
  * A number is encoded as a `string`.
  *
- * @category Number
+ * @category schemas
  * @since 3.10.0
  */
 export const NumberFromString: NumberFromString = String.annotate({
@@ -12910,7 +12840,7 @@ export const NumberFromString: NumberFromString = String.annotate({
 /**
  * Type-level representation of {@link FiniteFromString}.
  *
- * @category Number
+ * @category models
  * @since 4.0.0
  */
 export interface FiniteFromString extends decodeTo<Finite, String> {
@@ -12929,7 +12859,7 @@ export interface FiniteFromString extends decodeTo<Finite, String> {
  * Encoding:
  * - A finite number is encoded as a `string`.
  *
- * @category Number
+ * @category schemas
  * @since 4.0.0
  */
 export const FiniteFromString: FiniteFromString = String.annotate({
@@ -12939,7 +12869,7 @@ export const FiniteFromString: FiniteFromString = String.annotate({
 /**
  * Type-level representation of {@link BigIntFromString}.
  *
- * @category BigInt
+ * @category models
  * @since 4.0.0
  */
 export interface BigIntFromString extends decodeTo<BigInt, String> {
@@ -12971,7 +12901,7 @@ export interface BigIntFromString extends decodeTo<BigInt, String> {
  * @see {@link NumberFromString} for parsing JavaScript number strings, including non-finite values
  * @see {@link BigDecimalFromString} for parsing decimal number strings
  *
- * @category BigInt
+ * @category schemas
  * @since 4.0.0
  */
 export const BigIntFromString: BigIntFromString = make<String>(SchemaAST.bigIntString).pipe(
@@ -12981,7 +12911,7 @@ export const BigIntFromString: BigIntFromString = make<String>(SchemaAST.bigIntS
 /**
  * Type-level representation of {@link Trimmed}.
  *
- * @category string
+ * @category models
  * @since 3.10.0
  */
 export interface Trimmed extends String {
@@ -12991,7 +12921,7 @@ export interface Trimmed extends String {
 /**
  * Schema for strings that contains no leading or trailing whitespaces.
  *
- * @category string
+ * @category schemas
  * @since 3.10.0
  */
 export const Trimmed: Trimmed = String.check(isTrimmed())
@@ -12999,7 +12929,7 @@ export const Trimmed: Trimmed = String.check(isTrimmed())
 /**
  * Type-level representation of {@link Trim}.
  *
- * @category string
+ * @category models
  * @since 3.10.0
  */
 export interface Trim extends decodeTo<Trimmed, String> {
@@ -13017,7 +12947,7 @@ export interface Trim extends decodeTo<Trimmed, String> {
  * Encoding:
  * - The trimmed string is encoded as is.
  *
- * @category string
+ * @category schemas
  * @since 3.10.0
  */
 export const Trim: Trim = String.annotate({
@@ -13027,7 +12957,7 @@ export const Trim: Trim = String.annotate({
 /**
  * Type-level representation of {@link StringFromBase64}.
  *
- * @category string
+ * @category models
  * @since 3.10.0
  */
 export interface StringFromBase64 extends decodeTo<String, String> {
@@ -13045,7 +12975,7 @@ export interface StringFromBase64 extends decodeTo<String, String> {
  * Encoding:
  * - A `string` is encoded as a base64-encoded string.
  *
- * @category string
+ * @category schemas
  * @since 3.10.0
  */
 export const StringFromBase64: StringFromBase64 = String.annotate({
@@ -13057,7 +12987,7 @@ export const StringFromBase64: StringFromBase64 = String.annotate({
 /**
  * Type-level representation of {@link StringFromBase64Url}.
  *
- * @category string
+ * @category models
  * @since 3.10.0
  */
 export interface StringFromBase64Url extends decodeTo<String, String> {
@@ -13075,7 +13005,7 @@ export interface StringFromBase64Url extends decodeTo<String, String> {
  * Encoding:
  * - A `string` is encoded as a base64 (URL) encoded string.
  *
- * @category string
+ * @category schemas
  * @since 3.10.0
  */
 export const StringFromBase64Url: StringFromBase64Url = String.annotate({
@@ -13087,7 +13017,7 @@ export const StringFromBase64Url: StringFromBase64Url = String.annotate({
 /**
  * Type-level representation of {@link StringFromHex}.
  *
- * @category string
+ * @category models
  * @since 3.10.0
  */
 export interface StringFromHex extends decodeTo<String, String> {
@@ -13105,7 +13035,7 @@ export interface StringFromHex extends decodeTo<String, String> {
  * Encoding:
  * - A `string` is encoded as a hex string.
  *
- * @category string
+ * @category schemas
  * @since 3.10.0
  */
 export const StringFromHex: StringFromHex = String.annotate({
@@ -13117,7 +13047,7 @@ export const StringFromHex: StringFromHex = String.annotate({
 /**
  * Type-level representation of {@link StringFromUriComponent}.
  *
- * @category string
+ * @category models
  * @since 3.12.0
  */
 export interface StringFromUriComponent extends decodeTo<String, String> {
@@ -13138,7 +13068,7 @@ export interface StringFromUriComponent extends decodeTo<String, String> {
  *
  * **Example** (Decoding URI component strings)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const PaginationSchema = Schema.Struct({
@@ -13150,11 +13080,10 @@ export interface StringFromUriComponent extends decodeTo<String, String> {
  *   Schema.decodeTo(Schema.fromJsonString(PaginationSchema))
  * )
  *
- * console.log(Schema.encodeSync(UrlSchema)({ maxItemPerPage: 10, page: 1 }))
- * // %7B%22maxItemPerPage%22%3A10%2C%22page%22%3A1%7D
+ * Schema.encodeSync(UrlSchema)({ maxItemPerPage: 10, page: 1 }) // => "%7B%22maxItemPerPage%22%3A10%2C%22page%22%3A1%7D"
  * ```
  *
- * @category string
+ * @category schemas
  * @since 3.12.0
  */
 export const StringFromUriComponent: StringFromUriComponent = String.annotate({
@@ -13167,7 +13096,7 @@ export const StringFromUriComponent: StringFromUriComponent = String.annotate({
  * Schema for property keys accepted by Effect schemas: finite `number`,
  * `symbol`, or `string`.
  *
- * @category PropertyKey
+ * @category schemas
  * @since 4.0.0
  */
 export const PropertyKey = Union([Finite, Symbol, String])
@@ -13180,7 +13109,7 @@ export const PropertyKey = Union([Finite, Symbol, String])
  * The result contains an `issues` array where each issue has a message and an
  * optional path made of property keys or keyed path segments.
  *
- * @category Standard Schema
+ * @category schemas
  * @since 4.0.0
  */
 export const StandardSchemaV1FailureResult = Struct({
@@ -13193,7 +13122,7 @@ export const StandardSchemaV1FailureResult = Struct({
 /**
  * Type-level representation of {@link BooleanFromBit}.
  *
- * @category boolean
+ * @category models
  * @since 4.0.0
  */
 export interface BooleanFromBit extends decodeTo<Boolean, Literals<readonly [0, 1]>> {
@@ -13216,7 +13145,7 @@ export interface BooleanFromBit extends decodeTo<Boolean, Literals<readonly [0,
  * @see {@link Boolean} for validating values that are already booleans
  * @see {@link Literals} for keeping bit literals instead of decoding them
  *
- * @category boolean
+ * @category schemas
  * @since 4.0.0
  */
 export const BooleanFromBit: BooleanFromBit = Literals([0, 1]).pipe(
@@ -13232,7 +13161,7 @@ export const BooleanFromBit: BooleanFromBit = Literals([0, 1]).pipe(
 /**
  * Type-level representation of {@link Uint8Array}.
  *
- * @category Uint8Array
+ * @category models
  * @since 4.0.0
  */
 export interface Uint8Array extends instanceOf<globalThis.Uint8Array<ArrayBufferLike>> {
@@ -13254,7 +13183,7 @@ const Base64String = String.annotate({
  *
  * The default JSON serializer encodes Uint8Array as a Base64 encoded string.
  *
- * @category Uint8Array
+ * @category schemas
  * @since 4.0.0
  */
 export const Uint8Array: Uint8Array = instanceOf(globalThis.Uint8Array<ArrayBufferLike>, {
@@ -13284,7 +13213,7 @@ export const Uint8Array: Uint8Array = instanceOf(globalThis.Uint8Array<ArrayBuff
  *
  * @see {@link Uint8Array} for the corresponding schema
  *
- * @category Uint8Array
+ * @category schemas
  * @since 4.0.0
  */
 export const Uint8ArrayReviver = makeFixedDeclarationReviver(
@@ -13295,7 +13224,7 @@ export const Uint8ArrayReviver = makeFixedDeclarationReviver(
 /**
  * Type-level representation of {@link Uint8ArrayFromBase64}.
  *
- * @category Uint8Array
+ * @category models
  * @since 3.10.0
  */
 export interface Uint8ArrayFromBase64 extends decodeTo<Uint8Array, String> {
@@ -13314,7 +13243,7 @@ export interface Uint8ArrayFromBase64 extends decodeTo<Uint8Array, String> {
  * Encoding:
  * - A `Uint8Array` is encoded as a base64-encoded string.
  *
- * @category Uint8Array
+ * @category schemas
  * @since 3.10.0
  */
 export const Uint8ArrayFromBase64: Uint8ArrayFromBase64 = Base64String.pipe(
@@ -13324,7 +13253,7 @@ export const Uint8ArrayFromBase64: Uint8ArrayFromBase64 = Base64String.pipe(
 /**
  * Type-level representation of {@link Uint8ArrayFromBase64Url}.
  *
- * @category Uint8Array
+ * @category models
  * @since 3.10.0
  */
 export interface Uint8ArrayFromBase64Url extends decodeTo<Uint8Array, String> {
@@ -13343,7 +13272,7 @@ export interface Uint8ArrayFromBase64Url extends decodeTo<Uint8Array, String> {
  * Encoding:
  * - A `Uint8Array` is encoded as a base64 (URL) encoded string.
  *
- * @category Uint8Array
+ * @category schemas
  * @since 3.10.0
  */
 export const Uint8ArrayFromBase64Url: Uint8ArrayFromBase64Url = String.annotate({
@@ -13358,7 +13287,7 @@ export const Uint8ArrayFromBase64Url: Uint8ArrayFromBase64Url = String.annotate(
 /**
  * Type-level representation of {@link Uint8ArrayFromHex}.
  *
- * @category Uint8Array
+ * @category models
  * @since 3.10.0
  */
 export interface Uint8ArrayFromHex extends decodeTo<Uint8Array, String> {
@@ -13377,7 +13306,7 @@ export interface Uint8ArrayFromHex extends decodeTo<Uint8Array, String> {
  * Encoding:
  * - A `Uint8Array` is encoded as a hex encoded string.
  *
- * @category Uint8Array
+ * @category schemas
  * @since 3.10.0
  */
 export const Uint8ArrayFromHex: Uint8ArrayFromHex = String.annotate({
@@ -13392,7 +13321,7 @@ export const Uint8ArrayFromHex: Uint8ArrayFromHex = String.annotate({
 /**
  * Type-level representation of {@link DateTimeUtc}.
  *
- * @category DateTime
+ * @category models
  * @since 3.10.0
  */
 export interface DateTimeUtc extends declare<DateTime.Utc> {
@@ -13417,7 +13346,7 @@ export interface DateTimeUtc extends declare<DateTime.Utc> {
  * @see {@link DateTimeUtcFromMillis} for decoding epoch milliseconds into UTC values
  * @see {@link DateTimeZoned} for preserving zoned DateTime values
  *
- * @category DateTime
+ * @category schemas
  * @since 3.10.0
  */
 export const DateTimeUtc: DateTimeUtc = declare(
@@ -13459,7 +13388,7 @@ export const DateTimeUtc: DateTimeUtc = declare(
  *
  * @see {@link DateTimeUtc} for the corresponding schema
  *
- * @category DateTime
+ * @category schemas
  * @since 4.0.0
  */
 export const DateTimeUtcReviver = makeFixedDeclarationReviver(
@@ -13470,7 +13399,7 @@ export const DateTimeUtcReviver = makeFixedDeclarationReviver(
 /**
  * Type-level representation of {@link DateTimeUtcFromDate}.
  *
- * @category DateTime
+ * @category models
  * @since 3.12.0
  */
 export interface DateTimeUtcFromDate extends decodeTo<DateTimeUtc, Date> {
@@ -13498,7 +13427,7 @@ export interface DateTimeUtcFromDate extends decodeTo<DateTimeUtc, Date> {
  * @see {@link DateTimeUtcFromMillis} for decoding epoch milliseconds into UTC values
  * @see {@link Date} for validating Date instances without converting them
  *
- * @category DateTime
+ * @category schemas
  * @since 3.12.0
  */
 export const DateTimeUtcFromDate: DateTimeUtcFromDate = Date.pipe(
@@ -13511,7 +13440,7 @@ export const DateTimeUtcFromDate: DateTimeUtcFromDate = Date.pipe(
 /**
  * Type-level representation of {@link DateTimeUtcFromString}.
  *
- * @category DateTime
+ * @category models
  * @since 4.0.0
  */
 export interface DateTimeUtcFromString extends decodeTo<DateTimeUtc, String> {
@@ -13536,7 +13465,7 @@ export interface DateTimeUtcFromString extends decodeTo<DateTimeUtc, String> {
  * @see {@link DateTimeUtcFromMillis} for decoding epoch milliseconds into UTC values
  * @see {@link DateFromString} for decoding strings into JavaScript Date instances
  *
- * @category DateTime
+ * @category schemas
  * @since 4.0.0
  */
 export const DateTimeUtcFromString: DateTimeUtcFromString = String.annotate({
@@ -13551,7 +13480,7 @@ export const DateTimeUtcFromString: DateTimeUtcFromString = String.annotate({
 /**
  * Type-level representation of {@link DateTimeUtcFromMillis}.
  *
- * @category DateTime
+ * @category models
  * @since 4.0.0
  */
 export interface DateTimeUtcFromMillis extends decodeTo<instanceOf<DateTime.Utc>, Int> {
@@ -13573,7 +13502,7 @@ export interface DateTimeUtcFromMillis extends decodeTo<instanceOf<DateTime.Utc>
  * @see {@link DateTimeUtcFromString} for decoding date-time strings into UTC values
  * @see {@link DateFromMillis} for decoding epoch milliseconds into JavaScript Date instances
  *
- * @category DateTime
+ * @category schemas
  * @since 4.0.0
  */
 export const DateTimeUtcFromMillis: DateTimeUtcFromMillis = Int.pipe(
@@ -13586,7 +13515,7 @@ export const DateTimeUtcFromMillis: DateTimeUtcFromMillis = Int.pipe(
 /**
  * Type-level representation of {@link TimeZoneOffset}.
  *
- * @category DateTime
+ * @category models
  * @since 3.10.0
  */
 export interface TimeZoneOffset extends declare<DateTime.TimeZone.Offset> {
@@ -13602,7 +13531,7 @@ export interface TimeZoneOffset extends declare<DateTime.TimeZone.Offset> {
  *
  * - encodes `DateTime.TimeZone.Offset` as a number (offset in milliseconds)
  *
- * @category DateTime
+ * @category schemas
  * @since 3.10.0
  */
 export const TimeZoneOffset: TimeZoneOffset = declare(
@@ -13639,7 +13568,7 @@ export const TimeZoneOffset: TimeZoneOffset = declare(
  *
  * @see {@link TimeZoneOffset} for the corresponding schema
  *
- * @category DateTime
+ * @category schemas
  * @since 4.0.0
  */
 export const TimeZoneOffsetReviver = makeFixedDeclarationReviver(
@@ -13650,7 +13579,7 @@ export const TimeZoneOffsetReviver = makeFixedDeclarationReviver(
 /**
  * Type-level representation of {@link TimeZoneNamed}.
  *
- * @category DateTime
+ * @category models
  * @since 3.10.0
  */
 export interface TimeZoneNamed extends declare<DateTime.TimeZone.Named> {
@@ -13668,7 +13597,7 @@ const TimeZoneNamedString = String.annotate({ expected: "an IANA time zone ident
  *
  * - encodes `DateTime.TimeZone.Named` as a string (IANA time zone identifier)
  *
- * @category DateTime
+ * @category schemas
  * @since 3.10.0
  */
 export const TimeZoneNamed: TimeZoneNamed = declare(
@@ -13709,7 +13638,7 @@ export const TimeZoneNamed: TimeZoneNamed = declare(
  *
  * @see {@link TimeZoneNamed} for the corresponding schema
  *
- * @category DateTime
+ * @category schemas
  * @since 4.0.0
  */
 export const TimeZoneNamedReviver = makeFixedDeclarationReviver(
@@ -13720,7 +13649,7 @@ export const TimeZoneNamedReviver = makeFixedDeclarationReviver(
 /**
  * Type-level representation of {@link TimeZoneNamedFromString}.
  *
- * @category DateTime
+ * @category models
  * @since 4.0.0
  */
 export interface TimeZoneNamedFromString extends decodeTo<TimeZoneNamed, String> {
@@ -13738,7 +13667,7 @@ export interface TimeZoneNamedFromString extends decodeTo<TimeZoneNamed, String>
  * Encoding:
  * - A `DateTime.TimeZone.Named` is encoded as a `string`.
  *
- * @category DateTime
+ * @category schemas
  * @since 4.0.0
  */
 export const TimeZoneNamedFromString: TimeZoneNamedFromString = TimeZoneNamedString.pipe(
@@ -13748,7 +13677,7 @@ export const TimeZoneNamedFromString: TimeZoneNamedFromString = TimeZoneNamedStr
 /**
  * Type-level representation of {@link TimeZone}.
  *
- * @category DateTime
+ * @category models
  * @since 3.10.0
  */
 export interface TimeZone extends declare<DateTime.TimeZone> {
@@ -13769,7 +13698,7 @@ const TimeZoneString = String.annotate({
  * - encodes `DateTime.TimeZone` as a string (IANA identifier or offset like
  *   `+03:00`)
  *
- * @category DateTime
+ * @category schemas
  * @since 3.10.0
  */
 export const TimeZone: TimeZone = declare(
@@ -13813,7 +13742,7 @@ export const TimeZone: TimeZone = declare(
  *
  * @see {@link TimeZone} for the corresponding schema
  *
- * @category DateTime
+ * @category schemas
  * @since 4.0.0
  */
 export const TimeZoneReviver = makeFixedDeclarationReviver(
@@ -13824,7 +13753,7 @@ export const TimeZoneReviver = makeFixedDeclarationReviver(
 /**
  * Type-level representation of {@link TimeZoneFromString}.
  *
- * @category DateTime
+ * @category models
  * @since 4.0.0
  */
 export interface TimeZoneFromString extends decodeTo<TimeZone, String> {
@@ -13842,7 +13771,7 @@ export interface TimeZoneFromString extends decodeTo<TimeZone, String> {
  * Encoding:
  * - A `DateTime.TimeZone` is encoded as a `string`.
  *
- * @category DateTime
+ * @category schemas
  * @since 4.0.0
  */
 export const TimeZoneFromString: TimeZoneFromString = TimeZoneString.pipe(
@@ -13852,7 +13781,7 @@ export const TimeZoneFromString: TimeZoneFromString = TimeZoneString.pipe(
 /**
  * Type-level representation of {@link DateTimeZoned}.
  *
- * @category DateTime
+ * @category models
  * @since 3.10.0
  */
 export interface DateTimeZoned extends declare<DateTime.Zoned> {
@@ -13875,7 +13804,7 @@ const DateTimeZonedString = String.annotate({
  * - encodes named zones by appending the IANA identifier in brackets, such as
  *   `YYYY-MM-DDTHH:mm:ss.sss+HH:MM[Time/Zone]`
  *
- * @category DateTime
+ * @category schemas
  * @since 3.10.0
  */
 export const DateTimeZoned: DateTimeZoned = declare(
@@ -13923,7 +13852,7 @@ export const DateTimeZoned: DateTimeZoned = declare(
  *
  * @see {@link DateTimeZoned} for the corresponding schema
  *
- * @category DateTime
+ * @category schemas
  * @since 4.0.0
  */
 export const DateTimeZonedReviver = makeFixedDeclarationReviver(
@@ -13934,7 +13863,7 @@ export const DateTimeZonedReviver = makeFixedDeclarationReviver(
 /**
  * Type-level representation of {@link DateTimeZonedFromString}.
  *
- * @category DateTime
+ * @category models
  * @since 4.0.0
  */
 export interface DateTimeZonedFromString extends decodeTo<DateTimeZoned, String> {
@@ -13952,7 +13881,7 @@ export interface DateTimeZonedFromString extends decodeTo<DateTimeZoned, String>
  * Encoding:
  * - A `DateTime.Zoned` is encoded as a `string`.
  *
- * @category DateTime
+ * @category schemas
  * @since 4.0.0
  */
 export const DateTimeZonedFromString: DateTimeZonedFromString = DateTimeZonedString.pipe(
@@ -14172,7 +14101,14 @@ function makeClass<
 
 function getClassTransformation(self: new(...args: ReadonlyArray<any>) => any) {
   return new SchemaTransformation.Transformation<any, any, never, never>(
-    SchemaGetter.transform((input) => new self(input)),
+    SchemaGetter.transform((input) =>
+      new self(input, {
+        "~payload": {
+          token: payloadToken,
+          value: input
+        }
+      })
+    ),
     SchemaGetter.passthrough()
   )
 }
@@ -14201,7 +14137,7 @@ function getClassSchemaFactory<S extends Constraint>(
           return input instanceof self ||
               Predicate.hasProperty(input, getClassTypeId(identifier)) ?
             Effect.succeed(input) :
-            Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)))
+            Effect.fail(new SchemaIssue.InvalidType(ast))
         },
         {
           identifier,
@@ -14244,13 +14180,23 @@ type MissingSelfGeneric<Usage extends string> =
  * Pass the desired class type as the first type parameter. The second optional
  * type parameter can be used to add nominal brands.
  *
+ * The `identifier` is the schema's stable runtime name. It is exposed on the
+ * class, stored in the schema AST, and used to label diagnostics and generated
+ * references as well as to format class instances.
+ *
+ * It also derives a runtime marker that recognizes instances across hot module
+ * reloads, where `instanceof` can fail because the constructor has been
+ * replaced. The identifier is explicit because the outer JavaScript class name
+ * is not available while the `extends` expression is evaluated and may change
+ * through renaming or minification.
+ *
  * **Gotchas**
  *
  * Passing `disableChecks` in the options skips constructor validation.
  *
  * **Example** (Defining a basic class)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * class Person extends Schema.Class<Person>("Person")({
@@ -14259,13 +14205,13 @@ type MissingSelfGeneric<Usage extends string> =
  * }) {}
  *
  * const alice = new Person({ name: "Alice", age: 30 })
- * console.log(alice.name) // "Alice"
- * console.log(`${alice}`) // "Person({ name: Alice, age: 30 })"
+ * alice.name // => "Alice"
+ * String(alice) // => "Person({\"name\":\"Alice\",\"age\":30})"
  * ```
  *
  * **Example** (Extending a class)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * class Animal extends Schema.Class<Animal>("Animal")({
@@ -14277,8 +14223,8 @@ type MissingSelfGeneric<Usage extends string> =
  * }) {}
  *
  * const dog = new Dog({ name: "Rex", breed: "Labrador" })
- * console.log(dog.name) // "Rex"
- * console.log(dog.breed) // "Labrador"
+ * dog.name // => "Rex"
+ * dog.breed // => "Labrador"
  * ```
  *
  * @see {@link TaggedClass} for adding a `_tag` literal field to the class schema
@@ -14304,13 +14250,23 @@ export const Class: {
    * Pass the desired class type as the first type parameter. The second optional
    * type parameter can be used to add nominal brands.
    *
+   * The `identifier` is the schema's stable runtime name. It is exposed on the
+   * class, stored in the schema AST, and used to label diagnostics and generated
+   * references as well as to format class instances.
+   *
+   * It also derives a runtime marker that recognizes instances across hot module
+   * reloads, where `instanceof` can fail because the constructor has been
+   * replaced. The identifier is explicit because the outer JavaScript class name
+   * is not available while the `extends` expression is evaluated and may change
+   * through renaming or minification.
+   *
    * **Gotchas**
    *
    * Passing `disableChecks` in the options skips constructor validation.
    *
    * **Example** (Defining a basic class)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Schema } from "effect"
    *
    * class Person extends Schema.Class<Person>("Person")({
@@ -14319,13 +14275,13 @@ export const Class: {
    * }) {}
    *
    * const alice = new Person({ name: "Alice", age: 30 })
-   * console.log(alice.name) // "Alice"
-   * console.log(`${alice}`) // "Person({ name: Alice, age: 30 })"
+   * alice.name // => "Alice"
+   * String(alice) // => "Person({\"name\":\"Alice\",\"age\":30})"
    * ```
    *
    * **Example** (Extending a class)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Schema } from "effect"
    *
    * class Animal extends Schema.Class<Animal>("Animal")({
@@ -14337,8 +14293,8 @@ export const Class: {
    * }) {}
    *
    * const dog = new Dog({ name: "Rex", breed: "Labrador" })
-   * console.log(dog.name) // "Rex"
-   * console.log(dog.breed) // "Labrador"
+   * dog.name // => "Rex"
+   * dog.breed // => "Labrador"
    * ```
    *
    * @see {@link TaggedClass} for adding a `_tag` literal field to the class schema
@@ -14364,13 +14320,23 @@ export const Class: {
      * Pass the desired class type as the first type parameter. The second optional
      * type parameter can be used to add nominal brands.
      *
+     * The `identifier` is the schema's stable runtime name. It is exposed on the
+     * class, stored in the schema AST, and used to label diagnostics and generated
+     * references as well as to format class instances.
+     *
+     * It also derives a runtime marker that recognizes instances across hot module
+     * reloads, where `instanceof` can fail because the constructor has been
+     * replaced. The identifier is explicit because the outer JavaScript class name
+     * is not available while the `extends` expression is evaluated and may change
+     * through renaming or minification.
+     *
      * **Gotchas**
      *
      * Passing `disableChecks` in the options skips constructor validation.
      *
      * **Example** (Defining a basic class)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Schema } from "effect"
      *
      * class Person extends Schema.Class<Person>("Person")({
@@ -14379,13 +14345,13 @@ export const Class: {
      * }) {}
      *
      * const alice = new Person({ name: "Alice", age: 30 })
-     * console.log(alice.name) // "Alice"
-     * console.log(`${alice}`) // "Person({ name: Alice, age: 30 })"
+     * alice.name // => "Alice"
+     * String(alice) // => "Person({\"name\":\"Alice\",\"age\":30})"
      * ```
      *
      * **Example** (Extending a class)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Schema } from "effect"
      *
      * class Animal extends Schema.Class<Animal>("Animal")({
@@ -14397,8 +14363,8 @@ export const Class: {
      * }) {}
      *
      * const dog = new Dog({ name: "Rex", breed: "Labrador" })
-     * console.log(dog.name) // "Rex"
-     * console.log(dog.breed) // "Labrador"
+     * dog.name // => "Rex"
+     * dog.breed // => "Labrador"
      * ```
      *
      * @see {@link TaggedClass} for adding a `_tag` literal field to the class schema
@@ -14427,13 +14393,23 @@ export const Class: {
      * Pass the desired class type as the first type parameter. The second optional
      * type parameter can be used to add nominal brands.
      *
+     * The `identifier` is the schema's stable runtime name. It is exposed on the
+     * class, stored in the schema AST, and used to label diagnostics and generated
+     * references as well as to format class instances.
+     *
+     * It also derives a runtime marker that recognizes instances across hot module
+     * reloads, where `instanceof` can fail because the constructor has been
+     * replaced. The identifier is explicit because the outer JavaScript class name
+     * is not available while the `extends` expression is evaluated and may change
+     * through renaming or minification.
+     *
      * **Gotchas**
      *
      * Passing `disableChecks` in the options skips constructor validation.
      *
      * **Example** (Defining a basic class)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Schema } from "effect"
      *
      * class Person extends Schema.Class<Person>("Person")({
@@ -14442,13 +14418,13 @@ export const Class: {
      * }) {}
      *
      * const alice = new Person({ name: "Alice", age: 30 })
-     * console.log(alice.name) // "Alice"
-     * console.log(`${alice}`) // "Person({ name: Alice, age: 30 })"
+     * alice.name // => "Alice"
+     * String(alice) // => "Person({\"name\":\"Alice\",\"age\":30})"
      * ```
      *
      * **Example** (Extending a class)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Schema } from "effect"
      *
      * class Animal extends Schema.Class<Animal>("Animal")({
@@ -14460,8 +14436,8 @@ export const Class: {
      * }) {}
      *
      * const dog = new Dog({ name: "Rex", breed: "Labrador" })
-     * console.log(dog.name) // "Rex"
-     * console.log(dog.breed) // "Labrador"
+     * dog.name // => "Rex"
+     * dog.breed // => "Labrador"
      * ```
      *
      * @see {@link TaggedClass} for adding a `_tag` literal field to the class schema
@@ -14507,7 +14483,7 @@ export const Class: {
  *
  * **Example** (Defining a tagged class)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * class Circle extends Schema.TaggedClass<Circle>()("Circle", {
@@ -14515,8 +14491,8 @@ export const Class: {
  * }) {}
  *
  * const c = new Circle({ radius: 5 })
- * console.log(c._tag) // "Circle"
- * console.log(c.radius) // 5
+ * c._tag // => "Circle"
+ * c.radius // => 5
  * ```
  *
  * @category constructors
@@ -14538,7 +14514,7 @@ export const TaggedClass: {
    *
    * **Example** (Defining a tagged class)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Schema } from "effect"
    *
    * class Circle extends Schema.TaggedClass<Circle>()("Circle", {
@@ -14546,8 +14522,8 @@ export const TaggedClass: {
    * }) {}
    *
    * const c = new Circle({ radius: 5 })
-   * console.log(c._tag) // "Circle"
-   * console.log(c.radius) // 5
+   * c._tag // => "Circle"
+   * c.radius // => 5
    * ```
    *
    * @category constructors
@@ -14569,7 +14545,7 @@ export const TaggedClass: {
      *
      * **Example** (Defining a tagged class)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Schema } from "effect"
      *
      * class Circle extends Schema.TaggedClass<Circle>()("Circle", {
@@ -14577,8 +14553,8 @@ export const TaggedClass: {
      * }) {}
      *
      * const c = new Circle({ radius: 5 })
-     * console.log(c._tag) // "Circle"
-     * console.log(c.radius) // 5
+     * c._tag // => "Circle"
+     * c.radius // => 5
      * ```
      *
      * @category constructors
@@ -14604,7 +14580,7 @@ export const TaggedClass: {
      *
      * **Example** (Defining a tagged class)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Schema } from "effect"
      *
      * class Circle extends Schema.TaggedClass<Circle>()("Circle", {
@@ -14612,8 +14588,8 @@ export const TaggedClass: {
      * }) {}
      *
      * const c = new Circle({ radius: 5 })
-     * console.log(c._tag) // "Circle"
-     * console.log(c.radius) // 5
+     * c._tag // => "Circle"
+     * c.radius // => 5
      * ```
      *
      * @category constructors
@@ -14655,7 +14631,7 @@ export const TaggedClass: {
  *
  * **Example** (Schema-backed error)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Schema } from "effect"
  *
  * class NotFound extends Schema.ErrorClass<NotFound>("NotFound")({
@@ -14665,6 +14641,8 @@ export const TaggedClass: {
  * const program = Effect.gen(function*() {
  *   yield* new NotFound({ id: 1 })
  * })
+ * const error = await Effect.runPromise(Effect.flip(program))
+ * error.id // => 1
  * ```
  *
  * @category constructors
@@ -14679,7 +14657,7 @@ export const ErrorClass: {
    *
    * **Example** (Schema-backed error)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Effect, Schema } from "effect"
    *
    * class NotFound extends Schema.ErrorClass<NotFound>("NotFound")({
@@ -14689,6 +14667,8 @@ export const ErrorClass: {
    * const program = Effect.gen(function*() {
    *   yield* new NotFound({ id: 1 })
    * })
+   * const error = await Effect.runPromise(Effect.flip(program))
+   * error.id // => 1
    * ```
    *
    * @category constructors
@@ -14703,7 +14683,7 @@ export const ErrorClass: {
      *
      * **Example** (Schema-backed error)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, Schema } from "effect"
      *
      * class NotFound extends Schema.ErrorClass<NotFound>("NotFound")({
@@ -14713,6 +14693,8 @@ export const ErrorClass: {
      * const program = Effect.gen(function*() {
      *   yield* new NotFound({ id: 1 })
      * })
+     * const error = await Effect.runPromise(Effect.flip(program))
+     * error.id // => 1
      * ```
      *
      * @category constructors
@@ -14731,7 +14713,7 @@ export const ErrorClass: {
      *
      * **Example** (Schema-backed error)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, Schema } from "effect"
      *
      * class NotFound extends Schema.ErrorClass<NotFound>("NotFound")({
@@ -14741,6 +14723,8 @@ export const ErrorClass: {
      * const program = Effect.gen(function*() {
      *   yield* new NotFound({ id: 1 })
      * })
+     * const error = await Effect.runPromise(Effect.flip(program))
+     * error.id // => 1
      * ```
      *
      * @category constructors
@@ -14779,7 +14763,7 @@ export const ErrorClass: {
  *
  * **Example** (Defining a tagged error class)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Schema } from "effect"
  *
  * class NotFound extends Schema.TaggedErrorClass<NotFound>()("NotFound", {
@@ -14789,6 +14773,9 @@ export const ErrorClass: {
  * const program = Effect.gen(function*() {
  *   yield* new NotFound({ id: 42 })
  * })
+ * const error = await Effect.runPromise(Effect.flip(program))
+ * error._tag // => "NotFound"
+ * error.id // => 42
  * ```
  *
  * @category constructors
@@ -14806,7 +14793,7 @@ export const TaggedErrorClass: {
    *
    * **Example** (Defining a tagged error class)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Effect, Schema } from "effect"
    *
    * class NotFound extends Schema.TaggedErrorClass<NotFound>()("NotFound", {
@@ -14816,6 +14803,9 @@ export const TaggedErrorClass: {
    * const program = Effect.gen(function*() {
    *   yield* new NotFound({ id: 42 })
    * })
+   * const error = await Effect.runPromise(Effect.flip(program))
+   * error._tag // => "NotFound"
+   * error.id // => 42
    * ```
    *
    * @category constructors
@@ -14833,7 +14823,7 @@ export const TaggedErrorClass: {
      *
      * **Example** (Defining a tagged error class)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, Schema } from "effect"
      *
      * class NotFound extends Schema.TaggedErrorClass<NotFound>()("NotFound", {
@@ -14843,6 +14833,9 @@ export const TaggedErrorClass: {
      * const program = Effect.gen(function*() {
      *   yield* new NotFound({ id: 42 })
      * })
+     * const error = await Effect.runPromise(Effect.flip(program))
+     * error._tag // => "NotFound"
+     * error.id // => 42
      * ```
      *
      * @category constructors
@@ -14865,7 +14858,7 @@ export const TaggedErrorClass: {
      *
      * **Example** (Defining a tagged error class)
      *
-     * ```ts
+     * ```ts import.meta.vitest
      * import { Effect, Schema } from "effect"
      *
      * class NotFound extends Schema.TaggedErrorClass<NotFound>()("NotFound", {
@@ -14875,6 +14868,9 @@ export const TaggedErrorClass: {
      * const program = Effect.gen(function*() {
      *   yield* new NotFound({ id: 42 })
      * })
+     * const error = await Effect.runPromise(Effect.flip(program))
+     * error._tag // => "NotFound"
+     * error.id // => 42
      * ```
      *
      * @category constructors
@@ -14917,7 +14913,7 @@ export const TaggedErrorClass: {
  * Use this type when you need to defer instantiation of the arbitrary, for
  * example to support recursive schemas.
  *
- * @category Arbitrary
+ * @category utility types
  * @since 4.0.0
  */
 export type LazyArbitrary<T> = (fc: typeof FastCheck) => FastCheck.Arbitrary<T>
@@ -14933,7 +14929,7 @@ export type LazyArbitrary<T> = (fc: typeof FastCheck) => FastCheck.Arbitrary<T>
  * nodes, impossible constraints, invalid candidates, and recursive schemas
  * without a finite terminal path fail immediately.
  *
- * @category Arbitrary
+ * @category generators
  * @since 4.0.0
  */
 export function toArbitraryLazy<S extends Constraint>(schema: S): LazyArbitrary<S["Type"]> {
@@ -14954,7 +14950,7 @@ export function toArbitraryLazy<S extends Constraint>(schema: S): LazyArbitrary<
  *
  * **Example** (Generating arbitrary values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  * import * as FastCheck from "fast-check"
  *
@@ -14963,11 +14959,10 @@ export function toArbitraryLazy<S extends Constraint>(schema: S): LazyArbitrary<
  * )
  *
  * // Sample a random value
- * const sample = FastCheck.sample(PersonArb, 1)[0]
- * console.log(typeof sample.name) // "string"
+ * FastCheck.sample(PersonArb, 1)
  * ```
  *
- * @category Arbitrary
+ * @category generators
  * @since 4.0.0
  */
 export function toArbitrary<S extends Constraint>(schema: S): FastCheck.Arbitrary<S["Type"]>
@@ -15004,7 +14999,7 @@ export function toArbitrary<S extends Constraint>(
  * The annotation is applied through this helper because adding it directly to
  * `Annotations.Bottom` would make schemas invariant.
  *
- * @category Formatter
+ * @category formatting
  * @since 4.0.0
  */
 export function overrideToFormatter<S extends Top>(toFormatter: () => Formatter<S["Type"]>) {
@@ -15023,7 +15018,7 @@ export function overrideToFormatter<S extends Top>(toFormatter: () => Formatter<
  * The optional `onBefore` hook lets you intercept specific AST nodes before
  * the default formatting logic runs.
  *
- * @category Formatter
+ * @category formatting
  * @since 4.0.0
  */
 export function toFormatter<S extends Constraint>(schema: S, options?: {
@@ -15191,13 +15186,13 @@ export function overrideToEquivalence<S extends Top>(toEquivalence: () => Equiva
  *
  * **Example** (Comparing structs)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema } from "effect"
  *
  * const eq = Schema.toEquivalence(Schema.Struct({ id: Schema.Number, name: Schema.String }))
  *
- * console.log(eq({ id: 1, name: "Alice" }, { id: 1, name: "Alice" })) // true
- * console.log(eq({ id: 1, name: "Alice" }, { id: 2, name: "Alice" })) // false
+ * eq({ id: 1, name: "Alice" }, { id: 1, name: "Alice" }) // => true
+ * eq({ id: 1, name: "Alice" }, { id: 2, name: "Alice" }) // => false
  * ```
  *
  * @category instances
@@ -15219,7 +15214,7 @@ export function toEquivalence<T>(schema: Schema<T>): Equivalence.Equivalence<T>
  *
  * Use {@link toType} before this function to represent the type side instead.
  *
- * @category Representation
+ * @category converting
  * @since 4.0.0
  */
 export function toRepresentation(schema: Constraint): SchemaRepresentation.Document {
@@ -15280,7 +15275,7 @@ export interface ToJsonSchemaOptions {
    *
    * **Example** (Including custom annotations)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Schema } from "effect"
    *
    * const schema = Schema.String.annotate({
@@ -15293,12 +15288,7 @@ export interface ToJsonSchemaOptions {
    *     key === "markdownDescription" || key.startsWith("x-")
    * })
    *
-   * console.log(doc.schema)
-   * // {
-   * //   type: "string",
-   * //   description: "A name",
-   * //   markdownDescription: "The **name** field"
-   * // }
+   * doc.schema // => { type: "string", description: "A name", markdownDescription: "The **name** field" }
    * ```
    */
   readonly includeAnnotationKey?: ((key: string) => boolean) | undefined
@@ -15340,7 +15330,7 @@ export function toJsonSchemaDocument(
 /**
  * Type-level representation returned by {@link toCodecJson}.
  *
- * @category Canonical Codecs
+ * @category converting
  * @since 4.0.0
  */
 export interface toCodecJson<S extends Constraint> extends
@@ -15377,7 +15367,7 @@ export interface toCodecJson<S extends Constraint> extends
  * `toCodecJson` callback can return `undefined` when the declaration is already
  * in canonical JSON form.
  *
- * @category Canonical Codecs
+ * @category converting
  * @since 4.0.0
  */
 export function toCodecJson<S extends Constraint>(schema: S): toCodecJson<S> {
@@ -15392,24 +15382,7 @@ const toCodecJsonASTBase = SchemaAST.applyToSelfOrLastLinkEncoding((ast) => {
 })
 
 /** @internal */
-export const toCodecJsonAST = memoize((ast: SchemaAST.AST): SchemaAST.AST => {
-  const identifier = InternalAnnotations.resolveIdentifier(ast)
-  const out = toCodecJsonASTBase(ast)
-  if (identifier === undefined || out.encoding === undefined) return out
-
-  const encoded = SchemaAST.getLastEncoding(out)
-  if (
-    InternalAnnotations.resolveIdentifier(encoded) !== undefined ||
-    InternalAnnotations.resolveIdentifierFallback(encoded) === identifier
-  ) {
-    return out
-  }
-
-  const annotated = SchemaAST.annotate(encoded, {
-    [InternalAnnotations.IDENTIFIER_FALLBACK_KEY]: identifier
-  })
-  return SchemaAST.applyToSelfOrLastLinkEncoding(() => annotated)(out)
-})
+export const toCodecJsonAST = memoize(toCodecJsonASTBase)
 
 function withoutConstructorDefault(context: SchemaAST.Context): SchemaAST.Context {
   return context.defaultValue === undefined ?
@@ -15516,7 +15489,7 @@ function toCodecJsonBase(ast: SchemaAST.AST, recur: (ast: SchemaAST.AST) => Sche
  * Derives an isomorphism codec from a schema. The encoded form is the
  * schema's `Iso` type — the intermediate representation used for round-tripping.
  *
- * @category Canonical Codecs
+ * @category converting
  * @since 4.0.0
  */
 export function toCodecIso<S extends Constraint>(schema: S): Codec<S["Type"], S["Iso"]> {
@@ -15553,7 +15526,7 @@ function toCodecIsoBase(ast: SchemaAST.AST, recur: (ast: SchemaAST.AST) => Schem
  * A {@link Tree} of `string | undefined` nodes. Leaf values are either a
  * string representation or `undefined` for opaque/declaration types.
  *
- * @category Canonical Codecs
+ * @category models
  * @since 4.0.0
  */
 export type StringTree = Tree<string | undefined>
@@ -15561,7 +15534,7 @@ export type StringTree = Tree<string | undefined>
 /**
  * Type-level representation returned by {@link toCodecStringTree}.
  *
- * @category Canonical Codecs
+ * @category converting
  * @since 4.0.0
  */
 export interface toCodecStringTree<S extends Constraint> extends
@@ -15596,7 +15569,7 @@ export interface toCodecStringTree<S extends Constraint> extends
  * `toCodec` encoding. A callback can return `undefined` when the declaration is
  * already in canonical StringTree form.
  *
- * @category Canonical Codecs
+ * @category converting
  * @since 4.0.0
  */
 export function toCodecStringTree<S extends Constraint>(schema: S): toCodecStringTree<S> {
@@ -15606,7 +15579,7 @@ export function toCodecStringTree<S extends Constraint>(schema: S): toCodecStrin
 /**
  * Type-level representation returned by {@link toCodecArrayFromSingle}.
  *
- * @category Canonical Codecs
+ * @category converting
  * @since 4.0.0
  */
 export interface toCodecArrayFromSingle<S extends Constraint> extends
@@ -15645,7 +15618,7 @@ export interface toCodecArrayFromSingle<S extends Constraint> extends
  * decoding convenience rather than a canonical StringTree representation. It
  * does not parse comma-separated strings.
  *
- * @category Canonical Codecs
+ * @category converting
  * @since 4.0.0
  */
 export function toCodecArrayFromSingle<S extends Constraint>(schema: S): toCodecArrayFromSingle<S> {
@@ -15674,7 +15647,7 @@ type XmlEncoderOptions = {
  * an `Effect` that succeeds with the XML string or fails with `SchemaError` if
  * codec encoding fails.
  *
- * @category Canonical Codecs
+ * @category encoding
  * @since 4.0.0
  */
 export function toEncoderXml<T, RE>(
@@ -15934,7 +15907,7 @@ function onSerializerArrayFromSingle(ast: SchemaAST.AST): SchemaAST.AST {
  *
  * @see {@link isGreaterThanDate} for creating the corresponding check
  *
- * @category Date checks
+ * @category validation
  * @since 4.0.0
  */
 export const isGreaterThanDateReviver: SchemaRepresentation.FilterReviver<{
@@ -15954,7 +15927,7 @@ export const isGreaterThanDateReviver: SchemaRepresentation.FilterReviver<{
  *
  * @see {@link isGreaterThanOrEqualToDate} for creating the corresponding check
  *
- * @category Date checks
+ * @category validation
  * @since 4.0.0
  */
 export const isGreaterThanOrEqualToDateReviver: SchemaRepresentation.FilterReviver<{
@@ -15974,7 +15947,7 @@ export const isGreaterThanOrEqualToDateReviver: SchemaRepresentation.FilterReviv
  *
  * @see {@link isLessThanDate} for creating the corresponding check
  *
- * @category Date checks
+ * @category validation
  * @since 4.0.0
  */
 export const isLessThanDateReviver: SchemaRepresentation.FilterReviver<{
@@ -15994,7 +15967,7 @@ export const isLessThanDateReviver: SchemaRepresentation.FilterReviver<{
  *
  * @see {@link isLessThanOrEqualToDate} for creating the corresponding check
  *
- * @category Date checks
+ * @category validation
  * @since 4.0.0
  */
 export const isLessThanOrEqualToDateReviver: SchemaRepresentation.FilterReviver<{
@@ -16014,7 +15987,7 @@ export const isLessThanOrEqualToDateReviver: SchemaRepresentation.FilterReviver<
  *
  * @see {@link isBetweenDate} for creating the corresponding check
  *
- * @category Date checks
+ * @category validation
  * @since 4.0.0
  */
 export const isBetweenDateReviver: SchemaRepresentation.FilterReviver<{
@@ -16042,7 +16015,7 @@ export const isBetweenDateReviver: SchemaRepresentation.FilterReviver<{
  *
  * @see {@link isGreaterThanBigInt} for creating the corresponding check
  *
- * @category BigInt checks
+ * @category validation
  * @since 4.0.0
  */
 export const isGreaterThanBigIntReviver: SchemaRepresentation.FilterReviver<{
@@ -16062,7 +16035,7 @@ export const isGreaterThanBigIntReviver: SchemaRepresentation.FilterReviver<{
  *
  * @see {@link isGreaterThanOrEqualToBigInt} for creating the corresponding check
  *
- * @category BigInt checks
+ * @category validation
  * @since 4.0.0
  */
 export const isGreaterThanOrEqualToBigIntReviver: SchemaRepresentation.FilterReviver<{
@@ -16082,7 +16055,7 @@ export const isGreaterThanOrEqualToBigIntReviver: SchemaRepresentation.FilterRev
  *
  * @see {@link isLessThanBigInt} for creating the corresponding check
  *
- * @category BigInt checks
+ * @category validation
  * @since 4.0.0
  */
 export const isLessThanBigIntReviver: SchemaRepresentation.FilterReviver<{
@@ -16102,7 +16075,7 @@ export const isLessThanBigIntReviver: SchemaRepresentation.FilterReviver<{
  *
  * @see {@link isLessThanOrEqualToBigInt} for creating the corresponding check
  *
- * @category BigInt checks
+ * @category validation
  * @since 4.0.0
  */
 export const isLessThanOrEqualToBigIntReviver: SchemaRepresentation.FilterReviver<{
@@ -16122,7 +16095,7 @@ export const isLessThanOrEqualToBigIntReviver: SchemaRepresentation.FilterRevive
  *
  * @see {@link isBetweenBigInt} for creating the corresponding check
  *
- * @category BigInt checks
+ * @category validation
  * @since 4.0.0
  */
 export const isBetweenBigIntReviver: SchemaRepresentation.FilterReviver<{
@@ -16149,7 +16122,7 @@ export const isBetweenBigIntReviver: SchemaRepresentation.FilterReviver<{
  * Derives an `Iso` optic from a schema that isomorphically converts between
  * the schema's `Type` and its `Iso` (intermediate / serialized form).
  *
- * @category Optic
+ * @category converting
  * @since 4.0.0
  */
 export function toIso<S extends Constraint>(schema: S): Optic_.Iso<S["Type"], S["Iso"]> {
@@ -16160,7 +16133,7 @@ export function toIso<S extends Constraint>(schema: S): Optic_.Iso<S["Type"], S[
 /**
  * Returns an identity `Iso` over the schema's source (`Type`) side.
  *
- * @category Optic
+ * @category constructors
  * @since 4.0.0
  */
 export function toIsoSource<S extends Constraint>(_: S): Optic_.Iso<S["Type"], S["Type"]> {
@@ -16170,7 +16143,7 @@ export function toIsoSource<S extends Constraint>(_: S): Optic_.Iso<S["Type"], S
 /**
  * Returns an identity `Iso` over the schema's focus (`Iso`) side.
  *
- * @category Optic
+ * @category constructors
  * @since 4.0.0
  */
 export function toIsoFocus<S extends Constraint>(_: S): Optic_.Iso<S["Iso"], S["Iso"]> {
@@ -16180,7 +16153,7 @@ export function toIsoFocus<S extends Constraint>(_: S): Optic_.Iso<S["Iso"], S["
 /**
  * Type-level representation returned by {@link overrideToCodecIso}.
  *
- * @category Optic
+ * @category transforming
  * @since 4.0.0
  */
 export interface overrideToCodecIso<S extends Constraint, Iso> extends
@@ -16219,7 +16192,7 @@ export interface overrideToCodecIso<S extends Constraint, Iso> extends
  * provided `decode` and `encode` getters to transform between the schema type
  * and the target codec.
  *
- * @category Optic
+ * @category transforming
  * @since 4.0.0
  */
 export function overrideToCodecIso<S extends Constraint, Iso>(
@@ -16271,7 +16244,7 @@ export function toDifferJsonPatch<T>(schema: ConstraintCodec<T, unknown>): Diffe
  * Recursive tree type whose leaves are `Node` values and whose branches are
  * readonly arrays or string-keyed records of child trees.
  *
- * @category Tree
+ * @category models
  * @since 4.0.0
  */
 export type Tree<Node> = Node | TreeRecord<Node> | ReadonlyArray<Tree<Node>>
@@ -16280,7 +16253,7 @@ export type Tree<Node> = Node | TreeRecord<Node> | ReadonlyArray<Tree<Node>>
  * A record node in a {@link Tree}: an object mapping string keys to child
  * `Tree` nodes.
  *
- * @category Tree
+ * @category models
  * @since 4.0.0
  */
 export interface TreeRecord<A> {
@@ -16292,7 +16265,7 @@ export interface TreeRecord<A> {
  * The resulting schema accepts a single node value, an array of trees, or an
  * object whose values are trees.
  *
- * @category Tree
+ * @category schemas
  * @since 4.0.0
  */
 export function Tree<S extends Constraint>(node: S) {
@@ -16344,11 +16317,10 @@ export interface JsonObject {
  *
  * **Example** (Validating a JSON value)
  *
- * ```ts
- * import { Schema } from "effect"
+ * ```ts import.meta.vitest
+ * import { Option, Schema } from "effect"
  *
- * const result = Schema.decodeUnknownOption(Schema.Json)({ key: [1, true, null] })
- * console.log(result._tag) // "Some"
+ * Schema.decodeUnknownOption(Schema.Json)({ key: [1, true, null] }) // => Option.some({ key: [1, true, null] })
  * ```
  *
  * @category schemas
@@ -16453,7 +16425,7 @@ export const MutableJsonReviver = makeFixedDeclarationReviver(
  * annotations are taken from the last check; otherwise they are taken from
  * the base schema instance.
  *
- * @category Schema Resolvers
+ * @category getters
  * @since 4.0.0
  */
 export function resolveAnnotations<S extends Constraint>(
@@ -16467,7 +16439,7 @@ export function resolveAnnotations<S extends Constraint>(
  * annotations are those attached via `annotateKey` and live on the AST's
  * `context` rather than on the schema node itself.
  *
- * @category Schema Resolvers
+ * @category getters
  * @since 4.0.0
  */
 export function resolveAnnotationsKey<S extends Constraint>(schema: S): Annotations.Key<S["Type"]> | undefined {
@@ -16500,7 +16472,7 @@ export declare namespace Annotations {
    *
    * **Example** (Defining your own annotations)
    *
-   * ```ts
+   * ```ts import.meta.vitest
    * import { Schema } from "effect"
    *
    * // Extend the Annotations interface with a custom `version` annotation
@@ -16522,8 +16494,7 @@ export declare namespace Annotations {
    *
    * if (version) {
    *   // Access individual parts of the version
-   *   console.log(version[1])
-   *   // Output: 2
+   *   version[1] // => 2
    * }
    * ```
    *
@@ -16551,7 +16522,7 @@ export declare namespace Annotations {
      * `message` first, then `expected`, and finally falls back to `<filter>`.
      *
      * Use this to name a failed filter in the default message:
-     * `Expected <expected>, got <actual>`.
+     * `Expected <expected>`.
      */
     readonly expected?: string | undefined
     readonly title?: string | undefined
@@ -16610,7 +16581,7 @@ export declare namespace Annotations {
      * only changing the expected label. For a filter or refinement failure,
      * annotate the filter with `message` to replace the whole filter failure
      * message, or `expected` to keep the default
-     * `Expected <expected>, got <actual>` shape.
+     * `Expected <expected>` shape.
      */
     readonly message?: string | undefined
     /**
@@ -16625,7 +16596,7 @@ export declare namespace Annotations {
      * Identifiers are used by schema tooling, including JSON Schema
      * generation, to name references. The default formatter also uses
      * `identifier` as the expected label for type-level failures, such as
-     * `Expected UserId, got null`.
+     * `Expected UserId`.
      *
      * `identifier` does not name a failed filter or refinement. If the base
      * type matches and a filter fails, put `expected` or `message` on the